(() => {
  var __create = Object.create;
  var __defProp = Object.defineProperty;
  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
  var __getOwnPropNames = Object.getOwnPropertyNames;
  var __getProtoOf = Object.getPrototypeOf;
  var __hasOwnProp = Object.prototype.hasOwnProperty;
  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
  }) : x)(function(x) {
    if (typeof require !== "undefined")
      return require.apply(this, arguments);
    throw new Error('Dynamic require of "' + x + '" is not supported');
  });
  var __esm = (fn, res) => function __init() {
    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
  };
  var __commonJS = (cb, mod2) => function __require2() {
    return mod2 || (0, cb[__getOwnPropNames(cb)[0]])((mod2 = { exports: {} }).exports, mod2), mod2.exports;
  };
  var __export = (target, all) => {
    for (var name in all)
      __defProp(target, name, { get: all[name], enumerable: true });
  };
  var __copyProps = (to, from, except, desc) => {
    if (from && typeof from === "object" || typeof from === "function") {
      for (let key of __getOwnPropNames(from))
        if (!__hasOwnProp.call(to, key) && key !== except)
          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
    }
    return to;
  };
  var __reExport = (target, mod2, secondTarget) => (__copyProps(target, mod2, "default"), secondTarget && __copyProps(secondTarget, mod2, "default"));
  var __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __copyProps(isNodeMode || !mod2 || !mod2.__esModule ? __defProp(target, "default", { value: mod2, enumerable: true }) : target, mod2));
  var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);

  // node_modules/@rails/actioncable/src/adapters.js
  var adapters_default;
  var init_adapters = __esm({
    "node_modules/@rails/actioncable/src/adapters.js"() {
      adapters_default = {
        logger: self.console,
        WebSocket: self.WebSocket
      };
    }
  });

  // node_modules/@rails/actioncable/src/logger.js
  var logger_default;
  var init_logger = __esm({
    "node_modules/@rails/actioncable/src/logger.js"() {
      init_adapters();
      logger_default = {
        log(...messages) {
          if (this.enabled) {
            messages.push(Date.now());
            adapters_default.logger.log("[ActionCable]", ...messages);
          }
        }
      };
    }
  });

  // node_modules/@rails/actioncable/src/connection_monitor.js
  var now, secondsSince, ConnectionMonitor, connection_monitor_default;
  var init_connection_monitor = __esm({
    "node_modules/@rails/actioncable/src/connection_monitor.js"() {
      init_logger();
      now = () => new Date().getTime();
      secondsSince = (time) => (now() - time) / 1e3;
      ConnectionMonitor = class {
        constructor(connection) {
          this.visibilityDidChange = this.visibilityDidChange.bind(this);
          this.connection = connection;
          this.reconnectAttempts = 0;
        }
        start() {
          if (!this.isRunning()) {
            this.startedAt = now();
            delete this.stoppedAt;
            this.startPolling();
            addEventListener("visibilitychange", this.visibilityDidChange);
            logger_default.log(`ConnectionMonitor started. stale threshold = ${this.constructor.staleThreshold} s`);
          }
        }
        stop() {
          if (this.isRunning()) {
            this.stoppedAt = now();
            this.stopPolling();
            removeEventListener("visibilitychange", this.visibilityDidChange);
            logger_default.log("ConnectionMonitor stopped");
          }
        }
        isRunning() {
          return this.startedAt && !this.stoppedAt;
        }
        recordPing() {
          this.pingedAt = now();
        }
        recordConnect() {
          this.reconnectAttempts = 0;
          this.recordPing();
          delete this.disconnectedAt;
          logger_default.log("ConnectionMonitor recorded connect");
        }
        recordDisconnect() {
          this.disconnectedAt = now();
          logger_default.log("ConnectionMonitor recorded disconnect");
        }
        startPolling() {
          this.stopPolling();
          this.poll();
        }
        stopPolling() {
          clearTimeout(this.pollTimeout);
        }
        poll() {
          this.pollTimeout = setTimeout(() => {
            this.reconnectIfStale();
            this.poll();
          }, this.getPollInterval());
        }
        getPollInterval() {
          const { staleThreshold, reconnectionBackoffRate } = this.constructor;
          const backoff = Math.pow(1 + reconnectionBackoffRate, Math.min(this.reconnectAttempts, 10));
          const jitterMax = this.reconnectAttempts === 0 ? 1 : reconnectionBackoffRate;
          const jitter = jitterMax * Math.random();
          return staleThreshold * 1e3 * backoff * (1 + jitter);
        }
        reconnectIfStale() {
          if (this.connectionIsStale()) {
            logger_default.log(`ConnectionMonitor detected stale connection. reconnectAttempts = ${this.reconnectAttempts}, time stale = ${secondsSince(this.refreshedAt)} s, stale threshold = ${this.constructor.staleThreshold} s`);
            this.reconnectAttempts++;
            if (this.disconnectedRecently()) {
              logger_default.log(`ConnectionMonitor skipping reopening recent disconnect. time disconnected = ${secondsSince(this.disconnectedAt)} s`);
            } else {
              logger_default.log("ConnectionMonitor reopening");
              this.connection.reopen();
            }
          }
        }
        get refreshedAt() {
          return this.pingedAt ? this.pingedAt : this.startedAt;
        }
        connectionIsStale() {
          return secondsSince(this.refreshedAt) > this.constructor.staleThreshold;
        }
        disconnectedRecently() {
          return this.disconnectedAt && secondsSince(this.disconnectedAt) < this.constructor.staleThreshold;
        }
        visibilityDidChange() {
          if (document.visibilityState === "visible") {
            setTimeout(() => {
              if (this.connectionIsStale() || !this.connection.isOpen()) {
                logger_default.log(`ConnectionMonitor reopening stale connection on visibilitychange. visibilityState = ${document.visibilityState}`);
                this.connection.reopen();
              }
            }, 200);
          }
        }
      };
      ConnectionMonitor.staleThreshold = 6;
      ConnectionMonitor.reconnectionBackoffRate = 0.15;
      connection_monitor_default = ConnectionMonitor;
    }
  });

  // node_modules/@rails/actioncable/src/internal.js
  var internal_default;
  var init_internal = __esm({
    "node_modules/@rails/actioncable/src/internal.js"() {
      internal_default = {
        "message_types": {
          "welcome": "welcome",
          "disconnect": "disconnect",
          "ping": "ping",
          "confirmation": "confirm_subscription",
          "rejection": "reject_subscription"
        },
        "disconnect_reasons": {
          "unauthorized": "unauthorized",
          "invalid_request": "invalid_request",
          "server_restart": "server_restart"
        },
        "default_mount_path": "/cable",
        "protocols": [
          "actioncable-v1-json",
          "actioncable-unsupported"
        ]
      };
    }
  });

  // node_modules/@rails/actioncable/src/connection.js
  var message_types, protocols, supportedProtocols, indexOf, Connection, connection_default;
  var init_connection = __esm({
    "node_modules/@rails/actioncable/src/connection.js"() {
      init_adapters();
      init_connection_monitor();
      init_internal();
      init_logger();
      ({ message_types, protocols } = internal_default);
      supportedProtocols = protocols.slice(0, protocols.length - 1);
      indexOf = [].indexOf;
      Connection = class {
        constructor(consumer2) {
          this.open = this.open.bind(this);
          this.consumer = consumer2;
          this.subscriptions = this.consumer.subscriptions;
          this.monitor = new connection_monitor_default(this);
          this.disconnected = true;
        }
        send(data) {
          if (this.isOpen()) {
            this.webSocket.send(JSON.stringify(data));
            return true;
          } else {
            return false;
          }
        }
        open() {
          if (this.isActive()) {
            logger_default.log(`Attempted to open WebSocket, but existing socket is ${this.getState()}`);
            return false;
          } else {
            logger_default.log(`Opening WebSocket, current state is ${this.getState()}, subprotocols: ${protocols}`);
            if (this.webSocket) {
              this.uninstallEventHandlers();
            }
            this.webSocket = new adapters_default.WebSocket(this.consumer.url, protocols);
            this.installEventHandlers();
            this.monitor.start();
            return true;
          }
        }
        close({ allowReconnect } = { allowReconnect: true }) {
          if (!allowReconnect) {
            this.monitor.stop();
          }
          if (this.isActive()) {
            return this.webSocket.close();
          }
        }
        reopen() {
          logger_default.log(`Reopening WebSocket, current state is ${this.getState()}`);
          if (this.isActive()) {
            try {
              return this.close();
            } catch (error) {
              logger_default.log("Failed to reopen WebSocket", error);
            } finally {
              logger_default.log(`Reopening WebSocket in ${this.constructor.reopenDelay}ms`);
              setTimeout(this.open, this.constructor.reopenDelay);
            }
          } else {
            return this.open();
          }
        }
        getProtocol() {
          if (this.webSocket) {
            return this.webSocket.protocol;
          }
        }
        isOpen() {
          return this.isState("open");
        }
        isActive() {
          return this.isState("open", "connecting");
        }
        isProtocolSupported() {
          return indexOf.call(supportedProtocols, this.getProtocol()) >= 0;
        }
        isState(...states) {
          return indexOf.call(states, this.getState()) >= 0;
        }
        getState() {
          if (this.webSocket) {
            for (let state in adapters_default.WebSocket) {
              if (adapters_default.WebSocket[state] === this.webSocket.readyState) {
                return state.toLowerCase();
              }
            }
          }
          return null;
        }
        installEventHandlers() {
          for (let eventName in this.events) {
            const handler = this.events[eventName].bind(this);
            this.webSocket[`on${eventName}`] = handler;
          }
        }
        uninstallEventHandlers() {
          for (let eventName in this.events) {
            this.webSocket[`on${eventName}`] = function() {
            };
          }
        }
      };
      Connection.reopenDelay = 500;
      Connection.prototype.events = {
        message(event) {
          if (!this.isProtocolSupported()) {
            return;
          }
          const { identifier, message, reason, reconnect, type } = JSON.parse(event.data);
          switch (type) {
            case message_types.welcome:
              this.monitor.recordConnect();
              return this.subscriptions.reload();
            case message_types.disconnect:
              logger_default.log(`Disconnecting. Reason: ${reason}`);
              return this.close({ allowReconnect: reconnect });
            case message_types.ping:
              return this.monitor.recordPing();
            case message_types.confirmation:
              this.subscriptions.confirmSubscription(identifier);
              return this.subscriptions.notify(identifier, "connected");
            case message_types.rejection:
              return this.subscriptions.reject(identifier);
            default:
              return this.subscriptions.notify(identifier, "received", message);
          }
        },
        open() {
          logger_default.log(`WebSocket onopen event, using '${this.getProtocol()}' subprotocol`);
          this.disconnected = false;
          if (!this.isProtocolSupported()) {
            logger_default.log("Protocol is unsupported. Stopping monitor and disconnecting.");
            return this.close({ allowReconnect: false });
          }
        },
        close(event) {
          logger_default.log("WebSocket onclose event");
          if (this.disconnected) {
            return;
          }
          this.disconnected = true;
          this.monitor.recordDisconnect();
          return this.subscriptions.notifyAll("disconnected", { willAttemptReconnect: this.monitor.isRunning() });
        },
        error() {
          logger_default.log("WebSocket onerror event");
        }
      };
      connection_default = Connection;
    }
  });

  // node_modules/@rails/actioncable/src/subscription.js
  var extend, Subscription;
  var init_subscription = __esm({
    "node_modules/@rails/actioncable/src/subscription.js"() {
      extend = function(object, properties) {
        if (properties != null) {
          for (let key in properties) {
            const value = properties[key];
            object[key] = value;
          }
        }
        return object;
      };
      Subscription = class {
        constructor(consumer2, params = {}, mixin) {
          this.consumer = consumer2;
          this.identifier = JSON.stringify(params);
          extend(this, mixin);
        }
        perform(action, data = {}) {
          data.action = action;
          return this.send(data);
        }
        send(data) {
          return this.consumer.send({ command: "message", identifier: this.identifier, data: JSON.stringify(data) });
        }
        unsubscribe() {
          return this.consumer.subscriptions.remove(this);
        }
      };
    }
  });

  // node_modules/@rails/actioncable/src/subscription_guarantor.js
  var SubscriptionGuarantor, subscription_guarantor_default;
  var init_subscription_guarantor = __esm({
    "node_modules/@rails/actioncable/src/subscription_guarantor.js"() {
      init_logger();
      SubscriptionGuarantor = class {
        constructor(subscriptions) {
          this.subscriptions = subscriptions;
          this.pendingSubscriptions = [];
        }
        guarantee(subscription) {
          if (this.pendingSubscriptions.indexOf(subscription) == -1) {
            logger_default.log(`SubscriptionGuarantor guaranteeing ${subscription.identifier}`);
            this.pendingSubscriptions.push(subscription);
          } else {
            logger_default.log(`SubscriptionGuarantor already guaranteeing ${subscription.identifier}`);
          }
          this.startGuaranteeing();
        }
        forget(subscription) {
          logger_default.log(`SubscriptionGuarantor forgetting ${subscription.identifier}`);
          this.pendingSubscriptions = this.pendingSubscriptions.filter((s) => s !== subscription);
        }
        startGuaranteeing() {
          this.stopGuaranteeing();
          this.retrySubscribing();
        }
        stopGuaranteeing() {
          clearTimeout(this.retryTimeout);
        }
        retrySubscribing() {
          this.retryTimeout = setTimeout(() => {
            if (this.subscriptions && typeof this.subscriptions.subscribe === "function") {
              this.pendingSubscriptions.map((subscription) => {
                logger_default.log(`SubscriptionGuarantor resubscribing ${subscription.identifier}`);
                this.subscriptions.subscribe(subscription);
              });
            }
          }, 500);
        }
      };
      subscription_guarantor_default = SubscriptionGuarantor;
    }
  });

  // node_modules/@rails/actioncable/src/subscriptions.js
  var Subscriptions;
  var init_subscriptions = __esm({
    "node_modules/@rails/actioncable/src/subscriptions.js"() {
      init_subscription();
      init_subscription_guarantor();
      init_logger();
      Subscriptions = class {
        constructor(consumer2) {
          this.consumer = consumer2;
          this.guarantor = new subscription_guarantor_default(this);
          this.subscriptions = [];
        }
        create(channelName, mixin) {
          const channel = channelName;
          const params = typeof channel === "object" ? channel : { channel };
          const subscription = new Subscription(this.consumer, params, mixin);
          return this.add(subscription);
        }
        add(subscription) {
          this.subscriptions.push(subscription);
          this.consumer.ensureActiveConnection();
          this.notify(subscription, "initialized");
          this.subscribe(subscription);
          return subscription;
        }
        remove(subscription) {
          this.forget(subscription);
          if (!this.findAll(subscription.identifier).length) {
            this.sendCommand(subscription, "unsubscribe");
          }
          return subscription;
        }
        reject(identifier) {
          return this.findAll(identifier).map((subscription) => {
            this.forget(subscription);
            this.notify(subscription, "rejected");
            return subscription;
          });
        }
        forget(subscription) {
          this.guarantor.forget(subscription);
          this.subscriptions = this.subscriptions.filter((s) => s !== subscription);
          return subscription;
        }
        findAll(identifier) {
          return this.subscriptions.filter((s) => s.identifier === identifier);
        }
        reload() {
          return this.subscriptions.map((subscription) => this.subscribe(subscription));
        }
        notifyAll(callbackName, ...args) {
          return this.subscriptions.map((subscription) => this.notify(subscription, callbackName, ...args));
        }
        notify(subscription, callbackName, ...args) {
          let subscriptions;
          if (typeof subscription === "string") {
            subscriptions = this.findAll(subscription);
          } else {
            subscriptions = [subscription];
          }
          return subscriptions.map((subscription2) => typeof subscription2[callbackName] === "function" ? subscription2[callbackName](...args) : void 0);
        }
        subscribe(subscription) {
          if (this.sendCommand(subscription, "subscribe")) {
            this.guarantor.guarantee(subscription);
          }
        }
        confirmSubscription(identifier) {
          logger_default.log(`Subscription confirmed ${identifier}`);
          this.findAll(identifier).map((subscription) => this.guarantor.forget(subscription));
        }
        sendCommand(subscription, command) {
          const { identifier } = subscription;
          return this.consumer.send({ command, identifier });
        }
      };
    }
  });

  // node_modules/@rails/actioncable/src/consumer.js
  function createWebSocketURL(url) {
    if (typeof url === "function") {
      url = url();
    }
    if (url && !/^wss?:/i.test(url)) {
      const a = document.createElement("a");
      a.href = url;
      a.href = a.href;
      a.protocol = a.protocol.replace("http", "ws");
      return a.href;
    } else {
      return url;
    }
  }
  var Consumer;
  var init_consumer = __esm({
    "node_modules/@rails/actioncable/src/consumer.js"() {
      init_connection();
      init_subscriptions();
      Consumer = class {
        constructor(url) {
          this._url = url;
          this.subscriptions = new Subscriptions(this);
          this.connection = new connection_default(this);
        }
        get url() {
          return createWebSocketURL(this._url);
        }
        send(data) {
          return this.connection.send(data);
        }
        connect() {
          return this.connection.open();
        }
        disconnect() {
          return this.connection.close({ allowReconnect: false });
        }
        ensureActiveConnection() {
          if (!this.connection.isActive()) {
            return this.connection.open();
          }
        }
      };
    }
  });

  // node_modules/@rails/actioncable/src/index.js
  var src_exports = {};
  __export(src_exports, {
    Connection: () => connection_default,
    ConnectionMonitor: () => connection_monitor_default,
    Consumer: () => Consumer,
    INTERNAL: () => internal_default,
    Subscription: () => Subscription,
    SubscriptionGuarantor: () => subscription_guarantor_default,
    Subscriptions: () => Subscriptions,
    adapters: () => adapters_default,
    createConsumer: () => createConsumer,
    createWebSocketURL: () => createWebSocketURL,
    getConfig: () => getConfig,
    logger: () => logger_default
  });
  function createConsumer(url = getConfig("url") || internal_default.default_mount_path) {
    return new Consumer(url);
  }
  function getConfig(name) {
    const element = document.head.querySelector(`meta[name='action-cable-${name}']`);
    if (element) {
      return element.getAttribute("content");
    }
  }
  var init_src = __esm({
    "node_modules/@rails/actioncable/src/index.js"() {
      init_connection();
      init_connection_monitor();
      init_consumer();
      init_internal();
      init_subscription();
      init_subscriptions();
      init_subscription_guarantor();
      init_adapters();
      init_logger();
    }
  });

  // (disabled):node_modules/buffer/index.js
  var require_buffer = __commonJS({
    "(disabled):node_modules/buffer/index.js"() {
    }
  });

  // node_modules/@cosmjs/math/node_modules/bn.js/lib/bn.js
  var require_bn = __commonJS({
    "node_modules/@cosmjs/math/node_modules/bn.js/lib/bn.js"(exports2, module2) {
      (function(module3, exports3) {
        "use strict";
        function assert(val, msg) {
          if (!val)
            throw new Error(msg || "Assertion failed");
        }
        function inherits(ctor, superCtor) {
          ctor.super_ = superCtor;
          var TempCtor = function() {
          };
          TempCtor.prototype = superCtor.prototype;
          ctor.prototype = new TempCtor();
          ctor.prototype.constructor = ctor;
        }
        function BN(number, base, endian) {
          if (BN.isBN(number)) {
            return number;
          }
          this.negative = 0;
          this.words = null;
          this.length = 0;
          this.red = null;
          if (number !== null) {
            if (base === "le" || base === "be") {
              endian = base;
              base = 10;
            }
            this._init(number || 0, base || 10, endian || "be");
          }
        }
        if (typeof module3 === "object") {
          module3.exports = BN;
        } else {
          exports3.BN = BN;
        }
        BN.BN = BN;
        BN.wordSize = 26;
        var Buffer2;
        try {
          if (typeof window !== "undefined" && typeof window.Buffer !== "undefined") {
            Buffer2 = window.Buffer;
          } else {
            Buffer2 = require_buffer().Buffer;
          }
        } catch (e) {
        }
        BN.isBN = function isBN(num) {
          if (num instanceof BN) {
            return true;
          }
          return num !== null && typeof num === "object" && num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);
        };
        BN.max = function max(left, right) {
          if (left.cmp(right) > 0)
            return left;
          return right;
        };
        BN.min = function min(left, right) {
          if (left.cmp(right) < 0)
            return left;
          return right;
        };
        BN.prototype._init = function init(number, base, endian) {
          if (typeof number === "number") {
            return this._initNumber(number, base, endian);
          }
          if (typeof number === "object") {
            return this._initArray(number, base, endian);
          }
          if (base === "hex") {
            base = 16;
          }
          assert(base === (base | 0) && base >= 2 && base <= 36);
          number = number.toString().replace(/\s+/g, "");
          var start2 = 0;
          if (number[0] === "-") {
            start2++;
            this.negative = 1;
          }
          if (start2 < number.length) {
            if (base === 16) {
              this._parseHex(number, start2, endian);
            } else {
              this._parseBase(number, base, start2);
              if (endian === "le") {
                this._initArray(this.toArray(), base, endian);
              }
            }
          }
        };
        BN.prototype._initNumber = function _initNumber(number, base, endian) {
          if (number < 0) {
            this.negative = 1;
            number = -number;
          }
          if (number < 67108864) {
            this.words = [number & 67108863];
            this.length = 1;
          } else if (number < 4503599627370496) {
            this.words = [
              number & 67108863,
              number / 67108864 & 67108863
            ];
            this.length = 2;
          } else {
            assert(number < 9007199254740992);
            this.words = [
              number & 67108863,
              number / 67108864 & 67108863,
              1
            ];
            this.length = 3;
          }
          if (endian !== "le")
            return;
          this._initArray(this.toArray(), base, endian);
        };
        BN.prototype._initArray = function _initArray(number, base, endian) {
          assert(typeof number.length === "number");
          if (number.length <= 0) {
            this.words = [0];
            this.length = 1;
            return this;
          }
          this.length = Math.ceil(number.length / 3);
          this.words = new Array(this.length);
          for (var i = 0; i < this.length; i++) {
            this.words[i] = 0;
          }
          var j, w;
          var off = 0;
          if (endian === "be") {
            for (i = number.length - 1, j = 0; i >= 0; i -= 3) {
              w = number[i] | number[i - 1] << 8 | number[i - 2] << 16;
              this.words[j] |= w << off & 67108863;
              this.words[j + 1] = w >>> 26 - off & 67108863;
              off += 24;
              if (off >= 26) {
                off -= 26;
                j++;
              }
            }
          } else if (endian === "le") {
            for (i = 0, j = 0; i < number.length; i += 3) {
              w = number[i] | number[i + 1] << 8 | number[i + 2] << 16;
              this.words[j] |= w << off & 67108863;
              this.words[j + 1] = w >>> 26 - off & 67108863;
              off += 24;
              if (off >= 26) {
                off -= 26;
                j++;
              }
            }
          }
          return this._strip();
        };
        function parseHex4Bits(string, index) {
          var c = string.charCodeAt(index);
          if (c >= 48 && c <= 57) {
            return c - 48;
          } else if (c >= 65 && c <= 70) {
            return c - 55;
          } else if (c >= 97 && c <= 102) {
            return c - 87;
          } else {
            assert(false, "Invalid character in " + string);
          }
        }
        function parseHexByte(string, lowerBound, index) {
          var r = parseHex4Bits(string, index);
          if (index - 1 >= lowerBound) {
            r |= parseHex4Bits(string, index - 1) << 4;
          }
          return r;
        }
        BN.prototype._parseHex = function _parseHex(number, start2, endian) {
          this.length = Math.ceil((number.length - start2) / 6);
          this.words = new Array(this.length);
          for (var i = 0; i < this.length; i++) {
            this.words[i] = 0;
          }
          var off = 0;
          var j = 0;
          var w;
          if (endian === "be") {
            for (i = number.length - 1; i >= start2; i -= 2) {
              w = parseHexByte(number, start2, i) << off;
              this.words[j] |= w & 67108863;
              if (off >= 18) {
                off -= 18;
                j += 1;
                this.words[j] |= w >>> 26;
              } else {
                off += 8;
              }
            }
          } else {
            var parseLength = number.length - start2;
            for (i = parseLength % 2 === 0 ? start2 + 1 : start2; i < number.length; i += 2) {
              w = parseHexByte(number, start2, i) << off;
              this.words[j] |= w & 67108863;
              if (off >= 18) {
                off -= 18;
                j += 1;
                this.words[j] |= w >>> 26;
              } else {
                off += 8;
              }
            }
          }
          this._strip();
        };
        function parseBase(str, start2, end, mul) {
          var r = 0;
          var b = 0;
          var len = Math.min(str.length, end);
          for (var i = start2; i < len; i++) {
            var c = str.charCodeAt(i) - 48;
            r *= mul;
            if (c >= 49) {
              b = c - 49 + 10;
            } else if (c >= 17) {
              b = c - 17 + 10;
            } else {
              b = c;
            }
            assert(c >= 0 && b < mul, "Invalid character");
            r += b;
          }
          return r;
        }
        BN.prototype._parseBase = function _parseBase(number, base, start2) {
          this.words = [0];
          this.length = 1;
          for (var limbLen = 0, limbPow = 1; limbPow <= 67108863; limbPow *= base) {
            limbLen++;
          }
          limbLen--;
          limbPow = limbPow / base | 0;
          var total = number.length - start2;
          var mod2 = total % limbLen;
          var end = Math.min(total, total - mod2) + start2;
          var word = 0;
          for (var i = start2; i < end; i += limbLen) {
            word = parseBase(number, i, i + limbLen, base);
            this.imuln(limbPow);
            if (this.words[0] + word < 67108864) {
              this.words[0] += word;
            } else {
              this._iaddn(word);
            }
          }
          if (mod2 !== 0) {
            var pow = 1;
            word = parseBase(number, i, number.length, base);
            for (i = 0; i < mod2; i++) {
              pow *= base;
            }
            this.imuln(pow);
            if (this.words[0] + word < 67108864) {
              this.words[0] += word;
            } else {
              this._iaddn(word);
            }
          }
          this._strip();
        };
        BN.prototype.copy = function copy(dest) {
          dest.words = new Array(this.length);
          for (var i = 0; i < this.length; i++) {
            dest.words[i] = this.words[i];
          }
          dest.length = this.length;
          dest.negative = this.negative;
          dest.red = this.red;
        };
        function move(dest, src) {
          dest.words = src.words;
          dest.length = src.length;
          dest.negative = src.negative;
          dest.red = src.red;
        }
        BN.prototype._move = function _move(dest) {
          move(dest, this);
        };
        BN.prototype.clone = function clone() {
          var r = new BN(null);
          this.copy(r);
          return r;
        };
        BN.prototype._expand = function _expand(size) {
          while (this.length < size) {
            this.words[this.length++] = 0;
          }
          return this;
        };
        BN.prototype._strip = function strip() {
          while (this.length > 1 && this.words[this.length - 1] === 0) {
            this.length--;
          }
          return this._normSign();
        };
        BN.prototype._normSign = function _normSign() {
          if (this.length === 1 && this.words[0] === 0) {
            this.negative = 0;
          }
          return this;
        };
        if (typeof Symbol !== "undefined" && typeof Symbol.for === "function") {
          try {
            BN.prototype[Symbol.for("nodejs.util.inspect.custom")] = inspect;
          } catch (e) {
            BN.prototype.inspect = inspect;
          }
        } else {
          BN.prototype.inspect = inspect;
        }
        function inspect() {
          return (this.red ? "<BN-R: " : "<BN: ") + this.toString(16) + ">";
        }
        var zeros = [
          "",
          "0",
          "00",
          "000",
          "0000",
          "00000",
          "000000",
          "0000000",
          "00000000",
          "000000000",
          "0000000000",
          "00000000000",
          "000000000000",
          "0000000000000",
          "00000000000000",
          "000000000000000",
          "0000000000000000",
          "00000000000000000",
          "000000000000000000",
          "0000000000000000000",
          "00000000000000000000",
          "000000000000000000000",
          "0000000000000000000000",
          "00000000000000000000000",
          "000000000000000000000000",
          "0000000000000000000000000"
        ];
        var groupSizes = [
          0,
          0,
          25,
          16,
          12,
          11,
          10,
          9,
          8,
          8,
          7,
          7,
          7,
          7,
          6,
          6,
          6,
          6,
          6,
          6,
          6,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5
        ];
        var groupBases = [
          0,
          0,
          33554432,
          43046721,
          16777216,
          48828125,
          60466176,
          40353607,
          16777216,
          43046721,
          1e7,
          19487171,
          35831808,
          62748517,
          7529536,
          11390625,
          16777216,
          24137569,
          34012224,
          47045881,
          64e6,
          4084101,
          5153632,
          6436343,
          7962624,
          9765625,
          11881376,
          14348907,
          17210368,
          20511149,
          243e5,
          28629151,
          33554432,
          39135393,
          45435424,
          52521875,
          60466176
        ];
        BN.prototype.toString = function toString(base, padding) {
          base = base || 10;
          padding = padding | 0 || 1;
          var out;
          if (base === 16 || base === "hex") {
            out = "";
            var off = 0;
            var carry = 0;
            for (var i = 0; i < this.length; i++) {
              var w = this.words[i];
              var word = ((w << off | carry) & 16777215).toString(16);
              carry = w >>> 24 - off & 16777215;
              if (carry !== 0 || i !== this.length - 1) {
                out = zeros[6 - word.length] + word + out;
              } else {
                out = word + out;
              }
              off += 2;
              if (off >= 26) {
                off -= 26;
                i--;
              }
            }
            if (carry !== 0) {
              out = carry.toString(16) + out;
            }
            while (out.length % padding !== 0) {
              out = "0" + out;
            }
            if (this.negative !== 0) {
              out = "-" + out;
            }
            return out;
          }
          if (base === (base | 0) && base >= 2 && base <= 36) {
            var groupSize = groupSizes[base];
            var groupBase = groupBases[base];
            out = "";
            var c = this.clone();
            c.negative = 0;
            while (!c.isZero()) {
              var r = c.modrn(groupBase).toString(base);
              c = c.idivn(groupBase);
              if (!c.isZero()) {
                out = zeros[groupSize - r.length] + r + out;
              } else {
                out = r + out;
              }
            }
            if (this.isZero()) {
              out = "0" + out;
            }
            while (out.length % padding !== 0) {
              out = "0" + out;
            }
            if (this.negative !== 0) {
              out = "-" + out;
            }
            return out;
          }
          assert(false, "Base should be between 2 and 36");
        };
        BN.prototype.toNumber = function toNumber() {
          var ret = this.words[0];
          if (this.length === 2) {
            ret += this.words[1] * 67108864;
          } else if (this.length === 3 && this.words[2] === 1) {
            ret += 4503599627370496 + this.words[1] * 67108864;
          } else if (this.length > 2) {
            assert(false, "Number can only safely store up to 53 bits");
          }
          return this.negative !== 0 ? -ret : ret;
        };
        BN.prototype.toJSON = function toJSON() {
          return this.toString(16, 2);
        };
        if (Buffer2) {
          BN.prototype.toBuffer = function toBuffer(endian, length) {
            return this.toArrayLike(Buffer2, endian, length);
          };
        }
        BN.prototype.toArray = function toArray(endian, length) {
          return this.toArrayLike(Array, endian, length);
        };
        var allocate = function allocate2(ArrayType, size) {
          if (ArrayType.allocUnsafe) {
            return ArrayType.allocUnsafe(size);
          }
          return new ArrayType(size);
        };
        BN.prototype.toArrayLike = function toArrayLike(ArrayType, endian, length) {
          this._strip();
          var byteLength = this.byteLength();
          var reqLength = length || Math.max(1, byteLength);
          assert(byteLength <= reqLength, "byte array longer than desired length");
          assert(reqLength > 0, "Requested array length <= 0");
          var res = allocate(ArrayType, reqLength);
          var postfix = endian === "le" ? "LE" : "BE";
          this["_toArrayLike" + postfix](res, byteLength);
          return res;
        };
        BN.prototype._toArrayLikeLE = function _toArrayLikeLE(res, byteLength) {
          var position = 0;
          var carry = 0;
          for (var i = 0, shift = 0; i < this.length; i++) {
            var word = this.words[i] << shift | carry;
            res[position++] = word & 255;
            if (position < res.length) {
              res[position++] = word >> 8 & 255;
            }
            if (position < res.length) {
              res[position++] = word >> 16 & 255;
            }
            if (shift === 6) {
              if (position < res.length) {
                res[position++] = word >> 24 & 255;
              }
              carry = 0;
              shift = 0;
            } else {
              carry = word >>> 24;
              shift += 2;
            }
          }
          if (position < res.length) {
            res[position++] = carry;
            while (position < res.length) {
              res[position++] = 0;
            }
          }
        };
        BN.prototype._toArrayLikeBE = function _toArrayLikeBE(res, byteLength) {
          var position = res.length - 1;
          var carry = 0;
          for (var i = 0, shift = 0; i < this.length; i++) {
            var word = this.words[i] << shift | carry;
            res[position--] = word & 255;
            if (position >= 0) {
              res[position--] = word >> 8 & 255;
            }
            if (position >= 0) {
              res[position--] = word >> 16 & 255;
            }
            if (shift === 6) {
              if (position >= 0) {
                res[position--] = word >> 24 & 255;
              }
              carry = 0;
              shift = 0;
            } else {
              carry = word >>> 24;
              shift += 2;
            }
          }
          if (position >= 0) {
            res[position--] = carry;
            while (position >= 0) {
              res[position--] = 0;
            }
          }
        };
        if (Math.clz32) {
          BN.prototype._countBits = function _countBits(w) {
            return 32 - Math.clz32(w);
          };
        } else {
          BN.prototype._countBits = function _countBits(w) {
            var t = w;
            var r = 0;
            if (t >= 4096) {
              r += 13;
              t >>>= 13;
            }
            if (t >= 64) {
              r += 7;
              t >>>= 7;
            }
            if (t >= 8) {
              r += 4;
              t >>>= 4;
            }
            if (t >= 2) {
              r += 2;
              t >>>= 2;
            }
            return r + t;
          };
        }
        BN.prototype._zeroBits = function _zeroBits(w) {
          if (w === 0)
            return 26;
          var t = w;
          var r = 0;
          if ((t & 8191) === 0) {
            r += 13;
            t >>>= 13;
          }
          if ((t & 127) === 0) {
            r += 7;
            t >>>= 7;
          }
          if ((t & 15) === 0) {
            r += 4;
            t >>>= 4;
          }
          if ((t & 3) === 0) {
            r += 2;
            t >>>= 2;
          }
          if ((t & 1) === 0) {
            r++;
          }
          return r;
        };
        BN.prototype.bitLength = function bitLength() {
          var w = this.words[this.length - 1];
          var hi = this._countBits(w);
          return (this.length - 1) * 26 + hi;
        };
        function toBitArray(num) {
          var w = new Array(num.bitLength());
          for (var bit = 0; bit < w.length; bit++) {
            var off = bit / 26 | 0;
            var wbit = bit % 26;
            w[bit] = num.words[off] >>> wbit & 1;
          }
          return w;
        }
        BN.prototype.zeroBits = function zeroBits() {
          if (this.isZero())
            return 0;
          var r = 0;
          for (var i = 0; i < this.length; i++) {
            var b = this._zeroBits(this.words[i]);
            r += b;
            if (b !== 26)
              break;
          }
          return r;
        };
        BN.prototype.byteLength = function byteLength() {
          return Math.ceil(this.bitLength() / 8);
        };
        BN.prototype.toTwos = function toTwos(width) {
          if (this.negative !== 0) {
            return this.abs().inotn(width).iaddn(1);
          }
          return this.clone();
        };
        BN.prototype.fromTwos = function fromTwos(width) {
          if (this.testn(width - 1)) {
            return this.notn(width).iaddn(1).ineg();
          }
          return this.clone();
        };
        BN.prototype.isNeg = function isNeg() {
          return this.negative !== 0;
        };
        BN.prototype.neg = function neg() {
          return this.clone().ineg();
        };
        BN.prototype.ineg = function ineg() {
          if (!this.isZero()) {
            this.negative ^= 1;
          }
          return this;
        };
        BN.prototype.iuor = function iuor(num) {
          while (this.length < num.length) {
            this.words[this.length++] = 0;
          }
          for (var i = 0; i < num.length; i++) {
            this.words[i] = this.words[i] | num.words[i];
          }
          return this._strip();
        };
        BN.prototype.ior = function ior(num) {
          assert((this.negative | num.negative) === 0);
          return this.iuor(num);
        };
        BN.prototype.or = function or(num) {
          if (this.length > num.length)
            return this.clone().ior(num);
          return num.clone().ior(this);
        };
        BN.prototype.uor = function uor(num) {
          if (this.length > num.length)
            return this.clone().iuor(num);
          return num.clone().iuor(this);
        };
        BN.prototype.iuand = function iuand(num) {
          var b;
          if (this.length > num.length) {
            b = num;
          } else {
            b = this;
          }
          for (var i = 0; i < b.length; i++) {
            this.words[i] = this.words[i] & num.words[i];
          }
          this.length = b.length;
          return this._strip();
        };
        BN.prototype.iand = function iand(num) {
          assert((this.negative | num.negative) === 0);
          return this.iuand(num);
        };
        BN.prototype.and = function and(num) {
          if (this.length > num.length)
            return this.clone().iand(num);
          return num.clone().iand(this);
        };
        BN.prototype.uand = function uand(num) {
          if (this.length > num.length)
            return this.clone().iuand(num);
          return num.clone().iuand(this);
        };
        BN.prototype.iuxor = function iuxor(num) {
          var a;
          var b;
          if (this.length > num.length) {
            a = this;
            b = num;
          } else {
            a = num;
            b = this;
          }
          for (var i = 0; i < b.length; i++) {
            this.words[i] = a.words[i] ^ b.words[i];
          }
          if (this !== a) {
            for (; i < a.length; i++) {
              this.words[i] = a.words[i];
            }
          }
          this.length = a.length;
          return this._strip();
        };
        BN.prototype.ixor = function ixor(num) {
          assert((this.negative | num.negative) === 0);
          return this.iuxor(num);
        };
        BN.prototype.xor = function xor(num) {
          if (this.length > num.length)
            return this.clone().ixor(num);
          return num.clone().ixor(this);
        };
        BN.prototype.uxor = function uxor(num) {
          if (this.length > num.length)
            return this.clone().iuxor(num);
          return num.clone().iuxor(this);
        };
        BN.prototype.inotn = function inotn(width) {
          assert(typeof width === "number" && width >= 0);
          var bytesNeeded = Math.ceil(width / 26) | 0;
          var bitsLeft = width % 26;
          this._expand(bytesNeeded);
          if (bitsLeft > 0) {
            bytesNeeded--;
          }
          for (var i = 0; i < bytesNeeded; i++) {
            this.words[i] = ~this.words[i] & 67108863;
          }
          if (bitsLeft > 0) {
            this.words[i] = ~this.words[i] & 67108863 >> 26 - bitsLeft;
          }
          return this._strip();
        };
        BN.prototype.notn = function notn(width) {
          return this.clone().inotn(width);
        };
        BN.prototype.setn = function setn(bit, val) {
          assert(typeof bit === "number" && bit >= 0);
          var off = bit / 26 | 0;
          var wbit = bit % 26;
          this._expand(off + 1);
          if (val) {
            this.words[off] = this.words[off] | 1 << wbit;
          } else {
            this.words[off] = this.words[off] & ~(1 << wbit);
          }
          return this._strip();
        };
        BN.prototype.iadd = function iadd(num) {
          var r;
          if (this.negative !== 0 && num.negative === 0) {
            this.negative = 0;
            r = this.isub(num);
            this.negative ^= 1;
            return this._normSign();
          } else if (this.negative === 0 && num.negative !== 0) {
            num.negative = 0;
            r = this.isub(num);
            num.negative = 1;
            return r._normSign();
          }
          var a, b;
          if (this.length > num.length) {
            a = this;
            b = num;
          } else {
            a = num;
            b = this;
          }
          var carry = 0;
          for (var i = 0; i < b.length; i++) {
            r = (a.words[i] | 0) + (b.words[i] | 0) + carry;
            this.words[i] = r & 67108863;
            carry = r >>> 26;
          }
          for (; carry !== 0 && i < a.length; i++) {
            r = (a.words[i] | 0) + carry;
            this.words[i] = r & 67108863;
            carry = r >>> 26;
          }
          this.length = a.length;
          if (carry !== 0) {
            this.words[this.length] = carry;
            this.length++;
          } else if (a !== this) {
            for (; i < a.length; i++) {
              this.words[i] = a.words[i];
            }
          }
          return this;
        };
        BN.prototype.add = function add(num) {
          var res;
          if (num.negative !== 0 && this.negative === 0) {
            num.negative = 0;
            res = this.sub(num);
            num.negative ^= 1;
            return res;
          } else if (num.negative === 0 && this.negative !== 0) {
            this.negative = 0;
            res = num.sub(this);
            this.negative = 1;
            return res;
          }
          if (this.length > num.length)
            return this.clone().iadd(num);
          return num.clone().iadd(this);
        };
        BN.prototype.isub = function isub(num) {
          if (num.negative !== 0) {
            num.negative = 0;
            var r = this.iadd(num);
            num.negative = 1;
            return r._normSign();
          } else if (this.negative !== 0) {
            this.negative = 0;
            this.iadd(num);
            this.negative = 1;
            return this._normSign();
          }
          var cmp = this.cmp(num);
          if (cmp === 0) {
            this.negative = 0;
            this.length = 1;
            this.words[0] = 0;
            return this;
          }
          var a, b;
          if (cmp > 0) {
            a = this;
            b = num;
          } else {
            a = num;
            b = this;
          }
          var carry = 0;
          for (var i = 0; i < b.length; i++) {
            r = (a.words[i] | 0) - (b.words[i] | 0) + carry;
            carry = r >> 26;
            this.words[i] = r & 67108863;
          }
          for (; carry !== 0 && i < a.length; i++) {
            r = (a.words[i] | 0) + carry;
            carry = r >> 26;
            this.words[i] = r & 67108863;
          }
          if (carry === 0 && i < a.length && a !== this) {
            for (; i < a.length; i++) {
              this.words[i] = a.words[i];
            }
          }
          this.length = Math.max(this.length, i);
          if (a !== this) {
            this.negative = 1;
          }
          return this._strip();
        };
        BN.prototype.sub = function sub(num) {
          return this.clone().isub(num);
        };
        function smallMulTo(self2, num, out) {
          out.negative = num.negative ^ self2.negative;
          var len = self2.length + num.length | 0;
          out.length = len;
          len = len - 1 | 0;
          var a = self2.words[0] | 0;
          var b = num.words[0] | 0;
          var r = a * b;
          var lo = r & 67108863;
          var carry = r / 67108864 | 0;
          out.words[0] = lo;
          for (var k = 1; k < len; k++) {
            var ncarry = carry >>> 26;
            var rword = carry & 67108863;
            var maxJ = Math.min(k, num.length - 1);
            for (var j = Math.max(0, k - self2.length + 1); j <= maxJ; j++) {
              var i = k - j | 0;
              a = self2.words[i] | 0;
              b = num.words[j] | 0;
              r = a * b + rword;
              ncarry += r / 67108864 | 0;
              rword = r & 67108863;
            }
            out.words[k] = rword | 0;
            carry = ncarry | 0;
          }
          if (carry !== 0) {
            out.words[k] = carry | 0;
          } else {
            out.length--;
          }
          return out._strip();
        }
        var comb10MulTo = function comb10MulTo2(self2, num, out) {
          var a = self2.words;
          var b = num.words;
          var o = out.words;
          var c = 0;
          var lo;
          var mid;
          var hi;
          var a0 = a[0] | 0;
          var al0 = a0 & 8191;
          var ah0 = a0 >>> 13;
          var a1 = a[1] | 0;
          var al1 = a1 & 8191;
          var ah1 = a1 >>> 13;
          var a2 = a[2] | 0;
          var al2 = a2 & 8191;
          var ah2 = a2 >>> 13;
          var a3 = a[3] | 0;
          var al3 = a3 & 8191;
          var ah3 = a3 >>> 13;
          var a4 = a[4] | 0;
          var al4 = a4 & 8191;
          var ah4 = a4 >>> 13;
          var a5 = a[5] | 0;
          var al5 = a5 & 8191;
          var ah5 = a5 >>> 13;
          var a6 = a[6] | 0;
          var al6 = a6 & 8191;
          var ah6 = a6 >>> 13;
          var a7 = a[7] | 0;
          var al7 = a7 & 8191;
          var ah7 = a7 >>> 13;
          var a8 = a[8] | 0;
          var al8 = a8 & 8191;
          var ah8 = a8 >>> 13;
          var a9 = a[9] | 0;
          var al9 = a9 & 8191;
          var ah9 = a9 >>> 13;
          var b0 = b[0] | 0;
          var bl0 = b0 & 8191;
          var bh0 = b0 >>> 13;
          var b1 = b[1] | 0;
          var bl1 = b1 & 8191;
          var bh1 = b1 >>> 13;
          var b2 = b[2] | 0;
          var bl2 = b2 & 8191;
          var bh2 = b2 >>> 13;
          var b3 = b[3] | 0;
          var bl3 = b3 & 8191;
          var bh3 = b3 >>> 13;
          var b4 = b[4] | 0;
          var bl4 = b4 & 8191;
          var bh4 = b4 >>> 13;
          var b5 = b[5] | 0;
          var bl5 = b5 & 8191;
          var bh5 = b5 >>> 13;
          var b6 = b[6] | 0;
          var bl6 = b6 & 8191;
          var bh6 = b6 >>> 13;
          var b7 = b[7] | 0;
          var bl7 = b7 & 8191;
          var bh7 = b7 >>> 13;
          var b8 = b[8] | 0;
          var bl8 = b8 & 8191;
          var bh8 = b8 >>> 13;
          var b9 = b[9] | 0;
          var bl9 = b9 & 8191;
          var bh9 = b9 >>> 13;
          out.negative = self2.negative ^ num.negative;
          out.length = 19;
          lo = Math.imul(al0, bl0);
          mid = Math.imul(al0, bh0);
          mid = mid + Math.imul(ah0, bl0) | 0;
          hi = Math.imul(ah0, bh0);
          var w0 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w0 >>> 26) | 0;
          w0 &= 67108863;
          lo = Math.imul(al1, bl0);
          mid = Math.imul(al1, bh0);
          mid = mid + Math.imul(ah1, bl0) | 0;
          hi = Math.imul(ah1, bh0);
          lo = lo + Math.imul(al0, bl1) | 0;
          mid = mid + Math.imul(al0, bh1) | 0;
          mid = mid + Math.imul(ah0, bl1) | 0;
          hi = hi + Math.imul(ah0, bh1) | 0;
          var w1 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w1 >>> 26) | 0;
          w1 &= 67108863;
          lo = Math.imul(al2, bl0);
          mid = Math.imul(al2, bh0);
          mid = mid + Math.imul(ah2, bl0) | 0;
          hi = Math.imul(ah2, bh0);
          lo = lo + Math.imul(al1, bl1) | 0;
          mid = mid + Math.imul(al1, bh1) | 0;
          mid = mid + Math.imul(ah1, bl1) | 0;
          hi = hi + Math.imul(ah1, bh1) | 0;
          lo = lo + Math.imul(al0, bl2) | 0;
          mid = mid + Math.imul(al0, bh2) | 0;
          mid = mid + Math.imul(ah0, bl2) | 0;
          hi = hi + Math.imul(ah0, bh2) | 0;
          var w2 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w2 >>> 26) | 0;
          w2 &= 67108863;
          lo = Math.imul(al3, bl0);
          mid = Math.imul(al3, bh0);
          mid = mid + Math.imul(ah3, bl0) | 0;
          hi = Math.imul(ah3, bh0);
          lo = lo + Math.imul(al2, bl1) | 0;
          mid = mid + Math.imul(al2, bh1) | 0;
          mid = mid + Math.imul(ah2, bl1) | 0;
          hi = hi + Math.imul(ah2, bh1) | 0;
          lo = lo + Math.imul(al1, bl2) | 0;
          mid = mid + Math.imul(al1, bh2) | 0;
          mid = mid + Math.imul(ah1, bl2) | 0;
          hi = hi + Math.imul(ah1, bh2) | 0;
          lo = lo + Math.imul(al0, bl3) | 0;
          mid = mid + Math.imul(al0, bh3) | 0;
          mid = mid + Math.imul(ah0, bl3) | 0;
          hi = hi + Math.imul(ah0, bh3) | 0;
          var w3 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w3 >>> 26) | 0;
          w3 &= 67108863;
          lo = Math.imul(al4, bl0);
          mid = Math.imul(al4, bh0);
          mid = mid + Math.imul(ah4, bl0) | 0;
          hi = Math.imul(ah4, bh0);
          lo = lo + Math.imul(al3, bl1) | 0;
          mid = mid + Math.imul(al3, bh1) | 0;
          mid = mid + Math.imul(ah3, bl1) | 0;
          hi = hi + Math.imul(ah3, bh1) | 0;
          lo = lo + Math.imul(al2, bl2) | 0;
          mid = mid + Math.imul(al2, bh2) | 0;
          mid = mid + Math.imul(ah2, bl2) | 0;
          hi = hi + Math.imul(ah2, bh2) | 0;
          lo = lo + Math.imul(al1, bl3) | 0;
          mid = mid + Math.imul(al1, bh3) | 0;
          mid = mid + Math.imul(ah1, bl3) | 0;
          hi = hi + Math.imul(ah1, bh3) | 0;
          lo = lo + Math.imul(al0, bl4) | 0;
          mid = mid + Math.imul(al0, bh4) | 0;
          mid = mid + Math.imul(ah0, bl4) | 0;
          hi = hi + Math.imul(ah0, bh4) | 0;
          var w4 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w4 >>> 26) | 0;
          w4 &= 67108863;
          lo = Math.imul(al5, bl0);
          mid = Math.imul(al5, bh0);
          mid = mid + Math.imul(ah5, bl0) | 0;
          hi = Math.imul(ah5, bh0);
          lo = lo + Math.imul(al4, bl1) | 0;
          mid = mid + Math.imul(al4, bh1) | 0;
          mid = mid + Math.imul(ah4, bl1) | 0;
          hi = hi + Math.imul(ah4, bh1) | 0;
          lo = lo + Math.imul(al3, bl2) | 0;
          mid = mid + Math.imul(al3, bh2) | 0;
          mid = mid + Math.imul(ah3, bl2) | 0;
          hi = hi + Math.imul(ah3, bh2) | 0;
          lo = lo + Math.imul(al2, bl3) | 0;
          mid = mid + Math.imul(al2, bh3) | 0;
          mid = mid + Math.imul(ah2, bl3) | 0;
          hi = hi + Math.imul(ah2, bh3) | 0;
          lo = lo + Math.imul(al1, bl4) | 0;
          mid = mid + Math.imul(al1, bh4) | 0;
          mid = mid + Math.imul(ah1, bl4) | 0;
          hi = hi + Math.imul(ah1, bh4) | 0;
          lo = lo + Math.imul(al0, bl5) | 0;
          mid = mid + Math.imul(al0, bh5) | 0;
          mid = mid + Math.imul(ah0, bl5) | 0;
          hi = hi + Math.imul(ah0, bh5) | 0;
          var w5 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w5 >>> 26) | 0;
          w5 &= 67108863;
          lo = Math.imul(al6, bl0);
          mid = Math.imul(al6, bh0);
          mid = mid + Math.imul(ah6, bl0) | 0;
          hi = Math.imul(ah6, bh0);
          lo = lo + Math.imul(al5, bl1) | 0;
          mid = mid + Math.imul(al5, bh1) | 0;
          mid = mid + Math.imul(ah5, bl1) | 0;
          hi = hi + Math.imul(ah5, bh1) | 0;
          lo = lo + Math.imul(al4, bl2) | 0;
          mid = mid + Math.imul(al4, bh2) | 0;
          mid = mid + Math.imul(ah4, bl2) | 0;
          hi = hi + Math.imul(ah4, bh2) | 0;
          lo = lo + Math.imul(al3, bl3) | 0;
          mid = mid + Math.imul(al3, bh3) | 0;
          mid = mid + Math.imul(ah3, bl3) | 0;
          hi = hi + Math.imul(ah3, bh3) | 0;
          lo = lo + Math.imul(al2, bl4) | 0;
          mid = mid + Math.imul(al2, bh4) | 0;
          mid = mid + Math.imul(ah2, bl4) | 0;
          hi = hi + Math.imul(ah2, bh4) | 0;
          lo = lo + Math.imul(al1, bl5) | 0;
          mid = mid + Math.imul(al1, bh5) | 0;
          mid = mid + Math.imul(ah1, bl5) | 0;
          hi = hi + Math.imul(ah1, bh5) | 0;
          lo = lo + Math.imul(al0, bl6) | 0;
          mid = mid + Math.imul(al0, bh6) | 0;
          mid = mid + Math.imul(ah0, bl6) | 0;
          hi = hi + Math.imul(ah0, bh6) | 0;
          var w6 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w6 >>> 26) | 0;
          w6 &= 67108863;
          lo = Math.imul(al7, bl0);
          mid = Math.imul(al7, bh0);
          mid = mid + Math.imul(ah7, bl0) | 0;
          hi = Math.imul(ah7, bh0);
          lo = lo + Math.imul(al6, bl1) | 0;
          mid = mid + Math.imul(al6, bh1) | 0;
          mid = mid + Math.imul(ah6, bl1) | 0;
          hi = hi + Math.imul(ah6, bh1) | 0;
          lo = lo + Math.imul(al5, bl2) | 0;
          mid = mid + Math.imul(al5, bh2) | 0;
          mid = mid + Math.imul(ah5, bl2) | 0;
          hi = hi + Math.imul(ah5, bh2) | 0;
          lo = lo + Math.imul(al4, bl3) | 0;
          mid = mid + Math.imul(al4, bh3) | 0;
          mid = mid + Math.imul(ah4, bl3) | 0;
          hi = hi + Math.imul(ah4, bh3) | 0;
          lo = lo + Math.imul(al3, bl4) | 0;
          mid = mid + Math.imul(al3, bh4) | 0;
          mid = mid + Math.imul(ah3, bl4) | 0;
          hi = hi + Math.imul(ah3, bh4) | 0;
          lo = lo + Math.imul(al2, bl5) | 0;
          mid = mid + Math.imul(al2, bh5) | 0;
          mid = mid + Math.imul(ah2, bl5) | 0;
          hi = hi + Math.imul(ah2, bh5) | 0;
          lo = lo + Math.imul(al1, bl6) | 0;
          mid = mid + Math.imul(al1, bh6) | 0;
          mid = mid + Math.imul(ah1, bl6) | 0;
          hi = hi + Math.imul(ah1, bh6) | 0;
          lo = lo + Math.imul(al0, bl7) | 0;
          mid = mid + Math.imul(al0, bh7) | 0;
          mid = mid + Math.imul(ah0, bl7) | 0;
          hi = hi + Math.imul(ah0, bh7) | 0;
          var w7 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w7 >>> 26) | 0;
          w7 &= 67108863;
          lo = Math.imul(al8, bl0);
          mid = Math.imul(al8, bh0);
          mid = mid + Math.imul(ah8, bl0) | 0;
          hi = Math.imul(ah8, bh0);
          lo = lo + Math.imul(al7, bl1) | 0;
          mid = mid + Math.imul(al7, bh1) | 0;
          mid = mid + Math.imul(ah7, bl1) | 0;
          hi = hi + Math.imul(ah7, bh1) | 0;
          lo = lo + Math.imul(al6, bl2) | 0;
          mid = mid + Math.imul(al6, bh2) | 0;
          mid = mid + Math.imul(ah6, bl2) | 0;
          hi = hi + Math.imul(ah6, bh2) | 0;
          lo = lo + Math.imul(al5, bl3) | 0;
          mid = mid + Math.imul(al5, bh3) | 0;
          mid = mid + Math.imul(ah5, bl3) | 0;
          hi = hi + Math.imul(ah5, bh3) | 0;
          lo = lo + Math.imul(al4, bl4) | 0;
          mid = mid + Math.imul(al4, bh4) | 0;
          mid = mid + Math.imul(ah4, bl4) | 0;
          hi = hi + Math.imul(ah4, bh4) | 0;
          lo = lo + Math.imul(al3, bl5) | 0;
          mid = mid + Math.imul(al3, bh5) | 0;
          mid = mid + Math.imul(ah3, bl5) | 0;
          hi = hi + Math.imul(ah3, bh5) | 0;
          lo = lo + Math.imul(al2, bl6) | 0;
          mid = mid + Math.imul(al2, bh6) | 0;
          mid = mid + Math.imul(ah2, bl6) | 0;
          hi = hi + Math.imul(ah2, bh6) | 0;
          lo = lo + Math.imul(al1, bl7) | 0;
          mid = mid + Math.imul(al1, bh7) | 0;
          mid = mid + Math.imul(ah1, bl7) | 0;
          hi = hi + Math.imul(ah1, bh7) | 0;
          lo = lo + Math.imul(al0, bl8) | 0;
          mid = mid + Math.imul(al0, bh8) | 0;
          mid = mid + Math.imul(ah0, bl8) | 0;
          hi = hi + Math.imul(ah0, bh8) | 0;
          var w8 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w8 >>> 26) | 0;
          w8 &= 67108863;
          lo = Math.imul(al9, bl0);
          mid = Math.imul(al9, bh0);
          mid = mid + Math.imul(ah9, bl0) | 0;
          hi = Math.imul(ah9, bh0);
          lo = lo + Math.imul(al8, bl1) | 0;
          mid = mid + Math.imul(al8, bh1) | 0;
          mid = mid + Math.imul(ah8, bl1) | 0;
          hi = hi + Math.imul(ah8, bh1) | 0;
          lo = lo + Math.imul(al7, bl2) | 0;
          mid = mid + Math.imul(al7, bh2) | 0;
          mid = mid + Math.imul(ah7, bl2) | 0;
          hi = hi + Math.imul(ah7, bh2) | 0;
          lo = lo + Math.imul(al6, bl3) | 0;
          mid = mid + Math.imul(al6, bh3) | 0;
          mid = mid + Math.imul(ah6, bl3) | 0;
          hi = hi + Math.imul(ah6, bh3) | 0;
          lo = lo + Math.imul(al5, bl4) | 0;
          mid = mid + Math.imul(al5, bh4) | 0;
          mid = mid + Math.imul(ah5, bl4) | 0;
          hi = hi + Math.imul(ah5, bh4) | 0;
          lo = lo + Math.imul(al4, bl5) | 0;
          mid = mid + Math.imul(al4, bh5) | 0;
          mid = mid + Math.imul(ah4, bl5) | 0;
          hi = hi + Math.imul(ah4, bh5) | 0;
          lo = lo + Math.imul(al3, bl6) | 0;
          mid = mid + Math.imul(al3, bh6) | 0;
          mid = mid + Math.imul(ah3, bl6) | 0;
          hi = hi + Math.imul(ah3, bh6) | 0;
          lo = lo + Math.imul(al2, bl7) | 0;
          mid = mid + Math.imul(al2, bh7) | 0;
          mid = mid + Math.imul(ah2, bl7) | 0;
          hi = hi + Math.imul(ah2, bh7) | 0;
          lo = lo + Math.imul(al1, bl8) | 0;
          mid = mid + Math.imul(al1, bh8) | 0;
          mid = mid + Math.imul(ah1, bl8) | 0;
          hi = hi + Math.imul(ah1, bh8) | 0;
          lo = lo + Math.imul(al0, bl9) | 0;
          mid = mid + Math.imul(al0, bh9) | 0;
          mid = mid + Math.imul(ah0, bl9) | 0;
          hi = hi + Math.imul(ah0, bh9) | 0;
          var w9 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w9 >>> 26) | 0;
          w9 &= 67108863;
          lo = Math.imul(al9, bl1);
          mid = Math.imul(al9, bh1);
          mid = mid + Math.imul(ah9, bl1) | 0;
          hi = Math.imul(ah9, bh1);
          lo = lo + Math.imul(al8, bl2) | 0;
          mid = mid + Math.imul(al8, bh2) | 0;
          mid = mid + Math.imul(ah8, bl2) | 0;
          hi = hi + Math.imul(ah8, bh2) | 0;
          lo = lo + Math.imul(al7, bl3) | 0;
          mid = mid + Math.imul(al7, bh3) | 0;
          mid = mid + Math.imul(ah7, bl3) | 0;
          hi = hi + Math.imul(ah7, bh3) | 0;
          lo = lo + Math.imul(al6, bl4) | 0;
          mid = mid + Math.imul(al6, bh4) | 0;
          mid = mid + Math.imul(ah6, bl4) | 0;
          hi = hi + Math.imul(ah6, bh4) | 0;
          lo = lo + Math.imul(al5, bl5) | 0;
          mid = mid + Math.imul(al5, bh5) | 0;
          mid = mid + Math.imul(ah5, bl5) | 0;
          hi = hi + Math.imul(ah5, bh5) | 0;
          lo = lo + Math.imul(al4, bl6) | 0;
          mid = mid + Math.imul(al4, bh6) | 0;
          mid = mid + Math.imul(ah4, bl6) | 0;
          hi = hi + Math.imul(ah4, bh6) | 0;
          lo = lo + Math.imul(al3, bl7) | 0;
          mid = mid + Math.imul(al3, bh7) | 0;
          mid = mid + Math.imul(ah3, bl7) | 0;
          hi = hi + Math.imul(ah3, bh7) | 0;
          lo = lo + Math.imul(al2, bl8) | 0;
          mid = mid + Math.imul(al2, bh8) | 0;
          mid = mid + Math.imul(ah2, bl8) | 0;
          hi = hi + Math.imul(ah2, bh8) | 0;
          lo = lo + Math.imul(al1, bl9) | 0;
          mid = mid + Math.imul(al1, bh9) | 0;
          mid = mid + Math.imul(ah1, bl9) | 0;
          hi = hi + Math.imul(ah1, bh9) | 0;
          var w10 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w10 >>> 26) | 0;
          w10 &= 67108863;
          lo = Math.imul(al9, bl2);
          mid = Math.imul(al9, bh2);
          mid = mid + Math.imul(ah9, bl2) | 0;
          hi = Math.imul(ah9, bh2);
          lo = lo + Math.imul(al8, bl3) | 0;
          mid = mid + Math.imul(al8, bh3) | 0;
          mid = mid + Math.imul(ah8, bl3) | 0;
          hi = hi + Math.imul(ah8, bh3) | 0;
          lo = lo + Math.imul(al7, bl4) | 0;
          mid = mid + Math.imul(al7, bh4) | 0;
          mid = mid + Math.imul(ah7, bl4) | 0;
          hi = hi + Math.imul(ah7, bh4) | 0;
          lo = lo + Math.imul(al6, bl5) | 0;
          mid = mid + Math.imul(al6, bh5) | 0;
          mid = mid + Math.imul(ah6, bl5) | 0;
          hi = hi + Math.imul(ah6, bh5) | 0;
          lo = lo + Math.imul(al5, bl6) | 0;
          mid = mid + Math.imul(al5, bh6) | 0;
          mid = mid + Math.imul(ah5, bl6) | 0;
          hi = hi + Math.imul(ah5, bh6) | 0;
          lo = lo + Math.imul(al4, bl7) | 0;
          mid = mid + Math.imul(al4, bh7) | 0;
          mid = mid + Math.imul(ah4, bl7) | 0;
          hi = hi + Math.imul(ah4, bh7) | 0;
          lo = lo + Math.imul(al3, bl8) | 0;
          mid = mid + Math.imul(al3, bh8) | 0;
          mid = mid + Math.imul(ah3, bl8) | 0;
          hi = hi + Math.imul(ah3, bh8) | 0;
          lo = lo + Math.imul(al2, bl9) | 0;
          mid = mid + Math.imul(al2, bh9) | 0;
          mid = mid + Math.imul(ah2, bl9) | 0;
          hi = hi + Math.imul(ah2, bh9) | 0;
          var w11 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w11 >>> 26) | 0;
          w11 &= 67108863;
          lo = Math.imul(al9, bl3);
          mid = Math.imul(al9, bh3);
          mid = mid + Math.imul(ah9, bl3) | 0;
          hi = Math.imul(ah9, bh3);
          lo = lo + Math.imul(al8, bl4) | 0;
          mid = mid + Math.imul(al8, bh4) | 0;
          mid = mid + Math.imul(ah8, bl4) | 0;
          hi = hi + Math.imul(ah8, bh4) | 0;
          lo = lo + Math.imul(al7, bl5) | 0;
          mid = mid + Math.imul(al7, bh5) | 0;
          mid = mid + Math.imul(ah7, bl5) | 0;
          hi = hi + Math.imul(ah7, bh5) | 0;
          lo = lo + Math.imul(al6, bl6) | 0;
          mid = mid + Math.imul(al6, bh6) | 0;
          mid = mid + Math.imul(ah6, bl6) | 0;
          hi = hi + Math.imul(ah6, bh6) | 0;
          lo = lo + Math.imul(al5, bl7) | 0;
          mid = mid + Math.imul(al5, bh7) | 0;
          mid = mid + Math.imul(ah5, bl7) | 0;
          hi = hi + Math.imul(ah5, bh7) | 0;
          lo = lo + Math.imul(al4, bl8) | 0;
          mid = mid + Math.imul(al4, bh8) | 0;
          mid = mid + Math.imul(ah4, bl8) | 0;
          hi = hi + Math.imul(ah4, bh8) | 0;
          lo = lo + Math.imul(al3, bl9) | 0;
          mid = mid + Math.imul(al3, bh9) | 0;
          mid = mid + Math.imul(ah3, bl9) | 0;
          hi = hi + Math.imul(ah3, bh9) | 0;
          var w12 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w12 >>> 26) | 0;
          w12 &= 67108863;
          lo = Math.imul(al9, bl4);
          mid = Math.imul(al9, bh4);
          mid = mid + Math.imul(ah9, bl4) | 0;
          hi = Math.imul(ah9, bh4);
          lo = lo + Math.imul(al8, bl5) | 0;
          mid = mid + Math.imul(al8, bh5) | 0;
          mid = mid + Math.imul(ah8, bl5) | 0;
          hi = hi + Math.imul(ah8, bh5) | 0;
          lo = lo + Math.imul(al7, bl6) | 0;
          mid = mid + Math.imul(al7, bh6) | 0;
          mid = mid + Math.imul(ah7, bl6) | 0;
          hi = hi + Math.imul(ah7, bh6) | 0;
          lo = lo + Math.imul(al6, bl7) | 0;
          mid = mid + Math.imul(al6, bh7) | 0;
          mid = mid + Math.imul(ah6, bl7) | 0;
          hi = hi + Math.imul(ah6, bh7) | 0;
          lo = lo + Math.imul(al5, bl8) | 0;
          mid = mid + Math.imul(al5, bh8) | 0;
          mid = mid + Math.imul(ah5, bl8) | 0;
          hi = hi + Math.imul(ah5, bh8) | 0;
          lo = lo + Math.imul(al4, bl9) | 0;
          mid = mid + Math.imul(al4, bh9) | 0;
          mid = mid + Math.imul(ah4, bl9) | 0;
          hi = hi + Math.imul(ah4, bh9) | 0;
          var w13 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w13 >>> 26) | 0;
          w13 &= 67108863;
          lo = Math.imul(al9, bl5);
          mid = Math.imul(al9, bh5);
          mid = mid + Math.imul(ah9, bl5) | 0;
          hi = Math.imul(ah9, bh5);
          lo = lo + Math.imul(al8, bl6) | 0;
          mid = mid + Math.imul(al8, bh6) | 0;
          mid = mid + Math.imul(ah8, bl6) | 0;
          hi = hi + Math.imul(ah8, bh6) | 0;
          lo = lo + Math.imul(al7, bl7) | 0;
          mid = mid + Math.imul(al7, bh7) | 0;
          mid = mid + Math.imul(ah7, bl7) | 0;
          hi = hi + Math.imul(ah7, bh7) | 0;
          lo = lo + Math.imul(al6, bl8) | 0;
          mid = mid + Math.imul(al6, bh8) | 0;
          mid = mid + Math.imul(ah6, bl8) | 0;
          hi = hi + Math.imul(ah6, bh8) | 0;
          lo = lo + Math.imul(al5, bl9) | 0;
          mid = mid + Math.imul(al5, bh9) | 0;
          mid = mid + Math.imul(ah5, bl9) | 0;
          hi = hi + Math.imul(ah5, bh9) | 0;
          var w14 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w14 >>> 26) | 0;
          w14 &= 67108863;
          lo = Math.imul(al9, bl6);
          mid = Math.imul(al9, bh6);
          mid = mid + Math.imul(ah9, bl6) | 0;
          hi = Math.imul(ah9, bh6);
          lo = lo + Math.imul(al8, bl7) | 0;
          mid = mid + Math.imul(al8, bh7) | 0;
          mid = mid + Math.imul(ah8, bl7) | 0;
          hi = hi + Math.imul(ah8, bh7) | 0;
          lo = lo + Math.imul(al7, bl8) | 0;
          mid = mid + Math.imul(al7, bh8) | 0;
          mid = mid + Math.imul(ah7, bl8) | 0;
          hi = hi + Math.imul(ah7, bh8) | 0;
          lo = lo + Math.imul(al6, bl9) | 0;
          mid = mid + Math.imul(al6, bh9) | 0;
          mid = mid + Math.imul(ah6, bl9) | 0;
          hi = hi + Math.imul(ah6, bh9) | 0;
          var w15 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w15 >>> 26) | 0;
          w15 &= 67108863;
          lo = Math.imul(al9, bl7);
          mid = Math.imul(al9, bh7);
          mid = mid + Math.imul(ah9, bl7) | 0;
          hi = Math.imul(ah9, bh7);
          lo = lo + Math.imul(al8, bl8) | 0;
          mid = mid + Math.imul(al8, bh8) | 0;
          mid = mid + Math.imul(ah8, bl8) | 0;
          hi = hi + Math.imul(ah8, bh8) | 0;
          lo = lo + Math.imul(al7, bl9) | 0;
          mid = mid + Math.imul(al7, bh9) | 0;
          mid = mid + Math.imul(ah7, bl9) | 0;
          hi = hi + Math.imul(ah7, bh9) | 0;
          var w16 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w16 >>> 26) | 0;
          w16 &= 67108863;
          lo = Math.imul(al9, bl8);
          mid = Math.imul(al9, bh8);
          mid = mid + Math.imul(ah9, bl8) | 0;
          hi = Math.imul(ah9, bh8);
          lo = lo + Math.imul(al8, bl9) | 0;
          mid = mid + Math.imul(al8, bh9) | 0;
          mid = mid + Math.imul(ah8, bl9) | 0;
          hi = hi + Math.imul(ah8, bh9) | 0;
          var w17 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w17 >>> 26) | 0;
          w17 &= 67108863;
          lo = Math.imul(al9, bl9);
          mid = Math.imul(al9, bh9);
          mid = mid + Math.imul(ah9, bl9) | 0;
          hi = Math.imul(ah9, bh9);
          var w18 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w18 >>> 26) | 0;
          w18 &= 67108863;
          o[0] = w0;
          o[1] = w1;
          o[2] = w2;
          o[3] = w3;
          o[4] = w4;
          o[5] = w5;
          o[6] = w6;
          o[7] = w7;
          o[8] = w8;
          o[9] = w9;
          o[10] = w10;
          o[11] = w11;
          o[12] = w12;
          o[13] = w13;
          o[14] = w14;
          o[15] = w15;
          o[16] = w16;
          o[17] = w17;
          o[18] = w18;
          if (c !== 0) {
            o[19] = c;
            out.length++;
          }
          return out;
        };
        if (!Math.imul) {
          comb10MulTo = smallMulTo;
        }
        function bigMulTo(self2, num, out) {
          out.negative = num.negative ^ self2.negative;
          out.length = self2.length + num.length;
          var carry = 0;
          var hncarry = 0;
          for (var k = 0; k < out.length - 1; k++) {
            var ncarry = hncarry;
            hncarry = 0;
            var rword = carry & 67108863;
            var maxJ = Math.min(k, num.length - 1);
            for (var j = Math.max(0, k - self2.length + 1); j <= maxJ; j++) {
              var i = k - j;
              var a = self2.words[i] | 0;
              var b = num.words[j] | 0;
              var r = a * b;
              var lo = r & 67108863;
              ncarry = ncarry + (r / 67108864 | 0) | 0;
              lo = lo + rword | 0;
              rword = lo & 67108863;
              ncarry = ncarry + (lo >>> 26) | 0;
              hncarry += ncarry >>> 26;
              ncarry &= 67108863;
            }
            out.words[k] = rword;
            carry = ncarry;
            ncarry = hncarry;
          }
          if (carry !== 0) {
            out.words[k] = carry;
          } else {
            out.length--;
          }
          return out._strip();
        }
        function jumboMulTo(self2, num, out) {
          return bigMulTo(self2, num, out);
        }
        BN.prototype.mulTo = function mulTo(num, out) {
          var res;
          var len = this.length + num.length;
          if (this.length === 10 && num.length === 10) {
            res = comb10MulTo(this, num, out);
          } else if (len < 63) {
            res = smallMulTo(this, num, out);
          } else if (len < 1024) {
            res = bigMulTo(this, num, out);
          } else {
            res = jumboMulTo(this, num, out);
          }
          return res;
        };
        function FFTM(x, y) {
          this.x = x;
          this.y = y;
        }
        FFTM.prototype.makeRBT = function makeRBT(N) {
          var t = new Array(N);
          var l = BN.prototype._countBits(N) - 1;
          for (var i = 0; i < N; i++) {
            t[i] = this.revBin(i, l, N);
          }
          return t;
        };
        FFTM.prototype.revBin = function revBin(x, l, N) {
          if (x === 0 || x === N - 1)
            return x;
          var rb = 0;
          for (var i = 0; i < l; i++) {
            rb |= (x & 1) << l - i - 1;
            x >>= 1;
          }
          return rb;
        };
        FFTM.prototype.permute = function permute(rbt, rws, iws, rtws, itws, N) {
          for (var i = 0; i < N; i++) {
            rtws[i] = rws[rbt[i]];
            itws[i] = iws[rbt[i]];
          }
        };
        FFTM.prototype.transform = function transform(rws, iws, rtws, itws, N, rbt) {
          this.permute(rbt, rws, iws, rtws, itws, N);
          for (var s = 1; s < N; s <<= 1) {
            var l = s << 1;
            var rtwdf = Math.cos(2 * Math.PI / l);
            var itwdf = Math.sin(2 * Math.PI / l);
            for (var p = 0; p < N; p += l) {
              var rtwdf_ = rtwdf;
              var itwdf_ = itwdf;
              for (var j = 0; j < s; j++) {
                var re = rtws[p + j];
                var ie = itws[p + j];
                var ro = rtws[p + j + s];
                var io = itws[p + j + s];
                var rx = rtwdf_ * ro - itwdf_ * io;
                io = rtwdf_ * io + itwdf_ * ro;
                ro = rx;
                rtws[p + j] = re + ro;
                itws[p + j] = ie + io;
                rtws[p + j + s] = re - ro;
                itws[p + j + s] = ie - io;
                if (j !== l) {
                  rx = rtwdf * rtwdf_ - itwdf * itwdf_;
                  itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;
                  rtwdf_ = rx;
                }
              }
            }
          }
        };
        FFTM.prototype.guessLen13b = function guessLen13b(n, m) {
          var N = Math.max(m, n) | 1;
          var odd = N & 1;
          var i = 0;
          for (N = N / 2 | 0; N; N = N >>> 1) {
            i++;
          }
          return 1 << i + 1 + odd;
        };
        FFTM.prototype.conjugate = function conjugate(rws, iws, N) {
          if (N <= 1)
            return;
          for (var i = 0; i < N / 2; i++) {
            var t = rws[i];
            rws[i] = rws[N - i - 1];
            rws[N - i - 1] = t;
            t = iws[i];
            iws[i] = -iws[N - i - 1];
            iws[N - i - 1] = -t;
          }
        };
        FFTM.prototype.normalize13b = function normalize13b(ws, N) {
          var carry = 0;
          for (var i = 0; i < N / 2; i++) {
            var w = Math.round(ws[2 * i + 1] / N) * 8192 + Math.round(ws[2 * i] / N) + carry;
            ws[i] = w & 67108863;
            if (w < 67108864) {
              carry = 0;
            } else {
              carry = w / 67108864 | 0;
            }
          }
          return ws;
        };
        FFTM.prototype.convert13b = function convert13b(ws, len, rws, N) {
          var carry = 0;
          for (var i = 0; i < len; i++) {
            carry = carry + (ws[i] | 0);
            rws[2 * i] = carry & 8191;
            carry = carry >>> 13;
            rws[2 * i + 1] = carry & 8191;
            carry = carry >>> 13;
          }
          for (i = 2 * len; i < N; ++i) {
            rws[i] = 0;
          }
          assert(carry === 0);
          assert((carry & ~8191) === 0);
        };
        FFTM.prototype.stub = function stub(N) {
          var ph = new Array(N);
          for (var i = 0; i < N; i++) {
            ph[i] = 0;
          }
          return ph;
        };
        FFTM.prototype.mulp = function mulp(x, y, out) {
          var N = 2 * this.guessLen13b(x.length, y.length);
          var rbt = this.makeRBT(N);
          var _ = this.stub(N);
          var rws = new Array(N);
          var rwst = new Array(N);
          var iwst = new Array(N);
          var nrws = new Array(N);
          var nrwst = new Array(N);
          var niwst = new Array(N);
          var rmws = out.words;
          rmws.length = N;
          this.convert13b(x.words, x.length, rws, N);
          this.convert13b(y.words, y.length, nrws, N);
          this.transform(rws, _, rwst, iwst, N, rbt);
          this.transform(nrws, _, nrwst, niwst, N, rbt);
          for (var i = 0; i < N; i++) {
            var rx = rwst[i] * nrwst[i] - iwst[i] * niwst[i];
            iwst[i] = rwst[i] * niwst[i] + iwst[i] * nrwst[i];
            rwst[i] = rx;
          }
          this.conjugate(rwst, iwst, N);
          this.transform(rwst, iwst, rmws, _, N, rbt);
          this.conjugate(rmws, _, N);
          this.normalize13b(rmws, N);
          out.negative = x.negative ^ y.negative;
          out.length = x.length + y.length;
          return out._strip();
        };
        BN.prototype.mul = function mul(num) {
          var out = new BN(null);
          out.words = new Array(this.length + num.length);
          return this.mulTo(num, out);
        };
        BN.prototype.mulf = function mulf(num) {
          var out = new BN(null);
          out.words = new Array(this.length + num.length);
          return jumboMulTo(this, num, out);
        };
        BN.prototype.imul = function imul(num) {
          return this.clone().mulTo(num, this);
        };
        BN.prototype.imuln = function imuln(num) {
          var isNegNum = num < 0;
          if (isNegNum)
            num = -num;
          assert(typeof num === "number");
          assert(num < 67108864);
          var carry = 0;
          for (var i = 0; i < this.length; i++) {
            var w = (this.words[i] | 0) * num;
            var lo = (w & 67108863) + (carry & 67108863);
            carry >>= 26;
            carry += w / 67108864 | 0;
            carry += lo >>> 26;
            this.words[i] = lo & 67108863;
          }
          if (carry !== 0) {
            this.words[i] = carry;
            this.length++;
          }
          return isNegNum ? this.ineg() : this;
        };
        BN.prototype.muln = function muln(num) {
          return this.clone().imuln(num);
        };
        BN.prototype.sqr = function sqr() {
          return this.mul(this);
        };
        BN.prototype.isqr = function isqr() {
          return this.imul(this.clone());
        };
        BN.prototype.pow = function pow(num) {
          var w = toBitArray(num);
          if (w.length === 0)
            return new BN(1);
          var res = this;
          for (var i = 0; i < w.length; i++, res = res.sqr()) {
            if (w[i] !== 0)
              break;
          }
          if (++i < w.length) {
            for (var q = res.sqr(); i < w.length; i++, q = q.sqr()) {
              if (w[i] === 0)
                continue;
              res = res.mul(q);
            }
          }
          return res;
        };
        BN.prototype.iushln = function iushln(bits) {
          assert(typeof bits === "number" && bits >= 0);
          var r = bits % 26;
          var s = (bits - r) / 26;
          var carryMask = 67108863 >>> 26 - r << 26 - r;
          var i;
          if (r !== 0) {
            var carry = 0;
            for (i = 0; i < this.length; i++) {
              var newCarry = this.words[i] & carryMask;
              var c = (this.words[i] | 0) - newCarry << r;
              this.words[i] = c | carry;
              carry = newCarry >>> 26 - r;
            }
            if (carry) {
              this.words[i] = carry;
              this.length++;
            }
          }
          if (s !== 0) {
            for (i = this.length - 1; i >= 0; i--) {
              this.words[i + s] = this.words[i];
            }
            for (i = 0; i < s; i++) {
              this.words[i] = 0;
            }
            this.length += s;
          }
          return this._strip();
        };
        BN.prototype.ishln = function ishln(bits) {
          assert(this.negative === 0);
          return this.iushln(bits);
        };
        BN.prototype.iushrn = function iushrn(bits, hint, extended) {
          assert(typeof bits === "number" && bits >= 0);
          var h;
          if (hint) {
            h = (hint - hint % 26) / 26;
          } else {
            h = 0;
          }
          var r = bits % 26;
          var s = Math.min((bits - r) / 26, this.length);
          var mask = 67108863 ^ 67108863 >>> r << r;
          var maskedWords = extended;
          h -= s;
          h = Math.max(0, h);
          if (maskedWords) {
            for (var i = 0; i < s; i++) {
              maskedWords.words[i] = this.words[i];
            }
            maskedWords.length = s;
          }
          if (s === 0) {
          } else if (this.length > s) {
            this.length -= s;
            for (i = 0; i < this.length; i++) {
              this.words[i] = this.words[i + s];
            }
          } else {
            this.words[0] = 0;
            this.length = 1;
          }
          var carry = 0;
          for (i = this.length - 1; i >= 0 && (carry !== 0 || i >= h); i--) {
            var word = this.words[i] | 0;
            this.words[i] = carry << 26 - r | word >>> r;
            carry = word & mask;
          }
          if (maskedWords && carry !== 0) {
            maskedWords.words[maskedWords.length++] = carry;
          }
          if (this.length === 0) {
            this.words[0] = 0;
            this.length = 1;
          }
          return this._strip();
        };
        BN.prototype.ishrn = function ishrn(bits, hint, extended) {
          assert(this.negative === 0);
          return this.iushrn(bits, hint, extended);
        };
        BN.prototype.shln = function shln(bits) {
          return this.clone().ishln(bits);
        };
        BN.prototype.ushln = function ushln(bits) {
          return this.clone().iushln(bits);
        };
        BN.prototype.shrn = function shrn(bits) {
          return this.clone().ishrn(bits);
        };
        BN.prototype.ushrn = function ushrn(bits) {
          return this.clone().iushrn(bits);
        };
        BN.prototype.testn = function testn(bit) {
          assert(typeof bit === "number" && bit >= 0);
          var r = bit % 26;
          var s = (bit - r) / 26;
          var q = 1 << r;
          if (this.length <= s)
            return false;
          var w = this.words[s];
          return !!(w & q);
        };
        BN.prototype.imaskn = function imaskn(bits) {
          assert(typeof bits === "number" && bits >= 0);
          var r = bits % 26;
          var s = (bits - r) / 26;
          assert(this.negative === 0, "imaskn works only with positive numbers");
          if (this.length <= s) {
            return this;
          }
          if (r !== 0) {
            s++;
          }
          this.length = Math.min(s, this.length);
          if (r !== 0) {
            var mask = 67108863 ^ 67108863 >>> r << r;
            this.words[this.length - 1] &= mask;
          }
          return this._strip();
        };
        BN.prototype.maskn = function maskn(bits) {
          return this.clone().imaskn(bits);
        };
        BN.prototype.iaddn = function iaddn(num) {
          assert(typeof num === "number");
          assert(num < 67108864);
          if (num < 0)
            return this.isubn(-num);
          if (this.negative !== 0) {
            if (this.length === 1 && (this.words[0] | 0) <= num) {
              this.words[0] = num - (this.words[0] | 0);
              this.negative = 0;
              return this;
            }
            this.negative = 0;
            this.isubn(num);
            this.negative = 1;
            return this;
          }
          return this._iaddn(num);
        };
        BN.prototype._iaddn = function _iaddn(num) {
          this.words[0] += num;
          for (var i = 0; i < this.length && this.words[i] >= 67108864; i++) {
            this.words[i] -= 67108864;
            if (i === this.length - 1) {
              this.words[i + 1] = 1;
            } else {
              this.words[i + 1]++;
            }
          }
          this.length = Math.max(this.length, i + 1);
          return this;
        };
        BN.prototype.isubn = function isubn(num) {
          assert(typeof num === "number");
          assert(num < 67108864);
          if (num < 0)
            return this.iaddn(-num);
          if (this.negative !== 0) {
            this.negative = 0;
            this.iaddn(num);
            this.negative = 1;
            return this;
          }
          this.words[0] -= num;
          if (this.length === 1 && this.words[0] < 0) {
            this.words[0] = -this.words[0];
            this.negative = 1;
          } else {
            for (var i = 0; i < this.length && this.words[i] < 0; i++) {
              this.words[i] += 67108864;
              this.words[i + 1] -= 1;
            }
          }
          return this._strip();
        };
        BN.prototype.addn = function addn(num) {
          return this.clone().iaddn(num);
        };
        BN.prototype.subn = function subn(num) {
          return this.clone().isubn(num);
        };
        BN.prototype.iabs = function iabs() {
          this.negative = 0;
          return this;
        };
        BN.prototype.abs = function abs() {
          return this.clone().iabs();
        };
        BN.prototype._ishlnsubmul = function _ishlnsubmul(num, mul, shift) {
          var len = num.length + shift;
          var i;
          this._expand(len);
          var w;
          var carry = 0;
          for (i = 0; i < num.length; i++) {
            w = (this.words[i + shift] | 0) + carry;
            var right = (num.words[i] | 0) * mul;
            w -= right & 67108863;
            carry = (w >> 26) - (right / 67108864 | 0);
            this.words[i + shift] = w & 67108863;
          }
          for (; i < this.length - shift; i++) {
            w = (this.words[i + shift] | 0) + carry;
            carry = w >> 26;
            this.words[i + shift] = w & 67108863;
          }
          if (carry === 0)
            return this._strip();
          assert(carry === -1);
          carry = 0;
          for (i = 0; i < this.length; i++) {
            w = -(this.words[i] | 0) + carry;
            carry = w >> 26;
            this.words[i] = w & 67108863;
          }
          this.negative = 1;
          return this._strip();
        };
        BN.prototype._wordDiv = function _wordDiv(num, mode) {
          var shift = this.length - num.length;
          var a = this.clone();
          var b = num;
          var bhi = b.words[b.length - 1] | 0;
          var bhiBits = this._countBits(bhi);
          shift = 26 - bhiBits;
          if (shift !== 0) {
            b = b.ushln(shift);
            a.iushln(shift);
            bhi = b.words[b.length - 1] | 0;
          }
          var m = a.length - b.length;
          var q;
          if (mode !== "mod") {
            q = new BN(null);
            q.length = m + 1;
            q.words = new Array(q.length);
            for (var i = 0; i < q.length; i++) {
              q.words[i] = 0;
            }
          }
          var diff = a.clone()._ishlnsubmul(b, 1, m);
          if (diff.negative === 0) {
            a = diff;
            if (q) {
              q.words[m] = 1;
            }
          }
          for (var j = m - 1; j >= 0; j--) {
            var qj = (a.words[b.length + j] | 0) * 67108864 + (a.words[b.length + j - 1] | 0);
            qj = Math.min(qj / bhi | 0, 67108863);
            a._ishlnsubmul(b, qj, j);
            while (a.negative !== 0) {
              qj--;
              a.negative = 0;
              a._ishlnsubmul(b, 1, j);
              if (!a.isZero()) {
                a.negative ^= 1;
              }
            }
            if (q) {
              q.words[j] = qj;
            }
          }
          if (q) {
            q._strip();
          }
          a._strip();
          if (mode !== "div" && shift !== 0) {
            a.iushrn(shift);
          }
          return {
            div: q || null,
            mod: a
          };
        };
        BN.prototype.divmod = function divmod(num, mode, positive) {
          assert(!num.isZero());
          if (this.isZero()) {
            return {
              div: new BN(0),
              mod: new BN(0)
            };
          }
          var div, mod2, res;
          if (this.negative !== 0 && num.negative === 0) {
            res = this.neg().divmod(num, mode);
            if (mode !== "mod") {
              div = res.div.neg();
            }
            if (mode !== "div") {
              mod2 = res.mod.neg();
              if (positive && mod2.negative !== 0) {
                mod2.iadd(num);
              }
            }
            return {
              div,
              mod: mod2
            };
          }
          if (this.negative === 0 && num.negative !== 0) {
            res = this.divmod(num.neg(), mode);
            if (mode !== "mod") {
              div = res.div.neg();
            }
            return {
              div,
              mod: res.mod
            };
          }
          if ((this.negative & num.negative) !== 0) {
            res = this.neg().divmod(num.neg(), mode);
            if (mode !== "div") {
              mod2 = res.mod.neg();
              if (positive && mod2.negative !== 0) {
                mod2.isub(num);
              }
            }
            return {
              div: res.div,
              mod: mod2
            };
          }
          if (num.length > this.length || this.cmp(num) < 0) {
            return {
              div: new BN(0),
              mod: this
            };
          }
          if (num.length === 1) {
            if (mode === "div") {
              return {
                div: this.divn(num.words[0]),
                mod: null
              };
            }
            if (mode === "mod") {
              return {
                div: null,
                mod: new BN(this.modrn(num.words[0]))
              };
            }
            return {
              div: this.divn(num.words[0]),
              mod: new BN(this.modrn(num.words[0]))
            };
          }
          return this._wordDiv(num, mode);
        };
        BN.prototype.div = function div(num) {
          return this.divmod(num, "div", false).div;
        };
        BN.prototype.mod = function mod2(num) {
          return this.divmod(num, "mod", false).mod;
        };
        BN.prototype.umod = function umod(num) {
          return this.divmod(num, "mod", true).mod;
        };
        BN.prototype.divRound = function divRound(num) {
          var dm = this.divmod(num);
          if (dm.mod.isZero())
            return dm.div;
          var mod2 = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;
          var half = num.ushrn(1);
          var r2 = num.andln(1);
          var cmp = mod2.cmp(half);
          if (cmp < 0 || r2 === 1 && cmp === 0)
            return dm.div;
          return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
        };
        BN.prototype.modrn = function modrn(num) {
          var isNegNum = num < 0;
          if (isNegNum)
            num = -num;
          assert(num <= 67108863);
          var p = (1 << 26) % num;
          var acc = 0;
          for (var i = this.length - 1; i >= 0; i--) {
            acc = (p * acc + (this.words[i] | 0)) % num;
          }
          return isNegNum ? -acc : acc;
        };
        BN.prototype.modn = function modn(num) {
          return this.modrn(num);
        };
        BN.prototype.idivn = function idivn(num) {
          var isNegNum = num < 0;
          if (isNegNum)
            num = -num;
          assert(num <= 67108863);
          var carry = 0;
          for (var i = this.length - 1; i >= 0; i--) {
            var w = (this.words[i] | 0) + carry * 67108864;
            this.words[i] = w / num | 0;
            carry = w % num;
          }
          this._strip();
          return isNegNum ? this.ineg() : this;
        };
        BN.prototype.divn = function divn(num) {
          return this.clone().idivn(num);
        };
        BN.prototype.egcd = function egcd(p) {
          assert(p.negative === 0);
          assert(!p.isZero());
          var x = this;
          var y = p.clone();
          if (x.negative !== 0) {
            x = x.umod(p);
          } else {
            x = x.clone();
          }
          var A = new BN(1);
          var B = new BN(0);
          var C = new BN(0);
          var D = new BN(1);
          var g = 0;
          while (x.isEven() && y.isEven()) {
            x.iushrn(1);
            y.iushrn(1);
            ++g;
          }
          var yp = y.clone();
          var xp = x.clone();
          while (!x.isZero()) {
            for (var i = 0, im = 1; (x.words[0] & im) === 0 && i < 26; ++i, im <<= 1)
              ;
            if (i > 0) {
              x.iushrn(i);
              while (i-- > 0) {
                if (A.isOdd() || B.isOdd()) {
                  A.iadd(yp);
                  B.isub(xp);
                }
                A.iushrn(1);
                B.iushrn(1);
              }
            }
            for (var j = 0, jm = 1; (y.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1)
              ;
            if (j > 0) {
              y.iushrn(j);
              while (j-- > 0) {
                if (C.isOdd() || D.isOdd()) {
                  C.iadd(yp);
                  D.isub(xp);
                }
                C.iushrn(1);
                D.iushrn(1);
              }
            }
            if (x.cmp(y) >= 0) {
              x.isub(y);
              A.isub(C);
              B.isub(D);
            } else {
              y.isub(x);
              C.isub(A);
              D.isub(B);
            }
          }
          return {
            a: C,
            b: D,
            gcd: y.iushln(g)
          };
        };
        BN.prototype._invmp = function _invmp(p) {
          assert(p.negative === 0);
          assert(!p.isZero());
          var a = this;
          var b = p.clone();
          if (a.negative !== 0) {
            a = a.umod(p);
          } else {
            a = a.clone();
          }
          var x1 = new BN(1);
          var x2 = new BN(0);
          var delta = b.clone();
          while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {
            for (var i = 0, im = 1; (a.words[0] & im) === 0 && i < 26; ++i, im <<= 1)
              ;
            if (i > 0) {
              a.iushrn(i);
              while (i-- > 0) {
                if (x1.isOdd()) {
                  x1.iadd(delta);
                }
                x1.iushrn(1);
              }
            }
            for (var j = 0, jm = 1; (b.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1)
              ;
            if (j > 0) {
              b.iushrn(j);
              while (j-- > 0) {
                if (x2.isOdd()) {
                  x2.iadd(delta);
                }
                x2.iushrn(1);
              }
            }
            if (a.cmp(b) >= 0) {
              a.isub(b);
              x1.isub(x2);
            } else {
              b.isub(a);
              x2.isub(x1);
            }
          }
          var res;
          if (a.cmpn(1) === 0) {
            res = x1;
          } else {
            res = x2;
          }
          if (res.cmpn(0) < 0) {
            res.iadd(p);
          }
          return res;
        };
        BN.prototype.gcd = function gcd(num) {
          if (this.isZero())
            return num.abs();
          if (num.isZero())
            return this.abs();
          var a = this.clone();
          var b = num.clone();
          a.negative = 0;
          b.negative = 0;
          for (var shift = 0; a.isEven() && b.isEven(); shift++) {
            a.iushrn(1);
            b.iushrn(1);
          }
          do {
            while (a.isEven()) {
              a.iushrn(1);
            }
            while (b.isEven()) {
              b.iushrn(1);
            }
            var r = a.cmp(b);
            if (r < 0) {
              var t = a;
              a = b;
              b = t;
            } else if (r === 0 || b.cmpn(1) === 0) {
              break;
            }
            a.isub(b);
          } while (true);
          return b.iushln(shift);
        };
        BN.prototype.invm = function invm(num) {
          return this.egcd(num).a.umod(num);
        };
        BN.prototype.isEven = function isEven() {
          return (this.words[0] & 1) === 0;
        };
        BN.prototype.isOdd = function isOdd() {
          return (this.words[0] & 1) === 1;
        };
        BN.prototype.andln = function andln(num) {
          return this.words[0] & num;
        };
        BN.prototype.bincn = function bincn(bit) {
          assert(typeof bit === "number");
          var r = bit % 26;
          var s = (bit - r) / 26;
          var q = 1 << r;
          if (this.length <= s) {
            this._expand(s + 1);
            this.words[s] |= q;
            return this;
          }
          var carry = q;
          for (var i = s; carry !== 0 && i < this.length; i++) {
            var w = this.words[i] | 0;
            w += carry;
            carry = w >>> 26;
            w &= 67108863;
            this.words[i] = w;
          }
          if (carry !== 0) {
            this.words[i] = carry;
            this.length++;
          }
          return this;
        };
        BN.prototype.isZero = function isZero() {
          return this.length === 1 && this.words[0] === 0;
        };
        BN.prototype.cmpn = function cmpn(num) {
          var negative = num < 0;
          if (this.negative !== 0 && !negative)
            return -1;
          if (this.negative === 0 && negative)
            return 1;
          this._strip();
          var res;
          if (this.length > 1) {
            res = 1;
          } else {
            if (negative) {
              num = -num;
            }
            assert(num <= 67108863, "Number is too big");
            var w = this.words[0] | 0;
            res = w === num ? 0 : w < num ? -1 : 1;
          }
          if (this.negative !== 0)
            return -res | 0;
          return res;
        };
        BN.prototype.cmp = function cmp(num) {
          if (this.negative !== 0 && num.negative === 0)
            return -1;
          if (this.negative === 0 && num.negative !== 0)
            return 1;
          var res = this.ucmp(num);
          if (this.negative !== 0)
            return -res | 0;
          return res;
        };
        BN.prototype.ucmp = function ucmp(num) {
          if (this.length > num.length)
            return 1;
          if (this.length < num.length)
            return -1;
          var res = 0;
          for (var i = this.length - 1; i >= 0; i--) {
            var a = this.words[i] | 0;
            var b = num.words[i] | 0;
            if (a === b)
              continue;
            if (a < b) {
              res = -1;
            } else if (a > b) {
              res = 1;
            }
            break;
          }
          return res;
        };
        BN.prototype.gtn = function gtn(num) {
          return this.cmpn(num) === 1;
        };
        BN.prototype.gt = function gt(num) {
          return this.cmp(num) === 1;
        };
        BN.prototype.gten = function gten(num) {
          return this.cmpn(num) >= 0;
        };
        BN.prototype.gte = function gte(num) {
          return this.cmp(num) >= 0;
        };
        BN.prototype.ltn = function ltn(num) {
          return this.cmpn(num) === -1;
        };
        BN.prototype.lt = function lt(num) {
          return this.cmp(num) === -1;
        };
        BN.prototype.lten = function lten(num) {
          return this.cmpn(num) <= 0;
        };
        BN.prototype.lte = function lte(num) {
          return this.cmp(num) <= 0;
        };
        BN.prototype.eqn = function eqn(num) {
          return this.cmpn(num) === 0;
        };
        BN.prototype.eq = function eq(num) {
          return this.cmp(num) === 0;
        };
        BN.red = function red(num) {
          return new Red(num);
        };
        BN.prototype.toRed = function toRed(ctx) {
          assert(!this.red, "Already a number in reduction context");
          assert(this.negative === 0, "red works only with positives");
          return ctx.convertTo(this)._forceRed(ctx);
        };
        BN.prototype.fromRed = function fromRed() {
          assert(this.red, "fromRed works only with numbers in reduction context");
          return this.red.convertFrom(this);
        };
        BN.prototype._forceRed = function _forceRed(ctx) {
          this.red = ctx;
          return this;
        };
        BN.prototype.forceRed = function forceRed(ctx) {
          assert(!this.red, "Already a number in reduction context");
          return this._forceRed(ctx);
        };
        BN.prototype.redAdd = function redAdd(num) {
          assert(this.red, "redAdd works only with red numbers");
          return this.red.add(this, num);
        };
        BN.prototype.redIAdd = function redIAdd(num) {
          assert(this.red, "redIAdd works only with red numbers");
          return this.red.iadd(this, num);
        };
        BN.prototype.redSub = function redSub(num) {
          assert(this.red, "redSub works only with red numbers");
          return this.red.sub(this, num);
        };
        BN.prototype.redISub = function redISub(num) {
          assert(this.red, "redISub works only with red numbers");
          return this.red.isub(this, num);
        };
        BN.prototype.redShl = function redShl(num) {
          assert(this.red, "redShl works only with red numbers");
          return this.red.shl(this, num);
        };
        BN.prototype.redMul = function redMul(num) {
          assert(this.red, "redMul works only with red numbers");
          this.red._verify2(this, num);
          return this.red.mul(this, num);
        };
        BN.prototype.redIMul = function redIMul(num) {
          assert(this.red, "redMul works only with red numbers");
          this.red._verify2(this, num);
          return this.red.imul(this, num);
        };
        BN.prototype.redSqr = function redSqr() {
          assert(this.red, "redSqr works only with red numbers");
          this.red._verify1(this);
          return this.red.sqr(this);
        };
        BN.prototype.redISqr = function redISqr() {
          assert(this.red, "redISqr works only with red numbers");
          this.red._verify1(this);
          return this.red.isqr(this);
        };
        BN.prototype.redSqrt = function redSqrt() {
          assert(this.red, "redSqrt works only with red numbers");
          this.red._verify1(this);
          return this.red.sqrt(this);
        };
        BN.prototype.redInvm = function redInvm() {
          assert(this.red, "redInvm works only with red numbers");
          this.red._verify1(this);
          return this.red.invm(this);
        };
        BN.prototype.redNeg = function redNeg() {
          assert(this.red, "redNeg works only with red numbers");
          this.red._verify1(this);
          return this.red.neg(this);
        };
        BN.prototype.redPow = function redPow(num) {
          assert(this.red && !num.red, "redPow(normalNum)");
          this.red._verify1(this);
          return this.red.pow(this, num);
        };
        var primes = {
          k256: null,
          p224: null,
          p192: null,
          p25519: null
        };
        function MPrime(name, p) {
          this.name = name;
          this.p = new BN(p, 16);
          this.n = this.p.bitLength();
          this.k = new BN(1).iushln(this.n).isub(this.p);
          this.tmp = this._tmp();
        }
        MPrime.prototype._tmp = function _tmp() {
          var tmp = new BN(null);
          tmp.words = new Array(Math.ceil(this.n / 13));
          return tmp;
        };
        MPrime.prototype.ireduce = function ireduce(num) {
          var r = num;
          var rlen;
          do {
            this.split(r, this.tmp);
            r = this.imulK(r);
            r = r.iadd(this.tmp);
            rlen = r.bitLength();
          } while (rlen > this.n);
          var cmp = rlen < this.n ? -1 : r.ucmp(this.p);
          if (cmp === 0) {
            r.words[0] = 0;
            r.length = 1;
          } else if (cmp > 0) {
            r.isub(this.p);
          } else {
            if (r.strip !== void 0) {
              r.strip();
            } else {
              r._strip();
            }
          }
          return r;
        };
        MPrime.prototype.split = function split(input, out) {
          input.iushrn(this.n, 0, out);
        };
        MPrime.prototype.imulK = function imulK(num) {
          return num.imul(this.k);
        };
        function K256() {
          MPrime.call(this, "k256", "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f");
        }
        inherits(K256, MPrime);
        K256.prototype.split = function split(input, output) {
          var mask = 4194303;
          var outLen = Math.min(input.length, 9);
          for (var i = 0; i < outLen; i++) {
            output.words[i] = input.words[i];
          }
          output.length = outLen;
          if (input.length <= 9) {
            input.words[0] = 0;
            input.length = 1;
            return;
          }
          var prev = input.words[9];
          output.words[output.length++] = prev & mask;
          for (i = 10; i < input.length; i++) {
            var next = input.words[i] | 0;
            input.words[i - 10] = (next & mask) << 4 | prev >>> 22;
            prev = next;
          }
          prev >>>= 22;
          input.words[i - 10] = prev;
          if (prev === 0 && input.length > 10) {
            input.length -= 10;
          } else {
            input.length -= 9;
          }
        };
        K256.prototype.imulK = function imulK(num) {
          num.words[num.length] = 0;
          num.words[num.length + 1] = 0;
          num.length += 2;
          var lo = 0;
          for (var i = 0; i < num.length; i++) {
            var w = num.words[i] | 0;
            lo += w * 977;
            num.words[i] = lo & 67108863;
            lo = w * 64 + (lo / 67108864 | 0);
          }
          if (num.words[num.length - 1] === 0) {
            num.length--;
            if (num.words[num.length - 1] === 0) {
              num.length--;
            }
          }
          return num;
        };
        function P224() {
          MPrime.call(this, "p224", "ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001");
        }
        inherits(P224, MPrime);
        function P192() {
          MPrime.call(this, "p192", "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff");
        }
        inherits(P192, MPrime);
        function P25519() {
          MPrime.call(this, "25519", "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed");
        }
        inherits(P25519, MPrime);
        P25519.prototype.imulK = function imulK(num) {
          var carry = 0;
          for (var i = 0; i < num.length; i++) {
            var hi = (num.words[i] | 0) * 19 + carry;
            var lo = hi & 67108863;
            hi >>>= 26;
            num.words[i] = lo;
            carry = hi;
          }
          if (carry !== 0) {
            num.words[num.length++] = carry;
          }
          return num;
        };
        BN._prime = function prime(name) {
          if (primes[name])
            return primes[name];
          var prime2;
          if (name === "k256") {
            prime2 = new K256();
          } else if (name === "p224") {
            prime2 = new P224();
          } else if (name === "p192") {
            prime2 = new P192();
          } else if (name === "p25519") {
            prime2 = new P25519();
          } else {
            throw new Error("Unknown prime " + name);
          }
          primes[name] = prime2;
          return prime2;
        };
        function Red(m) {
          if (typeof m === "string") {
            var prime = BN._prime(m);
            this.m = prime.p;
            this.prime = prime;
          } else {
            assert(m.gtn(1), "modulus must be greater than 1");
            this.m = m;
            this.prime = null;
          }
        }
        Red.prototype._verify1 = function _verify1(a) {
          assert(a.negative === 0, "red works only with positives");
          assert(a.red, "red works only with red numbers");
        };
        Red.prototype._verify2 = function _verify2(a, b) {
          assert((a.negative | b.negative) === 0, "red works only with positives");
          assert(a.red && a.red === b.red, "red works only with red numbers");
        };
        Red.prototype.imod = function imod(a) {
          if (this.prime)
            return this.prime.ireduce(a)._forceRed(this);
          move(a, a.umod(this.m)._forceRed(this));
          return a;
        };
        Red.prototype.neg = function neg(a) {
          if (a.isZero()) {
            return a.clone();
          }
          return this.m.sub(a)._forceRed(this);
        };
        Red.prototype.add = function add(a, b) {
          this._verify2(a, b);
          var res = a.add(b);
          if (res.cmp(this.m) >= 0) {
            res.isub(this.m);
          }
          return res._forceRed(this);
        };
        Red.prototype.iadd = function iadd(a, b) {
          this._verify2(a, b);
          var res = a.iadd(b);
          if (res.cmp(this.m) >= 0) {
            res.isub(this.m);
          }
          return res;
        };
        Red.prototype.sub = function sub(a, b) {
          this._verify2(a, b);
          var res = a.sub(b);
          if (res.cmpn(0) < 0) {
            res.iadd(this.m);
          }
          return res._forceRed(this);
        };
        Red.prototype.isub = function isub(a, b) {
          this._verify2(a, b);
          var res = a.isub(b);
          if (res.cmpn(0) < 0) {
            res.iadd(this.m);
          }
          return res;
        };
        Red.prototype.shl = function shl(a, num) {
          this._verify1(a);
          return this.imod(a.ushln(num));
        };
        Red.prototype.imul = function imul(a, b) {
          this._verify2(a, b);
          return this.imod(a.imul(b));
        };
        Red.prototype.mul = function mul(a, b) {
          this._verify2(a, b);
          return this.imod(a.mul(b));
        };
        Red.prototype.isqr = function isqr(a) {
          return this.imul(a, a.clone());
        };
        Red.prototype.sqr = function sqr(a) {
          return this.mul(a, a);
        };
        Red.prototype.sqrt = function sqrt(a) {
          if (a.isZero())
            return a.clone();
          var mod3 = this.m.andln(3);
          assert(mod3 % 2 === 1);
          if (mod3 === 3) {
            var pow = this.m.add(new BN(1)).iushrn(2);
            return this.pow(a, pow);
          }
          var q = this.m.subn(1);
          var s = 0;
          while (!q.isZero() && q.andln(1) === 0) {
            s++;
            q.iushrn(1);
          }
          assert(!q.isZero());
          var one = new BN(1).toRed(this);
          var nOne = one.redNeg();
          var lpow = this.m.subn(1).iushrn(1);
          var z = this.m.bitLength();
          z = new BN(2 * z * z).toRed(this);
          while (this.pow(z, lpow).cmp(nOne) !== 0) {
            z.redIAdd(nOne);
          }
          var c = this.pow(z, q);
          var r = this.pow(a, q.addn(1).iushrn(1));
          var t = this.pow(a, q);
          var m = s;
          while (t.cmp(one) !== 0) {
            var tmp = t;
            for (var i = 0; tmp.cmp(one) !== 0; i++) {
              tmp = tmp.redSqr();
            }
            assert(i < m);
            var b = this.pow(c, new BN(1).iushln(m - i - 1));
            r = r.redMul(b);
            c = b.redSqr();
            t = t.redMul(c);
            m = i;
          }
          return r;
        };
        Red.prototype.invm = function invm(a) {
          var inv = a._invmp(this.m);
          if (inv.negative !== 0) {
            inv.negative = 0;
            return this.imod(inv).redNeg();
          } else {
            return this.imod(inv);
          }
        };
        Red.prototype.pow = function pow(a, num) {
          if (num.isZero())
            return new BN(1).toRed(this);
          if (num.cmpn(1) === 0)
            return a.clone();
          var windowSize = 4;
          var wnd = new Array(1 << windowSize);
          wnd[0] = new BN(1).toRed(this);
          wnd[1] = a;
          for (var i = 2; i < wnd.length; i++) {
            wnd[i] = this.mul(wnd[i - 1], a);
          }
          var res = wnd[0];
          var current = 0;
          var currentLen = 0;
          var start2 = num.bitLength() % 26;
          if (start2 === 0) {
            start2 = 26;
          }
          for (i = num.length - 1; i >= 0; i--) {
            var word = num.words[i];
            for (var j = start2 - 1; j >= 0; j--) {
              var bit = word >> j & 1;
              if (res !== wnd[0]) {
                res = this.sqr(res);
              }
              if (bit === 0 && current === 0) {
                currentLen = 0;
                continue;
              }
              current <<= 1;
              current |= bit;
              currentLen++;
              if (currentLen !== windowSize && (i !== 0 || j !== 0))
                continue;
              res = this.mul(res, wnd[current]);
              currentLen = 0;
              current = 0;
            }
            start2 = 26;
          }
          return res;
        };
        Red.prototype.convertTo = function convertTo(num) {
          var r = num.umod(this.m);
          return r === num ? r.clone() : r;
        };
        Red.prototype.convertFrom = function convertFrom(num) {
          var res = num.clone();
          res.red = null;
          return res;
        };
        BN.mont = function mont(num) {
          return new Mont(num);
        };
        function Mont(m) {
          Red.call(this, m);
          this.shift = this.m.bitLength();
          if (this.shift % 26 !== 0) {
            this.shift += 26 - this.shift % 26;
          }
          this.r = new BN(1).iushln(this.shift);
          this.r2 = this.imod(this.r.sqr());
          this.rinv = this.r._invmp(this.m);
          this.minv = this.rinv.mul(this.r).isubn(1).div(this.m);
          this.minv = this.minv.umod(this.r);
          this.minv = this.r.sub(this.minv);
        }
        inherits(Mont, Red);
        Mont.prototype.convertTo = function convertTo(num) {
          return this.imod(num.ushln(this.shift));
        };
        Mont.prototype.convertFrom = function convertFrom(num) {
          var r = this.imod(num.mul(this.rinv));
          r.red = null;
          return r;
        };
        Mont.prototype.imul = function imul(a, b) {
          if (a.isZero() || b.isZero()) {
            a.words[0] = 0;
            a.length = 1;
            return a;
          }
          var t = a.imul(b);
          var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
          var u = t.isub(c).iushrn(this.shift);
          var res = u;
          if (u.cmp(this.m) >= 0) {
            res = u.isub(this.m);
          } else if (u.cmpn(0) < 0) {
            res = u.iadd(this.m);
          }
          return res._forceRed(this);
        };
        Mont.prototype.mul = function mul(a, b) {
          if (a.isZero() || b.isZero())
            return new BN(0)._forceRed(this);
          var t = a.mul(b);
          var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
          var u = t.isub(c).iushrn(this.shift);
          var res = u;
          if (u.cmp(this.m) >= 0) {
            res = u.isub(this.m);
          } else if (u.cmpn(0) < 0) {
            res = u.iadd(this.m);
          }
          return res._forceRed(this);
        };
        Mont.prototype.invm = function invm(a) {
          var res = this.imod(a._invmp(this.m).mul(this.r2));
          return res._forceRed(this);
        };
      })(typeof module2 === "undefined" || module2, exports2);
    }
  });

  // node_modules/@cosmjs/math/build/decimal.js
  var require_decimal = __commonJS({
    "node_modules/@cosmjs/math/build/decimal.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.Decimal = void 0;
      var bn_js_1 = __importDefault(require_bn());
      var maxFractionalDigits = 100;
      var Decimal = class {
        constructor(atomics, fractionalDigits) {
          this.data = {
            atomics: new bn_js_1.default(atomics),
            fractionalDigits
          };
        }
        static fromUserInput(input, fractionalDigits) {
          Decimal.verifyFractionalDigits(fractionalDigits);
          const badCharacter = input.match(/[^0-9.]/);
          if (badCharacter) {
            throw new Error(`Invalid character at position ${badCharacter.index + 1}`);
          }
          let whole;
          let fractional;
          if (input.search(/\./) === -1) {
            whole = input;
            fractional = "";
          } else {
            const parts = input.split(".");
            switch (parts.length) {
              case 0:
              case 1:
                throw new Error("Fewer than two elements in split result. This must not happen here.");
              case 2:
                if (!parts[1])
                  throw new Error("Fractional part missing");
                whole = parts[0];
                fractional = parts[1].replace(/0+$/, "");
                break;
              default:
                throw new Error("More than one separator found");
            }
          }
          if (fractional.length > fractionalDigits) {
            throw new Error("Got more fractional digits than supported");
          }
          const quantity = `${whole}${fractional.padEnd(fractionalDigits, "0")}`;
          return new Decimal(quantity, fractionalDigits);
        }
        static fromAtomics(atomics, fractionalDigits) {
          Decimal.verifyFractionalDigits(fractionalDigits);
          return new Decimal(atomics, fractionalDigits);
        }
        static zero(fractionalDigits) {
          Decimal.verifyFractionalDigits(fractionalDigits);
          return new Decimal("0", fractionalDigits);
        }
        static one(fractionalDigits) {
          Decimal.verifyFractionalDigits(fractionalDigits);
          return new Decimal("1" + "0".repeat(fractionalDigits), fractionalDigits);
        }
        static verifyFractionalDigits(fractionalDigits) {
          if (!Number.isInteger(fractionalDigits))
            throw new Error("Fractional digits is not an integer");
          if (fractionalDigits < 0)
            throw new Error("Fractional digits must not be negative");
          if (fractionalDigits > maxFractionalDigits) {
            throw new Error(`Fractional digits must not exceed ${maxFractionalDigits}`);
          }
        }
        static compare(a, b) {
          if (a.fractionalDigits !== b.fractionalDigits)
            throw new Error("Fractional digits do not match");
          return a.data.atomics.cmp(new bn_js_1.default(b.atomics));
        }
        get atomics() {
          return this.data.atomics.toString();
        }
        get fractionalDigits() {
          return this.data.fractionalDigits;
        }
        toString() {
          const factor = new bn_js_1.default(10).pow(new bn_js_1.default(this.data.fractionalDigits));
          const whole = this.data.atomics.div(factor);
          const fractional = this.data.atomics.mod(factor);
          if (fractional.isZero()) {
            return whole.toString();
          } else {
            const fullFractionalPart = fractional.toString().padStart(this.data.fractionalDigits, "0");
            const trimmedFractionalPart = fullFractionalPart.replace(/0+$/, "");
            return `${whole.toString()}.${trimmedFractionalPart}`;
          }
        }
        toFloatApproximation() {
          const out = Number(this.toString());
          if (Number.isNaN(out))
            throw new Error("Conversion to number failed");
          return out;
        }
        plus(b) {
          if (this.fractionalDigits !== b.fractionalDigits)
            throw new Error("Fractional digits do not match");
          const sum = this.data.atomics.add(new bn_js_1.default(b.atomics));
          return new Decimal(sum.toString(), this.fractionalDigits);
        }
        minus(b) {
          if (this.fractionalDigits !== b.fractionalDigits)
            throw new Error("Fractional digits do not match");
          const difference = this.data.atomics.sub(new bn_js_1.default(b.atomics));
          if (difference.ltn(0))
            throw new Error("Difference must not be negative");
          return new Decimal(difference.toString(), this.fractionalDigits);
        }
        multiply(b) {
          const product = this.data.atomics.mul(new bn_js_1.default(b.toString()));
          return new Decimal(product.toString(), this.fractionalDigits);
        }
        equals(b) {
          return Decimal.compare(this, b) === 0;
        }
        isLessThan(b) {
          return Decimal.compare(this, b) < 0;
        }
        isLessThanOrEqual(b) {
          return Decimal.compare(this, b) <= 0;
        }
        isGreaterThan(b) {
          return Decimal.compare(this, b) > 0;
        }
        isGreaterThanOrEqual(b) {
          return Decimal.compare(this, b) >= 0;
        }
      };
      exports2.Decimal = Decimal;
    }
  });

  // node_modules/@cosmjs/math/build/integers.js
  var require_integers = __commonJS({
    "node_modules/@cosmjs/math/build/integers.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.Uint64 = exports2.Uint53 = exports2.Int53 = exports2.Uint32 = void 0;
      var bn_js_1 = __importDefault(require_bn());
      var uint64MaxValue = new bn_js_1.default("18446744073709551615", 10, "be");
      var Uint32 = class {
        constructor(input) {
          if (Number.isNaN(input)) {
            throw new Error("Input is not a number");
          }
          if (!Number.isInteger(input)) {
            throw new Error("Input is not an integer");
          }
          if (input < 0 || input > 4294967295) {
            throw new Error("Input not in uint32 range: " + input.toString());
          }
          this.data = input;
        }
        static fromBigEndianBytes(bytes) {
          return Uint32.fromBytes(bytes);
        }
        static fromBytes(bytes, endianess = "be") {
          if (bytes.length !== 4) {
            throw new Error("Invalid input length. Expected 4 bytes.");
          }
          for (let i = 0; i < bytes.length; ++i) {
            if (!Number.isInteger(bytes[i]) || bytes[i] > 255 || bytes[i] < 0) {
              throw new Error("Invalid value in byte. Found: " + bytes[i]);
            }
          }
          const beBytes = endianess === "be" ? bytes : Array.from(bytes).reverse();
          return new Uint32(beBytes[0] * 2 ** 24 + beBytes[1] * 2 ** 16 + beBytes[2] * 2 ** 8 + beBytes[3]);
        }
        static fromString(str) {
          if (!str.match(/^[0-9]+$/)) {
            throw new Error("Invalid string format");
          }
          return new Uint32(Number.parseInt(str, 10));
        }
        toBytesBigEndian() {
          return new Uint8Array([
            Math.floor(this.data / 2 ** 24) & 255,
            Math.floor(this.data / 2 ** 16) & 255,
            Math.floor(this.data / 2 ** 8) & 255,
            Math.floor(this.data / 2 ** 0) & 255
          ]);
        }
        toBytesLittleEndian() {
          return new Uint8Array([
            Math.floor(this.data / 2 ** 0) & 255,
            Math.floor(this.data / 2 ** 8) & 255,
            Math.floor(this.data / 2 ** 16) & 255,
            Math.floor(this.data / 2 ** 24) & 255
          ]);
        }
        toNumber() {
          return this.data;
        }
        toString() {
          return this.data.toString();
        }
      };
      exports2.Uint32 = Uint32;
      var Int53 = class {
        constructor(input) {
          if (Number.isNaN(input)) {
            throw new Error("Input is not a number");
          }
          if (!Number.isInteger(input)) {
            throw new Error("Input is not an integer");
          }
          if (input < Number.MIN_SAFE_INTEGER || input > Number.MAX_SAFE_INTEGER) {
            throw new Error("Input not in int53 range: " + input.toString());
          }
          this.data = input;
        }
        static fromString(str) {
          if (!str.match(/^-?[0-9]+$/)) {
            throw new Error("Invalid string format");
          }
          return new Int53(Number.parseInt(str, 10));
        }
        toNumber() {
          return this.data;
        }
        toString() {
          return this.data.toString();
        }
      };
      exports2.Int53 = Int53;
      var Uint53 = class {
        constructor(input) {
          const signed = new Int53(input);
          if (signed.toNumber() < 0) {
            throw new Error("Input is negative");
          }
          this.data = signed;
        }
        static fromString(str) {
          const signed = Int53.fromString(str);
          return new Uint53(signed.toNumber());
        }
        toNumber() {
          return this.data.toNumber();
        }
        toString() {
          return this.data.toString();
        }
      };
      exports2.Uint53 = Uint53;
      var Uint64 = class {
        constructor(data) {
          if (data.isNeg()) {
            throw new Error("Input is negative");
          }
          if (data.gt(uint64MaxValue)) {
            throw new Error("Input exceeds uint64 range");
          }
          this.data = data;
        }
        static fromBytesBigEndian(bytes) {
          return Uint64.fromBytes(bytes);
        }
        static fromBytes(bytes, endianess = "be") {
          if (bytes.length !== 8) {
            throw new Error("Invalid input length. Expected 8 bytes.");
          }
          for (let i = 0; i < bytes.length; ++i) {
            if (!Number.isInteger(bytes[i]) || bytes[i] > 255 || bytes[i] < 0) {
              throw new Error("Invalid value in byte. Found: " + bytes[i]);
            }
          }
          const beBytes = endianess === "be" ? Array.from(bytes) : Array.from(bytes).reverse();
          return new Uint64(new bn_js_1.default(beBytes));
        }
        static fromString(str) {
          if (!str.match(/^[0-9]+$/)) {
            throw new Error("Invalid string format");
          }
          return new Uint64(new bn_js_1.default(str, 10, "be"));
        }
        static fromNumber(input) {
          if (Number.isNaN(input)) {
            throw new Error("Input is not a number");
          }
          if (!Number.isInteger(input)) {
            throw new Error("Input is not an integer");
          }
          let bigint;
          try {
            bigint = new bn_js_1.default(input);
          } catch (_a) {
            throw new Error("Input is not a safe integer");
          }
          return new Uint64(bigint);
        }
        toBytesBigEndian() {
          return Uint8Array.from(this.data.toArray("be", 8));
        }
        toBytesLittleEndian() {
          return Uint8Array.from(this.data.toArray("le", 8));
        }
        toString() {
          return this.data.toString(10);
        }
        toNumber() {
          return this.data.toNumber();
        }
      };
      exports2.Uint64 = Uint64;
    }
  });

  // node_modules/@cosmjs/math/build/index.js
  var require_build = __commonJS({
    "node_modules/@cosmjs/math/build/index.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.Uint64 = exports2.Uint53 = exports2.Uint32 = exports2.Int53 = exports2.Decimal = void 0;
      var decimal_1 = require_decimal();
      Object.defineProperty(exports2, "Decimal", { enumerable: true, get: function() {
        return decimal_1.Decimal;
      } });
      var integers_1 = require_integers();
      Object.defineProperty(exports2, "Int53", { enumerable: true, get: function() {
        return integers_1.Int53;
      } });
      Object.defineProperty(exports2, "Uint32", { enumerable: true, get: function() {
        return integers_1.Uint32;
      } });
      Object.defineProperty(exports2, "Uint53", { enumerable: true, get: function() {
        return integers_1.Uint53;
      } });
      Object.defineProperty(exports2, "Uint64", { enumerable: true, get: function() {
        return integers_1.Uint64;
      } });
    }
  });

  // node_modules/@cosmjs/proto-signing/build/coins.js
  var require_coins = __commonJS({
    "node_modules/@cosmjs/proto-signing/build/coins.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.parseCoins = void 0;
      var math_1 = require_build();
      function parseCoins(input) {
        return input.replace(/\s/g, "").split(",").filter(Boolean).map((part) => {
          const match = part.match(/^([0-9]+)([a-zA-Z][a-zA-Z0-9/]{2,127})$/);
          if (!match)
            throw new Error("Got an invalid coin string");
          return {
            amount: math_1.Uint64.fromString(match[1]).toString(),
            denom: match[2]
          };
        });
      }
      exports2.parseCoins = parseCoins;
    }
  });

  // node_modules/long/src/long.js
  var require_long = __commonJS({
    "node_modules/long/src/long.js"(exports2, module2) {
      module2.exports = Long;
      var wasm = null;
      try {
        wasm = new WebAssembly.Instance(new WebAssembly.Module(new Uint8Array([
          0,
          97,
          115,
          109,
          1,
          0,
          0,
          0,
          1,
          13,
          2,
          96,
          0,
          1,
          127,
          96,
          4,
          127,
          127,
          127,
          127,
          1,
          127,
          3,
          7,
          6,
          0,
          1,
          1,
          1,
          1,
          1,
          6,
          6,
          1,
          127,
          1,
          65,
          0,
          11,
          7,
          50,
          6,
          3,
          109,
          117,
          108,
          0,
          1,
          5,
          100,
          105,
          118,
          95,
          115,
          0,
          2,
          5,
          100,
          105,
          118,
          95,
          117,
          0,
          3,
          5,
          114,
          101,
          109,
          95,
          115,
          0,
          4,
          5,
          114,
          101,
          109,
          95,
          117,
          0,
          5,
          8,
          103,
          101,
          116,
          95,
          104,
          105,
          103,
          104,
          0,
          0,
          10,
          191,
          1,
          6,
          4,
          0,
          35,
          0,
          11,
          36,
          1,
          1,
          126,
          32,
          0,
          173,
          32,
          1,
          173,
          66,
          32,
          134,
          132,
          32,
          2,
          173,
          32,
          3,
          173,
          66,
          32,
          134,
          132,
          126,
          34,
          4,
          66,
          32,
          135,
          167,
          36,
          0,
          32,
          4,
          167,
          11,
          36,
          1,
          1,
          126,
          32,
          0,
          173,
          32,
          1,
          173,
          66,
          32,
          134,
          132,
          32,
          2,
          173,
          32,
          3,
          173,
          66,
          32,
          134,
          132,
          127,
          34,
          4,
          66,
          32,
          135,
          167,
          36,
          0,
          32,
          4,
          167,
          11,
          36,
          1,
          1,
          126,
          32,
          0,
          173,
          32,
          1,
          173,
          66,
          32,
          134,
          132,
          32,
          2,
          173,
          32,
          3,
          173,
          66,
          32,
          134,
          132,
          128,
          34,
          4,
          66,
          32,
          135,
          167,
          36,
          0,
          32,
          4,
          167,
          11,
          36,
          1,
          1,
          126,
          32,
          0,
          173,
          32,
          1,
          173,
          66,
          32,
          134,
          132,
          32,
          2,
          173,
          32,
          3,
          173,
          66,
          32,
          134,
          132,
          129,
          34,
          4,
          66,
          32,
          135,
          167,
          36,
          0,
          32,
          4,
          167,
          11,
          36,
          1,
          1,
          126,
          32,
          0,
          173,
          32,
          1,
          173,
          66,
          32,
          134,
          132,
          32,
          2,
          173,
          32,
          3,
          173,
          66,
          32,
          134,
          132,
          130,
          34,
          4,
          66,
          32,
          135,
          167,
          36,
          0,
          32,
          4,
          167,
          11
        ])), {}).exports;
      } catch (e) {
      }
      function Long(low, high, unsigned) {
        this.low = low | 0;
        this.high = high | 0;
        this.unsigned = !!unsigned;
      }
      Long.prototype.__isLong__;
      Object.defineProperty(Long.prototype, "__isLong__", { value: true });
      function isLong(obj) {
        return (obj && obj["__isLong__"]) === true;
      }
      Long.isLong = isLong;
      var INT_CACHE = {};
      var UINT_CACHE = {};
      function fromInt(value, unsigned) {
        var obj, cachedObj, cache;
        if (unsigned) {
          value >>>= 0;
          if (cache = 0 <= value && value < 256) {
            cachedObj = UINT_CACHE[value];
            if (cachedObj)
              return cachedObj;
          }
          obj = fromBits(value, (value | 0) < 0 ? -1 : 0, true);
          if (cache)
            UINT_CACHE[value] = obj;
          return obj;
        } else {
          value |= 0;
          if (cache = -128 <= value && value < 128) {
            cachedObj = INT_CACHE[value];
            if (cachedObj)
              return cachedObj;
          }
          obj = fromBits(value, value < 0 ? -1 : 0, false);
          if (cache)
            INT_CACHE[value] = obj;
          return obj;
        }
      }
      Long.fromInt = fromInt;
      function fromNumber(value, unsigned) {
        if (isNaN(value))
          return unsigned ? UZERO : ZERO;
        if (unsigned) {
          if (value < 0)
            return UZERO;
          if (value >= TWO_PWR_64_DBL)
            return MAX_UNSIGNED_VALUE;
        } else {
          if (value <= -TWO_PWR_63_DBL)
            return MIN_VALUE;
          if (value + 1 >= TWO_PWR_63_DBL)
            return MAX_VALUE;
        }
        if (value < 0)
          return fromNumber(-value, unsigned).neg();
        return fromBits(value % TWO_PWR_32_DBL | 0, value / TWO_PWR_32_DBL | 0, unsigned);
      }
      Long.fromNumber = fromNumber;
      function fromBits(lowBits, highBits, unsigned) {
        return new Long(lowBits, highBits, unsigned);
      }
      Long.fromBits = fromBits;
      var pow_dbl = Math.pow;
      function fromString(str, unsigned, radix) {
        if (str.length === 0)
          throw Error("empty string");
        if (str === "NaN" || str === "Infinity" || str === "+Infinity" || str === "-Infinity")
          return ZERO;
        if (typeof unsigned === "number") {
          radix = unsigned, unsigned = false;
        } else {
          unsigned = !!unsigned;
        }
        radix = radix || 10;
        if (radix < 2 || 36 < radix)
          throw RangeError("radix");
        var p;
        if ((p = str.indexOf("-")) > 0)
          throw Error("interior hyphen");
        else if (p === 0) {
          return fromString(str.substring(1), unsigned, radix).neg();
        }
        var radixToPower = fromNumber(pow_dbl(radix, 8));
        var result = ZERO;
        for (var i = 0; i < str.length; i += 8) {
          var size = Math.min(8, str.length - i), value = parseInt(str.substring(i, i + size), radix);
          if (size < 8) {
            var power = fromNumber(pow_dbl(radix, size));
            result = result.mul(power).add(fromNumber(value));
          } else {
            result = result.mul(radixToPower);
            result = result.add(fromNumber(value));
          }
        }
        result.unsigned = unsigned;
        return result;
      }
      Long.fromString = fromString;
      function fromValue(val, unsigned) {
        if (typeof val === "number")
          return fromNumber(val, unsigned);
        if (typeof val === "string")
          return fromString(val, unsigned);
        return fromBits(val.low, val.high, typeof unsigned === "boolean" ? unsigned : val.unsigned);
      }
      Long.fromValue = fromValue;
      var TWO_PWR_16_DBL = 1 << 16;
      var TWO_PWR_24_DBL = 1 << 24;
      var TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;
      var TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL;
      var TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2;
      var TWO_PWR_24 = fromInt(TWO_PWR_24_DBL);
      var ZERO = fromInt(0);
      Long.ZERO = ZERO;
      var UZERO = fromInt(0, true);
      Long.UZERO = UZERO;
      var ONE = fromInt(1);
      Long.ONE = ONE;
      var UONE = fromInt(1, true);
      Long.UONE = UONE;
      var NEG_ONE = fromInt(-1);
      Long.NEG_ONE = NEG_ONE;
      var MAX_VALUE = fromBits(4294967295 | 0, 2147483647 | 0, false);
      Long.MAX_VALUE = MAX_VALUE;
      var MAX_UNSIGNED_VALUE = fromBits(4294967295 | 0, 4294967295 | 0, true);
      Long.MAX_UNSIGNED_VALUE = MAX_UNSIGNED_VALUE;
      var MIN_VALUE = fromBits(0, 2147483648 | 0, false);
      Long.MIN_VALUE = MIN_VALUE;
      var LongPrototype = Long.prototype;
      LongPrototype.toInt = function toInt() {
        return this.unsigned ? this.low >>> 0 : this.low;
      };
      LongPrototype.toNumber = function toNumber() {
        if (this.unsigned)
          return (this.high >>> 0) * TWO_PWR_32_DBL + (this.low >>> 0);
        return this.high * TWO_PWR_32_DBL + (this.low >>> 0);
      };
      LongPrototype.toString = function toString(radix) {
        radix = radix || 10;
        if (radix < 2 || 36 < radix)
          throw RangeError("radix");
        if (this.isZero())
          return "0";
        if (this.isNegative()) {
          if (this.eq(MIN_VALUE)) {
            var radixLong = fromNumber(radix), div = this.div(radixLong), rem1 = div.mul(radixLong).sub(this);
            return div.toString(radix) + rem1.toInt().toString(radix);
          } else
            return "-" + this.neg().toString(radix);
        }
        var radixToPower = fromNumber(pow_dbl(radix, 6), this.unsigned), rem = this;
        var result = "";
        while (true) {
          var remDiv = rem.div(radixToPower), intval = rem.sub(remDiv.mul(radixToPower)).toInt() >>> 0, digits = intval.toString(radix);
          rem = remDiv;
          if (rem.isZero())
            return digits + result;
          else {
            while (digits.length < 6)
              digits = "0" + digits;
            result = "" + digits + result;
          }
        }
      };
      LongPrototype.getHighBits = function getHighBits() {
        return this.high;
      };
      LongPrototype.getHighBitsUnsigned = function getHighBitsUnsigned() {
        return this.high >>> 0;
      };
      LongPrototype.getLowBits = function getLowBits() {
        return this.low;
      };
      LongPrototype.getLowBitsUnsigned = function getLowBitsUnsigned() {
        return this.low >>> 0;
      };
      LongPrototype.getNumBitsAbs = function getNumBitsAbs() {
        if (this.isNegative())
          return this.eq(MIN_VALUE) ? 64 : this.neg().getNumBitsAbs();
        var val = this.high != 0 ? this.high : this.low;
        for (var bit = 31; bit > 0; bit--)
          if ((val & 1 << bit) != 0)
            break;
        return this.high != 0 ? bit + 33 : bit + 1;
      };
      LongPrototype.isZero = function isZero() {
        return this.high === 0 && this.low === 0;
      };
      LongPrototype.eqz = LongPrototype.isZero;
      LongPrototype.isNegative = function isNegative() {
        return !this.unsigned && this.high < 0;
      };
      LongPrototype.isPositive = function isPositive() {
        return this.unsigned || this.high >= 0;
      };
      LongPrototype.isOdd = function isOdd() {
        return (this.low & 1) === 1;
      };
      LongPrototype.isEven = function isEven() {
        return (this.low & 1) === 0;
      };
      LongPrototype.equals = function equals(other) {
        if (!isLong(other))
          other = fromValue(other);
        if (this.unsigned !== other.unsigned && this.high >>> 31 === 1 && other.high >>> 31 === 1)
          return false;
        return this.high === other.high && this.low === other.low;
      };
      LongPrototype.eq = LongPrototype.equals;
      LongPrototype.notEquals = function notEquals(other) {
        return !this.eq(other);
      };
      LongPrototype.neq = LongPrototype.notEquals;
      LongPrototype.ne = LongPrototype.notEquals;
      LongPrototype.lessThan = function lessThan(other) {
        return this.comp(other) < 0;
      };
      LongPrototype.lt = LongPrototype.lessThan;
      LongPrototype.lessThanOrEqual = function lessThanOrEqual(other) {
        return this.comp(other) <= 0;
      };
      LongPrototype.lte = LongPrototype.lessThanOrEqual;
      LongPrototype.le = LongPrototype.lessThanOrEqual;
      LongPrototype.greaterThan = function greaterThan(other) {
        return this.comp(other) > 0;
      };
      LongPrototype.gt = LongPrototype.greaterThan;
      LongPrototype.greaterThanOrEqual = function greaterThanOrEqual(other) {
        return this.comp(other) >= 0;
      };
      LongPrototype.gte = LongPrototype.greaterThanOrEqual;
      LongPrototype.ge = LongPrototype.greaterThanOrEqual;
      LongPrototype.compare = function compare(other) {
        if (!isLong(other))
          other = fromValue(other);
        if (this.eq(other))
          return 0;
        var thisNeg = this.isNegative(), otherNeg = other.isNegative();
        if (thisNeg && !otherNeg)
          return -1;
        if (!thisNeg && otherNeg)
          return 1;
        if (!this.unsigned)
          return this.sub(other).isNegative() ? -1 : 1;
        return other.high >>> 0 > this.high >>> 0 || other.high === this.high && other.low >>> 0 > this.low >>> 0 ? -1 : 1;
      };
      LongPrototype.comp = LongPrototype.compare;
      LongPrototype.negate = function negate() {
        if (!this.unsigned && this.eq(MIN_VALUE))
          return MIN_VALUE;
        return this.not().add(ONE);
      };
      LongPrototype.neg = LongPrototype.negate;
      LongPrototype.add = function add(addend) {
        if (!isLong(addend))
          addend = fromValue(addend);
        var a48 = this.high >>> 16;
        var a32 = this.high & 65535;
        var a16 = this.low >>> 16;
        var a00 = this.low & 65535;
        var b48 = addend.high >>> 16;
        var b32 = addend.high & 65535;
        var b16 = addend.low >>> 16;
        var b00 = addend.low & 65535;
        var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
        c00 += a00 + b00;
        c16 += c00 >>> 16;
        c00 &= 65535;
        c16 += a16 + b16;
        c32 += c16 >>> 16;
        c16 &= 65535;
        c32 += a32 + b32;
        c48 += c32 >>> 16;
        c32 &= 65535;
        c48 += a48 + b48;
        c48 &= 65535;
        return fromBits(c16 << 16 | c00, c48 << 16 | c32, this.unsigned);
      };
      LongPrototype.subtract = function subtract(subtrahend) {
        if (!isLong(subtrahend))
          subtrahend = fromValue(subtrahend);
        return this.add(subtrahend.neg());
      };
      LongPrototype.sub = LongPrototype.subtract;
      LongPrototype.multiply = function multiply(multiplier) {
        if (this.isZero())
          return ZERO;
        if (!isLong(multiplier))
          multiplier = fromValue(multiplier);
        if (wasm) {
          var low = wasm.mul(this.low, this.high, multiplier.low, multiplier.high);
          return fromBits(low, wasm.get_high(), this.unsigned);
        }
        if (multiplier.isZero())
          return ZERO;
        if (this.eq(MIN_VALUE))
          return multiplier.isOdd() ? MIN_VALUE : ZERO;
        if (multiplier.eq(MIN_VALUE))
          return this.isOdd() ? MIN_VALUE : ZERO;
        if (this.isNegative()) {
          if (multiplier.isNegative())
            return this.neg().mul(multiplier.neg());
          else
            return this.neg().mul(multiplier).neg();
        } else if (multiplier.isNegative())
          return this.mul(multiplier.neg()).neg();
        if (this.lt(TWO_PWR_24) && multiplier.lt(TWO_PWR_24))
          return fromNumber(this.toNumber() * multiplier.toNumber(), this.unsigned);
        var a48 = this.high >>> 16;
        var a32 = this.high & 65535;
        var a16 = this.low >>> 16;
        var a00 = this.low & 65535;
        var b48 = multiplier.high >>> 16;
        var b32 = multiplier.high & 65535;
        var b16 = multiplier.low >>> 16;
        var b00 = multiplier.low & 65535;
        var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
        c00 += a00 * b00;
        c16 += c00 >>> 16;
        c00 &= 65535;
        c16 += a16 * b00;
        c32 += c16 >>> 16;
        c16 &= 65535;
        c16 += a00 * b16;
        c32 += c16 >>> 16;
        c16 &= 65535;
        c32 += a32 * b00;
        c48 += c32 >>> 16;
        c32 &= 65535;
        c32 += a16 * b16;
        c48 += c32 >>> 16;
        c32 &= 65535;
        c32 += a00 * b32;
        c48 += c32 >>> 16;
        c32 &= 65535;
        c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;
        c48 &= 65535;
        return fromBits(c16 << 16 | c00, c48 << 16 | c32, this.unsigned);
      };
      LongPrototype.mul = LongPrototype.multiply;
      LongPrototype.divide = function divide(divisor) {
        if (!isLong(divisor))
          divisor = fromValue(divisor);
        if (divisor.isZero())
          throw Error("division by zero");
        if (wasm) {
          if (!this.unsigned && this.high === -2147483648 && divisor.low === -1 && divisor.high === -1) {
            return this;
          }
          var low = (this.unsigned ? wasm.div_u : wasm.div_s)(this.low, this.high, divisor.low, divisor.high);
          return fromBits(low, wasm.get_high(), this.unsigned);
        }
        if (this.isZero())
          return this.unsigned ? UZERO : ZERO;
        var approx, rem, res;
        if (!this.unsigned) {
          if (this.eq(MIN_VALUE)) {
            if (divisor.eq(ONE) || divisor.eq(NEG_ONE))
              return MIN_VALUE;
            else if (divisor.eq(MIN_VALUE))
              return ONE;
            else {
              var halfThis = this.shr(1);
              approx = halfThis.div(divisor).shl(1);
              if (approx.eq(ZERO)) {
                return divisor.isNegative() ? ONE : NEG_ONE;
              } else {
                rem = this.sub(divisor.mul(approx));
                res = approx.add(rem.div(divisor));
                return res;
              }
            }
          } else if (divisor.eq(MIN_VALUE))
            return this.unsigned ? UZERO : ZERO;
          if (this.isNegative()) {
            if (divisor.isNegative())
              return this.neg().div(divisor.neg());
            return this.neg().div(divisor).neg();
          } else if (divisor.isNegative())
            return this.div(divisor.neg()).neg();
          res = ZERO;
        } else {
          if (!divisor.unsigned)
            divisor = divisor.toUnsigned();
          if (divisor.gt(this))
            return UZERO;
          if (divisor.gt(this.shru(1)))
            return UONE;
          res = UZERO;
        }
        rem = this;
        while (rem.gte(divisor)) {
          approx = Math.max(1, Math.floor(rem.toNumber() / divisor.toNumber()));
          var log2 = Math.ceil(Math.log(approx) / Math.LN2), delta = log2 <= 48 ? 1 : pow_dbl(2, log2 - 48), approxRes = fromNumber(approx), approxRem = approxRes.mul(divisor);
          while (approxRem.isNegative() || approxRem.gt(rem)) {
            approx -= delta;
            approxRes = fromNumber(approx, this.unsigned);
            approxRem = approxRes.mul(divisor);
          }
          if (approxRes.isZero())
            approxRes = ONE;
          res = res.add(approxRes);
          rem = rem.sub(approxRem);
        }
        return res;
      };
      LongPrototype.div = LongPrototype.divide;
      LongPrototype.modulo = function modulo(divisor) {
        if (!isLong(divisor))
          divisor = fromValue(divisor);
        if (wasm) {
          var low = (this.unsigned ? wasm.rem_u : wasm.rem_s)(this.low, this.high, divisor.low, divisor.high);
          return fromBits(low, wasm.get_high(), this.unsigned);
        }
        return this.sub(this.div(divisor).mul(divisor));
      };
      LongPrototype.mod = LongPrototype.modulo;
      LongPrototype.rem = LongPrototype.modulo;
      LongPrototype.not = function not() {
        return fromBits(~this.low, ~this.high, this.unsigned);
      };
      LongPrototype.and = function and(other) {
        if (!isLong(other))
          other = fromValue(other);
        return fromBits(this.low & other.low, this.high & other.high, this.unsigned);
      };
      LongPrototype.or = function or(other) {
        if (!isLong(other))
          other = fromValue(other);
        return fromBits(this.low | other.low, this.high | other.high, this.unsigned);
      };
      LongPrototype.xor = function xor(other) {
        if (!isLong(other))
          other = fromValue(other);
        return fromBits(this.low ^ other.low, this.high ^ other.high, this.unsigned);
      };
      LongPrototype.shiftLeft = function shiftLeft(numBits) {
        if (isLong(numBits))
          numBits = numBits.toInt();
        if ((numBits &= 63) === 0)
          return this;
        else if (numBits < 32)
          return fromBits(this.low << numBits, this.high << numBits | this.low >>> 32 - numBits, this.unsigned);
        else
          return fromBits(0, this.low << numBits - 32, this.unsigned);
      };
      LongPrototype.shl = LongPrototype.shiftLeft;
      LongPrototype.shiftRight = function shiftRight(numBits) {
        if (isLong(numBits))
          numBits = numBits.toInt();
        if ((numBits &= 63) === 0)
          return this;
        else if (numBits < 32)
          return fromBits(this.low >>> numBits | this.high << 32 - numBits, this.high >> numBits, this.unsigned);
        else
          return fromBits(this.high >> numBits - 32, this.high >= 0 ? 0 : -1, this.unsigned);
      };
      LongPrototype.shr = LongPrototype.shiftRight;
      LongPrototype.shiftRightUnsigned = function shiftRightUnsigned(numBits) {
        if (isLong(numBits))
          numBits = numBits.toInt();
        numBits &= 63;
        if (numBits === 0)
          return this;
        else {
          var high = this.high;
          if (numBits < 32) {
            var low = this.low;
            return fromBits(low >>> numBits | high << 32 - numBits, high >>> numBits, this.unsigned);
          } else if (numBits === 32)
            return fromBits(high, 0, this.unsigned);
          else
            return fromBits(high >>> numBits - 32, 0, this.unsigned);
        }
      };
      LongPrototype.shru = LongPrototype.shiftRightUnsigned;
      LongPrototype.shr_u = LongPrototype.shiftRightUnsigned;
      LongPrototype.toSigned = function toSigned() {
        if (!this.unsigned)
          return this;
        return fromBits(this.low, this.high, false);
      };
      LongPrototype.toUnsigned = function toUnsigned() {
        if (this.unsigned)
          return this;
        return fromBits(this.low, this.high, true);
      };
      LongPrototype.toBytes = function toBytes(le) {
        return le ? this.toBytesLE() : this.toBytesBE();
      };
      LongPrototype.toBytesLE = function toBytesLE() {
        var hi = this.high, lo = this.low;
        return [
          lo & 255,
          lo >>> 8 & 255,
          lo >>> 16 & 255,
          lo >>> 24,
          hi & 255,
          hi >>> 8 & 255,
          hi >>> 16 & 255,
          hi >>> 24
        ];
      };
      LongPrototype.toBytesBE = function toBytesBE() {
        var hi = this.high, lo = this.low;
        return [
          hi >>> 24,
          hi >>> 16 & 255,
          hi >>> 8 & 255,
          hi & 255,
          lo >>> 24,
          lo >>> 16 & 255,
          lo >>> 8 & 255,
          lo & 255
        ];
      };
      Long.fromBytes = function fromBytes(bytes, unsigned, le) {
        return le ? Long.fromBytesLE(bytes, unsigned) : Long.fromBytesBE(bytes, unsigned);
      };
      Long.fromBytesLE = function fromBytesLE(bytes, unsigned) {
        return new Long(bytes[0] | bytes[1] << 8 | bytes[2] << 16 | bytes[3] << 24, bytes[4] | bytes[5] << 8 | bytes[6] << 16 | bytes[7] << 24, unsigned);
      };
      Long.fromBytesBE = function fromBytesBE(bytes, unsigned) {
        return new Long(bytes[4] << 24 | bytes[5] << 16 | bytes[6] << 8 | bytes[7], bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3], unsigned);
      };
    }
  });

  // node_modules/@protobufjs/aspromise/index.js
  var require_aspromise = __commonJS({
    "node_modules/@protobufjs/aspromise/index.js"(exports2, module2) {
      "use strict";
      module2.exports = asPromise;
      function asPromise(fn, ctx) {
        var params = new Array(arguments.length - 1), offset = 0, index = 2, pending = true;
        while (index < arguments.length)
          params[offset++] = arguments[index++];
        return new Promise(function executor(resolve, reject) {
          params[offset] = function callback(err) {
            if (pending) {
              pending = false;
              if (err)
                reject(err);
              else {
                var params2 = new Array(arguments.length - 1), offset2 = 0;
                while (offset2 < params2.length)
                  params2[offset2++] = arguments[offset2];
                resolve.apply(null, params2);
              }
            }
          };
          try {
            fn.apply(ctx || null, params);
          } catch (err) {
            if (pending) {
              pending = false;
              reject(err);
            }
          }
        });
      }
    }
  });

  // node_modules/@protobufjs/base64/index.js
  var require_base64 = __commonJS({
    "node_modules/@protobufjs/base64/index.js"(exports2) {
      "use strict";
      var base64 = exports2;
      base64.length = function length(string) {
        var p = string.length;
        if (!p)
          return 0;
        var n = 0;
        while (--p % 4 > 1 && string.charAt(p) === "=")
          ++n;
        return Math.ceil(string.length * 3) / 4 - n;
      };
      var b64 = new Array(64);
      var s64 = new Array(123);
      for (i = 0; i < 64; )
        s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++;
      var i;
      base64.encode = function encode(buffer, start2, end) {
        var parts = null, chunk = [];
        var i2 = 0, j = 0, t;
        while (start2 < end) {
          var b = buffer[start2++];
          switch (j) {
            case 0:
              chunk[i2++] = b64[b >> 2];
              t = (b & 3) << 4;
              j = 1;
              break;
            case 1:
              chunk[i2++] = b64[t | b >> 4];
              t = (b & 15) << 2;
              j = 2;
              break;
            case 2:
              chunk[i2++] = b64[t | b >> 6];
              chunk[i2++] = b64[b & 63];
              j = 0;
              break;
          }
          if (i2 > 8191) {
            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
            i2 = 0;
          }
        }
        if (j) {
          chunk[i2++] = b64[t];
          chunk[i2++] = 61;
          if (j === 1)
            chunk[i2++] = 61;
        }
        if (parts) {
          if (i2)
            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i2)));
          return parts.join("");
        }
        return String.fromCharCode.apply(String, chunk.slice(0, i2));
      };
      var invalidEncoding = "invalid encoding";
      base64.decode = function decode(string, buffer, offset) {
        var start2 = offset;
        var j = 0, t;
        for (var i2 = 0; i2 < string.length; ) {
          var c = string.charCodeAt(i2++);
          if (c === 61 && j > 1)
            break;
          if ((c = s64[c]) === void 0)
            throw Error(invalidEncoding);
          switch (j) {
            case 0:
              t = c;
              j = 1;
              break;
            case 1:
              buffer[offset++] = t << 2 | (c & 48) >> 4;
              t = c;
              j = 2;
              break;
            case 2:
              buffer[offset++] = (t & 15) << 4 | (c & 60) >> 2;
              t = c;
              j = 3;
              break;
            case 3:
              buffer[offset++] = (t & 3) << 6 | c;
              j = 0;
              break;
          }
        }
        if (j === 1)
          throw Error(invalidEncoding);
        return offset - start2;
      };
      base64.test = function test(string) {
        return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(string);
      };
    }
  });

  // node_modules/@protobufjs/eventemitter/index.js
  var require_eventemitter = __commonJS({
    "node_modules/@protobufjs/eventemitter/index.js"(exports2, module2) {
      "use strict";
      module2.exports = EventEmitter;
      function EventEmitter() {
        this._listeners = {};
      }
      EventEmitter.prototype.on = function on(evt, fn, ctx) {
        (this._listeners[evt] || (this._listeners[evt] = [])).push({
          fn,
          ctx: ctx || this
        });
        return this;
      };
      EventEmitter.prototype.off = function off(evt, fn) {
        if (evt === void 0)
          this._listeners = {};
        else {
          if (fn === void 0)
            this._listeners[evt] = [];
          else {
            var listeners = this._listeners[evt];
            for (var i = 0; i < listeners.length; )
              if (listeners[i].fn === fn)
                listeners.splice(i, 1);
              else
                ++i;
          }
        }
        return this;
      };
      EventEmitter.prototype.emit = function emit(evt) {
        var listeners = this._listeners[evt];
        if (listeners) {
          var args = [], i = 1;
          for (; i < arguments.length; )
            args.push(arguments[i++]);
          for (i = 0; i < listeners.length; )
            listeners[i].fn.apply(listeners[i++].ctx, args);
        }
        return this;
      };
    }
  });

  // node_modules/@protobufjs/float/index.js
  var require_float = __commonJS({
    "node_modules/@protobufjs/float/index.js"(exports2, module2) {
      "use strict";
      module2.exports = factory(factory);
      function factory(exports3) {
        if (typeof Float32Array !== "undefined")
          (function() {
            var f32 = new Float32Array([-0]), f8b = new Uint8Array(f32.buffer), le = f8b[3] === 128;
            function writeFloat_f32_cpy(val, buf, pos) {
              f32[0] = val;
              buf[pos] = f8b[0];
              buf[pos + 1] = f8b[1];
              buf[pos + 2] = f8b[2];
              buf[pos + 3] = f8b[3];
            }
            function writeFloat_f32_rev(val, buf, pos) {
              f32[0] = val;
              buf[pos] = f8b[3];
              buf[pos + 1] = f8b[2];
              buf[pos + 2] = f8b[1];
              buf[pos + 3] = f8b[0];
            }
            exports3.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;
            exports3.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy;
            function readFloat_f32_cpy(buf, pos) {
              f8b[0] = buf[pos];
              f8b[1] = buf[pos + 1];
              f8b[2] = buf[pos + 2];
              f8b[3] = buf[pos + 3];
              return f32[0];
            }
            function readFloat_f32_rev(buf, pos) {
              f8b[3] = buf[pos];
              f8b[2] = buf[pos + 1];
              f8b[1] = buf[pos + 2];
              f8b[0] = buf[pos + 3];
              return f32[0];
            }
            exports3.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;
            exports3.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;
          })();
        else
          (function() {
            function writeFloat_ieee754(writeUint, val, buf, pos) {
              var sign = val < 0 ? 1 : 0;
              if (sign)
                val = -val;
              if (val === 0)
                writeUint(1 / val > 0 ? 0 : 2147483648, buf, pos);
              else if (isNaN(val))
                writeUint(2143289344, buf, pos);
              else if (val > 34028234663852886e22)
                writeUint((sign << 31 | 2139095040) >>> 0, buf, pos);
              else if (val < 11754943508222875e-54)
                writeUint((sign << 31 | Math.round(val / 1401298464324817e-60)) >>> 0, buf, pos);
              else {
                var exponent = Math.floor(Math.log(val) / Math.LN2), mantissa = Math.round(val * Math.pow(2, -exponent) * 8388608) & 8388607;
                writeUint((sign << 31 | exponent + 127 << 23 | mantissa) >>> 0, buf, pos);
              }
            }
            exports3.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);
            exports3.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);
            function readFloat_ieee754(readUint, buf, pos) {
              var uint = readUint(buf, pos), sign = (uint >> 31) * 2 + 1, exponent = uint >>> 23 & 255, mantissa = uint & 8388607;
              return exponent === 255 ? mantissa ? NaN : sign * Infinity : exponent === 0 ? sign * 1401298464324817e-60 * mantissa : sign * Math.pow(2, exponent - 150) * (mantissa + 8388608);
            }
            exports3.readFloatLE = readFloat_ieee754.bind(null, readUintLE);
            exports3.readFloatBE = readFloat_ieee754.bind(null, readUintBE);
          })();
        if (typeof Float64Array !== "undefined")
          (function() {
            var f64 = new Float64Array([-0]), f8b = new Uint8Array(f64.buffer), le = f8b[7] === 128;
            function writeDouble_f64_cpy(val, buf, pos) {
              f64[0] = val;
              buf[pos] = f8b[0];
              buf[pos + 1] = f8b[1];
              buf[pos + 2] = f8b[2];
              buf[pos + 3] = f8b[3];
              buf[pos + 4] = f8b[4];
              buf[pos + 5] = f8b[5];
              buf[pos + 6] = f8b[6];
              buf[pos + 7] = f8b[7];
            }
            function writeDouble_f64_rev(val, buf, pos) {
              f64[0] = val;
              buf[pos] = f8b[7];
              buf[pos + 1] = f8b[6];
              buf[pos + 2] = f8b[5];
              buf[pos + 3] = f8b[4];
              buf[pos + 4] = f8b[3];
              buf[pos + 5] = f8b[2];
              buf[pos + 6] = f8b[1];
              buf[pos + 7] = f8b[0];
            }
            exports3.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;
            exports3.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy;
            function readDouble_f64_cpy(buf, pos) {
              f8b[0] = buf[pos];
              f8b[1] = buf[pos + 1];
              f8b[2] = buf[pos + 2];
              f8b[3] = buf[pos + 3];
              f8b[4] = buf[pos + 4];
              f8b[5] = buf[pos + 5];
              f8b[6] = buf[pos + 6];
              f8b[7] = buf[pos + 7];
              return f64[0];
            }
            function readDouble_f64_rev(buf, pos) {
              f8b[7] = buf[pos];
              f8b[6] = buf[pos + 1];
              f8b[5] = buf[pos + 2];
              f8b[4] = buf[pos + 3];
              f8b[3] = buf[pos + 4];
              f8b[2] = buf[pos + 5];
              f8b[1] = buf[pos + 6];
              f8b[0] = buf[pos + 7];
              return f64[0];
            }
            exports3.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;
            exports3.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;
          })();
        else
          (function() {
            function writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) {
              var sign = val < 0 ? 1 : 0;
              if (sign)
                val = -val;
              if (val === 0) {
                writeUint(0, buf, pos + off0);
                writeUint(1 / val > 0 ? 0 : 2147483648, buf, pos + off1);
              } else if (isNaN(val)) {
                writeUint(0, buf, pos + off0);
                writeUint(2146959360, buf, pos + off1);
              } else if (val > 17976931348623157e292) {
                writeUint(0, buf, pos + off0);
                writeUint((sign << 31 | 2146435072) >>> 0, buf, pos + off1);
              } else {
                var mantissa;
                if (val < 22250738585072014e-324) {
                  mantissa = val / 5e-324;
                  writeUint(mantissa >>> 0, buf, pos + off0);
                  writeUint((sign << 31 | mantissa / 4294967296) >>> 0, buf, pos + off1);
                } else {
                  var exponent = Math.floor(Math.log(val) / Math.LN2);
                  if (exponent === 1024)
                    exponent = 1023;
                  mantissa = val * Math.pow(2, -exponent);
                  writeUint(mantissa * 4503599627370496 >>> 0, buf, pos + off0);
                  writeUint((sign << 31 | exponent + 1023 << 20 | mantissa * 1048576 & 1048575) >>> 0, buf, pos + off1);
                }
              }
            }
            exports3.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);
            exports3.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);
            function readDouble_ieee754(readUint, off0, off1, buf, pos) {
              var lo = readUint(buf, pos + off0), hi = readUint(buf, pos + off1);
              var sign = (hi >> 31) * 2 + 1, exponent = hi >>> 20 & 2047, mantissa = 4294967296 * (hi & 1048575) + lo;
              return exponent === 2047 ? mantissa ? NaN : sign * Infinity : exponent === 0 ? sign * 5e-324 * mantissa : sign * Math.pow(2, exponent - 1075) * (mantissa + 4503599627370496);
            }
            exports3.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);
            exports3.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);
          })();
        return exports3;
      }
      function writeUintLE(val, buf, pos) {
        buf[pos] = val & 255;
        buf[pos + 1] = val >>> 8 & 255;
        buf[pos + 2] = val >>> 16 & 255;
        buf[pos + 3] = val >>> 24;
      }
      function writeUintBE(val, buf, pos) {
        buf[pos] = val >>> 24;
        buf[pos + 1] = val >>> 16 & 255;
        buf[pos + 2] = val >>> 8 & 255;
        buf[pos + 3] = val & 255;
      }
      function readUintLE(buf, pos) {
        return (buf[pos] | buf[pos + 1] << 8 | buf[pos + 2] << 16 | buf[pos + 3] << 24) >>> 0;
      }
      function readUintBE(buf, pos) {
        return (buf[pos] << 24 | buf[pos + 1] << 16 | buf[pos + 2] << 8 | buf[pos + 3]) >>> 0;
      }
    }
  });

  // node_modules/@protobufjs/inquire/index.js
  var require_inquire = __commonJS({
    "node_modules/@protobufjs/inquire/index.js"(exports, module) {
      "use strict";
      module.exports = inquire;
      function inquire(moduleName) {
        try {
          var mod = eval("quire".replace(/^/, "re"))(moduleName);
          if (mod && (mod.length || Object.keys(mod).length))
            return mod;
        } catch (e) {
        }
        return null;
      }
    }
  });

  // node_modules/@protobufjs/utf8/index.js
  var require_utf8 = __commonJS({
    "node_modules/@protobufjs/utf8/index.js"(exports2) {
      "use strict";
      var utf8 = exports2;
      utf8.length = function utf8_length(string) {
        var len = 0, c = 0;
        for (var i = 0; i < string.length; ++i) {
          c = string.charCodeAt(i);
          if (c < 128)
            len += 1;
          else if (c < 2048)
            len += 2;
          else if ((c & 64512) === 55296 && (string.charCodeAt(i + 1) & 64512) === 56320) {
            ++i;
            len += 4;
          } else
            len += 3;
        }
        return len;
      };
      utf8.read = function utf8_read(buffer, start2, end) {
        var len = end - start2;
        if (len < 1)
          return "";
        var parts = null, chunk = [], i = 0, t;
        while (start2 < end) {
          t = buffer[start2++];
          if (t < 128)
            chunk[i++] = t;
          else if (t > 191 && t < 224)
            chunk[i++] = (t & 31) << 6 | buffer[start2++] & 63;
          else if (t > 239 && t < 365) {
            t = ((t & 7) << 18 | (buffer[start2++] & 63) << 12 | (buffer[start2++] & 63) << 6 | buffer[start2++] & 63) - 65536;
            chunk[i++] = 55296 + (t >> 10);
            chunk[i++] = 56320 + (t & 1023);
          } else
            chunk[i++] = (t & 15) << 12 | (buffer[start2++] & 63) << 6 | buffer[start2++] & 63;
          if (i > 8191) {
            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
            i = 0;
          }
        }
        if (parts) {
          if (i)
            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
          return parts.join("");
        }
        return String.fromCharCode.apply(String, chunk.slice(0, i));
      };
      utf8.write = function utf8_write(string, buffer, offset) {
        var start2 = offset, c1, c2;
        for (var i = 0; i < string.length; ++i) {
          c1 = string.charCodeAt(i);
          if (c1 < 128) {
            buffer[offset++] = c1;
          } else if (c1 < 2048) {
            buffer[offset++] = c1 >> 6 | 192;
            buffer[offset++] = c1 & 63 | 128;
          } else if ((c1 & 64512) === 55296 && ((c2 = string.charCodeAt(i + 1)) & 64512) === 56320) {
            c1 = 65536 + ((c1 & 1023) << 10) + (c2 & 1023);
            ++i;
            buffer[offset++] = c1 >> 18 | 240;
            buffer[offset++] = c1 >> 12 & 63 | 128;
            buffer[offset++] = c1 >> 6 & 63 | 128;
            buffer[offset++] = c1 & 63 | 128;
          } else {
            buffer[offset++] = c1 >> 12 | 224;
            buffer[offset++] = c1 >> 6 & 63 | 128;
            buffer[offset++] = c1 & 63 | 128;
          }
        }
        return offset - start2;
      };
    }
  });

  // node_modules/@protobufjs/pool/index.js
  var require_pool = __commonJS({
    "node_modules/@protobufjs/pool/index.js"(exports2, module2) {
      "use strict";
      module2.exports = pool;
      function pool(alloc, slice, size) {
        var SIZE = size || 8192;
        var MAX = SIZE >>> 1;
        var slab = null;
        var offset = SIZE;
        return function pool_alloc(size2) {
          if (size2 < 1 || size2 > MAX)
            return alloc(size2);
          if (offset + size2 > SIZE) {
            slab = alloc(SIZE);
            offset = 0;
          }
          var buf = slice.call(slab, offset, offset += size2);
          if (offset & 7)
            offset = (offset | 7) + 1;
          return buf;
        };
      }
    }
  });

  // node_modules/cosmjs-types/node_modules/protobufjs/src/util/longbits.js
  var require_longbits = __commonJS({
    "node_modules/cosmjs-types/node_modules/protobufjs/src/util/longbits.js"(exports2, module2) {
      "use strict";
      module2.exports = LongBits;
      var util = require_minimal();
      function LongBits(lo, hi) {
        this.lo = lo >>> 0;
        this.hi = hi >>> 0;
      }
      var zero = LongBits.zero = new LongBits(0, 0);
      zero.toNumber = function() {
        return 0;
      };
      zero.zzEncode = zero.zzDecode = function() {
        return this;
      };
      zero.length = function() {
        return 1;
      };
      var zeroHash = LongBits.zeroHash = "\0\0\0\0\0\0\0\0";
      LongBits.fromNumber = function fromNumber(value) {
        if (value === 0)
          return zero;
        var sign = value < 0;
        if (sign)
          value = -value;
        var lo = value >>> 0, hi = (value - lo) / 4294967296 >>> 0;
        if (sign) {
          hi = ~hi >>> 0;
          lo = ~lo >>> 0;
          if (++lo > 4294967295) {
            lo = 0;
            if (++hi > 4294967295)
              hi = 0;
          }
        }
        return new LongBits(lo, hi);
      };
      LongBits.from = function from(value) {
        if (typeof value === "number")
          return LongBits.fromNumber(value);
        if (util.isString(value)) {
          if (util.Long)
            value = util.Long.fromString(value);
          else
            return LongBits.fromNumber(parseInt(value, 10));
        }
        return value.low || value.high ? new LongBits(value.low >>> 0, value.high >>> 0) : zero;
      };
      LongBits.prototype.toNumber = function toNumber(unsigned) {
        if (!unsigned && this.hi >>> 31) {
          var lo = ~this.lo + 1 >>> 0, hi = ~this.hi >>> 0;
          if (!lo)
            hi = hi + 1 >>> 0;
          return -(lo + hi * 4294967296);
        }
        return this.lo + this.hi * 4294967296;
      };
      LongBits.prototype.toLong = function toLong(unsigned) {
        return util.Long ? new util.Long(this.lo | 0, this.hi | 0, Boolean(unsigned)) : { low: this.lo | 0, high: this.hi | 0, unsigned: Boolean(unsigned) };
      };
      var charCodeAt = String.prototype.charCodeAt;
      LongBits.fromHash = function fromHash(hash) {
        if (hash === zeroHash)
          return zero;
        return new LongBits((charCodeAt.call(hash, 0) | charCodeAt.call(hash, 1) << 8 | charCodeAt.call(hash, 2) << 16 | charCodeAt.call(hash, 3) << 24) >>> 0, (charCodeAt.call(hash, 4) | charCodeAt.call(hash, 5) << 8 | charCodeAt.call(hash, 6) << 16 | charCodeAt.call(hash, 7) << 24) >>> 0);
      };
      LongBits.prototype.toHash = function toHash() {
        return String.fromCharCode(this.lo & 255, this.lo >>> 8 & 255, this.lo >>> 16 & 255, this.lo >>> 24, this.hi & 255, this.hi >>> 8 & 255, this.hi >>> 16 & 255, this.hi >>> 24);
      };
      LongBits.prototype.zzEncode = function zzEncode() {
        var mask = this.hi >> 31;
        this.hi = ((this.hi << 1 | this.lo >>> 31) ^ mask) >>> 0;
        this.lo = (this.lo << 1 ^ mask) >>> 0;
        return this;
      };
      LongBits.prototype.zzDecode = function zzDecode() {
        var mask = -(this.lo & 1);
        this.lo = ((this.lo >>> 1 | this.hi << 31) ^ mask) >>> 0;
        this.hi = (this.hi >>> 1 ^ mask) >>> 0;
        return this;
      };
      LongBits.prototype.length = function length() {
        var part0 = this.lo, part1 = (this.lo >>> 28 | this.hi << 4) >>> 0, part2 = this.hi >>> 24;
        return part2 === 0 ? part1 === 0 ? part0 < 16384 ? part0 < 128 ? 1 : 2 : part0 < 2097152 ? 3 : 4 : part1 < 16384 ? part1 < 128 ? 5 : 6 : part1 < 2097152 ? 7 : 8 : part2 < 128 ? 9 : 10;
      };
    }
  });

  // node_modules/cosmjs-types/node_modules/protobufjs/src/util/minimal.js
  var require_minimal = __commonJS({
    "node_modules/cosmjs-types/node_modules/protobufjs/src/util/minimal.js"(exports2) {
      "use strict";
      var util = exports2;
      util.asPromise = require_aspromise();
      util.base64 = require_base64();
      util.EventEmitter = require_eventemitter();
      util.float = require_float();
      util.inquire = require_inquire();
      util.utf8 = require_utf8();
      util.pool = require_pool();
      util.LongBits = require_longbits();
      util.isNode = Boolean(typeof global !== "undefined" && global && global.process && global.process.versions && global.process.versions.node);
      util.global = util.isNode && global || typeof window !== "undefined" && window || typeof self !== "undefined" && self || exports2;
      util.emptyArray = Object.freeze ? Object.freeze([]) : [];
      util.emptyObject = Object.freeze ? Object.freeze({}) : {};
      util.isInteger = Number.isInteger || function isInteger(value) {
        return typeof value === "number" && isFinite(value) && Math.floor(value) === value;
      };
      util.isString = function isString(value) {
        return typeof value === "string" || value instanceof String;
      };
      util.isObject = function isObject(value) {
        return value && typeof value === "object";
      };
      util.isset = util.isSet = function isSet(obj, prop) {
        var value = obj[prop];
        if (value != null && obj.hasOwnProperty(prop))
          return typeof value !== "object" || (Array.isArray(value) ? value.length : Object.keys(value).length) > 0;
        return false;
      };
      util.Buffer = function() {
        try {
          var Buffer2 = util.inquire("buffer").Buffer;
          return Buffer2.prototype.utf8Write ? Buffer2 : null;
        } catch (e) {
          return null;
        }
      }();
      util._Buffer_from = null;
      util._Buffer_allocUnsafe = null;
      util.newBuffer = function newBuffer(sizeOrArray) {
        return typeof sizeOrArray === "number" ? util.Buffer ? util._Buffer_allocUnsafe(sizeOrArray) : new util.Array(sizeOrArray) : util.Buffer ? util._Buffer_from(sizeOrArray) : typeof Uint8Array === "undefined" ? sizeOrArray : new Uint8Array(sizeOrArray);
      };
      util.Array = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
      util.Long = util.global.dcodeIO && util.global.dcodeIO.Long || util.global.Long || util.inquire("long");
      util.key2Re = /^true|false|0|1$/;
      util.key32Re = /^-?(?:0|[1-9][0-9]*)$/;
      util.key64Re = /^(?:[\\x00-\\xff]{8}|-?(?:0|[1-9][0-9]*))$/;
      util.longToHash = function longToHash(value) {
        return value ? util.LongBits.from(value).toHash() : util.LongBits.zeroHash;
      };
      util.longFromHash = function longFromHash(hash, unsigned) {
        var bits = util.LongBits.fromHash(hash);
        if (util.Long)
          return util.Long.fromBits(bits.lo, bits.hi, unsigned);
        return bits.toNumber(Boolean(unsigned));
      };
      function merge(dst, src, ifNotSet) {
        for (var keys = Object.keys(src), i = 0; i < keys.length; ++i)
          if (dst[keys[i]] === void 0 || !ifNotSet)
            dst[keys[i]] = src[keys[i]];
        return dst;
      }
      util.merge = merge;
      util.lcFirst = function lcFirst(str) {
        return str.charAt(0).toLowerCase() + str.substring(1);
      };
      function newError(name) {
        function CustomError(message, properties) {
          if (!(this instanceof CustomError))
            return new CustomError(message, properties);
          Object.defineProperty(this, "message", { get: function() {
            return message;
          } });
          if (Error.captureStackTrace)
            Error.captureStackTrace(this, CustomError);
          else
            Object.defineProperty(this, "stack", { value: new Error().stack || "" });
          if (properties)
            merge(this, properties);
        }
        (CustomError.prototype = Object.create(Error.prototype)).constructor = CustomError;
        Object.defineProperty(CustomError.prototype, "name", { get: function() {
          return name;
        } });
        CustomError.prototype.toString = function toString() {
          return this.name + ": " + this.message;
        };
        return CustomError;
      }
      util.newError = newError;
      util.ProtocolError = newError("ProtocolError");
      util.oneOfGetter = function getOneOf(fieldNames) {
        var fieldMap = {};
        for (var i = 0; i < fieldNames.length; ++i)
          fieldMap[fieldNames[i]] = 1;
        return function() {
          for (var keys = Object.keys(this), i2 = keys.length - 1; i2 > -1; --i2)
            if (fieldMap[keys[i2]] === 1 && this[keys[i2]] !== void 0 && this[keys[i2]] !== null)
              return keys[i2];
        };
      };
      util.oneOfSetter = function setOneOf(fieldNames) {
        return function(name) {
          for (var i = 0; i < fieldNames.length; ++i)
            if (fieldNames[i] !== name)
              delete this[fieldNames[i]];
        };
      };
      util.toJSONOptions = {
        longs: String,
        enums: String,
        bytes: String,
        json: true
      };
      util._configure = function() {
        var Buffer2 = util.Buffer;
        if (!Buffer2) {
          util._Buffer_from = util._Buffer_allocUnsafe = null;
          return;
        }
        util._Buffer_from = Buffer2.from !== Uint8Array.from && Buffer2.from || function Buffer_from(value, encoding) {
          return new Buffer2(value, encoding);
        };
        util._Buffer_allocUnsafe = Buffer2.allocUnsafe || function Buffer_allocUnsafe(size) {
          return new Buffer2(size);
        };
      };
    }
  });

  // node_modules/cosmjs-types/node_modules/protobufjs/src/writer.js
  var require_writer = __commonJS({
    "node_modules/cosmjs-types/node_modules/protobufjs/src/writer.js"(exports2, module2) {
      "use strict";
      module2.exports = Writer;
      var util = require_minimal();
      var BufferWriter;
      var LongBits = util.LongBits;
      var base64 = util.base64;
      var utf8 = util.utf8;
      function Op(fn, len, val) {
        this.fn = fn;
        this.len = len;
        this.next = void 0;
        this.val = val;
      }
      function noop() {
      }
      function State(writer) {
        this.head = writer.head;
        this.tail = writer.tail;
        this.len = writer.len;
        this.next = writer.states;
      }
      function Writer() {
        this.len = 0;
        this.head = new Op(noop, 0, 0);
        this.tail = this.head;
        this.states = null;
      }
      var create = function create2() {
        return util.Buffer ? function create_buffer_setup() {
          return (Writer.create = function create_buffer() {
            return new BufferWriter();
          })();
        } : function create_array() {
          return new Writer();
        };
      };
      Writer.create = create();
      Writer.alloc = function alloc(size) {
        return new util.Array(size);
      };
      if (util.Array !== Array)
        Writer.alloc = util.pool(Writer.alloc, util.Array.prototype.subarray);
      Writer.prototype._push = function push(fn, len, val) {
        this.tail = this.tail.next = new Op(fn, len, val);
        this.len += len;
        return this;
      };
      function writeByte(val, buf, pos) {
        buf[pos] = val & 255;
      }
      function writeVarint32(val, buf, pos) {
        while (val > 127) {
          buf[pos++] = val & 127 | 128;
          val >>>= 7;
        }
        buf[pos] = val;
      }
      function VarintOp(len, val) {
        this.len = len;
        this.next = void 0;
        this.val = val;
      }
      VarintOp.prototype = Object.create(Op.prototype);
      VarintOp.prototype.fn = writeVarint32;
      Writer.prototype.uint32 = function write_uint32(value) {
        this.len += (this.tail = this.tail.next = new VarintOp((value = value >>> 0) < 128 ? 1 : value < 16384 ? 2 : value < 2097152 ? 3 : value < 268435456 ? 4 : 5, value)).len;
        return this;
      };
      Writer.prototype.int32 = function write_int32(value) {
        return value < 0 ? this._push(writeVarint64, 10, LongBits.fromNumber(value)) : this.uint32(value);
      };
      Writer.prototype.sint32 = function write_sint32(value) {
        return this.uint32((value << 1 ^ value >> 31) >>> 0);
      };
      function writeVarint64(val, buf, pos) {
        while (val.hi) {
          buf[pos++] = val.lo & 127 | 128;
          val.lo = (val.lo >>> 7 | val.hi << 25) >>> 0;
          val.hi >>>= 7;
        }
        while (val.lo > 127) {
          buf[pos++] = val.lo & 127 | 128;
          val.lo = val.lo >>> 7;
        }
        buf[pos++] = val.lo;
      }
      Writer.prototype.uint64 = function write_uint64(value) {
        var bits = LongBits.from(value);
        return this._push(writeVarint64, bits.length(), bits);
      };
      Writer.prototype.int64 = Writer.prototype.uint64;
      Writer.prototype.sint64 = function write_sint64(value) {
        var bits = LongBits.from(value).zzEncode();
        return this._push(writeVarint64, bits.length(), bits);
      };
      Writer.prototype.bool = function write_bool(value) {
        return this._push(writeByte, 1, value ? 1 : 0);
      };
      function writeFixed32(val, buf, pos) {
        buf[pos] = val & 255;
        buf[pos + 1] = val >>> 8 & 255;
        buf[pos + 2] = val >>> 16 & 255;
        buf[pos + 3] = val >>> 24;
      }
      Writer.prototype.fixed32 = function write_fixed32(value) {
        return this._push(writeFixed32, 4, value >>> 0);
      };
      Writer.prototype.sfixed32 = Writer.prototype.fixed32;
      Writer.prototype.fixed64 = function write_fixed64(value) {
        var bits = LongBits.from(value);
        return this._push(writeFixed32, 4, bits.lo)._push(writeFixed32, 4, bits.hi);
      };
      Writer.prototype.sfixed64 = Writer.prototype.fixed64;
      Writer.prototype.float = function write_float(value) {
        return this._push(util.float.writeFloatLE, 4, value);
      };
      Writer.prototype.double = function write_double(value) {
        return this._push(util.float.writeDoubleLE, 8, value);
      };
      var writeBytes = util.Array.prototype.set ? function writeBytes_set(val, buf, pos) {
        buf.set(val, pos);
      } : function writeBytes_for(val, buf, pos) {
        for (var i = 0; i < val.length; ++i)
          buf[pos + i] = val[i];
      };
      Writer.prototype.bytes = function write_bytes(value) {
        var len = value.length >>> 0;
        if (!len)
          return this._push(writeByte, 1, 0);
        if (util.isString(value)) {
          var buf = Writer.alloc(len = base64.length(value));
          base64.decode(value, buf, 0);
          value = buf;
        }
        return this.uint32(len)._push(writeBytes, len, value);
      };
      Writer.prototype.string = function write_string(value) {
        var len = utf8.length(value);
        return len ? this.uint32(len)._push(utf8.write, len, value) : this._push(writeByte, 1, 0);
      };
      Writer.prototype.fork = function fork() {
        this.states = new State(this);
        this.head = this.tail = new Op(noop, 0, 0);
        this.len = 0;
        return this;
      };
      Writer.prototype.reset = function reset() {
        if (this.states) {
          this.head = this.states.head;
          this.tail = this.states.tail;
          this.len = this.states.len;
          this.states = this.states.next;
        } else {
          this.head = this.tail = new Op(noop, 0, 0);
          this.len = 0;
        }
        return this;
      };
      Writer.prototype.ldelim = function ldelim() {
        var head = this.head, tail = this.tail, len = this.len;
        this.reset().uint32(len);
        if (len) {
          this.tail.next = head.next;
          this.tail = tail;
          this.len += len;
        }
        return this;
      };
      Writer.prototype.finish = function finish() {
        var head = this.head.next, buf = this.constructor.alloc(this.len), pos = 0;
        while (head) {
          head.fn(head.val, buf, pos);
          pos += head.len;
          head = head.next;
        }
        return buf;
      };
      Writer._configure = function(BufferWriter_) {
        BufferWriter = BufferWriter_;
        Writer.create = create();
        BufferWriter._configure();
      };
    }
  });

  // node_modules/cosmjs-types/node_modules/protobufjs/src/writer_buffer.js
  var require_writer_buffer = __commonJS({
    "node_modules/cosmjs-types/node_modules/protobufjs/src/writer_buffer.js"(exports2, module2) {
      "use strict";
      module2.exports = BufferWriter;
      var Writer = require_writer();
      (BufferWriter.prototype = Object.create(Writer.prototype)).constructor = BufferWriter;
      var util = require_minimal();
      function BufferWriter() {
        Writer.call(this);
      }
      BufferWriter._configure = function() {
        BufferWriter.alloc = util._Buffer_allocUnsafe;
        BufferWriter.writeBytesBuffer = util.Buffer && util.Buffer.prototype instanceof Uint8Array && util.Buffer.prototype.set.name === "set" ? function writeBytesBuffer_set(val, buf, pos) {
          buf.set(val, pos);
        } : function writeBytesBuffer_copy(val, buf, pos) {
          if (val.copy)
            val.copy(buf, pos, 0, val.length);
          else
            for (var i = 0; i < val.length; )
              buf[pos++] = val[i++];
        };
      };
      BufferWriter.prototype.bytes = function write_bytes_buffer(value) {
        if (util.isString(value))
          value = util._Buffer_from(value, "base64");
        var len = value.length >>> 0;
        this.uint32(len);
        if (len)
          this._push(BufferWriter.writeBytesBuffer, len, value);
        return this;
      };
      function writeStringBuffer(val, buf, pos) {
        if (val.length < 40)
          util.utf8.write(val, buf, pos);
        else if (buf.utf8Write)
          buf.utf8Write(val, pos);
        else
          buf.write(val, pos);
      }
      BufferWriter.prototype.string = function write_string_buffer(value) {
        var len = util.Buffer.byteLength(value);
        this.uint32(len);
        if (len)
          this._push(writeStringBuffer, len, value);
        return this;
      };
      BufferWriter._configure();
    }
  });

  // node_modules/cosmjs-types/node_modules/protobufjs/src/reader.js
  var require_reader = __commonJS({
    "node_modules/cosmjs-types/node_modules/protobufjs/src/reader.js"(exports2, module2) {
      "use strict";
      module2.exports = Reader;
      var util = require_minimal();
      var BufferReader;
      var LongBits = util.LongBits;
      var utf8 = util.utf8;
      function indexOutOfRange(reader, writeLength) {
        return RangeError("index out of range: " + reader.pos + " + " + (writeLength || 1) + " > " + reader.len);
      }
      function Reader(buffer) {
        this.buf = buffer;
        this.pos = 0;
        this.len = buffer.length;
      }
      var create_array = typeof Uint8Array !== "undefined" ? function create_typed_array(buffer) {
        if (buffer instanceof Uint8Array || Array.isArray(buffer))
          return new Reader(buffer);
        throw Error("illegal buffer");
      } : function create_array2(buffer) {
        if (Array.isArray(buffer))
          return new Reader(buffer);
        throw Error("illegal buffer");
      };
      var create = function create2() {
        return util.Buffer ? function create_buffer_setup(buffer) {
          return (Reader.create = function create_buffer(buffer2) {
            return util.Buffer.isBuffer(buffer2) ? new BufferReader(buffer2) : create_array(buffer2);
          })(buffer);
        } : create_array;
      };
      Reader.create = create();
      Reader.prototype._slice = util.Array.prototype.subarray || util.Array.prototype.slice;
      Reader.prototype.uint32 = function read_uint32_setup() {
        var value = 4294967295;
        return function read_uint32() {
          value = (this.buf[this.pos] & 127) >>> 0;
          if (this.buf[this.pos++] < 128)
            return value;
          value = (value | (this.buf[this.pos] & 127) << 7) >>> 0;
          if (this.buf[this.pos++] < 128)
            return value;
          value = (value | (this.buf[this.pos] & 127) << 14) >>> 0;
          if (this.buf[this.pos++] < 128)
            return value;
          value = (value | (this.buf[this.pos] & 127) << 21) >>> 0;
          if (this.buf[this.pos++] < 128)
            return value;
          value = (value | (this.buf[this.pos] & 15) << 28) >>> 0;
          if (this.buf[this.pos++] < 128)
            return value;
          if ((this.pos += 5) > this.len) {
            this.pos = this.len;
            throw indexOutOfRange(this, 10);
          }
          return value;
        };
      }();
      Reader.prototype.int32 = function read_int32() {
        return this.uint32() | 0;
      };
      Reader.prototype.sint32 = function read_sint32() {
        var value = this.uint32();
        return value >>> 1 ^ -(value & 1) | 0;
      };
      function readLongVarint() {
        var bits = new LongBits(0, 0);
        var i = 0;
        if (this.len - this.pos > 4) {
          for (; i < 4; ++i) {
            bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
            if (this.buf[this.pos++] < 128)
              return bits;
          }
          bits.lo = (bits.lo | (this.buf[this.pos] & 127) << 28) >>> 0;
          bits.hi = (bits.hi | (this.buf[this.pos] & 127) >> 4) >>> 0;
          if (this.buf[this.pos++] < 128)
            return bits;
          i = 0;
        } else {
          for (; i < 3; ++i) {
            if (this.pos >= this.len)
              throw indexOutOfRange(this);
            bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
            if (this.buf[this.pos++] < 128)
              return bits;
          }
          bits.lo = (bits.lo | (this.buf[this.pos++] & 127) << i * 7) >>> 0;
          return bits;
        }
        if (this.len - this.pos > 4) {
          for (; i < 5; ++i) {
            bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;
            if (this.buf[this.pos++] < 128)
              return bits;
          }
        } else {
          for (; i < 5; ++i) {
            if (this.pos >= this.len)
              throw indexOutOfRange(this);
            bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;
            if (this.buf[this.pos++] < 128)
              return bits;
          }
        }
        throw Error("invalid varint encoding");
      }
      Reader.prototype.bool = function read_bool() {
        return this.uint32() !== 0;
      };
      function readFixed32_end(buf, end) {
        return (buf[end - 4] | buf[end - 3] << 8 | buf[end - 2] << 16 | buf[end - 1] << 24) >>> 0;
      }
      Reader.prototype.fixed32 = function read_fixed32() {
        if (this.pos + 4 > this.len)
          throw indexOutOfRange(this, 4);
        return readFixed32_end(this.buf, this.pos += 4);
      };
      Reader.prototype.sfixed32 = function read_sfixed32() {
        if (this.pos + 4 > this.len)
          throw indexOutOfRange(this, 4);
        return readFixed32_end(this.buf, this.pos += 4) | 0;
      };
      function readFixed64() {
        if (this.pos + 8 > this.len)
          throw indexOutOfRange(this, 8);
        return new LongBits(readFixed32_end(this.buf, this.pos += 4), readFixed32_end(this.buf, this.pos += 4));
      }
      Reader.prototype.float = function read_float() {
        if (this.pos + 4 > this.len)
          throw indexOutOfRange(this, 4);
        var value = util.float.readFloatLE(this.buf, this.pos);
        this.pos += 4;
        return value;
      };
      Reader.prototype.double = function read_double() {
        if (this.pos + 8 > this.len)
          throw indexOutOfRange(this, 4);
        var value = util.float.readDoubleLE(this.buf, this.pos);
        this.pos += 8;
        return value;
      };
      Reader.prototype.bytes = function read_bytes() {
        var length = this.uint32(), start2 = this.pos, end = this.pos + length;
        if (end > this.len)
          throw indexOutOfRange(this, length);
        this.pos += length;
        if (Array.isArray(this.buf))
          return this.buf.slice(start2, end);
        return start2 === end ? new this.buf.constructor(0) : this._slice.call(this.buf, start2, end);
      };
      Reader.prototype.string = function read_string() {
        var bytes = this.bytes();
        return utf8.read(bytes, 0, bytes.length);
      };
      Reader.prototype.skip = function skip(length) {
        if (typeof length === "number") {
          if (this.pos + length > this.len)
            throw indexOutOfRange(this, length);
          this.pos += length;
        } else {
          do {
            if (this.pos >= this.len)
              throw indexOutOfRange(this);
          } while (this.buf[this.pos++] & 128);
        }
        return this;
      };
      Reader.prototype.skipType = function(wireType) {
        switch (wireType) {
          case 0:
            this.skip();
            break;
          case 1:
            this.skip(8);
            break;
          case 2:
            this.skip(this.uint32());
            break;
          case 3:
            while ((wireType = this.uint32() & 7) !== 4) {
              this.skipType(wireType);
            }
            break;
          case 5:
            this.skip(4);
            break;
          default:
            throw Error("invalid wire type " + wireType + " at offset " + this.pos);
        }
        return this;
      };
      Reader._configure = function(BufferReader_) {
        BufferReader = BufferReader_;
        Reader.create = create();
        BufferReader._configure();
        var fn = util.Long ? "toLong" : "toNumber";
        util.merge(Reader.prototype, {
          int64: function read_int64() {
            return readLongVarint.call(this)[fn](false);
          },
          uint64: function read_uint64() {
            return readLongVarint.call(this)[fn](true);
          },
          sint64: function read_sint64() {
            return readLongVarint.call(this).zzDecode()[fn](false);
          },
          fixed64: function read_fixed64() {
            return readFixed64.call(this)[fn](true);
          },
          sfixed64: function read_sfixed64() {
            return readFixed64.call(this)[fn](false);
          }
        });
      };
    }
  });

  // node_modules/cosmjs-types/node_modules/protobufjs/src/reader_buffer.js
  var require_reader_buffer = __commonJS({
    "node_modules/cosmjs-types/node_modules/protobufjs/src/reader_buffer.js"(exports2, module2) {
      "use strict";
      module2.exports = BufferReader;
      var Reader = require_reader();
      (BufferReader.prototype = Object.create(Reader.prototype)).constructor = BufferReader;
      var util = require_minimal();
      function BufferReader(buffer) {
        Reader.call(this, buffer);
      }
      BufferReader._configure = function() {
        if (util.Buffer)
          BufferReader.prototype._slice = util.Buffer.prototype.slice;
      };
      BufferReader.prototype.string = function read_string_buffer() {
        var len = this.uint32();
        return this.buf.utf8Slice ? this.buf.utf8Slice(this.pos, this.pos = Math.min(this.pos + len, this.len)) : this.buf.toString("utf-8", this.pos, this.pos = Math.min(this.pos + len, this.len));
      };
      BufferReader._configure();
    }
  });

  // node_modules/cosmjs-types/node_modules/protobufjs/src/rpc/service.js
  var require_service = __commonJS({
    "node_modules/cosmjs-types/node_modules/protobufjs/src/rpc/service.js"(exports2, module2) {
      "use strict";
      module2.exports = Service;
      var util = require_minimal();
      (Service.prototype = Object.create(util.EventEmitter.prototype)).constructor = Service;
      function Service(rpcImpl, requestDelimited, responseDelimited) {
        if (typeof rpcImpl !== "function")
          throw TypeError("rpcImpl must be a function");
        util.EventEmitter.call(this);
        this.rpcImpl = rpcImpl;
        this.requestDelimited = Boolean(requestDelimited);
        this.responseDelimited = Boolean(responseDelimited);
      }
      Service.prototype.rpcCall = function rpcCall(method, requestCtor, responseCtor, request, callback) {
        if (!request)
          throw TypeError("request must be specified");
        var self2 = this;
        if (!callback)
          return util.asPromise(rpcCall, self2, method, requestCtor, responseCtor, request);
        if (!self2.rpcImpl) {
          setTimeout(function() {
            callback(Error("already ended"));
          }, 0);
          return void 0;
        }
        try {
          return self2.rpcImpl(method, requestCtor[self2.requestDelimited ? "encodeDelimited" : "encode"](request).finish(), function rpcCallback(err, response) {
            if (err) {
              self2.emit("error", err, method);
              return callback(err);
            }
            if (response === null) {
              self2.end(true);
              return void 0;
            }
            if (!(response instanceof responseCtor)) {
              try {
                response = responseCtor[self2.responseDelimited ? "decodeDelimited" : "decode"](response);
              } catch (err2) {
                self2.emit("error", err2, method);
                return callback(err2);
              }
            }
            self2.emit("data", response, method);
            return callback(null, response);
          });
        } catch (err) {
          self2.emit("error", err, method);
          setTimeout(function() {
            callback(err);
          }, 0);
          return void 0;
        }
      };
      Service.prototype.end = function end(endedByRPC) {
        if (this.rpcImpl) {
          if (!endedByRPC)
            this.rpcImpl(null, null, null);
          this.rpcImpl = null;
          this.emit("end").off();
        }
        return this;
      };
    }
  });

  // node_modules/cosmjs-types/node_modules/protobufjs/src/rpc.js
  var require_rpc = __commonJS({
    "node_modules/cosmjs-types/node_modules/protobufjs/src/rpc.js"(exports2) {
      "use strict";
      var rpc = exports2;
      rpc.Service = require_service();
    }
  });

  // node_modules/cosmjs-types/node_modules/protobufjs/src/roots.js
  var require_roots = __commonJS({
    "node_modules/cosmjs-types/node_modules/protobufjs/src/roots.js"(exports2, module2) {
      "use strict";
      module2.exports = {};
    }
  });

  // node_modules/cosmjs-types/node_modules/protobufjs/src/index-minimal.js
  var require_index_minimal = __commonJS({
    "node_modules/cosmjs-types/node_modules/protobufjs/src/index-minimal.js"(exports2) {
      "use strict";
      var protobuf = exports2;
      protobuf.build = "minimal";
      protobuf.Writer = require_writer();
      protobuf.BufferWriter = require_writer_buffer();
      protobuf.Reader = require_reader();
      protobuf.BufferReader = require_reader_buffer();
      protobuf.util = require_minimal();
      protobuf.rpc = require_rpc();
      protobuf.roots = require_roots();
      protobuf.configure = configure;
      function configure() {
        protobuf.util._configure();
        protobuf.Writer._configure(protobuf.BufferWriter);
        protobuf.Reader._configure(protobuf.BufferReader);
      }
      configure();
    }
  });

  // node_modules/cosmjs-types/node_modules/protobufjs/minimal.js
  var require_minimal2 = __commonJS({
    "node_modules/cosmjs-types/node_modules/protobufjs/minimal.js"(exports2, module2) {
      "use strict";
      module2.exports = require_index_minimal();
    }
  });

  // node_modules/cosmjs-types/google/protobuf/any.js
  var require_any = __commonJS({
    "node_modules/cosmjs-types/google/protobuf/any.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.Any = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      exports2.protobufPackage = "google.protobuf";
      var baseAny = { typeUrl: "" };
      exports2.Any = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.typeUrl !== "") {
            writer.uint32(10).string(message.typeUrl);
          }
          if (message.value.length !== 0) {
            writer.uint32(18).bytes(message.value);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseAny);
          message.value = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.typeUrl = reader.string();
                break;
              case 2:
                message.value = reader.bytes();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseAny);
          message.typeUrl = object.typeUrl !== void 0 && object.typeUrl !== null ? String(object.typeUrl) : "";
          message.value = object.value !== void 0 && object.value !== null ? bytesFromBase64(object.value) : new Uint8Array();
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.typeUrl !== void 0 && (obj.typeUrl = message.typeUrl);
          message.value !== void 0 && (obj.value = base64FromBytes(message.value !== void 0 ? message.value : new Uint8Array()));
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseAny);
          message.typeUrl = (_a = object.typeUrl) !== null && _a !== void 0 ? _a : "";
          message.value = (_b = object.value) !== null && _b !== void 0 ? _b : new Uint8Array();
          return message;
        }
      };
      var globalThis2 = (() => {
        if (typeof globalThis2 !== "undefined")
          return globalThis2;
        if (typeof self !== "undefined")
          return self;
        if (typeof window !== "undefined")
          return window;
        if (typeof global !== "undefined")
          return global;
        throw "Unable to locate global object";
      })();
      var atob2 = globalThis2.atob || ((b64) => globalThis2.Buffer.from(b64, "base64").toString("binary"));
      function bytesFromBase64(b64) {
        const bin = atob2(b64);
        const arr = new Uint8Array(bin.length);
        for (let i = 0; i < bin.length; ++i) {
          arr[i] = bin.charCodeAt(i);
        }
        return arr;
      }
      var btoa2 = globalThis2.btoa || ((bin) => globalThis2.Buffer.from(bin, "binary").toString("base64"));
      function base64FromBytes(arr) {
        const bin = [];
        for (const byte of arr) {
          bin.push(String.fromCharCode(byte));
        }
        return btoa2(bin.join(""));
      }
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/cosmjs-types/cosmos/crypto/multisig/v1beta1/multisig.js
  var require_multisig = __commonJS({
    "node_modules/cosmjs-types/cosmos/crypto/multisig/v1beta1/multisig.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.CompactBitArray = exports2.MultiSignature = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      exports2.protobufPackage = "cosmos.crypto.multisig.v1beta1";
      var baseMultiSignature = {};
      exports2.MultiSignature = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.signatures) {
            writer.uint32(10).bytes(v);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMultiSignature);
          message.signatures = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.signatures.push(reader.bytes());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseMultiSignature);
          message.signatures = ((_a = object.signatures) !== null && _a !== void 0 ? _a : []).map((e) => bytesFromBase64(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.signatures) {
            obj.signatures = message.signatures.map((e) => base64FromBytes(e !== void 0 ? e : new Uint8Array()));
          } else {
            obj.signatures = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseMultiSignature);
          message.signatures = ((_a = object.signatures) === null || _a === void 0 ? void 0 : _a.map((e) => e)) || [];
          return message;
        }
      };
      var baseCompactBitArray = { extraBitsStored: 0 };
      exports2.CompactBitArray = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.extraBitsStored !== 0) {
            writer.uint32(8).uint32(message.extraBitsStored);
          }
          if (message.elems.length !== 0) {
            writer.uint32(18).bytes(message.elems);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseCompactBitArray);
          message.elems = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.extraBitsStored = reader.uint32();
                break;
              case 2:
                message.elems = reader.bytes();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseCompactBitArray);
          message.extraBitsStored = object.extraBitsStored !== void 0 && object.extraBitsStored !== null ? Number(object.extraBitsStored) : 0;
          message.elems = object.elems !== void 0 && object.elems !== null ? bytesFromBase64(object.elems) : new Uint8Array();
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.extraBitsStored !== void 0 && (obj.extraBitsStored = message.extraBitsStored);
          message.elems !== void 0 && (obj.elems = base64FromBytes(message.elems !== void 0 ? message.elems : new Uint8Array()));
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseCompactBitArray);
          message.extraBitsStored = (_a = object.extraBitsStored) !== null && _a !== void 0 ? _a : 0;
          message.elems = (_b = object.elems) !== null && _b !== void 0 ? _b : new Uint8Array();
          return message;
        }
      };
      var globalThis2 = (() => {
        if (typeof globalThis2 !== "undefined")
          return globalThis2;
        if (typeof self !== "undefined")
          return self;
        if (typeof window !== "undefined")
          return window;
        if (typeof global !== "undefined")
          return global;
        throw "Unable to locate global object";
      })();
      var atob2 = globalThis2.atob || ((b64) => globalThis2.Buffer.from(b64, "base64").toString("binary"));
      function bytesFromBase64(b64) {
        const bin = atob2(b64);
        const arr = new Uint8Array(bin.length);
        for (let i = 0; i < bin.length; ++i) {
          arr[i] = bin.charCodeAt(i);
        }
        return arr;
      }
      var btoa2 = globalThis2.btoa || ((bin) => globalThis2.Buffer.from(bin, "binary").toString("base64"));
      function base64FromBytes(arr) {
        const bin = [];
        for (const byte of arr) {
          bin.push(String.fromCharCode(byte));
        }
        return btoa2(bin.join(""));
      }
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/cosmjs-types/cosmos/tx/signing/v1beta1/signing.js
  var require_signing = __commonJS({
    "node_modules/cosmjs-types/cosmos/tx/signing/v1beta1/signing.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.SignatureDescriptor_Data_Multi = exports2.SignatureDescriptor_Data_Single = exports2.SignatureDescriptor_Data = exports2.SignatureDescriptor = exports2.SignatureDescriptors = exports2.signModeToJSON = exports2.signModeFromJSON = exports2.SignMode = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var any_1 = require_any();
      var multisig_1 = require_multisig();
      exports2.protobufPackage = "cosmos.tx.signing.v1beta1";
      var SignMode;
      (function(SignMode2) {
        SignMode2[SignMode2["SIGN_MODE_UNSPECIFIED"] = 0] = "SIGN_MODE_UNSPECIFIED";
        SignMode2[SignMode2["SIGN_MODE_DIRECT"] = 1] = "SIGN_MODE_DIRECT";
        SignMode2[SignMode2["SIGN_MODE_TEXTUAL"] = 2] = "SIGN_MODE_TEXTUAL";
        SignMode2[SignMode2["SIGN_MODE_LEGACY_AMINO_JSON"] = 127] = "SIGN_MODE_LEGACY_AMINO_JSON";
        SignMode2[SignMode2["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
      })(SignMode = exports2.SignMode || (exports2.SignMode = {}));
      function signModeFromJSON(object) {
        switch (object) {
          case 0:
          case "SIGN_MODE_UNSPECIFIED":
            return SignMode.SIGN_MODE_UNSPECIFIED;
          case 1:
          case "SIGN_MODE_DIRECT":
            return SignMode.SIGN_MODE_DIRECT;
          case 2:
          case "SIGN_MODE_TEXTUAL":
            return SignMode.SIGN_MODE_TEXTUAL;
          case 127:
          case "SIGN_MODE_LEGACY_AMINO_JSON":
            return SignMode.SIGN_MODE_LEGACY_AMINO_JSON;
          case -1:
          case "UNRECOGNIZED":
          default:
            return SignMode.UNRECOGNIZED;
        }
      }
      exports2.signModeFromJSON = signModeFromJSON;
      function signModeToJSON(object) {
        switch (object) {
          case SignMode.SIGN_MODE_UNSPECIFIED:
            return "SIGN_MODE_UNSPECIFIED";
          case SignMode.SIGN_MODE_DIRECT:
            return "SIGN_MODE_DIRECT";
          case SignMode.SIGN_MODE_TEXTUAL:
            return "SIGN_MODE_TEXTUAL";
          case SignMode.SIGN_MODE_LEGACY_AMINO_JSON:
            return "SIGN_MODE_LEGACY_AMINO_JSON";
          default:
            return "UNKNOWN";
        }
      }
      exports2.signModeToJSON = signModeToJSON;
      var baseSignatureDescriptors = {};
      exports2.SignatureDescriptors = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.signatures) {
            exports2.SignatureDescriptor.encode(v, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseSignatureDescriptors);
          message.signatures = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.signatures.push(exports2.SignatureDescriptor.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseSignatureDescriptors);
          message.signatures = ((_a = object.signatures) !== null && _a !== void 0 ? _a : []).map((e) => exports2.SignatureDescriptor.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.signatures) {
            obj.signatures = message.signatures.map((e) => e ? exports2.SignatureDescriptor.toJSON(e) : void 0);
          } else {
            obj.signatures = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseSignatureDescriptors);
          message.signatures = ((_a = object.signatures) === null || _a === void 0 ? void 0 : _a.map((e) => exports2.SignatureDescriptor.fromPartial(e))) || [];
          return message;
        }
      };
      var baseSignatureDescriptor = { sequence: long_1.default.UZERO };
      exports2.SignatureDescriptor = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.publicKey !== void 0) {
            any_1.Any.encode(message.publicKey, writer.uint32(10).fork()).ldelim();
          }
          if (message.data !== void 0) {
            exports2.SignatureDescriptor_Data.encode(message.data, writer.uint32(18).fork()).ldelim();
          }
          if (!message.sequence.isZero()) {
            writer.uint32(24).uint64(message.sequence);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseSignatureDescriptor);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.publicKey = any_1.Any.decode(reader, reader.uint32());
                break;
              case 2:
                message.data = exports2.SignatureDescriptor_Data.decode(reader, reader.uint32());
                break;
              case 3:
                message.sequence = reader.uint64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseSignatureDescriptor);
          message.publicKey = object.publicKey !== void 0 && object.publicKey !== null ? any_1.Any.fromJSON(object.publicKey) : void 0;
          message.data = object.data !== void 0 && object.data !== null ? exports2.SignatureDescriptor_Data.fromJSON(object.data) : void 0;
          message.sequence = object.sequence !== void 0 && object.sequence !== null ? long_1.default.fromString(object.sequence) : long_1.default.UZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.publicKey !== void 0 && (obj.publicKey = message.publicKey ? any_1.Any.toJSON(message.publicKey) : void 0);
          message.data !== void 0 && (obj.data = message.data ? exports2.SignatureDescriptor_Data.toJSON(message.data) : void 0);
          message.sequence !== void 0 && (obj.sequence = (message.sequence || long_1.default.UZERO).toString());
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseSignatureDescriptor);
          message.publicKey = object.publicKey !== void 0 && object.publicKey !== null ? any_1.Any.fromPartial(object.publicKey) : void 0;
          message.data = object.data !== void 0 && object.data !== null ? exports2.SignatureDescriptor_Data.fromPartial(object.data) : void 0;
          message.sequence = object.sequence !== void 0 && object.sequence !== null ? long_1.default.fromValue(object.sequence) : long_1.default.UZERO;
          return message;
        }
      };
      var baseSignatureDescriptor_Data = {};
      exports2.SignatureDescriptor_Data = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.single !== void 0) {
            exports2.SignatureDescriptor_Data_Single.encode(message.single, writer.uint32(10).fork()).ldelim();
          }
          if (message.multi !== void 0) {
            exports2.SignatureDescriptor_Data_Multi.encode(message.multi, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseSignatureDescriptor_Data);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.single = exports2.SignatureDescriptor_Data_Single.decode(reader, reader.uint32());
                break;
              case 2:
                message.multi = exports2.SignatureDescriptor_Data_Multi.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseSignatureDescriptor_Data);
          message.single = object.single !== void 0 && object.single !== null ? exports2.SignatureDescriptor_Data_Single.fromJSON(object.single) : void 0;
          message.multi = object.multi !== void 0 && object.multi !== null ? exports2.SignatureDescriptor_Data_Multi.fromJSON(object.multi) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.single !== void 0 && (obj.single = message.single ? exports2.SignatureDescriptor_Data_Single.toJSON(message.single) : void 0);
          message.multi !== void 0 && (obj.multi = message.multi ? exports2.SignatureDescriptor_Data_Multi.toJSON(message.multi) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseSignatureDescriptor_Data);
          message.single = object.single !== void 0 && object.single !== null ? exports2.SignatureDescriptor_Data_Single.fromPartial(object.single) : void 0;
          message.multi = object.multi !== void 0 && object.multi !== null ? exports2.SignatureDescriptor_Data_Multi.fromPartial(object.multi) : void 0;
          return message;
        }
      };
      var baseSignatureDescriptor_Data_Single = { mode: 0 };
      exports2.SignatureDescriptor_Data_Single = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.mode !== 0) {
            writer.uint32(8).int32(message.mode);
          }
          if (message.signature.length !== 0) {
            writer.uint32(18).bytes(message.signature);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseSignatureDescriptor_Data_Single);
          message.signature = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.mode = reader.int32();
                break;
              case 2:
                message.signature = reader.bytes();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseSignatureDescriptor_Data_Single);
          message.mode = object.mode !== void 0 && object.mode !== null ? signModeFromJSON(object.mode) : 0;
          message.signature = object.signature !== void 0 && object.signature !== null ? bytesFromBase64(object.signature) : new Uint8Array();
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.mode !== void 0 && (obj.mode = signModeToJSON(message.mode));
          message.signature !== void 0 && (obj.signature = base64FromBytes(message.signature !== void 0 ? message.signature : new Uint8Array()));
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseSignatureDescriptor_Data_Single);
          message.mode = (_a = object.mode) !== null && _a !== void 0 ? _a : 0;
          message.signature = (_b = object.signature) !== null && _b !== void 0 ? _b : new Uint8Array();
          return message;
        }
      };
      var baseSignatureDescriptor_Data_Multi = {};
      exports2.SignatureDescriptor_Data_Multi = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.bitarray !== void 0) {
            multisig_1.CompactBitArray.encode(message.bitarray, writer.uint32(10).fork()).ldelim();
          }
          for (const v of message.signatures) {
            exports2.SignatureDescriptor_Data.encode(v, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseSignatureDescriptor_Data_Multi);
          message.signatures = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.bitarray = multisig_1.CompactBitArray.decode(reader, reader.uint32());
                break;
              case 2:
                message.signatures.push(exports2.SignatureDescriptor_Data.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseSignatureDescriptor_Data_Multi);
          message.bitarray = object.bitarray !== void 0 && object.bitarray !== null ? multisig_1.CompactBitArray.fromJSON(object.bitarray) : void 0;
          message.signatures = ((_a = object.signatures) !== null && _a !== void 0 ? _a : []).map((e) => exports2.SignatureDescriptor_Data.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.bitarray !== void 0 && (obj.bitarray = message.bitarray ? multisig_1.CompactBitArray.toJSON(message.bitarray) : void 0);
          if (message.signatures) {
            obj.signatures = message.signatures.map((e) => e ? exports2.SignatureDescriptor_Data.toJSON(e) : void 0);
          } else {
            obj.signatures = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseSignatureDescriptor_Data_Multi);
          message.bitarray = object.bitarray !== void 0 && object.bitarray !== null ? multisig_1.CompactBitArray.fromPartial(object.bitarray) : void 0;
          message.signatures = ((_a = object.signatures) === null || _a === void 0 ? void 0 : _a.map((e) => exports2.SignatureDescriptor_Data.fromPartial(e))) || [];
          return message;
        }
      };
      var globalThis2 = (() => {
        if (typeof globalThis2 !== "undefined")
          return globalThis2;
        if (typeof self !== "undefined")
          return self;
        if (typeof window !== "undefined")
          return window;
        if (typeof global !== "undefined")
          return global;
        throw "Unable to locate global object";
      })();
      var atob2 = globalThis2.atob || ((b64) => globalThis2.Buffer.from(b64, "base64").toString("binary"));
      function bytesFromBase64(b64) {
        const bin = atob2(b64);
        const arr = new Uint8Array(bin.length);
        for (let i = 0; i < bin.length; ++i) {
          arr[i] = bin.charCodeAt(i);
        }
        return arr;
      }
      var btoa2 = globalThis2.btoa || ((bin) => globalThis2.Buffer.from(bin, "binary").toString("base64"));
      function base64FromBytes(arr) {
        const bin = [];
        for (const byte of arr) {
          bin.push(String.fromCharCode(byte));
        }
        return btoa2(bin.join(""));
      }
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/cosmjs-types/cosmos/base/v1beta1/coin.js
  var require_coin = __commonJS({
    "node_modules/cosmjs-types/cosmos/base/v1beta1/coin.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.DecProto = exports2.IntProto = exports2.DecCoin = exports2.Coin = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      exports2.protobufPackage = "cosmos.base.v1beta1";
      var baseCoin = { denom: "", amount: "" };
      exports2.Coin = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.denom !== "") {
            writer.uint32(10).string(message.denom);
          }
          if (message.amount !== "") {
            writer.uint32(18).string(message.amount);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseCoin);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.denom = reader.string();
                break;
              case 2:
                message.amount = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseCoin);
          message.denom = object.denom !== void 0 && object.denom !== null ? String(object.denom) : "";
          message.amount = object.amount !== void 0 && object.amount !== null ? String(object.amount) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.denom !== void 0 && (obj.denom = message.denom);
          message.amount !== void 0 && (obj.amount = message.amount);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseCoin);
          message.denom = (_a = object.denom) !== null && _a !== void 0 ? _a : "";
          message.amount = (_b = object.amount) !== null && _b !== void 0 ? _b : "";
          return message;
        }
      };
      var baseDecCoin = { denom: "", amount: "" };
      exports2.DecCoin = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.denom !== "") {
            writer.uint32(10).string(message.denom);
          }
          if (message.amount !== "") {
            writer.uint32(18).string(message.amount);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseDecCoin);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.denom = reader.string();
                break;
              case 2:
                message.amount = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseDecCoin);
          message.denom = object.denom !== void 0 && object.denom !== null ? String(object.denom) : "";
          message.amount = object.amount !== void 0 && object.amount !== null ? String(object.amount) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.denom !== void 0 && (obj.denom = message.denom);
          message.amount !== void 0 && (obj.amount = message.amount);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseDecCoin);
          message.denom = (_a = object.denom) !== null && _a !== void 0 ? _a : "";
          message.amount = (_b = object.amount) !== null && _b !== void 0 ? _b : "";
          return message;
        }
      };
      var baseIntProto = { int: "" };
      exports2.IntProto = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.int !== "") {
            writer.uint32(10).string(message.int);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseIntProto);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.int = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseIntProto);
          message.int = object.int !== void 0 && object.int !== null ? String(object.int) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.int !== void 0 && (obj.int = message.int);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseIntProto);
          message.int = (_a = object.int) !== null && _a !== void 0 ? _a : "";
          return message;
        }
      };
      var baseDecProto = { dec: "" };
      exports2.DecProto = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.dec !== "") {
            writer.uint32(10).string(message.dec);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseDecProto);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.dec = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseDecProto);
          message.dec = object.dec !== void 0 && object.dec !== null ? String(object.dec) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.dec !== void 0 && (obj.dec = message.dec);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseDecProto);
          message.dec = (_a = object.dec) !== null && _a !== void 0 ? _a : "";
          return message;
        }
      };
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/cosmjs-types/cosmos/tx/v1beta1/tx.js
  var require_tx = __commonJS({
    "node_modules/cosmjs-types/cosmos/tx/v1beta1/tx.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.Fee = exports2.ModeInfo_Multi = exports2.ModeInfo_Single = exports2.ModeInfo = exports2.SignerInfo = exports2.AuthInfo = exports2.TxBody = exports2.SignDoc = exports2.TxRaw = exports2.Tx = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var any_1 = require_any();
      var signing_1 = require_signing();
      var multisig_1 = require_multisig();
      var coin_1 = require_coin();
      exports2.protobufPackage = "cosmos.tx.v1beta1";
      var baseTx = {};
      exports2.Tx = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.body !== void 0) {
            exports2.TxBody.encode(message.body, writer.uint32(10).fork()).ldelim();
          }
          if (message.authInfo !== void 0) {
            exports2.AuthInfo.encode(message.authInfo, writer.uint32(18).fork()).ldelim();
          }
          for (const v of message.signatures) {
            writer.uint32(26).bytes(v);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseTx);
          message.signatures = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.body = exports2.TxBody.decode(reader, reader.uint32());
                break;
              case 2:
                message.authInfo = exports2.AuthInfo.decode(reader, reader.uint32());
                break;
              case 3:
                message.signatures.push(reader.bytes());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseTx);
          message.body = object.body !== void 0 && object.body !== null ? exports2.TxBody.fromJSON(object.body) : void 0;
          message.authInfo = object.authInfo !== void 0 && object.authInfo !== null ? exports2.AuthInfo.fromJSON(object.authInfo) : void 0;
          message.signatures = ((_a = object.signatures) !== null && _a !== void 0 ? _a : []).map((e) => bytesFromBase64(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.body !== void 0 && (obj.body = message.body ? exports2.TxBody.toJSON(message.body) : void 0);
          message.authInfo !== void 0 && (obj.authInfo = message.authInfo ? exports2.AuthInfo.toJSON(message.authInfo) : void 0);
          if (message.signatures) {
            obj.signatures = message.signatures.map((e) => base64FromBytes(e !== void 0 ? e : new Uint8Array()));
          } else {
            obj.signatures = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseTx);
          message.body = object.body !== void 0 && object.body !== null ? exports2.TxBody.fromPartial(object.body) : void 0;
          message.authInfo = object.authInfo !== void 0 && object.authInfo !== null ? exports2.AuthInfo.fromPartial(object.authInfo) : void 0;
          message.signatures = ((_a = object.signatures) === null || _a === void 0 ? void 0 : _a.map((e) => e)) || [];
          return message;
        }
      };
      var baseTxRaw = {};
      exports2.TxRaw = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.bodyBytes.length !== 0) {
            writer.uint32(10).bytes(message.bodyBytes);
          }
          if (message.authInfoBytes.length !== 0) {
            writer.uint32(18).bytes(message.authInfoBytes);
          }
          for (const v of message.signatures) {
            writer.uint32(26).bytes(v);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseTxRaw);
          message.signatures = [];
          message.bodyBytes = new Uint8Array();
          message.authInfoBytes = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.bodyBytes = reader.bytes();
                break;
              case 2:
                message.authInfoBytes = reader.bytes();
                break;
              case 3:
                message.signatures.push(reader.bytes());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseTxRaw);
          message.bodyBytes = object.bodyBytes !== void 0 && object.bodyBytes !== null ? bytesFromBase64(object.bodyBytes) : new Uint8Array();
          message.authInfoBytes = object.authInfoBytes !== void 0 && object.authInfoBytes !== null ? bytesFromBase64(object.authInfoBytes) : new Uint8Array();
          message.signatures = ((_a = object.signatures) !== null && _a !== void 0 ? _a : []).map((e) => bytesFromBase64(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.bodyBytes !== void 0 && (obj.bodyBytes = base64FromBytes(message.bodyBytes !== void 0 ? message.bodyBytes : new Uint8Array()));
          message.authInfoBytes !== void 0 && (obj.authInfoBytes = base64FromBytes(message.authInfoBytes !== void 0 ? message.authInfoBytes : new Uint8Array()));
          if (message.signatures) {
            obj.signatures = message.signatures.map((e) => base64FromBytes(e !== void 0 ? e : new Uint8Array()));
          } else {
            obj.signatures = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseTxRaw);
          message.bodyBytes = (_a = object.bodyBytes) !== null && _a !== void 0 ? _a : new Uint8Array();
          message.authInfoBytes = (_b = object.authInfoBytes) !== null && _b !== void 0 ? _b : new Uint8Array();
          message.signatures = ((_c = object.signatures) === null || _c === void 0 ? void 0 : _c.map((e) => e)) || [];
          return message;
        }
      };
      var baseSignDoc = { chainId: "", accountNumber: long_1.default.UZERO };
      exports2.SignDoc = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.bodyBytes.length !== 0) {
            writer.uint32(10).bytes(message.bodyBytes);
          }
          if (message.authInfoBytes.length !== 0) {
            writer.uint32(18).bytes(message.authInfoBytes);
          }
          if (message.chainId !== "") {
            writer.uint32(26).string(message.chainId);
          }
          if (!message.accountNumber.isZero()) {
            writer.uint32(32).uint64(message.accountNumber);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseSignDoc);
          message.bodyBytes = new Uint8Array();
          message.authInfoBytes = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.bodyBytes = reader.bytes();
                break;
              case 2:
                message.authInfoBytes = reader.bytes();
                break;
              case 3:
                message.chainId = reader.string();
                break;
              case 4:
                message.accountNumber = reader.uint64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseSignDoc);
          message.bodyBytes = object.bodyBytes !== void 0 && object.bodyBytes !== null ? bytesFromBase64(object.bodyBytes) : new Uint8Array();
          message.authInfoBytes = object.authInfoBytes !== void 0 && object.authInfoBytes !== null ? bytesFromBase64(object.authInfoBytes) : new Uint8Array();
          message.chainId = object.chainId !== void 0 && object.chainId !== null ? String(object.chainId) : "";
          message.accountNumber = object.accountNumber !== void 0 && object.accountNumber !== null ? long_1.default.fromString(object.accountNumber) : long_1.default.UZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.bodyBytes !== void 0 && (obj.bodyBytes = base64FromBytes(message.bodyBytes !== void 0 ? message.bodyBytes : new Uint8Array()));
          message.authInfoBytes !== void 0 && (obj.authInfoBytes = base64FromBytes(message.authInfoBytes !== void 0 ? message.authInfoBytes : new Uint8Array()));
          message.chainId !== void 0 && (obj.chainId = message.chainId);
          message.accountNumber !== void 0 && (obj.accountNumber = (message.accountNumber || long_1.default.UZERO).toString());
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseSignDoc);
          message.bodyBytes = (_a = object.bodyBytes) !== null && _a !== void 0 ? _a : new Uint8Array();
          message.authInfoBytes = (_b = object.authInfoBytes) !== null && _b !== void 0 ? _b : new Uint8Array();
          message.chainId = (_c = object.chainId) !== null && _c !== void 0 ? _c : "";
          message.accountNumber = object.accountNumber !== void 0 && object.accountNumber !== null ? long_1.default.fromValue(object.accountNumber) : long_1.default.UZERO;
          return message;
        }
      };
      var baseTxBody = { memo: "", timeoutHeight: long_1.default.UZERO };
      exports2.TxBody = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.messages) {
            any_1.Any.encode(v, writer.uint32(10).fork()).ldelim();
          }
          if (message.memo !== "") {
            writer.uint32(18).string(message.memo);
          }
          if (!message.timeoutHeight.isZero()) {
            writer.uint32(24).uint64(message.timeoutHeight);
          }
          for (const v of message.extensionOptions) {
            any_1.Any.encode(v, writer.uint32(8186).fork()).ldelim();
          }
          for (const v of message.nonCriticalExtensionOptions) {
            any_1.Any.encode(v, writer.uint32(16378).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseTxBody);
          message.messages = [];
          message.extensionOptions = [];
          message.nonCriticalExtensionOptions = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.messages.push(any_1.Any.decode(reader, reader.uint32()));
                break;
              case 2:
                message.memo = reader.string();
                break;
              case 3:
                message.timeoutHeight = reader.uint64();
                break;
              case 1023:
                message.extensionOptions.push(any_1.Any.decode(reader, reader.uint32()));
                break;
              case 2047:
                message.nonCriticalExtensionOptions.push(any_1.Any.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseTxBody);
          message.messages = ((_a = object.messages) !== null && _a !== void 0 ? _a : []).map((e) => any_1.Any.fromJSON(e));
          message.memo = object.memo !== void 0 && object.memo !== null ? String(object.memo) : "";
          message.timeoutHeight = object.timeoutHeight !== void 0 && object.timeoutHeight !== null ? long_1.default.fromString(object.timeoutHeight) : long_1.default.UZERO;
          message.extensionOptions = ((_b = object.extensionOptions) !== null && _b !== void 0 ? _b : []).map((e) => any_1.Any.fromJSON(e));
          message.nonCriticalExtensionOptions = ((_c = object.nonCriticalExtensionOptions) !== null && _c !== void 0 ? _c : []).map((e) => any_1.Any.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.messages) {
            obj.messages = message.messages.map((e) => e ? any_1.Any.toJSON(e) : void 0);
          } else {
            obj.messages = [];
          }
          message.memo !== void 0 && (obj.memo = message.memo);
          message.timeoutHeight !== void 0 && (obj.timeoutHeight = (message.timeoutHeight || long_1.default.UZERO).toString());
          if (message.extensionOptions) {
            obj.extensionOptions = message.extensionOptions.map((e) => e ? any_1.Any.toJSON(e) : void 0);
          } else {
            obj.extensionOptions = [];
          }
          if (message.nonCriticalExtensionOptions) {
            obj.nonCriticalExtensionOptions = message.nonCriticalExtensionOptions.map((e) => e ? any_1.Any.toJSON(e) : void 0);
          } else {
            obj.nonCriticalExtensionOptions = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c, _d;
          const message = Object.assign({}, baseTxBody);
          message.messages = ((_a = object.messages) === null || _a === void 0 ? void 0 : _a.map((e) => any_1.Any.fromPartial(e))) || [];
          message.memo = (_b = object.memo) !== null && _b !== void 0 ? _b : "";
          message.timeoutHeight = object.timeoutHeight !== void 0 && object.timeoutHeight !== null ? long_1.default.fromValue(object.timeoutHeight) : long_1.default.UZERO;
          message.extensionOptions = ((_c = object.extensionOptions) === null || _c === void 0 ? void 0 : _c.map((e) => any_1.Any.fromPartial(e))) || [];
          message.nonCriticalExtensionOptions = ((_d = object.nonCriticalExtensionOptions) === null || _d === void 0 ? void 0 : _d.map((e) => any_1.Any.fromPartial(e))) || [];
          return message;
        }
      };
      var baseAuthInfo = {};
      exports2.AuthInfo = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.signerInfos) {
            exports2.SignerInfo.encode(v, writer.uint32(10).fork()).ldelim();
          }
          if (message.fee !== void 0) {
            exports2.Fee.encode(message.fee, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseAuthInfo);
          message.signerInfos = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.signerInfos.push(exports2.SignerInfo.decode(reader, reader.uint32()));
                break;
              case 2:
                message.fee = exports2.Fee.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseAuthInfo);
          message.signerInfos = ((_a = object.signerInfos) !== null && _a !== void 0 ? _a : []).map((e) => exports2.SignerInfo.fromJSON(e));
          message.fee = object.fee !== void 0 && object.fee !== null ? exports2.Fee.fromJSON(object.fee) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.signerInfos) {
            obj.signerInfos = message.signerInfos.map((e) => e ? exports2.SignerInfo.toJSON(e) : void 0);
          } else {
            obj.signerInfos = [];
          }
          message.fee !== void 0 && (obj.fee = message.fee ? exports2.Fee.toJSON(message.fee) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseAuthInfo);
          message.signerInfos = ((_a = object.signerInfos) === null || _a === void 0 ? void 0 : _a.map((e) => exports2.SignerInfo.fromPartial(e))) || [];
          message.fee = object.fee !== void 0 && object.fee !== null ? exports2.Fee.fromPartial(object.fee) : void 0;
          return message;
        }
      };
      var baseSignerInfo = { sequence: long_1.default.UZERO };
      exports2.SignerInfo = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.publicKey !== void 0) {
            any_1.Any.encode(message.publicKey, writer.uint32(10).fork()).ldelim();
          }
          if (message.modeInfo !== void 0) {
            exports2.ModeInfo.encode(message.modeInfo, writer.uint32(18).fork()).ldelim();
          }
          if (!message.sequence.isZero()) {
            writer.uint32(24).uint64(message.sequence);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseSignerInfo);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.publicKey = any_1.Any.decode(reader, reader.uint32());
                break;
              case 2:
                message.modeInfo = exports2.ModeInfo.decode(reader, reader.uint32());
                break;
              case 3:
                message.sequence = reader.uint64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseSignerInfo);
          message.publicKey = object.publicKey !== void 0 && object.publicKey !== null ? any_1.Any.fromJSON(object.publicKey) : void 0;
          message.modeInfo = object.modeInfo !== void 0 && object.modeInfo !== null ? exports2.ModeInfo.fromJSON(object.modeInfo) : void 0;
          message.sequence = object.sequence !== void 0 && object.sequence !== null ? long_1.default.fromString(object.sequence) : long_1.default.UZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.publicKey !== void 0 && (obj.publicKey = message.publicKey ? any_1.Any.toJSON(message.publicKey) : void 0);
          message.modeInfo !== void 0 && (obj.modeInfo = message.modeInfo ? exports2.ModeInfo.toJSON(message.modeInfo) : void 0);
          message.sequence !== void 0 && (obj.sequence = (message.sequence || long_1.default.UZERO).toString());
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseSignerInfo);
          message.publicKey = object.publicKey !== void 0 && object.publicKey !== null ? any_1.Any.fromPartial(object.publicKey) : void 0;
          message.modeInfo = object.modeInfo !== void 0 && object.modeInfo !== null ? exports2.ModeInfo.fromPartial(object.modeInfo) : void 0;
          message.sequence = object.sequence !== void 0 && object.sequence !== null ? long_1.default.fromValue(object.sequence) : long_1.default.UZERO;
          return message;
        }
      };
      var baseModeInfo = {};
      exports2.ModeInfo = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.single !== void 0) {
            exports2.ModeInfo_Single.encode(message.single, writer.uint32(10).fork()).ldelim();
          }
          if (message.multi !== void 0) {
            exports2.ModeInfo_Multi.encode(message.multi, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseModeInfo);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.single = exports2.ModeInfo_Single.decode(reader, reader.uint32());
                break;
              case 2:
                message.multi = exports2.ModeInfo_Multi.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseModeInfo);
          message.single = object.single !== void 0 && object.single !== null ? exports2.ModeInfo_Single.fromJSON(object.single) : void 0;
          message.multi = object.multi !== void 0 && object.multi !== null ? exports2.ModeInfo_Multi.fromJSON(object.multi) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.single !== void 0 && (obj.single = message.single ? exports2.ModeInfo_Single.toJSON(message.single) : void 0);
          message.multi !== void 0 && (obj.multi = message.multi ? exports2.ModeInfo_Multi.toJSON(message.multi) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseModeInfo);
          message.single = object.single !== void 0 && object.single !== null ? exports2.ModeInfo_Single.fromPartial(object.single) : void 0;
          message.multi = object.multi !== void 0 && object.multi !== null ? exports2.ModeInfo_Multi.fromPartial(object.multi) : void 0;
          return message;
        }
      };
      var baseModeInfo_Single = { mode: 0 };
      exports2.ModeInfo_Single = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.mode !== 0) {
            writer.uint32(8).int32(message.mode);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseModeInfo_Single);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.mode = reader.int32();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseModeInfo_Single);
          message.mode = object.mode !== void 0 && object.mode !== null ? signing_1.signModeFromJSON(object.mode) : 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.mode !== void 0 && (obj.mode = signing_1.signModeToJSON(message.mode));
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseModeInfo_Single);
          message.mode = (_a = object.mode) !== null && _a !== void 0 ? _a : 0;
          return message;
        }
      };
      var baseModeInfo_Multi = {};
      exports2.ModeInfo_Multi = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.bitarray !== void 0) {
            multisig_1.CompactBitArray.encode(message.bitarray, writer.uint32(10).fork()).ldelim();
          }
          for (const v of message.modeInfos) {
            exports2.ModeInfo.encode(v, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseModeInfo_Multi);
          message.modeInfos = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.bitarray = multisig_1.CompactBitArray.decode(reader, reader.uint32());
                break;
              case 2:
                message.modeInfos.push(exports2.ModeInfo.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseModeInfo_Multi);
          message.bitarray = object.bitarray !== void 0 && object.bitarray !== null ? multisig_1.CompactBitArray.fromJSON(object.bitarray) : void 0;
          message.modeInfos = ((_a = object.modeInfos) !== null && _a !== void 0 ? _a : []).map((e) => exports2.ModeInfo.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.bitarray !== void 0 && (obj.bitarray = message.bitarray ? multisig_1.CompactBitArray.toJSON(message.bitarray) : void 0);
          if (message.modeInfos) {
            obj.modeInfos = message.modeInfos.map((e) => e ? exports2.ModeInfo.toJSON(e) : void 0);
          } else {
            obj.modeInfos = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseModeInfo_Multi);
          message.bitarray = object.bitarray !== void 0 && object.bitarray !== null ? multisig_1.CompactBitArray.fromPartial(object.bitarray) : void 0;
          message.modeInfos = ((_a = object.modeInfos) === null || _a === void 0 ? void 0 : _a.map((e) => exports2.ModeInfo.fromPartial(e))) || [];
          return message;
        }
      };
      var baseFee = { gasLimit: long_1.default.UZERO, payer: "", granter: "" };
      exports2.Fee = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.amount) {
            coin_1.Coin.encode(v, writer.uint32(10).fork()).ldelim();
          }
          if (!message.gasLimit.isZero()) {
            writer.uint32(16).uint64(message.gasLimit);
          }
          if (message.payer !== "") {
            writer.uint32(26).string(message.payer);
          }
          if (message.granter !== "") {
            writer.uint32(34).string(message.granter);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseFee);
          message.amount = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.amount.push(coin_1.Coin.decode(reader, reader.uint32()));
                break;
              case 2:
                message.gasLimit = reader.uint64();
                break;
              case 3:
                message.payer = reader.string();
                break;
              case 4:
                message.granter = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseFee);
          message.amount = ((_a = object.amount) !== null && _a !== void 0 ? _a : []).map((e) => coin_1.Coin.fromJSON(e));
          message.gasLimit = object.gasLimit !== void 0 && object.gasLimit !== null ? long_1.default.fromString(object.gasLimit) : long_1.default.UZERO;
          message.payer = object.payer !== void 0 && object.payer !== null ? String(object.payer) : "";
          message.granter = object.granter !== void 0 && object.granter !== null ? String(object.granter) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.amount) {
            obj.amount = message.amount.map((e) => e ? coin_1.Coin.toJSON(e) : void 0);
          } else {
            obj.amount = [];
          }
          message.gasLimit !== void 0 && (obj.gasLimit = (message.gasLimit || long_1.default.UZERO).toString());
          message.payer !== void 0 && (obj.payer = message.payer);
          message.granter !== void 0 && (obj.granter = message.granter);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseFee);
          message.amount = ((_a = object.amount) === null || _a === void 0 ? void 0 : _a.map((e) => coin_1.Coin.fromPartial(e))) || [];
          message.gasLimit = object.gasLimit !== void 0 && object.gasLimit !== null ? long_1.default.fromValue(object.gasLimit) : long_1.default.UZERO;
          message.payer = (_b = object.payer) !== null && _b !== void 0 ? _b : "";
          message.granter = (_c = object.granter) !== null && _c !== void 0 ? _c : "";
          return message;
        }
      };
      var globalThis2 = (() => {
        if (typeof globalThis2 !== "undefined")
          return globalThis2;
        if (typeof self !== "undefined")
          return self;
        if (typeof window !== "undefined")
          return window;
        if (typeof global !== "undefined")
          return global;
        throw "Unable to locate global object";
      })();
      var atob2 = globalThis2.atob || ((b64) => globalThis2.Buffer.from(b64, "base64").toString("binary"));
      function bytesFromBase64(b64) {
        const bin = atob2(b64);
        const arr = new Uint8Array(bin.length);
        for (let i = 0; i < bin.length; ++i) {
          arr[i] = bin.charCodeAt(i);
        }
        return arr;
      }
      var btoa2 = globalThis2.btoa || ((bin) => globalThis2.Buffer.from(bin, "binary").toString("base64"));
      function base64FromBytes(arr) {
        const bin = [];
        for (const byte of arr) {
          bin.push(String.fromCharCode(byte));
        }
        return btoa2(bin.join(""));
      }
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/@cosmjs/proto-signing/build/decode.js
  var require_decode = __commonJS({
    "node_modules/@cosmjs/proto-signing/build/decode.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.decodeTxRaw = void 0;
      var tx_1 = require_tx();
      function decodeTxRaw(tx) {
        const txRaw = tx_1.TxRaw.decode(tx);
        return {
          authInfo: tx_1.AuthInfo.decode(txRaw.authInfoBytes),
          body: tx_1.TxBody.decode(txRaw.bodyBytes),
          signatures: txRaw.signatures
        };
      }
      exports2.decodeTxRaw = decodeTxRaw;
    }
  });

  // node_modules/@cosmjs/encoding/build/ascii.js
  var require_ascii = __commonJS({
    "node_modules/@cosmjs/encoding/build/ascii.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.fromAscii = exports2.toAscii = void 0;
      function toAscii(input) {
        const toNums = (str) => str.split("").map((x) => {
          const charCode = x.charCodeAt(0);
          if (charCode < 32 || charCode > 126) {
            throw new Error("Cannot encode character that is out of printable ASCII range: " + charCode);
          }
          return charCode;
        });
        return Uint8Array.from(toNums(input));
      }
      exports2.toAscii = toAscii;
      function fromAscii(data) {
        const fromNums = (listOfNumbers) => listOfNumbers.map((x) => {
          if (x < 32 || x > 126) {
            throw new Error("Cannot decode character that is out of printable ASCII range: " + x);
          }
          return String.fromCharCode(x);
        });
        return fromNums(Array.from(data)).join("");
      }
      exports2.fromAscii = fromAscii;
    }
  });

  // node_modules/base64-js/index.js
  var require_base64_js = __commonJS({
    "node_modules/base64-js/index.js"(exports2) {
      "use strict";
      exports2.byteLength = byteLength;
      exports2.toByteArray = toByteArray;
      exports2.fromByteArray = fromByteArray;
      var lookup = [];
      var revLookup = [];
      var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
      var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
      for (i = 0, len = code.length; i < len; ++i) {
        lookup[i] = code[i];
        revLookup[code.charCodeAt(i)] = i;
      }
      var i;
      var len;
      revLookup["-".charCodeAt(0)] = 62;
      revLookup["_".charCodeAt(0)] = 63;
      function getLens(b64) {
        var len2 = b64.length;
        if (len2 % 4 > 0) {
          throw new Error("Invalid string. Length must be a multiple of 4");
        }
        var validLen = b64.indexOf("=");
        if (validLen === -1)
          validLen = len2;
        var placeHoldersLen = validLen === len2 ? 0 : 4 - validLen % 4;
        return [validLen, placeHoldersLen];
      }
      function byteLength(b64) {
        var lens = getLens(b64);
        var validLen = lens[0];
        var placeHoldersLen = lens[1];
        return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
      }
      function _byteLength(b64, validLen, placeHoldersLen) {
        return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
      }
      function toByteArray(b64) {
        var tmp;
        var lens = getLens(b64);
        var validLen = lens[0];
        var placeHoldersLen = lens[1];
        var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
        var curByte = 0;
        var len2 = placeHoldersLen > 0 ? validLen - 4 : validLen;
        var i2;
        for (i2 = 0; i2 < len2; i2 += 4) {
          tmp = revLookup[b64.charCodeAt(i2)] << 18 | revLookup[b64.charCodeAt(i2 + 1)] << 12 | revLookup[b64.charCodeAt(i2 + 2)] << 6 | revLookup[b64.charCodeAt(i2 + 3)];
          arr[curByte++] = tmp >> 16 & 255;
          arr[curByte++] = tmp >> 8 & 255;
          arr[curByte++] = tmp & 255;
        }
        if (placeHoldersLen === 2) {
          tmp = revLookup[b64.charCodeAt(i2)] << 2 | revLookup[b64.charCodeAt(i2 + 1)] >> 4;
          arr[curByte++] = tmp & 255;
        }
        if (placeHoldersLen === 1) {
          tmp = revLookup[b64.charCodeAt(i2)] << 10 | revLookup[b64.charCodeAt(i2 + 1)] << 4 | revLookup[b64.charCodeAt(i2 + 2)] >> 2;
          arr[curByte++] = tmp >> 8 & 255;
          arr[curByte++] = tmp & 255;
        }
        return arr;
      }
      function tripletToBase64(num) {
        return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];
      }
      function encodeChunk(uint8, start2, end) {
        var tmp;
        var output = [];
        for (var i2 = start2; i2 < end; i2 += 3) {
          tmp = (uint8[i2] << 16 & 16711680) + (uint8[i2 + 1] << 8 & 65280) + (uint8[i2 + 2] & 255);
          output.push(tripletToBase64(tmp));
        }
        return output.join("");
      }
      function fromByteArray(uint8) {
        var tmp;
        var len2 = uint8.length;
        var extraBytes = len2 % 3;
        var parts = [];
        var maxChunkLength = 16383;
        for (var i2 = 0, len22 = len2 - extraBytes; i2 < len22; i2 += maxChunkLength) {
          parts.push(encodeChunk(uint8, i2, i2 + maxChunkLength > len22 ? len22 : i2 + maxChunkLength));
        }
        if (extraBytes === 1) {
          tmp = uint8[len2 - 1];
          parts.push(lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "==");
        } else if (extraBytes === 2) {
          tmp = (uint8[len2 - 2] << 8) + uint8[len2 - 1];
          parts.push(lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "=");
        }
        return parts.join("");
      }
    }
  });

  // node_modules/@cosmjs/encoding/build/base64.js
  var require_base642 = __commonJS({
    "node_modules/@cosmjs/encoding/build/base64.js"(exports2) {
      "use strict";
      var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
        if (k2 === void 0)
          k2 = k;
        Object.defineProperty(o, k2, { enumerable: true, get: function() {
          return m[k];
        } });
      } : function(o, m, k, k2) {
        if (k2 === void 0)
          k2 = k;
        o[k2] = m[k];
      });
      var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
        Object.defineProperty(o, "default", { enumerable: true, value: v });
      } : function(o, v) {
        o["default"] = v;
      });
      var __importStar = exports2 && exports2.__importStar || function(mod2) {
        if (mod2 && mod2.__esModule)
          return mod2;
        var result = {};
        if (mod2 != null) {
          for (var k in mod2)
            if (k !== "default" && Object.prototype.hasOwnProperty.call(mod2, k))
              __createBinding(result, mod2, k);
        }
        __setModuleDefault(result, mod2);
        return result;
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.fromBase64 = exports2.toBase64 = void 0;
      var base64js = __importStar(require_base64_js());
      function toBase64(data) {
        return base64js.fromByteArray(data);
      }
      exports2.toBase64 = toBase64;
      function fromBase64(base64String) {
        if (!base64String.match(/^[a-zA-Z0-9+/]*={0,2}$/)) {
          throw new Error("Invalid base64 string format");
        }
        return base64js.toByteArray(base64String);
      }
      exports2.fromBase64 = fromBase64;
    }
  });

  // node_modules/bech32/index.js
  var require_bech32 = __commonJS({
    "node_modules/bech32/index.js"(exports2, module2) {
      "use strict";
      var ALPHABET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
      var ALPHABET_MAP = {};
      for (z = 0; z < ALPHABET.length; z++) {
        x = ALPHABET.charAt(z);
        if (ALPHABET_MAP[x] !== void 0)
          throw new TypeError(x + " is ambiguous");
        ALPHABET_MAP[x] = z;
      }
      var x;
      var z;
      function polymodStep(pre) {
        var b = pre >> 25;
        return (pre & 33554431) << 5 ^ -(b >> 0 & 1) & 996825010 ^ -(b >> 1 & 1) & 642813549 ^ -(b >> 2 & 1) & 513874426 ^ -(b >> 3 & 1) & 1027748829 ^ -(b >> 4 & 1) & 705979059;
      }
      function prefixChk(prefix) {
        var chk = 1;
        for (var i = 0; i < prefix.length; ++i) {
          var c = prefix.charCodeAt(i);
          if (c < 33 || c > 126)
            return "Invalid prefix (" + prefix + ")";
          chk = polymodStep(chk) ^ c >> 5;
        }
        chk = polymodStep(chk);
        for (i = 0; i < prefix.length; ++i) {
          var v = prefix.charCodeAt(i);
          chk = polymodStep(chk) ^ v & 31;
        }
        return chk;
      }
      function encode(prefix, words, LIMIT) {
        LIMIT = LIMIT || 90;
        if (prefix.length + 7 + words.length > LIMIT)
          throw new TypeError("Exceeds length limit");
        prefix = prefix.toLowerCase();
        var chk = prefixChk(prefix);
        if (typeof chk === "string")
          throw new Error(chk);
        var result = prefix + "1";
        for (var i = 0; i < words.length; ++i) {
          var x2 = words[i];
          if (x2 >> 5 !== 0)
            throw new Error("Non 5-bit word");
          chk = polymodStep(chk) ^ x2;
          result += ALPHABET.charAt(x2);
        }
        for (i = 0; i < 6; ++i) {
          chk = polymodStep(chk);
        }
        chk ^= 1;
        for (i = 0; i < 6; ++i) {
          var v = chk >> (5 - i) * 5 & 31;
          result += ALPHABET.charAt(v);
        }
        return result;
      }
      function __decode(str, LIMIT) {
        LIMIT = LIMIT || 90;
        if (str.length < 8)
          return str + " too short";
        if (str.length > LIMIT)
          return "Exceeds length limit";
        var lowered = str.toLowerCase();
        var uppered = str.toUpperCase();
        if (str !== lowered && str !== uppered)
          return "Mixed-case string " + str;
        str = lowered;
        var split = str.lastIndexOf("1");
        if (split === -1)
          return "No separator character for " + str;
        if (split === 0)
          return "Missing prefix for " + str;
        var prefix = str.slice(0, split);
        var wordChars = str.slice(split + 1);
        if (wordChars.length < 6)
          return "Data too short";
        var chk = prefixChk(prefix);
        if (typeof chk === "string")
          return chk;
        var words = [];
        for (var i = 0; i < wordChars.length; ++i) {
          var c = wordChars.charAt(i);
          var v = ALPHABET_MAP[c];
          if (v === void 0)
            return "Unknown character " + c;
          chk = polymodStep(chk) ^ v;
          if (i + 6 >= wordChars.length)
            continue;
          words.push(v);
        }
        if (chk !== 1)
          return "Invalid checksum for " + str;
        return { prefix, words };
      }
      function decodeUnsafe() {
        var res = __decode.apply(null, arguments);
        if (typeof res === "object")
          return res;
      }
      function decode(str) {
        var res = __decode.apply(null, arguments);
        if (typeof res === "object")
          return res;
        throw new Error(res);
      }
      function convert(data, inBits, outBits, pad) {
        var value = 0;
        var bits = 0;
        var maxV = (1 << outBits) - 1;
        var result = [];
        for (var i = 0; i < data.length; ++i) {
          value = value << inBits | data[i];
          bits += inBits;
          while (bits >= outBits) {
            bits -= outBits;
            result.push(value >> bits & maxV);
          }
        }
        if (pad) {
          if (bits > 0) {
            result.push(value << outBits - bits & maxV);
          }
        } else {
          if (bits >= inBits)
            return "Excess padding";
          if (value << outBits - bits & maxV)
            return "Non-zero padding";
        }
        return result;
      }
      function toWordsUnsafe(bytes) {
        var res = convert(bytes, 8, 5, true);
        if (Array.isArray(res))
          return res;
      }
      function toWords(bytes) {
        var res = convert(bytes, 8, 5, true);
        if (Array.isArray(res))
          return res;
        throw new Error(res);
      }
      function fromWordsUnsafe(words) {
        var res = convert(words, 5, 8, false);
        if (Array.isArray(res))
          return res;
      }
      function fromWords(words) {
        var res = convert(words, 5, 8, false);
        if (Array.isArray(res))
          return res;
        throw new Error(res);
      }
      module2.exports = {
        decodeUnsafe,
        decode,
        encode,
        toWordsUnsafe,
        toWords,
        fromWordsUnsafe,
        fromWords
      };
    }
  });

  // node_modules/@cosmjs/encoding/build/bech32.js
  var require_bech322 = __commonJS({
    "node_modules/@cosmjs/encoding/build/bech32.js"(exports2) {
      "use strict";
      var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
        if (k2 === void 0)
          k2 = k;
        Object.defineProperty(o, k2, { enumerable: true, get: function() {
          return m[k];
        } });
      } : function(o, m, k, k2) {
        if (k2 === void 0)
          k2 = k;
        o[k2] = m[k];
      });
      var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
        Object.defineProperty(o, "default", { enumerable: true, value: v });
      } : function(o, v) {
        o["default"] = v;
      });
      var __importStar = exports2 && exports2.__importStar || function(mod2) {
        if (mod2 && mod2.__esModule)
          return mod2;
        var result = {};
        if (mod2 != null) {
          for (var k in mod2)
            if (k !== "default" && Object.prototype.hasOwnProperty.call(mod2, k))
              __createBinding(result, mod2, k);
        }
        __setModuleDefault(result, mod2);
        return result;
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.Bech32 = exports2.normalizeBech32 = exports2.fromBech32 = exports2.toBech32 = void 0;
      var bech32 = __importStar(require_bech32());
      function toBech32(prefix, data, limit) {
        const address = bech32.encode(prefix, bech32.toWords(data), limit);
        return address;
      }
      exports2.toBech32 = toBech32;
      function fromBech32(address, limit = Infinity) {
        const decodedAddress = bech32.decode(address, limit);
        return {
          prefix: decodedAddress.prefix,
          data: new Uint8Array(bech32.fromWords(decodedAddress.words))
        };
      }
      exports2.fromBech32 = fromBech32;
      function normalizeBech32(address) {
        const { prefix, data } = fromBech32(address);
        return toBech32(prefix, data);
      }
      exports2.normalizeBech32 = normalizeBech32;
      var Bech32 = class {
        static encode(prefix, data, limit) {
          return toBech32(prefix, data, limit);
        }
        static decode(address, limit = Infinity) {
          return fromBech32(address, limit);
        }
      };
      exports2.Bech32 = Bech32;
    }
  });

  // node_modules/@cosmjs/encoding/build/hex.js
  var require_hex = __commonJS({
    "node_modules/@cosmjs/encoding/build/hex.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.fromHex = exports2.toHex = void 0;
      function toHex(data) {
        let out = "";
        for (const byte of data) {
          out += ("0" + byte.toString(16)).slice(-2);
        }
        return out;
      }
      exports2.toHex = toHex;
      function fromHex(hexstring) {
        if (hexstring.length % 2 !== 0) {
          throw new Error("hex string length must be a multiple of 2");
        }
        const out = new Uint8Array(hexstring.length / 2);
        for (let i = 0; i < out.length; i++) {
          const j = 2 * i;
          const hexByteAsString = hexstring.slice(j, j + 2);
          if (!hexByteAsString.match(/[0-9a-f]{2}/i)) {
            throw new Error("hex string contains invalid characters");
          }
          out[i] = parseInt(hexByteAsString, 16);
        }
        return out;
      }
      exports2.fromHex = fromHex;
    }
  });

  // node_modules/@cosmjs/encoding/build/rfc3339.js
  var require_rfc3339 = __commonJS({
    "node_modules/@cosmjs/encoding/build/rfc3339.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.toRfc3339 = exports2.fromRfc3339 = void 0;
      var rfc3339Matcher = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2}):(\d{2})(\.\d{1,9})?((?:[+-]\d{2}:\d{2})|Z)$/;
      function padded(integer, length = 2) {
        const filled = "00000" + integer.toString();
        return filled.substring(filled.length - length);
      }
      function fromRfc3339(str) {
        const matches = rfc3339Matcher.exec(str);
        if (!matches) {
          throw new Error("Date string is not in RFC3339 format");
        }
        const year = +matches[1];
        const month = +matches[2];
        const day = +matches[3];
        const hour = +matches[4];
        const minute = +matches[5];
        const second = +matches[6];
        const milliSeconds = matches[7] ? Math.floor(+matches[7] * 1e3) : 0;
        let tzOffsetSign;
        let tzOffsetHours;
        let tzOffsetMinutes;
        if (matches[8] === "Z") {
          tzOffsetSign = 1;
          tzOffsetHours = 0;
          tzOffsetMinutes = 0;
        } else {
          tzOffsetSign = matches[8].substring(0, 1) === "-" ? -1 : 1;
          tzOffsetHours = +matches[8].substring(1, 3);
          tzOffsetMinutes = +matches[8].substring(4, 6);
        }
        const tzOffset = tzOffsetSign * (tzOffsetHours * 60 + tzOffsetMinutes) * 60;
        const timestamp = Date.UTC(year, month - 1, day, hour, minute, second, milliSeconds) - tzOffset * 1e3;
        return new Date(timestamp);
      }
      exports2.fromRfc3339 = fromRfc3339;
      function toRfc3339(date) {
        const year = date.getUTCFullYear();
        const month = padded(date.getUTCMonth() + 1);
        const day = padded(date.getUTCDate());
        const hour = padded(date.getUTCHours());
        const minute = padded(date.getUTCMinutes());
        const second = padded(date.getUTCSeconds());
        const ms = padded(date.getUTCMilliseconds(), 3);
        return `${year}-${month}-${day}T${hour}:${minute}:${second}.${ms}Z`;
      }
      exports2.toRfc3339 = toRfc3339;
    }
  });

  // node_modules/@cosmjs/encoding/build/utf8.js
  var require_utf82 = __commonJS({
    "node_modules/@cosmjs/encoding/build/utf8.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.fromUtf8 = exports2.toUtf8 = void 0;
      function toUtf8(str) {
        return new TextEncoder().encode(str);
      }
      exports2.toUtf8 = toUtf8;
      function fromUtf8(data) {
        return new TextDecoder("utf-8", { fatal: true }).decode(data);
      }
      exports2.fromUtf8 = fromUtf8;
    }
  });

  // node_modules/@cosmjs/encoding/build/index.js
  var require_build2 = __commonJS({
    "node_modules/@cosmjs/encoding/build/index.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.toUtf8 = exports2.fromUtf8 = exports2.toRfc3339 = exports2.fromRfc3339 = exports2.toHex = exports2.fromHex = exports2.toBech32 = exports2.normalizeBech32 = exports2.fromBech32 = exports2.Bech32 = exports2.toBase64 = exports2.fromBase64 = exports2.toAscii = exports2.fromAscii = void 0;
      var ascii_1 = require_ascii();
      Object.defineProperty(exports2, "fromAscii", { enumerable: true, get: function() {
        return ascii_1.fromAscii;
      } });
      Object.defineProperty(exports2, "toAscii", { enumerable: true, get: function() {
        return ascii_1.toAscii;
      } });
      var base64_1 = require_base642();
      Object.defineProperty(exports2, "fromBase64", { enumerable: true, get: function() {
        return base64_1.fromBase64;
      } });
      Object.defineProperty(exports2, "toBase64", { enumerable: true, get: function() {
        return base64_1.toBase64;
      } });
      var bech32_1 = require_bech322();
      Object.defineProperty(exports2, "Bech32", { enumerable: true, get: function() {
        return bech32_1.Bech32;
      } });
      Object.defineProperty(exports2, "fromBech32", { enumerable: true, get: function() {
        return bech32_1.fromBech32;
      } });
      Object.defineProperty(exports2, "normalizeBech32", { enumerable: true, get: function() {
        return bech32_1.normalizeBech32;
      } });
      Object.defineProperty(exports2, "toBech32", { enumerable: true, get: function() {
        return bech32_1.toBech32;
      } });
      var hex_1 = require_hex();
      Object.defineProperty(exports2, "fromHex", { enumerable: true, get: function() {
        return hex_1.fromHex;
      } });
      Object.defineProperty(exports2, "toHex", { enumerable: true, get: function() {
        return hex_1.toHex;
      } });
      var rfc3339_1 = require_rfc3339();
      Object.defineProperty(exports2, "fromRfc3339", { enumerable: true, get: function() {
        return rfc3339_1.fromRfc3339;
      } });
      Object.defineProperty(exports2, "toRfc3339", { enumerable: true, get: function() {
        return rfc3339_1.toRfc3339;
      } });
      var utf8_1 = require_utf82();
      Object.defineProperty(exports2, "fromUtf8", { enumerable: true, get: function() {
        return utf8_1.fromUtf8;
      } });
      Object.defineProperty(exports2, "toUtf8", { enumerable: true, get: function() {
        return utf8_1.toUtf8;
      } });
    }
  });

  // node_modules/@cosmjs/utils/build/arrays.js
  var require_arrays = __commonJS({
    "node_modules/@cosmjs/utils/build/arrays.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.arrayContentStartsWith = exports2.arrayContentEquals = void 0;
      function arrayContentEquals(a, b) {
        if (a.length !== b.length)
          return false;
        for (let i = 0; i < a.length; ++i) {
          if (a[i] !== b[i])
            return false;
        }
        return true;
      }
      exports2.arrayContentEquals = arrayContentEquals;
      function arrayContentStartsWith(a, b) {
        if (a.length < b.length)
          return false;
        for (let i = 0; i < b.length; ++i) {
          if (a[i] !== b[i])
            return false;
        }
        return true;
      }
      exports2.arrayContentStartsWith = arrayContentStartsWith;
    }
  });

  // node_modules/@cosmjs/utils/build/assert.js
  var require_assert = __commonJS({
    "node_modules/@cosmjs/utils/build/assert.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.assertDefinedAndNotNull = exports2.assertDefined = exports2.assert = void 0;
      function assert(condition, msg) {
        if (!condition) {
          throw new Error(msg || "condition is not truthy");
        }
      }
      exports2.assert = assert;
      function assertDefined(value, msg) {
        if (value === void 0) {
          throw new Error(msg !== null && msg !== void 0 ? msg : "value is undefined");
        }
      }
      exports2.assertDefined = assertDefined;
      function assertDefinedAndNotNull(value, msg) {
        if (value === void 0 || value === null) {
          throw new Error(msg !== null && msg !== void 0 ? msg : "value is undefined or null");
        }
      }
      exports2.assertDefinedAndNotNull = assertDefinedAndNotNull;
    }
  });

  // node_modules/@cosmjs/utils/build/sleep.js
  var require_sleep = __commonJS({
    "node_modules/@cosmjs/utils/build/sleep.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.sleep = void 0;
      async function sleep(ms) {
        return new Promise((resolve) => setTimeout(resolve, ms));
      }
      exports2.sleep = sleep;
    }
  });

  // node_modules/@cosmjs/utils/build/typechecks.js
  var require_typechecks = __commonJS({
    "node_modules/@cosmjs/utils/build/typechecks.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.isUint8Array = exports2.isNonNullObject = void 0;
      function isNonNullObject(data) {
        return typeof data === "object" && data !== null;
      }
      exports2.isNonNullObject = isNonNullObject;
      function isUint8Array(data) {
        if (!isNonNullObject(data))
          return false;
        if (Object.prototype.toString.call(data) !== "[object Uint8Array]")
          return false;
        if (typeof Buffer !== "undefined" && typeof Buffer.isBuffer !== "undefined") {
          if (Buffer.isBuffer(data))
            return false;
        }
        return true;
      }
      exports2.isUint8Array = isUint8Array;
    }
  });

  // node_modules/@cosmjs/utils/build/index.js
  var require_build3 = __commonJS({
    "node_modules/@cosmjs/utils/build/index.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.isUint8Array = exports2.isNonNullObject = exports2.sleep = exports2.assertDefinedAndNotNull = exports2.assertDefined = exports2.assert = exports2.arrayContentStartsWith = exports2.arrayContentEquals = void 0;
      var arrays_1 = require_arrays();
      Object.defineProperty(exports2, "arrayContentEquals", { enumerable: true, get: function() {
        return arrays_1.arrayContentEquals;
      } });
      Object.defineProperty(exports2, "arrayContentStartsWith", { enumerable: true, get: function() {
        return arrays_1.arrayContentStartsWith;
      } });
      var assert_1 = require_assert();
      Object.defineProperty(exports2, "assert", { enumerable: true, get: function() {
        return assert_1.assert;
      } });
      Object.defineProperty(exports2, "assertDefined", { enumerable: true, get: function() {
        return assert_1.assertDefined;
      } });
      Object.defineProperty(exports2, "assertDefinedAndNotNull", { enumerable: true, get: function() {
        return assert_1.assertDefinedAndNotNull;
      } });
      var sleep_1 = require_sleep();
      Object.defineProperty(exports2, "sleep", { enumerable: true, get: function() {
        return sleep_1.sleep;
      } });
      var typechecks_1 = require_typechecks();
      Object.defineProperty(exports2, "isNonNullObject", { enumerable: true, get: function() {
        return typechecks_1.isNonNullObject;
      } });
      Object.defineProperty(exports2, "isUint8Array", { enumerable: true, get: function() {
        return typechecks_1.isUint8Array;
      } });
    }
  });

  // node_modules/@noble/hashes/cryptoBrowser.js
  var require_cryptoBrowser = __commonJS({
    "node_modules/@noble/hashes/cryptoBrowser.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.crypto = void 0;
      exports2.crypto = {
        node: void 0,
        web: typeof self === "object" && "crypto" in self ? self.crypto : void 0
      };
    }
  });

  // node_modules/@noble/hashes/utils.js
  var require_utils = __commonJS({
    "node_modules/@noble/hashes/utils.js"(exports2, module2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.randomBytes = exports2.wrapConstructorWithOpts = exports2.wrapConstructor = exports2.checkOpts = exports2.Hash = exports2.assertHash = exports2.assertBytes = exports2.assertBool = exports2.assertNumber = exports2.concatBytes = exports2.toBytes = exports2.utf8ToBytes = exports2.asyncLoop = exports2.nextTick = exports2.hexToBytes = exports2.bytesToHex = exports2.isLE = exports2.rotr = exports2.createView = exports2.u32 = exports2.u8 = void 0;
      var crypto_1 = require_cryptoBrowser();
      var u8 = (arr) => new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
      exports2.u8 = u8;
      var u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
      exports2.u32 = u32;
      var createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
      exports2.createView = createView;
      var rotr = (word, shift) => word << 32 - shift | word >>> shift;
      exports2.rotr = rotr;
      exports2.isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
      if (!exports2.isLE)
        throw new Error("Non little-endian hardware is not supported");
      var hexes = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, "0"));
      function bytesToHex(uint8a) {
        let hex = "";
        for (let i = 0; i < uint8a.length; i++) {
          hex += hexes[uint8a[i]];
        }
        return hex;
      }
      exports2.bytesToHex = bytesToHex;
      function hexToBytes(hex) {
        if (typeof hex !== "string") {
          throw new TypeError("hexToBytes: expected string, got " + typeof hex);
        }
        if (hex.length % 2)
          throw new Error("hexToBytes: received invalid unpadded hex");
        const array = new Uint8Array(hex.length / 2);
        for (let i = 0; i < array.length; i++) {
          const j = i * 2;
          const hexByte = hex.slice(j, j + 2);
          const byte = Number.parseInt(hexByte, 16);
          if (Number.isNaN(byte))
            throw new Error("Invalid byte sequence");
          array[i] = byte;
        }
        return array;
      }
      exports2.hexToBytes = hexToBytes;
      exports2.nextTick = (() => {
        const nodeRequire = typeof module2 !== "undefined" && typeof module2.require === "function" && module2.require.bind(module2);
        try {
          if (nodeRequire) {
            const { setImmediate } = nodeRequire("timers");
            return () => new Promise((resolve) => setImmediate(resolve));
          }
        } catch (e) {
        }
        return () => new Promise((resolve) => setTimeout(resolve, 0));
      })();
      async function asyncLoop(iters, tick, cb) {
        let ts = Date.now();
        for (let i = 0; i < iters; i++) {
          cb(i);
          const diff = Date.now() - ts;
          if (diff >= 0 && diff < tick)
            continue;
          await (0, exports2.nextTick)();
          ts += diff;
        }
      }
      exports2.asyncLoop = asyncLoop;
      function utf8ToBytes(str) {
        if (typeof str !== "string") {
          throw new TypeError(`utf8ToBytes expected string, got ${typeof str}`);
        }
        return new TextEncoder().encode(str);
      }
      exports2.utf8ToBytes = utf8ToBytes;
      function toBytes(data) {
        if (typeof data === "string")
          data = utf8ToBytes(data);
        if (!(data instanceof Uint8Array))
          throw new TypeError(`Expected input type is Uint8Array (got ${typeof data})`);
        return data;
      }
      exports2.toBytes = toBytes;
      function concatBytes(...arrays) {
        if (!arrays.every((a) => a instanceof Uint8Array))
          throw new Error("Uint8Array list expected");
        if (arrays.length === 1)
          return arrays[0];
        const length = arrays.reduce((a, arr) => a + arr.length, 0);
        const result = new Uint8Array(length);
        for (let i = 0, pad = 0; i < arrays.length; i++) {
          const arr = arrays[i];
          result.set(arr, pad);
          pad += arr.length;
        }
        return result;
      }
      exports2.concatBytes = concatBytes;
      function assertNumber(n) {
        if (!Number.isSafeInteger(n) || n < 0)
          throw new Error(`Wrong positive integer: ${n}`);
      }
      exports2.assertNumber = assertNumber;
      function assertBool(b) {
        if (typeof b !== "boolean") {
          throw new Error(`Expected boolean, not ${b}`);
        }
      }
      exports2.assertBool = assertBool;
      function assertBytes(bytes, ...lengths) {
        if (bytes instanceof Uint8Array && (!lengths.length || lengths.includes(bytes.length))) {
          return;
        }
        throw new TypeError(`Expected ${lengths} bytes, not ${typeof bytes} with length=${bytes.length}`);
      }
      exports2.assertBytes = assertBytes;
      function assertHash(hash) {
        if (typeof hash !== "function" || typeof hash.create !== "function")
          throw new Error("Hash should be wrapped by utils.wrapConstructor");
        assertNumber(hash.outputLen);
        assertNumber(hash.blockLen);
      }
      exports2.assertHash = assertHash;
      var Hash = class {
        clone() {
          return this._cloneInto();
        }
      };
      exports2.Hash = Hash;
      var isPlainObject = (obj) => Object.prototype.toString.call(obj) === "[object Object]" && obj.constructor === Object;
      function checkOpts(def, _opts) {
        if (_opts !== void 0 && (typeof _opts !== "object" || !isPlainObject(_opts)))
          throw new TypeError("Options should be object or undefined");
        const opts = Object.assign(def, _opts);
        return opts;
      }
      exports2.checkOpts = checkOpts;
      function wrapConstructor(hashConstructor) {
        const hashC = (message) => hashConstructor().update(toBytes(message)).digest();
        const tmp = hashConstructor();
        hashC.outputLen = tmp.outputLen;
        hashC.blockLen = tmp.blockLen;
        hashC.create = () => hashConstructor();
        return hashC;
      }
      exports2.wrapConstructor = wrapConstructor;
      function wrapConstructorWithOpts(hashCons) {
        const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
        const tmp = hashCons({});
        hashC.outputLen = tmp.outputLen;
        hashC.blockLen = tmp.blockLen;
        hashC.create = (opts) => hashCons(opts);
        return hashC;
      }
      exports2.wrapConstructorWithOpts = wrapConstructorWithOpts;
      function randomBytes(bytesLength = 32) {
        if (crypto_1.crypto.web) {
          return crypto_1.crypto.web.getRandomValues(new Uint8Array(bytesLength));
        } else if (crypto_1.crypto.node) {
          return new Uint8Array(crypto_1.crypto.node.randomBytes(bytesLength).buffer);
        } else {
          throw new Error("The environment doesn't have randomBytes function");
        }
      }
      exports2.randomBytes = randomBytes;
    }
  });

  // node_modules/@noble/hashes/hmac.js
  var require_hmac = __commonJS({
    "node_modules/@noble/hashes/hmac.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.hmac = void 0;
      var utils_js_1 = require_utils();
      var HMAC = class extends utils_js_1.Hash {
        constructor(hash, _key) {
          super();
          this.finished = false;
          this.destroyed = false;
          (0, utils_js_1.assertHash)(hash);
          const key = (0, utils_js_1.toBytes)(_key);
          this.iHash = hash.create();
          if (!(this.iHash instanceof utils_js_1.Hash))
            throw new TypeError("Expected instance of class which extends utils.Hash");
          const blockLen = this.blockLen = this.iHash.blockLen;
          this.outputLen = this.iHash.outputLen;
          const pad = new Uint8Array(blockLen);
          pad.set(key.length > this.iHash.blockLen ? hash.create().update(key).digest() : key);
          for (let i = 0; i < pad.length; i++)
            pad[i] ^= 54;
          this.iHash.update(pad);
          this.oHash = hash.create();
          for (let i = 0; i < pad.length; i++)
            pad[i] ^= 54 ^ 92;
          this.oHash.update(pad);
          pad.fill(0);
        }
        update(buf) {
          if (this.destroyed)
            throw new Error("instance is destroyed");
          this.iHash.update(buf);
          return this;
        }
        digestInto(out) {
          if (this.destroyed)
            throw new Error("instance is destroyed");
          if (!(out instanceof Uint8Array) || out.length !== this.outputLen)
            throw new Error("HMAC: Invalid output buffer");
          if (this.finished)
            throw new Error("digest() was already called");
          this.finished = true;
          this.iHash.digestInto(out);
          this.oHash.update(out);
          this.oHash.digestInto(out);
          this.destroy();
        }
        digest() {
          const out = new Uint8Array(this.oHash.outputLen);
          this.digestInto(out);
          return out;
        }
        _cloneInto(to) {
          to || (to = Object.create(Object.getPrototypeOf(this), {}));
          const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
          to = to;
          to.finished = finished;
          to.destroyed = destroyed;
          to.blockLen = blockLen;
          to.outputLen = outputLen;
          to.oHash = oHash._cloneInto(to.oHash);
          to.iHash = iHash._cloneInto(to.iHash);
          return to;
        }
        destroy() {
          this.destroyed = true;
          this.oHash.destroy();
          this.iHash.destroy();
        }
      };
      var hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();
      exports2.hmac = hmac;
      exports2.hmac.create = (hash, key) => new HMAC(hash, key);
    }
  });

  // node_modules/@noble/hashes/pbkdf2.js
  var require_pbkdf2 = __commonJS({
    "node_modules/@noble/hashes/pbkdf2.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.pbkdf2Async = exports2.pbkdf2 = void 0;
      var hmac_js_1 = require_hmac();
      var utils_js_1 = require_utils();
      function pbkdf2Init(hash, _password, _salt, _opts) {
        (0, utils_js_1.assertHash)(hash);
        const opts = (0, utils_js_1.checkOpts)({ dkLen: 32, asyncTick: 10 }, _opts);
        const { c, dkLen, asyncTick } = opts;
        (0, utils_js_1.assertNumber)(c);
        (0, utils_js_1.assertNumber)(dkLen);
        (0, utils_js_1.assertNumber)(asyncTick);
        if (c < 1)
          throw new Error("PBKDF2: iterations (c) should be >= 1");
        const password = (0, utils_js_1.toBytes)(_password);
        const salt = (0, utils_js_1.toBytes)(_salt);
        const DK = new Uint8Array(dkLen);
        const PRF = hmac_js_1.hmac.create(hash, password);
        const PRFSalt = PRF._cloneInto().update(salt);
        return { c, dkLen, asyncTick, DK, PRF, PRFSalt };
      }
      function pbkdf2Output(PRF, PRFSalt, DK, prfW, u) {
        PRF.destroy();
        PRFSalt.destroy();
        if (prfW)
          prfW.destroy();
        u.fill(0);
        return DK;
      }
      function pbkdf2(hash, password, salt, opts) {
        const { c, dkLen, DK, PRF, PRFSalt } = pbkdf2Init(hash, password, salt, opts);
        let prfW;
        const arr = new Uint8Array(4);
        const view = (0, utils_js_1.createView)(arr);
        const u = new Uint8Array(PRF.outputLen);
        for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) {
          const Ti = DK.subarray(pos, pos + PRF.outputLen);
          view.setInt32(0, ti, false);
          (prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u);
          Ti.set(u.subarray(0, Ti.length));
          for (let ui = 1; ui < c; ui++) {
            PRF._cloneInto(prfW).update(u).digestInto(u);
            for (let i = 0; i < Ti.length; i++)
              Ti[i] ^= u[i];
          }
        }
        return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);
      }
      exports2.pbkdf2 = pbkdf2;
      async function pbkdf2Async(hash, password, salt, opts) {
        const { c, dkLen, asyncTick, DK, PRF, PRFSalt } = pbkdf2Init(hash, password, salt, opts);
        let prfW;
        const arr = new Uint8Array(4);
        const view = (0, utils_js_1.createView)(arr);
        const u = new Uint8Array(PRF.outputLen);
        for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) {
          const Ti = DK.subarray(pos, pos + PRF.outputLen);
          view.setInt32(0, ti, false);
          (prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u);
          Ti.set(u.subarray(0, Ti.length));
          await (0, utils_js_1.asyncLoop)(c - 1, asyncTick, (i) => {
            PRF._cloneInto(prfW).update(u).digestInto(u);
            for (let i2 = 0; i2 < Ti.length; i2++)
              Ti[i2] ^= u[i2];
          });
        }
        return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);
      }
      exports2.pbkdf2Async = pbkdf2Async;
    }
  });

  // node_modules/@noble/hashes/_sha2.js
  var require_sha2 = __commonJS({
    "node_modules/@noble/hashes/_sha2.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.SHA2 = void 0;
      var utils_js_1 = require_utils();
      function setBigUint64(view, byteOffset, value, isLE) {
        if (typeof view.setBigUint64 === "function")
          return view.setBigUint64(byteOffset, value, isLE);
        const _32n = BigInt(32);
        const _u32_max = BigInt(4294967295);
        const wh = Number(value >> _32n & _u32_max);
        const wl = Number(value & _u32_max);
        const h = isLE ? 4 : 0;
        const l = isLE ? 0 : 4;
        view.setUint32(byteOffset + h, wh, isLE);
        view.setUint32(byteOffset + l, wl, isLE);
      }
      var SHA2 = class extends utils_js_1.Hash {
        constructor(blockLen, outputLen, padOffset, isLE) {
          super();
          this.blockLen = blockLen;
          this.outputLen = outputLen;
          this.padOffset = padOffset;
          this.isLE = isLE;
          this.finished = false;
          this.length = 0;
          this.pos = 0;
          this.destroyed = false;
          this.buffer = new Uint8Array(blockLen);
          this.view = (0, utils_js_1.createView)(this.buffer);
        }
        update(data) {
          if (this.destroyed)
            throw new Error("instance is destroyed");
          const { view, buffer, blockLen, finished } = this;
          if (finished)
            throw new Error("digest() was already called");
          data = (0, utils_js_1.toBytes)(data);
          const len = data.length;
          for (let pos = 0; pos < len; ) {
            const take = Math.min(blockLen - this.pos, len - pos);
            if (take === blockLen) {
              const dataView = (0, utils_js_1.createView)(data);
              for (; blockLen <= len - pos; pos += blockLen)
                this.process(dataView, pos);
              continue;
            }
            buffer.set(data.subarray(pos, pos + take), this.pos);
            this.pos += take;
            pos += take;
            if (this.pos === blockLen) {
              this.process(view, 0);
              this.pos = 0;
            }
          }
          this.length += data.length;
          this.roundClean();
          return this;
        }
        digestInto(out) {
          if (this.destroyed)
            throw new Error("instance is destroyed");
          if (!(out instanceof Uint8Array) || out.length < this.outputLen)
            throw new Error("_Sha2: Invalid output buffer");
          if (this.finished)
            throw new Error("digest() was already called");
          this.finished = true;
          const { buffer, view, blockLen, isLE } = this;
          let { pos } = this;
          buffer[pos++] = 128;
          this.buffer.subarray(pos).fill(0);
          if (this.padOffset > blockLen - pos) {
            this.process(view, 0);
            pos = 0;
          }
          for (let i = pos; i < blockLen; i++)
            buffer[i] = 0;
          setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);
          this.process(view, 0);
          const oview = (0, utils_js_1.createView)(out);
          this.get().forEach((v, i) => oview.setUint32(4 * i, v, isLE));
        }
        digest() {
          const { buffer, outputLen } = this;
          this.digestInto(buffer);
          const res = buffer.slice(0, outputLen);
          this.destroy();
          return res;
        }
        _cloneInto(to) {
          to || (to = new this.constructor());
          to.set(...this.get());
          const { blockLen, buffer, length, finished, destroyed, pos } = this;
          to.length = length;
          to.pos = pos;
          to.finished = finished;
          to.destroyed = destroyed;
          if (length % blockLen)
            to.buffer.set(buffer);
          return to;
        }
      };
      exports2.SHA2 = SHA2;
    }
  });

  // node_modules/@noble/hashes/_u64.js
  var require_u64 = __commonJS({
    "node_modules/@noble/hashes/_u64.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.add5H = exports2.add5L = exports2.add4H = exports2.add4L = exports2.add3H = exports2.add3L = exports2.add = exports2.rotlBL = exports2.rotlBH = exports2.rotlSL = exports2.rotlSH = exports2.rotr32L = exports2.rotr32H = exports2.rotrBL = exports2.rotrBH = exports2.rotrSL = exports2.rotrSH = exports2.shrSL = exports2.shrSH = exports2.toBig = exports2.split = exports2.fromBig = void 0;
      var U32_MASK64 = BigInt(2 ** 32 - 1);
      var _32n = BigInt(32);
      function fromBig(n, le = false) {
        if (le)
          return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
        return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
      }
      exports2.fromBig = fromBig;
      function split(lst, le = false) {
        let Ah = new Uint32Array(lst.length);
        let Al = new Uint32Array(lst.length);
        for (let i = 0; i < lst.length; i++) {
          const { h, l } = fromBig(lst[i], le);
          [Ah[i], Al[i]] = [h, l];
        }
        return [Ah, Al];
      }
      exports2.split = split;
      var toBig = (h, l) => BigInt(h >>> 0) << _32n | BigInt(l >>> 0);
      exports2.toBig = toBig;
      var shrSH = (h, l, s) => h >>> s;
      exports2.shrSH = shrSH;
      var shrSL = (h, l, s) => h << 32 - s | l >>> s;
      exports2.shrSL = shrSL;
      var rotrSH = (h, l, s) => h >>> s | l << 32 - s;
      exports2.rotrSH = rotrSH;
      var rotrSL = (h, l, s) => h << 32 - s | l >>> s;
      exports2.rotrSL = rotrSL;
      var rotrBH = (h, l, s) => h << 64 - s | l >>> s - 32;
      exports2.rotrBH = rotrBH;
      var rotrBL = (h, l, s) => h >>> s - 32 | l << 64 - s;
      exports2.rotrBL = rotrBL;
      var rotr32H = (h, l) => l;
      exports2.rotr32H = rotr32H;
      var rotr32L = (h, l) => h;
      exports2.rotr32L = rotr32L;
      var rotlSH = (h, l, s) => h << s | l >>> 32 - s;
      exports2.rotlSH = rotlSH;
      var rotlSL = (h, l, s) => l << s | h >>> 32 - s;
      exports2.rotlSL = rotlSL;
      var rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
      exports2.rotlBH = rotlBH;
      var rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
      exports2.rotlBL = rotlBL;
      function add(Ah, Al, Bh, Bl) {
        const l = (Al >>> 0) + (Bl >>> 0);
        return { h: Ah + Bh + (l / 2 ** 32 | 0) | 0, l: l | 0 };
      }
      exports2.add = add;
      var add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
      exports2.add3L = add3L;
      var add3H = (low, Ah, Bh, Ch) => Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0;
      exports2.add3H = add3H;
      var add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
      exports2.add4L = add4L;
      var add4H = (low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0;
      exports2.add4H = add4H;
      var add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
      exports2.add5L = add5L;
      var add5H = (low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0;
      exports2.add5H = add5H;
    }
  });

  // node_modules/@noble/hashes/sha512.js
  var require_sha512 = __commonJS({
    "node_modules/@noble/hashes/sha512.js"(exports2) {
      "use strict";
      var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
        if (k2 === void 0)
          k2 = k;
        Object.defineProperty(o, k2, { enumerable: true, get: function() {
          return m[k];
        } });
      } : function(o, m, k, k2) {
        if (k2 === void 0)
          k2 = k;
        o[k2] = m[k];
      });
      var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
        Object.defineProperty(o, "default", { enumerable: true, value: v });
      } : function(o, v) {
        o["default"] = v;
      });
      var __importStar = exports2 && exports2.__importStar || function(mod2) {
        if (mod2 && mod2.__esModule)
          return mod2;
        var result = {};
        if (mod2 != null) {
          for (var k in mod2)
            if (k !== "default" && Object.prototype.hasOwnProperty.call(mod2, k))
              __createBinding(result, mod2, k);
        }
        __setModuleDefault(result, mod2);
        return result;
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.sha384 = exports2.sha512_256 = exports2.sha512 = exports2.SHA512 = void 0;
      var _sha2_js_1 = require_sha2();
      var u64 = __importStar(require_u64());
      var utils_js_1 = require_utils();
      var [SHA512_Kh, SHA512_Kl] = u64.split([
        "0x428a2f98d728ae22",
        "0x7137449123ef65cd",
        "0xb5c0fbcfec4d3b2f",
        "0xe9b5dba58189dbbc",
        "0x3956c25bf348b538",
        "0x59f111f1b605d019",
        "0x923f82a4af194f9b",
        "0xab1c5ed5da6d8118",
        "0xd807aa98a3030242",
        "0x12835b0145706fbe",
        "0x243185be4ee4b28c",
        "0x550c7dc3d5ffb4e2",
        "0x72be5d74f27b896f",
        "0x80deb1fe3b1696b1",
        "0x9bdc06a725c71235",
        "0xc19bf174cf692694",
        "0xe49b69c19ef14ad2",
        "0xefbe4786384f25e3",
        "0x0fc19dc68b8cd5b5",
        "0x240ca1cc77ac9c65",
        "0x2de92c6f592b0275",
        "0x4a7484aa6ea6e483",
        "0x5cb0a9dcbd41fbd4",
        "0x76f988da831153b5",
        "0x983e5152ee66dfab",
        "0xa831c66d2db43210",
        "0xb00327c898fb213f",
        "0xbf597fc7beef0ee4",
        "0xc6e00bf33da88fc2",
        "0xd5a79147930aa725",
        "0x06ca6351e003826f",
        "0x142929670a0e6e70",
        "0x27b70a8546d22ffc",
        "0x2e1b21385c26c926",
        "0x4d2c6dfc5ac42aed",
        "0x53380d139d95b3df",
        "0x650a73548baf63de",
        "0x766a0abb3c77b2a8",
        "0x81c2c92e47edaee6",
        "0x92722c851482353b",
        "0xa2bfe8a14cf10364",
        "0xa81a664bbc423001",
        "0xc24b8b70d0f89791",
        "0xc76c51a30654be30",
        "0xd192e819d6ef5218",
        "0xd69906245565a910",
        "0xf40e35855771202a",
        "0x106aa07032bbd1b8",
        "0x19a4c116b8d2d0c8",
        "0x1e376c085141ab53",
        "0x2748774cdf8eeb99",
        "0x34b0bcb5e19b48a8",
        "0x391c0cb3c5c95a63",
        "0x4ed8aa4ae3418acb",
        "0x5b9cca4f7763e373",
        "0x682e6ff3d6b2b8a3",
        "0x748f82ee5defb2fc",
        "0x78a5636f43172f60",
        "0x84c87814a1f0ab72",
        "0x8cc702081a6439ec",
        "0x90befffa23631e28",
        "0xa4506cebde82bde9",
        "0xbef9a3f7b2c67915",
        "0xc67178f2e372532b",
        "0xca273eceea26619c",
        "0xd186b8c721c0c207",
        "0xeada7dd6cde0eb1e",
        "0xf57d4f7fee6ed178",
        "0x06f067aa72176fba",
        "0x0a637dc5a2c898a6",
        "0x113f9804bef90dae",
        "0x1b710b35131c471b",
        "0x28db77f523047d84",
        "0x32caab7b40c72493",
        "0x3c9ebe0a15c9bebc",
        "0x431d67c49c100d4c",
        "0x4cc5d4becb3e42b6",
        "0x597f299cfc657e2a",
        "0x5fcb6fab3ad6faec",
        "0x6c44198c4a475817"
      ].map((n) => BigInt(n)));
      var SHA512_W_H = new Uint32Array(80);
      var SHA512_W_L = new Uint32Array(80);
      var SHA512 = class extends _sha2_js_1.SHA2 {
        constructor() {
          super(128, 64, 16, false);
          this.Ah = 1779033703 | 0;
          this.Al = 4089235720 | 0;
          this.Bh = 3144134277 | 0;
          this.Bl = 2227873595 | 0;
          this.Ch = 1013904242 | 0;
          this.Cl = 4271175723 | 0;
          this.Dh = 2773480762 | 0;
          this.Dl = 1595750129 | 0;
          this.Eh = 1359893119 | 0;
          this.El = 2917565137 | 0;
          this.Fh = 2600822924 | 0;
          this.Fl = 725511199 | 0;
          this.Gh = 528734635 | 0;
          this.Gl = 4215389547 | 0;
          this.Hh = 1541459225 | 0;
          this.Hl = 327033209 | 0;
        }
        get() {
          const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
          return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];
        }
        set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {
          this.Ah = Ah | 0;
          this.Al = Al | 0;
          this.Bh = Bh | 0;
          this.Bl = Bl | 0;
          this.Ch = Ch | 0;
          this.Cl = Cl | 0;
          this.Dh = Dh | 0;
          this.Dl = Dl | 0;
          this.Eh = Eh | 0;
          this.El = El | 0;
          this.Fh = Fh | 0;
          this.Fl = Fl | 0;
          this.Gh = Gh | 0;
          this.Gl = Gl | 0;
          this.Hh = Hh | 0;
          this.Hl = Hl | 0;
        }
        process(view, offset) {
          for (let i = 0; i < 16; i++, offset += 4) {
            SHA512_W_H[i] = view.getUint32(offset);
            SHA512_W_L[i] = view.getUint32(offset += 4);
          }
          for (let i = 16; i < 80; i++) {
            const W15h = SHA512_W_H[i - 15] | 0;
            const W15l = SHA512_W_L[i - 15] | 0;
            const s0h = u64.rotrSH(W15h, W15l, 1) ^ u64.rotrSH(W15h, W15l, 8) ^ u64.shrSH(W15h, W15l, 7);
            const s0l = u64.rotrSL(W15h, W15l, 1) ^ u64.rotrSL(W15h, W15l, 8) ^ u64.shrSL(W15h, W15l, 7);
            const W2h = SHA512_W_H[i - 2] | 0;
            const W2l = SHA512_W_L[i - 2] | 0;
            const s1h = u64.rotrSH(W2h, W2l, 19) ^ u64.rotrBH(W2h, W2l, 61) ^ u64.shrSH(W2h, W2l, 6);
            const s1l = u64.rotrSL(W2h, W2l, 19) ^ u64.rotrBL(W2h, W2l, 61) ^ u64.shrSL(W2h, W2l, 6);
            const SUMl = u64.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);
            const SUMh = u64.add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);
            SHA512_W_H[i] = SUMh | 0;
            SHA512_W_L[i] = SUMl | 0;
          }
          let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
          for (let i = 0; i < 80; i++) {
            const sigma1h = u64.rotrSH(Eh, El, 14) ^ u64.rotrSH(Eh, El, 18) ^ u64.rotrBH(Eh, El, 41);
            const sigma1l = u64.rotrSL(Eh, El, 14) ^ u64.rotrSL(Eh, El, 18) ^ u64.rotrBL(Eh, El, 41);
            const CHIh = Eh & Fh ^ ~Eh & Gh;
            const CHIl = El & Fl ^ ~El & Gl;
            const T1ll = u64.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);
            const T1h = u64.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);
            const T1l = T1ll | 0;
            const sigma0h = u64.rotrSH(Ah, Al, 28) ^ u64.rotrBH(Ah, Al, 34) ^ u64.rotrBH(Ah, Al, 39);
            const sigma0l = u64.rotrSL(Ah, Al, 28) ^ u64.rotrBL(Ah, Al, 34) ^ u64.rotrBL(Ah, Al, 39);
            const MAJh = Ah & Bh ^ Ah & Ch ^ Bh & Ch;
            const MAJl = Al & Bl ^ Al & Cl ^ Bl & Cl;
            Hh = Gh | 0;
            Hl = Gl | 0;
            Gh = Fh | 0;
            Gl = Fl | 0;
            Fh = Eh | 0;
            Fl = El | 0;
            ({ h: Eh, l: El } = u64.add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));
            Dh = Ch | 0;
            Dl = Cl | 0;
            Ch = Bh | 0;
            Cl = Bl | 0;
            Bh = Ah | 0;
            Bl = Al | 0;
            const All = u64.add3L(T1l, sigma0l, MAJl);
            Ah = u64.add3H(All, T1h, sigma0h, MAJh);
            Al = All | 0;
          }
          ({ h: Ah, l: Al } = u64.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
          ({ h: Bh, l: Bl } = u64.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
          ({ h: Ch, l: Cl } = u64.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
          ({ h: Dh, l: Dl } = u64.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
          ({ h: Eh, l: El } = u64.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
          ({ h: Fh, l: Fl } = u64.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
          ({ h: Gh, l: Gl } = u64.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
          ({ h: Hh, l: Hl } = u64.add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));
          this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);
        }
        roundClean() {
          SHA512_W_H.fill(0);
          SHA512_W_L.fill(0);
        }
        destroy() {
          this.buffer.fill(0);
          this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
        }
      };
      exports2.SHA512 = SHA512;
      var SHA512_256 = class extends SHA512 {
        constructor() {
          super();
          this.Ah = 573645204 | 0;
          this.Al = 4230739756 | 0;
          this.Bh = 2673172387 | 0;
          this.Bl = 3360449730 | 0;
          this.Ch = 596883563 | 0;
          this.Cl = 1867755857 | 0;
          this.Dh = 2520282905 | 0;
          this.Dl = 1497426621 | 0;
          this.Eh = 2519219938 | 0;
          this.El = 2827943907 | 0;
          this.Fh = 3193839141 | 0;
          this.Fl = 1401305490 | 0;
          this.Gh = 721525244 | 0;
          this.Gl = 746961066 | 0;
          this.Hh = 246885852 | 0;
          this.Hl = 2177182882 | 0;
          this.outputLen = 32;
        }
      };
      var SHA384 = class extends SHA512 {
        constructor() {
          super();
          this.Ah = 3418070365 | 0;
          this.Al = 3238371032 | 0;
          this.Bh = 1654270250 | 0;
          this.Bl = 914150663 | 0;
          this.Ch = 2438529370 | 0;
          this.Cl = 812702999 | 0;
          this.Dh = 355462360 | 0;
          this.Dl = 4144912697 | 0;
          this.Eh = 1731405415 | 0;
          this.El = 4290775857 | 0;
          this.Fh = 2394180231 | 0;
          this.Fl = 1750603025 | 0;
          this.Gh = 3675008525 | 0;
          this.Gl = 1694076839 | 0;
          this.Hh = 1203062813 | 0;
          this.Hl = 3204075428 | 0;
          this.outputLen = 48;
        }
      };
      exports2.sha512 = (0, utils_js_1.wrapConstructor)(() => new SHA512());
      exports2.sha512_256 = (0, utils_js_1.wrapConstructor)(() => new SHA512_256());
      exports2.sha384 = (0, utils_js_1.wrapConstructor)(() => new SHA384());
    }
  });

  // node_modules/ieee754/index.js
  var require_ieee754 = __commonJS({
    "node_modules/ieee754/index.js"(exports2) {
      exports2.read = function(buffer, offset, isLE, mLen, nBytes) {
        var e, m;
        var eLen = nBytes * 8 - mLen - 1;
        var eMax = (1 << eLen) - 1;
        var eBias = eMax >> 1;
        var nBits = -7;
        var i = isLE ? nBytes - 1 : 0;
        var d = isLE ? -1 : 1;
        var s = buffer[offset + i];
        i += d;
        e = s & (1 << -nBits) - 1;
        s >>= -nBits;
        nBits += eLen;
        for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {
        }
        m = e & (1 << -nBits) - 1;
        e >>= -nBits;
        nBits += mLen;
        for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {
        }
        if (e === 0) {
          e = 1 - eBias;
        } else if (e === eMax) {
          return m ? NaN : (s ? -1 : 1) * Infinity;
        } else {
          m = m + Math.pow(2, mLen);
          e = e - eBias;
        }
        return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
      };
      exports2.write = function(buffer, value, offset, isLE, mLen, nBytes) {
        var e, m, c;
        var eLen = nBytes * 8 - mLen - 1;
        var eMax = (1 << eLen) - 1;
        var eBias = eMax >> 1;
        var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
        var i = isLE ? 0 : nBytes - 1;
        var d = isLE ? 1 : -1;
        var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
        value = Math.abs(value);
        if (isNaN(value) || value === Infinity) {
          m = isNaN(value) ? 1 : 0;
          e = eMax;
        } else {
          e = Math.floor(Math.log(value) / Math.LN2);
          if (value * (c = Math.pow(2, -e)) < 1) {
            e--;
            c *= 2;
          }
          if (e + eBias >= 1) {
            value += rt / c;
          } else {
            value += rt * Math.pow(2, 1 - eBias);
          }
          if (value * c >= 2) {
            e++;
            c /= 2;
          }
          if (e + eBias >= eMax) {
            m = 0;
            e = eMax;
          } else if (e + eBias >= 1) {
            m = (value * c - 1) * Math.pow(2, mLen);
            e = e + eBias;
          } else {
            m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
            e = 0;
          }
        }
        for (; mLen >= 8; buffer[offset + i] = m & 255, i += d, m /= 256, mLen -= 8) {
        }
        e = e << mLen | m;
        eLen += mLen;
        for (; eLen > 0; buffer[offset + i] = e & 255, i += d, e /= 256, eLen -= 8) {
        }
        buffer[offset + i - d] |= s * 128;
      };
    }
  });

  // node_modules/buffer/index.js
  var require_buffer2 = __commonJS({
    "node_modules/buffer/index.js"(exports2) {
      "use strict";
      var base64 = require_base64_js();
      var ieee754 = require_ieee754();
      var customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null;
      exports2.Buffer = Buffer2;
      exports2.SlowBuffer = SlowBuffer;
      exports2.INSPECT_MAX_BYTES = 50;
      var K_MAX_LENGTH = 2147483647;
      exports2.kMaxLength = K_MAX_LENGTH;
      Buffer2.TYPED_ARRAY_SUPPORT = typedArraySupport();
      if (!Buffer2.TYPED_ARRAY_SUPPORT && typeof console !== "undefined" && typeof console.error === "function") {
        console.error("This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support.");
      }
      function typedArraySupport() {
        try {
          const arr = new Uint8Array(1);
          const proto = { foo: function() {
            return 42;
          } };
          Object.setPrototypeOf(proto, Uint8Array.prototype);
          Object.setPrototypeOf(arr, proto);
          return arr.foo() === 42;
        } catch (e) {
          return false;
        }
      }
      Object.defineProperty(Buffer2.prototype, "parent", {
        enumerable: true,
        get: function() {
          if (!Buffer2.isBuffer(this))
            return void 0;
          return this.buffer;
        }
      });
      Object.defineProperty(Buffer2.prototype, "offset", {
        enumerable: true,
        get: function() {
          if (!Buffer2.isBuffer(this))
            return void 0;
          return this.byteOffset;
        }
      });
      function createBuffer(length) {
        if (length > K_MAX_LENGTH) {
          throw new RangeError('The value "' + length + '" is invalid for option "size"');
        }
        const buf = new Uint8Array(length);
        Object.setPrototypeOf(buf, Buffer2.prototype);
        return buf;
      }
      function Buffer2(arg, encodingOrOffset, length) {
        if (typeof arg === "number") {
          if (typeof encodingOrOffset === "string") {
            throw new TypeError('The "string" argument must be of type string. Received type number');
          }
          return allocUnsafe(arg);
        }
        return from(arg, encodingOrOffset, length);
      }
      Buffer2.poolSize = 8192;
      function from(value, encodingOrOffset, length) {
        if (typeof value === "string") {
          return fromString(value, encodingOrOffset);
        }
        if (ArrayBuffer.isView(value)) {
          return fromArrayView(value);
        }
        if (value == null) {
          throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
        }
        if (isInstance(value, ArrayBuffer) || value && isInstance(value.buffer, ArrayBuffer)) {
          return fromArrayBuffer(value, encodingOrOffset, length);
        }
        if (typeof SharedArrayBuffer !== "undefined" && (isInstance(value, SharedArrayBuffer) || value && isInstance(value.buffer, SharedArrayBuffer))) {
          return fromArrayBuffer(value, encodingOrOffset, length);
        }
        if (typeof value === "number") {
          throw new TypeError('The "value" argument must not be of type number. Received type number');
        }
        const valueOf = value.valueOf && value.valueOf();
        if (valueOf != null && valueOf !== value) {
          return Buffer2.from(valueOf, encodingOrOffset, length);
        }
        const b = fromObject(value);
        if (b)
          return b;
        if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function") {
          return Buffer2.from(value[Symbol.toPrimitive]("string"), encodingOrOffset, length);
        }
        throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
      }
      Buffer2.from = function(value, encodingOrOffset, length) {
        return from(value, encodingOrOffset, length);
      };
      Object.setPrototypeOf(Buffer2.prototype, Uint8Array.prototype);
      Object.setPrototypeOf(Buffer2, Uint8Array);
      function assertSize(size) {
        if (typeof size !== "number") {
          throw new TypeError('"size" argument must be of type number');
        } else if (size < 0) {
          throw new RangeError('The value "' + size + '" is invalid for option "size"');
        }
      }
      function alloc(size, fill, encoding) {
        assertSize(size);
        if (size <= 0) {
          return createBuffer(size);
        }
        if (fill !== void 0) {
          return typeof encoding === "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill);
        }
        return createBuffer(size);
      }
      Buffer2.alloc = function(size, fill, encoding) {
        return alloc(size, fill, encoding);
      };
      function allocUnsafe(size) {
        assertSize(size);
        return createBuffer(size < 0 ? 0 : checked(size) | 0);
      }
      Buffer2.allocUnsafe = function(size) {
        return allocUnsafe(size);
      };
      Buffer2.allocUnsafeSlow = function(size) {
        return allocUnsafe(size);
      };
      function fromString(string, encoding) {
        if (typeof encoding !== "string" || encoding === "") {
          encoding = "utf8";
        }
        if (!Buffer2.isEncoding(encoding)) {
          throw new TypeError("Unknown encoding: " + encoding);
        }
        const length = byteLength(string, encoding) | 0;
        let buf = createBuffer(length);
        const actual = buf.write(string, encoding);
        if (actual !== length) {
          buf = buf.slice(0, actual);
        }
        return buf;
      }
      function fromArrayLike(array) {
        const length = array.length < 0 ? 0 : checked(array.length) | 0;
        const buf = createBuffer(length);
        for (let i = 0; i < length; i += 1) {
          buf[i] = array[i] & 255;
        }
        return buf;
      }
      function fromArrayView(arrayView) {
        if (isInstance(arrayView, Uint8Array)) {
          const copy = new Uint8Array(arrayView);
          return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength);
        }
        return fromArrayLike(arrayView);
      }
      function fromArrayBuffer(array, byteOffset, length) {
        if (byteOffset < 0 || array.byteLength < byteOffset) {
          throw new RangeError('"offset" is outside of buffer bounds');
        }
        if (array.byteLength < byteOffset + (length || 0)) {
          throw new RangeError('"length" is outside of buffer bounds');
        }
        let buf;
        if (byteOffset === void 0 && length === void 0) {
          buf = new Uint8Array(array);
        } else if (length === void 0) {
          buf = new Uint8Array(array, byteOffset);
        } else {
          buf = new Uint8Array(array, byteOffset, length);
        }
        Object.setPrototypeOf(buf, Buffer2.prototype);
        return buf;
      }
      function fromObject(obj) {
        if (Buffer2.isBuffer(obj)) {
          const len = checked(obj.length) | 0;
          const buf = createBuffer(len);
          if (buf.length === 0) {
            return buf;
          }
          obj.copy(buf, 0, 0, len);
          return buf;
        }
        if (obj.length !== void 0) {
          if (typeof obj.length !== "number" || numberIsNaN(obj.length)) {
            return createBuffer(0);
          }
          return fromArrayLike(obj);
        }
        if (obj.type === "Buffer" && Array.isArray(obj.data)) {
          return fromArrayLike(obj.data);
        }
      }
      function checked(length) {
        if (length >= K_MAX_LENGTH) {
          throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + K_MAX_LENGTH.toString(16) + " bytes");
        }
        return length | 0;
      }
      function SlowBuffer(length) {
        if (+length != length) {
          length = 0;
        }
        return Buffer2.alloc(+length);
      }
      Buffer2.isBuffer = function isBuffer(b) {
        return b != null && b._isBuffer === true && b !== Buffer2.prototype;
      };
      Buffer2.compare = function compare(a, b) {
        if (isInstance(a, Uint8Array))
          a = Buffer2.from(a, a.offset, a.byteLength);
        if (isInstance(b, Uint8Array))
          b = Buffer2.from(b, b.offset, b.byteLength);
        if (!Buffer2.isBuffer(a) || !Buffer2.isBuffer(b)) {
          throw new TypeError('The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array');
        }
        if (a === b)
          return 0;
        let x = a.length;
        let y = b.length;
        for (let i = 0, len = Math.min(x, y); i < len; ++i) {
          if (a[i] !== b[i]) {
            x = a[i];
            y = b[i];
            break;
          }
        }
        if (x < y)
          return -1;
        if (y < x)
          return 1;
        return 0;
      };
      Buffer2.isEncoding = function isEncoding(encoding) {
        switch (String(encoding).toLowerCase()) {
          case "hex":
          case "utf8":
          case "utf-8":
          case "ascii":
          case "latin1":
          case "binary":
          case "base64":
          case "ucs2":
          case "ucs-2":
          case "utf16le":
          case "utf-16le":
            return true;
          default:
            return false;
        }
      };
      Buffer2.concat = function concat(list, length) {
        if (!Array.isArray(list)) {
          throw new TypeError('"list" argument must be an Array of Buffers');
        }
        if (list.length === 0) {
          return Buffer2.alloc(0);
        }
        let i;
        if (length === void 0) {
          length = 0;
          for (i = 0; i < list.length; ++i) {
            length += list[i].length;
          }
        }
        const buffer = Buffer2.allocUnsafe(length);
        let pos = 0;
        for (i = 0; i < list.length; ++i) {
          let buf = list[i];
          if (isInstance(buf, Uint8Array)) {
            if (pos + buf.length > buffer.length) {
              if (!Buffer2.isBuffer(buf))
                buf = Buffer2.from(buf);
              buf.copy(buffer, pos);
            } else {
              Uint8Array.prototype.set.call(buffer, buf, pos);
            }
          } else if (!Buffer2.isBuffer(buf)) {
            throw new TypeError('"list" argument must be an Array of Buffers');
          } else {
            buf.copy(buffer, pos);
          }
          pos += buf.length;
        }
        return buffer;
      };
      function byteLength(string, encoding) {
        if (Buffer2.isBuffer(string)) {
          return string.length;
        }
        if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {
          return string.byteLength;
        }
        if (typeof string !== "string") {
          throw new TypeError('The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string);
        }
        const len = string.length;
        const mustMatch = arguments.length > 2 && arguments[2] === true;
        if (!mustMatch && len === 0)
          return 0;
        let loweredCase = false;
        for (; ; ) {
          switch (encoding) {
            case "ascii":
            case "latin1":
            case "binary":
              return len;
            case "utf8":
            case "utf-8":
              return utf8ToBytes(string).length;
            case "ucs2":
            case "ucs-2":
            case "utf16le":
            case "utf-16le":
              return len * 2;
            case "hex":
              return len >>> 1;
            case "base64":
              return base64ToBytes(string).length;
            default:
              if (loweredCase) {
                return mustMatch ? -1 : utf8ToBytes(string).length;
              }
              encoding = ("" + encoding).toLowerCase();
              loweredCase = true;
          }
        }
      }
      Buffer2.byteLength = byteLength;
      function slowToString(encoding, start2, end) {
        let loweredCase = false;
        if (start2 === void 0 || start2 < 0) {
          start2 = 0;
        }
        if (start2 > this.length) {
          return "";
        }
        if (end === void 0 || end > this.length) {
          end = this.length;
        }
        if (end <= 0) {
          return "";
        }
        end >>>= 0;
        start2 >>>= 0;
        if (end <= start2) {
          return "";
        }
        if (!encoding)
          encoding = "utf8";
        while (true) {
          switch (encoding) {
            case "hex":
              return hexSlice(this, start2, end);
            case "utf8":
            case "utf-8":
              return utf8Slice(this, start2, end);
            case "ascii":
              return asciiSlice(this, start2, end);
            case "latin1":
            case "binary":
              return latin1Slice(this, start2, end);
            case "base64":
              return base64Slice(this, start2, end);
            case "ucs2":
            case "ucs-2":
            case "utf16le":
            case "utf-16le":
              return utf16leSlice(this, start2, end);
            default:
              if (loweredCase)
                throw new TypeError("Unknown encoding: " + encoding);
              encoding = (encoding + "").toLowerCase();
              loweredCase = true;
          }
        }
      }
      Buffer2.prototype._isBuffer = true;
      function swap(b, n, m) {
        const i = b[n];
        b[n] = b[m];
        b[m] = i;
      }
      Buffer2.prototype.swap16 = function swap16() {
        const len = this.length;
        if (len % 2 !== 0) {
          throw new RangeError("Buffer size must be a multiple of 16-bits");
        }
        for (let i = 0; i < len; i += 2) {
          swap(this, i, i + 1);
        }
        return this;
      };
      Buffer2.prototype.swap32 = function swap32() {
        const len = this.length;
        if (len % 4 !== 0) {
          throw new RangeError("Buffer size must be a multiple of 32-bits");
        }
        for (let i = 0; i < len; i += 4) {
          swap(this, i, i + 3);
          swap(this, i + 1, i + 2);
        }
        return this;
      };
      Buffer2.prototype.swap64 = function swap64() {
        const len = this.length;
        if (len % 8 !== 0) {
          throw new RangeError("Buffer size must be a multiple of 64-bits");
        }
        for (let i = 0; i < len; i += 8) {
          swap(this, i, i + 7);
          swap(this, i + 1, i + 6);
          swap(this, i + 2, i + 5);
          swap(this, i + 3, i + 4);
        }
        return this;
      };
      Buffer2.prototype.toString = function toString() {
        const length = this.length;
        if (length === 0)
          return "";
        if (arguments.length === 0)
          return utf8Slice(this, 0, length);
        return slowToString.apply(this, arguments);
      };
      Buffer2.prototype.toLocaleString = Buffer2.prototype.toString;
      Buffer2.prototype.equals = function equals(b) {
        if (!Buffer2.isBuffer(b))
          throw new TypeError("Argument must be a Buffer");
        if (this === b)
          return true;
        return Buffer2.compare(this, b) === 0;
      };
      Buffer2.prototype.inspect = function inspect() {
        let str = "";
        const max = exports2.INSPECT_MAX_BYTES;
        str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim();
        if (this.length > max)
          str += " ... ";
        return "<Buffer " + str + ">";
      };
      if (customInspectSymbol) {
        Buffer2.prototype[customInspectSymbol] = Buffer2.prototype.inspect;
      }
      Buffer2.prototype.compare = function compare(target, start2, end, thisStart, thisEnd) {
        if (isInstance(target, Uint8Array)) {
          target = Buffer2.from(target, target.offset, target.byteLength);
        }
        if (!Buffer2.isBuffer(target)) {
          throw new TypeError('The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof target);
        }
        if (start2 === void 0) {
          start2 = 0;
        }
        if (end === void 0) {
          end = target ? target.length : 0;
        }
        if (thisStart === void 0) {
          thisStart = 0;
        }
        if (thisEnd === void 0) {
          thisEnd = this.length;
        }
        if (start2 < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
          throw new RangeError("out of range index");
        }
        if (thisStart >= thisEnd && start2 >= end) {
          return 0;
        }
        if (thisStart >= thisEnd) {
          return -1;
        }
        if (start2 >= end) {
          return 1;
        }
        start2 >>>= 0;
        end >>>= 0;
        thisStart >>>= 0;
        thisEnd >>>= 0;
        if (this === target)
          return 0;
        let x = thisEnd - thisStart;
        let y = end - start2;
        const len = Math.min(x, y);
        const thisCopy = this.slice(thisStart, thisEnd);
        const targetCopy = target.slice(start2, end);
        for (let i = 0; i < len; ++i) {
          if (thisCopy[i] !== targetCopy[i]) {
            x = thisCopy[i];
            y = targetCopy[i];
            break;
          }
        }
        if (x < y)
          return -1;
        if (y < x)
          return 1;
        return 0;
      };
      function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
        if (buffer.length === 0)
          return -1;
        if (typeof byteOffset === "string") {
          encoding = byteOffset;
          byteOffset = 0;
        } else if (byteOffset > 2147483647) {
          byteOffset = 2147483647;
        } else if (byteOffset < -2147483648) {
          byteOffset = -2147483648;
        }
        byteOffset = +byteOffset;
        if (numberIsNaN(byteOffset)) {
          byteOffset = dir ? 0 : buffer.length - 1;
        }
        if (byteOffset < 0)
          byteOffset = buffer.length + byteOffset;
        if (byteOffset >= buffer.length) {
          if (dir)
            return -1;
          else
            byteOffset = buffer.length - 1;
        } else if (byteOffset < 0) {
          if (dir)
            byteOffset = 0;
          else
            return -1;
        }
        if (typeof val === "string") {
          val = Buffer2.from(val, encoding);
        }
        if (Buffer2.isBuffer(val)) {
          if (val.length === 0) {
            return -1;
          }
          return arrayIndexOf(buffer, val, byteOffset, encoding, dir);
        } else if (typeof val === "number") {
          val = val & 255;
          if (typeof Uint8Array.prototype.indexOf === "function") {
            if (dir) {
              return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset);
            } else {
              return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset);
            }
          }
          return arrayIndexOf(buffer, [val], byteOffset, encoding, dir);
        }
        throw new TypeError("val must be string, number or Buffer");
      }
      function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
        let indexSize = 1;
        let arrLength = arr.length;
        let valLength = val.length;
        if (encoding !== void 0) {
          encoding = String(encoding).toLowerCase();
          if (encoding === "ucs2" || encoding === "ucs-2" || encoding === "utf16le" || encoding === "utf-16le") {
            if (arr.length < 2 || val.length < 2) {
              return -1;
            }
            indexSize = 2;
            arrLength /= 2;
            valLength /= 2;
            byteOffset /= 2;
          }
        }
        function read(buf, i2) {
          if (indexSize === 1) {
            return buf[i2];
          } else {
            return buf.readUInt16BE(i2 * indexSize);
          }
        }
        let i;
        if (dir) {
          let foundIndex = -1;
          for (i = byteOffset; i < arrLength; i++) {
            if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
              if (foundIndex === -1)
                foundIndex = i;
              if (i - foundIndex + 1 === valLength)
                return foundIndex * indexSize;
            } else {
              if (foundIndex !== -1)
                i -= i - foundIndex;
              foundIndex = -1;
            }
          }
        } else {
          if (byteOffset + valLength > arrLength)
            byteOffset = arrLength - valLength;
          for (i = byteOffset; i >= 0; i--) {
            let found = true;
            for (let j = 0; j < valLength; j++) {
              if (read(arr, i + j) !== read(val, j)) {
                found = false;
                break;
              }
            }
            if (found)
              return i;
          }
        }
        return -1;
      }
      Buffer2.prototype.includes = function includes(val, byteOffset, encoding) {
        return this.indexOf(val, byteOffset, encoding) !== -1;
      };
      Buffer2.prototype.indexOf = function indexOf2(val, byteOffset, encoding) {
        return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
      };
      Buffer2.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
        return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
      };
      function hexWrite(buf, string, offset, length) {
        offset = Number(offset) || 0;
        const remaining = buf.length - offset;
        if (!length) {
          length = remaining;
        } else {
          length = Number(length);
          if (length > remaining) {
            length = remaining;
          }
        }
        const strLen = string.length;
        if (length > strLen / 2) {
          length = strLen / 2;
        }
        let i;
        for (i = 0; i < length; ++i) {
          const parsed = parseInt(string.substr(i * 2, 2), 16);
          if (numberIsNaN(parsed))
            return i;
          buf[offset + i] = parsed;
        }
        return i;
      }
      function utf8Write(buf, string, offset, length) {
        return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);
      }
      function asciiWrite(buf, string, offset, length) {
        return blitBuffer(asciiToBytes(string), buf, offset, length);
      }
      function base64Write(buf, string, offset, length) {
        return blitBuffer(base64ToBytes(string), buf, offset, length);
      }
      function ucs2Write(buf, string, offset, length) {
        return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length);
      }
      Buffer2.prototype.write = function write(string, offset, length, encoding) {
        if (offset === void 0) {
          encoding = "utf8";
          length = this.length;
          offset = 0;
        } else if (length === void 0 && typeof offset === "string") {
          encoding = offset;
          length = this.length;
          offset = 0;
        } else if (isFinite(offset)) {
          offset = offset >>> 0;
          if (isFinite(length)) {
            length = length >>> 0;
            if (encoding === void 0)
              encoding = "utf8";
          } else {
            encoding = length;
            length = void 0;
          }
        } else {
          throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");
        }
        const remaining = this.length - offset;
        if (length === void 0 || length > remaining)
          length = remaining;
        if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) {
          throw new RangeError("Attempt to write outside buffer bounds");
        }
        if (!encoding)
          encoding = "utf8";
        let loweredCase = false;
        for (; ; ) {
          switch (encoding) {
            case "hex":
              return hexWrite(this, string, offset, length);
            case "utf8":
            case "utf-8":
              return utf8Write(this, string, offset, length);
            case "ascii":
            case "latin1":
            case "binary":
              return asciiWrite(this, string, offset, length);
            case "base64":
              return base64Write(this, string, offset, length);
            case "ucs2":
            case "ucs-2":
            case "utf16le":
            case "utf-16le":
              return ucs2Write(this, string, offset, length);
            default:
              if (loweredCase)
                throw new TypeError("Unknown encoding: " + encoding);
              encoding = ("" + encoding).toLowerCase();
              loweredCase = true;
          }
        }
      };
      Buffer2.prototype.toJSON = function toJSON() {
        return {
          type: "Buffer",
          data: Array.prototype.slice.call(this._arr || this, 0)
        };
      };
      function base64Slice(buf, start2, end) {
        if (start2 === 0 && end === buf.length) {
          return base64.fromByteArray(buf);
        } else {
          return base64.fromByteArray(buf.slice(start2, end));
        }
      }
      function utf8Slice(buf, start2, end) {
        end = Math.min(buf.length, end);
        const res = [];
        let i = start2;
        while (i < end) {
          const firstByte = buf[i];
          let codePoint = null;
          let bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
          if (i + bytesPerSequence <= end) {
            let secondByte, thirdByte, fourthByte, tempCodePoint;
            switch (bytesPerSequence) {
              case 1:
                if (firstByte < 128) {
                  codePoint = firstByte;
                }
                break;
              case 2:
                secondByte = buf[i + 1];
                if ((secondByte & 192) === 128) {
                  tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
                  if (tempCodePoint > 127) {
                    codePoint = tempCodePoint;
                  }
                }
                break;
              case 3:
                secondByte = buf[i + 1];
                thirdByte = buf[i + 2];
                if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
                  tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;
                  if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) {
                    codePoint = tempCodePoint;
                  }
                }
                break;
              case 4:
                secondByte = buf[i + 1];
                thirdByte = buf[i + 2];
                fourthByte = buf[i + 3];
                if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
                  tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;
                  if (tempCodePoint > 65535 && tempCodePoint < 1114112) {
                    codePoint = tempCodePoint;
                  }
                }
            }
          }
          if (codePoint === null) {
            codePoint = 65533;
            bytesPerSequence = 1;
          } else if (codePoint > 65535) {
            codePoint -= 65536;
            res.push(codePoint >>> 10 & 1023 | 55296);
            codePoint = 56320 | codePoint & 1023;
          }
          res.push(codePoint);
          i += bytesPerSequence;
        }
        return decodeCodePointsArray(res);
      }
      var MAX_ARGUMENTS_LENGTH = 4096;
      function decodeCodePointsArray(codePoints) {
        const len = codePoints.length;
        if (len <= MAX_ARGUMENTS_LENGTH) {
          return String.fromCharCode.apply(String, codePoints);
        }
        let res = "";
        let i = 0;
        while (i < len) {
          res += String.fromCharCode.apply(String, codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH));
        }
        return res;
      }
      function asciiSlice(buf, start2, end) {
        let ret = "";
        end = Math.min(buf.length, end);
        for (let i = start2; i < end; ++i) {
          ret += String.fromCharCode(buf[i] & 127);
        }
        return ret;
      }
      function latin1Slice(buf, start2, end) {
        let ret = "";
        end = Math.min(buf.length, end);
        for (let i = start2; i < end; ++i) {
          ret += String.fromCharCode(buf[i]);
        }
        return ret;
      }
      function hexSlice(buf, start2, end) {
        const len = buf.length;
        if (!start2 || start2 < 0)
          start2 = 0;
        if (!end || end < 0 || end > len)
          end = len;
        let out = "";
        for (let i = start2; i < end; ++i) {
          out += hexSliceLookupTable[buf[i]];
        }
        return out;
      }
      function utf16leSlice(buf, start2, end) {
        const bytes = buf.slice(start2, end);
        let res = "";
        for (let i = 0; i < bytes.length - 1; i += 2) {
          res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
        }
        return res;
      }
      Buffer2.prototype.slice = function slice(start2, end) {
        const len = this.length;
        start2 = ~~start2;
        end = end === void 0 ? len : ~~end;
        if (start2 < 0) {
          start2 += len;
          if (start2 < 0)
            start2 = 0;
        } else if (start2 > len) {
          start2 = len;
        }
        if (end < 0) {
          end += len;
          if (end < 0)
            end = 0;
        } else if (end > len) {
          end = len;
        }
        if (end < start2)
          end = start2;
        const newBuf = this.subarray(start2, end);
        Object.setPrototypeOf(newBuf, Buffer2.prototype);
        return newBuf;
      };
      function checkOffset(offset, ext, length) {
        if (offset % 1 !== 0 || offset < 0)
          throw new RangeError("offset is not uint");
        if (offset + ext > length)
          throw new RangeError("Trying to access beyond buffer length");
      }
      Buffer2.prototype.readUintLE = Buffer2.prototype.readUIntLE = function readUIntLE(offset, byteLength2, noAssert) {
        offset = offset >>> 0;
        byteLength2 = byteLength2 >>> 0;
        if (!noAssert)
          checkOffset(offset, byteLength2, this.length);
        let val = this[offset];
        let mul = 1;
        let i = 0;
        while (++i < byteLength2 && (mul *= 256)) {
          val += this[offset + i] * mul;
        }
        return val;
      };
      Buffer2.prototype.readUintBE = Buffer2.prototype.readUIntBE = function readUIntBE(offset, byteLength2, noAssert) {
        offset = offset >>> 0;
        byteLength2 = byteLength2 >>> 0;
        if (!noAssert) {
          checkOffset(offset, byteLength2, this.length);
        }
        let val = this[offset + --byteLength2];
        let mul = 1;
        while (byteLength2 > 0 && (mul *= 256)) {
          val += this[offset + --byteLength2] * mul;
        }
        return val;
      };
      Buffer2.prototype.readUint8 = Buffer2.prototype.readUInt8 = function readUInt8(offset, noAssert) {
        offset = offset >>> 0;
        if (!noAssert)
          checkOffset(offset, 1, this.length);
        return this[offset];
      };
      Buffer2.prototype.readUint16LE = Buffer2.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
        offset = offset >>> 0;
        if (!noAssert)
          checkOffset(offset, 2, this.length);
        return this[offset] | this[offset + 1] << 8;
      };
      Buffer2.prototype.readUint16BE = Buffer2.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
        offset = offset >>> 0;
        if (!noAssert)
          checkOffset(offset, 2, this.length);
        return this[offset] << 8 | this[offset + 1];
      };
      Buffer2.prototype.readUint32LE = Buffer2.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
        offset = offset >>> 0;
        if (!noAssert)
          checkOffset(offset, 4, this.length);
        return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216;
      };
      Buffer2.prototype.readUint32BE = Buffer2.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
        offset = offset >>> 0;
        if (!noAssert)
          checkOffset(offset, 4, this.length);
        return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
      };
      Buffer2.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE(offset) {
        offset = offset >>> 0;
        validateNumber(offset, "offset");
        const first = this[offset];
        const last = this[offset + 7];
        if (first === void 0 || last === void 0) {
          boundsError(offset, this.length - 8);
        }
        const lo = first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24;
        const hi = this[++offset] + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + last * 2 ** 24;
        return BigInt(lo) + (BigInt(hi) << BigInt(32));
      });
      Buffer2.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE(offset) {
        offset = offset >>> 0;
        validateNumber(offset, "offset");
        const first = this[offset];
        const last = this[offset + 7];
        if (first === void 0 || last === void 0) {
          boundsError(offset, this.length - 8);
        }
        const hi = first * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];
        const lo = this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last;
        return (BigInt(hi) << BigInt(32)) + BigInt(lo);
      });
      Buffer2.prototype.readIntLE = function readIntLE(offset, byteLength2, noAssert) {
        offset = offset >>> 0;
        byteLength2 = byteLength2 >>> 0;
        if (!noAssert)
          checkOffset(offset, byteLength2, this.length);
        let val = this[offset];
        let mul = 1;
        let i = 0;
        while (++i < byteLength2 && (mul *= 256)) {
          val += this[offset + i] * mul;
        }
        mul *= 128;
        if (val >= mul)
          val -= Math.pow(2, 8 * byteLength2);
        return val;
      };
      Buffer2.prototype.readIntBE = function readIntBE(offset, byteLength2, noAssert) {
        offset = offset >>> 0;
        byteLength2 = byteLength2 >>> 0;
        if (!noAssert)
          checkOffset(offset, byteLength2, this.length);
        let i = byteLength2;
        let mul = 1;
        let val = this[offset + --i];
        while (i > 0 && (mul *= 256)) {
          val += this[offset + --i] * mul;
        }
        mul *= 128;
        if (val >= mul)
          val -= Math.pow(2, 8 * byteLength2);
        return val;
      };
      Buffer2.prototype.readInt8 = function readInt8(offset, noAssert) {
        offset = offset >>> 0;
        if (!noAssert)
          checkOffset(offset, 1, this.length);
        if (!(this[offset] & 128))
          return this[offset];
        return (255 - this[offset] + 1) * -1;
      };
      Buffer2.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
        offset = offset >>> 0;
        if (!noAssert)
          checkOffset(offset, 2, this.length);
        const val = this[offset] | this[offset + 1] << 8;
        return val & 32768 ? val | 4294901760 : val;
      };
      Buffer2.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
        offset = offset >>> 0;
        if (!noAssert)
          checkOffset(offset, 2, this.length);
        const val = this[offset + 1] | this[offset] << 8;
        return val & 32768 ? val | 4294901760 : val;
      };
      Buffer2.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
        offset = offset >>> 0;
        if (!noAssert)
          checkOffset(offset, 4, this.length);
        return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;
      };
      Buffer2.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
        offset = offset >>> 0;
        if (!noAssert)
          checkOffset(offset, 4, this.length);
        return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
      };
      Buffer2.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE(offset) {
        offset = offset >>> 0;
        validateNumber(offset, "offset");
        const first = this[offset];
        const last = this[offset + 7];
        if (first === void 0 || last === void 0) {
          boundsError(offset, this.length - 8);
        }
        const val = this[offset + 4] + this[offset + 5] * 2 ** 8 + this[offset + 6] * 2 ** 16 + (last << 24);
        return (BigInt(val) << BigInt(32)) + BigInt(first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24);
      });
      Buffer2.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE(offset) {
        offset = offset >>> 0;
        validateNumber(offset, "offset");
        const first = this[offset];
        const last = this[offset + 7];
        if (first === void 0 || last === void 0) {
          boundsError(offset, this.length - 8);
        }
        const val = (first << 24) + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];
        return (BigInt(val) << BigInt(32)) + BigInt(this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last);
      });
      Buffer2.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
        offset = offset >>> 0;
        if (!noAssert)
          checkOffset(offset, 4, this.length);
        return ieee754.read(this, offset, true, 23, 4);
      };
      Buffer2.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
        offset = offset >>> 0;
        if (!noAssert)
          checkOffset(offset, 4, this.length);
        return ieee754.read(this, offset, false, 23, 4);
      };
      Buffer2.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
        offset = offset >>> 0;
        if (!noAssert)
          checkOffset(offset, 8, this.length);
        return ieee754.read(this, offset, true, 52, 8);
      };
      Buffer2.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
        offset = offset >>> 0;
        if (!noAssert)
          checkOffset(offset, 8, this.length);
        return ieee754.read(this, offset, false, 52, 8);
      };
      function checkInt(buf, value, offset, ext, max, min) {
        if (!Buffer2.isBuffer(buf))
          throw new TypeError('"buffer" argument must be a Buffer instance');
        if (value > max || value < min)
          throw new RangeError('"value" argument is out of bounds');
        if (offset + ext > buf.length)
          throw new RangeError("Index out of range");
      }
      Buffer2.prototype.writeUintLE = Buffer2.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength2, noAssert) {
        value = +value;
        offset = offset >>> 0;
        byteLength2 = byteLength2 >>> 0;
        if (!noAssert) {
          const maxBytes = Math.pow(2, 8 * byteLength2) - 1;
          checkInt(this, value, offset, byteLength2, maxBytes, 0);
        }
        let mul = 1;
        let i = 0;
        this[offset] = value & 255;
        while (++i < byteLength2 && (mul *= 256)) {
          this[offset + i] = value / mul & 255;
        }
        return offset + byteLength2;
      };
      Buffer2.prototype.writeUintBE = Buffer2.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength2, noAssert) {
        value = +value;
        offset = offset >>> 0;
        byteLength2 = byteLength2 >>> 0;
        if (!noAssert) {
          const maxBytes = Math.pow(2, 8 * byteLength2) - 1;
          checkInt(this, value, offset, byteLength2, maxBytes, 0);
        }
        let i = byteLength2 - 1;
        let mul = 1;
        this[offset + i] = value & 255;
        while (--i >= 0 && (mul *= 256)) {
          this[offset + i] = value / mul & 255;
        }
        return offset + byteLength2;
      };
      Buffer2.prototype.writeUint8 = Buffer2.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
        value = +value;
        offset = offset >>> 0;
        if (!noAssert)
          checkInt(this, value, offset, 1, 255, 0);
        this[offset] = value & 255;
        return offset + 1;
      };
      Buffer2.prototype.writeUint16LE = Buffer2.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
        value = +value;
        offset = offset >>> 0;
        if (!noAssert)
          checkInt(this, value, offset, 2, 65535, 0);
        this[offset] = value & 255;
        this[offset + 1] = value >>> 8;
        return offset + 2;
      };
      Buffer2.prototype.writeUint16BE = Buffer2.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
        value = +value;
        offset = offset >>> 0;
        if (!noAssert)
          checkInt(this, value, offset, 2, 65535, 0);
        this[offset] = value >>> 8;
        this[offset + 1] = value & 255;
        return offset + 2;
      };
      Buffer2.prototype.writeUint32LE = Buffer2.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
        value = +value;
        offset = offset >>> 0;
        if (!noAssert)
          checkInt(this, value, offset, 4, 4294967295, 0);
        this[offset + 3] = value >>> 24;
        this[offset + 2] = value >>> 16;
        this[offset + 1] = value >>> 8;
        this[offset] = value & 255;
        return offset + 4;
      };
      Buffer2.prototype.writeUint32BE = Buffer2.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
        value = +value;
        offset = offset >>> 0;
        if (!noAssert)
          checkInt(this, value, offset, 4, 4294967295, 0);
        this[offset] = value >>> 24;
        this[offset + 1] = value >>> 16;
        this[offset + 2] = value >>> 8;
        this[offset + 3] = value & 255;
        return offset + 4;
      };
      function wrtBigUInt64LE(buf, value, offset, min, max) {
        checkIntBI(value, min, max, buf, offset, 7);
        let lo = Number(value & BigInt(4294967295));
        buf[offset++] = lo;
        lo = lo >> 8;
        buf[offset++] = lo;
        lo = lo >> 8;
        buf[offset++] = lo;
        lo = lo >> 8;
        buf[offset++] = lo;
        let hi = Number(value >> BigInt(32) & BigInt(4294967295));
        buf[offset++] = hi;
        hi = hi >> 8;
        buf[offset++] = hi;
        hi = hi >> 8;
        buf[offset++] = hi;
        hi = hi >> 8;
        buf[offset++] = hi;
        return offset;
      }
      function wrtBigUInt64BE(buf, value, offset, min, max) {
        checkIntBI(value, min, max, buf, offset, 7);
        let lo = Number(value & BigInt(4294967295));
        buf[offset + 7] = lo;
        lo = lo >> 8;
        buf[offset + 6] = lo;
        lo = lo >> 8;
        buf[offset + 5] = lo;
        lo = lo >> 8;
        buf[offset + 4] = lo;
        let hi = Number(value >> BigInt(32) & BigInt(4294967295));
        buf[offset + 3] = hi;
        hi = hi >> 8;
        buf[offset + 2] = hi;
        hi = hi >> 8;
        buf[offset + 1] = hi;
        hi = hi >> 8;
        buf[offset] = hi;
        return offset + 8;
      }
      Buffer2.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE(value, offset = 0) {
        return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
      });
      Buffer2.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value, offset = 0) {
        return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
      });
      Buffer2.prototype.writeIntLE = function writeIntLE(value, offset, byteLength2, noAssert) {
        value = +value;
        offset = offset >>> 0;
        if (!noAssert) {
          const limit = Math.pow(2, 8 * byteLength2 - 1);
          checkInt(this, value, offset, byteLength2, limit - 1, -limit);
        }
        let i = 0;
        let mul = 1;
        let sub = 0;
        this[offset] = value & 255;
        while (++i < byteLength2 && (mul *= 256)) {
          if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
            sub = 1;
          }
          this[offset + i] = (value / mul >> 0) - sub & 255;
        }
        return offset + byteLength2;
      };
      Buffer2.prototype.writeIntBE = function writeIntBE(value, offset, byteLength2, noAssert) {
        value = +value;
        offset = offset >>> 0;
        if (!noAssert) {
          const limit = Math.pow(2, 8 * byteLength2 - 1);
          checkInt(this, value, offset, byteLength2, limit - 1, -limit);
        }
        let i = byteLength2 - 1;
        let mul = 1;
        let sub = 0;
        this[offset + i] = value & 255;
        while (--i >= 0 && (mul *= 256)) {
          if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
            sub = 1;
          }
          this[offset + i] = (value / mul >> 0) - sub & 255;
        }
        return offset + byteLength2;
      };
      Buffer2.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
        value = +value;
        offset = offset >>> 0;
        if (!noAssert)
          checkInt(this, value, offset, 1, 127, -128);
        if (value < 0)
          value = 255 + value + 1;
        this[offset] = value & 255;
        return offset + 1;
      };
      Buffer2.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {
        value = +value;
        offset = offset >>> 0;
        if (!noAssert)
          checkInt(this, value, offset, 2, 32767, -32768);
        this[offset] = value & 255;
        this[offset + 1] = value >>> 8;
        return offset + 2;
      };
      Buffer2.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {
        value = +value;
        offset = offset >>> 0;
        if (!noAssert)
          checkInt(this, value, offset, 2, 32767, -32768);
        this[offset] = value >>> 8;
        this[offset + 1] = value & 255;
        return offset + 2;
      };
      Buffer2.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {
        value = +value;
        offset = offset >>> 0;
        if (!noAssert)
          checkInt(this, value, offset, 4, 2147483647, -2147483648);
        this[offset] = value & 255;
        this[offset + 1] = value >>> 8;
        this[offset + 2] = value >>> 16;
        this[offset + 3] = value >>> 24;
        return offset + 4;
      };
      Buffer2.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {
        value = +value;
        offset = offset >>> 0;
        if (!noAssert)
          checkInt(this, value, offset, 4, 2147483647, -2147483648);
        if (value < 0)
          value = 4294967295 + value + 1;
        this[offset] = value >>> 24;
        this[offset + 1] = value >>> 16;
        this[offset + 2] = value >>> 8;
        this[offset + 3] = value & 255;
        return offset + 4;
      };
      Buffer2.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE(value, offset = 0) {
        return wrtBigUInt64LE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
      });
      Buffer2.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE(value, offset = 0) {
        return wrtBigUInt64BE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
      });
      function checkIEEE754(buf, value, offset, ext, max, min) {
        if (offset + ext > buf.length)
          throw new RangeError("Index out of range");
        if (offset < 0)
          throw new RangeError("Index out of range");
      }
      function writeFloat(buf, value, offset, littleEndian, noAssert) {
        value = +value;
        offset = offset >>> 0;
        if (!noAssert) {
          checkIEEE754(buf, value, offset, 4, 34028234663852886e22, -34028234663852886e22);
        }
        ieee754.write(buf, value, offset, littleEndian, 23, 4);
        return offset + 4;
      }
      Buffer2.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
        return writeFloat(this, value, offset, true, noAssert);
      };
      Buffer2.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {
        return writeFloat(this, value, offset, false, noAssert);
      };
      function writeDouble(buf, value, offset, littleEndian, noAssert) {
        value = +value;
        offset = offset >>> 0;
        if (!noAssert) {
          checkIEEE754(buf, value, offset, 8, 17976931348623157e292, -17976931348623157e292);
        }
        ieee754.write(buf, value, offset, littleEndian, 52, 8);
        return offset + 8;
      }
      Buffer2.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
        return writeDouble(this, value, offset, true, noAssert);
      };
      Buffer2.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
        return writeDouble(this, value, offset, false, noAssert);
      };
      Buffer2.prototype.copy = function copy(target, targetStart, start2, end) {
        if (!Buffer2.isBuffer(target))
          throw new TypeError("argument should be a Buffer");
        if (!start2)
          start2 = 0;
        if (!end && end !== 0)
          end = this.length;
        if (targetStart >= target.length)
          targetStart = target.length;
        if (!targetStart)
          targetStart = 0;
        if (end > 0 && end < start2)
          end = start2;
        if (end === start2)
          return 0;
        if (target.length === 0 || this.length === 0)
          return 0;
        if (targetStart < 0) {
          throw new RangeError("targetStart out of bounds");
        }
        if (start2 < 0 || start2 >= this.length)
          throw new RangeError("Index out of range");
        if (end < 0)
          throw new RangeError("sourceEnd out of bounds");
        if (end > this.length)
          end = this.length;
        if (target.length - targetStart < end - start2) {
          end = target.length - targetStart + start2;
        }
        const len = end - start2;
        if (this === target && typeof Uint8Array.prototype.copyWithin === "function") {
          this.copyWithin(targetStart, start2, end);
        } else {
          Uint8Array.prototype.set.call(target, this.subarray(start2, end), targetStart);
        }
        return len;
      };
      Buffer2.prototype.fill = function fill(val, start2, end, encoding) {
        if (typeof val === "string") {
          if (typeof start2 === "string") {
            encoding = start2;
            start2 = 0;
            end = this.length;
          } else if (typeof end === "string") {
            encoding = end;
            end = this.length;
          }
          if (encoding !== void 0 && typeof encoding !== "string") {
            throw new TypeError("encoding must be a string");
          }
          if (typeof encoding === "string" && !Buffer2.isEncoding(encoding)) {
            throw new TypeError("Unknown encoding: " + encoding);
          }
          if (val.length === 1) {
            const code = val.charCodeAt(0);
            if (encoding === "utf8" && code < 128 || encoding === "latin1") {
              val = code;
            }
          }
        } else if (typeof val === "number") {
          val = val & 255;
        } else if (typeof val === "boolean") {
          val = Number(val);
        }
        if (start2 < 0 || this.length < start2 || this.length < end) {
          throw new RangeError("Out of range index");
        }
        if (end <= start2) {
          return this;
        }
        start2 = start2 >>> 0;
        end = end === void 0 ? this.length : end >>> 0;
        if (!val)
          val = 0;
        let i;
        if (typeof val === "number") {
          for (i = start2; i < end; ++i) {
            this[i] = val;
          }
        } else {
          const bytes = Buffer2.isBuffer(val) ? val : Buffer2.from(val, encoding);
          const len = bytes.length;
          if (len === 0) {
            throw new TypeError('The value "' + val + '" is invalid for argument "value"');
          }
          for (i = 0; i < end - start2; ++i) {
            this[i + start2] = bytes[i % len];
          }
        }
        return this;
      };
      var errors = {};
      function E(sym, getMessage, Base) {
        errors[sym] = class NodeError extends Base {
          constructor() {
            super();
            Object.defineProperty(this, "message", {
              value: getMessage.apply(this, arguments),
              writable: true,
              configurable: true
            });
            this.name = `${this.name} [${sym}]`;
            this.stack;
            delete this.name;
          }
          get code() {
            return sym;
          }
          set code(value) {
            Object.defineProperty(this, "code", {
              configurable: true,
              enumerable: true,
              value,
              writable: true
            });
          }
          toString() {
            return `${this.name} [${sym}]: ${this.message}`;
          }
        };
      }
      E("ERR_BUFFER_OUT_OF_BOUNDS", function(name) {
        if (name) {
          return `${name} is outside of buffer bounds`;
        }
        return "Attempt to access memory outside buffer bounds";
      }, RangeError);
      E("ERR_INVALID_ARG_TYPE", function(name, actual) {
        return `The "${name}" argument must be of type number. Received type ${typeof actual}`;
      }, TypeError);
      E("ERR_OUT_OF_RANGE", function(str, range, input) {
        let msg = `The value of "${str}" is out of range.`;
        let received = input;
        if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {
          received = addNumericalSeparator(String(input));
        } else if (typeof input === "bigint") {
          received = String(input);
          if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) {
            received = addNumericalSeparator(received);
          }
          received += "n";
        }
        msg += ` It must be ${range}. Received ${received}`;
        return msg;
      }, RangeError);
      function addNumericalSeparator(val) {
        let res = "";
        let i = val.length;
        const start2 = val[0] === "-" ? 1 : 0;
        for (; i >= start2 + 4; i -= 3) {
          res = `_${val.slice(i - 3, i)}${res}`;
        }
        return `${val.slice(0, i)}${res}`;
      }
      function checkBounds(buf, offset, byteLength2) {
        validateNumber(offset, "offset");
        if (buf[offset] === void 0 || buf[offset + byteLength2] === void 0) {
          boundsError(offset, buf.length - (byteLength2 + 1));
        }
      }
      function checkIntBI(value, min, max, buf, offset, byteLength2) {
        if (value > max || value < min) {
          const n = typeof min === "bigint" ? "n" : "";
          let range;
          if (byteLength2 > 3) {
            if (min === 0 || min === BigInt(0)) {
              range = `>= 0${n} and < 2${n} ** ${(byteLength2 + 1) * 8}${n}`;
            } else {
              range = `>= -(2${n} ** ${(byteLength2 + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength2 + 1) * 8 - 1}${n}`;
            }
          } else {
            range = `>= ${min}${n} and <= ${max}${n}`;
          }
          throw new errors.ERR_OUT_OF_RANGE("value", range, value);
        }
        checkBounds(buf, offset, byteLength2);
      }
      function validateNumber(value, name) {
        if (typeof value !== "number") {
          throw new errors.ERR_INVALID_ARG_TYPE(name, "number", value);
        }
      }
      function boundsError(value, length, type) {
        if (Math.floor(value) !== value) {
          validateNumber(value, type);
          throw new errors.ERR_OUT_OF_RANGE(type || "offset", "an integer", value);
        }
        if (length < 0) {
          throw new errors.ERR_BUFFER_OUT_OF_BOUNDS();
        }
        throw new errors.ERR_OUT_OF_RANGE(type || "offset", `>= ${type ? 1 : 0} and <= ${length}`, value);
      }
      var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
      function base64clean(str) {
        str = str.split("=")[0];
        str = str.trim().replace(INVALID_BASE64_RE, "");
        if (str.length < 2)
          return "";
        while (str.length % 4 !== 0) {
          str = str + "=";
        }
        return str;
      }
      function utf8ToBytes(string, units) {
        units = units || Infinity;
        let codePoint;
        const length = string.length;
        let leadSurrogate = null;
        const bytes = [];
        for (let i = 0; i < length; ++i) {
          codePoint = string.charCodeAt(i);
          if (codePoint > 55295 && codePoint < 57344) {
            if (!leadSurrogate) {
              if (codePoint > 56319) {
                if ((units -= 3) > -1)
                  bytes.push(239, 191, 189);
                continue;
              } else if (i + 1 === length) {
                if ((units -= 3) > -1)
                  bytes.push(239, 191, 189);
                continue;
              }
              leadSurrogate = codePoint;
              continue;
            }
            if (codePoint < 56320) {
              if ((units -= 3) > -1)
                bytes.push(239, 191, 189);
              leadSurrogate = codePoint;
              continue;
            }
            codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;
          } else if (leadSurrogate) {
            if ((units -= 3) > -1)
              bytes.push(239, 191, 189);
          }
          leadSurrogate = null;
          if (codePoint < 128) {
            if ((units -= 1) < 0)
              break;
            bytes.push(codePoint);
          } else if (codePoint < 2048) {
            if ((units -= 2) < 0)
              break;
            bytes.push(codePoint >> 6 | 192, codePoint & 63 | 128);
          } else if (codePoint < 65536) {
            if ((units -= 3) < 0)
              break;
            bytes.push(codePoint >> 12 | 224, codePoint >> 6 & 63 | 128, codePoint & 63 | 128);
          } else if (codePoint < 1114112) {
            if ((units -= 4) < 0)
              break;
            bytes.push(codePoint >> 18 | 240, codePoint >> 12 & 63 | 128, codePoint >> 6 & 63 | 128, codePoint & 63 | 128);
          } else {
            throw new Error("Invalid code point");
          }
        }
        return bytes;
      }
      function asciiToBytes(str) {
        const byteArray = [];
        for (let i = 0; i < str.length; ++i) {
          byteArray.push(str.charCodeAt(i) & 255);
        }
        return byteArray;
      }
      function utf16leToBytes(str, units) {
        let c, hi, lo;
        const byteArray = [];
        for (let i = 0; i < str.length; ++i) {
          if ((units -= 2) < 0)
            break;
          c = str.charCodeAt(i);
          hi = c >> 8;
          lo = c % 256;
          byteArray.push(lo);
          byteArray.push(hi);
        }
        return byteArray;
      }
      function base64ToBytes(str) {
        return base64.toByteArray(base64clean(str));
      }
      function blitBuffer(src, dst, offset, length) {
        let i;
        for (i = 0; i < length; ++i) {
          if (i + offset >= dst.length || i >= src.length)
            break;
          dst[i + offset] = src[i];
        }
        return i;
      }
      function isInstance(obj, type) {
        return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name;
      }
      function numberIsNaN(obj) {
        return obj !== obj;
      }
      var hexSliceLookupTable = function() {
        const alphabet = "0123456789abcdef";
        const table = new Array(256);
        for (let i = 0; i < 16; ++i) {
          const i16 = i * 16;
          for (let j = 0; j < 16; ++j) {
            table[i16 + j] = alphabet[i] + alphabet[j];
          }
        }
        return table;
      }();
      function defineBigIntMethod(fn) {
        return typeof BigInt === "undefined" ? BufferBigIntNotDefined : fn;
      }
      function BufferBigIntNotDefined() {
        throw new Error("BigInt not supported");
      }
    }
  });

  // node_modules/safe-buffer/index.js
  var require_safe_buffer = __commonJS({
    "node_modules/safe-buffer/index.js"(exports2, module2) {
      var buffer = require_buffer2();
      var Buffer2 = buffer.Buffer;
      function copyProps(src, dst) {
        for (var key in src) {
          dst[key] = src[key];
        }
      }
      if (Buffer2.from && Buffer2.alloc && Buffer2.allocUnsafe && Buffer2.allocUnsafeSlow) {
        module2.exports = buffer;
      } else {
        copyProps(buffer, exports2);
        exports2.Buffer = SafeBuffer;
      }
      function SafeBuffer(arg, encodingOrOffset, length) {
        return Buffer2(arg, encodingOrOffset, length);
      }
      SafeBuffer.prototype = Object.create(Buffer2.prototype);
      copyProps(Buffer2, SafeBuffer);
      SafeBuffer.from = function(arg, encodingOrOffset, length) {
        if (typeof arg === "number") {
          throw new TypeError("Argument must not be a number");
        }
        return Buffer2(arg, encodingOrOffset, length);
      };
      SafeBuffer.alloc = function(size, fill, encoding) {
        if (typeof size !== "number") {
          throw new TypeError("Argument must be a number");
        }
        var buf = Buffer2(size);
        if (fill !== void 0) {
          if (typeof encoding === "string") {
            buf.fill(fill, encoding);
          } else {
            buf.fill(fill);
          }
        } else {
          buf.fill(0);
        }
        return buf;
      };
      SafeBuffer.allocUnsafe = function(size) {
        if (typeof size !== "number") {
          throw new TypeError("Argument must be a number");
        }
        return Buffer2(size);
      };
      SafeBuffer.allocUnsafeSlow = function(size) {
        if (typeof size !== "number") {
          throw new TypeError("Argument must be a number");
        }
        return buffer.SlowBuffer(size);
      };
    }
  });

  // node_modules/randombytes/browser.js
  var require_browser = __commonJS({
    "node_modules/randombytes/browser.js"(exports2, module2) {
      "use strict";
      var MAX_BYTES = 65536;
      var MAX_UINT32 = 4294967295;
      function oldBrowser() {
        throw new Error("Secure random number generation is not supported by this browser.\nUse Chrome, Firefox or Internet Explorer 11");
      }
      var Buffer2 = require_safe_buffer().Buffer;
      var crypto = global.crypto || global.msCrypto;
      if (crypto && crypto.getRandomValues) {
        module2.exports = randomBytes;
      } else {
        module2.exports = oldBrowser;
      }
      function randomBytes(size, cb) {
        if (size > MAX_UINT32)
          throw new RangeError("requested too many random bytes");
        var bytes = Buffer2.allocUnsafe(size);
        if (size > 0) {
          if (size > MAX_BYTES) {
            for (var generated = 0; generated < size; generated += MAX_BYTES) {
              crypto.getRandomValues(bytes.slice(generated, generated + MAX_BYTES));
            }
          } else {
            crypto.getRandomValues(bytes);
          }
        }
        if (typeof cb === "function") {
          return process.nextTick(function() {
            cb(null, bytes);
          });
        }
        return bytes;
      }
    }
  });

  // node_modules/inherits/inherits_browser.js
  var require_inherits_browser = __commonJS({
    "node_modules/inherits/inherits_browser.js"(exports2, module2) {
      if (typeof Object.create === "function") {
        module2.exports = function inherits(ctor, superCtor) {
          if (superCtor) {
            ctor.super_ = superCtor;
            ctor.prototype = Object.create(superCtor.prototype, {
              constructor: {
                value: ctor,
                enumerable: false,
                writable: true,
                configurable: true
              }
            });
          }
        };
      } else {
        module2.exports = function inherits(ctor, superCtor) {
          if (superCtor) {
            ctor.super_ = superCtor;
            var TempCtor = function() {
            };
            TempCtor.prototype = superCtor.prototype;
            ctor.prototype = new TempCtor();
            ctor.prototype.constructor = ctor;
          }
        };
      }
    }
  });

  // node_modules/events/events.js
  var require_events = __commonJS({
    "node_modules/events/events.js"(exports2, module2) {
      "use strict";
      var R = typeof Reflect === "object" ? Reflect : null;
      var ReflectApply = R && typeof R.apply === "function" ? R.apply : function ReflectApply2(target, receiver, args) {
        return Function.prototype.apply.call(target, receiver, args);
      };
      var ReflectOwnKeys;
      if (R && typeof R.ownKeys === "function") {
        ReflectOwnKeys = R.ownKeys;
      } else if (Object.getOwnPropertySymbols) {
        ReflectOwnKeys = function ReflectOwnKeys2(target) {
          return Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target));
        };
      } else {
        ReflectOwnKeys = function ReflectOwnKeys2(target) {
          return Object.getOwnPropertyNames(target);
        };
      }
      function ProcessEmitWarning(warning) {
        if (console && console.warn)
          console.warn(warning);
      }
      var NumberIsNaN = Number.isNaN || function NumberIsNaN2(value) {
        return value !== value;
      };
      function EventEmitter() {
        EventEmitter.init.call(this);
      }
      module2.exports = EventEmitter;
      module2.exports.once = once;
      EventEmitter.EventEmitter = EventEmitter;
      EventEmitter.prototype._events = void 0;
      EventEmitter.prototype._eventsCount = 0;
      EventEmitter.prototype._maxListeners = void 0;
      var defaultMaxListeners = 10;
      function checkListener(listener) {
        if (typeof listener !== "function") {
          throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
        }
      }
      Object.defineProperty(EventEmitter, "defaultMaxListeners", {
        enumerable: true,
        get: function() {
          return defaultMaxListeners;
        },
        set: function(arg) {
          if (typeof arg !== "number" || arg < 0 || NumberIsNaN(arg)) {
            throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + ".");
          }
          defaultMaxListeners = arg;
        }
      });
      EventEmitter.init = function() {
        if (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) {
          this._events = /* @__PURE__ */ Object.create(null);
          this._eventsCount = 0;
        }
        this._maxListeners = this._maxListeners || void 0;
      };
      EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
        if (typeof n !== "number" || n < 0 || NumberIsNaN(n)) {
          throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + ".");
        }
        this._maxListeners = n;
        return this;
      };
      function _getMaxListeners(that) {
        if (that._maxListeners === void 0)
          return EventEmitter.defaultMaxListeners;
        return that._maxListeners;
      }
      EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
        return _getMaxListeners(this);
      };
      EventEmitter.prototype.emit = function emit(type) {
        var args = [];
        for (var i = 1; i < arguments.length; i++)
          args.push(arguments[i]);
        var doError = type === "error";
        var events = this._events;
        if (events !== void 0)
          doError = doError && events.error === void 0;
        else if (!doError)
          return false;
        if (doError) {
          var er;
          if (args.length > 0)
            er = args[0];
          if (er instanceof Error) {
            throw er;
          }
          var err = new Error("Unhandled error." + (er ? " (" + er.message + ")" : ""));
          err.context = er;
          throw err;
        }
        var handler = events[type];
        if (handler === void 0)
          return false;
        if (typeof handler === "function") {
          ReflectApply(handler, this, args);
        } else {
          var len = handler.length;
          var listeners = arrayClone(handler, len);
          for (var i = 0; i < len; ++i)
            ReflectApply(listeners[i], this, args);
        }
        return true;
      };
      function _addListener(target, type, listener, prepend) {
        var m;
        var events;
        var existing;
        checkListener(listener);
        events = target._events;
        if (events === void 0) {
          events = target._events = /* @__PURE__ */ Object.create(null);
          target._eventsCount = 0;
        } else {
          if (events.newListener !== void 0) {
            target.emit("newListener", type, listener.listener ? listener.listener : listener);
            events = target._events;
          }
          existing = events[type];
        }
        if (existing === void 0) {
          existing = events[type] = listener;
          ++target._eventsCount;
        } else {
          if (typeof existing === "function") {
            existing = events[type] = prepend ? [listener, existing] : [existing, listener];
          } else if (prepend) {
            existing.unshift(listener);
          } else {
            existing.push(listener);
          }
          m = _getMaxListeners(target);
          if (m > 0 && existing.length > m && !existing.warned) {
            existing.warned = true;
            var w = new Error("Possible EventEmitter memory leak detected. " + existing.length + " " + String(type) + " listeners added. Use emitter.setMaxListeners() to increase limit");
            w.name = "MaxListenersExceededWarning";
            w.emitter = target;
            w.type = type;
            w.count = existing.length;
            ProcessEmitWarning(w);
          }
        }
        return target;
      }
      EventEmitter.prototype.addListener = function addListener(type, listener) {
        return _addListener(this, type, listener, false);
      };
      EventEmitter.prototype.on = EventEmitter.prototype.addListener;
      EventEmitter.prototype.prependListener = function prependListener(type, listener) {
        return _addListener(this, type, listener, true);
      };
      function onceWrapper() {
        if (!this.fired) {
          this.target.removeListener(this.type, this.wrapFn);
          this.fired = true;
          if (arguments.length === 0)
            return this.listener.call(this.target);
          return this.listener.apply(this.target, arguments);
        }
      }
      function _onceWrap(target, type, listener) {
        var state = { fired: false, wrapFn: void 0, target, type, listener };
        var wrapped = onceWrapper.bind(state);
        wrapped.listener = listener;
        state.wrapFn = wrapped;
        return wrapped;
      }
      EventEmitter.prototype.once = function once2(type, listener) {
        checkListener(listener);
        this.on(type, _onceWrap(this, type, listener));
        return this;
      };
      EventEmitter.prototype.prependOnceListener = function prependOnceListener(type, listener) {
        checkListener(listener);
        this.prependListener(type, _onceWrap(this, type, listener));
        return this;
      };
      EventEmitter.prototype.removeListener = function removeListener(type, listener) {
        var list, events, position, i, originalListener;
        checkListener(listener);
        events = this._events;
        if (events === void 0)
          return this;
        list = events[type];
        if (list === void 0)
          return this;
        if (list === listener || list.listener === listener) {
          if (--this._eventsCount === 0)
            this._events = /* @__PURE__ */ Object.create(null);
          else {
            delete events[type];
            if (events.removeListener)
              this.emit("removeListener", type, list.listener || listener);
          }
        } else if (typeof list !== "function") {
          position = -1;
          for (i = list.length - 1; i >= 0; i--) {
            if (list[i] === listener || list[i].listener === listener) {
              originalListener = list[i].listener;
              position = i;
              break;
            }
          }
          if (position < 0)
            return this;
          if (position === 0)
            list.shift();
          else {
            spliceOne(list, position);
          }
          if (list.length === 1)
            events[type] = list[0];
          if (events.removeListener !== void 0)
            this.emit("removeListener", type, originalListener || listener);
        }
        return this;
      };
      EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
      EventEmitter.prototype.removeAllListeners = function removeAllListeners(type) {
        var listeners, events, i;
        events = this._events;
        if (events === void 0)
          return this;
        if (events.removeListener === void 0) {
          if (arguments.length === 0) {
            this._events = /* @__PURE__ */ Object.create(null);
            this._eventsCount = 0;
          } else if (events[type] !== void 0) {
            if (--this._eventsCount === 0)
              this._events = /* @__PURE__ */ Object.create(null);
            else
              delete events[type];
          }
          return this;
        }
        if (arguments.length === 0) {
          var keys = Object.keys(events);
          var key;
          for (i = 0; i < keys.length; ++i) {
            key = keys[i];
            if (key === "removeListener")
              continue;
            this.removeAllListeners(key);
          }
          this.removeAllListeners("removeListener");
          this._events = /* @__PURE__ */ Object.create(null);
          this._eventsCount = 0;
          return this;
        }
        listeners = events[type];
        if (typeof listeners === "function") {
          this.removeListener(type, listeners);
        } else if (listeners !== void 0) {
          for (i = listeners.length - 1; i >= 0; i--) {
            this.removeListener(type, listeners[i]);
          }
        }
        return this;
      };
      function _listeners(target, type, unwrap) {
        var events = target._events;
        if (events === void 0)
          return [];
        var evlistener = events[type];
        if (evlistener === void 0)
          return [];
        if (typeof evlistener === "function")
          return unwrap ? [evlistener.listener || evlistener] : [evlistener];
        return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
      }
      EventEmitter.prototype.listeners = function listeners(type) {
        return _listeners(this, type, true);
      };
      EventEmitter.prototype.rawListeners = function rawListeners(type) {
        return _listeners(this, type, false);
      };
      EventEmitter.listenerCount = function(emitter, type) {
        if (typeof emitter.listenerCount === "function") {
          return emitter.listenerCount(type);
        } else {
          return listenerCount.call(emitter, type);
        }
      };
      EventEmitter.prototype.listenerCount = listenerCount;
      function listenerCount(type) {
        var events = this._events;
        if (events !== void 0) {
          var evlistener = events[type];
          if (typeof evlistener === "function") {
            return 1;
          } else if (evlistener !== void 0) {
            return evlistener.length;
          }
        }
        return 0;
      }
      EventEmitter.prototype.eventNames = function eventNames() {
        return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
      };
      function arrayClone(arr, n) {
        var copy = new Array(n);
        for (var i = 0; i < n; ++i)
          copy[i] = arr[i];
        return copy;
      }
      function spliceOne(list, index) {
        for (; index + 1 < list.length; index++)
          list[index] = list[index + 1];
        list.pop();
      }
      function unwrapListeners(arr) {
        var ret = new Array(arr.length);
        for (var i = 0; i < ret.length; ++i) {
          ret[i] = arr[i].listener || arr[i];
        }
        return ret;
      }
      function once(emitter, name) {
        return new Promise(function(resolve, reject) {
          function errorListener(err) {
            emitter.removeListener(name, resolver);
            reject(err);
          }
          function resolver() {
            if (typeof emitter.removeListener === "function") {
              emitter.removeListener("error", errorListener);
            }
            resolve([].slice.call(arguments));
          }
          ;
          eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
          if (name !== "error") {
            addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
          }
        });
      }
      function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
        if (typeof emitter.on === "function") {
          eventTargetAgnosticAddListener(emitter, "error", handler, flags);
        }
      }
      function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
        if (typeof emitter.on === "function") {
          if (flags.once) {
            emitter.once(name, listener);
          } else {
            emitter.on(name, listener);
          }
        } else if (typeof emitter.addEventListener === "function") {
          emitter.addEventListener(name, function wrapListener(arg) {
            if (flags.once) {
              emitter.removeEventListener(name, wrapListener);
            }
            listener(arg);
          });
        } else {
          throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
        }
      }
    }
  });

  // node_modules/readable-stream/lib/internal/streams/stream-browser.js
  var require_stream_browser = __commonJS({
    "node_modules/readable-stream/lib/internal/streams/stream-browser.js"(exports2, module2) {
      module2.exports = require_events().EventEmitter;
    }
  });

  // (disabled):util
  var require_util = __commonJS({
    "(disabled):util"() {
    }
  });

  // node_modules/readable-stream/lib/internal/streams/buffer_list.js
  var require_buffer_list = __commonJS({
    "node_modules/readable-stream/lib/internal/streams/buffer_list.js"(exports2, module2) {
      "use strict";
      function ownKeys(object, enumerableOnly) {
        var keys = Object.keys(object);
        if (Object.getOwnPropertySymbols) {
          var symbols = Object.getOwnPropertySymbols(object);
          if (enumerableOnly)
            symbols = symbols.filter(function(sym) {
              return Object.getOwnPropertyDescriptor(object, sym).enumerable;
            });
          keys.push.apply(keys, symbols);
        }
        return keys;
      }
      function _objectSpread(target) {
        for (var i = 1; i < arguments.length; i++) {
          var source = arguments[i] != null ? arguments[i] : {};
          if (i % 2) {
            ownKeys(Object(source), true).forEach(function(key) {
              _defineProperty(target, key, source[key]);
            });
          } else if (Object.getOwnPropertyDescriptors) {
            Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
          } else {
            ownKeys(Object(source)).forEach(function(key) {
              Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
            });
          }
        }
        return target;
      }
      function _defineProperty(obj, key, value) {
        if (key in obj) {
          Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
        } else {
          obj[key] = value;
        }
        return obj;
      }
      function _classCallCheck(instance, Constructor) {
        if (!(instance instanceof Constructor)) {
          throw new TypeError("Cannot call a class as a function");
        }
      }
      function _defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor)
            descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }
      function _createClass(Constructor, protoProps, staticProps) {
        if (protoProps)
          _defineProperties(Constructor.prototype, protoProps);
        if (staticProps)
          _defineProperties(Constructor, staticProps);
        return Constructor;
      }
      var _require = require_buffer2();
      var Buffer2 = _require.Buffer;
      var _require2 = require_util();
      var inspect = _require2.inspect;
      var custom = inspect && inspect.custom || "inspect";
      function copyBuffer(src, target, offset) {
        Buffer2.prototype.copy.call(src, target, offset);
      }
      module2.exports = /* @__PURE__ */ function() {
        function BufferList() {
          _classCallCheck(this, BufferList);
          this.head = null;
          this.tail = null;
          this.length = 0;
        }
        _createClass(BufferList, [{
          key: "push",
          value: function push(v) {
            var entry = {
              data: v,
              next: null
            };
            if (this.length > 0)
              this.tail.next = entry;
            else
              this.head = entry;
            this.tail = entry;
            ++this.length;
          }
        }, {
          key: "unshift",
          value: function unshift(v) {
            var entry = {
              data: v,
              next: this.head
            };
            if (this.length === 0)
              this.tail = entry;
            this.head = entry;
            ++this.length;
          }
        }, {
          key: "shift",
          value: function shift() {
            if (this.length === 0)
              return;
            var ret = this.head.data;
            if (this.length === 1)
              this.head = this.tail = null;
            else
              this.head = this.head.next;
            --this.length;
            return ret;
          }
        }, {
          key: "clear",
          value: function clear() {
            this.head = this.tail = null;
            this.length = 0;
          }
        }, {
          key: "join",
          value: function join(s) {
            if (this.length === 0)
              return "";
            var p = this.head;
            var ret = "" + p.data;
            while (p = p.next) {
              ret += s + p.data;
            }
            return ret;
          }
        }, {
          key: "concat",
          value: function concat(n) {
            if (this.length === 0)
              return Buffer2.alloc(0);
            var ret = Buffer2.allocUnsafe(n >>> 0);
            var p = this.head;
            var i = 0;
            while (p) {
              copyBuffer(p.data, ret, i);
              i += p.data.length;
              p = p.next;
            }
            return ret;
          }
        }, {
          key: "consume",
          value: function consume(n, hasStrings) {
            var ret;
            if (n < this.head.data.length) {
              ret = this.head.data.slice(0, n);
              this.head.data = this.head.data.slice(n);
            } else if (n === this.head.data.length) {
              ret = this.shift();
            } else {
              ret = hasStrings ? this._getString(n) : this._getBuffer(n);
            }
            return ret;
          }
        }, {
          key: "first",
          value: function first() {
            return this.head.data;
          }
        }, {
          key: "_getString",
          value: function _getString(n) {
            var p = this.head;
            var c = 1;
            var ret = p.data;
            n -= ret.length;
            while (p = p.next) {
              var str = p.data;
              var nb = n > str.length ? str.length : n;
              if (nb === str.length)
                ret += str;
              else
                ret += str.slice(0, n);
              n -= nb;
              if (n === 0) {
                if (nb === str.length) {
                  ++c;
                  if (p.next)
                    this.head = p.next;
                  else
                    this.head = this.tail = null;
                } else {
                  this.head = p;
                  p.data = str.slice(nb);
                }
                break;
              }
              ++c;
            }
            this.length -= c;
            return ret;
          }
        }, {
          key: "_getBuffer",
          value: function _getBuffer(n) {
            var ret = Buffer2.allocUnsafe(n);
            var p = this.head;
            var c = 1;
            p.data.copy(ret);
            n -= p.data.length;
            while (p = p.next) {
              var buf = p.data;
              var nb = n > buf.length ? buf.length : n;
              buf.copy(ret, ret.length - n, 0, nb);
              n -= nb;
              if (n === 0) {
                if (nb === buf.length) {
                  ++c;
                  if (p.next)
                    this.head = p.next;
                  else
                    this.head = this.tail = null;
                } else {
                  this.head = p;
                  p.data = buf.slice(nb);
                }
                break;
              }
              ++c;
            }
            this.length -= c;
            return ret;
          }
        }, {
          key: custom,
          value: function value(_, options) {
            return inspect(this, _objectSpread({}, options, {
              depth: 0,
              customInspect: false
            }));
          }
        }]);
        return BufferList;
      }();
    }
  });

  // node_modules/readable-stream/lib/internal/streams/destroy.js
  var require_destroy = __commonJS({
    "node_modules/readable-stream/lib/internal/streams/destroy.js"(exports2, module2) {
      "use strict";
      function destroy(err, cb) {
        var _this = this;
        var readableDestroyed = this._readableState && this._readableState.destroyed;
        var writableDestroyed = this._writableState && this._writableState.destroyed;
        if (readableDestroyed || writableDestroyed) {
          if (cb) {
            cb(err);
          } else if (err) {
            if (!this._writableState) {
              process.nextTick(emitErrorNT, this, err);
            } else if (!this._writableState.errorEmitted) {
              this._writableState.errorEmitted = true;
              process.nextTick(emitErrorNT, this, err);
            }
          }
          return this;
        }
        if (this._readableState) {
          this._readableState.destroyed = true;
        }
        if (this._writableState) {
          this._writableState.destroyed = true;
        }
        this._destroy(err || null, function(err2) {
          if (!cb && err2) {
            if (!_this._writableState) {
              process.nextTick(emitErrorAndCloseNT, _this, err2);
            } else if (!_this._writableState.errorEmitted) {
              _this._writableState.errorEmitted = true;
              process.nextTick(emitErrorAndCloseNT, _this, err2);
            } else {
              process.nextTick(emitCloseNT, _this);
            }
          } else if (cb) {
            process.nextTick(emitCloseNT, _this);
            cb(err2);
          } else {
            process.nextTick(emitCloseNT, _this);
          }
        });
        return this;
      }
      function emitErrorAndCloseNT(self2, err) {
        emitErrorNT(self2, err);
        emitCloseNT(self2);
      }
      function emitCloseNT(self2) {
        if (self2._writableState && !self2._writableState.emitClose)
          return;
        if (self2._readableState && !self2._readableState.emitClose)
          return;
        self2.emit("close");
      }
      function undestroy() {
        if (this._readableState) {
          this._readableState.destroyed = false;
          this._readableState.reading = false;
          this._readableState.ended = false;
          this._readableState.endEmitted = false;
        }
        if (this._writableState) {
          this._writableState.destroyed = false;
          this._writableState.ended = false;
          this._writableState.ending = false;
          this._writableState.finalCalled = false;
          this._writableState.prefinished = false;
          this._writableState.finished = false;
          this._writableState.errorEmitted = false;
        }
      }
      function emitErrorNT(self2, err) {
        self2.emit("error", err);
      }
      function errorOrDestroy(stream, err) {
        var rState = stream._readableState;
        var wState = stream._writableState;
        if (rState && rState.autoDestroy || wState && wState.autoDestroy)
          stream.destroy(err);
        else
          stream.emit("error", err);
      }
      module2.exports = {
        destroy,
        undestroy,
        errorOrDestroy
      };
    }
  });

  // node_modules/readable-stream/errors-browser.js
  var require_errors_browser = __commonJS({
    "node_modules/readable-stream/errors-browser.js"(exports2, module2) {
      "use strict";
      function _inheritsLoose(subClass, superClass) {
        subClass.prototype = Object.create(superClass.prototype);
        subClass.prototype.constructor = subClass;
        subClass.__proto__ = superClass;
      }
      var codes = {};
      function createErrorType(code, message, Base) {
        if (!Base) {
          Base = Error;
        }
        function getMessage(arg1, arg2, arg3) {
          if (typeof message === "string") {
            return message;
          } else {
            return message(arg1, arg2, arg3);
          }
        }
        var NodeError = /* @__PURE__ */ function(_Base) {
          _inheritsLoose(NodeError2, _Base);
          function NodeError2(arg1, arg2, arg3) {
            return _Base.call(this, getMessage(arg1, arg2, arg3)) || this;
          }
          return NodeError2;
        }(Base);
        NodeError.prototype.name = Base.name;
        NodeError.prototype.code = code;
        codes[code] = NodeError;
      }
      function oneOf(expected, thing) {
        if (Array.isArray(expected)) {
          var len = expected.length;
          expected = expected.map(function(i) {
            return String(i);
          });
          if (len > 2) {
            return "one of ".concat(thing, " ").concat(expected.slice(0, len - 1).join(", "), ", or ") + expected[len - 1];
          } else if (len === 2) {
            return "one of ".concat(thing, " ").concat(expected[0], " or ").concat(expected[1]);
          } else {
            return "of ".concat(thing, " ").concat(expected[0]);
          }
        } else {
          return "of ".concat(thing, " ").concat(String(expected));
        }
      }
      function startsWith(str, search, pos) {
        return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;
      }
      function endsWith(str, search, this_len) {
        if (this_len === void 0 || this_len > str.length) {
          this_len = str.length;
        }
        return str.substring(this_len - search.length, this_len) === search;
      }
      function includes(str, search, start2) {
        if (typeof start2 !== "number") {
          start2 = 0;
        }
        if (start2 + search.length > str.length) {
          return false;
        } else {
          return str.indexOf(search, start2) !== -1;
        }
      }
      createErrorType("ERR_INVALID_OPT_VALUE", function(name, value) {
        return 'The value "' + value + '" is invalid for option "' + name + '"';
      }, TypeError);
      createErrorType("ERR_INVALID_ARG_TYPE", function(name, expected, actual) {
        var determiner;
        if (typeof expected === "string" && startsWith(expected, "not ")) {
          determiner = "must not be";
          expected = expected.replace(/^not /, "");
        } else {
          determiner = "must be";
        }
        var msg;
        if (endsWith(name, " argument")) {
          msg = "The ".concat(name, " ").concat(determiner, " ").concat(oneOf(expected, "type"));
        } else {
          var type = includes(name, ".") ? "property" : "argument";
          msg = 'The "'.concat(name, '" ').concat(type, " ").concat(determiner, " ").concat(oneOf(expected, "type"));
        }
        msg += ". Received type ".concat(typeof actual);
        return msg;
      }, TypeError);
      createErrorType("ERR_STREAM_PUSH_AFTER_EOF", "stream.push() after EOF");
      createErrorType("ERR_METHOD_NOT_IMPLEMENTED", function(name) {
        return "The " + name + " method is not implemented";
      });
      createErrorType("ERR_STREAM_PREMATURE_CLOSE", "Premature close");
      createErrorType("ERR_STREAM_DESTROYED", function(name) {
        return "Cannot call " + name + " after a stream was destroyed";
      });
      createErrorType("ERR_MULTIPLE_CALLBACK", "Callback called multiple times");
      createErrorType("ERR_STREAM_CANNOT_PIPE", "Cannot pipe, not readable");
      createErrorType("ERR_STREAM_WRITE_AFTER_END", "write after end");
      createErrorType("ERR_STREAM_NULL_VALUES", "May not write null values to stream", TypeError);
      createErrorType("ERR_UNKNOWN_ENCODING", function(arg) {
        return "Unknown encoding: " + arg;
      }, TypeError);
      createErrorType("ERR_STREAM_UNSHIFT_AFTER_END_EVENT", "stream.unshift() after end event");
      module2.exports.codes = codes;
    }
  });

  // node_modules/readable-stream/lib/internal/streams/state.js
  var require_state = __commonJS({
    "node_modules/readable-stream/lib/internal/streams/state.js"(exports2, module2) {
      "use strict";
      var ERR_INVALID_OPT_VALUE = require_errors_browser().codes.ERR_INVALID_OPT_VALUE;
      function highWaterMarkFrom(options, isDuplex, duplexKey) {
        return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;
      }
      function getHighWaterMark(state, options, duplexKey, isDuplex) {
        var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);
        if (hwm != null) {
          if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {
            var name = isDuplex ? duplexKey : "highWaterMark";
            throw new ERR_INVALID_OPT_VALUE(name, hwm);
          }
          return Math.floor(hwm);
        }
        return state.objectMode ? 16 : 16 * 1024;
      }
      module2.exports = {
        getHighWaterMark
      };
    }
  });

  // node_modules/util-deprecate/browser.js
  var require_browser2 = __commonJS({
    "node_modules/util-deprecate/browser.js"(exports2, module2) {
      module2.exports = deprecate;
      function deprecate(fn, msg) {
        if (config("noDeprecation")) {
          return fn;
        }
        var warned = false;
        function deprecated() {
          if (!warned) {
            if (config("throwDeprecation")) {
              throw new Error(msg);
            } else if (config("traceDeprecation")) {
              console.trace(msg);
            } else {
              console.warn(msg);
            }
            warned = true;
          }
          return fn.apply(this, arguments);
        }
        return deprecated;
      }
      function config(name) {
        try {
          if (!global.localStorage)
            return false;
        } catch (_) {
          return false;
        }
        var val = global.localStorage[name];
        if (val == null)
          return false;
        return String(val).toLowerCase() === "true";
      }
    }
  });

  // node_modules/readable-stream/lib/_stream_writable.js
  var require_stream_writable = __commonJS({
    "node_modules/readable-stream/lib/_stream_writable.js"(exports2, module2) {
      "use strict";
      module2.exports = Writable;
      function CorkedRequest(state) {
        var _this = this;
        this.next = null;
        this.entry = null;
        this.finish = function() {
          onCorkedFinish(_this, state);
        };
      }
      var Duplex;
      Writable.WritableState = WritableState;
      var internalUtil = {
        deprecate: require_browser2()
      };
      var Stream = require_stream_browser();
      var Buffer2 = require_buffer2().Buffer;
      var OurUint8Array = global.Uint8Array || function() {
      };
      function _uint8ArrayToBuffer(chunk) {
        return Buffer2.from(chunk);
      }
      function _isUint8Array(obj) {
        return Buffer2.isBuffer(obj) || obj instanceof OurUint8Array;
      }
      var destroyImpl = require_destroy();
      var _require = require_state();
      var getHighWaterMark = _require.getHighWaterMark;
      var _require$codes = require_errors_browser().codes;
      var ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE;
      var ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED;
      var ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK;
      var ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE;
      var ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;
      var ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES;
      var ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END;
      var ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;
      var errorOrDestroy = destroyImpl.errorOrDestroy;
      require_inherits_browser()(Writable, Stream);
      function nop() {
      }
      function WritableState(options, stream, isDuplex) {
        Duplex = Duplex || require_stream_duplex();
        options = options || {};
        if (typeof isDuplex !== "boolean")
          isDuplex = stream instanceof Duplex;
        this.objectMode = !!options.objectMode;
        if (isDuplex)
          this.objectMode = this.objectMode || !!options.writableObjectMode;
        this.highWaterMark = getHighWaterMark(this, options, "writableHighWaterMark", isDuplex);
        this.finalCalled = false;
        this.needDrain = false;
        this.ending = false;
        this.ended = false;
        this.finished = false;
        this.destroyed = false;
        var noDecode = options.decodeStrings === false;
        this.decodeStrings = !noDecode;
        this.defaultEncoding = options.defaultEncoding || "utf8";
        this.length = 0;
        this.writing = false;
        this.corked = 0;
        this.sync = true;
        this.bufferProcessing = false;
        this.onwrite = function(er) {
          onwrite(stream, er);
        };
        this.writecb = null;
        this.writelen = 0;
        this.bufferedRequest = null;
        this.lastBufferedRequest = null;
        this.pendingcb = 0;
        this.prefinished = false;
        this.errorEmitted = false;
        this.emitClose = options.emitClose !== false;
        this.autoDestroy = !!options.autoDestroy;
        this.bufferedRequestCount = 0;
        this.corkedRequestsFree = new CorkedRequest(this);
      }
      WritableState.prototype.getBuffer = function getBuffer() {
        var current = this.bufferedRequest;
        var out = [];
        while (current) {
          out.push(current);
          current = current.next;
        }
        return out;
      };
      (function() {
        try {
          Object.defineProperty(WritableState.prototype, "buffer", {
            get: internalUtil.deprecate(function writableStateBufferGetter() {
              return this.getBuffer();
            }, "_writableState.buffer is deprecated. Use _writableState.getBuffer instead.", "DEP0003")
          });
        } catch (_) {
        }
      })();
      var realHasInstance;
      if (typeof Symbol === "function" && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === "function") {
        realHasInstance = Function.prototype[Symbol.hasInstance];
        Object.defineProperty(Writable, Symbol.hasInstance, {
          value: function value(object) {
            if (realHasInstance.call(this, object))
              return true;
            if (this !== Writable)
              return false;
            return object && object._writableState instanceof WritableState;
          }
        });
      } else {
        realHasInstance = function realHasInstance2(object) {
          return object instanceof this;
        };
      }
      function Writable(options) {
        Duplex = Duplex || require_stream_duplex();
        var isDuplex = this instanceof Duplex;
        if (!isDuplex && !realHasInstance.call(Writable, this))
          return new Writable(options);
        this._writableState = new WritableState(options, this, isDuplex);
        this.writable = true;
        if (options) {
          if (typeof options.write === "function")
            this._write = options.write;
          if (typeof options.writev === "function")
            this._writev = options.writev;
          if (typeof options.destroy === "function")
            this._destroy = options.destroy;
          if (typeof options.final === "function")
            this._final = options.final;
        }
        Stream.call(this);
      }
      Writable.prototype.pipe = function() {
        errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());
      };
      function writeAfterEnd(stream, cb) {
        var er = new ERR_STREAM_WRITE_AFTER_END();
        errorOrDestroy(stream, er);
        process.nextTick(cb, er);
      }
      function validChunk(stream, state, chunk, cb) {
        var er;
        if (chunk === null) {
          er = new ERR_STREAM_NULL_VALUES();
        } else if (typeof chunk !== "string" && !state.objectMode) {
          er = new ERR_INVALID_ARG_TYPE("chunk", ["string", "Buffer"], chunk);
        }
        if (er) {
          errorOrDestroy(stream, er);
          process.nextTick(cb, er);
          return false;
        }
        return true;
      }
      Writable.prototype.write = function(chunk, encoding, cb) {
        var state = this._writableState;
        var ret = false;
        var isBuf = !state.objectMode && _isUint8Array(chunk);
        if (isBuf && !Buffer2.isBuffer(chunk)) {
          chunk = _uint8ArrayToBuffer(chunk);
        }
        if (typeof encoding === "function") {
          cb = encoding;
          encoding = null;
        }
        if (isBuf)
          encoding = "buffer";
        else if (!encoding)
          encoding = state.defaultEncoding;
        if (typeof cb !== "function")
          cb = nop;
        if (state.ending)
          writeAfterEnd(this, cb);
        else if (isBuf || validChunk(this, state, chunk, cb)) {
          state.pendingcb++;
          ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
        }
        return ret;
      };
      Writable.prototype.cork = function() {
        this._writableState.corked++;
      };
      Writable.prototype.uncork = function() {
        var state = this._writableState;
        if (state.corked) {
          state.corked--;
          if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest)
            clearBuffer(this, state);
        }
      };
      Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
        if (typeof encoding === "string")
          encoding = encoding.toLowerCase();
        if (!(["hex", "utf8", "utf-8", "ascii", "binary", "base64", "ucs2", "ucs-2", "utf16le", "utf-16le", "raw"].indexOf((encoding + "").toLowerCase()) > -1))
          throw new ERR_UNKNOWN_ENCODING(encoding);
        this._writableState.defaultEncoding = encoding;
        return this;
      };
      Object.defineProperty(Writable.prototype, "writableBuffer", {
        enumerable: false,
        get: function get() {
          return this._writableState && this._writableState.getBuffer();
        }
      });
      function decodeChunk(state, chunk, encoding) {
        if (!state.objectMode && state.decodeStrings !== false && typeof chunk === "string") {
          chunk = Buffer2.from(chunk, encoding);
        }
        return chunk;
      }
      Object.defineProperty(Writable.prototype, "writableHighWaterMark", {
        enumerable: false,
        get: function get() {
          return this._writableState.highWaterMark;
        }
      });
      function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
        if (!isBuf) {
          var newChunk = decodeChunk(state, chunk, encoding);
          if (chunk !== newChunk) {
            isBuf = true;
            encoding = "buffer";
            chunk = newChunk;
          }
        }
        var len = state.objectMode ? 1 : chunk.length;
        state.length += len;
        var ret = state.length < state.highWaterMark;
        if (!ret)
          state.needDrain = true;
        if (state.writing || state.corked) {
          var last = state.lastBufferedRequest;
          state.lastBufferedRequest = {
            chunk,
            encoding,
            isBuf,
            callback: cb,
            next: null
          };
          if (last) {
            last.next = state.lastBufferedRequest;
          } else {
            state.bufferedRequest = state.lastBufferedRequest;
          }
          state.bufferedRequestCount += 1;
        } else {
          doWrite(stream, state, false, len, chunk, encoding, cb);
        }
        return ret;
      }
      function doWrite(stream, state, writev, len, chunk, encoding, cb) {
        state.writelen = len;
        state.writecb = cb;
        state.writing = true;
        state.sync = true;
        if (state.destroyed)
          state.onwrite(new ERR_STREAM_DESTROYED("write"));
        else if (writev)
          stream._writev(chunk, state.onwrite);
        else
          stream._write(chunk, encoding, state.onwrite);
        state.sync = false;
      }
      function onwriteError(stream, state, sync, er, cb) {
        --state.pendingcb;
        if (sync) {
          process.nextTick(cb, er);
          process.nextTick(finishMaybe, stream, state);
          stream._writableState.errorEmitted = true;
          errorOrDestroy(stream, er);
        } else {
          cb(er);
          stream._writableState.errorEmitted = true;
          errorOrDestroy(stream, er);
          finishMaybe(stream, state);
        }
      }
      function onwriteStateUpdate(state) {
        state.writing = false;
        state.writecb = null;
        state.length -= state.writelen;
        state.writelen = 0;
      }
      function onwrite(stream, er) {
        var state = stream._writableState;
        var sync = state.sync;
        var cb = state.writecb;
        if (typeof cb !== "function")
          throw new ERR_MULTIPLE_CALLBACK();
        onwriteStateUpdate(state);
        if (er)
          onwriteError(stream, state, sync, er, cb);
        else {
          var finished = needFinish(state) || stream.destroyed;
          if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
            clearBuffer(stream, state);
          }
          if (sync) {
            process.nextTick(afterWrite, stream, state, finished, cb);
          } else {
            afterWrite(stream, state, finished, cb);
          }
        }
      }
      function afterWrite(stream, state, finished, cb) {
        if (!finished)
          onwriteDrain(stream, state);
        state.pendingcb--;
        cb();
        finishMaybe(stream, state);
      }
      function onwriteDrain(stream, state) {
        if (state.length === 0 && state.needDrain) {
          state.needDrain = false;
          stream.emit("drain");
        }
      }
      function clearBuffer(stream, state) {
        state.bufferProcessing = true;
        var entry = state.bufferedRequest;
        if (stream._writev && entry && entry.next) {
          var l = state.bufferedRequestCount;
          var buffer = new Array(l);
          var holder = state.corkedRequestsFree;
          holder.entry = entry;
          var count = 0;
          var allBuffers = true;
          while (entry) {
            buffer[count] = entry;
            if (!entry.isBuf)
              allBuffers = false;
            entry = entry.next;
            count += 1;
          }
          buffer.allBuffers = allBuffers;
          doWrite(stream, state, true, state.length, buffer, "", holder.finish);
          state.pendingcb++;
          state.lastBufferedRequest = null;
          if (holder.next) {
            state.corkedRequestsFree = holder.next;
            holder.next = null;
          } else {
            state.corkedRequestsFree = new CorkedRequest(state);
          }
          state.bufferedRequestCount = 0;
        } else {
          while (entry) {
            var chunk = entry.chunk;
            var encoding = entry.encoding;
            var cb = entry.callback;
            var len = state.objectMode ? 1 : chunk.length;
            doWrite(stream, state, false, len, chunk, encoding, cb);
            entry = entry.next;
            state.bufferedRequestCount--;
            if (state.writing) {
              break;
            }
          }
          if (entry === null)
            state.lastBufferedRequest = null;
        }
        state.bufferedRequest = entry;
        state.bufferProcessing = false;
      }
      Writable.prototype._write = function(chunk, encoding, cb) {
        cb(new ERR_METHOD_NOT_IMPLEMENTED("_write()"));
      };
      Writable.prototype._writev = null;
      Writable.prototype.end = function(chunk, encoding, cb) {
        var state = this._writableState;
        if (typeof chunk === "function") {
          cb = chunk;
          chunk = null;
          encoding = null;
        } else if (typeof encoding === "function") {
          cb = encoding;
          encoding = null;
        }
        if (chunk !== null && chunk !== void 0)
          this.write(chunk, encoding);
        if (state.corked) {
          state.corked = 1;
          this.uncork();
        }
        if (!state.ending)
          endWritable(this, state, cb);
        return this;
      };
      Object.defineProperty(Writable.prototype, "writableLength", {
        enumerable: false,
        get: function get() {
          return this._writableState.length;
        }
      });
      function needFinish(state) {
        return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
      }
      function callFinal(stream, state) {
        stream._final(function(err) {
          state.pendingcb--;
          if (err) {
            errorOrDestroy(stream, err);
          }
          state.prefinished = true;
          stream.emit("prefinish");
          finishMaybe(stream, state);
        });
      }
      function prefinish(stream, state) {
        if (!state.prefinished && !state.finalCalled) {
          if (typeof stream._final === "function" && !state.destroyed) {
            state.pendingcb++;
            state.finalCalled = true;
            process.nextTick(callFinal, stream, state);
          } else {
            state.prefinished = true;
            stream.emit("prefinish");
          }
        }
      }
      function finishMaybe(stream, state) {
        var need = needFinish(state);
        if (need) {
          prefinish(stream, state);
          if (state.pendingcb === 0) {
            state.finished = true;
            stream.emit("finish");
            if (state.autoDestroy) {
              var rState = stream._readableState;
              if (!rState || rState.autoDestroy && rState.endEmitted) {
                stream.destroy();
              }
            }
          }
        }
        return need;
      }
      function endWritable(stream, state, cb) {
        state.ending = true;
        finishMaybe(stream, state);
        if (cb) {
          if (state.finished)
            process.nextTick(cb);
          else
            stream.once("finish", cb);
        }
        state.ended = true;
        stream.writable = false;
      }
      function onCorkedFinish(corkReq, state, err) {
        var entry = corkReq.entry;
        corkReq.entry = null;
        while (entry) {
          var cb = entry.callback;
          state.pendingcb--;
          cb(err);
          entry = entry.next;
        }
        state.corkedRequestsFree.next = corkReq;
      }
      Object.defineProperty(Writable.prototype, "destroyed", {
        enumerable: false,
        get: function get() {
          if (this._writableState === void 0) {
            return false;
          }
          return this._writableState.destroyed;
        },
        set: function set(value) {
          if (!this._writableState) {
            return;
          }
          this._writableState.destroyed = value;
        }
      });
      Writable.prototype.destroy = destroyImpl.destroy;
      Writable.prototype._undestroy = destroyImpl.undestroy;
      Writable.prototype._destroy = function(err, cb) {
        cb(err);
      };
    }
  });

  // node_modules/readable-stream/lib/_stream_duplex.js
  var require_stream_duplex = __commonJS({
    "node_modules/readable-stream/lib/_stream_duplex.js"(exports2, module2) {
      "use strict";
      var objectKeys = Object.keys || function(obj) {
        var keys2 = [];
        for (var key in obj) {
          keys2.push(key);
        }
        return keys2;
      };
      module2.exports = Duplex;
      var Readable = require_stream_readable();
      var Writable = require_stream_writable();
      require_inherits_browser()(Duplex, Readable);
      {
        keys = objectKeys(Writable.prototype);
        for (v = 0; v < keys.length; v++) {
          method = keys[v];
          if (!Duplex.prototype[method])
            Duplex.prototype[method] = Writable.prototype[method];
        }
      }
      var keys;
      var method;
      var v;
      function Duplex(options) {
        if (!(this instanceof Duplex))
          return new Duplex(options);
        Readable.call(this, options);
        Writable.call(this, options);
        this.allowHalfOpen = true;
        if (options) {
          if (options.readable === false)
            this.readable = false;
          if (options.writable === false)
            this.writable = false;
          if (options.allowHalfOpen === false) {
            this.allowHalfOpen = false;
            this.once("end", onend);
          }
        }
      }
      Object.defineProperty(Duplex.prototype, "writableHighWaterMark", {
        enumerable: false,
        get: function get() {
          return this._writableState.highWaterMark;
        }
      });
      Object.defineProperty(Duplex.prototype, "writableBuffer", {
        enumerable: false,
        get: function get() {
          return this._writableState && this._writableState.getBuffer();
        }
      });
      Object.defineProperty(Duplex.prototype, "writableLength", {
        enumerable: false,
        get: function get() {
          return this._writableState.length;
        }
      });
      function onend() {
        if (this._writableState.ended)
          return;
        process.nextTick(onEndNT, this);
      }
      function onEndNT(self2) {
        self2.end();
      }
      Object.defineProperty(Duplex.prototype, "destroyed", {
        enumerable: false,
        get: function get() {
          if (this._readableState === void 0 || this._writableState === void 0) {
            return false;
          }
          return this._readableState.destroyed && this._writableState.destroyed;
        },
        set: function set(value) {
          if (this._readableState === void 0 || this._writableState === void 0) {
            return;
          }
          this._readableState.destroyed = value;
          this._writableState.destroyed = value;
        }
      });
    }
  });

  // node_modules/string_decoder/lib/string_decoder.js
  var require_string_decoder = __commonJS({
    "node_modules/string_decoder/lib/string_decoder.js"(exports2) {
      "use strict";
      var Buffer2 = require_safe_buffer().Buffer;
      var isEncoding = Buffer2.isEncoding || function(encoding) {
        encoding = "" + encoding;
        switch (encoding && encoding.toLowerCase()) {
          case "hex":
          case "utf8":
          case "utf-8":
          case "ascii":
          case "binary":
          case "base64":
          case "ucs2":
          case "ucs-2":
          case "utf16le":
          case "utf-16le":
          case "raw":
            return true;
          default:
            return false;
        }
      };
      function _normalizeEncoding(enc) {
        if (!enc)
          return "utf8";
        var retried;
        while (true) {
          switch (enc) {
            case "utf8":
            case "utf-8":
              return "utf8";
            case "ucs2":
            case "ucs-2":
            case "utf16le":
            case "utf-16le":
              return "utf16le";
            case "latin1":
            case "binary":
              return "latin1";
            case "base64":
            case "ascii":
            case "hex":
              return enc;
            default:
              if (retried)
                return;
              enc = ("" + enc).toLowerCase();
              retried = true;
          }
        }
      }
      function normalizeEncoding(enc) {
        var nenc = _normalizeEncoding(enc);
        if (typeof nenc !== "string" && (Buffer2.isEncoding === isEncoding || !isEncoding(enc)))
          throw new Error("Unknown encoding: " + enc);
        return nenc || enc;
      }
      exports2.StringDecoder = StringDecoder;
      function StringDecoder(encoding) {
        this.encoding = normalizeEncoding(encoding);
        var nb;
        switch (this.encoding) {
          case "utf16le":
            this.text = utf16Text;
            this.end = utf16End;
            nb = 4;
            break;
          case "utf8":
            this.fillLast = utf8FillLast;
            nb = 4;
            break;
          case "base64":
            this.text = base64Text;
            this.end = base64End;
            nb = 3;
            break;
          default:
            this.write = simpleWrite;
            this.end = simpleEnd;
            return;
        }
        this.lastNeed = 0;
        this.lastTotal = 0;
        this.lastChar = Buffer2.allocUnsafe(nb);
      }
      StringDecoder.prototype.write = function(buf) {
        if (buf.length === 0)
          return "";
        var r;
        var i;
        if (this.lastNeed) {
          r = this.fillLast(buf);
          if (r === void 0)
            return "";
          i = this.lastNeed;
          this.lastNeed = 0;
        } else {
          i = 0;
        }
        if (i < buf.length)
          return r ? r + this.text(buf, i) : this.text(buf, i);
        return r || "";
      };
      StringDecoder.prototype.end = utf8End;
      StringDecoder.prototype.text = utf8Text;
      StringDecoder.prototype.fillLast = function(buf) {
        if (this.lastNeed <= buf.length) {
          buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
          return this.lastChar.toString(this.encoding, 0, this.lastTotal);
        }
        buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
        this.lastNeed -= buf.length;
      };
      function utf8CheckByte(byte) {
        if (byte <= 127)
          return 0;
        else if (byte >> 5 === 6)
          return 2;
        else if (byte >> 4 === 14)
          return 3;
        else if (byte >> 3 === 30)
          return 4;
        return byte >> 6 === 2 ? -1 : -2;
      }
      function utf8CheckIncomplete(self2, buf, i) {
        var j = buf.length - 1;
        if (j < i)
          return 0;
        var nb = utf8CheckByte(buf[j]);
        if (nb >= 0) {
          if (nb > 0)
            self2.lastNeed = nb - 1;
          return nb;
        }
        if (--j < i || nb === -2)
          return 0;
        nb = utf8CheckByte(buf[j]);
        if (nb >= 0) {
          if (nb > 0)
            self2.lastNeed = nb - 2;
          return nb;
        }
        if (--j < i || nb === -2)
          return 0;
        nb = utf8CheckByte(buf[j]);
        if (nb >= 0) {
          if (nb > 0) {
            if (nb === 2)
              nb = 0;
            else
              self2.lastNeed = nb - 3;
          }
          return nb;
        }
        return 0;
      }
      function utf8CheckExtraBytes(self2, buf, p) {
        if ((buf[0] & 192) !== 128) {
          self2.lastNeed = 0;
          return "\uFFFD";
        }
        if (self2.lastNeed > 1 && buf.length > 1) {
          if ((buf[1] & 192) !== 128) {
            self2.lastNeed = 1;
            return "\uFFFD";
          }
          if (self2.lastNeed > 2 && buf.length > 2) {
            if ((buf[2] & 192) !== 128) {
              self2.lastNeed = 2;
              return "\uFFFD";
            }
          }
        }
      }
      function utf8FillLast(buf) {
        var p = this.lastTotal - this.lastNeed;
        var r = utf8CheckExtraBytes(this, buf, p);
        if (r !== void 0)
          return r;
        if (this.lastNeed <= buf.length) {
          buf.copy(this.lastChar, p, 0, this.lastNeed);
          return this.lastChar.toString(this.encoding, 0, this.lastTotal);
        }
        buf.copy(this.lastChar, p, 0, buf.length);
        this.lastNeed -= buf.length;
      }
      function utf8Text(buf, i) {
        var total = utf8CheckIncomplete(this, buf, i);
        if (!this.lastNeed)
          return buf.toString("utf8", i);
        this.lastTotal = total;
        var end = buf.length - (total - this.lastNeed);
        buf.copy(this.lastChar, 0, end);
        return buf.toString("utf8", i, end);
      }
      function utf8End(buf) {
        var r = buf && buf.length ? this.write(buf) : "";
        if (this.lastNeed)
          return r + "\uFFFD";
        return r;
      }
      function utf16Text(buf, i) {
        if ((buf.length - i) % 2 === 0) {
          var r = buf.toString("utf16le", i);
          if (r) {
            var c = r.charCodeAt(r.length - 1);
            if (c >= 55296 && c <= 56319) {
              this.lastNeed = 2;
              this.lastTotal = 4;
              this.lastChar[0] = buf[buf.length - 2];
              this.lastChar[1] = buf[buf.length - 1];
              return r.slice(0, -1);
            }
          }
          return r;
        }
        this.lastNeed = 1;
        this.lastTotal = 2;
        this.lastChar[0] = buf[buf.length - 1];
        return buf.toString("utf16le", i, buf.length - 1);
      }
      function utf16End(buf) {
        var r = buf && buf.length ? this.write(buf) : "";
        if (this.lastNeed) {
          var end = this.lastTotal - this.lastNeed;
          return r + this.lastChar.toString("utf16le", 0, end);
        }
        return r;
      }
      function base64Text(buf, i) {
        var n = (buf.length - i) % 3;
        if (n === 0)
          return buf.toString("base64", i);
        this.lastNeed = 3 - n;
        this.lastTotal = 3;
        if (n === 1) {
          this.lastChar[0] = buf[buf.length - 1];
        } else {
          this.lastChar[0] = buf[buf.length - 2];
          this.lastChar[1] = buf[buf.length - 1];
        }
        return buf.toString("base64", i, buf.length - n);
      }
      function base64End(buf) {
        var r = buf && buf.length ? this.write(buf) : "";
        if (this.lastNeed)
          return r + this.lastChar.toString("base64", 0, 3 - this.lastNeed);
        return r;
      }
      function simpleWrite(buf) {
        return buf.toString(this.encoding);
      }
      function simpleEnd(buf) {
        return buf && buf.length ? this.write(buf) : "";
      }
    }
  });

  // node_modules/readable-stream/lib/internal/streams/end-of-stream.js
  var require_end_of_stream = __commonJS({
    "node_modules/readable-stream/lib/internal/streams/end-of-stream.js"(exports2, module2) {
      "use strict";
      var ERR_STREAM_PREMATURE_CLOSE = require_errors_browser().codes.ERR_STREAM_PREMATURE_CLOSE;
      function once(callback) {
        var called = false;
        return function() {
          if (called)
            return;
          called = true;
          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
            args[_key] = arguments[_key];
          }
          callback.apply(this, args);
        };
      }
      function noop() {
      }
      function isRequest(stream) {
        return stream.setHeader && typeof stream.abort === "function";
      }
      function eos(stream, opts, callback) {
        if (typeof opts === "function")
          return eos(stream, null, opts);
        if (!opts)
          opts = {};
        callback = once(callback || noop);
        var readable = opts.readable || opts.readable !== false && stream.readable;
        var writable = opts.writable || opts.writable !== false && stream.writable;
        var onlegacyfinish = function onlegacyfinish2() {
          if (!stream.writable)
            onfinish();
        };
        var writableEnded = stream._writableState && stream._writableState.finished;
        var onfinish = function onfinish2() {
          writable = false;
          writableEnded = true;
          if (!readable)
            callback.call(stream);
        };
        var readableEnded = stream._readableState && stream._readableState.endEmitted;
        var onend = function onend2() {
          readable = false;
          readableEnded = true;
          if (!writable)
            callback.call(stream);
        };
        var onerror = function onerror2(err) {
          callback.call(stream, err);
        };
        var onclose = function onclose2() {
          var err;
          if (readable && !readableEnded) {
            if (!stream._readableState || !stream._readableState.ended)
              err = new ERR_STREAM_PREMATURE_CLOSE();
            return callback.call(stream, err);
          }
          if (writable && !writableEnded) {
            if (!stream._writableState || !stream._writableState.ended)
              err = new ERR_STREAM_PREMATURE_CLOSE();
            return callback.call(stream, err);
          }
        };
        var onrequest = function onrequest2() {
          stream.req.on("finish", onfinish);
        };
        if (isRequest(stream)) {
          stream.on("complete", onfinish);
          stream.on("abort", onclose);
          if (stream.req)
            onrequest();
          else
            stream.on("request", onrequest);
        } else if (writable && !stream._writableState) {
          stream.on("end", onlegacyfinish);
          stream.on("close", onlegacyfinish);
        }
        stream.on("end", onend);
        stream.on("finish", onfinish);
        if (opts.error !== false)
          stream.on("error", onerror);
        stream.on("close", onclose);
        return function() {
          stream.removeListener("complete", onfinish);
          stream.removeListener("abort", onclose);
          stream.removeListener("request", onrequest);
          if (stream.req)
            stream.req.removeListener("finish", onfinish);
          stream.removeListener("end", onlegacyfinish);
          stream.removeListener("close", onlegacyfinish);
          stream.removeListener("finish", onfinish);
          stream.removeListener("end", onend);
          stream.removeListener("error", onerror);
          stream.removeListener("close", onclose);
        };
      }
      module2.exports = eos;
    }
  });

  // node_modules/readable-stream/lib/internal/streams/async_iterator.js
  var require_async_iterator = __commonJS({
    "node_modules/readable-stream/lib/internal/streams/async_iterator.js"(exports2, module2) {
      "use strict";
      var _Object$setPrototypeO;
      function _defineProperty(obj, key, value) {
        if (key in obj) {
          Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
        } else {
          obj[key] = value;
        }
        return obj;
      }
      var finished = require_end_of_stream();
      var kLastResolve = Symbol("lastResolve");
      var kLastReject = Symbol("lastReject");
      var kError = Symbol("error");
      var kEnded = Symbol("ended");
      var kLastPromise = Symbol("lastPromise");
      var kHandlePromise = Symbol("handlePromise");
      var kStream = Symbol("stream");
      function createIterResult(value, done) {
        return {
          value,
          done
        };
      }
      function readAndResolve(iter) {
        var resolve = iter[kLastResolve];
        if (resolve !== null) {
          var data = iter[kStream].read();
          if (data !== null) {
            iter[kLastPromise] = null;
            iter[kLastResolve] = null;
            iter[kLastReject] = null;
            resolve(createIterResult(data, false));
          }
        }
      }
      function onReadable(iter) {
        process.nextTick(readAndResolve, iter);
      }
      function wrapForNext(lastPromise, iter) {
        return function(resolve, reject) {
          lastPromise.then(function() {
            if (iter[kEnded]) {
              resolve(createIterResult(void 0, true));
              return;
            }
            iter[kHandlePromise](resolve, reject);
          }, reject);
        };
      }
      var AsyncIteratorPrototype = Object.getPrototypeOf(function() {
      });
      var ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = {
        get stream() {
          return this[kStream];
        },
        next: function next() {
          var _this = this;
          var error = this[kError];
          if (error !== null) {
            return Promise.reject(error);
          }
          if (this[kEnded]) {
            return Promise.resolve(createIterResult(void 0, true));
          }
          if (this[kStream].destroyed) {
            return new Promise(function(resolve, reject) {
              process.nextTick(function() {
                if (_this[kError]) {
                  reject(_this[kError]);
                } else {
                  resolve(createIterResult(void 0, true));
                }
              });
            });
          }
          var lastPromise = this[kLastPromise];
          var promise;
          if (lastPromise) {
            promise = new Promise(wrapForNext(lastPromise, this));
          } else {
            var data = this[kStream].read();
            if (data !== null) {
              return Promise.resolve(createIterResult(data, false));
            }
            promise = new Promise(this[kHandlePromise]);
          }
          this[kLastPromise] = promise;
          return promise;
        }
      }, _defineProperty(_Object$setPrototypeO, Symbol.asyncIterator, function() {
        return this;
      }), _defineProperty(_Object$setPrototypeO, "return", function _return() {
        var _this2 = this;
        return new Promise(function(resolve, reject) {
          _this2[kStream].destroy(null, function(err) {
            if (err) {
              reject(err);
              return;
            }
            resolve(createIterResult(void 0, true));
          });
        });
      }), _Object$setPrototypeO), AsyncIteratorPrototype);
      var createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator2(stream) {
        var _Object$create;
        var iterator = Object.create(ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, _defineProperty(_Object$create, kStream, {
          value: stream,
          writable: true
        }), _defineProperty(_Object$create, kLastResolve, {
          value: null,
          writable: true
        }), _defineProperty(_Object$create, kLastReject, {
          value: null,
          writable: true
        }), _defineProperty(_Object$create, kError, {
          value: null,
          writable: true
        }), _defineProperty(_Object$create, kEnded, {
          value: stream._readableState.endEmitted,
          writable: true
        }), _defineProperty(_Object$create, kHandlePromise, {
          value: function value(resolve, reject) {
            var data = iterator[kStream].read();
            if (data) {
              iterator[kLastPromise] = null;
              iterator[kLastResolve] = null;
              iterator[kLastReject] = null;
              resolve(createIterResult(data, false));
            } else {
              iterator[kLastResolve] = resolve;
              iterator[kLastReject] = reject;
            }
          },
          writable: true
        }), _Object$create));
        iterator[kLastPromise] = null;
        finished(stream, function(err) {
          if (err && err.code !== "ERR_STREAM_PREMATURE_CLOSE") {
            var reject = iterator[kLastReject];
            if (reject !== null) {
              iterator[kLastPromise] = null;
              iterator[kLastResolve] = null;
              iterator[kLastReject] = null;
              reject(err);
            }
            iterator[kError] = err;
            return;
          }
          var resolve = iterator[kLastResolve];
          if (resolve !== null) {
            iterator[kLastPromise] = null;
            iterator[kLastResolve] = null;
            iterator[kLastReject] = null;
            resolve(createIterResult(void 0, true));
          }
          iterator[kEnded] = true;
        });
        stream.on("readable", onReadable.bind(null, iterator));
        return iterator;
      };
      module2.exports = createReadableStreamAsyncIterator;
    }
  });

  // node_modules/readable-stream/lib/internal/streams/from-browser.js
  var require_from_browser = __commonJS({
    "node_modules/readable-stream/lib/internal/streams/from-browser.js"(exports2, module2) {
      module2.exports = function() {
        throw new Error("Readable.from is not available in the browser");
      };
    }
  });

  // node_modules/readable-stream/lib/_stream_readable.js
  var require_stream_readable = __commonJS({
    "node_modules/readable-stream/lib/_stream_readable.js"(exports2, module2) {
      "use strict";
      module2.exports = Readable;
      var Duplex;
      Readable.ReadableState = ReadableState;
      var EE = require_events().EventEmitter;
      var EElistenerCount = function EElistenerCount2(emitter, type) {
        return emitter.listeners(type).length;
      };
      var Stream = require_stream_browser();
      var Buffer2 = require_buffer2().Buffer;
      var OurUint8Array = global.Uint8Array || function() {
      };
      function _uint8ArrayToBuffer(chunk) {
        return Buffer2.from(chunk);
      }
      function _isUint8Array(obj) {
        return Buffer2.isBuffer(obj) || obj instanceof OurUint8Array;
      }
      var debugUtil = require_util();
      var debug;
      if (debugUtil && debugUtil.debuglog) {
        debug = debugUtil.debuglog("stream");
      } else {
        debug = function debug2() {
        };
      }
      var BufferList = require_buffer_list();
      var destroyImpl = require_destroy();
      var _require = require_state();
      var getHighWaterMark = _require.getHighWaterMark;
      var _require$codes = require_errors_browser().codes;
      var ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE;
      var ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF;
      var ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED;
      var ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT;
      var StringDecoder;
      var createReadableStreamAsyncIterator;
      var from;
      require_inherits_browser()(Readable, Stream);
      var errorOrDestroy = destroyImpl.errorOrDestroy;
      var kProxyEvents = ["error", "close", "destroy", "pause", "resume"];
      function prependListener(emitter, event, fn) {
        if (typeof emitter.prependListener === "function")
          return emitter.prependListener(event, fn);
        if (!emitter._events || !emitter._events[event])
          emitter.on(event, fn);
        else if (Array.isArray(emitter._events[event]))
          emitter._events[event].unshift(fn);
        else
          emitter._events[event] = [fn, emitter._events[event]];
      }
      function ReadableState(options, stream, isDuplex) {
        Duplex = Duplex || require_stream_duplex();
        options = options || {};
        if (typeof isDuplex !== "boolean")
          isDuplex = stream instanceof Duplex;
        this.objectMode = !!options.objectMode;
        if (isDuplex)
          this.objectMode = this.objectMode || !!options.readableObjectMode;
        this.highWaterMark = getHighWaterMark(this, options, "readableHighWaterMark", isDuplex);
        this.buffer = new BufferList();
        this.length = 0;
        this.pipes = null;
        this.pipesCount = 0;
        this.flowing = null;
        this.ended = false;
        this.endEmitted = false;
        this.reading = false;
        this.sync = true;
        this.needReadable = false;
        this.emittedReadable = false;
        this.readableListening = false;
        this.resumeScheduled = false;
        this.paused = true;
        this.emitClose = options.emitClose !== false;
        this.autoDestroy = !!options.autoDestroy;
        this.destroyed = false;
        this.defaultEncoding = options.defaultEncoding || "utf8";
        this.awaitDrain = 0;
        this.readingMore = false;
        this.decoder = null;
        this.encoding = null;
        if (options.encoding) {
          if (!StringDecoder)
            StringDecoder = require_string_decoder().StringDecoder;
          this.decoder = new StringDecoder(options.encoding);
          this.encoding = options.encoding;
        }
      }
      function Readable(options) {
        Duplex = Duplex || require_stream_duplex();
        if (!(this instanceof Readable))
          return new Readable(options);
        var isDuplex = this instanceof Duplex;
        this._readableState = new ReadableState(options, this, isDuplex);
        this.readable = true;
        if (options) {
          if (typeof options.read === "function")
            this._read = options.read;
          if (typeof options.destroy === "function")
            this._destroy = options.destroy;
        }
        Stream.call(this);
      }
      Object.defineProperty(Readable.prototype, "destroyed", {
        enumerable: false,
        get: function get() {
          if (this._readableState === void 0) {
            return false;
          }
          return this._readableState.destroyed;
        },
        set: function set(value) {
          if (!this._readableState) {
            return;
          }
          this._readableState.destroyed = value;
        }
      });
      Readable.prototype.destroy = destroyImpl.destroy;
      Readable.prototype._undestroy = destroyImpl.undestroy;
      Readable.prototype._destroy = function(err, cb) {
        cb(err);
      };
      Readable.prototype.push = function(chunk, encoding) {
        var state = this._readableState;
        var skipChunkCheck;
        if (!state.objectMode) {
          if (typeof chunk === "string") {
            encoding = encoding || state.defaultEncoding;
            if (encoding !== state.encoding) {
              chunk = Buffer2.from(chunk, encoding);
              encoding = "";
            }
            skipChunkCheck = true;
          }
        } else {
          skipChunkCheck = true;
        }
        return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
      };
      Readable.prototype.unshift = function(chunk) {
        return readableAddChunk(this, chunk, null, true, false);
      };
      function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
        debug("readableAddChunk", chunk);
        var state = stream._readableState;
        if (chunk === null) {
          state.reading = false;
          onEofChunk(stream, state);
        } else {
          var er;
          if (!skipChunkCheck)
            er = chunkInvalid(state, chunk);
          if (er) {
            errorOrDestroy(stream, er);
          } else if (state.objectMode || chunk && chunk.length > 0) {
            if (typeof chunk !== "string" && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer2.prototype) {
              chunk = _uint8ArrayToBuffer(chunk);
            }
            if (addToFront) {
              if (state.endEmitted)
                errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());
              else
                addChunk(stream, state, chunk, true);
            } else if (state.ended) {
              errorOrDestroy(stream, new ERR_STREAM_PUSH_AFTER_EOF());
            } else if (state.destroyed) {
              return false;
            } else {
              state.reading = false;
              if (state.decoder && !encoding) {
                chunk = state.decoder.write(chunk);
                if (state.objectMode || chunk.length !== 0)
                  addChunk(stream, state, chunk, false);
                else
                  maybeReadMore(stream, state);
              } else {
                addChunk(stream, state, chunk, false);
              }
            }
          } else if (!addToFront) {
            state.reading = false;
            maybeReadMore(stream, state);
          }
        }
        return !state.ended && (state.length < state.highWaterMark || state.length === 0);
      }
      function addChunk(stream, state, chunk, addToFront) {
        if (state.flowing && state.length === 0 && !state.sync) {
          state.awaitDrain = 0;
          stream.emit("data", chunk);
        } else {
          state.length += state.objectMode ? 1 : chunk.length;
          if (addToFront)
            state.buffer.unshift(chunk);
          else
            state.buffer.push(chunk);
          if (state.needReadable)
            emitReadable(stream);
        }
        maybeReadMore(stream, state);
      }
      function chunkInvalid(state, chunk) {
        var er;
        if (!_isUint8Array(chunk) && typeof chunk !== "string" && chunk !== void 0 && !state.objectMode) {
          er = new ERR_INVALID_ARG_TYPE("chunk", ["string", "Buffer", "Uint8Array"], chunk);
        }
        return er;
      }
      Readable.prototype.isPaused = function() {
        return this._readableState.flowing === false;
      };
      Readable.prototype.setEncoding = function(enc) {
        if (!StringDecoder)
          StringDecoder = require_string_decoder().StringDecoder;
        var decoder = new StringDecoder(enc);
        this._readableState.decoder = decoder;
        this._readableState.encoding = this._readableState.decoder.encoding;
        var p = this._readableState.buffer.head;
        var content = "";
        while (p !== null) {
          content += decoder.write(p.data);
          p = p.next;
        }
        this._readableState.buffer.clear();
        if (content !== "")
          this._readableState.buffer.push(content);
        this._readableState.length = content.length;
        return this;
      };
      var MAX_HWM = 1073741824;
      function computeNewHighWaterMark(n) {
        if (n >= MAX_HWM) {
          n = MAX_HWM;
        } else {
          n--;
          n |= n >>> 1;
          n |= n >>> 2;
          n |= n >>> 4;
          n |= n >>> 8;
          n |= n >>> 16;
          n++;
        }
        return n;
      }
      function howMuchToRead(n, state) {
        if (n <= 0 || state.length === 0 && state.ended)
          return 0;
        if (state.objectMode)
          return 1;
        if (n !== n) {
          if (state.flowing && state.length)
            return state.buffer.head.data.length;
          else
            return state.length;
        }
        if (n > state.highWaterMark)
          state.highWaterMark = computeNewHighWaterMark(n);
        if (n <= state.length)
          return n;
        if (!state.ended) {
          state.needReadable = true;
          return 0;
        }
        return state.length;
      }
      Readable.prototype.read = function(n) {
        debug("read", n);
        n = parseInt(n, 10);
        var state = this._readableState;
        var nOrig = n;
        if (n !== 0)
          state.emittedReadable = false;
        if (n === 0 && state.needReadable && ((state.highWaterMark !== 0 ? state.length >= state.highWaterMark : state.length > 0) || state.ended)) {
          debug("read: emitReadable", state.length, state.ended);
          if (state.length === 0 && state.ended)
            endReadable(this);
          else
            emitReadable(this);
          return null;
        }
        n = howMuchToRead(n, state);
        if (n === 0 && state.ended) {
          if (state.length === 0)
            endReadable(this);
          return null;
        }
        var doRead = state.needReadable;
        debug("need readable", doRead);
        if (state.length === 0 || state.length - n < state.highWaterMark) {
          doRead = true;
          debug("length less than watermark", doRead);
        }
        if (state.ended || state.reading) {
          doRead = false;
          debug("reading or ended", doRead);
        } else if (doRead) {
          debug("do read");
          state.reading = true;
          state.sync = true;
          if (state.length === 0)
            state.needReadable = true;
          this._read(state.highWaterMark);
          state.sync = false;
          if (!state.reading)
            n = howMuchToRead(nOrig, state);
        }
        var ret;
        if (n > 0)
          ret = fromList(n, state);
        else
          ret = null;
        if (ret === null) {
          state.needReadable = state.length <= state.highWaterMark;
          n = 0;
        } else {
          state.length -= n;
          state.awaitDrain = 0;
        }
        if (state.length === 0) {
          if (!state.ended)
            state.needReadable = true;
          if (nOrig !== n && state.ended)
            endReadable(this);
        }
        if (ret !== null)
          this.emit("data", ret);
        return ret;
      };
      function onEofChunk(stream, state) {
        debug("onEofChunk");
        if (state.ended)
          return;
        if (state.decoder) {
          var chunk = state.decoder.end();
          if (chunk && chunk.length) {
            state.buffer.push(chunk);
            state.length += state.objectMode ? 1 : chunk.length;
          }
        }
        state.ended = true;
        if (state.sync) {
          emitReadable(stream);
        } else {
          state.needReadable = false;
          if (!state.emittedReadable) {
            state.emittedReadable = true;
            emitReadable_(stream);
          }
        }
      }
      function emitReadable(stream) {
        var state = stream._readableState;
        debug("emitReadable", state.needReadable, state.emittedReadable);
        state.needReadable = false;
        if (!state.emittedReadable) {
          debug("emitReadable", state.flowing);
          state.emittedReadable = true;
          process.nextTick(emitReadable_, stream);
        }
      }
      function emitReadable_(stream) {
        var state = stream._readableState;
        debug("emitReadable_", state.destroyed, state.length, state.ended);
        if (!state.destroyed && (state.length || state.ended)) {
          stream.emit("readable");
          state.emittedReadable = false;
        }
        state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark;
        flow(stream);
      }
      function maybeReadMore(stream, state) {
        if (!state.readingMore) {
          state.readingMore = true;
          process.nextTick(maybeReadMore_, stream, state);
        }
      }
      function maybeReadMore_(stream, state) {
        while (!state.reading && !state.ended && (state.length < state.highWaterMark || state.flowing && state.length === 0)) {
          var len = state.length;
          debug("maybeReadMore read 0");
          stream.read(0);
          if (len === state.length)
            break;
        }
        state.readingMore = false;
      }
      Readable.prototype._read = function(n) {
        errorOrDestroy(this, new ERR_METHOD_NOT_IMPLEMENTED("_read()"));
      };
      Readable.prototype.pipe = function(dest, pipeOpts) {
        var src = this;
        var state = this._readableState;
        switch (state.pipesCount) {
          case 0:
            state.pipes = dest;
            break;
          case 1:
            state.pipes = [state.pipes, dest];
            break;
          default:
            state.pipes.push(dest);
            break;
        }
        state.pipesCount += 1;
        debug("pipe count=%d opts=%j", state.pipesCount, pipeOpts);
        var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;
        var endFn = doEnd ? onend : unpipe;
        if (state.endEmitted)
          process.nextTick(endFn);
        else
          src.once("end", endFn);
        dest.on("unpipe", onunpipe);
        function onunpipe(readable, unpipeInfo) {
          debug("onunpipe");
          if (readable === src) {
            if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
              unpipeInfo.hasUnpiped = true;
              cleanup();
            }
          }
        }
        function onend() {
          debug("onend");
          dest.end();
        }
        var ondrain = pipeOnDrain(src);
        dest.on("drain", ondrain);
        var cleanedUp = false;
        function cleanup() {
          debug("cleanup");
          dest.removeListener("close", onclose);
          dest.removeListener("finish", onfinish);
          dest.removeListener("drain", ondrain);
          dest.removeListener("error", onerror);
          dest.removeListener("unpipe", onunpipe);
          src.removeListener("end", onend);
          src.removeListener("end", unpipe);
          src.removeListener("data", ondata);
          cleanedUp = true;
          if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain))
            ondrain();
        }
        src.on("data", ondata);
        function ondata(chunk) {
          debug("ondata");
          var ret = dest.write(chunk);
          debug("dest.write", ret);
          if (ret === false) {
            if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf2(state.pipes, dest) !== -1) && !cleanedUp) {
              debug("false write response, pause", state.awaitDrain);
              state.awaitDrain++;
            }
            src.pause();
          }
        }
        function onerror(er) {
          debug("onerror", er);
          unpipe();
          dest.removeListener("error", onerror);
          if (EElistenerCount(dest, "error") === 0)
            errorOrDestroy(dest, er);
        }
        prependListener(dest, "error", onerror);
        function onclose() {
          dest.removeListener("finish", onfinish);
          unpipe();
        }
        dest.once("close", onclose);
        function onfinish() {
          debug("onfinish");
          dest.removeListener("close", onclose);
          unpipe();
        }
        dest.once("finish", onfinish);
        function unpipe() {
          debug("unpipe");
          src.unpipe(dest);
        }
        dest.emit("pipe", src);
        if (!state.flowing) {
          debug("pipe resume");
          src.resume();
        }
        return dest;
      };
      function pipeOnDrain(src) {
        return function pipeOnDrainFunctionResult() {
          var state = src._readableState;
          debug("pipeOnDrain", state.awaitDrain);
          if (state.awaitDrain)
            state.awaitDrain--;
          if (state.awaitDrain === 0 && EElistenerCount(src, "data")) {
            state.flowing = true;
            flow(src);
          }
        };
      }
      Readable.prototype.unpipe = function(dest) {
        var state = this._readableState;
        var unpipeInfo = {
          hasUnpiped: false
        };
        if (state.pipesCount === 0)
          return this;
        if (state.pipesCount === 1) {
          if (dest && dest !== state.pipes)
            return this;
          if (!dest)
            dest = state.pipes;
          state.pipes = null;
          state.pipesCount = 0;
          state.flowing = false;
          if (dest)
            dest.emit("unpipe", this, unpipeInfo);
          return this;
        }
        if (!dest) {
          var dests = state.pipes;
          var len = state.pipesCount;
          state.pipes = null;
          state.pipesCount = 0;
          state.flowing = false;
          for (var i = 0; i < len; i++) {
            dests[i].emit("unpipe", this, {
              hasUnpiped: false
            });
          }
          return this;
        }
        var index = indexOf2(state.pipes, dest);
        if (index === -1)
          return this;
        state.pipes.splice(index, 1);
        state.pipesCount -= 1;
        if (state.pipesCount === 1)
          state.pipes = state.pipes[0];
        dest.emit("unpipe", this, unpipeInfo);
        return this;
      };
      Readable.prototype.on = function(ev, fn) {
        var res = Stream.prototype.on.call(this, ev, fn);
        var state = this._readableState;
        if (ev === "data") {
          state.readableListening = this.listenerCount("readable") > 0;
          if (state.flowing !== false)
            this.resume();
        } else if (ev === "readable") {
          if (!state.endEmitted && !state.readableListening) {
            state.readableListening = state.needReadable = true;
            state.flowing = false;
            state.emittedReadable = false;
            debug("on readable", state.length, state.reading);
            if (state.length) {
              emitReadable(this);
            } else if (!state.reading) {
              process.nextTick(nReadingNextTick, this);
            }
          }
        }
        return res;
      };
      Readable.prototype.addListener = Readable.prototype.on;
      Readable.prototype.removeListener = function(ev, fn) {
        var res = Stream.prototype.removeListener.call(this, ev, fn);
        if (ev === "readable") {
          process.nextTick(updateReadableListening, this);
        }
        return res;
      };
      Readable.prototype.removeAllListeners = function(ev) {
        var res = Stream.prototype.removeAllListeners.apply(this, arguments);
        if (ev === "readable" || ev === void 0) {
          process.nextTick(updateReadableListening, this);
        }
        return res;
      };
      function updateReadableListening(self2) {
        var state = self2._readableState;
        state.readableListening = self2.listenerCount("readable") > 0;
        if (state.resumeScheduled && !state.paused) {
          state.flowing = true;
        } else if (self2.listenerCount("data") > 0) {
          self2.resume();
        }
      }
      function nReadingNextTick(self2) {
        debug("readable nexttick read 0");
        self2.read(0);
      }
      Readable.prototype.resume = function() {
        var state = this._readableState;
        if (!state.flowing) {
          debug("resume");
          state.flowing = !state.readableListening;
          resume(this, state);
        }
        state.paused = false;
        return this;
      };
      function resume(stream, state) {
        if (!state.resumeScheduled) {
          state.resumeScheduled = true;
          process.nextTick(resume_, stream, state);
        }
      }
      function resume_(stream, state) {
        debug("resume", state.reading);
        if (!state.reading) {
          stream.read(0);
        }
        state.resumeScheduled = false;
        stream.emit("resume");
        flow(stream);
        if (state.flowing && !state.reading)
          stream.read(0);
      }
      Readable.prototype.pause = function() {
        debug("call pause flowing=%j", this._readableState.flowing);
        if (this._readableState.flowing !== false) {
          debug("pause");
          this._readableState.flowing = false;
          this.emit("pause");
        }
        this._readableState.paused = true;
        return this;
      };
      function flow(stream) {
        var state = stream._readableState;
        debug("flow", state.flowing);
        while (state.flowing && stream.read() !== null) {
          ;
        }
      }
      Readable.prototype.wrap = function(stream) {
        var _this = this;
        var state = this._readableState;
        var paused = false;
        stream.on("end", function() {
          debug("wrapped end");
          if (state.decoder && !state.ended) {
            var chunk = state.decoder.end();
            if (chunk && chunk.length)
              _this.push(chunk);
          }
          _this.push(null);
        });
        stream.on("data", function(chunk) {
          debug("wrapped data");
          if (state.decoder)
            chunk = state.decoder.write(chunk);
          if (state.objectMode && (chunk === null || chunk === void 0))
            return;
          else if (!state.objectMode && (!chunk || !chunk.length))
            return;
          var ret = _this.push(chunk);
          if (!ret) {
            paused = true;
            stream.pause();
          }
        });
        for (var i in stream) {
          if (this[i] === void 0 && typeof stream[i] === "function") {
            this[i] = function methodWrap(method) {
              return function methodWrapReturnFunction() {
                return stream[method].apply(stream, arguments);
              };
            }(i);
          }
        }
        for (var n = 0; n < kProxyEvents.length; n++) {
          stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));
        }
        this._read = function(n2) {
          debug("wrapped _read", n2);
          if (paused) {
            paused = false;
            stream.resume();
          }
        };
        return this;
      };
      if (typeof Symbol === "function") {
        Readable.prototype[Symbol.asyncIterator] = function() {
          if (createReadableStreamAsyncIterator === void 0) {
            createReadableStreamAsyncIterator = require_async_iterator();
          }
          return createReadableStreamAsyncIterator(this);
        };
      }
      Object.defineProperty(Readable.prototype, "readableHighWaterMark", {
        enumerable: false,
        get: function get() {
          return this._readableState.highWaterMark;
        }
      });
      Object.defineProperty(Readable.prototype, "readableBuffer", {
        enumerable: false,
        get: function get() {
          return this._readableState && this._readableState.buffer;
        }
      });
      Object.defineProperty(Readable.prototype, "readableFlowing", {
        enumerable: false,
        get: function get() {
          return this._readableState.flowing;
        },
        set: function set(state) {
          if (this._readableState) {
            this._readableState.flowing = state;
          }
        }
      });
      Readable._fromList = fromList;
      Object.defineProperty(Readable.prototype, "readableLength", {
        enumerable: false,
        get: function get() {
          return this._readableState.length;
        }
      });
      function fromList(n, state) {
        if (state.length === 0)
          return null;
        var ret;
        if (state.objectMode)
          ret = state.buffer.shift();
        else if (!n || n >= state.length) {
          if (state.decoder)
            ret = state.buffer.join("");
          else if (state.buffer.length === 1)
            ret = state.buffer.first();
          else
            ret = state.buffer.concat(state.length);
          state.buffer.clear();
        } else {
          ret = state.buffer.consume(n, state.decoder);
        }
        return ret;
      }
      function endReadable(stream) {
        var state = stream._readableState;
        debug("endReadable", state.endEmitted);
        if (!state.endEmitted) {
          state.ended = true;
          process.nextTick(endReadableNT, state, stream);
        }
      }
      function endReadableNT(state, stream) {
        debug("endReadableNT", state.endEmitted, state.length);
        if (!state.endEmitted && state.length === 0) {
          state.endEmitted = true;
          stream.readable = false;
          stream.emit("end");
          if (state.autoDestroy) {
            var wState = stream._writableState;
            if (!wState || wState.autoDestroy && wState.finished) {
              stream.destroy();
            }
          }
        }
      }
      if (typeof Symbol === "function") {
        Readable.from = function(iterable, opts) {
          if (from === void 0) {
            from = require_from_browser();
          }
          return from(Readable, iterable, opts);
        };
      }
      function indexOf2(xs, x) {
        for (var i = 0, l = xs.length; i < l; i++) {
          if (xs[i] === x)
            return i;
        }
        return -1;
      }
    }
  });

  // node_modules/readable-stream/lib/_stream_transform.js
  var require_stream_transform = __commonJS({
    "node_modules/readable-stream/lib/_stream_transform.js"(exports2, module2) {
      "use strict";
      module2.exports = Transform;
      var _require$codes = require_errors_browser().codes;
      var ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED;
      var ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK;
      var ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING;
      var ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0;
      var Duplex = require_stream_duplex();
      require_inherits_browser()(Transform, Duplex);
      function afterTransform(er, data) {
        var ts = this._transformState;
        ts.transforming = false;
        var cb = ts.writecb;
        if (cb === null) {
          return this.emit("error", new ERR_MULTIPLE_CALLBACK());
        }
        ts.writechunk = null;
        ts.writecb = null;
        if (data != null)
          this.push(data);
        cb(er);
        var rs = this._readableState;
        rs.reading = false;
        if (rs.needReadable || rs.length < rs.highWaterMark) {
          this._read(rs.highWaterMark);
        }
      }
      function Transform(options) {
        if (!(this instanceof Transform))
          return new Transform(options);
        Duplex.call(this, options);
        this._transformState = {
          afterTransform: afterTransform.bind(this),
          needTransform: false,
          transforming: false,
          writecb: null,
          writechunk: null,
          writeencoding: null
        };
        this._readableState.needReadable = true;
        this._readableState.sync = false;
        if (options) {
          if (typeof options.transform === "function")
            this._transform = options.transform;
          if (typeof options.flush === "function")
            this._flush = options.flush;
        }
        this.on("prefinish", prefinish);
      }
      function prefinish() {
        var _this = this;
        if (typeof this._flush === "function" && !this._readableState.destroyed) {
          this._flush(function(er, data) {
            done(_this, er, data);
          });
        } else {
          done(this, null, null);
        }
      }
      Transform.prototype.push = function(chunk, encoding) {
        this._transformState.needTransform = false;
        return Duplex.prototype.push.call(this, chunk, encoding);
      };
      Transform.prototype._transform = function(chunk, encoding, cb) {
        cb(new ERR_METHOD_NOT_IMPLEMENTED("_transform()"));
      };
      Transform.prototype._write = function(chunk, encoding, cb) {
        var ts = this._transformState;
        ts.writecb = cb;
        ts.writechunk = chunk;
        ts.writeencoding = encoding;
        if (!ts.transforming) {
          var rs = this._readableState;
          if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark)
            this._read(rs.highWaterMark);
        }
      };
      Transform.prototype._read = function(n) {
        var ts = this._transformState;
        if (ts.writechunk !== null && !ts.transforming) {
          ts.transforming = true;
          this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
        } else {
          ts.needTransform = true;
        }
      };
      Transform.prototype._destroy = function(err, cb) {
        Duplex.prototype._destroy.call(this, err, function(err2) {
          cb(err2);
        });
      };
      function done(stream, er, data) {
        if (er)
          return stream.emit("error", er);
        if (data != null)
          stream.push(data);
        if (stream._writableState.length)
          throw new ERR_TRANSFORM_WITH_LENGTH_0();
        if (stream._transformState.transforming)
          throw new ERR_TRANSFORM_ALREADY_TRANSFORMING();
        return stream.push(null);
      }
    }
  });

  // node_modules/readable-stream/lib/_stream_passthrough.js
  var require_stream_passthrough = __commonJS({
    "node_modules/readable-stream/lib/_stream_passthrough.js"(exports2, module2) {
      "use strict";
      module2.exports = PassThrough;
      var Transform = require_stream_transform();
      require_inherits_browser()(PassThrough, Transform);
      function PassThrough(options) {
        if (!(this instanceof PassThrough))
          return new PassThrough(options);
        Transform.call(this, options);
      }
      PassThrough.prototype._transform = function(chunk, encoding, cb) {
        cb(null, chunk);
      };
    }
  });

  // node_modules/readable-stream/lib/internal/streams/pipeline.js
  var require_pipeline = __commonJS({
    "node_modules/readable-stream/lib/internal/streams/pipeline.js"(exports2, module2) {
      "use strict";
      var eos;
      function once(callback) {
        var called = false;
        return function() {
          if (called)
            return;
          called = true;
          callback.apply(void 0, arguments);
        };
      }
      var _require$codes = require_errors_browser().codes;
      var ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS;
      var ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;
      function noop(err) {
        if (err)
          throw err;
      }
      function isRequest(stream) {
        return stream.setHeader && typeof stream.abort === "function";
      }
      function destroyer(stream, reading, writing, callback) {
        callback = once(callback);
        var closed = false;
        stream.on("close", function() {
          closed = true;
        });
        if (eos === void 0)
          eos = require_end_of_stream();
        eos(stream, {
          readable: reading,
          writable: writing
        }, function(err) {
          if (err)
            return callback(err);
          closed = true;
          callback();
        });
        var destroyed = false;
        return function(err) {
          if (closed)
            return;
          if (destroyed)
            return;
          destroyed = true;
          if (isRequest(stream))
            return stream.abort();
          if (typeof stream.destroy === "function")
            return stream.destroy();
          callback(err || new ERR_STREAM_DESTROYED("pipe"));
        };
      }
      function call(fn) {
        fn();
      }
      function pipe(from, to) {
        return from.pipe(to);
      }
      function popCallback(streams) {
        if (!streams.length)
          return noop;
        if (typeof streams[streams.length - 1] !== "function")
          return noop;
        return streams.pop();
      }
      function pipeline() {
        for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) {
          streams[_key] = arguments[_key];
        }
        var callback = popCallback(streams);
        if (Array.isArray(streams[0]))
          streams = streams[0];
        if (streams.length < 2) {
          throw new ERR_MISSING_ARGS("streams");
        }
        var error;
        var destroys = streams.map(function(stream, i) {
          var reading = i < streams.length - 1;
          var writing = i > 0;
          return destroyer(stream, reading, writing, function(err) {
            if (!error)
              error = err;
            if (err)
              destroys.forEach(call);
            if (reading)
              return;
            destroys.forEach(call);
            callback(error);
          });
        });
        return streams.reduce(pipe);
      }
      module2.exports = pipeline;
    }
  });

  // node_modules/readable-stream/readable-browser.js
  var require_readable_browser = __commonJS({
    "node_modules/readable-stream/readable-browser.js"(exports2, module2) {
      exports2 = module2.exports = require_stream_readable();
      exports2.Stream = exports2;
      exports2.Readable = exports2;
      exports2.Writable = require_stream_writable();
      exports2.Duplex = require_stream_duplex();
      exports2.Transform = require_stream_transform();
      exports2.PassThrough = require_stream_passthrough();
      exports2.finished = require_end_of_stream();
      exports2.pipeline = require_pipeline();
    }
  });

  // node_modules/hash-base/index.js
  var require_hash_base = __commonJS({
    "node_modules/hash-base/index.js"(exports2, module2) {
      "use strict";
      var Buffer2 = require_safe_buffer().Buffer;
      var Transform = require_readable_browser().Transform;
      var inherits = require_inherits_browser();
      function throwIfNotStringOrBuffer(val, prefix) {
        if (!Buffer2.isBuffer(val) && typeof val !== "string") {
          throw new TypeError(prefix + " must be a string or a buffer");
        }
      }
      function HashBase(blockSize) {
        Transform.call(this);
        this._block = Buffer2.allocUnsafe(blockSize);
        this._blockSize = blockSize;
        this._blockOffset = 0;
        this._length = [0, 0, 0, 0];
        this._finalized = false;
      }
      inherits(HashBase, Transform);
      HashBase.prototype._transform = function(chunk, encoding, callback) {
        var error = null;
        try {
          this.update(chunk, encoding);
        } catch (err) {
          error = err;
        }
        callback(error);
      };
      HashBase.prototype._flush = function(callback) {
        var error = null;
        try {
          this.push(this.digest());
        } catch (err) {
          error = err;
        }
        callback(error);
      };
      HashBase.prototype.update = function(data, encoding) {
        throwIfNotStringOrBuffer(data, "Data");
        if (this._finalized)
          throw new Error("Digest already called");
        if (!Buffer2.isBuffer(data))
          data = Buffer2.from(data, encoding);
        var block = this._block;
        var offset = 0;
        while (this._blockOffset + data.length - offset >= this._blockSize) {
          for (var i = this._blockOffset; i < this._blockSize; )
            block[i++] = data[offset++];
          this._update();
          this._blockOffset = 0;
        }
        while (offset < data.length)
          block[this._blockOffset++] = data[offset++];
        for (var j = 0, carry = data.length * 8; carry > 0; ++j) {
          this._length[j] += carry;
          carry = this._length[j] / 4294967296 | 0;
          if (carry > 0)
            this._length[j] -= 4294967296 * carry;
        }
        return this;
      };
      HashBase.prototype._update = function() {
        throw new Error("_update is not implemented");
      };
      HashBase.prototype.digest = function(encoding) {
        if (this._finalized)
          throw new Error("Digest already called");
        this._finalized = true;
        var digest = this._digest();
        if (encoding !== void 0)
          digest = digest.toString(encoding);
        this._block.fill(0);
        this._blockOffset = 0;
        for (var i = 0; i < 4; ++i)
          this._length[i] = 0;
        return digest;
      };
      HashBase.prototype._digest = function() {
        throw new Error("_digest is not implemented");
      };
      module2.exports = HashBase;
    }
  });

  // node_modules/md5.js/index.js
  var require_md5 = __commonJS({
    "node_modules/md5.js/index.js"(exports2, module2) {
      "use strict";
      var inherits = require_inherits_browser();
      var HashBase = require_hash_base();
      var Buffer2 = require_safe_buffer().Buffer;
      var ARRAY16 = new Array(16);
      function MD5() {
        HashBase.call(this, 64);
        this._a = 1732584193;
        this._b = 4023233417;
        this._c = 2562383102;
        this._d = 271733878;
      }
      inherits(MD5, HashBase);
      MD5.prototype._update = function() {
        var M = ARRAY16;
        for (var i = 0; i < 16; ++i)
          M[i] = this._block.readInt32LE(i * 4);
        var a = this._a;
        var b = this._b;
        var c = this._c;
        var d = this._d;
        a = fnF(a, b, c, d, M[0], 3614090360, 7);
        d = fnF(d, a, b, c, M[1], 3905402710, 12);
        c = fnF(c, d, a, b, M[2], 606105819, 17);
        b = fnF(b, c, d, a, M[3], 3250441966, 22);
        a = fnF(a, b, c, d, M[4], 4118548399, 7);
        d = fnF(d, a, b, c, M[5], 1200080426, 12);
        c = fnF(c, d, a, b, M[6], 2821735955, 17);
        b = fnF(b, c, d, a, M[7], 4249261313, 22);
        a = fnF(a, b, c, d, M[8], 1770035416, 7);
        d = fnF(d, a, b, c, M[9], 2336552879, 12);
        c = fnF(c, d, a, b, M[10], 4294925233, 17);
        b = fnF(b, c, d, a, M[11], 2304563134, 22);
        a = fnF(a, b, c, d, M[12], 1804603682, 7);
        d = fnF(d, a, b, c, M[13], 4254626195, 12);
        c = fnF(c, d, a, b, M[14], 2792965006, 17);
        b = fnF(b, c, d, a, M[15], 1236535329, 22);
        a = fnG(a, b, c, d, M[1], 4129170786, 5);
        d = fnG(d, a, b, c, M[6], 3225465664, 9);
        c = fnG(c, d, a, b, M[11], 643717713, 14);
        b = fnG(b, c, d, a, M[0], 3921069994, 20);
        a = fnG(a, b, c, d, M[5], 3593408605, 5);
        d = fnG(d, a, b, c, M[10], 38016083, 9);
        c = fnG(c, d, a, b, M[15], 3634488961, 14);
        b = fnG(b, c, d, a, M[4], 3889429448, 20);
        a = fnG(a, b, c, d, M[9], 568446438, 5);
        d = fnG(d, a, b, c, M[14], 3275163606, 9);
        c = fnG(c, d, a, b, M[3], 4107603335, 14);
        b = fnG(b, c, d, a, M[8], 1163531501, 20);
        a = fnG(a, b, c, d, M[13], 2850285829, 5);
        d = fnG(d, a, b, c, M[2], 4243563512, 9);
        c = fnG(c, d, a, b, M[7], 1735328473, 14);
        b = fnG(b, c, d, a, M[12], 2368359562, 20);
        a = fnH(a, b, c, d, M[5], 4294588738, 4);
        d = fnH(d, a, b, c, M[8], 2272392833, 11);
        c = fnH(c, d, a, b, M[11], 1839030562, 16);
        b = fnH(b, c, d, a, M[14], 4259657740, 23);
        a = fnH(a, b, c, d, M[1], 2763975236, 4);
        d = fnH(d, a, b, c, M[4], 1272893353, 11);
        c = fnH(c, d, a, b, M[7], 4139469664, 16);
        b = fnH(b, c, d, a, M[10], 3200236656, 23);
        a = fnH(a, b, c, d, M[13], 681279174, 4);
        d = fnH(d, a, b, c, M[0], 3936430074, 11);
        c = fnH(c, d, a, b, M[3], 3572445317, 16);
        b = fnH(b, c, d, a, M[6], 76029189, 23);
        a = fnH(a, b, c, d, M[9], 3654602809, 4);
        d = fnH(d, a, b, c, M[12], 3873151461, 11);
        c = fnH(c, d, a, b, M[15], 530742520, 16);
        b = fnH(b, c, d, a, M[2], 3299628645, 23);
        a = fnI(a, b, c, d, M[0], 4096336452, 6);
        d = fnI(d, a, b, c, M[7], 1126891415, 10);
        c = fnI(c, d, a, b, M[14], 2878612391, 15);
        b = fnI(b, c, d, a, M[5], 4237533241, 21);
        a = fnI(a, b, c, d, M[12], 1700485571, 6);
        d = fnI(d, a, b, c, M[3], 2399980690, 10);
        c = fnI(c, d, a, b, M[10], 4293915773, 15);
        b = fnI(b, c, d, a, M[1], 2240044497, 21);
        a = fnI(a, b, c, d, M[8], 1873313359, 6);
        d = fnI(d, a, b, c, M[15], 4264355552, 10);
        c = fnI(c, d, a, b, M[6], 2734768916, 15);
        b = fnI(b, c, d, a, M[13], 1309151649, 21);
        a = fnI(a, b, c, d, M[4], 4149444226, 6);
        d = fnI(d, a, b, c, M[11], 3174756917, 10);
        c = fnI(c, d, a, b, M[2], 718787259, 15);
        b = fnI(b, c, d, a, M[9], 3951481745, 21);
        this._a = this._a + a | 0;
        this._b = this._b + b | 0;
        this._c = this._c + c | 0;
        this._d = this._d + d | 0;
      };
      MD5.prototype._digest = function() {
        this._block[this._blockOffset++] = 128;
        if (this._blockOffset > 56) {
          this._block.fill(0, this._blockOffset, 64);
          this._update();
          this._blockOffset = 0;
        }
        this._block.fill(0, this._blockOffset, 56);
        this._block.writeUInt32LE(this._length[0], 56);
        this._block.writeUInt32LE(this._length[1], 60);
        this._update();
        var buffer = Buffer2.allocUnsafe(16);
        buffer.writeInt32LE(this._a, 0);
        buffer.writeInt32LE(this._b, 4);
        buffer.writeInt32LE(this._c, 8);
        buffer.writeInt32LE(this._d, 12);
        return buffer;
      };
      function rotl(x, n) {
        return x << n | x >>> 32 - n;
      }
      function fnF(a, b, c, d, m, k, s) {
        return rotl(a + (b & c | ~b & d) + m + k | 0, s) + b | 0;
      }
      function fnG(a, b, c, d, m, k, s) {
        return rotl(a + (b & d | c & ~d) + m + k | 0, s) + b | 0;
      }
      function fnH(a, b, c, d, m, k, s) {
        return rotl(a + (b ^ c ^ d) + m + k | 0, s) + b | 0;
      }
      function fnI(a, b, c, d, m, k, s) {
        return rotl(a + (c ^ (b | ~d)) + m + k | 0, s) + b | 0;
      }
      module2.exports = MD5;
    }
  });

  // node_modules/ripemd160/index.js
  var require_ripemd160 = __commonJS({
    "node_modules/ripemd160/index.js"(exports2, module2) {
      "use strict";
      var Buffer2 = require_buffer2().Buffer;
      var inherits = require_inherits_browser();
      var HashBase = require_hash_base();
      var ARRAY16 = new Array(16);
      var zl = [
        0,
        1,
        2,
        3,
        4,
        5,
        6,
        7,
        8,
        9,
        10,
        11,
        12,
        13,
        14,
        15,
        7,
        4,
        13,
        1,
        10,
        6,
        15,
        3,
        12,
        0,
        9,
        5,
        2,
        14,
        11,
        8,
        3,
        10,
        14,
        4,
        9,
        15,
        8,
        1,
        2,
        7,
        0,
        6,
        13,
        11,
        5,
        12,
        1,
        9,
        11,
        10,
        0,
        8,
        12,
        4,
        13,
        3,
        7,
        15,
        14,
        5,
        6,
        2,
        4,
        0,
        5,
        9,
        7,
        12,
        2,
        10,
        14,
        1,
        3,
        8,
        11,
        6,
        15,
        13
      ];
      var zr = [
        5,
        14,
        7,
        0,
        9,
        2,
        11,
        4,
        13,
        6,
        15,
        8,
        1,
        10,
        3,
        12,
        6,
        11,
        3,
        7,
        0,
        13,
        5,
        10,
        14,
        15,
        8,
        12,
        4,
        9,
        1,
        2,
        15,
        5,
        1,
        3,
        7,
        14,
        6,
        9,
        11,
        8,
        12,
        2,
        10,
        0,
        4,
        13,
        8,
        6,
        4,
        1,
        3,
        11,
        15,
        0,
        5,
        12,
        2,
        13,
        9,
        7,
        10,
        14,
        12,
        15,
        10,
        4,
        1,
        5,
        8,
        7,
        6,
        2,
        13,
        14,
        0,
        3,
        9,
        11
      ];
      var sl = [
        11,
        14,
        15,
        12,
        5,
        8,
        7,
        9,
        11,
        13,
        14,
        15,
        6,
        7,
        9,
        8,
        7,
        6,
        8,
        13,
        11,
        9,
        7,
        15,
        7,
        12,
        15,
        9,
        11,
        7,
        13,
        12,
        11,
        13,
        6,
        7,
        14,
        9,
        13,
        15,
        14,
        8,
        13,
        6,
        5,
        12,
        7,
        5,
        11,
        12,
        14,
        15,
        14,
        15,
        9,
        8,
        9,
        14,
        5,
        6,
        8,
        6,
        5,
        12,
        9,
        15,
        5,
        11,
        6,
        8,
        13,
        12,
        5,
        12,
        13,
        14,
        11,
        8,
        5,
        6
      ];
      var sr = [
        8,
        9,
        9,
        11,
        13,
        15,
        15,
        5,
        7,
        7,
        8,
        11,
        14,
        14,
        12,
        6,
        9,
        13,
        15,
        7,
        12,
        8,
        9,
        11,
        7,
        7,
        12,
        7,
        6,
        15,
        13,
        11,
        9,
        7,
        15,
        11,
        8,
        6,
        6,
        14,
        12,
        13,
        5,
        14,
        13,
        13,
        7,
        5,
        15,
        5,
        8,
        11,
        14,
        14,
        6,
        14,
        6,
        9,
        12,
        9,
        12,
        5,
        15,
        8,
        8,
        5,
        12,
        9,
        12,
        5,
        14,
        6,
        8,
        13,
        6,
        5,
        15,
        13,
        11,
        11
      ];
      var hl = [0, 1518500249, 1859775393, 2400959708, 2840853838];
      var hr = [1352829926, 1548603684, 1836072691, 2053994217, 0];
      function RIPEMD160() {
        HashBase.call(this, 64);
        this._a = 1732584193;
        this._b = 4023233417;
        this._c = 2562383102;
        this._d = 271733878;
        this._e = 3285377520;
      }
      inherits(RIPEMD160, HashBase);
      RIPEMD160.prototype._update = function() {
        var words = ARRAY16;
        for (var j = 0; j < 16; ++j)
          words[j] = this._block.readInt32LE(j * 4);
        var al = this._a | 0;
        var bl = this._b | 0;
        var cl = this._c | 0;
        var dl = this._d | 0;
        var el = this._e | 0;
        var ar = this._a | 0;
        var br = this._b | 0;
        var cr = this._c | 0;
        var dr = this._d | 0;
        var er = this._e | 0;
        for (var i = 0; i < 80; i += 1) {
          var tl;
          var tr;
          if (i < 16) {
            tl = fn1(al, bl, cl, dl, el, words[zl[i]], hl[0], sl[i]);
            tr = fn5(ar, br, cr, dr, er, words[zr[i]], hr[0], sr[i]);
          } else if (i < 32) {
            tl = fn2(al, bl, cl, dl, el, words[zl[i]], hl[1], sl[i]);
            tr = fn4(ar, br, cr, dr, er, words[zr[i]], hr[1], sr[i]);
          } else if (i < 48) {
            tl = fn3(al, bl, cl, dl, el, words[zl[i]], hl[2], sl[i]);
            tr = fn3(ar, br, cr, dr, er, words[zr[i]], hr[2], sr[i]);
          } else if (i < 64) {
            tl = fn4(al, bl, cl, dl, el, words[zl[i]], hl[3], sl[i]);
            tr = fn2(ar, br, cr, dr, er, words[zr[i]], hr[3], sr[i]);
          } else {
            tl = fn5(al, bl, cl, dl, el, words[zl[i]], hl[4], sl[i]);
            tr = fn1(ar, br, cr, dr, er, words[zr[i]], hr[4], sr[i]);
          }
          al = el;
          el = dl;
          dl = rotl(cl, 10);
          cl = bl;
          bl = tl;
          ar = er;
          er = dr;
          dr = rotl(cr, 10);
          cr = br;
          br = tr;
        }
        var t = this._b + cl + dr | 0;
        this._b = this._c + dl + er | 0;
        this._c = this._d + el + ar | 0;
        this._d = this._e + al + br | 0;
        this._e = this._a + bl + cr | 0;
        this._a = t;
      };
      RIPEMD160.prototype._digest = function() {
        this._block[this._blockOffset++] = 128;
        if (this._blockOffset > 56) {
          this._block.fill(0, this._blockOffset, 64);
          this._update();
          this._blockOffset = 0;
        }
        this._block.fill(0, this._blockOffset, 56);
        this._block.writeUInt32LE(this._length[0], 56);
        this._block.writeUInt32LE(this._length[1], 60);
        this._update();
        var buffer = Buffer2.alloc ? Buffer2.alloc(20) : new Buffer2(20);
        buffer.writeInt32LE(this._a, 0);
        buffer.writeInt32LE(this._b, 4);
        buffer.writeInt32LE(this._c, 8);
        buffer.writeInt32LE(this._d, 12);
        buffer.writeInt32LE(this._e, 16);
        return buffer;
      };
      function rotl(x, n) {
        return x << n | x >>> 32 - n;
      }
      function fn1(a, b, c, d, e, m, k, s) {
        return rotl(a + (b ^ c ^ d) + m + k | 0, s) + e | 0;
      }
      function fn2(a, b, c, d, e, m, k, s) {
        return rotl(a + (b & c | ~b & d) + m + k | 0, s) + e | 0;
      }
      function fn3(a, b, c, d, e, m, k, s) {
        return rotl(a + ((b | ~c) ^ d) + m + k | 0, s) + e | 0;
      }
      function fn4(a, b, c, d, e, m, k, s) {
        return rotl(a + (b & d | c & ~d) + m + k | 0, s) + e | 0;
      }
      function fn5(a, b, c, d, e, m, k, s) {
        return rotl(a + (b ^ (c | ~d)) + m + k | 0, s) + e | 0;
      }
      module2.exports = RIPEMD160;
    }
  });

  // node_modules/sha.js/hash.js
  var require_hash = __commonJS({
    "node_modules/sha.js/hash.js"(exports2, module2) {
      var Buffer2 = require_safe_buffer().Buffer;
      function Hash(blockSize, finalSize) {
        this._block = Buffer2.alloc(blockSize);
        this._finalSize = finalSize;
        this._blockSize = blockSize;
        this._len = 0;
      }
      Hash.prototype.update = function(data, enc) {
        if (typeof data === "string") {
          enc = enc || "utf8";
          data = Buffer2.from(data, enc);
        }
        var block = this._block;
        var blockSize = this._blockSize;
        var length = data.length;
        var accum = this._len;
        for (var offset = 0; offset < length; ) {
          var assigned = accum % blockSize;
          var remainder = Math.min(length - offset, blockSize - assigned);
          for (var i = 0; i < remainder; i++) {
            block[assigned + i] = data[offset + i];
          }
          accum += remainder;
          offset += remainder;
          if (accum % blockSize === 0) {
            this._update(block);
          }
        }
        this._len += length;
        return this;
      };
      Hash.prototype.digest = function(enc) {
        var rem = this._len % this._blockSize;
        this._block[rem] = 128;
        this._block.fill(0, rem + 1);
        if (rem >= this._finalSize) {
          this._update(this._block);
          this._block.fill(0);
        }
        var bits = this._len * 8;
        if (bits <= 4294967295) {
          this._block.writeUInt32BE(bits, this._blockSize - 4);
        } else {
          var lowBits = (bits & 4294967295) >>> 0;
          var highBits = (bits - lowBits) / 4294967296;
          this._block.writeUInt32BE(highBits, this._blockSize - 8);
          this._block.writeUInt32BE(lowBits, this._blockSize - 4);
        }
        this._update(this._block);
        var hash = this._hash();
        return enc ? hash.toString(enc) : hash;
      };
      Hash.prototype._update = function() {
        throw new Error("_update must be implemented by subclass");
      };
      module2.exports = Hash;
    }
  });

  // node_modules/sha.js/sha.js
  var require_sha = __commonJS({
    "node_modules/sha.js/sha.js"(exports2, module2) {
      var inherits = require_inherits_browser();
      var Hash = require_hash();
      var Buffer2 = require_safe_buffer().Buffer;
      var K = [
        1518500249,
        1859775393,
        2400959708 | 0,
        3395469782 | 0
      ];
      var W = new Array(80);
      function Sha() {
        this.init();
        this._w = W;
        Hash.call(this, 64, 56);
      }
      inherits(Sha, Hash);
      Sha.prototype.init = function() {
        this._a = 1732584193;
        this._b = 4023233417;
        this._c = 2562383102;
        this._d = 271733878;
        this._e = 3285377520;
        return this;
      };
      function rotl5(num) {
        return num << 5 | num >>> 27;
      }
      function rotl30(num) {
        return num << 30 | num >>> 2;
      }
      function ft(s, b, c, d) {
        if (s === 0)
          return b & c | ~b & d;
        if (s === 2)
          return b & c | b & d | c & d;
        return b ^ c ^ d;
      }
      Sha.prototype._update = function(M) {
        var W2 = this._w;
        var a = this._a | 0;
        var b = this._b | 0;
        var c = this._c | 0;
        var d = this._d | 0;
        var e = this._e | 0;
        for (var i = 0; i < 16; ++i)
          W2[i] = M.readInt32BE(i * 4);
        for (; i < 80; ++i)
          W2[i] = W2[i - 3] ^ W2[i - 8] ^ W2[i - 14] ^ W2[i - 16];
        for (var j = 0; j < 80; ++j) {
          var s = ~~(j / 20);
          var t = rotl5(a) + ft(s, b, c, d) + e + W2[j] + K[s] | 0;
          e = d;
          d = c;
          c = rotl30(b);
          b = a;
          a = t;
        }
        this._a = a + this._a | 0;
        this._b = b + this._b | 0;
        this._c = c + this._c | 0;
        this._d = d + this._d | 0;
        this._e = e + this._e | 0;
      };
      Sha.prototype._hash = function() {
        var H = Buffer2.allocUnsafe(20);
        H.writeInt32BE(this._a | 0, 0);
        H.writeInt32BE(this._b | 0, 4);
        H.writeInt32BE(this._c | 0, 8);
        H.writeInt32BE(this._d | 0, 12);
        H.writeInt32BE(this._e | 0, 16);
        return H;
      };
      module2.exports = Sha;
    }
  });

  // node_modules/sha.js/sha1.js
  var require_sha1 = __commonJS({
    "node_modules/sha.js/sha1.js"(exports2, module2) {
      var inherits = require_inherits_browser();
      var Hash = require_hash();
      var Buffer2 = require_safe_buffer().Buffer;
      var K = [
        1518500249,
        1859775393,
        2400959708 | 0,
        3395469782 | 0
      ];
      var W = new Array(80);
      function Sha1() {
        this.init();
        this._w = W;
        Hash.call(this, 64, 56);
      }
      inherits(Sha1, Hash);
      Sha1.prototype.init = function() {
        this._a = 1732584193;
        this._b = 4023233417;
        this._c = 2562383102;
        this._d = 271733878;
        this._e = 3285377520;
        return this;
      };
      function rotl1(num) {
        return num << 1 | num >>> 31;
      }
      function rotl5(num) {
        return num << 5 | num >>> 27;
      }
      function rotl30(num) {
        return num << 30 | num >>> 2;
      }
      function ft(s, b, c, d) {
        if (s === 0)
          return b & c | ~b & d;
        if (s === 2)
          return b & c | b & d | c & d;
        return b ^ c ^ d;
      }
      Sha1.prototype._update = function(M) {
        var W2 = this._w;
        var a = this._a | 0;
        var b = this._b | 0;
        var c = this._c | 0;
        var d = this._d | 0;
        var e = this._e | 0;
        for (var i = 0; i < 16; ++i)
          W2[i] = M.readInt32BE(i * 4);
        for (; i < 80; ++i)
          W2[i] = rotl1(W2[i - 3] ^ W2[i - 8] ^ W2[i - 14] ^ W2[i - 16]);
        for (var j = 0; j < 80; ++j) {
          var s = ~~(j / 20);
          var t = rotl5(a) + ft(s, b, c, d) + e + W2[j] + K[s] | 0;
          e = d;
          d = c;
          c = rotl30(b);
          b = a;
          a = t;
        }
        this._a = a + this._a | 0;
        this._b = b + this._b | 0;
        this._c = c + this._c | 0;
        this._d = d + this._d | 0;
        this._e = e + this._e | 0;
      };
      Sha1.prototype._hash = function() {
        var H = Buffer2.allocUnsafe(20);
        H.writeInt32BE(this._a | 0, 0);
        H.writeInt32BE(this._b | 0, 4);
        H.writeInt32BE(this._c | 0, 8);
        H.writeInt32BE(this._d | 0, 12);
        H.writeInt32BE(this._e | 0, 16);
        return H;
      };
      module2.exports = Sha1;
    }
  });

  // node_modules/sha.js/sha256.js
  var require_sha256 = __commonJS({
    "node_modules/sha.js/sha256.js"(exports2, module2) {
      var inherits = require_inherits_browser();
      var Hash = require_hash();
      var Buffer2 = require_safe_buffer().Buffer;
      var K = [
        1116352408,
        1899447441,
        3049323471,
        3921009573,
        961987163,
        1508970993,
        2453635748,
        2870763221,
        3624381080,
        310598401,
        607225278,
        1426881987,
        1925078388,
        2162078206,
        2614888103,
        3248222580,
        3835390401,
        4022224774,
        264347078,
        604807628,
        770255983,
        1249150122,
        1555081692,
        1996064986,
        2554220882,
        2821834349,
        2952996808,
        3210313671,
        3336571891,
        3584528711,
        113926993,
        338241895,
        666307205,
        773529912,
        1294757372,
        1396182291,
        1695183700,
        1986661051,
        2177026350,
        2456956037,
        2730485921,
        2820302411,
        3259730800,
        3345764771,
        3516065817,
        3600352804,
        4094571909,
        275423344,
        430227734,
        506948616,
        659060556,
        883997877,
        958139571,
        1322822218,
        1537002063,
        1747873779,
        1955562222,
        2024104815,
        2227730452,
        2361852424,
        2428436474,
        2756734187,
        3204031479,
        3329325298
      ];
      var W = new Array(64);
      function Sha256() {
        this.init();
        this._w = W;
        Hash.call(this, 64, 56);
      }
      inherits(Sha256, Hash);
      Sha256.prototype.init = function() {
        this._a = 1779033703;
        this._b = 3144134277;
        this._c = 1013904242;
        this._d = 2773480762;
        this._e = 1359893119;
        this._f = 2600822924;
        this._g = 528734635;
        this._h = 1541459225;
        return this;
      };
      function ch(x, y, z) {
        return z ^ x & (y ^ z);
      }
      function maj(x, y, z) {
        return x & y | z & (x | y);
      }
      function sigma0(x) {
        return (x >>> 2 | x << 30) ^ (x >>> 13 | x << 19) ^ (x >>> 22 | x << 10);
      }
      function sigma1(x) {
        return (x >>> 6 | x << 26) ^ (x >>> 11 | x << 21) ^ (x >>> 25 | x << 7);
      }
      function gamma0(x) {
        return (x >>> 7 | x << 25) ^ (x >>> 18 | x << 14) ^ x >>> 3;
      }
      function gamma1(x) {
        return (x >>> 17 | x << 15) ^ (x >>> 19 | x << 13) ^ x >>> 10;
      }
      Sha256.prototype._update = function(M) {
        var W2 = this._w;
        var a = this._a | 0;
        var b = this._b | 0;
        var c = this._c | 0;
        var d = this._d | 0;
        var e = this._e | 0;
        var f = this._f | 0;
        var g = this._g | 0;
        var h = this._h | 0;
        for (var i = 0; i < 16; ++i)
          W2[i] = M.readInt32BE(i * 4);
        for (; i < 64; ++i)
          W2[i] = gamma1(W2[i - 2]) + W2[i - 7] + gamma0(W2[i - 15]) + W2[i - 16] | 0;
        for (var j = 0; j < 64; ++j) {
          var T1 = h + sigma1(e) + ch(e, f, g) + K[j] + W2[j] | 0;
          var T2 = sigma0(a) + maj(a, b, c) | 0;
          h = g;
          g = f;
          f = e;
          e = d + T1 | 0;
          d = c;
          c = b;
          b = a;
          a = T1 + T2 | 0;
        }
        this._a = a + this._a | 0;
        this._b = b + this._b | 0;
        this._c = c + this._c | 0;
        this._d = d + this._d | 0;
        this._e = e + this._e | 0;
        this._f = f + this._f | 0;
        this._g = g + this._g | 0;
        this._h = h + this._h | 0;
      };
      Sha256.prototype._hash = function() {
        var H = Buffer2.allocUnsafe(32);
        H.writeInt32BE(this._a, 0);
        H.writeInt32BE(this._b, 4);
        H.writeInt32BE(this._c, 8);
        H.writeInt32BE(this._d, 12);
        H.writeInt32BE(this._e, 16);
        H.writeInt32BE(this._f, 20);
        H.writeInt32BE(this._g, 24);
        H.writeInt32BE(this._h, 28);
        return H;
      };
      module2.exports = Sha256;
    }
  });

  // node_modules/sha.js/sha224.js
  var require_sha224 = __commonJS({
    "node_modules/sha.js/sha224.js"(exports2, module2) {
      var inherits = require_inherits_browser();
      var Sha256 = require_sha256();
      var Hash = require_hash();
      var Buffer2 = require_safe_buffer().Buffer;
      var W = new Array(64);
      function Sha224() {
        this.init();
        this._w = W;
        Hash.call(this, 64, 56);
      }
      inherits(Sha224, Sha256);
      Sha224.prototype.init = function() {
        this._a = 3238371032;
        this._b = 914150663;
        this._c = 812702999;
        this._d = 4144912697;
        this._e = 4290775857;
        this._f = 1750603025;
        this._g = 1694076839;
        this._h = 3204075428;
        return this;
      };
      Sha224.prototype._hash = function() {
        var H = Buffer2.allocUnsafe(28);
        H.writeInt32BE(this._a, 0);
        H.writeInt32BE(this._b, 4);
        H.writeInt32BE(this._c, 8);
        H.writeInt32BE(this._d, 12);
        H.writeInt32BE(this._e, 16);
        H.writeInt32BE(this._f, 20);
        H.writeInt32BE(this._g, 24);
        return H;
      };
      module2.exports = Sha224;
    }
  });

  // node_modules/sha.js/sha512.js
  var require_sha5122 = __commonJS({
    "node_modules/sha.js/sha512.js"(exports2, module2) {
      var inherits = require_inherits_browser();
      var Hash = require_hash();
      var Buffer2 = require_safe_buffer().Buffer;
      var K = [
        1116352408,
        3609767458,
        1899447441,
        602891725,
        3049323471,
        3964484399,
        3921009573,
        2173295548,
        961987163,
        4081628472,
        1508970993,
        3053834265,
        2453635748,
        2937671579,
        2870763221,
        3664609560,
        3624381080,
        2734883394,
        310598401,
        1164996542,
        607225278,
        1323610764,
        1426881987,
        3590304994,
        1925078388,
        4068182383,
        2162078206,
        991336113,
        2614888103,
        633803317,
        3248222580,
        3479774868,
        3835390401,
        2666613458,
        4022224774,
        944711139,
        264347078,
        2341262773,
        604807628,
        2007800933,
        770255983,
        1495990901,
        1249150122,
        1856431235,
        1555081692,
        3175218132,
        1996064986,
        2198950837,
        2554220882,
        3999719339,
        2821834349,
        766784016,
        2952996808,
        2566594879,
        3210313671,
        3203337956,
        3336571891,
        1034457026,
        3584528711,
        2466948901,
        113926993,
        3758326383,
        338241895,
        168717936,
        666307205,
        1188179964,
        773529912,
        1546045734,
        1294757372,
        1522805485,
        1396182291,
        2643833823,
        1695183700,
        2343527390,
        1986661051,
        1014477480,
        2177026350,
        1206759142,
        2456956037,
        344077627,
        2730485921,
        1290863460,
        2820302411,
        3158454273,
        3259730800,
        3505952657,
        3345764771,
        106217008,
        3516065817,
        3606008344,
        3600352804,
        1432725776,
        4094571909,
        1467031594,
        275423344,
        851169720,
        430227734,
        3100823752,
        506948616,
        1363258195,
        659060556,
        3750685593,
        883997877,
        3785050280,
        958139571,
        3318307427,
        1322822218,
        3812723403,
        1537002063,
        2003034995,
        1747873779,
        3602036899,
        1955562222,
        1575990012,
        2024104815,
        1125592928,
        2227730452,
        2716904306,
        2361852424,
        442776044,
        2428436474,
        593698344,
        2756734187,
        3733110249,
        3204031479,
        2999351573,
        3329325298,
        3815920427,
        3391569614,
        3928383900,
        3515267271,
        566280711,
        3940187606,
        3454069534,
        4118630271,
        4000239992,
        116418474,
        1914138554,
        174292421,
        2731055270,
        289380356,
        3203993006,
        460393269,
        320620315,
        685471733,
        587496836,
        852142971,
        1086792851,
        1017036298,
        365543100,
        1126000580,
        2618297676,
        1288033470,
        3409855158,
        1501505948,
        4234509866,
        1607167915,
        987167468,
        1816402316,
        1246189591
      ];
      var W = new Array(160);
      function Sha512() {
        this.init();
        this._w = W;
        Hash.call(this, 128, 112);
      }
      inherits(Sha512, Hash);
      Sha512.prototype.init = function() {
        this._ah = 1779033703;
        this._bh = 3144134277;
        this._ch = 1013904242;
        this._dh = 2773480762;
        this._eh = 1359893119;
        this._fh = 2600822924;
        this._gh = 528734635;
        this._hh = 1541459225;
        this._al = 4089235720;
        this._bl = 2227873595;
        this._cl = 4271175723;
        this._dl = 1595750129;
        this._el = 2917565137;
        this._fl = 725511199;
        this._gl = 4215389547;
        this._hl = 327033209;
        return this;
      };
      function Ch(x, y, z) {
        return z ^ x & (y ^ z);
      }
      function maj(x, y, z) {
        return x & y | z & (x | y);
      }
      function sigma0(x, xl) {
        return (x >>> 28 | xl << 4) ^ (xl >>> 2 | x << 30) ^ (xl >>> 7 | x << 25);
      }
      function sigma1(x, xl) {
        return (x >>> 14 | xl << 18) ^ (x >>> 18 | xl << 14) ^ (xl >>> 9 | x << 23);
      }
      function Gamma0(x, xl) {
        return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ x >>> 7;
      }
      function Gamma0l(x, xl) {
        return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7 | xl << 25);
      }
      function Gamma1(x, xl) {
        return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ x >>> 6;
      }
      function Gamma1l(x, xl) {
        return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6 | xl << 26);
      }
      function getCarry(a, b) {
        return a >>> 0 < b >>> 0 ? 1 : 0;
      }
      Sha512.prototype._update = function(M) {
        var W2 = this._w;
        var ah = this._ah | 0;
        var bh = this._bh | 0;
        var ch = this._ch | 0;
        var dh = this._dh | 0;
        var eh = this._eh | 0;
        var fh = this._fh | 0;
        var gh = this._gh | 0;
        var hh = this._hh | 0;
        var al = this._al | 0;
        var bl = this._bl | 0;
        var cl = this._cl | 0;
        var dl = this._dl | 0;
        var el = this._el | 0;
        var fl = this._fl | 0;
        var gl = this._gl | 0;
        var hl = this._hl | 0;
        for (var i = 0; i < 32; i += 2) {
          W2[i] = M.readInt32BE(i * 4);
          W2[i + 1] = M.readInt32BE(i * 4 + 4);
        }
        for (; i < 160; i += 2) {
          var xh = W2[i - 15 * 2];
          var xl = W2[i - 15 * 2 + 1];
          var gamma0 = Gamma0(xh, xl);
          var gamma0l = Gamma0l(xl, xh);
          xh = W2[i - 2 * 2];
          xl = W2[i - 2 * 2 + 1];
          var gamma1 = Gamma1(xh, xl);
          var gamma1l = Gamma1l(xl, xh);
          var Wi7h = W2[i - 7 * 2];
          var Wi7l = W2[i - 7 * 2 + 1];
          var Wi16h = W2[i - 16 * 2];
          var Wi16l = W2[i - 16 * 2 + 1];
          var Wil = gamma0l + Wi7l | 0;
          var Wih = gamma0 + Wi7h + getCarry(Wil, gamma0l) | 0;
          Wil = Wil + gamma1l | 0;
          Wih = Wih + gamma1 + getCarry(Wil, gamma1l) | 0;
          Wil = Wil + Wi16l | 0;
          Wih = Wih + Wi16h + getCarry(Wil, Wi16l) | 0;
          W2[i] = Wih;
          W2[i + 1] = Wil;
        }
        for (var j = 0; j < 160; j += 2) {
          Wih = W2[j];
          Wil = W2[j + 1];
          var majh = maj(ah, bh, ch);
          var majl = maj(al, bl, cl);
          var sigma0h = sigma0(ah, al);
          var sigma0l = sigma0(al, ah);
          var sigma1h = sigma1(eh, el);
          var sigma1l = sigma1(el, eh);
          var Kih = K[j];
          var Kil = K[j + 1];
          var chh = Ch(eh, fh, gh);
          var chl = Ch(el, fl, gl);
          var t1l = hl + sigma1l | 0;
          var t1h = hh + sigma1h + getCarry(t1l, hl) | 0;
          t1l = t1l + chl | 0;
          t1h = t1h + chh + getCarry(t1l, chl) | 0;
          t1l = t1l + Kil | 0;
          t1h = t1h + Kih + getCarry(t1l, Kil) | 0;
          t1l = t1l + Wil | 0;
          t1h = t1h + Wih + getCarry(t1l, Wil) | 0;
          var t2l = sigma0l + majl | 0;
          var t2h = sigma0h + majh + getCarry(t2l, sigma0l) | 0;
          hh = gh;
          hl = gl;
          gh = fh;
          gl = fl;
          fh = eh;
          fl = el;
          el = dl + t1l | 0;
          eh = dh + t1h + getCarry(el, dl) | 0;
          dh = ch;
          dl = cl;
          ch = bh;
          cl = bl;
          bh = ah;
          bl = al;
          al = t1l + t2l | 0;
          ah = t1h + t2h + getCarry(al, t1l) | 0;
        }
        this._al = this._al + al | 0;
        this._bl = this._bl + bl | 0;
        this._cl = this._cl + cl | 0;
        this._dl = this._dl + dl | 0;
        this._el = this._el + el | 0;
        this._fl = this._fl + fl | 0;
        this._gl = this._gl + gl | 0;
        this._hl = this._hl + hl | 0;
        this._ah = this._ah + ah + getCarry(this._al, al) | 0;
        this._bh = this._bh + bh + getCarry(this._bl, bl) | 0;
        this._ch = this._ch + ch + getCarry(this._cl, cl) | 0;
        this._dh = this._dh + dh + getCarry(this._dl, dl) | 0;
        this._eh = this._eh + eh + getCarry(this._el, el) | 0;
        this._fh = this._fh + fh + getCarry(this._fl, fl) | 0;
        this._gh = this._gh + gh + getCarry(this._gl, gl) | 0;
        this._hh = this._hh + hh + getCarry(this._hl, hl) | 0;
      };
      Sha512.prototype._hash = function() {
        var H = Buffer2.allocUnsafe(64);
        function writeInt64BE(h, l, offset) {
          H.writeInt32BE(h, offset);
          H.writeInt32BE(l, offset + 4);
        }
        writeInt64BE(this._ah, this._al, 0);
        writeInt64BE(this._bh, this._bl, 8);
        writeInt64BE(this._ch, this._cl, 16);
        writeInt64BE(this._dh, this._dl, 24);
        writeInt64BE(this._eh, this._el, 32);
        writeInt64BE(this._fh, this._fl, 40);
        writeInt64BE(this._gh, this._gl, 48);
        writeInt64BE(this._hh, this._hl, 56);
        return H;
      };
      module2.exports = Sha512;
    }
  });

  // node_modules/sha.js/sha384.js
  var require_sha384 = __commonJS({
    "node_modules/sha.js/sha384.js"(exports2, module2) {
      var inherits = require_inherits_browser();
      var SHA512 = require_sha5122();
      var Hash = require_hash();
      var Buffer2 = require_safe_buffer().Buffer;
      var W = new Array(160);
      function Sha384() {
        this.init();
        this._w = W;
        Hash.call(this, 128, 112);
      }
      inherits(Sha384, SHA512);
      Sha384.prototype.init = function() {
        this._ah = 3418070365;
        this._bh = 1654270250;
        this._ch = 2438529370;
        this._dh = 355462360;
        this._eh = 1731405415;
        this._fh = 2394180231;
        this._gh = 3675008525;
        this._hh = 1203062813;
        this._al = 3238371032;
        this._bl = 914150663;
        this._cl = 812702999;
        this._dl = 4144912697;
        this._el = 4290775857;
        this._fl = 1750603025;
        this._gl = 1694076839;
        this._hl = 3204075428;
        return this;
      };
      Sha384.prototype._hash = function() {
        var H = Buffer2.allocUnsafe(48);
        function writeInt64BE(h, l, offset) {
          H.writeInt32BE(h, offset);
          H.writeInt32BE(l, offset + 4);
        }
        writeInt64BE(this._ah, this._al, 0);
        writeInt64BE(this._bh, this._bl, 8);
        writeInt64BE(this._ch, this._cl, 16);
        writeInt64BE(this._dh, this._dl, 24);
        writeInt64BE(this._eh, this._el, 32);
        writeInt64BE(this._fh, this._fl, 40);
        return H;
      };
      module2.exports = Sha384;
    }
  });

  // node_modules/sha.js/index.js
  var require_sha3 = __commonJS({
    "node_modules/sha.js/index.js"(exports2, module2) {
      var exports2 = module2.exports = function SHA(algorithm) {
        algorithm = algorithm.toLowerCase();
        var Algorithm = exports2[algorithm];
        if (!Algorithm)
          throw new Error(algorithm + " is not supported (we accept pull requests)");
        return new Algorithm();
      };
      exports2.sha = require_sha();
      exports2.sha1 = require_sha1();
      exports2.sha224 = require_sha224();
      exports2.sha256 = require_sha256();
      exports2.sha384 = require_sha384();
      exports2.sha512 = require_sha5122();
    }
  });

  // node_modules/stream-browserify/index.js
  var require_stream_browserify = __commonJS({
    "node_modules/stream-browserify/index.js"(exports2, module2) {
      module2.exports = Stream;
      var EE = require_events().EventEmitter;
      var inherits = require_inherits_browser();
      inherits(Stream, EE);
      Stream.Readable = require_stream_readable();
      Stream.Writable = require_stream_writable();
      Stream.Duplex = require_stream_duplex();
      Stream.Transform = require_stream_transform();
      Stream.PassThrough = require_stream_passthrough();
      Stream.finished = require_end_of_stream();
      Stream.pipeline = require_pipeline();
      Stream.Stream = Stream;
      function Stream() {
        EE.call(this);
      }
      Stream.prototype.pipe = function(dest, options) {
        var source = this;
        function ondata(chunk) {
          if (dest.writable) {
            if (dest.write(chunk) === false && source.pause) {
              source.pause();
            }
          }
        }
        source.on("data", ondata);
        function ondrain() {
          if (source.readable && source.resume) {
            source.resume();
          }
        }
        dest.on("drain", ondrain);
        if (!dest._isStdio && (!options || options.end !== false)) {
          source.on("end", onend);
          source.on("close", onclose);
        }
        var didOnEnd = false;
        function onend() {
          if (didOnEnd)
            return;
          didOnEnd = true;
          dest.end();
        }
        function onclose() {
          if (didOnEnd)
            return;
          didOnEnd = true;
          if (typeof dest.destroy === "function")
            dest.destroy();
        }
        function onerror(er) {
          cleanup();
          if (EE.listenerCount(this, "error") === 0) {
            throw er;
          }
        }
        source.on("error", onerror);
        dest.on("error", onerror);
        function cleanup() {
          source.removeListener("data", ondata);
          dest.removeListener("drain", ondrain);
          source.removeListener("end", onend);
          source.removeListener("close", onclose);
          source.removeListener("error", onerror);
          dest.removeListener("error", onerror);
          source.removeListener("end", cleanup);
          source.removeListener("close", cleanup);
          dest.removeListener("close", cleanup);
        }
        source.on("end", cleanup);
        source.on("close", cleanup);
        dest.on("close", cleanup);
        dest.emit("pipe", source);
        return dest;
      };
    }
  });

  // node_modules/cipher-base/index.js
  var require_cipher_base = __commonJS({
    "node_modules/cipher-base/index.js"(exports2, module2) {
      var Buffer2 = require_safe_buffer().Buffer;
      var Transform = require_stream_browserify().Transform;
      var StringDecoder = require_string_decoder().StringDecoder;
      var inherits = require_inherits_browser();
      function CipherBase(hashMode) {
        Transform.call(this);
        this.hashMode = typeof hashMode === "string";
        if (this.hashMode) {
          this[hashMode] = this._finalOrDigest;
        } else {
          this.final = this._finalOrDigest;
        }
        if (this._final) {
          this.__final = this._final;
          this._final = null;
        }
        this._decoder = null;
        this._encoding = null;
      }
      inherits(CipherBase, Transform);
      CipherBase.prototype.update = function(data, inputEnc, outputEnc) {
        if (typeof data === "string") {
          data = Buffer2.from(data, inputEnc);
        }
        var outData = this._update(data);
        if (this.hashMode)
          return this;
        if (outputEnc) {
          outData = this._toString(outData, outputEnc);
        }
        return outData;
      };
      CipherBase.prototype.setAutoPadding = function() {
      };
      CipherBase.prototype.getAuthTag = function() {
        throw new Error("trying to get auth tag in unsupported state");
      };
      CipherBase.prototype.setAuthTag = function() {
        throw new Error("trying to set auth tag in unsupported state");
      };
      CipherBase.prototype.setAAD = function() {
        throw new Error("trying to set aad in unsupported state");
      };
      CipherBase.prototype._transform = function(data, _, next) {
        var err;
        try {
          if (this.hashMode) {
            this._update(data);
          } else {
            this.push(this._update(data));
          }
        } catch (e) {
          err = e;
        } finally {
          next(err);
        }
      };
      CipherBase.prototype._flush = function(done) {
        var err;
        try {
          this.push(this.__final());
        } catch (e) {
          err = e;
        }
        done(err);
      };
      CipherBase.prototype._finalOrDigest = function(outputEnc) {
        var outData = this.__final() || Buffer2.alloc(0);
        if (outputEnc) {
          outData = this._toString(outData, outputEnc, true);
        }
        return outData;
      };
      CipherBase.prototype._toString = function(value, enc, fin) {
        if (!this._decoder) {
          this._decoder = new StringDecoder(enc);
          this._encoding = enc;
        }
        if (this._encoding !== enc)
          throw new Error("can't switch encodings");
        var out = this._decoder.write(value);
        if (fin) {
          out += this._decoder.end();
        }
        return out;
      };
      module2.exports = CipherBase;
    }
  });

  // node_modules/create-hash/browser.js
  var require_browser3 = __commonJS({
    "node_modules/create-hash/browser.js"(exports2, module2) {
      "use strict";
      var inherits = require_inherits_browser();
      var MD5 = require_md5();
      var RIPEMD160 = require_ripemd160();
      var sha = require_sha3();
      var Base = require_cipher_base();
      function Hash(hash) {
        Base.call(this, "digest");
        this._hash = hash;
      }
      inherits(Hash, Base);
      Hash.prototype._update = function(data) {
        this._hash.update(data);
      };
      Hash.prototype._final = function() {
        return this._hash.digest();
      };
      module2.exports = function createHash(alg) {
        alg = alg.toLowerCase();
        if (alg === "md5")
          return new MD5();
        if (alg === "rmd160" || alg === "ripemd160")
          return new RIPEMD160();
        return new Hash(sha(alg));
      };
    }
  });

  // node_modules/create-hmac/legacy.js
  var require_legacy = __commonJS({
    "node_modules/create-hmac/legacy.js"(exports2, module2) {
      "use strict";
      var inherits = require_inherits_browser();
      var Buffer2 = require_safe_buffer().Buffer;
      var Base = require_cipher_base();
      var ZEROS = Buffer2.alloc(128);
      var blocksize = 64;
      function Hmac(alg, key) {
        Base.call(this, "digest");
        if (typeof key === "string") {
          key = Buffer2.from(key);
        }
        this._alg = alg;
        this._key = key;
        if (key.length > blocksize) {
          key = alg(key);
        } else if (key.length < blocksize) {
          key = Buffer2.concat([key, ZEROS], blocksize);
        }
        var ipad = this._ipad = Buffer2.allocUnsafe(blocksize);
        var opad = this._opad = Buffer2.allocUnsafe(blocksize);
        for (var i = 0; i < blocksize; i++) {
          ipad[i] = key[i] ^ 54;
          opad[i] = key[i] ^ 92;
        }
        this._hash = [ipad];
      }
      inherits(Hmac, Base);
      Hmac.prototype._update = function(data) {
        this._hash.push(data);
      };
      Hmac.prototype._final = function() {
        var h = this._alg(Buffer2.concat(this._hash));
        return this._alg(Buffer2.concat([this._opad, h]));
      };
      module2.exports = Hmac;
    }
  });

  // node_modules/create-hash/md5.js
  var require_md52 = __commonJS({
    "node_modules/create-hash/md5.js"(exports2, module2) {
      var MD5 = require_md5();
      module2.exports = function(buffer) {
        return new MD5().update(buffer).digest();
      };
    }
  });

  // node_modules/create-hmac/browser.js
  var require_browser4 = __commonJS({
    "node_modules/create-hmac/browser.js"(exports2, module2) {
      "use strict";
      var inherits = require_inherits_browser();
      var Legacy = require_legacy();
      var Base = require_cipher_base();
      var Buffer2 = require_safe_buffer().Buffer;
      var md5 = require_md52();
      var RIPEMD160 = require_ripemd160();
      var sha = require_sha3();
      var ZEROS = Buffer2.alloc(128);
      function Hmac(alg, key) {
        Base.call(this, "digest");
        if (typeof key === "string") {
          key = Buffer2.from(key);
        }
        var blocksize = alg === "sha512" || alg === "sha384" ? 128 : 64;
        this._alg = alg;
        this._key = key;
        if (key.length > blocksize) {
          var hash = alg === "rmd160" ? new RIPEMD160() : sha(alg);
          key = hash.update(key).digest();
        } else if (key.length < blocksize) {
          key = Buffer2.concat([key, ZEROS], blocksize);
        }
        var ipad = this._ipad = Buffer2.allocUnsafe(blocksize);
        var opad = this._opad = Buffer2.allocUnsafe(blocksize);
        for (var i = 0; i < blocksize; i++) {
          ipad[i] = key[i] ^ 54;
          opad[i] = key[i] ^ 92;
        }
        this._hash = alg === "rmd160" ? new RIPEMD160() : sha(alg);
        this._hash.update(ipad);
      }
      inherits(Hmac, Base);
      Hmac.prototype._update = function(data) {
        this._hash.update(data);
      };
      Hmac.prototype._final = function() {
        var h = this._hash.digest();
        var hash = this._alg === "rmd160" ? new RIPEMD160() : sha(this._alg);
        return hash.update(this._opad).update(h).digest();
      };
      module2.exports = function createHmac(alg, key) {
        alg = alg.toLowerCase();
        if (alg === "rmd160" || alg === "ripemd160") {
          return new Hmac("rmd160", key);
        }
        if (alg === "md5") {
          return new Legacy(md5, key);
        }
        return new Hmac(alg, key);
      };
    }
  });

  // node_modules/browserify-sign/browser/algorithms.json
  var require_algorithms = __commonJS({
    "node_modules/browserify-sign/browser/algorithms.json"(exports2, module2) {
      module2.exports = {
        sha224WithRSAEncryption: {
          sign: "rsa",
          hash: "sha224",
          id: "302d300d06096086480165030402040500041c"
        },
        "RSA-SHA224": {
          sign: "ecdsa/rsa",
          hash: "sha224",
          id: "302d300d06096086480165030402040500041c"
        },
        sha256WithRSAEncryption: {
          sign: "rsa",
          hash: "sha256",
          id: "3031300d060960864801650304020105000420"
        },
        "RSA-SHA256": {
          sign: "ecdsa/rsa",
          hash: "sha256",
          id: "3031300d060960864801650304020105000420"
        },
        sha384WithRSAEncryption: {
          sign: "rsa",
          hash: "sha384",
          id: "3041300d060960864801650304020205000430"
        },
        "RSA-SHA384": {
          sign: "ecdsa/rsa",
          hash: "sha384",
          id: "3041300d060960864801650304020205000430"
        },
        sha512WithRSAEncryption: {
          sign: "rsa",
          hash: "sha512",
          id: "3051300d060960864801650304020305000440"
        },
        "RSA-SHA512": {
          sign: "ecdsa/rsa",
          hash: "sha512",
          id: "3051300d060960864801650304020305000440"
        },
        "RSA-SHA1": {
          sign: "rsa",
          hash: "sha1",
          id: "3021300906052b0e03021a05000414"
        },
        "ecdsa-with-SHA1": {
          sign: "ecdsa",
          hash: "sha1",
          id: ""
        },
        sha256: {
          sign: "ecdsa",
          hash: "sha256",
          id: ""
        },
        sha224: {
          sign: "ecdsa",
          hash: "sha224",
          id: ""
        },
        sha384: {
          sign: "ecdsa",
          hash: "sha384",
          id: ""
        },
        sha512: {
          sign: "ecdsa",
          hash: "sha512",
          id: ""
        },
        "DSA-SHA": {
          sign: "dsa",
          hash: "sha1",
          id: ""
        },
        "DSA-SHA1": {
          sign: "dsa",
          hash: "sha1",
          id: ""
        },
        DSA: {
          sign: "dsa",
          hash: "sha1",
          id: ""
        },
        "DSA-WITH-SHA224": {
          sign: "dsa",
          hash: "sha224",
          id: ""
        },
        "DSA-SHA224": {
          sign: "dsa",
          hash: "sha224",
          id: ""
        },
        "DSA-WITH-SHA256": {
          sign: "dsa",
          hash: "sha256",
          id: ""
        },
        "DSA-SHA256": {
          sign: "dsa",
          hash: "sha256",
          id: ""
        },
        "DSA-WITH-SHA384": {
          sign: "dsa",
          hash: "sha384",
          id: ""
        },
        "DSA-SHA384": {
          sign: "dsa",
          hash: "sha384",
          id: ""
        },
        "DSA-WITH-SHA512": {
          sign: "dsa",
          hash: "sha512",
          id: ""
        },
        "DSA-SHA512": {
          sign: "dsa",
          hash: "sha512",
          id: ""
        },
        "DSA-RIPEMD160": {
          sign: "dsa",
          hash: "rmd160",
          id: ""
        },
        ripemd160WithRSA: {
          sign: "rsa",
          hash: "rmd160",
          id: "3021300906052b2403020105000414"
        },
        "RSA-RIPEMD160": {
          sign: "rsa",
          hash: "rmd160",
          id: "3021300906052b2403020105000414"
        },
        md5WithRSAEncryption: {
          sign: "rsa",
          hash: "md5",
          id: "3020300c06082a864886f70d020505000410"
        },
        "RSA-MD5": {
          sign: "rsa",
          hash: "md5",
          id: "3020300c06082a864886f70d020505000410"
        }
      };
    }
  });

  // node_modules/browserify-sign/algos.js
  var require_algos = __commonJS({
    "node_modules/browserify-sign/algos.js"(exports2, module2) {
      module2.exports = require_algorithms();
    }
  });

  // node_modules/pbkdf2/lib/precondition.js
  var require_precondition = __commonJS({
    "node_modules/pbkdf2/lib/precondition.js"(exports2, module2) {
      var MAX_ALLOC = Math.pow(2, 30) - 1;
      module2.exports = function(iterations, keylen) {
        if (typeof iterations !== "number") {
          throw new TypeError("Iterations not a number");
        }
        if (iterations < 0) {
          throw new TypeError("Bad iterations");
        }
        if (typeof keylen !== "number") {
          throw new TypeError("Key length not a number");
        }
        if (keylen < 0 || keylen > MAX_ALLOC || keylen !== keylen) {
          throw new TypeError("Bad key length");
        }
      };
    }
  });

  // node_modules/pbkdf2/lib/default-encoding.js
  var require_default_encoding = __commonJS({
    "node_modules/pbkdf2/lib/default-encoding.js"(exports2, module2) {
      var defaultEncoding;
      if (global.process && global.process.browser) {
        defaultEncoding = "utf-8";
      } else if (global.process && global.process.version) {
        pVersionMajor = parseInt(process.version.split(".")[0].slice(1), 10);
        defaultEncoding = pVersionMajor >= 6 ? "utf-8" : "binary";
      } else {
        defaultEncoding = "utf-8";
      }
      var pVersionMajor;
      module2.exports = defaultEncoding;
    }
  });

  // node_modules/pbkdf2/lib/to-buffer.js
  var require_to_buffer = __commonJS({
    "node_modules/pbkdf2/lib/to-buffer.js"(exports2, module2) {
      var Buffer2 = require_safe_buffer().Buffer;
      module2.exports = function(thing, encoding, name) {
        if (Buffer2.isBuffer(thing)) {
          return thing;
        } else if (typeof thing === "string") {
          return Buffer2.from(thing, encoding);
        } else if (ArrayBuffer.isView(thing)) {
          return Buffer2.from(thing.buffer);
        } else {
          throw new TypeError(name + " must be a string, a Buffer, a typed array or a DataView");
        }
      };
    }
  });

  // node_modules/pbkdf2/lib/sync-browser.js
  var require_sync_browser = __commonJS({
    "node_modules/pbkdf2/lib/sync-browser.js"(exports2, module2) {
      var md5 = require_md52();
      var RIPEMD160 = require_ripemd160();
      var sha = require_sha3();
      var Buffer2 = require_safe_buffer().Buffer;
      var checkParameters = require_precondition();
      var defaultEncoding = require_default_encoding();
      var toBuffer = require_to_buffer();
      var ZEROS = Buffer2.alloc(128);
      var sizes = {
        md5: 16,
        sha1: 20,
        sha224: 28,
        sha256: 32,
        sha384: 48,
        sha512: 64,
        rmd160: 20,
        ripemd160: 20
      };
      function Hmac(alg, key, saltLen) {
        var hash = getDigest(alg);
        var blocksize = alg === "sha512" || alg === "sha384" ? 128 : 64;
        if (key.length > blocksize) {
          key = hash(key);
        } else if (key.length < blocksize) {
          key = Buffer2.concat([key, ZEROS], blocksize);
        }
        var ipad = Buffer2.allocUnsafe(blocksize + sizes[alg]);
        var opad = Buffer2.allocUnsafe(blocksize + sizes[alg]);
        for (var i = 0; i < blocksize; i++) {
          ipad[i] = key[i] ^ 54;
          opad[i] = key[i] ^ 92;
        }
        var ipad1 = Buffer2.allocUnsafe(blocksize + saltLen + 4);
        ipad.copy(ipad1, 0, 0, blocksize);
        this.ipad1 = ipad1;
        this.ipad2 = ipad;
        this.opad = opad;
        this.alg = alg;
        this.blocksize = blocksize;
        this.hash = hash;
        this.size = sizes[alg];
      }
      Hmac.prototype.run = function(data, ipad) {
        data.copy(ipad, this.blocksize);
        var h = this.hash(ipad);
        h.copy(this.opad, this.blocksize);
        return this.hash(this.opad);
      };
      function getDigest(alg) {
        function shaFunc(data) {
          return sha(alg).update(data).digest();
        }
        function rmd160Func(data) {
          return new RIPEMD160().update(data).digest();
        }
        if (alg === "rmd160" || alg === "ripemd160")
          return rmd160Func;
        if (alg === "md5")
          return md5;
        return shaFunc;
      }
      function pbkdf2(password, salt, iterations, keylen, digest) {
        checkParameters(iterations, keylen);
        password = toBuffer(password, defaultEncoding, "Password");
        salt = toBuffer(salt, defaultEncoding, "Salt");
        digest = digest || "sha1";
        var hmac = new Hmac(digest, password, salt.length);
        var DK = Buffer2.allocUnsafe(keylen);
        var block1 = Buffer2.allocUnsafe(salt.length + 4);
        salt.copy(block1, 0, 0, salt.length);
        var destPos = 0;
        var hLen = sizes[digest];
        var l = Math.ceil(keylen / hLen);
        for (var i = 1; i <= l; i++) {
          block1.writeUInt32BE(i, salt.length);
          var T = hmac.run(block1, hmac.ipad1);
          var U = T;
          for (var j = 1; j < iterations; j++) {
            U = hmac.run(U, hmac.ipad2);
            for (var k = 0; k < hLen; k++)
              T[k] ^= U[k];
          }
          T.copy(DK, destPos);
          destPos += hLen;
        }
        return DK;
      }
      module2.exports = pbkdf2;
    }
  });

  // node_modules/pbkdf2/lib/async.js
  var require_async = __commonJS({
    "node_modules/pbkdf2/lib/async.js"(exports2, module2) {
      var Buffer2 = require_safe_buffer().Buffer;
      var checkParameters = require_precondition();
      var defaultEncoding = require_default_encoding();
      var sync = require_sync_browser();
      var toBuffer = require_to_buffer();
      var ZERO_BUF;
      var subtle = global.crypto && global.crypto.subtle;
      var toBrowser = {
        sha: "SHA-1",
        "sha-1": "SHA-1",
        sha1: "SHA-1",
        sha256: "SHA-256",
        "sha-256": "SHA-256",
        sha384: "SHA-384",
        "sha-384": "SHA-384",
        "sha-512": "SHA-512",
        sha512: "SHA-512"
      };
      var checks = [];
      function checkNative(algo) {
        if (global.process && !global.process.browser) {
          return Promise.resolve(false);
        }
        if (!subtle || !subtle.importKey || !subtle.deriveBits) {
          return Promise.resolve(false);
        }
        if (checks[algo] !== void 0) {
          return checks[algo];
        }
        ZERO_BUF = ZERO_BUF || Buffer2.alloc(8);
        var prom = browserPbkdf2(ZERO_BUF, ZERO_BUF, 10, 128, algo).then(function() {
          return true;
        }).catch(function() {
          return false;
        });
        checks[algo] = prom;
        return prom;
      }
      var nextTick;
      function getNextTick() {
        if (nextTick) {
          return nextTick;
        }
        if (global.process && global.process.nextTick) {
          nextTick = global.process.nextTick;
        } else if (global.queueMicrotask) {
          nextTick = global.queueMicrotask;
        } else if (global.setImmediate) {
          nextTick = global.setImmediate;
        } else {
          nextTick = global.setTimeout;
        }
        return nextTick;
      }
      function browserPbkdf2(password, salt, iterations, length, algo) {
        return subtle.importKey("raw", password, { name: "PBKDF2" }, false, ["deriveBits"]).then(function(key) {
          return subtle.deriveBits({
            name: "PBKDF2",
            salt,
            iterations,
            hash: {
              name: algo
            }
          }, key, length << 3);
        }).then(function(res) {
          return Buffer2.from(res);
        });
      }
      function resolvePromise(promise, callback) {
        promise.then(function(out) {
          getNextTick()(function() {
            callback(null, out);
          });
        }, function(e) {
          getNextTick()(function() {
            callback(e);
          });
        });
      }
      module2.exports = function(password, salt, iterations, keylen, digest, callback) {
        if (typeof digest === "function") {
          callback = digest;
          digest = void 0;
        }
        digest = digest || "sha1";
        var algo = toBrowser[digest.toLowerCase()];
        if (!algo || typeof global.Promise !== "function") {
          getNextTick()(function() {
            var out;
            try {
              out = sync(password, salt, iterations, keylen, digest);
            } catch (e) {
              return callback(e);
            }
            callback(null, out);
          });
          return;
        }
        checkParameters(iterations, keylen);
        password = toBuffer(password, defaultEncoding, "Password");
        salt = toBuffer(salt, defaultEncoding, "Salt");
        if (typeof callback !== "function")
          throw new Error("No callback provided to pbkdf2");
        resolvePromise(checkNative(algo).then(function(resp) {
          if (resp)
            return browserPbkdf2(password, salt, iterations, keylen, algo);
          return sync(password, salt, iterations, keylen, digest);
        }), callback);
      };
    }
  });

  // node_modules/pbkdf2/browser.js
  var require_browser5 = __commonJS({
    "node_modules/pbkdf2/browser.js"(exports2) {
      exports2.pbkdf2 = require_async();
      exports2.pbkdf2Sync = require_sync_browser();
    }
  });

  // node_modules/des.js/lib/des/utils.js
  var require_utils2 = __commonJS({
    "node_modules/des.js/lib/des/utils.js"(exports2) {
      "use strict";
      exports2.readUInt32BE = function readUInt32BE(bytes, off) {
        var res = bytes[0 + off] << 24 | bytes[1 + off] << 16 | bytes[2 + off] << 8 | bytes[3 + off];
        return res >>> 0;
      };
      exports2.writeUInt32BE = function writeUInt32BE(bytes, value, off) {
        bytes[0 + off] = value >>> 24;
        bytes[1 + off] = value >>> 16 & 255;
        bytes[2 + off] = value >>> 8 & 255;
        bytes[3 + off] = value & 255;
      };
      exports2.ip = function ip(inL, inR, out, off) {
        var outL = 0;
        var outR = 0;
        for (var i = 6; i >= 0; i -= 2) {
          for (var j = 0; j <= 24; j += 8) {
            outL <<= 1;
            outL |= inR >>> j + i & 1;
          }
          for (var j = 0; j <= 24; j += 8) {
            outL <<= 1;
            outL |= inL >>> j + i & 1;
          }
        }
        for (var i = 6; i >= 0; i -= 2) {
          for (var j = 1; j <= 25; j += 8) {
            outR <<= 1;
            outR |= inR >>> j + i & 1;
          }
          for (var j = 1; j <= 25; j += 8) {
            outR <<= 1;
            outR |= inL >>> j + i & 1;
          }
        }
        out[off + 0] = outL >>> 0;
        out[off + 1] = outR >>> 0;
      };
      exports2.rip = function rip(inL, inR, out, off) {
        var outL = 0;
        var outR = 0;
        for (var i = 0; i < 4; i++) {
          for (var j = 24; j >= 0; j -= 8) {
            outL <<= 1;
            outL |= inR >>> j + i & 1;
            outL <<= 1;
            outL |= inL >>> j + i & 1;
          }
        }
        for (var i = 4; i < 8; i++) {
          for (var j = 24; j >= 0; j -= 8) {
            outR <<= 1;
            outR |= inR >>> j + i & 1;
            outR <<= 1;
            outR |= inL >>> j + i & 1;
          }
        }
        out[off + 0] = outL >>> 0;
        out[off + 1] = outR >>> 0;
      };
      exports2.pc1 = function pc1(inL, inR, out, off) {
        var outL = 0;
        var outR = 0;
        for (var i = 7; i >= 5; i--) {
          for (var j = 0; j <= 24; j += 8) {
            outL <<= 1;
            outL |= inR >> j + i & 1;
          }
          for (var j = 0; j <= 24; j += 8) {
            outL <<= 1;
            outL |= inL >> j + i & 1;
          }
        }
        for (var j = 0; j <= 24; j += 8) {
          outL <<= 1;
          outL |= inR >> j + i & 1;
        }
        for (var i = 1; i <= 3; i++) {
          for (var j = 0; j <= 24; j += 8) {
            outR <<= 1;
            outR |= inR >> j + i & 1;
          }
          for (var j = 0; j <= 24; j += 8) {
            outR <<= 1;
            outR |= inL >> j + i & 1;
          }
        }
        for (var j = 0; j <= 24; j += 8) {
          outR <<= 1;
          outR |= inL >> j + i & 1;
        }
        out[off + 0] = outL >>> 0;
        out[off + 1] = outR >>> 0;
      };
      exports2.r28shl = function r28shl(num, shift) {
        return num << shift & 268435455 | num >>> 28 - shift;
      };
      var pc2table = [
        14,
        11,
        17,
        4,
        27,
        23,
        25,
        0,
        13,
        22,
        7,
        18,
        5,
        9,
        16,
        24,
        2,
        20,
        12,
        21,
        1,
        8,
        15,
        26,
        15,
        4,
        25,
        19,
        9,
        1,
        26,
        16,
        5,
        11,
        23,
        8,
        12,
        7,
        17,
        0,
        22,
        3,
        10,
        14,
        6,
        20,
        27,
        24
      ];
      exports2.pc2 = function pc2(inL, inR, out, off) {
        var outL = 0;
        var outR = 0;
        var len = pc2table.length >>> 1;
        for (var i = 0; i < len; i++) {
          outL <<= 1;
          outL |= inL >>> pc2table[i] & 1;
        }
        for (var i = len; i < pc2table.length; i++) {
          outR <<= 1;
          outR |= inR >>> pc2table[i] & 1;
        }
        out[off + 0] = outL >>> 0;
        out[off + 1] = outR >>> 0;
      };
      exports2.expand = function expand(r, out, off) {
        var outL = 0;
        var outR = 0;
        outL = (r & 1) << 5 | r >>> 27;
        for (var i = 23; i >= 15; i -= 4) {
          outL <<= 6;
          outL |= r >>> i & 63;
        }
        for (var i = 11; i >= 3; i -= 4) {
          outR |= r >>> i & 63;
          outR <<= 6;
        }
        outR |= (r & 31) << 1 | r >>> 31;
        out[off + 0] = outL >>> 0;
        out[off + 1] = outR >>> 0;
      };
      var sTable = [
        14,
        0,
        4,
        15,
        13,
        7,
        1,
        4,
        2,
        14,
        15,
        2,
        11,
        13,
        8,
        1,
        3,
        10,
        10,
        6,
        6,
        12,
        12,
        11,
        5,
        9,
        9,
        5,
        0,
        3,
        7,
        8,
        4,
        15,
        1,
        12,
        14,
        8,
        8,
        2,
        13,
        4,
        6,
        9,
        2,
        1,
        11,
        7,
        15,
        5,
        12,
        11,
        9,
        3,
        7,
        14,
        3,
        10,
        10,
        0,
        5,
        6,
        0,
        13,
        15,
        3,
        1,
        13,
        8,
        4,
        14,
        7,
        6,
        15,
        11,
        2,
        3,
        8,
        4,
        14,
        9,
        12,
        7,
        0,
        2,
        1,
        13,
        10,
        12,
        6,
        0,
        9,
        5,
        11,
        10,
        5,
        0,
        13,
        14,
        8,
        7,
        10,
        11,
        1,
        10,
        3,
        4,
        15,
        13,
        4,
        1,
        2,
        5,
        11,
        8,
        6,
        12,
        7,
        6,
        12,
        9,
        0,
        3,
        5,
        2,
        14,
        15,
        9,
        10,
        13,
        0,
        7,
        9,
        0,
        14,
        9,
        6,
        3,
        3,
        4,
        15,
        6,
        5,
        10,
        1,
        2,
        13,
        8,
        12,
        5,
        7,
        14,
        11,
        12,
        4,
        11,
        2,
        15,
        8,
        1,
        13,
        1,
        6,
        10,
        4,
        13,
        9,
        0,
        8,
        6,
        15,
        9,
        3,
        8,
        0,
        7,
        11,
        4,
        1,
        15,
        2,
        14,
        12,
        3,
        5,
        11,
        10,
        5,
        14,
        2,
        7,
        12,
        7,
        13,
        13,
        8,
        14,
        11,
        3,
        5,
        0,
        6,
        6,
        15,
        9,
        0,
        10,
        3,
        1,
        4,
        2,
        7,
        8,
        2,
        5,
        12,
        11,
        1,
        12,
        10,
        4,
        14,
        15,
        9,
        10,
        3,
        6,
        15,
        9,
        0,
        0,
        6,
        12,
        10,
        11,
        1,
        7,
        13,
        13,
        8,
        15,
        9,
        1,
        4,
        3,
        5,
        14,
        11,
        5,
        12,
        2,
        7,
        8,
        2,
        4,
        14,
        2,
        14,
        12,
        11,
        4,
        2,
        1,
        12,
        7,
        4,
        10,
        7,
        11,
        13,
        6,
        1,
        8,
        5,
        5,
        0,
        3,
        15,
        15,
        10,
        13,
        3,
        0,
        9,
        14,
        8,
        9,
        6,
        4,
        11,
        2,
        8,
        1,
        12,
        11,
        7,
        10,
        1,
        13,
        14,
        7,
        2,
        8,
        13,
        15,
        6,
        9,
        15,
        12,
        0,
        5,
        9,
        6,
        10,
        3,
        4,
        0,
        5,
        14,
        3,
        12,
        10,
        1,
        15,
        10,
        4,
        15,
        2,
        9,
        7,
        2,
        12,
        6,
        9,
        8,
        5,
        0,
        6,
        13,
        1,
        3,
        13,
        4,
        14,
        14,
        0,
        7,
        11,
        5,
        3,
        11,
        8,
        9,
        4,
        14,
        3,
        15,
        2,
        5,
        12,
        2,
        9,
        8,
        5,
        12,
        15,
        3,
        10,
        7,
        11,
        0,
        14,
        4,
        1,
        10,
        7,
        1,
        6,
        13,
        0,
        11,
        8,
        6,
        13,
        4,
        13,
        11,
        0,
        2,
        11,
        14,
        7,
        15,
        4,
        0,
        9,
        8,
        1,
        13,
        10,
        3,
        14,
        12,
        3,
        9,
        5,
        7,
        12,
        5,
        2,
        10,
        15,
        6,
        8,
        1,
        6,
        1,
        6,
        4,
        11,
        11,
        13,
        13,
        8,
        12,
        1,
        3,
        4,
        7,
        10,
        14,
        7,
        10,
        9,
        15,
        5,
        6,
        0,
        8,
        15,
        0,
        14,
        5,
        2,
        9,
        3,
        2,
        12,
        13,
        1,
        2,
        15,
        8,
        13,
        4,
        8,
        6,
        10,
        15,
        3,
        11,
        7,
        1,
        4,
        10,
        12,
        9,
        5,
        3,
        6,
        14,
        11,
        5,
        0,
        0,
        14,
        12,
        9,
        7,
        2,
        7,
        2,
        11,
        1,
        4,
        14,
        1,
        7,
        9,
        4,
        12,
        10,
        14,
        8,
        2,
        13,
        0,
        15,
        6,
        12,
        10,
        9,
        13,
        0,
        15,
        3,
        3,
        5,
        5,
        6,
        8,
        11
      ];
      exports2.substitute = function substitute(inL, inR) {
        var out = 0;
        for (var i = 0; i < 4; i++) {
          var b = inL >>> 18 - i * 6 & 63;
          var sb = sTable[i * 64 + b];
          out <<= 4;
          out |= sb;
        }
        for (var i = 0; i < 4; i++) {
          var b = inR >>> 18 - i * 6 & 63;
          var sb = sTable[4 * 64 + i * 64 + b];
          out <<= 4;
          out |= sb;
        }
        return out >>> 0;
      };
      var permuteTable = [
        16,
        25,
        12,
        11,
        3,
        20,
        4,
        15,
        31,
        17,
        9,
        6,
        27,
        14,
        1,
        22,
        30,
        24,
        8,
        18,
        0,
        5,
        29,
        23,
        13,
        19,
        2,
        26,
        10,
        21,
        28,
        7
      ];
      exports2.permute = function permute(num) {
        var out = 0;
        for (var i = 0; i < permuteTable.length; i++) {
          out <<= 1;
          out |= num >>> permuteTable[i] & 1;
        }
        return out >>> 0;
      };
      exports2.padSplit = function padSplit(num, size, group) {
        var str = num.toString(2);
        while (str.length < size)
          str = "0" + str;
        var out = [];
        for (var i = 0; i < size; i += group)
          out.push(str.slice(i, i + group));
        return out.join(" ");
      };
    }
  });

  // node_modules/minimalistic-assert/index.js
  var require_minimalistic_assert = __commonJS({
    "node_modules/minimalistic-assert/index.js"(exports2, module2) {
      module2.exports = assert;
      function assert(val, msg) {
        if (!val)
          throw new Error(msg || "Assertion failed");
      }
      assert.equal = function assertEqual(l, r, msg) {
        if (l != r)
          throw new Error(msg || "Assertion failed: " + l + " != " + r);
      };
    }
  });

  // node_modules/des.js/lib/des/cipher.js
  var require_cipher = __commonJS({
    "node_modules/des.js/lib/des/cipher.js"(exports2, module2) {
      "use strict";
      var assert = require_minimalistic_assert();
      function Cipher(options) {
        this.options = options;
        this.type = this.options.type;
        this.blockSize = 8;
        this._init();
        this.buffer = new Array(this.blockSize);
        this.bufferOff = 0;
      }
      module2.exports = Cipher;
      Cipher.prototype._init = function _init() {
      };
      Cipher.prototype.update = function update(data) {
        if (data.length === 0)
          return [];
        if (this.type === "decrypt")
          return this._updateDecrypt(data);
        else
          return this._updateEncrypt(data);
      };
      Cipher.prototype._buffer = function _buffer(data, off) {
        var min = Math.min(this.buffer.length - this.bufferOff, data.length - off);
        for (var i = 0; i < min; i++)
          this.buffer[this.bufferOff + i] = data[off + i];
        this.bufferOff += min;
        return min;
      };
      Cipher.prototype._flushBuffer = function _flushBuffer(out, off) {
        this._update(this.buffer, 0, out, off);
        this.bufferOff = 0;
        return this.blockSize;
      };
      Cipher.prototype._updateEncrypt = function _updateEncrypt(data) {
        var inputOff = 0;
        var outputOff = 0;
        var count = (this.bufferOff + data.length) / this.blockSize | 0;
        var out = new Array(count * this.blockSize);
        if (this.bufferOff !== 0) {
          inputOff += this._buffer(data, inputOff);
          if (this.bufferOff === this.buffer.length)
            outputOff += this._flushBuffer(out, outputOff);
        }
        var max = data.length - (data.length - inputOff) % this.blockSize;
        for (; inputOff < max; inputOff += this.blockSize) {
          this._update(data, inputOff, out, outputOff);
          outputOff += this.blockSize;
        }
        for (; inputOff < data.length; inputOff++, this.bufferOff++)
          this.buffer[this.bufferOff] = data[inputOff];
        return out;
      };
      Cipher.prototype._updateDecrypt = function _updateDecrypt(data) {
        var inputOff = 0;
        var outputOff = 0;
        var count = Math.ceil((this.bufferOff + data.length) / this.blockSize) - 1;
        var out = new Array(count * this.blockSize);
        for (; count > 0; count--) {
          inputOff += this._buffer(data, inputOff);
          outputOff += this._flushBuffer(out, outputOff);
        }
        inputOff += this._buffer(data, inputOff);
        return out;
      };
      Cipher.prototype.final = function final(buffer) {
        var first;
        if (buffer)
          first = this.update(buffer);
        var last;
        if (this.type === "encrypt")
          last = this._finalEncrypt();
        else
          last = this._finalDecrypt();
        if (first)
          return first.concat(last);
        else
          return last;
      };
      Cipher.prototype._pad = function _pad(buffer, off) {
        if (off === 0)
          return false;
        while (off < buffer.length)
          buffer[off++] = 0;
        return true;
      };
      Cipher.prototype._finalEncrypt = function _finalEncrypt() {
        if (!this._pad(this.buffer, this.bufferOff))
          return [];
        var out = new Array(this.blockSize);
        this._update(this.buffer, 0, out, 0);
        return out;
      };
      Cipher.prototype._unpad = function _unpad(buffer) {
        return buffer;
      };
      Cipher.prototype._finalDecrypt = function _finalDecrypt() {
        assert.equal(this.bufferOff, this.blockSize, "Not enough data to decrypt");
        var out = new Array(this.blockSize);
        this._flushBuffer(out, 0);
        return this._unpad(out);
      };
    }
  });

  // node_modules/des.js/lib/des/des.js
  var require_des = __commonJS({
    "node_modules/des.js/lib/des/des.js"(exports2, module2) {
      "use strict";
      var assert = require_minimalistic_assert();
      var inherits = require_inherits_browser();
      var utils = require_utils2();
      var Cipher = require_cipher();
      function DESState() {
        this.tmp = new Array(2);
        this.keys = null;
      }
      function DES(options) {
        Cipher.call(this, options);
        var state = new DESState();
        this._desState = state;
        this.deriveKeys(state, options.key);
      }
      inherits(DES, Cipher);
      module2.exports = DES;
      DES.create = function create(options) {
        return new DES(options);
      };
      var shiftTable = [
        1,
        1,
        2,
        2,
        2,
        2,
        2,
        2,
        1,
        2,
        2,
        2,
        2,
        2,
        2,
        1
      ];
      DES.prototype.deriveKeys = function deriveKeys(state, key) {
        state.keys = new Array(16 * 2);
        assert.equal(key.length, this.blockSize, "Invalid key length");
        var kL = utils.readUInt32BE(key, 0);
        var kR = utils.readUInt32BE(key, 4);
        utils.pc1(kL, kR, state.tmp, 0);
        kL = state.tmp[0];
        kR = state.tmp[1];
        for (var i = 0; i < state.keys.length; i += 2) {
          var shift = shiftTable[i >>> 1];
          kL = utils.r28shl(kL, shift);
          kR = utils.r28shl(kR, shift);
          utils.pc2(kL, kR, state.keys, i);
        }
      };
      DES.prototype._update = function _update(inp, inOff, out, outOff) {
        var state = this._desState;
        var l = utils.readUInt32BE(inp, inOff);
        var r = utils.readUInt32BE(inp, inOff + 4);
        utils.ip(l, r, state.tmp, 0);
        l = state.tmp[0];
        r = state.tmp[1];
        if (this.type === "encrypt")
          this._encrypt(state, l, r, state.tmp, 0);
        else
          this._decrypt(state, l, r, state.tmp, 0);
        l = state.tmp[0];
        r = state.tmp[1];
        utils.writeUInt32BE(out, l, outOff);
        utils.writeUInt32BE(out, r, outOff + 4);
      };
      DES.prototype._pad = function _pad(buffer, off) {
        var value = buffer.length - off;
        for (var i = off; i < buffer.length; i++)
          buffer[i] = value;
        return true;
      };
      DES.prototype._unpad = function _unpad(buffer) {
        var pad = buffer[buffer.length - 1];
        for (var i = buffer.length - pad; i < buffer.length; i++)
          assert.equal(buffer[i], pad);
        return buffer.slice(0, buffer.length - pad);
      };
      DES.prototype._encrypt = function _encrypt(state, lStart, rStart, out, off) {
        var l = lStart;
        var r = rStart;
        for (var i = 0; i < state.keys.length; i += 2) {
          var keyL = state.keys[i];
          var keyR = state.keys[i + 1];
          utils.expand(r, state.tmp, 0);
          keyL ^= state.tmp[0];
          keyR ^= state.tmp[1];
          var s = utils.substitute(keyL, keyR);
          var f = utils.permute(s);
          var t = r;
          r = (l ^ f) >>> 0;
          l = t;
        }
        utils.rip(r, l, out, off);
      };
      DES.prototype._decrypt = function _decrypt(state, lStart, rStart, out, off) {
        var l = rStart;
        var r = lStart;
        for (var i = state.keys.length - 2; i >= 0; i -= 2) {
          var keyL = state.keys[i];
          var keyR = state.keys[i + 1];
          utils.expand(l, state.tmp, 0);
          keyL ^= state.tmp[0];
          keyR ^= state.tmp[1];
          var s = utils.substitute(keyL, keyR);
          var f = utils.permute(s);
          var t = l;
          l = (r ^ f) >>> 0;
          r = t;
        }
        utils.rip(l, r, out, off);
      };
    }
  });

  // node_modules/des.js/lib/des/cbc.js
  var require_cbc = __commonJS({
    "node_modules/des.js/lib/des/cbc.js"(exports2) {
      "use strict";
      var assert = require_minimalistic_assert();
      var inherits = require_inherits_browser();
      var proto = {};
      function CBCState(iv) {
        assert.equal(iv.length, 8, "Invalid IV length");
        this.iv = new Array(8);
        for (var i = 0; i < this.iv.length; i++)
          this.iv[i] = iv[i];
      }
      function instantiate(Base) {
        function CBC(options) {
          Base.call(this, options);
          this._cbcInit();
        }
        inherits(CBC, Base);
        var keys = Object.keys(proto);
        for (var i = 0; i < keys.length; i++) {
          var key = keys[i];
          CBC.prototype[key] = proto[key];
        }
        CBC.create = function create(options) {
          return new CBC(options);
        };
        return CBC;
      }
      exports2.instantiate = instantiate;
      proto._cbcInit = function _cbcInit() {
        var state = new CBCState(this.options.iv);
        this._cbcState = state;
      };
      proto._update = function _update(inp, inOff, out, outOff) {
        var state = this._cbcState;
        var superProto = this.constructor.super_.prototype;
        var iv = state.iv;
        if (this.type === "encrypt") {
          for (var i = 0; i < this.blockSize; i++)
            iv[i] ^= inp[inOff + i];
          superProto._update.call(this, iv, 0, out, outOff);
          for (var i = 0; i < this.blockSize; i++)
            iv[i] = out[outOff + i];
        } else {
          superProto._update.call(this, inp, inOff, out, outOff);
          for (var i = 0; i < this.blockSize; i++)
            out[outOff + i] ^= iv[i];
          for (var i = 0; i < this.blockSize; i++)
            iv[i] = inp[inOff + i];
        }
      };
    }
  });

  // node_modules/des.js/lib/des/ede.js
  var require_ede = __commonJS({
    "node_modules/des.js/lib/des/ede.js"(exports2, module2) {
      "use strict";
      var assert = require_minimalistic_assert();
      var inherits = require_inherits_browser();
      var Cipher = require_cipher();
      var DES = require_des();
      function EDEState(type, key) {
        assert.equal(key.length, 24, "Invalid key length");
        var k1 = key.slice(0, 8);
        var k2 = key.slice(8, 16);
        var k3 = key.slice(16, 24);
        if (type === "encrypt") {
          this.ciphers = [
            DES.create({ type: "encrypt", key: k1 }),
            DES.create({ type: "decrypt", key: k2 }),
            DES.create({ type: "encrypt", key: k3 })
          ];
        } else {
          this.ciphers = [
            DES.create({ type: "decrypt", key: k3 }),
            DES.create({ type: "encrypt", key: k2 }),
            DES.create({ type: "decrypt", key: k1 })
          ];
        }
      }
      function EDE(options) {
        Cipher.call(this, options);
        var state = new EDEState(this.type, this.options.key);
        this._edeState = state;
      }
      inherits(EDE, Cipher);
      module2.exports = EDE;
      EDE.create = function create(options) {
        return new EDE(options);
      };
      EDE.prototype._update = function _update(inp, inOff, out, outOff) {
        var state = this._edeState;
        state.ciphers[0]._update(inp, inOff, out, outOff);
        state.ciphers[1]._update(out, outOff, out, outOff);
        state.ciphers[2]._update(out, outOff, out, outOff);
      };
      EDE.prototype._pad = DES.prototype._pad;
      EDE.prototype._unpad = DES.prototype._unpad;
    }
  });

  // node_modules/des.js/lib/des.js
  var require_des2 = __commonJS({
    "node_modules/des.js/lib/des.js"(exports2) {
      "use strict";
      exports2.utils = require_utils2();
      exports2.Cipher = require_cipher();
      exports2.DES = require_des();
      exports2.CBC = require_cbc();
      exports2.EDE = require_ede();
    }
  });

  // node_modules/browserify-des/index.js
  var require_browserify_des = __commonJS({
    "node_modules/browserify-des/index.js"(exports2, module2) {
      var CipherBase = require_cipher_base();
      var des = require_des2();
      var inherits = require_inherits_browser();
      var Buffer2 = require_safe_buffer().Buffer;
      var modes = {
        "des-ede3-cbc": des.CBC.instantiate(des.EDE),
        "des-ede3": des.EDE,
        "des-ede-cbc": des.CBC.instantiate(des.EDE),
        "des-ede": des.EDE,
        "des-cbc": des.CBC.instantiate(des.DES),
        "des-ecb": des.DES
      };
      modes.des = modes["des-cbc"];
      modes.des3 = modes["des-ede3-cbc"];
      module2.exports = DES;
      inherits(DES, CipherBase);
      function DES(opts) {
        CipherBase.call(this);
        var modeName = opts.mode.toLowerCase();
        var mode = modes[modeName];
        var type;
        if (opts.decrypt) {
          type = "decrypt";
        } else {
          type = "encrypt";
        }
        var key = opts.key;
        if (!Buffer2.isBuffer(key)) {
          key = Buffer2.from(key);
        }
        if (modeName === "des-ede" || modeName === "des-ede-cbc") {
          key = Buffer2.concat([key, key.slice(0, 8)]);
        }
        var iv = opts.iv;
        if (!Buffer2.isBuffer(iv)) {
          iv = Buffer2.from(iv);
        }
        this._des = mode.create({
          key,
          iv,
          type
        });
      }
      DES.prototype._update = function(data) {
        return Buffer2.from(this._des.update(data));
      };
      DES.prototype._final = function() {
        return Buffer2.from(this._des.final());
      };
    }
  });

  // node_modules/browserify-aes/modes/ecb.js
  var require_ecb = __commonJS({
    "node_modules/browserify-aes/modes/ecb.js"(exports2) {
      exports2.encrypt = function(self2, block) {
        return self2._cipher.encryptBlock(block);
      };
      exports2.decrypt = function(self2, block) {
        return self2._cipher.decryptBlock(block);
      };
    }
  });

  // node_modules/buffer-xor/index.js
  var require_buffer_xor = __commonJS({
    "node_modules/buffer-xor/index.js"(exports2, module2) {
      module2.exports = function xor(a, b) {
        var length = Math.min(a.length, b.length);
        var buffer = new Buffer(length);
        for (var i = 0; i < length; ++i) {
          buffer[i] = a[i] ^ b[i];
        }
        return buffer;
      };
    }
  });

  // node_modules/browserify-aes/modes/cbc.js
  var require_cbc2 = __commonJS({
    "node_modules/browserify-aes/modes/cbc.js"(exports2) {
      var xor = require_buffer_xor();
      exports2.encrypt = function(self2, block) {
        var data = xor(block, self2._prev);
        self2._prev = self2._cipher.encryptBlock(data);
        return self2._prev;
      };
      exports2.decrypt = function(self2, block) {
        var pad = self2._prev;
        self2._prev = block;
        var out = self2._cipher.decryptBlock(block);
        return xor(out, pad);
      };
    }
  });

  // node_modules/browserify-aes/modes/cfb.js
  var require_cfb = __commonJS({
    "node_modules/browserify-aes/modes/cfb.js"(exports2) {
      var Buffer2 = require_safe_buffer().Buffer;
      var xor = require_buffer_xor();
      function encryptStart(self2, data, decrypt) {
        var len = data.length;
        var out = xor(data, self2._cache);
        self2._cache = self2._cache.slice(len);
        self2._prev = Buffer2.concat([self2._prev, decrypt ? data : out]);
        return out;
      }
      exports2.encrypt = function(self2, data, decrypt) {
        var out = Buffer2.allocUnsafe(0);
        var len;
        while (data.length) {
          if (self2._cache.length === 0) {
            self2._cache = self2._cipher.encryptBlock(self2._prev);
            self2._prev = Buffer2.allocUnsafe(0);
          }
          if (self2._cache.length <= data.length) {
            len = self2._cache.length;
            out = Buffer2.concat([out, encryptStart(self2, data.slice(0, len), decrypt)]);
            data = data.slice(len);
          } else {
            out = Buffer2.concat([out, encryptStart(self2, data, decrypt)]);
            break;
          }
        }
        return out;
      };
    }
  });

  // node_modules/browserify-aes/modes/cfb8.js
  var require_cfb8 = __commonJS({
    "node_modules/browserify-aes/modes/cfb8.js"(exports2) {
      var Buffer2 = require_safe_buffer().Buffer;
      function encryptByte(self2, byteParam, decrypt) {
        var pad = self2._cipher.encryptBlock(self2._prev);
        var out = pad[0] ^ byteParam;
        self2._prev = Buffer2.concat([
          self2._prev.slice(1),
          Buffer2.from([decrypt ? byteParam : out])
        ]);
        return out;
      }
      exports2.encrypt = function(self2, chunk, decrypt) {
        var len = chunk.length;
        var out = Buffer2.allocUnsafe(len);
        var i = -1;
        while (++i < len) {
          out[i] = encryptByte(self2, chunk[i], decrypt);
        }
        return out;
      };
    }
  });

  // node_modules/browserify-aes/modes/cfb1.js
  var require_cfb1 = __commonJS({
    "node_modules/browserify-aes/modes/cfb1.js"(exports2) {
      var Buffer2 = require_safe_buffer().Buffer;
      function encryptByte(self2, byteParam, decrypt) {
        var pad;
        var i = -1;
        var len = 8;
        var out = 0;
        var bit, value;
        while (++i < len) {
          pad = self2._cipher.encryptBlock(self2._prev);
          bit = byteParam & 1 << 7 - i ? 128 : 0;
          value = pad[0] ^ bit;
          out += (value & 128) >> i % 8;
          self2._prev = shiftIn(self2._prev, decrypt ? bit : value);
        }
        return out;
      }
      function shiftIn(buffer, value) {
        var len = buffer.length;
        var i = -1;
        var out = Buffer2.allocUnsafe(buffer.length);
        buffer = Buffer2.concat([buffer, Buffer2.from([value])]);
        while (++i < len) {
          out[i] = buffer[i] << 1 | buffer[i + 1] >> 7;
        }
        return out;
      }
      exports2.encrypt = function(self2, chunk, decrypt) {
        var len = chunk.length;
        var out = Buffer2.allocUnsafe(len);
        var i = -1;
        while (++i < len) {
          out[i] = encryptByte(self2, chunk[i], decrypt);
        }
        return out;
      };
    }
  });

  // node_modules/browserify-aes/modes/ofb.js
  var require_ofb = __commonJS({
    "node_modules/browserify-aes/modes/ofb.js"(exports2) {
      var xor = require_buffer_xor();
      function getBlock(self2) {
        self2._prev = self2._cipher.encryptBlock(self2._prev);
        return self2._prev;
      }
      exports2.encrypt = function(self2, chunk) {
        while (self2._cache.length < chunk.length) {
          self2._cache = Buffer.concat([self2._cache, getBlock(self2)]);
        }
        var pad = self2._cache.slice(0, chunk.length);
        self2._cache = self2._cache.slice(chunk.length);
        return xor(chunk, pad);
      };
    }
  });

  // node_modules/browserify-aes/incr32.js
  var require_incr32 = __commonJS({
    "node_modules/browserify-aes/incr32.js"(exports2, module2) {
      function incr32(iv) {
        var len = iv.length;
        var item;
        while (len--) {
          item = iv.readUInt8(len);
          if (item === 255) {
            iv.writeUInt8(0, len);
          } else {
            item++;
            iv.writeUInt8(item, len);
            break;
          }
        }
      }
      module2.exports = incr32;
    }
  });

  // node_modules/browserify-aes/modes/ctr.js
  var require_ctr = __commonJS({
    "node_modules/browserify-aes/modes/ctr.js"(exports2) {
      var xor = require_buffer_xor();
      var Buffer2 = require_safe_buffer().Buffer;
      var incr32 = require_incr32();
      function getBlock(self2) {
        var out = self2._cipher.encryptBlockRaw(self2._prev);
        incr32(self2._prev);
        return out;
      }
      var blockSize = 16;
      exports2.encrypt = function(self2, chunk) {
        var chunkNum = Math.ceil(chunk.length / blockSize);
        var start2 = self2._cache.length;
        self2._cache = Buffer2.concat([
          self2._cache,
          Buffer2.allocUnsafe(chunkNum * blockSize)
        ]);
        for (var i = 0; i < chunkNum; i++) {
          var out = getBlock(self2);
          var offset = start2 + i * blockSize;
          self2._cache.writeUInt32BE(out[0], offset + 0);
          self2._cache.writeUInt32BE(out[1], offset + 4);
          self2._cache.writeUInt32BE(out[2], offset + 8);
          self2._cache.writeUInt32BE(out[3], offset + 12);
        }
        var pad = self2._cache.slice(0, chunk.length);
        self2._cache = self2._cache.slice(chunk.length);
        return xor(chunk, pad);
      };
    }
  });

  // node_modules/browserify-aes/modes/list.json
  var require_list = __commonJS({
    "node_modules/browserify-aes/modes/list.json"(exports2, module2) {
      module2.exports = {
        "aes-128-ecb": {
          cipher: "AES",
          key: 128,
          iv: 0,
          mode: "ECB",
          type: "block"
        },
        "aes-192-ecb": {
          cipher: "AES",
          key: 192,
          iv: 0,
          mode: "ECB",
          type: "block"
        },
        "aes-256-ecb": {
          cipher: "AES",
          key: 256,
          iv: 0,
          mode: "ECB",
          type: "block"
        },
        "aes-128-cbc": {
          cipher: "AES",
          key: 128,
          iv: 16,
          mode: "CBC",
          type: "block"
        },
        "aes-192-cbc": {
          cipher: "AES",
          key: 192,
          iv: 16,
          mode: "CBC",
          type: "block"
        },
        "aes-256-cbc": {
          cipher: "AES",
          key: 256,
          iv: 16,
          mode: "CBC",
          type: "block"
        },
        aes128: {
          cipher: "AES",
          key: 128,
          iv: 16,
          mode: "CBC",
          type: "block"
        },
        aes192: {
          cipher: "AES",
          key: 192,
          iv: 16,
          mode: "CBC",
          type: "block"
        },
        aes256: {
          cipher: "AES",
          key: 256,
          iv: 16,
          mode: "CBC",
          type: "block"
        },
        "aes-128-cfb": {
          cipher: "AES",
          key: 128,
          iv: 16,
          mode: "CFB",
          type: "stream"
        },
        "aes-192-cfb": {
          cipher: "AES",
          key: 192,
          iv: 16,
          mode: "CFB",
          type: "stream"
        },
        "aes-256-cfb": {
          cipher: "AES",
          key: 256,
          iv: 16,
          mode: "CFB",
          type: "stream"
        },
        "aes-128-cfb8": {
          cipher: "AES",
          key: 128,
          iv: 16,
          mode: "CFB8",
          type: "stream"
        },
        "aes-192-cfb8": {
          cipher: "AES",
          key: 192,
          iv: 16,
          mode: "CFB8",
          type: "stream"
        },
        "aes-256-cfb8": {
          cipher: "AES",
          key: 256,
          iv: 16,
          mode: "CFB8",
          type: "stream"
        },
        "aes-128-cfb1": {
          cipher: "AES",
          key: 128,
          iv: 16,
          mode: "CFB1",
          type: "stream"
        },
        "aes-192-cfb1": {
          cipher: "AES",
          key: 192,
          iv: 16,
          mode: "CFB1",
          type: "stream"
        },
        "aes-256-cfb1": {
          cipher: "AES",
          key: 256,
          iv: 16,
          mode: "CFB1",
          type: "stream"
        },
        "aes-128-ofb": {
          cipher: "AES",
          key: 128,
          iv: 16,
          mode: "OFB",
          type: "stream"
        },
        "aes-192-ofb": {
          cipher: "AES",
          key: 192,
          iv: 16,
          mode: "OFB",
          type: "stream"
        },
        "aes-256-ofb": {
          cipher: "AES",
          key: 256,
          iv: 16,
          mode: "OFB",
          type: "stream"
        },
        "aes-128-ctr": {
          cipher: "AES",
          key: 128,
          iv: 16,
          mode: "CTR",
          type: "stream"
        },
        "aes-192-ctr": {
          cipher: "AES",
          key: 192,
          iv: 16,
          mode: "CTR",
          type: "stream"
        },
        "aes-256-ctr": {
          cipher: "AES",
          key: 256,
          iv: 16,
          mode: "CTR",
          type: "stream"
        },
        "aes-128-gcm": {
          cipher: "AES",
          key: 128,
          iv: 12,
          mode: "GCM",
          type: "auth"
        },
        "aes-192-gcm": {
          cipher: "AES",
          key: 192,
          iv: 12,
          mode: "GCM",
          type: "auth"
        },
        "aes-256-gcm": {
          cipher: "AES",
          key: 256,
          iv: 12,
          mode: "GCM",
          type: "auth"
        }
      };
    }
  });

  // node_modules/browserify-aes/modes/index.js
  var require_modes = __commonJS({
    "node_modules/browserify-aes/modes/index.js"(exports2, module2) {
      var modeModules = {
        ECB: require_ecb(),
        CBC: require_cbc2(),
        CFB: require_cfb(),
        CFB8: require_cfb8(),
        CFB1: require_cfb1(),
        OFB: require_ofb(),
        CTR: require_ctr(),
        GCM: require_ctr()
      };
      var modes = require_list();
      for (key in modes) {
        modes[key].module = modeModules[modes[key].mode];
      }
      var key;
      module2.exports = modes;
    }
  });

  // node_modules/browserify-aes/aes.js
  var require_aes = __commonJS({
    "node_modules/browserify-aes/aes.js"(exports2, module2) {
      var Buffer2 = require_safe_buffer().Buffer;
      function asUInt32Array(buf) {
        if (!Buffer2.isBuffer(buf))
          buf = Buffer2.from(buf);
        var len = buf.length / 4 | 0;
        var out = new Array(len);
        for (var i = 0; i < len; i++) {
          out[i] = buf.readUInt32BE(i * 4);
        }
        return out;
      }
      function scrubVec(v) {
        for (var i = 0; i < v.length; v++) {
          v[i] = 0;
        }
      }
      function cryptBlock(M, keySchedule, SUB_MIX, SBOX, nRounds) {
        var SUB_MIX0 = SUB_MIX[0];
        var SUB_MIX1 = SUB_MIX[1];
        var SUB_MIX2 = SUB_MIX[2];
        var SUB_MIX3 = SUB_MIX[3];
        var s0 = M[0] ^ keySchedule[0];
        var s1 = M[1] ^ keySchedule[1];
        var s2 = M[2] ^ keySchedule[2];
        var s3 = M[3] ^ keySchedule[3];
        var t0, t1, t2, t3;
        var ksRow = 4;
        for (var round = 1; round < nRounds; round++) {
          t0 = SUB_MIX0[s0 >>> 24] ^ SUB_MIX1[s1 >>> 16 & 255] ^ SUB_MIX2[s2 >>> 8 & 255] ^ SUB_MIX3[s3 & 255] ^ keySchedule[ksRow++];
          t1 = SUB_MIX0[s1 >>> 24] ^ SUB_MIX1[s2 >>> 16 & 255] ^ SUB_MIX2[s3 >>> 8 & 255] ^ SUB_MIX3[s0 & 255] ^ keySchedule[ksRow++];
          t2 = SUB_MIX0[s2 >>> 24] ^ SUB_MIX1[s3 >>> 16 & 255] ^ SUB_MIX2[s0 >>> 8 & 255] ^ SUB_MIX3[s1 & 255] ^ keySchedule[ksRow++];
          t3 = SUB_MIX0[s3 >>> 24] ^ SUB_MIX1[s0 >>> 16 & 255] ^ SUB_MIX2[s1 >>> 8 & 255] ^ SUB_MIX3[s2 & 255] ^ keySchedule[ksRow++];
          s0 = t0;
          s1 = t1;
          s2 = t2;
          s3 = t3;
        }
        t0 = (SBOX[s0 >>> 24] << 24 | SBOX[s1 >>> 16 & 255] << 16 | SBOX[s2 >>> 8 & 255] << 8 | SBOX[s3 & 255]) ^ keySchedule[ksRow++];
        t1 = (SBOX[s1 >>> 24] << 24 | SBOX[s2 >>> 16 & 255] << 16 | SBOX[s3 >>> 8 & 255] << 8 | SBOX[s0 & 255]) ^ keySchedule[ksRow++];
        t2 = (SBOX[s2 >>> 24] << 24 | SBOX[s3 >>> 16 & 255] << 16 | SBOX[s0 >>> 8 & 255] << 8 | SBOX[s1 & 255]) ^ keySchedule[ksRow++];
        t3 = (SBOX[s3 >>> 24] << 24 | SBOX[s0 >>> 16 & 255] << 16 | SBOX[s1 >>> 8 & 255] << 8 | SBOX[s2 & 255]) ^ keySchedule[ksRow++];
        t0 = t0 >>> 0;
        t1 = t1 >>> 0;
        t2 = t2 >>> 0;
        t3 = t3 >>> 0;
        return [t0, t1, t2, t3];
      }
      var RCON = [0, 1, 2, 4, 8, 16, 32, 64, 128, 27, 54];
      var G = function() {
        var d = new Array(256);
        for (var j = 0; j < 256; j++) {
          if (j < 128) {
            d[j] = j << 1;
          } else {
            d[j] = j << 1 ^ 283;
          }
        }
        var SBOX = [];
        var INV_SBOX = [];
        var SUB_MIX = [[], [], [], []];
        var INV_SUB_MIX = [[], [], [], []];
        var x = 0;
        var xi = 0;
        for (var i = 0; i < 256; ++i) {
          var sx = xi ^ xi << 1 ^ xi << 2 ^ xi << 3 ^ xi << 4;
          sx = sx >>> 8 ^ sx & 255 ^ 99;
          SBOX[x] = sx;
          INV_SBOX[sx] = x;
          var x2 = d[x];
          var x4 = d[x2];
          var x8 = d[x4];
          var t = d[sx] * 257 ^ sx * 16843008;
          SUB_MIX[0][x] = t << 24 | t >>> 8;
          SUB_MIX[1][x] = t << 16 | t >>> 16;
          SUB_MIX[2][x] = t << 8 | t >>> 24;
          SUB_MIX[3][x] = t;
          t = x8 * 16843009 ^ x4 * 65537 ^ x2 * 257 ^ x * 16843008;
          INV_SUB_MIX[0][sx] = t << 24 | t >>> 8;
          INV_SUB_MIX[1][sx] = t << 16 | t >>> 16;
          INV_SUB_MIX[2][sx] = t << 8 | t >>> 24;
          INV_SUB_MIX[3][sx] = t;
          if (x === 0) {
            x = xi = 1;
          } else {
            x = x2 ^ d[d[d[x8 ^ x2]]];
            xi ^= d[d[xi]];
          }
        }
        return {
          SBOX,
          INV_SBOX,
          SUB_MIX,
          INV_SUB_MIX
        };
      }();
      function AES(key) {
        this._key = asUInt32Array(key);
        this._reset();
      }
      AES.blockSize = 4 * 4;
      AES.keySize = 256 / 8;
      AES.prototype.blockSize = AES.blockSize;
      AES.prototype.keySize = AES.keySize;
      AES.prototype._reset = function() {
        var keyWords = this._key;
        var keySize = keyWords.length;
        var nRounds = keySize + 6;
        var ksRows = (nRounds + 1) * 4;
        var keySchedule = [];
        for (var k = 0; k < keySize; k++) {
          keySchedule[k] = keyWords[k];
        }
        for (k = keySize; k < ksRows; k++) {
          var t = keySchedule[k - 1];
          if (k % keySize === 0) {
            t = t << 8 | t >>> 24;
            t = G.SBOX[t >>> 24] << 24 | G.SBOX[t >>> 16 & 255] << 16 | G.SBOX[t >>> 8 & 255] << 8 | G.SBOX[t & 255];
            t ^= RCON[k / keySize | 0] << 24;
          } else if (keySize > 6 && k % keySize === 4) {
            t = G.SBOX[t >>> 24] << 24 | G.SBOX[t >>> 16 & 255] << 16 | G.SBOX[t >>> 8 & 255] << 8 | G.SBOX[t & 255];
          }
          keySchedule[k] = keySchedule[k - keySize] ^ t;
        }
        var invKeySchedule = [];
        for (var ik = 0; ik < ksRows; ik++) {
          var ksR = ksRows - ik;
          var tt = keySchedule[ksR - (ik % 4 ? 0 : 4)];
          if (ik < 4 || ksR <= 4) {
            invKeySchedule[ik] = tt;
          } else {
            invKeySchedule[ik] = G.INV_SUB_MIX[0][G.SBOX[tt >>> 24]] ^ G.INV_SUB_MIX[1][G.SBOX[tt >>> 16 & 255]] ^ G.INV_SUB_MIX[2][G.SBOX[tt >>> 8 & 255]] ^ G.INV_SUB_MIX[3][G.SBOX[tt & 255]];
          }
        }
        this._nRounds = nRounds;
        this._keySchedule = keySchedule;
        this._invKeySchedule = invKeySchedule;
      };
      AES.prototype.encryptBlockRaw = function(M) {
        M = asUInt32Array(M);
        return cryptBlock(M, this._keySchedule, G.SUB_MIX, G.SBOX, this._nRounds);
      };
      AES.prototype.encryptBlock = function(M) {
        var out = this.encryptBlockRaw(M);
        var buf = Buffer2.allocUnsafe(16);
        buf.writeUInt32BE(out[0], 0);
        buf.writeUInt32BE(out[1], 4);
        buf.writeUInt32BE(out[2], 8);
        buf.writeUInt32BE(out[3], 12);
        return buf;
      };
      AES.prototype.decryptBlock = function(M) {
        M = asUInt32Array(M);
        var m1 = M[1];
        M[1] = M[3];
        M[3] = m1;
        var out = cryptBlock(M, this._invKeySchedule, G.INV_SUB_MIX, G.INV_SBOX, this._nRounds);
        var buf = Buffer2.allocUnsafe(16);
        buf.writeUInt32BE(out[0], 0);
        buf.writeUInt32BE(out[3], 4);
        buf.writeUInt32BE(out[2], 8);
        buf.writeUInt32BE(out[1], 12);
        return buf;
      };
      AES.prototype.scrub = function() {
        scrubVec(this._keySchedule);
        scrubVec(this._invKeySchedule);
        scrubVec(this._key);
      };
      module2.exports.AES = AES;
    }
  });

  // node_modules/browserify-aes/ghash.js
  var require_ghash = __commonJS({
    "node_modules/browserify-aes/ghash.js"(exports2, module2) {
      var Buffer2 = require_safe_buffer().Buffer;
      var ZEROES = Buffer2.alloc(16, 0);
      function toArray(buf) {
        return [
          buf.readUInt32BE(0),
          buf.readUInt32BE(4),
          buf.readUInt32BE(8),
          buf.readUInt32BE(12)
        ];
      }
      function fromArray(out) {
        var buf = Buffer2.allocUnsafe(16);
        buf.writeUInt32BE(out[0] >>> 0, 0);
        buf.writeUInt32BE(out[1] >>> 0, 4);
        buf.writeUInt32BE(out[2] >>> 0, 8);
        buf.writeUInt32BE(out[3] >>> 0, 12);
        return buf;
      }
      function GHASH(key) {
        this.h = key;
        this.state = Buffer2.alloc(16, 0);
        this.cache = Buffer2.allocUnsafe(0);
      }
      GHASH.prototype.ghash = function(block) {
        var i = -1;
        while (++i < block.length) {
          this.state[i] ^= block[i];
        }
        this._multiply();
      };
      GHASH.prototype._multiply = function() {
        var Vi = toArray(this.h);
        var Zi = [0, 0, 0, 0];
        var j, xi, lsbVi;
        var i = -1;
        while (++i < 128) {
          xi = (this.state[~~(i / 8)] & 1 << 7 - i % 8) !== 0;
          if (xi) {
            Zi[0] ^= Vi[0];
            Zi[1] ^= Vi[1];
            Zi[2] ^= Vi[2];
            Zi[3] ^= Vi[3];
          }
          lsbVi = (Vi[3] & 1) !== 0;
          for (j = 3; j > 0; j--) {
            Vi[j] = Vi[j] >>> 1 | (Vi[j - 1] & 1) << 31;
          }
          Vi[0] = Vi[0] >>> 1;
          if (lsbVi) {
            Vi[0] = Vi[0] ^ 225 << 24;
          }
        }
        this.state = fromArray(Zi);
      };
      GHASH.prototype.update = function(buf) {
        this.cache = Buffer2.concat([this.cache, buf]);
        var chunk;
        while (this.cache.length >= 16) {
          chunk = this.cache.slice(0, 16);
          this.cache = this.cache.slice(16);
          this.ghash(chunk);
        }
      };
      GHASH.prototype.final = function(abl, bl) {
        if (this.cache.length) {
          this.ghash(Buffer2.concat([this.cache, ZEROES], 16));
        }
        this.ghash(fromArray([0, abl, 0, bl]));
        return this.state;
      };
      module2.exports = GHASH;
    }
  });

  // node_modules/browserify-aes/authCipher.js
  var require_authCipher = __commonJS({
    "node_modules/browserify-aes/authCipher.js"(exports2, module2) {
      var aes = require_aes();
      var Buffer2 = require_safe_buffer().Buffer;
      var Transform = require_cipher_base();
      var inherits = require_inherits_browser();
      var GHASH = require_ghash();
      var xor = require_buffer_xor();
      var incr32 = require_incr32();
      function xorTest(a, b) {
        var out = 0;
        if (a.length !== b.length)
          out++;
        var len = Math.min(a.length, b.length);
        for (var i = 0; i < len; ++i) {
          out += a[i] ^ b[i];
        }
        return out;
      }
      function calcIv(self2, iv, ck) {
        if (iv.length === 12) {
          self2._finID = Buffer2.concat([iv, Buffer2.from([0, 0, 0, 1])]);
          return Buffer2.concat([iv, Buffer2.from([0, 0, 0, 2])]);
        }
        var ghash = new GHASH(ck);
        var len = iv.length;
        var toPad = len % 16;
        ghash.update(iv);
        if (toPad) {
          toPad = 16 - toPad;
          ghash.update(Buffer2.alloc(toPad, 0));
        }
        ghash.update(Buffer2.alloc(8, 0));
        var ivBits = len * 8;
        var tail = Buffer2.alloc(8);
        tail.writeUIntBE(ivBits, 0, 8);
        ghash.update(tail);
        self2._finID = ghash.state;
        var out = Buffer2.from(self2._finID);
        incr32(out);
        return out;
      }
      function StreamCipher(mode, key, iv, decrypt) {
        Transform.call(this);
        var h = Buffer2.alloc(4, 0);
        this._cipher = new aes.AES(key);
        var ck = this._cipher.encryptBlock(h);
        this._ghash = new GHASH(ck);
        iv = calcIv(this, iv, ck);
        this._prev = Buffer2.from(iv);
        this._cache = Buffer2.allocUnsafe(0);
        this._secCache = Buffer2.allocUnsafe(0);
        this._decrypt = decrypt;
        this._alen = 0;
        this._len = 0;
        this._mode = mode;
        this._authTag = null;
        this._called = false;
      }
      inherits(StreamCipher, Transform);
      StreamCipher.prototype._update = function(chunk) {
        if (!this._called && this._alen) {
          var rump = 16 - this._alen % 16;
          if (rump < 16) {
            rump = Buffer2.alloc(rump, 0);
            this._ghash.update(rump);
          }
        }
        this._called = true;
        var out = this._mode.encrypt(this, chunk);
        if (this._decrypt) {
          this._ghash.update(chunk);
        } else {
          this._ghash.update(out);
        }
        this._len += chunk.length;
        return out;
      };
      StreamCipher.prototype._final = function() {
        if (this._decrypt && !this._authTag)
          throw new Error("Unsupported state or unable to authenticate data");
        var tag = xor(this._ghash.final(this._alen * 8, this._len * 8), this._cipher.encryptBlock(this._finID));
        if (this._decrypt && xorTest(tag, this._authTag))
          throw new Error("Unsupported state or unable to authenticate data");
        this._authTag = tag;
        this._cipher.scrub();
      };
      StreamCipher.prototype.getAuthTag = function getAuthTag() {
        if (this._decrypt || !Buffer2.isBuffer(this._authTag))
          throw new Error("Attempting to get auth tag in unsupported state");
        return this._authTag;
      };
      StreamCipher.prototype.setAuthTag = function setAuthTag(tag) {
        if (!this._decrypt)
          throw new Error("Attempting to set auth tag in unsupported state");
        this._authTag = tag;
      };
      StreamCipher.prototype.setAAD = function setAAD(buf) {
        if (this._called)
          throw new Error("Attempting to set AAD in unsupported state");
        this._ghash.update(buf);
        this._alen += buf.length;
      };
      module2.exports = StreamCipher;
    }
  });

  // node_modules/browserify-aes/streamCipher.js
  var require_streamCipher = __commonJS({
    "node_modules/browserify-aes/streamCipher.js"(exports2, module2) {
      var aes = require_aes();
      var Buffer2 = require_safe_buffer().Buffer;
      var Transform = require_cipher_base();
      var inherits = require_inherits_browser();
      function StreamCipher(mode, key, iv, decrypt) {
        Transform.call(this);
        this._cipher = new aes.AES(key);
        this._prev = Buffer2.from(iv);
        this._cache = Buffer2.allocUnsafe(0);
        this._secCache = Buffer2.allocUnsafe(0);
        this._decrypt = decrypt;
        this._mode = mode;
      }
      inherits(StreamCipher, Transform);
      StreamCipher.prototype._update = function(chunk) {
        return this._mode.encrypt(this, chunk, this._decrypt);
      };
      StreamCipher.prototype._final = function() {
        this._cipher.scrub();
      };
      module2.exports = StreamCipher;
    }
  });

  // node_modules/evp_bytestokey/index.js
  var require_evp_bytestokey = __commonJS({
    "node_modules/evp_bytestokey/index.js"(exports2, module2) {
      var Buffer2 = require_safe_buffer().Buffer;
      var MD5 = require_md5();
      function EVP_BytesToKey(password, salt, keyBits, ivLen) {
        if (!Buffer2.isBuffer(password))
          password = Buffer2.from(password, "binary");
        if (salt) {
          if (!Buffer2.isBuffer(salt))
            salt = Buffer2.from(salt, "binary");
          if (salt.length !== 8)
            throw new RangeError("salt should be Buffer with 8 byte length");
        }
        var keyLen = keyBits / 8;
        var key = Buffer2.alloc(keyLen);
        var iv = Buffer2.alloc(ivLen || 0);
        var tmp = Buffer2.alloc(0);
        while (keyLen > 0 || ivLen > 0) {
          var hash = new MD5();
          hash.update(tmp);
          hash.update(password);
          if (salt)
            hash.update(salt);
          tmp = hash.digest();
          var used = 0;
          if (keyLen > 0) {
            var keyStart = key.length - keyLen;
            used = Math.min(keyLen, tmp.length);
            tmp.copy(key, keyStart, 0, used);
            keyLen -= used;
          }
          if (used < tmp.length && ivLen > 0) {
            var ivStart = iv.length - ivLen;
            var length = Math.min(ivLen, tmp.length - used);
            tmp.copy(iv, ivStart, used, used + length);
            ivLen -= length;
          }
        }
        tmp.fill(0);
        return { key, iv };
      }
      module2.exports = EVP_BytesToKey;
    }
  });

  // node_modules/browserify-aes/encrypter.js
  var require_encrypter = __commonJS({
    "node_modules/browserify-aes/encrypter.js"(exports2) {
      var MODES = require_modes();
      var AuthCipher = require_authCipher();
      var Buffer2 = require_safe_buffer().Buffer;
      var StreamCipher = require_streamCipher();
      var Transform = require_cipher_base();
      var aes = require_aes();
      var ebtk = require_evp_bytestokey();
      var inherits = require_inherits_browser();
      function Cipher(mode, key, iv) {
        Transform.call(this);
        this._cache = new Splitter();
        this._cipher = new aes.AES(key);
        this._prev = Buffer2.from(iv);
        this._mode = mode;
        this._autopadding = true;
      }
      inherits(Cipher, Transform);
      Cipher.prototype._update = function(data) {
        this._cache.add(data);
        var chunk;
        var thing;
        var out = [];
        while (chunk = this._cache.get()) {
          thing = this._mode.encrypt(this, chunk);
          out.push(thing);
        }
        return Buffer2.concat(out);
      };
      var PADDING = Buffer2.alloc(16, 16);
      Cipher.prototype._final = function() {
        var chunk = this._cache.flush();
        if (this._autopadding) {
          chunk = this._mode.encrypt(this, chunk);
          this._cipher.scrub();
          return chunk;
        }
        if (!chunk.equals(PADDING)) {
          this._cipher.scrub();
          throw new Error("data not multiple of block length");
        }
      };
      Cipher.prototype.setAutoPadding = function(setTo) {
        this._autopadding = !!setTo;
        return this;
      };
      function Splitter() {
        this.cache = Buffer2.allocUnsafe(0);
      }
      Splitter.prototype.add = function(data) {
        this.cache = Buffer2.concat([this.cache, data]);
      };
      Splitter.prototype.get = function() {
        if (this.cache.length > 15) {
          var out = this.cache.slice(0, 16);
          this.cache = this.cache.slice(16);
          return out;
        }
        return null;
      };
      Splitter.prototype.flush = function() {
        var len = 16 - this.cache.length;
        var padBuff = Buffer2.allocUnsafe(len);
        var i = -1;
        while (++i < len) {
          padBuff.writeUInt8(len, i);
        }
        return Buffer2.concat([this.cache, padBuff]);
      };
      function createCipheriv(suite, password, iv) {
        var config = MODES[suite.toLowerCase()];
        if (!config)
          throw new TypeError("invalid suite type");
        if (typeof password === "string")
          password = Buffer2.from(password);
        if (password.length !== config.key / 8)
          throw new TypeError("invalid key length " + password.length);
        if (typeof iv === "string")
          iv = Buffer2.from(iv);
        if (config.mode !== "GCM" && iv.length !== config.iv)
          throw new TypeError("invalid iv length " + iv.length);
        if (config.type === "stream") {
          return new StreamCipher(config.module, password, iv);
        } else if (config.type === "auth") {
          return new AuthCipher(config.module, password, iv);
        }
        return new Cipher(config.module, password, iv);
      }
      function createCipher(suite, password) {
        var config = MODES[suite.toLowerCase()];
        if (!config)
          throw new TypeError("invalid suite type");
        var keys = ebtk(password, false, config.key, config.iv);
        return createCipheriv(suite, keys.key, keys.iv);
      }
      exports2.createCipheriv = createCipheriv;
      exports2.createCipher = createCipher;
    }
  });

  // node_modules/browserify-aes/decrypter.js
  var require_decrypter = __commonJS({
    "node_modules/browserify-aes/decrypter.js"(exports2) {
      var AuthCipher = require_authCipher();
      var Buffer2 = require_safe_buffer().Buffer;
      var MODES = require_modes();
      var StreamCipher = require_streamCipher();
      var Transform = require_cipher_base();
      var aes = require_aes();
      var ebtk = require_evp_bytestokey();
      var inherits = require_inherits_browser();
      function Decipher(mode, key, iv) {
        Transform.call(this);
        this._cache = new Splitter();
        this._last = void 0;
        this._cipher = new aes.AES(key);
        this._prev = Buffer2.from(iv);
        this._mode = mode;
        this._autopadding = true;
      }
      inherits(Decipher, Transform);
      Decipher.prototype._update = function(data) {
        this._cache.add(data);
        var chunk;
        var thing;
        var out = [];
        while (chunk = this._cache.get(this._autopadding)) {
          thing = this._mode.decrypt(this, chunk);
          out.push(thing);
        }
        return Buffer2.concat(out);
      };
      Decipher.prototype._final = function() {
        var chunk = this._cache.flush();
        if (this._autopadding) {
          return unpad(this._mode.decrypt(this, chunk));
        } else if (chunk) {
          throw new Error("data not multiple of block length");
        }
      };
      Decipher.prototype.setAutoPadding = function(setTo) {
        this._autopadding = !!setTo;
        return this;
      };
      function Splitter() {
        this.cache = Buffer2.allocUnsafe(0);
      }
      Splitter.prototype.add = function(data) {
        this.cache = Buffer2.concat([this.cache, data]);
      };
      Splitter.prototype.get = function(autoPadding) {
        var out;
        if (autoPadding) {
          if (this.cache.length > 16) {
            out = this.cache.slice(0, 16);
            this.cache = this.cache.slice(16);
            return out;
          }
        } else {
          if (this.cache.length >= 16) {
            out = this.cache.slice(0, 16);
            this.cache = this.cache.slice(16);
            return out;
          }
        }
        return null;
      };
      Splitter.prototype.flush = function() {
        if (this.cache.length)
          return this.cache;
      };
      function unpad(last) {
        var padded = last[15];
        if (padded < 1 || padded > 16) {
          throw new Error("unable to decrypt data");
        }
        var i = -1;
        while (++i < padded) {
          if (last[i + (16 - padded)] !== padded) {
            throw new Error("unable to decrypt data");
          }
        }
        if (padded === 16)
          return;
        return last.slice(0, 16 - padded);
      }
      function createDecipheriv(suite, password, iv) {
        var config = MODES[suite.toLowerCase()];
        if (!config)
          throw new TypeError("invalid suite type");
        if (typeof iv === "string")
          iv = Buffer2.from(iv);
        if (config.mode !== "GCM" && iv.length !== config.iv)
          throw new TypeError("invalid iv length " + iv.length);
        if (typeof password === "string")
          password = Buffer2.from(password);
        if (password.length !== config.key / 8)
          throw new TypeError("invalid key length " + password.length);
        if (config.type === "stream") {
          return new StreamCipher(config.module, password, iv, true);
        } else if (config.type === "auth") {
          return new AuthCipher(config.module, password, iv, true);
        }
        return new Decipher(config.module, password, iv);
      }
      function createDecipher(suite, password) {
        var config = MODES[suite.toLowerCase()];
        if (!config)
          throw new TypeError("invalid suite type");
        var keys = ebtk(password, false, config.key, config.iv);
        return createDecipheriv(suite, keys.key, keys.iv);
      }
      exports2.createDecipher = createDecipher;
      exports2.createDecipheriv = createDecipheriv;
    }
  });

  // node_modules/browserify-aes/browser.js
  var require_browser6 = __commonJS({
    "node_modules/browserify-aes/browser.js"(exports2) {
      var ciphers = require_encrypter();
      var deciphers = require_decrypter();
      var modes = require_list();
      function getCiphers() {
        return Object.keys(modes);
      }
      exports2.createCipher = exports2.Cipher = ciphers.createCipher;
      exports2.createCipheriv = exports2.Cipheriv = ciphers.createCipheriv;
      exports2.createDecipher = exports2.Decipher = deciphers.createDecipher;
      exports2.createDecipheriv = exports2.Decipheriv = deciphers.createDecipheriv;
      exports2.listCiphers = exports2.getCiphers = getCiphers;
    }
  });

  // node_modules/browserify-des/modes.js
  var require_modes2 = __commonJS({
    "node_modules/browserify-des/modes.js"(exports2) {
      exports2["des-ecb"] = {
        key: 8,
        iv: 0
      };
      exports2["des-cbc"] = exports2.des = {
        key: 8,
        iv: 8
      };
      exports2["des-ede3-cbc"] = exports2.des3 = {
        key: 24,
        iv: 8
      };
      exports2["des-ede3"] = {
        key: 24,
        iv: 0
      };
      exports2["des-ede-cbc"] = {
        key: 16,
        iv: 8
      };
      exports2["des-ede"] = {
        key: 16,
        iv: 0
      };
    }
  });

  // node_modules/browserify-cipher/browser.js
  var require_browser7 = __commonJS({
    "node_modules/browserify-cipher/browser.js"(exports2) {
      var DES = require_browserify_des();
      var aes = require_browser6();
      var aesModes = require_modes();
      var desModes = require_modes2();
      var ebtk = require_evp_bytestokey();
      function createCipher(suite, password) {
        suite = suite.toLowerCase();
        var keyLen, ivLen;
        if (aesModes[suite]) {
          keyLen = aesModes[suite].key;
          ivLen = aesModes[suite].iv;
        } else if (desModes[suite]) {
          keyLen = desModes[suite].key * 8;
          ivLen = desModes[suite].iv;
        } else {
          throw new TypeError("invalid suite type");
        }
        var keys = ebtk(password, false, keyLen, ivLen);
        return createCipheriv(suite, keys.key, keys.iv);
      }
      function createDecipher(suite, password) {
        suite = suite.toLowerCase();
        var keyLen, ivLen;
        if (aesModes[suite]) {
          keyLen = aesModes[suite].key;
          ivLen = aesModes[suite].iv;
        } else if (desModes[suite]) {
          keyLen = desModes[suite].key * 8;
          ivLen = desModes[suite].iv;
        } else {
          throw new TypeError("invalid suite type");
        }
        var keys = ebtk(password, false, keyLen, ivLen);
        return createDecipheriv(suite, keys.key, keys.iv);
      }
      function createCipheriv(suite, key, iv) {
        suite = suite.toLowerCase();
        if (aesModes[suite])
          return aes.createCipheriv(suite, key, iv);
        if (desModes[suite])
          return new DES({ key, iv, mode: suite });
        throw new TypeError("invalid suite type");
      }
      function createDecipheriv(suite, key, iv) {
        suite = suite.toLowerCase();
        if (aesModes[suite])
          return aes.createDecipheriv(suite, key, iv);
        if (desModes[suite])
          return new DES({ key, iv, mode: suite, decrypt: true });
        throw new TypeError("invalid suite type");
      }
      function getCiphers() {
        return Object.keys(desModes).concat(aes.getCiphers());
      }
      exports2.createCipher = exports2.Cipher = createCipher;
      exports2.createCipheriv = exports2.Cipheriv = createCipheriv;
      exports2.createDecipher = exports2.Decipher = createDecipher;
      exports2.createDecipheriv = exports2.Decipheriv = createDecipheriv;
      exports2.listCiphers = exports2.getCiphers = getCiphers;
    }
  });

  // node_modules/bn.js/lib/bn.js
  var require_bn2 = __commonJS({
    "node_modules/bn.js/lib/bn.js"(exports2, module2) {
      (function(module3, exports3) {
        "use strict";
        function assert(val, msg) {
          if (!val)
            throw new Error(msg || "Assertion failed");
        }
        function inherits(ctor, superCtor) {
          ctor.super_ = superCtor;
          var TempCtor = function() {
          };
          TempCtor.prototype = superCtor.prototype;
          ctor.prototype = new TempCtor();
          ctor.prototype.constructor = ctor;
        }
        function BN(number, base, endian) {
          if (BN.isBN(number)) {
            return number;
          }
          this.negative = 0;
          this.words = null;
          this.length = 0;
          this.red = null;
          if (number !== null) {
            if (base === "le" || base === "be") {
              endian = base;
              base = 10;
            }
            this._init(number || 0, base || 10, endian || "be");
          }
        }
        if (typeof module3 === "object") {
          module3.exports = BN;
        } else {
          exports3.BN = BN;
        }
        BN.BN = BN;
        BN.wordSize = 26;
        var Buffer2;
        try {
          if (typeof window !== "undefined" && typeof window.Buffer !== "undefined") {
            Buffer2 = window.Buffer;
          } else {
            Buffer2 = require_buffer().Buffer;
          }
        } catch (e) {
        }
        BN.isBN = function isBN(num) {
          if (num instanceof BN) {
            return true;
          }
          return num !== null && typeof num === "object" && num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);
        };
        BN.max = function max(left, right) {
          if (left.cmp(right) > 0)
            return left;
          return right;
        };
        BN.min = function min(left, right) {
          if (left.cmp(right) < 0)
            return left;
          return right;
        };
        BN.prototype._init = function init(number, base, endian) {
          if (typeof number === "number") {
            return this._initNumber(number, base, endian);
          }
          if (typeof number === "object") {
            return this._initArray(number, base, endian);
          }
          if (base === "hex") {
            base = 16;
          }
          assert(base === (base | 0) && base >= 2 && base <= 36);
          number = number.toString().replace(/\s+/g, "");
          var start2 = 0;
          if (number[0] === "-") {
            start2++;
            this.negative = 1;
          }
          if (start2 < number.length) {
            if (base === 16) {
              this._parseHex(number, start2, endian);
            } else {
              this._parseBase(number, base, start2);
              if (endian === "le") {
                this._initArray(this.toArray(), base, endian);
              }
            }
          }
        };
        BN.prototype._initNumber = function _initNumber(number, base, endian) {
          if (number < 0) {
            this.negative = 1;
            number = -number;
          }
          if (number < 67108864) {
            this.words = [number & 67108863];
            this.length = 1;
          } else if (number < 4503599627370496) {
            this.words = [
              number & 67108863,
              number / 67108864 & 67108863
            ];
            this.length = 2;
          } else {
            assert(number < 9007199254740992);
            this.words = [
              number & 67108863,
              number / 67108864 & 67108863,
              1
            ];
            this.length = 3;
          }
          if (endian !== "le")
            return;
          this._initArray(this.toArray(), base, endian);
        };
        BN.prototype._initArray = function _initArray(number, base, endian) {
          assert(typeof number.length === "number");
          if (number.length <= 0) {
            this.words = [0];
            this.length = 1;
            return this;
          }
          this.length = Math.ceil(number.length / 3);
          this.words = new Array(this.length);
          for (var i = 0; i < this.length; i++) {
            this.words[i] = 0;
          }
          var j, w;
          var off = 0;
          if (endian === "be") {
            for (i = number.length - 1, j = 0; i >= 0; i -= 3) {
              w = number[i] | number[i - 1] << 8 | number[i - 2] << 16;
              this.words[j] |= w << off & 67108863;
              this.words[j + 1] = w >>> 26 - off & 67108863;
              off += 24;
              if (off >= 26) {
                off -= 26;
                j++;
              }
            }
          } else if (endian === "le") {
            for (i = 0, j = 0; i < number.length; i += 3) {
              w = number[i] | number[i + 1] << 8 | number[i + 2] << 16;
              this.words[j] |= w << off & 67108863;
              this.words[j + 1] = w >>> 26 - off & 67108863;
              off += 24;
              if (off >= 26) {
                off -= 26;
                j++;
              }
            }
          }
          return this.strip();
        };
        function parseHex4Bits(string, index) {
          var c = string.charCodeAt(index);
          if (c >= 65 && c <= 70) {
            return c - 55;
          } else if (c >= 97 && c <= 102) {
            return c - 87;
          } else {
            return c - 48 & 15;
          }
        }
        function parseHexByte(string, lowerBound, index) {
          var r = parseHex4Bits(string, index);
          if (index - 1 >= lowerBound) {
            r |= parseHex4Bits(string, index - 1) << 4;
          }
          return r;
        }
        BN.prototype._parseHex = function _parseHex(number, start2, endian) {
          this.length = Math.ceil((number.length - start2) / 6);
          this.words = new Array(this.length);
          for (var i = 0; i < this.length; i++) {
            this.words[i] = 0;
          }
          var off = 0;
          var j = 0;
          var w;
          if (endian === "be") {
            for (i = number.length - 1; i >= start2; i -= 2) {
              w = parseHexByte(number, start2, i) << off;
              this.words[j] |= w & 67108863;
              if (off >= 18) {
                off -= 18;
                j += 1;
                this.words[j] |= w >>> 26;
              } else {
                off += 8;
              }
            }
          } else {
            var parseLength = number.length - start2;
            for (i = parseLength % 2 === 0 ? start2 + 1 : start2; i < number.length; i += 2) {
              w = parseHexByte(number, start2, i) << off;
              this.words[j] |= w & 67108863;
              if (off >= 18) {
                off -= 18;
                j += 1;
                this.words[j] |= w >>> 26;
              } else {
                off += 8;
              }
            }
          }
          this.strip();
        };
        function parseBase(str, start2, end, mul) {
          var r = 0;
          var len = Math.min(str.length, end);
          for (var i = start2; i < len; i++) {
            var c = str.charCodeAt(i) - 48;
            r *= mul;
            if (c >= 49) {
              r += c - 49 + 10;
            } else if (c >= 17) {
              r += c - 17 + 10;
            } else {
              r += c;
            }
          }
          return r;
        }
        BN.prototype._parseBase = function _parseBase(number, base, start2) {
          this.words = [0];
          this.length = 1;
          for (var limbLen = 0, limbPow = 1; limbPow <= 67108863; limbPow *= base) {
            limbLen++;
          }
          limbLen--;
          limbPow = limbPow / base | 0;
          var total = number.length - start2;
          var mod2 = total % limbLen;
          var end = Math.min(total, total - mod2) + start2;
          var word = 0;
          for (var i = start2; i < end; i += limbLen) {
            word = parseBase(number, i, i + limbLen, base);
            this.imuln(limbPow);
            if (this.words[0] + word < 67108864) {
              this.words[0] += word;
            } else {
              this._iaddn(word);
            }
          }
          if (mod2 !== 0) {
            var pow = 1;
            word = parseBase(number, i, number.length, base);
            for (i = 0; i < mod2; i++) {
              pow *= base;
            }
            this.imuln(pow);
            if (this.words[0] + word < 67108864) {
              this.words[0] += word;
            } else {
              this._iaddn(word);
            }
          }
          this.strip();
        };
        BN.prototype.copy = function copy(dest) {
          dest.words = new Array(this.length);
          for (var i = 0; i < this.length; i++) {
            dest.words[i] = this.words[i];
          }
          dest.length = this.length;
          dest.negative = this.negative;
          dest.red = this.red;
        };
        BN.prototype.clone = function clone() {
          var r = new BN(null);
          this.copy(r);
          return r;
        };
        BN.prototype._expand = function _expand(size) {
          while (this.length < size) {
            this.words[this.length++] = 0;
          }
          return this;
        };
        BN.prototype.strip = function strip() {
          while (this.length > 1 && this.words[this.length - 1] === 0) {
            this.length--;
          }
          return this._normSign();
        };
        BN.prototype._normSign = function _normSign() {
          if (this.length === 1 && this.words[0] === 0) {
            this.negative = 0;
          }
          return this;
        };
        BN.prototype.inspect = function inspect() {
          return (this.red ? "<BN-R: " : "<BN: ") + this.toString(16) + ">";
        };
        var zeros = [
          "",
          "0",
          "00",
          "000",
          "0000",
          "00000",
          "000000",
          "0000000",
          "00000000",
          "000000000",
          "0000000000",
          "00000000000",
          "000000000000",
          "0000000000000",
          "00000000000000",
          "000000000000000",
          "0000000000000000",
          "00000000000000000",
          "000000000000000000",
          "0000000000000000000",
          "00000000000000000000",
          "000000000000000000000",
          "0000000000000000000000",
          "00000000000000000000000",
          "000000000000000000000000",
          "0000000000000000000000000"
        ];
        var groupSizes = [
          0,
          0,
          25,
          16,
          12,
          11,
          10,
          9,
          8,
          8,
          7,
          7,
          7,
          7,
          6,
          6,
          6,
          6,
          6,
          6,
          6,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5
        ];
        var groupBases = [
          0,
          0,
          33554432,
          43046721,
          16777216,
          48828125,
          60466176,
          40353607,
          16777216,
          43046721,
          1e7,
          19487171,
          35831808,
          62748517,
          7529536,
          11390625,
          16777216,
          24137569,
          34012224,
          47045881,
          64e6,
          4084101,
          5153632,
          6436343,
          7962624,
          9765625,
          11881376,
          14348907,
          17210368,
          20511149,
          243e5,
          28629151,
          33554432,
          39135393,
          45435424,
          52521875,
          60466176
        ];
        BN.prototype.toString = function toString(base, padding) {
          base = base || 10;
          padding = padding | 0 || 1;
          var out;
          if (base === 16 || base === "hex") {
            out = "";
            var off = 0;
            var carry = 0;
            for (var i = 0; i < this.length; i++) {
              var w = this.words[i];
              var word = ((w << off | carry) & 16777215).toString(16);
              carry = w >>> 24 - off & 16777215;
              if (carry !== 0 || i !== this.length - 1) {
                out = zeros[6 - word.length] + word + out;
              } else {
                out = word + out;
              }
              off += 2;
              if (off >= 26) {
                off -= 26;
                i--;
              }
            }
            if (carry !== 0) {
              out = carry.toString(16) + out;
            }
            while (out.length % padding !== 0) {
              out = "0" + out;
            }
            if (this.negative !== 0) {
              out = "-" + out;
            }
            return out;
          }
          if (base === (base | 0) && base >= 2 && base <= 36) {
            var groupSize = groupSizes[base];
            var groupBase = groupBases[base];
            out = "";
            var c = this.clone();
            c.negative = 0;
            while (!c.isZero()) {
              var r = c.modn(groupBase).toString(base);
              c = c.idivn(groupBase);
              if (!c.isZero()) {
                out = zeros[groupSize - r.length] + r + out;
              } else {
                out = r + out;
              }
            }
            if (this.isZero()) {
              out = "0" + out;
            }
            while (out.length % padding !== 0) {
              out = "0" + out;
            }
            if (this.negative !== 0) {
              out = "-" + out;
            }
            return out;
          }
          assert(false, "Base should be between 2 and 36");
        };
        BN.prototype.toNumber = function toNumber() {
          var ret = this.words[0];
          if (this.length === 2) {
            ret += this.words[1] * 67108864;
          } else if (this.length === 3 && this.words[2] === 1) {
            ret += 4503599627370496 + this.words[1] * 67108864;
          } else if (this.length > 2) {
            assert(false, "Number can only safely store up to 53 bits");
          }
          return this.negative !== 0 ? -ret : ret;
        };
        BN.prototype.toJSON = function toJSON() {
          return this.toString(16);
        };
        BN.prototype.toBuffer = function toBuffer(endian, length) {
          assert(typeof Buffer2 !== "undefined");
          return this.toArrayLike(Buffer2, endian, length);
        };
        BN.prototype.toArray = function toArray(endian, length) {
          return this.toArrayLike(Array, endian, length);
        };
        BN.prototype.toArrayLike = function toArrayLike(ArrayType, endian, length) {
          var byteLength = this.byteLength();
          var reqLength = length || Math.max(1, byteLength);
          assert(byteLength <= reqLength, "byte array longer than desired length");
          assert(reqLength > 0, "Requested array length <= 0");
          this.strip();
          var littleEndian = endian === "le";
          var res = new ArrayType(reqLength);
          var b, i;
          var q = this.clone();
          if (!littleEndian) {
            for (i = 0; i < reqLength - byteLength; i++) {
              res[i] = 0;
            }
            for (i = 0; !q.isZero(); i++) {
              b = q.andln(255);
              q.iushrn(8);
              res[reqLength - i - 1] = b;
            }
          } else {
            for (i = 0; !q.isZero(); i++) {
              b = q.andln(255);
              q.iushrn(8);
              res[i] = b;
            }
            for (; i < reqLength; i++) {
              res[i] = 0;
            }
          }
          return res;
        };
        if (Math.clz32) {
          BN.prototype._countBits = function _countBits(w) {
            return 32 - Math.clz32(w);
          };
        } else {
          BN.prototype._countBits = function _countBits(w) {
            var t = w;
            var r = 0;
            if (t >= 4096) {
              r += 13;
              t >>>= 13;
            }
            if (t >= 64) {
              r += 7;
              t >>>= 7;
            }
            if (t >= 8) {
              r += 4;
              t >>>= 4;
            }
            if (t >= 2) {
              r += 2;
              t >>>= 2;
            }
            return r + t;
          };
        }
        BN.prototype._zeroBits = function _zeroBits(w) {
          if (w === 0)
            return 26;
          var t = w;
          var r = 0;
          if ((t & 8191) === 0) {
            r += 13;
            t >>>= 13;
          }
          if ((t & 127) === 0) {
            r += 7;
            t >>>= 7;
          }
          if ((t & 15) === 0) {
            r += 4;
            t >>>= 4;
          }
          if ((t & 3) === 0) {
            r += 2;
            t >>>= 2;
          }
          if ((t & 1) === 0) {
            r++;
          }
          return r;
        };
        BN.prototype.bitLength = function bitLength() {
          var w = this.words[this.length - 1];
          var hi = this._countBits(w);
          return (this.length - 1) * 26 + hi;
        };
        function toBitArray(num) {
          var w = new Array(num.bitLength());
          for (var bit = 0; bit < w.length; bit++) {
            var off = bit / 26 | 0;
            var wbit = bit % 26;
            w[bit] = (num.words[off] & 1 << wbit) >>> wbit;
          }
          return w;
        }
        BN.prototype.zeroBits = function zeroBits() {
          if (this.isZero())
            return 0;
          var r = 0;
          for (var i = 0; i < this.length; i++) {
            var b = this._zeroBits(this.words[i]);
            r += b;
            if (b !== 26)
              break;
          }
          return r;
        };
        BN.prototype.byteLength = function byteLength() {
          return Math.ceil(this.bitLength() / 8);
        };
        BN.prototype.toTwos = function toTwos(width) {
          if (this.negative !== 0) {
            return this.abs().inotn(width).iaddn(1);
          }
          return this.clone();
        };
        BN.prototype.fromTwos = function fromTwos(width) {
          if (this.testn(width - 1)) {
            return this.notn(width).iaddn(1).ineg();
          }
          return this.clone();
        };
        BN.prototype.isNeg = function isNeg() {
          return this.negative !== 0;
        };
        BN.prototype.neg = function neg() {
          return this.clone().ineg();
        };
        BN.prototype.ineg = function ineg() {
          if (!this.isZero()) {
            this.negative ^= 1;
          }
          return this;
        };
        BN.prototype.iuor = function iuor(num) {
          while (this.length < num.length) {
            this.words[this.length++] = 0;
          }
          for (var i = 0; i < num.length; i++) {
            this.words[i] = this.words[i] | num.words[i];
          }
          return this.strip();
        };
        BN.prototype.ior = function ior(num) {
          assert((this.negative | num.negative) === 0);
          return this.iuor(num);
        };
        BN.prototype.or = function or(num) {
          if (this.length > num.length)
            return this.clone().ior(num);
          return num.clone().ior(this);
        };
        BN.prototype.uor = function uor(num) {
          if (this.length > num.length)
            return this.clone().iuor(num);
          return num.clone().iuor(this);
        };
        BN.prototype.iuand = function iuand(num) {
          var b;
          if (this.length > num.length) {
            b = num;
          } else {
            b = this;
          }
          for (var i = 0; i < b.length; i++) {
            this.words[i] = this.words[i] & num.words[i];
          }
          this.length = b.length;
          return this.strip();
        };
        BN.prototype.iand = function iand(num) {
          assert((this.negative | num.negative) === 0);
          return this.iuand(num);
        };
        BN.prototype.and = function and(num) {
          if (this.length > num.length)
            return this.clone().iand(num);
          return num.clone().iand(this);
        };
        BN.prototype.uand = function uand(num) {
          if (this.length > num.length)
            return this.clone().iuand(num);
          return num.clone().iuand(this);
        };
        BN.prototype.iuxor = function iuxor(num) {
          var a;
          var b;
          if (this.length > num.length) {
            a = this;
            b = num;
          } else {
            a = num;
            b = this;
          }
          for (var i = 0; i < b.length; i++) {
            this.words[i] = a.words[i] ^ b.words[i];
          }
          if (this !== a) {
            for (; i < a.length; i++) {
              this.words[i] = a.words[i];
            }
          }
          this.length = a.length;
          return this.strip();
        };
        BN.prototype.ixor = function ixor(num) {
          assert((this.negative | num.negative) === 0);
          return this.iuxor(num);
        };
        BN.prototype.xor = function xor(num) {
          if (this.length > num.length)
            return this.clone().ixor(num);
          return num.clone().ixor(this);
        };
        BN.prototype.uxor = function uxor(num) {
          if (this.length > num.length)
            return this.clone().iuxor(num);
          return num.clone().iuxor(this);
        };
        BN.prototype.inotn = function inotn(width) {
          assert(typeof width === "number" && width >= 0);
          var bytesNeeded = Math.ceil(width / 26) | 0;
          var bitsLeft = width % 26;
          this._expand(bytesNeeded);
          if (bitsLeft > 0) {
            bytesNeeded--;
          }
          for (var i = 0; i < bytesNeeded; i++) {
            this.words[i] = ~this.words[i] & 67108863;
          }
          if (bitsLeft > 0) {
            this.words[i] = ~this.words[i] & 67108863 >> 26 - bitsLeft;
          }
          return this.strip();
        };
        BN.prototype.notn = function notn(width) {
          return this.clone().inotn(width);
        };
        BN.prototype.setn = function setn(bit, val) {
          assert(typeof bit === "number" && bit >= 0);
          var off = bit / 26 | 0;
          var wbit = bit % 26;
          this._expand(off + 1);
          if (val) {
            this.words[off] = this.words[off] | 1 << wbit;
          } else {
            this.words[off] = this.words[off] & ~(1 << wbit);
          }
          return this.strip();
        };
        BN.prototype.iadd = function iadd(num) {
          var r;
          if (this.negative !== 0 && num.negative === 0) {
            this.negative = 0;
            r = this.isub(num);
            this.negative ^= 1;
            return this._normSign();
          } else if (this.negative === 0 && num.negative !== 0) {
            num.negative = 0;
            r = this.isub(num);
            num.negative = 1;
            return r._normSign();
          }
          var a, b;
          if (this.length > num.length) {
            a = this;
            b = num;
          } else {
            a = num;
            b = this;
          }
          var carry = 0;
          for (var i = 0; i < b.length; i++) {
            r = (a.words[i] | 0) + (b.words[i] | 0) + carry;
            this.words[i] = r & 67108863;
            carry = r >>> 26;
          }
          for (; carry !== 0 && i < a.length; i++) {
            r = (a.words[i] | 0) + carry;
            this.words[i] = r & 67108863;
            carry = r >>> 26;
          }
          this.length = a.length;
          if (carry !== 0) {
            this.words[this.length] = carry;
            this.length++;
          } else if (a !== this) {
            for (; i < a.length; i++) {
              this.words[i] = a.words[i];
            }
          }
          return this;
        };
        BN.prototype.add = function add(num) {
          var res;
          if (num.negative !== 0 && this.negative === 0) {
            num.negative = 0;
            res = this.sub(num);
            num.negative ^= 1;
            return res;
          } else if (num.negative === 0 && this.negative !== 0) {
            this.negative = 0;
            res = num.sub(this);
            this.negative = 1;
            return res;
          }
          if (this.length > num.length)
            return this.clone().iadd(num);
          return num.clone().iadd(this);
        };
        BN.prototype.isub = function isub(num) {
          if (num.negative !== 0) {
            num.negative = 0;
            var r = this.iadd(num);
            num.negative = 1;
            return r._normSign();
          } else if (this.negative !== 0) {
            this.negative = 0;
            this.iadd(num);
            this.negative = 1;
            return this._normSign();
          }
          var cmp = this.cmp(num);
          if (cmp === 0) {
            this.negative = 0;
            this.length = 1;
            this.words[0] = 0;
            return this;
          }
          var a, b;
          if (cmp > 0) {
            a = this;
            b = num;
          } else {
            a = num;
            b = this;
          }
          var carry = 0;
          for (var i = 0; i < b.length; i++) {
            r = (a.words[i] | 0) - (b.words[i] | 0) + carry;
            carry = r >> 26;
            this.words[i] = r & 67108863;
          }
          for (; carry !== 0 && i < a.length; i++) {
            r = (a.words[i] | 0) + carry;
            carry = r >> 26;
            this.words[i] = r & 67108863;
          }
          if (carry === 0 && i < a.length && a !== this) {
            for (; i < a.length; i++) {
              this.words[i] = a.words[i];
            }
          }
          this.length = Math.max(this.length, i);
          if (a !== this) {
            this.negative = 1;
          }
          return this.strip();
        };
        BN.prototype.sub = function sub(num) {
          return this.clone().isub(num);
        };
        function smallMulTo(self2, num, out) {
          out.negative = num.negative ^ self2.negative;
          var len = self2.length + num.length | 0;
          out.length = len;
          len = len - 1 | 0;
          var a = self2.words[0] | 0;
          var b = num.words[0] | 0;
          var r = a * b;
          var lo = r & 67108863;
          var carry = r / 67108864 | 0;
          out.words[0] = lo;
          for (var k = 1; k < len; k++) {
            var ncarry = carry >>> 26;
            var rword = carry & 67108863;
            var maxJ = Math.min(k, num.length - 1);
            for (var j = Math.max(0, k - self2.length + 1); j <= maxJ; j++) {
              var i = k - j | 0;
              a = self2.words[i] | 0;
              b = num.words[j] | 0;
              r = a * b + rword;
              ncarry += r / 67108864 | 0;
              rword = r & 67108863;
            }
            out.words[k] = rword | 0;
            carry = ncarry | 0;
          }
          if (carry !== 0) {
            out.words[k] = carry | 0;
          } else {
            out.length--;
          }
          return out.strip();
        }
        var comb10MulTo = function comb10MulTo2(self2, num, out) {
          var a = self2.words;
          var b = num.words;
          var o = out.words;
          var c = 0;
          var lo;
          var mid;
          var hi;
          var a0 = a[0] | 0;
          var al0 = a0 & 8191;
          var ah0 = a0 >>> 13;
          var a1 = a[1] | 0;
          var al1 = a1 & 8191;
          var ah1 = a1 >>> 13;
          var a2 = a[2] | 0;
          var al2 = a2 & 8191;
          var ah2 = a2 >>> 13;
          var a3 = a[3] | 0;
          var al3 = a3 & 8191;
          var ah3 = a3 >>> 13;
          var a4 = a[4] | 0;
          var al4 = a4 & 8191;
          var ah4 = a4 >>> 13;
          var a5 = a[5] | 0;
          var al5 = a5 & 8191;
          var ah5 = a5 >>> 13;
          var a6 = a[6] | 0;
          var al6 = a6 & 8191;
          var ah6 = a6 >>> 13;
          var a7 = a[7] | 0;
          var al7 = a7 & 8191;
          var ah7 = a7 >>> 13;
          var a8 = a[8] | 0;
          var al8 = a8 & 8191;
          var ah8 = a8 >>> 13;
          var a9 = a[9] | 0;
          var al9 = a9 & 8191;
          var ah9 = a9 >>> 13;
          var b0 = b[0] | 0;
          var bl0 = b0 & 8191;
          var bh0 = b0 >>> 13;
          var b1 = b[1] | 0;
          var bl1 = b1 & 8191;
          var bh1 = b1 >>> 13;
          var b2 = b[2] | 0;
          var bl2 = b2 & 8191;
          var bh2 = b2 >>> 13;
          var b3 = b[3] | 0;
          var bl3 = b3 & 8191;
          var bh3 = b3 >>> 13;
          var b4 = b[4] | 0;
          var bl4 = b4 & 8191;
          var bh4 = b4 >>> 13;
          var b5 = b[5] | 0;
          var bl5 = b5 & 8191;
          var bh5 = b5 >>> 13;
          var b6 = b[6] | 0;
          var bl6 = b6 & 8191;
          var bh6 = b6 >>> 13;
          var b7 = b[7] | 0;
          var bl7 = b7 & 8191;
          var bh7 = b7 >>> 13;
          var b8 = b[8] | 0;
          var bl8 = b8 & 8191;
          var bh8 = b8 >>> 13;
          var b9 = b[9] | 0;
          var bl9 = b9 & 8191;
          var bh9 = b9 >>> 13;
          out.negative = self2.negative ^ num.negative;
          out.length = 19;
          lo = Math.imul(al0, bl0);
          mid = Math.imul(al0, bh0);
          mid = mid + Math.imul(ah0, bl0) | 0;
          hi = Math.imul(ah0, bh0);
          var w0 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w0 >>> 26) | 0;
          w0 &= 67108863;
          lo = Math.imul(al1, bl0);
          mid = Math.imul(al1, bh0);
          mid = mid + Math.imul(ah1, bl0) | 0;
          hi = Math.imul(ah1, bh0);
          lo = lo + Math.imul(al0, bl1) | 0;
          mid = mid + Math.imul(al0, bh1) | 0;
          mid = mid + Math.imul(ah0, bl1) | 0;
          hi = hi + Math.imul(ah0, bh1) | 0;
          var w1 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w1 >>> 26) | 0;
          w1 &= 67108863;
          lo = Math.imul(al2, bl0);
          mid = Math.imul(al2, bh0);
          mid = mid + Math.imul(ah2, bl0) | 0;
          hi = Math.imul(ah2, bh0);
          lo = lo + Math.imul(al1, bl1) | 0;
          mid = mid + Math.imul(al1, bh1) | 0;
          mid = mid + Math.imul(ah1, bl1) | 0;
          hi = hi + Math.imul(ah1, bh1) | 0;
          lo = lo + Math.imul(al0, bl2) | 0;
          mid = mid + Math.imul(al0, bh2) | 0;
          mid = mid + Math.imul(ah0, bl2) | 0;
          hi = hi + Math.imul(ah0, bh2) | 0;
          var w2 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w2 >>> 26) | 0;
          w2 &= 67108863;
          lo = Math.imul(al3, bl0);
          mid = Math.imul(al3, bh0);
          mid = mid + Math.imul(ah3, bl0) | 0;
          hi = Math.imul(ah3, bh0);
          lo = lo + Math.imul(al2, bl1) | 0;
          mid = mid + Math.imul(al2, bh1) | 0;
          mid = mid + Math.imul(ah2, bl1) | 0;
          hi = hi + Math.imul(ah2, bh1) | 0;
          lo = lo + Math.imul(al1, bl2) | 0;
          mid = mid + Math.imul(al1, bh2) | 0;
          mid = mid + Math.imul(ah1, bl2) | 0;
          hi = hi + Math.imul(ah1, bh2) | 0;
          lo = lo + Math.imul(al0, bl3) | 0;
          mid = mid + Math.imul(al0, bh3) | 0;
          mid = mid + Math.imul(ah0, bl3) | 0;
          hi = hi + Math.imul(ah0, bh3) | 0;
          var w3 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w3 >>> 26) | 0;
          w3 &= 67108863;
          lo = Math.imul(al4, bl0);
          mid = Math.imul(al4, bh0);
          mid = mid + Math.imul(ah4, bl0) | 0;
          hi = Math.imul(ah4, bh0);
          lo = lo + Math.imul(al3, bl1) | 0;
          mid = mid + Math.imul(al3, bh1) | 0;
          mid = mid + Math.imul(ah3, bl1) | 0;
          hi = hi + Math.imul(ah3, bh1) | 0;
          lo = lo + Math.imul(al2, bl2) | 0;
          mid = mid + Math.imul(al2, bh2) | 0;
          mid = mid + Math.imul(ah2, bl2) | 0;
          hi = hi + Math.imul(ah2, bh2) | 0;
          lo = lo + Math.imul(al1, bl3) | 0;
          mid = mid + Math.imul(al1, bh3) | 0;
          mid = mid + Math.imul(ah1, bl3) | 0;
          hi = hi + Math.imul(ah1, bh3) | 0;
          lo = lo + Math.imul(al0, bl4) | 0;
          mid = mid + Math.imul(al0, bh4) | 0;
          mid = mid + Math.imul(ah0, bl4) | 0;
          hi = hi + Math.imul(ah0, bh4) | 0;
          var w4 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w4 >>> 26) | 0;
          w4 &= 67108863;
          lo = Math.imul(al5, bl0);
          mid = Math.imul(al5, bh0);
          mid = mid + Math.imul(ah5, bl0) | 0;
          hi = Math.imul(ah5, bh0);
          lo = lo + Math.imul(al4, bl1) | 0;
          mid = mid + Math.imul(al4, bh1) | 0;
          mid = mid + Math.imul(ah4, bl1) | 0;
          hi = hi + Math.imul(ah4, bh1) | 0;
          lo = lo + Math.imul(al3, bl2) | 0;
          mid = mid + Math.imul(al3, bh2) | 0;
          mid = mid + Math.imul(ah3, bl2) | 0;
          hi = hi + Math.imul(ah3, bh2) | 0;
          lo = lo + Math.imul(al2, bl3) | 0;
          mid = mid + Math.imul(al2, bh3) | 0;
          mid = mid + Math.imul(ah2, bl3) | 0;
          hi = hi + Math.imul(ah2, bh3) | 0;
          lo = lo + Math.imul(al1, bl4) | 0;
          mid = mid + Math.imul(al1, bh4) | 0;
          mid = mid + Math.imul(ah1, bl4) | 0;
          hi = hi + Math.imul(ah1, bh4) | 0;
          lo = lo + Math.imul(al0, bl5) | 0;
          mid = mid + Math.imul(al0, bh5) | 0;
          mid = mid + Math.imul(ah0, bl5) | 0;
          hi = hi + Math.imul(ah0, bh5) | 0;
          var w5 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w5 >>> 26) | 0;
          w5 &= 67108863;
          lo = Math.imul(al6, bl0);
          mid = Math.imul(al6, bh0);
          mid = mid + Math.imul(ah6, bl0) | 0;
          hi = Math.imul(ah6, bh0);
          lo = lo + Math.imul(al5, bl1) | 0;
          mid = mid + Math.imul(al5, bh1) | 0;
          mid = mid + Math.imul(ah5, bl1) | 0;
          hi = hi + Math.imul(ah5, bh1) | 0;
          lo = lo + Math.imul(al4, bl2) | 0;
          mid = mid + Math.imul(al4, bh2) | 0;
          mid = mid + Math.imul(ah4, bl2) | 0;
          hi = hi + Math.imul(ah4, bh2) | 0;
          lo = lo + Math.imul(al3, bl3) | 0;
          mid = mid + Math.imul(al3, bh3) | 0;
          mid = mid + Math.imul(ah3, bl3) | 0;
          hi = hi + Math.imul(ah3, bh3) | 0;
          lo = lo + Math.imul(al2, bl4) | 0;
          mid = mid + Math.imul(al2, bh4) | 0;
          mid = mid + Math.imul(ah2, bl4) | 0;
          hi = hi + Math.imul(ah2, bh4) | 0;
          lo = lo + Math.imul(al1, bl5) | 0;
          mid = mid + Math.imul(al1, bh5) | 0;
          mid = mid + Math.imul(ah1, bl5) | 0;
          hi = hi + Math.imul(ah1, bh5) | 0;
          lo = lo + Math.imul(al0, bl6) | 0;
          mid = mid + Math.imul(al0, bh6) | 0;
          mid = mid + Math.imul(ah0, bl6) | 0;
          hi = hi + Math.imul(ah0, bh6) | 0;
          var w6 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w6 >>> 26) | 0;
          w6 &= 67108863;
          lo = Math.imul(al7, bl0);
          mid = Math.imul(al7, bh0);
          mid = mid + Math.imul(ah7, bl0) | 0;
          hi = Math.imul(ah7, bh0);
          lo = lo + Math.imul(al6, bl1) | 0;
          mid = mid + Math.imul(al6, bh1) | 0;
          mid = mid + Math.imul(ah6, bl1) | 0;
          hi = hi + Math.imul(ah6, bh1) | 0;
          lo = lo + Math.imul(al5, bl2) | 0;
          mid = mid + Math.imul(al5, bh2) | 0;
          mid = mid + Math.imul(ah5, bl2) | 0;
          hi = hi + Math.imul(ah5, bh2) | 0;
          lo = lo + Math.imul(al4, bl3) | 0;
          mid = mid + Math.imul(al4, bh3) | 0;
          mid = mid + Math.imul(ah4, bl3) | 0;
          hi = hi + Math.imul(ah4, bh3) | 0;
          lo = lo + Math.imul(al3, bl4) | 0;
          mid = mid + Math.imul(al3, bh4) | 0;
          mid = mid + Math.imul(ah3, bl4) | 0;
          hi = hi + Math.imul(ah3, bh4) | 0;
          lo = lo + Math.imul(al2, bl5) | 0;
          mid = mid + Math.imul(al2, bh5) | 0;
          mid = mid + Math.imul(ah2, bl5) | 0;
          hi = hi + Math.imul(ah2, bh5) | 0;
          lo = lo + Math.imul(al1, bl6) | 0;
          mid = mid + Math.imul(al1, bh6) | 0;
          mid = mid + Math.imul(ah1, bl6) | 0;
          hi = hi + Math.imul(ah1, bh6) | 0;
          lo = lo + Math.imul(al0, bl7) | 0;
          mid = mid + Math.imul(al0, bh7) | 0;
          mid = mid + Math.imul(ah0, bl7) | 0;
          hi = hi + Math.imul(ah0, bh7) | 0;
          var w7 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w7 >>> 26) | 0;
          w7 &= 67108863;
          lo = Math.imul(al8, bl0);
          mid = Math.imul(al8, bh0);
          mid = mid + Math.imul(ah8, bl0) | 0;
          hi = Math.imul(ah8, bh0);
          lo = lo + Math.imul(al7, bl1) | 0;
          mid = mid + Math.imul(al7, bh1) | 0;
          mid = mid + Math.imul(ah7, bl1) | 0;
          hi = hi + Math.imul(ah7, bh1) | 0;
          lo = lo + Math.imul(al6, bl2) | 0;
          mid = mid + Math.imul(al6, bh2) | 0;
          mid = mid + Math.imul(ah6, bl2) | 0;
          hi = hi + Math.imul(ah6, bh2) | 0;
          lo = lo + Math.imul(al5, bl3) | 0;
          mid = mid + Math.imul(al5, bh3) | 0;
          mid = mid + Math.imul(ah5, bl3) | 0;
          hi = hi + Math.imul(ah5, bh3) | 0;
          lo = lo + Math.imul(al4, bl4) | 0;
          mid = mid + Math.imul(al4, bh4) | 0;
          mid = mid + Math.imul(ah4, bl4) | 0;
          hi = hi + Math.imul(ah4, bh4) | 0;
          lo = lo + Math.imul(al3, bl5) | 0;
          mid = mid + Math.imul(al3, bh5) | 0;
          mid = mid + Math.imul(ah3, bl5) | 0;
          hi = hi + Math.imul(ah3, bh5) | 0;
          lo = lo + Math.imul(al2, bl6) | 0;
          mid = mid + Math.imul(al2, bh6) | 0;
          mid = mid + Math.imul(ah2, bl6) | 0;
          hi = hi + Math.imul(ah2, bh6) | 0;
          lo = lo + Math.imul(al1, bl7) | 0;
          mid = mid + Math.imul(al1, bh7) | 0;
          mid = mid + Math.imul(ah1, bl7) | 0;
          hi = hi + Math.imul(ah1, bh7) | 0;
          lo = lo + Math.imul(al0, bl8) | 0;
          mid = mid + Math.imul(al0, bh8) | 0;
          mid = mid + Math.imul(ah0, bl8) | 0;
          hi = hi + Math.imul(ah0, bh8) | 0;
          var w8 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w8 >>> 26) | 0;
          w8 &= 67108863;
          lo = Math.imul(al9, bl0);
          mid = Math.imul(al9, bh0);
          mid = mid + Math.imul(ah9, bl0) | 0;
          hi = Math.imul(ah9, bh0);
          lo = lo + Math.imul(al8, bl1) | 0;
          mid = mid + Math.imul(al8, bh1) | 0;
          mid = mid + Math.imul(ah8, bl1) | 0;
          hi = hi + Math.imul(ah8, bh1) | 0;
          lo = lo + Math.imul(al7, bl2) | 0;
          mid = mid + Math.imul(al7, bh2) | 0;
          mid = mid + Math.imul(ah7, bl2) | 0;
          hi = hi + Math.imul(ah7, bh2) | 0;
          lo = lo + Math.imul(al6, bl3) | 0;
          mid = mid + Math.imul(al6, bh3) | 0;
          mid = mid + Math.imul(ah6, bl3) | 0;
          hi = hi + Math.imul(ah6, bh3) | 0;
          lo = lo + Math.imul(al5, bl4) | 0;
          mid = mid + Math.imul(al5, bh4) | 0;
          mid = mid + Math.imul(ah5, bl4) | 0;
          hi = hi + Math.imul(ah5, bh4) | 0;
          lo = lo + Math.imul(al4, bl5) | 0;
          mid = mid + Math.imul(al4, bh5) | 0;
          mid = mid + Math.imul(ah4, bl5) | 0;
          hi = hi + Math.imul(ah4, bh5) | 0;
          lo = lo + Math.imul(al3, bl6) | 0;
          mid = mid + Math.imul(al3, bh6) | 0;
          mid = mid + Math.imul(ah3, bl6) | 0;
          hi = hi + Math.imul(ah3, bh6) | 0;
          lo = lo + Math.imul(al2, bl7) | 0;
          mid = mid + Math.imul(al2, bh7) | 0;
          mid = mid + Math.imul(ah2, bl7) | 0;
          hi = hi + Math.imul(ah2, bh7) | 0;
          lo = lo + Math.imul(al1, bl8) | 0;
          mid = mid + Math.imul(al1, bh8) | 0;
          mid = mid + Math.imul(ah1, bl8) | 0;
          hi = hi + Math.imul(ah1, bh8) | 0;
          lo = lo + Math.imul(al0, bl9) | 0;
          mid = mid + Math.imul(al0, bh9) | 0;
          mid = mid + Math.imul(ah0, bl9) | 0;
          hi = hi + Math.imul(ah0, bh9) | 0;
          var w9 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w9 >>> 26) | 0;
          w9 &= 67108863;
          lo = Math.imul(al9, bl1);
          mid = Math.imul(al9, bh1);
          mid = mid + Math.imul(ah9, bl1) | 0;
          hi = Math.imul(ah9, bh1);
          lo = lo + Math.imul(al8, bl2) | 0;
          mid = mid + Math.imul(al8, bh2) | 0;
          mid = mid + Math.imul(ah8, bl2) | 0;
          hi = hi + Math.imul(ah8, bh2) | 0;
          lo = lo + Math.imul(al7, bl3) | 0;
          mid = mid + Math.imul(al7, bh3) | 0;
          mid = mid + Math.imul(ah7, bl3) | 0;
          hi = hi + Math.imul(ah7, bh3) | 0;
          lo = lo + Math.imul(al6, bl4) | 0;
          mid = mid + Math.imul(al6, bh4) | 0;
          mid = mid + Math.imul(ah6, bl4) | 0;
          hi = hi + Math.imul(ah6, bh4) | 0;
          lo = lo + Math.imul(al5, bl5) | 0;
          mid = mid + Math.imul(al5, bh5) | 0;
          mid = mid + Math.imul(ah5, bl5) | 0;
          hi = hi + Math.imul(ah5, bh5) | 0;
          lo = lo + Math.imul(al4, bl6) | 0;
          mid = mid + Math.imul(al4, bh6) | 0;
          mid = mid + Math.imul(ah4, bl6) | 0;
          hi = hi + Math.imul(ah4, bh6) | 0;
          lo = lo + Math.imul(al3, bl7) | 0;
          mid = mid + Math.imul(al3, bh7) | 0;
          mid = mid + Math.imul(ah3, bl7) | 0;
          hi = hi + Math.imul(ah3, bh7) | 0;
          lo = lo + Math.imul(al2, bl8) | 0;
          mid = mid + Math.imul(al2, bh8) | 0;
          mid = mid + Math.imul(ah2, bl8) | 0;
          hi = hi + Math.imul(ah2, bh8) | 0;
          lo = lo + Math.imul(al1, bl9) | 0;
          mid = mid + Math.imul(al1, bh9) | 0;
          mid = mid + Math.imul(ah1, bl9) | 0;
          hi = hi + Math.imul(ah1, bh9) | 0;
          var w10 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w10 >>> 26) | 0;
          w10 &= 67108863;
          lo = Math.imul(al9, bl2);
          mid = Math.imul(al9, bh2);
          mid = mid + Math.imul(ah9, bl2) | 0;
          hi = Math.imul(ah9, bh2);
          lo = lo + Math.imul(al8, bl3) | 0;
          mid = mid + Math.imul(al8, bh3) | 0;
          mid = mid + Math.imul(ah8, bl3) | 0;
          hi = hi + Math.imul(ah8, bh3) | 0;
          lo = lo + Math.imul(al7, bl4) | 0;
          mid = mid + Math.imul(al7, bh4) | 0;
          mid = mid + Math.imul(ah7, bl4) | 0;
          hi = hi + Math.imul(ah7, bh4) | 0;
          lo = lo + Math.imul(al6, bl5) | 0;
          mid = mid + Math.imul(al6, bh5) | 0;
          mid = mid + Math.imul(ah6, bl5) | 0;
          hi = hi + Math.imul(ah6, bh5) | 0;
          lo = lo + Math.imul(al5, bl6) | 0;
          mid = mid + Math.imul(al5, bh6) | 0;
          mid = mid + Math.imul(ah5, bl6) | 0;
          hi = hi + Math.imul(ah5, bh6) | 0;
          lo = lo + Math.imul(al4, bl7) | 0;
          mid = mid + Math.imul(al4, bh7) | 0;
          mid = mid + Math.imul(ah4, bl7) | 0;
          hi = hi + Math.imul(ah4, bh7) | 0;
          lo = lo + Math.imul(al3, bl8) | 0;
          mid = mid + Math.imul(al3, bh8) | 0;
          mid = mid + Math.imul(ah3, bl8) | 0;
          hi = hi + Math.imul(ah3, bh8) | 0;
          lo = lo + Math.imul(al2, bl9) | 0;
          mid = mid + Math.imul(al2, bh9) | 0;
          mid = mid + Math.imul(ah2, bl9) | 0;
          hi = hi + Math.imul(ah2, bh9) | 0;
          var w11 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w11 >>> 26) | 0;
          w11 &= 67108863;
          lo = Math.imul(al9, bl3);
          mid = Math.imul(al9, bh3);
          mid = mid + Math.imul(ah9, bl3) | 0;
          hi = Math.imul(ah9, bh3);
          lo = lo + Math.imul(al8, bl4) | 0;
          mid = mid + Math.imul(al8, bh4) | 0;
          mid = mid + Math.imul(ah8, bl4) | 0;
          hi = hi + Math.imul(ah8, bh4) | 0;
          lo = lo + Math.imul(al7, bl5) | 0;
          mid = mid + Math.imul(al7, bh5) | 0;
          mid = mid + Math.imul(ah7, bl5) | 0;
          hi = hi + Math.imul(ah7, bh5) | 0;
          lo = lo + Math.imul(al6, bl6) | 0;
          mid = mid + Math.imul(al6, bh6) | 0;
          mid = mid + Math.imul(ah6, bl6) | 0;
          hi = hi + Math.imul(ah6, bh6) | 0;
          lo = lo + Math.imul(al5, bl7) | 0;
          mid = mid + Math.imul(al5, bh7) | 0;
          mid = mid + Math.imul(ah5, bl7) | 0;
          hi = hi + Math.imul(ah5, bh7) | 0;
          lo = lo + Math.imul(al4, bl8) | 0;
          mid = mid + Math.imul(al4, bh8) | 0;
          mid = mid + Math.imul(ah4, bl8) | 0;
          hi = hi + Math.imul(ah4, bh8) | 0;
          lo = lo + Math.imul(al3, bl9) | 0;
          mid = mid + Math.imul(al3, bh9) | 0;
          mid = mid + Math.imul(ah3, bl9) | 0;
          hi = hi + Math.imul(ah3, bh9) | 0;
          var w12 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w12 >>> 26) | 0;
          w12 &= 67108863;
          lo = Math.imul(al9, bl4);
          mid = Math.imul(al9, bh4);
          mid = mid + Math.imul(ah9, bl4) | 0;
          hi = Math.imul(ah9, bh4);
          lo = lo + Math.imul(al8, bl5) | 0;
          mid = mid + Math.imul(al8, bh5) | 0;
          mid = mid + Math.imul(ah8, bl5) | 0;
          hi = hi + Math.imul(ah8, bh5) | 0;
          lo = lo + Math.imul(al7, bl6) | 0;
          mid = mid + Math.imul(al7, bh6) | 0;
          mid = mid + Math.imul(ah7, bl6) | 0;
          hi = hi + Math.imul(ah7, bh6) | 0;
          lo = lo + Math.imul(al6, bl7) | 0;
          mid = mid + Math.imul(al6, bh7) | 0;
          mid = mid + Math.imul(ah6, bl7) | 0;
          hi = hi + Math.imul(ah6, bh7) | 0;
          lo = lo + Math.imul(al5, bl8) | 0;
          mid = mid + Math.imul(al5, bh8) | 0;
          mid = mid + Math.imul(ah5, bl8) | 0;
          hi = hi + Math.imul(ah5, bh8) | 0;
          lo = lo + Math.imul(al4, bl9) | 0;
          mid = mid + Math.imul(al4, bh9) | 0;
          mid = mid + Math.imul(ah4, bl9) | 0;
          hi = hi + Math.imul(ah4, bh9) | 0;
          var w13 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w13 >>> 26) | 0;
          w13 &= 67108863;
          lo = Math.imul(al9, bl5);
          mid = Math.imul(al9, bh5);
          mid = mid + Math.imul(ah9, bl5) | 0;
          hi = Math.imul(ah9, bh5);
          lo = lo + Math.imul(al8, bl6) | 0;
          mid = mid + Math.imul(al8, bh6) | 0;
          mid = mid + Math.imul(ah8, bl6) | 0;
          hi = hi + Math.imul(ah8, bh6) | 0;
          lo = lo + Math.imul(al7, bl7) | 0;
          mid = mid + Math.imul(al7, bh7) | 0;
          mid = mid + Math.imul(ah7, bl7) | 0;
          hi = hi + Math.imul(ah7, bh7) | 0;
          lo = lo + Math.imul(al6, bl8) | 0;
          mid = mid + Math.imul(al6, bh8) | 0;
          mid = mid + Math.imul(ah6, bl8) | 0;
          hi = hi + Math.imul(ah6, bh8) | 0;
          lo = lo + Math.imul(al5, bl9) | 0;
          mid = mid + Math.imul(al5, bh9) | 0;
          mid = mid + Math.imul(ah5, bl9) | 0;
          hi = hi + Math.imul(ah5, bh9) | 0;
          var w14 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w14 >>> 26) | 0;
          w14 &= 67108863;
          lo = Math.imul(al9, bl6);
          mid = Math.imul(al9, bh6);
          mid = mid + Math.imul(ah9, bl6) | 0;
          hi = Math.imul(ah9, bh6);
          lo = lo + Math.imul(al8, bl7) | 0;
          mid = mid + Math.imul(al8, bh7) | 0;
          mid = mid + Math.imul(ah8, bl7) | 0;
          hi = hi + Math.imul(ah8, bh7) | 0;
          lo = lo + Math.imul(al7, bl8) | 0;
          mid = mid + Math.imul(al7, bh8) | 0;
          mid = mid + Math.imul(ah7, bl8) | 0;
          hi = hi + Math.imul(ah7, bh8) | 0;
          lo = lo + Math.imul(al6, bl9) | 0;
          mid = mid + Math.imul(al6, bh9) | 0;
          mid = mid + Math.imul(ah6, bl9) | 0;
          hi = hi + Math.imul(ah6, bh9) | 0;
          var w15 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w15 >>> 26) | 0;
          w15 &= 67108863;
          lo = Math.imul(al9, bl7);
          mid = Math.imul(al9, bh7);
          mid = mid + Math.imul(ah9, bl7) | 0;
          hi = Math.imul(ah9, bh7);
          lo = lo + Math.imul(al8, bl8) | 0;
          mid = mid + Math.imul(al8, bh8) | 0;
          mid = mid + Math.imul(ah8, bl8) | 0;
          hi = hi + Math.imul(ah8, bh8) | 0;
          lo = lo + Math.imul(al7, bl9) | 0;
          mid = mid + Math.imul(al7, bh9) | 0;
          mid = mid + Math.imul(ah7, bl9) | 0;
          hi = hi + Math.imul(ah7, bh9) | 0;
          var w16 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w16 >>> 26) | 0;
          w16 &= 67108863;
          lo = Math.imul(al9, bl8);
          mid = Math.imul(al9, bh8);
          mid = mid + Math.imul(ah9, bl8) | 0;
          hi = Math.imul(ah9, bh8);
          lo = lo + Math.imul(al8, bl9) | 0;
          mid = mid + Math.imul(al8, bh9) | 0;
          mid = mid + Math.imul(ah8, bl9) | 0;
          hi = hi + Math.imul(ah8, bh9) | 0;
          var w17 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w17 >>> 26) | 0;
          w17 &= 67108863;
          lo = Math.imul(al9, bl9);
          mid = Math.imul(al9, bh9);
          mid = mid + Math.imul(ah9, bl9) | 0;
          hi = Math.imul(ah9, bh9);
          var w18 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w18 >>> 26) | 0;
          w18 &= 67108863;
          o[0] = w0;
          o[1] = w1;
          o[2] = w2;
          o[3] = w3;
          o[4] = w4;
          o[5] = w5;
          o[6] = w6;
          o[7] = w7;
          o[8] = w8;
          o[9] = w9;
          o[10] = w10;
          o[11] = w11;
          o[12] = w12;
          o[13] = w13;
          o[14] = w14;
          o[15] = w15;
          o[16] = w16;
          o[17] = w17;
          o[18] = w18;
          if (c !== 0) {
            o[19] = c;
            out.length++;
          }
          return out;
        };
        if (!Math.imul) {
          comb10MulTo = smallMulTo;
        }
        function bigMulTo(self2, num, out) {
          out.negative = num.negative ^ self2.negative;
          out.length = self2.length + num.length;
          var carry = 0;
          var hncarry = 0;
          for (var k = 0; k < out.length - 1; k++) {
            var ncarry = hncarry;
            hncarry = 0;
            var rword = carry & 67108863;
            var maxJ = Math.min(k, num.length - 1);
            for (var j = Math.max(0, k - self2.length + 1); j <= maxJ; j++) {
              var i = k - j;
              var a = self2.words[i] | 0;
              var b = num.words[j] | 0;
              var r = a * b;
              var lo = r & 67108863;
              ncarry = ncarry + (r / 67108864 | 0) | 0;
              lo = lo + rword | 0;
              rword = lo & 67108863;
              ncarry = ncarry + (lo >>> 26) | 0;
              hncarry += ncarry >>> 26;
              ncarry &= 67108863;
            }
            out.words[k] = rword;
            carry = ncarry;
            ncarry = hncarry;
          }
          if (carry !== 0) {
            out.words[k] = carry;
          } else {
            out.length--;
          }
          return out.strip();
        }
        function jumboMulTo(self2, num, out) {
          var fftm = new FFTM();
          return fftm.mulp(self2, num, out);
        }
        BN.prototype.mulTo = function mulTo(num, out) {
          var res;
          var len = this.length + num.length;
          if (this.length === 10 && num.length === 10) {
            res = comb10MulTo(this, num, out);
          } else if (len < 63) {
            res = smallMulTo(this, num, out);
          } else if (len < 1024) {
            res = bigMulTo(this, num, out);
          } else {
            res = jumboMulTo(this, num, out);
          }
          return res;
        };
        function FFTM(x, y) {
          this.x = x;
          this.y = y;
        }
        FFTM.prototype.makeRBT = function makeRBT(N) {
          var t = new Array(N);
          var l = BN.prototype._countBits(N) - 1;
          for (var i = 0; i < N; i++) {
            t[i] = this.revBin(i, l, N);
          }
          return t;
        };
        FFTM.prototype.revBin = function revBin(x, l, N) {
          if (x === 0 || x === N - 1)
            return x;
          var rb = 0;
          for (var i = 0; i < l; i++) {
            rb |= (x & 1) << l - i - 1;
            x >>= 1;
          }
          return rb;
        };
        FFTM.prototype.permute = function permute(rbt, rws, iws, rtws, itws, N) {
          for (var i = 0; i < N; i++) {
            rtws[i] = rws[rbt[i]];
            itws[i] = iws[rbt[i]];
          }
        };
        FFTM.prototype.transform = function transform(rws, iws, rtws, itws, N, rbt) {
          this.permute(rbt, rws, iws, rtws, itws, N);
          for (var s = 1; s < N; s <<= 1) {
            var l = s << 1;
            var rtwdf = Math.cos(2 * Math.PI / l);
            var itwdf = Math.sin(2 * Math.PI / l);
            for (var p = 0; p < N; p += l) {
              var rtwdf_ = rtwdf;
              var itwdf_ = itwdf;
              for (var j = 0; j < s; j++) {
                var re = rtws[p + j];
                var ie = itws[p + j];
                var ro = rtws[p + j + s];
                var io = itws[p + j + s];
                var rx = rtwdf_ * ro - itwdf_ * io;
                io = rtwdf_ * io + itwdf_ * ro;
                ro = rx;
                rtws[p + j] = re + ro;
                itws[p + j] = ie + io;
                rtws[p + j + s] = re - ro;
                itws[p + j + s] = ie - io;
                if (j !== l) {
                  rx = rtwdf * rtwdf_ - itwdf * itwdf_;
                  itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;
                  rtwdf_ = rx;
                }
              }
            }
          }
        };
        FFTM.prototype.guessLen13b = function guessLen13b(n, m) {
          var N = Math.max(m, n) | 1;
          var odd = N & 1;
          var i = 0;
          for (N = N / 2 | 0; N; N = N >>> 1) {
            i++;
          }
          return 1 << i + 1 + odd;
        };
        FFTM.prototype.conjugate = function conjugate(rws, iws, N) {
          if (N <= 1)
            return;
          for (var i = 0; i < N / 2; i++) {
            var t = rws[i];
            rws[i] = rws[N - i - 1];
            rws[N - i - 1] = t;
            t = iws[i];
            iws[i] = -iws[N - i - 1];
            iws[N - i - 1] = -t;
          }
        };
        FFTM.prototype.normalize13b = function normalize13b(ws, N) {
          var carry = 0;
          for (var i = 0; i < N / 2; i++) {
            var w = Math.round(ws[2 * i + 1] / N) * 8192 + Math.round(ws[2 * i] / N) + carry;
            ws[i] = w & 67108863;
            if (w < 67108864) {
              carry = 0;
            } else {
              carry = w / 67108864 | 0;
            }
          }
          return ws;
        };
        FFTM.prototype.convert13b = function convert13b(ws, len, rws, N) {
          var carry = 0;
          for (var i = 0; i < len; i++) {
            carry = carry + (ws[i] | 0);
            rws[2 * i] = carry & 8191;
            carry = carry >>> 13;
            rws[2 * i + 1] = carry & 8191;
            carry = carry >>> 13;
          }
          for (i = 2 * len; i < N; ++i) {
            rws[i] = 0;
          }
          assert(carry === 0);
          assert((carry & ~8191) === 0);
        };
        FFTM.prototype.stub = function stub(N) {
          var ph = new Array(N);
          for (var i = 0; i < N; i++) {
            ph[i] = 0;
          }
          return ph;
        };
        FFTM.prototype.mulp = function mulp(x, y, out) {
          var N = 2 * this.guessLen13b(x.length, y.length);
          var rbt = this.makeRBT(N);
          var _ = this.stub(N);
          var rws = new Array(N);
          var rwst = new Array(N);
          var iwst = new Array(N);
          var nrws = new Array(N);
          var nrwst = new Array(N);
          var niwst = new Array(N);
          var rmws = out.words;
          rmws.length = N;
          this.convert13b(x.words, x.length, rws, N);
          this.convert13b(y.words, y.length, nrws, N);
          this.transform(rws, _, rwst, iwst, N, rbt);
          this.transform(nrws, _, nrwst, niwst, N, rbt);
          for (var i = 0; i < N; i++) {
            var rx = rwst[i] * nrwst[i] - iwst[i] * niwst[i];
            iwst[i] = rwst[i] * niwst[i] + iwst[i] * nrwst[i];
            rwst[i] = rx;
          }
          this.conjugate(rwst, iwst, N);
          this.transform(rwst, iwst, rmws, _, N, rbt);
          this.conjugate(rmws, _, N);
          this.normalize13b(rmws, N);
          out.negative = x.negative ^ y.negative;
          out.length = x.length + y.length;
          return out.strip();
        };
        BN.prototype.mul = function mul(num) {
          var out = new BN(null);
          out.words = new Array(this.length + num.length);
          return this.mulTo(num, out);
        };
        BN.prototype.mulf = function mulf(num) {
          var out = new BN(null);
          out.words = new Array(this.length + num.length);
          return jumboMulTo(this, num, out);
        };
        BN.prototype.imul = function imul(num) {
          return this.clone().mulTo(num, this);
        };
        BN.prototype.imuln = function imuln(num) {
          assert(typeof num === "number");
          assert(num < 67108864);
          var carry = 0;
          for (var i = 0; i < this.length; i++) {
            var w = (this.words[i] | 0) * num;
            var lo = (w & 67108863) + (carry & 67108863);
            carry >>= 26;
            carry += w / 67108864 | 0;
            carry += lo >>> 26;
            this.words[i] = lo & 67108863;
          }
          if (carry !== 0) {
            this.words[i] = carry;
            this.length++;
          }
          return this;
        };
        BN.prototype.muln = function muln(num) {
          return this.clone().imuln(num);
        };
        BN.prototype.sqr = function sqr() {
          return this.mul(this);
        };
        BN.prototype.isqr = function isqr() {
          return this.imul(this.clone());
        };
        BN.prototype.pow = function pow(num) {
          var w = toBitArray(num);
          if (w.length === 0)
            return new BN(1);
          var res = this;
          for (var i = 0; i < w.length; i++, res = res.sqr()) {
            if (w[i] !== 0)
              break;
          }
          if (++i < w.length) {
            for (var q = res.sqr(); i < w.length; i++, q = q.sqr()) {
              if (w[i] === 0)
                continue;
              res = res.mul(q);
            }
          }
          return res;
        };
        BN.prototype.iushln = function iushln(bits) {
          assert(typeof bits === "number" && bits >= 0);
          var r = bits % 26;
          var s = (bits - r) / 26;
          var carryMask = 67108863 >>> 26 - r << 26 - r;
          var i;
          if (r !== 0) {
            var carry = 0;
            for (i = 0; i < this.length; i++) {
              var newCarry = this.words[i] & carryMask;
              var c = (this.words[i] | 0) - newCarry << r;
              this.words[i] = c | carry;
              carry = newCarry >>> 26 - r;
            }
            if (carry) {
              this.words[i] = carry;
              this.length++;
            }
          }
          if (s !== 0) {
            for (i = this.length - 1; i >= 0; i--) {
              this.words[i + s] = this.words[i];
            }
            for (i = 0; i < s; i++) {
              this.words[i] = 0;
            }
            this.length += s;
          }
          return this.strip();
        };
        BN.prototype.ishln = function ishln(bits) {
          assert(this.negative === 0);
          return this.iushln(bits);
        };
        BN.prototype.iushrn = function iushrn(bits, hint, extended) {
          assert(typeof bits === "number" && bits >= 0);
          var h;
          if (hint) {
            h = (hint - hint % 26) / 26;
          } else {
            h = 0;
          }
          var r = bits % 26;
          var s = Math.min((bits - r) / 26, this.length);
          var mask = 67108863 ^ 67108863 >>> r << r;
          var maskedWords = extended;
          h -= s;
          h = Math.max(0, h);
          if (maskedWords) {
            for (var i = 0; i < s; i++) {
              maskedWords.words[i] = this.words[i];
            }
            maskedWords.length = s;
          }
          if (s === 0) {
          } else if (this.length > s) {
            this.length -= s;
            for (i = 0; i < this.length; i++) {
              this.words[i] = this.words[i + s];
            }
          } else {
            this.words[0] = 0;
            this.length = 1;
          }
          var carry = 0;
          for (i = this.length - 1; i >= 0 && (carry !== 0 || i >= h); i--) {
            var word = this.words[i] | 0;
            this.words[i] = carry << 26 - r | word >>> r;
            carry = word & mask;
          }
          if (maskedWords && carry !== 0) {
            maskedWords.words[maskedWords.length++] = carry;
          }
          if (this.length === 0) {
            this.words[0] = 0;
            this.length = 1;
          }
          return this.strip();
        };
        BN.prototype.ishrn = function ishrn(bits, hint, extended) {
          assert(this.negative === 0);
          return this.iushrn(bits, hint, extended);
        };
        BN.prototype.shln = function shln(bits) {
          return this.clone().ishln(bits);
        };
        BN.prototype.ushln = function ushln(bits) {
          return this.clone().iushln(bits);
        };
        BN.prototype.shrn = function shrn(bits) {
          return this.clone().ishrn(bits);
        };
        BN.prototype.ushrn = function ushrn(bits) {
          return this.clone().iushrn(bits);
        };
        BN.prototype.testn = function testn(bit) {
          assert(typeof bit === "number" && bit >= 0);
          var r = bit % 26;
          var s = (bit - r) / 26;
          var q = 1 << r;
          if (this.length <= s)
            return false;
          var w = this.words[s];
          return !!(w & q);
        };
        BN.prototype.imaskn = function imaskn(bits) {
          assert(typeof bits === "number" && bits >= 0);
          var r = bits % 26;
          var s = (bits - r) / 26;
          assert(this.negative === 0, "imaskn works only with positive numbers");
          if (this.length <= s) {
            return this;
          }
          if (r !== 0) {
            s++;
          }
          this.length = Math.min(s, this.length);
          if (r !== 0) {
            var mask = 67108863 ^ 67108863 >>> r << r;
            this.words[this.length - 1] &= mask;
          }
          return this.strip();
        };
        BN.prototype.maskn = function maskn(bits) {
          return this.clone().imaskn(bits);
        };
        BN.prototype.iaddn = function iaddn(num) {
          assert(typeof num === "number");
          assert(num < 67108864);
          if (num < 0)
            return this.isubn(-num);
          if (this.negative !== 0) {
            if (this.length === 1 && (this.words[0] | 0) < num) {
              this.words[0] = num - (this.words[0] | 0);
              this.negative = 0;
              return this;
            }
            this.negative = 0;
            this.isubn(num);
            this.negative = 1;
            return this;
          }
          return this._iaddn(num);
        };
        BN.prototype._iaddn = function _iaddn(num) {
          this.words[0] += num;
          for (var i = 0; i < this.length && this.words[i] >= 67108864; i++) {
            this.words[i] -= 67108864;
            if (i === this.length - 1) {
              this.words[i + 1] = 1;
            } else {
              this.words[i + 1]++;
            }
          }
          this.length = Math.max(this.length, i + 1);
          return this;
        };
        BN.prototype.isubn = function isubn(num) {
          assert(typeof num === "number");
          assert(num < 67108864);
          if (num < 0)
            return this.iaddn(-num);
          if (this.negative !== 0) {
            this.negative = 0;
            this.iaddn(num);
            this.negative = 1;
            return this;
          }
          this.words[0] -= num;
          if (this.length === 1 && this.words[0] < 0) {
            this.words[0] = -this.words[0];
            this.negative = 1;
          } else {
            for (var i = 0; i < this.length && this.words[i] < 0; i++) {
              this.words[i] += 67108864;
              this.words[i + 1] -= 1;
            }
          }
          return this.strip();
        };
        BN.prototype.addn = function addn(num) {
          return this.clone().iaddn(num);
        };
        BN.prototype.subn = function subn(num) {
          return this.clone().isubn(num);
        };
        BN.prototype.iabs = function iabs() {
          this.negative = 0;
          return this;
        };
        BN.prototype.abs = function abs() {
          return this.clone().iabs();
        };
        BN.prototype._ishlnsubmul = function _ishlnsubmul(num, mul, shift) {
          var len = num.length + shift;
          var i;
          this._expand(len);
          var w;
          var carry = 0;
          for (i = 0; i < num.length; i++) {
            w = (this.words[i + shift] | 0) + carry;
            var right = (num.words[i] | 0) * mul;
            w -= right & 67108863;
            carry = (w >> 26) - (right / 67108864 | 0);
            this.words[i + shift] = w & 67108863;
          }
          for (; i < this.length - shift; i++) {
            w = (this.words[i + shift] | 0) + carry;
            carry = w >> 26;
            this.words[i + shift] = w & 67108863;
          }
          if (carry === 0)
            return this.strip();
          assert(carry === -1);
          carry = 0;
          for (i = 0; i < this.length; i++) {
            w = -(this.words[i] | 0) + carry;
            carry = w >> 26;
            this.words[i] = w & 67108863;
          }
          this.negative = 1;
          return this.strip();
        };
        BN.prototype._wordDiv = function _wordDiv(num, mode) {
          var shift = this.length - num.length;
          var a = this.clone();
          var b = num;
          var bhi = b.words[b.length - 1] | 0;
          var bhiBits = this._countBits(bhi);
          shift = 26 - bhiBits;
          if (shift !== 0) {
            b = b.ushln(shift);
            a.iushln(shift);
            bhi = b.words[b.length - 1] | 0;
          }
          var m = a.length - b.length;
          var q;
          if (mode !== "mod") {
            q = new BN(null);
            q.length = m + 1;
            q.words = new Array(q.length);
            for (var i = 0; i < q.length; i++) {
              q.words[i] = 0;
            }
          }
          var diff = a.clone()._ishlnsubmul(b, 1, m);
          if (diff.negative === 0) {
            a = diff;
            if (q) {
              q.words[m] = 1;
            }
          }
          for (var j = m - 1; j >= 0; j--) {
            var qj = (a.words[b.length + j] | 0) * 67108864 + (a.words[b.length + j - 1] | 0);
            qj = Math.min(qj / bhi | 0, 67108863);
            a._ishlnsubmul(b, qj, j);
            while (a.negative !== 0) {
              qj--;
              a.negative = 0;
              a._ishlnsubmul(b, 1, j);
              if (!a.isZero()) {
                a.negative ^= 1;
              }
            }
            if (q) {
              q.words[j] = qj;
            }
          }
          if (q) {
            q.strip();
          }
          a.strip();
          if (mode !== "div" && shift !== 0) {
            a.iushrn(shift);
          }
          return {
            div: q || null,
            mod: a
          };
        };
        BN.prototype.divmod = function divmod(num, mode, positive) {
          assert(!num.isZero());
          if (this.isZero()) {
            return {
              div: new BN(0),
              mod: new BN(0)
            };
          }
          var div, mod2, res;
          if (this.negative !== 0 && num.negative === 0) {
            res = this.neg().divmod(num, mode);
            if (mode !== "mod") {
              div = res.div.neg();
            }
            if (mode !== "div") {
              mod2 = res.mod.neg();
              if (positive && mod2.negative !== 0) {
                mod2.iadd(num);
              }
            }
            return {
              div,
              mod: mod2
            };
          }
          if (this.negative === 0 && num.negative !== 0) {
            res = this.divmod(num.neg(), mode);
            if (mode !== "mod") {
              div = res.div.neg();
            }
            return {
              div,
              mod: res.mod
            };
          }
          if ((this.negative & num.negative) !== 0) {
            res = this.neg().divmod(num.neg(), mode);
            if (mode !== "div") {
              mod2 = res.mod.neg();
              if (positive && mod2.negative !== 0) {
                mod2.isub(num);
              }
            }
            return {
              div: res.div,
              mod: mod2
            };
          }
          if (num.length > this.length || this.cmp(num) < 0) {
            return {
              div: new BN(0),
              mod: this
            };
          }
          if (num.length === 1) {
            if (mode === "div") {
              return {
                div: this.divn(num.words[0]),
                mod: null
              };
            }
            if (mode === "mod") {
              return {
                div: null,
                mod: new BN(this.modn(num.words[0]))
              };
            }
            return {
              div: this.divn(num.words[0]),
              mod: new BN(this.modn(num.words[0]))
            };
          }
          return this._wordDiv(num, mode);
        };
        BN.prototype.div = function div(num) {
          return this.divmod(num, "div", false).div;
        };
        BN.prototype.mod = function mod2(num) {
          return this.divmod(num, "mod", false).mod;
        };
        BN.prototype.umod = function umod(num) {
          return this.divmod(num, "mod", true).mod;
        };
        BN.prototype.divRound = function divRound(num) {
          var dm = this.divmod(num);
          if (dm.mod.isZero())
            return dm.div;
          var mod2 = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;
          var half = num.ushrn(1);
          var r2 = num.andln(1);
          var cmp = mod2.cmp(half);
          if (cmp < 0 || r2 === 1 && cmp === 0)
            return dm.div;
          return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
        };
        BN.prototype.modn = function modn(num) {
          assert(num <= 67108863);
          var p = (1 << 26) % num;
          var acc = 0;
          for (var i = this.length - 1; i >= 0; i--) {
            acc = (p * acc + (this.words[i] | 0)) % num;
          }
          return acc;
        };
        BN.prototype.idivn = function idivn(num) {
          assert(num <= 67108863);
          var carry = 0;
          for (var i = this.length - 1; i >= 0; i--) {
            var w = (this.words[i] | 0) + carry * 67108864;
            this.words[i] = w / num | 0;
            carry = w % num;
          }
          return this.strip();
        };
        BN.prototype.divn = function divn(num) {
          return this.clone().idivn(num);
        };
        BN.prototype.egcd = function egcd(p) {
          assert(p.negative === 0);
          assert(!p.isZero());
          var x = this;
          var y = p.clone();
          if (x.negative !== 0) {
            x = x.umod(p);
          } else {
            x = x.clone();
          }
          var A = new BN(1);
          var B = new BN(0);
          var C = new BN(0);
          var D = new BN(1);
          var g = 0;
          while (x.isEven() && y.isEven()) {
            x.iushrn(1);
            y.iushrn(1);
            ++g;
          }
          var yp = y.clone();
          var xp = x.clone();
          while (!x.isZero()) {
            for (var i = 0, im = 1; (x.words[0] & im) === 0 && i < 26; ++i, im <<= 1)
              ;
            if (i > 0) {
              x.iushrn(i);
              while (i-- > 0) {
                if (A.isOdd() || B.isOdd()) {
                  A.iadd(yp);
                  B.isub(xp);
                }
                A.iushrn(1);
                B.iushrn(1);
              }
            }
            for (var j = 0, jm = 1; (y.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1)
              ;
            if (j > 0) {
              y.iushrn(j);
              while (j-- > 0) {
                if (C.isOdd() || D.isOdd()) {
                  C.iadd(yp);
                  D.isub(xp);
                }
                C.iushrn(1);
                D.iushrn(1);
              }
            }
            if (x.cmp(y) >= 0) {
              x.isub(y);
              A.isub(C);
              B.isub(D);
            } else {
              y.isub(x);
              C.isub(A);
              D.isub(B);
            }
          }
          return {
            a: C,
            b: D,
            gcd: y.iushln(g)
          };
        };
        BN.prototype._invmp = function _invmp(p) {
          assert(p.negative === 0);
          assert(!p.isZero());
          var a = this;
          var b = p.clone();
          if (a.negative !== 0) {
            a = a.umod(p);
          } else {
            a = a.clone();
          }
          var x1 = new BN(1);
          var x2 = new BN(0);
          var delta = b.clone();
          while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {
            for (var i = 0, im = 1; (a.words[0] & im) === 0 && i < 26; ++i, im <<= 1)
              ;
            if (i > 0) {
              a.iushrn(i);
              while (i-- > 0) {
                if (x1.isOdd()) {
                  x1.iadd(delta);
                }
                x1.iushrn(1);
              }
            }
            for (var j = 0, jm = 1; (b.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1)
              ;
            if (j > 0) {
              b.iushrn(j);
              while (j-- > 0) {
                if (x2.isOdd()) {
                  x2.iadd(delta);
                }
                x2.iushrn(1);
              }
            }
            if (a.cmp(b) >= 0) {
              a.isub(b);
              x1.isub(x2);
            } else {
              b.isub(a);
              x2.isub(x1);
            }
          }
          var res;
          if (a.cmpn(1) === 0) {
            res = x1;
          } else {
            res = x2;
          }
          if (res.cmpn(0) < 0) {
            res.iadd(p);
          }
          return res;
        };
        BN.prototype.gcd = function gcd(num) {
          if (this.isZero())
            return num.abs();
          if (num.isZero())
            return this.abs();
          var a = this.clone();
          var b = num.clone();
          a.negative = 0;
          b.negative = 0;
          for (var shift = 0; a.isEven() && b.isEven(); shift++) {
            a.iushrn(1);
            b.iushrn(1);
          }
          do {
            while (a.isEven()) {
              a.iushrn(1);
            }
            while (b.isEven()) {
              b.iushrn(1);
            }
            var r = a.cmp(b);
            if (r < 0) {
              var t = a;
              a = b;
              b = t;
            } else if (r === 0 || b.cmpn(1) === 0) {
              break;
            }
            a.isub(b);
          } while (true);
          return b.iushln(shift);
        };
        BN.prototype.invm = function invm(num) {
          return this.egcd(num).a.umod(num);
        };
        BN.prototype.isEven = function isEven() {
          return (this.words[0] & 1) === 0;
        };
        BN.prototype.isOdd = function isOdd() {
          return (this.words[0] & 1) === 1;
        };
        BN.prototype.andln = function andln(num) {
          return this.words[0] & num;
        };
        BN.prototype.bincn = function bincn(bit) {
          assert(typeof bit === "number");
          var r = bit % 26;
          var s = (bit - r) / 26;
          var q = 1 << r;
          if (this.length <= s) {
            this._expand(s + 1);
            this.words[s] |= q;
            return this;
          }
          var carry = q;
          for (var i = s; carry !== 0 && i < this.length; i++) {
            var w = this.words[i] | 0;
            w += carry;
            carry = w >>> 26;
            w &= 67108863;
            this.words[i] = w;
          }
          if (carry !== 0) {
            this.words[i] = carry;
            this.length++;
          }
          return this;
        };
        BN.prototype.isZero = function isZero() {
          return this.length === 1 && this.words[0] === 0;
        };
        BN.prototype.cmpn = function cmpn(num) {
          var negative = num < 0;
          if (this.negative !== 0 && !negative)
            return -1;
          if (this.negative === 0 && negative)
            return 1;
          this.strip();
          var res;
          if (this.length > 1) {
            res = 1;
          } else {
            if (negative) {
              num = -num;
            }
            assert(num <= 67108863, "Number is too big");
            var w = this.words[0] | 0;
            res = w === num ? 0 : w < num ? -1 : 1;
          }
          if (this.negative !== 0)
            return -res | 0;
          return res;
        };
        BN.prototype.cmp = function cmp(num) {
          if (this.negative !== 0 && num.negative === 0)
            return -1;
          if (this.negative === 0 && num.negative !== 0)
            return 1;
          var res = this.ucmp(num);
          if (this.negative !== 0)
            return -res | 0;
          return res;
        };
        BN.prototype.ucmp = function ucmp(num) {
          if (this.length > num.length)
            return 1;
          if (this.length < num.length)
            return -1;
          var res = 0;
          for (var i = this.length - 1; i >= 0; i--) {
            var a = this.words[i] | 0;
            var b = num.words[i] | 0;
            if (a === b)
              continue;
            if (a < b) {
              res = -1;
            } else if (a > b) {
              res = 1;
            }
            break;
          }
          return res;
        };
        BN.prototype.gtn = function gtn(num) {
          return this.cmpn(num) === 1;
        };
        BN.prototype.gt = function gt(num) {
          return this.cmp(num) === 1;
        };
        BN.prototype.gten = function gten(num) {
          return this.cmpn(num) >= 0;
        };
        BN.prototype.gte = function gte(num) {
          return this.cmp(num) >= 0;
        };
        BN.prototype.ltn = function ltn(num) {
          return this.cmpn(num) === -1;
        };
        BN.prototype.lt = function lt(num) {
          return this.cmp(num) === -1;
        };
        BN.prototype.lten = function lten(num) {
          return this.cmpn(num) <= 0;
        };
        BN.prototype.lte = function lte(num) {
          return this.cmp(num) <= 0;
        };
        BN.prototype.eqn = function eqn(num) {
          return this.cmpn(num) === 0;
        };
        BN.prototype.eq = function eq(num) {
          return this.cmp(num) === 0;
        };
        BN.red = function red(num) {
          return new Red(num);
        };
        BN.prototype.toRed = function toRed(ctx) {
          assert(!this.red, "Already a number in reduction context");
          assert(this.negative === 0, "red works only with positives");
          return ctx.convertTo(this)._forceRed(ctx);
        };
        BN.prototype.fromRed = function fromRed() {
          assert(this.red, "fromRed works only with numbers in reduction context");
          return this.red.convertFrom(this);
        };
        BN.prototype._forceRed = function _forceRed(ctx) {
          this.red = ctx;
          return this;
        };
        BN.prototype.forceRed = function forceRed(ctx) {
          assert(!this.red, "Already a number in reduction context");
          return this._forceRed(ctx);
        };
        BN.prototype.redAdd = function redAdd(num) {
          assert(this.red, "redAdd works only with red numbers");
          return this.red.add(this, num);
        };
        BN.prototype.redIAdd = function redIAdd(num) {
          assert(this.red, "redIAdd works only with red numbers");
          return this.red.iadd(this, num);
        };
        BN.prototype.redSub = function redSub(num) {
          assert(this.red, "redSub works only with red numbers");
          return this.red.sub(this, num);
        };
        BN.prototype.redISub = function redISub(num) {
          assert(this.red, "redISub works only with red numbers");
          return this.red.isub(this, num);
        };
        BN.prototype.redShl = function redShl(num) {
          assert(this.red, "redShl works only with red numbers");
          return this.red.shl(this, num);
        };
        BN.prototype.redMul = function redMul(num) {
          assert(this.red, "redMul works only with red numbers");
          this.red._verify2(this, num);
          return this.red.mul(this, num);
        };
        BN.prototype.redIMul = function redIMul(num) {
          assert(this.red, "redMul works only with red numbers");
          this.red._verify2(this, num);
          return this.red.imul(this, num);
        };
        BN.prototype.redSqr = function redSqr() {
          assert(this.red, "redSqr works only with red numbers");
          this.red._verify1(this);
          return this.red.sqr(this);
        };
        BN.prototype.redISqr = function redISqr() {
          assert(this.red, "redISqr works only with red numbers");
          this.red._verify1(this);
          return this.red.isqr(this);
        };
        BN.prototype.redSqrt = function redSqrt() {
          assert(this.red, "redSqrt works only with red numbers");
          this.red._verify1(this);
          return this.red.sqrt(this);
        };
        BN.prototype.redInvm = function redInvm() {
          assert(this.red, "redInvm works only with red numbers");
          this.red._verify1(this);
          return this.red.invm(this);
        };
        BN.prototype.redNeg = function redNeg() {
          assert(this.red, "redNeg works only with red numbers");
          this.red._verify1(this);
          return this.red.neg(this);
        };
        BN.prototype.redPow = function redPow(num) {
          assert(this.red && !num.red, "redPow(normalNum)");
          this.red._verify1(this);
          return this.red.pow(this, num);
        };
        var primes = {
          k256: null,
          p224: null,
          p192: null,
          p25519: null
        };
        function MPrime(name, p) {
          this.name = name;
          this.p = new BN(p, 16);
          this.n = this.p.bitLength();
          this.k = new BN(1).iushln(this.n).isub(this.p);
          this.tmp = this._tmp();
        }
        MPrime.prototype._tmp = function _tmp() {
          var tmp = new BN(null);
          tmp.words = new Array(Math.ceil(this.n / 13));
          return tmp;
        };
        MPrime.prototype.ireduce = function ireduce(num) {
          var r = num;
          var rlen;
          do {
            this.split(r, this.tmp);
            r = this.imulK(r);
            r = r.iadd(this.tmp);
            rlen = r.bitLength();
          } while (rlen > this.n);
          var cmp = rlen < this.n ? -1 : r.ucmp(this.p);
          if (cmp === 0) {
            r.words[0] = 0;
            r.length = 1;
          } else if (cmp > 0) {
            r.isub(this.p);
          } else {
            if (r.strip !== void 0) {
              r.strip();
            } else {
              r._strip();
            }
          }
          return r;
        };
        MPrime.prototype.split = function split(input, out) {
          input.iushrn(this.n, 0, out);
        };
        MPrime.prototype.imulK = function imulK(num) {
          return num.imul(this.k);
        };
        function K256() {
          MPrime.call(this, "k256", "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f");
        }
        inherits(K256, MPrime);
        K256.prototype.split = function split(input, output) {
          var mask = 4194303;
          var outLen = Math.min(input.length, 9);
          for (var i = 0; i < outLen; i++) {
            output.words[i] = input.words[i];
          }
          output.length = outLen;
          if (input.length <= 9) {
            input.words[0] = 0;
            input.length = 1;
            return;
          }
          var prev = input.words[9];
          output.words[output.length++] = prev & mask;
          for (i = 10; i < input.length; i++) {
            var next = input.words[i] | 0;
            input.words[i - 10] = (next & mask) << 4 | prev >>> 22;
            prev = next;
          }
          prev >>>= 22;
          input.words[i - 10] = prev;
          if (prev === 0 && input.length > 10) {
            input.length -= 10;
          } else {
            input.length -= 9;
          }
        };
        K256.prototype.imulK = function imulK(num) {
          num.words[num.length] = 0;
          num.words[num.length + 1] = 0;
          num.length += 2;
          var lo = 0;
          for (var i = 0; i < num.length; i++) {
            var w = num.words[i] | 0;
            lo += w * 977;
            num.words[i] = lo & 67108863;
            lo = w * 64 + (lo / 67108864 | 0);
          }
          if (num.words[num.length - 1] === 0) {
            num.length--;
            if (num.words[num.length - 1] === 0) {
              num.length--;
            }
          }
          return num;
        };
        function P224() {
          MPrime.call(this, "p224", "ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001");
        }
        inherits(P224, MPrime);
        function P192() {
          MPrime.call(this, "p192", "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff");
        }
        inherits(P192, MPrime);
        function P25519() {
          MPrime.call(this, "25519", "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed");
        }
        inherits(P25519, MPrime);
        P25519.prototype.imulK = function imulK(num) {
          var carry = 0;
          for (var i = 0; i < num.length; i++) {
            var hi = (num.words[i] | 0) * 19 + carry;
            var lo = hi & 67108863;
            hi >>>= 26;
            num.words[i] = lo;
            carry = hi;
          }
          if (carry !== 0) {
            num.words[num.length++] = carry;
          }
          return num;
        };
        BN._prime = function prime(name) {
          if (primes[name])
            return primes[name];
          var prime2;
          if (name === "k256") {
            prime2 = new K256();
          } else if (name === "p224") {
            prime2 = new P224();
          } else if (name === "p192") {
            prime2 = new P192();
          } else if (name === "p25519") {
            prime2 = new P25519();
          } else {
            throw new Error("Unknown prime " + name);
          }
          primes[name] = prime2;
          return prime2;
        };
        function Red(m) {
          if (typeof m === "string") {
            var prime = BN._prime(m);
            this.m = prime.p;
            this.prime = prime;
          } else {
            assert(m.gtn(1), "modulus must be greater than 1");
            this.m = m;
            this.prime = null;
          }
        }
        Red.prototype._verify1 = function _verify1(a) {
          assert(a.negative === 0, "red works only with positives");
          assert(a.red, "red works only with red numbers");
        };
        Red.prototype._verify2 = function _verify2(a, b) {
          assert((a.negative | b.negative) === 0, "red works only with positives");
          assert(a.red && a.red === b.red, "red works only with red numbers");
        };
        Red.prototype.imod = function imod(a) {
          if (this.prime)
            return this.prime.ireduce(a)._forceRed(this);
          return a.umod(this.m)._forceRed(this);
        };
        Red.prototype.neg = function neg(a) {
          if (a.isZero()) {
            return a.clone();
          }
          return this.m.sub(a)._forceRed(this);
        };
        Red.prototype.add = function add(a, b) {
          this._verify2(a, b);
          var res = a.add(b);
          if (res.cmp(this.m) >= 0) {
            res.isub(this.m);
          }
          return res._forceRed(this);
        };
        Red.prototype.iadd = function iadd(a, b) {
          this._verify2(a, b);
          var res = a.iadd(b);
          if (res.cmp(this.m) >= 0) {
            res.isub(this.m);
          }
          return res;
        };
        Red.prototype.sub = function sub(a, b) {
          this._verify2(a, b);
          var res = a.sub(b);
          if (res.cmpn(0) < 0) {
            res.iadd(this.m);
          }
          return res._forceRed(this);
        };
        Red.prototype.isub = function isub(a, b) {
          this._verify2(a, b);
          var res = a.isub(b);
          if (res.cmpn(0) < 0) {
            res.iadd(this.m);
          }
          return res;
        };
        Red.prototype.shl = function shl(a, num) {
          this._verify1(a);
          return this.imod(a.ushln(num));
        };
        Red.prototype.imul = function imul(a, b) {
          this._verify2(a, b);
          return this.imod(a.imul(b));
        };
        Red.prototype.mul = function mul(a, b) {
          this._verify2(a, b);
          return this.imod(a.mul(b));
        };
        Red.prototype.isqr = function isqr(a) {
          return this.imul(a, a.clone());
        };
        Red.prototype.sqr = function sqr(a) {
          return this.mul(a, a);
        };
        Red.prototype.sqrt = function sqrt(a) {
          if (a.isZero())
            return a.clone();
          var mod3 = this.m.andln(3);
          assert(mod3 % 2 === 1);
          if (mod3 === 3) {
            var pow = this.m.add(new BN(1)).iushrn(2);
            return this.pow(a, pow);
          }
          var q = this.m.subn(1);
          var s = 0;
          while (!q.isZero() && q.andln(1) === 0) {
            s++;
            q.iushrn(1);
          }
          assert(!q.isZero());
          var one = new BN(1).toRed(this);
          var nOne = one.redNeg();
          var lpow = this.m.subn(1).iushrn(1);
          var z = this.m.bitLength();
          z = new BN(2 * z * z).toRed(this);
          while (this.pow(z, lpow).cmp(nOne) !== 0) {
            z.redIAdd(nOne);
          }
          var c = this.pow(z, q);
          var r = this.pow(a, q.addn(1).iushrn(1));
          var t = this.pow(a, q);
          var m = s;
          while (t.cmp(one) !== 0) {
            var tmp = t;
            for (var i = 0; tmp.cmp(one) !== 0; i++) {
              tmp = tmp.redSqr();
            }
            assert(i < m);
            var b = this.pow(c, new BN(1).iushln(m - i - 1));
            r = r.redMul(b);
            c = b.redSqr();
            t = t.redMul(c);
            m = i;
          }
          return r;
        };
        Red.prototype.invm = function invm(a) {
          var inv = a._invmp(this.m);
          if (inv.negative !== 0) {
            inv.negative = 0;
            return this.imod(inv).redNeg();
          } else {
            return this.imod(inv);
          }
        };
        Red.prototype.pow = function pow(a, num) {
          if (num.isZero())
            return new BN(1).toRed(this);
          if (num.cmpn(1) === 0)
            return a.clone();
          var windowSize = 4;
          var wnd = new Array(1 << windowSize);
          wnd[0] = new BN(1).toRed(this);
          wnd[1] = a;
          for (var i = 2; i < wnd.length; i++) {
            wnd[i] = this.mul(wnd[i - 1], a);
          }
          var res = wnd[0];
          var current = 0;
          var currentLen = 0;
          var start2 = num.bitLength() % 26;
          if (start2 === 0) {
            start2 = 26;
          }
          for (i = num.length - 1; i >= 0; i--) {
            var word = num.words[i];
            for (var j = start2 - 1; j >= 0; j--) {
              var bit = word >> j & 1;
              if (res !== wnd[0]) {
                res = this.sqr(res);
              }
              if (bit === 0 && current === 0) {
                currentLen = 0;
                continue;
              }
              current <<= 1;
              current |= bit;
              currentLen++;
              if (currentLen !== windowSize && (i !== 0 || j !== 0))
                continue;
              res = this.mul(res, wnd[current]);
              currentLen = 0;
              current = 0;
            }
            start2 = 26;
          }
          return res;
        };
        Red.prototype.convertTo = function convertTo(num) {
          var r = num.umod(this.m);
          return r === num ? r.clone() : r;
        };
        Red.prototype.convertFrom = function convertFrom(num) {
          var res = num.clone();
          res.red = null;
          return res;
        };
        BN.mont = function mont(num) {
          return new Mont(num);
        };
        function Mont(m) {
          Red.call(this, m);
          this.shift = this.m.bitLength();
          if (this.shift % 26 !== 0) {
            this.shift += 26 - this.shift % 26;
          }
          this.r = new BN(1).iushln(this.shift);
          this.r2 = this.imod(this.r.sqr());
          this.rinv = this.r._invmp(this.m);
          this.minv = this.rinv.mul(this.r).isubn(1).div(this.m);
          this.minv = this.minv.umod(this.r);
          this.minv = this.r.sub(this.minv);
        }
        inherits(Mont, Red);
        Mont.prototype.convertTo = function convertTo(num) {
          return this.imod(num.ushln(this.shift));
        };
        Mont.prototype.convertFrom = function convertFrom(num) {
          var r = this.imod(num.mul(this.rinv));
          r.red = null;
          return r;
        };
        Mont.prototype.imul = function imul(a, b) {
          if (a.isZero() || b.isZero()) {
            a.words[0] = 0;
            a.length = 1;
            return a;
          }
          var t = a.imul(b);
          var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
          var u = t.isub(c).iushrn(this.shift);
          var res = u;
          if (u.cmp(this.m) >= 0) {
            res = u.isub(this.m);
          } else if (u.cmpn(0) < 0) {
            res = u.iadd(this.m);
          }
          return res._forceRed(this);
        };
        Mont.prototype.mul = function mul(a, b) {
          if (a.isZero() || b.isZero())
            return new BN(0)._forceRed(this);
          var t = a.mul(b);
          var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
          var u = t.isub(c).iushrn(this.shift);
          var res = u;
          if (u.cmp(this.m) >= 0) {
            res = u.isub(this.m);
          } else if (u.cmpn(0) < 0) {
            res = u.iadd(this.m);
          }
          return res._forceRed(this);
        };
        Mont.prototype.invm = function invm(a) {
          var res = this.imod(a._invmp(this.m).mul(this.r2));
          return res._forceRed(this);
        };
      })(typeof module2 === "undefined" || module2, exports2);
    }
  });

  // (disabled):crypto
  var require_crypto = __commonJS({
    "(disabled):crypto"() {
    }
  });

  // node_modules/brorand/index.js
  var require_brorand = __commonJS({
    "node_modules/brorand/index.js"(exports2, module2) {
      var r;
      module2.exports = function rand(len) {
        if (!r)
          r = new Rand(null);
        return r.generate(len);
      };
      function Rand(rand) {
        this.rand = rand;
      }
      module2.exports.Rand = Rand;
      Rand.prototype.generate = function generate(len) {
        return this._rand(len);
      };
      Rand.prototype._rand = function _rand(n) {
        if (this.rand.getBytes)
          return this.rand.getBytes(n);
        var res = new Uint8Array(n);
        for (var i = 0; i < res.length; i++)
          res[i] = this.rand.getByte();
        return res;
      };
      if (typeof self === "object") {
        if (self.crypto && self.crypto.getRandomValues) {
          Rand.prototype._rand = function _rand(n) {
            var arr = new Uint8Array(n);
            self.crypto.getRandomValues(arr);
            return arr;
          };
        } else if (self.msCrypto && self.msCrypto.getRandomValues) {
          Rand.prototype._rand = function _rand(n) {
            var arr = new Uint8Array(n);
            self.msCrypto.getRandomValues(arr);
            return arr;
          };
        } else if (typeof window === "object") {
          Rand.prototype._rand = function() {
            throw new Error("Not implemented yet");
          };
        }
      } else {
        try {
          crypto = require_crypto();
          if (typeof crypto.randomBytes !== "function")
            throw new Error("Not supported");
          Rand.prototype._rand = function _rand(n) {
            return crypto.randomBytes(n);
          };
        } catch (e) {
        }
      }
      var crypto;
    }
  });

  // node_modules/miller-rabin/lib/mr.js
  var require_mr = __commonJS({
    "node_modules/miller-rabin/lib/mr.js"(exports2, module2) {
      var bn = require_bn2();
      var brorand = require_brorand();
      function MillerRabin(rand) {
        this.rand = rand || new brorand.Rand();
      }
      module2.exports = MillerRabin;
      MillerRabin.create = function create(rand) {
        return new MillerRabin(rand);
      };
      MillerRabin.prototype._randbelow = function _randbelow(n) {
        var len = n.bitLength();
        var min_bytes = Math.ceil(len / 8);
        do
          var a = new bn(this.rand.generate(min_bytes));
        while (a.cmp(n) >= 0);
        return a;
      };
      MillerRabin.prototype._randrange = function _randrange(start2, stop) {
        var size = stop.sub(start2);
        return start2.add(this._randbelow(size));
      };
      MillerRabin.prototype.test = function test(n, k, cb) {
        var len = n.bitLength();
        var red = bn.mont(n);
        var rone = new bn(1).toRed(red);
        if (!k)
          k = Math.max(1, len / 48 | 0);
        var n1 = n.subn(1);
        for (var s = 0; !n1.testn(s); s++) {
        }
        var d = n.shrn(s);
        var rn1 = n1.toRed(red);
        var prime = true;
        for (; k > 0; k--) {
          var a = this._randrange(new bn(2), n1);
          if (cb)
            cb(a);
          var x = a.toRed(red).redPow(d);
          if (x.cmp(rone) === 0 || x.cmp(rn1) === 0)
            continue;
          for (var i = 1; i < s; i++) {
            x = x.redSqr();
            if (x.cmp(rone) === 0)
              return false;
            if (x.cmp(rn1) === 0)
              break;
          }
          if (i === s)
            return false;
        }
        return prime;
      };
      MillerRabin.prototype.getDivisor = function getDivisor(n, k) {
        var len = n.bitLength();
        var red = bn.mont(n);
        var rone = new bn(1).toRed(red);
        if (!k)
          k = Math.max(1, len / 48 | 0);
        var n1 = n.subn(1);
        for (var s = 0; !n1.testn(s); s++) {
        }
        var d = n.shrn(s);
        var rn1 = n1.toRed(red);
        for (; k > 0; k--) {
          var a = this._randrange(new bn(2), n1);
          var g = n.gcd(a);
          if (g.cmpn(1) !== 0)
            return g;
          var x = a.toRed(red).redPow(d);
          if (x.cmp(rone) === 0 || x.cmp(rn1) === 0)
            continue;
          for (var i = 1; i < s; i++) {
            x = x.redSqr();
            if (x.cmp(rone) === 0)
              return x.fromRed().subn(1).gcd(n);
            if (x.cmp(rn1) === 0)
              break;
          }
          if (i === s) {
            x = x.redSqr();
            return x.fromRed().subn(1).gcd(n);
          }
        }
        return false;
      };
    }
  });

  // node_modules/diffie-hellman/lib/generatePrime.js
  var require_generatePrime = __commonJS({
    "node_modules/diffie-hellman/lib/generatePrime.js"(exports2, module2) {
      var randomBytes = require_browser();
      module2.exports = findPrime;
      findPrime.simpleSieve = simpleSieve;
      findPrime.fermatTest = fermatTest;
      var BN = require_bn2();
      var TWENTYFOUR = new BN(24);
      var MillerRabin = require_mr();
      var millerRabin = new MillerRabin();
      var ONE = new BN(1);
      var TWO = new BN(2);
      var FIVE = new BN(5);
      var SIXTEEN = new BN(16);
      var EIGHT = new BN(8);
      var TEN = new BN(10);
      var THREE = new BN(3);
      var SEVEN = new BN(7);
      var ELEVEN = new BN(11);
      var FOUR = new BN(4);
      var TWELVE = new BN(12);
      var primes = null;
      function _getPrimes() {
        if (primes !== null)
          return primes;
        var limit = 1048576;
        var res = [];
        res[0] = 2;
        for (var i = 1, k = 3; k < limit; k += 2) {
          var sqrt = Math.ceil(Math.sqrt(k));
          for (var j = 0; j < i && res[j] <= sqrt; j++)
            if (k % res[j] === 0)
              break;
          if (i !== j && res[j] <= sqrt)
            continue;
          res[i++] = k;
        }
        primes = res;
        return res;
      }
      function simpleSieve(p) {
        var primes2 = _getPrimes();
        for (var i = 0; i < primes2.length; i++)
          if (p.modn(primes2[i]) === 0) {
            if (p.cmpn(primes2[i]) === 0) {
              return true;
            } else {
              return false;
            }
          }
        return true;
      }
      function fermatTest(p) {
        var red = BN.mont(p);
        return TWO.toRed(red).redPow(p.subn(1)).fromRed().cmpn(1) === 0;
      }
      function findPrime(bits, gen) {
        if (bits < 16) {
          if (gen === 2 || gen === 5) {
            return new BN([140, 123]);
          } else {
            return new BN([140, 39]);
          }
        }
        gen = new BN(gen);
        var num, n2;
        while (true) {
          num = new BN(randomBytes(Math.ceil(bits / 8)));
          while (num.bitLength() > bits) {
            num.ishrn(1);
          }
          if (num.isEven()) {
            num.iadd(ONE);
          }
          if (!num.testn(1)) {
            num.iadd(TWO);
          }
          if (!gen.cmp(TWO)) {
            while (num.mod(TWENTYFOUR).cmp(ELEVEN)) {
              num.iadd(FOUR);
            }
          } else if (!gen.cmp(FIVE)) {
            while (num.mod(TEN).cmp(THREE)) {
              num.iadd(FOUR);
            }
          }
          n2 = num.shrn(1);
          if (simpleSieve(n2) && simpleSieve(num) && fermatTest(n2) && fermatTest(num) && millerRabin.test(n2) && millerRabin.test(num)) {
            return num;
          }
        }
      }
    }
  });

  // node_modules/diffie-hellman/lib/primes.json
  var require_primes = __commonJS({
    "node_modules/diffie-hellman/lib/primes.json"(exports2, module2) {
      module2.exports = {
        modp1: {
          gen: "02",
          prime: "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a63a3620ffffffffffffffff"
        },
        modp2: {
          gen: "02",
          prime: "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece65381ffffffffffffffff"
        },
        modp5: {
          gen: "02",
          prime: "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca237327ffffffffffffffff"
        },
        modp14: {
          gen: "02",
          prime: "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aacaa68ffffffffffffffff"
        },
        modp15: {
          gen: "02",
          prime: "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a93ad2caffffffffffffffff"
        },
        modp16: {
          gen: "02",
          prime: "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a92108011a723c12a787e6d788719a10bdba5b2699c327186af4e23c1a946834b6150bda2583e9ca2ad44ce8dbbbc2db04de8ef92e8efc141fbecaa6287c59474e6bc05d99b2964fa090c3a2233ba186515be7ed1f612970cee2d7afb81bdd762170481cd0069127d5b05aa993b4ea988d8fddc186ffb7dc90a6c08f4df435c934063199ffffffffffffffff"
        },
        modp17: {
          gen: "02",
          prime: "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a92108011a723c12a787e6d788719a10bdba5b2699c327186af4e23c1a946834b6150bda2583e9ca2ad44ce8dbbbc2db04de8ef92e8efc141fbecaa6287c59474e6bc05d99b2964fa090c3a2233ba186515be7ed1f612970cee2d7afb81bdd762170481cd0069127d5b05aa993b4ea988d8fddc186ffb7dc90a6c08f4df435c93402849236c3fab4d27c7026c1d4dcb2602646dec9751e763dba37bdf8ff9406ad9e530ee5db382f413001aeb06a53ed9027d831179727b0865a8918da3edbebcf9b14ed44ce6cbaced4bb1bdb7f1447e6cc254b332051512bd7af426fb8f401378cd2bf5983ca01c64b92ecf032ea15d1721d03f482d7ce6e74fef6d55e702f46980c82b5a84031900b1c9e59e7c97fbec7e8f323a97a7e36cc88be0f1d45b7ff585ac54bd407b22b4154aacc8f6d7ebf48e1d814cc5ed20f8037e0a79715eef29be32806a1d58bb7c5da76f550aa3d8a1fbff0eb19ccb1a313d55cda56c9ec2ef29632387fe8d76e3c0468043e8f663f4860ee12bf2d5b0b7474d6e694f91e6dcc4024ffffffffffffffff"
        },
        modp18: {
          gen: "02",
          prime: "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"
        }
      };
    }
  });

  // node_modules/diffie-hellman/lib/dh.js
  var require_dh = __commonJS({
    "node_modules/diffie-hellman/lib/dh.js"(exports2, module2) {
      var BN = require_bn2();
      var MillerRabin = require_mr();
      var millerRabin = new MillerRabin();
      var TWENTYFOUR = new BN(24);
      var ELEVEN = new BN(11);
      var TEN = new BN(10);
      var THREE = new BN(3);
      var SEVEN = new BN(7);
      var primes = require_generatePrime();
      var randomBytes = require_browser();
      module2.exports = DH;
      function setPublicKey(pub, enc) {
        enc = enc || "utf8";
        if (!Buffer.isBuffer(pub)) {
          pub = new Buffer(pub, enc);
        }
        this._pub = new BN(pub);
        return this;
      }
      function setPrivateKey(priv, enc) {
        enc = enc || "utf8";
        if (!Buffer.isBuffer(priv)) {
          priv = new Buffer(priv, enc);
        }
        this._priv = new BN(priv);
        return this;
      }
      var primeCache = {};
      function checkPrime(prime, generator) {
        var gen = generator.toString("hex");
        var hex = [gen, prime.toString(16)].join("_");
        if (hex in primeCache) {
          return primeCache[hex];
        }
        var error = 0;
        if (prime.isEven() || !primes.simpleSieve || !primes.fermatTest(prime) || !millerRabin.test(prime)) {
          error += 1;
          if (gen === "02" || gen === "05") {
            error += 8;
          } else {
            error += 4;
          }
          primeCache[hex] = error;
          return error;
        }
        if (!millerRabin.test(prime.shrn(1))) {
          error += 2;
        }
        var rem;
        switch (gen) {
          case "02":
            if (prime.mod(TWENTYFOUR).cmp(ELEVEN)) {
              error += 8;
            }
            break;
          case "05":
            rem = prime.mod(TEN);
            if (rem.cmp(THREE) && rem.cmp(SEVEN)) {
              error += 8;
            }
            break;
          default:
            error += 4;
        }
        primeCache[hex] = error;
        return error;
      }
      function DH(prime, generator, malleable) {
        this.setGenerator(generator);
        this.__prime = new BN(prime);
        this._prime = BN.mont(this.__prime);
        this._primeLen = prime.length;
        this._pub = void 0;
        this._priv = void 0;
        this._primeCode = void 0;
        if (malleable) {
          this.setPublicKey = setPublicKey;
          this.setPrivateKey = setPrivateKey;
        } else {
          this._primeCode = 8;
        }
      }
      Object.defineProperty(DH.prototype, "verifyError", {
        enumerable: true,
        get: function() {
          if (typeof this._primeCode !== "number") {
            this._primeCode = checkPrime(this.__prime, this.__gen);
          }
          return this._primeCode;
        }
      });
      DH.prototype.generateKeys = function() {
        if (!this._priv) {
          this._priv = new BN(randomBytes(this._primeLen));
        }
        this._pub = this._gen.toRed(this._prime).redPow(this._priv).fromRed();
        return this.getPublicKey();
      };
      DH.prototype.computeSecret = function(other) {
        other = new BN(other);
        other = other.toRed(this._prime);
        var secret = other.redPow(this._priv).fromRed();
        var out = new Buffer(secret.toArray());
        var prime = this.getPrime();
        if (out.length < prime.length) {
          var front = new Buffer(prime.length - out.length);
          front.fill(0);
          out = Buffer.concat([front, out]);
        }
        return out;
      };
      DH.prototype.getPublicKey = function getPublicKey(enc) {
        return formatReturnValue(this._pub, enc);
      };
      DH.prototype.getPrivateKey = function getPrivateKey(enc) {
        return formatReturnValue(this._priv, enc);
      };
      DH.prototype.getPrime = function(enc) {
        return formatReturnValue(this.__prime, enc);
      };
      DH.prototype.getGenerator = function(enc) {
        return formatReturnValue(this._gen, enc);
      };
      DH.prototype.setGenerator = function(gen, enc) {
        enc = enc || "utf8";
        if (!Buffer.isBuffer(gen)) {
          gen = new Buffer(gen, enc);
        }
        this.__gen = gen;
        this._gen = new BN(gen);
        return this;
      };
      function formatReturnValue(bn, enc) {
        var buf = new Buffer(bn.toArray());
        if (!enc) {
          return buf;
        } else {
          return buf.toString(enc);
        }
      }
    }
  });

  // node_modules/diffie-hellman/browser.js
  var require_browser8 = __commonJS({
    "node_modules/diffie-hellman/browser.js"(exports2) {
      var generatePrime = require_generatePrime();
      var primes = require_primes();
      var DH = require_dh();
      function getDiffieHellman(mod2) {
        var prime = new Buffer(primes[mod2].prime, "hex");
        var gen = new Buffer(primes[mod2].gen, "hex");
        return new DH(prime, gen);
      }
      var ENCODINGS = {
        "binary": true,
        "hex": true,
        "base64": true
      };
      function createDiffieHellman(prime, enc, generator, genc) {
        if (Buffer.isBuffer(enc) || ENCODINGS[enc] === void 0) {
          return createDiffieHellman(prime, "binary", enc, generator);
        }
        enc = enc || "binary";
        genc = genc || "binary";
        generator = generator || new Buffer([2]);
        if (!Buffer.isBuffer(generator)) {
          generator = new Buffer(generator, genc);
        }
        if (typeof prime === "number") {
          return new DH(generatePrime(prime, generator), generator, true);
        }
        if (!Buffer.isBuffer(prime)) {
          prime = new Buffer(prime, enc);
        }
        return new DH(prime, generator, true);
      }
      exports2.DiffieHellmanGroup = exports2.createDiffieHellmanGroup = exports2.getDiffieHellman = getDiffieHellman;
      exports2.createDiffieHellman = exports2.DiffieHellman = createDiffieHellman;
    }
  });

  // node_modules/browserify-rsa/node_modules/bn.js/lib/bn.js
  var require_bn3 = __commonJS({
    "node_modules/browserify-rsa/node_modules/bn.js/lib/bn.js"(exports2, module2) {
      (function(module3, exports3) {
        "use strict";
        function assert(val, msg) {
          if (!val)
            throw new Error(msg || "Assertion failed");
        }
        function inherits(ctor, superCtor) {
          ctor.super_ = superCtor;
          var TempCtor = function() {
          };
          TempCtor.prototype = superCtor.prototype;
          ctor.prototype = new TempCtor();
          ctor.prototype.constructor = ctor;
        }
        function BN(number, base, endian) {
          if (BN.isBN(number)) {
            return number;
          }
          this.negative = 0;
          this.words = null;
          this.length = 0;
          this.red = null;
          if (number !== null) {
            if (base === "le" || base === "be") {
              endian = base;
              base = 10;
            }
            this._init(number || 0, base || 10, endian || "be");
          }
        }
        if (typeof module3 === "object") {
          module3.exports = BN;
        } else {
          exports3.BN = BN;
        }
        BN.BN = BN;
        BN.wordSize = 26;
        var Buffer2;
        try {
          if (typeof window !== "undefined" && typeof window.Buffer !== "undefined") {
            Buffer2 = window.Buffer;
          } else {
            Buffer2 = require_buffer().Buffer;
          }
        } catch (e) {
        }
        BN.isBN = function isBN(num) {
          if (num instanceof BN) {
            return true;
          }
          return num !== null && typeof num === "object" && num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);
        };
        BN.max = function max(left, right) {
          if (left.cmp(right) > 0)
            return left;
          return right;
        };
        BN.min = function min(left, right) {
          if (left.cmp(right) < 0)
            return left;
          return right;
        };
        BN.prototype._init = function init(number, base, endian) {
          if (typeof number === "number") {
            return this._initNumber(number, base, endian);
          }
          if (typeof number === "object") {
            return this._initArray(number, base, endian);
          }
          if (base === "hex") {
            base = 16;
          }
          assert(base === (base | 0) && base >= 2 && base <= 36);
          number = number.toString().replace(/\s+/g, "");
          var start2 = 0;
          if (number[0] === "-") {
            start2++;
            this.negative = 1;
          }
          if (start2 < number.length) {
            if (base === 16) {
              this._parseHex(number, start2, endian);
            } else {
              this._parseBase(number, base, start2);
              if (endian === "le") {
                this._initArray(this.toArray(), base, endian);
              }
            }
          }
        };
        BN.prototype._initNumber = function _initNumber(number, base, endian) {
          if (number < 0) {
            this.negative = 1;
            number = -number;
          }
          if (number < 67108864) {
            this.words = [number & 67108863];
            this.length = 1;
          } else if (number < 4503599627370496) {
            this.words = [
              number & 67108863,
              number / 67108864 & 67108863
            ];
            this.length = 2;
          } else {
            assert(number < 9007199254740992);
            this.words = [
              number & 67108863,
              number / 67108864 & 67108863,
              1
            ];
            this.length = 3;
          }
          if (endian !== "le")
            return;
          this._initArray(this.toArray(), base, endian);
        };
        BN.prototype._initArray = function _initArray(number, base, endian) {
          assert(typeof number.length === "number");
          if (number.length <= 0) {
            this.words = [0];
            this.length = 1;
            return this;
          }
          this.length = Math.ceil(number.length / 3);
          this.words = new Array(this.length);
          for (var i = 0; i < this.length; i++) {
            this.words[i] = 0;
          }
          var j, w;
          var off = 0;
          if (endian === "be") {
            for (i = number.length - 1, j = 0; i >= 0; i -= 3) {
              w = number[i] | number[i - 1] << 8 | number[i - 2] << 16;
              this.words[j] |= w << off & 67108863;
              this.words[j + 1] = w >>> 26 - off & 67108863;
              off += 24;
              if (off >= 26) {
                off -= 26;
                j++;
              }
            }
          } else if (endian === "le") {
            for (i = 0, j = 0; i < number.length; i += 3) {
              w = number[i] | number[i + 1] << 8 | number[i + 2] << 16;
              this.words[j] |= w << off & 67108863;
              this.words[j + 1] = w >>> 26 - off & 67108863;
              off += 24;
              if (off >= 26) {
                off -= 26;
                j++;
              }
            }
          }
          return this._strip();
        };
        function parseHex4Bits(string, index) {
          var c = string.charCodeAt(index);
          if (c >= 48 && c <= 57) {
            return c - 48;
          } else if (c >= 65 && c <= 70) {
            return c - 55;
          } else if (c >= 97 && c <= 102) {
            return c - 87;
          } else {
            assert(false, "Invalid character in " + string);
          }
        }
        function parseHexByte(string, lowerBound, index) {
          var r = parseHex4Bits(string, index);
          if (index - 1 >= lowerBound) {
            r |= parseHex4Bits(string, index - 1) << 4;
          }
          return r;
        }
        BN.prototype._parseHex = function _parseHex(number, start2, endian) {
          this.length = Math.ceil((number.length - start2) / 6);
          this.words = new Array(this.length);
          for (var i = 0; i < this.length; i++) {
            this.words[i] = 0;
          }
          var off = 0;
          var j = 0;
          var w;
          if (endian === "be") {
            for (i = number.length - 1; i >= start2; i -= 2) {
              w = parseHexByte(number, start2, i) << off;
              this.words[j] |= w & 67108863;
              if (off >= 18) {
                off -= 18;
                j += 1;
                this.words[j] |= w >>> 26;
              } else {
                off += 8;
              }
            }
          } else {
            var parseLength = number.length - start2;
            for (i = parseLength % 2 === 0 ? start2 + 1 : start2; i < number.length; i += 2) {
              w = parseHexByte(number, start2, i) << off;
              this.words[j] |= w & 67108863;
              if (off >= 18) {
                off -= 18;
                j += 1;
                this.words[j] |= w >>> 26;
              } else {
                off += 8;
              }
            }
          }
          this._strip();
        };
        function parseBase(str, start2, end, mul) {
          var r = 0;
          var b = 0;
          var len = Math.min(str.length, end);
          for (var i = start2; i < len; i++) {
            var c = str.charCodeAt(i) - 48;
            r *= mul;
            if (c >= 49) {
              b = c - 49 + 10;
            } else if (c >= 17) {
              b = c - 17 + 10;
            } else {
              b = c;
            }
            assert(c >= 0 && b < mul, "Invalid character");
            r += b;
          }
          return r;
        }
        BN.prototype._parseBase = function _parseBase(number, base, start2) {
          this.words = [0];
          this.length = 1;
          for (var limbLen = 0, limbPow = 1; limbPow <= 67108863; limbPow *= base) {
            limbLen++;
          }
          limbLen--;
          limbPow = limbPow / base | 0;
          var total = number.length - start2;
          var mod2 = total % limbLen;
          var end = Math.min(total, total - mod2) + start2;
          var word = 0;
          for (var i = start2; i < end; i += limbLen) {
            word = parseBase(number, i, i + limbLen, base);
            this.imuln(limbPow);
            if (this.words[0] + word < 67108864) {
              this.words[0] += word;
            } else {
              this._iaddn(word);
            }
          }
          if (mod2 !== 0) {
            var pow = 1;
            word = parseBase(number, i, number.length, base);
            for (i = 0; i < mod2; i++) {
              pow *= base;
            }
            this.imuln(pow);
            if (this.words[0] + word < 67108864) {
              this.words[0] += word;
            } else {
              this._iaddn(word);
            }
          }
          this._strip();
        };
        BN.prototype.copy = function copy(dest) {
          dest.words = new Array(this.length);
          for (var i = 0; i < this.length; i++) {
            dest.words[i] = this.words[i];
          }
          dest.length = this.length;
          dest.negative = this.negative;
          dest.red = this.red;
        };
        function move(dest, src) {
          dest.words = src.words;
          dest.length = src.length;
          dest.negative = src.negative;
          dest.red = src.red;
        }
        BN.prototype._move = function _move(dest) {
          move(dest, this);
        };
        BN.prototype.clone = function clone() {
          var r = new BN(null);
          this.copy(r);
          return r;
        };
        BN.prototype._expand = function _expand(size) {
          while (this.length < size) {
            this.words[this.length++] = 0;
          }
          return this;
        };
        BN.prototype._strip = function strip() {
          while (this.length > 1 && this.words[this.length - 1] === 0) {
            this.length--;
          }
          return this._normSign();
        };
        BN.prototype._normSign = function _normSign() {
          if (this.length === 1 && this.words[0] === 0) {
            this.negative = 0;
          }
          return this;
        };
        if (typeof Symbol !== "undefined" && typeof Symbol.for === "function") {
          try {
            BN.prototype[Symbol.for("nodejs.util.inspect.custom")] = inspect;
          } catch (e) {
            BN.prototype.inspect = inspect;
          }
        } else {
          BN.prototype.inspect = inspect;
        }
        function inspect() {
          return (this.red ? "<BN-R: " : "<BN: ") + this.toString(16) + ">";
        }
        var zeros = [
          "",
          "0",
          "00",
          "000",
          "0000",
          "00000",
          "000000",
          "0000000",
          "00000000",
          "000000000",
          "0000000000",
          "00000000000",
          "000000000000",
          "0000000000000",
          "00000000000000",
          "000000000000000",
          "0000000000000000",
          "00000000000000000",
          "000000000000000000",
          "0000000000000000000",
          "00000000000000000000",
          "000000000000000000000",
          "0000000000000000000000",
          "00000000000000000000000",
          "000000000000000000000000",
          "0000000000000000000000000"
        ];
        var groupSizes = [
          0,
          0,
          25,
          16,
          12,
          11,
          10,
          9,
          8,
          8,
          7,
          7,
          7,
          7,
          6,
          6,
          6,
          6,
          6,
          6,
          6,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5
        ];
        var groupBases = [
          0,
          0,
          33554432,
          43046721,
          16777216,
          48828125,
          60466176,
          40353607,
          16777216,
          43046721,
          1e7,
          19487171,
          35831808,
          62748517,
          7529536,
          11390625,
          16777216,
          24137569,
          34012224,
          47045881,
          64e6,
          4084101,
          5153632,
          6436343,
          7962624,
          9765625,
          11881376,
          14348907,
          17210368,
          20511149,
          243e5,
          28629151,
          33554432,
          39135393,
          45435424,
          52521875,
          60466176
        ];
        BN.prototype.toString = function toString(base, padding) {
          base = base || 10;
          padding = padding | 0 || 1;
          var out;
          if (base === 16 || base === "hex") {
            out = "";
            var off = 0;
            var carry = 0;
            for (var i = 0; i < this.length; i++) {
              var w = this.words[i];
              var word = ((w << off | carry) & 16777215).toString(16);
              carry = w >>> 24 - off & 16777215;
              if (carry !== 0 || i !== this.length - 1) {
                out = zeros[6 - word.length] + word + out;
              } else {
                out = word + out;
              }
              off += 2;
              if (off >= 26) {
                off -= 26;
                i--;
              }
            }
            if (carry !== 0) {
              out = carry.toString(16) + out;
            }
            while (out.length % padding !== 0) {
              out = "0" + out;
            }
            if (this.negative !== 0) {
              out = "-" + out;
            }
            return out;
          }
          if (base === (base | 0) && base >= 2 && base <= 36) {
            var groupSize = groupSizes[base];
            var groupBase = groupBases[base];
            out = "";
            var c = this.clone();
            c.negative = 0;
            while (!c.isZero()) {
              var r = c.modrn(groupBase).toString(base);
              c = c.idivn(groupBase);
              if (!c.isZero()) {
                out = zeros[groupSize - r.length] + r + out;
              } else {
                out = r + out;
              }
            }
            if (this.isZero()) {
              out = "0" + out;
            }
            while (out.length % padding !== 0) {
              out = "0" + out;
            }
            if (this.negative !== 0) {
              out = "-" + out;
            }
            return out;
          }
          assert(false, "Base should be between 2 and 36");
        };
        BN.prototype.toNumber = function toNumber() {
          var ret = this.words[0];
          if (this.length === 2) {
            ret += this.words[1] * 67108864;
          } else if (this.length === 3 && this.words[2] === 1) {
            ret += 4503599627370496 + this.words[1] * 67108864;
          } else if (this.length > 2) {
            assert(false, "Number can only safely store up to 53 bits");
          }
          return this.negative !== 0 ? -ret : ret;
        };
        BN.prototype.toJSON = function toJSON() {
          return this.toString(16, 2);
        };
        if (Buffer2) {
          BN.prototype.toBuffer = function toBuffer(endian, length) {
            return this.toArrayLike(Buffer2, endian, length);
          };
        }
        BN.prototype.toArray = function toArray(endian, length) {
          return this.toArrayLike(Array, endian, length);
        };
        var allocate = function allocate2(ArrayType, size) {
          if (ArrayType.allocUnsafe) {
            return ArrayType.allocUnsafe(size);
          }
          return new ArrayType(size);
        };
        BN.prototype.toArrayLike = function toArrayLike(ArrayType, endian, length) {
          this._strip();
          var byteLength = this.byteLength();
          var reqLength = length || Math.max(1, byteLength);
          assert(byteLength <= reqLength, "byte array longer than desired length");
          assert(reqLength > 0, "Requested array length <= 0");
          var res = allocate(ArrayType, reqLength);
          var postfix = endian === "le" ? "LE" : "BE";
          this["_toArrayLike" + postfix](res, byteLength);
          return res;
        };
        BN.prototype._toArrayLikeLE = function _toArrayLikeLE(res, byteLength) {
          var position = 0;
          var carry = 0;
          for (var i = 0, shift = 0; i < this.length; i++) {
            var word = this.words[i] << shift | carry;
            res[position++] = word & 255;
            if (position < res.length) {
              res[position++] = word >> 8 & 255;
            }
            if (position < res.length) {
              res[position++] = word >> 16 & 255;
            }
            if (shift === 6) {
              if (position < res.length) {
                res[position++] = word >> 24 & 255;
              }
              carry = 0;
              shift = 0;
            } else {
              carry = word >>> 24;
              shift += 2;
            }
          }
          if (position < res.length) {
            res[position++] = carry;
            while (position < res.length) {
              res[position++] = 0;
            }
          }
        };
        BN.prototype._toArrayLikeBE = function _toArrayLikeBE(res, byteLength) {
          var position = res.length - 1;
          var carry = 0;
          for (var i = 0, shift = 0; i < this.length; i++) {
            var word = this.words[i] << shift | carry;
            res[position--] = word & 255;
            if (position >= 0) {
              res[position--] = word >> 8 & 255;
            }
            if (position >= 0) {
              res[position--] = word >> 16 & 255;
            }
            if (shift === 6) {
              if (position >= 0) {
                res[position--] = word >> 24 & 255;
              }
              carry = 0;
              shift = 0;
            } else {
              carry = word >>> 24;
              shift += 2;
            }
          }
          if (position >= 0) {
            res[position--] = carry;
            while (position >= 0) {
              res[position--] = 0;
            }
          }
        };
        if (Math.clz32) {
          BN.prototype._countBits = function _countBits(w) {
            return 32 - Math.clz32(w);
          };
        } else {
          BN.prototype._countBits = function _countBits(w) {
            var t = w;
            var r = 0;
            if (t >= 4096) {
              r += 13;
              t >>>= 13;
            }
            if (t >= 64) {
              r += 7;
              t >>>= 7;
            }
            if (t >= 8) {
              r += 4;
              t >>>= 4;
            }
            if (t >= 2) {
              r += 2;
              t >>>= 2;
            }
            return r + t;
          };
        }
        BN.prototype._zeroBits = function _zeroBits(w) {
          if (w === 0)
            return 26;
          var t = w;
          var r = 0;
          if ((t & 8191) === 0) {
            r += 13;
            t >>>= 13;
          }
          if ((t & 127) === 0) {
            r += 7;
            t >>>= 7;
          }
          if ((t & 15) === 0) {
            r += 4;
            t >>>= 4;
          }
          if ((t & 3) === 0) {
            r += 2;
            t >>>= 2;
          }
          if ((t & 1) === 0) {
            r++;
          }
          return r;
        };
        BN.prototype.bitLength = function bitLength() {
          var w = this.words[this.length - 1];
          var hi = this._countBits(w);
          return (this.length - 1) * 26 + hi;
        };
        function toBitArray(num) {
          var w = new Array(num.bitLength());
          for (var bit = 0; bit < w.length; bit++) {
            var off = bit / 26 | 0;
            var wbit = bit % 26;
            w[bit] = num.words[off] >>> wbit & 1;
          }
          return w;
        }
        BN.prototype.zeroBits = function zeroBits() {
          if (this.isZero())
            return 0;
          var r = 0;
          for (var i = 0; i < this.length; i++) {
            var b = this._zeroBits(this.words[i]);
            r += b;
            if (b !== 26)
              break;
          }
          return r;
        };
        BN.prototype.byteLength = function byteLength() {
          return Math.ceil(this.bitLength() / 8);
        };
        BN.prototype.toTwos = function toTwos(width) {
          if (this.negative !== 0) {
            return this.abs().inotn(width).iaddn(1);
          }
          return this.clone();
        };
        BN.prototype.fromTwos = function fromTwos(width) {
          if (this.testn(width - 1)) {
            return this.notn(width).iaddn(1).ineg();
          }
          return this.clone();
        };
        BN.prototype.isNeg = function isNeg() {
          return this.negative !== 0;
        };
        BN.prototype.neg = function neg() {
          return this.clone().ineg();
        };
        BN.prototype.ineg = function ineg() {
          if (!this.isZero()) {
            this.negative ^= 1;
          }
          return this;
        };
        BN.prototype.iuor = function iuor(num) {
          while (this.length < num.length) {
            this.words[this.length++] = 0;
          }
          for (var i = 0; i < num.length; i++) {
            this.words[i] = this.words[i] | num.words[i];
          }
          return this._strip();
        };
        BN.prototype.ior = function ior(num) {
          assert((this.negative | num.negative) === 0);
          return this.iuor(num);
        };
        BN.prototype.or = function or(num) {
          if (this.length > num.length)
            return this.clone().ior(num);
          return num.clone().ior(this);
        };
        BN.prototype.uor = function uor(num) {
          if (this.length > num.length)
            return this.clone().iuor(num);
          return num.clone().iuor(this);
        };
        BN.prototype.iuand = function iuand(num) {
          var b;
          if (this.length > num.length) {
            b = num;
          } else {
            b = this;
          }
          for (var i = 0; i < b.length; i++) {
            this.words[i] = this.words[i] & num.words[i];
          }
          this.length = b.length;
          return this._strip();
        };
        BN.prototype.iand = function iand(num) {
          assert((this.negative | num.negative) === 0);
          return this.iuand(num);
        };
        BN.prototype.and = function and(num) {
          if (this.length > num.length)
            return this.clone().iand(num);
          return num.clone().iand(this);
        };
        BN.prototype.uand = function uand(num) {
          if (this.length > num.length)
            return this.clone().iuand(num);
          return num.clone().iuand(this);
        };
        BN.prototype.iuxor = function iuxor(num) {
          var a;
          var b;
          if (this.length > num.length) {
            a = this;
            b = num;
          } else {
            a = num;
            b = this;
          }
          for (var i = 0; i < b.length; i++) {
            this.words[i] = a.words[i] ^ b.words[i];
          }
          if (this !== a) {
            for (; i < a.length; i++) {
              this.words[i] = a.words[i];
            }
          }
          this.length = a.length;
          return this._strip();
        };
        BN.prototype.ixor = function ixor(num) {
          assert((this.negative | num.negative) === 0);
          return this.iuxor(num);
        };
        BN.prototype.xor = function xor(num) {
          if (this.length > num.length)
            return this.clone().ixor(num);
          return num.clone().ixor(this);
        };
        BN.prototype.uxor = function uxor(num) {
          if (this.length > num.length)
            return this.clone().iuxor(num);
          return num.clone().iuxor(this);
        };
        BN.prototype.inotn = function inotn(width) {
          assert(typeof width === "number" && width >= 0);
          var bytesNeeded = Math.ceil(width / 26) | 0;
          var bitsLeft = width % 26;
          this._expand(bytesNeeded);
          if (bitsLeft > 0) {
            bytesNeeded--;
          }
          for (var i = 0; i < bytesNeeded; i++) {
            this.words[i] = ~this.words[i] & 67108863;
          }
          if (bitsLeft > 0) {
            this.words[i] = ~this.words[i] & 67108863 >> 26 - bitsLeft;
          }
          return this._strip();
        };
        BN.prototype.notn = function notn(width) {
          return this.clone().inotn(width);
        };
        BN.prototype.setn = function setn(bit, val) {
          assert(typeof bit === "number" && bit >= 0);
          var off = bit / 26 | 0;
          var wbit = bit % 26;
          this._expand(off + 1);
          if (val) {
            this.words[off] = this.words[off] | 1 << wbit;
          } else {
            this.words[off] = this.words[off] & ~(1 << wbit);
          }
          return this._strip();
        };
        BN.prototype.iadd = function iadd(num) {
          var r;
          if (this.negative !== 0 && num.negative === 0) {
            this.negative = 0;
            r = this.isub(num);
            this.negative ^= 1;
            return this._normSign();
          } else if (this.negative === 0 && num.negative !== 0) {
            num.negative = 0;
            r = this.isub(num);
            num.negative = 1;
            return r._normSign();
          }
          var a, b;
          if (this.length > num.length) {
            a = this;
            b = num;
          } else {
            a = num;
            b = this;
          }
          var carry = 0;
          for (var i = 0; i < b.length; i++) {
            r = (a.words[i] | 0) + (b.words[i] | 0) + carry;
            this.words[i] = r & 67108863;
            carry = r >>> 26;
          }
          for (; carry !== 0 && i < a.length; i++) {
            r = (a.words[i] | 0) + carry;
            this.words[i] = r & 67108863;
            carry = r >>> 26;
          }
          this.length = a.length;
          if (carry !== 0) {
            this.words[this.length] = carry;
            this.length++;
          } else if (a !== this) {
            for (; i < a.length; i++) {
              this.words[i] = a.words[i];
            }
          }
          return this;
        };
        BN.prototype.add = function add(num) {
          var res;
          if (num.negative !== 0 && this.negative === 0) {
            num.negative = 0;
            res = this.sub(num);
            num.negative ^= 1;
            return res;
          } else if (num.negative === 0 && this.negative !== 0) {
            this.negative = 0;
            res = num.sub(this);
            this.negative = 1;
            return res;
          }
          if (this.length > num.length)
            return this.clone().iadd(num);
          return num.clone().iadd(this);
        };
        BN.prototype.isub = function isub(num) {
          if (num.negative !== 0) {
            num.negative = 0;
            var r = this.iadd(num);
            num.negative = 1;
            return r._normSign();
          } else if (this.negative !== 0) {
            this.negative = 0;
            this.iadd(num);
            this.negative = 1;
            return this._normSign();
          }
          var cmp = this.cmp(num);
          if (cmp === 0) {
            this.negative = 0;
            this.length = 1;
            this.words[0] = 0;
            return this;
          }
          var a, b;
          if (cmp > 0) {
            a = this;
            b = num;
          } else {
            a = num;
            b = this;
          }
          var carry = 0;
          for (var i = 0; i < b.length; i++) {
            r = (a.words[i] | 0) - (b.words[i] | 0) + carry;
            carry = r >> 26;
            this.words[i] = r & 67108863;
          }
          for (; carry !== 0 && i < a.length; i++) {
            r = (a.words[i] | 0) + carry;
            carry = r >> 26;
            this.words[i] = r & 67108863;
          }
          if (carry === 0 && i < a.length && a !== this) {
            for (; i < a.length; i++) {
              this.words[i] = a.words[i];
            }
          }
          this.length = Math.max(this.length, i);
          if (a !== this) {
            this.negative = 1;
          }
          return this._strip();
        };
        BN.prototype.sub = function sub(num) {
          return this.clone().isub(num);
        };
        function smallMulTo(self2, num, out) {
          out.negative = num.negative ^ self2.negative;
          var len = self2.length + num.length | 0;
          out.length = len;
          len = len - 1 | 0;
          var a = self2.words[0] | 0;
          var b = num.words[0] | 0;
          var r = a * b;
          var lo = r & 67108863;
          var carry = r / 67108864 | 0;
          out.words[0] = lo;
          for (var k = 1; k < len; k++) {
            var ncarry = carry >>> 26;
            var rword = carry & 67108863;
            var maxJ = Math.min(k, num.length - 1);
            for (var j = Math.max(0, k - self2.length + 1); j <= maxJ; j++) {
              var i = k - j | 0;
              a = self2.words[i] | 0;
              b = num.words[j] | 0;
              r = a * b + rword;
              ncarry += r / 67108864 | 0;
              rword = r & 67108863;
            }
            out.words[k] = rword | 0;
            carry = ncarry | 0;
          }
          if (carry !== 0) {
            out.words[k] = carry | 0;
          } else {
            out.length--;
          }
          return out._strip();
        }
        var comb10MulTo = function comb10MulTo2(self2, num, out) {
          var a = self2.words;
          var b = num.words;
          var o = out.words;
          var c = 0;
          var lo;
          var mid;
          var hi;
          var a0 = a[0] | 0;
          var al0 = a0 & 8191;
          var ah0 = a0 >>> 13;
          var a1 = a[1] | 0;
          var al1 = a1 & 8191;
          var ah1 = a1 >>> 13;
          var a2 = a[2] | 0;
          var al2 = a2 & 8191;
          var ah2 = a2 >>> 13;
          var a3 = a[3] | 0;
          var al3 = a3 & 8191;
          var ah3 = a3 >>> 13;
          var a4 = a[4] | 0;
          var al4 = a4 & 8191;
          var ah4 = a4 >>> 13;
          var a5 = a[5] | 0;
          var al5 = a5 & 8191;
          var ah5 = a5 >>> 13;
          var a6 = a[6] | 0;
          var al6 = a6 & 8191;
          var ah6 = a6 >>> 13;
          var a7 = a[7] | 0;
          var al7 = a7 & 8191;
          var ah7 = a7 >>> 13;
          var a8 = a[8] | 0;
          var al8 = a8 & 8191;
          var ah8 = a8 >>> 13;
          var a9 = a[9] | 0;
          var al9 = a9 & 8191;
          var ah9 = a9 >>> 13;
          var b0 = b[0] | 0;
          var bl0 = b0 & 8191;
          var bh0 = b0 >>> 13;
          var b1 = b[1] | 0;
          var bl1 = b1 & 8191;
          var bh1 = b1 >>> 13;
          var b2 = b[2] | 0;
          var bl2 = b2 & 8191;
          var bh2 = b2 >>> 13;
          var b3 = b[3] | 0;
          var bl3 = b3 & 8191;
          var bh3 = b3 >>> 13;
          var b4 = b[4] | 0;
          var bl4 = b4 & 8191;
          var bh4 = b4 >>> 13;
          var b5 = b[5] | 0;
          var bl5 = b5 & 8191;
          var bh5 = b5 >>> 13;
          var b6 = b[6] | 0;
          var bl6 = b6 & 8191;
          var bh6 = b6 >>> 13;
          var b7 = b[7] | 0;
          var bl7 = b7 & 8191;
          var bh7 = b7 >>> 13;
          var b8 = b[8] | 0;
          var bl8 = b8 & 8191;
          var bh8 = b8 >>> 13;
          var b9 = b[9] | 0;
          var bl9 = b9 & 8191;
          var bh9 = b9 >>> 13;
          out.negative = self2.negative ^ num.negative;
          out.length = 19;
          lo = Math.imul(al0, bl0);
          mid = Math.imul(al0, bh0);
          mid = mid + Math.imul(ah0, bl0) | 0;
          hi = Math.imul(ah0, bh0);
          var w0 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w0 >>> 26) | 0;
          w0 &= 67108863;
          lo = Math.imul(al1, bl0);
          mid = Math.imul(al1, bh0);
          mid = mid + Math.imul(ah1, bl0) | 0;
          hi = Math.imul(ah1, bh0);
          lo = lo + Math.imul(al0, bl1) | 0;
          mid = mid + Math.imul(al0, bh1) | 0;
          mid = mid + Math.imul(ah0, bl1) | 0;
          hi = hi + Math.imul(ah0, bh1) | 0;
          var w1 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w1 >>> 26) | 0;
          w1 &= 67108863;
          lo = Math.imul(al2, bl0);
          mid = Math.imul(al2, bh0);
          mid = mid + Math.imul(ah2, bl0) | 0;
          hi = Math.imul(ah2, bh0);
          lo = lo + Math.imul(al1, bl1) | 0;
          mid = mid + Math.imul(al1, bh1) | 0;
          mid = mid + Math.imul(ah1, bl1) | 0;
          hi = hi + Math.imul(ah1, bh1) | 0;
          lo = lo + Math.imul(al0, bl2) | 0;
          mid = mid + Math.imul(al0, bh2) | 0;
          mid = mid + Math.imul(ah0, bl2) | 0;
          hi = hi + Math.imul(ah0, bh2) | 0;
          var w2 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w2 >>> 26) | 0;
          w2 &= 67108863;
          lo = Math.imul(al3, bl0);
          mid = Math.imul(al3, bh0);
          mid = mid + Math.imul(ah3, bl0) | 0;
          hi = Math.imul(ah3, bh0);
          lo = lo + Math.imul(al2, bl1) | 0;
          mid = mid + Math.imul(al2, bh1) | 0;
          mid = mid + Math.imul(ah2, bl1) | 0;
          hi = hi + Math.imul(ah2, bh1) | 0;
          lo = lo + Math.imul(al1, bl2) | 0;
          mid = mid + Math.imul(al1, bh2) | 0;
          mid = mid + Math.imul(ah1, bl2) | 0;
          hi = hi + Math.imul(ah1, bh2) | 0;
          lo = lo + Math.imul(al0, bl3) | 0;
          mid = mid + Math.imul(al0, bh3) | 0;
          mid = mid + Math.imul(ah0, bl3) | 0;
          hi = hi + Math.imul(ah0, bh3) | 0;
          var w3 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w3 >>> 26) | 0;
          w3 &= 67108863;
          lo = Math.imul(al4, bl0);
          mid = Math.imul(al4, bh0);
          mid = mid + Math.imul(ah4, bl0) | 0;
          hi = Math.imul(ah4, bh0);
          lo = lo + Math.imul(al3, bl1) | 0;
          mid = mid + Math.imul(al3, bh1) | 0;
          mid = mid + Math.imul(ah3, bl1) | 0;
          hi = hi + Math.imul(ah3, bh1) | 0;
          lo = lo + Math.imul(al2, bl2) | 0;
          mid = mid + Math.imul(al2, bh2) | 0;
          mid = mid + Math.imul(ah2, bl2) | 0;
          hi = hi + Math.imul(ah2, bh2) | 0;
          lo = lo + Math.imul(al1, bl3) | 0;
          mid = mid + Math.imul(al1, bh3) | 0;
          mid = mid + Math.imul(ah1, bl3) | 0;
          hi = hi + Math.imul(ah1, bh3) | 0;
          lo = lo + Math.imul(al0, bl4) | 0;
          mid = mid + Math.imul(al0, bh4) | 0;
          mid = mid + Math.imul(ah0, bl4) | 0;
          hi = hi + Math.imul(ah0, bh4) | 0;
          var w4 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w4 >>> 26) | 0;
          w4 &= 67108863;
          lo = Math.imul(al5, bl0);
          mid = Math.imul(al5, bh0);
          mid = mid + Math.imul(ah5, bl0) | 0;
          hi = Math.imul(ah5, bh0);
          lo = lo + Math.imul(al4, bl1) | 0;
          mid = mid + Math.imul(al4, bh1) | 0;
          mid = mid + Math.imul(ah4, bl1) | 0;
          hi = hi + Math.imul(ah4, bh1) | 0;
          lo = lo + Math.imul(al3, bl2) | 0;
          mid = mid + Math.imul(al3, bh2) | 0;
          mid = mid + Math.imul(ah3, bl2) | 0;
          hi = hi + Math.imul(ah3, bh2) | 0;
          lo = lo + Math.imul(al2, bl3) | 0;
          mid = mid + Math.imul(al2, bh3) | 0;
          mid = mid + Math.imul(ah2, bl3) | 0;
          hi = hi + Math.imul(ah2, bh3) | 0;
          lo = lo + Math.imul(al1, bl4) | 0;
          mid = mid + Math.imul(al1, bh4) | 0;
          mid = mid + Math.imul(ah1, bl4) | 0;
          hi = hi + Math.imul(ah1, bh4) | 0;
          lo = lo + Math.imul(al0, bl5) | 0;
          mid = mid + Math.imul(al0, bh5) | 0;
          mid = mid + Math.imul(ah0, bl5) | 0;
          hi = hi + Math.imul(ah0, bh5) | 0;
          var w5 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w5 >>> 26) | 0;
          w5 &= 67108863;
          lo = Math.imul(al6, bl0);
          mid = Math.imul(al6, bh0);
          mid = mid + Math.imul(ah6, bl0) | 0;
          hi = Math.imul(ah6, bh0);
          lo = lo + Math.imul(al5, bl1) | 0;
          mid = mid + Math.imul(al5, bh1) | 0;
          mid = mid + Math.imul(ah5, bl1) | 0;
          hi = hi + Math.imul(ah5, bh1) | 0;
          lo = lo + Math.imul(al4, bl2) | 0;
          mid = mid + Math.imul(al4, bh2) | 0;
          mid = mid + Math.imul(ah4, bl2) | 0;
          hi = hi + Math.imul(ah4, bh2) | 0;
          lo = lo + Math.imul(al3, bl3) | 0;
          mid = mid + Math.imul(al3, bh3) | 0;
          mid = mid + Math.imul(ah3, bl3) | 0;
          hi = hi + Math.imul(ah3, bh3) | 0;
          lo = lo + Math.imul(al2, bl4) | 0;
          mid = mid + Math.imul(al2, bh4) | 0;
          mid = mid + Math.imul(ah2, bl4) | 0;
          hi = hi + Math.imul(ah2, bh4) | 0;
          lo = lo + Math.imul(al1, bl5) | 0;
          mid = mid + Math.imul(al1, bh5) | 0;
          mid = mid + Math.imul(ah1, bl5) | 0;
          hi = hi + Math.imul(ah1, bh5) | 0;
          lo = lo + Math.imul(al0, bl6) | 0;
          mid = mid + Math.imul(al0, bh6) | 0;
          mid = mid + Math.imul(ah0, bl6) | 0;
          hi = hi + Math.imul(ah0, bh6) | 0;
          var w6 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w6 >>> 26) | 0;
          w6 &= 67108863;
          lo = Math.imul(al7, bl0);
          mid = Math.imul(al7, bh0);
          mid = mid + Math.imul(ah7, bl0) | 0;
          hi = Math.imul(ah7, bh0);
          lo = lo + Math.imul(al6, bl1) | 0;
          mid = mid + Math.imul(al6, bh1) | 0;
          mid = mid + Math.imul(ah6, bl1) | 0;
          hi = hi + Math.imul(ah6, bh1) | 0;
          lo = lo + Math.imul(al5, bl2) | 0;
          mid = mid + Math.imul(al5, bh2) | 0;
          mid = mid + Math.imul(ah5, bl2) | 0;
          hi = hi + Math.imul(ah5, bh2) | 0;
          lo = lo + Math.imul(al4, bl3) | 0;
          mid = mid + Math.imul(al4, bh3) | 0;
          mid = mid + Math.imul(ah4, bl3) | 0;
          hi = hi + Math.imul(ah4, bh3) | 0;
          lo = lo + Math.imul(al3, bl4) | 0;
          mid = mid + Math.imul(al3, bh4) | 0;
          mid = mid + Math.imul(ah3, bl4) | 0;
          hi = hi + Math.imul(ah3, bh4) | 0;
          lo = lo + Math.imul(al2, bl5) | 0;
          mid = mid + Math.imul(al2, bh5) | 0;
          mid = mid + Math.imul(ah2, bl5) | 0;
          hi = hi + Math.imul(ah2, bh5) | 0;
          lo = lo + Math.imul(al1, bl6) | 0;
          mid = mid + Math.imul(al1, bh6) | 0;
          mid = mid + Math.imul(ah1, bl6) | 0;
          hi = hi + Math.imul(ah1, bh6) | 0;
          lo = lo + Math.imul(al0, bl7) | 0;
          mid = mid + Math.imul(al0, bh7) | 0;
          mid = mid + Math.imul(ah0, bl7) | 0;
          hi = hi + Math.imul(ah0, bh7) | 0;
          var w7 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w7 >>> 26) | 0;
          w7 &= 67108863;
          lo = Math.imul(al8, bl0);
          mid = Math.imul(al8, bh0);
          mid = mid + Math.imul(ah8, bl0) | 0;
          hi = Math.imul(ah8, bh0);
          lo = lo + Math.imul(al7, bl1) | 0;
          mid = mid + Math.imul(al7, bh1) | 0;
          mid = mid + Math.imul(ah7, bl1) | 0;
          hi = hi + Math.imul(ah7, bh1) | 0;
          lo = lo + Math.imul(al6, bl2) | 0;
          mid = mid + Math.imul(al6, bh2) | 0;
          mid = mid + Math.imul(ah6, bl2) | 0;
          hi = hi + Math.imul(ah6, bh2) | 0;
          lo = lo + Math.imul(al5, bl3) | 0;
          mid = mid + Math.imul(al5, bh3) | 0;
          mid = mid + Math.imul(ah5, bl3) | 0;
          hi = hi + Math.imul(ah5, bh3) | 0;
          lo = lo + Math.imul(al4, bl4) | 0;
          mid = mid + Math.imul(al4, bh4) | 0;
          mid = mid + Math.imul(ah4, bl4) | 0;
          hi = hi + Math.imul(ah4, bh4) | 0;
          lo = lo + Math.imul(al3, bl5) | 0;
          mid = mid + Math.imul(al3, bh5) | 0;
          mid = mid + Math.imul(ah3, bl5) | 0;
          hi = hi + Math.imul(ah3, bh5) | 0;
          lo = lo + Math.imul(al2, bl6) | 0;
          mid = mid + Math.imul(al2, bh6) | 0;
          mid = mid + Math.imul(ah2, bl6) | 0;
          hi = hi + Math.imul(ah2, bh6) | 0;
          lo = lo + Math.imul(al1, bl7) | 0;
          mid = mid + Math.imul(al1, bh7) | 0;
          mid = mid + Math.imul(ah1, bl7) | 0;
          hi = hi + Math.imul(ah1, bh7) | 0;
          lo = lo + Math.imul(al0, bl8) | 0;
          mid = mid + Math.imul(al0, bh8) | 0;
          mid = mid + Math.imul(ah0, bl8) | 0;
          hi = hi + Math.imul(ah0, bh8) | 0;
          var w8 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w8 >>> 26) | 0;
          w8 &= 67108863;
          lo = Math.imul(al9, bl0);
          mid = Math.imul(al9, bh0);
          mid = mid + Math.imul(ah9, bl0) | 0;
          hi = Math.imul(ah9, bh0);
          lo = lo + Math.imul(al8, bl1) | 0;
          mid = mid + Math.imul(al8, bh1) | 0;
          mid = mid + Math.imul(ah8, bl1) | 0;
          hi = hi + Math.imul(ah8, bh1) | 0;
          lo = lo + Math.imul(al7, bl2) | 0;
          mid = mid + Math.imul(al7, bh2) | 0;
          mid = mid + Math.imul(ah7, bl2) | 0;
          hi = hi + Math.imul(ah7, bh2) | 0;
          lo = lo + Math.imul(al6, bl3) | 0;
          mid = mid + Math.imul(al6, bh3) | 0;
          mid = mid + Math.imul(ah6, bl3) | 0;
          hi = hi + Math.imul(ah6, bh3) | 0;
          lo = lo + Math.imul(al5, bl4) | 0;
          mid = mid + Math.imul(al5, bh4) | 0;
          mid = mid + Math.imul(ah5, bl4) | 0;
          hi = hi + Math.imul(ah5, bh4) | 0;
          lo = lo + Math.imul(al4, bl5) | 0;
          mid = mid + Math.imul(al4, bh5) | 0;
          mid = mid + Math.imul(ah4, bl5) | 0;
          hi = hi + Math.imul(ah4, bh5) | 0;
          lo = lo + Math.imul(al3, bl6) | 0;
          mid = mid + Math.imul(al3, bh6) | 0;
          mid = mid + Math.imul(ah3, bl6) | 0;
          hi = hi + Math.imul(ah3, bh6) | 0;
          lo = lo + Math.imul(al2, bl7) | 0;
          mid = mid + Math.imul(al2, bh7) | 0;
          mid = mid + Math.imul(ah2, bl7) | 0;
          hi = hi + Math.imul(ah2, bh7) | 0;
          lo = lo + Math.imul(al1, bl8) | 0;
          mid = mid + Math.imul(al1, bh8) | 0;
          mid = mid + Math.imul(ah1, bl8) | 0;
          hi = hi + Math.imul(ah1, bh8) | 0;
          lo = lo + Math.imul(al0, bl9) | 0;
          mid = mid + Math.imul(al0, bh9) | 0;
          mid = mid + Math.imul(ah0, bl9) | 0;
          hi = hi + Math.imul(ah0, bh9) | 0;
          var w9 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w9 >>> 26) | 0;
          w9 &= 67108863;
          lo = Math.imul(al9, bl1);
          mid = Math.imul(al9, bh1);
          mid = mid + Math.imul(ah9, bl1) | 0;
          hi = Math.imul(ah9, bh1);
          lo = lo + Math.imul(al8, bl2) | 0;
          mid = mid + Math.imul(al8, bh2) | 0;
          mid = mid + Math.imul(ah8, bl2) | 0;
          hi = hi + Math.imul(ah8, bh2) | 0;
          lo = lo + Math.imul(al7, bl3) | 0;
          mid = mid + Math.imul(al7, bh3) | 0;
          mid = mid + Math.imul(ah7, bl3) | 0;
          hi = hi + Math.imul(ah7, bh3) | 0;
          lo = lo + Math.imul(al6, bl4) | 0;
          mid = mid + Math.imul(al6, bh4) | 0;
          mid = mid + Math.imul(ah6, bl4) | 0;
          hi = hi + Math.imul(ah6, bh4) | 0;
          lo = lo + Math.imul(al5, bl5) | 0;
          mid = mid + Math.imul(al5, bh5) | 0;
          mid = mid + Math.imul(ah5, bl5) | 0;
          hi = hi + Math.imul(ah5, bh5) | 0;
          lo = lo + Math.imul(al4, bl6) | 0;
          mid = mid + Math.imul(al4, bh6) | 0;
          mid = mid + Math.imul(ah4, bl6) | 0;
          hi = hi + Math.imul(ah4, bh6) | 0;
          lo = lo + Math.imul(al3, bl7) | 0;
          mid = mid + Math.imul(al3, bh7) | 0;
          mid = mid + Math.imul(ah3, bl7) | 0;
          hi = hi + Math.imul(ah3, bh7) | 0;
          lo = lo + Math.imul(al2, bl8) | 0;
          mid = mid + Math.imul(al2, bh8) | 0;
          mid = mid + Math.imul(ah2, bl8) | 0;
          hi = hi + Math.imul(ah2, bh8) | 0;
          lo = lo + Math.imul(al1, bl9) | 0;
          mid = mid + Math.imul(al1, bh9) | 0;
          mid = mid + Math.imul(ah1, bl9) | 0;
          hi = hi + Math.imul(ah1, bh9) | 0;
          var w10 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w10 >>> 26) | 0;
          w10 &= 67108863;
          lo = Math.imul(al9, bl2);
          mid = Math.imul(al9, bh2);
          mid = mid + Math.imul(ah9, bl2) | 0;
          hi = Math.imul(ah9, bh2);
          lo = lo + Math.imul(al8, bl3) | 0;
          mid = mid + Math.imul(al8, bh3) | 0;
          mid = mid + Math.imul(ah8, bl3) | 0;
          hi = hi + Math.imul(ah8, bh3) | 0;
          lo = lo + Math.imul(al7, bl4) | 0;
          mid = mid + Math.imul(al7, bh4) | 0;
          mid = mid + Math.imul(ah7, bl4) | 0;
          hi = hi + Math.imul(ah7, bh4) | 0;
          lo = lo + Math.imul(al6, bl5) | 0;
          mid = mid + Math.imul(al6, bh5) | 0;
          mid = mid + Math.imul(ah6, bl5) | 0;
          hi = hi + Math.imul(ah6, bh5) | 0;
          lo = lo + Math.imul(al5, bl6) | 0;
          mid = mid + Math.imul(al5, bh6) | 0;
          mid = mid + Math.imul(ah5, bl6) | 0;
          hi = hi + Math.imul(ah5, bh6) | 0;
          lo = lo + Math.imul(al4, bl7) | 0;
          mid = mid + Math.imul(al4, bh7) | 0;
          mid = mid + Math.imul(ah4, bl7) | 0;
          hi = hi + Math.imul(ah4, bh7) | 0;
          lo = lo + Math.imul(al3, bl8) | 0;
          mid = mid + Math.imul(al3, bh8) | 0;
          mid = mid + Math.imul(ah3, bl8) | 0;
          hi = hi + Math.imul(ah3, bh8) | 0;
          lo = lo + Math.imul(al2, bl9) | 0;
          mid = mid + Math.imul(al2, bh9) | 0;
          mid = mid + Math.imul(ah2, bl9) | 0;
          hi = hi + Math.imul(ah2, bh9) | 0;
          var w11 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w11 >>> 26) | 0;
          w11 &= 67108863;
          lo = Math.imul(al9, bl3);
          mid = Math.imul(al9, bh3);
          mid = mid + Math.imul(ah9, bl3) | 0;
          hi = Math.imul(ah9, bh3);
          lo = lo + Math.imul(al8, bl4) | 0;
          mid = mid + Math.imul(al8, bh4) | 0;
          mid = mid + Math.imul(ah8, bl4) | 0;
          hi = hi + Math.imul(ah8, bh4) | 0;
          lo = lo + Math.imul(al7, bl5) | 0;
          mid = mid + Math.imul(al7, bh5) | 0;
          mid = mid + Math.imul(ah7, bl5) | 0;
          hi = hi + Math.imul(ah7, bh5) | 0;
          lo = lo + Math.imul(al6, bl6) | 0;
          mid = mid + Math.imul(al6, bh6) | 0;
          mid = mid + Math.imul(ah6, bl6) | 0;
          hi = hi + Math.imul(ah6, bh6) | 0;
          lo = lo + Math.imul(al5, bl7) | 0;
          mid = mid + Math.imul(al5, bh7) | 0;
          mid = mid + Math.imul(ah5, bl7) | 0;
          hi = hi + Math.imul(ah5, bh7) | 0;
          lo = lo + Math.imul(al4, bl8) | 0;
          mid = mid + Math.imul(al4, bh8) | 0;
          mid = mid + Math.imul(ah4, bl8) | 0;
          hi = hi + Math.imul(ah4, bh8) | 0;
          lo = lo + Math.imul(al3, bl9) | 0;
          mid = mid + Math.imul(al3, bh9) | 0;
          mid = mid + Math.imul(ah3, bl9) | 0;
          hi = hi + Math.imul(ah3, bh9) | 0;
          var w12 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w12 >>> 26) | 0;
          w12 &= 67108863;
          lo = Math.imul(al9, bl4);
          mid = Math.imul(al9, bh4);
          mid = mid + Math.imul(ah9, bl4) | 0;
          hi = Math.imul(ah9, bh4);
          lo = lo + Math.imul(al8, bl5) | 0;
          mid = mid + Math.imul(al8, bh5) | 0;
          mid = mid + Math.imul(ah8, bl5) | 0;
          hi = hi + Math.imul(ah8, bh5) | 0;
          lo = lo + Math.imul(al7, bl6) | 0;
          mid = mid + Math.imul(al7, bh6) | 0;
          mid = mid + Math.imul(ah7, bl6) | 0;
          hi = hi + Math.imul(ah7, bh6) | 0;
          lo = lo + Math.imul(al6, bl7) | 0;
          mid = mid + Math.imul(al6, bh7) | 0;
          mid = mid + Math.imul(ah6, bl7) | 0;
          hi = hi + Math.imul(ah6, bh7) | 0;
          lo = lo + Math.imul(al5, bl8) | 0;
          mid = mid + Math.imul(al5, bh8) | 0;
          mid = mid + Math.imul(ah5, bl8) | 0;
          hi = hi + Math.imul(ah5, bh8) | 0;
          lo = lo + Math.imul(al4, bl9) | 0;
          mid = mid + Math.imul(al4, bh9) | 0;
          mid = mid + Math.imul(ah4, bl9) | 0;
          hi = hi + Math.imul(ah4, bh9) | 0;
          var w13 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w13 >>> 26) | 0;
          w13 &= 67108863;
          lo = Math.imul(al9, bl5);
          mid = Math.imul(al9, bh5);
          mid = mid + Math.imul(ah9, bl5) | 0;
          hi = Math.imul(ah9, bh5);
          lo = lo + Math.imul(al8, bl6) | 0;
          mid = mid + Math.imul(al8, bh6) | 0;
          mid = mid + Math.imul(ah8, bl6) | 0;
          hi = hi + Math.imul(ah8, bh6) | 0;
          lo = lo + Math.imul(al7, bl7) | 0;
          mid = mid + Math.imul(al7, bh7) | 0;
          mid = mid + Math.imul(ah7, bl7) | 0;
          hi = hi + Math.imul(ah7, bh7) | 0;
          lo = lo + Math.imul(al6, bl8) | 0;
          mid = mid + Math.imul(al6, bh8) | 0;
          mid = mid + Math.imul(ah6, bl8) | 0;
          hi = hi + Math.imul(ah6, bh8) | 0;
          lo = lo + Math.imul(al5, bl9) | 0;
          mid = mid + Math.imul(al5, bh9) | 0;
          mid = mid + Math.imul(ah5, bl9) | 0;
          hi = hi + Math.imul(ah5, bh9) | 0;
          var w14 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w14 >>> 26) | 0;
          w14 &= 67108863;
          lo = Math.imul(al9, bl6);
          mid = Math.imul(al9, bh6);
          mid = mid + Math.imul(ah9, bl6) | 0;
          hi = Math.imul(ah9, bh6);
          lo = lo + Math.imul(al8, bl7) | 0;
          mid = mid + Math.imul(al8, bh7) | 0;
          mid = mid + Math.imul(ah8, bl7) | 0;
          hi = hi + Math.imul(ah8, bh7) | 0;
          lo = lo + Math.imul(al7, bl8) | 0;
          mid = mid + Math.imul(al7, bh8) | 0;
          mid = mid + Math.imul(ah7, bl8) | 0;
          hi = hi + Math.imul(ah7, bh8) | 0;
          lo = lo + Math.imul(al6, bl9) | 0;
          mid = mid + Math.imul(al6, bh9) | 0;
          mid = mid + Math.imul(ah6, bl9) | 0;
          hi = hi + Math.imul(ah6, bh9) | 0;
          var w15 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w15 >>> 26) | 0;
          w15 &= 67108863;
          lo = Math.imul(al9, bl7);
          mid = Math.imul(al9, bh7);
          mid = mid + Math.imul(ah9, bl7) | 0;
          hi = Math.imul(ah9, bh7);
          lo = lo + Math.imul(al8, bl8) | 0;
          mid = mid + Math.imul(al8, bh8) | 0;
          mid = mid + Math.imul(ah8, bl8) | 0;
          hi = hi + Math.imul(ah8, bh8) | 0;
          lo = lo + Math.imul(al7, bl9) | 0;
          mid = mid + Math.imul(al7, bh9) | 0;
          mid = mid + Math.imul(ah7, bl9) | 0;
          hi = hi + Math.imul(ah7, bh9) | 0;
          var w16 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w16 >>> 26) | 0;
          w16 &= 67108863;
          lo = Math.imul(al9, bl8);
          mid = Math.imul(al9, bh8);
          mid = mid + Math.imul(ah9, bl8) | 0;
          hi = Math.imul(ah9, bh8);
          lo = lo + Math.imul(al8, bl9) | 0;
          mid = mid + Math.imul(al8, bh9) | 0;
          mid = mid + Math.imul(ah8, bl9) | 0;
          hi = hi + Math.imul(ah8, bh9) | 0;
          var w17 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w17 >>> 26) | 0;
          w17 &= 67108863;
          lo = Math.imul(al9, bl9);
          mid = Math.imul(al9, bh9);
          mid = mid + Math.imul(ah9, bl9) | 0;
          hi = Math.imul(ah9, bh9);
          var w18 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w18 >>> 26) | 0;
          w18 &= 67108863;
          o[0] = w0;
          o[1] = w1;
          o[2] = w2;
          o[3] = w3;
          o[4] = w4;
          o[5] = w5;
          o[6] = w6;
          o[7] = w7;
          o[8] = w8;
          o[9] = w9;
          o[10] = w10;
          o[11] = w11;
          o[12] = w12;
          o[13] = w13;
          o[14] = w14;
          o[15] = w15;
          o[16] = w16;
          o[17] = w17;
          o[18] = w18;
          if (c !== 0) {
            o[19] = c;
            out.length++;
          }
          return out;
        };
        if (!Math.imul) {
          comb10MulTo = smallMulTo;
        }
        function bigMulTo(self2, num, out) {
          out.negative = num.negative ^ self2.negative;
          out.length = self2.length + num.length;
          var carry = 0;
          var hncarry = 0;
          for (var k = 0; k < out.length - 1; k++) {
            var ncarry = hncarry;
            hncarry = 0;
            var rword = carry & 67108863;
            var maxJ = Math.min(k, num.length - 1);
            for (var j = Math.max(0, k - self2.length + 1); j <= maxJ; j++) {
              var i = k - j;
              var a = self2.words[i] | 0;
              var b = num.words[j] | 0;
              var r = a * b;
              var lo = r & 67108863;
              ncarry = ncarry + (r / 67108864 | 0) | 0;
              lo = lo + rword | 0;
              rword = lo & 67108863;
              ncarry = ncarry + (lo >>> 26) | 0;
              hncarry += ncarry >>> 26;
              ncarry &= 67108863;
            }
            out.words[k] = rword;
            carry = ncarry;
            ncarry = hncarry;
          }
          if (carry !== 0) {
            out.words[k] = carry;
          } else {
            out.length--;
          }
          return out._strip();
        }
        function jumboMulTo(self2, num, out) {
          return bigMulTo(self2, num, out);
        }
        BN.prototype.mulTo = function mulTo(num, out) {
          var res;
          var len = this.length + num.length;
          if (this.length === 10 && num.length === 10) {
            res = comb10MulTo(this, num, out);
          } else if (len < 63) {
            res = smallMulTo(this, num, out);
          } else if (len < 1024) {
            res = bigMulTo(this, num, out);
          } else {
            res = jumboMulTo(this, num, out);
          }
          return res;
        };
        function FFTM(x, y) {
          this.x = x;
          this.y = y;
        }
        FFTM.prototype.makeRBT = function makeRBT(N) {
          var t = new Array(N);
          var l = BN.prototype._countBits(N) - 1;
          for (var i = 0; i < N; i++) {
            t[i] = this.revBin(i, l, N);
          }
          return t;
        };
        FFTM.prototype.revBin = function revBin(x, l, N) {
          if (x === 0 || x === N - 1)
            return x;
          var rb = 0;
          for (var i = 0; i < l; i++) {
            rb |= (x & 1) << l - i - 1;
            x >>= 1;
          }
          return rb;
        };
        FFTM.prototype.permute = function permute(rbt, rws, iws, rtws, itws, N) {
          for (var i = 0; i < N; i++) {
            rtws[i] = rws[rbt[i]];
            itws[i] = iws[rbt[i]];
          }
        };
        FFTM.prototype.transform = function transform(rws, iws, rtws, itws, N, rbt) {
          this.permute(rbt, rws, iws, rtws, itws, N);
          for (var s = 1; s < N; s <<= 1) {
            var l = s << 1;
            var rtwdf = Math.cos(2 * Math.PI / l);
            var itwdf = Math.sin(2 * Math.PI / l);
            for (var p = 0; p < N; p += l) {
              var rtwdf_ = rtwdf;
              var itwdf_ = itwdf;
              for (var j = 0; j < s; j++) {
                var re = rtws[p + j];
                var ie = itws[p + j];
                var ro = rtws[p + j + s];
                var io = itws[p + j + s];
                var rx = rtwdf_ * ro - itwdf_ * io;
                io = rtwdf_ * io + itwdf_ * ro;
                ro = rx;
                rtws[p + j] = re + ro;
                itws[p + j] = ie + io;
                rtws[p + j + s] = re - ro;
                itws[p + j + s] = ie - io;
                if (j !== l) {
                  rx = rtwdf * rtwdf_ - itwdf * itwdf_;
                  itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;
                  rtwdf_ = rx;
                }
              }
            }
          }
        };
        FFTM.prototype.guessLen13b = function guessLen13b(n, m) {
          var N = Math.max(m, n) | 1;
          var odd = N & 1;
          var i = 0;
          for (N = N / 2 | 0; N; N = N >>> 1) {
            i++;
          }
          return 1 << i + 1 + odd;
        };
        FFTM.prototype.conjugate = function conjugate(rws, iws, N) {
          if (N <= 1)
            return;
          for (var i = 0; i < N / 2; i++) {
            var t = rws[i];
            rws[i] = rws[N - i - 1];
            rws[N - i - 1] = t;
            t = iws[i];
            iws[i] = -iws[N - i - 1];
            iws[N - i - 1] = -t;
          }
        };
        FFTM.prototype.normalize13b = function normalize13b(ws, N) {
          var carry = 0;
          for (var i = 0; i < N / 2; i++) {
            var w = Math.round(ws[2 * i + 1] / N) * 8192 + Math.round(ws[2 * i] / N) + carry;
            ws[i] = w & 67108863;
            if (w < 67108864) {
              carry = 0;
            } else {
              carry = w / 67108864 | 0;
            }
          }
          return ws;
        };
        FFTM.prototype.convert13b = function convert13b(ws, len, rws, N) {
          var carry = 0;
          for (var i = 0; i < len; i++) {
            carry = carry + (ws[i] | 0);
            rws[2 * i] = carry & 8191;
            carry = carry >>> 13;
            rws[2 * i + 1] = carry & 8191;
            carry = carry >>> 13;
          }
          for (i = 2 * len; i < N; ++i) {
            rws[i] = 0;
          }
          assert(carry === 0);
          assert((carry & ~8191) === 0);
        };
        FFTM.prototype.stub = function stub(N) {
          var ph = new Array(N);
          for (var i = 0; i < N; i++) {
            ph[i] = 0;
          }
          return ph;
        };
        FFTM.prototype.mulp = function mulp(x, y, out) {
          var N = 2 * this.guessLen13b(x.length, y.length);
          var rbt = this.makeRBT(N);
          var _ = this.stub(N);
          var rws = new Array(N);
          var rwst = new Array(N);
          var iwst = new Array(N);
          var nrws = new Array(N);
          var nrwst = new Array(N);
          var niwst = new Array(N);
          var rmws = out.words;
          rmws.length = N;
          this.convert13b(x.words, x.length, rws, N);
          this.convert13b(y.words, y.length, nrws, N);
          this.transform(rws, _, rwst, iwst, N, rbt);
          this.transform(nrws, _, nrwst, niwst, N, rbt);
          for (var i = 0; i < N; i++) {
            var rx = rwst[i] * nrwst[i] - iwst[i] * niwst[i];
            iwst[i] = rwst[i] * niwst[i] + iwst[i] * nrwst[i];
            rwst[i] = rx;
          }
          this.conjugate(rwst, iwst, N);
          this.transform(rwst, iwst, rmws, _, N, rbt);
          this.conjugate(rmws, _, N);
          this.normalize13b(rmws, N);
          out.negative = x.negative ^ y.negative;
          out.length = x.length + y.length;
          return out._strip();
        };
        BN.prototype.mul = function mul(num) {
          var out = new BN(null);
          out.words = new Array(this.length + num.length);
          return this.mulTo(num, out);
        };
        BN.prototype.mulf = function mulf(num) {
          var out = new BN(null);
          out.words = new Array(this.length + num.length);
          return jumboMulTo(this, num, out);
        };
        BN.prototype.imul = function imul(num) {
          return this.clone().mulTo(num, this);
        };
        BN.prototype.imuln = function imuln(num) {
          var isNegNum = num < 0;
          if (isNegNum)
            num = -num;
          assert(typeof num === "number");
          assert(num < 67108864);
          var carry = 0;
          for (var i = 0; i < this.length; i++) {
            var w = (this.words[i] | 0) * num;
            var lo = (w & 67108863) + (carry & 67108863);
            carry >>= 26;
            carry += w / 67108864 | 0;
            carry += lo >>> 26;
            this.words[i] = lo & 67108863;
          }
          if (carry !== 0) {
            this.words[i] = carry;
            this.length++;
          }
          return isNegNum ? this.ineg() : this;
        };
        BN.prototype.muln = function muln(num) {
          return this.clone().imuln(num);
        };
        BN.prototype.sqr = function sqr() {
          return this.mul(this);
        };
        BN.prototype.isqr = function isqr() {
          return this.imul(this.clone());
        };
        BN.prototype.pow = function pow(num) {
          var w = toBitArray(num);
          if (w.length === 0)
            return new BN(1);
          var res = this;
          for (var i = 0; i < w.length; i++, res = res.sqr()) {
            if (w[i] !== 0)
              break;
          }
          if (++i < w.length) {
            for (var q = res.sqr(); i < w.length; i++, q = q.sqr()) {
              if (w[i] === 0)
                continue;
              res = res.mul(q);
            }
          }
          return res;
        };
        BN.prototype.iushln = function iushln(bits) {
          assert(typeof bits === "number" && bits >= 0);
          var r = bits % 26;
          var s = (bits - r) / 26;
          var carryMask = 67108863 >>> 26 - r << 26 - r;
          var i;
          if (r !== 0) {
            var carry = 0;
            for (i = 0; i < this.length; i++) {
              var newCarry = this.words[i] & carryMask;
              var c = (this.words[i] | 0) - newCarry << r;
              this.words[i] = c | carry;
              carry = newCarry >>> 26 - r;
            }
            if (carry) {
              this.words[i] = carry;
              this.length++;
            }
          }
          if (s !== 0) {
            for (i = this.length - 1; i >= 0; i--) {
              this.words[i + s] = this.words[i];
            }
            for (i = 0; i < s; i++) {
              this.words[i] = 0;
            }
            this.length += s;
          }
          return this._strip();
        };
        BN.prototype.ishln = function ishln(bits) {
          assert(this.negative === 0);
          return this.iushln(bits);
        };
        BN.prototype.iushrn = function iushrn(bits, hint, extended) {
          assert(typeof bits === "number" && bits >= 0);
          var h;
          if (hint) {
            h = (hint - hint % 26) / 26;
          } else {
            h = 0;
          }
          var r = bits % 26;
          var s = Math.min((bits - r) / 26, this.length);
          var mask = 67108863 ^ 67108863 >>> r << r;
          var maskedWords = extended;
          h -= s;
          h = Math.max(0, h);
          if (maskedWords) {
            for (var i = 0; i < s; i++) {
              maskedWords.words[i] = this.words[i];
            }
            maskedWords.length = s;
          }
          if (s === 0) {
          } else if (this.length > s) {
            this.length -= s;
            for (i = 0; i < this.length; i++) {
              this.words[i] = this.words[i + s];
            }
          } else {
            this.words[0] = 0;
            this.length = 1;
          }
          var carry = 0;
          for (i = this.length - 1; i >= 0 && (carry !== 0 || i >= h); i--) {
            var word = this.words[i] | 0;
            this.words[i] = carry << 26 - r | word >>> r;
            carry = word & mask;
          }
          if (maskedWords && carry !== 0) {
            maskedWords.words[maskedWords.length++] = carry;
          }
          if (this.length === 0) {
            this.words[0] = 0;
            this.length = 1;
          }
          return this._strip();
        };
        BN.prototype.ishrn = function ishrn(bits, hint, extended) {
          assert(this.negative === 0);
          return this.iushrn(bits, hint, extended);
        };
        BN.prototype.shln = function shln(bits) {
          return this.clone().ishln(bits);
        };
        BN.prototype.ushln = function ushln(bits) {
          return this.clone().iushln(bits);
        };
        BN.prototype.shrn = function shrn(bits) {
          return this.clone().ishrn(bits);
        };
        BN.prototype.ushrn = function ushrn(bits) {
          return this.clone().iushrn(bits);
        };
        BN.prototype.testn = function testn(bit) {
          assert(typeof bit === "number" && bit >= 0);
          var r = bit % 26;
          var s = (bit - r) / 26;
          var q = 1 << r;
          if (this.length <= s)
            return false;
          var w = this.words[s];
          return !!(w & q);
        };
        BN.prototype.imaskn = function imaskn(bits) {
          assert(typeof bits === "number" && bits >= 0);
          var r = bits % 26;
          var s = (bits - r) / 26;
          assert(this.negative === 0, "imaskn works only with positive numbers");
          if (this.length <= s) {
            return this;
          }
          if (r !== 0) {
            s++;
          }
          this.length = Math.min(s, this.length);
          if (r !== 0) {
            var mask = 67108863 ^ 67108863 >>> r << r;
            this.words[this.length - 1] &= mask;
          }
          return this._strip();
        };
        BN.prototype.maskn = function maskn(bits) {
          return this.clone().imaskn(bits);
        };
        BN.prototype.iaddn = function iaddn(num) {
          assert(typeof num === "number");
          assert(num < 67108864);
          if (num < 0)
            return this.isubn(-num);
          if (this.negative !== 0) {
            if (this.length === 1 && (this.words[0] | 0) <= num) {
              this.words[0] = num - (this.words[0] | 0);
              this.negative = 0;
              return this;
            }
            this.negative = 0;
            this.isubn(num);
            this.negative = 1;
            return this;
          }
          return this._iaddn(num);
        };
        BN.prototype._iaddn = function _iaddn(num) {
          this.words[0] += num;
          for (var i = 0; i < this.length && this.words[i] >= 67108864; i++) {
            this.words[i] -= 67108864;
            if (i === this.length - 1) {
              this.words[i + 1] = 1;
            } else {
              this.words[i + 1]++;
            }
          }
          this.length = Math.max(this.length, i + 1);
          return this;
        };
        BN.prototype.isubn = function isubn(num) {
          assert(typeof num === "number");
          assert(num < 67108864);
          if (num < 0)
            return this.iaddn(-num);
          if (this.negative !== 0) {
            this.negative = 0;
            this.iaddn(num);
            this.negative = 1;
            return this;
          }
          this.words[0] -= num;
          if (this.length === 1 && this.words[0] < 0) {
            this.words[0] = -this.words[0];
            this.negative = 1;
          } else {
            for (var i = 0; i < this.length && this.words[i] < 0; i++) {
              this.words[i] += 67108864;
              this.words[i + 1] -= 1;
            }
          }
          return this._strip();
        };
        BN.prototype.addn = function addn(num) {
          return this.clone().iaddn(num);
        };
        BN.prototype.subn = function subn(num) {
          return this.clone().isubn(num);
        };
        BN.prototype.iabs = function iabs() {
          this.negative = 0;
          return this;
        };
        BN.prototype.abs = function abs() {
          return this.clone().iabs();
        };
        BN.prototype._ishlnsubmul = function _ishlnsubmul(num, mul, shift) {
          var len = num.length + shift;
          var i;
          this._expand(len);
          var w;
          var carry = 0;
          for (i = 0; i < num.length; i++) {
            w = (this.words[i + shift] | 0) + carry;
            var right = (num.words[i] | 0) * mul;
            w -= right & 67108863;
            carry = (w >> 26) - (right / 67108864 | 0);
            this.words[i + shift] = w & 67108863;
          }
          for (; i < this.length - shift; i++) {
            w = (this.words[i + shift] | 0) + carry;
            carry = w >> 26;
            this.words[i + shift] = w & 67108863;
          }
          if (carry === 0)
            return this._strip();
          assert(carry === -1);
          carry = 0;
          for (i = 0; i < this.length; i++) {
            w = -(this.words[i] | 0) + carry;
            carry = w >> 26;
            this.words[i] = w & 67108863;
          }
          this.negative = 1;
          return this._strip();
        };
        BN.prototype._wordDiv = function _wordDiv(num, mode) {
          var shift = this.length - num.length;
          var a = this.clone();
          var b = num;
          var bhi = b.words[b.length - 1] | 0;
          var bhiBits = this._countBits(bhi);
          shift = 26 - bhiBits;
          if (shift !== 0) {
            b = b.ushln(shift);
            a.iushln(shift);
            bhi = b.words[b.length - 1] | 0;
          }
          var m = a.length - b.length;
          var q;
          if (mode !== "mod") {
            q = new BN(null);
            q.length = m + 1;
            q.words = new Array(q.length);
            for (var i = 0; i < q.length; i++) {
              q.words[i] = 0;
            }
          }
          var diff = a.clone()._ishlnsubmul(b, 1, m);
          if (diff.negative === 0) {
            a = diff;
            if (q) {
              q.words[m] = 1;
            }
          }
          for (var j = m - 1; j >= 0; j--) {
            var qj = (a.words[b.length + j] | 0) * 67108864 + (a.words[b.length + j - 1] | 0);
            qj = Math.min(qj / bhi | 0, 67108863);
            a._ishlnsubmul(b, qj, j);
            while (a.negative !== 0) {
              qj--;
              a.negative = 0;
              a._ishlnsubmul(b, 1, j);
              if (!a.isZero()) {
                a.negative ^= 1;
              }
            }
            if (q) {
              q.words[j] = qj;
            }
          }
          if (q) {
            q._strip();
          }
          a._strip();
          if (mode !== "div" && shift !== 0) {
            a.iushrn(shift);
          }
          return {
            div: q || null,
            mod: a
          };
        };
        BN.prototype.divmod = function divmod(num, mode, positive) {
          assert(!num.isZero());
          if (this.isZero()) {
            return {
              div: new BN(0),
              mod: new BN(0)
            };
          }
          var div, mod2, res;
          if (this.negative !== 0 && num.negative === 0) {
            res = this.neg().divmod(num, mode);
            if (mode !== "mod") {
              div = res.div.neg();
            }
            if (mode !== "div") {
              mod2 = res.mod.neg();
              if (positive && mod2.negative !== 0) {
                mod2.iadd(num);
              }
            }
            return {
              div,
              mod: mod2
            };
          }
          if (this.negative === 0 && num.negative !== 0) {
            res = this.divmod(num.neg(), mode);
            if (mode !== "mod") {
              div = res.div.neg();
            }
            return {
              div,
              mod: res.mod
            };
          }
          if ((this.negative & num.negative) !== 0) {
            res = this.neg().divmod(num.neg(), mode);
            if (mode !== "div") {
              mod2 = res.mod.neg();
              if (positive && mod2.negative !== 0) {
                mod2.isub(num);
              }
            }
            return {
              div: res.div,
              mod: mod2
            };
          }
          if (num.length > this.length || this.cmp(num) < 0) {
            return {
              div: new BN(0),
              mod: this
            };
          }
          if (num.length === 1) {
            if (mode === "div") {
              return {
                div: this.divn(num.words[0]),
                mod: null
              };
            }
            if (mode === "mod") {
              return {
                div: null,
                mod: new BN(this.modrn(num.words[0]))
              };
            }
            return {
              div: this.divn(num.words[0]),
              mod: new BN(this.modrn(num.words[0]))
            };
          }
          return this._wordDiv(num, mode);
        };
        BN.prototype.div = function div(num) {
          return this.divmod(num, "div", false).div;
        };
        BN.prototype.mod = function mod2(num) {
          return this.divmod(num, "mod", false).mod;
        };
        BN.prototype.umod = function umod(num) {
          return this.divmod(num, "mod", true).mod;
        };
        BN.prototype.divRound = function divRound(num) {
          var dm = this.divmod(num);
          if (dm.mod.isZero())
            return dm.div;
          var mod2 = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;
          var half = num.ushrn(1);
          var r2 = num.andln(1);
          var cmp = mod2.cmp(half);
          if (cmp < 0 || r2 === 1 && cmp === 0)
            return dm.div;
          return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
        };
        BN.prototype.modrn = function modrn(num) {
          var isNegNum = num < 0;
          if (isNegNum)
            num = -num;
          assert(num <= 67108863);
          var p = (1 << 26) % num;
          var acc = 0;
          for (var i = this.length - 1; i >= 0; i--) {
            acc = (p * acc + (this.words[i] | 0)) % num;
          }
          return isNegNum ? -acc : acc;
        };
        BN.prototype.modn = function modn(num) {
          return this.modrn(num);
        };
        BN.prototype.idivn = function idivn(num) {
          var isNegNum = num < 0;
          if (isNegNum)
            num = -num;
          assert(num <= 67108863);
          var carry = 0;
          for (var i = this.length - 1; i >= 0; i--) {
            var w = (this.words[i] | 0) + carry * 67108864;
            this.words[i] = w / num | 0;
            carry = w % num;
          }
          this._strip();
          return isNegNum ? this.ineg() : this;
        };
        BN.prototype.divn = function divn(num) {
          return this.clone().idivn(num);
        };
        BN.prototype.egcd = function egcd(p) {
          assert(p.negative === 0);
          assert(!p.isZero());
          var x = this;
          var y = p.clone();
          if (x.negative !== 0) {
            x = x.umod(p);
          } else {
            x = x.clone();
          }
          var A = new BN(1);
          var B = new BN(0);
          var C = new BN(0);
          var D = new BN(1);
          var g = 0;
          while (x.isEven() && y.isEven()) {
            x.iushrn(1);
            y.iushrn(1);
            ++g;
          }
          var yp = y.clone();
          var xp = x.clone();
          while (!x.isZero()) {
            for (var i = 0, im = 1; (x.words[0] & im) === 0 && i < 26; ++i, im <<= 1)
              ;
            if (i > 0) {
              x.iushrn(i);
              while (i-- > 0) {
                if (A.isOdd() || B.isOdd()) {
                  A.iadd(yp);
                  B.isub(xp);
                }
                A.iushrn(1);
                B.iushrn(1);
              }
            }
            for (var j = 0, jm = 1; (y.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1)
              ;
            if (j > 0) {
              y.iushrn(j);
              while (j-- > 0) {
                if (C.isOdd() || D.isOdd()) {
                  C.iadd(yp);
                  D.isub(xp);
                }
                C.iushrn(1);
                D.iushrn(1);
              }
            }
            if (x.cmp(y) >= 0) {
              x.isub(y);
              A.isub(C);
              B.isub(D);
            } else {
              y.isub(x);
              C.isub(A);
              D.isub(B);
            }
          }
          return {
            a: C,
            b: D,
            gcd: y.iushln(g)
          };
        };
        BN.prototype._invmp = function _invmp(p) {
          assert(p.negative === 0);
          assert(!p.isZero());
          var a = this;
          var b = p.clone();
          if (a.negative !== 0) {
            a = a.umod(p);
          } else {
            a = a.clone();
          }
          var x1 = new BN(1);
          var x2 = new BN(0);
          var delta = b.clone();
          while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {
            for (var i = 0, im = 1; (a.words[0] & im) === 0 && i < 26; ++i, im <<= 1)
              ;
            if (i > 0) {
              a.iushrn(i);
              while (i-- > 0) {
                if (x1.isOdd()) {
                  x1.iadd(delta);
                }
                x1.iushrn(1);
              }
            }
            for (var j = 0, jm = 1; (b.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1)
              ;
            if (j > 0) {
              b.iushrn(j);
              while (j-- > 0) {
                if (x2.isOdd()) {
                  x2.iadd(delta);
                }
                x2.iushrn(1);
              }
            }
            if (a.cmp(b) >= 0) {
              a.isub(b);
              x1.isub(x2);
            } else {
              b.isub(a);
              x2.isub(x1);
            }
          }
          var res;
          if (a.cmpn(1) === 0) {
            res = x1;
          } else {
            res = x2;
          }
          if (res.cmpn(0) < 0) {
            res.iadd(p);
          }
          return res;
        };
        BN.prototype.gcd = function gcd(num) {
          if (this.isZero())
            return num.abs();
          if (num.isZero())
            return this.abs();
          var a = this.clone();
          var b = num.clone();
          a.negative = 0;
          b.negative = 0;
          for (var shift = 0; a.isEven() && b.isEven(); shift++) {
            a.iushrn(1);
            b.iushrn(1);
          }
          do {
            while (a.isEven()) {
              a.iushrn(1);
            }
            while (b.isEven()) {
              b.iushrn(1);
            }
            var r = a.cmp(b);
            if (r < 0) {
              var t = a;
              a = b;
              b = t;
            } else if (r === 0 || b.cmpn(1) === 0) {
              break;
            }
            a.isub(b);
          } while (true);
          return b.iushln(shift);
        };
        BN.prototype.invm = function invm(num) {
          return this.egcd(num).a.umod(num);
        };
        BN.prototype.isEven = function isEven() {
          return (this.words[0] & 1) === 0;
        };
        BN.prototype.isOdd = function isOdd() {
          return (this.words[0] & 1) === 1;
        };
        BN.prototype.andln = function andln(num) {
          return this.words[0] & num;
        };
        BN.prototype.bincn = function bincn(bit) {
          assert(typeof bit === "number");
          var r = bit % 26;
          var s = (bit - r) / 26;
          var q = 1 << r;
          if (this.length <= s) {
            this._expand(s + 1);
            this.words[s] |= q;
            return this;
          }
          var carry = q;
          for (var i = s; carry !== 0 && i < this.length; i++) {
            var w = this.words[i] | 0;
            w += carry;
            carry = w >>> 26;
            w &= 67108863;
            this.words[i] = w;
          }
          if (carry !== 0) {
            this.words[i] = carry;
            this.length++;
          }
          return this;
        };
        BN.prototype.isZero = function isZero() {
          return this.length === 1 && this.words[0] === 0;
        };
        BN.prototype.cmpn = function cmpn(num) {
          var negative = num < 0;
          if (this.negative !== 0 && !negative)
            return -1;
          if (this.negative === 0 && negative)
            return 1;
          this._strip();
          var res;
          if (this.length > 1) {
            res = 1;
          } else {
            if (negative) {
              num = -num;
            }
            assert(num <= 67108863, "Number is too big");
            var w = this.words[0] | 0;
            res = w === num ? 0 : w < num ? -1 : 1;
          }
          if (this.negative !== 0)
            return -res | 0;
          return res;
        };
        BN.prototype.cmp = function cmp(num) {
          if (this.negative !== 0 && num.negative === 0)
            return -1;
          if (this.negative === 0 && num.negative !== 0)
            return 1;
          var res = this.ucmp(num);
          if (this.negative !== 0)
            return -res | 0;
          return res;
        };
        BN.prototype.ucmp = function ucmp(num) {
          if (this.length > num.length)
            return 1;
          if (this.length < num.length)
            return -1;
          var res = 0;
          for (var i = this.length - 1; i >= 0; i--) {
            var a = this.words[i] | 0;
            var b = num.words[i] | 0;
            if (a === b)
              continue;
            if (a < b) {
              res = -1;
            } else if (a > b) {
              res = 1;
            }
            break;
          }
          return res;
        };
        BN.prototype.gtn = function gtn(num) {
          return this.cmpn(num) === 1;
        };
        BN.prototype.gt = function gt(num) {
          return this.cmp(num) === 1;
        };
        BN.prototype.gten = function gten(num) {
          return this.cmpn(num) >= 0;
        };
        BN.prototype.gte = function gte(num) {
          return this.cmp(num) >= 0;
        };
        BN.prototype.ltn = function ltn(num) {
          return this.cmpn(num) === -1;
        };
        BN.prototype.lt = function lt(num) {
          return this.cmp(num) === -1;
        };
        BN.prototype.lten = function lten(num) {
          return this.cmpn(num) <= 0;
        };
        BN.prototype.lte = function lte(num) {
          return this.cmp(num) <= 0;
        };
        BN.prototype.eqn = function eqn(num) {
          return this.cmpn(num) === 0;
        };
        BN.prototype.eq = function eq(num) {
          return this.cmp(num) === 0;
        };
        BN.red = function red(num) {
          return new Red(num);
        };
        BN.prototype.toRed = function toRed(ctx) {
          assert(!this.red, "Already a number in reduction context");
          assert(this.negative === 0, "red works only with positives");
          return ctx.convertTo(this)._forceRed(ctx);
        };
        BN.prototype.fromRed = function fromRed() {
          assert(this.red, "fromRed works only with numbers in reduction context");
          return this.red.convertFrom(this);
        };
        BN.prototype._forceRed = function _forceRed(ctx) {
          this.red = ctx;
          return this;
        };
        BN.prototype.forceRed = function forceRed(ctx) {
          assert(!this.red, "Already a number in reduction context");
          return this._forceRed(ctx);
        };
        BN.prototype.redAdd = function redAdd(num) {
          assert(this.red, "redAdd works only with red numbers");
          return this.red.add(this, num);
        };
        BN.prototype.redIAdd = function redIAdd(num) {
          assert(this.red, "redIAdd works only with red numbers");
          return this.red.iadd(this, num);
        };
        BN.prototype.redSub = function redSub(num) {
          assert(this.red, "redSub works only with red numbers");
          return this.red.sub(this, num);
        };
        BN.prototype.redISub = function redISub(num) {
          assert(this.red, "redISub works only with red numbers");
          return this.red.isub(this, num);
        };
        BN.prototype.redShl = function redShl(num) {
          assert(this.red, "redShl works only with red numbers");
          return this.red.shl(this, num);
        };
        BN.prototype.redMul = function redMul(num) {
          assert(this.red, "redMul works only with red numbers");
          this.red._verify2(this, num);
          return this.red.mul(this, num);
        };
        BN.prototype.redIMul = function redIMul(num) {
          assert(this.red, "redMul works only with red numbers");
          this.red._verify2(this, num);
          return this.red.imul(this, num);
        };
        BN.prototype.redSqr = function redSqr() {
          assert(this.red, "redSqr works only with red numbers");
          this.red._verify1(this);
          return this.red.sqr(this);
        };
        BN.prototype.redISqr = function redISqr() {
          assert(this.red, "redISqr works only with red numbers");
          this.red._verify1(this);
          return this.red.isqr(this);
        };
        BN.prototype.redSqrt = function redSqrt() {
          assert(this.red, "redSqrt works only with red numbers");
          this.red._verify1(this);
          return this.red.sqrt(this);
        };
        BN.prototype.redInvm = function redInvm() {
          assert(this.red, "redInvm works only with red numbers");
          this.red._verify1(this);
          return this.red.invm(this);
        };
        BN.prototype.redNeg = function redNeg() {
          assert(this.red, "redNeg works only with red numbers");
          this.red._verify1(this);
          return this.red.neg(this);
        };
        BN.prototype.redPow = function redPow(num) {
          assert(this.red && !num.red, "redPow(normalNum)");
          this.red._verify1(this);
          return this.red.pow(this, num);
        };
        var primes = {
          k256: null,
          p224: null,
          p192: null,
          p25519: null
        };
        function MPrime(name, p) {
          this.name = name;
          this.p = new BN(p, 16);
          this.n = this.p.bitLength();
          this.k = new BN(1).iushln(this.n).isub(this.p);
          this.tmp = this._tmp();
        }
        MPrime.prototype._tmp = function _tmp() {
          var tmp = new BN(null);
          tmp.words = new Array(Math.ceil(this.n / 13));
          return tmp;
        };
        MPrime.prototype.ireduce = function ireduce(num) {
          var r = num;
          var rlen;
          do {
            this.split(r, this.tmp);
            r = this.imulK(r);
            r = r.iadd(this.tmp);
            rlen = r.bitLength();
          } while (rlen > this.n);
          var cmp = rlen < this.n ? -1 : r.ucmp(this.p);
          if (cmp === 0) {
            r.words[0] = 0;
            r.length = 1;
          } else if (cmp > 0) {
            r.isub(this.p);
          } else {
            if (r.strip !== void 0) {
              r.strip();
            } else {
              r._strip();
            }
          }
          return r;
        };
        MPrime.prototype.split = function split(input, out) {
          input.iushrn(this.n, 0, out);
        };
        MPrime.prototype.imulK = function imulK(num) {
          return num.imul(this.k);
        };
        function K256() {
          MPrime.call(this, "k256", "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f");
        }
        inherits(K256, MPrime);
        K256.prototype.split = function split(input, output) {
          var mask = 4194303;
          var outLen = Math.min(input.length, 9);
          for (var i = 0; i < outLen; i++) {
            output.words[i] = input.words[i];
          }
          output.length = outLen;
          if (input.length <= 9) {
            input.words[0] = 0;
            input.length = 1;
            return;
          }
          var prev = input.words[9];
          output.words[output.length++] = prev & mask;
          for (i = 10; i < input.length; i++) {
            var next = input.words[i] | 0;
            input.words[i - 10] = (next & mask) << 4 | prev >>> 22;
            prev = next;
          }
          prev >>>= 22;
          input.words[i - 10] = prev;
          if (prev === 0 && input.length > 10) {
            input.length -= 10;
          } else {
            input.length -= 9;
          }
        };
        K256.prototype.imulK = function imulK(num) {
          num.words[num.length] = 0;
          num.words[num.length + 1] = 0;
          num.length += 2;
          var lo = 0;
          for (var i = 0; i < num.length; i++) {
            var w = num.words[i] | 0;
            lo += w * 977;
            num.words[i] = lo & 67108863;
            lo = w * 64 + (lo / 67108864 | 0);
          }
          if (num.words[num.length - 1] === 0) {
            num.length--;
            if (num.words[num.length - 1] === 0) {
              num.length--;
            }
          }
          return num;
        };
        function P224() {
          MPrime.call(this, "p224", "ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001");
        }
        inherits(P224, MPrime);
        function P192() {
          MPrime.call(this, "p192", "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff");
        }
        inherits(P192, MPrime);
        function P25519() {
          MPrime.call(this, "25519", "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed");
        }
        inherits(P25519, MPrime);
        P25519.prototype.imulK = function imulK(num) {
          var carry = 0;
          for (var i = 0; i < num.length; i++) {
            var hi = (num.words[i] | 0) * 19 + carry;
            var lo = hi & 67108863;
            hi >>>= 26;
            num.words[i] = lo;
            carry = hi;
          }
          if (carry !== 0) {
            num.words[num.length++] = carry;
          }
          return num;
        };
        BN._prime = function prime(name) {
          if (primes[name])
            return primes[name];
          var prime2;
          if (name === "k256") {
            prime2 = new K256();
          } else if (name === "p224") {
            prime2 = new P224();
          } else if (name === "p192") {
            prime2 = new P192();
          } else if (name === "p25519") {
            prime2 = new P25519();
          } else {
            throw new Error("Unknown prime " + name);
          }
          primes[name] = prime2;
          return prime2;
        };
        function Red(m) {
          if (typeof m === "string") {
            var prime = BN._prime(m);
            this.m = prime.p;
            this.prime = prime;
          } else {
            assert(m.gtn(1), "modulus must be greater than 1");
            this.m = m;
            this.prime = null;
          }
        }
        Red.prototype._verify1 = function _verify1(a) {
          assert(a.negative === 0, "red works only with positives");
          assert(a.red, "red works only with red numbers");
        };
        Red.prototype._verify2 = function _verify2(a, b) {
          assert((a.negative | b.negative) === 0, "red works only with positives");
          assert(a.red && a.red === b.red, "red works only with red numbers");
        };
        Red.prototype.imod = function imod(a) {
          if (this.prime)
            return this.prime.ireduce(a)._forceRed(this);
          move(a, a.umod(this.m)._forceRed(this));
          return a;
        };
        Red.prototype.neg = function neg(a) {
          if (a.isZero()) {
            return a.clone();
          }
          return this.m.sub(a)._forceRed(this);
        };
        Red.prototype.add = function add(a, b) {
          this._verify2(a, b);
          var res = a.add(b);
          if (res.cmp(this.m) >= 0) {
            res.isub(this.m);
          }
          return res._forceRed(this);
        };
        Red.prototype.iadd = function iadd(a, b) {
          this._verify2(a, b);
          var res = a.iadd(b);
          if (res.cmp(this.m) >= 0) {
            res.isub(this.m);
          }
          return res;
        };
        Red.prototype.sub = function sub(a, b) {
          this._verify2(a, b);
          var res = a.sub(b);
          if (res.cmpn(0) < 0) {
            res.iadd(this.m);
          }
          return res._forceRed(this);
        };
        Red.prototype.isub = function isub(a, b) {
          this._verify2(a, b);
          var res = a.isub(b);
          if (res.cmpn(0) < 0) {
            res.iadd(this.m);
          }
          return res;
        };
        Red.prototype.shl = function shl(a, num) {
          this._verify1(a);
          return this.imod(a.ushln(num));
        };
        Red.prototype.imul = function imul(a, b) {
          this._verify2(a, b);
          return this.imod(a.imul(b));
        };
        Red.prototype.mul = function mul(a, b) {
          this._verify2(a, b);
          return this.imod(a.mul(b));
        };
        Red.prototype.isqr = function isqr(a) {
          return this.imul(a, a.clone());
        };
        Red.prototype.sqr = function sqr(a) {
          return this.mul(a, a);
        };
        Red.prototype.sqrt = function sqrt(a) {
          if (a.isZero())
            return a.clone();
          var mod3 = this.m.andln(3);
          assert(mod3 % 2 === 1);
          if (mod3 === 3) {
            var pow = this.m.add(new BN(1)).iushrn(2);
            return this.pow(a, pow);
          }
          var q = this.m.subn(1);
          var s = 0;
          while (!q.isZero() && q.andln(1) === 0) {
            s++;
            q.iushrn(1);
          }
          assert(!q.isZero());
          var one = new BN(1).toRed(this);
          var nOne = one.redNeg();
          var lpow = this.m.subn(1).iushrn(1);
          var z = this.m.bitLength();
          z = new BN(2 * z * z).toRed(this);
          while (this.pow(z, lpow).cmp(nOne) !== 0) {
            z.redIAdd(nOne);
          }
          var c = this.pow(z, q);
          var r = this.pow(a, q.addn(1).iushrn(1));
          var t = this.pow(a, q);
          var m = s;
          while (t.cmp(one) !== 0) {
            var tmp = t;
            for (var i = 0; tmp.cmp(one) !== 0; i++) {
              tmp = tmp.redSqr();
            }
            assert(i < m);
            var b = this.pow(c, new BN(1).iushln(m - i - 1));
            r = r.redMul(b);
            c = b.redSqr();
            t = t.redMul(c);
            m = i;
          }
          return r;
        };
        Red.prototype.invm = function invm(a) {
          var inv = a._invmp(this.m);
          if (inv.negative !== 0) {
            inv.negative = 0;
            return this.imod(inv).redNeg();
          } else {
            return this.imod(inv);
          }
        };
        Red.prototype.pow = function pow(a, num) {
          if (num.isZero())
            return new BN(1).toRed(this);
          if (num.cmpn(1) === 0)
            return a.clone();
          var windowSize = 4;
          var wnd = new Array(1 << windowSize);
          wnd[0] = new BN(1).toRed(this);
          wnd[1] = a;
          for (var i = 2; i < wnd.length; i++) {
            wnd[i] = this.mul(wnd[i - 1], a);
          }
          var res = wnd[0];
          var current = 0;
          var currentLen = 0;
          var start2 = num.bitLength() % 26;
          if (start2 === 0) {
            start2 = 26;
          }
          for (i = num.length - 1; i >= 0; i--) {
            var word = num.words[i];
            for (var j = start2 - 1; j >= 0; j--) {
              var bit = word >> j & 1;
              if (res !== wnd[0]) {
                res = this.sqr(res);
              }
              if (bit === 0 && current === 0) {
                currentLen = 0;
                continue;
              }
              current <<= 1;
              current |= bit;
              currentLen++;
              if (currentLen !== windowSize && (i !== 0 || j !== 0))
                continue;
              res = this.mul(res, wnd[current]);
              currentLen = 0;
              current = 0;
            }
            start2 = 26;
          }
          return res;
        };
        Red.prototype.convertTo = function convertTo(num) {
          var r = num.umod(this.m);
          return r === num ? r.clone() : r;
        };
        Red.prototype.convertFrom = function convertFrom(num) {
          var res = num.clone();
          res.red = null;
          return res;
        };
        BN.mont = function mont(num) {
          return new Mont(num);
        };
        function Mont(m) {
          Red.call(this, m);
          this.shift = this.m.bitLength();
          if (this.shift % 26 !== 0) {
            this.shift += 26 - this.shift % 26;
          }
          this.r = new BN(1).iushln(this.shift);
          this.r2 = this.imod(this.r.sqr());
          this.rinv = this.r._invmp(this.m);
          this.minv = this.rinv.mul(this.r).isubn(1).div(this.m);
          this.minv = this.minv.umod(this.r);
          this.minv = this.r.sub(this.minv);
        }
        inherits(Mont, Red);
        Mont.prototype.convertTo = function convertTo(num) {
          return this.imod(num.ushln(this.shift));
        };
        Mont.prototype.convertFrom = function convertFrom(num) {
          var r = this.imod(num.mul(this.rinv));
          r.red = null;
          return r;
        };
        Mont.prototype.imul = function imul(a, b) {
          if (a.isZero() || b.isZero()) {
            a.words[0] = 0;
            a.length = 1;
            return a;
          }
          var t = a.imul(b);
          var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
          var u = t.isub(c).iushrn(this.shift);
          var res = u;
          if (u.cmp(this.m) >= 0) {
            res = u.isub(this.m);
          } else if (u.cmpn(0) < 0) {
            res = u.iadd(this.m);
          }
          return res._forceRed(this);
        };
        Mont.prototype.mul = function mul(a, b) {
          if (a.isZero() || b.isZero())
            return new BN(0)._forceRed(this);
          var t = a.mul(b);
          var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
          var u = t.isub(c).iushrn(this.shift);
          var res = u;
          if (u.cmp(this.m) >= 0) {
            res = u.isub(this.m);
          } else if (u.cmpn(0) < 0) {
            res = u.iadd(this.m);
          }
          return res._forceRed(this);
        };
        Mont.prototype.invm = function invm(a) {
          var res = this.imod(a._invmp(this.m).mul(this.r2));
          return res._forceRed(this);
        };
      })(typeof module2 === "undefined" || module2, exports2);
    }
  });

  // node_modules/browserify-rsa/index.js
  var require_browserify_rsa = __commonJS({
    "node_modules/browserify-rsa/index.js"(exports2, module2) {
      var BN = require_bn3();
      var randomBytes = require_browser();
      function blind(priv) {
        var r = getr(priv);
        var blinder = r.toRed(BN.mont(priv.modulus)).redPow(new BN(priv.publicExponent)).fromRed();
        return { blinder, unblinder: r.invm(priv.modulus) };
      }
      function getr(priv) {
        var len = priv.modulus.byteLength();
        var r;
        do {
          r = new BN(randomBytes(len));
        } while (r.cmp(priv.modulus) >= 0 || !r.umod(priv.prime1) || !r.umod(priv.prime2));
        return r;
      }
      function crt(msg, priv) {
        var blinds = blind(priv);
        var len = priv.modulus.byteLength();
        var blinded = new BN(msg).mul(blinds.blinder).umod(priv.modulus);
        var c1 = blinded.toRed(BN.mont(priv.prime1));
        var c2 = blinded.toRed(BN.mont(priv.prime2));
        var qinv = priv.coefficient;
        var p = priv.prime1;
        var q = priv.prime2;
        var m1 = c1.redPow(priv.exponent1).fromRed();
        var m2 = c2.redPow(priv.exponent2).fromRed();
        var h = m1.isub(m2).imul(qinv).umod(p).imul(q);
        return m2.iadd(h).imul(blinds.unblinder).umod(priv.modulus).toArrayLike(Buffer, "be", len);
      }
      crt.getr = getr;
      module2.exports = crt;
    }
  });

  // node_modules/elliptic/package.json
  var require_package = __commonJS({
    "node_modules/elliptic/package.json"(exports2, module2) {
      module2.exports = {
        name: "elliptic",
        version: "6.5.4",
        description: "EC cryptography",
        main: "lib/elliptic.js",
        files: [
          "lib"
        ],
        scripts: {
          lint: "eslint lib test",
          "lint:fix": "npm run lint -- --fix",
          unit: "istanbul test _mocha --reporter=spec test/index.js",
          test: "npm run lint && npm run unit",
          version: "grunt dist && git add dist/"
        },
        repository: {
          type: "git",
          url: "git@github.com:indutny/elliptic"
        },
        keywords: [
          "EC",
          "Elliptic",
          "curve",
          "Cryptography"
        ],
        author: "Fedor Indutny <fedor@indutny.com>",
        license: "MIT",
        bugs: {
          url: "https://github.com/indutny/elliptic/issues"
        },
        homepage: "https://github.com/indutny/elliptic",
        devDependencies: {
          brfs: "^2.0.2",
          coveralls: "^3.1.0",
          eslint: "^7.6.0",
          grunt: "^1.2.1",
          "grunt-browserify": "^5.3.0",
          "grunt-cli": "^1.3.2",
          "grunt-contrib-connect": "^3.0.0",
          "grunt-contrib-copy": "^1.0.0",
          "grunt-contrib-uglify": "^5.0.0",
          "grunt-mocha-istanbul": "^5.0.2",
          "grunt-saucelabs": "^9.0.1",
          istanbul: "^0.4.5",
          mocha: "^8.0.1"
        },
        dependencies: {
          "bn.js": "^4.11.9",
          brorand: "^1.1.0",
          "hash.js": "^1.0.0",
          "hmac-drbg": "^1.0.1",
          inherits: "^2.0.4",
          "minimalistic-assert": "^1.0.1",
          "minimalistic-crypto-utils": "^1.0.1"
        }
      };
    }
  });

  // node_modules/minimalistic-crypto-utils/lib/utils.js
  var require_utils3 = __commonJS({
    "node_modules/minimalistic-crypto-utils/lib/utils.js"(exports2) {
      "use strict";
      var utils = exports2;
      function toArray(msg, enc) {
        if (Array.isArray(msg))
          return msg.slice();
        if (!msg)
          return [];
        var res = [];
        if (typeof msg !== "string") {
          for (var i = 0; i < msg.length; i++)
            res[i] = msg[i] | 0;
          return res;
        }
        if (enc === "hex") {
          msg = msg.replace(/[^a-z0-9]+/ig, "");
          if (msg.length % 2 !== 0)
            msg = "0" + msg;
          for (var i = 0; i < msg.length; i += 2)
            res.push(parseInt(msg[i] + msg[i + 1], 16));
        } else {
          for (var i = 0; i < msg.length; i++) {
            var c = msg.charCodeAt(i);
            var hi = c >> 8;
            var lo = c & 255;
            if (hi)
              res.push(hi, lo);
            else
              res.push(lo);
          }
        }
        return res;
      }
      utils.toArray = toArray;
      function zero2(word) {
        if (word.length === 1)
          return "0" + word;
        else
          return word;
      }
      utils.zero2 = zero2;
      function toHex(msg) {
        var res = "";
        for (var i = 0; i < msg.length; i++)
          res += zero2(msg[i].toString(16));
        return res;
      }
      utils.toHex = toHex;
      utils.encode = function encode(arr, enc) {
        if (enc === "hex")
          return toHex(arr);
        else
          return arr;
      };
    }
  });

  // node_modules/elliptic/lib/elliptic/utils.js
  var require_utils4 = __commonJS({
    "node_modules/elliptic/lib/elliptic/utils.js"(exports2) {
      "use strict";
      var utils = exports2;
      var BN = require_bn2();
      var minAssert = require_minimalistic_assert();
      var minUtils = require_utils3();
      utils.assert = minAssert;
      utils.toArray = minUtils.toArray;
      utils.zero2 = minUtils.zero2;
      utils.toHex = minUtils.toHex;
      utils.encode = minUtils.encode;
      function getNAF(num, w, bits) {
        var naf = new Array(Math.max(num.bitLength(), bits) + 1);
        naf.fill(0);
        var ws = 1 << w + 1;
        var k = num.clone();
        for (var i = 0; i < naf.length; i++) {
          var z;
          var mod2 = k.andln(ws - 1);
          if (k.isOdd()) {
            if (mod2 > (ws >> 1) - 1)
              z = (ws >> 1) - mod2;
            else
              z = mod2;
            k.isubn(z);
          } else {
            z = 0;
          }
          naf[i] = z;
          k.iushrn(1);
        }
        return naf;
      }
      utils.getNAF = getNAF;
      function getJSF(k1, k2) {
        var jsf = [
          [],
          []
        ];
        k1 = k1.clone();
        k2 = k2.clone();
        var d1 = 0;
        var d2 = 0;
        var m8;
        while (k1.cmpn(-d1) > 0 || k2.cmpn(-d2) > 0) {
          var m14 = k1.andln(3) + d1 & 3;
          var m24 = k2.andln(3) + d2 & 3;
          if (m14 === 3)
            m14 = -1;
          if (m24 === 3)
            m24 = -1;
          var u1;
          if ((m14 & 1) === 0) {
            u1 = 0;
          } else {
            m8 = k1.andln(7) + d1 & 7;
            if ((m8 === 3 || m8 === 5) && m24 === 2)
              u1 = -m14;
            else
              u1 = m14;
          }
          jsf[0].push(u1);
          var u2;
          if ((m24 & 1) === 0) {
            u2 = 0;
          } else {
            m8 = k2.andln(7) + d2 & 7;
            if ((m8 === 3 || m8 === 5) && m14 === 2)
              u2 = -m24;
            else
              u2 = m24;
          }
          jsf[1].push(u2);
          if (2 * d1 === u1 + 1)
            d1 = 1 - d1;
          if (2 * d2 === u2 + 1)
            d2 = 1 - d2;
          k1.iushrn(1);
          k2.iushrn(1);
        }
        return jsf;
      }
      utils.getJSF = getJSF;
      function cachedProperty(obj, name, computer) {
        var key = "_" + name;
        obj.prototype[name] = function cachedProperty2() {
          return this[key] !== void 0 ? this[key] : this[key] = computer.call(this);
        };
      }
      utils.cachedProperty = cachedProperty;
      function parseBytes(bytes) {
        return typeof bytes === "string" ? utils.toArray(bytes, "hex") : bytes;
      }
      utils.parseBytes = parseBytes;
      function intFromLE(bytes) {
        return new BN(bytes, "hex", "le");
      }
      utils.intFromLE = intFromLE;
    }
  });

  // node_modules/elliptic/lib/elliptic/curve/base.js
  var require_base = __commonJS({
    "node_modules/elliptic/lib/elliptic/curve/base.js"(exports2, module2) {
      "use strict";
      var BN = require_bn2();
      var utils = require_utils4();
      var getNAF = utils.getNAF;
      var getJSF = utils.getJSF;
      var assert = utils.assert;
      function BaseCurve(type, conf) {
        this.type = type;
        this.p = new BN(conf.p, 16);
        this.red = conf.prime ? BN.red(conf.prime) : BN.mont(this.p);
        this.zero = new BN(0).toRed(this.red);
        this.one = new BN(1).toRed(this.red);
        this.two = new BN(2).toRed(this.red);
        this.n = conf.n && new BN(conf.n, 16);
        this.g = conf.g && this.pointFromJSON(conf.g, conf.gRed);
        this._wnafT1 = new Array(4);
        this._wnafT2 = new Array(4);
        this._wnafT3 = new Array(4);
        this._wnafT4 = new Array(4);
        this._bitLength = this.n ? this.n.bitLength() : 0;
        var adjustCount = this.n && this.p.div(this.n);
        if (!adjustCount || adjustCount.cmpn(100) > 0) {
          this.redN = null;
        } else {
          this._maxwellTrick = true;
          this.redN = this.n.toRed(this.red);
        }
      }
      module2.exports = BaseCurve;
      BaseCurve.prototype.point = function point() {
        throw new Error("Not implemented");
      };
      BaseCurve.prototype.validate = function validate() {
        throw new Error("Not implemented");
      };
      BaseCurve.prototype._fixedNafMul = function _fixedNafMul(p, k) {
        assert(p.precomputed);
        var doubles = p._getDoubles();
        var naf = getNAF(k, 1, this._bitLength);
        var I = (1 << doubles.step + 1) - (doubles.step % 2 === 0 ? 2 : 1);
        I /= 3;
        var repr = [];
        var j;
        var nafW;
        for (j = 0; j < naf.length; j += doubles.step) {
          nafW = 0;
          for (var l = j + doubles.step - 1; l >= j; l--)
            nafW = (nafW << 1) + naf[l];
          repr.push(nafW);
        }
        var a = this.jpoint(null, null, null);
        var b = this.jpoint(null, null, null);
        for (var i = I; i > 0; i--) {
          for (j = 0; j < repr.length; j++) {
            nafW = repr[j];
            if (nafW === i)
              b = b.mixedAdd(doubles.points[j]);
            else if (nafW === -i)
              b = b.mixedAdd(doubles.points[j].neg());
          }
          a = a.add(b);
        }
        return a.toP();
      };
      BaseCurve.prototype._wnafMul = function _wnafMul(p, k) {
        var w = 4;
        var nafPoints = p._getNAFPoints(w);
        w = nafPoints.wnd;
        var wnd = nafPoints.points;
        var naf = getNAF(k, w, this._bitLength);
        var acc = this.jpoint(null, null, null);
        for (var i = naf.length - 1; i >= 0; i--) {
          for (var l = 0; i >= 0 && naf[i] === 0; i--)
            l++;
          if (i >= 0)
            l++;
          acc = acc.dblp(l);
          if (i < 0)
            break;
          var z = naf[i];
          assert(z !== 0);
          if (p.type === "affine") {
            if (z > 0)
              acc = acc.mixedAdd(wnd[z - 1 >> 1]);
            else
              acc = acc.mixedAdd(wnd[-z - 1 >> 1].neg());
          } else {
            if (z > 0)
              acc = acc.add(wnd[z - 1 >> 1]);
            else
              acc = acc.add(wnd[-z - 1 >> 1].neg());
          }
        }
        return p.type === "affine" ? acc.toP() : acc;
      };
      BaseCurve.prototype._wnafMulAdd = function _wnafMulAdd(defW, points, coeffs, len, jacobianResult) {
        var wndWidth = this._wnafT1;
        var wnd = this._wnafT2;
        var naf = this._wnafT3;
        var max = 0;
        var i;
        var j;
        var p;
        for (i = 0; i < len; i++) {
          p = points[i];
          var nafPoints = p._getNAFPoints(defW);
          wndWidth[i] = nafPoints.wnd;
          wnd[i] = nafPoints.points;
        }
        for (i = len - 1; i >= 1; i -= 2) {
          var a = i - 1;
          var b = i;
          if (wndWidth[a] !== 1 || wndWidth[b] !== 1) {
            naf[a] = getNAF(coeffs[a], wndWidth[a], this._bitLength);
            naf[b] = getNAF(coeffs[b], wndWidth[b], this._bitLength);
            max = Math.max(naf[a].length, max);
            max = Math.max(naf[b].length, max);
            continue;
          }
          var comb = [
            points[a],
            null,
            null,
            points[b]
          ];
          if (points[a].y.cmp(points[b].y) === 0) {
            comb[1] = points[a].add(points[b]);
            comb[2] = points[a].toJ().mixedAdd(points[b].neg());
          } else if (points[a].y.cmp(points[b].y.redNeg()) === 0) {
            comb[1] = points[a].toJ().mixedAdd(points[b]);
            comb[2] = points[a].add(points[b].neg());
          } else {
            comb[1] = points[a].toJ().mixedAdd(points[b]);
            comb[2] = points[a].toJ().mixedAdd(points[b].neg());
          }
          var index = [
            -3,
            -1,
            -5,
            -7,
            0,
            7,
            5,
            1,
            3
          ];
          var jsf = getJSF(coeffs[a], coeffs[b]);
          max = Math.max(jsf[0].length, max);
          naf[a] = new Array(max);
          naf[b] = new Array(max);
          for (j = 0; j < max; j++) {
            var ja = jsf[0][j] | 0;
            var jb = jsf[1][j] | 0;
            naf[a][j] = index[(ja + 1) * 3 + (jb + 1)];
            naf[b][j] = 0;
            wnd[a] = comb;
          }
        }
        var acc = this.jpoint(null, null, null);
        var tmp = this._wnafT4;
        for (i = max; i >= 0; i--) {
          var k = 0;
          while (i >= 0) {
            var zero = true;
            for (j = 0; j < len; j++) {
              tmp[j] = naf[j][i] | 0;
              if (tmp[j] !== 0)
                zero = false;
            }
            if (!zero)
              break;
            k++;
            i--;
          }
          if (i >= 0)
            k++;
          acc = acc.dblp(k);
          if (i < 0)
            break;
          for (j = 0; j < len; j++) {
            var z = tmp[j];
            p;
            if (z === 0)
              continue;
            else if (z > 0)
              p = wnd[j][z - 1 >> 1];
            else if (z < 0)
              p = wnd[j][-z - 1 >> 1].neg();
            if (p.type === "affine")
              acc = acc.mixedAdd(p);
            else
              acc = acc.add(p);
          }
        }
        for (i = 0; i < len; i++)
          wnd[i] = null;
        if (jacobianResult)
          return acc;
        else
          return acc.toP();
      };
      function BasePoint(curve, type) {
        this.curve = curve;
        this.type = type;
        this.precomputed = null;
      }
      BaseCurve.BasePoint = BasePoint;
      BasePoint.prototype.eq = function eq() {
        throw new Error("Not implemented");
      };
      BasePoint.prototype.validate = function validate() {
        return this.curve.validate(this);
      };
      BaseCurve.prototype.decodePoint = function decodePoint(bytes, enc) {
        bytes = utils.toArray(bytes, enc);
        var len = this.p.byteLength();
        if ((bytes[0] === 4 || bytes[0] === 6 || bytes[0] === 7) && bytes.length - 1 === 2 * len) {
          if (bytes[0] === 6)
            assert(bytes[bytes.length - 1] % 2 === 0);
          else if (bytes[0] === 7)
            assert(bytes[bytes.length - 1] % 2 === 1);
          var res = this.point(bytes.slice(1, 1 + len), bytes.slice(1 + len, 1 + 2 * len));
          return res;
        } else if ((bytes[0] === 2 || bytes[0] === 3) && bytes.length - 1 === len) {
          return this.pointFromX(bytes.slice(1, 1 + len), bytes[0] === 3);
        }
        throw new Error("Unknown point format");
      };
      BasePoint.prototype.encodeCompressed = function encodeCompressed(enc) {
        return this.encode(enc, true);
      };
      BasePoint.prototype._encode = function _encode(compact) {
        var len = this.curve.p.byteLength();
        var x = this.getX().toArray("be", len);
        if (compact)
          return [this.getY().isEven() ? 2 : 3].concat(x);
        return [4].concat(x, this.getY().toArray("be", len));
      };
      BasePoint.prototype.encode = function encode(enc, compact) {
        return utils.encode(this._encode(compact), enc);
      };
      BasePoint.prototype.precompute = function precompute(power) {
        if (this.precomputed)
          return this;
        var precomputed = {
          doubles: null,
          naf: null,
          beta: null
        };
        precomputed.naf = this._getNAFPoints(8);
        precomputed.doubles = this._getDoubles(4, power);
        precomputed.beta = this._getBeta();
        this.precomputed = precomputed;
        return this;
      };
      BasePoint.prototype._hasDoubles = function _hasDoubles(k) {
        if (!this.precomputed)
          return false;
        var doubles = this.precomputed.doubles;
        if (!doubles)
          return false;
        return doubles.points.length >= Math.ceil((k.bitLength() + 1) / doubles.step);
      };
      BasePoint.prototype._getDoubles = function _getDoubles(step, power) {
        if (this.precomputed && this.precomputed.doubles)
          return this.precomputed.doubles;
        var doubles = [this];
        var acc = this;
        for (var i = 0; i < power; i += step) {
          for (var j = 0; j < step; j++)
            acc = acc.dbl();
          doubles.push(acc);
        }
        return {
          step,
          points: doubles
        };
      };
      BasePoint.prototype._getNAFPoints = function _getNAFPoints(wnd) {
        if (this.precomputed && this.precomputed.naf)
          return this.precomputed.naf;
        var res = [this];
        var max = (1 << wnd) - 1;
        var dbl = max === 1 ? null : this.dbl();
        for (var i = 1; i < max; i++)
          res[i] = res[i - 1].add(dbl);
        return {
          wnd,
          points: res
        };
      };
      BasePoint.prototype._getBeta = function _getBeta() {
        return null;
      };
      BasePoint.prototype.dblp = function dblp(k) {
        var r = this;
        for (var i = 0; i < k; i++)
          r = r.dbl();
        return r;
      };
    }
  });

  // node_modules/elliptic/lib/elliptic/curve/short.js
  var require_short = __commonJS({
    "node_modules/elliptic/lib/elliptic/curve/short.js"(exports2, module2) {
      "use strict";
      var utils = require_utils4();
      var BN = require_bn2();
      var inherits = require_inherits_browser();
      var Base = require_base();
      var assert = utils.assert;
      function ShortCurve(conf) {
        Base.call(this, "short", conf);
        this.a = new BN(conf.a, 16).toRed(this.red);
        this.b = new BN(conf.b, 16).toRed(this.red);
        this.tinv = this.two.redInvm();
        this.zeroA = this.a.fromRed().cmpn(0) === 0;
        this.threeA = this.a.fromRed().sub(this.p).cmpn(-3) === 0;
        this.endo = this._getEndomorphism(conf);
        this._endoWnafT1 = new Array(4);
        this._endoWnafT2 = new Array(4);
      }
      inherits(ShortCurve, Base);
      module2.exports = ShortCurve;
      ShortCurve.prototype._getEndomorphism = function _getEndomorphism(conf) {
        if (!this.zeroA || !this.g || !this.n || this.p.modn(3) !== 1)
          return;
        var beta;
        var lambda;
        if (conf.beta) {
          beta = new BN(conf.beta, 16).toRed(this.red);
        } else {
          var betas = this._getEndoRoots(this.p);
          beta = betas[0].cmp(betas[1]) < 0 ? betas[0] : betas[1];
          beta = beta.toRed(this.red);
        }
        if (conf.lambda) {
          lambda = new BN(conf.lambda, 16);
        } else {
          var lambdas = this._getEndoRoots(this.n);
          if (this.g.mul(lambdas[0]).x.cmp(this.g.x.redMul(beta)) === 0) {
            lambda = lambdas[0];
          } else {
            lambda = lambdas[1];
            assert(this.g.mul(lambda).x.cmp(this.g.x.redMul(beta)) === 0);
          }
        }
        var basis;
        if (conf.basis) {
          basis = conf.basis.map(function(vec) {
            return {
              a: new BN(vec.a, 16),
              b: new BN(vec.b, 16)
            };
          });
        } else {
          basis = this._getEndoBasis(lambda);
        }
        return {
          beta,
          lambda,
          basis
        };
      };
      ShortCurve.prototype._getEndoRoots = function _getEndoRoots(num) {
        var red = num === this.p ? this.red : BN.mont(num);
        var tinv = new BN(2).toRed(red).redInvm();
        var ntinv = tinv.redNeg();
        var s = new BN(3).toRed(red).redNeg().redSqrt().redMul(tinv);
        var l1 = ntinv.redAdd(s).fromRed();
        var l2 = ntinv.redSub(s).fromRed();
        return [l1, l2];
      };
      ShortCurve.prototype._getEndoBasis = function _getEndoBasis(lambda) {
        var aprxSqrt = this.n.ushrn(Math.floor(this.n.bitLength() / 2));
        var u = lambda;
        var v = this.n.clone();
        var x1 = new BN(1);
        var y1 = new BN(0);
        var x2 = new BN(0);
        var y2 = new BN(1);
        var a0;
        var b0;
        var a1;
        var b1;
        var a2;
        var b2;
        var prevR;
        var i = 0;
        var r;
        var x;
        while (u.cmpn(0) !== 0) {
          var q = v.div(u);
          r = v.sub(q.mul(u));
          x = x2.sub(q.mul(x1));
          var y = y2.sub(q.mul(y1));
          if (!a1 && r.cmp(aprxSqrt) < 0) {
            a0 = prevR.neg();
            b0 = x1;
            a1 = r.neg();
            b1 = x;
          } else if (a1 && ++i === 2) {
            break;
          }
          prevR = r;
          v = u;
          u = r;
          x2 = x1;
          x1 = x;
          y2 = y1;
          y1 = y;
        }
        a2 = r.neg();
        b2 = x;
        var len1 = a1.sqr().add(b1.sqr());
        var len2 = a2.sqr().add(b2.sqr());
        if (len2.cmp(len1) >= 0) {
          a2 = a0;
          b2 = b0;
        }
        if (a1.negative) {
          a1 = a1.neg();
          b1 = b1.neg();
        }
        if (a2.negative) {
          a2 = a2.neg();
          b2 = b2.neg();
        }
        return [
          { a: a1, b: b1 },
          { a: a2, b: b2 }
        ];
      };
      ShortCurve.prototype._endoSplit = function _endoSplit(k) {
        var basis = this.endo.basis;
        var v1 = basis[0];
        var v2 = basis[1];
        var c1 = v2.b.mul(k).divRound(this.n);
        var c2 = v1.b.neg().mul(k).divRound(this.n);
        var p1 = c1.mul(v1.a);
        var p2 = c2.mul(v2.a);
        var q1 = c1.mul(v1.b);
        var q2 = c2.mul(v2.b);
        var k1 = k.sub(p1).sub(p2);
        var k2 = q1.add(q2).neg();
        return { k1, k2 };
      };
      ShortCurve.prototype.pointFromX = function pointFromX(x, odd) {
        x = new BN(x, 16);
        if (!x.red)
          x = x.toRed(this.red);
        var y2 = x.redSqr().redMul(x).redIAdd(x.redMul(this.a)).redIAdd(this.b);
        var y = y2.redSqrt();
        if (y.redSqr().redSub(y2).cmp(this.zero) !== 0)
          throw new Error("invalid point");
        var isOdd = y.fromRed().isOdd();
        if (odd && !isOdd || !odd && isOdd)
          y = y.redNeg();
        return this.point(x, y);
      };
      ShortCurve.prototype.validate = function validate(point) {
        if (point.inf)
          return true;
        var x = point.x;
        var y = point.y;
        var ax = this.a.redMul(x);
        var rhs = x.redSqr().redMul(x).redIAdd(ax).redIAdd(this.b);
        return y.redSqr().redISub(rhs).cmpn(0) === 0;
      };
      ShortCurve.prototype._endoWnafMulAdd = function _endoWnafMulAdd(points, coeffs, jacobianResult) {
        var npoints = this._endoWnafT1;
        var ncoeffs = this._endoWnafT2;
        for (var i = 0; i < points.length; i++) {
          var split = this._endoSplit(coeffs[i]);
          var p = points[i];
          var beta = p._getBeta();
          if (split.k1.negative) {
            split.k1.ineg();
            p = p.neg(true);
          }
          if (split.k2.negative) {
            split.k2.ineg();
            beta = beta.neg(true);
          }
          npoints[i * 2] = p;
          npoints[i * 2 + 1] = beta;
          ncoeffs[i * 2] = split.k1;
          ncoeffs[i * 2 + 1] = split.k2;
        }
        var res = this._wnafMulAdd(1, npoints, ncoeffs, i * 2, jacobianResult);
        for (var j = 0; j < i * 2; j++) {
          npoints[j] = null;
          ncoeffs[j] = null;
        }
        return res;
      };
      function Point(curve, x, y, isRed) {
        Base.BasePoint.call(this, curve, "affine");
        if (x === null && y === null) {
          this.x = null;
          this.y = null;
          this.inf = true;
        } else {
          this.x = new BN(x, 16);
          this.y = new BN(y, 16);
          if (isRed) {
            this.x.forceRed(this.curve.red);
            this.y.forceRed(this.curve.red);
          }
          if (!this.x.red)
            this.x = this.x.toRed(this.curve.red);
          if (!this.y.red)
            this.y = this.y.toRed(this.curve.red);
          this.inf = false;
        }
      }
      inherits(Point, Base.BasePoint);
      ShortCurve.prototype.point = function point(x, y, isRed) {
        return new Point(this, x, y, isRed);
      };
      ShortCurve.prototype.pointFromJSON = function pointFromJSON(obj, red) {
        return Point.fromJSON(this, obj, red);
      };
      Point.prototype._getBeta = function _getBeta() {
        if (!this.curve.endo)
          return;
        var pre = this.precomputed;
        if (pre && pre.beta)
          return pre.beta;
        var beta = this.curve.point(this.x.redMul(this.curve.endo.beta), this.y);
        if (pre) {
          var curve = this.curve;
          var endoMul = function(p) {
            return curve.point(p.x.redMul(curve.endo.beta), p.y);
          };
          pre.beta = beta;
          beta.precomputed = {
            beta: null,
            naf: pre.naf && {
              wnd: pre.naf.wnd,
              points: pre.naf.points.map(endoMul)
            },
            doubles: pre.doubles && {
              step: pre.doubles.step,
              points: pre.doubles.points.map(endoMul)
            }
          };
        }
        return beta;
      };
      Point.prototype.toJSON = function toJSON() {
        if (!this.precomputed)
          return [this.x, this.y];
        return [this.x, this.y, this.precomputed && {
          doubles: this.precomputed.doubles && {
            step: this.precomputed.doubles.step,
            points: this.precomputed.doubles.points.slice(1)
          },
          naf: this.precomputed.naf && {
            wnd: this.precomputed.naf.wnd,
            points: this.precomputed.naf.points.slice(1)
          }
        }];
      };
      Point.fromJSON = function fromJSON(curve, obj, red) {
        if (typeof obj === "string")
          obj = JSON.parse(obj);
        var res = curve.point(obj[0], obj[1], red);
        if (!obj[2])
          return res;
        function obj2point(obj2) {
          return curve.point(obj2[0], obj2[1], red);
        }
        var pre = obj[2];
        res.precomputed = {
          beta: null,
          doubles: pre.doubles && {
            step: pre.doubles.step,
            points: [res].concat(pre.doubles.points.map(obj2point))
          },
          naf: pre.naf && {
            wnd: pre.naf.wnd,
            points: [res].concat(pre.naf.points.map(obj2point))
          }
        };
        return res;
      };
      Point.prototype.inspect = function inspect() {
        if (this.isInfinity())
          return "<EC Point Infinity>";
        return "<EC Point x: " + this.x.fromRed().toString(16, 2) + " y: " + this.y.fromRed().toString(16, 2) + ">";
      };
      Point.prototype.isInfinity = function isInfinity() {
        return this.inf;
      };
      Point.prototype.add = function add(p) {
        if (this.inf)
          return p;
        if (p.inf)
          return this;
        if (this.eq(p))
          return this.dbl();
        if (this.neg().eq(p))
          return this.curve.point(null, null);
        if (this.x.cmp(p.x) === 0)
          return this.curve.point(null, null);
        var c = this.y.redSub(p.y);
        if (c.cmpn(0) !== 0)
          c = c.redMul(this.x.redSub(p.x).redInvm());
        var nx = c.redSqr().redISub(this.x).redISub(p.x);
        var ny = c.redMul(this.x.redSub(nx)).redISub(this.y);
        return this.curve.point(nx, ny);
      };
      Point.prototype.dbl = function dbl() {
        if (this.inf)
          return this;
        var ys1 = this.y.redAdd(this.y);
        if (ys1.cmpn(0) === 0)
          return this.curve.point(null, null);
        var a = this.curve.a;
        var x2 = this.x.redSqr();
        var dyinv = ys1.redInvm();
        var c = x2.redAdd(x2).redIAdd(x2).redIAdd(a).redMul(dyinv);
        var nx = c.redSqr().redISub(this.x.redAdd(this.x));
        var ny = c.redMul(this.x.redSub(nx)).redISub(this.y);
        return this.curve.point(nx, ny);
      };
      Point.prototype.getX = function getX() {
        return this.x.fromRed();
      };
      Point.prototype.getY = function getY() {
        return this.y.fromRed();
      };
      Point.prototype.mul = function mul(k) {
        k = new BN(k, 16);
        if (this.isInfinity())
          return this;
        else if (this._hasDoubles(k))
          return this.curve._fixedNafMul(this, k);
        else if (this.curve.endo)
          return this.curve._endoWnafMulAdd([this], [k]);
        else
          return this.curve._wnafMul(this, k);
      };
      Point.prototype.mulAdd = function mulAdd(k1, p2, k2) {
        var points = [this, p2];
        var coeffs = [k1, k2];
        if (this.curve.endo)
          return this.curve._endoWnafMulAdd(points, coeffs);
        else
          return this.curve._wnafMulAdd(1, points, coeffs, 2);
      };
      Point.prototype.jmulAdd = function jmulAdd(k1, p2, k2) {
        var points = [this, p2];
        var coeffs = [k1, k2];
        if (this.curve.endo)
          return this.curve._endoWnafMulAdd(points, coeffs, true);
        else
          return this.curve._wnafMulAdd(1, points, coeffs, 2, true);
      };
      Point.prototype.eq = function eq(p) {
        return this === p || this.inf === p.inf && (this.inf || this.x.cmp(p.x) === 0 && this.y.cmp(p.y) === 0);
      };
      Point.prototype.neg = function neg(_precompute) {
        if (this.inf)
          return this;
        var res = this.curve.point(this.x, this.y.redNeg());
        if (_precompute && this.precomputed) {
          var pre = this.precomputed;
          var negate = function(p) {
            return p.neg();
          };
          res.precomputed = {
            naf: pre.naf && {
              wnd: pre.naf.wnd,
              points: pre.naf.points.map(negate)
            },
            doubles: pre.doubles && {
              step: pre.doubles.step,
              points: pre.doubles.points.map(negate)
            }
          };
        }
        return res;
      };
      Point.prototype.toJ = function toJ() {
        if (this.inf)
          return this.curve.jpoint(null, null, null);
        var res = this.curve.jpoint(this.x, this.y, this.curve.one);
        return res;
      };
      function JPoint(curve, x, y, z) {
        Base.BasePoint.call(this, curve, "jacobian");
        if (x === null && y === null && z === null) {
          this.x = this.curve.one;
          this.y = this.curve.one;
          this.z = new BN(0);
        } else {
          this.x = new BN(x, 16);
          this.y = new BN(y, 16);
          this.z = new BN(z, 16);
        }
        if (!this.x.red)
          this.x = this.x.toRed(this.curve.red);
        if (!this.y.red)
          this.y = this.y.toRed(this.curve.red);
        if (!this.z.red)
          this.z = this.z.toRed(this.curve.red);
        this.zOne = this.z === this.curve.one;
      }
      inherits(JPoint, Base.BasePoint);
      ShortCurve.prototype.jpoint = function jpoint(x, y, z) {
        return new JPoint(this, x, y, z);
      };
      JPoint.prototype.toP = function toP() {
        if (this.isInfinity())
          return this.curve.point(null, null);
        var zinv = this.z.redInvm();
        var zinv2 = zinv.redSqr();
        var ax = this.x.redMul(zinv2);
        var ay = this.y.redMul(zinv2).redMul(zinv);
        return this.curve.point(ax, ay);
      };
      JPoint.prototype.neg = function neg() {
        return this.curve.jpoint(this.x, this.y.redNeg(), this.z);
      };
      JPoint.prototype.add = function add(p) {
        if (this.isInfinity())
          return p;
        if (p.isInfinity())
          return this;
        var pz2 = p.z.redSqr();
        var z2 = this.z.redSqr();
        var u1 = this.x.redMul(pz2);
        var u2 = p.x.redMul(z2);
        var s1 = this.y.redMul(pz2.redMul(p.z));
        var s2 = p.y.redMul(z2.redMul(this.z));
        var h = u1.redSub(u2);
        var r = s1.redSub(s2);
        if (h.cmpn(0) === 0) {
          if (r.cmpn(0) !== 0)
            return this.curve.jpoint(null, null, null);
          else
            return this.dbl();
        }
        var h2 = h.redSqr();
        var h3 = h2.redMul(h);
        var v = u1.redMul(h2);
        var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v);
        var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3));
        var nz = this.z.redMul(p.z).redMul(h);
        return this.curve.jpoint(nx, ny, nz);
      };
      JPoint.prototype.mixedAdd = function mixedAdd(p) {
        if (this.isInfinity())
          return p.toJ();
        if (p.isInfinity())
          return this;
        var z2 = this.z.redSqr();
        var u1 = this.x;
        var u2 = p.x.redMul(z2);
        var s1 = this.y;
        var s2 = p.y.redMul(z2).redMul(this.z);
        var h = u1.redSub(u2);
        var r = s1.redSub(s2);
        if (h.cmpn(0) === 0) {
          if (r.cmpn(0) !== 0)
            return this.curve.jpoint(null, null, null);
          else
            return this.dbl();
        }
        var h2 = h.redSqr();
        var h3 = h2.redMul(h);
        var v = u1.redMul(h2);
        var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v);
        var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3));
        var nz = this.z.redMul(h);
        return this.curve.jpoint(nx, ny, nz);
      };
      JPoint.prototype.dblp = function dblp(pow) {
        if (pow === 0)
          return this;
        if (this.isInfinity())
          return this;
        if (!pow)
          return this.dbl();
        var i;
        if (this.curve.zeroA || this.curve.threeA) {
          var r = this;
          for (i = 0; i < pow; i++)
            r = r.dbl();
          return r;
        }
        var a = this.curve.a;
        var tinv = this.curve.tinv;
        var jx = this.x;
        var jy = this.y;
        var jz = this.z;
        var jz4 = jz.redSqr().redSqr();
        var jyd = jy.redAdd(jy);
        for (i = 0; i < pow; i++) {
          var jx2 = jx.redSqr();
          var jyd2 = jyd.redSqr();
          var jyd4 = jyd2.redSqr();
          var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4));
          var t1 = jx.redMul(jyd2);
          var nx = c.redSqr().redISub(t1.redAdd(t1));
          var t2 = t1.redISub(nx);
          var dny = c.redMul(t2);
          dny = dny.redIAdd(dny).redISub(jyd4);
          var nz = jyd.redMul(jz);
          if (i + 1 < pow)
            jz4 = jz4.redMul(jyd4);
          jx = nx;
          jz = nz;
          jyd = dny;
        }
        return this.curve.jpoint(jx, jyd.redMul(tinv), jz);
      };
      JPoint.prototype.dbl = function dbl() {
        if (this.isInfinity())
          return this;
        if (this.curve.zeroA)
          return this._zeroDbl();
        else if (this.curve.threeA)
          return this._threeDbl();
        else
          return this._dbl();
      };
      JPoint.prototype._zeroDbl = function _zeroDbl() {
        var nx;
        var ny;
        var nz;
        if (this.zOne) {
          var xx = this.x.redSqr();
          var yy = this.y.redSqr();
          var yyyy = yy.redSqr();
          var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);
          s = s.redIAdd(s);
          var m = xx.redAdd(xx).redIAdd(xx);
          var t = m.redSqr().redISub(s).redISub(s);
          var yyyy8 = yyyy.redIAdd(yyyy);
          yyyy8 = yyyy8.redIAdd(yyyy8);
          yyyy8 = yyyy8.redIAdd(yyyy8);
          nx = t;
          ny = m.redMul(s.redISub(t)).redISub(yyyy8);
          nz = this.y.redAdd(this.y);
        } else {
          var a = this.x.redSqr();
          var b = this.y.redSqr();
          var c = b.redSqr();
          var d = this.x.redAdd(b).redSqr().redISub(a).redISub(c);
          d = d.redIAdd(d);
          var e = a.redAdd(a).redIAdd(a);
          var f = e.redSqr();
          var c8 = c.redIAdd(c);
          c8 = c8.redIAdd(c8);
          c8 = c8.redIAdd(c8);
          nx = f.redISub(d).redISub(d);
          ny = e.redMul(d.redISub(nx)).redISub(c8);
          nz = this.y.redMul(this.z);
          nz = nz.redIAdd(nz);
        }
        return this.curve.jpoint(nx, ny, nz);
      };
      JPoint.prototype._threeDbl = function _threeDbl() {
        var nx;
        var ny;
        var nz;
        if (this.zOne) {
          var xx = this.x.redSqr();
          var yy = this.y.redSqr();
          var yyyy = yy.redSqr();
          var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);
          s = s.redIAdd(s);
          var m = xx.redAdd(xx).redIAdd(xx).redIAdd(this.curve.a);
          var t = m.redSqr().redISub(s).redISub(s);
          nx = t;
          var yyyy8 = yyyy.redIAdd(yyyy);
          yyyy8 = yyyy8.redIAdd(yyyy8);
          yyyy8 = yyyy8.redIAdd(yyyy8);
          ny = m.redMul(s.redISub(t)).redISub(yyyy8);
          nz = this.y.redAdd(this.y);
        } else {
          var delta = this.z.redSqr();
          var gamma = this.y.redSqr();
          var beta = this.x.redMul(gamma);
          var alpha = this.x.redSub(delta).redMul(this.x.redAdd(delta));
          alpha = alpha.redAdd(alpha).redIAdd(alpha);
          var beta4 = beta.redIAdd(beta);
          beta4 = beta4.redIAdd(beta4);
          var beta8 = beta4.redAdd(beta4);
          nx = alpha.redSqr().redISub(beta8);
          nz = this.y.redAdd(this.z).redSqr().redISub(gamma).redISub(delta);
          var ggamma8 = gamma.redSqr();
          ggamma8 = ggamma8.redIAdd(ggamma8);
          ggamma8 = ggamma8.redIAdd(ggamma8);
          ggamma8 = ggamma8.redIAdd(ggamma8);
          ny = alpha.redMul(beta4.redISub(nx)).redISub(ggamma8);
        }
        return this.curve.jpoint(nx, ny, nz);
      };
      JPoint.prototype._dbl = function _dbl() {
        var a = this.curve.a;
        var jx = this.x;
        var jy = this.y;
        var jz = this.z;
        var jz4 = jz.redSqr().redSqr();
        var jx2 = jx.redSqr();
        var jy2 = jy.redSqr();
        var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4));
        var jxd4 = jx.redAdd(jx);
        jxd4 = jxd4.redIAdd(jxd4);
        var t1 = jxd4.redMul(jy2);
        var nx = c.redSqr().redISub(t1.redAdd(t1));
        var t2 = t1.redISub(nx);
        var jyd8 = jy2.redSqr();
        jyd8 = jyd8.redIAdd(jyd8);
        jyd8 = jyd8.redIAdd(jyd8);
        jyd8 = jyd8.redIAdd(jyd8);
        var ny = c.redMul(t2).redISub(jyd8);
        var nz = jy.redAdd(jy).redMul(jz);
        return this.curve.jpoint(nx, ny, nz);
      };
      JPoint.prototype.trpl = function trpl() {
        if (!this.curve.zeroA)
          return this.dbl().add(this);
        var xx = this.x.redSqr();
        var yy = this.y.redSqr();
        var zz = this.z.redSqr();
        var yyyy = yy.redSqr();
        var m = xx.redAdd(xx).redIAdd(xx);
        var mm = m.redSqr();
        var e = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);
        e = e.redIAdd(e);
        e = e.redAdd(e).redIAdd(e);
        e = e.redISub(mm);
        var ee = e.redSqr();
        var t = yyyy.redIAdd(yyyy);
        t = t.redIAdd(t);
        t = t.redIAdd(t);
        t = t.redIAdd(t);
        var u = m.redIAdd(e).redSqr().redISub(mm).redISub(ee).redISub(t);
        var yyu4 = yy.redMul(u);
        yyu4 = yyu4.redIAdd(yyu4);
        yyu4 = yyu4.redIAdd(yyu4);
        var nx = this.x.redMul(ee).redISub(yyu4);
        nx = nx.redIAdd(nx);
        nx = nx.redIAdd(nx);
        var ny = this.y.redMul(u.redMul(t.redISub(u)).redISub(e.redMul(ee)));
        ny = ny.redIAdd(ny);
        ny = ny.redIAdd(ny);
        ny = ny.redIAdd(ny);
        var nz = this.z.redAdd(e).redSqr().redISub(zz).redISub(ee);
        return this.curve.jpoint(nx, ny, nz);
      };
      JPoint.prototype.mul = function mul(k, kbase) {
        k = new BN(k, kbase);
        return this.curve._wnafMul(this, k);
      };
      JPoint.prototype.eq = function eq(p) {
        if (p.type === "affine")
          return this.eq(p.toJ());
        if (this === p)
          return true;
        var z2 = this.z.redSqr();
        var pz2 = p.z.redSqr();
        if (this.x.redMul(pz2).redISub(p.x.redMul(z2)).cmpn(0) !== 0)
          return false;
        var z3 = z2.redMul(this.z);
        var pz3 = pz2.redMul(p.z);
        return this.y.redMul(pz3).redISub(p.y.redMul(z3)).cmpn(0) === 0;
      };
      JPoint.prototype.eqXToP = function eqXToP(x) {
        var zs = this.z.redSqr();
        var rx = x.toRed(this.curve.red).redMul(zs);
        if (this.x.cmp(rx) === 0)
          return true;
        var xc = x.clone();
        var t = this.curve.redN.redMul(zs);
        for (; ; ) {
          xc.iadd(this.curve.n);
          if (xc.cmp(this.curve.p) >= 0)
            return false;
          rx.redIAdd(t);
          if (this.x.cmp(rx) === 0)
            return true;
        }
      };
      JPoint.prototype.inspect = function inspect() {
        if (this.isInfinity())
          return "<EC JPoint Infinity>";
        return "<EC JPoint x: " + this.x.toString(16, 2) + " y: " + this.y.toString(16, 2) + " z: " + this.z.toString(16, 2) + ">";
      };
      JPoint.prototype.isInfinity = function isInfinity() {
        return this.z.cmpn(0) === 0;
      };
    }
  });

  // node_modules/elliptic/lib/elliptic/curve/mont.js
  var require_mont = __commonJS({
    "node_modules/elliptic/lib/elliptic/curve/mont.js"(exports2, module2) {
      "use strict";
      var BN = require_bn2();
      var inherits = require_inherits_browser();
      var Base = require_base();
      var utils = require_utils4();
      function MontCurve(conf) {
        Base.call(this, "mont", conf);
        this.a = new BN(conf.a, 16).toRed(this.red);
        this.b = new BN(conf.b, 16).toRed(this.red);
        this.i4 = new BN(4).toRed(this.red).redInvm();
        this.two = new BN(2).toRed(this.red);
        this.a24 = this.i4.redMul(this.a.redAdd(this.two));
      }
      inherits(MontCurve, Base);
      module2.exports = MontCurve;
      MontCurve.prototype.validate = function validate(point) {
        var x = point.normalize().x;
        var x2 = x.redSqr();
        var rhs = x2.redMul(x).redAdd(x2.redMul(this.a)).redAdd(x);
        var y = rhs.redSqrt();
        return y.redSqr().cmp(rhs) === 0;
      };
      function Point(curve, x, z) {
        Base.BasePoint.call(this, curve, "projective");
        if (x === null && z === null) {
          this.x = this.curve.one;
          this.z = this.curve.zero;
        } else {
          this.x = new BN(x, 16);
          this.z = new BN(z, 16);
          if (!this.x.red)
            this.x = this.x.toRed(this.curve.red);
          if (!this.z.red)
            this.z = this.z.toRed(this.curve.red);
        }
      }
      inherits(Point, Base.BasePoint);
      MontCurve.prototype.decodePoint = function decodePoint(bytes, enc) {
        return this.point(utils.toArray(bytes, enc), 1);
      };
      MontCurve.prototype.point = function point(x, z) {
        return new Point(this, x, z);
      };
      MontCurve.prototype.pointFromJSON = function pointFromJSON(obj) {
        return Point.fromJSON(this, obj);
      };
      Point.prototype.precompute = function precompute() {
      };
      Point.prototype._encode = function _encode() {
        return this.getX().toArray("be", this.curve.p.byteLength());
      };
      Point.fromJSON = function fromJSON(curve, obj) {
        return new Point(curve, obj[0], obj[1] || curve.one);
      };
      Point.prototype.inspect = function inspect() {
        if (this.isInfinity())
          return "<EC Point Infinity>";
        return "<EC Point x: " + this.x.fromRed().toString(16, 2) + " z: " + this.z.fromRed().toString(16, 2) + ">";
      };
      Point.prototype.isInfinity = function isInfinity() {
        return this.z.cmpn(0) === 0;
      };
      Point.prototype.dbl = function dbl() {
        var a = this.x.redAdd(this.z);
        var aa = a.redSqr();
        var b = this.x.redSub(this.z);
        var bb = b.redSqr();
        var c = aa.redSub(bb);
        var nx = aa.redMul(bb);
        var nz = c.redMul(bb.redAdd(this.curve.a24.redMul(c)));
        return this.curve.point(nx, nz);
      };
      Point.prototype.add = function add() {
        throw new Error("Not supported on Montgomery curve");
      };
      Point.prototype.diffAdd = function diffAdd(p, diff) {
        var a = this.x.redAdd(this.z);
        var b = this.x.redSub(this.z);
        var c = p.x.redAdd(p.z);
        var d = p.x.redSub(p.z);
        var da = d.redMul(a);
        var cb = c.redMul(b);
        var nx = diff.z.redMul(da.redAdd(cb).redSqr());
        var nz = diff.x.redMul(da.redISub(cb).redSqr());
        return this.curve.point(nx, nz);
      };
      Point.prototype.mul = function mul(k) {
        var t = k.clone();
        var a = this;
        var b = this.curve.point(null, null);
        var c = this;
        for (var bits = []; t.cmpn(0) !== 0; t.iushrn(1))
          bits.push(t.andln(1));
        for (var i = bits.length - 1; i >= 0; i--) {
          if (bits[i] === 0) {
            a = a.diffAdd(b, c);
            b = b.dbl();
          } else {
            b = a.diffAdd(b, c);
            a = a.dbl();
          }
        }
        return b;
      };
      Point.prototype.mulAdd = function mulAdd() {
        throw new Error("Not supported on Montgomery curve");
      };
      Point.prototype.jumlAdd = function jumlAdd() {
        throw new Error("Not supported on Montgomery curve");
      };
      Point.prototype.eq = function eq(other) {
        return this.getX().cmp(other.getX()) === 0;
      };
      Point.prototype.normalize = function normalize() {
        this.x = this.x.redMul(this.z.redInvm());
        this.z = this.curve.one;
        return this;
      };
      Point.prototype.getX = function getX() {
        this.normalize();
        return this.x.fromRed();
      };
    }
  });

  // node_modules/elliptic/lib/elliptic/curve/edwards.js
  var require_edwards = __commonJS({
    "node_modules/elliptic/lib/elliptic/curve/edwards.js"(exports2, module2) {
      "use strict";
      var utils = require_utils4();
      var BN = require_bn2();
      var inherits = require_inherits_browser();
      var Base = require_base();
      var assert = utils.assert;
      function EdwardsCurve(conf) {
        this.twisted = (conf.a | 0) !== 1;
        this.mOneA = this.twisted && (conf.a | 0) === -1;
        this.extended = this.mOneA;
        Base.call(this, "edwards", conf);
        this.a = new BN(conf.a, 16).umod(this.red.m);
        this.a = this.a.toRed(this.red);
        this.c = new BN(conf.c, 16).toRed(this.red);
        this.c2 = this.c.redSqr();
        this.d = new BN(conf.d, 16).toRed(this.red);
        this.dd = this.d.redAdd(this.d);
        assert(!this.twisted || this.c.fromRed().cmpn(1) === 0);
        this.oneC = (conf.c | 0) === 1;
      }
      inherits(EdwardsCurve, Base);
      module2.exports = EdwardsCurve;
      EdwardsCurve.prototype._mulA = function _mulA(num) {
        if (this.mOneA)
          return num.redNeg();
        else
          return this.a.redMul(num);
      };
      EdwardsCurve.prototype._mulC = function _mulC(num) {
        if (this.oneC)
          return num;
        else
          return this.c.redMul(num);
      };
      EdwardsCurve.prototype.jpoint = function jpoint(x, y, z, t) {
        return this.point(x, y, z, t);
      };
      EdwardsCurve.prototype.pointFromX = function pointFromX(x, odd) {
        x = new BN(x, 16);
        if (!x.red)
          x = x.toRed(this.red);
        var x2 = x.redSqr();
        var rhs = this.c2.redSub(this.a.redMul(x2));
        var lhs = this.one.redSub(this.c2.redMul(this.d).redMul(x2));
        var y2 = rhs.redMul(lhs.redInvm());
        var y = y2.redSqrt();
        if (y.redSqr().redSub(y2).cmp(this.zero) !== 0)
          throw new Error("invalid point");
        var isOdd = y.fromRed().isOdd();
        if (odd && !isOdd || !odd && isOdd)
          y = y.redNeg();
        return this.point(x, y);
      };
      EdwardsCurve.prototype.pointFromY = function pointFromY(y, odd) {
        y = new BN(y, 16);
        if (!y.red)
          y = y.toRed(this.red);
        var y2 = y.redSqr();
        var lhs = y2.redSub(this.c2);
        var rhs = y2.redMul(this.d).redMul(this.c2).redSub(this.a);
        var x2 = lhs.redMul(rhs.redInvm());
        if (x2.cmp(this.zero) === 0) {
          if (odd)
            throw new Error("invalid point");
          else
            return this.point(this.zero, y);
        }
        var x = x2.redSqrt();
        if (x.redSqr().redSub(x2).cmp(this.zero) !== 0)
          throw new Error("invalid point");
        if (x.fromRed().isOdd() !== odd)
          x = x.redNeg();
        return this.point(x, y);
      };
      EdwardsCurve.prototype.validate = function validate(point) {
        if (point.isInfinity())
          return true;
        point.normalize();
        var x2 = point.x.redSqr();
        var y2 = point.y.redSqr();
        var lhs = x2.redMul(this.a).redAdd(y2);
        var rhs = this.c2.redMul(this.one.redAdd(this.d.redMul(x2).redMul(y2)));
        return lhs.cmp(rhs) === 0;
      };
      function Point(curve, x, y, z, t) {
        Base.BasePoint.call(this, curve, "projective");
        if (x === null && y === null && z === null) {
          this.x = this.curve.zero;
          this.y = this.curve.one;
          this.z = this.curve.one;
          this.t = this.curve.zero;
          this.zOne = true;
        } else {
          this.x = new BN(x, 16);
          this.y = new BN(y, 16);
          this.z = z ? new BN(z, 16) : this.curve.one;
          this.t = t && new BN(t, 16);
          if (!this.x.red)
            this.x = this.x.toRed(this.curve.red);
          if (!this.y.red)
            this.y = this.y.toRed(this.curve.red);
          if (!this.z.red)
            this.z = this.z.toRed(this.curve.red);
          if (this.t && !this.t.red)
            this.t = this.t.toRed(this.curve.red);
          this.zOne = this.z === this.curve.one;
          if (this.curve.extended && !this.t) {
            this.t = this.x.redMul(this.y);
            if (!this.zOne)
              this.t = this.t.redMul(this.z.redInvm());
          }
        }
      }
      inherits(Point, Base.BasePoint);
      EdwardsCurve.prototype.pointFromJSON = function pointFromJSON(obj) {
        return Point.fromJSON(this, obj);
      };
      EdwardsCurve.prototype.point = function point(x, y, z, t) {
        return new Point(this, x, y, z, t);
      };
      Point.fromJSON = function fromJSON(curve, obj) {
        return new Point(curve, obj[0], obj[1], obj[2]);
      };
      Point.prototype.inspect = function inspect() {
        if (this.isInfinity())
          return "<EC Point Infinity>";
        return "<EC Point x: " + this.x.fromRed().toString(16, 2) + " y: " + this.y.fromRed().toString(16, 2) + " z: " + this.z.fromRed().toString(16, 2) + ">";
      };
      Point.prototype.isInfinity = function isInfinity() {
        return this.x.cmpn(0) === 0 && (this.y.cmp(this.z) === 0 || this.zOne && this.y.cmp(this.curve.c) === 0);
      };
      Point.prototype._extDbl = function _extDbl() {
        var a = this.x.redSqr();
        var b = this.y.redSqr();
        var c = this.z.redSqr();
        c = c.redIAdd(c);
        var d = this.curve._mulA(a);
        var e = this.x.redAdd(this.y).redSqr().redISub(a).redISub(b);
        var g = d.redAdd(b);
        var f = g.redSub(c);
        var h = d.redSub(b);
        var nx = e.redMul(f);
        var ny = g.redMul(h);
        var nt = e.redMul(h);
        var nz = f.redMul(g);
        return this.curve.point(nx, ny, nz, nt);
      };
      Point.prototype._projDbl = function _projDbl() {
        var b = this.x.redAdd(this.y).redSqr();
        var c = this.x.redSqr();
        var d = this.y.redSqr();
        var nx;
        var ny;
        var nz;
        var e;
        var h;
        var j;
        if (this.curve.twisted) {
          e = this.curve._mulA(c);
          var f = e.redAdd(d);
          if (this.zOne) {
            nx = b.redSub(c).redSub(d).redMul(f.redSub(this.curve.two));
            ny = f.redMul(e.redSub(d));
            nz = f.redSqr().redSub(f).redSub(f);
          } else {
            h = this.z.redSqr();
            j = f.redSub(h).redISub(h);
            nx = b.redSub(c).redISub(d).redMul(j);
            ny = f.redMul(e.redSub(d));
            nz = f.redMul(j);
          }
        } else {
          e = c.redAdd(d);
          h = this.curve._mulC(this.z).redSqr();
          j = e.redSub(h).redSub(h);
          nx = this.curve._mulC(b.redISub(e)).redMul(j);
          ny = this.curve._mulC(e).redMul(c.redISub(d));
          nz = e.redMul(j);
        }
        return this.curve.point(nx, ny, nz);
      };
      Point.prototype.dbl = function dbl() {
        if (this.isInfinity())
          return this;
        if (this.curve.extended)
          return this._extDbl();
        else
          return this._projDbl();
      };
      Point.prototype._extAdd = function _extAdd(p) {
        var a = this.y.redSub(this.x).redMul(p.y.redSub(p.x));
        var b = this.y.redAdd(this.x).redMul(p.y.redAdd(p.x));
        var c = this.t.redMul(this.curve.dd).redMul(p.t);
        var d = this.z.redMul(p.z.redAdd(p.z));
        var e = b.redSub(a);
        var f = d.redSub(c);
        var g = d.redAdd(c);
        var h = b.redAdd(a);
        var nx = e.redMul(f);
        var ny = g.redMul(h);
        var nt = e.redMul(h);
        var nz = f.redMul(g);
        return this.curve.point(nx, ny, nz, nt);
      };
      Point.prototype._projAdd = function _projAdd(p) {
        var a = this.z.redMul(p.z);
        var b = a.redSqr();
        var c = this.x.redMul(p.x);
        var d = this.y.redMul(p.y);
        var e = this.curve.d.redMul(c).redMul(d);
        var f = b.redSub(e);
        var g = b.redAdd(e);
        var tmp = this.x.redAdd(this.y).redMul(p.x.redAdd(p.y)).redISub(c).redISub(d);
        var nx = a.redMul(f).redMul(tmp);
        var ny;
        var nz;
        if (this.curve.twisted) {
          ny = a.redMul(g).redMul(d.redSub(this.curve._mulA(c)));
          nz = f.redMul(g);
        } else {
          ny = a.redMul(g).redMul(d.redSub(c));
          nz = this.curve._mulC(f).redMul(g);
        }
        return this.curve.point(nx, ny, nz);
      };
      Point.prototype.add = function add(p) {
        if (this.isInfinity())
          return p;
        if (p.isInfinity())
          return this;
        if (this.curve.extended)
          return this._extAdd(p);
        else
          return this._projAdd(p);
      };
      Point.prototype.mul = function mul(k) {
        if (this._hasDoubles(k))
          return this.curve._fixedNafMul(this, k);
        else
          return this.curve._wnafMul(this, k);
      };
      Point.prototype.mulAdd = function mulAdd(k1, p, k2) {
        return this.curve._wnafMulAdd(1, [this, p], [k1, k2], 2, false);
      };
      Point.prototype.jmulAdd = function jmulAdd(k1, p, k2) {
        return this.curve._wnafMulAdd(1, [this, p], [k1, k2], 2, true);
      };
      Point.prototype.normalize = function normalize() {
        if (this.zOne)
          return this;
        var zi = this.z.redInvm();
        this.x = this.x.redMul(zi);
        this.y = this.y.redMul(zi);
        if (this.t)
          this.t = this.t.redMul(zi);
        this.z = this.curve.one;
        this.zOne = true;
        return this;
      };
      Point.prototype.neg = function neg() {
        return this.curve.point(this.x.redNeg(), this.y, this.z, this.t && this.t.redNeg());
      };
      Point.prototype.getX = function getX() {
        this.normalize();
        return this.x.fromRed();
      };
      Point.prototype.getY = function getY() {
        this.normalize();
        return this.y.fromRed();
      };
      Point.prototype.eq = function eq(other) {
        return this === other || this.getX().cmp(other.getX()) === 0 && this.getY().cmp(other.getY()) === 0;
      };
      Point.prototype.eqXToP = function eqXToP(x) {
        var rx = x.toRed(this.curve.red).redMul(this.z);
        if (this.x.cmp(rx) === 0)
          return true;
        var xc = x.clone();
        var t = this.curve.redN.redMul(this.z);
        for (; ; ) {
          xc.iadd(this.curve.n);
          if (xc.cmp(this.curve.p) >= 0)
            return false;
          rx.redIAdd(t);
          if (this.x.cmp(rx) === 0)
            return true;
        }
      };
      Point.prototype.toP = Point.prototype.normalize;
      Point.prototype.mixedAdd = Point.prototype.add;
    }
  });

  // node_modules/elliptic/lib/elliptic/curve/index.js
  var require_curve = __commonJS({
    "node_modules/elliptic/lib/elliptic/curve/index.js"(exports2) {
      "use strict";
      var curve = exports2;
      curve.base = require_base();
      curve.short = require_short();
      curve.mont = require_mont();
      curve.edwards = require_edwards();
    }
  });

  // node_modules/hash.js/lib/hash/utils.js
  var require_utils5 = __commonJS({
    "node_modules/hash.js/lib/hash/utils.js"(exports2) {
      "use strict";
      var assert = require_minimalistic_assert();
      var inherits = require_inherits_browser();
      exports2.inherits = inherits;
      function isSurrogatePair(msg, i) {
        if ((msg.charCodeAt(i) & 64512) !== 55296) {
          return false;
        }
        if (i < 0 || i + 1 >= msg.length) {
          return false;
        }
        return (msg.charCodeAt(i + 1) & 64512) === 56320;
      }
      function toArray(msg, enc) {
        if (Array.isArray(msg))
          return msg.slice();
        if (!msg)
          return [];
        var res = [];
        if (typeof msg === "string") {
          if (!enc) {
            var p = 0;
            for (var i = 0; i < msg.length; i++) {
              var c = msg.charCodeAt(i);
              if (c < 128) {
                res[p++] = c;
              } else if (c < 2048) {
                res[p++] = c >> 6 | 192;
                res[p++] = c & 63 | 128;
              } else if (isSurrogatePair(msg, i)) {
                c = 65536 + ((c & 1023) << 10) + (msg.charCodeAt(++i) & 1023);
                res[p++] = c >> 18 | 240;
                res[p++] = c >> 12 & 63 | 128;
                res[p++] = c >> 6 & 63 | 128;
                res[p++] = c & 63 | 128;
              } else {
                res[p++] = c >> 12 | 224;
                res[p++] = c >> 6 & 63 | 128;
                res[p++] = c & 63 | 128;
              }
            }
          } else if (enc === "hex") {
            msg = msg.replace(/[^a-z0-9]+/ig, "");
            if (msg.length % 2 !== 0)
              msg = "0" + msg;
            for (i = 0; i < msg.length; i += 2)
              res.push(parseInt(msg[i] + msg[i + 1], 16));
          }
        } else {
          for (i = 0; i < msg.length; i++)
            res[i] = msg[i] | 0;
        }
        return res;
      }
      exports2.toArray = toArray;
      function toHex(msg) {
        var res = "";
        for (var i = 0; i < msg.length; i++)
          res += zero2(msg[i].toString(16));
        return res;
      }
      exports2.toHex = toHex;
      function htonl(w) {
        var res = w >>> 24 | w >>> 8 & 65280 | w << 8 & 16711680 | (w & 255) << 24;
        return res >>> 0;
      }
      exports2.htonl = htonl;
      function toHex32(msg, endian) {
        var res = "";
        for (var i = 0; i < msg.length; i++) {
          var w = msg[i];
          if (endian === "little")
            w = htonl(w);
          res += zero8(w.toString(16));
        }
        return res;
      }
      exports2.toHex32 = toHex32;
      function zero2(word) {
        if (word.length === 1)
          return "0" + word;
        else
          return word;
      }
      exports2.zero2 = zero2;
      function zero8(word) {
        if (word.length === 7)
          return "0" + word;
        else if (word.length === 6)
          return "00" + word;
        else if (word.length === 5)
          return "000" + word;
        else if (word.length === 4)
          return "0000" + word;
        else if (word.length === 3)
          return "00000" + word;
        else if (word.length === 2)
          return "000000" + word;
        else if (word.length === 1)
          return "0000000" + word;
        else
          return word;
      }
      exports2.zero8 = zero8;
      function join32(msg, start2, end, endian) {
        var len = end - start2;
        assert(len % 4 === 0);
        var res = new Array(len / 4);
        for (var i = 0, k = start2; i < res.length; i++, k += 4) {
          var w;
          if (endian === "big")
            w = msg[k] << 24 | msg[k + 1] << 16 | msg[k + 2] << 8 | msg[k + 3];
          else
            w = msg[k + 3] << 24 | msg[k + 2] << 16 | msg[k + 1] << 8 | msg[k];
          res[i] = w >>> 0;
        }
        return res;
      }
      exports2.join32 = join32;
      function split32(msg, endian) {
        var res = new Array(msg.length * 4);
        for (var i = 0, k = 0; i < msg.length; i++, k += 4) {
          var m = msg[i];
          if (endian === "big") {
            res[k] = m >>> 24;
            res[k + 1] = m >>> 16 & 255;
            res[k + 2] = m >>> 8 & 255;
            res[k + 3] = m & 255;
          } else {
            res[k + 3] = m >>> 24;
            res[k + 2] = m >>> 16 & 255;
            res[k + 1] = m >>> 8 & 255;
            res[k] = m & 255;
          }
        }
        return res;
      }
      exports2.split32 = split32;
      function rotr32(w, b) {
        return w >>> b | w << 32 - b;
      }
      exports2.rotr32 = rotr32;
      function rotl32(w, b) {
        return w << b | w >>> 32 - b;
      }
      exports2.rotl32 = rotl32;
      function sum32(a, b) {
        return a + b >>> 0;
      }
      exports2.sum32 = sum32;
      function sum32_3(a, b, c) {
        return a + b + c >>> 0;
      }
      exports2.sum32_3 = sum32_3;
      function sum32_4(a, b, c, d) {
        return a + b + c + d >>> 0;
      }
      exports2.sum32_4 = sum32_4;
      function sum32_5(a, b, c, d, e) {
        return a + b + c + d + e >>> 0;
      }
      exports2.sum32_5 = sum32_5;
      function sum64(buf, pos, ah, al) {
        var bh = buf[pos];
        var bl = buf[pos + 1];
        var lo = al + bl >>> 0;
        var hi = (lo < al ? 1 : 0) + ah + bh;
        buf[pos] = hi >>> 0;
        buf[pos + 1] = lo;
      }
      exports2.sum64 = sum64;
      function sum64_hi(ah, al, bh, bl) {
        var lo = al + bl >>> 0;
        var hi = (lo < al ? 1 : 0) + ah + bh;
        return hi >>> 0;
      }
      exports2.sum64_hi = sum64_hi;
      function sum64_lo(ah, al, bh, bl) {
        var lo = al + bl;
        return lo >>> 0;
      }
      exports2.sum64_lo = sum64_lo;
      function sum64_4_hi(ah, al, bh, bl, ch, cl, dh, dl) {
        var carry = 0;
        var lo = al;
        lo = lo + bl >>> 0;
        carry += lo < al ? 1 : 0;
        lo = lo + cl >>> 0;
        carry += lo < cl ? 1 : 0;
        lo = lo + dl >>> 0;
        carry += lo < dl ? 1 : 0;
        var hi = ah + bh + ch + dh + carry;
        return hi >>> 0;
      }
      exports2.sum64_4_hi = sum64_4_hi;
      function sum64_4_lo(ah, al, bh, bl, ch, cl, dh, dl) {
        var lo = al + bl + cl + dl;
        return lo >>> 0;
      }
      exports2.sum64_4_lo = sum64_4_lo;
      function sum64_5_hi(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
        var carry = 0;
        var lo = al;
        lo = lo + bl >>> 0;
        carry += lo < al ? 1 : 0;
        lo = lo + cl >>> 0;
        carry += lo < cl ? 1 : 0;
        lo = lo + dl >>> 0;
        carry += lo < dl ? 1 : 0;
        lo = lo + el >>> 0;
        carry += lo < el ? 1 : 0;
        var hi = ah + bh + ch + dh + eh + carry;
        return hi >>> 0;
      }
      exports2.sum64_5_hi = sum64_5_hi;
      function sum64_5_lo(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
        var lo = al + bl + cl + dl + el;
        return lo >>> 0;
      }
      exports2.sum64_5_lo = sum64_5_lo;
      function rotr64_hi(ah, al, num) {
        var r = al << 32 - num | ah >>> num;
        return r >>> 0;
      }
      exports2.rotr64_hi = rotr64_hi;
      function rotr64_lo(ah, al, num) {
        var r = ah << 32 - num | al >>> num;
        return r >>> 0;
      }
      exports2.rotr64_lo = rotr64_lo;
      function shr64_hi(ah, al, num) {
        return ah >>> num;
      }
      exports2.shr64_hi = shr64_hi;
      function shr64_lo(ah, al, num) {
        var r = ah << 32 - num | al >>> num;
        return r >>> 0;
      }
      exports2.shr64_lo = shr64_lo;
    }
  });

  // node_modules/hash.js/lib/hash/common.js
  var require_common = __commonJS({
    "node_modules/hash.js/lib/hash/common.js"(exports2) {
      "use strict";
      var utils = require_utils5();
      var assert = require_minimalistic_assert();
      function BlockHash() {
        this.pending = null;
        this.pendingTotal = 0;
        this.blockSize = this.constructor.blockSize;
        this.outSize = this.constructor.outSize;
        this.hmacStrength = this.constructor.hmacStrength;
        this.padLength = this.constructor.padLength / 8;
        this.endian = "big";
        this._delta8 = this.blockSize / 8;
        this._delta32 = this.blockSize / 32;
      }
      exports2.BlockHash = BlockHash;
      BlockHash.prototype.update = function update(msg, enc) {
        msg = utils.toArray(msg, enc);
        if (!this.pending)
          this.pending = msg;
        else
          this.pending = this.pending.concat(msg);
        this.pendingTotal += msg.length;
        if (this.pending.length >= this._delta8) {
          msg = this.pending;
          var r = msg.length % this._delta8;
          this.pending = msg.slice(msg.length - r, msg.length);
          if (this.pending.length === 0)
            this.pending = null;
          msg = utils.join32(msg, 0, msg.length - r, this.endian);
          for (var i = 0; i < msg.length; i += this._delta32)
            this._update(msg, i, i + this._delta32);
        }
        return this;
      };
      BlockHash.prototype.digest = function digest(enc) {
        this.update(this._pad());
        assert(this.pending === null);
        return this._digest(enc);
      };
      BlockHash.prototype._pad = function pad() {
        var len = this.pendingTotal;
        var bytes = this._delta8;
        var k = bytes - (len + this.padLength) % bytes;
        var res = new Array(k + this.padLength);
        res[0] = 128;
        for (var i = 1; i < k; i++)
          res[i] = 0;
        len <<= 3;
        if (this.endian === "big") {
          for (var t = 8; t < this.padLength; t++)
            res[i++] = 0;
          res[i++] = 0;
          res[i++] = 0;
          res[i++] = 0;
          res[i++] = 0;
          res[i++] = len >>> 24 & 255;
          res[i++] = len >>> 16 & 255;
          res[i++] = len >>> 8 & 255;
          res[i++] = len & 255;
        } else {
          res[i++] = len & 255;
          res[i++] = len >>> 8 & 255;
          res[i++] = len >>> 16 & 255;
          res[i++] = len >>> 24 & 255;
          res[i++] = 0;
          res[i++] = 0;
          res[i++] = 0;
          res[i++] = 0;
          for (t = 8; t < this.padLength; t++)
            res[i++] = 0;
        }
        return res;
      };
    }
  });

  // node_modules/hash.js/lib/hash/sha/common.js
  var require_common2 = __commonJS({
    "node_modules/hash.js/lib/hash/sha/common.js"(exports2) {
      "use strict";
      var utils = require_utils5();
      var rotr32 = utils.rotr32;
      function ft_1(s, x, y, z) {
        if (s === 0)
          return ch32(x, y, z);
        if (s === 1 || s === 3)
          return p32(x, y, z);
        if (s === 2)
          return maj32(x, y, z);
      }
      exports2.ft_1 = ft_1;
      function ch32(x, y, z) {
        return x & y ^ ~x & z;
      }
      exports2.ch32 = ch32;
      function maj32(x, y, z) {
        return x & y ^ x & z ^ y & z;
      }
      exports2.maj32 = maj32;
      function p32(x, y, z) {
        return x ^ y ^ z;
      }
      exports2.p32 = p32;
      function s0_256(x) {
        return rotr32(x, 2) ^ rotr32(x, 13) ^ rotr32(x, 22);
      }
      exports2.s0_256 = s0_256;
      function s1_256(x) {
        return rotr32(x, 6) ^ rotr32(x, 11) ^ rotr32(x, 25);
      }
      exports2.s1_256 = s1_256;
      function g0_256(x) {
        return rotr32(x, 7) ^ rotr32(x, 18) ^ x >>> 3;
      }
      exports2.g0_256 = g0_256;
      function g1_256(x) {
        return rotr32(x, 17) ^ rotr32(x, 19) ^ x >>> 10;
      }
      exports2.g1_256 = g1_256;
    }
  });

  // node_modules/hash.js/lib/hash/sha/1.js
  var require__ = __commonJS({
    "node_modules/hash.js/lib/hash/sha/1.js"(exports2, module2) {
      "use strict";
      var utils = require_utils5();
      var common = require_common();
      var shaCommon = require_common2();
      var rotl32 = utils.rotl32;
      var sum32 = utils.sum32;
      var sum32_5 = utils.sum32_5;
      var ft_1 = shaCommon.ft_1;
      var BlockHash = common.BlockHash;
      var sha1_K = [
        1518500249,
        1859775393,
        2400959708,
        3395469782
      ];
      function SHA1() {
        if (!(this instanceof SHA1))
          return new SHA1();
        BlockHash.call(this);
        this.h = [
          1732584193,
          4023233417,
          2562383102,
          271733878,
          3285377520
        ];
        this.W = new Array(80);
      }
      utils.inherits(SHA1, BlockHash);
      module2.exports = SHA1;
      SHA1.blockSize = 512;
      SHA1.outSize = 160;
      SHA1.hmacStrength = 80;
      SHA1.padLength = 64;
      SHA1.prototype._update = function _update(msg, start2) {
        var W = this.W;
        for (var i = 0; i < 16; i++)
          W[i] = msg[start2 + i];
        for (; i < W.length; i++)
          W[i] = rotl32(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16], 1);
        var a = this.h[0];
        var b = this.h[1];
        var c = this.h[2];
        var d = this.h[3];
        var e = this.h[4];
        for (i = 0; i < W.length; i++) {
          var s = ~~(i / 20);
          var t = sum32_5(rotl32(a, 5), ft_1(s, b, c, d), e, W[i], sha1_K[s]);
          e = d;
          d = c;
          c = rotl32(b, 30);
          b = a;
          a = t;
        }
        this.h[0] = sum32(this.h[0], a);
        this.h[1] = sum32(this.h[1], b);
        this.h[2] = sum32(this.h[2], c);
        this.h[3] = sum32(this.h[3], d);
        this.h[4] = sum32(this.h[4], e);
      };
      SHA1.prototype._digest = function digest(enc) {
        if (enc === "hex")
          return utils.toHex32(this.h, "big");
        else
          return utils.split32(this.h, "big");
      };
    }
  });

  // node_modules/hash.js/lib/hash/sha/256.js
  var require__2 = __commonJS({
    "node_modules/hash.js/lib/hash/sha/256.js"(exports2, module2) {
      "use strict";
      var utils = require_utils5();
      var common = require_common();
      var shaCommon = require_common2();
      var assert = require_minimalistic_assert();
      var sum32 = utils.sum32;
      var sum32_4 = utils.sum32_4;
      var sum32_5 = utils.sum32_5;
      var ch32 = shaCommon.ch32;
      var maj32 = shaCommon.maj32;
      var s0_256 = shaCommon.s0_256;
      var s1_256 = shaCommon.s1_256;
      var g0_256 = shaCommon.g0_256;
      var g1_256 = shaCommon.g1_256;
      var BlockHash = common.BlockHash;
      var sha256_K = [
        1116352408,
        1899447441,
        3049323471,
        3921009573,
        961987163,
        1508970993,
        2453635748,
        2870763221,
        3624381080,
        310598401,
        607225278,
        1426881987,
        1925078388,
        2162078206,
        2614888103,
        3248222580,
        3835390401,
        4022224774,
        264347078,
        604807628,
        770255983,
        1249150122,
        1555081692,
        1996064986,
        2554220882,
        2821834349,
        2952996808,
        3210313671,
        3336571891,
        3584528711,
        113926993,
        338241895,
        666307205,
        773529912,
        1294757372,
        1396182291,
        1695183700,
        1986661051,
        2177026350,
        2456956037,
        2730485921,
        2820302411,
        3259730800,
        3345764771,
        3516065817,
        3600352804,
        4094571909,
        275423344,
        430227734,
        506948616,
        659060556,
        883997877,
        958139571,
        1322822218,
        1537002063,
        1747873779,
        1955562222,
        2024104815,
        2227730452,
        2361852424,
        2428436474,
        2756734187,
        3204031479,
        3329325298
      ];
      function SHA256() {
        if (!(this instanceof SHA256))
          return new SHA256();
        BlockHash.call(this);
        this.h = [
          1779033703,
          3144134277,
          1013904242,
          2773480762,
          1359893119,
          2600822924,
          528734635,
          1541459225
        ];
        this.k = sha256_K;
        this.W = new Array(64);
      }
      utils.inherits(SHA256, BlockHash);
      module2.exports = SHA256;
      SHA256.blockSize = 512;
      SHA256.outSize = 256;
      SHA256.hmacStrength = 192;
      SHA256.padLength = 64;
      SHA256.prototype._update = function _update(msg, start2) {
        var W = this.W;
        for (var i = 0; i < 16; i++)
          W[i] = msg[start2 + i];
        for (; i < W.length; i++)
          W[i] = sum32_4(g1_256(W[i - 2]), W[i - 7], g0_256(W[i - 15]), W[i - 16]);
        var a = this.h[0];
        var b = this.h[1];
        var c = this.h[2];
        var d = this.h[3];
        var e = this.h[4];
        var f = this.h[5];
        var g = this.h[6];
        var h = this.h[7];
        assert(this.k.length === W.length);
        for (i = 0; i < W.length; i++) {
          var T1 = sum32_5(h, s1_256(e), ch32(e, f, g), this.k[i], W[i]);
          var T2 = sum32(s0_256(a), maj32(a, b, c));
          h = g;
          g = f;
          f = e;
          e = sum32(d, T1);
          d = c;
          c = b;
          b = a;
          a = sum32(T1, T2);
        }
        this.h[0] = sum32(this.h[0], a);
        this.h[1] = sum32(this.h[1], b);
        this.h[2] = sum32(this.h[2], c);
        this.h[3] = sum32(this.h[3], d);
        this.h[4] = sum32(this.h[4], e);
        this.h[5] = sum32(this.h[5], f);
        this.h[6] = sum32(this.h[6], g);
        this.h[7] = sum32(this.h[7], h);
      };
      SHA256.prototype._digest = function digest(enc) {
        if (enc === "hex")
          return utils.toHex32(this.h, "big");
        else
          return utils.split32(this.h, "big");
      };
    }
  });

  // node_modules/hash.js/lib/hash/sha/224.js
  var require__3 = __commonJS({
    "node_modules/hash.js/lib/hash/sha/224.js"(exports2, module2) {
      "use strict";
      var utils = require_utils5();
      var SHA256 = require__2();
      function SHA224() {
        if (!(this instanceof SHA224))
          return new SHA224();
        SHA256.call(this);
        this.h = [
          3238371032,
          914150663,
          812702999,
          4144912697,
          4290775857,
          1750603025,
          1694076839,
          3204075428
        ];
      }
      utils.inherits(SHA224, SHA256);
      module2.exports = SHA224;
      SHA224.blockSize = 512;
      SHA224.outSize = 224;
      SHA224.hmacStrength = 192;
      SHA224.padLength = 64;
      SHA224.prototype._digest = function digest(enc) {
        if (enc === "hex")
          return utils.toHex32(this.h.slice(0, 7), "big");
        else
          return utils.split32(this.h.slice(0, 7), "big");
      };
    }
  });

  // node_modules/hash.js/lib/hash/sha/512.js
  var require__4 = __commonJS({
    "node_modules/hash.js/lib/hash/sha/512.js"(exports2, module2) {
      "use strict";
      var utils = require_utils5();
      var common = require_common();
      var assert = require_minimalistic_assert();
      var rotr64_hi = utils.rotr64_hi;
      var rotr64_lo = utils.rotr64_lo;
      var shr64_hi = utils.shr64_hi;
      var shr64_lo = utils.shr64_lo;
      var sum64 = utils.sum64;
      var sum64_hi = utils.sum64_hi;
      var sum64_lo = utils.sum64_lo;
      var sum64_4_hi = utils.sum64_4_hi;
      var sum64_4_lo = utils.sum64_4_lo;
      var sum64_5_hi = utils.sum64_5_hi;
      var sum64_5_lo = utils.sum64_5_lo;
      var BlockHash = common.BlockHash;
      var sha512_K = [
        1116352408,
        3609767458,
        1899447441,
        602891725,
        3049323471,
        3964484399,
        3921009573,
        2173295548,
        961987163,
        4081628472,
        1508970993,
        3053834265,
        2453635748,
        2937671579,
        2870763221,
        3664609560,
        3624381080,
        2734883394,
        310598401,
        1164996542,
        607225278,
        1323610764,
        1426881987,
        3590304994,
        1925078388,
        4068182383,
        2162078206,
        991336113,
        2614888103,
        633803317,
        3248222580,
        3479774868,
        3835390401,
        2666613458,
        4022224774,
        944711139,
        264347078,
        2341262773,
        604807628,
        2007800933,
        770255983,
        1495990901,
        1249150122,
        1856431235,
        1555081692,
        3175218132,
        1996064986,
        2198950837,
        2554220882,
        3999719339,
        2821834349,
        766784016,
        2952996808,
        2566594879,
        3210313671,
        3203337956,
        3336571891,
        1034457026,
        3584528711,
        2466948901,
        113926993,
        3758326383,
        338241895,
        168717936,
        666307205,
        1188179964,
        773529912,
        1546045734,
        1294757372,
        1522805485,
        1396182291,
        2643833823,
        1695183700,
        2343527390,
        1986661051,
        1014477480,
        2177026350,
        1206759142,
        2456956037,
        344077627,
        2730485921,
        1290863460,
        2820302411,
        3158454273,
        3259730800,
        3505952657,
        3345764771,
        106217008,
        3516065817,
        3606008344,
        3600352804,
        1432725776,
        4094571909,
        1467031594,
        275423344,
        851169720,
        430227734,
        3100823752,
        506948616,
        1363258195,
        659060556,
        3750685593,
        883997877,
        3785050280,
        958139571,
        3318307427,
        1322822218,
        3812723403,
        1537002063,
        2003034995,
        1747873779,
        3602036899,
        1955562222,
        1575990012,
        2024104815,
        1125592928,
        2227730452,
        2716904306,
        2361852424,
        442776044,
        2428436474,
        593698344,
        2756734187,
        3733110249,
        3204031479,
        2999351573,
        3329325298,
        3815920427,
        3391569614,
        3928383900,
        3515267271,
        566280711,
        3940187606,
        3454069534,
        4118630271,
        4000239992,
        116418474,
        1914138554,
        174292421,
        2731055270,
        289380356,
        3203993006,
        460393269,
        320620315,
        685471733,
        587496836,
        852142971,
        1086792851,
        1017036298,
        365543100,
        1126000580,
        2618297676,
        1288033470,
        3409855158,
        1501505948,
        4234509866,
        1607167915,
        987167468,
        1816402316,
        1246189591
      ];
      function SHA512() {
        if (!(this instanceof SHA512))
          return new SHA512();
        BlockHash.call(this);
        this.h = [
          1779033703,
          4089235720,
          3144134277,
          2227873595,
          1013904242,
          4271175723,
          2773480762,
          1595750129,
          1359893119,
          2917565137,
          2600822924,
          725511199,
          528734635,
          4215389547,
          1541459225,
          327033209
        ];
        this.k = sha512_K;
        this.W = new Array(160);
      }
      utils.inherits(SHA512, BlockHash);
      module2.exports = SHA512;
      SHA512.blockSize = 1024;
      SHA512.outSize = 512;
      SHA512.hmacStrength = 192;
      SHA512.padLength = 128;
      SHA512.prototype._prepareBlock = function _prepareBlock(msg, start2) {
        var W = this.W;
        for (var i = 0; i < 32; i++)
          W[i] = msg[start2 + i];
        for (; i < W.length; i += 2) {
          var c0_hi = g1_512_hi(W[i - 4], W[i - 3]);
          var c0_lo = g1_512_lo(W[i - 4], W[i - 3]);
          var c1_hi = W[i - 14];
          var c1_lo = W[i - 13];
          var c2_hi = g0_512_hi(W[i - 30], W[i - 29]);
          var c2_lo = g0_512_lo(W[i - 30], W[i - 29]);
          var c3_hi = W[i - 32];
          var c3_lo = W[i - 31];
          W[i] = sum64_4_hi(c0_hi, c0_lo, c1_hi, c1_lo, c2_hi, c2_lo, c3_hi, c3_lo);
          W[i + 1] = sum64_4_lo(c0_hi, c0_lo, c1_hi, c1_lo, c2_hi, c2_lo, c3_hi, c3_lo);
        }
      };
      SHA512.prototype._update = function _update(msg, start2) {
        this._prepareBlock(msg, start2);
        var W = this.W;
        var ah = this.h[0];
        var al = this.h[1];
        var bh = this.h[2];
        var bl = this.h[3];
        var ch = this.h[4];
        var cl = this.h[5];
        var dh = this.h[6];
        var dl = this.h[7];
        var eh = this.h[8];
        var el = this.h[9];
        var fh = this.h[10];
        var fl = this.h[11];
        var gh = this.h[12];
        var gl = this.h[13];
        var hh = this.h[14];
        var hl = this.h[15];
        assert(this.k.length === W.length);
        for (var i = 0; i < W.length; i += 2) {
          var c0_hi = hh;
          var c0_lo = hl;
          var c1_hi = s1_512_hi(eh, el);
          var c1_lo = s1_512_lo(eh, el);
          var c2_hi = ch64_hi(eh, el, fh, fl, gh, gl);
          var c2_lo = ch64_lo(eh, el, fh, fl, gh, gl);
          var c3_hi = this.k[i];
          var c3_lo = this.k[i + 1];
          var c4_hi = W[i];
          var c4_lo = W[i + 1];
          var T1_hi = sum64_5_hi(c0_hi, c0_lo, c1_hi, c1_lo, c2_hi, c2_lo, c3_hi, c3_lo, c4_hi, c4_lo);
          var T1_lo = sum64_5_lo(c0_hi, c0_lo, c1_hi, c1_lo, c2_hi, c2_lo, c3_hi, c3_lo, c4_hi, c4_lo);
          c0_hi = s0_512_hi(ah, al);
          c0_lo = s0_512_lo(ah, al);
          c1_hi = maj64_hi(ah, al, bh, bl, ch, cl);
          c1_lo = maj64_lo(ah, al, bh, bl, ch, cl);
          var T2_hi = sum64_hi(c0_hi, c0_lo, c1_hi, c1_lo);
          var T2_lo = sum64_lo(c0_hi, c0_lo, c1_hi, c1_lo);
          hh = gh;
          hl = gl;
          gh = fh;
          gl = fl;
          fh = eh;
          fl = el;
          eh = sum64_hi(dh, dl, T1_hi, T1_lo);
          el = sum64_lo(dl, dl, T1_hi, T1_lo);
          dh = ch;
          dl = cl;
          ch = bh;
          cl = bl;
          bh = ah;
          bl = al;
          ah = sum64_hi(T1_hi, T1_lo, T2_hi, T2_lo);
          al = sum64_lo(T1_hi, T1_lo, T2_hi, T2_lo);
        }
        sum64(this.h, 0, ah, al);
        sum64(this.h, 2, bh, bl);
        sum64(this.h, 4, ch, cl);
        sum64(this.h, 6, dh, dl);
        sum64(this.h, 8, eh, el);
        sum64(this.h, 10, fh, fl);
        sum64(this.h, 12, gh, gl);
        sum64(this.h, 14, hh, hl);
      };
      SHA512.prototype._digest = function digest(enc) {
        if (enc === "hex")
          return utils.toHex32(this.h, "big");
        else
          return utils.split32(this.h, "big");
      };
      function ch64_hi(xh, xl, yh, yl, zh) {
        var r = xh & yh ^ ~xh & zh;
        if (r < 0)
          r += 4294967296;
        return r;
      }
      function ch64_lo(xh, xl, yh, yl, zh, zl) {
        var r = xl & yl ^ ~xl & zl;
        if (r < 0)
          r += 4294967296;
        return r;
      }
      function maj64_hi(xh, xl, yh, yl, zh) {
        var r = xh & yh ^ xh & zh ^ yh & zh;
        if (r < 0)
          r += 4294967296;
        return r;
      }
      function maj64_lo(xh, xl, yh, yl, zh, zl) {
        var r = xl & yl ^ xl & zl ^ yl & zl;
        if (r < 0)
          r += 4294967296;
        return r;
      }
      function s0_512_hi(xh, xl) {
        var c0_hi = rotr64_hi(xh, xl, 28);
        var c1_hi = rotr64_hi(xl, xh, 2);
        var c2_hi = rotr64_hi(xl, xh, 7);
        var r = c0_hi ^ c1_hi ^ c2_hi;
        if (r < 0)
          r += 4294967296;
        return r;
      }
      function s0_512_lo(xh, xl) {
        var c0_lo = rotr64_lo(xh, xl, 28);
        var c1_lo = rotr64_lo(xl, xh, 2);
        var c2_lo = rotr64_lo(xl, xh, 7);
        var r = c0_lo ^ c1_lo ^ c2_lo;
        if (r < 0)
          r += 4294967296;
        return r;
      }
      function s1_512_hi(xh, xl) {
        var c0_hi = rotr64_hi(xh, xl, 14);
        var c1_hi = rotr64_hi(xh, xl, 18);
        var c2_hi = rotr64_hi(xl, xh, 9);
        var r = c0_hi ^ c1_hi ^ c2_hi;
        if (r < 0)
          r += 4294967296;
        return r;
      }
      function s1_512_lo(xh, xl) {
        var c0_lo = rotr64_lo(xh, xl, 14);
        var c1_lo = rotr64_lo(xh, xl, 18);
        var c2_lo = rotr64_lo(xl, xh, 9);
        var r = c0_lo ^ c1_lo ^ c2_lo;
        if (r < 0)
          r += 4294967296;
        return r;
      }
      function g0_512_hi(xh, xl) {
        var c0_hi = rotr64_hi(xh, xl, 1);
        var c1_hi = rotr64_hi(xh, xl, 8);
        var c2_hi = shr64_hi(xh, xl, 7);
        var r = c0_hi ^ c1_hi ^ c2_hi;
        if (r < 0)
          r += 4294967296;
        return r;
      }
      function g0_512_lo(xh, xl) {
        var c0_lo = rotr64_lo(xh, xl, 1);
        var c1_lo = rotr64_lo(xh, xl, 8);
        var c2_lo = shr64_lo(xh, xl, 7);
        var r = c0_lo ^ c1_lo ^ c2_lo;
        if (r < 0)
          r += 4294967296;
        return r;
      }
      function g1_512_hi(xh, xl) {
        var c0_hi = rotr64_hi(xh, xl, 19);
        var c1_hi = rotr64_hi(xl, xh, 29);
        var c2_hi = shr64_hi(xh, xl, 6);
        var r = c0_hi ^ c1_hi ^ c2_hi;
        if (r < 0)
          r += 4294967296;
        return r;
      }
      function g1_512_lo(xh, xl) {
        var c0_lo = rotr64_lo(xh, xl, 19);
        var c1_lo = rotr64_lo(xl, xh, 29);
        var c2_lo = shr64_lo(xh, xl, 6);
        var r = c0_lo ^ c1_lo ^ c2_lo;
        if (r < 0)
          r += 4294967296;
        return r;
      }
    }
  });

  // node_modules/hash.js/lib/hash/sha/384.js
  var require__5 = __commonJS({
    "node_modules/hash.js/lib/hash/sha/384.js"(exports2, module2) {
      "use strict";
      var utils = require_utils5();
      var SHA512 = require__4();
      function SHA384() {
        if (!(this instanceof SHA384))
          return new SHA384();
        SHA512.call(this);
        this.h = [
          3418070365,
          3238371032,
          1654270250,
          914150663,
          2438529370,
          812702999,
          355462360,
          4144912697,
          1731405415,
          4290775857,
          2394180231,
          1750603025,
          3675008525,
          1694076839,
          1203062813,
          3204075428
        ];
      }
      utils.inherits(SHA384, SHA512);
      module2.exports = SHA384;
      SHA384.blockSize = 1024;
      SHA384.outSize = 384;
      SHA384.hmacStrength = 192;
      SHA384.padLength = 128;
      SHA384.prototype._digest = function digest(enc) {
        if (enc === "hex")
          return utils.toHex32(this.h.slice(0, 12), "big");
        else
          return utils.split32(this.h.slice(0, 12), "big");
      };
    }
  });

  // node_modules/hash.js/lib/hash/sha.js
  var require_sha4 = __commonJS({
    "node_modules/hash.js/lib/hash/sha.js"(exports2) {
      "use strict";
      exports2.sha1 = require__();
      exports2.sha224 = require__3();
      exports2.sha256 = require__2();
      exports2.sha384 = require__5();
      exports2.sha512 = require__4();
    }
  });

  // node_modules/hash.js/lib/hash/ripemd.js
  var require_ripemd = __commonJS({
    "node_modules/hash.js/lib/hash/ripemd.js"(exports2) {
      "use strict";
      var utils = require_utils5();
      var common = require_common();
      var rotl32 = utils.rotl32;
      var sum32 = utils.sum32;
      var sum32_3 = utils.sum32_3;
      var sum32_4 = utils.sum32_4;
      var BlockHash = common.BlockHash;
      function RIPEMD160() {
        if (!(this instanceof RIPEMD160))
          return new RIPEMD160();
        BlockHash.call(this);
        this.h = [1732584193, 4023233417, 2562383102, 271733878, 3285377520];
        this.endian = "little";
      }
      utils.inherits(RIPEMD160, BlockHash);
      exports2.ripemd160 = RIPEMD160;
      RIPEMD160.blockSize = 512;
      RIPEMD160.outSize = 160;
      RIPEMD160.hmacStrength = 192;
      RIPEMD160.padLength = 64;
      RIPEMD160.prototype._update = function update(msg, start2) {
        var A = this.h[0];
        var B = this.h[1];
        var C = this.h[2];
        var D = this.h[3];
        var E = this.h[4];
        var Ah = A;
        var Bh = B;
        var Ch = C;
        var Dh = D;
        var Eh = E;
        for (var j = 0; j < 80; j++) {
          var T = sum32(rotl32(sum32_4(A, f(j, B, C, D), msg[r[j] + start2], K(j)), s[j]), E);
          A = E;
          E = D;
          D = rotl32(C, 10);
          C = B;
          B = T;
          T = sum32(rotl32(sum32_4(Ah, f(79 - j, Bh, Ch, Dh), msg[rh[j] + start2], Kh(j)), sh[j]), Eh);
          Ah = Eh;
          Eh = Dh;
          Dh = rotl32(Ch, 10);
          Ch = Bh;
          Bh = T;
        }
        T = sum32_3(this.h[1], C, Dh);
        this.h[1] = sum32_3(this.h[2], D, Eh);
        this.h[2] = sum32_3(this.h[3], E, Ah);
        this.h[3] = sum32_3(this.h[4], A, Bh);
        this.h[4] = sum32_3(this.h[0], B, Ch);
        this.h[0] = T;
      };
      RIPEMD160.prototype._digest = function digest(enc) {
        if (enc === "hex")
          return utils.toHex32(this.h, "little");
        else
          return utils.split32(this.h, "little");
      };
      function f(j, x, y, z) {
        if (j <= 15)
          return x ^ y ^ z;
        else if (j <= 31)
          return x & y | ~x & z;
        else if (j <= 47)
          return (x | ~y) ^ z;
        else if (j <= 63)
          return x & z | y & ~z;
        else
          return x ^ (y | ~z);
      }
      function K(j) {
        if (j <= 15)
          return 0;
        else if (j <= 31)
          return 1518500249;
        else if (j <= 47)
          return 1859775393;
        else if (j <= 63)
          return 2400959708;
        else
          return 2840853838;
      }
      function Kh(j) {
        if (j <= 15)
          return 1352829926;
        else if (j <= 31)
          return 1548603684;
        else if (j <= 47)
          return 1836072691;
        else if (j <= 63)
          return 2053994217;
        else
          return 0;
      }
      var r = [
        0,
        1,
        2,
        3,
        4,
        5,
        6,
        7,
        8,
        9,
        10,
        11,
        12,
        13,
        14,
        15,
        7,
        4,
        13,
        1,
        10,
        6,
        15,
        3,
        12,
        0,
        9,
        5,
        2,
        14,
        11,
        8,
        3,
        10,
        14,
        4,
        9,
        15,
        8,
        1,
        2,
        7,
        0,
        6,
        13,
        11,
        5,
        12,
        1,
        9,
        11,
        10,
        0,
        8,
        12,
        4,
        13,
        3,
        7,
        15,
        14,
        5,
        6,
        2,
        4,
        0,
        5,
        9,
        7,
        12,
        2,
        10,
        14,
        1,
        3,
        8,
        11,
        6,
        15,
        13
      ];
      var rh = [
        5,
        14,
        7,
        0,
        9,
        2,
        11,
        4,
        13,
        6,
        15,
        8,
        1,
        10,
        3,
        12,
        6,
        11,
        3,
        7,
        0,
        13,
        5,
        10,
        14,
        15,
        8,
        12,
        4,
        9,
        1,
        2,
        15,
        5,
        1,
        3,
        7,
        14,
        6,
        9,
        11,
        8,
        12,
        2,
        10,
        0,
        4,
        13,
        8,
        6,
        4,
        1,
        3,
        11,
        15,
        0,
        5,
        12,
        2,
        13,
        9,
        7,
        10,
        14,
        12,
        15,
        10,
        4,
        1,
        5,
        8,
        7,
        6,
        2,
        13,
        14,
        0,
        3,
        9,
        11
      ];
      var s = [
        11,
        14,
        15,
        12,
        5,
        8,
        7,
        9,
        11,
        13,
        14,
        15,
        6,
        7,
        9,
        8,
        7,
        6,
        8,
        13,
        11,
        9,
        7,
        15,
        7,
        12,
        15,
        9,
        11,
        7,
        13,
        12,
        11,
        13,
        6,
        7,
        14,
        9,
        13,
        15,
        14,
        8,
        13,
        6,
        5,
        12,
        7,
        5,
        11,
        12,
        14,
        15,
        14,
        15,
        9,
        8,
        9,
        14,
        5,
        6,
        8,
        6,
        5,
        12,
        9,
        15,
        5,
        11,
        6,
        8,
        13,
        12,
        5,
        12,
        13,
        14,
        11,
        8,
        5,
        6
      ];
      var sh = [
        8,
        9,
        9,
        11,
        13,
        15,
        15,
        5,
        7,
        7,
        8,
        11,
        14,
        14,
        12,
        6,
        9,
        13,
        15,
        7,
        12,
        8,
        9,
        11,
        7,
        7,
        12,
        7,
        6,
        15,
        13,
        11,
        9,
        7,
        15,
        11,
        8,
        6,
        6,
        14,
        12,
        13,
        5,
        14,
        13,
        13,
        7,
        5,
        15,
        5,
        8,
        11,
        14,
        14,
        6,
        14,
        6,
        9,
        12,
        9,
        12,
        5,
        15,
        8,
        8,
        5,
        12,
        9,
        12,
        5,
        14,
        6,
        8,
        13,
        6,
        5,
        15,
        13,
        11,
        11
      ];
    }
  });

  // node_modules/hash.js/lib/hash/hmac.js
  var require_hmac2 = __commonJS({
    "node_modules/hash.js/lib/hash/hmac.js"(exports2, module2) {
      "use strict";
      var utils = require_utils5();
      var assert = require_minimalistic_assert();
      function Hmac(hash, key, enc) {
        if (!(this instanceof Hmac))
          return new Hmac(hash, key, enc);
        this.Hash = hash;
        this.blockSize = hash.blockSize / 8;
        this.outSize = hash.outSize / 8;
        this.inner = null;
        this.outer = null;
        this._init(utils.toArray(key, enc));
      }
      module2.exports = Hmac;
      Hmac.prototype._init = function init(key) {
        if (key.length > this.blockSize)
          key = new this.Hash().update(key).digest();
        assert(key.length <= this.blockSize);
        for (var i = key.length; i < this.blockSize; i++)
          key.push(0);
        for (i = 0; i < key.length; i++)
          key[i] ^= 54;
        this.inner = new this.Hash().update(key);
        for (i = 0; i < key.length; i++)
          key[i] ^= 106;
        this.outer = new this.Hash().update(key);
      };
      Hmac.prototype.update = function update(msg, enc) {
        this.inner.update(msg, enc);
        return this;
      };
      Hmac.prototype.digest = function digest(enc) {
        this.outer.update(this.inner.digest());
        return this.outer.digest(enc);
      };
    }
  });

  // node_modules/hash.js/lib/hash.js
  var require_hash2 = __commonJS({
    "node_modules/hash.js/lib/hash.js"(exports2) {
      var hash = exports2;
      hash.utils = require_utils5();
      hash.common = require_common();
      hash.sha = require_sha4();
      hash.ripemd = require_ripemd();
      hash.hmac = require_hmac2();
      hash.sha1 = hash.sha.sha1;
      hash.sha256 = hash.sha.sha256;
      hash.sha224 = hash.sha.sha224;
      hash.sha384 = hash.sha.sha384;
      hash.sha512 = hash.sha.sha512;
      hash.ripemd160 = hash.ripemd.ripemd160;
    }
  });

  // node_modules/elliptic/lib/elliptic/precomputed/secp256k1.js
  var require_secp256k1 = __commonJS({
    "node_modules/elliptic/lib/elliptic/precomputed/secp256k1.js"(exports2, module2) {
      module2.exports = {
        doubles: {
          step: 4,
          points: [
            [
              "e60fce93b59e9ec53011aabc21c23e97b2a31369b87a5ae9c44ee89e2a6dec0a",
              "f7e3507399e595929db99f34f57937101296891e44d23f0be1f32cce69616821"
            ],
            [
              "8282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508",
              "11f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf"
            ],
            [
              "175e159f728b865a72f99cc6c6fc846de0b93833fd2222ed73fce5b551e5b739",
              "d3506e0d9e3c79eba4ef97a51ff71f5eacb5955add24345c6efa6ffee9fed695"
            ],
            [
              "363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640",
              "4e273adfc732221953b445397f3363145b9a89008199ecb62003c7f3bee9de9"
            ],
            [
              "8b4b5f165df3c2be8c6244b5b745638843e4a781a15bcd1b69f79a55dffdf80c",
              "4aad0a6f68d308b4b3fbd7813ab0da04f9e336546162ee56b3eff0c65fd4fd36"
            ],
            [
              "723cbaa6e5db996d6bf771c00bd548c7b700dbffa6c0e77bcb6115925232fcda",
              "96e867b5595cc498a921137488824d6e2660a0653779494801dc069d9eb39f5f"
            ],
            [
              "eebfa4d493bebf98ba5feec812c2d3b50947961237a919839a533eca0e7dd7fa",
              "5d9a8ca3970ef0f269ee7edaf178089d9ae4cdc3a711f712ddfd4fdae1de8999"
            ],
            [
              "100f44da696e71672791d0a09b7bde459f1215a29b3c03bfefd7835b39a48db0",
              "cdd9e13192a00b772ec8f3300c090666b7ff4a18ff5195ac0fbd5cd62bc65a09"
            ],
            [
              "e1031be262c7ed1b1dc9227a4a04c017a77f8d4464f3b3852c8acde6e534fd2d",
              "9d7061928940405e6bb6a4176597535af292dd419e1ced79a44f18f29456a00d"
            ],
            [
              "feea6cae46d55b530ac2839f143bd7ec5cf8b266a41d6af52d5e688d9094696d",
              "e57c6b6c97dce1bab06e4e12bf3ecd5c981c8957cc41442d3155debf18090088"
            ],
            [
              "da67a91d91049cdcb367be4be6ffca3cfeed657d808583de33fa978bc1ec6cb1",
              "9bacaa35481642bc41f463f7ec9780e5dec7adc508f740a17e9ea8e27a68be1d"
            ],
            [
              "53904faa0b334cdda6e000935ef22151ec08d0f7bb11069f57545ccc1a37b7c0",
              "5bc087d0bc80106d88c9eccac20d3c1c13999981e14434699dcb096b022771c8"
            ],
            [
              "8e7bcd0bd35983a7719cca7764ca906779b53a043a9b8bcaeff959f43ad86047",
              "10b7770b2a3da4b3940310420ca9514579e88e2e47fd68b3ea10047e8460372a"
            ],
            [
              "385eed34c1cdff21e6d0818689b81bde71a7f4f18397e6690a841e1599c43862",
              "283bebc3e8ea23f56701de19e9ebf4576b304eec2086dc8cc0458fe5542e5453"
            ],
            [
              "6f9d9b803ecf191637c73a4413dfa180fddf84a5947fbc9c606ed86c3fac3a7",
              "7c80c68e603059ba69b8e2a30e45c4d47ea4dd2f5c281002d86890603a842160"
            ],
            [
              "3322d401243c4e2582a2147c104d6ecbf774d163db0f5e5313b7e0e742d0e6bd",
              "56e70797e9664ef5bfb019bc4ddaf9b72805f63ea2873af624f3a2e96c28b2a0"
            ],
            [
              "85672c7d2de0b7da2bd1770d89665868741b3f9af7643397721d74d28134ab83",
              "7c481b9b5b43b2eb6374049bfa62c2e5e77f17fcc5298f44c8e3094f790313a6"
            ],
            [
              "948bf809b1988a46b06c9f1919413b10f9226c60f668832ffd959af60c82a0a",
              "53a562856dcb6646dc6b74c5d1c3418c6d4dff08c97cd2bed4cb7f88d8c8e589"
            ],
            [
              "6260ce7f461801c34f067ce0f02873a8f1b0e44dfc69752accecd819f38fd8e8",
              "bc2da82b6fa5b571a7f09049776a1ef7ecd292238051c198c1a84e95b2b4ae17"
            ],
            [
              "e5037de0afc1d8d43d8348414bbf4103043ec8f575bfdc432953cc8d2037fa2d",
              "4571534baa94d3b5f9f98d09fb990bddbd5f5b03ec481f10e0e5dc841d755bda"
            ],
            [
              "e06372b0f4a207adf5ea905e8f1771b4e7e8dbd1c6a6c5b725866a0ae4fce725",
              "7a908974bce18cfe12a27bb2ad5a488cd7484a7787104870b27034f94eee31dd"
            ],
            [
              "213c7a715cd5d45358d0bbf9dc0ce02204b10bdde2a3f58540ad6908d0559754",
              "4b6dad0b5ae462507013ad06245ba190bb4850f5f36a7eeddff2c27534b458f2"
            ],
            [
              "4e7c272a7af4b34e8dbb9352a5419a87e2838c70adc62cddf0cc3a3b08fbd53c",
              "17749c766c9d0b18e16fd09f6def681b530b9614bff7dd33e0b3941817dcaae6"
            ],
            [
              "fea74e3dbe778b1b10f238ad61686aa5c76e3db2be43057632427e2840fb27b6",
              "6e0568db9b0b13297cf674deccb6af93126b596b973f7b77701d3db7f23cb96f"
            ],
            [
              "76e64113f677cf0e10a2570d599968d31544e179b760432952c02a4417bdde39",
              "c90ddf8dee4e95cf577066d70681f0d35e2a33d2b56d2032b4b1752d1901ac01"
            ],
            [
              "c738c56b03b2abe1e8281baa743f8f9a8f7cc643df26cbee3ab150242bcbb891",
              "893fb578951ad2537f718f2eacbfbbbb82314eef7880cfe917e735d9699a84c3"
            ],
            [
              "d895626548b65b81e264c7637c972877d1d72e5f3a925014372e9f6588f6c14b",
              "febfaa38f2bc7eae728ec60818c340eb03428d632bb067e179363ed75d7d991f"
            ],
            [
              "b8da94032a957518eb0f6433571e8761ceffc73693e84edd49150a564f676e03",
              "2804dfa44805a1e4d7c99cc9762808b092cc584d95ff3b511488e4e74efdf6e7"
            ],
            [
              "e80fea14441fb33a7d8adab9475d7fab2019effb5156a792f1a11778e3c0df5d",
              "eed1de7f638e00771e89768ca3ca94472d155e80af322ea9fcb4291b6ac9ec78"
            ],
            [
              "a301697bdfcd704313ba48e51d567543f2a182031efd6915ddc07bbcc4e16070",
              "7370f91cfb67e4f5081809fa25d40f9b1735dbf7c0a11a130c0d1a041e177ea1"
            ],
            [
              "90ad85b389d6b936463f9d0512678de208cc330b11307fffab7ac63e3fb04ed4",
              "e507a3620a38261affdcbd9427222b839aefabe1582894d991d4d48cb6ef150"
            ],
            [
              "8f68b9d2f63b5f339239c1ad981f162ee88c5678723ea3351b7b444c9ec4c0da",
              "662a9f2dba063986de1d90c2b6be215dbbea2cfe95510bfdf23cbf79501fff82"
            ],
            [
              "e4f3fb0176af85d65ff99ff9198c36091f48e86503681e3e6686fd5053231e11",
              "1e63633ad0ef4f1c1661a6d0ea02b7286cc7e74ec951d1c9822c38576feb73bc"
            ],
            [
              "8c00fa9b18ebf331eb961537a45a4266c7034f2f0d4e1d0716fb6eae20eae29e",
              "efa47267fea521a1a9dc343a3736c974c2fadafa81e36c54e7d2a4c66702414b"
            ],
            [
              "e7a26ce69dd4829f3e10cec0a9e98ed3143d084f308b92c0997fddfc60cb3e41",
              "2a758e300fa7984b471b006a1aafbb18d0a6b2c0420e83e20e8a9421cf2cfd51"
            ],
            [
              "b6459e0ee3662ec8d23540c223bcbdc571cbcb967d79424f3cf29eb3de6b80ef",
              "67c876d06f3e06de1dadf16e5661db3c4b3ae6d48e35b2ff30bf0b61a71ba45"
            ],
            [
              "d68a80c8280bb840793234aa118f06231d6f1fc67e73c5a5deda0f5b496943e8",
              "db8ba9fff4b586d00c4b1f9177b0e28b5b0e7b8f7845295a294c84266b133120"
            ],
            [
              "324aed7df65c804252dc0270907a30b09612aeb973449cea4095980fc28d3d5d",
              "648a365774b61f2ff130c0c35aec1f4f19213b0c7e332843967224af96ab7c84"
            ],
            [
              "4df9c14919cde61f6d51dfdbe5fee5dceec4143ba8d1ca888e8bd373fd054c96",
              "35ec51092d8728050974c23a1d85d4b5d506cdc288490192ebac06cad10d5d"
            ],
            [
              "9c3919a84a474870faed8a9c1cc66021523489054d7f0308cbfc99c8ac1f98cd",
              "ddb84f0f4a4ddd57584f044bf260e641905326f76c64c8e6be7e5e03d4fc599d"
            ],
            [
              "6057170b1dd12fdf8de05f281d8e06bb91e1493a8b91d4cc5a21382120a959e5",
              "9a1af0b26a6a4807add9a2daf71df262465152bc3ee24c65e899be932385a2a8"
            ],
            [
              "a576df8e23a08411421439a4518da31880cef0fba7d4df12b1a6973eecb94266",
              "40a6bf20e76640b2c92b97afe58cd82c432e10a7f514d9f3ee8be11ae1b28ec8"
            ],
            [
              "7778a78c28dec3e30a05fe9629de8c38bb30d1f5cf9a3a208f763889be58ad71",
              "34626d9ab5a5b22ff7098e12f2ff580087b38411ff24ac563b513fc1fd9f43ac"
            ],
            [
              "928955ee637a84463729fd30e7afd2ed5f96274e5ad7e5cb09eda9c06d903ac",
              "c25621003d3f42a827b78a13093a95eeac3d26efa8a8d83fc5180e935bcd091f"
            ],
            [
              "85d0fef3ec6db109399064f3a0e3b2855645b4a907ad354527aae75163d82751",
              "1f03648413a38c0be29d496e582cf5663e8751e96877331582c237a24eb1f962"
            ],
            [
              "ff2b0dce97eece97c1c9b6041798b85dfdfb6d8882da20308f5404824526087e",
              "493d13fef524ba188af4c4dc54d07936c7b7ed6fb90e2ceb2c951e01f0c29907"
            ],
            [
              "827fbbe4b1e880ea9ed2b2e6301b212b57f1ee148cd6dd28780e5e2cf856e241",
              "c60f9c923c727b0b71bef2c67d1d12687ff7a63186903166d605b68baec293ec"
            ],
            [
              "eaa649f21f51bdbae7be4ae34ce6e5217a58fdce7f47f9aa7f3b58fa2120e2b3",
              "be3279ed5bbbb03ac69a80f89879aa5a01a6b965f13f7e59d47a5305ba5ad93d"
            ],
            [
              "e4a42d43c5cf169d9391df6decf42ee541b6d8f0c9a137401e23632dda34d24f",
              "4d9f92e716d1c73526fc99ccfb8ad34ce886eedfa8d8e4f13a7f7131deba9414"
            ],
            [
              "1ec80fef360cbdd954160fadab352b6b92b53576a88fea4947173b9d4300bf19",
              "aeefe93756b5340d2f3a4958a7abbf5e0146e77f6295a07b671cdc1cc107cefd"
            ],
            [
              "146a778c04670c2f91b00af4680dfa8bce3490717d58ba889ddb5928366642be",
              "b318e0ec3354028add669827f9d4b2870aaa971d2f7e5ed1d0b297483d83efd0"
            ],
            [
              "fa50c0f61d22e5f07e3acebb1aa07b128d0012209a28b9776d76a8793180eef9",
              "6b84c6922397eba9b72cd2872281a68a5e683293a57a213b38cd8d7d3f4f2811"
            ],
            [
              "da1d61d0ca721a11b1a5bf6b7d88e8421a288ab5d5bba5220e53d32b5f067ec2",
              "8157f55a7c99306c79c0766161c91e2966a73899d279b48a655fba0f1ad836f1"
            ],
            [
              "a8e282ff0c9706907215ff98e8fd416615311de0446f1e062a73b0610d064e13",
              "7f97355b8db81c09abfb7f3c5b2515888b679a3e50dd6bd6cef7c73111f4cc0c"
            ],
            [
              "174a53b9c9a285872d39e56e6913cab15d59b1fa512508c022f382de8319497c",
              "ccc9dc37abfc9c1657b4155f2c47f9e6646b3a1d8cb9854383da13ac079afa73"
            ],
            [
              "959396981943785c3d3e57edf5018cdbe039e730e4918b3d884fdff09475b7ba",
              "2e7e552888c331dd8ba0386a4b9cd6849c653f64c8709385e9b8abf87524f2fd"
            ],
            [
              "d2a63a50ae401e56d645a1153b109a8fcca0a43d561fba2dbb51340c9d82b151",
              "e82d86fb6443fcb7565aee58b2948220a70f750af484ca52d4142174dcf89405"
            ],
            [
              "64587e2335471eb890ee7896d7cfdc866bacbdbd3839317b3436f9b45617e073",
              "d99fcdd5bf6902e2ae96dd6447c299a185b90a39133aeab358299e5e9faf6589"
            ],
            [
              "8481bde0e4e4d885b3a546d3e549de042f0aa6cea250e7fd358d6c86dd45e458",
              "38ee7b8cba5404dd84a25bf39cecb2ca900a79c42b262e556d64b1b59779057e"
            ],
            [
              "13464a57a78102aa62b6979ae817f4637ffcfed3c4b1ce30bcd6303f6caf666b",
              "69be159004614580ef7e433453ccb0ca48f300a81d0942e13f495a907f6ecc27"
            ],
            [
              "bc4a9df5b713fe2e9aef430bcc1dc97a0cd9ccede2f28588cada3a0d2d83f366",
              "d3a81ca6e785c06383937adf4b798caa6e8a9fbfa547b16d758d666581f33c1"
            ],
            [
              "8c28a97bf8298bc0d23d8c749452a32e694b65e30a9472a3954ab30fe5324caa",
              "40a30463a3305193378fedf31f7cc0eb7ae784f0451cb9459e71dc73cbef9482"
            ],
            [
              "8ea9666139527a8c1dd94ce4f071fd23c8b350c5a4bb33748c4ba111faccae0",
              "620efabbc8ee2782e24e7c0cfb95c5d735b783be9cf0f8e955af34a30e62b945"
            ],
            [
              "dd3625faef5ba06074669716bbd3788d89bdde815959968092f76cc4eb9a9787",
              "7a188fa3520e30d461da2501045731ca941461982883395937f68d00c644a573"
            ],
            [
              "f710d79d9eb962297e4f6232b40e8f7feb2bc63814614d692c12de752408221e",
              "ea98e67232d3b3295d3b535532115ccac8612c721851617526ae47a9c77bfc82"
            ]
          ]
        },
        naf: {
          wnd: 7,
          points: [
            [
              "f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9",
              "388f7b0f632de8140fe337e62a37f3566500a99934c2231b6cb9fd7584b8e672"
            ],
            [
              "2f8bde4d1a07209355b4a7250a5c5128e88b84bddc619ab7cba8d569b240efe4",
              "d8ac222636e5e3d6d4dba9dda6c9c426f788271bab0d6840dca87d3aa6ac62d6"
            ],
            [
              "5cbdf0646e5db4eaa398f365f2ea7a0e3d419b7e0330e39ce92bddedcac4f9bc",
              "6aebca40ba255960a3178d6d861a54dba813d0b813fde7b5a5082628087264da"
            ],
            [
              "acd484e2f0c7f65309ad178a9f559abde09796974c57e714c35f110dfc27ccbe",
              "cc338921b0a7d9fd64380971763b61e9add888a4375f8e0f05cc262ac64f9c37"
            ],
            [
              "774ae7f858a9411e5ef4246b70c65aac5649980be5c17891bbec17895da008cb",
              "d984a032eb6b5e190243dd56d7b7b365372db1e2dff9d6a8301d74c9c953c61b"
            ],
            [
              "f28773c2d975288bc7d1d205c3748651b075fbc6610e58cddeeddf8f19405aa8",
              "ab0902e8d880a89758212eb65cdaf473a1a06da521fa91f29b5cb52db03ed81"
            ],
            [
              "d7924d4f7d43ea965a465ae3095ff41131e5946f3c85f79e44adbcf8e27e080e",
              "581e2872a86c72a683842ec228cc6defea40af2bd896d3a5c504dc9ff6a26b58"
            ],
            [
              "defdea4cdb677750a420fee807eacf21eb9898ae79b9768766e4faa04a2d4a34",
              "4211ab0694635168e997b0ead2a93daeced1f4a04a95c0f6cfb199f69e56eb77"
            ],
            [
              "2b4ea0a797a443d293ef5cff444f4979f06acfebd7e86d277475656138385b6c",
              "85e89bc037945d93b343083b5a1c86131a01f60c50269763b570c854e5c09b7a"
            ],
            [
              "352bbf4a4cdd12564f93fa332ce333301d9ad40271f8107181340aef25be59d5",
              "321eb4075348f534d59c18259dda3e1f4a1b3b2e71b1039c67bd3d8bcf81998c"
            ],
            [
              "2fa2104d6b38d11b0230010559879124e42ab8dfeff5ff29dc9cdadd4ecacc3f",
              "2de1068295dd865b64569335bd5dd80181d70ecfc882648423ba76b532b7d67"
            ],
            [
              "9248279b09b4d68dab21a9b066edda83263c3d84e09572e269ca0cd7f5453714",
              "73016f7bf234aade5d1aa71bdea2b1ff3fc0de2a887912ffe54a32ce97cb3402"
            ],
            [
              "daed4f2be3a8bf278e70132fb0beb7522f570e144bf615c07e996d443dee8729",
              "a69dce4a7d6c98e8d4a1aca87ef8d7003f83c230f3afa726ab40e52290be1c55"
            ],
            [
              "c44d12c7065d812e8acf28d7cbb19f9011ecd9e9fdf281b0e6a3b5e87d22e7db",
              "2119a460ce326cdc76c45926c982fdac0e106e861edf61c5a039063f0e0e6482"
            ],
            [
              "6a245bf6dc698504c89a20cfded60853152b695336c28063b61c65cbd269e6b4",
              "e022cf42c2bd4a708b3f5126f16a24ad8b33ba48d0423b6efd5e6348100d8a82"
            ],
            [
              "1697ffa6fd9de627c077e3d2fe541084ce13300b0bec1146f95ae57f0d0bd6a5",
              "b9c398f186806f5d27561506e4557433a2cf15009e498ae7adee9d63d01b2396"
            ],
            [
              "605bdb019981718b986d0f07e834cb0d9deb8360ffb7f61df982345ef27a7479",
              "2972d2de4f8d20681a78d93ec96fe23c26bfae84fb14db43b01e1e9056b8c49"
            ],
            [
              "62d14dab4150bf497402fdc45a215e10dcb01c354959b10cfe31c7e9d87ff33d",
              "80fc06bd8cc5b01098088a1950eed0db01aa132967ab472235f5642483b25eaf"
            ],
            [
              "80c60ad0040f27dade5b4b06c408e56b2c50e9f56b9b8b425e555c2f86308b6f",
              "1c38303f1cc5c30f26e66bad7fe72f70a65eed4cbe7024eb1aa01f56430bd57a"
            ],
            [
              "7a9375ad6167ad54aa74c6348cc54d344cc5dc9487d847049d5eabb0fa03c8fb",
              "d0e3fa9eca8726909559e0d79269046bdc59ea10c70ce2b02d499ec224dc7f7"
            ],
            [
              "d528ecd9b696b54c907a9ed045447a79bb408ec39b68df504bb51f459bc3ffc9",
              "eecf41253136e5f99966f21881fd656ebc4345405c520dbc063465b521409933"
            ],
            [
              "49370a4b5f43412ea25f514e8ecdad05266115e4a7ecb1387231808f8b45963",
              "758f3f41afd6ed428b3081b0512fd62a54c3f3afbb5b6764b653052a12949c9a"
            ],
            [
              "77f230936ee88cbbd73df930d64702ef881d811e0e1498e2f1c13eb1fc345d74",
              "958ef42a7886b6400a08266e9ba1b37896c95330d97077cbbe8eb3c7671c60d6"
            ],
            [
              "f2dac991cc4ce4b9ea44887e5c7c0bce58c80074ab9d4dbaeb28531b7739f530",
              "e0dedc9b3b2f8dad4da1f32dec2531df9eb5fbeb0598e4fd1a117dba703a3c37"
            ],
            [
              "463b3d9f662621fb1b4be8fbbe2520125a216cdfc9dae3debcba4850c690d45b",
              "5ed430d78c296c3543114306dd8622d7c622e27c970a1de31cb377b01af7307e"
            ],
            [
              "f16f804244e46e2a09232d4aff3b59976b98fac14328a2d1a32496b49998f247",
              "cedabd9b82203f7e13d206fcdf4e33d92a6c53c26e5cce26d6579962c4e31df6"
            ],
            [
              "caf754272dc84563b0352b7a14311af55d245315ace27c65369e15f7151d41d1",
              "cb474660ef35f5f2a41b643fa5e460575f4fa9b7962232a5c32f908318a04476"
            ],
            [
              "2600ca4b282cb986f85d0f1709979d8b44a09c07cb86d7c124497bc86f082120",
              "4119b88753c15bd6a693b03fcddbb45d5ac6be74ab5f0ef44b0be9475a7e4b40"
            ],
            [
              "7635ca72d7e8432c338ec53cd12220bc01c48685e24f7dc8c602a7746998e435",
              "91b649609489d613d1d5e590f78e6d74ecfc061d57048bad9e76f302c5b9c61"
            ],
            [
              "754e3239f325570cdbbf4a87deee8a66b7f2b33479d468fbc1a50743bf56cc18",
              "673fb86e5bda30fb3cd0ed304ea49a023ee33d0197a695d0c5d98093c536683"
            ],
            [
              "e3e6bd1071a1e96aff57859c82d570f0330800661d1c952f9fe2694691d9b9e8",
              "59c9e0bba394e76f40c0aa58379a3cb6a5a2283993e90c4167002af4920e37f5"
            ],
            [
              "186b483d056a033826ae73d88f732985c4ccb1f32ba35f4b4cc47fdcf04aa6eb",
              "3b952d32c67cf77e2e17446e204180ab21fb8090895138b4a4a797f86e80888b"
            ],
            [
              "df9d70a6b9876ce544c98561f4be4f725442e6d2b737d9c91a8321724ce0963f",
              "55eb2dafd84d6ccd5f862b785dc39d4ab157222720ef9da217b8c45cf2ba2417"
            ],
            [
              "5edd5cc23c51e87a497ca815d5dce0f8ab52554f849ed8995de64c5f34ce7143",
              "efae9c8dbc14130661e8cec030c89ad0c13c66c0d17a2905cdc706ab7399a868"
            ],
            [
              "290798c2b6476830da12fe02287e9e777aa3fba1c355b17a722d362f84614fba",
              "e38da76dcd440621988d00bcf79af25d5b29c094db2a23146d003afd41943e7a"
            ],
            [
              "af3c423a95d9f5b3054754efa150ac39cd29552fe360257362dfdecef4053b45",
              "f98a3fd831eb2b749a93b0e6f35cfb40c8cd5aa667a15581bc2feded498fd9c6"
            ],
            [
              "766dbb24d134e745cccaa28c99bf274906bb66b26dcf98df8d2fed50d884249a",
              "744b1152eacbe5e38dcc887980da38b897584a65fa06cedd2c924f97cbac5996"
            ],
            [
              "59dbf46f8c94759ba21277c33784f41645f7b44f6c596a58ce92e666191abe3e",
              "c534ad44175fbc300f4ea6ce648309a042ce739a7919798cd85e216c4a307f6e"
            ],
            [
              "f13ada95103c4537305e691e74e9a4a8dd647e711a95e73cb62dc6018cfd87b8",
              "e13817b44ee14de663bf4bc808341f326949e21a6a75c2570778419bdaf5733d"
            ],
            [
              "7754b4fa0e8aced06d4167a2c59cca4cda1869c06ebadfb6488550015a88522c",
              "30e93e864e669d82224b967c3020b8fa8d1e4e350b6cbcc537a48b57841163a2"
            ],
            [
              "948dcadf5990e048aa3874d46abef9d701858f95de8041d2a6828c99e2262519",
              "e491a42537f6e597d5d28a3224b1bc25df9154efbd2ef1d2cbba2cae5347d57e"
            ],
            [
              "7962414450c76c1689c7b48f8202ec37fb224cf5ac0bfa1570328a8a3d7c77ab",
              "100b610ec4ffb4760d5c1fc133ef6f6b12507a051f04ac5760afa5b29db83437"
            ],
            [
              "3514087834964b54b15b160644d915485a16977225b8847bb0dd085137ec47ca",
              "ef0afbb2056205448e1652c48e8127fc6039e77c15c2378b7e7d15a0de293311"
            ],
            [
              "d3cc30ad6b483e4bc79ce2c9dd8bc54993e947eb8df787b442943d3f7b527eaf",
              "8b378a22d827278d89c5e9be8f9508ae3c2ad46290358630afb34db04eede0a4"
            ],
            [
              "1624d84780732860ce1c78fcbfefe08b2b29823db913f6493975ba0ff4847610",
              "68651cf9b6da903e0914448c6cd9d4ca896878f5282be4c8cc06e2a404078575"
            ],
            [
              "733ce80da955a8a26902c95633e62a985192474b5af207da6df7b4fd5fc61cd4",
              "f5435a2bd2badf7d485a4d8b8db9fcce3e1ef8e0201e4578c54673bc1dc5ea1d"
            ],
            [
              "15d9441254945064cf1a1c33bbd3b49f8966c5092171e699ef258dfab81c045c",
              "d56eb30b69463e7234f5137b73b84177434800bacebfc685fc37bbe9efe4070d"
            ],
            [
              "a1d0fcf2ec9de675b612136e5ce70d271c21417c9d2b8aaaac138599d0717940",
              "edd77f50bcb5a3cab2e90737309667f2641462a54070f3d519212d39c197a629"
            ],
            [
              "e22fbe15c0af8ccc5780c0735f84dbe9a790badee8245c06c7ca37331cb36980",
              "a855babad5cd60c88b430a69f53a1a7a38289154964799be43d06d77d31da06"
            ],
            [
              "311091dd9860e8e20ee13473c1155f5f69635e394704eaa74009452246cfa9b3",
              "66db656f87d1f04fffd1f04788c06830871ec5a64feee685bd80f0b1286d8374"
            ],
            [
              "34c1fd04d301be89b31c0442d3e6ac24883928b45a9340781867d4232ec2dbdf",
              "9414685e97b1b5954bd46f730174136d57f1ceeb487443dc5321857ba73abee"
            ],
            [
              "f219ea5d6b54701c1c14de5b557eb42a8d13f3abbcd08affcc2a5e6b049b8d63",
              "4cb95957e83d40b0f73af4544cccf6b1f4b08d3c07b27fb8d8c2962a400766d1"
            ],
            [
              "d7b8740f74a8fbaab1f683db8f45de26543a5490bca627087236912469a0b448",
              "fa77968128d9c92ee1010f337ad4717eff15db5ed3c049b3411e0315eaa4593b"
            ],
            [
              "32d31c222f8f6f0ef86f7c98d3a3335ead5bcd32abdd94289fe4d3091aa824bf",
              "5f3032f5892156e39ccd3d7915b9e1da2e6dac9e6f26e961118d14b8462e1661"
            ],
            [
              "7461f371914ab32671045a155d9831ea8793d77cd59592c4340f86cbc18347b5",
              "8ec0ba238b96bec0cbdddcae0aa442542eee1ff50c986ea6b39847b3cc092ff6"
            ],
            [
              "ee079adb1df1860074356a25aa38206a6d716b2c3e67453d287698bad7b2b2d6",
              "8dc2412aafe3be5c4c5f37e0ecc5f9f6a446989af04c4e25ebaac479ec1c8c1e"
            ],
            [
              "16ec93e447ec83f0467b18302ee620f7e65de331874c9dc72bfd8616ba9da6b5",
              "5e4631150e62fb40d0e8c2a7ca5804a39d58186a50e497139626778e25b0674d"
            ],
            [
              "eaa5f980c245f6f038978290afa70b6bd8855897f98b6aa485b96065d537bd99",
              "f65f5d3e292c2e0819a528391c994624d784869d7e6ea67fb18041024edc07dc"
            ],
            [
              "78c9407544ac132692ee1910a02439958ae04877151342ea96c4b6b35a49f51",
              "f3e0319169eb9b85d5404795539a5e68fa1fbd583c064d2462b675f194a3ddb4"
            ],
            [
              "494f4be219a1a77016dcd838431aea0001cdc8ae7a6fc688726578d9702857a5",
              "42242a969283a5f339ba7f075e36ba2af925ce30d767ed6e55f4b031880d562c"
            ],
            [
              "a598a8030da6d86c6bc7f2f5144ea549d28211ea58faa70ebf4c1e665c1fe9b5",
              "204b5d6f84822c307e4b4a7140737aec23fc63b65b35f86a10026dbd2d864e6b"
            ],
            [
              "c41916365abb2b5d09192f5f2dbeafec208f020f12570a184dbadc3e58595997",
              "4f14351d0087efa49d245b328984989d5caf9450f34bfc0ed16e96b58fa9913"
            ],
            [
              "841d6063a586fa475a724604da03bc5b92a2e0d2e0a36acfe4c73a5514742881",
              "73867f59c0659e81904f9a1c7543698e62562d6744c169ce7a36de01a8d6154"
            ],
            [
              "5e95bb399a6971d376026947f89bde2f282b33810928be4ded112ac4d70e20d5",
              "39f23f366809085beebfc71181313775a99c9aed7d8ba38b161384c746012865"
            ],
            [
              "36e4641a53948fd476c39f8a99fd974e5ec07564b5315d8bf99471bca0ef2f66",
              "d2424b1b1abe4eb8164227b085c9aa9456ea13493fd563e06fd51cf5694c78fc"
            ],
            [
              "336581ea7bfbbb290c191a2f507a41cf5643842170e914faeab27c2c579f726",
              "ead12168595fe1be99252129b6e56b3391f7ab1410cd1e0ef3dcdcabd2fda224"
            ],
            [
              "8ab89816dadfd6b6a1f2634fcf00ec8403781025ed6890c4849742706bd43ede",
              "6fdcef09f2f6d0a044e654aef624136f503d459c3e89845858a47a9129cdd24e"
            ],
            [
              "1e33f1a746c9c5778133344d9299fcaa20b0938e8acff2544bb40284b8c5fb94",
              "60660257dd11b3aa9c8ed618d24edff2306d320f1d03010e33a7d2057f3b3b6"
            ],
            [
              "85b7c1dcb3cec1b7ee7f30ded79dd20a0ed1f4cc18cbcfcfa410361fd8f08f31",
              "3d98a9cdd026dd43f39048f25a8847f4fcafad1895d7a633c6fed3c35e999511"
            ],
            [
              "29df9fbd8d9e46509275f4b125d6d45d7fbe9a3b878a7af872a2800661ac5f51",
              "b4c4fe99c775a606e2d8862179139ffda61dc861c019e55cd2876eb2a27d84b"
            ],
            [
              "a0b1cae06b0a847a3fea6e671aaf8adfdfe58ca2f768105c8082b2e449fce252",
              "ae434102edde0958ec4b19d917a6a28e6b72da1834aff0e650f049503a296cf2"
            ],
            [
              "4e8ceafb9b3e9a136dc7ff67e840295b499dfb3b2133e4ba113f2e4c0e121e5",
              "cf2174118c8b6d7a4b48f6d534ce5c79422c086a63460502b827ce62a326683c"
            ],
            [
              "d24a44e047e19b6f5afb81c7ca2f69080a5076689a010919f42725c2b789a33b",
              "6fb8d5591b466f8fc63db50f1c0f1c69013f996887b8244d2cdec417afea8fa3"
            ],
            [
              "ea01606a7a6c9cdd249fdfcfacb99584001edd28abbab77b5104e98e8e3b35d4",
              "322af4908c7312b0cfbfe369f7a7b3cdb7d4494bc2823700cfd652188a3ea98d"
            ],
            [
              "af8addbf2b661c8a6c6328655eb96651252007d8c5ea31be4ad196de8ce2131f",
              "6749e67c029b85f52a034eafd096836b2520818680e26ac8f3dfbcdb71749700"
            ],
            [
              "e3ae1974566ca06cc516d47e0fb165a674a3dabcfca15e722f0e3450f45889",
              "2aeabe7e4531510116217f07bf4d07300de97e4874f81f533420a72eeb0bd6a4"
            ],
            [
              "591ee355313d99721cf6993ffed1e3e301993ff3ed258802075ea8ced397e246",
              "b0ea558a113c30bea60fc4775460c7901ff0b053d25ca2bdeee98f1a4be5d196"
            ],
            [
              "11396d55fda54c49f19aa97318d8da61fa8584e47b084945077cf03255b52984",
              "998c74a8cd45ac01289d5833a7beb4744ff536b01b257be4c5767bea93ea57a4"
            ],
            [
              "3c5d2a1ba39c5a1790000738c9e0c40b8dcdfd5468754b6405540157e017aa7a",
              "b2284279995a34e2f9d4de7396fc18b80f9b8b9fdd270f6661f79ca4c81bd257"
            ],
            [
              "cc8704b8a60a0defa3a99a7299f2e9c3fbc395afb04ac078425ef8a1793cc030",
              "bdd46039feed17881d1e0862db347f8cf395b74fc4bcdc4e940b74e3ac1f1b13"
            ],
            [
              "c533e4f7ea8555aacd9777ac5cad29b97dd4defccc53ee7ea204119b2889b197",
              "6f0a256bc5efdf429a2fb6242f1a43a2d9b925bb4a4b3a26bb8e0f45eb596096"
            ],
            [
              "c14f8f2ccb27d6f109f6d08d03cc96a69ba8c34eec07bbcf566d48e33da6593",
              "c359d6923bb398f7fd4473e16fe1c28475b740dd098075e6c0e8649113dc3a38"
            ],
            [
              "a6cbc3046bc6a450bac24789fa17115a4c9739ed75f8f21ce441f72e0b90e6ef",
              "21ae7f4680e889bb130619e2c0f95a360ceb573c70603139862afd617fa9b9f"
            ],
            [
              "347d6d9a02c48927ebfb86c1359b1caf130a3c0267d11ce6344b39f99d43cc38",
              "60ea7f61a353524d1c987f6ecec92f086d565ab687870cb12689ff1e31c74448"
            ],
            [
              "da6545d2181db8d983f7dcb375ef5866d47c67b1bf31c8cf855ef7437b72656a",
              "49b96715ab6878a79e78f07ce5680c5d6673051b4935bd897fea824b77dc208a"
            ],
            [
              "c40747cc9d012cb1a13b8148309c6de7ec25d6945d657146b9d5994b8feb1111",
              "5ca560753be2a12fc6de6caf2cb489565db936156b9514e1bb5e83037e0fa2d4"
            ],
            [
              "4e42c8ec82c99798ccf3a610be870e78338c7f713348bd34c8203ef4037f3502",
              "7571d74ee5e0fb92a7a8b33a07783341a5492144cc54bcc40a94473693606437"
            ],
            [
              "3775ab7089bc6af823aba2e1af70b236d251cadb0c86743287522a1b3b0dedea",
              "be52d107bcfa09d8bcb9736a828cfa7fac8db17bf7a76a2c42ad961409018cf7"
            ],
            [
              "cee31cbf7e34ec379d94fb814d3d775ad954595d1314ba8846959e3e82f74e26",
              "8fd64a14c06b589c26b947ae2bcf6bfa0149ef0be14ed4d80f448a01c43b1c6d"
            ],
            [
              "b4f9eaea09b6917619f6ea6a4eb5464efddb58fd45b1ebefcdc1a01d08b47986",
              "39e5c9925b5a54b07433a4f18c61726f8bb131c012ca542eb24a8ac07200682a"
            ],
            [
              "d4263dfc3d2df923a0179a48966d30ce84e2515afc3dccc1b77907792ebcc60e",
              "62dfaf07a0f78feb30e30d6295853ce189e127760ad6cf7fae164e122a208d54"
            ],
            [
              "48457524820fa65a4f8d35eb6930857c0032acc0a4a2de422233eeda897612c4",
              "25a748ab367979d98733c38a1fa1c2e7dc6cc07db2d60a9ae7a76aaa49bd0f77"
            ],
            [
              "dfeeef1881101f2cb11644f3a2afdfc2045e19919152923f367a1767c11cceda",
              "ecfb7056cf1de042f9420bab396793c0c390bde74b4bbdff16a83ae09a9a7517"
            ],
            [
              "6d7ef6b17543f8373c573f44e1f389835d89bcbc6062ced36c82df83b8fae859",
              "cd450ec335438986dfefa10c57fea9bcc521a0959b2d80bbf74b190dca712d10"
            ],
            [
              "e75605d59102a5a2684500d3b991f2e3f3c88b93225547035af25af66e04541f",
              "f5c54754a8f71ee540b9b48728473e314f729ac5308b06938360990e2bfad125"
            ],
            [
              "eb98660f4c4dfaa06a2be453d5020bc99a0c2e60abe388457dd43fefb1ed620c",
              "6cb9a8876d9cb8520609af3add26cd20a0a7cd8a9411131ce85f44100099223e"
            ],
            [
              "13e87b027d8514d35939f2e6892b19922154596941888336dc3563e3b8dba942",
              "fef5a3c68059a6dec5d624114bf1e91aac2b9da568d6abeb2570d55646b8adf1"
            ],
            [
              "ee163026e9fd6fe017c38f06a5be6fc125424b371ce2708e7bf4491691e5764a",
              "1acb250f255dd61c43d94ccc670d0f58f49ae3fa15b96623e5430da0ad6c62b2"
            ],
            [
              "b268f5ef9ad51e4d78de3a750c2dc89b1e626d43505867999932e5db33af3d80",
              "5f310d4b3c99b9ebb19f77d41c1dee018cf0d34fd4191614003e945a1216e423"
            ],
            [
              "ff07f3118a9df035e9fad85eb6c7bfe42b02f01ca99ceea3bf7ffdba93c4750d",
              "438136d603e858a3a5c440c38eccbaddc1d2942114e2eddd4740d098ced1f0d8"
            ],
            [
              "8d8b9855c7c052a34146fd20ffb658bea4b9f69e0d825ebec16e8c3ce2b526a1",
              "cdb559eedc2d79f926baf44fb84ea4d44bcf50fee51d7ceb30e2e7f463036758"
            ],
            [
              "52db0b5384dfbf05bfa9d472d7ae26dfe4b851ceca91b1eba54263180da32b63",
              "c3b997d050ee5d423ebaf66a6db9f57b3180c902875679de924b69d84a7b375"
            ],
            [
              "e62f9490d3d51da6395efd24e80919cc7d0f29c3f3fa48c6fff543becbd43352",
              "6d89ad7ba4876b0b22c2ca280c682862f342c8591f1daf5170e07bfd9ccafa7d"
            ],
            [
              "7f30ea2476b399b4957509c88f77d0191afa2ff5cb7b14fd6d8e7d65aaab1193",
              "ca5ef7d4b231c94c3b15389a5f6311e9daff7bb67b103e9880ef4bff637acaec"
            ],
            [
              "5098ff1e1d9f14fb46a210fada6c903fef0fb7b4a1dd1d9ac60a0361800b7a00",
              "9731141d81fc8f8084d37c6e7542006b3ee1b40d60dfe5362a5b132fd17ddc0"
            ],
            [
              "32b78c7de9ee512a72895be6b9cbefa6e2f3c4ccce445c96b9f2c81e2778ad58",
              "ee1849f513df71e32efc3896ee28260c73bb80547ae2275ba497237794c8753c"
            ],
            [
              "e2cb74fddc8e9fbcd076eef2a7c72b0ce37d50f08269dfc074b581550547a4f7",
              "d3aa2ed71c9dd2247a62df062736eb0baddea9e36122d2be8641abcb005cc4a4"
            ],
            [
              "8438447566d4d7bedadc299496ab357426009a35f235cb141be0d99cd10ae3a8",
              "c4e1020916980a4da5d01ac5e6ad330734ef0d7906631c4f2390426b2edd791f"
            ],
            [
              "4162d488b89402039b584c6fc6c308870587d9c46f660b878ab65c82c711d67e",
              "67163e903236289f776f22c25fb8a3afc1732f2b84b4e95dbda47ae5a0852649"
            ],
            [
              "3fad3fa84caf0f34f0f89bfd2dcf54fc175d767aec3e50684f3ba4a4bf5f683d",
              "cd1bc7cb6cc407bb2f0ca647c718a730cf71872e7d0d2a53fa20efcdfe61826"
            ],
            [
              "674f2600a3007a00568c1a7ce05d0816c1fb84bf1370798f1c69532faeb1a86b",
              "299d21f9413f33b3edf43b257004580b70db57da0b182259e09eecc69e0d38a5"
            ],
            [
              "d32f4da54ade74abb81b815ad1fb3b263d82d6c692714bcff87d29bd5ee9f08f",
              "f9429e738b8e53b968e99016c059707782e14f4535359d582fc416910b3eea87"
            ],
            [
              "30e4e670435385556e593657135845d36fbb6931f72b08cb1ed954f1e3ce3ff6",
              "462f9bce619898638499350113bbc9b10a878d35da70740dc695a559eb88db7b"
            ],
            [
              "be2062003c51cc3004682904330e4dee7f3dcd10b01e580bf1971b04d4cad297",
              "62188bc49d61e5428573d48a74e1c655b1c61090905682a0d5558ed72dccb9bc"
            ],
            [
              "93144423ace3451ed29e0fb9ac2af211cb6e84a601df5993c419859fff5df04a",
              "7c10dfb164c3425f5c71a3f9d7992038f1065224f72bb9d1d902a6d13037b47c"
            ],
            [
              "b015f8044f5fcbdcf21ca26d6c34fb8197829205c7b7d2a7cb66418c157b112c",
              "ab8c1e086d04e813744a655b2df8d5f83b3cdc6faa3088c1d3aea1454e3a1d5f"
            ],
            [
              "d5e9e1da649d97d89e4868117a465a3a4f8a18de57a140d36b3f2af341a21b52",
              "4cb04437f391ed73111a13cc1d4dd0db1693465c2240480d8955e8592f27447a"
            ],
            [
              "d3ae41047dd7ca065dbf8ed77b992439983005cd72e16d6f996a5316d36966bb",
              "bd1aeb21ad22ebb22a10f0303417c6d964f8cdd7df0aca614b10dc14d125ac46"
            ],
            [
              "463e2763d885f958fc66cdd22800f0a487197d0a82e377b49f80af87c897b065",
              "bfefacdb0e5d0fd7df3a311a94de062b26b80c61fbc97508b79992671ef7ca7f"
            ],
            [
              "7985fdfd127c0567c6f53ec1bb63ec3158e597c40bfe747c83cddfc910641917",
              "603c12daf3d9862ef2b25fe1de289aed24ed291e0ec6708703a5bd567f32ed03"
            ],
            [
              "74a1ad6b5f76e39db2dd249410eac7f99e74c59cb83d2d0ed5ff1543da7703e9",
              "cc6157ef18c9c63cd6193d83631bbea0093e0968942e8c33d5737fd790e0db08"
            ],
            [
              "30682a50703375f602d416664ba19b7fc9bab42c72747463a71d0896b22f6da3",
              "553e04f6b018b4fa6c8f39e7f311d3176290d0e0f19ca73f17714d9977a22ff8"
            ],
            [
              "9e2158f0d7c0d5f26c3791efefa79597654e7a2b2464f52b1ee6c1347769ef57",
              "712fcdd1b9053f09003a3481fa7762e9ffd7c8ef35a38509e2fbf2629008373"
            ],
            [
              "176e26989a43c9cfeba4029c202538c28172e566e3c4fce7322857f3be327d66",
              "ed8cc9d04b29eb877d270b4878dc43c19aefd31f4eee09ee7b47834c1fa4b1c3"
            ],
            [
              "75d46efea3771e6e68abb89a13ad747ecf1892393dfc4f1b7004788c50374da8",
              "9852390a99507679fd0b86fd2b39a868d7efc22151346e1a3ca4726586a6bed8"
            ],
            [
              "809a20c67d64900ffb698c4c825f6d5f2310fb0451c869345b7319f645605721",
              "9e994980d9917e22b76b061927fa04143d096ccc54963e6a5ebfa5f3f8e286c1"
            ],
            [
              "1b38903a43f7f114ed4500b4eac7083fdefece1cf29c63528d563446f972c180",
              "4036edc931a60ae889353f77fd53de4a2708b26b6f5da72ad3394119daf408f9"
            ]
          ]
        }
      };
    }
  });

  // node_modules/elliptic/lib/elliptic/curves.js
  var require_curves = __commonJS({
    "node_modules/elliptic/lib/elliptic/curves.js"(exports2) {
      "use strict";
      var curves = exports2;
      var hash = require_hash2();
      var curve = require_curve();
      var utils = require_utils4();
      var assert = utils.assert;
      function PresetCurve(options) {
        if (options.type === "short")
          this.curve = new curve.short(options);
        else if (options.type === "edwards")
          this.curve = new curve.edwards(options);
        else
          this.curve = new curve.mont(options);
        this.g = this.curve.g;
        this.n = this.curve.n;
        this.hash = options.hash;
        assert(this.g.validate(), "Invalid curve");
        assert(this.g.mul(this.n).isInfinity(), "Invalid curve, G*N != O");
      }
      curves.PresetCurve = PresetCurve;
      function defineCurve(name, options) {
        Object.defineProperty(curves, name, {
          configurable: true,
          enumerable: true,
          get: function() {
            var curve2 = new PresetCurve(options);
            Object.defineProperty(curves, name, {
              configurable: true,
              enumerable: true,
              value: curve2
            });
            return curve2;
          }
        });
      }
      defineCurve("p192", {
        type: "short",
        prime: "p192",
        p: "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff",
        a: "ffffffff ffffffff ffffffff fffffffe ffffffff fffffffc",
        b: "64210519 e59c80e7 0fa7e9ab 72243049 feb8deec c146b9b1",
        n: "ffffffff ffffffff ffffffff 99def836 146bc9b1 b4d22831",
        hash: hash.sha256,
        gRed: false,
        g: [
          "188da80e b03090f6 7cbf20eb 43a18800 f4ff0afd 82ff1012",
          "07192b95 ffc8da78 631011ed 6b24cdd5 73f977a1 1e794811"
        ]
      });
      defineCurve("p224", {
        type: "short",
        prime: "p224",
        p: "ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001",
        a: "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff fffffffe",
        b: "b4050a85 0c04b3ab f5413256 5044b0b7 d7bfd8ba 270b3943 2355ffb4",
        n: "ffffffff ffffffff ffffffff ffff16a2 e0b8f03e 13dd2945 5c5c2a3d",
        hash: hash.sha256,
        gRed: false,
        g: [
          "b70e0cbd 6bb4bf7f 321390b9 4a03c1d3 56c21122 343280d6 115c1d21",
          "bd376388 b5f723fb 4c22dfe6 cd4375a0 5a074764 44d58199 85007e34"
        ]
      });
      defineCurve("p256", {
        type: "short",
        prime: null,
        p: "ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff ffffffff",
        a: "ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff fffffffc",
        b: "5ac635d8 aa3a93e7 b3ebbd55 769886bc 651d06b0 cc53b0f6 3bce3c3e 27d2604b",
        n: "ffffffff 00000000 ffffffff ffffffff bce6faad a7179e84 f3b9cac2 fc632551",
        hash: hash.sha256,
        gRed: false,
        g: [
          "6b17d1f2 e12c4247 f8bce6e5 63a440f2 77037d81 2deb33a0 f4a13945 d898c296",
          "4fe342e2 fe1a7f9b 8ee7eb4a 7c0f9e16 2bce3357 6b315ece cbb64068 37bf51f5"
        ]
      });
      defineCurve("p384", {
        type: "short",
        prime: null,
        p: "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe ffffffff 00000000 00000000 ffffffff",
        a: "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe ffffffff 00000000 00000000 fffffffc",
        b: "b3312fa7 e23ee7e4 988e056b e3f82d19 181d9c6e fe814112 0314088f 5013875a c656398d 8a2ed19d 2a85c8ed d3ec2aef",
        n: "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff c7634d81 f4372ddf 581a0db2 48b0a77a ecec196a ccc52973",
        hash: hash.sha384,
        gRed: false,
        g: [
          "aa87ca22 be8b0537 8eb1c71e f320ad74 6e1d3b62 8ba79b98 59f741e0 82542a38 5502f25d bf55296c 3a545e38 72760ab7",
          "3617de4a 96262c6f 5d9e98bf 9292dc29 f8f41dbd 289a147c e9da3113 b5f0b8c0 0a60b1ce 1d7e819d 7a431d7c 90ea0e5f"
        ]
      });
      defineCurve("p521", {
        type: "short",
        prime: null,
        p: "000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff",
        a: "000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffc",
        b: "00000051 953eb961 8e1c9a1f 929a21a0 b68540ee a2da725b 99b315f3 b8b48991 8ef109e1 56193951 ec7e937b 1652c0bd 3bb1bf07 3573df88 3d2c34f1 ef451fd4 6b503f00",
        n: "000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffa 51868783 bf2f966b 7fcc0148 f709a5d0 3bb5c9b8 899c47ae bb6fb71e 91386409",
        hash: hash.sha512,
        gRed: false,
        g: [
          "000000c6 858e06b7 0404e9cd 9e3ecb66 2395b442 9c648139 053fb521 f828af60 6b4d3dba a14b5e77 efe75928 fe1dc127 a2ffa8de 3348b3c1 856a429b f97e7e31 c2e5bd66",
          "00000118 39296a78 9a3bc004 5c8a5fb4 2c7d1bd9 98f54449 579b4468 17afbd17 273e662c 97ee7299 5ef42640 c550b901 3fad0761 353c7086 a272c240 88be9476 9fd16650"
        ]
      });
      defineCurve("curve25519", {
        type: "mont",
        prime: "p25519",
        p: "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed",
        a: "76d06",
        b: "1",
        n: "1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed",
        hash: hash.sha256,
        gRed: false,
        g: [
          "9"
        ]
      });
      defineCurve("ed25519", {
        type: "edwards",
        prime: "p25519",
        p: "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed",
        a: "-1",
        c: "1",
        d: "52036cee2b6ffe73 8cc740797779e898 00700a4d4141d8ab 75eb4dca135978a3",
        n: "1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed",
        hash: hash.sha256,
        gRed: false,
        g: [
          "216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a",
          "6666666666666666666666666666666666666666666666666666666666666658"
        ]
      });
      var pre;
      try {
        pre = require_secp256k1();
      } catch (e) {
        pre = void 0;
      }
      defineCurve("secp256k1", {
        type: "short",
        prime: "k256",
        p: "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f",
        a: "0",
        b: "7",
        n: "ffffffff ffffffff ffffffff fffffffe baaedce6 af48a03b bfd25e8c d0364141",
        h: "1",
        hash: hash.sha256,
        beta: "7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee",
        lambda: "5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72",
        basis: [
          {
            a: "3086d221a7d46bcde86c90e49284eb15",
            b: "-e4437ed6010e88286f547fa90abfe4c3"
          },
          {
            a: "114ca50f7a8e2f3f657c1108d9d44cfd8",
            b: "3086d221a7d46bcde86c90e49284eb15"
          }
        ],
        gRed: false,
        g: [
          "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
          "483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8",
          pre
        ]
      });
    }
  });

  // node_modules/hmac-drbg/lib/hmac-drbg.js
  var require_hmac_drbg = __commonJS({
    "node_modules/hmac-drbg/lib/hmac-drbg.js"(exports2, module2) {
      "use strict";
      var hash = require_hash2();
      var utils = require_utils3();
      var assert = require_minimalistic_assert();
      function HmacDRBG(options) {
        if (!(this instanceof HmacDRBG))
          return new HmacDRBG(options);
        this.hash = options.hash;
        this.predResist = !!options.predResist;
        this.outLen = this.hash.outSize;
        this.minEntropy = options.minEntropy || this.hash.hmacStrength;
        this._reseed = null;
        this.reseedInterval = null;
        this.K = null;
        this.V = null;
        var entropy = utils.toArray(options.entropy, options.entropyEnc || "hex");
        var nonce = utils.toArray(options.nonce, options.nonceEnc || "hex");
        var pers = utils.toArray(options.pers, options.persEnc || "hex");
        assert(entropy.length >= this.minEntropy / 8, "Not enough entropy. Minimum is: " + this.minEntropy + " bits");
        this._init(entropy, nonce, pers);
      }
      module2.exports = HmacDRBG;
      HmacDRBG.prototype._init = function init(entropy, nonce, pers) {
        var seed = entropy.concat(nonce).concat(pers);
        this.K = new Array(this.outLen / 8);
        this.V = new Array(this.outLen / 8);
        for (var i = 0; i < this.V.length; i++) {
          this.K[i] = 0;
          this.V[i] = 1;
        }
        this._update(seed);
        this._reseed = 1;
        this.reseedInterval = 281474976710656;
      };
      HmacDRBG.prototype._hmac = function hmac() {
        return new hash.hmac(this.hash, this.K);
      };
      HmacDRBG.prototype._update = function update(seed) {
        var kmac = this._hmac().update(this.V).update([0]);
        if (seed)
          kmac = kmac.update(seed);
        this.K = kmac.digest();
        this.V = this._hmac().update(this.V).digest();
        if (!seed)
          return;
        this.K = this._hmac().update(this.V).update([1]).update(seed).digest();
        this.V = this._hmac().update(this.V).digest();
      };
      HmacDRBG.prototype.reseed = function reseed(entropy, entropyEnc, add, addEnc) {
        if (typeof entropyEnc !== "string") {
          addEnc = add;
          add = entropyEnc;
          entropyEnc = null;
        }
        entropy = utils.toArray(entropy, entropyEnc);
        add = utils.toArray(add, addEnc);
        assert(entropy.length >= this.minEntropy / 8, "Not enough entropy. Minimum is: " + this.minEntropy + " bits");
        this._update(entropy.concat(add || []));
        this._reseed = 1;
      };
      HmacDRBG.prototype.generate = function generate(len, enc, add, addEnc) {
        if (this._reseed > this.reseedInterval)
          throw new Error("Reseed is required");
        if (typeof enc !== "string") {
          addEnc = add;
          add = enc;
          enc = null;
        }
        if (add) {
          add = utils.toArray(add, addEnc || "hex");
          this._update(add);
        }
        var temp = [];
        while (temp.length < len) {
          this.V = this._hmac().update(this.V).digest();
          temp = temp.concat(this.V);
        }
        var res = temp.slice(0, len);
        this._update(add);
        this._reseed++;
        return utils.encode(res, enc);
      };
    }
  });

  // node_modules/elliptic/lib/elliptic/ec/key.js
  var require_key = __commonJS({
    "node_modules/elliptic/lib/elliptic/ec/key.js"(exports2, module2) {
      "use strict";
      var BN = require_bn2();
      var utils = require_utils4();
      var assert = utils.assert;
      function KeyPair(ec, options) {
        this.ec = ec;
        this.priv = null;
        this.pub = null;
        if (options.priv)
          this._importPrivate(options.priv, options.privEnc);
        if (options.pub)
          this._importPublic(options.pub, options.pubEnc);
      }
      module2.exports = KeyPair;
      KeyPair.fromPublic = function fromPublic(ec, pub, enc) {
        if (pub instanceof KeyPair)
          return pub;
        return new KeyPair(ec, {
          pub,
          pubEnc: enc
        });
      };
      KeyPair.fromPrivate = function fromPrivate(ec, priv, enc) {
        if (priv instanceof KeyPair)
          return priv;
        return new KeyPair(ec, {
          priv,
          privEnc: enc
        });
      };
      KeyPair.prototype.validate = function validate() {
        var pub = this.getPublic();
        if (pub.isInfinity())
          return { result: false, reason: "Invalid public key" };
        if (!pub.validate())
          return { result: false, reason: "Public key is not a point" };
        if (!pub.mul(this.ec.curve.n).isInfinity())
          return { result: false, reason: "Public key * N != O" };
        return { result: true, reason: null };
      };
      KeyPair.prototype.getPublic = function getPublic(compact, enc) {
        if (typeof compact === "string") {
          enc = compact;
          compact = null;
        }
        if (!this.pub)
          this.pub = this.ec.g.mul(this.priv);
        if (!enc)
          return this.pub;
        return this.pub.encode(enc, compact);
      };
      KeyPair.prototype.getPrivate = function getPrivate(enc) {
        if (enc === "hex")
          return this.priv.toString(16, 2);
        else
          return this.priv;
      };
      KeyPair.prototype._importPrivate = function _importPrivate(key, enc) {
        this.priv = new BN(key, enc || 16);
        this.priv = this.priv.umod(this.ec.curve.n);
      };
      KeyPair.prototype._importPublic = function _importPublic(key, enc) {
        if (key.x || key.y) {
          if (this.ec.curve.type === "mont") {
            assert(key.x, "Need x coordinate");
          } else if (this.ec.curve.type === "short" || this.ec.curve.type === "edwards") {
            assert(key.x && key.y, "Need both x and y coordinate");
          }
          this.pub = this.ec.curve.point(key.x, key.y);
          return;
        }
        this.pub = this.ec.curve.decodePoint(key, enc);
      };
      KeyPair.prototype.derive = function derive(pub) {
        if (!pub.validate()) {
          assert(pub.validate(), "public point not validated");
        }
        return pub.mul(this.priv).getX();
      };
      KeyPair.prototype.sign = function sign(msg, enc, options) {
        return this.ec.sign(msg, this, enc, options);
      };
      KeyPair.prototype.verify = function verify(msg, signature) {
        return this.ec.verify(msg, signature, this);
      };
      KeyPair.prototype.inspect = function inspect() {
        return "<Key priv: " + (this.priv && this.priv.toString(16, 2)) + " pub: " + (this.pub && this.pub.inspect()) + " >";
      };
    }
  });

  // node_modules/elliptic/lib/elliptic/ec/signature.js
  var require_signature = __commonJS({
    "node_modules/elliptic/lib/elliptic/ec/signature.js"(exports2, module2) {
      "use strict";
      var BN = require_bn2();
      var utils = require_utils4();
      var assert = utils.assert;
      function Signature(options, enc) {
        if (options instanceof Signature)
          return options;
        if (this._importDER(options, enc))
          return;
        assert(options.r && options.s, "Signature without r or s");
        this.r = new BN(options.r, 16);
        this.s = new BN(options.s, 16);
        if (options.recoveryParam === void 0)
          this.recoveryParam = null;
        else
          this.recoveryParam = options.recoveryParam;
      }
      module2.exports = Signature;
      function Position() {
        this.place = 0;
      }
      function getLength(buf, p) {
        var initial = buf[p.place++];
        if (!(initial & 128)) {
          return initial;
        }
        var octetLen = initial & 15;
        if (octetLen === 0 || octetLen > 4) {
          return false;
        }
        var val = 0;
        for (var i = 0, off = p.place; i < octetLen; i++, off++) {
          val <<= 8;
          val |= buf[off];
          val >>>= 0;
        }
        if (val <= 127) {
          return false;
        }
        p.place = off;
        return val;
      }
      function rmPadding(buf) {
        var i = 0;
        var len = buf.length - 1;
        while (!buf[i] && !(buf[i + 1] & 128) && i < len) {
          i++;
        }
        if (i === 0) {
          return buf;
        }
        return buf.slice(i);
      }
      Signature.prototype._importDER = function _importDER(data, enc) {
        data = utils.toArray(data, enc);
        var p = new Position();
        if (data[p.place++] !== 48) {
          return false;
        }
        var len = getLength(data, p);
        if (len === false) {
          return false;
        }
        if (len + p.place !== data.length) {
          return false;
        }
        if (data[p.place++] !== 2) {
          return false;
        }
        var rlen = getLength(data, p);
        if (rlen === false) {
          return false;
        }
        var r = data.slice(p.place, rlen + p.place);
        p.place += rlen;
        if (data[p.place++] !== 2) {
          return false;
        }
        var slen = getLength(data, p);
        if (slen === false) {
          return false;
        }
        if (data.length !== slen + p.place) {
          return false;
        }
        var s = data.slice(p.place, slen + p.place);
        if (r[0] === 0) {
          if (r[1] & 128) {
            r = r.slice(1);
          } else {
            return false;
          }
        }
        if (s[0] === 0) {
          if (s[1] & 128) {
            s = s.slice(1);
          } else {
            return false;
          }
        }
        this.r = new BN(r);
        this.s = new BN(s);
        this.recoveryParam = null;
        return true;
      };
      function constructLength(arr, len) {
        if (len < 128) {
          arr.push(len);
          return;
        }
        var octets = 1 + (Math.log(len) / Math.LN2 >>> 3);
        arr.push(octets | 128);
        while (--octets) {
          arr.push(len >>> (octets << 3) & 255);
        }
        arr.push(len);
      }
      Signature.prototype.toDER = function toDER(enc) {
        var r = this.r.toArray();
        var s = this.s.toArray();
        if (r[0] & 128)
          r = [0].concat(r);
        if (s[0] & 128)
          s = [0].concat(s);
        r = rmPadding(r);
        s = rmPadding(s);
        while (!s[0] && !(s[1] & 128)) {
          s = s.slice(1);
        }
        var arr = [2];
        constructLength(arr, r.length);
        arr = arr.concat(r);
        arr.push(2);
        constructLength(arr, s.length);
        var backHalf = arr.concat(s);
        var res = [48];
        constructLength(res, backHalf.length);
        res = res.concat(backHalf);
        return utils.encode(res, enc);
      };
    }
  });

  // node_modules/elliptic/lib/elliptic/ec/index.js
  var require_ec = __commonJS({
    "node_modules/elliptic/lib/elliptic/ec/index.js"(exports2, module2) {
      "use strict";
      var BN = require_bn2();
      var HmacDRBG = require_hmac_drbg();
      var utils = require_utils4();
      var curves = require_curves();
      var rand = require_brorand();
      var assert = utils.assert;
      var KeyPair = require_key();
      var Signature = require_signature();
      function EC(options) {
        if (!(this instanceof EC))
          return new EC(options);
        if (typeof options === "string") {
          assert(Object.prototype.hasOwnProperty.call(curves, options), "Unknown curve " + options);
          options = curves[options];
        }
        if (options instanceof curves.PresetCurve)
          options = { curve: options };
        this.curve = options.curve.curve;
        this.n = this.curve.n;
        this.nh = this.n.ushrn(1);
        this.g = this.curve.g;
        this.g = options.curve.g;
        this.g.precompute(options.curve.n.bitLength() + 1);
        this.hash = options.hash || options.curve.hash;
      }
      module2.exports = EC;
      EC.prototype.keyPair = function keyPair(options) {
        return new KeyPair(this, options);
      };
      EC.prototype.keyFromPrivate = function keyFromPrivate(priv, enc) {
        return KeyPair.fromPrivate(this, priv, enc);
      };
      EC.prototype.keyFromPublic = function keyFromPublic(pub, enc) {
        return KeyPair.fromPublic(this, pub, enc);
      };
      EC.prototype.genKeyPair = function genKeyPair(options) {
        if (!options)
          options = {};
        var drbg = new HmacDRBG({
          hash: this.hash,
          pers: options.pers,
          persEnc: options.persEnc || "utf8",
          entropy: options.entropy || rand(this.hash.hmacStrength),
          entropyEnc: options.entropy && options.entropyEnc || "utf8",
          nonce: this.n.toArray()
        });
        var bytes = this.n.byteLength();
        var ns2 = this.n.sub(new BN(2));
        for (; ; ) {
          var priv = new BN(drbg.generate(bytes));
          if (priv.cmp(ns2) > 0)
            continue;
          priv.iaddn(1);
          return this.keyFromPrivate(priv);
        }
      };
      EC.prototype._truncateToN = function _truncateToN(msg, truncOnly) {
        var delta = msg.byteLength() * 8 - this.n.bitLength();
        if (delta > 0)
          msg = msg.ushrn(delta);
        if (!truncOnly && msg.cmp(this.n) >= 0)
          return msg.sub(this.n);
        else
          return msg;
      };
      EC.prototype.sign = function sign(msg, key, enc, options) {
        if (typeof enc === "object") {
          options = enc;
          enc = null;
        }
        if (!options)
          options = {};
        key = this.keyFromPrivate(key, enc);
        msg = this._truncateToN(new BN(msg, 16));
        var bytes = this.n.byteLength();
        var bkey = key.getPrivate().toArray("be", bytes);
        var nonce = msg.toArray("be", bytes);
        var drbg = new HmacDRBG({
          hash: this.hash,
          entropy: bkey,
          nonce,
          pers: options.pers,
          persEnc: options.persEnc || "utf8"
        });
        var ns1 = this.n.sub(new BN(1));
        for (var iter = 0; ; iter++) {
          var k = options.k ? options.k(iter) : new BN(drbg.generate(this.n.byteLength()));
          k = this._truncateToN(k, true);
          if (k.cmpn(1) <= 0 || k.cmp(ns1) >= 0)
            continue;
          var kp = this.g.mul(k);
          if (kp.isInfinity())
            continue;
          var kpX = kp.getX();
          var r = kpX.umod(this.n);
          if (r.cmpn(0) === 0)
            continue;
          var s = k.invm(this.n).mul(r.mul(key.getPrivate()).iadd(msg));
          s = s.umod(this.n);
          if (s.cmpn(0) === 0)
            continue;
          var recoveryParam = (kp.getY().isOdd() ? 1 : 0) | (kpX.cmp(r) !== 0 ? 2 : 0);
          if (options.canonical && s.cmp(this.nh) > 0) {
            s = this.n.sub(s);
            recoveryParam ^= 1;
          }
          return new Signature({ r, s, recoveryParam });
        }
      };
      EC.prototype.verify = function verify(msg, signature, key, enc) {
        msg = this._truncateToN(new BN(msg, 16));
        key = this.keyFromPublic(key, enc);
        signature = new Signature(signature, "hex");
        var r = signature.r;
        var s = signature.s;
        if (r.cmpn(1) < 0 || r.cmp(this.n) >= 0)
          return false;
        if (s.cmpn(1) < 0 || s.cmp(this.n) >= 0)
          return false;
        var sinv = s.invm(this.n);
        var u1 = sinv.mul(msg).umod(this.n);
        var u2 = sinv.mul(r).umod(this.n);
        var p;
        if (!this.curve._maxwellTrick) {
          p = this.g.mulAdd(u1, key.getPublic(), u2);
          if (p.isInfinity())
            return false;
          return p.getX().umod(this.n).cmp(r) === 0;
        }
        p = this.g.jmulAdd(u1, key.getPublic(), u2);
        if (p.isInfinity())
          return false;
        return p.eqXToP(r);
      };
      EC.prototype.recoverPubKey = function(msg, signature, j, enc) {
        assert((3 & j) === j, "The recovery param is more than two bits");
        signature = new Signature(signature, enc);
        var n = this.n;
        var e = new BN(msg);
        var r = signature.r;
        var s = signature.s;
        var isYOdd = j & 1;
        var isSecondKey = j >> 1;
        if (r.cmp(this.curve.p.umod(this.curve.n)) >= 0 && isSecondKey)
          throw new Error("Unable to find sencond key candinate");
        if (isSecondKey)
          r = this.curve.pointFromX(r.add(this.curve.n), isYOdd);
        else
          r = this.curve.pointFromX(r, isYOdd);
        var rInv = signature.r.invm(n);
        var s1 = n.sub(e).mul(rInv).umod(n);
        var s2 = s.mul(rInv).umod(n);
        return this.g.mulAdd(s1, r, s2);
      };
      EC.prototype.getKeyRecoveryParam = function(e, signature, Q, enc) {
        signature = new Signature(signature, enc);
        if (signature.recoveryParam !== null)
          return signature.recoveryParam;
        for (var i = 0; i < 4; i++) {
          var Qprime;
          try {
            Qprime = this.recoverPubKey(e, signature, i);
          } catch (e2) {
            continue;
          }
          if (Qprime.eq(Q))
            return i;
        }
        throw new Error("Unable to find valid recovery factor");
      };
    }
  });

  // node_modules/elliptic/lib/elliptic/eddsa/key.js
  var require_key2 = __commonJS({
    "node_modules/elliptic/lib/elliptic/eddsa/key.js"(exports2, module2) {
      "use strict";
      var utils = require_utils4();
      var assert = utils.assert;
      var parseBytes = utils.parseBytes;
      var cachedProperty = utils.cachedProperty;
      function KeyPair(eddsa, params) {
        this.eddsa = eddsa;
        this._secret = parseBytes(params.secret);
        if (eddsa.isPoint(params.pub))
          this._pub = params.pub;
        else
          this._pubBytes = parseBytes(params.pub);
      }
      KeyPair.fromPublic = function fromPublic(eddsa, pub) {
        if (pub instanceof KeyPair)
          return pub;
        return new KeyPair(eddsa, { pub });
      };
      KeyPair.fromSecret = function fromSecret(eddsa, secret) {
        if (secret instanceof KeyPair)
          return secret;
        return new KeyPair(eddsa, { secret });
      };
      KeyPair.prototype.secret = function secret() {
        return this._secret;
      };
      cachedProperty(KeyPair, "pubBytes", function pubBytes() {
        return this.eddsa.encodePoint(this.pub());
      });
      cachedProperty(KeyPair, "pub", function pub() {
        if (this._pubBytes)
          return this.eddsa.decodePoint(this._pubBytes);
        return this.eddsa.g.mul(this.priv());
      });
      cachedProperty(KeyPair, "privBytes", function privBytes() {
        var eddsa = this.eddsa;
        var hash = this.hash();
        var lastIx = eddsa.encodingLength - 1;
        var a = hash.slice(0, eddsa.encodingLength);
        a[0] &= 248;
        a[lastIx] &= 127;
        a[lastIx] |= 64;
        return a;
      });
      cachedProperty(KeyPair, "priv", function priv() {
        return this.eddsa.decodeInt(this.privBytes());
      });
      cachedProperty(KeyPair, "hash", function hash() {
        return this.eddsa.hash().update(this.secret()).digest();
      });
      cachedProperty(KeyPair, "messagePrefix", function messagePrefix() {
        return this.hash().slice(this.eddsa.encodingLength);
      });
      KeyPair.prototype.sign = function sign(message) {
        assert(this._secret, "KeyPair can only verify");
        return this.eddsa.sign(message, this);
      };
      KeyPair.prototype.verify = function verify(message, sig) {
        return this.eddsa.verify(message, sig, this);
      };
      KeyPair.prototype.getSecret = function getSecret(enc) {
        assert(this._secret, "KeyPair is public only");
        return utils.encode(this.secret(), enc);
      };
      KeyPair.prototype.getPublic = function getPublic(enc) {
        return utils.encode(this.pubBytes(), enc);
      };
      module2.exports = KeyPair;
    }
  });

  // node_modules/elliptic/lib/elliptic/eddsa/signature.js
  var require_signature2 = __commonJS({
    "node_modules/elliptic/lib/elliptic/eddsa/signature.js"(exports2, module2) {
      "use strict";
      var BN = require_bn2();
      var utils = require_utils4();
      var assert = utils.assert;
      var cachedProperty = utils.cachedProperty;
      var parseBytes = utils.parseBytes;
      function Signature(eddsa, sig) {
        this.eddsa = eddsa;
        if (typeof sig !== "object")
          sig = parseBytes(sig);
        if (Array.isArray(sig)) {
          sig = {
            R: sig.slice(0, eddsa.encodingLength),
            S: sig.slice(eddsa.encodingLength)
          };
        }
        assert(sig.R && sig.S, "Signature without R or S");
        if (eddsa.isPoint(sig.R))
          this._R = sig.R;
        if (sig.S instanceof BN)
          this._S = sig.S;
        this._Rencoded = Array.isArray(sig.R) ? sig.R : sig.Rencoded;
        this._Sencoded = Array.isArray(sig.S) ? sig.S : sig.Sencoded;
      }
      cachedProperty(Signature, "S", function S() {
        return this.eddsa.decodeInt(this.Sencoded());
      });
      cachedProperty(Signature, "R", function R() {
        return this.eddsa.decodePoint(this.Rencoded());
      });
      cachedProperty(Signature, "Rencoded", function Rencoded() {
        return this.eddsa.encodePoint(this.R());
      });
      cachedProperty(Signature, "Sencoded", function Sencoded() {
        return this.eddsa.encodeInt(this.S());
      });
      Signature.prototype.toBytes = function toBytes() {
        return this.Rencoded().concat(this.Sencoded());
      };
      Signature.prototype.toHex = function toHex() {
        return utils.encode(this.toBytes(), "hex").toUpperCase();
      };
      module2.exports = Signature;
    }
  });

  // node_modules/elliptic/lib/elliptic/eddsa/index.js
  var require_eddsa = __commonJS({
    "node_modules/elliptic/lib/elliptic/eddsa/index.js"(exports2, module2) {
      "use strict";
      var hash = require_hash2();
      var curves = require_curves();
      var utils = require_utils4();
      var assert = utils.assert;
      var parseBytes = utils.parseBytes;
      var KeyPair = require_key2();
      var Signature = require_signature2();
      function EDDSA(curve) {
        assert(curve === "ed25519", "only tested with ed25519 so far");
        if (!(this instanceof EDDSA))
          return new EDDSA(curve);
        curve = curves[curve].curve;
        this.curve = curve;
        this.g = curve.g;
        this.g.precompute(curve.n.bitLength() + 1);
        this.pointClass = curve.point().constructor;
        this.encodingLength = Math.ceil(curve.n.bitLength() / 8);
        this.hash = hash.sha512;
      }
      module2.exports = EDDSA;
      EDDSA.prototype.sign = function sign(message, secret) {
        message = parseBytes(message);
        var key = this.keyFromSecret(secret);
        var r = this.hashInt(key.messagePrefix(), message);
        var R = this.g.mul(r);
        var Rencoded = this.encodePoint(R);
        var s_ = this.hashInt(Rencoded, key.pubBytes(), message).mul(key.priv());
        var S = r.add(s_).umod(this.curve.n);
        return this.makeSignature({ R, S, Rencoded });
      };
      EDDSA.prototype.verify = function verify(message, sig, pub) {
        message = parseBytes(message);
        sig = this.makeSignature(sig);
        var key = this.keyFromPublic(pub);
        var h = this.hashInt(sig.Rencoded(), key.pubBytes(), message);
        var SG = this.g.mul(sig.S());
        var RplusAh = sig.R().add(key.pub().mul(h));
        return RplusAh.eq(SG);
      };
      EDDSA.prototype.hashInt = function hashInt() {
        var hash2 = this.hash();
        for (var i = 0; i < arguments.length; i++)
          hash2.update(arguments[i]);
        return utils.intFromLE(hash2.digest()).umod(this.curve.n);
      };
      EDDSA.prototype.keyFromPublic = function keyFromPublic(pub) {
        return KeyPair.fromPublic(this, pub);
      };
      EDDSA.prototype.keyFromSecret = function keyFromSecret(secret) {
        return KeyPair.fromSecret(this, secret);
      };
      EDDSA.prototype.makeSignature = function makeSignature(sig) {
        if (sig instanceof Signature)
          return sig;
        return new Signature(this, sig);
      };
      EDDSA.prototype.encodePoint = function encodePoint(point) {
        var enc = point.getY().toArray("le", this.encodingLength);
        enc[this.encodingLength - 1] |= point.getX().isOdd() ? 128 : 0;
        return enc;
      };
      EDDSA.prototype.decodePoint = function decodePoint(bytes) {
        bytes = utils.parseBytes(bytes);
        var lastIx = bytes.length - 1;
        var normed = bytes.slice(0, lastIx).concat(bytes[lastIx] & ~128);
        var xIsOdd = (bytes[lastIx] & 128) !== 0;
        var y = utils.intFromLE(normed);
        return this.curve.pointFromY(y, xIsOdd);
      };
      EDDSA.prototype.encodeInt = function encodeInt(num) {
        return num.toArray("le", this.encodingLength);
      };
      EDDSA.prototype.decodeInt = function decodeInt(bytes) {
        return utils.intFromLE(bytes);
      };
      EDDSA.prototype.isPoint = function isPoint(val) {
        return val instanceof this.pointClass;
      };
    }
  });

  // node_modules/elliptic/lib/elliptic.js
  var require_elliptic = __commonJS({
    "node_modules/elliptic/lib/elliptic.js"(exports2) {
      "use strict";
      var elliptic = exports2;
      elliptic.version = require_package().version;
      elliptic.utils = require_utils4();
      elliptic.rand = require_brorand();
      elliptic.curve = require_curve();
      elliptic.curves = require_curves();
      elliptic.ec = require_ec();
      elliptic.eddsa = require_eddsa();
    }
  });

  // node_modules/browserify-sign/node_modules/bn.js/lib/bn.js
  var require_bn4 = __commonJS({
    "node_modules/browserify-sign/node_modules/bn.js/lib/bn.js"(exports2, module2) {
      (function(module3, exports3) {
        "use strict";
        function assert(val, msg) {
          if (!val)
            throw new Error(msg || "Assertion failed");
        }
        function inherits(ctor, superCtor) {
          ctor.super_ = superCtor;
          var TempCtor = function() {
          };
          TempCtor.prototype = superCtor.prototype;
          ctor.prototype = new TempCtor();
          ctor.prototype.constructor = ctor;
        }
        function BN(number, base, endian) {
          if (BN.isBN(number)) {
            return number;
          }
          this.negative = 0;
          this.words = null;
          this.length = 0;
          this.red = null;
          if (number !== null) {
            if (base === "le" || base === "be") {
              endian = base;
              base = 10;
            }
            this._init(number || 0, base || 10, endian || "be");
          }
        }
        if (typeof module3 === "object") {
          module3.exports = BN;
        } else {
          exports3.BN = BN;
        }
        BN.BN = BN;
        BN.wordSize = 26;
        var Buffer2;
        try {
          if (typeof window !== "undefined" && typeof window.Buffer !== "undefined") {
            Buffer2 = window.Buffer;
          } else {
            Buffer2 = require_buffer().Buffer;
          }
        } catch (e) {
        }
        BN.isBN = function isBN(num) {
          if (num instanceof BN) {
            return true;
          }
          return num !== null && typeof num === "object" && num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);
        };
        BN.max = function max(left, right) {
          if (left.cmp(right) > 0)
            return left;
          return right;
        };
        BN.min = function min(left, right) {
          if (left.cmp(right) < 0)
            return left;
          return right;
        };
        BN.prototype._init = function init(number, base, endian) {
          if (typeof number === "number") {
            return this._initNumber(number, base, endian);
          }
          if (typeof number === "object") {
            return this._initArray(number, base, endian);
          }
          if (base === "hex") {
            base = 16;
          }
          assert(base === (base | 0) && base >= 2 && base <= 36);
          number = number.toString().replace(/\s+/g, "");
          var start2 = 0;
          if (number[0] === "-") {
            start2++;
            this.negative = 1;
          }
          if (start2 < number.length) {
            if (base === 16) {
              this._parseHex(number, start2, endian);
            } else {
              this._parseBase(number, base, start2);
              if (endian === "le") {
                this._initArray(this.toArray(), base, endian);
              }
            }
          }
        };
        BN.prototype._initNumber = function _initNumber(number, base, endian) {
          if (number < 0) {
            this.negative = 1;
            number = -number;
          }
          if (number < 67108864) {
            this.words = [number & 67108863];
            this.length = 1;
          } else if (number < 4503599627370496) {
            this.words = [
              number & 67108863,
              number / 67108864 & 67108863
            ];
            this.length = 2;
          } else {
            assert(number < 9007199254740992);
            this.words = [
              number & 67108863,
              number / 67108864 & 67108863,
              1
            ];
            this.length = 3;
          }
          if (endian !== "le")
            return;
          this._initArray(this.toArray(), base, endian);
        };
        BN.prototype._initArray = function _initArray(number, base, endian) {
          assert(typeof number.length === "number");
          if (number.length <= 0) {
            this.words = [0];
            this.length = 1;
            return this;
          }
          this.length = Math.ceil(number.length / 3);
          this.words = new Array(this.length);
          for (var i = 0; i < this.length; i++) {
            this.words[i] = 0;
          }
          var j, w;
          var off = 0;
          if (endian === "be") {
            for (i = number.length - 1, j = 0; i >= 0; i -= 3) {
              w = number[i] | number[i - 1] << 8 | number[i - 2] << 16;
              this.words[j] |= w << off & 67108863;
              this.words[j + 1] = w >>> 26 - off & 67108863;
              off += 24;
              if (off >= 26) {
                off -= 26;
                j++;
              }
            }
          } else if (endian === "le") {
            for (i = 0, j = 0; i < number.length; i += 3) {
              w = number[i] | number[i + 1] << 8 | number[i + 2] << 16;
              this.words[j] |= w << off & 67108863;
              this.words[j + 1] = w >>> 26 - off & 67108863;
              off += 24;
              if (off >= 26) {
                off -= 26;
                j++;
              }
            }
          }
          return this._strip();
        };
        function parseHex4Bits(string, index) {
          var c = string.charCodeAt(index);
          if (c >= 48 && c <= 57) {
            return c - 48;
          } else if (c >= 65 && c <= 70) {
            return c - 55;
          } else if (c >= 97 && c <= 102) {
            return c - 87;
          } else {
            assert(false, "Invalid character in " + string);
          }
        }
        function parseHexByte(string, lowerBound, index) {
          var r = parseHex4Bits(string, index);
          if (index - 1 >= lowerBound) {
            r |= parseHex4Bits(string, index - 1) << 4;
          }
          return r;
        }
        BN.prototype._parseHex = function _parseHex(number, start2, endian) {
          this.length = Math.ceil((number.length - start2) / 6);
          this.words = new Array(this.length);
          for (var i = 0; i < this.length; i++) {
            this.words[i] = 0;
          }
          var off = 0;
          var j = 0;
          var w;
          if (endian === "be") {
            for (i = number.length - 1; i >= start2; i -= 2) {
              w = parseHexByte(number, start2, i) << off;
              this.words[j] |= w & 67108863;
              if (off >= 18) {
                off -= 18;
                j += 1;
                this.words[j] |= w >>> 26;
              } else {
                off += 8;
              }
            }
          } else {
            var parseLength = number.length - start2;
            for (i = parseLength % 2 === 0 ? start2 + 1 : start2; i < number.length; i += 2) {
              w = parseHexByte(number, start2, i) << off;
              this.words[j] |= w & 67108863;
              if (off >= 18) {
                off -= 18;
                j += 1;
                this.words[j] |= w >>> 26;
              } else {
                off += 8;
              }
            }
          }
          this._strip();
        };
        function parseBase(str, start2, end, mul) {
          var r = 0;
          var b = 0;
          var len = Math.min(str.length, end);
          for (var i = start2; i < len; i++) {
            var c = str.charCodeAt(i) - 48;
            r *= mul;
            if (c >= 49) {
              b = c - 49 + 10;
            } else if (c >= 17) {
              b = c - 17 + 10;
            } else {
              b = c;
            }
            assert(c >= 0 && b < mul, "Invalid character");
            r += b;
          }
          return r;
        }
        BN.prototype._parseBase = function _parseBase(number, base, start2) {
          this.words = [0];
          this.length = 1;
          for (var limbLen = 0, limbPow = 1; limbPow <= 67108863; limbPow *= base) {
            limbLen++;
          }
          limbLen--;
          limbPow = limbPow / base | 0;
          var total = number.length - start2;
          var mod2 = total % limbLen;
          var end = Math.min(total, total - mod2) + start2;
          var word = 0;
          for (var i = start2; i < end; i += limbLen) {
            word = parseBase(number, i, i + limbLen, base);
            this.imuln(limbPow);
            if (this.words[0] + word < 67108864) {
              this.words[0] += word;
            } else {
              this._iaddn(word);
            }
          }
          if (mod2 !== 0) {
            var pow = 1;
            word = parseBase(number, i, number.length, base);
            for (i = 0; i < mod2; i++) {
              pow *= base;
            }
            this.imuln(pow);
            if (this.words[0] + word < 67108864) {
              this.words[0] += word;
            } else {
              this._iaddn(word);
            }
          }
          this._strip();
        };
        BN.prototype.copy = function copy(dest) {
          dest.words = new Array(this.length);
          for (var i = 0; i < this.length; i++) {
            dest.words[i] = this.words[i];
          }
          dest.length = this.length;
          dest.negative = this.negative;
          dest.red = this.red;
        };
        function move(dest, src) {
          dest.words = src.words;
          dest.length = src.length;
          dest.negative = src.negative;
          dest.red = src.red;
        }
        BN.prototype._move = function _move(dest) {
          move(dest, this);
        };
        BN.prototype.clone = function clone() {
          var r = new BN(null);
          this.copy(r);
          return r;
        };
        BN.prototype._expand = function _expand(size) {
          while (this.length < size) {
            this.words[this.length++] = 0;
          }
          return this;
        };
        BN.prototype._strip = function strip() {
          while (this.length > 1 && this.words[this.length - 1] === 0) {
            this.length--;
          }
          return this._normSign();
        };
        BN.prototype._normSign = function _normSign() {
          if (this.length === 1 && this.words[0] === 0) {
            this.negative = 0;
          }
          return this;
        };
        if (typeof Symbol !== "undefined" && typeof Symbol.for === "function") {
          try {
            BN.prototype[Symbol.for("nodejs.util.inspect.custom")] = inspect;
          } catch (e) {
            BN.prototype.inspect = inspect;
          }
        } else {
          BN.prototype.inspect = inspect;
        }
        function inspect() {
          return (this.red ? "<BN-R: " : "<BN: ") + this.toString(16) + ">";
        }
        var zeros = [
          "",
          "0",
          "00",
          "000",
          "0000",
          "00000",
          "000000",
          "0000000",
          "00000000",
          "000000000",
          "0000000000",
          "00000000000",
          "000000000000",
          "0000000000000",
          "00000000000000",
          "000000000000000",
          "0000000000000000",
          "00000000000000000",
          "000000000000000000",
          "0000000000000000000",
          "00000000000000000000",
          "000000000000000000000",
          "0000000000000000000000",
          "00000000000000000000000",
          "000000000000000000000000",
          "0000000000000000000000000"
        ];
        var groupSizes = [
          0,
          0,
          25,
          16,
          12,
          11,
          10,
          9,
          8,
          8,
          7,
          7,
          7,
          7,
          6,
          6,
          6,
          6,
          6,
          6,
          6,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5
        ];
        var groupBases = [
          0,
          0,
          33554432,
          43046721,
          16777216,
          48828125,
          60466176,
          40353607,
          16777216,
          43046721,
          1e7,
          19487171,
          35831808,
          62748517,
          7529536,
          11390625,
          16777216,
          24137569,
          34012224,
          47045881,
          64e6,
          4084101,
          5153632,
          6436343,
          7962624,
          9765625,
          11881376,
          14348907,
          17210368,
          20511149,
          243e5,
          28629151,
          33554432,
          39135393,
          45435424,
          52521875,
          60466176
        ];
        BN.prototype.toString = function toString(base, padding) {
          base = base || 10;
          padding = padding | 0 || 1;
          var out;
          if (base === 16 || base === "hex") {
            out = "";
            var off = 0;
            var carry = 0;
            for (var i = 0; i < this.length; i++) {
              var w = this.words[i];
              var word = ((w << off | carry) & 16777215).toString(16);
              carry = w >>> 24 - off & 16777215;
              if (carry !== 0 || i !== this.length - 1) {
                out = zeros[6 - word.length] + word + out;
              } else {
                out = word + out;
              }
              off += 2;
              if (off >= 26) {
                off -= 26;
                i--;
              }
            }
            if (carry !== 0) {
              out = carry.toString(16) + out;
            }
            while (out.length % padding !== 0) {
              out = "0" + out;
            }
            if (this.negative !== 0) {
              out = "-" + out;
            }
            return out;
          }
          if (base === (base | 0) && base >= 2 && base <= 36) {
            var groupSize = groupSizes[base];
            var groupBase = groupBases[base];
            out = "";
            var c = this.clone();
            c.negative = 0;
            while (!c.isZero()) {
              var r = c.modrn(groupBase).toString(base);
              c = c.idivn(groupBase);
              if (!c.isZero()) {
                out = zeros[groupSize - r.length] + r + out;
              } else {
                out = r + out;
              }
            }
            if (this.isZero()) {
              out = "0" + out;
            }
            while (out.length % padding !== 0) {
              out = "0" + out;
            }
            if (this.negative !== 0) {
              out = "-" + out;
            }
            return out;
          }
          assert(false, "Base should be between 2 and 36");
        };
        BN.prototype.toNumber = function toNumber() {
          var ret = this.words[0];
          if (this.length === 2) {
            ret += this.words[1] * 67108864;
          } else if (this.length === 3 && this.words[2] === 1) {
            ret += 4503599627370496 + this.words[1] * 67108864;
          } else if (this.length > 2) {
            assert(false, "Number can only safely store up to 53 bits");
          }
          return this.negative !== 0 ? -ret : ret;
        };
        BN.prototype.toJSON = function toJSON() {
          return this.toString(16, 2);
        };
        if (Buffer2) {
          BN.prototype.toBuffer = function toBuffer(endian, length) {
            return this.toArrayLike(Buffer2, endian, length);
          };
        }
        BN.prototype.toArray = function toArray(endian, length) {
          return this.toArrayLike(Array, endian, length);
        };
        var allocate = function allocate2(ArrayType, size) {
          if (ArrayType.allocUnsafe) {
            return ArrayType.allocUnsafe(size);
          }
          return new ArrayType(size);
        };
        BN.prototype.toArrayLike = function toArrayLike(ArrayType, endian, length) {
          this._strip();
          var byteLength = this.byteLength();
          var reqLength = length || Math.max(1, byteLength);
          assert(byteLength <= reqLength, "byte array longer than desired length");
          assert(reqLength > 0, "Requested array length <= 0");
          var res = allocate(ArrayType, reqLength);
          var postfix = endian === "le" ? "LE" : "BE";
          this["_toArrayLike" + postfix](res, byteLength);
          return res;
        };
        BN.prototype._toArrayLikeLE = function _toArrayLikeLE(res, byteLength) {
          var position = 0;
          var carry = 0;
          for (var i = 0, shift = 0; i < this.length; i++) {
            var word = this.words[i] << shift | carry;
            res[position++] = word & 255;
            if (position < res.length) {
              res[position++] = word >> 8 & 255;
            }
            if (position < res.length) {
              res[position++] = word >> 16 & 255;
            }
            if (shift === 6) {
              if (position < res.length) {
                res[position++] = word >> 24 & 255;
              }
              carry = 0;
              shift = 0;
            } else {
              carry = word >>> 24;
              shift += 2;
            }
          }
          if (position < res.length) {
            res[position++] = carry;
            while (position < res.length) {
              res[position++] = 0;
            }
          }
        };
        BN.prototype._toArrayLikeBE = function _toArrayLikeBE(res, byteLength) {
          var position = res.length - 1;
          var carry = 0;
          for (var i = 0, shift = 0; i < this.length; i++) {
            var word = this.words[i] << shift | carry;
            res[position--] = word & 255;
            if (position >= 0) {
              res[position--] = word >> 8 & 255;
            }
            if (position >= 0) {
              res[position--] = word >> 16 & 255;
            }
            if (shift === 6) {
              if (position >= 0) {
                res[position--] = word >> 24 & 255;
              }
              carry = 0;
              shift = 0;
            } else {
              carry = word >>> 24;
              shift += 2;
            }
          }
          if (position >= 0) {
            res[position--] = carry;
            while (position >= 0) {
              res[position--] = 0;
            }
          }
        };
        if (Math.clz32) {
          BN.prototype._countBits = function _countBits(w) {
            return 32 - Math.clz32(w);
          };
        } else {
          BN.prototype._countBits = function _countBits(w) {
            var t = w;
            var r = 0;
            if (t >= 4096) {
              r += 13;
              t >>>= 13;
            }
            if (t >= 64) {
              r += 7;
              t >>>= 7;
            }
            if (t >= 8) {
              r += 4;
              t >>>= 4;
            }
            if (t >= 2) {
              r += 2;
              t >>>= 2;
            }
            return r + t;
          };
        }
        BN.prototype._zeroBits = function _zeroBits(w) {
          if (w === 0)
            return 26;
          var t = w;
          var r = 0;
          if ((t & 8191) === 0) {
            r += 13;
            t >>>= 13;
          }
          if ((t & 127) === 0) {
            r += 7;
            t >>>= 7;
          }
          if ((t & 15) === 0) {
            r += 4;
            t >>>= 4;
          }
          if ((t & 3) === 0) {
            r += 2;
            t >>>= 2;
          }
          if ((t & 1) === 0) {
            r++;
          }
          return r;
        };
        BN.prototype.bitLength = function bitLength() {
          var w = this.words[this.length - 1];
          var hi = this._countBits(w);
          return (this.length - 1) * 26 + hi;
        };
        function toBitArray(num) {
          var w = new Array(num.bitLength());
          for (var bit = 0; bit < w.length; bit++) {
            var off = bit / 26 | 0;
            var wbit = bit % 26;
            w[bit] = num.words[off] >>> wbit & 1;
          }
          return w;
        }
        BN.prototype.zeroBits = function zeroBits() {
          if (this.isZero())
            return 0;
          var r = 0;
          for (var i = 0; i < this.length; i++) {
            var b = this._zeroBits(this.words[i]);
            r += b;
            if (b !== 26)
              break;
          }
          return r;
        };
        BN.prototype.byteLength = function byteLength() {
          return Math.ceil(this.bitLength() / 8);
        };
        BN.prototype.toTwos = function toTwos(width) {
          if (this.negative !== 0) {
            return this.abs().inotn(width).iaddn(1);
          }
          return this.clone();
        };
        BN.prototype.fromTwos = function fromTwos(width) {
          if (this.testn(width - 1)) {
            return this.notn(width).iaddn(1).ineg();
          }
          return this.clone();
        };
        BN.prototype.isNeg = function isNeg() {
          return this.negative !== 0;
        };
        BN.prototype.neg = function neg() {
          return this.clone().ineg();
        };
        BN.prototype.ineg = function ineg() {
          if (!this.isZero()) {
            this.negative ^= 1;
          }
          return this;
        };
        BN.prototype.iuor = function iuor(num) {
          while (this.length < num.length) {
            this.words[this.length++] = 0;
          }
          for (var i = 0; i < num.length; i++) {
            this.words[i] = this.words[i] | num.words[i];
          }
          return this._strip();
        };
        BN.prototype.ior = function ior(num) {
          assert((this.negative | num.negative) === 0);
          return this.iuor(num);
        };
        BN.prototype.or = function or(num) {
          if (this.length > num.length)
            return this.clone().ior(num);
          return num.clone().ior(this);
        };
        BN.prototype.uor = function uor(num) {
          if (this.length > num.length)
            return this.clone().iuor(num);
          return num.clone().iuor(this);
        };
        BN.prototype.iuand = function iuand(num) {
          var b;
          if (this.length > num.length) {
            b = num;
          } else {
            b = this;
          }
          for (var i = 0; i < b.length; i++) {
            this.words[i] = this.words[i] & num.words[i];
          }
          this.length = b.length;
          return this._strip();
        };
        BN.prototype.iand = function iand(num) {
          assert((this.negative | num.negative) === 0);
          return this.iuand(num);
        };
        BN.prototype.and = function and(num) {
          if (this.length > num.length)
            return this.clone().iand(num);
          return num.clone().iand(this);
        };
        BN.prototype.uand = function uand(num) {
          if (this.length > num.length)
            return this.clone().iuand(num);
          return num.clone().iuand(this);
        };
        BN.prototype.iuxor = function iuxor(num) {
          var a;
          var b;
          if (this.length > num.length) {
            a = this;
            b = num;
          } else {
            a = num;
            b = this;
          }
          for (var i = 0; i < b.length; i++) {
            this.words[i] = a.words[i] ^ b.words[i];
          }
          if (this !== a) {
            for (; i < a.length; i++) {
              this.words[i] = a.words[i];
            }
          }
          this.length = a.length;
          return this._strip();
        };
        BN.prototype.ixor = function ixor(num) {
          assert((this.negative | num.negative) === 0);
          return this.iuxor(num);
        };
        BN.prototype.xor = function xor(num) {
          if (this.length > num.length)
            return this.clone().ixor(num);
          return num.clone().ixor(this);
        };
        BN.prototype.uxor = function uxor(num) {
          if (this.length > num.length)
            return this.clone().iuxor(num);
          return num.clone().iuxor(this);
        };
        BN.prototype.inotn = function inotn(width) {
          assert(typeof width === "number" && width >= 0);
          var bytesNeeded = Math.ceil(width / 26) | 0;
          var bitsLeft = width % 26;
          this._expand(bytesNeeded);
          if (bitsLeft > 0) {
            bytesNeeded--;
          }
          for (var i = 0; i < bytesNeeded; i++) {
            this.words[i] = ~this.words[i] & 67108863;
          }
          if (bitsLeft > 0) {
            this.words[i] = ~this.words[i] & 67108863 >> 26 - bitsLeft;
          }
          return this._strip();
        };
        BN.prototype.notn = function notn(width) {
          return this.clone().inotn(width);
        };
        BN.prototype.setn = function setn(bit, val) {
          assert(typeof bit === "number" && bit >= 0);
          var off = bit / 26 | 0;
          var wbit = bit % 26;
          this._expand(off + 1);
          if (val) {
            this.words[off] = this.words[off] | 1 << wbit;
          } else {
            this.words[off] = this.words[off] & ~(1 << wbit);
          }
          return this._strip();
        };
        BN.prototype.iadd = function iadd(num) {
          var r;
          if (this.negative !== 0 && num.negative === 0) {
            this.negative = 0;
            r = this.isub(num);
            this.negative ^= 1;
            return this._normSign();
          } else if (this.negative === 0 && num.negative !== 0) {
            num.negative = 0;
            r = this.isub(num);
            num.negative = 1;
            return r._normSign();
          }
          var a, b;
          if (this.length > num.length) {
            a = this;
            b = num;
          } else {
            a = num;
            b = this;
          }
          var carry = 0;
          for (var i = 0; i < b.length; i++) {
            r = (a.words[i] | 0) + (b.words[i] | 0) + carry;
            this.words[i] = r & 67108863;
            carry = r >>> 26;
          }
          for (; carry !== 0 && i < a.length; i++) {
            r = (a.words[i] | 0) + carry;
            this.words[i] = r & 67108863;
            carry = r >>> 26;
          }
          this.length = a.length;
          if (carry !== 0) {
            this.words[this.length] = carry;
            this.length++;
          } else if (a !== this) {
            for (; i < a.length; i++) {
              this.words[i] = a.words[i];
            }
          }
          return this;
        };
        BN.prototype.add = function add(num) {
          var res;
          if (num.negative !== 0 && this.negative === 0) {
            num.negative = 0;
            res = this.sub(num);
            num.negative ^= 1;
            return res;
          } else if (num.negative === 0 && this.negative !== 0) {
            this.negative = 0;
            res = num.sub(this);
            this.negative = 1;
            return res;
          }
          if (this.length > num.length)
            return this.clone().iadd(num);
          return num.clone().iadd(this);
        };
        BN.prototype.isub = function isub(num) {
          if (num.negative !== 0) {
            num.negative = 0;
            var r = this.iadd(num);
            num.negative = 1;
            return r._normSign();
          } else if (this.negative !== 0) {
            this.negative = 0;
            this.iadd(num);
            this.negative = 1;
            return this._normSign();
          }
          var cmp = this.cmp(num);
          if (cmp === 0) {
            this.negative = 0;
            this.length = 1;
            this.words[0] = 0;
            return this;
          }
          var a, b;
          if (cmp > 0) {
            a = this;
            b = num;
          } else {
            a = num;
            b = this;
          }
          var carry = 0;
          for (var i = 0; i < b.length; i++) {
            r = (a.words[i] | 0) - (b.words[i] | 0) + carry;
            carry = r >> 26;
            this.words[i] = r & 67108863;
          }
          for (; carry !== 0 && i < a.length; i++) {
            r = (a.words[i] | 0) + carry;
            carry = r >> 26;
            this.words[i] = r & 67108863;
          }
          if (carry === 0 && i < a.length && a !== this) {
            for (; i < a.length; i++) {
              this.words[i] = a.words[i];
            }
          }
          this.length = Math.max(this.length, i);
          if (a !== this) {
            this.negative = 1;
          }
          return this._strip();
        };
        BN.prototype.sub = function sub(num) {
          return this.clone().isub(num);
        };
        function smallMulTo(self2, num, out) {
          out.negative = num.negative ^ self2.negative;
          var len = self2.length + num.length | 0;
          out.length = len;
          len = len - 1 | 0;
          var a = self2.words[0] | 0;
          var b = num.words[0] | 0;
          var r = a * b;
          var lo = r & 67108863;
          var carry = r / 67108864 | 0;
          out.words[0] = lo;
          for (var k = 1; k < len; k++) {
            var ncarry = carry >>> 26;
            var rword = carry & 67108863;
            var maxJ = Math.min(k, num.length - 1);
            for (var j = Math.max(0, k - self2.length + 1); j <= maxJ; j++) {
              var i = k - j | 0;
              a = self2.words[i] | 0;
              b = num.words[j] | 0;
              r = a * b + rword;
              ncarry += r / 67108864 | 0;
              rword = r & 67108863;
            }
            out.words[k] = rword | 0;
            carry = ncarry | 0;
          }
          if (carry !== 0) {
            out.words[k] = carry | 0;
          } else {
            out.length--;
          }
          return out._strip();
        }
        var comb10MulTo = function comb10MulTo2(self2, num, out) {
          var a = self2.words;
          var b = num.words;
          var o = out.words;
          var c = 0;
          var lo;
          var mid;
          var hi;
          var a0 = a[0] | 0;
          var al0 = a0 & 8191;
          var ah0 = a0 >>> 13;
          var a1 = a[1] | 0;
          var al1 = a1 & 8191;
          var ah1 = a1 >>> 13;
          var a2 = a[2] | 0;
          var al2 = a2 & 8191;
          var ah2 = a2 >>> 13;
          var a3 = a[3] | 0;
          var al3 = a3 & 8191;
          var ah3 = a3 >>> 13;
          var a4 = a[4] | 0;
          var al4 = a4 & 8191;
          var ah4 = a4 >>> 13;
          var a5 = a[5] | 0;
          var al5 = a5 & 8191;
          var ah5 = a5 >>> 13;
          var a6 = a[6] | 0;
          var al6 = a6 & 8191;
          var ah6 = a6 >>> 13;
          var a7 = a[7] | 0;
          var al7 = a7 & 8191;
          var ah7 = a7 >>> 13;
          var a8 = a[8] | 0;
          var al8 = a8 & 8191;
          var ah8 = a8 >>> 13;
          var a9 = a[9] | 0;
          var al9 = a9 & 8191;
          var ah9 = a9 >>> 13;
          var b0 = b[0] | 0;
          var bl0 = b0 & 8191;
          var bh0 = b0 >>> 13;
          var b1 = b[1] | 0;
          var bl1 = b1 & 8191;
          var bh1 = b1 >>> 13;
          var b2 = b[2] | 0;
          var bl2 = b2 & 8191;
          var bh2 = b2 >>> 13;
          var b3 = b[3] | 0;
          var bl3 = b3 & 8191;
          var bh3 = b3 >>> 13;
          var b4 = b[4] | 0;
          var bl4 = b4 & 8191;
          var bh4 = b4 >>> 13;
          var b5 = b[5] | 0;
          var bl5 = b5 & 8191;
          var bh5 = b5 >>> 13;
          var b6 = b[6] | 0;
          var bl6 = b6 & 8191;
          var bh6 = b6 >>> 13;
          var b7 = b[7] | 0;
          var bl7 = b7 & 8191;
          var bh7 = b7 >>> 13;
          var b8 = b[8] | 0;
          var bl8 = b8 & 8191;
          var bh8 = b8 >>> 13;
          var b9 = b[9] | 0;
          var bl9 = b9 & 8191;
          var bh9 = b9 >>> 13;
          out.negative = self2.negative ^ num.negative;
          out.length = 19;
          lo = Math.imul(al0, bl0);
          mid = Math.imul(al0, bh0);
          mid = mid + Math.imul(ah0, bl0) | 0;
          hi = Math.imul(ah0, bh0);
          var w0 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w0 >>> 26) | 0;
          w0 &= 67108863;
          lo = Math.imul(al1, bl0);
          mid = Math.imul(al1, bh0);
          mid = mid + Math.imul(ah1, bl0) | 0;
          hi = Math.imul(ah1, bh0);
          lo = lo + Math.imul(al0, bl1) | 0;
          mid = mid + Math.imul(al0, bh1) | 0;
          mid = mid + Math.imul(ah0, bl1) | 0;
          hi = hi + Math.imul(ah0, bh1) | 0;
          var w1 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w1 >>> 26) | 0;
          w1 &= 67108863;
          lo = Math.imul(al2, bl0);
          mid = Math.imul(al2, bh0);
          mid = mid + Math.imul(ah2, bl0) | 0;
          hi = Math.imul(ah2, bh0);
          lo = lo + Math.imul(al1, bl1) | 0;
          mid = mid + Math.imul(al1, bh1) | 0;
          mid = mid + Math.imul(ah1, bl1) | 0;
          hi = hi + Math.imul(ah1, bh1) | 0;
          lo = lo + Math.imul(al0, bl2) | 0;
          mid = mid + Math.imul(al0, bh2) | 0;
          mid = mid + Math.imul(ah0, bl2) | 0;
          hi = hi + Math.imul(ah0, bh2) | 0;
          var w2 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w2 >>> 26) | 0;
          w2 &= 67108863;
          lo = Math.imul(al3, bl0);
          mid = Math.imul(al3, bh0);
          mid = mid + Math.imul(ah3, bl0) | 0;
          hi = Math.imul(ah3, bh0);
          lo = lo + Math.imul(al2, bl1) | 0;
          mid = mid + Math.imul(al2, bh1) | 0;
          mid = mid + Math.imul(ah2, bl1) | 0;
          hi = hi + Math.imul(ah2, bh1) | 0;
          lo = lo + Math.imul(al1, bl2) | 0;
          mid = mid + Math.imul(al1, bh2) | 0;
          mid = mid + Math.imul(ah1, bl2) | 0;
          hi = hi + Math.imul(ah1, bh2) | 0;
          lo = lo + Math.imul(al0, bl3) | 0;
          mid = mid + Math.imul(al0, bh3) | 0;
          mid = mid + Math.imul(ah0, bl3) | 0;
          hi = hi + Math.imul(ah0, bh3) | 0;
          var w3 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w3 >>> 26) | 0;
          w3 &= 67108863;
          lo = Math.imul(al4, bl0);
          mid = Math.imul(al4, bh0);
          mid = mid + Math.imul(ah4, bl0) | 0;
          hi = Math.imul(ah4, bh0);
          lo = lo + Math.imul(al3, bl1) | 0;
          mid = mid + Math.imul(al3, bh1) | 0;
          mid = mid + Math.imul(ah3, bl1) | 0;
          hi = hi + Math.imul(ah3, bh1) | 0;
          lo = lo + Math.imul(al2, bl2) | 0;
          mid = mid + Math.imul(al2, bh2) | 0;
          mid = mid + Math.imul(ah2, bl2) | 0;
          hi = hi + Math.imul(ah2, bh2) | 0;
          lo = lo + Math.imul(al1, bl3) | 0;
          mid = mid + Math.imul(al1, bh3) | 0;
          mid = mid + Math.imul(ah1, bl3) | 0;
          hi = hi + Math.imul(ah1, bh3) | 0;
          lo = lo + Math.imul(al0, bl4) | 0;
          mid = mid + Math.imul(al0, bh4) | 0;
          mid = mid + Math.imul(ah0, bl4) | 0;
          hi = hi + Math.imul(ah0, bh4) | 0;
          var w4 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w4 >>> 26) | 0;
          w4 &= 67108863;
          lo = Math.imul(al5, bl0);
          mid = Math.imul(al5, bh0);
          mid = mid + Math.imul(ah5, bl0) | 0;
          hi = Math.imul(ah5, bh0);
          lo = lo + Math.imul(al4, bl1) | 0;
          mid = mid + Math.imul(al4, bh1) | 0;
          mid = mid + Math.imul(ah4, bl1) | 0;
          hi = hi + Math.imul(ah4, bh1) | 0;
          lo = lo + Math.imul(al3, bl2) | 0;
          mid = mid + Math.imul(al3, bh2) | 0;
          mid = mid + Math.imul(ah3, bl2) | 0;
          hi = hi + Math.imul(ah3, bh2) | 0;
          lo = lo + Math.imul(al2, bl3) | 0;
          mid = mid + Math.imul(al2, bh3) | 0;
          mid = mid + Math.imul(ah2, bl3) | 0;
          hi = hi + Math.imul(ah2, bh3) | 0;
          lo = lo + Math.imul(al1, bl4) | 0;
          mid = mid + Math.imul(al1, bh4) | 0;
          mid = mid + Math.imul(ah1, bl4) | 0;
          hi = hi + Math.imul(ah1, bh4) | 0;
          lo = lo + Math.imul(al0, bl5) | 0;
          mid = mid + Math.imul(al0, bh5) | 0;
          mid = mid + Math.imul(ah0, bl5) | 0;
          hi = hi + Math.imul(ah0, bh5) | 0;
          var w5 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w5 >>> 26) | 0;
          w5 &= 67108863;
          lo = Math.imul(al6, bl0);
          mid = Math.imul(al6, bh0);
          mid = mid + Math.imul(ah6, bl0) | 0;
          hi = Math.imul(ah6, bh0);
          lo = lo + Math.imul(al5, bl1) | 0;
          mid = mid + Math.imul(al5, bh1) | 0;
          mid = mid + Math.imul(ah5, bl1) | 0;
          hi = hi + Math.imul(ah5, bh1) | 0;
          lo = lo + Math.imul(al4, bl2) | 0;
          mid = mid + Math.imul(al4, bh2) | 0;
          mid = mid + Math.imul(ah4, bl2) | 0;
          hi = hi + Math.imul(ah4, bh2) | 0;
          lo = lo + Math.imul(al3, bl3) | 0;
          mid = mid + Math.imul(al3, bh3) | 0;
          mid = mid + Math.imul(ah3, bl3) | 0;
          hi = hi + Math.imul(ah3, bh3) | 0;
          lo = lo + Math.imul(al2, bl4) | 0;
          mid = mid + Math.imul(al2, bh4) | 0;
          mid = mid + Math.imul(ah2, bl4) | 0;
          hi = hi + Math.imul(ah2, bh4) | 0;
          lo = lo + Math.imul(al1, bl5) | 0;
          mid = mid + Math.imul(al1, bh5) | 0;
          mid = mid + Math.imul(ah1, bl5) | 0;
          hi = hi + Math.imul(ah1, bh5) | 0;
          lo = lo + Math.imul(al0, bl6) | 0;
          mid = mid + Math.imul(al0, bh6) | 0;
          mid = mid + Math.imul(ah0, bl6) | 0;
          hi = hi + Math.imul(ah0, bh6) | 0;
          var w6 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w6 >>> 26) | 0;
          w6 &= 67108863;
          lo = Math.imul(al7, bl0);
          mid = Math.imul(al7, bh0);
          mid = mid + Math.imul(ah7, bl0) | 0;
          hi = Math.imul(ah7, bh0);
          lo = lo + Math.imul(al6, bl1) | 0;
          mid = mid + Math.imul(al6, bh1) | 0;
          mid = mid + Math.imul(ah6, bl1) | 0;
          hi = hi + Math.imul(ah6, bh1) | 0;
          lo = lo + Math.imul(al5, bl2) | 0;
          mid = mid + Math.imul(al5, bh2) | 0;
          mid = mid + Math.imul(ah5, bl2) | 0;
          hi = hi + Math.imul(ah5, bh2) | 0;
          lo = lo + Math.imul(al4, bl3) | 0;
          mid = mid + Math.imul(al4, bh3) | 0;
          mid = mid + Math.imul(ah4, bl3) | 0;
          hi = hi + Math.imul(ah4, bh3) | 0;
          lo = lo + Math.imul(al3, bl4) | 0;
          mid = mid + Math.imul(al3, bh4) | 0;
          mid = mid + Math.imul(ah3, bl4) | 0;
          hi = hi + Math.imul(ah3, bh4) | 0;
          lo = lo + Math.imul(al2, bl5) | 0;
          mid = mid + Math.imul(al2, bh5) | 0;
          mid = mid + Math.imul(ah2, bl5) | 0;
          hi = hi + Math.imul(ah2, bh5) | 0;
          lo = lo + Math.imul(al1, bl6) | 0;
          mid = mid + Math.imul(al1, bh6) | 0;
          mid = mid + Math.imul(ah1, bl6) | 0;
          hi = hi + Math.imul(ah1, bh6) | 0;
          lo = lo + Math.imul(al0, bl7) | 0;
          mid = mid + Math.imul(al0, bh7) | 0;
          mid = mid + Math.imul(ah0, bl7) | 0;
          hi = hi + Math.imul(ah0, bh7) | 0;
          var w7 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w7 >>> 26) | 0;
          w7 &= 67108863;
          lo = Math.imul(al8, bl0);
          mid = Math.imul(al8, bh0);
          mid = mid + Math.imul(ah8, bl0) | 0;
          hi = Math.imul(ah8, bh0);
          lo = lo + Math.imul(al7, bl1) | 0;
          mid = mid + Math.imul(al7, bh1) | 0;
          mid = mid + Math.imul(ah7, bl1) | 0;
          hi = hi + Math.imul(ah7, bh1) | 0;
          lo = lo + Math.imul(al6, bl2) | 0;
          mid = mid + Math.imul(al6, bh2) | 0;
          mid = mid + Math.imul(ah6, bl2) | 0;
          hi = hi + Math.imul(ah6, bh2) | 0;
          lo = lo + Math.imul(al5, bl3) | 0;
          mid = mid + Math.imul(al5, bh3) | 0;
          mid = mid + Math.imul(ah5, bl3) | 0;
          hi = hi + Math.imul(ah5, bh3) | 0;
          lo = lo + Math.imul(al4, bl4) | 0;
          mid = mid + Math.imul(al4, bh4) | 0;
          mid = mid + Math.imul(ah4, bl4) | 0;
          hi = hi + Math.imul(ah4, bh4) | 0;
          lo = lo + Math.imul(al3, bl5) | 0;
          mid = mid + Math.imul(al3, bh5) | 0;
          mid = mid + Math.imul(ah3, bl5) | 0;
          hi = hi + Math.imul(ah3, bh5) | 0;
          lo = lo + Math.imul(al2, bl6) | 0;
          mid = mid + Math.imul(al2, bh6) | 0;
          mid = mid + Math.imul(ah2, bl6) | 0;
          hi = hi + Math.imul(ah2, bh6) | 0;
          lo = lo + Math.imul(al1, bl7) | 0;
          mid = mid + Math.imul(al1, bh7) | 0;
          mid = mid + Math.imul(ah1, bl7) | 0;
          hi = hi + Math.imul(ah1, bh7) | 0;
          lo = lo + Math.imul(al0, bl8) | 0;
          mid = mid + Math.imul(al0, bh8) | 0;
          mid = mid + Math.imul(ah0, bl8) | 0;
          hi = hi + Math.imul(ah0, bh8) | 0;
          var w8 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w8 >>> 26) | 0;
          w8 &= 67108863;
          lo = Math.imul(al9, bl0);
          mid = Math.imul(al9, bh0);
          mid = mid + Math.imul(ah9, bl0) | 0;
          hi = Math.imul(ah9, bh0);
          lo = lo + Math.imul(al8, bl1) | 0;
          mid = mid + Math.imul(al8, bh1) | 0;
          mid = mid + Math.imul(ah8, bl1) | 0;
          hi = hi + Math.imul(ah8, bh1) | 0;
          lo = lo + Math.imul(al7, bl2) | 0;
          mid = mid + Math.imul(al7, bh2) | 0;
          mid = mid + Math.imul(ah7, bl2) | 0;
          hi = hi + Math.imul(ah7, bh2) | 0;
          lo = lo + Math.imul(al6, bl3) | 0;
          mid = mid + Math.imul(al6, bh3) | 0;
          mid = mid + Math.imul(ah6, bl3) | 0;
          hi = hi + Math.imul(ah6, bh3) | 0;
          lo = lo + Math.imul(al5, bl4) | 0;
          mid = mid + Math.imul(al5, bh4) | 0;
          mid = mid + Math.imul(ah5, bl4) | 0;
          hi = hi + Math.imul(ah5, bh4) | 0;
          lo = lo + Math.imul(al4, bl5) | 0;
          mid = mid + Math.imul(al4, bh5) | 0;
          mid = mid + Math.imul(ah4, bl5) | 0;
          hi = hi + Math.imul(ah4, bh5) | 0;
          lo = lo + Math.imul(al3, bl6) | 0;
          mid = mid + Math.imul(al3, bh6) | 0;
          mid = mid + Math.imul(ah3, bl6) | 0;
          hi = hi + Math.imul(ah3, bh6) | 0;
          lo = lo + Math.imul(al2, bl7) | 0;
          mid = mid + Math.imul(al2, bh7) | 0;
          mid = mid + Math.imul(ah2, bl7) | 0;
          hi = hi + Math.imul(ah2, bh7) | 0;
          lo = lo + Math.imul(al1, bl8) | 0;
          mid = mid + Math.imul(al1, bh8) | 0;
          mid = mid + Math.imul(ah1, bl8) | 0;
          hi = hi + Math.imul(ah1, bh8) | 0;
          lo = lo + Math.imul(al0, bl9) | 0;
          mid = mid + Math.imul(al0, bh9) | 0;
          mid = mid + Math.imul(ah0, bl9) | 0;
          hi = hi + Math.imul(ah0, bh9) | 0;
          var w9 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w9 >>> 26) | 0;
          w9 &= 67108863;
          lo = Math.imul(al9, bl1);
          mid = Math.imul(al9, bh1);
          mid = mid + Math.imul(ah9, bl1) | 0;
          hi = Math.imul(ah9, bh1);
          lo = lo + Math.imul(al8, bl2) | 0;
          mid = mid + Math.imul(al8, bh2) | 0;
          mid = mid + Math.imul(ah8, bl2) | 0;
          hi = hi + Math.imul(ah8, bh2) | 0;
          lo = lo + Math.imul(al7, bl3) | 0;
          mid = mid + Math.imul(al7, bh3) | 0;
          mid = mid + Math.imul(ah7, bl3) | 0;
          hi = hi + Math.imul(ah7, bh3) | 0;
          lo = lo + Math.imul(al6, bl4) | 0;
          mid = mid + Math.imul(al6, bh4) | 0;
          mid = mid + Math.imul(ah6, bl4) | 0;
          hi = hi + Math.imul(ah6, bh4) | 0;
          lo = lo + Math.imul(al5, bl5) | 0;
          mid = mid + Math.imul(al5, bh5) | 0;
          mid = mid + Math.imul(ah5, bl5) | 0;
          hi = hi + Math.imul(ah5, bh5) | 0;
          lo = lo + Math.imul(al4, bl6) | 0;
          mid = mid + Math.imul(al4, bh6) | 0;
          mid = mid + Math.imul(ah4, bl6) | 0;
          hi = hi + Math.imul(ah4, bh6) | 0;
          lo = lo + Math.imul(al3, bl7) | 0;
          mid = mid + Math.imul(al3, bh7) | 0;
          mid = mid + Math.imul(ah3, bl7) | 0;
          hi = hi + Math.imul(ah3, bh7) | 0;
          lo = lo + Math.imul(al2, bl8) | 0;
          mid = mid + Math.imul(al2, bh8) | 0;
          mid = mid + Math.imul(ah2, bl8) | 0;
          hi = hi + Math.imul(ah2, bh8) | 0;
          lo = lo + Math.imul(al1, bl9) | 0;
          mid = mid + Math.imul(al1, bh9) | 0;
          mid = mid + Math.imul(ah1, bl9) | 0;
          hi = hi + Math.imul(ah1, bh9) | 0;
          var w10 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w10 >>> 26) | 0;
          w10 &= 67108863;
          lo = Math.imul(al9, bl2);
          mid = Math.imul(al9, bh2);
          mid = mid + Math.imul(ah9, bl2) | 0;
          hi = Math.imul(ah9, bh2);
          lo = lo + Math.imul(al8, bl3) | 0;
          mid = mid + Math.imul(al8, bh3) | 0;
          mid = mid + Math.imul(ah8, bl3) | 0;
          hi = hi + Math.imul(ah8, bh3) | 0;
          lo = lo + Math.imul(al7, bl4) | 0;
          mid = mid + Math.imul(al7, bh4) | 0;
          mid = mid + Math.imul(ah7, bl4) | 0;
          hi = hi + Math.imul(ah7, bh4) | 0;
          lo = lo + Math.imul(al6, bl5) | 0;
          mid = mid + Math.imul(al6, bh5) | 0;
          mid = mid + Math.imul(ah6, bl5) | 0;
          hi = hi + Math.imul(ah6, bh5) | 0;
          lo = lo + Math.imul(al5, bl6) | 0;
          mid = mid + Math.imul(al5, bh6) | 0;
          mid = mid + Math.imul(ah5, bl6) | 0;
          hi = hi + Math.imul(ah5, bh6) | 0;
          lo = lo + Math.imul(al4, bl7) | 0;
          mid = mid + Math.imul(al4, bh7) | 0;
          mid = mid + Math.imul(ah4, bl7) | 0;
          hi = hi + Math.imul(ah4, bh7) | 0;
          lo = lo + Math.imul(al3, bl8) | 0;
          mid = mid + Math.imul(al3, bh8) | 0;
          mid = mid + Math.imul(ah3, bl8) | 0;
          hi = hi + Math.imul(ah3, bh8) | 0;
          lo = lo + Math.imul(al2, bl9) | 0;
          mid = mid + Math.imul(al2, bh9) | 0;
          mid = mid + Math.imul(ah2, bl9) | 0;
          hi = hi + Math.imul(ah2, bh9) | 0;
          var w11 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w11 >>> 26) | 0;
          w11 &= 67108863;
          lo = Math.imul(al9, bl3);
          mid = Math.imul(al9, bh3);
          mid = mid + Math.imul(ah9, bl3) | 0;
          hi = Math.imul(ah9, bh3);
          lo = lo + Math.imul(al8, bl4) | 0;
          mid = mid + Math.imul(al8, bh4) | 0;
          mid = mid + Math.imul(ah8, bl4) | 0;
          hi = hi + Math.imul(ah8, bh4) | 0;
          lo = lo + Math.imul(al7, bl5) | 0;
          mid = mid + Math.imul(al7, bh5) | 0;
          mid = mid + Math.imul(ah7, bl5) | 0;
          hi = hi + Math.imul(ah7, bh5) | 0;
          lo = lo + Math.imul(al6, bl6) | 0;
          mid = mid + Math.imul(al6, bh6) | 0;
          mid = mid + Math.imul(ah6, bl6) | 0;
          hi = hi + Math.imul(ah6, bh6) | 0;
          lo = lo + Math.imul(al5, bl7) | 0;
          mid = mid + Math.imul(al5, bh7) | 0;
          mid = mid + Math.imul(ah5, bl7) | 0;
          hi = hi + Math.imul(ah5, bh7) | 0;
          lo = lo + Math.imul(al4, bl8) | 0;
          mid = mid + Math.imul(al4, bh8) | 0;
          mid = mid + Math.imul(ah4, bl8) | 0;
          hi = hi + Math.imul(ah4, bh8) | 0;
          lo = lo + Math.imul(al3, bl9) | 0;
          mid = mid + Math.imul(al3, bh9) | 0;
          mid = mid + Math.imul(ah3, bl9) | 0;
          hi = hi + Math.imul(ah3, bh9) | 0;
          var w12 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w12 >>> 26) | 0;
          w12 &= 67108863;
          lo = Math.imul(al9, bl4);
          mid = Math.imul(al9, bh4);
          mid = mid + Math.imul(ah9, bl4) | 0;
          hi = Math.imul(ah9, bh4);
          lo = lo + Math.imul(al8, bl5) | 0;
          mid = mid + Math.imul(al8, bh5) | 0;
          mid = mid + Math.imul(ah8, bl5) | 0;
          hi = hi + Math.imul(ah8, bh5) | 0;
          lo = lo + Math.imul(al7, bl6) | 0;
          mid = mid + Math.imul(al7, bh6) | 0;
          mid = mid + Math.imul(ah7, bl6) | 0;
          hi = hi + Math.imul(ah7, bh6) | 0;
          lo = lo + Math.imul(al6, bl7) | 0;
          mid = mid + Math.imul(al6, bh7) | 0;
          mid = mid + Math.imul(ah6, bl7) | 0;
          hi = hi + Math.imul(ah6, bh7) | 0;
          lo = lo + Math.imul(al5, bl8) | 0;
          mid = mid + Math.imul(al5, bh8) | 0;
          mid = mid + Math.imul(ah5, bl8) | 0;
          hi = hi + Math.imul(ah5, bh8) | 0;
          lo = lo + Math.imul(al4, bl9) | 0;
          mid = mid + Math.imul(al4, bh9) | 0;
          mid = mid + Math.imul(ah4, bl9) | 0;
          hi = hi + Math.imul(ah4, bh9) | 0;
          var w13 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w13 >>> 26) | 0;
          w13 &= 67108863;
          lo = Math.imul(al9, bl5);
          mid = Math.imul(al9, bh5);
          mid = mid + Math.imul(ah9, bl5) | 0;
          hi = Math.imul(ah9, bh5);
          lo = lo + Math.imul(al8, bl6) | 0;
          mid = mid + Math.imul(al8, bh6) | 0;
          mid = mid + Math.imul(ah8, bl6) | 0;
          hi = hi + Math.imul(ah8, bh6) | 0;
          lo = lo + Math.imul(al7, bl7) | 0;
          mid = mid + Math.imul(al7, bh7) | 0;
          mid = mid + Math.imul(ah7, bl7) | 0;
          hi = hi + Math.imul(ah7, bh7) | 0;
          lo = lo + Math.imul(al6, bl8) | 0;
          mid = mid + Math.imul(al6, bh8) | 0;
          mid = mid + Math.imul(ah6, bl8) | 0;
          hi = hi + Math.imul(ah6, bh8) | 0;
          lo = lo + Math.imul(al5, bl9) | 0;
          mid = mid + Math.imul(al5, bh9) | 0;
          mid = mid + Math.imul(ah5, bl9) | 0;
          hi = hi + Math.imul(ah5, bh9) | 0;
          var w14 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w14 >>> 26) | 0;
          w14 &= 67108863;
          lo = Math.imul(al9, bl6);
          mid = Math.imul(al9, bh6);
          mid = mid + Math.imul(ah9, bl6) | 0;
          hi = Math.imul(ah9, bh6);
          lo = lo + Math.imul(al8, bl7) | 0;
          mid = mid + Math.imul(al8, bh7) | 0;
          mid = mid + Math.imul(ah8, bl7) | 0;
          hi = hi + Math.imul(ah8, bh7) | 0;
          lo = lo + Math.imul(al7, bl8) | 0;
          mid = mid + Math.imul(al7, bh8) | 0;
          mid = mid + Math.imul(ah7, bl8) | 0;
          hi = hi + Math.imul(ah7, bh8) | 0;
          lo = lo + Math.imul(al6, bl9) | 0;
          mid = mid + Math.imul(al6, bh9) | 0;
          mid = mid + Math.imul(ah6, bl9) | 0;
          hi = hi + Math.imul(ah6, bh9) | 0;
          var w15 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w15 >>> 26) | 0;
          w15 &= 67108863;
          lo = Math.imul(al9, bl7);
          mid = Math.imul(al9, bh7);
          mid = mid + Math.imul(ah9, bl7) | 0;
          hi = Math.imul(ah9, bh7);
          lo = lo + Math.imul(al8, bl8) | 0;
          mid = mid + Math.imul(al8, bh8) | 0;
          mid = mid + Math.imul(ah8, bl8) | 0;
          hi = hi + Math.imul(ah8, bh8) | 0;
          lo = lo + Math.imul(al7, bl9) | 0;
          mid = mid + Math.imul(al7, bh9) | 0;
          mid = mid + Math.imul(ah7, bl9) | 0;
          hi = hi + Math.imul(ah7, bh9) | 0;
          var w16 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w16 >>> 26) | 0;
          w16 &= 67108863;
          lo = Math.imul(al9, bl8);
          mid = Math.imul(al9, bh8);
          mid = mid + Math.imul(ah9, bl8) | 0;
          hi = Math.imul(ah9, bh8);
          lo = lo + Math.imul(al8, bl9) | 0;
          mid = mid + Math.imul(al8, bh9) | 0;
          mid = mid + Math.imul(ah8, bl9) | 0;
          hi = hi + Math.imul(ah8, bh9) | 0;
          var w17 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w17 >>> 26) | 0;
          w17 &= 67108863;
          lo = Math.imul(al9, bl9);
          mid = Math.imul(al9, bh9);
          mid = mid + Math.imul(ah9, bl9) | 0;
          hi = Math.imul(ah9, bh9);
          var w18 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w18 >>> 26) | 0;
          w18 &= 67108863;
          o[0] = w0;
          o[1] = w1;
          o[2] = w2;
          o[3] = w3;
          o[4] = w4;
          o[5] = w5;
          o[6] = w6;
          o[7] = w7;
          o[8] = w8;
          o[9] = w9;
          o[10] = w10;
          o[11] = w11;
          o[12] = w12;
          o[13] = w13;
          o[14] = w14;
          o[15] = w15;
          o[16] = w16;
          o[17] = w17;
          o[18] = w18;
          if (c !== 0) {
            o[19] = c;
            out.length++;
          }
          return out;
        };
        if (!Math.imul) {
          comb10MulTo = smallMulTo;
        }
        function bigMulTo(self2, num, out) {
          out.negative = num.negative ^ self2.negative;
          out.length = self2.length + num.length;
          var carry = 0;
          var hncarry = 0;
          for (var k = 0; k < out.length - 1; k++) {
            var ncarry = hncarry;
            hncarry = 0;
            var rword = carry & 67108863;
            var maxJ = Math.min(k, num.length - 1);
            for (var j = Math.max(0, k - self2.length + 1); j <= maxJ; j++) {
              var i = k - j;
              var a = self2.words[i] | 0;
              var b = num.words[j] | 0;
              var r = a * b;
              var lo = r & 67108863;
              ncarry = ncarry + (r / 67108864 | 0) | 0;
              lo = lo + rword | 0;
              rword = lo & 67108863;
              ncarry = ncarry + (lo >>> 26) | 0;
              hncarry += ncarry >>> 26;
              ncarry &= 67108863;
            }
            out.words[k] = rword;
            carry = ncarry;
            ncarry = hncarry;
          }
          if (carry !== 0) {
            out.words[k] = carry;
          } else {
            out.length--;
          }
          return out._strip();
        }
        function jumboMulTo(self2, num, out) {
          return bigMulTo(self2, num, out);
        }
        BN.prototype.mulTo = function mulTo(num, out) {
          var res;
          var len = this.length + num.length;
          if (this.length === 10 && num.length === 10) {
            res = comb10MulTo(this, num, out);
          } else if (len < 63) {
            res = smallMulTo(this, num, out);
          } else if (len < 1024) {
            res = bigMulTo(this, num, out);
          } else {
            res = jumboMulTo(this, num, out);
          }
          return res;
        };
        function FFTM(x, y) {
          this.x = x;
          this.y = y;
        }
        FFTM.prototype.makeRBT = function makeRBT(N) {
          var t = new Array(N);
          var l = BN.prototype._countBits(N) - 1;
          for (var i = 0; i < N; i++) {
            t[i] = this.revBin(i, l, N);
          }
          return t;
        };
        FFTM.prototype.revBin = function revBin(x, l, N) {
          if (x === 0 || x === N - 1)
            return x;
          var rb = 0;
          for (var i = 0; i < l; i++) {
            rb |= (x & 1) << l - i - 1;
            x >>= 1;
          }
          return rb;
        };
        FFTM.prototype.permute = function permute(rbt, rws, iws, rtws, itws, N) {
          for (var i = 0; i < N; i++) {
            rtws[i] = rws[rbt[i]];
            itws[i] = iws[rbt[i]];
          }
        };
        FFTM.prototype.transform = function transform(rws, iws, rtws, itws, N, rbt) {
          this.permute(rbt, rws, iws, rtws, itws, N);
          for (var s = 1; s < N; s <<= 1) {
            var l = s << 1;
            var rtwdf = Math.cos(2 * Math.PI / l);
            var itwdf = Math.sin(2 * Math.PI / l);
            for (var p = 0; p < N; p += l) {
              var rtwdf_ = rtwdf;
              var itwdf_ = itwdf;
              for (var j = 0; j < s; j++) {
                var re = rtws[p + j];
                var ie = itws[p + j];
                var ro = rtws[p + j + s];
                var io = itws[p + j + s];
                var rx = rtwdf_ * ro - itwdf_ * io;
                io = rtwdf_ * io + itwdf_ * ro;
                ro = rx;
                rtws[p + j] = re + ro;
                itws[p + j] = ie + io;
                rtws[p + j + s] = re - ro;
                itws[p + j + s] = ie - io;
                if (j !== l) {
                  rx = rtwdf * rtwdf_ - itwdf * itwdf_;
                  itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;
                  rtwdf_ = rx;
                }
              }
            }
          }
        };
        FFTM.prototype.guessLen13b = function guessLen13b(n, m) {
          var N = Math.max(m, n) | 1;
          var odd = N & 1;
          var i = 0;
          for (N = N / 2 | 0; N; N = N >>> 1) {
            i++;
          }
          return 1 << i + 1 + odd;
        };
        FFTM.prototype.conjugate = function conjugate(rws, iws, N) {
          if (N <= 1)
            return;
          for (var i = 0; i < N / 2; i++) {
            var t = rws[i];
            rws[i] = rws[N - i - 1];
            rws[N - i - 1] = t;
            t = iws[i];
            iws[i] = -iws[N - i - 1];
            iws[N - i - 1] = -t;
          }
        };
        FFTM.prototype.normalize13b = function normalize13b(ws, N) {
          var carry = 0;
          for (var i = 0; i < N / 2; i++) {
            var w = Math.round(ws[2 * i + 1] / N) * 8192 + Math.round(ws[2 * i] / N) + carry;
            ws[i] = w & 67108863;
            if (w < 67108864) {
              carry = 0;
            } else {
              carry = w / 67108864 | 0;
            }
          }
          return ws;
        };
        FFTM.prototype.convert13b = function convert13b(ws, len, rws, N) {
          var carry = 0;
          for (var i = 0; i < len; i++) {
            carry = carry + (ws[i] | 0);
            rws[2 * i] = carry & 8191;
            carry = carry >>> 13;
            rws[2 * i + 1] = carry & 8191;
            carry = carry >>> 13;
          }
          for (i = 2 * len; i < N; ++i) {
            rws[i] = 0;
          }
          assert(carry === 0);
          assert((carry & ~8191) === 0);
        };
        FFTM.prototype.stub = function stub(N) {
          var ph = new Array(N);
          for (var i = 0; i < N; i++) {
            ph[i] = 0;
          }
          return ph;
        };
        FFTM.prototype.mulp = function mulp(x, y, out) {
          var N = 2 * this.guessLen13b(x.length, y.length);
          var rbt = this.makeRBT(N);
          var _ = this.stub(N);
          var rws = new Array(N);
          var rwst = new Array(N);
          var iwst = new Array(N);
          var nrws = new Array(N);
          var nrwst = new Array(N);
          var niwst = new Array(N);
          var rmws = out.words;
          rmws.length = N;
          this.convert13b(x.words, x.length, rws, N);
          this.convert13b(y.words, y.length, nrws, N);
          this.transform(rws, _, rwst, iwst, N, rbt);
          this.transform(nrws, _, nrwst, niwst, N, rbt);
          for (var i = 0; i < N; i++) {
            var rx = rwst[i] * nrwst[i] - iwst[i] * niwst[i];
            iwst[i] = rwst[i] * niwst[i] + iwst[i] * nrwst[i];
            rwst[i] = rx;
          }
          this.conjugate(rwst, iwst, N);
          this.transform(rwst, iwst, rmws, _, N, rbt);
          this.conjugate(rmws, _, N);
          this.normalize13b(rmws, N);
          out.negative = x.negative ^ y.negative;
          out.length = x.length + y.length;
          return out._strip();
        };
        BN.prototype.mul = function mul(num) {
          var out = new BN(null);
          out.words = new Array(this.length + num.length);
          return this.mulTo(num, out);
        };
        BN.prototype.mulf = function mulf(num) {
          var out = new BN(null);
          out.words = new Array(this.length + num.length);
          return jumboMulTo(this, num, out);
        };
        BN.prototype.imul = function imul(num) {
          return this.clone().mulTo(num, this);
        };
        BN.prototype.imuln = function imuln(num) {
          var isNegNum = num < 0;
          if (isNegNum)
            num = -num;
          assert(typeof num === "number");
          assert(num < 67108864);
          var carry = 0;
          for (var i = 0; i < this.length; i++) {
            var w = (this.words[i] | 0) * num;
            var lo = (w & 67108863) + (carry & 67108863);
            carry >>= 26;
            carry += w / 67108864 | 0;
            carry += lo >>> 26;
            this.words[i] = lo & 67108863;
          }
          if (carry !== 0) {
            this.words[i] = carry;
            this.length++;
          }
          return isNegNum ? this.ineg() : this;
        };
        BN.prototype.muln = function muln(num) {
          return this.clone().imuln(num);
        };
        BN.prototype.sqr = function sqr() {
          return this.mul(this);
        };
        BN.prototype.isqr = function isqr() {
          return this.imul(this.clone());
        };
        BN.prototype.pow = function pow(num) {
          var w = toBitArray(num);
          if (w.length === 0)
            return new BN(1);
          var res = this;
          for (var i = 0; i < w.length; i++, res = res.sqr()) {
            if (w[i] !== 0)
              break;
          }
          if (++i < w.length) {
            for (var q = res.sqr(); i < w.length; i++, q = q.sqr()) {
              if (w[i] === 0)
                continue;
              res = res.mul(q);
            }
          }
          return res;
        };
        BN.prototype.iushln = function iushln(bits) {
          assert(typeof bits === "number" && bits >= 0);
          var r = bits % 26;
          var s = (bits - r) / 26;
          var carryMask = 67108863 >>> 26 - r << 26 - r;
          var i;
          if (r !== 0) {
            var carry = 0;
            for (i = 0; i < this.length; i++) {
              var newCarry = this.words[i] & carryMask;
              var c = (this.words[i] | 0) - newCarry << r;
              this.words[i] = c | carry;
              carry = newCarry >>> 26 - r;
            }
            if (carry) {
              this.words[i] = carry;
              this.length++;
            }
          }
          if (s !== 0) {
            for (i = this.length - 1; i >= 0; i--) {
              this.words[i + s] = this.words[i];
            }
            for (i = 0; i < s; i++) {
              this.words[i] = 0;
            }
            this.length += s;
          }
          return this._strip();
        };
        BN.prototype.ishln = function ishln(bits) {
          assert(this.negative === 0);
          return this.iushln(bits);
        };
        BN.prototype.iushrn = function iushrn(bits, hint, extended) {
          assert(typeof bits === "number" && bits >= 0);
          var h;
          if (hint) {
            h = (hint - hint % 26) / 26;
          } else {
            h = 0;
          }
          var r = bits % 26;
          var s = Math.min((bits - r) / 26, this.length);
          var mask = 67108863 ^ 67108863 >>> r << r;
          var maskedWords = extended;
          h -= s;
          h = Math.max(0, h);
          if (maskedWords) {
            for (var i = 0; i < s; i++) {
              maskedWords.words[i] = this.words[i];
            }
            maskedWords.length = s;
          }
          if (s === 0) {
          } else if (this.length > s) {
            this.length -= s;
            for (i = 0; i < this.length; i++) {
              this.words[i] = this.words[i + s];
            }
          } else {
            this.words[0] = 0;
            this.length = 1;
          }
          var carry = 0;
          for (i = this.length - 1; i >= 0 && (carry !== 0 || i >= h); i--) {
            var word = this.words[i] | 0;
            this.words[i] = carry << 26 - r | word >>> r;
            carry = word & mask;
          }
          if (maskedWords && carry !== 0) {
            maskedWords.words[maskedWords.length++] = carry;
          }
          if (this.length === 0) {
            this.words[0] = 0;
            this.length = 1;
          }
          return this._strip();
        };
        BN.prototype.ishrn = function ishrn(bits, hint, extended) {
          assert(this.negative === 0);
          return this.iushrn(bits, hint, extended);
        };
        BN.prototype.shln = function shln(bits) {
          return this.clone().ishln(bits);
        };
        BN.prototype.ushln = function ushln(bits) {
          return this.clone().iushln(bits);
        };
        BN.prototype.shrn = function shrn(bits) {
          return this.clone().ishrn(bits);
        };
        BN.prototype.ushrn = function ushrn(bits) {
          return this.clone().iushrn(bits);
        };
        BN.prototype.testn = function testn(bit) {
          assert(typeof bit === "number" && bit >= 0);
          var r = bit % 26;
          var s = (bit - r) / 26;
          var q = 1 << r;
          if (this.length <= s)
            return false;
          var w = this.words[s];
          return !!(w & q);
        };
        BN.prototype.imaskn = function imaskn(bits) {
          assert(typeof bits === "number" && bits >= 0);
          var r = bits % 26;
          var s = (bits - r) / 26;
          assert(this.negative === 0, "imaskn works only with positive numbers");
          if (this.length <= s) {
            return this;
          }
          if (r !== 0) {
            s++;
          }
          this.length = Math.min(s, this.length);
          if (r !== 0) {
            var mask = 67108863 ^ 67108863 >>> r << r;
            this.words[this.length - 1] &= mask;
          }
          return this._strip();
        };
        BN.prototype.maskn = function maskn(bits) {
          return this.clone().imaskn(bits);
        };
        BN.prototype.iaddn = function iaddn(num) {
          assert(typeof num === "number");
          assert(num < 67108864);
          if (num < 0)
            return this.isubn(-num);
          if (this.negative !== 0) {
            if (this.length === 1 && (this.words[0] | 0) <= num) {
              this.words[0] = num - (this.words[0] | 0);
              this.negative = 0;
              return this;
            }
            this.negative = 0;
            this.isubn(num);
            this.negative = 1;
            return this;
          }
          return this._iaddn(num);
        };
        BN.prototype._iaddn = function _iaddn(num) {
          this.words[0] += num;
          for (var i = 0; i < this.length && this.words[i] >= 67108864; i++) {
            this.words[i] -= 67108864;
            if (i === this.length - 1) {
              this.words[i + 1] = 1;
            } else {
              this.words[i + 1]++;
            }
          }
          this.length = Math.max(this.length, i + 1);
          return this;
        };
        BN.prototype.isubn = function isubn(num) {
          assert(typeof num === "number");
          assert(num < 67108864);
          if (num < 0)
            return this.iaddn(-num);
          if (this.negative !== 0) {
            this.negative = 0;
            this.iaddn(num);
            this.negative = 1;
            return this;
          }
          this.words[0] -= num;
          if (this.length === 1 && this.words[0] < 0) {
            this.words[0] = -this.words[0];
            this.negative = 1;
          } else {
            for (var i = 0; i < this.length && this.words[i] < 0; i++) {
              this.words[i] += 67108864;
              this.words[i + 1] -= 1;
            }
          }
          return this._strip();
        };
        BN.prototype.addn = function addn(num) {
          return this.clone().iaddn(num);
        };
        BN.prototype.subn = function subn(num) {
          return this.clone().isubn(num);
        };
        BN.prototype.iabs = function iabs() {
          this.negative = 0;
          return this;
        };
        BN.prototype.abs = function abs() {
          return this.clone().iabs();
        };
        BN.prototype._ishlnsubmul = function _ishlnsubmul(num, mul, shift) {
          var len = num.length + shift;
          var i;
          this._expand(len);
          var w;
          var carry = 0;
          for (i = 0; i < num.length; i++) {
            w = (this.words[i + shift] | 0) + carry;
            var right = (num.words[i] | 0) * mul;
            w -= right & 67108863;
            carry = (w >> 26) - (right / 67108864 | 0);
            this.words[i + shift] = w & 67108863;
          }
          for (; i < this.length - shift; i++) {
            w = (this.words[i + shift] | 0) + carry;
            carry = w >> 26;
            this.words[i + shift] = w & 67108863;
          }
          if (carry === 0)
            return this._strip();
          assert(carry === -1);
          carry = 0;
          for (i = 0; i < this.length; i++) {
            w = -(this.words[i] | 0) + carry;
            carry = w >> 26;
            this.words[i] = w & 67108863;
          }
          this.negative = 1;
          return this._strip();
        };
        BN.prototype._wordDiv = function _wordDiv(num, mode) {
          var shift = this.length - num.length;
          var a = this.clone();
          var b = num;
          var bhi = b.words[b.length - 1] | 0;
          var bhiBits = this._countBits(bhi);
          shift = 26 - bhiBits;
          if (shift !== 0) {
            b = b.ushln(shift);
            a.iushln(shift);
            bhi = b.words[b.length - 1] | 0;
          }
          var m = a.length - b.length;
          var q;
          if (mode !== "mod") {
            q = new BN(null);
            q.length = m + 1;
            q.words = new Array(q.length);
            for (var i = 0; i < q.length; i++) {
              q.words[i] = 0;
            }
          }
          var diff = a.clone()._ishlnsubmul(b, 1, m);
          if (diff.negative === 0) {
            a = diff;
            if (q) {
              q.words[m] = 1;
            }
          }
          for (var j = m - 1; j >= 0; j--) {
            var qj = (a.words[b.length + j] | 0) * 67108864 + (a.words[b.length + j - 1] | 0);
            qj = Math.min(qj / bhi | 0, 67108863);
            a._ishlnsubmul(b, qj, j);
            while (a.negative !== 0) {
              qj--;
              a.negative = 0;
              a._ishlnsubmul(b, 1, j);
              if (!a.isZero()) {
                a.negative ^= 1;
              }
            }
            if (q) {
              q.words[j] = qj;
            }
          }
          if (q) {
            q._strip();
          }
          a._strip();
          if (mode !== "div" && shift !== 0) {
            a.iushrn(shift);
          }
          return {
            div: q || null,
            mod: a
          };
        };
        BN.prototype.divmod = function divmod(num, mode, positive) {
          assert(!num.isZero());
          if (this.isZero()) {
            return {
              div: new BN(0),
              mod: new BN(0)
            };
          }
          var div, mod2, res;
          if (this.negative !== 0 && num.negative === 0) {
            res = this.neg().divmod(num, mode);
            if (mode !== "mod") {
              div = res.div.neg();
            }
            if (mode !== "div") {
              mod2 = res.mod.neg();
              if (positive && mod2.negative !== 0) {
                mod2.iadd(num);
              }
            }
            return {
              div,
              mod: mod2
            };
          }
          if (this.negative === 0 && num.negative !== 0) {
            res = this.divmod(num.neg(), mode);
            if (mode !== "mod") {
              div = res.div.neg();
            }
            return {
              div,
              mod: res.mod
            };
          }
          if ((this.negative & num.negative) !== 0) {
            res = this.neg().divmod(num.neg(), mode);
            if (mode !== "div") {
              mod2 = res.mod.neg();
              if (positive && mod2.negative !== 0) {
                mod2.isub(num);
              }
            }
            return {
              div: res.div,
              mod: mod2
            };
          }
          if (num.length > this.length || this.cmp(num) < 0) {
            return {
              div: new BN(0),
              mod: this
            };
          }
          if (num.length === 1) {
            if (mode === "div") {
              return {
                div: this.divn(num.words[0]),
                mod: null
              };
            }
            if (mode === "mod") {
              return {
                div: null,
                mod: new BN(this.modrn(num.words[0]))
              };
            }
            return {
              div: this.divn(num.words[0]),
              mod: new BN(this.modrn(num.words[0]))
            };
          }
          return this._wordDiv(num, mode);
        };
        BN.prototype.div = function div(num) {
          return this.divmod(num, "div", false).div;
        };
        BN.prototype.mod = function mod2(num) {
          return this.divmod(num, "mod", false).mod;
        };
        BN.prototype.umod = function umod(num) {
          return this.divmod(num, "mod", true).mod;
        };
        BN.prototype.divRound = function divRound(num) {
          var dm = this.divmod(num);
          if (dm.mod.isZero())
            return dm.div;
          var mod2 = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;
          var half = num.ushrn(1);
          var r2 = num.andln(1);
          var cmp = mod2.cmp(half);
          if (cmp < 0 || r2 === 1 && cmp === 0)
            return dm.div;
          return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
        };
        BN.prototype.modrn = function modrn(num) {
          var isNegNum = num < 0;
          if (isNegNum)
            num = -num;
          assert(num <= 67108863);
          var p = (1 << 26) % num;
          var acc = 0;
          for (var i = this.length - 1; i >= 0; i--) {
            acc = (p * acc + (this.words[i] | 0)) % num;
          }
          return isNegNum ? -acc : acc;
        };
        BN.prototype.modn = function modn(num) {
          return this.modrn(num);
        };
        BN.prototype.idivn = function idivn(num) {
          var isNegNum = num < 0;
          if (isNegNum)
            num = -num;
          assert(num <= 67108863);
          var carry = 0;
          for (var i = this.length - 1; i >= 0; i--) {
            var w = (this.words[i] | 0) + carry * 67108864;
            this.words[i] = w / num | 0;
            carry = w % num;
          }
          this._strip();
          return isNegNum ? this.ineg() : this;
        };
        BN.prototype.divn = function divn(num) {
          return this.clone().idivn(num);
        };
        BN.prototype.egcd = function egcd(p) {
          assert(p.negative === 0);
          assert(!p.isZero());
          var x = this;
          var y = p.clone();
          if (x.negative !== 0) {
            x = x.umod(p);
          } else {
            x = x.clone();
          }
          var A = new BN(1);
          var B = new BN(0);
          var C = new BN(0);
          var D = new BN(1);
          var g = 0;
          while (x.isEven() && y.isEven()) {
            x.iushrn(1);
            y.iushrn(1);
            ++g;
          }
          var yp = y.clone();
          var xp = x.clone();
          while (!x.isZero()) {
            for (var i = 0, im = 1; (x.words[0] & im) === 0 && i < 26; ++i, im <<= 1)
              ;
            if (i > 0) {
              x.iushrn(i);
              while (i-- > 0) {
                if (A.isOdd() || B.isOdd()) {
                  A.iadd(yp);
                  B.isub(xp);
                }
                A.iushrn(1);
                B.iushrn(1);
              }
            }
            for (var j = 0, jm = 1; (y.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1)
              ;
            if (j > 0) {
              y.iushrn(j);
              while (j-- > 0) {
                if (C.isOdd() || D.isOdd()) {
                  C.iadd(yp);
                  D.isub(xp);
                }
                C.iushrn(1);
                D.iushrn(1);
              }
            }
            if (x.cmp(y) >= 0) {
              x.isub(y);
              A.isub(C);
              B.isub(D);
            } else {
              y.isub(x);
              C.isub(A);
              D.isub(B);
            }
          }
          return {
            a: C,
            b: D,
            gcd: y.iushln(g)
          };
        };
        BN.prototype._invmp = function _invmp(p) {
          assert(p.negative === 0);
          assert(!p.isZero());
          var a = this;
          var b = p.clone();
          if (a.negative !== 0) {
            a = a.umod(p);
          } else {
            a = a.clone();
          }
          var x1 = new BN(1);
          var x2 = new BN(0);
          var delta = b.clone();
          while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {
            for (var i = 0, im = 1; (a.words[0] & im) === 0 && i < 26; ++i, im <<= 1)
              ;
            if (i > 0) {
              a.iushrn(i);
              while (i-- > 0) {
                if (x1.isOdd()) {
                  x1.iadd(delta);
                }
                x1.iushrn(1);
              }
            }
            for (var j = 0, jm = 1; (b.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1)
              ;
            if (j > 0) {
              b.iushrn(j);
              while (j-- > 0) {
                if (x2.isOdd()) {
                  x2.iadd(delta);
                }
                x2.iushrn(1);
              }
            }
            if (a.cmp(b) >= 0) {
              a.isub(b);
              x1.isub(x2);
            } else {
              b.isub(a);
              x2.isub(x1);
            }
          }
          var res;
          if (a.cmpn(1) === 0) {
            res = x1;
          } else {
            res = x2;
          }
          if (res.cmpn(0) < 0) {
            res.iadd(p);
          }
          return res;
        };
        BN.prototype.gcd = function gcd(num) {
          if (this.isZero())
            return num.abs();
          if (num.isZero())
            return this.abs();
          var a = this.clone();
          var b = num.clone();
          a.negative = 0;
          b.negative = 0;
          for (var shift = 0; a.isEven() && b.isEven(); shift++) {
            a.iushrn(1);
            b.iushrn(1);
          }
          do {
            while (a.isEven()) {
              a.iushrn(1);
            }
            while (b.isEven()) {
              b.iushrn(1);
            }
            var r = a.cmp(b);
            if (r < 0) {
              var t = a;
              a = b;
              b = t;
            } else if (r === 0 || b.cmpn(1) === 0) {
              break;
            }
            a.isub(b);
          } while (true);
          return b.iushln(shift);
        };
        BN.prototype.invm = function invm(num) {
          return this.egcd(num).a.umod(num);
        };
        BN.prototype.isEven = function isEven() {
          return (this.words[0] & 1) === 0;
        };
        BN.prototype.isOdd = function isOdd() {
          return (this.words[0] & 1) === 1;
        };
        BN.prototype.andln = function andln(num) {
          return this.words[0] & num;
        };
        BN.prototype.bincn = function bincn(bit) {
          assert(typeof bit === "number");
          var r = bit % 26;
          var s = (bit - r) / 26;
          var q = 1 << r;
          if (this.length <= s) {
            this._expand(s + 1);
            this.words[s] |= q;
            return this;
          }
          var carry = q;
          for (var i = s; carry !== 0 && i < this.length; i++) {
            var w = this.words[i] | 0;
            w += carry;
            carry = w >>> 26;
            w &= 67108863;
            this.words[i] = w;
          }
          if (carry !== 0) {
            this.words[i] = carry;
            this.length++;
          }
          return this;
        };
        BN.prototype.isZero = function isZero() {
          return this.length === 1 && this.words[0] === 0;
        };
        BN.prototype.cmpn = function cmpn(num) {
          var negative = num < 0;
          if (this.negative !== 0 && !negative)
            return -1;
          if (this.negative === 0 && negative)
            return 1;
          this._strip();
          var res;
          if (this.length > 1) {
            res = 1;
          } else {
            if (negative) {
              num = -num;
            }
            assert(num <= 67108863, "Number is too big");
            var w = this.words[0] | 0;
            res = w === num ? 0 : w < num ? -1 : 1;
          }
          if (this.negative !== 0)
            return -res | 0;
          return res;
        };
        BN.prototype.cmp = function cmp(num) {
          if (this.negative !== 0 && num.negative === 0)
            return -1;
          if (this.negative === 0 && num.negative !== 0)
            return 1;
          var res = this.ucmp(num);
          if (this.negative !== 0)
            return -res | 0;
          return res;
        };
        BN.prototype.ucmp = function ucmp(num) {
          if (this.length > num.length)
            return 1;
          if (this.length < num.length)
            return -1;
          var res = 0;
          for (var i = this.length - 1; i >= 0; i--) {
            var a = this.words[i] | 0;
            var b = num.words[i] | 0;
            if (a === b)
              continue;
            if (a < b) {
              res = -1;
            } else if (a > b) {
              res = 1;
            }
            break;
          }
          return res;
        };
        BN.prototype.gtn = function gtn(num) {
          return this.cmpn(num) === 1;
        };
        BN.prototype.gt = function gt(num) {
          return this.cmp(num) === 1;
        };
        BN.prototype.gten = function gten(num) {
          return this.cmpn(num) >= 0;
        };
        BN.prototype.gte = function gte(num) {
          return this.cmp(num) >= 0;
        };
        BN.prototype.ltn = function ltn(num) {
          return this.cmpn(num) === -1;
        };
        BN.prototype.lt = function lt(num) {
          return this.cmp(num) === -1;
        };
        BN.prototype.lten = function lten(num) {
          return this.cmpn(num) <= 0;
        };
        BN.prototype.lte = function lte(num) {
          return this.cmp(num) <= 0;
        };
        BN.prototype.eqn = function eqn(num) {
          return this.cmpn(num) === 0;
        };
        BN.prototype.eq = function eq(num) {
          return this.cmp(num) === 0;
        };
        BN.red = function red(num) {
          return new Red(num);
        };
        BN.prototype.toRed = function toRed(ctx) {
          assert(!this.red, "Already a number in reduction context");
          assert(this.negative === 0, "red works only with positives");
          return ctx.convertTo(this)._forceRed(ctx);
        };
        BN.prototype.fromRed = function fromRed() {
          assert(this.red, "fromRed works only with numbers in reduction context");
          return this.red.convertFrom(this);
        };
        BN.prototype._forceRed = function _forceRed(ctx) {
          this.red = ctx;
          return this;
        };
        BN.prototype.forceRed = function forceRed(ctx) {
          assert(!this.red, "Already a number in reduction context");
          return this._forceRed(ctx);
        };
        BN.prototype.redAdd = function redAdd(num) {
          assert(this.red, "redAdd works only with red numbers");
          return this.red.add(this, num);
        };
        BN.prototype.redIAdd = function redIAdd(num) {
          assert(this.red, "redIAdd works only with red numbers");
          return this.red.iadd(this, num);
        };
        BN.prototype.redSub = function redSub(num) {
          assert(this.red, "redSub works only with red numbers");
          return this.red.sub(this, num);
        };
        BN.prototype.redISub = function redISub(num) {
          assert(this.red, "redISub works only with red numbers");
          return this.red.isub(this, num);
        };
        BN.prototype.redShl = function redShl(num) {
          assert(this.red, "redShl works only with red numbers");
          return this.red.shl(this, num);
        };
        BN.prototype.redMul = function redMul(num) {
          assert(this.red, "redMul works only with red numbers");
          this.red._verify2(this, num);
          return this.red.mul(this, num);
        };
        BN.prototype.redIMul = function redIMul(num) {
          assert(this.red, "redMul works only with red numbers");
          this.red._verify2(this, num);
          return this.red.imul(this, num);
        };
        BN.prototype.redSqr = function redSqr() {
          assert(this.red, "redSqr works only with red numbers");
          this.red._verify1(this);
          return this.red.sqr(this);
        };
        BN.prototype.redISqr = function redISqr() {
          assert(this.red, "redISqr works only with red numbers");
          this.red._verify1(this);
          return this.red.isqr(this);
        };
        BN.prototype.redSqrt = function redSqrt() {
          assert(this.red, "redSqrt works only with red numbers");
          this.red._verify1(this);
          return this.red.sqrt(this);
        };
        BN.prototype.redInvm = function redInvm() {
          assert(this.red, "redInvm works only with red numbers");
          this.red._verify1(this);
          return this.red.invm(this);
        };
        BN.prototype.redNeg = function redNeg() {
          assert(this.red, "redNeg works only with red numbers");
          this.red._verify1(this);
          return this.red.neg(this);
        };
        BN.prototype.redPow = function redPow(num) {
          assert(this.red && !num.red, "redPow(normalNum)");
          this.red._verify1(this);
          return this.red.pow(this, num);
        };
        var primes = {
          k256: null,
          p224: null,
          p192: null,
          p25519: null
        };
        function MPrime(name, p) {
          this.name = name;
          this.p = new BN(p, 16);
          this.n = this.p.bitLength();
          this.k = new BN(1).iushln(this.n).isub(this.p);
          this.tmp = this._tmp();
        }
        MPrime.prototype._tmp = function _tmp() {
          var tmp = new BN(null);
          tmp.words = new Array(Math.ceil(this.n / 13));
          return tmp;
        };
        MPrime.prototype.ireduce = function ireduce(num) {
          var r = num;
          var rlen;
          do {
            this.split(r, this.tmp);
            r = this.imulK(r);
            r = r.iadd(this.tmp);
            rlen = r.bitLength();
          } while (rlen > this.n);
          var cmp = rlen < this.n ? -1 : r.ucmp(this.p);
          if (cmp === 0) {
            r.words[0] = 0;
            r.length = 1;
          } else if (cmp > 0) {
            r.isub(this.p);
          } else {
            if (r.strip !== void 0) {
              r.strip();
            } else {
              r._strip();
            }
          }
          return r;
        };
        MPrime.prototype.split = function split(input, out) {
          input.iushrn(this.n, 0, out);
        };
        MPrime.prototype.imulK = function imulK(num) {
          return num.imul(this.k);
        };
        function K256() {
          MPrime.call(this, "k256", "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f");
        }
        inherits(K256, MPrime);
        K256.prototype.split = function split(input, output) {
          var mask = 4194303;
          var outLen = Math.min(input.length, 9);
          for (var i = 0; i < outLen; i++) {
            output.words[i] = input.words[i];
          }
          output.length = outLen;
          if (input.length <= 9) {
            input.words[0] = 0;
            input.length = 1;
            return;
          }
          var prev = input.words[9];
          output.words[output.length++] = prev & mask;
          for (i = 10; i < input.length; i++) {
            var next = input.words[i] | 0;
            input.words[i - 10] = (next & mask) << 4 | prev >>> 22;
            prev = next;
          }
          prev >>>= 22;
          input.words[i - 10] = prev;
          if (prev === 0 && input.length > 10) {
            input.length -= 10;
          } else {
            input.length -= 9;
          }
        };
        K256.prototype.imulK = function imulK(num) {
          num.words[num.length] = 0;
          num.words[num.length + 1] = 0;
          num.length += 2;
          var lo = 0;
          for (var i = 0; i < num.length; i++) {
            var w = num.words[i] | 0;
            lo += w * 977;
            num.words[i] = lo & 67108863;
            lo = w * 64 + (lo / 67108864 | 0);
          }
          if (num.words[num.length - 1] === 0) {
            num.length--;
            if (num.words[num.length - 1] === 0) {
              num.length--;
            }
          }
          return num;
        };
        function P224() {
          MPrime.call(this, "p224", "ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001");
        }
        inherits(P224, MPrime);
        function P192() {
          MPrime.call(this, "p192", "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff");
        }
        inherits(P192, MPrime);
        function P25519() {
          MPrime.call(this, "25519", "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed");
        }
        inherits(P25519, MPrime);
        P25519.prototype.imulK = function imulK(num) {
          var carry = 0;
          for (var i = 0; i < num.length; i++) {
            var hi = (num.words[i] | 0) * 19 + carry;
            var lo = hi & 67108863;
            hi >>>= 26;
            num.words[i] = lo;
            carry = hi;
          }
          if (carry !== 0) {
            num.words[num.length++] = carry;
          }
          return num;
        };
        BN._prime = function prime(name) {
          if (primes[name])
            return primes[name];
          var prime2;
          if (name === "k256") {
            prime2 = new K256();
          } else if (name === "p224") {
            prime2 = new P224();
          } else if (name === "p192") {
            prime2 = new P192();
          } else if (name === "p25519") {
            prime2 = new P25519();
          } else {
            throw new Error("Unknown prime " + name);
          }
          primes[name] = prime2;
          return prime2;
        };
        function Red(m) {
          if (typeof m === "string") {
            var prime = BN._prime(m);
            this.m = prime.p;
            this.prime = prime;
          } else {
            assert(m.gtn(1), "modulus must be greater than 1");
            this.m = m;
            this.prime = null;
          }
        }
        Red.prototype._verify1 = function _verify1(a) {
          assert(a.negative === 0, "red works only with positives");
          assert(a.red, "red works only with red numbers");
        };
        Red.prototype._verify2 = function _verify2(a, b) {
          assert((a.negative | b.negative) === 0, "red works only with positives");
          assert(a.red && a.red === b.red, "red works only with red numbers");
        };
        Red.prototype.imod = function imod(a) {
          if (this.prime)
            return this.prime.ireduce(a)._forceRed(this);
          move(a, a.umod(this.m)._forceRed(this));
          return a;
        };
        Red.prototype.neg = function neg(a) {
          if (a.isZero()) {
            return a.clone();
          }
          return this.m.sub(a)._forceRed(this);
        };
        Red.prototype.add = function add(a, b) {
          this._verify2(a, b);
          var res = a.add(b);
          if (res.cmp(this.m) >= 0) {
            res.isub(this.m);
          }
          return res._forceRed(this);
        };
        Red.prototype.iadd = function iadd(a, b) {
          this._verify2(a, b);
          var res = a.iadd(b);
          if (res.cmp(this.m) >= 0) {
            res.isub(this.m);
          }
          return res;
        };
        Red.prototype.sub = function sub(a, b) {
          this._verify2(a, b);
          var res = a.sub(b);
          if (res.cmpn(0) < 0) {
            res.iadd(this.m);
          }
          return res._forceRed(this);
        };
        Red.prototype.isub = function isub(a, b) {
          this._verify2(a, b);
          var res = a.isub(b);
          if (res.cmpn(0) < 0) {
            res.iadd(this.m);
          }
          return res;
        };
        Red.prototype.shl = function shl(a, num) {
          this._verify1(a);
          return this.imod(a.ushln(num));
        };
        Red.prototype.imul = function imul(a, b) {
          this._verify2(a, b);
          return this.imod(a.imul(b));
        };
        Red.prototype.mul = function mul(a, b) {
          this._verify2(a, b);
          return this.imod(a.mul(b));
        };
        Red.prototype.isqr = function isqr(a) {
          return this.imul(a, a.clone());
        };
        Red.prototype.sqr = function sqr(a) {
          return this.mul(a, a);
        };
        Red.prototype.sqrt = function sqrt(a) {
          if (a.isZero())
            return a.clone();
          var mod3 = this.m.andln(3);
          assert(mod3 % 2 === 1);
          if (mod3 === 3) {
            var pow = this.m.add(new BN(1)).iushrn(2);
            return this.pow(a, pow);
          }
          var q = this.m.subn(1);
          var s = 0;
          while (!q.isZero() && q.andln(1) === 0) {
            s++;
            q.iushrn(1);
          }
          assert(!q.isZero());
          var one = new BN(1).toRed(this);
          var nOne = one.redNeg();
          var lpow = this.m.subn(1).iushrn(1);
          var z = this.m.bitLength();
          z = new BN(2 * z * z).toRed(this);
          while (this.pow(z, lpow).cmp(nOne) !== 0) {
            z.redIAdd(nOne);
          }
          var c = this.pow(z, q);
          var r = this.pow(a, q.addn(1).iushrn(1));
          var t = this.pow(a, q);
          var m = s;
          while (t.cmp(one) !== 0) {
            var tmp = t;
            for (var i = 0; tmp.cmp(one) !== 0; i++) {
              tmp = tmp.redSqr();
            }
            assert(i < m);
            var b = this.pow(c, new BN(1).iushln(m - i - 1));
            r = r.redMul(b);
            c = b.redSqr();
            t = t.redMul(c);
            m = i;
          }
          return r;
        };
        Red.prototype.invm = function invm(a) {
          var inv = a._invmp(this.m);
          if (inv.negative !== 0) {
            inv.negative = 0;
            return this.imod(inv).redNeg();
          } else {
            return this.imod(inv);
          }
        };
        Red.prototype.pow = function pow(a, num) {
          if (num.isZero())
            return new BN(1).toRed(this);
          if (num.cmpn(1) === 0)
            return a.clone();
          var windowSize = 4;
          var wnd = new Array(1 << windowSize);
          wnd[0] = new BN(1).toRed(this);
          wnd[1] = a;
          for (var i = 2; i < wnd.length; i++) {
            wnd[i] = this.mul(wnd[i - 1], a);
          }
          var res = wnd[0];
          var current = 0;
          var currentLen = 0;
          var start2 = num.bitLength() % 26;
          if (start2 === 0) {
            start2 = 26;
          }
          for (i = num.length - 1; i >= 0; i--) {
            var word = num.words[i];
            for (var j = start2 - 1; j >= 0; j--) {
              var bit = word >> j & 1;
              if (res !== wnd[0]) {
                res = this.sqr(res);
              }
              if (bit === 0 && current === 0) {
                currentLen = 0;
                continue;
              }
              current <<= 1;
              current |= bit;
              currentLen++;
              if (currentLen !== windowSize && (i !== 0 || j !== 0))
                continue;
              res = this.mul(res, wnd[current]);
              currentLen = 0;
              current = 0;
            }
            start2 = 26;
          }
          return res;
        };
        Red.prototype.convertTo = function convertTo(num) {
          var r = num.umod(this.m);
          return r === num ? r.clone() : r;
        };
        Red.prototype.convertFrom = function convertFrom(num) {
          var res = num.clone();
          res.red = null;
          return res;
        };
        BN.mont = function mont(num) {
          return new Mont(num);
        };
        function Mont(m) {
          Red.call(this, m);
          this.shift = this.m.bitLength();
          if (this.shift % 26 !== 0) {
            this.shift += 26 - this.shift % 26;
          }
          this.r = new BN(1).iushln(this.shift);
          this.r2 = this.imod(this.r.sqr());
          this.rinv = this.r._invmp(this.m);
          this.minv = this.rinv.mul(this.r).isubn(1).div(this.m);
          this.minv = this.minv.umod(this.r);
          this.minv = this.r.sub(this.minv);
        }
        inherits(Mont, Red);
        Mont.prototype.convertTo = function convertTo(num) {
          return this.imod(num.ushln(this.shift));
        };
        Mont.prototype.convertFrom = function convertFrom(num) {
          var r = this.imod(num.mul(this.rinv));
          r.red = null;
          return r;
        };
        Mont.prototype.imul = function imul(a, b) {
          if (a.isZero() || b.isZero()) {
            a.words[0] = 0;
            a.length = 1;
            return a;
          }
          var t = a.imul(b);
          var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
          var u = t.isub(c).iushrn(this.shift);
          var res = u;
          if (u.cmp(this.m) >= 0) {
            res = u.isub(this.m);
          } else if (u.cmpn(0) < 0) {
            res = u.iadd(this.m);
          }
          return res._forceRed(this);
        };
        Mont.prototype.mul = function mul(a, b) {
          if (a.isZero() || b.isZero())
            return new BN(0)._forceRed(this);
          var t = a.mul(b);
          var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
          var u = t.isub(c).iushrn(this.shift);
          var res = u;
          if (u.cmp(this.m) >= 0) {
            res = u.isub(this.m);
          } else if (u.cmpn(0) < 0) {
            res = u.iadd(this.m);
          }
          return res._forceRed(this);
        };
        Mont.prototype.invm = function invm(a) {
          var res = this.imod(a._invmp(this.m).mul(this.r2));
          return res._forceRed(this);
        };
      })(typeof module2 === "undefined" || module2, exports2);
    }
  });

  // node_modules/safer-buffer/safer.js
  var require_safer = __commonJS({
    "node_modules/safer-buffer/safer.js"(exports2, module2) {
      "use strict";
      var buffer = require_buffer2();
      var Buffer2 = buffer.Buffer;
      var safer = {};
      var key;
      for (key in buffer) {
        if (!buffer.hasOwnProperty(key))
          continue;
        if (key === "SlowBuffer" || key === "Buffer")
          continue;
        safer[key] = buffer[key];
      }
      var Safer = safer.Buffer = {};
      for (key in Buffer2) {
        if (!Buffer2.hasOwnProperty(key))
          continue;
        if (key === "allocUnsafe" || key === "allocUnsafeSlow")
          continue;
        Safer[key] = Buffer2[key];
      }
      safer.Buffer.prototype = Buffer2.prototype;
      if (!Safer.from || Safer.from === Uint8Array.from) {
        Safer.from = function(value, encodingOrOffset, length) {
          if (typeof value === "number") {
            throw new TypeError('The "value" argument must not be of type number. Received type ' + typeof value);
          }
          if (value && typeof value.length === "undefined") {
            throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
          }
          return Buffer2(value, encodingOrOffset, length);
        };
      }
      if (!Safer.alloc) {
        Safer.alloc = function(size, fill, encoding) {
          if (typeof size !== "number") {
            throw new TypeError('The "size" argument must be of type number. Received type ' + typeof size);
          }
          if (size < 0 || size >= 2 * (1 << 30)) {
            throw new RangeError('The value "' + size + '" is invalid for option "size"');
          }
          var buf = Buffer2(size);
          if (!fill || fill.length === 0) {
            buf.fill(0);
          } else if (typeof encoding === "string") {
            buf.fill(fill, encoding);
          } else {
            buf.fill(fill);
          }
          return buf;
        };
      }
      if (!safer.kStringMaxLength) {
        try {
          safer.kStringMaxLength = process.binding("buffer").kStringMaxLength;
        } catch (e) {
        }
      }
      if (!safer.constants) {
        safer.constants = {
          MAX_LENGTH: safer.kMaxLength
        };
        if (safer.kStringMaxLength) {
          safer.constants.MAX_STRING_LENGTH = safer.kStringMaxLength;
        }
      }
      module2.exports = safer;
    }
  });

  // node_modules/asn1.js/lib/asn1/base/reporter.js
  var require_reporter = __commonJS({
    "node_modules/asn1.js/lib/asn1/base/reporter.js"(exports2) {
      "use strict";
      var inherits = require_inherits_browser();
      function Reporter(options) {
        this._reporterState = {
          obj: null,
          path: [],
          options: options || {},
          errors: []
        };
      }
      exports2.Reporter = Reporter;
      Reporter.prototype.isError = function isError(obj) {
        return obj instanceof ReporterError;
      };
      Reporter.prototype.save = function save() {
        const state = this._reporterState;
        return { obj: state.obj, pathLen: state.path.length };
      };
      Reporter.prototype.restore = function restore(data) {
        const state = this._reporterState;
        state.obj = data.obj;
        state.path = state.path.slice(0, data.pathLen);
      };
      Reporter.prototype.enterKey = function enterKey(key) {
        return this._reporterState.path.push(key);
      };
      Reporter.prototype.exitKey = function exitKey(index) {
        const state = this._reporterState;
        state.path = state.path.slice(0, index - 1);
      };
      Reporter.prototype.leaveKey = function leaveKey(index, key, value) {
        const state = this._reporterState;
        this.exitKey(index);
        if (state.obj !== null)
          state.obj[key] = value;
      };
      Reporter.prototype.path = function path() {
        return this._reporterState.path.join("/");
      };
      Reporter.prototype.enterObject = function enterObject() {
        const state = this._reporterState;
        const prev = state.obj;
        state.obj = {};
        return prev;
      };
      Reporter.prototype.leaveObject = function leaveObject(prev) {
        const state = this._reporterState;
        const now2 = state.obj;
        state.obj = prev;
        return now2;
      };
      Reporter.prototype.error = function error(msg) {
        let err;
        const state = this._reporterState;
        const inherited = msg instanceof ReporterError;
        if (inherited) {
          err = msg;
        } else {
          err = new ReporterError(state.path.map(function(elem) {
            return "[" + JSON.stringify(elem) + "]";
          }).join(""), msg.message || msg, msg.stack);
        }
        if (!state.options.partial)
          throw err;
        if (!inherited)
          state.errors.push(err);
        return err;
      };
      Reporter.prototype.wrapResult = function wrapResult(result) {
        const state = this._reporterState;
        if (!state.options.partial)
          return result;
        return {
          result: this.isError(result) ? null : result,
          errors: state.errors
        };
      };
      function ReporterError(path, msg) {
        this.path = path;
        this.rethrow(msg);
      }
      inherits(ReporterError, Error);
      ReporterError.prototype.rethrow = function rethrow(msg) {
        this.message = msg + " at: " + (this.path || "(shallow)");
        if (Error.captureStackTrace)
          Error.captureStackTrace(this, ReporterError);
        if (!this.stack) {
          try {
            throw new Error(this.message);
          } catch (e) {
            this.stack = e.stack;
          }
        }
        return this;
      };
    }
  });

  // node_modules/asn1.js/lib/asn1/base/buffer.js
  var require_buffer3 = __commonJS({
    "node_modules/asn1.js/lib/asn1/base/buffer.js"(exports2) {
      "use strict";
      var inherits = require_inherits_browser();
      var Reporter = require_reporter().Reporter;
      var Buffer2 = require_safer().Buffer;
      function DecoderBuffer(base, options) {
        Reporter.call(this, options);
        if (!Buffer2.isBuffer(base)) {
          this.error("Input not Buffer");
          return;
        }
        this.base = base;
        this.offset = 0;
        this.length = base.length;
      }
      inherits(DecoderBuffer, Reporter);
      exports2.DecoderBuffer = DecoderBuffer;
      DecoderBuffer.isDecoderBuffer = function isDecoderBuffer(data) {
        if (data instanceof DecoderBuffer) {
          return true;
        }
        const isCompatible = typeof data === "object" && Buffer2.isBuffer(data.base) && data.constructor.name === "DecoderBuffer" && typeof data.offset === "number" && typeof data.length === "number" && typeof data.save === "function" && typeof data.restore === "function" && typeof data.isEmpty === "function" && typeof data.readUInt8 === "function" && typeof data.skip === "function" && typeof data.raw === "function";
        return isCompatible;
      };
      DecoderBuffer.prototype.save = function save() {
        return { offset: this.offset, reporter: Reporter.prototype.save.call(this) };
      };
      DecoderBuffer.prototype.restore = function restore(save) {
        const res = new DecoderBuffer(this.base);
        res.offset = save.offset;
        res.length = this.offset;
        this.offset = save.offset;
        Reporter.prototype.restore.call(this, save.reporter);
        return res;
      };
      DecoderBuffer.prototype.isEmpty = function isEmpty() {
        return this.offset === this.length;
      };
      DecoderBuffer.prototype.readUInt8 = function readUInt8(fail) {
        if (this.offset + 1 <= this.length)
          return this.base.readUInt8(this.offset++, true);
        else
          return this.error(fail || "DecoderBuffer overrun");
      };
      DecoderBuffer.prototype.skip = function skip(bytes, fail) {
        if (!(this.offset + bytes <= this.length))
          return this.error(fail || "DecoderBuffer overrun");
        const res = new DecoderBuffer(this.base);
        res._reporterState = this._reporterState;
        res.offset = this.offset;
        res.length = this.offset + bytes;
        this.offset += bytes;
        return res;
      };
      DecoderBuffer.prototype.raw = function raw(save) {
        return this.base.slice(save ? save.offset : this.offset, this.length);
      };
      function EncoderBuffer(value, reporter) {
        if (Array.isArray(value)) {
          this.length = 0;
          this.value = value.map(function(item) {
            if (!EncoderBuffer.isEncoderBuffer(item))
              item = new EncoderBuffer(item, reporter);
            this.length += item.length;
            return item;
          }, this);
        } else if (typeof value === "number") {
          if (!(0 <= value && value <= 255))
            return reporter.error("non-byte EncoderBuffer value");
          this.value = value;
          this.length = 1;
        } else if (typeof value === "string") {
          this.value = value;
          this.length = Buffer2.byteLength(value);
        } else if (Buffer2.isBuffer(value)) {
          this.value = value;
          this.length = value.length;
        } else {
          return reporter.error("Unsupported type: " + typeof value);
        }
      }
      exports2.EncoderBuffer = EncoderBuffer;
      EncoderBuffer.isEncoderBuffer = function isEncoderBuffer(data) {
        if (data instanceof EncoderBuffer) {
          return true;
        }
        const isCompatible = typeof data === "object" && data.constructor.name === "EncoderBuffer" && typeof data.length === "number" && typeof data.join === "function";
        return isCompatible;
      };
      EncoderBuffer.prototype.join = function join(out, offset) {
        if (!out)
          out = Buffer2.alloc(this.length);
        if (!offset)
          offset = 0;
        if (this.length === 0)
          return out;
        if (Array.isArray(this.value)) {
          this.value.forEach(function(item) {
            item.join(out, offset);
            offset += item.length;
          });
        } else {
          if (typeof this.value === "number")
            out[offset] = this.value;
          else if (typeof this.value === "string")
            out.write(this.value, offset);
          else if (Buffer2.isBuffer(this.value))
            this.value.copy(out, offset);
          offset += this.length;
        }
        return out;
      };
    }
  });

  // node_modules/asn1.js/lib/asn1/base/node.js
  var require_node = __commonJS({
    "node_modules/asn1.js/lib/asn1/base/node.js"(exports2, module2) {
      "use strict";
      var Reporter = require_reporter().Reporter;
      var EncoderBuffer = require_buffer3().EncoderBuffer;
      var DecoderBuffer = require_buffer3().DecoderBuffer;
      var assert = require_minimalistic_assert();
      var tags = [
        "seq",
        "seqof",
        "set",
        "setof",
        "objid",
        "bool",
        "gentime",
        "utctime",
        "null_",
        "enum",
        "int",
        "objDesc",
        "bitstr",
        "bmpstr",
        "charstr",
        "genstr",
        "graphstr",
        "ia5str",
        "iso646str",
        "numstr",
        "octstr",
        "printstr",
        "t61str",
        "unistr",
        "utf8str",
        "videostr"
      ];
      var methods = [
        "key",
        "obj",
        "use",
        "optional",
        "explicit",
        "implicit",
        "def",
        "choice",
        "any",
        "contains"
      ].concat(tags);
      var overrided = [
        "_peekTag",
        "_decodeTag",
        "_use",
        "_decodeStr",
        "_decodeObjid",
        "_decodeTime",
        "_decodeNull",
        "_decodeInt",
        "_decodeBool",
        "_decodeList",
        "_encodeComposite",
        "_encodeStr",
        "_encodeObjid",
        "_encodeTime",
        "_encodeNull",
        "_encodeInt",
        "_encodeBool"
      ];
      function Node2(enc, parent, name) {
        const state = {};
        this._baseState = state;
        state.name = name;
        state.enc = enc;
        state.parent = parent || null;
        state.children = null;
        state.tag = null;
        state.args = null;
        state.reverseArgs = null;
        state.choice = null;
        state.optional = false;
        state.any = false;
        state.obj = false;
        state.use = null;
        state.useDecoder = null;
        state.key = null;
        state["default"] = null;
        state.explicit = null;
        state.implicit = null;
        state.contains = null;
        if (!state.parent) {
          state.children = [];
          this._wrap();
        }
      }
      module2.exports = Node2;
      var stateProps = [
        "enc",
        "parent",
        "children",
        "tag",
        "args",
        "reverseArgs",
        "choice",
        "optional",
        "any",
        "obj",
        "use",
        "alteredUse",
        "key",
        "default",
        "explicit",
        "implicit",
        "contains"
      ];
      Node2.prototype.clone = function clone() {
        const state = this._baseState;
        const cstate = {};
        stateProps.forEach(function(prop) {
          cstate[prop] = state[prop];
        });
        const res = new this.constructor(cstate.parent);
        res._baseState = cstate;
        return res;
      };
      Node2.prototype._wrap = function wrap() {
        const state = this._baseState;
        methods.forEach(function(method) {
          this[method] = function _wrappedMethod() {
            const clone = new this.constructor(this);
            state.children.push(clone);
            return clone[method].apply(clone, arguments);
          };
        }, this);
      };
      Node2.prototype._init = function init(body) {
        const state = this._baseState;
        assert(state.parent === null);
        body.call(this);
        state.children = state.children.filter(function(child) {
          return child._baseState.parent === this;
        }, this);
        assert.equal(state.children.length, 1, "Root node can have only one child");
      };
      Node2.prototype._useArgs = function useArgs(args) {
        const state = this._baseState;
        const children = args.filter(function(arg) {
          return arg instanceof this.constructor;
        }, this);
        args = args.filter(function(arg) {
          return !(arg instanceof this.constructor);
        }, this);
        if (children.length !== 0) {
          assert(state.children === null);
          state.children = children;
          children.forEach(function(child) {
            child._baseState.parent = this;
          }, this);
        }
        if (args.length !== 0) {
          assert(state.args === null);
          state.args = args;
          state.reverseArgs = args.map(function(arg) {
            if (typeof arg !== "object" || arg.constructor !== Object)
              return arg;
            const res = {};
            Object.keys(arg).forEach(function(key) {
              if (key == (key | 0))
                key |= 0;
              const value = arg[key];
              res[value] = key;
            });
            return res;
          });
        }
      };
      overrided.forEach(function(method) {
        Node2.prototype[method] = function _overrided() {
          const state = this._baseState;
          throw new Error(method + " not implemented for encoding: " + state.enc);
        };
      });
      tags.forEach(function(tag) {
        Node2.prototype[tag] = function _tagMethod() {
          const state = this._baseState;
          const args = Array.prototype.slice.call(arguments);
          assert(state.tag === null);
          state.tag = tag;
          this._useArgs(args);
          return this;
        };
      });
      Node2.prototype.use = function use(item) {
        assert(item);
        const state = this._baseState;
        assert(state.use === null);
        state.use = item;
        return this;
      };
      Node2.prototype.optional = function optional() {
        const state = this._baseState;
        state.optional = true;
        return this;
      };
      Node2.prototype.def = function def(val) {
        const state = this._baseState;
        assert(state["default"] === null);
        state["default"] = val;
        state.optional = true;
        return this;
      };
      Node2.prototype.explicit = function explicit(num) {
        const state = this._baseState;
        assert(state.explicit === null && state.implicit === null);
        state.explicit = num;
        return this;
      };
      Node2.prototype.implicit = function implicit(num) {
        const state = this._baseState;
        assert(state.explicit === null && state.implicit === null);
        state.implicit = num;
        return this;
      };
      Node2.prototype.obj = function obj() {
        const state = this._baseState;
        const args = Array.prototype.slice.call(arguments);
        state.obj = true;
        if (args.length !== 0)
          this._useArgs(args);
        return this;
      };
      Node2.prototype.key = function key(newKey) {
        const state = this._baseState;
        assert(state.key === null);
        state.key = newKey;
        return this;
      };
      Node2.prototype.any = function any() {
        const state = this._baseState;
        state.any = true;
        return this;
      };
      Node2.prototype.choice = function choice(obj) {
        const state = this._baseState;
        assert(state.choice === null);
        state.choice = obj;
        this._useArgs(Object.keys(obj).map(function(key) {
          return obj[key];
        }));
        return this;
      };
      Node2.prototype.contains = function contains(item) {
        const state = this._baseState;
        assert(state.use === null);
        state.contains = item;
        return this;
      };
      Node2.prototype._decode = function decode(input, options) {
        const state = this._baseState;
        if (state.parent === null)
          return input.wrapResult(state.children[0]._decode(input, options));
        let result = state["default"];
        let present = true;
        let prevKey = null;
        if (state.key !== null)
          prevKey = input.enterKey(state.key);
        if (state.optional) {
          let tag = null;
          if (state.explicit !== null)
            tag = state.explicit;
          else if (state.implicit !== null)
            tag = state.implicit;
          else if (state.tag !== null)
            tag = state.tag;
          if (tag === null && !state.any) {
            const save = input.save();
            try {
              if (state.choice === null)
                this._decodeGeneric(state.tag, input, options);
              else
                this._decodeChoice(input, options);
              present = true;
            } catch (e) {
              present = false;
            }
            input.restore(save);
          } else {
            present = this._peekTag(input, tag, state.any);
            if (input.isError(present))
              return present;
          }
        }
        let prevObj;
        if (state.obj && present)
          prevObj = input.enterObject();
        if (present) {
          if (state.explicit !== null) {
            const explicit = this._decodeTag(input, state.explicit);
            if (input.isError(explicit))
              return explicit;
            input = explicit;
          }
          const start2 = input.offset;
          if (state.use === null && state.choice === null) {
            let save;
            if (state.any)
              save = input.save();
            const body = this._decodeTag(input, state.implicit !== null ? state.implicit : state.tag, state.any);
            if (input.isError(body))
              return body;
            if (state.any)
              result = input.raw(save);
            else
              input = body;
          }
          if (options && options.track && state.tag !== null)
            options.track(input.path(), start2, input.length, "tagged");
          if (options && options.track && state.tag !== null)
            options.track(input.path(), input.offset, input.length, "content");
          if (state.any) {
          } else if (state.choice === null) {
            result = this._decodeGeneric(state.tag, input, options);
          } else {
            result = this._decodeChoice(input, options);
          }
          if (input.isError(result))
            return result;
          if (!state.any && state.choice === null && state.children !== null) {
            state.children.forEach(function decodeChildren(child) {
              child._decode(input, options);
            });
          }
          if (state.contains && (state.tag === "octstr" || state.tag === "bitstr")) {
            const data = new DecoderBuffer(result);
            result = this._getUse(state.contains, input._reporterState.obj)._decode(data, options);
          }
        }
        if (state.obj && present)
          result = input.leaveObject(prevObj);
        if (state.key !== null && (result !== null || present === true))
          input.leaveKey(prevKey, state.key, result);
        else if (prevKey !== null)
          input.exitKey(prevKey);
        return result;
      };
      Node2.prototype._decodeGeneric = function decodeGeneric(tag, input, options) {
        const state = this._baseState;
        if (tag === "seq" || tag === "set")
          return null;
        if (tag === "seqof" || tag === "setof")
          return this._decodeList(input, tag, state.args[0], options);
        else if (/str$/.test(tag))
          return this._decodeStr(input, tag, options);
        else if (tag === "objid" && state.args)
          return this._decodeObjid(input, state.args[0], state.args[1], options);
        else if (tag === "objid")
          return this._decodeObjid(input, null, null, options);
        else if (tag === "gentime" || tag === "utctime")
          return this._decodeTime(input, tag, options);
        else if (tag === "null_")
          return this._decodeNull(input, options);
        else if (tag === "bool")
          return this._decodeBool(input, options);
        else if (tag === "objDesc")
          return this._decodeStr(input, tag, options);
        else if (tag === "int" || tag === "enum")
          return this._decodeInt(input, state.args && state.args[0], options);
        if (state.use !== null) {
          return this._getUse(state.use, input._reporterState.obj)._decode(input, options);
        } else {
          return input.error("unknown tag: " + tag);
        }
      };
      Node2.prototype._getUse = function _getUse(entity, obj) {
        const state = this._baseState;
        state.useDecoder = this._use(entity, obj);
        assert(state.useDecoder._baseState.parent === null);
        state.useDecoder = state.useDecoder._baseState.children[0];
        if (state.implicit !== state.useDecoder._baseState.implicit) {
          state.useDecoder = state.useDecoder.clone();
          state.useDecoder._baseState.implicit = state.implicit;
        }
        return state.useDecoder;
      };
      Node2.prototype._decodeChoice = function decodeChoice(input, options) {
        const state = this._baseState;
        let result = null;
        let match = false;
        Object.keys(state.choice).some(function(key) {
          const save = input.save();
          const node = state.choice[key];
          try {
            const value = node._decode(input, options);
            if (input.isError(value))
              return false;
            result = { type: key, value };
            match = true;
          } catch (e) {
            input.restore(save);
            return false;
          }
          return true;
        }, this);
        if (!match)
          return input.error("Choice not matched");
        return result;
      };
      Node2.prototype._createEncoderBuffer = function createEncoderBuffer(data) {
        return new EncoderBuffer(data, this.reporter);
      };
      Node2.prototype._encode = function encode(data, reporter, parent) {
        const state = this._baseState;
        if (state["default"] !== null && state["default"] === data)
          return;
        const result = this._encodeValue(data, reporter, parent);
        if (result === void 0)
          return;
        if (this._skipDefault(result, reporter, parent))
          return;
        return result;
      };
      Node2.prototype._encodeValue = function encode(data, reporter, parent) {
        const state = this._baseState;
        if (state.parent === null)
          return state.children[0]._encode(data, reporter || new Reporter());
        let result = null;
        this.reporter = reporter;
        if (state.optional && data === void 0) {
          if (state["default"] !== null)
            data = state["default"];
          else
            return;
        }
        let content = null;
        let primitive = false;
        if (state.any) {
          result = this._createEncoderBuffer(data);
        } else if (state.choice) {
          result = this._encodeChoice(data, reporter);
        } else if (state.contains) {
          content = this._getUse(state.contains, parent)._encode(data, reporter);
          primitive = true;
        } else if (state.children) {
          content = state.children.map(function(child) {
            if (child._baseState.tag === "null_")
              return child._encode(null, reporter, data);
            if (child._baseState.key === null)
              return reporter.error("Child should have a key");
            const prevKey = reporter.enterKey(child._baseState.key);
            if (typeof data !== "object")
              return reporter.error("Child expected, but input is not object");
            const res = child._encode(data[child._baseState.key], reporter, data);
            reporter.leaveKey(prevKey);
            return res;
          }, this).filter(function(child) {
            return child;
          });
          content = this._createEncoderBuffer(content);
        } else {
          if (state.tag === "seqof" || state.tag === "setof") {
            if (!(state.args && state.args.length === 1))
              return reporter.error("Too many args for : " + state.tag);
            if (!Array.isArray(data))
              return reporter.error("seqof/setof, but data is not Array");
            const child = this.clone();
            child._baseState.implicit = null;
            content = this._createEncoderBuffer(data.map(function(item) {
              const state2 = this._baseState;
              return this._getUse(state2.args[0], data)._encode(item, reporter);
            }, child));
          } else if (state.use !== null) {
            result = this._getUse(state.use, parent)._encode(data, reporter);
          } else {
            content = this._encodePrimitive(state.tag, data);
            primitive = true;
          }
        }
        if (!state.any && state.choice === null) {
          const tag = state.implicit !== null ? state.implicit : state.tag;
          const cls = state.implicit === null ? "universal" : "context";
          if (tag === null) {
            if (state.use === null)
              reporter.error("Tag could be omitted only for .use()");
          } else {
            if (state.use === null)
              result = this._encodeComposite(tag, primitive, cls, content);
          }
        }
        if (state.explicit !== null)
          result = this._encodeComposite(state.explicit, false, "context", result);
        return result;
      };
      Node2.prototype._encodeChoice = function encodeChoice(data, reporter) {
        const state = this._baseState;
        const node = state.choice[data.type];
        if (!node) {
          assert(false, data.type + " not found in " + JSON.stringify(Object.keys(state.choice)));
        }
        return node._encode(data.value, reporter);
      };
      Node2.prototype._encodePrimitive = function encodePrimitive(tag, data) {
        const state = this._baseState;
        if (/str$/.test(tag))
          return this._encodeStr(data, tag);
        else if (tag === "objid" && state.args)
          return this._encodeObjid(data, state.reverseArgs[0], state.args[1]);
        else if (tag === "objid")
          return this._encodeObjid(data, null, null);
        else if (tag === "gentime" || tag === "utctime")
          return this._encodeTime(data, tag);
        else if (tag === "null_")
          return this._encodeNull();
        else if (tag === "int" || tag === "enum")
          return this._encodeInt(data, state.args && state.reverseArgs[0]);
        else if (tag === "bool")
          return this._encodeBool(data);
        else if (tag === "objDesc")
          return this._encodeStr(data, tag);
        else
          throw new Error("Unsupported tag: " + tag);
      };
      Node2.prototype._isNumstr = function isNumstr(str) {
        return /^[0-9 ]*$/.test(str);
      };
      Node2.prototype._isPrintstr = function isPrintstr(str) {
        return /^[A-Za-z0-9 '()+,-./:=?]*$/.test(str);
      };
    }
  });

  // node_modules/asn1.js/lib/asn1/constants/der.js
  var require_der = __commonJS({
    "node_modules/asn1.js/lib/asn1/constants/der.js"(exports2) {
      "use strict";
      function reverse(map) {
        const res = {};
        Object.keys(map).forEach(function(key) {
          if ((key | 0) == key)
            key = key | 0;
          const value = map[key];
          res[value] = key;
        });
        return res;
      }
      exports2.tagClass = {
        0: "universal",
        1: "application",
        2: "context",
        3: "private"
      };
      exports2.tagClassByName = reverse(exports2.tagClass);
      exports2.tag = {
        0: "end",
        1: "bool",
        2: "int",
        3: "bitstr",
        4: "octstr",
        5: "null_",
        6: "objid",
        7: "objDesc",
        8: "external",
        9: "real",
        10: "enum",
        11: "embed",
        12: "utf8str",
        13: "relativeOid",
        16: "seq",
        17: "set",
        18: "numstr",
        19: "printstr",
        20: "t61str",
        21: "videostr",
        22: "ia5str",
        23: "utctime",
        24: "gentime",
        25: "graphstr",
        26: "iso646str",
        27: "genstr",
        28: "unistr",
        29: "charstr",
        30: "bmpstr"
      };
      exports2.tagByName = reverse(exports2.tag);
    }
  });

  // node_modules/asn1.js/lib/asn1/encoders/der.js
  var require_der2 = __commonJS({
    "node_modules/asn1.js/lib/asn1/encoders/der.js"(exports2, module2) {
      "use strict";
      var inherits = require_inherits_browser();
      var Buffer2 = require_safer().Buffer;
      var Node2 = require_node();
      var der = require_der();
      function DEREncoder(entity) {
        this.enc = "der";
        this.name = entity.name;
        this.entity = entity;
        this.tree = new DERNode();
        this.tree._init(entity.body);
      }
      module2.exports = DEREncoder;
      DEREncoder.prototype.encode = function encode(data, reporter) {
        return this.tree._encode(data, reporter).join();
      };
      function DERNode(parent) {
        Node2.call(this, "der", parent);
      }
      inherits(DERNode, Node2);
      DERNode.prototype._encodeComposite = function encodeComposite(tag, primitive, cls, content) {
        const encodedTag = encodeTag(tag, primitive, cls, this.reporter);
        if (content.length < 128) {
          const header2 = Buffer2.alloc(2);
          header2[0] = encodedTag;
          header2[1] = content.length;
          return this._createEncoderBuffer([header2, content]);
        }
        let lenOctets = 1;
        for (let i = content.length; i >= 256; i >>= 8)
          lenOctets++;
        const header = Buffer2.alloc(1 + 1 + lenOctets);
        header[0] = encodedTag;
        header[1] = 128 | lenOctets;
        for (let i = 1 + lenOctets, j = content.length; j > 0; i--, j >>= 8)
          header[i] = j & 255;
        return this._createEncoderBuffer([header, content]);
      };
      DERNode.prototype._encodeStr = function encodeStr(str, tag) {
        if (tag === "bitstr") {
          return this._createEncoderBuffer([str.unused | 0, str.data]);
        } else if (tag === "bmpstr") {
          const buf = Buffer2.alloc(str.length * 2);
          for (let i = 0; i < str.length; i++) {
            buf.writeUInt16BE(str.charCodeAt(i), i * 2);
          }
          return this._createEncoderBuffer(buf);
        } else if (tag === "numstr") {
          if (!this._isNumstr(str)) {
            return this.reporter.error("Encoding of string type: numstr supports only digits and space");
          }
          return this._createEncoderBuffer(str);
        } else if (tag === "printstr") {
          if (!this._isPrintstr(str)) {
            return this.reporter.error("Encoding of string type: printstr supports only latin upper and lower case letters, digits, space, apostrophe, left and rigth parenthesis, plus sign, comma, hyphen, dot, slash, colon, equal sign, question mark");
          }
          return this._createEncoderBuffer(str);
        } else if (/str$/.test(tag)) {
          return this._createEncoderBuffer(str);
        } else if (tag === "objDesc") {
          return this._createEncoderBuffer(str);
        } else {
          return this.reporter.error("Encoding of string type: " + tag + " unsupported");
        }
      };
      DERNode.prototype._encodeObjid = function encodeObjid(id, values, relative) {
        if (typeof id === "string") {
          if (!values)
            return this.reporter.error("string objid given, but no values map found");
          if (!values.hasOwnProperty(id))
            return this.reporter.error("objid not found in values map");
          id = values[id].split(/[\s.]+/g);
          for (let i = 0; i < id.length; i++)
            id[i] |= 0;
        } else if (Array.isArray(id)) {
          id = id.slice();
          for (let i = 0; i < id.length; i++)
            id[i] |= 0;
        }
        if (!Array.isArray(id)) {
          return this.reporter.error("objid() should be either array or string, got: " + JSON.stringify(id));
        }
        if (!relative) {
          if (id[1] >= 40)
            return this.reporter.error("Second objid identifier OOB");
          id.splice(0, 2, id[0] * 40 + id[1]);
        }
        let size = 0;
        for (let i = 0; i < id.length; i++) {
          let ident = id[i];
          for (size++; ident >= 128; ident >>= 7)
            size++;
        }
        const objid = Buffer2.alloc(size);
        let offset = objid.length - 1;
        for (let i = id.length - 1; i >= 0; i--) {
          let ident = id[i];
          objid[offset--] = ident & 127;
          while ((ident >>= 7) > 0)
            objid[offset--] = 128 | ident & 127;
        }
        return this._createEncoderBuffer(objid);
      };
      function two(num) {
        if (num < 10)
          return "0" + num;
        else
          return num;
      }
      DERNode.prototype._encodeTime = function encodeTime(time, tag) {
        let str;
        const date = new Date(time);
        if (tag === "gentime") {
          str = [
            two(date.getUTCFullYear()),
            two(date.getUTCMonth() + 1),
            two(date.getUTCDate()),
            two(date.getUTCHours()),
            two(date.getUTCMinutes()),
            two(date.getUTCSeconds()),
            "Z"
          ].join("");
        } else if (tag === "utctime") {
          str = [
            two(date.getUTCFullYear() % 100),
            two(date.getUTCMonth() + 1),
            two(date.getUTCDate()),
            two(date.getUTCHours()),
            two(date.getUTCMinutes()),
            two(date.getUTCSeconds()),
            "Z"
          ].join("");
        } else {
          this.reporter.error("Encoding " + tag + " time is not supported yet");
        }
        return this._encodeStr(str, "octstr");
      };
      DERNode.prototype._encodeNull = function encodeNull() {
        return this._createEncoderBuffer("");
      };
      DERNode.prototype._encodeInt = function encodeInt(num, values) {
        if (typeof num === "string") {
          if (!values)
            return this.reporter.error("String int or enum given, but no values map");
          if (!values.hasOwnProperty(num)) {
            return this.reporter.error("Values map doesn't contain: " + JSON.stringify(num));
          }
          num = values[num];
        }
        if (typeof num !== "number" && !Buffer2.isBuffer(num)) {
          const numArray = num.toArray();
          if (!num.sign && numArray[0] & 128) {
            numArray.unshift(0);
          }
          num = Buffer2.from(numArray);
        }
        if (Buffer2.isBuffer(num)) {
          let size2 = num.length;
          if (num.length === 0)
            size2++;
          const out2 = Buffer2.alloc(size2);
          num.copy(out2);
          if (num.length === 0)
            out2[0] = 0;
          return this._createEncoderBuffer(out2);
        }
        if (num < 128)
          return this._createEncoderBuffer(num);
        if (num < 256)
          return this._createEncoderBuffer([0, num]);
        let size = 1;
        for (let i = num; i >= 256; i >>= 8)
          size++;
        const out = new Array(size);
        for (let i = out.length - 1; i >= 0; i--) {
          out[i] = num & 255;
          num >>= 8;
        }
        if (out[0] & 128) {
          out.unshift(0);
        }
        return this._createEncoderBuffer(Buffer2.from(out));
      };
      DERNode.prototype._encodeBool = function encodeBool(value) {
        return this._createEncoderBuffer(value ? 255 : 0);
      };
      DERNode.prototype._use = function use(entity, obj) {
        if (typeof entity === "function")
          entity = entity(obj);
        return entity._getEncoder("der").tree;
      };
      DERNode.prototype._skipDefault = function skipDefault(dataBuffer, reporter, parent) {
        const state = this._baseState;
        let i;
        if (state["default"] === null)
          return false;
        const data = dataBuffer.join();
        if (state.defaultBuffer === void 0)
          state.defaultBuffer = this._encodeValue(state["default"], reporter, parent).join();
        if (data.length !== state.defaultBuffer.length)
          return false;
        for (i = 0; i < data.length; i++)
          if (data[i] !== state.defaultBuffer[i])
            return false;
        return true;
      };
      function encodeTag(tag, primitive, cls, reporter) {
        let res;
        if (tag === "seqof")
          tag = "seq";
        else if (tag === "setof")
          tag = "set";
        if (der.tagByName.hasOwnProperty(tag))
          res = der.tagByName[tag];
        else if (typeof tag === "number" && (tag | 0) === tag)
          res = tag;
        else
          return reporter.error("Unknown tag: " + tag);
        if (res >= 31)
          return reporter.error("Multi-octet tag encoding unsupported");
        if (!primitive)
          res |= 32;
        res |= der.tagClassByName[cls || "universal"] << 6;
        return res;
      }
    }
  });

  // node_modules/asn1.js/lib/asn1/encoders/pem.js
  var require_pem = __commonJS({
    "node_modules/asn1.js/lib/asn1/encoders/pem.js"(exports2, module2) {
      "use strict";
      var inherits = require_inherits_browser();
      var DEREncoder = require_der2();
      function PEMEncoder(entity) {
        DEREncoder.call(this, entity);
        this.enc = "pem";
      }
      inherits(PEMEncoder, DEREncoder);
      module2.exports = PEMEncoder;
      PEMEncoder.prototype.encode = function encode(data, options) {
        const buf = DEREncoder.prototype.encode.call(this, data);
        const p = buf.toString("base64");
        const out = ["-----BEGIN " + options.label + "-----"];
        for (let i = 0; i < p.length; i += 64)
          out.push(p.slice(i, i + 64));
        out.push("-----END " + options.label + "-----");
        return out.join("\n");
      };
    }
  });

  // node_modules/asn1.js/lib/asn1/encoders/index.js
  var require_encoders = __commonJS({
    "node_modules/asn1.js/lib/asn1/encoders/index.js"(exports2) {
      "use strict";
      var encoders = exports2;
      encoders.der = require_der2();
      encoders.pem = require_pem();
    }
  });

  // node_modules/asn1.js/lib/asn1/decoders/der.js
  var require_der3 = __commonJS({
    "node_modules/asn1.js/lib/asn1/decoders/der.js"(exports2, module2) {
      "use strict";
      var inherits = require_inherits_browser();
      var bignum = require_bn2();
      var DecoderBuffer = require_buffer3().DecoderBuffer;
      var Node2 = require_node();
      var der = require_der();
      function DERDecoder(entity) {
        this.enc = "der";
        this.name = entity.name;
        this.entity = entity;
        this.tree = new DERNode();
        this.tree._init(entity.body);
      }
      module2.exports = DERDecoder;
      DERDecoder.prototype.decode = function decode(data, options) {
        if (!DecoderBuffer.isDecoderBuffer(data)) {
          data = new DecoderBuffer(data, options);
        }
        return this.tree._decode(data, options);
      };
      function DERNode(parent) {
        Node2.call(this, "der", parent);
      }
      inherits(DERNode, Node2);
      DERNode.prototype._peekTag = function peekTag(buffer, tag, any) {
        if (buffer.isEmpty())
          return false;
        const state = buffer.save();
        const decodedTag = derDecodeTag(buffer, 'Failed to peek tag: "' + tag + '"');
        if (buffer.isError(decodedTag))
          return decodedTag;
        buffer.restore(state);
        return decodedTag.tag === tag || decodedTag.tagStr === tag || decodedTag.tagStr + "of" === tag || any;
      };
      DERNode.prototype._decodeTag = function decodeTag(buffer, tag, any) {
        const decodedTag = derDecodeTag(buffer, 'Failed to decode tag of "' + tag + '"');
        if (buffer.isError(decodedTag))
          return decodedTag;
        let len = derDecodeLen(buffer, decodedTag.primitive, 'Failed to get length of "' + tag + '"');
        if (buffer.isError(len))
          return len;
        if (!any && decodedTag.tag !== tag && decodedTag.tagStr !== tag && decodedTag.tagStr + "of" !== tag) {
          return buffer.error('Failed to match tag: "' + tag + '"');
        }
        if (decodedTag.primitive || len !== null)
          return buffer.skip(len, 'Failed to match body of: "' + tag + '"');
        const state = buffer.save();
        const res = this._skipUntilEnd(buffer, 'Failed to skip indefinite length body: "' + this.tag + '"');
        if (buffer.isError(res))
          return res;
        len = buffer.offset - state.offset;
        buffer.restore(state);
        return buffer.skip(len, 'Failed to match body of: "' + tag + '"');
      };
      DERNode.prototype._skipUntilEnd = function skipUntilEnd(buffer, fail) {
        for (; ; ) {
          const tag = derDecodeTag(buffer, fail);
          if (buffer.isError(tag))
            return tag;
          const len = derDecodeLen(buffer, tag.primitive, fail);
          if (buffer.isError(len))
            return len;
          let res;
          if (tag.primitive || len !== null)
            res = buffer.skip(len);
          else
            res = this._skipUntilEnd(buffer, fail);
          if (buffer.isError(res))
            return res;
          if (tag.tagStr === "end")
            break;
        }
      };
      DERNode.prototype._decodeList = function decodeList(buffer, tag, decoder, options) {
        const result = [];
        while (!buffer.isEmpty()) {
          const possibleEnd = this._peekTag(buffer, "end");
          if (buffer.isError(possibleEnd))
            return possibleEnd;
          const res = decoder.decode(buffer, "der", options);
          if (buffer.isError(res) && possibleEnd)
            break;
          result.push(res);
        }
        return result;
      };
      DERNode.prototype._decodeStr = function decodeStr(buffer, tag) {
        if (tag === "bitstr") {
          const unused = buffer.readUInt8();
          if (buffer.isError(unused))
            return unused;
          return { unused, data: buffer.raw() };
        } else if (tag === "bmpstr") {
          const raw = buffer.raw();
          if (raw.length % 2 === 1)
            return buffer.error("Decoding of string type: bmpstr length mismatch");
          let str = "";
          for (let i = 0; i < raw.length / 2; i++) {
            str += String.fromCharCode(raw.readUInt16BE(i * 2));
          }
          return str;
        } else if (tag === "numstr") {
          const numstr = buffer.raw().toString("ascii");
          if (!this._isNumstr(numstr)) {
            return buffer.error("Decoding of string type: numstr unsupported characters");
          }
          return numstr;
        } else if (tag === "octstr") {
          return buffer.raw();
        } else if (tag === "objDesc") {
          return buffer.raw();
        } else if (tag === "printstr") {
          const printstr = buffer.raw().toString("ascii");
          if (!this._isPrintstr(printstr)) {
            return buffer.error("Decoding of string type: printstr unsupported characters");
          }
          return printstr;
        } else if (/str$/.test(tag)) {
          return buffer.raw().toString();
        } else {
          return buffer.error("Decoding of string type: " + tag + " unsupported");
        }
      };
      DERNode.prototype._decodeObjid = function decodeObjid(buffer, values, relative) {
        let result;
        const identifiers = [];
        let ident = 0;
        let subident = 0;
        while (!buffer.isEmpty()) {
          subident = buffer.readUInt8();
          ident <<= 7;
          ident |= subident & 127;
          if ((subident & 128) === 0) {
            identifiers.push(ident);
            ident = 0;
          }
        }
        if (subident & 128)
          identifiers.push(ident);
        const first = identifiers[0] / 40 | 0;
        const second = identifiers[0] % 40;
        if (relative)
          result = identifiers;
        else
          result = [first, second].concat(identifiers.slice(1));
        if (values) {
          let tmp = values[result.join(" ")];
          if (tmp === void 0)
            tmp = values[result.join(".")];
          if (tmp !== void 0)
            result = tmp;
        }
        return result;
      };
      DERNode.prototype._decodeTime = function decodeTime(buffer, tag) {
        const str = buffer.raw().toString();
        let year;
        let mon;
        let day;
        let hour;
        let min;
        let sec;
        if (tag === "gentime") {
          year = str.slice(0, 4) | 0;
          mon = str.slice(4, 6) | 0;
          day = str.slice(6, 8) | 0;
          hour = str.slice(8, 10) | 0;
          min = str.slice(10, 12) | 0;
          sec = str.slice(12, 14) | 0;
        } else if (tag === "utctime") {
          year = str.slice(0, 2) | 0;
          mon = str.slice(2, 4) | 0;
          day = str.slice(4, 6) | 0;
          hour = str.slice(6, 8) | 0;
          min = str.slice(8, 10) | 0;
          sec = str.slice(10, 12) | 0;
          if (year < 70)
            year = 2e3 + year;
          else
            year = 1900 + year;
        } else {
          return buffer.error("Decoding " + tag + " time is not supported yet");
        }
        return Date.UTC(year, mon - 1, day, hour, min, sec, 0);
      };
      DERNode.prototype._decodeNull = function decodeNull() {
        return null;
      };
      DERNode.prototype._decodeBool = function decodeBool(buffer) {
        const res = buffer.readUInt8();
        if (buffer.isError(res))
          return res;
        else
          return res !== 0;
      };
      DERNode.prototype._decodeInt = function decodeInt(buffer, values) {
        const raw = buffer.raw();
        let res = new bignum(raw);
        if (values)
          res = values[res.toString(10)] || res;
        return res;
      };
      DERNode.prototype._use = function use(entity, obj) {
        if (typeof entity === "function")
          entity = entity(obj);
        return entity._getDecoder("der").tree;
      };
      function derDecodeTag(buf, fail) {
        let tag = buf.readUInt8(fail);
        if (buf.isError(tag))
          return tag;
        const cls = der.tagClass[tag >> 6];
        const primitive = (tag & 32) === 0;
        if ((tag & 31) === 31) {
          let oct = tag;
          tag = 0;
          while ((oct & 128) === 128) {
            oct = buf.readUInt8(fail);
            if (buf.isError(oct))
              return oct;
            tag <<= 7;
            tag |= oct & 127;
          }
        } else {
          tag &= 31;
        }
        const tagStr = der.tag[tag];
        return {
          cls,
          primitive,
          tag,
          tagStr
        };
      }
      function derDecodeLen(buf, primitive, fail) {
        let len = buf.readUInt8(fail);
        if (buf.isError(len))
          return len;
        if (!primitive && len === 128)
          return null;
        if ((len & 128) === 0) {
          return len;
        }
        const num = len & 127;
        if (num > 4)
          return buf.error("length octect is too long");
        len = 0;
        for (let i = 0; i < num; i++) {
          len <<= 8;
          const j = buf.readUInt8(fail);
          if (buf.isError(j))
            return j;
          len |= j;
        }
        return len;
      }
    }
  });

  // node_modules/asn1.js/lib/asn1/decoders/pem.js
  var require_pem2 = __commonJS({
    "node_modules/asn1.js/lib/asn1/decoders/pem.js"(exports2, module2) {
      "use strict";
      var inherits = require_inherits_browser();
      var Buffer2 = require_safer().Buffer;
      var DERDecoder = require_der3();
      function PEMDecoder(entity) {
        DERDecoder.call(this, entity);
        this.enc = "pem";
      }
      inherits(PEMDecoder, DERDecoder);
      module2.exports = PEMDecoder;
      PEMDecoder.prototype.decode = function decode(data, options) {
        const lines = data.toString().split(/[\r\n]+/g);
        const label = options.label.toUpperCase();
        const re = /^-----(BEGIN|END) ([^-]+)-----$/;
        let start2 = -1;
        let end = -1;
        for (let i = 0; i < lines.length; i++) {
          const match = lines[i].match(re);
          if (match === null)
            continue;
          if (match[2] !== label)
            continue;
          if (start2 === -1) {
            if (match[1] !== "BEGIN")
              break;
            start2 = i;
          } else {
            if (match[1] !== "END")
              break;
            end = i;
            break;
          }
        }
        if (start2 === -1 || end === -1)
          throw new Error("PEM section not found for: " + label);
        const base64 = lines.slice(start2 + 1, end).join("");
        base64.replace(/[^a-z0-9+/=]+/gi, "");
        const input = Buffer2.from(base64, "base64");
        return DERDecoder.prototype.decode.call(this, input, options);
      };
    }
  });

  // node_modules/asn1.js/lib/asn1/decoders/index.js
  var require_decoders = __commonJS({
    "node_modules/asn1.js/lib/asn1/decoders/index.js"(exports2) {
      "use strict";
      var decoders = exports2;
      decoders.der = require_der3();
      decoders.pem = require_pem2();
    }
  });

  // node_modules/asn1.js/lib/asn1/api.js
  var require_api = __commonJS({
    "node_modules/asn1.js/lib/asn1/api.js"(exports2) {
      "use strict";
      var encoders = require_encoders();
      var decoders = require_decoders();
      var inherits = require_inherits_browser();
      var api = exports2;
      api.define = function define2(name, body) {
        return new Entity(name, body);
      };
      function Entity(name, body) {
        this.name = name;
        this.body = body;
        this.decoders = {};
        this.encoders = {};
      }
      Entity.prototype._createNamed = function createNamed(Base) {
        const name = this.name;
        function Generated(entity) {
          this._initNamed(entity, name);
        }
        inherits(Generated, Base);
        Generated.prototype._initNamed = function _initNamed(entity, name2) {
          Base.call(this, entity, name2);
        };
        return new Generated(this);
      };
      Entity.prototype._getDecoder = function _getDecoder(enc) {
        enc = enc || "der";
        if (!this.decoders.hasOwnProperty(enc))
          this.decoders[enc] = this._createNamed(decoders[enc]);
        return this.decoders[enc];
      };
      Entity.prototype.decode = function decode(data, enc, options) {
        return this._getDecoder(enc).decode(data, options);
      };
      Entity.prototype._getEncoder = function _getEncoder(enc) {
        enc = enc || "der";
        if (!this.encoders.hasOwnProperty(enc))
          this.encoders[enc] = this._createNamed(encoders[enc]);
        return this.encoders[enc];
      };
      Entity.prototype.encode = function encode(data, enc, reporter) {
        return this._getEncoder(enc).encode(data, reporter);
      };
    }
  });

  // node_modules/asn1.js/lib/asn1/base/index.js
  var require_base2 = __commonJS({
    "node_modules/asn1.js/lib/asn1/base/index.js"(exports2) {
      "use strict";
      var base = exports2;
      base.Reporter = require_reporter().Reporter;
      base.DecoderBuffer = require_buffer3().DecoderBuffer;
      base.EncoderBuffer = require_buffer3().EncoderBuffer;
      base.Node = require_node();
    }
  });

  // node_modules/asn1.js/lib/asn1/constants/index.js
  var require_constants = __commonJS({
    "node_modules/asn1.js/lib/asn1/constants/index.js"(exports2) {
      "use strict";
      var constants = exports2;
      constants._reverse = function reverse(map) {
        const res = {};
        Object.keys(map).forEach(function(key) {
          if ((key | 0) == key)
            key = key | 0;
          const value = map[key];
          res[value] = key;
        });
        return res;
      };
      constants.der = require_der();
    }
  });

  // node_modules/asn1.js/lib/asn1.js
  var require_asn1 = __commonJS({
    "node_modules/asn1.js/lib/asn1.js"(exports2) {
      "use strict";
      var asn1 = exports2;
      asn1.bignum = require_bn2();
      asn1.define = require_api().define;
      asn1.base = require_base2();
      asn1.constants = require_constants();
      asn1.decoders = require_decoders();
      asn1.encoders = require_encoders();
    }
  });

  // node_modules/parse-asn1/certificate.js
  var require_certificate = __commonJS({
    "node_modules/parse-asn1/certificate.js"(exports2, module2) {
      "use strict";
      var asn = require_asn1();
      var Time = asn.define("Time", function() {
        this.choice({
          utcTime: this.utctime(),
          generalTime: this.gentime()
        });
      });
      var AttributeTypeValue = asn.define("AttributeTypeValue", function() {
        this.seq().obj(this.key("type").objid(), this.key("value").any());
      });
      var AlgorithmIdentifier = asn.define("AlgorithmIdentifier", function() {
        this.seq().obj(this.key("algorithm").objid(), this.key("parameters").optional(), this.key("curve").objid().optional());
      });
      var SubjectPublicKeyInfo = asn.define("SubjectPublicKeyInfo", function() {
        this.seq().obj(this.key("algorithm").use(AlgorithmIdentifier), this.key("subjectPublicKey").bitstr());
      });
      var RelativeDistinguishedName = asn.define("RelativeDistinguishedName", function() {
        this.setof(AttributeTypeValue);
      });
      var RDNSequence = asn.define("RDNSequence", function() {
        this.seqof(RelativeDistinguishedName);
      });
      var Name = asn.define("Name", function() {
        this.choice({
          rdnSequence: this.use(RDNSequence)
        });
      });
      var Validity = asn.define("Validity", function() {
        this.seq().obj(this.key("notBefore").use(Time), this.key("notAfter").use(Time));
      });
      var Extension = asn.define("Extension", function() {
        this.seq().obj(this.key("extnID").objid(), this.key("critical").bool().def(false), this.key("extnValue").octstr());
      });
      var TBSCertificate = asn.define("TBSCertificate", function() {
        this.seq().obj(this.key("version").explicit(0).int().optional(), this.key("serialNumber").int(), this.key("signature").use(AlgorithmIdentifier), this.key("issuer").use(Name), this.key("validity").use(Validity), this.key("subject").use(Name), this.key("subjectPublicKeyInfo").use(SubjectPublicKeyInfo), this.key("issuerUniqueID").implicit(1).bitstr().optional(), this.key("subjectUniqueID").implicit(2).bitstr().optional(), this.key("extensions").explicit(3).seqof(Extension).optional());
      });
      var X509Certificate = asn.define("X509Certificate", function() {
        this.seq().obj(this.key("tbsCertificate").use(TBSCertificate), this.key("signatureAlgorithm").use(AlgorithmIdentifier), this.key("signatureValue").bitstr());
      });
      module2.exports = X509Certificate;
    }
  });

  // node_modules/parse-asn1/asn1.js
  var require_asn12 = __commonJS({
    "node_modules/parse-asn1/asn1.js"(exports2) {
      "use strict";
      var asn1 = require_asn1();
      exports2.certificate = require_certificate();
      var RSAPrivateKey = asn1.define("RSAPrivateKey", function() {
        this.seq().obj(this.key("version").int(), this.key("modulus").int(), this.key("publicExponent").int(), this.key("privateExponent").int(), this.key("prime1").int(), this.key("prime2").int(), this.key("exponent1").int(), this.key("exponent2").int(), this.key("coefficient").int());
      });
      exports2.RSAPrivateKey = RSAPrivateKey;
      var RSAPublicKey = asn1.define("RSAPublicKey", function() {
        this.seq().obj(this.key("modulus").int(), this.key("publicExponent").int());
      });
      exports2.RSAPublicKey = RSAPublicKey;
      var PublicKey = asn1.define("SubjectPublicKeyInfo", function() {
        this.seq().obj(this.key("algorithm").use(AlgorithmIdentifier), this.key("subjectPublicKey").bitstr());
      });
      exports2.PublicKey = PublicKey;
      var AlgorithmIdentifier = asn1.define("AlgorithmIdentifier", function() {
        this.seq().obj(this.key("algorithm").objid(), this.key("none").null_().optional(), this.key("curve").objid().optional(), this.key("params").seq().obj(this.key("p").int(), this.key("q").int(), this.key("g").int()).optional());
      });
      var PrivateKeyInfo = asn1.define("PrivateKeyInfo", function() {
        this.seq().obj(this.key("version").int(), this.key("algorithm").use(AlgorithmIdentifier), this.key("subjectPrivateKey").octstr());
      });
      exports2.PrivateKey = PrivateKeyInfo;
      var EncryptedPrivateKeyInfo = asn1.define("EncryptedPrivateKeyInfo", function() {
        this.seq().obj(this.key("algorithm").seq().obj(this.key("id").objid(), this.key("decrypt").seq().obj(this.key("kde").seq().obj(this.key("id").objid(), this.key("kdeparams").seq().obj(this.key("salt").octstr(), this.key("iters").int())), this.key("cipher").seq().obj(this.key("algo").objid(), this.key("iv").octstr()))), this.key("subjectPrivateKey").octstr());
      });
      exports2.EncryptedPrivateKey = EncryptedPrivateKeyInfo;
      var DSAPrivateKey = asn1.define("DSAPrivateKey", function() {
        this.seq().obj(this.key("version").int(), this.key("p").int(), this.key("q").int(), this.key("g").int(), this.key("pub_key").int(), this.key("priv_key").int());
      });
      exports2.DSAPrivateKey = DSAPrivateKey;
      exports2.DSAparam = asn1.define("DSAparam", function() {
        this.int();
      });
      var ECPrivateKey = asn1.define("ECPrivateKey", function() {
        this.seq().obj(this.key("version").int(), this.key("privateKey").octstr(), this.key("parameters").optional().explicit(0).use(ECParameters), this.key("publicKey").optional().explicit(1).bitstr());
      });
      exports2.ECPrivateKey = ECPrivateKey;
      var ECParameters = asn1.define("ECParameters", function() {
        this.choice({
          namedCurve: this.objid()
        });
      });
      exports2.signature = asn1.define("signature", function() {
        this.seq().obj(this.key("r").int(), this.key("s").int());
      });
    }
  });

  // node_modules/parse-asn1/aesid.json
  var require_aesid = __commonJS({
    "node_modules/parse-asn1/aesid.json"(exports2, module2) {
      module2.exports = {
        "2.16.840.1.101.3.4.1.1": "aes-128-ecb",
        "2.16.840.1.101.3.4.1.2": "aes-128-cbc",
        "2.16.840.1.101.3.4.1.3": "aes-128-ofb",
        "2.16.840.1.101.3.4.1.4": "aes-128-cfb",
        "2.16.840.1.101.3.4.1.21": "aes-192-ecb",
        "2.16.840.1.101.3.4.1.22": "aes-192-cbc",
        "2.16.840.1.101.3.4.1.23": "aes-192-ofb",
        "2.16.840.1.101.3.4.1.24": "aes-192-cfb",
        "2.16.840.1.101.3.4.1.41": "aes-256-ecb",
        "2.16.840.1.101.3.4.1.42": "aes-256-cbc",
        "2.16.840.1.101.3.4.1.43": "aes-256-ofb",
        "2.16.840.1.101.3.4.1.44": "aes-256-cfb"
      };
    }
  });

  // node_modules/parse-asn1/fixProc.js
  var require_fixProc = __commonJS({
    "node_modules/parse-asn1/fixProc.js"(exports2, module2) {
      var findProc = /Proc-Type: 4,ENCRYPTED[\n\r]+DEK-Info: AES-((?:128)|(?:192)|(?:256))-CBC,([0-9A-H]+)[\n\r]+([0-9A-z\n\r+/=]+)[\n\r]+/m;
      var startRegex = /^-----BEGIN ((?:.*? KEY)|CERTIFICATE)-----/m;
      var fullRegex = /^-----BEGIN ((?:.*? KEY)|CERTIFICATE)-----([0-9A-z\n\r+/=]+)-----END \1-----$/m;
      var evp = require_evp_bytestokey();
      var ciphers = require_browser6();
      var Buffer2 = require_safe_buffer().Buffer;
      module2.exports = function(okey, password) {
        var key = okey.toString();
        var match = key.match(findProc);
        var decrypted;
        if (!match) {
          var match2 = key.match(fullRegex);
          decrypted = Buffer2.from(match2[2].replace(/[\r\n]/g, ""), "base64");
        } else {
          var suite = "aes" + match[1];
          var iv = Buffer2.from(match[2], "hex");
          var cipherText = Buffer2.from(match[3].replace(/[\r\n]/g, ""), "base64");
          var cipherKey = evp(password, iv.slice(0, 8), parseInt(match[1], 10)).key;
          var out = [];
          var cipher = ciphers.createDecipheriv(suite, cipherKey, iv);
          out.push(cipher.update(cipherText));
          out.push(cipher.final());
          decrypted = Buffer2.concat(out);
        }
        var tag = key.match(startRegex)[1];
        return {
          tag,
          data: decrypted
        };
      };
    }
  });

  // node_modules/parse-asn1/index.js
  var require_parse_asn1 = __commonJS({
    "node_modules/parse-asn1/index.js"(exports2, module2) {
      var asn1 = require_asn12();
      var aesid = require_aesid();
      var fixProc = require_fixProc();
      var ciphers = require_browser6();
      var compat = require_browser5();
      var Buffer2 = require_safe_buffer().Buffer;
      module2.exports = parseKeys;
      function parseKeys(buffer) {
        var password;
        if (typeof buffer === "object" && !Buffer2.isBuffer(buffer)) {
          password = buffer.passphrase;
          buffer = buffer.key;
        }
        if (typeof buffer === "string") {
          buffer = Buffer2.from(buffer);
        }
        var stripped = fixProc(buffer, password);
        var type = stripped.tag;
        var data = stripped.data;
        var subtype, ndata;
        switch (type) {
          case "CERTIFICATE":
            ndata = asn1.certificate.decode(data, "der").tbsCertificate.subjectPublicKeyInfo;
          case "PUBLIC KEY":
            if (!ndata) {
              ndata = asn1.PublicKey.decode(data, "der");
            }
            subtype = ndata.algorithm.algorithm.join(".");
            switch (subtype) {
              case "1.2.840.113549.1.1.1":
                return asn1.RSAPublicKey.decode(ndata.subjectPublicKey.data, "der");
              case "1.2.840.10045.2.1":
                ndata.subjectPrivateKey = ndata.subjectPublicKey;
                return {
                  type: "ec",
                  data: ndata
                };
              case "1.2.840.10040.4.1":
                ndata.algorithm.params.pub_key = asn1.DSAparam.decode(ndata.subjectPublicKey.data, "der");
                return {
                  type: "dsa",
                  data: ndata.algorithm.params
                };
              default:
                throw new Error("unknown key id " + subtype);
            }
          case "ENCRYPTED PRIVATE KEY":
            data = asn1.EncryptedPrivateKey.decode(data, "der");
            data = decrypt(data, password);
          case "PRIVATE KEY":
            ndata = asn1.PrivateKey.decode(data, "der");
            subtype = ndata.algorithm.algorithm.join(".");
            switch (subtype) {
              case "1.2.840.113549.1.1.1":
                return asn1.RSAPrivateKey.decode(ndata.subjectPrivateKey, "der");
              case "1.2.840.10045.2.1":
                return {
                  curve: ndata.algorithm.curve,
                  privateKey: asn1.ECPrivateKey.decode(ndata.subjectPrivateKey, "der").privateKey
                };
              case "1.2.840.10040.4.1":
                ndata.algorithm.params.priv_key = asn1.DSAparam.decode(ndata.subjectPrivateKey, "der");
                return {
                  type: "dsa",
                  params: ndata.algorithm.params
                };
              default:
                throw new Error("unknown key id " + subtype);
            }
          case "RSA PUBLIC KEY":
            return asn1.RSAPublicKey.decode(data, "der");
          case "RSA PRIVATE KEY":
            return asn1.RSAPrivateKey.decode(data, "der");
          case "DSA PRIVATE KEY":
            return {
              type: "dsa",
              params: asn1.DSAPrivateKey.decode(data, "der")
            };
          case "EC PRIVATE KEY":
            data = asn1.ECPrivateKey.decode(data, "der");
            return {
              curve: data.parameters.value,
              privateKey: data.privateKey
            };
          default:
            throw new Error("unknown key type " + type);
        }
      }
      parseKeys.signature = asn1.signature;
      function decrypt(data, password) {
        var salt = data.algorithm.decrypt.kde.kdeparams.salt;
        var iters = parseInt(data.algorithm.decrypt.kde.kdeparams.iters.toString(), 10);
        var algo = aesid[data.algorithm.decrypt.cipher.algo.join(".")];
        var iv = data.algorithm.decrypt.cipher.iv;
        var cipherText = data.subjectPrivateKey;
        var keylen = parseInt(algo.split("-")[1], 10) / 8;
        var key = compat.pbkdf2Sync(password, salt, iters, keylen, "sha1");
        var cipher = ciphers.createDecipheriv(algo, key, iv);
        var out = [];
        out.push(cipher.update(cipherText));
        out.push(cipher.final());
        return Buffer2.concat(out);
      }
    }
  });

  // node_modules/browserify-sign/browser/curves.json
  var require_curves2 = __commonJS({
    "node_modules/browserify-sign/browser/curves.json"(exports2, module2) {
      module2.exports = {
        "1.3.132.0.10": "secp256k1",
        "1.3.132.0.33": "p224",
        "1.2.840.10045.3.1.1": "p192",
        "1.2.840.10045.3.1.7": "p256",
        "1.3.132.0.34": "p384",
        "1.3.132.0.35": "p521"
      };
    }
  });

  // node_modules/browserify-sign/browser/sign.js
  var require_sign = __commonJS({
    "node_modules/browserify-sign/browser/sign.js"(exports2, module2) {
      var Buffer2 = require_safe_buffer().Buffer;
      var createHmac = require_browser4();
      var crt = require_browserify_rsa();
      var EC = require_elliptic().ec;
      var BN = require_bn4();
      var parseKeys = require_parse_asn1();
      var curves = require_curves2();
      function sign(hash, key, hashType, signType, tag) {
        var priv = parseKeys(key);
        if (priv.curve) {
          if (signType !== "ecdsa" && signType !== "ecdsa/rsa")
            throw new Error("wrong private key type");
          return ecSign(hash, priv);
        } else if (priv.type === "dsa") {
          if (signType !== "dsa")
            throw new Error("wrong private key type");
          return dsaSign(hash, priv, hashType);
        } else {
          if (signType !== "rsa" && signType !== "ecdsa/rsa")
            throw new Error("wrong private key type");
        }
        hash = Buffer2.concat([tag, hash]);
        var len = priv.modulus.byteLength();
        var pad = [0, 1];
        while (hash.length + pad.length + 1 < len)
          pad.push(255);
        pad.push(0);
        var i = -1;
        while (++i < hash.length)
          pad.push(hash[i]);
        var out = crt(pad, priv);
        return out;
      }
      function ecSign(hash, priv) {
        var curveId = curves[priv.curve.join(".")];
        if (!curveId)
          throw new Error("unknown curve " + priv.curve.join("."));
        var curve = new EC(curveId);
        var key = curve.keyFromPrivate(priv.privateKey);
        var out = key.sign(hash);
        return Buffer2.from(out.toDER());
      }
      function dsaSign(hash, priv, algo) {
        var x = priv.params.priv_key;
        var p = priv.params.p;
        var q = priv.params.q;
        var g = priv.params.g;
        var r = new BN(0);
        var k;
        var H = bits2int(hash, q).mod(q);
        var s = false;
        var kv = getKey(x, q, hash, algo);
        while (s === false) {
          k = makeKey(q, kv, algo);
          r = makeR(g, k, p, q);
          s = k.invm(q).imul(H.add(x.mul(r))).mod(q);
          if (s.cmpn(0) === 0) {
            s = false;
            r = new BN(0);
          }
        }
        return toDER(r, s);
      }
      function toDER(r, s) {
        r = r.toArray();
        s = s.toArray();
        if (r[0] & 128)
          r = [0].concat(r);
        if (s[0] & 128)
          s = [0].concat(s);
        var total = r.length + s.length + 4;
        var res = [48, total, 2, r.length];
        res = res.concat(r, [2, s.length], s);
        return Buffer2.from(res);
      }
      function getKey(x, q, hash, algo) {
        x = Buffer2.from(x.toArray());
        if (x.length < q.byteLength()) {
          var zeros = Buffer2.alloc(q.byteLength() - x.length);
          x = Buffer2.concat([zeros, x]);
        }
        var hlen = hash.length;
        var hbits = bits2octets(hash, q);
        var v = Buffer2.alloc(hlen);
        v.fill(1);
        var k = Buffer2.alloc(hlen);
        k = createHmac(algo, k).update(v).update(Buffer2.from([0])).update(x).update(hbits).digest();
        v = createHmac(algo, k).update(v).digest();
        k = createHmac(algo, k).update(v).update(Buffer2.from([1])).update(x).update(hbits).digest();
        v = createHmac(algo, k).update(v).digest();
        return { k, v };
      }
      function bits2int(obits, q) {
        var bits = new BN(obits);
        var shift = (obits.length << 3) - q.bitLength();
        if (shift > 0)
          bits.ishrn(shift);
        return bits;
      }
      function bits2octets(bits, q) {
        bits = bits2int(bits, q);
        bits = bits.mod(q);
        var out = Buffer2.from(bits.toArray());
        if (out.length < q.byteLength()) {
          var zeros = Buffer2.alloc(q.byteLength() - out.length);
          out = Buffer2.concat([zeros, out]);
        }
        return out;
      }
      function makeKey(q, kv, algo) {
        var t;
        var k;
        do {
          t = Buffer2.alloc(0);
          while (t.length * 8 < q.bitLength()) {
            kv.v = createHmac(algo, kv.k).update(kv.v).digest();
            t = Buffer2.concat([t, kv.v]);
          }
          k = bits2int(t, q);
          kv.k = createHmac(algo, kv.k).update(kv.v).update(Buffer2.from([0])).digest();
          kv.v = createHmac(algo, kv.k).update(kv.v).digest();
        } while (k.cmp(q) !== -1);
        return k;
      }
      function makeR(g, k, p, q) {
        return g.toRed(BN.mont(p)).redPow(k).fromRed().mod(q);
      }
      module2.exports = sign;
      module2.exports.getKey = getKey;
      module2.exports.makeKey = makeKey;
    }
  });

  // node_modules/browserify-sign/browser/verify.js
  var require_verify = __commonJS({
    "node_modules/browserify-sign/browser/verify.js"(exports2, module2) {
      var Buffer2 = require_safe_buffer().Buffer;
      var BN = require_bn4();
      var EC = require_elliptic().ec;
      var parseKeys = require_parse_asn1();
      var curves = require_curves2();
      function verify(sig, hash, key, signType, tag) {
        var pub = parseKeys(key);
        if (pub.type === "ec") {
          if (signType !== "ecdsa" && signType !== "ecdsa/rsa")
            throw new Error("wrong public key type");
          return ecVerify(sig, hash, pub);
        } else if (pub.type === "dsa") {
          if (signType !== "dsa")
            throw new Error("wrong public key type");
          return dsaVerify(sig, hash, pub);
        } else {
          if (signType !== "rsa" && signType !== "ecdsa/rsa")
            throw new Error("wrong public key type");
        }
        hash = Buffer2.concat([tag, hash]);
        var len = pub.modulus.byteLength();
        var pad = [1];
        var padNum = 0;
        while (hash.length + pad.length + 2 < len) {
          pad.push(255);
          padNum++;
        }
        pad.push(0);
        var i = -1;
        while (++i < hash.length) {
          pad.push(hash[i]);
        }
        pad = Buffer2.from(pad);
        var red = BN.mont(pub.modulus);
        sig = new BN(sig).toRed(red);
        sig = sig.redPow(new BN(pub.publicExponent));
        sig = Buffer2.from(sig.fromRed().toArray());
        var out = padNum < 8 ? 1 : 0;
        len = Math.min(sig.length, pad.length);
        if (sig.length !== pad.length)
          out = 1;
        i = -1;
        while (++i < len)
          out |= sig[i] ^ pad[i];
        return out === 0;
      }
      function ecVerify(sig, hash, pub) {
        var curveId = curves[pub.data.algorithm.curve.join(".")];
        if (!curveId)
          throw new Error("unknown curve " + pub.data.algorithm.curve.join("."));
        var curve = new EC(curveId);
        var pubkey = pub.data.subjectPrivateKey.data;
        return curve.verify(hash, sig, pubkey);
      }
      function dsaVerify(sig, hash, pub) {
        var p = pub.data.p;
        var q = pub.data.q;
        var g = pub.data.g;
        var y = pub.data.pub_key;
        var unpacked = parseKeys.signature.decode(sig, "der");
        var s = unpacked.s;
        var r = unpacked.r;
        checkValue(s, q);
        checkValue(r, q);
        var montp = BN.mont(p);
        var w = s.invm(q);
        var v = g.toRed(montp).redPow(new BN(hash).mul(w).mod(q)).fromRed().mul(y.toRed(montp).redPow(r.mul(w).mod(q)).fromRed()).mod(p).mod(q);
        return v.cmp(r) === 0;
      }
      function checkValue(b, q) {
        if (b.cmpn(0) <= 0)
          throw new Error("invalid sig");
        if (b.cmp(q) >= q)
          throw new Error("invalid sig");
      }
      module2.exports = verify;
    }
  });

  // node_modules/browserify-sign/browser/index.js
  var require_browser9 = __commonJS({
    "node_modules/browserify-sign/browser/index.js"(exports2, module2) {
      var Buffer2 = require_safe_buffer().Buffer;
      var createHash = require_browser3();
      var stream = require_readable_browser();
      var inherits = require_inherits_browser();
      var sign = require_sign();
      var verify = require_verify();
      var algorithms = require_algorithms();
      Object.keys(algorithms).forEach(function(key) {
        algorithms[key].id = Buffer2.from(algorithms[key].id, "hex");
        algorithms[key.toLowerCase()] = algorithms[key];
      });
      function Sign(algorithm) {
        stream.Writable.call(this);
        var data = algorithms[algorithm];
        if (!data)
          throw new Error("Unknown message digest");
        this._hashType = data.hash;
        this._hash = createHash(data.hash);
        this._tag = data.id;
        this._signType = data.sign;
      }
      inherits(Sign, stream.Writable);
      Sign.prototype._write = function _write(data, _, done) {
        this._hash.update(data);
        done();
      };
      Sign.prototype.update = function update(data, enc) {
        if (typeof data === "string")
          data = Buffer2.from(data, enc);
        this._hash.update(data);
        return this;
      };
      Sign.prototype.sign = function signMethod(key, enc) {
        this.end();
        var hash = this._hash.digest();
        var sig = sign(hash, key, this._hashType, this._signType, this._tag);
        return enc ? sig.toString(enc) : sig;
      };
      function Verify(algorithm) {
        stream.Writable.call(this);
        var data = algorithms[algorithm];
        if (!data)
          throw new Error("Unknown message digest");
        this._hash = createHash(data.hash);
        this._tag = data.id;
        this._signType = data.sign;
      }
      inherits(Verify, stream.Writable);
      Verify.prototype._write = function _write(data, _, done) {
        this._hash.update(data);
        done();
      };
      Verify.prototype.update = function update(data, enc) {
        if (typeof data === "string")
          data = Buffer2.from(data, enc);
        this._hash.update(data);
        return this;
      };
      Verify.prototype.verify = function verifyMethod(key, sig, enc) {
        if (typeof sig === "string")
          sig = Buffer2.from(sig, enc);
        this.end();
        var hash = this._hash.digest();
        return verify(sig, hash, key, this._signType, this._tag);
      };
      function createSign(algorithm) {
        return new Sign(algorithm);
      }
      function createVerify(algorithm) {
        return new Verify(algorithm);
      }
      module2.exports = {
        Sign: createSign,
        Verify: createVerify,
        createSign,
        createVerify
      };
    }
  });

  // node_modules/create-ecdh/browser.js
  var require_browser10 = __commonJS({
    "node_modules/create-ecdh/browser.js"(exports2, module2) {
      var elliptic = require_elliptic();
      var BN = require_bn2();
      module2.exports = function createECDH(curve) {
        return new ECDH(curve);
      };
      var aliases = {
        secp256k1: {
          name: "secp256k1",
          byteLength: 32
        },
        secp224r1: {
          name: "p224",
          byteLength: 28
        },
        prime256v1: {
          name: "p256",
          byteLength: 32
        },
        prime192v1: {
          name: "p192",
          byteLength: 24
        },
        ed25519: {
          name: "ed25519",
          byteLength: 32
        },
        secp384r1: {
          name: "p384",
          byteLength: 48
        },
        secp521r1: {
          name: "p521",
          byteLength: 66
        }
      };
      aliases.p224 = aliases.secp224r1;
      aliases.p256 = aliases.secp256r1 = aliases.prime256v1;
      aliases.p192 = aliases.secp192r1 = aliases.prime192v1;
      aliases.p384 = aliases.secp384r1;
      aliases.p521 = aliases.secp521r1;
      function ECDH(curve) {
        this.curveType = aliases[curve];
        if (!this.curveType) {
          this.curveType = {
            name: curve
          };
        }
        this.curve = new elliptic.ec(this.curveType.name);
        this.keys = void 0;
      }
      ECDH.prototype.generateKeys = function(enc, format) {
        this.keys = this.curve.genKeyPair();
        return this.getPublicKey(enc, format);
      };
      ECDH.prototype.computeSecret = function(other, inenc, enc) {
        inenc = inenc || "utf8";
        if (!Buffer.isBuffer(other)) {
          other = new Buffer(other, inenc);
        }
        var otherPub = this.curve.keyFromPublic(other).getPublic();
        var out = otherPub.mul(this.keys.getPrivate()).getX();
        return formatReturnValue(out, enc, this.curveType.byteLength);
      };
      ECDH.prototype.getPublicKey = function(enc, format) {
        var key = this.keys.getPublic(format === "compressed", true);
        if (format === "hybrid") {
          if (key[key.length - 1] % 2) {
            key[0] = 7;
          } else {
            key[0] = 6;
          }
        }
        return formatReturnValue(key, enc);
      };
      ECDH.prototype.getPrivateKey = function(enc) {
        return formatReturnValue(this.keys.getPrivate(), enc);
      };
      ECDH.prototype.setPublicKey = function(pub, enc) {
        enc = enc || "utf8";
        if (!Buffer.isBuffer(pub)) {
          pub = new Buffer(pub, enc);
        }
        this.keys._importPublic(pub);
        return this;
      };
      ECDH.prototype.setPrivateKey = function(priv, enc) {
        enc = enc || "utf8";
        if (!Buffer.isBuffer(priv)) {
          priv = new Buffer(priv, enc);
        }
        var _priv = new BN(priv);
        _priv = _priv.toString(16);
        this.keys = this.curve.genKeyPair();
        this.keys._importPrivate(_priv);
        return this;
      };
      function formatReturnValue(bn, enc, len) {
        if (!Array.isArray(bn)) {
          bn = bn.toArray();
        }
        var buf = new Buffer(bn);
        if (len && buf.length < len) {
          var zeros = new Buffer(len - buf.length);
          zeros.fill(0);
          buf = Buffer.concat([zeros, buf]);
        }
        if (!enc) {
          return buf;
        } else {
          return buf.toString(enc);
        }
      }
    }
  });

  // node_modules/public-encrypt/mgf.js
  var require_mgf = __commonJS({
    "node_modules/public-encrypt/mgf.js"(exports2, module2) {
      var createHash = require_browser3();
      var Buffer2 = require_safe_buffer().Buffer;
      module2.exports = function(seed, len) {
        var t = Buffer2.alloc(0);
        var i = 0;
        var c;
        while (t.length < len) {
          c = i2ops(i++);
          t = Buffer2.concat([t, createHash("sha1").update(seed).update(c).digest()]);
        }
        return t.slice(0, len);
      };
      function i2ops(c) {
        var out = Buffer2.allocUnsafe(4);
        out.writeUInt32BE(c, 0);
        return out;
      }
    }
  });

  // node_modules/public-encrypt/xor.js
  var require_xor = __commonJS({
    "node_modules/public-encrypt/xor.js"(exports2, module2) {
      module2.exports = function xor(a, b) {
        var len = a.length;
        var i = -1;
        while (++i < len) {
          a[i] ^= b[i];
        }
        return a;
      };
    }
  });

  // node_modules/public-encrypt/withPublic.js
  var require_withPublic = __commonJS({
    "node_modules/public-encrypt/withPublic.js"(exports2, module2) {
      var BN = require_bn2();
      var Buffer2 = require_safe_buffer().Buffer;
      function withPublic(paddedMsg, key) {
        return Buffer2.from(paddedMsg.toRed(BN.mont(key.modulus)).redPow(new BN(key.publicExponent)).fromRed().toArray());
      }
      module2.exports = withPublic;
    }
  });

  // node_modules/public-encrypt/publicEncrypt.js
  var require_publicEncrypt = __commonJS({
    "node_modules/public-encrypt/publicEncrypt.js"(exports2, module2) {
      var parseKeys = require_parse_asn1();
      var randomBytes = require_browser();
      var createHash = require_browser3();
      var mgf = require_mgf();
      var xor = require_xor();
      var BN = require_bn2();
      var withPublic = require_withPublic();
      var crt = require_browserify_rsa();
      var Buffer2 = require_safe_buffer().Buffer;
      module2.exports = function publicEncrypt(publicKey, msg, reverse) {
        var padding;
        if (publicKey.padding) {
          padding = publicKey.padding;
        } else if (reverse) {
          padding = 1;
        } else {
          padding = 4;
        }
        var key = parseKeys(publicKey);
        var paddedMsg;
        if (padding === 4) {
          paddedMsg = oaep(key, msg);
        } else if (padding === 1) {
          paddedMsg = pkcs1(key, msg, reverse);
        } else if (padding === 3) {
          paddedMsg = new BN(msg);
          if (paddedMsg.cmp(key.modulus) >= 0) {
            throw new Error("data too long for modulus");
          }
        } else {
          throw new Error("unknown padding");
        }
        if (reverse) {
          return crt(paddedMsg, key);
        } else {
          return withPublic(paddedMsg, key);
        }
      };
      function oaep(key, msg) {
        var k = key.modulus.byteLength();
        var mLen = msg.length;
        var iHash = createHash("sha1").update(Buffer2.alloc(0)).digest();
        var hLen = iHash.length;
        var hLen2 = 2 * hLen;
        if (mLen > k - hLen2 - 2) {
          throw new Error("message too long");
        }
        var ps = Buffer2.alloc(k - mLen - hLen2 - 2);
        var dblen = k - hLen - 1;
        var seed = randomBytes(hLen);
        var maskedDb = xor(Buffer2.concat([iHash, ps, Buffer2.alloc(1, 1), msg], dblen), mgf(seed, dblen));
        var maskedSeed = xor(seed, mgf(maskedDb, hLen));
        return new BN(Buffer2.concat([Buffer2.alloc(1), maskedSeed, maskedDb], k));
      }
      function pkcs1(key, msg, reverse) {
        var mLen = msg.length;
        var k = key.modulus.byteLength();
        if (mLen > k - 11) {
          throw new Error("message too long");
        }
        var ps;
        if (reverse) {
          ps = Buffer2.alloc(k - mLen - 3, 255);
        } else {
          ps = nonZero(k - mLen - 3);
        }
        return new BN(Buffer2.concat([Buffer2.from([0, reverse ? 1 : 2]), ps, Buffer2.alloc(1), msg], k));
      }
      function nonZero(len) {
        var out = Buffer2.allocUnsafe(len);
        var i = 0;
        var cache = randomBytes(len * 2);
        var cur = 0;
        var num;
        while (i < len) {
          if (cur === cache.length) {
            cache = randomBytes(len * 2);
            cur = 0;
          }
          num = cache[cur++];
          if (num) {
            out[i++] = num;
          }
        }
        return out;
      }
    }
  });

  // node_modules/public-encrypt/privateDecrypt.js
  var require_privateDecrypt = __commonJS({
    "node_modules/public-encrypt/privateDecrypt.js"(exports2, module2) {
      var parseKeys = require_parse_asn1();
      var mgf = require_mgf();
      var xor = require_xor();
      var BN = require_bn2();
      var crt = require_browserify_rsa();
      var createHash = require_browser3();
      var withPublic = require_withPublic();
      var Buffer2 = require_safe_buffer().Buffer;
      module2.exports = function privateDecrypt(privateKey, enc, reverse) {
        var padding;
        if (privateKey.padding) {
          padding = privateKey.padding;
        } else if (reverse) {
          padding = 1;
        } else {
          padding = 4;
        }
        var key = parseKeys(privateKey);
        var k = key.modulus.byteLength();
        if (enc.length > k || new BN(enc).cmp(key.modulus) >= 0) {
          throw new Error("decryption error");
        }
        var msg;
        if (reverse) {
          msg = withPublic(new BN(enc), key);
        } else {
          msg = crt(enc, key);
        }
        var zBuffer = Buffer2.alloc(k - msg.length);
        msg = Buffer2.concat([zBuffer, msg], k);
        if (padding === 4) {
          return oaep(key, msg);
        } else if (padding === 1) {
          return pkcs1(key, msg, reverse);
        } else if (padding === 3) {
          return msg;
        } else {
          throw new Error("unknown padding");
        }
      };
      function oaep(key, msg) {
        var k = key.modulus.byteLength();
        var iHash = createHash("sha1").update(Buffer2.alloc(0)).digest();
        var hLen = iHash.length;
        if (msg[0] !== 0) {
          throw new Error("decryption error");
        }
        var maskedSeed = msg.slice(1, hLen + 1);
        var maskedDb = msg.slice(hLen + 1);
        var seed = xor(maskedSeed, mgf(maskedDb, hLen));
        var db = xor(maskedDb, mgf(seed, k - hLen - 1));
        if (compare(iHash, db.slice(0, hLen))) {
          throw new Error("decryption error");
        }
        var i = hLen;
        while (db[i] === 0) {
          i++;
        }
        if (db[i++] !== 1) {
          throw new Error("decryption error");
        }
        return db.slice(i);
      }
      function pkcs1(key, msg, reverse) {
        var p1 = msg.slice(0, 2);
        var i = 2;
        var status = 0;
        while (msg[i++] !== 0) {
          if (i >= msg.length) {
            status++;
            break;
          }
        }
        var ps = msg.slice(2, i - 1);
        if (p1.toString("hex") !== "0002" && !reverse || p1.toString("hex") !== "0001" && reverse) {
          status++;
        }
        if (ps.length < 8) {
          status++;
        }
        if (status) {
          throw new Error("decryption error");
        }
        return msg.slice(i);
      }
      function compare(a, b) {
        a = Buffer2.from(a);
        b = Buffer2.from(b);
        var dif = 0;
        var len = a.length;
        if (a.length !== b.length) {
          dif++;
          len = Math.min(a.length, b.length);
        }
        var i = -1;
        while (++i < len) {
          dif += a[i] ^ b[i];
        }
        return dif;
      }
    }
  });

  // node_modules/public-encrypt/browser.js
  var require_browser11 = __commonJS({
    "node_modules/public-encrypt/browser.js"(exports2) {
      exports2.publicEncrypt = require_publicEncrypt();
      exports2.privateDecrypt = require_privateDecrypt();
      exports2.privateEncrypt = function privateEncrypt(key, buf) {
        return exports2.publicEncrypt(key, buf, true);
      };
      exports2.publicDecrypt = function publicDecrypt(key, buf) {
        return exports2.privateDecrypt(key, buf, true);
      };
    }
  });

  // node_modules/randomfill/browser.js
  var require_browser12 = __commonJS({
    "node_modules/randomfill/browser.js"(exports2) {
      "use strict";
      function oldBrowser() {
        throw new Error("secure random number generation not supported by this browser\nuse chrome, FireFox or Internet Explorer 11");
      }
      var safeBuffer = require_safe_buffer();
      var randombytes = require_browser();
      var Buffer2 = safeBuffer.Buffer;
      var kBufferMaxLength = safeBuffer.kMaxLength;
      var crypto = global.crypto || global.msCrypto;
      var kMaxUint32 = Math.pow(2, 32) - 1;
      function assertOffset(offset, length) {
        if (typeof offset !== "number" || offset !== offset) {
          throw new TypeError("offset must be a number");
        }
        if (offset > kMaxUint32 || offset < 0) {
          throw new TypeError("offset must be a uint32");
        }
        if (offset > kBufferMaxLength || offset > length) {
          throw new RangeError("offset out of range");
        }
      }
      function assertSize(size, offset, length) {
        if (typeof size !== "number" || size !== size) {
          throw new TypeError("size must be a number");
        }
        if (size > kMaxUint32 || size < 0) {
          throw new TypeError("size must be a uint32");
        }
        if (size + offset > length || size > kBufferMaxLength) {
          throw new RangeError("buffer too small");
        }
      }
      if (crypto && crypto.getRandomValues || !process.browser) {
        exports2.randomFill = randomFill;
        exports2.randomFillSync = randomFillSync;
      } else {
        exports2.randomFill = oldBrowser;
        exports2.randomFillSync = oldBrowser;
      }
      function randomFill(buf, offset, size, cb) {
        if (!Buffer2.isBuffer(buf) && !(buf instanceof global.Uint8Array)) {
          throw new TypeError('"buf" argument must be a Buffer or Uint8Array');
        }
        if (typeof offset === "function") {
          cb = offset;
          offset = 0;
          size = buf.length;
        } else if (typeof size === "function") {
          cb = size;
          size = buf.length - offset;
        } else if (typeof cb !== "function") {
          throw new TypeError('"cb" argument must be a function');
        }
        assertOffset(offset, buf.length);
        assertSize(size, offset, buf.length);
        return actualFill(buf, offset, size, cb);
      }
      function actualFill(buf, offset, size, cb) {
        if (process.browser) {
          var ourBuf = buf.buffer;
          var uint = new Uint8Array(ourBuf, offset, size);
          crypto.getRandomValues(uint);
          if (cb) {
            process.nextTick(function() {
              cb(null, buf);
            });
            return;
          }
          return buf;
        }
        if (cb) {
          randombytes(size, function(err, bytes2) {
            if (err) {
              return cb(err);
            }
            bytes2.copy(buf, offset);
            cb(null, buf);
          });
          return;
        }
        var bytes = randombytes(size);
        bytes.copy(buf, offset);
        return buf;
      }
      function randomFillSync(buf, offset, size) {
        if (typeof offset === "undefined") {
          offset = 0;
        }
        if (!Buffer2.isBuffer(buf) && !(buf instanceof global.Uint8Array)) {
          throw new TypeError('"buf" argument must be a Buffer or Uint8Array');
        }
        assertOffset(offset, buf.length);
        if (size === void 0)
          size = buf.length - offset;
        assertSize(size, offset, buf.length);
        return actualFill(buf, offset, size);
      }
    }
  });

  // node_modules/crypto-browserify/index.js
  var require_crypto_browserify = __commonJS({
    "node_modules/crypto-browserify/index.js"(exports2) {
      "use strict";
      exports2.randomBytes = exports2.rng = exports2.pseudoRandomBytes = exports2.prng = require_browser();
      exports2.createHash = exports2.Hash = require_browser3();
      exports2.createHmac = exports2.Hmac = require_browser4();
      var algos = require_algos();
      var algoKeys = Object.keys(algos);
      var hashes = ["sha1", "sha224", "sha256", "sha384", "sha512", "md5", "rmd160"].concat(algoKeys);
      exports2.getHashes = function() {
        return hashes;
      };
      var p = require_browser5();
      exports2.pbkdf2 = p.pbkdf2;
      exports2.pbkdf2Sync = p.pbkdf2Sync;
      var aes = require_browser7();
      exports2.Cipher = aes.Cipher;
      exports2.createCipher = aes.createCipher;
      exports2.Cipheriv = aes.Cipheriv;
      exports2.createCipheriv = aes.createCipheriv;
      exports2.Decipher = aes.Decipher;
      exports2.createDecipher = aes.createDecipher;
      exports2.Decipheriv = aes.Decipheriv;
      exports2.createDecipheriv = aes.createDecipheriv;
      exports2.getCiphers = aes.getCiphers;
      exports2.listCiphers = aes.listCiphers;
      var dh = require_browser8();
      exports2.DiffieHellmanGroup = dh.DiffieHellmanGroup;
      exports2.createDiffieHellmanGroup = dh.createDiffieHellmanGroup;
      exports2.getDiffieHellman = dh.getDiffieHellman;
      exports2.createDiffieHellman = dh.createDiffieHellman;
      exports2.DiffieHellman = dh.DiffieHellman;
      var sign = require_browser9();
      exports2.createSign = sign.createSign;
      exports2.Sign = sign.Sign;
      exports2.createVerify = sign.createVerify;
      exports2.Verify = sign.Verify;
      exports2.createECDH = require_browser10();
      var publicEncrypt = require_browser11();
      exports2.publicEncrypt = publicEncrypt.publicEncrypt;
      exports2.privateEncrypt = publicEncrypt.privateEncrypt;
      exports2.publicDecrypt = publicEncrypt.publicDecrypt;
      exports2.privateDecrypt = publicEncrypt.privateDecrypt;
      var rf = require_browser12();
      exports2.randomFill = rf.randomFill;
      exports2.randomFillSync = rf.randomFillSync;
      exports2.createCredentials = function() {
        throw new Error([
          "sorry, createCredentials is not implemented yet",
          "we accept pull requests",
          "https://github.com/crypto-browserify/crypto-browserify"
        ].join("\n"));
      };
      exports2.constants = {
        "DH_CHECK_P_NOT_SAFE_PRIME": 2,
        "DH_CHECK_P_NOT_PRIME": 1,
        "DH_UNABLE_TO_CHECK_GENERATOR": 4,
        "DH_NOT_SUITABLE_GENERATOR": 8,
        "NPN_ENABLED": 1,
        "ALPN_ENABLED": 1,
        "RSA_PKCS1_PADDING": 1,
        "RSA_SSLV23_PADDING": 2,
        "RSA_NO_PADDING": 3,
        "RSA_PKCS1_OAEP_PADDING": 4,
        "RSA_X931_PADDING": 5,
        "RSA_PKCS1_PSS_PADDING": 6,
        "POINT_CONVERSION_COMPRESSED": 2,
        "POINT_CONVERSION_UNCOMPRESSED": 4,
        "POINT_CONVERSION_HYBRID": 6
      };
    }
  });

  // node_modules/@cosmjs/crypto/build/pbkdf2.js
  var require_pbkdf22 = __commonJS({
    "node_modules/@cosmjs/crypto/build/pbkdf2.js"(exports2) {
      "use strict";
      var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
        if (k2 === void 0)
          k2 = k;
        Object.defineProperty(o, k2, { enumerable: true, get: function() {
          return m[k];
        } });
      } : function(o, m, k, k2) {
        if (k2 === void 0)
          k2 = k;
        o[k2] = m[k];
      });
      var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
        Object.defineProperty(o, "default", { enumerable: true, value: v });
      } : function(o, v) {
        o["default"] = v;
      });
      var __importStar = exports2 && exports2.__importStar || function(mod2) {
        if (mod2 && mod2.__esModule)
          return mod2;
        var result = {};
        if (mod2 != null) {
          for (var k in mod2)
            if (k !== "default" && Object.prototype.hasOwnProperty.call(mod2, k))
              __createBinding(result, mod2, k);
        }
        __setModuleDefault(result, mod2);
        return result;
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.pbkdf2Sha512 = exports2.pbkdf2Sha512Noble = exports2.pbkdf2Sha512Crypto = exports2.pbkdf2Sha512Subtle = exports2.getSubtle = exports2.getCryptoModule = void 0;
      var utils_1 = require_build3();
      var pbkdf2_1 = require_pbkdf2();
      var sha512_1 = require_sha512();
      async function getCryptoModule() {
        try {
          const crypto = await Promise.resolve().then(() => __importStar(require_crypto_browserify()));
          if (typeof crypto === "object" && Object.keys(crypto).length <= 1) {
            return void 0;
          }
          return crypto;
        } catch (_a) {
          return void 0;
        }
      }
      exports2.getCryptoModule = getCryptoModule;
      async function getSubtle() {
        const g = globalThis;
        let subtle = g.crypto && g.crypto.subtle;
        if (!subtle) {
          const crypto = await getCryptoModule();
          if (crypto && crypto.webcrypto && crypto.webcrypto.subtle) {
            subtle = crypto.webcrypto.subtle;
          }
        }
        return subtle;
      }
      exports2.getSubtle = getSubtle;
      async function pbkdf2Sha512Subtle(subtle, secret, salt, iterations, keylen) {
        (0, utils_1.assert)(subtle, "Argument subtle is falsy");
        (0, utils_1.assert)(typeof subtle === "object", "Argument subtle is not of type object");
        (0, utils_1.assert)(typeof subtle.importKey === "function", "subtle.importKey is not a function");
        (0, utils_1.assert)(typeof subtle.deriveBits === "function", "subtle.deriveBits is not a function");
        return subtle.importKey("raw", secret, { name: "PBKDF2" }, false, ["deriveBits"]).then((key) => subtle.deriveBits({
          name: "PBKDF2",
          salt,
          iterations,
          hash: { name: "SHA-512" }
        }, key, keylen * 8).then((buffer) => new Uint8Array(buffer)));
      }
      exports2.pbkdf2Sha512Subtle = pbkdf2Sha512Subtle;
      async function pbkdf2Sha512Crypto(crypto, secret, salt, iterations, keylen) {
        (0, utils_1.assert)(crypto, "Argument crypto is falsy");
        (0, utils_1.assert)(typeof crypto === "object", "Argument crypto is not of type object");
        (0, utils_1.assert)(typeof crypto.pbkdf2 === "function", "crypto.pbkdf2 is not a function");
        return new Promise((resolve, reject) => {
          crypto.pbkdf2(secret, salt, iterations, keylen, "sha512", (error, result) => {
            if (error) {
              reject(error);
            } else {
              resolve(Uint8Array.from(result));
            }
          });
        });
      }
      exports2.pbkdf2Sha512Crypto = pbkdf2Sha512Crypto;
      async function pbkdf2Sha512Noble(secret, salt, iterations, keylen) {
        return (0, pbkdf2_1.pbkdf2Async)(sha512_1.sha512, secret, salt, { c: iterations, dkLen: keylen });
      }
      exports2.pbkdf2Sha512Noble = pbkdf2Sha512Noble;
      async function pbkdf2Sha512(secret, salt, iterations, keylen) {
        const subtle = await getSubtle();
        if (subtle) {
          return pbkdf2Sha512Subtle(subtle, secret, salt, iterations, keylen);
        } else {
          const crypto = await getCryptoModule();
          if (crypto) {
            return pbkdf2Sha512Crypto(crypto, secret, salt, iterations, keylen);
          } else {
            return pbkdf2Sha512Noble(secret, salt, iterations, keylen);
          }
        }
      }
      exports2.pbkdf2Sha512 = pbkdf2Sha512;
    }
  });

  // node_modules/@noble/hashes/sha256.js
  var require_sha2562 = __commonJS({
    "node_modules/@noble/hashes/sha256.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.sha256 = void 0;
      var _sha2_js_1 = require_sha2();
      var utils_js_1 = require_utils();
      var Chi = (a, b, c) => a & b ^ ~a & c;
      var Maj = (a, b, c) => a & b ^ a & c ^ b & c;
      var SHA256_K = new Uint32Array([
        1116352408,
        1899447441,
        3049323471,
        3921009573,
        961987163,
        1508970993,
        2453635748,
        2870763221,
        3624381080,
        310598401,
        607225278,
        1426881987,
        1925078388,
        2162078206,
        2614888103,
        3248222580,
        3835390401,
        4022224774,
        264347078,
        604807628,
        770255983,
        1249150122,
        1555081692,
        1996064986,
        2554220882,
        2821834349,
        2952996808,
        3210313671,
        3336571891,
        3584528711,
        113926993,
        338241895,
        666307205,
        773529912,
        1294757372,
        1396182291,
        1695183700,
        1986661051,
        2177026350,
        2456956037,
        2730485921,
        2820302411,
        3259730800,
        3345764771,
        3516065817,
        3600352804,
        4094571909,
        275423344,
        430227734,
        506948616,
        659060556,
        883997877,
        958139571,
        1322822218,
        1537002063,
        1747873779,
        1955562222,
        2024104815,
        2227730452,
        2361852424,
        2428436474,
        2756734187,
        3204031479,
        3329325298
      ]);
      var IV = new Uint32Array([
        1779033703,
        3144134277,
        1013904242,
        2773480762,
        1359893119,
        2600822924,
        528734635,
        1541459225
      ]);
      var SHA256_W = new Uint32Array(64);
      var SHA256 = class extends _sha2_js_1.SHA2 {
        constructor() {
          super(64, 32, 8, false);
          this.A = IV[0] | 0;
          this.B = IV[1] | 0;
          this.C = IV[2] | 0;
          this.D = IV[3] | 0;
          this.E = IV[4] | 0;
          this.F = IV[5] | 0;
          this.G = IV[6] | 0;
          this.H = IV[7] | 0;
        }
        get() {
          const { A, B, C, D, E, F, G, H } = this;
          return [A, B, C, D, E, F, G, H];
        }
        set(A, B, C, D, E, F, G, H) {
          this.A = A | 0;
          this.B = B | 0;
          this.C = C | 0;
          this.D = D | 0;
          this.E = E | 0;
          this.F = F | 0;
          this.G = G | 0;
          this.H = H | 0;
        }
        process(view, offset) {
          for (let i = 0; i < 16; i++, offset += 4)
            SHA256_W[i] = view.getUint32(offset, false);
          for (let i = 16; i < 64; i++) {
            const W15 = SHA256_W[i - 15];
            const W2 = SHA256_W[i - 2];
            const s0 = (0, utils_js_1.rotr)(W15, 7) ^ (0, utils_js_1.rotr)(W15, 18) ^ W15 >>> 3;
            const s1 = (0, utils_js_1.rotr)(W2, 17) ^ (0, utils_js_1.rotr)(W2, 19) ^ W2 >>> 10;
            SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
          }
          let { A, B, C, D, E, F, G, H } = this;
          for (let i = 0; i < 64; i++) {
            const sigma1 = (0, utils_js_1.rotr)(E, 6) ^ (0, utils_js_1.rotr)(E, 11) ^ (0, utils_js_1.rotr)(E, 25);
            const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
            const sigma0 = (0, utils_js_1.rotr)(A, 2) ^ (0, utils_js_1.rotr)(A, 13) ^ (0, utils_js_1.rotr)(A, 22);
            const T2 = sigma0 + Maj(A, B, C) | 0;
            H = G;
            G = F;
            F = E;
            E = D + T1 | 0;
            D = C;
            C = B;
            B = A;
            A = T1 + T2 | 0;
          }
          A = A + this.A | 0;
          B = B + this.B | 0;
          C = C + this.C | 0;
          D = D + this.D | 0;
          E = E + this.E | 0;
          F = F + this.F | 0;
          G = G + this.G | 0;
          H = H + this.H | 0;
          this.set(A, B, C, D, E, F, G, H);
        }
        roundClean() {
          SHA256_W.fill(0);
        }
        destroy() {
          this.set(0, 0, 0, 0, 0, 0, 0, 0);
          this.buffer.fill(0);
        }
      };
      exports2.sha256 = (0, utils_js_1.wrapConstructor)(() => new SHA256());
    }
  });

  // node_modules/@cosmjs/crypto/build/utils.js
  var require_utils6 = __commonJS({
    "node_modules/@cosmjs/crypto/build/utils.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.toRealUint8Array = void 0;
      function toRealUint8Array(data) {
        if (data instanceof Uint8Array)
          return data;
        else
          return Uint8Array.from(data);
      }
      exports2.toRealUint8Array = toRealUint8Array;
    }
  });

  // node_modules/@cosmjs/crypto/build/sha.js
  var require_sha5 = __commonJS({
    "node_modules/@cosmjs/crypto/build/sha.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.sha512 = exports2.Sha512 = exports2.sha256 = exports2.Sha256 = void 0;
      var sha256_1 = require_sha2562();
      var sha512_1 = require_sha512();
      var utils_1 = require_utils6();
      var Sha256 = class {
        constructor(firstData) {
          this.blockSize = 512 / 8;
          this.impl = sha256_1.sha256.create();
          if (firstData) {
            this.update(firstData);
          }
        }
        update(data) {
          this.impl.update((0, utils_1.toRealUint8Array)(data));
          return this;
        }
        digest() {
          return this.impl.digest();
        }
      };
      exports2.Sha256 = Sha256;
      function sha256(data) {
        return new Sha256(data).digest();
      }
      exports2.sha256 = sha256;
      var Sha512 = class {
        constructor(firstData) {
          this.blockSize = 1024 / 8;
          this.impl = sha512_1.sha512.create();
          if (firstData) {
            this.update(firstData);
          }
        }
        update(data) {
          this.impl.update((0, utils_1.toRealUint8Array)(data));
          return this;
        }
        digest() {
          return this.impl.digest();
        }
      };
      exports2.Sha512 = Sha512;
      function sha512(data) {
        return new Sha512(data).digest();
      }
      exports2.sha512 = sha512;
    }
  });

  // node_modules/@cosmjs/crypto/build/bip39.js
  var require_bip39 = __commonJS({
    "node_modules/@cosmjs/crypto/build/bip39.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.Bip39 = exports2.EnglishMnemonic = exports2.mnemonicToEntropy = exports2.entropyToMnemonic = void 0;
      var encoding_1 = require_build2();
      var pbkdf2_1 = require_pbkdf22();
      var sha_1 = require_sha5();
      var wordlist = [
        "abandon",
        "ability",
        "able",
        "about",
        "above",
        "absent",
        "absorb",
        "abstract",
        "absurd",
        "abuse",
        "access",
        "accident",
        "account",
        "accuse",
        "achieve",
        "acid",
        "acoustic",
        "acquire",
        "across",
        "act",
        "action",
        "actor",
        "actress",
        "actual",
        "adapt",
        "add",
        "addict",
        "address",
        "adjust",
        "admit",
        "adult",
        "advance",
        "advice",
        "aerobic",
        "affair",
        "afford",
        "afraid",
        "again",
        "age",
        "agent",
        "agree",
        "ahead",
        "aim",
        "air",
        "airport",
        "aisle",
        "alarm",
        "album",
        "alcohol",
        "alert",
        "alien",
        "all",
        "alley",
        "allow",
        "almost",
        "alone",
        "alpha",
        "already",
        "also",
        "alter",
        "always",
        "amateur",
        "amazing",
        "among",
        "amount",
        "amused",
        "analyst",
        "anchor",
        "ancient",
        "anger",
        "angle",
        "angry",
        "animal",
        "ankle",
        "announce",
        "annual",
        "another",
        "answer",
        "antenna",
        "antique",
        "anxiety",
        "any",
        "apart",
        "apology",
        "appear",
        "apple",
        "approve",
        "april",
        "arch",
        "arctic",
        "area",
        "arena",
        "argue",
        "arm",
        "armed",
        "armor",
        "army",
        "around",
        "arrange",
        "arrest",
        "arrive",
        "arrow",
        "art",
        "artefact",
        "artist",
        "artwork",
        "ask",
        "aspect",
        "assault",
        "asset",
        "assist",
        "assume",
        "asthma",
        "athlete",
        "atom",
        "attack",
        "attend",
        "attitude",
        "attract",
        "auction",
        "audit",
        "august",
        "aunt",
        "author",
        "auto",
        "autumn",
        "average",
        "avocado",
        "avoid",
        "awake",
        "aware",
        "away",
        "awesome",
        "awful",
        "awkward",
        "axis",
        "baby",
        "bachelor",
        "bacon",
        "badge",
        "bag",
        "balance",
        "balcony",
        "ball",
        "bamboo",
        "banana",
        "banner",
        "bar",
        "barely",
        "bargain",
        "barrel",
        "base",
        "basic",
        "basket",
        "battle",
        "beach",
        "bean",
        "beauty",
        "because",
        "become",
        "beef",
        "before",
        "begin",
        "behave",
        "behind",
        "believe",
        "below",
        "belt",
        "bench",
        "benefit",
        "best",
        "betray",
        "better",
        "between",
        "beyond",
        "bicycle",
        "bid",
        "bike",
        "bind",
        "biology",
        "bird",
        "birth",
        "bitter",
        "black",
        "blade",
        "blame",
        "blanket",
        "blast",
        "bleak",
        "bless",
        "blind",
        "blood",
        "blossom",
        "blouse",
        "blue",
        "blur",
        "blush",
        "board",
        "boat",
        "body",
        "boil",
        "bomb",
        "bone",
        "bonus",
        "book",
        "boost",
        "border",
        "boring",
        "borrow",
        "boss",
        "bottom",
        "bounce",
        "box",
        "boy",
        "bracket",
        "brain",
        "brand",
        "brass",
        "brave",
        "bread",
        "breeze",
        "brick",
        "bridge",
        "brief",
        "bright",
        "bring",
        "brisk",
        "broccoli",
        "broken",
        "bronze",
        "broom",
        "brother",
        "brown",
        "brush",
        "bubble",
        "buddy",
        "budget",
        "buffalo",
        "build",
        "bulb",
        "bulk",
        "bullet",
        "bundle",
        "bunker",
        "burden",
        "burger",
        "burst",
        "bus",
        "business",
        "busy",
        "butter",
        "buyer",
        "buzz",
        "cabbage",
        "cabin",
        "cable",
        "cactus",
        "cage",
        "cake",
        "call",
        "calm",
        "camera",
        "camp",
        "can",
        "canal",
        "cancel",
        "candy",
        "cannon",
        "canoe",
        "canvas",
        "canyon",
        "capable",
        "capital",
        "captain",
        "car",
        "carbon",
        "card",
        "cargo",
        "carpet",
        "carry",
        "cart",
        "case",
        "cash",
        "casino",
        "castle",
        "casual",
        "cat",
        "catalog",
        "catch",
        "category",
        "cattle",
        "caught",
        "cause",
        "caution",
        "cave",
        "ceiling",
        "celery",
        "cement",
        "census",
        "century",
        "cereal",
        "certain",
        "chair",
        "chalk",
        "champion",
        "change",
        "chaos",
        "chapter",
        "charge",
        "chase",
        "chat",
        "cheap",
        "check",
        "cheese",
        "chef",
        "cherry",
        "chest",
        "chicken",
        "chief",
        "child",
        "chimney",
        "choice",
        "choose",
        "chronic",
        "chuckle",
        "chunk",
        "churn",
        "cigar",
        "cinnamon",
        "circle",
        "citizen",
        "city",
        "civil",
        "claim",
        "clap",
        "clarify",
        "claw",
        "clay",
        "clean",
        "clerk",
        "clever",
        "click",
        "client",
        "cliff",
        "climb",
        "clinic",
        "clip",
        "clock",
        "clog",
        "close",
        "cloth",
        "cloud",
        "clown",
        "club",
        "clump",
        "cluster",
        "clutch",
        "coach",
        "coast",
        "coconut",
        "code",
        "coffee",
        "coil",
        "coin",
        "collect",
        "color",
        "column",
        "combine",
        "come",
        "comfort",
        "comic",
        "common",
        "company",
        "concert",
        "conduct",
        "confirm",
        "congress",
        "connect",
        "consider",
        "control",
        "convince",
        "cook",
        "cool",
        "copper",
        "copy",
        "coral",
        "core",
        "corn",
        "correct",
        "cost",
        "cotton",
        "couch",
        "country",
        "couple",
        "course",
        "cousin",
        "cover",
        "coyote",
        "crack",
        "cradle",
        "craft",
        "cram",
        "crane",
        "crash",
        "crater",
        "crawl",
        "crazy",
        "cream",
        "credit",
        "creek",
        "crew",
        "cricket",
        "crime",
        "crisp",
        "critic",
        "crop",
        "cross",
        "crouch",
        "crowd",
        "crucial",
        "cruel",
        "cruise",
        "crumble",
        "crunch",
        "crush",
        "cry",
        "crystal",
        "cube",
        "culture",
        "cup",
        "cupboard",
        "curious",
        "current",
        "curtain",
        "curve",
        "cushion",
        "custom",
        "cute",
        "cycle",
        "dad",
        "damage",
        "damp",
        "dance",
        "danger",
        "daring",
        "dash",
        "daughter",
        "dawn",
        "day",
        "deal",
        "debate",
        "debris",
        "decade",
        "december",
        "decide",
        "decline",
        "decorate",
        "decrease",
        "deer",
        "defense",
        "define",
        "defy",
        "degree",
        "delay",
        "deliver",
        "demand",
        "demise",
        "denial",
        "dentist",
        "deny",
        "depart",
        "depend",
        "deposit",
        "depth",
        "deputy",
        "derive",
        "describe",
        "desert",
        "design",
        "desk",
        "despair",
        "destroy",
        "detail",
        "detect",
        "develop",
        "device",
        "devote",
        "diagram",
        "dial",
        "diamond",
        "diary",
        "dice",
        "diesel",
        "diet",
        "differ",
        "digital",
        "dignity",
        "dilemma",
        "dinner",
        "dinosaur",
        "direct",
        "dirt",
        "disagree",
        "discover",
        "disease",
        "dish",
        "dismiss",
        "disorder",
        "display",
        "distance",
        "divert",
        "divide",
        "divorce",
        "dizzy",
        "doctor",
        "document",
        "dog",
        "doll",
        "dolphin",
        "domain",
        "donate",
        "donkey",
        "donor",
        "door",
        "dose",
        "double",
        "dove",
        "draft",
        "dragon",
        "drama",
        "drastic",
        "draw",
        "dream",
        "dress",
        "drift",
        "drill",
        "drink",
        "drip",
        "drive",
        "drop",
        "drum",
        "dry",
        "duck",
        "dumb",
        "dune",
        "during",
        "dust",
        "dutch",
        "duty",
        "dwarf",
        "dynamic",
        "eager",
        "eagle",
        "early",
        "earn",
        "earth",
        "easily",
        "east",
        "easy",
        "echo",
        "ecology",
        "economy",
        "edge",
        "edit",
        "educate",
        "effort",
        "egg",
        "eight",
        "either",
        "elbow",
        "elder",
        "electric",
        "elegant",
        "element",
        "elephant",
        "elevator",
        "elite",
        "else",
        "embark",
        "embody",
        "embrace",
        "emerge",
        "emotion",
        "employ",
        "empower",
        "empty",
        "enable",
        "enact",
        "end",
        "endless",
        "endorse",
        "enemy",
        "energy",
        "enforce",
        "engage",
        "engine",
        "enhance",
        "enjoy",
        "enlist",
        "enough",
        "enrich",
        "enroll",
        "ensure",
        "enter",
        "entire",
        "entry",
        "envelope",
        "episode",
        "equal",
        "equip",
        "era",
        "erase",
        "erode",
        "erosion",
        "error",
        "erupt",
        "escape",
        "essay",
        "essence",
        "estate",
        "eternal",
        "ethics",
        "evidence",
        "evil",
        "evoke",
        "evolve",
        "exact",
        "example",
        "excess",
        "exchange",
        "excite",
        "exclude",
        "excuse",
        "execute",
        "exercise",
        "exhaust",
        "exhibit",
        "exile",
        "exist",
        "exit",
        "exotic",
        "expand",
        "expect",
        "expire",
        "explain",
        "expose",
        "express",
        "extend",
        "extra",
        "eye",
        "eyebrow",
        "fabric",
        "face",
        "faculty",
        "fade",
        "faint",
        "faith",
        "fall",
        "false",
        "fame",
        "family",
        "famous",
        "fan",
        "fancy",
        "fantasy",
        "farm",
        "fashion",
        "fat",
        "fatal",
        "father",
        "fatigue",
        "fault",
        "favorite",
        "feature",
        "february",
        "federal",
        "fee",
        "feed",
        "feel",
        "female",
        "fence",
        "festival",
        "fetch",
        "fever",
        "few",
        "fiber",
        "fiction",
        "field",
        "figure",
        "file",
        "film",
        "filter",
        "final",
        "find",
        "fine",
        "finger",
        "finish",
        "fire",
        "firm",
        "first",
        "fiscal",
        "fish",
        "fit",
        "fitness",
        "fix",
        "flag",
        "flame",
        "flash",
        "flat",
        "flavor",
        "flee",
        "flight",
        "flip",
        "float",
        "flock",
        "floor",
        "flower",
        "fluid",
        "flush",
        "fly",
        "foam",
        "focus",
        "fog",
        "foil",
        "fold",
        "follow",
        "food",
        "foot",
        "force",
        "forest",
        "forget",
        "fork",
        "fortune",
        "forum",
        "forward",
        "fossil",
        "foster",
        "found",
        "fox",
        "fragile",
        "frame",
        "frequent",
        "fresh",
        "friend",
        "fringe",
        "frog",
        "front",
        "frost",
        "frown",
        "frozen",
        "fruit",
        "fuel",
        "fun",
        "funny",
        "furnace",
        "fury",
        "future",
        "gadget",
        "gain",
        "galaxy",
        "gallery",
        "game",
        "gap",
        "garage",
        "garbage",
        "garden",
        "garlic",
        "garment",
        "gas",
        "gasp",
        "gate",
        "gather",
        "gauge",
        "gaze",
        "general",
        "genius",
        "genre",
        "gentle",
        "genuine",
        "gesture",
        "ghost",
        "giant",
        "gift",
        "giggle",
        "ginger",
        "giraffe",
        "girl",
        "give",
        "glad",
        "glance",
        "glare",
        "glass",
        "glide",
        "glimpse",
        "globe",
        "gloom",
        "glory",
        "glove",
        "glow",
        "glue",
        "goat",
        "goddess",
        "gold",
        "good",
        "goose",
        "gorilla",
        "gospel",
        "gossip",
        "govern",
        "gown",
        "grab",
        "grace",
        "grain",
        "grant",
        "grape",
        "grass",
        "gravity",
        "great",
        "green",
        "grid",
        "grief",
        "grit",
        "grocery",
        "group",
        "grow",
        "grunt",
        "guard",
        "guess",
        "guide",
        "guilt",
        "guitar",
        "gun",
        "gym",
        "habit",
        "hair",
        "half",
        "hammer",
        "hamster",
        "hand",
        "happy",
        "harbor",
        "hard",
        "harsh",
        "harvest",
        "hat",
        "have",
        "hawk",
        "hazard",
        "head",
        "health",
        "heart",
        "heavy",
        "hedgehog",
        "height",
        "hello",
        "helmet",
        "help",
        "hen",
        "hero",
        "hidden",
        "high",
        "hill",
        "hint",
        "hip",
        "hire",
        "history",
        "hobby",
        "hockey",
        "hold",
        "hole",
        "holiday",
        "hollow",
        "home",
        "honey",
        "hood",
        "hope",
        "horn",
        "horror",
        "horse",
        "hospital",
        "host",
        "hotel",
        "hour",
        "hover",
        "hub",
        "huge",
        "human",
        "humble",
        "humor",
        "hundred",
        "hungry",
        "hunt",
        "hurdle",
        "hurry",
        "hurt",
        "husband",
        "hybrid",
        "ice",
        "icon",
        "idea",
        "identify",
        "idle",
        "ignore",
        "ill",
        "illegal",
        "illness",
        "image",
        "imitate",
        "immense",
        "immune",
        "impact",
        "impose",
        "improve",
        "impulse",
        "inch",
        "include",
        "income",
        "increase",
        "index",
        "indicate",
        "indoor",
        "industry",
        "infant",
        "inflict",
        "inform",
        "inhale",
        "inherit",
        "initial",
        "inject",
        "injury",
        "inmate",
        "inner",
        "innocent",
        "input",
        "inquiry",
        "insane",
        "insect",
        "inside",
        "inspire",
        "install",
        "intact",
        "interest",
        "into",
        "invest",
        "invite",
        "involve",
        "iron",
        "island",
        "isolate",
        "issue",
        "item",
        "ivory",
        "jacket",
        "jaguar",
        "jar",
        "jazz",
        "jealous",
        "jeans",
        "jelly",
        "jewel",
        "job",
        "join",
        "joke",
        "journey",
        "joy",
        "judge",
        "juice",
        "jump",
        "jungle",
        "junior",
        "junk",
        "just",
        "kangaroo",
        "keen",
        "keep",
        "ketchup",
        "key",
        "kick",
        "kid",
        "kidney",
        "kind",
        "kingdom",
        "kiss",
        "kit",
        "kitchen",
        "kite",
        "kitten",
        "kiwi",
        "knee",
        "knife",
        "knock",
        "know",
        "lab",
        "label",
        "labor",
        "ladder",
        "lady",
        "lake",
        "lamp",
        "language",
        "laptop",
        "large",
        "later",
        "latin",
        "laugh",
        "laundry",
        "lava",
        "law",
        "lawn",
        "lawsuit",
        "layer",
        "lazy",
        "leader",
        "leaf",
        "learn",
        "leave",
        "lecture",
        "left",
        "leg",
        "legal",
        "legend",
        "leisure",
        "lemon",
        "lend",
        "length",
        "lens",
        "leopard",
        "lesson",
        "letter",
        "level",
        "liar",
        "liberty",
        "library",
        "license",
        "life",
        "lift",
        "light",
        "like",
        "limb",
        "limit",
        "link",
        "lion",
        "liquid",
        "list",
        "little",
        "live",
        "lizard",
        "load",
        "loan",
        "lobster",
        "local",
        "lock",
        "logic",
        "lonely",
        "long",
        "loop",
        "lottery",
        "loud",
        "lounge",
        "love",
        "loyal",
        "lucky",
        "luggage",
        "lumber",
        "lunar",
        "lunch",
        "luxury",
        "lyrics",
        "machine",
        "mad",
        "magic",
        "magnet",
        "maid",
        "mail",
        "main",
        "major",
        "make",
        "mammal",
        "man",
        "manage",
        "mandate",
        "mango",
        "mansion",
        "manual",
        "maple",
        "marble",
        "march",
        "margin",
        "marine",
        "market",
        "marriage",
        "mask",
        "mass",
        "master",
        "match",
        "material",
        "math",
        "matrix",
        "matter",
        "maximum",
        "maze",
        "meadow",
        "mean",
        "measure",
        "meat",
        "mechanic",
        "medal",
        "media",
        "melody",
        "melt",
        "member",
        "memory",
        "mention",
        "menu",
        "mercy",
        "merge",
        "merit",
        "merry",
        "mesh",
        "message",
        "metal",
        "method",
        "middle",
        "midnight",
        "milk",
        "million",
        "mimic",
        "mind",
        "minimum",
        "minor",
        "minute",
        "miracle",
        "mirror",
        "misery",
        "miss",
        "mistake",
        "mix",
        "mixed",
        "mixture",
        "mobile",
        "model",
        "modify",
        "mom",
        "moment",
        "monitor",
        "monkey",
        "monster",
        "month",
        "moon",
        "moral",
        "more",
        "morning",
        "mosquito",
        "mother",
        "motion",
        "motor",
        "mountain",
        "mouse",
        "move",
        "movie",
        "much",
        "muffin",
        "mule",
        "multiply",
        "muscle",
        "museum",
        "mushroom",
        "music",
        "must",
        "mutual",
        "myself",
        "mystery",
        "myth",
        "naive",
        "name",
        "napkin",
        "narrow",
        "nasty",
        "nation",
        "nature",
        "near",
        "neck",
        "need",
        "negative",
        "neglect",
        "neither",
        "nephew",
        "nerve",
        "nest",
        "net",
        "network",
        "neutral",
        "never",
        "news",
        "next",
        "nice",
        "night",
        "noble",
        "noise",
        "nominee",
        "noodle",
        "normal",
        "north",
        "nose",
        "notable",
        "note",
        "nothing",
        "notice",
        "novel",
        "now",
        "nuclear",
        "number",
        "nurse",
        "nut",
        "oak",
        "obey",
        "object",
        "oblige",
        "obscure",
        "observe",
        "obtain",
        "obvious",
        "occur",
        "ocean",
        "october",
        "odor",
        "off",
        "offer",
        "office",
        "often",
        "oil",
        "okay",
        "old",
        "olive",
        "olympic",
        "omit",
        "once",
        "one",
        "onion",
        "online",
        "only",
        "open",
        "opera",
        "opinion",
        "oppose",
        "option",
        "orange",
        "orbit",
        "orchard",
        "order",
        "ordinary",
        "organ",
        "orient",
        "original",
        "orphan",
        "ostrich",
        "other",
        "outdoor",
        "outer",
        "output",
        "outside",
        "oval",
        "oven",
        "over",
        "own",
        "owner",
        "oxygen",
        "oyster",
        "ozone",
        "pact",
        "paddle",
        "page",
        "pair",
        "palace",
        "palm",
        "panda",
        "panel",
        "panic",
        "panther",
        "paper",
        "parade",
        "parent",
        "park",
        "parrot",
        "party",
        "pass",
        "patch",
        "path",
        "patient",
        "patrol",
        "pattern",
        "pause",
        "pave",
        "payment",
        "peace",
        "peanut",
        "pear",
        "peasant",
        "pelican",
        "pen",
        "penalty",
        "pencil",
        "people",
        "pepper",
        "perfect",
        "permit",
        "person",
        "pet",
        "phone",
        "photo",
        "phrase",
        "physical",
        "piano",
        "picnic",
        "picture",
        "piece",
        "pig",
        "pigeon",
        "pill",
        "pilot",
        "pink",
        "pioneer",
        "pipe",
        "pistol",
        "pitch",
        "pizza",
        "place",
        "planet",
        "plastic",
        "plate",
        "play",
        "please",
        "pledge",
        "pluck",
        "plug",
        "plunge",
        "poem",
        "poet",
        "point",
        "polar",
        "pole",
        "police",
        "pond",
        "pony",
        "pool",
        "popular",
        "portion",
        "position",
        "possible",
        "post",
        "potato",
        "pottery",
        "poverty",
        "powder",
        "power",
        "practice",
        "praise",
        "predict",
        "prefer",
        "prepare",
        "present",
        "pretty",
        "prevent",
        "price",
        "pride",
        "primary",
        "print",
        "priority",
        "prison",
        "private",
        "prize",
        "problem",
        "process",
        "produce",
        "profit",
        "program",
        "project",
        "promote",
        "proof",
        "property",
        "prosper",
        "protect",
        "proud",
        "provide",
        "public",
        "pudding",
        "pull",
        "pulp",
        "pulse",
        "pumpkin",
        "punch",
        "pupil",
        "puppy",
        "purchase",
        "purity",
        "purpose",
        "purse",
        "push",
        "put",
        "puzzle",
        "pyramid",
        "quality",
        "quantum",
        "quarter",
        "question",
        "quick",
        "quit",
        "quiz",
        "quote",
        "rabbit",
        "raccoon",
        "race",
        "rack",
        "radar",
        "radio",
        "rail",
        "rain",
        "raise",
        "rally",
        "ramp",
        "ranch",
        "random",
        "range",
        "rapid",
        "rare",
        "rate",
        "rather",
        "raven",
        "raw",
        "razor",
        "ready",
        "real",
        "reason",
        "rebel",
        "rebuild",
        "recall",
        "receive",
        "recipe",
        "record",
        "recycle",
        "reduce",
        "reflect",
        "reform",
        "refuse",
        "region",
        "regret",
        "regular",
        "reject",
        "relax",
        "release",
        "relief",
        "rely",
        "remain",
        "remember",
        "remind",
        "remove",
        "render",
        "renew",
        "rent",
        "reopen",
        "repair",
        "repeat",
        "replace",
        "report",
        "require",
        "rescue",
        "resemble",
        "resist",
        "resource",
        "response",
        "result",
        "retire",
        "retreat",
        "return",
        "reunion",
        "reveal",
        "review",
        "reward",
        "rhythm",
        "rib",
        "ribbon",
        "rice",
        "rich",
        "ride",
        "ridge",
        "rifle",
        "right",
        "rigid",
        "ring",
        "riot",
        "ripple",
        "risk",
        "ritual",
        "rival",
        "river",
        "road",
        "roast",
        "robot",
        "robust",
        "rocket",
        "romance",
        "roof",
        "rookie",
        "room",
        "rose",
        "rotate",
        "rough",
        "round",
        "route",
        "royal",
        "rubber",
        "rude",
        "rug",
        "rule",
        "run",
        "runway",
        "rural",
        "sad",
        "saddle",
        "sadness",
        "safe",
        "sail",
        "salad",
        "salmon",
        "salon",
        "salt",
        "salute",
        "same",
        "sample",
        "sand",
        "satisfy",
        "satoshi",
        "sauce",
        "sausage",
        "save",
        "say",
        "scale",
        "scan",
        "scare",
        "scatter",
        "scene",
        "scheme",
        "school",
        "science",
        "scissors",
        "scorpion",
        "scout",
        "scrap",
        "screen",
        "script",
        "scrub",
        "sea",
        "search",
        "season",
        "seat",
        "second",
        "secret",
        "section",
        "security",
        "seed",
        "seek",
        "segment",
        "select",
        "sell",
        "seminar",
        "senior",
        "sense",
        "sentence",
        "series",
        "service",
        "session",
        "settle",
        "setup",
        "seven",
        "shadow",
        "shaft",
        "shallow",
        "share",
        "shed",
        "shell",
        "sheriff",
        "shield",
        "shift",
        "shine",
        "ship",
        "shiver",
        "shock",
        "shoe",
        "shoot",
        "shop",
        "short",
        "shoulder",
        "shove",
        "shrimp",
        "shrug",
        "shuffle",
        "shy",
        "sibling",
        "sick",
        "side",
        "siege",
        "sight",
        "sign",
        "silent",
        "silk",
        "silly",
        "silver",
        "similar",
        "simple",
        "since",
        "sing",
        "siren",
        "sister",
        "situate",
        "six",
        "size",
        "skate",
        "sketch",
        "ski",
        "skill",
        "skin",
        "skirt",
        "skull",
        "slab",
        "slam",
        "sleep",
        "slender",
        "slice",
        "slide",
        "slight",
        "slim",
        "slogan",
        "slot",
        "slow",
        "slush",
        "small",
        "smart",
        "smile",
        "smoke",
        "smooth",
        "snack",
        "snake",
        "snap",
        "sniff",
        "snow",
        "soap",
        "soccer",
        "social",
        "sock",
        "soda",
        "soft",
        "solar",
        "soldier",
        "solid",
        "solution",
        "solve",
        "someone",
        "song",
        "soon",
        "sorry",
        "sort",
        "soul",
        "sound",
        "soup",
        "source",
        "south",
        "space",
        "spare",
        "spatial",
        "spawn",
        "speak",
        "special",
        "speed",
        "spell",
        "spend",
        "sphere",
        "spice",
        "spider",
        "spike",
        "spin",
        "spirit",
        "split",
        "spoil",
        "sponsor",
        "spoon",
        "sport",
        "spot",
        "spray",
        "spread",
        "spring",
        "spy",
        "square",
        "squeeze",
        "squirrel",
        "stable",
        "stadium",
        "staff",
        "stage",
        "stairs",
        "stamp",
        "stand",
        "start",
        "state",
        "stay",
        "steak",
        "steel",
        "stem",
        "step",
        "stereo",
        "stick",
        "still",
        "sting",
        "stock",
        "stomach",
        "stone",
        "stool",
        "story",
        "stove",
        "strategy",
        "street",
        "strike",
        "strong",
        "struggle",
        "student",
        "stuff",
        "stumble",
        "style",
        "subject",
        "submit",
        "subway",
        "success",
        "such",
        "sudden",
        "suffer",
        "sugar",
        "suggest",
        "suit",
        "summer",
        "sun",
        "sunny",
        "sunset",
        "super",
        "supply",
        "supreme",
        "sure",
        "surface",
        "surge",
        "surprise",
        "surround",
        "survey",
        "suspect",
        "sustain",
        "swallow",
        "swamp",
        "swap",
        "swarm",
        "swear",
        "sweet",
        "swift",
        "swim",
        "swing",
        "switch",
        "sword",
        "symbol",
        "symptom",
        "syrup",
        "system",
        "table",
        "tackle",
        "tag",
        "tail",
        "talent",
        "talk",
        "tank",
        "tape",
        "target",
        "task",
        "taste",
        "tattoo",
        "taxi",
        "teach",
        "team",
        "tell",
        "ten",
        "tenant",
        "tennis",
        "tent",
        "term",
        "test",
        "text",
        "thank",
        "that",
        "theme",
        "then",
        "theory",
        "there",
        "they",
        "thing",
        "this",
        "thought",
        "three",
        "thrive",
        "throw",
        "thumb",
        "thunder",
        "ticket",
        "tide",
        "tiger",
        "tilt",
        "timber",
        "time",
        "tiny",
        "tip",
        "tired",
        "tissue",
        "title",
        "toast",
        "tobacco",
        "today",
        "toddler",
        "toe",
        "together",
        "toilet",
        "token",
        "tomato",
        "tomorrow",
        "tone",
        "tongue",
        "tonight",
        "tool",
        "tooth",
        "top",
        "topic",
        "topple",
        "torch",
        "tornado",
        "tortoise",
        "toss",
        "total",
        "tourist",
        "toward",
        "tower",
        "town",
        "toy",
        "track",
        "trade",
        "traffic",
        "tragic",
        "train",
        "transfer",
        "trap",
        "trash",
        "travel",
        "tray",
        "treat",
        "tree",
        "trend",
        "trial",
        "tribe",
        "trick",
        "trigger",
        "trim",
        "trip",
        "trophy",
        "trouble",
        "truck",
        "true",
        "truly",
        "trumpet",
        "trust",
        "truth",
        "try",
        "tube",
        "tuition",
        "tumble",
        "tuna",
        "tunnel",
        "turkey",
        "turn",
        "turtle",
        "twelve",
        "twenty",
        "twice",
        "twin",
        "twist",
        "two",
        "type",
        "typical",
        "ugly",
        "umbrella",
        "unable",
        "unaware",
        "uncle",
        "uncover",
        "under",
        "undo",
        "unfair",
        "unfold",
        "unhappy",
        "uniform",
        "unique",
        "unit",
        "universe",
        "unknown",
        "unlock",
        "until",
        "unusual",
        "unveil",
        "update",
        "upgrade",
        "uphold",
        "upon",
        "upper",
        "upset",
        "urban",
        "urge",
        "usage",
        "use",
        "used",
        "useful",
        "useless",
        "usual",
        "utility",
        "vacant",
        "vacuum",
        "vague",
        "valid",
        "valley",
        "valve",
        "van",
        "vanish",
        "vapor",
        "various",
        "vast",
        "vault",
        "vehicle",
        "velvet",
        "vendor",
        "venture",
        "venue",
        "verb",
        "verify",
        "version",
        "very",
        "vessel",
        "veteran",
        "viable",
        "vibrant",
        "vicious",
        "victory",
        "video",
        "view",
        "village",
        "vintage",
        "violin",
        "virtual",
        "virus",
        "visa",
        "visit",
        "visual",
        "vital",
        "vivid",
        "vocal",
        "voice",
        "void",
        "volcano",
        "volume",
        "vote",
        "voyage",
        "wage",
        "wagon",
        "wait",
        "walk",
        "wall",
        "walnut",
        "want",
        "warfare",
        "warm",
        "warrior",
        "wash",
        "wasp",
        "waste",
        "water",
        "wave",
        "way",
        "wealth",
        "weapon",
        "wear",
        "weasel",
        "weather",
        "web",
        "wedding",
        "weekend",
        "weird",
        "welcome",
        "west",
        "wet",
        "whale",
        "what",
        "wheat",
        "wheel",
        "when",
        "where",
        "whip",
        "whisper",
        "wide",
        "width",
        "wife",
        "wild",
        "will",
        "win",
        "window",
        "wine",
        "wing",
        "wink",
        "winner",
        "winter",
        "wire",
        "wisdom",
        "wise",
        "wish",
        "witness",
        "wolf",
        "woman",
        "wonder",
        "wood",
        "wool",
        "word",
        "work",
        "world",
        "worry",
        "worth",
        "wrap",
        "wreck",
        "wrestle",
        "wrist",
        "write",
        "wrong",
        "yard",
        "year",
        "yellow",
        "you",
        "young",
        "youth",
        "zebra",
        "zero",
        "zone",
        "zoo"
      ];
      function bytesToBitstring(bytes) {
        return Array.from(bytes).map((byte) => byte.toString(2).padStart(8, "0")).join("");
      }
      function deriveChecksumBits(entropy) {
        const entropyLengthBits = entropy.length * 8;
        const checksumLengthBits = entropyLengthBits / 32;
        const hash = (0, sha_1.sha256)(entropy);
        return bytesToBitstring(hash).slice(0, checksumLengthBits);
      }
      function bitstringToByte(bin) {
        return parseInt(bin, 2);
      }
      var allowedEntropyLengths = [16, 20, 24, 28, 32];
      var allowedWordLengths = [12, 15, 18, 21, 24];
      function entropyToMnemonic(entropy) {
        if (allowedEntropyLengths.indexOf(entropy.length) === -1) {
          throw new Error("invalid input length");
        }
        const entropyBits = bytesToBitstring(entropy);
        const checksumBits = deriveChecksumBits(entropy);
        const bits = entropyBits + checksumBits;
        const chunks = bits.match(/(.{11})/g);
        const words = chunks.map((binary) => {
          const index = bitstringToByte(binary);
          return wordlist[index];
        });
        return words.join(" ");
      }
      exports2.entropyToMnemonic = entropyToMnemonic;
      var invalidNumberOfWorks = "Invalid number of words";
      var wordNotInWordlist = "Found word that is not in the wordlist";
      var invalidEntropy = "Invalid entropy";
      var invalidChecksum = "Invalid mnemonic checksum";
      function normalize(str) {
        return str.normalize("NFKD");
      }
      function mnemonicToEntropy(mnemonic) {
        const words = normalize(mnemonic).split(" ");
        if (!allowedWordLengths.includes(words.length)) {
          throw new Error(invalidNumberOfWorks);
        }
        const bits = words.map((word) => {
          const index = wordlist.indexOf(word);
          if (index === -1) {
            throw new Error(wordNotInWordlist);
          }
          return index.toString(2).padStart(11, "0");
        }).join("");
        const dividerIndex = Math.floor(bits.length / 33) * 32;
        const entropyBits = bits.slice(0, dividerIndex);
        const checksumBits = bits.slice(dividerIndex);
        const entropyBytes = entropyBits.match(/(.{1,8})/g).map(bitstringToByte);
        if (entropyBytes.length < 16 || entropyBytes.length > 32 || entropyBytes.length % 4 !== 0) {
          throw new Error(invalidEntropy);
        }
        const entropy = Uint8Array.from(entropyBytes);
        const newChecksum = deriveChecksumBits(entropy);
        if (newChecksum !== checksumBits) {
          throw new Error(invalidChecksum);
        }
        return entropy;
      }
      exports2.mnemonicToEntropy = mnemonicToEntropy;
      var EnglishMnemonic = class {
        constructor(mnemonic) {
          if (!EnglishMnemonic.mnemonicMatcher.test(mnemonic)) {
            throw new Error("Invalid mnemonic format");
          }
          const words = mnemonic.split(" ");
          const allowedWordsLengths = [12, 15, 18, 21, 24];
          if (allowedWordsLengths.indexOf(words.length) === -1) {
            throw new Error(`Invalid word count in mnemonic (allowed: ${allowedWordsLengths} got: ${words.length})`);
          }
          for (const word of words) {
            if (EnglishMnemonic.wordlist.indexOf(word) === -1) {
              throw new Error("Mnemonic contains invalid word");
            }
          }
          mnemonicToEntropy(mnemonic);
          this.data = mnemonic;
        }
        toString() {
          return this.data;
        }
      };
      exports2.EnglishMnemonic = EnglishMnemonic;
      EnglishMnemonic.wordlist = wordlist;
      EnglishMnemonic.mnemonicMatcher = /^[a-z]+( [a-z]+)*$/;
      var Bip39 = class {
        static encode(entropy) {
          return new EnglishMnemonic(entropyToMnemonic(entropy));
        }
        static decode(mnemonic) {
          return mnemonicToEntropy(mnemonic.toString());
        }
        static async mnemonicToSeed(mnemonic, password) {
          const mnemonicBytes = (0, encoding_1.toUtf8)(normalize(mnemonic.toString()));
          const salt = "mnemonic" + (password ? normalize(password) : "");
          const saltBytes = (0, encoding_1.toUtf8)(salt);
          return (0, pbkdf2_1.pbkdf2Sha512)(mnemonicBytes, saltBytes, 2048, 64);
        }
      };
      exports2.Bip39 = Bip39;
    }
  });

  // node_modules/@cosmjs/crypto/build/hmac.js
  var require_hmac3 = __commonJS({
    "node_modules/@cosmjs/crypto/build/hmac.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.Hmac = void 0;
      var Hmac = class {
        constructor(hashFunctionConstructor, originalKey) {
          const blockSize = new hashFunctionConstructor().blockSize;
          this.hash = (data) => new hashFunctionConstructor().update(data).digest();
          let key = originalKey;
          if (key.length > blockSize) {
            key = this.hash(key);
          }
          if (key.length < blockSize) {
            const zeroPadding = new Uint8Array(blockSize - key.length);
            key = new Uint8Array([...key, ...zeroPadding]);
          }
          this.oKeyPad = key.map((keyByte) => keyByte ^ 92);
          this.iKeyPad = key.map((keyByte) => keyByte ^ 54);
          this.messageHasher = new hashFunctionConstructor();
          this.blockSize = blockSize;
          this.update(this.iKeyPad);
        }
        update(data) {
          this.messageHasher.update(data);
          return this;
        }
        digest() {
          const innerHash = this.messageHasher.digest();
          return this.hash(new Uint8Array([...this.oKeyPad, ...innerHash]));
        }
      };
      exports2.Hmac = Hmac;
    }
  });

  // node_modules/@noble/hashes/sha3.js
  var require_sha32 = __commonJS({
    "node_modules/@noble/hashes/sha3.js"(exports2) {
      "use strict";
      var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
        if (k2 === void 0)
          k2 = k;
        Object.defineProperty(o, k2, { enumerable: true, get: function() {
          return m[k];
        } });
      } : function(o, m, k, k2) {
        if (k2 === void 0)
          k2 = k;
        o[k2] = m[k];
      });
      var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
        Object.defineProperty(o, "default", { enumerable: true, value: v });
      } : function(o, v) {
        o["default"] = v;
      });
      var __importStar = exports2 && exports2.__importStar || function(mod2) {
        if (mod2 && mod2.__esModule)
          return mod2;
        var result = {};
        if (mod2 != null) {
          for (var k in mod2)
            if (k !== "default" && Object.prototype.hasOwnProperty.call(mod2, k))
              __createBinding(result, mod2, k);
        }
        __setModuleDefault(result, mod2);
        return result;
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.shake256 = exports2.shake128 = exports2.keccak_512 = exports2.keccak_384 = exports2.keccak_256 = exports2.keccak_224 = exports2.sha3_512 = exports2.sha3_384 = exports2.sha3_256 = exports2.sha3_224 = exports2.Keccak = exports2.keccakP = void 0;
      var u64 = __importStar(require_u64());
      var utils_js_1 = require_utils();
      var [SHA3_PI, SHA3_ROTL, _SHA3_IOTA] = [[], [], []];
      var _0n = BigInt(0);
      var _1n = BigInt(1);
      var _2n = BigInt(2);
      var _7n = BigInt(7);
      var _256n = BigInt(256);
      var _0x71n = BigInt(113);
      for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
        [x, y] = [y, (2 * x + 3 * y) % 5];
        SHA3_PI.push(2 * (5 * y + x));
        SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
        let t = _0n;
        for (let j = 0; j < 7; j++) {
          R = (R << _1n ^ (R >> _7n) * _0x71n) % _256n;
          if (R & _2n)
            t ^= _1n << (_1n << BigInt(j)) - _1n;
        }
        _SHA3_IOTA.push(t);
      }
      var [SHA3_IOTA_H, SHA3_IOTA_L] = u64.split(_SHA3_IOTA, true);
      var rotlH = (h, l, s) => s > 32 ? u64.rotlBH(h, l, s) : u64.rotlSH(h, l, s);
      var rotlL = (h, l, s) => s > 32 ? u64.rotlBL(h, l, s) : u64.rotlSL(h, l, s);
      function keccakP(s, rounds = 24) {
        const B = new Uint32Array(5 * 2);
        for (let round = 24 - rounds; round < 24; round++) {
          for (let x = 0; x < 10; x++)
            B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
          for (let x = 0; x < 10; x += 2) {
            const idx1 = (x + 8) % 10;
            const idx0 = (x + 2) % 10;
            const B0 = B[idx0];
            const B1 = B[idx0 + 1];
            const Th = rotlH(B0, B1, 1) ^ B[idx1];
            const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
            for (let y = 0; y < 50; y += 10) {
              s[x + y] ^= Th;
              s[x + y + 1] ^= Tl;
            }
          }
          let curH = s[2];
          let curL = s[3];
          for (let t = 0; t < 24; t++) {
            const shift = SHA3_ROTL[t];
            const Th = rotlH(curH, curL, shift);
            const Tl = rotlL(curH, curL, shift);
            const PI = SHA3_PI[t];
            curH = s[PI];
            curL = s[PI + 1];
            s[PI] = Th;
            s[PI + 1] = Tl;
          }
          for (let y = 0; y < 50; y += 10) {
            for (let x = 0; x < 10; x++)
              B[x] = s[y + x];
            for (let x = 0; x < 10; x++)
              s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
          }
          s[0] ^= SHA3_IOTA_H[round];
          s[1] ^= SHA3_IOTA_L[round];
        }
        B.fill(0);
      }
      exports2.keccakP = keccakP;
      var Keccak = class extends utils_js_1.Hash {
        constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
          super();
          this.blockLen = blockLen;
          this.suffix = suffix;
          this.outputLen = outputLen;
          this.enableXOF = enableXOF;
          this.rounds = rounds;
          this.pos = 0;
          this.posOut = 0;
          this.finished = false;
          this.destroyed = false;
          (0, utils_js_1.assertNumber)(outputLen);
          if (0 >= this.blockLen || this.blockLen >= 200)
            throw new Error("Sha3 supports only keccak-f1600 function");
          this.state = new Uint8Array(200);
          this.state32 = (0, utils_js_1.u32)(this.state);
        }
        keccak() {
          keccakP(this.state32, this.rounds);
          this.posOut = 0;
          this.pos = 0;
        }
        update(data) {
          if (this.destroyed)
            throw new Error("instance is destroyed");
          if (this.finished)
            throw new Error("digest() was already called");
          const { blockLen, state } = this;
          data = (0, utils_js_1.toBytes)(data);
          const len = data.length;
          for (let pos = 0; pos < len; ) {
            const take = Math.min(blockLen - this.pos, len - pos);
            for (let i = 0; i < take; i++)
              state[this.pos++] ^= data[pos++];
            if (this.pos === blockLen)
              this.keccak();
          }
          return this;
        }
        finish() {
          if (this.finished)
            return;
          this.finished = true;
          const { state, suffix, pos, blockLen } = this;
          state[pos] ^= suffix;
          if ((suffix & 128) !== 0 && pos === blockLen - 1)
            this.keccak();
          state[blockLen - 1] ^= 128;
          this.keccak();
        }
        writeInto(out) {
          if (this.destroyed)
            throw new Error("instance is destroyed");
          if (!(out instanceof Uint8Array))
            throw new Error("Keccak: invalid output buffer");
          this.finish();
          for (let pos = 0, len = out.length; pos < len; ) {
            if (this.posOut >= this.blockLen)
              this.keccak();
            const take = Math.min(this.blockLen - this.posOut, len - pos);
            out.set(this.state.subarray(this.posOut, this.posOut + take), pos);
            this.posOut += take;
            pos += take;
          }
          return out;
        }
        xofInto(out) {
          if (!this.enableXOF)
            throw new Error("XOF is not possible for this instance");
          return this.writeInto(out);
        }
        xof(bytes) {
          (0, utils_js_1.assertNumber)(bytes);
          return this.xofInto(new Uint8Array(bytes));
        }
        digestInto(out) {
          if (out.length < this.outputLen)
            throw new Error("Keccak: invalid output buffer");
          if (this.finished)
            throw new Error("digest() was already called");
          this.finish();
          this.writeInto(out);
          this.destroy();
          return out;
        }
        digest() {
          return this.digestInto(new Uint8Array(this.outputLen));
        }
        destroy() {
          this.destroyed = true;
          this.state.fill(0);
        }
        _cloneInto(to) {
          const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
          to || (to = new Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
          to.state32.set(this.state32);
          to.pos = this.pos;
          to.posOut = this.posOut;
          to.finished = this.finished;
          to.rounds = rounds;
          to.suffix = suffix;
          to.outputLen = outputLen;
          to.enableXOF = enableXOF;
          to.destroyed = this.destroyed;
          return to;
        }
      };
      exports2.Keccak = Keccak;
      var gen = (suffix, blockLen, outputLen) => (0, utils_js_1.wrapConstructor)(() => new Keccak(blockLen, suffix, outputLen));
      exports2.sha3_224 = gen(6, 144, 224 / 8);
      exports2.sha3_256 = gen(6, 136, 256 / 8);
      exports2.sha3_384 = gen(6, 104, 384 / 8);
      exports2.sha3_512 = gen(6, 72, 512 / 8);
      exports2.keccak_224 = gen(1, 144, 224 / 8);
      exports2.keccak_256 = gen(1, 136, 256 / 8);
      exports2.keccak_384 = gen(1, 104, 384 / 8);
      exports2.keccak_512 = gen(1, 72, 512 / 8);
      var genShake = (suffix, blockLen, outputLen) => (0, utils_js_1.wrapConstructorWithOpts)((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen !== void 0 ? opts.dkLen : outputLen, true));
      exports2.shake128 = genShake(31, 168, 128 / 8);
      exports2.shake256 = genShake(31, 136, 256 / 8);
    }
  });

  // node_modules/@cosmjs/crypto/build/keccak.js
  var require_keccak = __commonJS({
    "node_modules/@cosmjs/crypto/build/keccak.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.keccak256 = exports2.Keccak256 = void 0;
      var sha3_1 = require_sha32();
      var utils_1 = require_utils6();
      var Keccak256 = class {
        constructor(firstData) {
          this.blockSize = 512 / 8;
          this.impl = sha3_1.keccak_256.create();
          if (firstData) {
            this.update(firstData);
          }
        }
        update(data) {
          this.impl.update((0, utils_1.toRealUint8Array)(data));
          return this;
        }
        digest() {
          return this.impl.digest();
        }
      };
      exports2.Keccak256 = Keccak256;
      function keccak256(data) {
        return new Keccak256(data).digest();
      }
      exports2.keccak256 = keccak256;
    }
  });

  // node_modules/path-browserify/index.js
  var require_path_browserify = __commonJS({
    "node_modules/path-browserify/index.js"(exports2, module2) {
      "use strict";
      function assertPath(path) {
        if (typeof path !== "string") {
          throw new TypeError("Path must be a string. Received " + JSON.stringify(path));
        }
      }
      function normalizeStringPosix(path, allowAboveRoot) {
        var res = "";
        var lastSegmentLength = 0;
        var lastSlash = -1;
        var dots = 0;
        var code;
        for (var i = 0; i <= path.length; ++i) {
          if (i < path.length)
            code = path.charCodeAt(i);
          else if (code === 47)
            break;
          else
            code = 47;
          if (code === 47) {
            if (lastSlash === i - 1 || dots === 1) {
            } else if (lastSlash !== i - 1 && dots === 2) {
              if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) {
                if (res.length > 2) {
                  var lastSlashIndex = res.lastIndexOf("/");
                  if (lastSlashIndex !== res.length - 1) {
                    if (lastSlashIndex === -1) {
                      res = "";
                      lastSegmentLength = 0;
                    } else {
                      res = res.slice(0, lastSlashIndex);
                      lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
                    }
                    lastSlash = i;
                    dots = 0;
                    continue;
                  }
                } else if (res.length === 2 || res.length === 1) {
                  res = "";
                  lastSegmentLength = 0;
                  lastSlash = i;
                  dots = 0;
                  continue;
                }
              }
              if (allowAboveRoot) {
                if (res.length > 0)
                  res += "/..";
                else
                  res = "..";
                lastSegmentLength = 2;
              }
            } else {
              if (res.length > 0)
                res += "/" + path.slice(lastSlash + 1, i);
              else
                res = path.slice(lastSlash + 1, i);
              lastSegmentLength = i - lastSlash - 1;
            }
            lastSlash = i;
            dots = 0;
          } else if (code === 46 && dots !== -1) {
            ++dots;
          } else {
            dots = -1;
          }
        }
        return res;
      }
      function _format(sep, pathObject) {
        var dir = pathObject.dir || pathObject.root;
        var base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
        if (!dir) {
          return base;
        }
        if (dir === pathObject.root) {
          return dir + base;
        }
        return dir + sep + base;
      }
      var posix = {
        resolve: function resolve() {
          var resolvedPath = "";
          var resolvedAbsolute = false;
          var cwd;
          for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
            var path;
            if (i >= 0)
              path = arguments[i];
            else {
              if (cwd === void 0)
                cwd = process.cwd();
              path = cwd;
            }
            assertPath(path);
            if (path.length === 0) {
              continue;
            }
            resolvedPath = path + "/" + resolvedPath;
            resolvedAbsolute = path.charCodeAt(0) === 47;
          }
          resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
          if (resolvedAbsolute) {
            if (resolvedPath.length > 0)
              return "/" + resolvedPath;
            else
              return "/";
          } else if (resolvedPath.length > 0) {
            return resolvedPath;
          } else {
            return ".";
          }
        },
        normalize: function normalize(path) {
          assertPath(path);
          if (path.length === 0)
            return ".";
          var isAbsolute = path.charCodeAt(0) === 47;
          var trailingSeparator = path.charCodeAt(path.length - 1) === 47;
          path = normalizeStringPosix(path, !isAbsolute);
          if (path.length === 0 && !isAbsolute)
            path = ".";
          if (path.length > 0 && trailingSeparator)
            path += "/";
          if (isAbsolute)
            return "/" + path;
          return path;
        },
        isAbsolute: function isAbsolute(path) {
          assertPath(path);
          return path.length > 0 && path.charCodeAt(0) === 47;
        },
        join: function join() {
          if (arguments.length === 0)
            return ".";
          var joined;
          for (var i = 0; i < arguments.length; ++i) {
            var arg = arguments[i];
            assertPath(arg);
            if (arg.length > 0) {
              if (joined === void 0)
                joined = arg;
              else
                joined += "/" + arg;
            }
          }
          if (joined === void 0)
            return ".";
          return posix.normalize(joined);
        },
        relative: function relative(from, to) {
          assertPath(from);
          assertPath(to);
          if (from === to)
            return "";
          from = posix.resolve(from);
          to = posix.resolve(to);
          if (from === to)
            return "";
          var fromStart = 1;
          for (; fromStart < from.length; ++fromStart) {
            if (from.charCodeAt(fromStart) !== 47)
              break;
          }
          var fromEnd = from.length;
          var fromLen = fromEnd - fromStart;
          var toStart = 1;
          for (; toStart < to.length; ++toStart) {
            if (to.charCodeAt(toStart) !== 47)
              break;
          }
          var toEnd = to.length;
          var toLen = toEnd - toStart;
          var length = fromLen < toLen ? fromLen : toLen;
          var lastCommonSep = -1;
          var i = 0;
          for (; i <= length; ++i) {
            if (i === length) {
              if (toLen > length) {
                if (to.charCodeAt(toStart + i) === 47) {
                  return to.slice(toStart + i + 1);
                } else if (i === 0) {
                  return to.slice(toStart + i);
                }
              } else if (fromLen > length) {
                if (from.charCodeAt(fromStart + i) === 47) {
                  lastCommonSep = i;
                } else if (i === 0) {
                  lastCommonSep = 0;
                }
              }
              break;
            }
            var fromCode = from.charCodeAt(fromStart + i);
            var toCode = to.charCodeAt(toStart + i);
            if (fromCode !== toCode)
              break;
            else if (fromCode === 47)
              lastCommonSep = i;
          }
          var out = "";
          for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
            if (i === fromEnd || from.charCodeAt(i) === 47) {
              if (out.length === 0)
                out += "..";
              else
                out += "/..";
            }
          }
          if (out.length > 0)
            return out + to.slice(toStart + lastCommonSep);
          else {
            toStart += lastCommonSep;
            if (to.charCodeAt(toStart) === 47)
              ++toStart;
            return to.slice(toStart);
          }
        },
        _makeLong: function _makeLong(path) {
          return path;
        },
        dirname: function dirname(path) {
          assertPath(path);
          if (path.length === 0)
            return ".";
          var code = path.charCodeAt(0);
          var hasRoot = code === 47;
          var end = -1;
          var matchedSlash = true;
          for (var i = path.length - 1; i >= 1; --i) {
            code = path.charCodeAt(i);
            if (code === 47) {
              if (!matchedSlash) {
                end = i;
                break;
              }
            } else {
              matchedSlash = false;
            }
          }
          if (end === -1)
            return hasRoot ? "/" : ".";
          if (hasRoot && end === 1)
            return "//";
          return path.slice(0, end);
        },
        basename: function basename(path, ext) {
          if (ext !== void 0 && typeof ext !== "string")
            throw new TypeError('"ext" argument must be a string');
          assertPath(path);
          var start2 = 0;
          var end = -1;
          var matchedSlash = true;
          var i;
          if (ext !== void 0 && ext.length > 0 && ext.length <= path.length) {
            if (ext.length === path.length && ext === path)
              return "";
            var extIdx = ext.length - 1;
            var firstNonSlashEnd = -1;
            for (i = path.length - 1; i >= 0; --i) {
              var code = path.charCodeAt(i);
              if (code === 47) {
                if (!matchedSlash) {
                  start2 = i + 1;
                  break;
                }
              } else {
                if (firstNonSlashEnd === -1) {
                  matchedSlash = false;
                  firstNonSlashEnd = i + 1;
                }
                if (extIdx >= 0) {
                  if (code === ext.charCodeAt(extIdx)) {
                    if (--extIdx === -1) {
                      end = i;
                    }
                  } else {
                    extIdx = -1;
                    end = firstNonSlashEnd;
                  }
                }
              }
            }
            if (start2 === end)
              end = firstNonSlashEnd;
            else if (end === -1)
              end = path.length;
            return path.slice(start2, end);
          } else {
            for (i = path.length - 1; i >= 0; --i) {
              if (path.charCodeAt(i) === 47) {
                if (!matchedSlash) {
                  start2 = i + 1;
                  break;
                }
              } else if (end === -1) {
                matchedSlash = false;
                end = i + 1;
              }
            }
            if (end === -1)
              return "";
            return path.slice(start2, end);
          }
        },
        extname: function extname(path) {
          assertPath(path);
          var startDot = -1;
          var startPart = 0;
          var end = -1;
          var matchedSlash = true;
          var preDotState = 0;
          for (var i = path.length - 1; i >= 0; --i) {
            var code = path.charCodeAt(i);
            if (code === 47) {
              if (!matchedSlash) {
                startPart = i + 1;
                break;
              }
              continue;
            }
            if (end === -1) {
              matchedSlash = false;
              end = i + 1;
            }
            if (code === 46) {
              if (startDot === -1)
                startDot = i;
              else if (preDotState !== 1)
                preDotState = 1;
            } else if (startDot !== -1) {
              preDotState = -1;
            }
          }
          if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
            return "";
          }
          return path.slice(startDot, end);
        },
        format: function format(pathObject) {
          if (pathObject === null || typeof pathObject !== "object") {
            throw new TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject);
          }
          return _format("/", pathObject);
        },
        parse: function parse(path) {
          assertPath(path);
          var ret = { root: "", dir: "", base: "", ext: "", name: "" };
          if (path.length === 0)
            return ret;
          var code = path.charCodeAt(0);
          var isAbsolute = code === 47;
          var start2;
          if (isAbsolute) {
            ret.root = "/";
            start2 = 1;
          } else {
            start2 = 0;
          }
          var startDot = -1;
          var startPart = 0;
          var end = -1;
          var matchedSlash = true;
          var i = path.length - 1;
          var preDotState = 0;
          for (; i >= start2; --i) {
            code = path.charCodeAt(i);
            if (code === 47) {
              if (!matchedSlash) {
                startPart = i + 1;
                break;
              }
              continue;
            }
            if (end === -1) {
              matchedSlash = false;
              end = i + 1;
            }
            if (code === 46) {
              if (startDot === -1)
                startDot = i;
              else if (preDotState !== 1)
                preDotState = 1;
            } else if (startDot !== -1) {
              preDotState = -1;
            }
          }
          if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
            if (end !== -1) {
              if (startPart === 0 && isAbsolute)
                ret.base = ret.name = path.slice(1, end);
              else
                ret.base = ret.name = path.slice(startPart, end);
            }
          } else {
            if (startPart === 0 && isAbsolute) {
              ret.name = path.slice(1, startDot);
              ret.base = path.slice(1, end);
            } else {
              ret.name = path.slice(startPart, startDot);
              ret.base = path.slice(startPart, end);
            }
            ret.ext = path.slice(startDot, end);
          }
          if (startPart > 0)
            ret.dir = path.slice(0, startPart - 1);
          else if (isAbsolute)
            ret.dir = "/";
          return ret;
        },
        sep: "/",
        delimiter: ":",
        win32: null,
        posix: null
      };
      posix.posix = posix;
      module2.exports = posix;
    }
  });

  // esbuild-resolve:path
  var path_exports = {};
  __export(path_exports, {
    default: () => import_path_browserify.default
  });
  var import_path_browserify;
  var init_path = __esm({
    "esbuild-resolve:path"() {
      __reExport(path_exports, __toESM(require_path_browserify()));
      import_path_browserify = __toESM(require_path_browserify());
    }
  });

  // (disabled):fs
  var require_fs = __commonJS({
    "(disabled):fs"() {
    }
  });

  // node_modules/libsodium/dist/modules/libsodium.js
  var require_libsodium = __commonJS({
    "node_modules/libsodium/dist/modules/libsodium.js"(exports2, module2) {
      !function(A) {
        function I(A2) {
          "use strict";
          var I2;
          (I2 = A2) === void 0 && (I2 = {});
          var g = I2;
          typeof g.sodium != "object" && (typeof global == "object" ? g = global : typeof window == "object" && (g = window)), typeof g.sodium == "object" && typeof g.sodium.totalMemory == "number" && (I2.TOTAL_MEMORY = g.sodium.totalMemory);
          var B = I2;
          return I2.ready = new Promise(function(A3, I3) {
            (a = B).onAbort = I3, a.print = function(A4) {
            }, a.printErr = function(A4) {
            }, a.onRuntimeInitialized = function() {
              try {
                a._crypto_secretbox_keybytes(), A3();
              } catch (A4) {
                I3(A4);
              }
            }, a.useBackupModule = function() {
              return new Promise(function(A4, I4) {
                (a2 = {}).onAbort = I4, a2.onRuntimeInitialized = function() {
                  Object.keys(B).forEach(function(A5) {
                    A5 !== "getRandomValue" && delete B[A5];
                  }), Object.keys(a2).forEach(function(A5) {
                    B[A5] = a2[A5];
                  }), A4();
                };
                var g3, C2, Q2, E2, i2, n2, a2 = a2 !== void 0 ? a2 : {}, r2 = Object.assign({}, a2), o2 = [], t2 = typeof window == "object", e2 = typeof importScripts == "function", f2 = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string", c2 = "";
                f2 ? (c2 = e2 ? (init_path(), __toCommonJS(path_exports)).dirname(c2) + "/" : __dirname + "/", n2 = () => {
                  i2 || (E2 = require_fs(), i2 = (init_path(), __toCommonJS(path_exports)));
                }, g3 = function(A5, I5) {
                  var g4 = AA2(A5);
                  return g4 ? I5 ? g4 : g4.toString() : (n2(), A5 = i2.normalize(A5), E2.readFileSync(A5, I5 ? void 0 : "utf8"));
                }, Q2 = (A5) => {
                  var I5 = g3(A5, true);
                  return I5.buffer || (I5 = new Uint8Array(I5)), I5;
                }, C2 = (A5, I5, g4) => {
                  var B2 = AA2(A5);
                  B2 && I5(B2), n2(), A5 = i2.normalize(A5), E2.readFile(A5, function(A6, B3) {
                    A6 ? g4(A6) : I5(B3.buffer);
                  });
                }, process.argv.length > 1 && process.argv[1].replace(/\\/g, "/"), o2 = process.argv.slice(2), typeof module2 != "undefined" && (module2.exports = a2), a2.inspect = function() {
                  return "[Emscripten Module object]";
                }) : (t2 || e2) && (e2 ? c2 = self.location.href : typeof document != "undefined" && document.currentScript && (c2 = document.currentScript.src), c2 = c2.indexOf("blob:") !== 0 ? c2.substr(0, c2.replace(/[?#].*/, "").lastIndexOf("/") + 1) : "", g3 = (A5) => {
                  try {
                    var I5 = new XMLHttpRequest();
                    return I5.open("GET", A5, false), I5.send(null), I5.responseText;
                  } catch (I6) {
                    var g4 = AA2(A5);
                    if (g4)
                      return function(A6) {
                        for (var I7 = [], g5 = 0; g5 < A6.length; g5++) {
                          var B2 = A6[g5];
                          B2 > 255 && (B2 &= 255), I7.push(String.fromCharCode(B2));
                        }
                        return I7.join("");
                      }(g4);
                    throw I6;
                  }
                }, e2 && (Q2 = (A5) => {
                  try {
                    var I5 = new XMLHttpRequest();
                    return I5.open("GET", A5, false), I5.responseType = "arraybuffer", I5.send(null), new Uint8Array(I5.response);
                  } catch (I6) {
                    var g4 = AA2(A5);
                    if (g4)
                      return g4;
                    throw I6;
                  }
                }), C2 = (A5, I5, g4) => {
                  var B2 = new XMLHttpRequest();
                  B2.open("GET", A5, true), B2.responseType = "arraybuffer", B2.onload = () => {
                    if (B2.status == 200 || B2.status == 0 && B2.response)
                      I5(B2.response);
                    else {
                      var C3 = AA2(A5);
                      C3 ? I5(C3.buffer) : g4();
                    }
                  }, B2.onerror = g4, B2.send(null);
                }), a2.print;
                var y2, s2 = a2.printErr || void 0;
                Object.assign(a2, r2), r2 = null, a2.arguments && (o2 = a2.arguments), a2.thisProgram && a2.thisProgram, a2.quit && a2.quit, a2.wasmBinary && (y2 = a2.wasmBinary), a2.noExitRuntime;
                var w2, D2 = { Memory: function(A5) {
                  this.buffer = new ArrayBuffer(65536 * A5.initial);
                }, Module: function(A5) {
                }, Instance: function(A5, I5) {
                  this.exports = function(A6) {
                    for (var I6, g4 = new Uint8Array(123), B2 = 25; B2 >= 0; --B2)
                      g4[48 + B2] = 52 + B2, g4[65 + B2] = B2, g4[97 + B2] = 26 + B2;
                    function C3(A7, I7, B3) {
                      for (var C4, Q3, E3 = 0, i3 = I7, n3 = B3.length, a3 = I7 + (3 * n3 >> 2) - (B3[n3 - 2] == "=") - (B3[n3 - 1] == "="); E3 < n3; E3 += 4)
                        C4 = g4[B3.charCodeAt(E3 + 1)], Q3 = g4[B3.charCodeAt(E3 + 2)], A7[i3++] = g4[B3.charCodeAt(E3)] << 2 | C4 >> 4, i3 < a3 && (A7[i3++] = C4 << 4 | Q3 >> 2), i3 < a3 && (A7[i3++] = Q3 << 6 | g4[B3.charCodeAt(E3 + 3)]);
                    }
                    return g4[43] = 62, g4[47] = 63, function(A7) {
                      var g5 = A7.a, B3 = g5.buffer;
                      g5.grow = function(A8) {
                        A8 |= 0;
                        var C4 = 0 | Mg(), o4 = C4 + A8 | 0;
                        if (C4 < o4 && o4 < 65536) {
                          var t4 = new ArrayBuffer(r3(o4, 65536));
                          new Int8Array(t4).set(Q3), Q3 = new Int8Array(t4), E3 = new Int16Array(t4), i3 = new Int32Array(t4), n3 = new Uint8Array(t4), new Uint16Array(t4), a3 = new Uint32Array(t4), new Float32Array(t4), new Float64Array(t4), B3 = t4, g5.buffer = B3, I6 = n3;
                        }
                        return C4;
                      };
                      var Q3 = new Int8Array(B3), E3 = new Int16Array(B3), i3 = new Int32Array(B3), n3 = new Uint8Array(B3), a3 = (new Uint16Array(B3), new Uint32Array(B3)), r3 = (new Float32Array(B3), new Float64Array(B3), Math.imul), o3 = (Math.fround, Math.abs, Math.clz32), t3 = (Math.min, Math.max, Math.floor, Math.ceil, Math.trunc, Math.sqrt, A7.abort), e3 = A7.b, f3 = A7.c, c3 = A7.d, y3 = A7.e, s3 = 5279280, w3 = 0, D3 = 0, h3 = 0;
                      function p3(A8, I7) {
                        var g6, B4, C4, E4, a4, r4 = 0, o4 = 0, t4 = 0, e4 = 0, f4 = 0, c4 = 0, y4 = 0, w4 = 0, D4 = 0, p4 = 0, u4 = 0, F4 = 0, l4 = 0, _4 = 0, k4 = 0, H4 = 0, G4 = 0, U4 = 0, S4 = 0, b4 = 0, m4 = 0, v4 = 0, M4 = 0, P4 = 0, Y4 = 0, N4 = 0, R4 = 0, d4 = 0, J4 = 0, x4 = 0, L4 = 0, K4 = 0, X4 = 0, T4 = 0, V4 = 0, q4 = 0, z4 = 0, j4 = 0, W4 = 0, O4 = 0, Z4 = 0, $4 = 0, AA4 = 0, IA4 = 0, gA3 = 0, BA3 = 0, CA2 = 0, QA2 = 0, EA2 = 0, iA2 = 0, nA2 = 0, aA2 = 0, rA2 = 0, oA2 = 0, tA2 = 0, eA2 = 0, fA2 = 0, cA2 = 0, yA2 = 0, sA2 = 0, wA2 = 0;
                        for (s3 = q4 = s3 - 256 | 0; j4 = (K4 = X4 << 3) + (q4 + 128 | 0) | 0, IA4 = n3[4 + (K4 = I7 + K4 | 0) | 0] | n3[K4 + 5 | 0] << 8 | n3[K4 + 6 | 0] << 16 | n3[K4 + 7 | 0] << 24, i3[j4 >> 2] = n3[0 | K4] | n3[K4 + 1 | 0] << 8 | n3[K4 + 2 | 0] << 16 | n3[K4 + 3 | 0] << 24, i3[j4 + 4 >> 2] = IA4, (0 | (X4 = X4 + 1 | 0)) != 16; )
                          ;
                        for (g6 = eI(q4, A8, 64), K4 = i3[(I7 = g6) >> 2], X4 = i3[I7 + 4 >> 2], o4 = K4, K4 = (IA4 = i3[I7 + 32 >> 2]) + (q4 = i3[I7 + 128 >> 2]) | 0, I7 = (O4 = i3[I7 + 36 >> 2]) + i3[I7 + 132 >> 2] | 0, I7 = K4 >>> 0 < q4 >>> 0 ? I7 + 1 | 0 : I7, q4 = K4, I7 = I7 + X4 | 0, q4 = I7 = (K4 = o4 + K4 | 0) >>> 0 < q4 >>> 0 ? I7 + 1 | 0 : I7, L4 = pA((X4 = K4) ^ (n3[0 | (K4 = A8 - -64 | 0)] | n3[K4 + 1 | 0] << 8 | n3[K4 + 2 | 0] << 16 | n3[K4 + 3 | 0] << 24) ^ -1377402159, I7 ^ (n3[K4 + 4 | 0] | n3[K4 + 5 | 0] << 8 | n3[K4 + 6 | 0] << 16 | n3[K4 + 7 | 0] << 24) ^ 1359893119, 32), K4 = I7 = h3, I7 = I7 + 1779033703 | 0, o4 = IA4 ^ (j4 = L4 - 205731576 | 0), IA4 = I7 = j4 >>> 0 < 4089235720 ? I7 + 1 | 0 : I7, H4 = pA(o4, O4 ^ I7, 24), O4 = I7 = h3, T4 = K4, o4 = L4, I7 = I7 + q4 | 0, I7 = (I7 = (L4 = H4 + X4 | 0) >>> 0 < X4 >>> 0 ? I7 + 1 | 0 : I7) + (t4 = B4 = i3[g6 + 140 >> 2]) | 0, r4 = pA(o4 ^ (b4 = X4 = (K4 = i3[g6 + 136 >> 2]) + L4 | 0), (p4 = b4 >>> 0 < L4 >>> 0 ? I7 + 1 | 0 : I7) ^ T4, 16), I7 = IA4 + (f4 = h3) | 0, o4 = pA((Y4 = X4 = j4 + r4 | 0) ^ H4, (q4 = Y4 >>> 0 < j4 >>> 0 ? I7 + 1 | 0 : I7) ^ O4, 63), w4 = h3, j4 = i3[g6 + 12 >> 2], X4 = (H4 = i3[g6 + 144 >> 2]) + (IA4 = i3[g6 + 40 >> 2]) | 0, I7 = (gA3 = i3[g6 + 148 >> 2]) + (O4 = i3[g6 + 44 >> 2]) | 0, T4 = X4, I7 = (I7 = X4 >>> 0 < IA4 >>> 0 ? I7 + 1 | 0 : I7) + j4 | 0, I7 = (X4 = X4 + i3[g6 + 8 >> 2] | 0) >>> 0 < T4 >>> 0 ? I7 + 1 | 0 : I7, L4 = pA(X4 ^ (n3[A8 + 72 | 0] | n3[A8 + 73 | 0] << 8 | n3[A8 + 74 | 0] << 16 | n3[A8 + 75 | 0] << 24) ^ 725511199, (n3[A8 + 76 | 0] | n3[A8 + 77 | 0] << 8 | n3[A8 + 78 | 0] << 16 | n3[A8 + 79 | 0] << 24) ^ I7 ^ -1694144372, 32), T4 = pA(u4 = IA4 ^ (j4 = L4 - 2067093701 | 0), O4 ^ (t4 = (IA4 = h3) - ((L4 >>> 0 < 2067093701) + 1150833018 | 0) | 0), 24), G4 = i3[g6 + 156 >> 2], u4 = T4, I7 = I7 + (O4 = h3) | 0, I7 = (I7 = (T4 = X4 + T4 | 0) >>> 0 < X4 >>> 0 ? I7 + 1 | 0 : I7) + G4 | 0, z4 = pA((S4 = X4 = T4 + i3[g6 + 152 >> 2] | 0) ^ L4, (_4 = S4 >>> 0 < T4 >>> 0 ? I7 + 1 | 0 : I7) ^ IA4, 16), I7 = t4 + (v4 = h3) | 0, fA2 = X4 = j4 + z4 | 0, L4 = pA(u4 ^ X4, (j4 = X4 >>> 0 < j4 >>> 0 ? I7 + 1 | 0 : I7) ^ O4, 63), t4 = h3, IA4 = i3[g6 + 20 >> 2], X4 = (U4 = i3[g6 + 160 >> 2]) + (T4 = i3[g6 + 48 >> 2]) | 0, I7 = (QA2 = i3[g6 + 164 >> 2]) + (G4 = i3[g6 + 52 >> 2]) | 0, O4 = X4, I7 = (I7 = X4 >>> 0 < T4 >>> 0 ? I7 + 1 | 0 : I7) + IA4 | 0, nA2 = X4 = X4 + i3[g6 + 16 >> 2] | 0, X4 = X4 >>> 0 < O4 >>> 0 ? I7 + 1 | 0 : I7, k4 = pA(nA2 ^ (n3[A8 + 80 | 0] | n3[A8 + 81 | 0] << 8 | n3[A8 + 82 | 0] << 16 | n3[A8 + 83 | 0] << 24) ^ -79577749, X4 ^ (n3[A8 + 84 | 0] | n3[A8 + 85 | 0] << 8 | n3[A8 + 86 | 0] << 16 | n3[A8 + 87 | 0] << 24) ^ 528734635, 32), IA4 = I7 = h3, I7 = I7 + 1013904242 | 0, u4 = T4 ^ (O4 = k4 - 23791573 | 0), T4 = I7 = O4 >>> 0 < 4271175723 ? I7 + 1 | 0 : I7, I7 = pA(u4, G4 ^ I7, 24), c4 = IA4, C4 = i3[g6 + 172 >> 2], e4 = I7, u4 = k4, k4 = I7, nA2 = I7 + nA2 | 0, I7 = (G4 = h3) + X4 | 0, I7 = (I7 = k4 >>> 0 > nA2 >>> 0 ? I7 + 1 | 0 : I7) + (F4 = C4) | 0, J4 = pA(u4 ^ (F4 = X4 = (IA4 = i3[g6 + 168 >> 2]) + (k4 = nA2) | 0), (M4 = k4 >>> 0 > F4 >>> 0 ? I7 + 1 | 0 : I7) ^ c4, 16), I7 = T4 + (l4 = h3) | 0, G4 = pA(e4 ^ (P4 = X4 = O4 + J4 | 0), (T4 = P4 >>> 0 < O4 >>> 0 ? I7 + 1 | 0 : I7) ^ G4, 63), c4 = h3, k4 = i3[g6 + 28 >> 2], O4 = (X4 = i3[g6 + 176 >> 2]) + (nA2 = i3[g6 + 56 >> 2]) | 0, I7 = (E4 = i3[g6 + 180 >> 2]) + (m4 = i3[g6 + 60 >> 2]) | 0, I7 = (I7 = O4 >>> 0 < nA2 >>> 0 ? I7 + 1 | 0 : I7) + k4 | 0, I7 = (y4 = O4) >>> 0 > (N4 = O4 = y4 + i3[g6 + 24 >> 2] | 0) >>> 0 ? I7 + 1 | 0 : I7, e4 = pA(N4 ^ (n3[A8 + 88 | 0] | n3[A8 + 89 | 0] << 8 | n3[A8 + 90 | 0] << 16 | n3[A8 + 91 | 0] << 24) ^ 327033209, I7 ^ (n3[A8 + 92 | 0] | n3[A8 + 93 | 0] << 8 | n3[A8 + 94 | 0] << 16 | n3[A8 + 95 | 0] << 24) ^ 1541459225, 32), k4 = pA(u4 = nA2 ^ (D4 = (k4 = e4) + 1595750129 | 0), m4 ^ (nA2 = (O4 = h3) - ((k4 >>> 0 < 2699217167) + 1521486533 | 0) | 0), 24), y4 = nA2, u4 = O4, nA2 = i3[g6 + 188 >> 2], d4 = k4, I7 = (m4 = h3) + I7 | 0, I7 = (I7 = (N4 = k4 + N4 | 0) >>> 0 < k4 >>> 0 ? I7 + 1 | 0 : I7) + nA2 | 0, V4 = k4 = (O4 = i3[g6 + 184 >> 2]) + N4 | 0, e4 = pA(k4 ^ e4, (R4 = u4) ^ (u4 = k4 >>> 0 < N4 >>> 0 ? I7 + 1 | 0 : I7), 16), I7 = (I7 = y4) + (y4 = h3) | 0, N4 = k4 = e4 + D4 | 0, D4 = m4, m4 = I7 = k4 >>> 0 < e4 >>> 0 ? I7 + 1 | 0 : I7, R4 = pA(d4 ^ k4, D4 ^ I7, 63), k4 = h3, d4 = L4, I7 = t4 + p4 | 0, I7 = (I7 = (b4 = b4 + L4 | 0) >>> 0 < L4 >>> 0 ? I7 + 1 | 0 : I7) + (D4 = W4 = i3[g6 + 196 >> 2]) | 0, D4 = P4, b4 = pA((P4 = L4 = (CA2 = i3[g6 + 192 >> 2]) + (p4 = b4) | 0) ^ e4, (L4 = p4 >>> 0 > P4 >>> 0 ? I7 + 1 | 0 : I7) ^ y4, 32), I7 = (I7 = T4) + (T4 = h3) | 0, e4 = t4, t4 = I7 = (p4 = D4 + (y4 = b4) | 0) >>> 0 < y4 >>> 0 ? I7 + 1 | 0 : I7, I7 = pA(d4 ^ p4, e4 ^ I7, 24), aA2 = i3[g6 + 204 >> 2], x4 = I7, d4 = y4, e4 = P4, P4 = I7, e4 = e4 + I7 | 0, I7 = (y4 = h3) + L4 | 0, I7 = (I7 = e4 >>> 0 < P4 >>> 0 ? I7 + 1 | 0 : I7) + (D4 = aA2) | 0, Z4 = L4 = (b4 = i3[g6 + 200 >> 2]) + e4 | 0, oA2 = pA(d4 ^ L4, (P4 = e4 >>> 0 > L4 >>> 0 ? I7 + 1 | 0 : I7) ^ T4, 16), I7 = t4 + (e4 = h3) | 0, x4 = pA(x4 ^ (D4 = T4 = p4 + oA2 | 0), (t4 = y4) ^ (y4 = p4 >>> 0 > D4 >>> 0 ? I7 + 1 | 0 : I7), 63), p4 = h3, d4 = G4, I7 = c4 + _4 | 0, I7 = (I7 = (T4 = G4 + S4 | 0) >>> 0 < G4 >>> 0 ? I7 + 1 | 0 : I7) + (t4 = iA2 = i3[g6 + 212 >> 2]) | 0, S4 = pA((t4 = r4) ^ (r4 = T4 = (L4 = i3[g6 + 208 >> 2]) + (G4 = T4) | 0), (G4 = G4 >>> 0 > r4 >>> 0 ? I7 + 1 | 0 : I7) ^ f4, 32), I7 = m4 + (t4 = h3) | 0, T4 = pA(d4 ^ (m4 = T4 = N4 + S4 | 0), (I7 = N4 >>> 0 > m4 >>> 0 ? I7 + 1 | 0 : I7) ^ c4, 24), f4 = I7, _4 = t4, AA4 = i3[g6 + 220 >> 2], $4 = T4, d4 = m4, I7 = (c4 = h3) + G4 | 0, I7 = (I7 = (m4 = r4 + T4 | 0) >>> 0 < T4 >>> 0 ? I7 + 1 | 0 : I7) + (N4 = AA4) | 0, _4 = pA((m4 = T4 = (t4 = i3[g6 + 216 >> 2]) + (G4 = m4) | 0) ^ S4, (N4 = G4 >>> 0 > m4 >>> 0 ? I7 + 1 | 0 : I7) ^ _4, 16), I7 = (r4 = h3) + f4 | 0, rA2 = T4 = d4 + _4 | 0, d4 = pA($4 ^ T4, (G4 = _4 >>> 0 > T4 >>> 0 ? I7 + 1 | 0 : I7) ^ c4, 63), c4 = h3, $4 = R4, I7 = k4 + M4 | 0, I7 = (f4 = F4 + R4 | 0) >>> 0 < F4 >>> 0 ? I7 + 1 | 0 : I7, F4 = f4, I7 = I7 + (S4 = a4 = i3[g6 + 228 >> 2]) | 0, R4 = pA((M4 = f4 = (T4 = i3[g6 + 224 >> 2]) + f4 | 0) ^ z4, (f4 = f4 >>> 0 < F4 >>> 0 ? I7 + 1 | 0 : I7) ^ v4, 32), I7 = (v4 = h3) + q4 | 0, Y4 = F4 = R4 + Y4 | 0, q4 = pA($4 ^ F4, (I7 = F4 >>> 0 < R4 >>> 0 ? I7 + 1 | 0 : I7) ^ k4, 24), F4 = I7, z4 = i3[g6 + 236 >> 2], $4 = q4, I7 = (k4 = h3) + f4 | 0, I7 = (I7 = (M4 = M4 + q4 | 0) >>> 0 < q4 >>> 0 ? I7 + 1 | 0 : I7) + (S4 = z4) | 0, eA2 = pA((M4 = q4 = (BA3 = i3[g6 + 232 >> 2]) + (f4 = M4) | 0) ^ R4, (S4 = v4) ^ (v4 = f4 >>> 0 > M4 >>> 0 ? I7 + 1 | 0 : I7), 16), I7 = (I7 = F4) + (F4 = h3) | 0, k4 = pA($4 ^ (R4 = q4 = (f4 = eA2) + Y4 | 0), (Y4 = f4 >>> 0 > R4 >>> 0 ? I7 + 1 | 0 : I7) ^ k4, 63), f4 = h3, $4 = o4, I7 = w4 + u4 | 0, I7 = (I7 = (S4 = o4 + V4 | 0) >>> 0 < o4 >>> 0 ? I7 + 1 | 0 : I7) + (cA2 = i3[g6 + 244 >> 2]) | 0, I7 = (o4 = (q4 = i3[g6 + 240 >> 2]) + (u4 = S4) | 0) >>> 0 < u4 >>> 0 ? I7 + 1 | 0 : I7, u4 = l4, l4 = I7, S4 = pA(o4 ^ J4, u4 ^ I7, 32), I7 = (I7 = j4) + (j4 = h3) | 0, J4 = u4 = S4 + fA2 | 0, V4 = pA($4 ^ u4, (I7 = u4 >>> 0 < S4 >>> 0 ? I7 + 1 | 0 : I7) ^ w4, 24), w4 = I7, u4 = j4, fA2 = i3[g6 + 252 >> 2], tA2 = V4, EA2 = J4, J4 = S4, I7 = l4 + ($4 = h3) | 0, I7 = (I7 = (S4 = o4 + V4 | 0) >>> 0 < o4 >>> 0 ? I7 + 1 | 0 : I7) + fA2 | 0, I7 = (o4 = (j4 = i3[g6 + 248 >> 2]) + (l4 = S4) | 0) >>> 0 < l4 >>> 0 ? I7 + 1 | 0 : I7, l4 = o4, S4 = u4, u4 = I7, V4 = pA(J4 ^ o4, S4 ^ I7, 16), I7 = (S4 = h3) + w4 | 0, J4 = pA(tA2 ^ (EA2 = o4 = EA2 + (J4 = V4) | 0), (o4 = o4 >>> 0 < J4 >>> 0 ? I7 + 1 | 0 : I7) ^ $4, 63), $4 = I7 = h3, w4 = I7, tA2 = _4, I7 = P4 + cA2 | 0, P4 = _4 = q4 + Z4 | 0, I7 = (I7 = _4 >>> 0 < q4 >>> 0 ? I7 + 1 | 0 : I7) + w4 | 0, Z4 = pA(tA2 ^ (w4 = _4 = _4 + J4 | 0), (_4 = w4 >>> 0 < P4 >>> 0 ? I7 + 1 | 0 : I7) ^ r4, 32), I7 = Y4 + (P4 = h3) | 0, R4 = I7 = (r4 = R4 + Z4 | 0) >>> 0 < R4 >>> 0 ? I7 + 1 | 0 : I7, J4 = pA(J4 ^ r4, $4 ^ I7, 24), $4 = I7 = h3, Y4 = I7, yA2 = J4, I7 = _4 + iA2 | 0, _4 = J4 = w4 + L4 | 0, I7 = (I7 = J4 >>> 0 < w4 >>> 0 ? I7 + 1 | 0 : I7) + Y4 | 0, J4 = Z4, Z4 = w4 = yA2 + _4 | 0, tA2 = pA(J4 ^ w4, (Y4 = P4) ^ (P4 = w4 >>> 0 < _4 >>> 0 ? I7 + 1 | 0 : I7), 16), I7 = R4 + (Y4 = h3) | 0, R4 = I7 = (w4 = r4 + tA2 | 0) >>> 0 < r4 >>> 0 ? I7 + 1 | 0 : I7, J4 = pA(yA2 ^ (r4 = w4), I7 ^ $4, 63), _4 = h3, I7 = p4 + QA2 | 0, I7 = (I7 = (w4 = U4 + x4 | 0) >>> 0 < U4 >>> 0 ? I7 + 1 | 0 : I7) + N4 | 0, U4 = I7 = (w4 = w4 + m4 | 0) >>> 0 < m4 >>> 0 ? I7 + 1 | 0 : I7, N4 = pA(w4 ^ eA2, I7 ^ F4, 32), I7 = (I7 = o4) + (o4 = h3) | 0, I7 = (F4 = (m4 = N4) + EA2 | 0) >>> 0 < m4 >>> 0 ? I7 + 1 | 0 : I7, m4 = p4, p4 = I7, x4 = pA(F4 ^ x4, m4 ^ I7, 24), QA2 = I7 = h3, m4 = I7, $4 = N4, I7 = U4 + W4 | 0, I7 = (I7 = (N4 = w4 + CA2 | 0) >>> 0 < w4 >>> 0 ? I7 + 1 | 0 : I7) + m4 | 0, I7 = (w4 = (U4 = N4) + x4 | 0) >>> 0 < U4 >>> 0 ? I7 + 1 | 0 : I7, U4 = w4, m4 = I7, eA2 = pA($4 ^ w4, I7 ^ o4, 16), I7 = p4 + (N4 = h3) | 0, $4 = o4 = F4 + eA2 | 0, x4 = pA(o4 ^ x4, (w4 = o4 >>> 0 < F4 >>> 0 ? I7 + 1 | 0 : I7) ^ QA2, 63), o4 = h3, I7 = c4 + aA2 | 0, I7 = (I7 = (p4 = b4 + d4 | 0) >>> 0 < b4 >>> 0 ? I7 + 1 | 0 : I7) + v4 | 0, S4 = pA((b4 = p4 = p4 + M4 | 0) ^ V4, (p4 = p4 >>> 0 < M4 >>> 0 ? I7 + 1 | 0 : I7) ^ S4, 32), I7 = y4 + (v4 = h3) | 0, y4 = c4, c4 = I7 = (F4 = D4 + S4 | 0) >>> 0 < D4 >>> 0 ? I7 + 1 | 0 : I7, y4 = pA(F4 ^ d4, y4 ^ I7, 24), D4 = I7 = h3, d4 = y4, I7 = p4 + fA2 | 0, I7 = (I7 = (y4 = b4 + j4 | 0) >>> 0 < j4 >>> 0 ? I7 + 1 | 0 : I7) + D4 | 0, aA2 = p4 = d4 + y4 | 0, EA2 = pA(p4 ^ S4, (b4 = v4) ^ (v4 = p4 >>> 0 < y4 >>> 0 ? I7 + 1 | 0 : I7), 16), I7 = c4 + (M4 = h3) | 0, b4 = p4 = F4 + EA2 | 0, S4 = pA(d4 ^ p4, (c4 = p4 >>> 0 < F4 >>> 0 ? I7 + 1 | 0 : I7) ^ D4, 63), p4 = h3, D4 = k4, I7 = f4 + z4 | 0, I7 = (I7 = (F4 = k4 + BA3 | 0) >>> 0 < k4 >>> 0 ? I7 + 1 | 0 : I7) + u4 | 0, I7 = (k4 = F4 + l4 | 0) >>> 0 < l4 >>> 0 ? I7 + 1 | 0 : I7, l4 = k4, k4 = I7, y4 = pA(l4 ^ oA2, I7 ^ e4, 32), I7 = (I7 = G4) + (G4 = h3) | 0, u4 = F4 = y4 + rA2 | 0, e4 = pA(D4 ^ F4, (I7 = y4 >>> 0 > F4 >>> 0 ? I7 + 1 | 0 : I7) ^ f4, 24), D4 = f4 = h3, F4 = I7, I7 = k4 + E4 | 0, I7 = (I7 = (l4 = l4 + X4 | 0) >>> 0 < X4 >>> 0 ? I7 + 1 | 0 : I7) + f4 | 0, I7 = (k4 = l4 + e4 | 0) >>> 0 < l4 >>> 0 ? I7 + 1 | 0 : I7, f4 = u4, l4 = k4, u4 = k4 ^ y4, y4 = I7, G4 = f4 + (k4 = u4 = pA(u4, I7 ^ G4, 16)) | 0, I7 = (f4 = h3) + F4 | 0, V4 = G4, d4 = pA(G4 ^ e4, (k4 = G4 >>> 0 < k4 >>> 0 ? I7 + 1 | 0 : I7) ^ D4, 63), G4 = h3, D4 = b4, e4 = u4, I7 = P4 + B4 | 0, u4 = F4 = K4 + Z4 | 0, I7 = (I7 = F4 >>> 0 < K4 >>> 0 ? I7 + 1 | 0 : I7) + o4 | 0, I7 = (F4 = F4 + x4 | 0) >>> 0 < u4 >>> 0 ? I7 + 1 | 0 : I7, u4 = f4, f4 = I7, b4 = pA(e4 ^ F4, u4 ^ I7, 32), I7 = (I7 = c4) + (c4 = h3) | 0, P4 = u4 = D4 + b4 | 0, e4 = pA(u4 ^ x4, (I7 = u4 >>> 0 < b4 >>> 0 ? I7 + 1 | 0 : I7) ^ o4, 24), D4 = o4 = h3, u4 = I7, x4 = b4, I7 = f4 + a4 | 0, I7 = (I7 = (b4 = F4 + T4 | 0) >>> 0 < F4 >>> 0 ? I7 + 1 | 0 : I7) + o4 | 0, I7 = (f4 = (F4 = b4) + e4 | 0) >>> 0 < F4 >>> 0 ? I7 + 1 | 0 : I7, F4 = f4, b4 = I7, oA2 = pA(x4 ^ f4, I7 ^ c4, 16), I7 = (I7 = u4) + (u4 = h3) | 0, P4 = o4 = (c4 = oA2) + P4 | 0, QA2 = pA(f4 = o4 ^ e4, (e4 = o4 >>> 0 < c4 >>> 0 ? I7 + 1 | 0 : I7) ^ D4, 63), c4 = h3, I7 = p4 + m4 | 0, I7 = (o4 = U4 + S4 | 0) >>> 0 < U4 >>> 0 ? I7 + 1 | 0 : I7, U4 = o4, I7 = I7 + (f4 = rA2 = i3[g6 + 132 >> 2]) | 0, f4 = I7 = (o4 = (D4 = i3[g6 + 128 >> 2]) + o4 | 0) >>> 0 < U4 >>> 0 ? I7 + 1 | 0 : I7, m4 = pA(o4 ^ tA2, I7 ^ Y4, 32), I7 = (I7 = k4) + (k4 = h3) | 0, Y4 = U4 = m4 + V4 | 0, S4 = pA(U4 ^ S4, (I7 = U4 >>> 0 < m4 >>> 0 ? I7 + 1 | 0 : I7) ^ p4, 24), x4 = p4 = h3, U4 = I7, V4 = m4, I7 = f4 + gA3 | 0, I7 = (I7 = (m4 = o4 + H4 | 0) >>> 0 < o4 >>> 0 ? I7 + 1 | 0 : I7) + p4 | 0, m4 = o4 = (f4 = m4) + S4 | 0, o4 = pA(V4 ^ o4, (p4 = k4) ^ (k4 = o4 >>> 0 < f4 >>> 0 ? I7 + 1 | 0 : I7), 16), I7 = (I7 = U4) + (U4 = h3) | 0, Y4 = p4 = o4 + Y4 | 0, V4 = pA(f4 = p4 ^ S4, (S4 = o4 >>> 0 > p4 >>> 0 ? I7 + 1 | 0 : I7) ^ x4, 63), p4 = h3, Z4 = d4, I7 = v4 + AA4 | 0, v4 = f4 = t4 + aA2 | 0, I7 = (I7 = f4 >>> 0 < t4 >>> 0 ? I7 + 1 | 0 : I7) + G4 | 0, d4 = pA((x4 = f4 = f4 + d4 | 0) ^ eA2, (f4 = f4 >>> 0 < v4 >>> 0 ? I7 + 1 | 0 : I7) ^ N4, 32), I7 = R4 + (v4 = h3) | 0, I7 = r4 >>> 0 > (N4 = r4 + d4 | 0) >>> 0 ? I7 + 1 | 0 : I7, R4 = pA(Z4 ^ (r4 = N4), I7 ^ G4, 24), aA2 = G4 = h3, N4 = I7, tA2 = R4, Z4 = r4, I7 = f4 + nA2 | 0, I7 = (I7 = (r4 = x4 + O4 | 0) >>> 0 < O4 >>> 0 ? I7 + 1 | 0 : I7) + G4 | 0, I7 = r4 >>> 0 > (f4 = r4 + R4 | 0) >>> 0 ? I7 + 1 | 0 : I7, r4 = f4, G4 = v4, v4 = I7, eA2 = pA(f4 ^ d4, G4 ^ I7, 16), I7 = (G4 = h3) + N4 | 0, N4 = f4 = Z4 + (R4 = eA2) | 0, aA2 = pA(tA2 ^ f4, (I7 = f4 >>> 0 < R4 >>> 0 ? I7 + 1 | 0 : I7) ^ aA2, 63), f4 = h3, R4 = I7, x4 = o4, I7 = _4 + C4 | 0, I7 = (I7 = (o4 = J4 + IA4 | 0) >>> 0 < IA4 >>> 0 ? I7 + 1 | 0 : I7) + y4 | 0, I7 = (o4 = o4 + l4 | 0) >>> 0 < l4 >>> 0 ? I7 + 1 | 0 : I7, l4 = o4, y4 = M4, M4 = I7, d4 = pA(o4 ^ EA2, y4 ^ I7, 32), I7 = (o4 = h3) + w4 | 0, Z4 = pA((y4 = d4 + $4 | 0) ^ J4, (I7 = y4 >>> 0 < d4 >>> 0 ? I7 + 1 | 0 : I7) ^ _4, 24), w4 = I7, _4 = o4, J4 = i3[g6 + 156 >> 2], tA2 = y4, I7 = M4 + ($4 = h3) | 0, I7 = (I7 = (y4 = l4 + Z4 | 0) >>> 0 < l4 >>> 0 ? I7 + 1 | 0 : I7) + J4 | 0, l4 = I7 = y4 >>> 0 > (M4 = (o4 = i3[g6 + 152 >> 2]) + y4 | 0) >>> 0 ? I7 + 1 | 0 : I7, EA2 = pA(M4 ^ d4, I7 ^ _4, 16), I7 = (I7 = w4) + (w4 = h3) | 0, d4 = I7 = (y4 = EA2) >>> 0 > (_4 = tA2 + y4 | 0) >>> 0 ? I7 + 1 | 0 : I7, Z4 = pA((y4 = _4) ^ Z4, I7 ^ $4, 63), $4 = I7 = h3, _4 = I7, tA2 = N4, I7 = b4 + AA4 | 0, I7 = (I7 = (N4 = t4 + F4 | 0) >>> 0 < F4 >>> 0 ? I7 + 1 | 0 : I7) + _4 | 0, _4 = F4 = N4 + Z4 | 0, x4 = pA(F4 ^ x4, (b4 = U4) ^ (U4 = F4 >>> 0 < N4 >>> 0 ? I7 + 1 | 0 : I7), 32), I7 = (F4 = h3) + R4 | 0, b4 = I7 = (b4 = x4) >>> 0 > (N4 = tA2 + b4 | 0) >>> 0 ? I7 + 1 | 0 : I7, Z4 = pA(Z4 ^ N4, $4 ^ I7, 24), $4 = I7 = h3, R4 = I7, tA2 = x4, I7 = U4 + W4 | 0, I7 = (I7 = (x4 = _4 + CA2 | 0) >>> 0 < _4 >>> 0 ? I7 + 1 | 0 : I7) + R4 | 0, I7 = (_4 = (U4 = x4) + Z4 | 0) >>> 0 < U4 >>> 0 ? I7 + 1 | 0 : I7, U4 = _4, R4 = F4, F4 = I7, CA2 = pA(tA2 ^ _4, R4 ^ I7, 16), I7 = b4 + (R4 = h3) | 0, I7 = (_4 = N4 + CA2 | 0) >>> 0 < N4 >>> 0 ? I7 + 1 | 0 : I7, N4 = _4, b4 = I7, x4 = pA(_4 ^ Z4, I7 ^ $4, 63), _4 = h3, Z4 = QA2, I7 = c4 + a4 | 0, I7 = (I7 = (W4 = T4 + QA2 | 0) >>> 0 < T4 >>> 0 ? I7 + 1 | 0 : I7) + k4 | 0, k4 = G4, G4 = I7 = m4 >>> 0 > (W4 = m4 + W4 | 0) >>> 0 ? I7 + 1 | 0 : I7, QA2 = pA(W4 ^ eA2, k4 ^ I7, 32), I7 = d4 + (k4 = h3) | 0, I7 = y4 >>> 0 > (m4 = y4 + QA2 | 0) >>> 0 ? I7 + 1 | 0 : I7, y4 = c4, c4 = I7, d4 = pA(Z4 ^ m4, y4 ^ I7, 24), Z4 = I7 = h3, y4 = I7, $4 = d4, I7 = G4 + rA2 | 0, I7 = (I7 = (d4 = D4 + W4 | 0) >>> 0 < D4 >>> 0 ? I7 + 1 | 0 : I7) + y4 | 0, W4 = G4 = $4 + (D4 = d4) | 0, QA2 = pA(G4 ^ QA2, (y4 = G4 >>> 0 < D4 >>> 0 ? I7 + 1 | 0 : I7) ^ k4, 16), I7 = c4 + (D4 = h3) | 0, rA2 = G4 = m4 + QA2 | 0, d4 = pA($4 ^ G4, (k4 = G4 >>> 0 < m4 >>> 0 ? I7 + 1 | 0 : I7) ^ Z4, 63), G4 = h3, Z4 = V4, I7 = p4 + C4 | 0, I7 = (I7 = (c4 = IA4 + V4 | 0) >>> 0 < IA4 >>> 0 ? I7 + 1 | 0 : I7) + v4 | 0, I7 = (c4 = c4 + r4 | 0) >>> 0 < r4 >>> 0 ? I7 + 1 | 0 : I7, r4 = c4, m4 = w4, w4 = I7, V4 = pA(c4 ^ EA2, m4 ^ I7, 32), I7 = e4 + (c4 = h3) | 0, e4 = p4, p4 = I7 = (v4 = P4 + V4 | 0) >>> 0 < P4 >>> 0 ? I7 + 1 | 0 : I7, P4 = pA(Z4 ^ v4, e4 ^ I7, 24), e4 = I7 = h3, $4 = P4, I7 = w4 + gA3 | 0, I7 = (I7 = (P4 = r4 + H4 | 0) >>> 0 < H4 >>> 0 ? I7 + 1 | 0 : I7) + e4 | 0, r4 = V4, V4 = w4 = $4 + P4 | 0, Z4 = pA(r4 ^ w4, (m4 = w4 >>> 0 < P4 >>> 0 ? I7 + 1 | 0 : I7) ^ c4, 16), I7 = p4 + (P4 = h3) | 0, eA2 = w4 = v4 + Z4 | 0, e4 = pA($4 ^ w4, (p4 = w4 >>> 0 < v4 >>> 0 ? I7 + 1 | 0 : I7) ^ e4, 63), w4 = h3, I7 = f4 + fA2 | 0, I7 = (I7 = (c4 = j4 + aA2 | 0) >>> 0 < j4 >>> 0 ? I7 + 1 | 0 : I7) + l4 | 0, v4 = I7 = (c4 = c4 + M4 | 0) >>> 0 < M4 >>> 0 ? I7 + 1 | 0 : I7, r4 = pA(c4 ^ oA2, I7 ^ u4, 32), I7 = S4 + (M4 = h3) | 0, u4 = f4, f4 = I7 = (l4 = Y4 + r4 | 0) >>> 0 < Y4 >>> 0 ? I7 + 1 | 0 : I7, Y4 = pA(l4 ^ aA2, u4 ^ I7, 24), S4 = I7 = h3, u4 = I7, $4 = r4, I7 = v4 + z4 | 0, I7 = (I7 = (r4 = c4 + BA3 | 0) >>> 0 < c4 >>> 0 ? I7 + 1 | 0 : I7) + u4 | 0, u4 = c4 = r4 + Y4 | 0, r4 = pA($4 ^ c4, (v4 = M4) ^ (M4 = c4 >>> 0 < r4 >>> 0 ? I7 + 1 | 0 : I7), 16), I7 = f4 + (v4 = h3) | 0, aA2 = c4 = l4 + r4 | 0, Y4 = pA(c4 ^ Y4, (f4 = c4 >>> 0 < l4 >>> 0 ? I7 + 1 | 0 : I7) ^ S4, 63), c4 = h3, I7 = F4 + iA2 | 0, I7 = (I7 = (l4 = U4 + L4 | 0) >>> 0 < U4 >>> 0 ? I7 + 1 | 0 : I7) + G4 | 0, l4 = U4 = (F4 = l4) + d4 | 0, r4 = pA(U4 ^ r4, (S4 = v4) ^ (v4 = F4 >>> 0 > U4 >>> 0 ? I7 + 1 | 0 : I7), 32), I7 = (I7 = p4) + (p4 = h3) | 0, F4 = G4, G4 = I7 = r4 >>> 0 > (U4 = r4 + eA2 | 0) >>> 0 ? I7 + 1 | 0 : I7, S4 = pA(U4 ^ d4, F4 ^ I7, 24), d4 = I7 = h3, F4 = I7, I7 = v4 + cA2 | 0, I7 = (I7 = (l4 = l4 + q4 | 0) >>> 0 < q4 >>> 0 ? I7 + 1 | 0 : I7) + F4 | 0, oA2 = v4 = l4 + S4 | 0, eA2 = pA(v4 ^ r4, (F4 = v4 >>> 0 < l4 >>> 0 ? I7 + 1 | 0 : I7) ^ p4, 16), I7 = G4 + (l4 = h3) | 0, $4 = p4 = U4 + eA2 | 0, S4 = pA(p4 ^ S4, (G4 = p4 >>> 0 < U4 >>> 0 ? I7 + 1 | 0 : I7) ^ d4, 63), p4 = h3, d4 = e4, I7 = y4 + J4 | 0, I7 = (I7 = (v4 = o4 + W4 | 0) >>> 0 < o4 >>> 0 ? I7 + 1 | 0 : I7) + w4 | 0, e4 = pA((y4 = v4 = (U4 = v4) + e4 | 0) ^ CA2, (v4 = y4 >>> 0 < U4 >>> 0 ? I7 + 1 | 0 : I7) ^ R4, 32), I7 = (I7 = f4) + (f4 = h3) | 0, R4 = pA(d4 ^ (r4 = U4 = e4 + aA2 | 0), (I7 = e4 >>> 0 > r4 >>> 0 ? I7 + 1 | 0 : I7) ^ w4, 24), d4 = w4 = h3, U4 = I7, W4 = R4, I7 = v4 + E4 | 0, I7 = (I7 = (y4 = y4 + X4 | 0) >>> 0 < X4 >>> 0 ? I7 + 1 | 0 : I7) + w4 | 0, I7 = y4 >>> 0 > (v4 = y4 + R4 | 0) >>> 0 ? I7 + 1 | 0 : I7, w4 = r4, r4 = (y4 = v4) ^ e4, e4 = I7, r4 = pA(r4, I7 ^ f4, 16), I7 = (R4 = h3) + U4 | 0, f4 = pA(W4 ^ (EA2 = w4 = w4 + r4 | 0), (w4 = w4 >>> 0 < r4 >>> 0 ? I7 + 1 | 0 : I7) ^ d4, 63), v4 = h3, W4 = Y4, I7 = m4 + nA2 | 0, m4 = U4 = O4 + V4 | 0, I7 = (I7 = U4 >>> 0 < O4 >>> 0 ? I7 + 1 | 0 : I7) + c4 | 0, d4 = pA((Y4 = U4 = U4 + Y4 | 0) ^ QA2, (U4 = U4 >>> 0 < m4 >>> 0 ? I7 + 1 | 0 : I7) ^ D4, 32), I7 = b4 + (m4 = h3) | 0, b4 = D4 = N4 + d4 | 0, D4 = pA(W4 ^ D4, (I7 = D4 >>> 0 < N4 >>> 0 ? I7 + 1 | 0 : I7) ^ c4, 24), W4 = c4 = h3, N4 = I7, V4 = b4, I7 = U4 + B4 | 0, I7 = (I7 = (b4 = Y4 + K4 | 0) >>> 0 < K4 >>> 0 ? I7 + 1 | 0 : I7) + c4 | 0, I7 = (U4 = b4 + D4 | 0) >>> 0 < b4 >>> 0 ? I7 + 1 | 0 : I7, b4 = U4, c4 = m4, m4 = I7, tA2 = pA(U4 ^ d4, c4 ^ I7, 16), I7 = (I7 = N4) + (N4 = h3) | 0, d4 = pA((c4 = V4 + (U4 = tA2) | 0) ^ D4, (I7 = c4 >>> 0 < U4 >>> 0 ? I7 + 1 | 0 : I7) ^ W4, 63), U4 = h3, D4 = c4, Y4 = I7, I7 = _4 + M4 | 0, M4 = c4 = u4 + x4 | 0, I7 = (I7 = c4 >>> 0 < u4 >>> 0 ? I7 + 1 | 0 : I7) + (W4 = i3[g6 + 204 >> 2]) | 0, M4 = I7 = (c4 = (CA2 = i3[g6 + 200 >> 2]) + c4 | 0) >>> 0 < M4 >>> 0 ? I7 + 1 | 0 : I7, P4 = pA(c4 ^ Z4, I7 ^ P4, 32), I7 = (I7 = k4) + (k4 = h3) | 0, x4 = pA((u4 = P4 + rA2 | 0) ^ x4, (I7 = u4 >>> 0 < P4 >>> 0 ? I7 + 1 | 0 : I7) ^ _4, 24), _4 = I7, QA2 = i3[g6 + 164 >> 2], rA2 = u4, I7 = M4 + (aA2 = h3) | 0, I7 = (I7 = (u4 = c4 + x4 | 0) >>> 0 < c4 >>> 0 ? I7 + 1 | 0 : I7) + QA2 | 0, M4 = c4 = (V4 = i3[g6 + 160 >> 2]) + u4 | 0, u4 = I7 = c4 >>> 0 < u4 >>> 0 ? I7 + 1 | 0 : I7, Z4 = pA(c4 ^ P4, I7 ^ k4, 16), I7 = (P4 = h3) + _4 | 0, x4 = pA((rA2 = c4 = rA2 + (k4 = Z4) | 0) ^ x4, (c4 = c4 >>> 0 < k4 >>> 0 ? I7 + 1 | 0 : I7) ^ aA2, 63), aA2 = I7 = h3, k4 = I7, I7 = F4 + nA2 | 0, I7 = (I7 = (_4 = O4 + oA2 | 0) >>> 0 < O4 >>> 0 ? I7 + 1 | 0 : I7) + k4 | 0, R4 = pA((k4 = _4 = (F4 = _4) + x4 | 0) ^ r4, (_4 = F4 >>> 0 > k4 >>> 0 ? I7 + 1 | 0 : I7) ^ R4, 32), I7 = (F4 = h3) + Y4 | 0, Y4 = D4 = (r4 = R4) + D4 | 0, x4 = pA(x4 ^ D4, aA2 ^ (I7 = r4 >>> 0 > D4 >>> 0 ? I7 + 1 | 0 : I7), 24), aA2 = D4 = h3, r4 = I7, yA2 = x4, oA2 = R4, I7 = _4 + W4 | 0, I7 = (I7 = (R4 = k4 + CA2 | 0) >>> 0 < k4 >>> 0 ? I7 + 1 | 0 : I7) + D4 | 0, R4 = k4 = (_4 = R4) + x4 | 0, x4 = pA(oA2 ^ k4, (D4 = F4) ^ (F4 = _4 >>> 0 > k4 >>> 0 ? I7 + 1 | 0 : I7), 16), I7 = (D4 = h3) + r4 | 0, aA2 = pA(yA2 ^ (oA2 = k4 = (_4 = x4) + Y4 | 0), (k4 = _4 >>> 0 > k4 >>> 0 ? I7 + 1 | 0 : I7) ^ aA2, 63), _4 = h3, I7 = p4 + J4 | 0, I7 = (I7 = (r4 = o4 + S4 | 0) >>> 0 < o4 >>> 0 ? I7 + 1 | 0 : I7) + e4 | 0, r4 = pA((e4 = o4 = r4 + y4 | 0) ^ tA2, (o4 = o4 >>> 0 < y4 >>> 0 ? I7 + 1 | 0 : I7) ^ N4, 32), I7 = (I7 = c4) + (c4 = h3) | 0, N4 = p4, p4 = I7 = (y4 = r4 + rA2 | 0) >>> 0 < r4 >>> 0 ? I7 + 1 | 0 : I7, Y4 = pA(y4 ^ S4, N4 ^ I7, 24), S4 = I7 = h3, N4 = I7, I7 = o4 + B4 | 0, I7 = (I7 = (e4 = e4 + K4 | 0) >>> 0 < K4 >>> 0 ? I7 + 1 | 0 : I7) + N4 | 0, J4 = o4 = e4 + Y4 | 0, rA2 = pA(o4 ^ r4, (N4 = o4 >>> 0 < e4 >>> 0 ? I7 + 1 | 0 : I7) ^ c4, 16), I7 = p4 + (e4 = h3) | 0, tA2 = o4 = y4 + rA2 | 0, r4 = pA(o4 ^ Y4, (c4 = o4 >>> 0 < y4 >>> 0 ? I7 + 1 | 0 : I7) ^ S4, 63), o4 = h3, Y4 = f4, I7 = v4 + z4 | 0, I7 = (I7 = (p4 = f4 + BA3 | 0) >>> 0 < f4 >>> 0 ? I7 + 1 | 0 : I7) + m4 | 0, f4 = I7 = (p4 = p4 + b4 | 0) >>> 0 < b4 >>> 0 ? I7 + 1 | 0 : I7, y4 = pA(p4 ^ Z4, I7 ^ P4, 32), I7 = (I7 = G4) + (G4 = h3) | 0, b4 = m4 = y4 + $4 | 0, P4 = pA(Y4 ^ m4, (I7 = y4 >>> 0 > m4 >>> 0 ? I7 + 1 | 0 : I7) ^ v4, 24), m4 = I7, S4 = b4, Y4 = y4, I7 = f4 + a4 | 0, f4 = y4 = p4 + T4 | 0, I7 = (I7 = y4 >>> 0 < p4 >>> 0 ? I7 + 1 | 0 : I7) + (v4 = h3) | 0, Z4 = pA(Y4 ^ (y4 = p4 = y4 + P4 | 0), (b4 = y4 >>> 0 < f4 >>> 0 ? I7 + 1 | 0 : I7) ^ G4, 16), I7 = (I7 = m4) + (m4 = h3) | 0, f4 = P4, P4 = G4 = S4 + (p4 = Z4) | 0, Y4 = pA(f4 ^ G4, (p4 = p4 >>> 0 > G4 >>> 0 ? I7 + 1 | 0 : I7) ^ v4, 63), G4 = h3, I7 = U4 + AA4 | 0, I7 = (I7 = (f4 = t4 + d4 | 0) >>> 0 < t4 >>> 0 ? I7 + 1 | 0 : I7) + u4 | 0, l4 = pA((u4 = f4 = f4 + M4 | 0) ^ eA2, (f4 = f4 >>> 0 < M4 >>> 0 ? I7 + 1 | 0 : I7) ^ l4, 32), I7 = (I7 = w4) + (w4 = h3) | 0, M4 = U4, U4 = I7 = (v4 = l4 + EA2 | 0) >>> 0 < l4 >>> 0 ? I7 + 1 | 0 : I7, S4 = pA(v4 ^ d4, M4 ^ I7, 24), d4 = I7 = h3, M4 = I7, z4 = l4, I7 = f4 + cA2 | 0, I7 = (I7 = (l4 = u4 + q4 | 0) >>> 0 < q4 >>> 0 ? I7 + 1 | 0 : I7) + M4 | 0, M4 = f4 = l4 + S4 | 0, u4 = pA(z4 ^ f4, (l4 = f4 >>> 0 < l4 >>> 0 ? I7 + 1 | 0 : I7) ^ w4, 16), I7 = U4 + (f4 = h3) | 0, I7 = (w4 = v4 + u4 | 0) >>> 0 < v4 >>> 0 ? I7 + 1 | 0 : I7, v4 = w4, U4 = I7, S4 = pA(w4 ^ S4, I7 ^ d4, 63), w4 = h3, z4 = P4, d4 = u4, I7 = F4 + gA3 | 0, I7 = (I7 = (u4 = H4 + R4 | 0) >>> 0 < H4 >>> 0 ? I7 + 1 | 0 : I7) + o4 | 0, I7 = (F4 = u4 + r4 | 0) >>> 0 < u4 >>> 0 ? I7 + 1 | 0 : I7, u4 = F4, P4 = f4, f4 = I7, P4 = pA(d4 ^ F4, P4 ^ I7, 32), I7 = (I7 = p4) + (p4 = h3) | 0, R4 = pA((R4 = r4) ^ (r4 = F4 = z4 + P4 | 0), (I7 = r4 >>> 0 < P4 >>> 0 ? I7 + 1 | 0 : I7) ^ o4, 24), d4 = o4 = h3, F4 = I7, I7 = f4 + E4 | 0, I7 = (I7 = (u4 = u4 + X4 | 0) >>> 0 < X4 >>> 0 ? I7 + 1 | 0 : I7) + o4 | 0, I7 = (f4 = u4 + R4 | 0) >>> 0 < u4 >>> 0 ? I7 + 1 | 0 : I7, u4 = f4, o4 = f4 ^ P4, P4 = I7, eA2 = pA(o4, I7 ^ p4, 16), I7 = (I7 = F4) + (F4 = h3) | 0, r4 = o4 = (p4 = eA2) + r4 | 0, d4 = pA(f4 = o4 ^ R4, (R4 = o4 >>> 0 < p4 >>> 0 ? I7 + 1 | 0 : I7) ^ d4, 63), f4 = h3, z4 = Y4, I7 = N4 + C4 | 0, p4 = o4 = J4 + IA4 | 0, I7 = (I7 = o4 >>> 0 < IA4 >>> 0 ? I7 + 1 | 0 : I7) + G4 | 0, D4 = pA((Y4 = o4 = o4 + Y4 | 0) ^ x4, (o4 = o4 >>> 0 < p4 >>> 0 ? I7 + 1 | 0 : I7) ^ D4, 32), I7 = U4 + (p4 = h3) | 0, N4 = pA(z4 ^ (U4 = N4 = v4 + D4 | 0), (I7 = v4 >>> 0 > U4 >>> 0 ? I7 + 1 | 0 : I7) ^ G4, 24), x4 = G4 = h3, v4 = I7, J4 = N4, z4 = U4, I7 = o4 + iA2 | 0, I7 = (I7 = (U4 = Y4 + L4 | 0) >>> 0 < L4 >>> 0 ? I7 + 1 | 0 : I7) + G4 | 0, N4 = o4 = U4 + N4 | 0, G4 = pA(G4 = o4 ^ D4, (D4 = o4 >>> 0 < U4 >>> 0 ? I7 + 1 | 0 : I7) ^ p4, 16), I7 = (U4 = h3) + v4 | 0, $4 = o4 = z4 + G4 | 0, z4 = pA(J4 ^ o4, (p4 = o4 >>> 0 < G4 >>> 0 ? I7 + 1 | 0 : I7) ^ x4, 63), v4 = h3, Y4 = S4, I7 = b4 + QA2 | 0, I7 = (o4 = y4 + V4 | 0) >>> 0 < y4 >>> 0 ? I7 + 1 | 0 : I7, y4 = o4, I7 = I7 + w4 | 0, I7 = (o4 = o4 + S4 | 0) >>> 0 < y4 >>> 0 ? I7 + 1 | 0 : I7, y4 = o4, b4 = I7, S4 = pA(o4 ^ rA2, I7 ^ e4, 32), I7 = (o4 = h3) + k4 | 0, x4 = e4 = S4 + oA2 | 0, Y4 = pA(Y4 ^ e4, (I7 = e4 >>> 0 < S4 >>> 0 ? I7 + 1 | 0 : I7) ^ w4, 24), k4 = I7, e4 = o4, BA3 = i3[g6 + 132 >> 2], J4 = Y4, I7 = b4 + (w4 = h3) | 0, I7 = (I7 = (Y4 = y4 + Y4 | 0) >>> 0 < y4 >>> 0 ? I7 + 1 | 0 : I7) + BA3 | 0, b4 = I7 = (y4 = (o4 = i3[g6 + 128 >> 2]) + (b4 = Y4) | 0) >>> 0 < b4 >>> 0 ? I7 + 1 | 0 : I7, oA2 = pA(y4 ^ S4, I7 ^ e4, 16), I7 = (e4 = h3) + k4 | 0, J4 = pA(J4 ^ (Y4 = (S4 = oA2) + x4 | 0), (I7 = S4 >>> 0 > Y4 >>> 0 ? I7 + 1 | 0 : I7) ^ w4, 63), k4 = h3, S4 = I7, x4 = G4, I7 = _4 + fA2 | 0, I7 = (I7 = (G4 = j4 + aA2 | 0) >>> 0 < j4 >>> 0 ? I7 + 1 | 0 : I7) + l4 | 0, m4 = pA((w4 = G4 = G4 + M4 | 0) ^ Z4, (M4 = w4 >>> 0 < M4 >>> 0 ? I7 + 1 | 0 : I7) ^ m4, 32), I7 = (G4 = h3) + c4 | 0, Z4 = pA((l4 = m4 + tA2 | 0) ^ aA2, (I7 = l4 >>> 0 < m4 >>> 0 ? I7 + 1 | 0 : I7) ^ _4, 24), c4 = I7, _4 = G4, aA2 = i3[g6 + 196 >> 2], tA2 = Z4, EA2 = l4, I7 = M4 + (rA2 = h3) | 0, I7 = (I7 = (l4 = w4 + Z4 | 0) >>> 0 < w4 >>> 0 ? I7 + 1 | 0 : I7) + aA2 | 0, M4 = w4 = (G4 = i3[g6 + 192 >> 2]) + l4 | 0, l4 = I7 = w4 >>> 0 < l4 >>> 0 ? I7 + 1 | 0 : I7, Z4 = pA(w4 ^ m4, I7 ^ _4, 16), I7 = (I7 = c4) + (c4 = h3) | 0, m4 = pA(tA2 ^ (EA2 = w4 = EA2 + (_4 = Z4) | 0), (w4 = w4 >>> 0 < _4 >>> 0 ? I7 + 1 | 0 : I7) ^ rA2, 63), rA2 = I7 = h3, _4 = I7, tA2 = Y4, I7 = P4 + W4 | 0, I7 = (I7 = (Y4 = u4 + CA2 | 0) >>> 0 < u4 >>> 0 ? I7 + 1 | 0 : I7) + _4 | 0, I7 = (u4 = (P4 = Y4) + m4 | 0) >>> 0 < P4 >>> 0 ? I7 + 1 | 0 : I7, P4 = u4, _4 = I7, Y4 = pA(u4 ^ x4, I7 ^ U4, 32), I7 = (U4 = h3) + S4 | 0, S4 = u4 = tA2 + Y4 | 0, x4 = pA(m4 ^ u4, rA2 ^ (I7 = u4 >>> 0 < Y4 >>> 0 ? I7 + 1 | 0 : I7), 24), W4 = m4 = h3, u4 = I7, I7 = _4 + BA3 | 0, I7 = (I7 = (P4 = o4 + P4 | 0) >>> 0 < o4 >>> 0 ? I7 + 1 | 0 : I7) + m4 | 0, CA2 = _4 = P4 + x4 | 0, rA2 = pA(_4 ^ Y4, (m4 = _4 >>> 0 < P4 >>> 0 ? I7 + 1 | 0 : I7) ^ U4, 16), I7 = (I7 = u4) + (u4 = h3) | 0, P4 = _4 = (U4 = rA2) + S4 | 0, W4 = pA(_4 ^ x4, (Y4 = _4 >>> 0 < U4 >>> 0 ? I7 + 1 | 0 : I7) ^ W4, 63), U4 = h3, I7 = f4 + C4 | 0, I7 = (I7 = (_4 = d4 + IA4 | 0) >>> 0 < IA4 >>> 0 ? I7 + 1 | 0 : I7) + D4 | 0, N4 = I7 = (_4 = _4 + N4 | 0) >>> 0 < N4 >>> 0 ? I7 + 1 | 0 : I7, S4 = pA(_4 ^ oA2, I7 ^ e4, 32), I7 = (I7 = w4) + (w4 = h3) | 0, I7 = (e4 = (D4 = S4) + EA2 | 0) >>> 0 < D4 >>> 0 ? I7 + 1 | 0 : I7, D4 = f4, f4 = I7, x4 = pA(e4 ^ d4, D4 ^ I7, 24), d4 = I7 = h3, D4 = I7, EA2 = S4, I7 = N4 + nA2 | 0, I7 = (I7 = (S4 = _4 + O4 | 0) >>> 0 < _4 >>> 0 ? I7 + 1 | 0 : I7) + D4 | 0, N4 = _4 = S4 + x4 | 0, D4 = I7 = _4 >>> 0 < S4 >>> 0 ? I7 + 1 | 0 : I7, oA2 = pA(EA2 ^ _4, I7 ^ w4, 16), I7 = f4 + (S4 = h3) | 0, EA2 = w4 = e4 + oA2 | 0, x4 = pA(w4 ^ x4, (f4 = w4 >>> 0 < e4 >>> 0 ? I7 + 1 | 0 : I7) ^ d4, 63), w4 = h3, I7 = v4 + gA3 | 0, I7 = (I7 = (_4 = H4 + z4 | 0) >>> 0 < H4 >>> 0 ? I7 + 1 | 0 : I7) + b4 | 0, e4 = c4, c4 = I7 = y4 >>> 0 > (_4 = y4 + _4 | 0) >>> 0 ? I7 + 1 | 0 : I7, d4 = pA(_4 ^ Z4, e4 ^ I7, 32), I7 = R4 + (y4 = h3) | 0, I7 = r4 >>> 0 > (b4 = r4 + d4 | 0) >>> 0 ? I7 + 1 | 0 : I7, r4 = v4, v4 = I7, r4 = pA(b4 ^ z4, r4 ^ I7, 24), R4 = I7 = h3, e4 = I7, Z4 = r4, I7 = c4 + QA2 | 0, I7 = (I7 = (r4 = _4 + V4 | 0) >>> 0 < _4 >>> 0 ? I7 + 1 | 0 : I7) + e4 | 0, _4 = d4, d4 = c4 = Z4 + r4 | 0, z4 = pA(_4 ^ c4, (e4 = y4) ^ (y4 = c4 >>> 0 < r4 >>> 0 ? I7 + 1 | 0 : I7), 16), I7 = v4 + (e4 = h3) | 0, b4 = pA(Z4 ^ (r4 = c4 = b4 + z4 | 0), (_4 = r4 >>> 0 < b4 >>> 0 ? I7 + 1 | 0 : I7) ^ R4, 63), c4 = h3, I7 = k4 + iA2 | 0, I7 = (I7 = (v4 = L4 + J4 | 0) >>> 0 < L4 >>> 0 ? I7 + 1 | 0 : I7) + l4 | 0, I7 = (v4 = v4 + M4 | 0) >>> 0 < M4 >>> 0 ? I7 + 1 | 0 : I7, M4 = v4, v4 = I7, l4 = pA(M4 ^ eA2, I7 ^ F4, 32), I7 = (I7 = p4) + (p4 = h3) | 0, R4 = F4 = l4 + $4 | 0, J4 = pA(F4 ^ J4, (I7 = F4 >>> 0 < l4 >>> 0 ? I7 + 1 | 0 : I7) ^ k4, 24), QA2 = k4 = h3, F4 = I7, I7 = v4 + fA2 | 0, I7 = (I7 = (M4 = M4 + j4 | 0) >>> 0 < j4 >>> 0 ? I7 + 1 | 0 : I7) + k4 | 0, M4 = I7 = (v4 = M4 + J4 | 0) >>> 0 < M4 >>> 0 ? I7 + 1 | 0 : I7, k4 = (p4 = l4 = pA(v4 ^ l4, I7 ^ p4, 16)) + R4 | 0, I7 = (I7 = F4) + (F4 = h3) | 0, R4 = J4, J4 = k4, R4 = pA(R4 ^ k4, (p4 = p4 >>> 0 > k4 >>> 0 ? I7 + 1 | 0 : I7) ^ QA2, 63), k4 = h3, Z4 = r4, V4 = l4, I7 = m4 + cA2 | 0, m4 = l4 = q4 + CA2 | 0, I7 = (I7 = l4 >>> 0 < q4 >>> 0 ? I7 + 1 | 0 : I7) + w4 | 0, I7 = (l4 = l4 + x4 | 0) >>> 0 < m4 >>> 0 ? I7 + 1 | 0 : I7, m4 = l4, r4 = F4, F4 = I7, r4 = pA(V4 ^ l4, r4 ^ I7, 32), I7 = (I7 = _4) + (_4 = h3) | 0, V4 = x4, x4 = l4 = Z4 + r4 | 0, CA2 = pA(V4 ^ l4, (I7 = r4 >>> 0 > l4 >>> 0 ? I7 + 1 | 0 : I7) ^ w4, 24), QA2 = w4 = h3, l4 = I7, I7 = F4 + B4 | 0, I7 = (I7 = (m4 = m4 + K4 | 0) >>> 0 < K4 >>> 0 ? I7 + 1 | 0 : I7) + w4 | 0, V4 = F4 = m4 + CA2 | 0, Z4 = pA(F4 ^ r4, (w4 = _4) ^ (_4 = F4 >>> 0 < m4 >>> 0 ? I7 + 1 | 0 : I7), 16), I7 = (F4 = h3) + l4 | 0, l4 = w4 = (m4 = Z4) + x4 | 0, CA2 = pA(w4 ^ CA2, (m4 = w4 >>> 0 < m4 >>> 0 ? I7 + 1 | 0 : I7) ^ QA2, 63), w4 = h3, x4 = b4, I7 = D4 + AA4 | 0, I7 = (I7 = (b4 = t4 + N4 | 0) >>> 0 < N4 >>> 0 ? I7 + 1 | 0 : I7) + c4 | 0, r4 = pA((D4 = N4 = x4 + b4 | 0) ^ rA2, (r4 = u4) ^ (u4 = b4 >>> 0 > D4 >>> 0 ? I7 + 1 | 0 : I7), 32), I7 = (I7 = p4) + (p4 = h3) | 0, b4 = c4, c4 = I7 = r4 >>> 0 > (N4 = r4 + J4 | 0) >>> 0 ? I7 + 1 | 0 : I7, x4 = pA(x4 ^ N4, b4 ^ I7, 24), J4 = I7 = h3, b4 = I7, I7 = u4 + a4 | 0, I7 = (I7 = (D4 = D4 + T4 | 0) >>> 0 < T4 >>> 0 ? I7 + 1 | 0 : I7) + b4 | 0, b4 = I7 = (u4 = D4 + x4 | 0) >>> 0 < D4 >>> 0 ? I7 + 1 | 0 : I7, p4 = pA(u4 ^ r4, I7 ^ p4, 16), I7 = c4 + (D4 = h3) | 0, I7 = (r4 = N4 + p4 | 0) >>> 0 < N4 >>> 0 ? I7 + 1 | 0 : I7, N4 = r4, r4 = I7, J4 = pA(N4 ^ x4, I7 ^ J4, 63), c4 = h3, $4 = R4, I7 = y4 + E4 | 0, I7 = (I7 = (R4 = d4 + X4 | 0) >>> 0 < X4 >>> 0 ? I7 + 1 | 0 : I7) + k4 | 0, d4 = pA((x4 = y4 = $4 + R4 | 0) ^ oA2, (y4 = y4 >>> 0 < R4 >>> 0 ? I7 + 1 | 0 : I7) ^ S4, 32), I7 = Y4 + (R4 = h3) | 0, Y4 = k4, k4 = I7 = (S4 = P4 + d4 | 0) >>> 0 < P4 >>> 0 ? I7 + 1 | 0 : I7, S4 = pA($4 ^ (P4 = S4), Y4 ^ I7, 24), QA2 = I7 = h3, Y4 = I7, $4 = S4, I7 = y4 + aA2 | 0, I7 = (I7 = (S4 = G4 + x4 | 0) >>> 0 < G4 >>> 0 ? I7 + 1 | 0 : I7) + Y4 | 0, Y4 = R4, R4 = I7 = (y4 = $4 + S4 | 0) >>> 0 < S4 >>> 0 ? I7 + 1 | 0 : I7, oA2 = pA(y4 ^ d4, Y4 ^ I7, 16), I7 = k4 + (Y4 = h3) | 0, I7 = (S4 = P4 + oA2 | 0) >>> 0 < P4 >>> 0 ? I7 + 1 | 0 : I7, QA2 = pA($4 ^ (P4 = S4), I7 ^ QA2, 63), k4 = h3, S4 = I7, I7 = U4 + M4 | 0, I7 = (I7 = (d4 = v4 + W4 | 0) >>> 0 < v4 >>> 0 ? I7 + 1 | 0 : I7) + (rA2 = i3[g6 + 156 >> 2]) | 0, M4 = I7 = (v4 = (x4 = i3[g6 + 152 >> 2]) + (M4 = d4) | 0) >>> 0 < M4 >>> 0 ? I7 + 1 | 0 : I7, d4 = pA(v4 ^ z4, I7 ^ e4, 32), I7 = (I7 = f4) + (f4 = h3) | 0, z4 = pA((e4 = d4 + EA2 | 0) ^ W4, (I7 = e4 >>> 0 < d4 >>> 0 ? I7 + 1 | 0 : I7) ^ U4, 24), U4 = I7, eA2 = i3[g6 + 236 >> 2], EA2 = e4, $4 = d4, I7 = M4 + (W4 = h3) | 0, I7 = (I7 = (d4 = v4 + z4 | 0) >>> 0 < v4 >>> 0 ? I7 + 1 | 0 : I7) + eA2 | 0, I7 = (v4 = (e4 = i3[g6 + 232 >> 2]) + (M4 = d4) | 0) >>> 0 < M4 >>> 0 ? I7 + 1 | 0 : I7, M4 = f4, f4 = I7, $4 = pA($4 ^ v4, M4 ^ I7, 16), I7 = (I7 = U4) + (U4 = h3) | 0, d4 = I7 = (M4 = EA2 + (d4 = $4) | 0) >>> 0 < d4 >>> 0 ? I7 + 1 | 0 : I7, W4 = pA(M4 ^ z4, I7 ^ W4, 63), z4 = I7 = h3, EA2 = P4, P4 = p4, I7 = _4 + gA3 | 0, I7 = (I7 = (p4 = H4 + V4 | 0) >>> 0 < H4 >>> 0 ? I7 + 1 | 0 : I7) + z4 | 0, D4 = pA(P4 ^ (gA3 = H4 = p4 + W4 | 0), (H4 = p4 >>> 0 > H4 >>> 0 ? I7 + 1 | 0 : I7) ^ D4, 32), I7 = (p4 = h3) + S4 | 0, S4 = _4 = EA2 + D4 | 0, z4 = pA(W4 ^ _4, z4 ^ (I7 = _4 >>> 0 < D4 >>> 0 ? I7 + 1 | 0 : I7), 24), W4 = _4 = h3, P4 = I7, V4 = D4, I7 = H4 + a4 | 0, I7 = (I7 = (D4 = T4 + gA3 | 0) >>> 0 < T4 >>> 0 ? I7 + 1 | 0 : I7) + _4 | 0, V4 = pA(V4 ^ (_4 = H4 = D4 + z4 | 0), (D4 = _4 >>> 0 < D4 >>> 0 ? I7 + 1 | 0 : I7) ^ p4, 16), I7 = (I7 = P4) + (P4 = h3) | 0, S4 = H4 = (p4 = V4) + S4 | 0, gA3 = pA(gA3 = H4 ^ z4, (z4 = p4 >>> 0 > H4 >>> 0 ? I7 + 1 | 0 : I7) ^ W4, 63), p4 = h3, I7 = w4 + E4 | 0, I7 = (I7 = (H4 = X4 + CA2 | 0) >>> 0 < X4 >>> 0 ? I7 + 1 | 0 : I7) + b4 | 0, Y4 = pA((W4 = H4 = H4 + u4 | 0) ^ oA2, (H4 = H4 >>> 0 < u4 >>> 0 ? I7 + 1 | 0 : I7) ^ Y4, 32), I7 = d4 + (u4 = h3) | 0, I7 = (b4 = M4 + Y4 | 0) >>> 0 < M4 >>> 0 ? I7 + 1 | 0 : I7, M4 = b4, d4 = w4, w4 = I7, d4 = pA(b4 ^ CA2, d4 ^ I7, 24), CA2 = I7 = h3, b4 = I7, EA2 = Y4, I7 = H4 + iA2 | 0, I7 = (I7 = (Y4 = L4 + W4 | 0) >>> 0 < L4 >>> 0 ? I7 + 1 | 0 : I7) + b4 | 0, W4 = H4 = Y4 + d4 | 0, oA2 = pA(EA2 ^ H4, (b4 = u4) ^ (u4 = H4 >>> 0 < Y4 >>> 0 ? I7 + 1 | 0 : I7), 16), I7 = w4 + (b4 = h3) | 0, I7 = (H4 = M4 + oA2 | 0) >>> 0 < M4 >>> 0 ? I7 + 1 | 0 : I7, M4 = H4, Y4 = I7, d4 = pA(H4 ^ d4, I7 ^ CA2, 63), w4 = h3, I7 = c4 + BA3 | 0, I7 = (I7 = (H4 = o4 + J4 | 0) >>> 0 < o4 >>> 0 ? I7 + 1 | 0 : I7) + R4 | 0, I7 = y4 >>> 0 > (H4 = y4 + H4 | 0) >>> 0 ? I7 + 1 | 0 : I7, y4 = H4, H4 = I7, R4 = pA(y4 ^ $4, I7 ^ U4, 32), I7 = m4 + (o4 = h3) | 0, I7 = l4 >>> 0 > (U4 = l4 + R4 | 0) >>> 0 ? I7 + 1 | 0 : I7, l4 = c4, c4 = I7, m4 = pA(U4 ^ J4, l4 ^ I7, 24), BA3 = I7 = h3, l4 = I7, J4 = m4, I7 = H4 + AA4 | 0, I7 = (I7 = (m4 = t4 + y4 | 0) >>> 0 < t4 >>> 0 ? I7 + 1 | 0 : I7) + l4 | 0, y4 = R4, R4 = H4 = J4 + (t4 = m4) | 0, AA4 = pA(y4 ^ H4, (l4 = t4 >>> 0 > H4 >>> 0 ? I7 + 1 | 0 : I7) ^ o4, 16), I7 = c4 + (m4 = h3) | 0, CA2 = H4 = U4 + AA4 | 0, y4 = pA(J4 ^ H4, (o4 = H4 >>> 0 < U4 >>> 0 ? I7 + 1 | 0 : I7) ^ BA3, 63), H4 = h3, I7 = k4 + aA2 | 0, I7 = (I7 = (t4 = G4 + QA2 | 0) >>> 0 < G4 >>> 0 ? I7 + 1 | 0 : I7) + f4 | 0, I7 = (t4 = t4 + v4 | 0) >>> 0 < v4 >>> 0 ? I7 + 1 | 0 : I7, v4 = t4, t4 = I7, U4 = pA(v4 ^ Z4, I7 ^ F4, 32), I7 = r4 + (G4 = h3) | 0, f4 = k4, k4 = I7 = (c4 = N4 + U4 | 0) >>> 0 < N4 >>> 0 ? I7 + 1 | 0 : I7, F4 = pA(c4 ^ QA2, f4 ^ I7, 24), N4 = I7 = h3, f4 = I7, r4 = F4, I7 = t4 + rA2 | 0, I7 = (I7 = (v4 = v4 + x4 | 0) >>> 0 < x4 >>> 0 ? I7 + 1 | 0 : I7) + f4 | 0, f4 = t4 = v4 + F4 | 0, F4 = pA(t4 ^ U4, (v4 = t4 >>> 0 < v4 >>> 0 ? I7 + 1 | 0 : I7) ^ G4, 16), I7 = k4 + (U4 = h3) | 0, BA3 = t4 = c4 + F4 | 0, r4 = pA(r4 ^ t4, (G4 = t4 >>> 0 < c4 >>> 0 ? I7 + 1 | 0 : I7) ^ N4, 63), t4 = h3, I7 = w4 + D4 | 0, I7 = (c4 = _4 + d4 | 0) >>> 0 < _4 >>> 0 ? I7 + 1 | 0 : I7, _4 = c4, I7 = I7 + (k4 = i3[g6 + 164 >> 2]) | 0, U4 = pA((k4 = F4) ^ (F4 = c4 = c4 + i3[g6 + 160 >> 2] | 0), (c4 = c4 >>> 0 < _4 >>> 0 ? I7 + 1 | 0 : I7) ^ U4, 32), I7 = (I7 = o4) + (o4 = h3) | 0, N4 = w4, w4 = I7 = (_4 = U4) >>> 0 > (k4 = _4 + CA2 | 0) >>> 0 ? I7 + 1 | 0 : I7, N4 = pA(k4 ^ d4, N4 ^ I7, 24), D4 = I7 = h3, _4 = I7, d4 = U4, I7 = c4 + eA2 | 0, I7 = (I7 = (U4 = F4 + e4 | 0) >>> 0 < e4 >>> 0 ? I7 + 1 | 0 : I7) + _4 | 0, J4 = pA(d4 ^ (CA2 = c4 = U4 + N4 | 0), (c4 = c4 >>> 0 < U4 >>> 0 ? I7 + 1 | 0 : I7) ^ o4, 16), I7 = w4 + (_4 = h3) | 0, I7 = (o4 = k4 + J4 | 0) >>> 0 < k4 >>> 0 ? I7 + 1 | 0 : I7, k4 = o4, U4 = I7, x4 = pA(o4 ^ N4, I7 ^ D4, 63), o4 = h3, D4 = y4, I7 = u4 + nA2 | 0, F4 = w4 = O4 + W4 | 0, I7 = (I7 = w4 >>> 0 < O4 >>> 0 ? I7 + 1 | 0 : I7) + H4 | 0, N4 = pA((u4 = w4 = w4 + y4 | 0) ^ V4, (w4 = w4 >>> 0 < F4 >>> 0 ? I7 + 1 | 0 : I7) ^ P4, 32), I7 = (I7 = G4) + (G4 = h3) | 0, e4 = H4, H4 = I7 = (y4 = N4) >>> 0 > (F4 = y4 + BA3 | 0) >>> 0 ? I7 + 1 | 0 : I7, P4 = pA(D4 ^ F4, e4 ^ I7, 24), e4 = I7 = h3, y4 = I7, I7 = w4 + C4 | 0, I7 = (I7 = (u4 = u4 + IA4 | 0) >>> 0 < IA4 >>> 0 ? I7 + 1 | 0 : I7) + y4 | 0, w4 = pA((y4 = w4 = u4 + P4 | 0) ^ N4, (u4 = y4 >>> 0 < u4 >>> 0 ? I7 + 1 | 0 : I7) ^ G4, 16), I7 = H4 + (N4 = h3) | 0, I7 = F4 >>> 0 > (G4 = F4 + w4 | 0) >>> 0 ? I7 + 1 | 0 : I7, G4 = (F4 = G4) ^ P4, P4 = I7, d4 = pA(G4, I7 ^ e4, 63), H4 = h3, V4 = r4, I7 = l4 + fA2 | 0, I7 = (I7 = (G4 = R4 + j4 | 0) >>> 0 < j4 >>> 0 ? I7 + 1 | 0 : I7) + t4 | 0, r4 = pA((D4 = G4 = (l4 = G4) + r4 | 0) ^ oA2, (G4 = D4 >>> 0 < l4 >>> 0 ? I7 + 1 | 0 : I7) ^ b4, 32), I7 = z4 + (l4 = h3) | 0, e4 = t4, t4 = I7 = (b4 = S4 + r4 | 0) >>> 0 < S4 >>> 0 ? I7 + 1 | 0 : I7, R4 = pA(V4 ^ b4, e4 ^ I7, 24), S4 = I7 = h3, e4 = I7, I7 = G4 + cA2 | 0, I7 = (I7 = (D4 = D4 + q4 | 0) >>> 0 < q4 >>> 0 ? I7 + 1 | 0 : I7) + e4 | 0, z4 = pA((e4 = G4 = D4 + R4 | 0) ^ r4, (G4 = l4) ^ (l4 = e4 >>> 0 < D4 >>> 0 ? I7 + 1 | 0 : I7), 16), I7 = t4 + (D4 = h3) | 0, S4 = pA((t4 = G4 = b4 + z4 | 0) ^ R4, (I7 = t4 >>> 0 < b4 >>> 0 ? I7 + 1 | 0 : I7) ^ S4, 63), G4 = h3, b4 = I7, I7 = p4 + B4 | 0, I7 = (I7 = (r4 = K4 + gA3 | 0) >>> 0 < K4 >>> 0 ? I7 + 1 | 0 : I7) + v4 | 0, f4 = I7 = (r4 = r4 + f4 | 0) >>> 0 < f4 >>> 0 ? I7 + 1 | 0 : I7, R4 = pA(r4 ^ AA4, I7 ^ m4, 32), I7 = Y4 + (v4 = h3) | 0, I7 = (m4 = M4 + R4 | 0) >>> 0 < M4 >>> 0 ? I7 + 1 | 0 : I7, M4 = m4, Y4 = p4, p4 = I7, I7 = pA(m4 ^ gA3, Y4 ^ I7, 24), gA3 = i3[g6 + 204 >> 2], V4 = I7, m4 = I7, r4 = I7 + r4 | 0, I7 = (Y4 = h3) + f4 | 0, I7 = (I7 = r4 >>> 0 < m4 >>> 0 ? I7 + 1 | 0 : I7) + gA3 | 0, I7 = (f4 = r4 + i3[g6 + 200 >> 2] | 0) >>> 0 < r4 >>> 0 ? I7 + 1 | 0 : I7, r4 = v4, v4 = I7, gA3 = pA(f4 ^ R4, r4 ^ I7, 16), I7 = p4 + (m4 = h3) | 0, p4 = r4 = M4 + gA3 | 0, R4 = pA(V4 ^ r4, (M4 = r4 >>> 0 < M4 >>> 0 ? I7 + 1 | 0 : I7) ^ Y4, 63), r4 = I7 = h3, Z4 = t4, V4 = w4, I7 = c4 + a4 | 0, w4 = t4 = T4 + CA2 | 0, I7 = (I7 = t4 >>> 0 < T4 >>> 0 ? I7 + 1 | 0 : I7) + r4 | 0, AA4 = pA(V4 ^ (Y4 = t4 = t4 + R4 | 0), (t4 = t4 >>> 0 < w4 >>> 0 ? I7 + 1 | 0 : I7) ^ N4, 32), I7 = (w4 = h3) + b4 | 0, N4 = I7 = (c4 = Z4 + (N4 = AA4) | 0) >>> 0 < N4 >>> 0 ? I7 + 1 | 0 : I7, r4 = pA(R4 ^ c4, r4 ^ I7, 24), BA3 = I7 = h3, b4 = I7, V4 = r4, I7 = t4 + C4 | 0, I7 = (I7 = (r4 = Y4 + IA4 | 0) >>> 0 < IA4 >>> 0 ? I7 + 1 | 0 : I7) + b4 | 0, b4 = t4 = V4 + r4 | 0, AA4 = pA(t4 ^ AA4, (r4 = t4 >>> 0 < r4 >>> 0 ? I7 + 1 | 0 : I7) ^ w4, 16), I7 = N4 + (R4 = h3) | 0, N4 = t4 = c4 + AA4 | 0, w4 = pA(V4 ^ t4, (Y4 = t4 >>> 0 < c4 >>> 0 ? I7 + 1 | 0 : I7) ^ BA3, 63), c4 = h3, V4 = x4, I7 = o4 + B4 | 0, I7 = (I7 = (t4 = K4 + x4 | 0) >>> 0 < K4 >>> 0 ? I7 + 1 | 0 : I7) + u4 | 0, D4 = pA((x4 = t4 = t4 + y4 | 0) ^ z4, (t4 = t4 >>> 0 < y4 >>> 0 ? I7 + 1 | 0 : I7) ^ D4, 32), I7 = M4 + (y4 = h3) | 0, I7 = p4 >>> 0 > (u4 = p4 + D4 | 0) >>> 0 ? I7 + 1 | 0 : I7, p4 = u4, u4 = o4, o4 = I7, u4 = pA(V4 ^ p4, u4 ^ I7, 24), z4 = I7 = h3, M4 = I7, V4 = u4, I7 = t4 + fA2 | 0, I7 = (I7 = (u4 = x4 + j4 | 0) >>> 0 < j4 >>> 0 ? I7 + 1 | 0 : I7) + M4 | 0, BA3 = t4 = V4 + u4 | 0, W4 = pA(t4 ^ D4, (M4 = t4 >>> 0 < u4 >>> 0 ? I7 + 1 | 0 : I7) ^ y4, 16), I7 = o4 + (y4 = h3) | 0, I7 = (t4 = p4 + W4 | 0) >>> 0 < p4 >>> 0 ? I7 + 1 | 0 : I7, p4 = t4, u4 = I7, D4 = pA(V4 ^ t4, I7 ^ z4, 63), o4 = h3, I7 = H4 + cA2 | 0, I7 = (I7 = (t4 = d4 + q4 | 0) >>> 0 < q4 >>> 0 ? I7 + 1 | 0 : I7) + l4 | 0, I7 = (t4 = t4 + e4 | 0) >>> 0 < e4 >>> 0 ? I7 + 1 | 0 : I7, e4 = t4, t4 = I7, x4 = pA(e4 ^ gA3, I7 ^ m4, 32), I7 = U4 + (l4 = h3) | 0, U4 = H4, H4 = I7 = k4 >>> 0 > (m4 = k4 + x4 | 0) >>> 0 ? I7 + 1 | 0 : I7, I7 = pA((k4 = m4) ^ d4, U4 ^ I7, 24), d4 = i3[g6 + 236 >> 2], V4 = I7, m4 = I7, e4 = I7 + e4 | 0, I7 = (U4 = h3) + t4 | 0, I7 = (I7 = e4 >>> 0 < m4 >>> 0 ? I7 + 1 | 0 : I7) + d4 | 0, I7 = (t4 = e4 + i3[g6 + 232 >> 2] | 0) >>> 0 < e4 >>> 0 ? I7 + 1 | 0 : I7, m4 = t4, e4 = l4, l4 = I7, z4 = pA(t4 ^ x4, e4 ^ I7, 16), I7 = H4 + (e4 = h3) | 0, x4 = pA(V4 ^ (d4 = t4 = k4 + z4 | 0), (t4 = t4 >>> 0 < k4 >>> 0 ? I7 + 1 | 0 : I7) ^ U4, 63), H4 = h3, V4 = S4, I7 = G4 + v4 | 0, I7 = (I7 = (k4 = f4 + S4 | 0) >>> 0 < f4 >>> 0 ? I7 + 1 | 0 : I7) + (U4 = i3[g6 + 164 >> 2]) | 0, S4 = pA((U4 = k4 = (f4 = k4) + i3[g6 + 160 >> 2] | 0) ^ J4, (k4 = f4 >>> 0 > k4 >>> 0 ? I7 + 1 | 0 : I7) ^ _4, 32), I7 = P4 + (f4 = h3) | 0, I7 = F4 >>> 0 > (_4 = F4 + S4 | 0) >>> 0 ? I7 + 1 | 0 : I7, F4 = G4, G4 = I7, F4 = pA(V4 ^ _4, F4 ^ I7, 24), P4 = I7 = h3, v4 = I7, I7 = k4 + iA2 | 0, I7 = (I7 = (U4 = U4 + L4 | 0) >>> 0 < L4 >>> 0 ? I7 + 1 | 0 : I7) + v4 | 0, U4 = pA((gA3 = k4 = U4 + F4 | 0) ^ S4, (k4 = k4 >>> 0 < U4 >>> 0 ? I7 + 1 | 0 : I7) ^ f4, 16), I7 = G4 + (f4 = h3) | 0, I7 = (v4 = _4 + U4 | 0) >>> 0 < _4 >>> 0 ? I7 + 1 | 0 : I7, _4 = v4, v4 = I7, S4 = pA(_4 ^ F4, I7 ^ P4, 63), G4 = h3, P4 = U4, I7 = o4 + r4 | 0, I7 = (U4 = D4 + b4 | 0) >>> 0 < b4 >>> 0 ? I7 + 1 | 0 : I7, b4 = U4, I7 = I7 + (F4 = i3[g6 + 132 >> 2]) | 0, I7 = (U4 = U4 + i3[g6 + 128 >> 2] | 0) >>> 0 < b4 >>> 0 ? I7 + 1 | 0 : I7, b4 = U4, r4 = f4, f4 = I7, P4 = pA(P4 ^ U4, r4 ^ I7, 32), I7 = (I7 = t4) + (t4 = h3) | 0, r4 = o4, o4 = I7 = (F4 = P4) >>> 0 > (U4 = F4 + d4 | 0) >>> 0 ? I7 + 1 | 0 : I7, D4 = pA(U4 ^ D4, r4 ^ I7, 24), r4 = I7 = h3, I7 = f4 + nA2 | 0, I7 = (I7 = (b4 = b4 + O4 | 0) >>> 0 < O4 >>> 0 ? I7 + 1 | 0 : I7) + r4 | 0, J4 = pA((CA2 = f4 = b4 + D4 | 0) ^ P4, (f4 = f4 >>> 0 < b4 >>> 0 ? I7 + 1 | 0 : I7) ^ t4, 16), I7 = o4 + (F4 = h3) | 0, I7 = (t4 = U4 + J4 | 0) >>> 0 < U4 >>> 0 ? I7 + 1 | 0 : I7, U4 = t4, b4 = I7, d4 = pA(t4 ^ D4, I7 ^ r4, 63), t4 = h3, I7 = M4 + E4 | 0, M4 = o4 = X4 + BA3 | 0, I7 = (I7 = o4 >>> 0 < X4 >>> 0 ? I7 + 1 | 0 : I7) + H4 | 0, r4 = pA((D4 = o4 = o4 + x4 | 0) ^ AA4, (o4 = o4 >>> 0 < M4 >>> 0 ? I7 + 1 | 0 : I7) ^ R4, 32), I7 = v4 + (M4 = h3) | 0, I7 = _4 >>> 0 > (P4 = _4 + r4 | 0) >>> 0 ? I7 + 1 | 0 : I7, _4 = P4, P4 = H4, H4 = I7, I7 = pA(_4 ^ x4, P4 ^ I7, 24), R4 = i3[g6 + 156 >> 2], x4 = I7, P4 = I7, D4 = I7 + D4 | 0, I7 = (v4 = h3) + o4 | 0, I7 = (I7 = D4 >>> 0 < P4 >>> 0 ? I7 + 1 | 0 : I7) + R4 | 0, I7 = (o4 = D4 + i3[g6 + 152 >> 2] | 0) >>> 0 < D4 >>> 0 ? I7 + 1 | 0 : I7, P4 = o4, D4 = M4, M4 = I7, AA4 = pA(o4 ^ r4, D4 ^ I7, 16), I7 = H4 + (D4 = h3) | 0, I7 = (o4 = _4 + AA4 | 0) >>> 0 < _4 >>> 0 ? I7 + 1 | 0 : I7, _4 = o4, r4 = v4, v4 = I7, x4 = pA(x4 ^ o4, r4 ^ I7, 63), o4 = h3, I7 = G4 + l4 | 0, l4 = H4 = m4 + S4 | 0, I7 = (I7 = H4 >>> 0 < m4 >>> 0 ? I7 + 1 | 0 : I7) + (r4 = i3[g6 + 204 >> 2]) | 0, l4 = I7 = (H4 = H4 + i3[g6 + 200 >> 2] | 0) >>> 0 < l4 >>> 0 ? I7 + 1 | 0 : I7, R4 = pA(H4 ^ W4, I7 ^ y4, 32), I7 = Y4 + (m4 = h3) | 0, r4 = G4, G4 = I7 = (y4 = N4 + R4 | 0) >>> 0 < N4 >>> 0 ? I7 + 1 | 0 : I7, r4 = pA(y4 ^ S4, r4 ^ I7, 24), N4 = I7 = h3, S4 = r4, I7 = I7 + l4 | 0, I7 = (I7 = (r4 = r4 + H4 | 0) >>> 0 < H4 >>> 0 ? I7 + 1 | 0 : I7) + (Y4 = i3[g6 + 148 >> 2]) | 0, I7 = (H4 = r4 + i3[g6 + 144 >> 2] | 0) >>> 0 < r4 >>> 0 ? I7 + 1 | 0 : I7, l4 = H4, r4 = m4, m4 = I7, BA3 = pA(H4 ^ R4, r4 ^ I7, 16), I7 = G4 + (r4 = h3) | 0, G4 = N4, N4 = I7 = y4 >>> 0 > (H4 = y4 + BA3 | 0) >>> 0 ? I7 + 1 | 0 : I7, Y4 = pA(S4 ^ (y4 = H4), G4 ^ I7, 63), G4 = h3, S4 = w4, I7 = c4 + k4 | 0, I7 = (I7 = (H4 = w4 + gA3 | 0) >>> 0 < w4 >>> 0 ? I7 + 1 | 0 : I7) + (R4 = i3[g6 + 196 >> 2]) | 0, R4 = H4 = (w4 = H4) + i3[g6 + 192 >> 2] | 0, e4 = pA(H4 ^ z4, (w4 = w4 >>> 0 > H4 >>> 0 ? I7 + 1 | 0 : I7) ^ e4, 32), I7 = u4 + (k4 = h3) | 0, u4 = H4 = p4 + e4 | 0, H4 = pA(S4 ^ H4, (I7 = p4 >>> 0 > H4 >>> 0 ? I7 + 1 | 0 : I7) ^ c4, 24), p4 = I7, z4 = i3[g6 + 220 >> 2], $4 = H4, Z4 = u4, V4 = e4, I7 = (c4 = h3) + w4 | 0, I7 = (I7 = (e4 = H4 + R4 | 0) >>> 0 < H4 >>> 0 ? I7 + 1 | 0 : I7) + (S4 = z4) | 0, gA3 = pA(V4 ^ (e4 = H4 = (u4 = i3[g6 + 216 >> 2]) + (w4 = e4) | 0), (H4 = k4) ^ (k4 = w4 >>> 0 > e4 >>> 0 ? I7 + 1 | 0 : I7), 16), I7 = (I7 = p4) + (p4 = h3) | 0, R4 = I7 = (w4 = gA3) >>> 0 > (H4 = Z4 + w4 | 0) >>> 0 ? I7 + 1 | 0 : I7, I7 = pA($4 ^ H4, I7 ^ c4, 63), W4 = i3[g6 + 236 >> 2], V4 = I7, c4 = I7, S4 = I7 + CA2 | 0, I7 = (w4 = h3) + f4 | 0, I7 = (I7 = c4 >>> 0 > S4 >>> 0 ? I7 + 1 | 0 : I7) + W4 | 0, AA4 = pA((S4 = c4 = (f4 = S4) + i3[g6 + 232 >> 2] | 0) ^ AA4, (c4 = c4 >>> 0 < f4 >>> 0 ? I7 + 1 | 0 : I7) ^ D4, 32), I7 = N4 + (f4 = h3) | 0, N4 = w4, w4 = I7 = y4 >>> 0 > (D4 = y4 + AA4 | 0) >>> 0 ? I7 + 1 | 0 : I7, D4 = I7 = pA(V4 ^ (y4 = D4), N4 ^ I7, 24), S4 = I7 + S4 | 0, I7 = (N4 = h3) + c4 | 0, I7 = z4 + (D4 >>> 0 > S4 >>> 0 ? I7 + 1 | 0 : I7) | 0, z4 = c4 = u4 + S4 | 0, AA4 = pA(c4 ^ AA4, (S4 = f4) ^ (f4 = c4 >>> 0 < u4 >>> 0 ? I7 + 1 | 0 : I7), 16), I7 = w4 + (u4 = h3) | 0, w4 = N4, N4 = I7 = (c4 = y4 + AA4 | 0) >>> 0 < y4 >>> 0 ? I7 + 1 | 0 : I7, w4 = pA(D4 ^ (y4 = c4), w4 ^ I7, 63), c4 = h3, I7 = t4 + nA2 | 0, I7 = (I7 = (D4 = d4 + O4 | 0) >>> 0 < O4 >>> 0 ? I7 + 1 | 0 : I7) + M4 | 0, S4 = D4 = D4 + P4 | 0, r4 = pA(D4 ^ BA3, (M4 = D4 >>> 0 < P4 >>> 0 ? I7 + 1 | 0 : I7) ^ r4, 32), I7 = R4 + (P4 = h3) | 0, I7 = H4 >>> 0 > (D4 = H4 + r4 | 0) >>> 0 ? I7 + 1 | 0 : I7, H4 = D4, R4 = t4, t4 = I7, R4 = pA(D4 ^ d4, R4 ^ I7, 24), d4 = I7 = h3, D4 = I7, V4 = r4, I7 = M4 + cA2 | 0, I7 = (I7 = (r4 = S4 + q4 | 0) >>> 0 < q4 >>> 0 ? I7 + 1 | 0 : I7) + D4 | 0, W4 = pA(V4 ^ (BA3 = M4 = r4 + R4 | 0), (M4 = r4 >>> 0 > M4 >>> 0 ? I7 + 1 | 0 : I7) ^ P4, 16), I7 = t4 + (P4 = h3) | 0, r4 = I7 = H4 >>> 0 > (D4 = H4 + W4 | 0) >>> 0 ? I7 + 1 | 0 : I7, R4 = pA(D4 ^ R4, I7 ^ d4, 63), H4 = h3, I7 = o4 + a4 | 0, I7 = (I7 = (t4 = x4 + T4 | 0) >>> 0 < T4 >>> 0 ? I7 + 1 | 0 : I7) + m4 | 0, S4 = pA((m4 = t4 = t4 + l4 | 0) ^ gA3, (t4 = t4 >>> 0 < l4 >>> 0 ? I7 + 1 | 0 : I7) ^ p4, 32), I7 = b4 + (p4 = h3) | 0, I7 = (l4 = U4 + S4 | 0) >>> 0 < U4 >>> 0 ? I7 + 1 | 0 : I7, U4 = l4, l4 = o4, o4 = I7, b4 = pA(U4 ^ x4, l4 ^ I7, 24), x4 = I7 = h3, l4 = I7, I7 = t4 + B4 | 0, I7 = (I7 = (m4 = m4 + K4 | 0) >>> 0 < K4 >>> 0 ? I7 + 1 | 0 : I7) + l4 | 0, l4 = t4 = m4 + b4 | 0, d4 = pA(t4 ^ S4, (d4 = p4) ^ (p4 = t4 >>> 0 < m4 >>> 0 ? I7 + 1 | 0 : I7), 16), I7 = o4 + (m4 = h3) | 0, I7 = (t4 = U4 + d4 | 0) >>> 0 < U4 >>> 0 ? I7 + 1 | 0 : I7, U4 = t4, o4 = t4 ^ b4, b4 = I7, S4 = pA(o4, I7 ^ x4, 63), t4 = h3, V4 = Y4, I7 = G4 + k4 | 0, k4 = o4 = e4 + Y4 | 0, I7 = (I7 = o4 >>> 0 < e4 >>> 0 ? I7 + 1 | 0 : I7) + (x4 = i3[g6 + 156 >> 2]) | 0, k4 = I7 = (o4 = o4 + i3[g6 + 152 >> 2] | 0) >>> 0 < k4 >>> 0 ? I7 + 1 | 0 : I7, Y4 = pA(o4 ^ J4, I7 ^ F4, 32), I7 = v4 + (F4 = h3) | 0, I7 = (e4 = _4 + Y4 | 0) >>> 0 < _4 >>> 0 ? I7 + 1 | 0 : I7, _4 = e4, v4 = G4, G4 = I7, e4 = pA(V4 ^ e4, v4 ^ I7, 24), v4 = I7 = h3, J4 = e4, I7 = I7 + k4 | 0, I7 = (I7 = (e4 = o4 + e4 | 0) >>> 0 < o4 >>> 0 ? I7 + 1 | 0 : I7) + (x4 = i3[g6 + 204 >> 2]) | 0, gA3 = o4 = e4 + i3[g6 + 200 >> 2] | 0, e4 = pA(o4 ^ Y4, (k4 = o4 >>> 0 < e4 >>> 0 ? I7 + 1 | 0 : I7) ^ F4, 16), I7 = G4 + (F4 = h3) | 0, G4 = o4 = _4 + e4 | 0, Y4 = pA(J4 ^ o4, (_4 = o4 >>> 0 < _4 >>> 0 ? I7 + 1 | 0 : I7) ^ v4, 63), o4 = h3, x4 = R4, I7 = f4 + C4 | 0, I7 = (I7 = (v4 = z4 + IA4 | 0) >>> 0 < IA4 >>> 0 ? I7 + 1 | 0 : I7) + H4 | 0, v4 = I7 = (f4 = v4 + R4 | 0) >>> 0 < v4 >>> 0 ? I7 + 1 | 0 : I7, R4 = pA(f4 ^ e4, I7 ^ F4, 32), I7 = b4 + (F4 = h3) | 0, I7 = (e4 = U4 + R4 | 0) >>> 0 < U4 >>> 0 ? I7 + 1 | 0 : I7, U4 = e4, b4 = H4, H4 = I7, e4 = pA(x4 ^ e4, b4 ^ I7, 24), b4 = I7 = h3, J4 = e4, I7 = I7 + v4 | 0, I7 = (I7 = (e4 = f4 + e4 | 0) >>> 0 < f4 >>> 0 ? I7 + 1 | 0 : I7) + (x4 = i3[g6 + 132 >> 2]) | 0, CA2 = pA((z4 = f4 = e4 + i3[g6 + 128 >> 2] | 0) ^ R4, (f4 = f4 >>> 0 < e4 >>> 0 ? I7 + 1 | 0 : I7) ^ F4, 16), I7 = H4 + (v4 = h3) | 0, I7 = (F4 = U4 + CA2 | 0) >>> 0 < U4 >>> 0 ? I7 + 1 | 0 : I7, U4 = F4, F4 = I7, x4 = pA(J4 ^ U4, I7 ^ b4, 63), H4 = h3, I7 = M4 + fA2 | 0, I7 = (I7 = (b4 = j4 + BA3 | 0) >>> 0 < j4 >>> 0 ? I7 + 1 | 0 : I7) + t4 | 0, R4 = pA((e4 = M4 = b4 + S4 | 0) ^ AA4, (M4 = b4 >>> 0 > e4 >>> 0 ? I7 + 1 | 0 : I7) ^ u4, 32), I7 = _4 + (u4 = h3) | 0, I7 = G4 >>> 0 > (b4 = G4 + R4 | 0) >>> 0 ? I7 + 1 | 0 : I7, G4 = b4, b4 = t4, t4 = I7, I7 = pA(G4 ^ S4, b4 ^ I7, 24), S4 = i3[g6 + 164 >> 2], J4 = I7, b4 = I7, e4 = I7 + e4 | 0, I7 = (_4 = h3) + M4 | 0, I7 = (I7 = e4 >>> 0 < b4 >>> 0 ? I7 + 1 | 0 : I7) + S4 | 0, I7 = e4 >>> 0 > (M4 = e4 + i3[g6 + 160 >> 2] | 0) >>> 0 ? I7 + 1 | 0 : I7, e4 = u4, u4 = I7, b4 = pA(M4 ^ R4, e4 ^ I7, 16), I7 = t4 + (e4 = h3) | 0, t4 = _4, _4 = I7 = G4 >>> 0 > (R4 = G4 + b4 | 0) >>> 0 ? I7 + 1 | 0 : I7, t4 = pA(J4 ^ R4, t4 ^ I7, 63), G4 = h3, J4 = Y4, I7 = o4 + p4 | 0, I7 = (I7 = (Y4 = l4 + Y4 | 0) >>> 0 < l4 >>> 0 ? I7 + 1 | 0 : I7) + (S4 = i3[g6 + 196 >> 2]) | 0, S4 = pA((Y4 = p4 = (l4 = Y4) + i3[g6 + 192 >> 2] | 0) ^ W4, (p4 = p4 >>> 0 < l4 >>> 0 ? I7 + 1 | 0 : I7) ^ P4, 32), I7 = N4 + (l4 = h3) | 0, N4 = o4, o4 = I7 = y4 >>> 0 > (P4 = y4 + S4 | 0) >>> 0 ? I7 + 1 | 0 : I7, P4 = pA(J4 ^ (y4 = P4), N4 ^ I7, 24), AA4 = I7 = h3, N4 = I7, J4 = P4, I7 = p4 + E4 | 0, I7 = (I7 = (P4 = Y4 + X4 | 0) >>> 0 < X4 >>> 0 ? I7 + 1 | 0 : I7) + N4 | 0, W4 = pA((BA3 = p4 = J4 + P4 | 0) ^ S4, (p4 = p4 >>> 0 < P4 >>> 0 ? I7 + 1 | 0 : I7) ^ l4, 16), I7 = o4 + (l4 = h3) | 0, I7 = y4 >>> 0 > (N4 = y4 + W4 | 0) >>> 0 ? I7 + 1 | 0 : I7, Y4 = pA(J4 ^ (y4 = N4), I7 ^ AA4, 63), o4 = h3, N4 = I7, J4 = w4, I7 = c4 + k4 | 0, I7 = (I7 = (P4 = w4 + gA3 | 0) >>> 0 < w4 >>> 0 ? I7 + 1 | 0 : I7) + (S4 = i3[g6 + 148 >> 2]) | 0, d4 = pA((S4 = w4 = (k4 = P4) + i3[g6 + 144 >> 2] | 0) ^ d4, (w4 = w4 >>> 0 < k4 >>> 0 ? I7 + 1 | 0 : I7) ^ m4, 32), I7 = r4 + (k4 = h3) | 0, r4 = c4, c4 = I7 = D4 >>> 0 > (m4 = D4 + d4 | 0) >>> 0 ? I7 + 1 | 0 : I7, D4 = pA(J4 ^ m4, r4 ^ I7, 24), r4 = I7 = h3, J4 = D4, I7 = w4 + iA2 | 0, I7 = (I7 = (D4 = S4 + L4 | 0) >>> 0 < L4 >>> 0 ? I7 + 1 | 0 : I7) + r4 | 0, P4 = w4 = J4 + D4 | 0, d4 = pA(w4 ^ d4, (S4 = k4) ^ (k4 = w4 >>> 0 < D4 >>> 0 ? I7 + 1 | 0 : I7), 16), I7 = c4 + (D4 = h3) | 0, r4 = pA(J4 ^ (c4 = w4 = m4 + d4 | 0), (m4 = c4 >>> 0 < m4 >>> 0 ? I7 + 1 | 0 : I7) ^ r4, 63), S4 = I7 = h3, w4 = I7, J4 = y4, I7 = f4 + E4 | 0, I7 = (I7 = (y4 = X4 + z4 | 0) >>> 0 < X4 >>> 0 ? I7 + 1 | 0 : I7) + w4 | 0, z4 = f4 = y4 + r4 | 0, e4 = pA(f4 ^ b4, (w4 = f4 >>> 0 < y4 >>> 0 ? I7 + 1 | 0 : I7) ^ e4, 32), I7 = (f4 = h3) + N4 | 0, N4 = I7 = (y4 = J4 + e4 | 0) >>> 0 < e4 >>> 0 ? I7 + 1 | 0 : I7, r4 = pA(r4 ^ y4, S4 ^ I7, 24), S4 = I7 = h3, b4 = I7, J4 = e4, I7 = w4 + fA2 | 0, I7 = (I7 = (e4 = j4 + z4 | 0) >>> 0 < j4 >>> 0 ? I7 + 1 | 0 : I7) + b4 | 0, z4 = w4 = e4 + r4 | 0, gA3 = pA(J4 ^ w4, (b4 = f4) ^ (f4 = w4 >>> 0 < e4 >>> 0 ? I7 + 1 | 0 : I7), 16), I7 = N4 + (b4 = h3) | 0, N4 = I7 = (w4 = y4 + gA3 | 0) >>> 0 < y4 >>> 0 ? I7 + 1 | 0 : I7, S4 = pA((y4 = w4) ^ r4, I7 ^ S4, 63), w4 = h3, I7 = H4 + cA2 | 0, I7 = (I7 = (e4 = x4 + q4 | 0) >>> 0 < q4 >>> 0 ? I7 + 1 | 0 : I7) + u4 | 0, M4 = I7 = (e4 = e4 + M4 | 0) >>> 0 < M4 >>> 0 ? I7 + 1 | 0 : I7, r4 = pA(e4 ^ W4, I7 ^ l4, 32), I7 = m4 + (l4 = h3) | 0, I7 = c4 >>> 0 > (u4 = c4 + r4 | 0) >>> 0 ? I7 + 1 | 0 : I7, c4 = u4, u4 = H4, H4 = I7, I7 = pA(c4 ^ x4, u4 ^ I7, 24), x4 = i3[g6 + 204 >> 2], J4 = I7, u4 = I7, e4 = I7 + e4 | 0, I7 = (m4 = h3) + M4 | 0, I7 = (I7 = u4 >>> 0 > e4 >>> 0 ? I7 + 1 | 0 : I7) + x4 | 0, W4 = pA((AA4 = M4 = e4 + i3[g6 + 200 >> 2] | 0) ^ r4, (M4 = e4 >>> 0 > M4 >>> 0 ? I7 + 1 | 0 : I7) ^ l4, 16), I7 = H4 + (l4 = h3) | 0, r4 = m4, m4 = I7 = c4 >>> 0 > (u4 = c4 + W4 | 0) >>> 0 ? I7 + 1 | 0 : I7, r4 = pA(J4 ^ u4, r4 ^ I7, 63), H4 = h3, x4 = t4, I7 = p4 + G4 | 0, I7 = (I7 = (c4 = t4 + BA3 | 0) >>> 0 < t4 >>> 0 ? I7 + 1 | 0 : I7) + (e4 = i3[g6 + 220 >> 2]) | 0, D4 = pA((e4 = t4 = c4 + i3[g6 + 216 >> 2] | 0) ^ d4, (t4 = t4 >>> 0 < c4 >>> 0 ? I7 + 1 | 0 : I7) ^ D4, 32), I7 = F4 + (c4 = h3) | 0, I7 = (p4 = U4 + D4 | 0) >>> 0 < U4 >>> 0 ? I7 + 1 | 0 : I7, U4 = G4, G4 = I7, I7 = pA(x4 ^ p4, U4 ^ I7, 24), x4 = i3[g6 + 156 >> 2], d4 = I7, F4 = I7, e4 = I7 + e4 | 0, I7 = (U4 = h3) + t4 | 0, I7 = (I7 = F4 >>> 0 > e4 >>> 0 ? I7 + 1 | 0 : I7) + x4 | 0, BA3 = t4 = e4 + i3[g6 + 152 >> 2] | 0, J4 = pA(t4 ^ D4, (F4 = t4 >>> 0 < e4 >>> 0 ? I7 + 1 | 0 : I7) ^ c4, 16), I7 = G4 + (e4 = h3) | 0, I7 = (t4 = p4 + J4 | 0) >>> 0 < p4 >>> 0 ? I7 + 1 | 0 : I7, p4 = t4, c4 = U4, U4 = I7, G4 = pA(d4 ^ t4, c4 ^ I7, 63), c4 = h3, d4 = Y4, I7 = o4 + k4 | 0, k4 = t4 = P4 + Y4 | 0, I7 = (I7 = t4 >>> 0 < P4 >>> 0 ? I7 + 1 | 0 : I7) + (D4 = i3[g6 + 132 >> 2]) | 0, k4 = I7 = (t4 = t4 + i3[g6 + 128 >> 2] | 0) >>> 0 < k4 >>> 0 ? I7 + 1 | 0 : I7, Y4 = pA(t4 ^ CA2, I7 ^ v4, 32), I7 = _4 + (v4 = h3) | 0, D4 = pA(d4 ^ (_4 = P4 = R4 + Y4 | 0), (P4 = o4) ^ (o4 = _4 >>> 0 < R4 >>> 0 ? I7 + 1 | 0 : I7), 24), P4 = I7 = h3, d4 = D4, I7 = I7 + k4 | 0, k4 = D4 = t4 + D4 | 0, I7 = (I7 = D4 >>> 0 < t4 >>> 0 ? I7 + 1 | 0 : I7) + (R4 = i3[g6 + 196 >> 2]) | 0, D4 = t4 = D4 + i3[g6 + 192 >> 2] | 0, R4 = pA(t4 ^ Y4, (R4 = v4) ^ (v4 = t4 >>> 0 < k4 >>> 0 ? I7 + 1 | 0 : I7), 16), I7 = o4 + (k4 = h3) | 0, I7 = (t4 = _4 + R4 | 0) >>> 0 < _4 >>> 0 ? I7 + 1 | 0 : I7, _4 = t4, o4 = P4, P4 = I7, x4 = pA(d4 ^ t4, o4 ^ I7, 63), t4 = h3, Y4 = r4, I7 = f4 + a4 | 0, f4 = o4 = T4 + z4 | 0, I7 = (I7 = o4 >>> 0 < T4 >>> 0 ? I7 + 1 | 0 : I7) + H4 | 0, I7 = (o4 = o4 + r4 | 0) >>> 0 < f4 >>> 0 ? I7 + 1 | 0 : I7, f4 = k4, k4 = I7, R4 = pA(o4 ^ R4, f4 ^ I7, 32), I7 = U4 + (f4 = h3) | 0, U4 = r4 = p4 + R4 | 0, r4 = pA(Y4 ^ r4, (I7 = p4 >>> 0 > r4 >>> 0 ? I7 + 1 | 0 : I7) ^ H4, 24), p4 = I7, z4 = i3[g6 + 148 >> 2], V4 = r4, d4 = U4, I7 = k4 + (H4 = h3) | 0, I7 = (I7 = (r4 = o4 + r4 | 0) >>> 0 < o4 >>> 0 ? I7 + 1 | 0 : I7) + (Y4 = z4) | 0, CA2 = o4 = (U4 = i3[g6 + 144 >> 2]) + r4 | 0, QA2 = pA(o4 ^ R4, (k4 = f4) ^ (f4 = o4 >>> 0 < r4 >>> 0 ? I7 + 1 | 0 : I7), 16), I7 = (r4 = h3) + p4 | 0, R4 = o4 = d4 + (k4 = QA2) | 0, o4 = pA(V4 ^ o4, (Y4 = o4 >>> 0 < k4 >>> 0 ? I7 + 1 | 0 : I7) ^ H4, 63), k4 = h3, d4 = G4, I7 = c4 + M4 | 0, I7 = (H4 = G4 + AA4 | 0) >>> 0 < G4 >>> 0 ? I7 + 1 | 0 : I7, G4 = H4, I7 = I7 + (p4 = i3[g6 + 236 >> 2]) | 0, b4 = pA((M4 = H4 = H4 + i3[g6 + 232 >> 2] | 0) ^ gA3, (H4 = H4 >>> 0 < G4 >>> 0 ? I7 + 1 | 0 : I7) ^ b4, 32), I7 = P4 + (G4 = h3) | 0, I7 = (p4 = _4 + b4 | 0) >>> 0 < _4 >>> 0 ? I7 + 1 | 0 : I7, _4 = c4, c4 = I7, P4 = pA(d4 ^ p4, _4 ^ I7, 24), d4 = I7 = h3, _4 = I7, I7 = H4 + nA2 | 0, I7 = (I7 = (M4 = M4 + O4 | 0) >>> 0 < O4 >>> 0 ? I7 + 1 | 0 : I7) + _4 | 0, gA3 = H4 = M4 + P4 | 0, H4 = pA(H4 ^ b4, (_4 = H4 >>> 0 < M4 >>> 0 ? I7 + 1 | 0 : I7) ^ G4, 16), I7 = c4 + (M4 = h3) | 0, b4 = G4 = p4 + H4 | 0, d4 = pA(c4 = G4 ^ P4, (P4 = p4 >>> 0 > G4 >>> 0 ? I7 + 1 | 0 : I7) ^ d4, 63), G4 = h3, V4 = x4, I7 = F4 + B4 | 0, p4 = c4 = K4 + BA3 | 0, I7 = (I7 = c4 >>> 0 < K4 >>> 0 ? I7 + 1 | 0 : I7) + t4 | 0, p4 = I7 = (c4 = c4 + x4 | 0) >>> 0 < p4 >>> 0 ? I7 + 1 | 0 : I7, x4 = pA(c4 ^ W4, I7 ^ l4, 32), I7 = N4 + (F4 = h3) | 0, I7 = y4 >>> 0 > (l4 = y4 + x4 | 0) >>> 0 ? I7 + 1 | 0 : I7, N4 = pA(V4 ^ (y4 = l4), I7 ^ t4, 24), l4 = I7, AA4 = i3[g6 + 164 >> 2], $4 = N4, Z4 = y4, I7 = p4 + (t4 = h3) | 0, I7 = (I7 = (N4 = c4 + N4 | 0) >>> 0 < c4 >>> 0 ? I7 + 1 | 0 : I7) + AA4 | 0, N4 = c4 = (y4 = i3[g6 + 160 >> 2]) + (p4 = N4) | 0, BA3 = pA(c4 ^ x4, (V4 = F4) ^ (F4 = c4 >>> 0 < p4 >>> 0 ? I7 + 1 | 0 : I7), 16), I7 = (I7 = l4) + (l4 = h3) | 0, I7 = (c4 = Z4 + (p4 = BA3) | 0) >>> 0 < p4 >>> 0 ? I7 + 1 | 0 : I7, p4 = c4, x4 = t4, t4 = I7, x4 = pA($4 ^ c4, x4 ^ I7, 63), c4 = h3, V4 = S4, I7 = w4 + iA2 | 0, I7 = (I7 = (S4 = S4 + L4 | 0) >>> 0 < L4 >>> 0 ? I7 + 1 | 0 : I7) + v4 | 0, v4 = I7 = D4 >>> 0 > (S4 = D4 + S4 | 0) >>> 0 ? I7 + 1 | 0 : I7, W4 = pA(S4 ^ J4, I7 ^ e4, 32), I7 = m4 + (e4 = h3) | 0, m4 = D4 = u4 + W4 | 0, D4 = pA(V4 ^ D4, (J4 = w4) ^ (w4 = u4 >>> 0 > D4 >>> 0 ? I7 + 1 | 0 : I7), 24), J4 = I7 = h3, u4 = I7, V4 = D4, I7 = v4 + C4 | 0, I7 = (I7 = (D4 = S4 + IA4 | 0) >>> 0 < IA4 >>> 0 ? I7 + 1 | 0 : I7) + u4 | 0, u4 = I7 = (v4 = V4 + D4 | 0) >>> 0 < D4 >>> 0 ? I7 + 1 | 0 : I7, W4 = pA(v4 ^ W4, I7 ^ e4, 16), I7 = w4 + (e4 = h3) | 0, I7 = (D4 = m4 + W4 | 0) >>> 0 < m4 >>> 0 ? I7 + 1 | 0 : I7, m4 = D4, D4 = I7, S4 = pA(V4 ^ m4, I7 ^ J4, 63), J4 = I7 = h3, w4 = I7, V4 = H4, I7 = f4 + iA2 | 0, I7 = (I7 = (H4 = L4 + CA2 | 0) >>> 0 < L4 >>> 0 ? I7 + 1 | 0 : I7) + w4 | 0, M4 = pA(V4 ^ (f4 = L4 = H4 + S4 | 0), (H4 = H4 >>> 0 > f4 >>> 0 ? I7 + 1 | 0 : I7) ^ M4, 32), I7 = t4 + (w4 = h3) | 0, iA2 = L4 = p4 + M4 | 0, p4 = I7 = p4 >>> 0 > L4 >>> 0 ? I7 + 1 | 0 : I7, J4 = L4 = pA(S4 ^ L4, J4 ^ I7, 24), I7 = (t4 = h3) + H4 | 0, I7 = (I7 = (f4 = f4 + L4 | 0) >>> 0 < L4 >>> 0 ? I7 + 1 | 0 : I7) + z4 | 0, z4 = pA((S4 = L4 = f4 + U4 | 0) ^ M4, (f4 = U4 >>> 0 > S4 >>> 0 ? I7 + 1 | 0 : I7) ^ w4, 16), I7 = (U4 = h3) + p4 | 0, iA2 = L4 = (H4 = z4) + iA2 | 0, w4 = pA(J4 ^ L4, (H4 = H4 >>> 0 > L4 >>> 0 ? I7 + 1 | 0 : I7) ^ t4, 63), p4 = h3, J4 = o4, I7 = _4 + k4 | 0, I7 = (I7 = (L4 = o4 + gA3 | 0) >>> 0 < o4 >>> 0 ? I7 + 1 | 0 : I7) + (t4 = i3[g6 + 196 >> 2]) | 0, l4 = pA((M4 = L4 = (o4 = L4) + i3[g6 + 192 >> 2] | 0) ^ BA3, (L4 = o4 >>> 0 > M4 >>> 0 ? I7 + 1 | 0 : I7) ^ l4, 32), I7 = D4 + (t4 = h3) | 0, _4 = k4, k4 = I7 = (o4 = m4 + l4 | 0) >>> 0 < m4 >>> 0 ? I7 + 1 | 0 : I7, D4 = I7 = pA(J4 ^ o4, _4 ^ I7, 24), m4 = l4, l4 = M4, M4 = I7, l4 = l4 + I7 | 0, I7 = (_4 = h3) + L4 | 0, I7 = AA4 + (l4 >>> 0 < M4 >>> 0 ? I7 + 1 | 0 : I7) | 0, gA3 = L4 = y4 + l4 | 0, AA4 = pA(m4 ^ L4, (M4 = y4 >>> 0 > L4 >>> 0 ? I7 + 1 | 0 : I7) ^ t4, 16), I7 = k4 + (l4 = h3) | 0, D4 = pA(D4 ^ (k4 = L4 = o4 + AA4 | 0), (t4 = _4) ^ (_4 = o4 >>> 0 > k4 >>> 0 ? I7 + 1 | 0 : I7), 63), L4 = h3, I7 = G4 + nA2 | 0, I7 = (I7 = (t4 = d4 + O4 | 0) >>> 0 < O4 >>> 0 ? I7 + 1 | 0 : I7) + F4 | 0, N4 = pA((y4 = t4 = t4 + N4 | 0) ^ W4, (t4 = t4 >>> 0 < N4 >>> 0 ? I7 + 1 | 0 : I7) ^ e4, 32), I7 = Y4 + (o4 = h3) | 0, e4 = G4, G4 = I7 = (F4 = R4 + N4 | 0) >>> 0 < R4 >>> 0 ? I7 + 1 | 0 : I7, e4 = pA(F4 ^ d4, e4 ^ I7, 24), R4 = I7 = h3, m4 = I7, I7 = t4 + E4 | 0, I7 = (I7 = (y4 = y4 + X4 | 0) >>> 0 < X4 >>> 0 ? I7 + 1 | 0 : I7) + m4 | 0, m4 = t4 = y4 + e4 | 0, d4 = pA(t4 ^ N4, (y4 = t4 >>> 0 < y4 >>> 0 ? I7 + 1 | 0 : I7) ^ o4, 16), I7 = G4 + (N4 = h3) | 0, o4 = pA((o4 = e4) ^ (e4 = t4 = F4 + d4 | 0), (t4 = t4 >>> 0 < F4 >>> 0 ? I7 + 1 | 0 : I7) ^ R4, 63), G4 = h3, I7 = c4 + B4 | 0, I7 = (I7 = (F4 = K4 + x4 | 0) >>> 0 < K4 >>> 0 ? I7 + 1 | 0 : I7) + u4 | 0, R4 = F4 = F4 + v4 | 0, r4 = pA(F4 ^ QA2, (v4 = F4 >>> 0 < v4 >>> 0 ? I7 + 1 | 0 : I7) ^ r4, 32), I7 = P4 + (F4 = h3) | 0, I7 = (u4 = b4 + r4 | 0) >>> 0 < b4 >>> 0 ? I7 + 1 | 0 : I7, b4 = c4, c4 = I7, P4 = pA(u4 ^ x4, b4 ^ I7, 24), Y4 = I7 = h3, b4 = I7, x4 = P4, I7 = v4 + C4 | 0, I7 = (I7 = (P4 = R4 + IA4 | 0) >>> 0 < IA4 >>> 0 ? I7 + 1 | 0 : I7) + b4 | 0, P4 = pA((R4 = v4 = x4 + P4 | 0) ^ r4, (v4 = v4 >>> 0 < P4 >>> 0 ? I7 + 1 | 0 : I7) ^ F4, 16), I7 = c4 + (F4 = h3) | 0, I7 = u4 >>> 0 > (b4 = u4 + P4 | 0) >>> 0 ? I7 + 1 | 0 : I7, u4 = b4, b4 = I7, r4 = pA(x4 ^ u4, I7 ^ Y4, 63), c4 = h3, J4 = D4, x4 = e4, Y4 = P4, I7 = f4 + fA2 | 0, I7 = (I7 = (P4 = S4 + j4 | 0) >>> 0 < j4 >>> 0 ? I7 + 1 | 0 : I7) + L4 | 0, D4 = pA(Y4 ^ (e4 = f4 = P4 + D4 | 0), (f4 = e4 >>> 0 < P4 >>> 0 ? I7 + 1 | 0 : I7) ^ F4, 32), I7 = (I7 = t4) + (t4 = h3) | 0, P4 = L4, L4 = I7 = (F4 = x4 + D4 | 0) >>> 0 < D4 >>> 0 ? I7 + 1 | 0 : I7, I7 = pA(J4 ^ F4, P4 ^ I7, 24), Y4 = i3[g6 + 220 >> 2], J4 = I7, x4 = D4, P4 = e4, e4 = I7, D4 = P4 + I7 | 0, I7 = (P4 = h3) + f4 | 0, I7 = (I7 = e4 >>> 0 > D4 >>> 0 ? I7 + 1 | 0 : I7) + Y4 | 0, x4 = pA(x4 ^ (S4 = f4 = (e4 = D4) + i3[g6 + 216 >> 2] | 0), (f4 = f4 >>> 0 < e4 >>> 0 ? I7 + 1 | 0 : I7) ^ t4, 16), I7 = L4 + (e4 = h3) | 0, I7 = (t4 = F4 + x4 | 0) >>> 0 < F4 >>> 0 ? I7 + 1 | 0 : I7, F4 = t4, D4 = P4, P4 = I7, L4 = pA(J4 ^ t4, D4 ^ I7, 63), t4 = h3, J4 = o4, I7 = G4 + M4 | 0, M4 = D4 = o4 + gA3 | 0, I7 = (I7 = D4 >>> 0 < o4 >>> 0 ? I7 + 1 | 0 : I7) + (Y4 = i3[g6 + 204 >> 2]) | 0, Y4 = pA((D4 = o4 = D4 + i3[g6 + 200 >> 2] | 0) ^ z4, (o4 = o4 >>> 0 < M4 >>> 0 ? I7 + 1 | 0 : I7) ^ U4, 32), I7 = b4 + (U4 = h3) | 0, I7 = u4 >>> 0 > (M4 = u4 + Y4 | 0) >>> 0 ? I7 + 1 | 0 : I7, u4 = G4, G4 = I7, b4 = pA(J4 ^ M4, u4 ^ I7, 24), z4 = I7 = h3, u4 = I7, J4 = b4, I7 = o4 + cA2 | 0, I7 = (I7 = (b4 = D4 + q4 | 0) >>> 0 < q4 >>> 0 ? I7 + 1 | 0 : I7) + u4 | 0, gA3 = o4 = J4 + b4 | 0, BA3 = pA(o4 ^ Y4, (u4 = U4) ^ (U4 = o4 >>> 0 < b4 >>> 0 ? I7 + 1 | 0 : I7), 16), I7 = G4 + (u4 = h3) | 0, I7 = (o4 = M4 + BA3 | 0) >>> 0 < M4 >>> 0 ? I7 + 1 | 0 : I7, M4 = o4, b4 = I7, o4 = pA(J4 ^ o4, I7 ^ z4, 63), G4 = h3, J4 = r4, I7 = c4 + y4 | 0, y4 = r4 = r4 + m4 | 0, I7 = (I7 = r4 >>> 0 < m4 >>> 0 ? I7 + 1 | 0 : I7) + (Y4 = z4 = i3[g6 + 156 >> 2]) | 0, Y4 = pA((r4 = m4 = (D4 = i3[g6 + 152 >> 2]) + r4 | 0) ^ AA4, (m4 = l4) ^ (l4 = y4 >>> 0 > r4 >>> 0 ? I7 + 1 | 0 : I7), 32), I7 = (I7 = H4) + (H4 = h3) | 0, I7 = (y4 = Y4) >>> 0 > (m4 = y4 + iA2 | 0) >>> 0 ? I7 + 1 | 0 : I7, y4 = c4, c4 = I7, iA2 = pA(J4 ^ m4, y4 ^ I7, 24), AA4 = I7 = h3, y4 = I7, J4 = iA2, I7 = l4 + a4 | 0, I7 = (I7 = (r4 = r4 + T4 | 0) >>> 0 < T4 >>> 0 ? I7 + 1 | 0 : I7) + y4 | 0, W4 = pA((iA2 = l4 = r4 + iA2 | 0) ^ Y4, (l4 = r4 >>> 0 > l4 >>> 0 ? I7 + 1 | 0 : I7) ^ H4, 16), I7 = c4 + (y4 = h3) | 0, Y4 = pA(J4 ^ (c4 = H4 = m4 + W4 | 0), (m4 = c4 >>> 0 < m4 >>> 0 ? I7 + 1 | 0 : I7) ^ AA4, 63), H4 = h3, J4 = w4, I7 = p4 + v4 | 0, v4 = r4 = w4 + R4 | 0, I7 = (I7 = r4 >>> 0 < w4 >>> 0 ? I7 + 1 | 0 : I7) + (AA4 = i3[g6 + 236 >> 2]) | 0, R4 = pA((r4 = w4 = r4 + i3[g6 + 232 >> 2] | 0) ^ d4, (v4 = r4 >>> 0 < v4 >>> 0 ? I7 + 1 | 0 : I7) ^ N4, 32), I7 = _4 + (N4 = h3) | 0, _4 = w4 = k4 + R4 | 0, w4 = pA(J4 ^ w4, (I7 = w4 >>> 0 < k4 >>> 0 ? I7 + 1 | 0 : I7) ^ p4, 24), p4 = I7, d4 = i3[g6 + 132 >> 2], V4 = w4, J4 = _4, I7 = (k4 = h3) + v4 | 0, I7 = (I7 = (r4 = w4 + r4 | 0) >>> 0 < w4 >>> 0 ? I7 + 1 | 0 : I7) + d4 | 0, I7 = (w4 = (_4 = i3[g6 + 128 >> 2]) + r4 | 0) >>> 0 < r4 >>> 0 ? I7 + 1 | 0 : I7, v4 = w4, r4 = N4, N4 = I7, AA4 = pA(w4 ^ R4, r4 ^ I7, 16), I7 = (I7 = p4) + (p4 = h3) | 0, I7 = (w4 = J4 + (r4 = AA4) | 0) >>> 0 < r4 >>> 0 ? I7 + 1 | 0 : I7, r4 = w4, w4 = k4, k4 = I7, J4 = I7 = pA(V4 ^ r4, w4 ^ I7, 63), R4 = I7, S4 = I7 + S4 | 0, I7 = (w4 = h3) + f4 | 0, I7 = d4 + (S4 >>> 0 < R4 >>> 0 ? I7 + 1 | 0 : I7) | 0, S4 = pA((R4 = f4 = _4 + S4 | 0) ^ BA3, (f4 = f4 >>> 0 < _4 >>> 0 ? I7 + 1 | 0 : I7) ^ u4, 32), I7 = m4 + (_4 = h3) | 0, I7 = c4 >>> 0 > (u4 = c4 + S4 | 0) >>> 0 ? I7 + 1 | 0 : I7, c4 = u4, u4 = w4, w4 = I7, u4 = pA(J4 ^ c4, u4 ^ I7, 24), d4 = I7 = h3, m4 = I7, J4 = u4, I7 = f4 + B4 | 0, I7 = (I7 = (u4 = R4 + K4 | 0) >>> 0 < K4 >>> 0 ? I7 + 1 | 0 : I7) + m4 | 0, BA3 = pA((R4 = f4 = J4 + u4 | 0) ^ S4, (f4 = f4 >>> 0 < u4 >>> 0 ? I7 + 1 | 0 : I7) ^ _4, 16), I7 = w4 + (_4 = h3) | 0, u4 = I7 = c4 >>> 0 > (m4 = c4 + BA3 | 0) >>> 0 ? I7 + 1 | 0 : I7, S4 = pA(J4 ^ m4, I7 ^ d4, 63), w4 = h3, J4 = L4, I7 = t4 + U4 | 0, I7 = (I7 = (c4 = L4 + gA3 | 0) >>> 0 < L4 >>> 0 ? I7 + 1 | 0 : I7) + (d4 = i3[g6 + 148 >> 2]) | 0, y4 = pA((d4 = L4 = c4 + i3[g6 + 144 >> 2] | 0) ^ W4, (L4 = c4 >>> 0 > L4 >>> 0 ? I7 + 1 | 0 : I7) ^ y4, 32), I7 = k4 + (c4 = h3) | 0, V4 = I7 = pA(J4 ^ (k4 = U4 = r4 + y4 | 0), (U4 = t4) ^ (t4 = r4 >>> 0 > k4 >>> 0 ? I7 + 1 | 0 : I7), 24), J4 = y4, y4 = I7, r4 = I7 + d4 | 0, I7 = (U4 = h3) + L4 | 0, I7 = z4 + (r4 >>> 0 < y4 >>> 0 ? I7 + 1 | 0 : I7) | 0, d4 = pA(J4 ^ (r4 = L4 = r4 + D4 | 0), (y4 = D4 >>> 0 > r4 >>> 0 ? I7 + 1 | 0 : I7) ^ c4, 16), I7 = t4 + (D4 = h3) | 0, t4 = U4, U4 = I7 = k4 >>> 0 > (L4 = k4 + d4 | 0) >>> 0 ? I7 + 1 | 0 : I7, t4 = pA(V4 ^ (k4 = L4), t4 ^ I7, 63), c4 = h3, J4 = o4, I7 = G4 + l4 | 0, I7 = (I7 = (L4 = o4 + iA2 | 0) >>> 0 < o4 >>> 0 ? I7 + 1 | 0 : I7) + (z4 = i3[g6 + 164 >> 2]) | 0, z4 = pA((l4 = L4 = (o4 = L4) + i3[g6 + 160 >> 2] | 0) ^ AA4, (L4 = o4 >>> 0 > l4 >>> 0 ? I7 + 1 | 0 : I7) ^ p4, 32), I7 = P4 + (o4 = h3) | 0, I7 = (p4 = F4 + z4 | 0) >>> 0 < F4 >>> 0 ? I7 + 1 | 0 : I7, F4 = G4, G4 = I7, P4 = pA(J4 ^ p4, F4 ^ I7, 24), iA2 = I7 = h3, F4 = I7, I7 = L4 + C4 | 0, I7 = (I7 = (l4 = l4 + IA4 | 0) >>> 0 < IA4 >>> 0 ? I7 + 1 | 0 : I7) + F4 | 0, J4 = z4, z4 = L4 = l4 + P4 | 0, gA3 = pA(J4 ^ L4, (F4 = l4 >>> 0 > L4 >>> 0 ? I7 + 1 | 0 : I7) ^ o4, 16), I7 = G4 + (l4 = h3) | 0, I7 = p4 >>> 0 > (L4 = p4 + gA3 | 0) >>> 0 ? I7 + 1 | 0 : I7, o4 = (p4 = L4) ^ P4, P4 = I7, o4 = pA(o4, I7 ^ iA2, 63), G4 = h3, J4 = Y4, I7 = H4 + E4 | 0, I7 = (I7 = (L4 = Y4 + X4 | 0) >>> 0 < X4 >>> 0 ? I7 + 1 | 0 : I7) + N4 | 0, e4 = pA((Y4 = L4 = v4 + L4 | 0) ^ x4, (L4 = v4 >>> 0 > L4 >>> 0 ? I7 + 1 | 0 : I7) ^ e4, 32), I7 = b4 + (v4 = h3) | 0, I7 = M4 >>> 0 > (N4 = M4 + e4 | 0) >>> 0 ? I7 + 1 | 0 : I7, M4 = N4, N4 = H4, H4 = I7, b4 = pA(J4 ^ M4, N4 ^ I7, 24), x4 = I7 = h3, N4 = I7, J4 = b4, I7 = L4 + nA2 | 0, I7 = (I7 = (b4 = Y4 + O4 | 0) >>> 0 < O4 >>> 0 ? I7 + 1 | 0 : I7) + N4 | 0, e4 = pA((N4 = L4 = J4 + b4 | 0) ^ e4, (Y4 = v4) ^ (v4 = b4 >>> 0 > N4 >>> 0 ? I7 + 1 | 0 : I7), 16), I7 = H4 + (b4 = h3) | 0, iA2 = L4 = M4 + e4 | 0, Y4 = pA(J4 ^ L4, (H4 = M4 >>> 0 > L4 >>> 0 ? I7 + 1 | 0 : I7) ^ x4, 63), L4 = h3, J4 = t4, I7 = c4 + f4 | 0, f4 = M4 = t4 + R4 | 0, I7 = (I7 = M4 >>> 0 < t4 >>> 0 ? I7 + 1 | 0 : I7) + (x4 = i3[g6 + 196 >> 2]) | 0, b4 = pA((M4 = e4) ^ (e4 = t4 = f4 + i3[g6 + 192 >> 2] | 0), (t4 = t4 >>> 0 < f4 >>> 0 ? I7 + 1 | 0 : I7) ^ b4, 32), I7 = P4 + (f4 = h3) | 0, P4 = c4, c4 = I7 = p4 >>> 0 > (M4 = p4 + b4 | 0) >>> 0 ? I7 + 1 | 0 : I7, I7 = pA(J4 ^ (p4 = M4), P4 ^ I7, 24), R4 = i3[g6 + 204 >> 2], V4 = I7, J4 = b4, b4 = I7, P4 = I7 + e4 | 0, I7 = (M4 = h3) + t4 | 0, I7 = (I7 = b4 >>> 0 > P4 >>> 0 ? I7 + 1 | 0 : I7) + R4 | 0, x4 = t4 = (b4 = P4) + i3[g6 + 200 >> 2] | 0, AA4 = pA(J4 ^ t4, (e4 = f4) ^ (f4 = t4 >>> 0 < b4 >>> 0 ? I7 + 1 | 0 : I7), 16), I7 = c4 + (b4 = h3) | 0, I7 = (t4 = p4 + AA4 | 0) >>> 0 < p4 >>> 0 ? I7 + 1 | 0 : I7, p4 = t4, c4 = M4, M4 = I7, t4 = pA(V4 ^ t4, c4 ^ I7, 63), c4 = h3, J4 = o4, I7 = y4 + G4 | 0, y4 = e4 = o4 + r4 | 0, I7 = (I7 = e4 >>> 0 < o4 >>> 0 ? I7 + 1 | 0 : I7) + (R4 = W4 = i3[g6 + 212 >> 2]) | 0, r4 = pA((e4 = o4 = (P4 = i3[g6 + 208 >> 2]) + e4 | 0) ^ BA3, (o4 = o4 >>> 0 < y4 >>> 0 ? I7 + 1 | 0 : I7) ^ _4, 32), I7 = (I7 = H4) + (H4 = h3) | 0, y4 = G4, G4 = I7 = r4 >>> 0 > (_4 = r4 + iA2 | 0) >>> 0 ? I7 + 1 | 0 : I7, I7 = pA(J4 ^ _4, y4 ^ I7, 24), R4 = i3[g6 + 220 >> 2], V4 = I7, J4 = r4, r4 = e4, e4 = I7, r4 = r4 + I7 | 0, I7 = (y4 = h3) + o4 | 0, I7 = (I7 = r4 >>> 0 < e4 >>> 0 ? I7 + 1 | 0 : I7) + R4 | 0, iA2 = o4 = r4 + i3[g6 + 216 >> 2] | 0, r4 = pA(J4 ^ o4, (e4 = o4 >>> 0 < r4 >>> 0 ? I7 + 1 | 0 : I7) ^ H4, 16), I7 = G4 + (R4 = h3) | 0, o4 = y4, y4 = I7 = (H4 = _4 + r4 | 0) >>> 0 < _4 >>> 0 ? I7 + 1 | 0 : I7, H4 = pA(V4 ^ (_4 = H4), o4 ^ I7, 63), o4 = h3, J4 = Y4, I7 = F4 + a4 | 0, I7 = (I7 = (G4 = T4 + z4 | 0) >>> 0 < T4 >>> 0 ? I7 + 1 | 0 : I7) + L4 | 0, F4 = I7 = (F4 = G4) >>> 0 > (G4 = F4 + Y4 | 0) >>> 0 ? I7 + 1 | 0 : I7, d4 = pA(G4 ^ d4, I7 ^ D4, 32), I7 = u4 + (D4 = h3) | 0, u4 = L4, L4 = I7 = m4 >>> 0 > (Y4 = m4 + d4 | 0) >>> 0 ? I7 + 1 | 0 : I7, Y4 = pA(J4 ^ (m4 = Y4), u4 ^ I7, 24), u4 = I7 = h3, J4 = Y4, I7 = I7 + F4 | 0, F4 = Y4 = G4 + Y4 | 0, I7 = (I7 = Y4 >>> 0 < G4 >>> 0 ? I7 + 1 | 0 : I7) + (z4 = i3[g6 + 236 >> 2]) | 0, Y4 = d4, d4 = G4 = F4 + i3[g6 + 232 >> 2] | 0, z4 = pA(Y4 ^ G4, (F4 = F4 >>> 0 > G4 >>> 0 ? I7 + 1 | 0 : I7) ^ D4, 16), I7 = L4 + (D4 = h3) | 0, m4 = I7 = (G4 = m4 + z4 | 0) >>> 0 < m4 >>> 0 ? I7 + 1 | 0 : I7, Y4 = pA(J4 ^ G4, I7 ^ u4, 63), L4 = h3, J4 = S4, I7 = w4 + cA2 | 0, I7 = (I7 = (u4 = S4 + q4 | 0) >>> 0 < q4 >>> 0 ? I7 + 1 | 0 : I7) + v4 | 0, I7 = (u4 = u4 + N4 | 0) >>> 0 < N4 >>> 0 ? I7 + 1 | 0 : I7, N4 = u4, v4 = I7, S4 = pA(u4 ^ gA3, I7 ^ l4, 32), I7 = U4 + (l4 = h3) | 0, I7 = (u4 = k4 + S4 | 0) >>> 0 < k4 >>> 0 ? I7 + 1 | 0 : I7, k4 = u4, u4 = w4, w4 = I7, u4 = pA(J4 ^ k4, u4 ^ I7, 24), gA3 = I7 = h3, U4 = I7, J4 = u4, I7 = v4 + fA2 | 0, I7 = (I7 = (u4 = N4 + j4 | 0) >>> 0 < j4 >>> 0 ? I7 + 1 | 0 : I7) + U4 | 0, U4 = I7 = u4 >>> 0 > (v4 = J4 + u4 | 0) >>> 0 ? I7 + 1 | 0 : I7, S4 = pA(v4 ^ S4, I7 ^ l4, 16), I7 = w4 + (l4 = h3) | 0, I7 = (u4 = k4 + S4 | 0) >>> 0 < k4 >>> 0 ? I7 + 1 | 0 : I7, k4 = u4, u4 = I7, N4 = pA(J4 ^ k4, I7 ^ gA3, 63), gA3 = I7 = h3, w4 = I7, J4 = r4, I7 = f4 + cA2 | 0, f4 = r4 = x4 + q4 | 0, I7 = (I7 = r4 >>> 0 < q4 >>> 0 ? I7 + 1 | 0 : I7) + w4 | 0, R4 = pA(J4 ^ (r4 = q4 = r4 + N4 | 0), (q4 = f4 >>> 0 > r4 >>> 0 ? I7 + 1 | 0 : I7) ^ R4, 32), I7 = m4 + (w4 = h3) | 0, I7 = (f4 = G4 + R4 | 0) >>> 0 < G4 >>> 0 ? I7 + 1 | 0 : I7, G4 = f4, f4 = I7, x4 = I7 = pA(N4 ^ G4, gA3 ^ I7, 24), N4 = I7, r4 = I7 + r4 | 0, I7 = (m4 = h3) + q4 | 0, I7 = W4 + (r4 >>> 0 < N4 >>> 0 ? I7 + 1 | 0 : I7) | 0, R4 = pA((r4 = q4 = r4 + P4 | 0) ^ R4, (N4 = P4 >>> 0 > r4 >>> 0 ? I7 + 1 | 0 : I7) ^ w4, 16), I7 = f4 + (P4 = h3) | 0, G4 = pA(x4 ^ (f4 = q4 = G4 + R4 | 0), (w4 = m4) ^ (m4 = G4 >>> 0 > f4 >>> 0 ? I7 + 1 | 0 : I7), 63), w4 = h3, J4 = t4, I7 = c4 + e4 | 0, I7 = (I7 = (q4 = t4 + iA2 | 0) >>> 0 < t4 >>> 0 ? I7 + 1 | 0 : I7) + (x4 = i3[g6 + 164 >> 2]) | 0, D4 = pA((x4 = q4 = (t4 = q4) + i3[g6 + 160 >> 2] | 0) ^ z4, (q4 = t4 >>> 0 > x4 >>> 0 ? I7 + 1 | 0 : I7) ^ D4, 32), I7 = u4 + (t4 = h3) | 0, I7 = (e4 = k4 + D4 | 0) >>> 0 < k4 >>> 0 ? I7 + 1 | 0 : I7, k4 = e4, u4 = c4, c4 = I7, I7 = pA(J4 ^ e4, u4 ^ I7, 24), z4 = i3[g6 + 196 >> 2], V4 = I7, J4 = D4, e4 = I7, D4 = I7 + x4 | 0, I7 = (u4 = h3) + q4 | 0, I7 = (I7 = e4 >>> 0 > D4 >>> 0 ? I7 + 1 | 0 : I7) + z4 | 0, x4 = pA(J4 ^ (D4 = q4 = (e4 = D4) + i3[g6 + 192 >> 2] | 0), (x4 = t4) ^ (t4 = e4 >>> 0 > D4 >>> 0 ? I7 + 1 | 0 : I7), 16), I7 = c4 + (z4 = h3) | 0, u4 = pA(V4 ^ (c4 = q4 = k4 + x4 | 0), (k4 = k4 >>> 0 > c4 >>> 0 ? I7 + 1 | 0 : I7) ^ u4, 63), q4 = h3, J4 = H4, I7 = o4 + F4 | 0, F4 = e4 = H4 + d4 | 0, I7 = (I7 = e4 >>> 0 < H4 >>> 0 ? I7 + 1 | 0 : I7) + (cA2 = i3[g6 + 204 >> 2]) | 0, S4 = pA((e4 = H4 = e4 + i3[g6 + 200 >> 2] | 0) ^ S4, (H4 = F4 >>> 0 > e4 >>> 0 ? I7 + 1 | 0 : I7) ^ l4, 32), I7 = M4 + (F4 = h3) | 0, I7 = p4 >>> 0 > (l4 = p4 + S4 | 0) >>> 0 ? I7 + 1 | 0 : I7, p4 = l4, l4 = o4, o4 = I7, l4 = pA(J4 ^ p4, l4 ^ I7, 24), d4 = I7 = h3, M4 = I7, J4 = l4, I7 = H4 + fA2 | 0, I7 = (I7 = (l4 = e4 + j4 | 0) >>> 0 < j4 >>> 0 ? I7 + 1 | 0 : I7) + M4 | 0, S4 = pA((e4 = j4 = J4 + (H4 = l4) | 0) ^ S4, (l4 = F4) ^ (F4 = H4 >>> 0 > e4 >>> 0 ? I7 + 1 | 0 : I7), 16), I7 = o4 + (M4 = h3) | 0, j4 = pA(J4 ^ (o4 = j4 = p4 + S4 | 0), (p4 = p4 >>> 0 > o4 >>> 0 ? I7 + 1 | 0 : I7) ^ d4, 63), H4 = h3, J4 = Y4, I7 = U4 + L4 | 0, I7 = (I7 = (l4 = v4 + Y4 | 0) >>> 0 < v4 >>> 0 ? I7 + 1 | 0 : I7) + (d4 = i3[g6 + 236 >> 2]) | 0, b4 = pA((Y4 = v4 = l4 + i3[g6 + 232 >> 2] | 0) ^ AA4, (v4 = v4 >>> 0 < l4 >>> 0 ? I7 + 1 | 0 : I7) ^ b4, 32), I7 = y4 + (U4 = h3) | 0, I7 = _4 >>> 0 > (l4 = _4 + b4 | 0) >>> 0 ? I7 + 1 | 0 : I7, _4 = l4, l4 = L4, L4 = I7, y4 = pA(J4 ^ _4, l4 ^ I7, 24), l4 = I7 = h3, d4 = y4, I7 = v4 + E4 | 0, I7 = (I7 = (y4 = Y4 + X4 | 0) >>> 0 < X4 >>> 0 ? I7 + 1 | 0 : I7) + l4 | 0, I7 = y4 >>> 0 > (X4 = d4 + y4 | 0) >>> 0 ? I7 + 1 | 0 : I7, y4 = U4, U4 = I7, b4 = pA((v4 = X4) ^ b4, y4 ^ I7, 16), I7 = L4 + (Y4 = h3) | 0, y4 = l4, l4 = I7 = _4 >>> 0 > (X4 = _4 + b4 | 0) >>> 0 ? I7 + 1 | 0 : I7, X4 = pA(d4 ^ (_4 = X4), y4 ^ I7, 63), L4 = h3, I7 = N4 + B4 | 0, I7 = (I7 = (y4 = r4 + K4 | 0) >>> 0 < K4 >>> 0 ? I7 + 1 | 0 : I7) + q4 | 0, I7 = y4 >>> 0 > (K4 = y4 + u4 | 0) >>> 0 ? I7 + 1 | 0 : I7, N4 = K4, y4 = T4 + K4 | 0, K4 = I7, I7 = a4 + I7 | 0, T4 = (r4 = y4) >>> 0 < T4 >>> 0 ? I7 + 1 | 0 : I7, y4 = u4, u4 = pA(b4 ^ N4, Y4 ^ K4, 32), I7 = p4 + (N4 = h3) | 0, q4 = (o4 = b4 = pA(y4 ^ (p4 = K4 = o4 + u4 | 0), (K4 = o4 >>> 0 > p4 >>> 0 ? I7 + 1 | 0 : I7) ^ q4, 24)) + r4 | 0, I7 = (r4 = h3) + T4 | 0, I7 = o4 >>> 0 > q4 >>> 0 ? I7 + 1 | 0 : I7, o4 = q4, i3[g6 >> 2] = o4, i3[g6 + 4 >> 2] = I7, q4 = I7, I7 = pA(o4 ^ u4, I7 ^ N4, 16), y4 = T4 = h3, i3[g6 + 120 >> 2] = I7, i3[g6 + 124 >> 2] = y4, T4 = I7, p4 = I7 + p4 | 0, I7 = y4 + K4 | 0, i3[g6 + 80 >> 2] = p4, I7 = p4 >>> 0 < T4 >>> 0 ? I7 + 1 | 0 : I7, i3[g6 + 84 >> 2] = I7, sA2 = g6, wA2 = pA(b4 ^ p4, I7 ^ r4, 63), i3[sA2 + 40 >> 2] = wA2, i3[g6 + 44 >> 2] = h3, r4 = j4, I7 = t4 + H4 | 0, I7 = (K4 = D4 + j4 | 0) >>> 0 < j4 >>> 0 ? I7 + 1 | 0 : I7, j4 = K4, I7 = I7 + (T4 = i3[g6 + 132 >> 2]) | 0, j4 = I7 = (K4 = K4 + i3[g6 + 128 >> 2] | 0) >>> 0 < j4 >>> 0 ? I7 + 1 | 0 : I7, t4 = pA(K4 ^ R4, I7 ^ P4, 32), I7 = l4 + (p4 = h3) | 0, I7 = _4 >>> 0 > (T4 = _4 + t4 | 0) >>> 0 ? I7 + 1 | 0 : I7, _4 = T4, T4 = I7, l4 = pA(r4 ^ _4, I7 ^ H4, 24), I7 = j4 + (y4 = h3) | 0, I7 = (H4 = l4 + K4 | 0) >>> 0 < K4 >>> 0 ? I7 + 1 | 0 : I7, K4 = (j4 = i3[g6 + 144 >> 2]) + H4 | 0, I7 = i3[g6 + 148 >> 2] + I7 | 0, I7 = K4 >>> 0 < j4 >>> 0 ? I7 + 1 | 0 : I7, i3[g6 + 8 >> 2] = K4, i3[g6 + 12 >> 2] = I7, I7 = pA(t4 ^ K4, I7 ^ p4, 16), H4 = K4 = h3, i3[g6 + 96 >> 2] = I7, i3[g6 + 100 >> 2] = H4, K4 = I7, j4 = I7 + _4 | 0, I7 = H4 + T4 | 0, I7 = K4 >>> 0 > j4 >>> 0 ? I7 + 1 | 0 : I7, K4 = j4, i3[g6 + 88 >> 2] = K4, i3[g6 + 92 >> 2] = I7, sA2 = g6, wA2 = pA(l4 ^ K4, I7 ^ y4, 63), i3[sA2 + 48 >> 2] = wA2, i3[g6 + 52 >> 2] = h3, r4 = O4, I7 = F4 + L4 | 0, O4 = K4 = e4 + X4 | 0, I7 = (I7 = K4 >>> 0 < X4 >>> 0 ? I7 + 1 | 0 : I7) + (j4 = i3[g6 + 220 >> 2]) | 0, T4 = K4 = K4 + i3[g6 + 216 >> 2] | 0, j4 = r4 + K4 | 0, K4 = I7 = K4 >>> 0 < O4 >>> 0 ? I7 + 1 | 0 : I7, I7 = I7 + nA2 | 0, j4 = (H4 = j4) >>> 0 < T4 >>> 0 ? I7 + 1 | 0 : I7, r4 = H4, T4 = pA(x4 ^ T4, K4 ^ z4, 32), I7 = m4 + (H4 = h3) | 0, L4 = pA((t4 = K4 = f4 + T4 | 0) ^ X4, (K4 = f4 >>> 0 > t4 >>> 0 ? I7 + 1 | 0 : I7) ^ L4, 24), I7 = (p4 = h3) + j4 | 0, I7 = L4 >>> 0 > (X4 = r4 + L4 | 0) >>> 0 ? I7 + 1 | 0 : I7, i3[g6 + 16 >> 2] = X4, i3[g6 + 20 >> 2] = I7, I7 = pA(X4 ^ T4, I7 ^ H4, 16), O4 = X4 = h3, i3[g6 + 104 >> 2] = I7, i3[g6 + 108 >> 2] = X4, X4 = I7, j4 = I7 + t4 | 0, I7 = K4 + O4 | 0, K4 = j4, i3[g6 + 64 >> 2] = K4, I7 = X4 >>> 0 > K4 >>> 0 ? I7 + 1 | 0 : I7, i3[g6 + 68 >> 2] = I7, sA2 = g6, wA2 = pA(L4 ^ K4, I7 ^ p4, 63), i3[sA2 + 56 >> 2] = wA2, i3[g6 + 60 >> 2] = h3, I7 = w4 + C4 | 0, I7 = (I7 = (K4 = G4 + IA4 | 0) >>> 0 < G4 >>> 0 ? I7 + 1 | 0 : I7) + U4 | 0, X4 = I7 = v4 >>> 0 > (K4 = v4 + K4 | 0) >>> 0 ? I7 + 1 | 0 : I7, T4 = pA(K4 ^ S4, I7 ^ M4, 32), I7 = k4 + (L4 = h3) | 0, IA4 = I7 = c4 >>> 0 > (j4 = c4 + T4 | 0) >>> 0 ? I7 + 1 | 0 : I7, H4 = pA(j4 ^ G4, I7 ^ w4, 24), I7 = X4 + (t4 = h3) | 0, I7 = K4 >>> 0 > (O4 = K4 + H4 | 0) >>> 0 ? I7 + 1 | 0 : I7, K4 = (X4 = i3[g6 + 152 >> 2]) + O4 | 0, I7 = i3[g6 + 156 >> 2] + I7 | 0, I7 = K4 >>> 0 < X4 >>> 0 ? I7 + 1 | 0 : I7, i3[g6 + 24 >> 2] = K4, i3[g6 + 28 >> 2] = I7, I7 = pA(K4 ^ T4, I7 ^ L4, 16), i3[g6 + 112 >> 2] = I7, X4 = h3, i3[g6 + 116 >> 2] = X4, K4 = I7 + j4 | 0, I7 = X4 + IA4 | 0, I7 = K4 >>> 0 < j4 >>> 0 ? I7 + 1 | 0 : I7, i3[g6 + 72 >> 2] = K4, i3[g6 + 76 >> 2] = I7, sA2 = g6, wA2 = pA(H4 ^ K4, I7 ^ t4, 63), i3[sA2 + 32 >> 2] = wA2, i3[g6 + 36 >> 2] = h3, I7 = i3[g6 + 68 >> 2] ^ (n3[A8 + 4 | 0] | n3[A8 + 5 | 0] << 8 | n3[A8 + 6 | 0] << 16 | n3[A8 + 7 | 0] << 24) ^ q4, K4 = i3[g6 + 64 >> 2] ^ (n3[0 | A8] | n3[A8 + 1 | 0] << 8 | n3[A8 + 2 | 0] << 16 | n3[A8 + 3 | 0] << 24) ^ o4, Q3[0 | A8] = K4, Q3[A8 + 1 | 0] = K4 >>> 8, Q3[A8 + 2 | 0] = K4 >>> 16, Q3[A8 + 3 | 0] = K4 >>> 24, Q3[A8 + 4 | 0] = I7, Q3[A8 + 5 | 0] = I7 >>> 8, Q3[A8 + 6 | 0] = I7 >>> 16, Q3[A8 + 7 | 0] = I7 >>> 24, X4 = 1; I7 = (K4 = X4 << 3) + A8 | 0, q4 = i3[(K4 = g6 + K4 | 0) >> 2] ^ (n3[0 | I7] | n3[I7 + 1 | 0] << 8 | n3[I7 + 2 | 0] << 16 | n3[I7 + 3 | 0] << 24), IA4 = i3[(j4 = K4 - -64 | 0) >> 2], K4 = i3[j4 + 4 >> 2] ^ i3[K4 + 4 >> 2] ^ (n3[I7 + 4 | 0] | n3[I7 + 5 | 0] << 8 | n3[I7 + 6 | 0] << 16 | n3[I7 + 7 | 0] << 24), q4 ^= IA4, Q3[0 | I7] = q4, Q3[I7 + 1 | 0] = q4 >>> 8, Q3[I7 + 2 | 0] = q4 >>> 16, Q3[I7 + 3 | 0] = q4 >>> 24, Q3[I7 + 4 | 0] = K4, Q3[I7 + 5 | 0] = K4 >>> 8, Q3[I7 + 6 | 0] = K4 >>> 16, Q3[I7 + 7 | 0] = K4 >>> 24, (0 | (X4 = X4 + 1 | 0)) != 8; )
                          ;
                        s3 = g6 + 256 | 0;
                      }
                      function u3(A8, I7, g6, B4, C4, E4, a4) {
                        var r4, o4, t4, e4, f4, c4, y4, w4, D4, p4, u4, F4, _4, k4, H4, G4, U4, S4, b4, m4, v4, M4, P4, Y4, N4, R4, d4, J4, x4, L4, K4, X4, T4, V4, q4, j4, W4, O4, Z4, $4, AA4, IA4 = 0, gA3 = 0, CA2 = 0, QA2 = 0, EA2 = 0, iA2 = 0, nA2 = 0, aA2 = 0, rA2 = 0, oA2 = 0, tA2 = 0, eA2 = 0, fA2 = 0, cA2 = 0, yA2 = 0, sA2 = 0, wA2 = 0, DA2 = 0, hA2 = 0, pA2 = 0, uA2 = 0, FA2 = 0, lA2 = 0, _A2 = 0, kA2 = 0, HA2 = 0, GA2 = 0, UA2 = 0, SA2 = 0, bA2 = 0, mA2 = 0, vA2 = 0, PA2 = 0, YA2 = 0, NA2 = 0, RA2 = 0, dA2 = 0, JA2 = 0, xA2 = 0, LA2 = 0, KA2 = 0, XA2 = 0, TA2 = 0, VA2 = 0, zA2 = 0, jA2 = 0, WA2 = 0, OA2 = 0, ZA2 = 0, $A2 = 0, AI2 = 0, gI2 = 0, BI2 = 0;
                        return s3 = R4 = s3 - 560 | 0, WI(rA2 = R4 + 352 | 0, a4), _I(d4 = R4 + 288 | 0, E4, 32, 0), z3(rA2, R4 + 320 | 0, 32, 0), z3(rA2, g6, B4, C4), MA(rA2, r4 = R4 + 224 | 0), IA4 = n3[E4 + 32 | 0] | n3[E4 + 33 | 0] << 8 | n3[E4 + 34 | 0] << 16 | n3[E4 + 35 | 0] << 24, QA2 = n3[E4 + 36 | 0] | n3[E4 + 37 | 0] << 8 | n3[E4 + 38 | 0] << 16 | n3[E4 + 39 | 0] << 24, nA2 = n3[E4 + 40 | 0] | n3[E4 + 41 | 0] << 8 | n3[E4 + 42 | 0] << 16 | n3[E4 + 43 | 0] << 24, gA3 = n3[E4 + 44 | 0] | n3[E4 + 45 | 0] << 8 | n3[E4 + 46 | 0] << 16 | n3[E4 + 47 | 0] << 24, EA2 = n3[E4 + 48 | 0] | n3[E4 + 49 | 0] << 8 | n3[E4 + 50 | 0] << 16 | n3[E4 + 51 | 0] << 24, iA2 = n3[E4 + 52 | 0] | n3[E4 + 53 | 0] << 8 | n3[E4 + 54 | 0] << 16 | n3[E4 + 55 | 0] << 24, oA2 = n3[E4 + 60 | 0] | n3[E4 + 61 | 0] << 8 | n3[E4 + 62 | 0] << 16 | n3[E4 + 63 | 0] << 24, E4 = n3[E4 + 56 | 0] | n3[E4 + 57 | 0] << 8 | n3[E4 + 58 | 0] << 16 | n3[E4 + 59 | 0] << 24, Q3[A8 + 56 | 0] = E4, Q3[A8 + 57 | 0] = E4 >>> 8, Q3[A8 + 58 | 0] = E4 >>> 16, Q3[A8 + 59 | 0] = E4 >>> 24, Q3[A8 + 60 | 0] = oA2, Q3[A8 + 61 | 0] = oA2 >>> 8, Q3[A8 + 62 | 0] = oA2 >>> 16, Q3[A8 + 63 | 0] = oA2 >>> 24, E4 = EA2, Q3[A8 + 48 | 0] = E4, Q3[A8 + 49 | 0] = E4 >>> 8, Q3[A8 + 50 | 0] = E4 >>> 16, Q3[A8 + 51 | 0] = E4 >>> 24, E4 = iA2, Q3[A8 + 52 | 0] = E4, Q3[A8 + 53 | 0] = E4 >>> 8, Q3[A8 + 54 | 0] = E4 >>> 16, Q3[A8 + 55 | 0] = E4 >>> 24, E4 = nA2, Q3[A8 + 40 | 0] = E4, Q3[A8 + 41 | 0] = E4 >>> 8, Q3[A8 + 42 | 0] = E4 >>> 16, Q3[A8 + 43 | 0] = E4 >>> 24, E4 = gA3, Q3[A8 + 44 | 0] = E4, Q3[A8 + 45 | 0] = E4 >>> 8, Q3[A8 + 46 | 0] = E4 >>> 16, Q3[A8 + 47 | 0] = E4 >>> 24, Q3[0 | (E4 = A8 + 32 | 0)] = IA4, Q3[E4 + 1 | 0] = IA4 >>> 8, Q3[E4 + 2 | 0] = IA4 >>> 16, Q3[E4 + 3 | 0] = IA4 >>> 24, IA4 = QA2, Q3[E4 + 4 | 0] = IA4, Q3[E4 + 5 | 0] = IA4 >>> 8, Q3[E4 + 6 | 0] = IA4 >>> 16, Q3[E4 + 7 | 0] = IA4 >>> 24, l3(r4), BA2(R4, r4), II(A8, R4), WI(rA2, a4), z3(rA2, A8, 64, 0), z3(rA2, g6, B4, C4), MA(rA2, A8 = R4 + 160 | 0), l3(A8), Q3[0 | d4] = 248 & n3[0 | d4], Q3[d4 + 31 | 0] = 63 & n3[d4 + 31 | 0] | 64, TA2 = uI(A8), nA2 = n3[A8 + 2 | 0] | n3[A8 + 3 | 0] << 8 | n3[A8 + 4 | 0] << 16 | n3[A8 + 5 | 0] << 24, SA2 = uI(A8 + 5 | 0), EA2 = h3, gA3 = n3[A8 + 7 | 0] | n3[A8 + 8 | 0] << 8 | n3[A8 + 9 | 0] << 16 | n3[A8 + 10 | 0] << 24, rA2 = n3[A8 + 10 | 0] | n3[A8 + 11 | 0] << 8 | n3[A8 + 12 | 0] << 16 | n3[A8 + 13 | 0] << 24, LA2 = uI(A8 + 13 | 0), oA2 = h3, aA2 = n3[A8 + 15 | 0] | n3[A8 + 16 | 0] << 8 | n3[A8 + 17 | 0] << 16 | n3[A8 + 18 | 0] << 24, bA2 = uI(A8 + 18 | 0), cA2 = h3, NA2 = uI(A8 + 21 | 0), B4 = n3[A8 + 23 | 0] | n3[A8 + 24 | 0] << 8 | n3[A8 + 25 | 0] << 16 | n3[A8 + 26 | 0] << 24, iA2 = uI(A8 + 26 | 0), g6 = h3, C4 = n3[A8 + 28 | 0] | n3[A8 + 29 | 0] << 8 | n3[A8 + 30 | 0] << 16 | n3[A8 + 31 | 0] << 24, KA2 = uI(d4), uA2 = n3[(A8 = d4) + 2 | 0] | n3[A8 + 3 | 0] << 8 | n3[A8 + 4 | 0] << 16 | n3[A8 + 5 | 0] << 24, RA2 = uI(A8 + 5 | 0), kA2 = h3, fA2 = n3[A8 + 7 | 0] | n3[A8 + 8 | 0] << 8 | n3[A8 + 9 | 0] << 16 | n3[A8 + 10 | 0] << 24, tA2 = n3[A8 + 10 | 0] | n3[A8 + 11 | 0] << 8 | n3[A8 + 12 | 0] << 16 | n3[A8 + 13 | 0] << 24, jA2 = uI(A8 + 13 | 0), FA2 = h3, sA2 = n3[A8 + 15 | 0] | n3[A8 + 16 | 0] << 8 | n3[A8 + 17 | 0] << 16 | n3[A8 + 18 | 0] << 24, VA2 = uI(A8 + 18 | 0), hA2 = h3, dA2 = uI(A8 + 21 | 0), a4 = n3[A8 + 23 | 0] | n3[A8 + 24 | 0] << 8 | n3[A8 + 25 | 0] << 16 | n3[A8 + 26 | 0] << 24, eA2 = uI(A8 + 26 | 0), IA4 = h3, QA2 = n3[A8 + 28 | 0] | n3[A8 + 29 | 0] << 8 | n3[A8 + 30 | 0] << 16 | n3[A8 + 31 | 0] << 24, W4 = uI(r4), O4 = n3[(A8 = r4) + 2 | 0] | n3[A8 + 3 | 0] << 8 | n3[A8 + 4 | 0] << 16 | n3[A8 + 5 | 0] << 24, Z4 = uI(A8 + 5 | 0), $4 = h3, AA4 = n3[A8 + 7 | 0] | n3[A8 + 8 | 0] << 8 | n3[A8 + 9 | 0] << 16 | n3[A8 + 10 | 0] << 24, PA2 = n3[A8 + 10 | 0] | n3[A8 + 11 | 0] << 8 | n3[A8 + 12 | 0] << 16 | n3[A8 + 13 | 0] << 24, $A2 = uI(A8 + 13 | 0), HA2 = h3, DA2 = n3[A8 + 15 | 0] | n3[A8 + 16 | 0] << 8 | n3[A8 + 17 | 0] << 16 | n3[A8 + 18 | 0] << 24, AI2 = uI(A8 + 18 | 0), yA2 = h3, JA2 = uI(A8 + 21 | 0), A8 = qA(o4 = QA2 >>> 7 | 0, 0, t4 = 2097151 & ((3 & (A8 = g6)) << 30 | (g6 = iA2) >>> 2), 0), g6 = h3, QA2 = A8, C4 = qA(e4 = 2097151 & ((3 & (A8 = IA4)) << 30 | (IA4 = eA2) >>> 2), 0, f4 = C4 >>> 7 | 0, 0), g6 = h3 + g6 | 0, QA2 = A8 = QA2 + C4 | 0, IA4 = A8 >>> 0 < C4 >>> 0 ? g6 + 1 | 0 : g6, A8 = qA(t4, CA2, e4, CA2), C4 = h3, g6 = (a4 = qA(c4 = a4 >>> 5 & 2097151, 0, f4, 0)) + A8 | 0, A8 = h3 + C4 | 0, A8 = g6 >>> 0 < a4 >>> 0 ? A8 + 1 | 0 : A8, C4 = qA(o4, 0, y4 = B4 >>> 5 & 2097151, 0), B4 = h3 + A8 | 0, B4 = (g6 = C4 + g6 | 0) >>> 0 < C4 >>> 0 ? B4 + 1 | 0 : B4, C4 = g6, mA2 = B4, wA2 = A8 = B4 - ((g6 >>> 0 < 4293918720) - 1 | 0) | 0, a4 = (2097151 & A8) << 11 | (iA2 = g6 - -1048576 | 0) >>> 21, A8 = (A8 >> 21) + IA4 | 0, A8 = (B4 = a4 + QA2 | 0) >>> 0 < a4 >>> 0 ? A8 + 1 | 0 : A8, a4 = B4, GA2 = A8, vA2 = IA4 = A8 - ((B4 >>> 0 < 4293918720) - 1 | 0) | 0, g6 = IA4 >> 21, UA2 = (A8 = qA(o4, 0, f4, 0)) - (lA2 = -2097152 & (pA2 = A8 - -1048576 | 0)) | 0, A8 = ((eA2 = h3) - ((A8 >>> 0 < lA2 >>> 0) + (B4 = eA2 - ((A8 >>> 0 < 4293918720) - 1 | 0) | 0) | 0) | 0) + g6 | 0, T4 = IA4 = UA2 + ((2097151 & IA4) << 11 | (QA2 = a4 - -1048576 | 0) >>> 21) | 0, eA2 = A8 = IA4 >>> 0 < UA2 >>> 0 ? A8 + 1 | 0 : A8, g6 = qA(IA4, A8, -683901, -1), IA4 = h3, J4 = (2097151 & B4) << 11 | pA2 >>> 21, pA2 = A8 = B4 >> 21, A8 = (B4 = qA(J4, A8, 136657, 0)) + g6 | 0, g6 = h3 + IA4 | 0, UA2 = A8, lA2 = A8 >>> 0 < B4 >>> 0 ? g6 + 1 | 0 : g6, A8 = qA(w4 = 2097151 & ((1 & (A8 = FA2)) << 31 | jA2 >>> 1), 0, t4, CA2), g6 = h3, IA4 = qA(D4 = tA2 >>> 4 & 2097151, 0, f4, 0), B4 = h3 + g6 | 0, B4 = (A8 = IA4 + A8 | 0) >>> 0 < IA4 >>> 0 ? B4 + 1 | 0 : B4, IA4 = qA(p4 = sA2 >>> 6 & 2097151, 0, y4, 0), g6 = h3 + B4 | 0, g6 = (A8 = IA4 + A8 | 0) >>> 0 < IA4 >>> 0 ? g6 + 1 | 0 : g6, FA2 = A8, IA4 = qA(u4 = 2097151 & dA2, B4 = 0, F4 = 2097151 & ((7 & (A8 = cA2)) << 29 | bA2 >>> 3), 0), A8 = h3 + g6 | 0, g6 = A8 = (B4 = FA2 + IA4 | 0) >>> 0 < IA4 >>> 0 ? A8 + 1 | 0 : A8, A8 = (IA4 = qA(_4 = 2097151 & ((7 & (A8 = hA2)) << 29 | VA2 >>> 3), 0, k4 = 2097151 & NA2, 0)) + B4 | 0, B4 = h3 + g6 | 0, B4 = A8 >>> 0 < IA4 >>> 0 ? B4 + 1 | 0 : B4, IA4 = qA(c4, 0, H4 = aA2 >>> 6 & 2097151, 0), g6 = h3 + B4 | 0, g6 = (A8 = IA4 + A8 | 0) >>> 0 < IA4 >>> 0 ? g6 + 1 | 0 : g6, B4 = A8, IA4 = qA(e4, CA2, G4 = 2097151 & ((1 & (A8 = oA2)) << 31 | LA2 >>> 1), 0), A8 = h3 + g6 | 0, A8 = (B4 = B4 + IA4 | 0) >>> 0 < IA4 >>> 0 ? A8 + 1 | 0 : A8, g6 = (IA4 = qA(o4, 0, U4 = rA2 >>> 4 & 2097151, 0)) + B4 | 0, B4 = h3 + A8 | 0, cA2 = g6, rA2 = g6 >>> 0 < IA4 >>> 0 ? B4 + 1 | 0 : B4, A8 = qA(t4, CA2, D4, 0), g6 = h3, B4 = qA(S4 = fA2 >>> 7 & 2097151, 0, f4, 0), g6 = h3 + g6 | 0, g6 = (A8 = B4 + A8 | 0) >>> 0 < B4 >>> 0 ? g6 + 1 | 0 : g6, B4 = (IA4 = qA(y4, 0, w4, CA2)) + A8 | 0, A8 = h3 + g6 | 0, A8 = B4 >>> 0 < IA4 >>> 0 ? A8 + 1 | 0 : A8, g6 = (IA4 = qA(p4, 0, k4, CA2)) + B4 | 0, B4 = h3 + A8 | 0, B4 = g6 >>> 0 < IA4 >>> 0 ? B4 + 1 | 0 : B4, A8 = (IA4 = qA(u4, CA2, H4, 0)) + g6 | 0, g6 = h3 + B4 | 0, g6 = A8 >>> 0 < IA4 >>> 0 ? g6 + 1 | 0 : g6, B4 = (IA4 = qA(F4, CA2, _4, CA2)) + A8 | 0, A8 = h3 + g6 | 0, A8 = B4 >>> 0 < IA4 >>> 0 ? A8 + 1 | 0 : A8, IA4 = qA(c4, 0, G4, CA2), g6 = h3 + A8 | 0, g6 = (B4 = IA4 + B4 | 0) >>> 0 < IA4 >>> 0 ? g6 + 1 | 0 : g6, IA4 = qA(e4, CA2, U4, 0), A8 = h3 + g6 | 0, A8 = (B4 = IA4 + B4 | 0) >>> 0 < IA4 >>> 0 ? A8 + 1 | 0 : A8, g6 = (IA4 = qA(o4, 0, b4 = gA3 >>> 7 & 2097151, 0)) + B4 | 0, B4 = h3 + A8 | 0, B4 = g6 >>> 0 < IA4 >>> 0 ? B4 + 1 | 0 : B4, IA4 = g6, oA2 = B4, A8 = B4 - ((g6 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = g6 - -1048576 | 0, aA2 = A8, g6 = cA2, cA2 = (2097151 & A8) << 11 | B4 >>> 21, A8 = (A8 >> 21) + rA2 | 0, A8 = (gA3 = (g6 = gA3 = g6 + cA2 | 0) >>> 0 < cA2 >>> 0 ? A8 + 1 | 0 : A8) + lA2 | 0, A8 = g6 >>> 0 > (rA2 = g6 + UA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, gA3 = gA3 - ((g6 >>> 0 < 4293918720) - 1 | 0) | 0, tA2 = rA2 - (g6 = -2097152 & (fA2 = g6 - -1048576 | 0)) | 0, rA2 = A8 - ((g6 >>> 0 > rA2 >>> 0) + gA3 | 0) | 0, cA2 = GA2 - (((A8 = -2097152 & QA2) >>> 0 > a4 >>> 0) + vA2 | 0) | 0, x4 = a4 - A8 | 0, a4 = qA(J4, pA2, -997805, -1), g6 = h3 + oA2 | 0, g6 = (A8 = a4 + IA4 | 0) >>> 0 < a4 >>> 0 ? g6 + 1 | 0 : g6, a4 = (IA4 = qA(T4, eA2, 136657, 0)) + A8 | 0, A8 = h3 + g6 | 0, A8 = a4 >>> 0 < IA4 >>> 0 ? A8 + 1 | 0 : A8, g6 = a4, a4 = qA(x4, cA2, -683901, -1), A8 = h3 + A8 | 0, QA2 = (g6 = g6 + a4 | 0) - (B4 &= -2097152) | 0, oA2 = (A8 = g6 >>> 0 < a4 >>> 0 ? A8 + 1 | 0 : A8) - ((g6 >>> 0 < B4 >>> 0) + aA2 | 0) | 0, A8 = qA(t4, CA2, S4, 0), B4 = h3, g6 = A8, a4 = qA(m4 = 2097151 & ((3 & (A8 = kA2)) << 30 | RA2 >>> 2), 0, f4, 0), A8 = h3 + B4 | 0, A8 = (g6 = g6 + a4 | 0) >>> 0 < a4 >>> 0 ? A8 + 1 | 0 : A8, a4 = qA(y4, 0, D4, 0), B4 = h3 + A8 | 0, B4 = (g6 = a4 + g6 | 0) >>> 0 < a4 >>> 0 ? B4 + 1 | 0 : B4, A8 = (a4 = qA(w4, CA2, k4, CA2)) + g6 | 0, g6 = h3 + B4 | 0, g6 = A8 >>> 0 < a4 >>> 0 ? g6 + 1 | 0 : g6, B4 = (a4 = qA(p4, 0, F4, CA2)) + A8 | 0, A8 = h3 + g6 | 0, A8 = B4 >>> 0 < a4 >>> 0 ? A8 + 1 | 0 : A8, a4 = qA(u4, CA2, G4, CA2), g6 = h3 + A8 | 0, g6 = (B4 = a4 + B4 | 0) >>> 0 < a4 >>> 0 ? g6 + 1 | 0 : g6, a4 = qA(_4, CA2, H4, 0), A8 = h3 + g6 | 0, A8 = (B4 = a4 + B4 | 0) >>> 0 < a4 >>> 0 ? A8 + 1 | 0 : A8, g6 = (a4 = qA(c4, 0, U4, 0)) + B4 | 0, B4 = h3 + A8 | 0, B4 = g6 >>> 0 < a4 >>> 0 ? B4 + 1 | 0 : B4, A8 = (a4 = qA(e4, CA2, b4, 0)) + g6 | 0, g6 = h3 + B4 | 0, g6 = A8 >>> 0 < a4 >>> 0 ? g6 + 1 | 0 : g6, B4 = A8, a4 = qA(o4, 0, v4 = 2097151 & ((3 & (A8 = EA2)) << 30 | SA2 >>> 2), 0), A8 = h3 + g6 | 0, EA2 = B4 = B4 + a4 | 0, IA4 = B4 >>> 0 < a4 >>> 0 ? A8 + 1 | 0 : A8, A8 = qA(t4, CA2, m4, 0), g6 = h3, B4 = qA(M4 = uA2 >>> 5 & 2097151, 0, f4, 0), g6 = h3 + g6 | 0, g6 = (A8 = B4 + A8 | 0) >>> 0 < B4 >>> 0 ? g6 + 1 | 0 : g6, B4 = qA(y4, 0, S4, 0), g6 = h3 + g6 | 0, g6 = (A8 = B4 + A8 | 0) >>> 0 < B4 >>> 0 ? g6 + 1 | 0 : g6, B4 = (a4 = qA(D4, 0, k4, CA2)) + A8 | 0, A8 = h3 + g6 | 0, A8 = B4 >>> 0 < a4 >>> 0 ? A8 + 1 | 0 : A8, g6 = B4, B4 = qA(w4, CA2, F4, CA2), A8 = h3 + A8 | 0, A8 = (g6 = g6 + B4 | 0) >>> 0 < B4 >>> 0 ? A8 + 1 | 0 : A8, a4 = qA(p4, 0, H4, 0), B4 = h3 + A8 | 0, B4 = (g6 = a4 + g6 | 0) >>> 0 < a4 >>> 0 ? B4 + 1 | 0 : B4, A8 = (a4 = qA(u4, CA2, U4, 0)) + g6 | 0, g6 = h3 + B4 | 0, g6 = A8 >>> 0 < a4 >>> 0 ? g6 + 1 | 0 : g6, B4 = qA(_4, CA2, G4, CA2), g6 = h3 + g6 | 0, g6 = (A8 = B4 + A8 | 0) >>> 0 < B4 >>> 0 ? g6 + 1 | 0 : g6, B4 = (a4 = qA(c4, 0, b4, 0)) + A8 | 0, A8 = h3 + g6 | 0, A8 = B4 >>> 0 < a4 >>> 0 ? A8 + 1 | 0 : A8, g6 = B4, B4 = qA(e4, CA2, v4, 0), A8 = h3 + A8 | 0, A8 = (g6 = g6 + B4 | 0) >>> 0 < B4 >>> 0 ? A8 + 1 | 0 : A8, a4 = qA(o4, 0, P4 = nA2 >>> 5 & 2097151, 0), B4 = h3 + A8 | 0, B4 = (g6 = a4 + g6 | 0) >>> 0 < a4 >>> 0 ? B4 + 1 | 0 : B4, a4 = g6, SA2 = B4, LA2 = g6 = B4 - ((g6 >>> 0 < 4293918720) - 1 | 0) | 0, A8 = (A8 = g6 >> 21) + IA4 | 0, IA4 = g6 = (B4 = (2097151 & g6) << 11 | (hA2 = a4 - -1048576 | 0) >>> 21) + EA2 | 0, bA2 = A8 = g6 >>> 0 < B4 >>> 0 ? A8 + 1 | 0 : A8, NA2 = g6 = A8 - ((g6 >>> 0 < 4293918720) - 1 | 0) | 0, A8 = g6 >> 21, g6 = (B4 = QA2) + (QA2 = (2097151 & g6) << 11 | (GA2 = IA4 - -1048576 | 0) >>> 21) | 0, B4 = A8 + oA2 | 0, B4 = g6 >>> 0 < QA2 >>> 0 ? B4 + 1 | 0 : B4, QA2 = g6, RA2 = B4, jA2 = g6 = B4 - ((g6 >>> 0 < 4293918720) - 1 | 0) | 0, A8 = (A8 = g6 >> 21) + rA2 | 0, nA2 = g6 = (B4 = (2097151 & g6) << 11 | (vA2 = QA2 - -1048576 | 0) >>> 21) + tA2 | 0, lA2 = A8 = g6 >>> 0 < B4 >>> 0 ? A8 + 1 | 0 : A8, VA2 = g6 = A8 - ((g6 >>> 0 < 4293918720) - 1 | 0) | 0, uA2 = (2097151 & g6) << 11 | (aA2 = nA2 - -1048576 | 0) >>> 21, rA2 = g6 >> 21, A8 = qA(t4, CA2, p4, 0), g6 = h3, EA2 = qA(f4, 0, w4, CA2), B4 = h3 + g6 | 0, B4 = (A8 = EA2 + A8 | 0) >>> 0 < EA2 >>> 0 ? B4 + 1 | 0 : B4, EA2 = qA(u4, CA2, k4, CA2), g6 = h3 + B4 | 0, g6 = (A8 = EA2 + A8 | 0) >>> 0 < EA2 >>> 0 ? g6 + 1 | 0 : g6, B4 = (EA2 = qA(y4, 0, _4, CA2)) + A8 | 0, A8 = h3 + g6 | 0, A8 = B4 >>> 0 < EA2 >>> 0 ? A8 + 1 | 0 : A8, EA2 = qA(c4, 0, F4, CA2), g6 = h3 + A8 | 0, g6 = (B4 = EA2 + B4 | 0) >>> 0 < EA2 >>> 0 ? g6 + 1 | 0 : g6, EA2 = qA(e4, CA2, H4, 0), A8 = h3 + g6 | 0, A8 = (B4 = EA2 + B4 | 0) >>> 0 < EA2 >>> 0 ? A8 + 1 | 0 : A8, g6 = (EA2 = qA(o4, 0, G4, CA2)) + B4 | 0, B4 = h3 + A8 | 0, B4 = g6 >>> 0 < EA2 >>> 0 ? B4 + 1 | 0 : B4, A8 = g6, oA2 = qA(J4, pA2, -683901, -1), g6 = h3 + B4 | 0, g6 = (EA2 = A8 + oA2 | 0) >>> 0 < oA2 >>> 0 ? g6 + 1 | 0 : g6, oA2 = EA2, EA2 = B4 - ((A8 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = oA2 - (A8 = -2097152 & (kA2 = A8 - -1048576 | 0)) | 0, oA2 = g6 - ((A8 >>> 0 > oA2 >>> 0) + EA2 | 0) | 0, g6 = (A8 = B4) + (B4 = (2097151 & gA3) << 11 | fA2 >>> 21) | 0, A8 = (gA3 >> 21) + oA2 | 0, A8 = g6 >>> 0 < B4 >>> 0 ? A8 + 1 | 0 : A8, B4 = uA2, fA2 = g6 - (uA2 = -2097152 & (oA2 = g6 - -1048576 | 0)) | 0, g6 = (A8 - ((gA3 = A8 - ((g6 >>> 0 < 4293918720) - 1 | 0) | 0) + (g6 >>> 0 < uA2 >>> 0) | 0) | 0) + rA2 | 0, V4 = B4 = B4 + fA2 | 0, uA2 = g6 = B4 >>> 0 < fA2 >>> 0 ? g6 + 1 | 0 : g6, rA2 = qA(B4, g6, -683901, -1), fA2 = h3, A8 = qA(y4, 0, u4, CA2), B4 = h3, g6 = (tA2 = qA(f4, 0, p4, 0)) + A8 | 0, A8 = h3 + B4 | 0, A8 = g6 >>> 0 < tA2 >>> 0 ? A8 + 1 | 0 : A8, B4 = (tA2 = qA(t4, CA2, _4, CA2)) + g6 | 0, g6 = h3 + A8 | 0, g6 = B4 >>> 0 < tA2 >>> 0 ? g6 + 1 | 0 : g6, tA2 = qA(c4, 0, k4, CA2), A8 = h3 + g6 | 0, A8 = (B4 = tA2 + B4 | 0) >>> 0 < tA2 >>> 0 ? A8 + 1 | 0 : A8, g6 = (tA2 = qA(e4, CA2, F4, CA2)) + B4 | 0, B4 = h3 + A8 | 0, B4 = g6 >>> 0 < tA2 >>> 0 ? B4 + 1 | 0 : B4, A8 = (tA2 = qA(o4, 0, H4, 0)) + g6 | 0, g6 = h3 + B4 | 0, g6 = A8 >>> 0 < tA2 >>> 0 ? g6 + 1 | 0 : g6, B4 = A8, A8 = (A8 = EA2 >> 21) + g6 | 0, FA2 = B4 = (A8 = (g6 = B4 = B4 + (EA2 = (2097151 & EA2) << 11 | kA2 >>> 21) | 0) >>> 0 < EA2 >>> 0 ? A8 + 1 | 0 : A8) - ((g6 >>> 0 < 4293918720) - 1 | 0) | 0, kA2 = g6 - (EA2 = -2097152 & (UA2 = g6 - -1048576 | 0)) | 0, B4 = A8 - ((g6 >>> 0 < EA2 >>> 0) + B4 | 0) | 0, g6 = (g6 = (A8 = gA3) >> 21) + B4 | 0, q4 = A8 = (gA3 = (2097151 & A8) << 11 | (gA3 = oA2) >>> 21) + kA2 | 0, kA2 = g6 = A8 >>> 0 < gA3 >>> 0 ? g6 + 1 | 0 : g6, B4 = qA(A8, g6, 136657, 0), A8 = h3 + fA2 | 0, gI2 = g6 = B4 + rA2 | 0, dA2 = g6 >>> 0 < B4 >>> 0 ? A8 + 1 | 0 : A8, A8 = qA(k4, CA2, M4, 0), B4 = h3, g6 = (gA3 = qA(Y4 = 2097151 & KA2, 0, y4, 0)) + A8 | 0, A8 = h3 + B4 | 0, A8 = g6 >>> 0 < gA3 >>> 0 ? A8 + 1 | 0 : A8, gA3 = qA(F4, CA2, m4, 0), B4 = h3 + A8 | 0, B4 = (g6 = gA3 + g6 | 0) >>> 0 < gA3 >>> 0 ? B4 + 1 | 0 : B4, A8 = (gA3 = qA(H4, 0, S4, 0)) + g6 | 0, g6 = h3 + B4 | 0, g6 = A8 >>> 0 < gA3 >>> 0 ? g6 + 1 | 0 : g6, B4 = (gA3 = qA(D4, 0, G4, CA2)) + A8 | 0, A8 = h3 + g6 | 0, A8 = B4 >>> 0 < gA3 >>> 0 ? A8 + 1 | 0 : A8, gA3 = qA(w4, CA2, U4, 0), g6 = h3 + A8 | 0, g6 = (B4 = gA3 + B4 | 0) >>> 0 < gA3 >>> 0 ? g6 + 1 | 0 : g6, gA3 = qA(p4, 0, b4, 0), A8 = h3 + g6 | 0, A8 = (B4 = gA3 + B4 | 0) >>> 0 < gA3 >>> 0 ? A8 + 1 | 0 : A8, g6 = (gA3 = qA(u4, CA2, P4, 0)) + B4 | 0, B4 = h3 + A8 | 0, B4 = g6 >>> 0 < gA3 >>> 0 ? B4 + 1 | 0 : B4, A8 = (gA3 = qA(_4, CA2, v4, 0)) + g6 | 0, g6 = h3 + B4 | 0, g6 = A8 >>> 0 < gA3 >>> 0 ? g6 + 1 | 0 : g6, B4 = (gA3 = qA(c4, 0, N4 = 2097151 & TA2, 0)) + A8 | 0, A8 = h3 + g6 | 0, A8 = B4 >>> 0 < gA3 >>> 0 ? A8 + 1 | 0 : A8, rA2 = B4 = (gA3 = (n3[r4 + 23 | 0] | n3[r4 + 24 | 0] << 8 | n3[r4 + 25 | 0] << 16 | n3[r4 + 26 | 0] << 24) >>> 5 & 2097151) + B4 | 0, EA2 = B4 >>> 0 < gA3 >>> 0 ? A8 + 1 | 0 : A8, A8 = qA(F4, CA2, M4, 0), g6 = h3, gA3 = qA(k4, CA2, Y4, 0), B4 = h3 + g6 | 0, B4 = (A8 = gA3 + A8 | 0) >>> 0 < gA3 >>> 0 ? B4 + 1 | 0 : B4, gA3 = qA(H4, 0, m4, 0), g6 = h3 + B4 | 0, g6 = (A8 = gA3 + A8 | 0) >>> 0 < gA3 >>> 0 ? g6 + 1 | 0 : g6, B4 = (gA3 = qA(G4, CA2, S4, 0)) + A8 | 0, A8 = h3 + g6 | 0, A8 = B4 >>> 0 < gA3 >>> 0 ? A8 + 1 | 0 : A8, g6 = B4, B4 = qA(D4, 0, U4, 0), A8 = h3 + A8 | 0, A8 = (g6 = g6 + B4 | 0) >>> 0 < B4 >>> 0 ? A8 + 1 | 0 : A8, B4 = (gA3 = qA(w4, CA2, b4, 0)) + g6 | 0, g6 = h3 + A8 | 0, g6 = B4 >>> 0 < gA3 >>> 0 ? g6 + 1 | 0 : g6, A8 = (gA3 = qA(p4, 0, v4, 0)) + B4 | 0, B4 = h3 + g6 | 0, B4 = A8 >>> 0 < gA3 >>> 0 ? B4 + 1 | 0 : B4, gA3 = qA(N4, 0, u4, CA2), g6 = h3 + B4 | 0, g6 = (A8 = gA3 + A8 | 0) >>> 0 < gA3 >>> 0 ? g6 + 1 | 0 : g6, B4 = (gA3 = qA(_4, CA2, P4, 0)) + A8 | 0, A8 = h3 + g6 | 0, A8 = B4 >>> 0 < gA3 >>> 0 ? A8 + 1 | 0 : A8, gA3 = g6 = (g6 = B4) + (B4 = 2097151 & JA2) | 0, sA2 = A8 = g6 >>> 0 < B4 >>> 0 ? A8 + 1 | 0 : A8, TA2 = A8 = A8 - ((g6 >>> 0 < 4293918720) - 1 | 0) | 0, oA2 = g6 - -1048576 | 0, g6 = (B4 = A8 >>> 21 | 0) + EA2 | 0, EA2 = A8 = (tA2 = rA2) + (rA2 = (2097151 & A8) << 11 | oA2 >>> 21) | 0, KA2 = A8 >>> 0 < rA2 >>> 0 ? g6 + 1 | 0 : g6, fA2 = C4 - (A8 = -2097152 & iA2) | 0, WA2 = mA2 - ((A8 >>> 0 > C4 >>> 0) + wA2 | 0) | 0, A8 = qA(t4, CA2, c4, 0), B4 = h3, g6 = (C4 = qA(f4, 0, u4, CA2)) + A8 | 0, A8 = h3 + B4 | 0, A8 = g6 >>> 0 < C4 >>> 0 ? A8 + 1 | 0 : A8, C4 = qA(e4, CA2, y4, 0), B4 = h3 + A8 | 0, B4 = (g6 = C4 + g6 | 0) >>> 0 < C4 >>> 0 ? B4 + 1 | 0 : B4, A8 = (C4 = qA(o4, 0, k4, CA2)) + g6 | 0, g6 = h3 + B4 | 0, tA2 = A8, iA2 = A8 >>> 0 < C4 >>> 0 ? g6 + 1 | 0 : g6, A8 = qA(f4, 0, _4, CA2), g6 = h3, B4 = qA(t4, CA2, u4, CA2), g6 = h3 + g6 | 0, g6 = (A8 = B4 + A8 | 0) >>> 0 < B4 >>> 0 ? g6 + 1 | 0 : g6, B4 = (C4 = qA(c4, 0, y4, 0)) + A8 | 0, A8 = h3 + g6 | 0, A8 = B4 >>> 0 < C4 >>> 0 ? A8 + 1 | 0 : A8, g6 = B4, B4 = qA(e4, CA2, k4, CA2), A8 = h3 + A8 | 0, A8 = (g6 = g6 + B4 | 0) >>> 0 < B4 >>> 0 ? A8 + 1 | 0 : A8, C4 = qA(o4, 0, F4, CA2), B4 = h3 + A8 | 0, B4 = (g6 = C4 + g6 | 0) >>> 0 < C4 >>> 0 ? B4 + 1 | 0 : B4, C4 = g6, mA2 = B4, wA2 = g6 = B4 - ((g6 >>> 0 < 4293918720) - 1 | 0) | 0, A8 = tA2, tA2 = (2097151 & g6) << 11 | (rA2 = C4 - -1048576 | 0) >>> 21, g6 = (g6 >> 21) + iA2 | 0, iA2 = B4 = A8 + tA2 | 0, JA2 = g6 = B4 >>> 0 < tA2 >>> 0 ? g6 + 1 | 0 : g6, tA2 = B4 - -1048576 | 0, B4 = (A8 = (g6 = g6 - ((B4 >>> 0 < 4293918720) - 1 | 0) | 0) >> 21) + WA2 | 0, L4 = fA2 = (ZA2 = (2097151 & g6) << 11 | tA2 >>> 21) + fA2 | 0, fA2 = B4 = fA2 >>> 0 < ZA2 >>> 0 ? B4 + 1 | 0 : B4, A8 = qA(L4, B4, 470296, 0), B4 = h3, tA2 = JA2 - ((YA2 = g6) + ((g6 = -2097152 & tA2) >>> 0 > iA2 >>> 0) | 0) | 0, K4 = iA2 - g6 | 0, iA2 = qA(x4, cA2, 666643, 0), g6 = h3 + B4 | 0, g6 = (A8 = iA2 + A8 | 0) >>> 0 < iA2 >>> 0 ? g6 + 1 | 0 : g6, B4 = (iA2 = qA(K4, tA2, 654183, 0)) + A8 | 0, A8 = h3 + g6 | 0, A8 = B4 >>> 0 < iA2 >>> 0 ? A8 + 1 | 0 : A8, iA2 = B4, B4 = A8, rA2 = mA2 - (((A8 = -2097152 & rA2) >>> 0 > C4 >>> 0) + wA2 | 0) | 0, C4 = g6 = C4 - A8 | 0, FA2 = (2097151 & (g6 = FA2)) << 11 | UA2 >>> 21, g6 = (A8 = g6 >> 21) + rA2 | 0, j4 = C4 = C4 + FA2 | 0, FA2 = g6 = C4 >>> 0 < FA2 >>> 0 ? g6 + 1 | 0 : g6, rA2 = KA2 - (((A8 = EA2) >>> 0 < 4293918720) - 1 | 0) | 0, XA2 = A8 - -1048576 | 0, C4 = qA(C4, g6, -997805, -1), g6 = h3 + B4 | 0, g6 = (A8 = C4 + iA2 | 0) >>> 0 < C4 >>> 0 ? g6 + 1 | 0 : g6, C4 = A8, B4 = EA2 + A8 | 0, A8 = g6 + KA2 | 0, A8 = B4 >>> 0 < C4 >>> 0 ? A8 + 1 | 0 : A8, UA2 = (g6 = B4) - (B4 = -2097152 & XA2) | 0, WA2 = A8 - ((g6 >>> 0 < B4 >>> 0) + rA2 | 0) | 0, A8 = qA(K4, tA2, 470296, 0), g6 = h3, B4 = qA(L4, fA2, 666643, 0), g6 = h3 + g6 | 0, g6 = (A8 = B4 + A8 | 0) >>> 0 < B4 >>> 0 ? g6 + 1 | 0 : g6, B4 = (C4 = qA(j4, FA2, 654183, 0)) + A8 | 0, A8 = h3 + g6 | 0, g6 = B4 + gA3 | 0, B4 = sA2 + (B4 >>> 0 < C4 >>> 0 ? A8 + 1 | 0 : A8) | 0, B4 = g6 >>> 0 < gA3 >>> 0 ? B4 + 1 | 0 : B4, oA2 = (A8 = g6) - (g6 = -2097152 & oA2) | 0, sA2 = B4 - ((A8 >>> 0 < g6 >>> 0) + TA2 | 0) | 0, A8 = qA(H4, 0, M4, 0), B4 = h3, g6 = (C4 = qA(F4, CA2, Y4, 0)) + A8 | 0, A8 = h3 + B4 | 0, A8 = g6 >>> 0 < C4 >>> 0 ? A8 + 1 | 0 : A8, B4 = qA(G4, CA2, m4, 0), A8 = h3 + A8 | 0, A8 = (g6 = B4 + g6 | 0) >>> 0 < B4 >>> 0 ? A8 + 1 | 0 : A8, C4 = qA(U4, 0, S4, 0), B4 = h3 + A8 | 0, B4 = (g6 = C4 + g6 | 0) >>> 0 < C4 >>> 0 ? B4 + 1 | 0 : B4, A8 = (C4 = qA(D4, 0, b4, 0)) + g6 | 0, g6 = h3 + B4 | 0, g6 = A8 >>> 0 < C4 >>> 0 ? g6 + 1 | 0 : g6, B4 = qA(w4, CA2, v4, 0), g6 = h3 + g6 | 0, g6 = (A8 = B4 + A8 | 0) >>> 0 < B4 >>> 0 ? g6 + 1 | 0 : g6, B4 = (C4 = qA(p4, 0, P4, 0)) + A8 | 0, A8 = h3 + g6 | 0, A8 = B4 >>> 0 < C4 >>> 0 ? A8 + 1 | 0 : A8, g6 = B4, B4 = qA(N4, 0, _4, CA2), A8 = h3 + A8 | 0, A8 = (g6 = g6 + B4 | 0) >>> 0 < B4 >>> 0 ? A8 + 1 | 0 : A8, B4 = g6, g6 = A8, iA2 = A8 = (C4 = 2097151 & ((7 & (A8 = yA2)) << 29 | AI2 >>> 3)) + B4 | 0, C4 = A8 >>> 0 < C4 >>> 0 ? g6 + 1 | 0 : g6, A8 = qA(G4, CA2, M4, 0), g6 = h3, B4 = qA(H4, 0, Y4, 0), g6 = h3 + g6 | 0, g6 = (A8 = B4 + A8 | 0) >>> 0 < B4 >>> 0 ? g6 + 1 | 0 : g6, B4 = (gA3 = qA(U4, 0, m4, 0)) + A8 | 0, A8 = h3 + g6 | 0, A8 = B4 >>> 0 < gA3 >>> 0 ? A8 + 1 | 0 : A8, gA3 = qA(S4, 0, b4, 0), g6 = h3 + A8 | 0, g6 = (B4 = gA3 + B4 | 0) >>> 0 < gA3 >>> 0 ? g6 + 1 | 0 : g6, gA3 = qA(D4, 0, v4, 0), A8 = h3 + g6 | 0, A8 = (B4 = gA3 + B4 | 0) >>> 0 < gA3 >>> 0 ? A8 + 1 | 0 : A8, g6 = (gA3 = qA(w4, CA2, P4, 0)) + B4 | 0, B4 = h3 + A8 | 0, B4 = g6 >>> 0 < gA3 >>> 0 ? B4 + 1 | 0 : B4, A8 = (gA3 = qA(N4, 0, p4, 0)) + g6 | 0, g6 = h3 + B4 | 0, B4 = A8, A8 = A8 >>> 0 < gA3 >>> 0 ? g6 + 1 | 0 : g6, gA3 = g6 = (g6 = B4) + (B4 = DA2 >>> 6 & 2097151) | 0, yA2 = A8 = g6 >>> 0 < B4 >>> 0 ? A8 + 1 | 0 : A8, mA2 = A8 = A8 - ((g6 >>> 0 < 4293918720) - 1 | 0) | 0, EA2 = g6 - -1048576 | 0, g6 = (B4 = A8 >>> 21 | 0) + C4 | 0, C4 = A8 = (wA2 = iA2) + (iA2 = (2097151 & A8) << 11 | EA2 >>> 21) | 0, wA2 = g6 = A8 >>> 0 < iA2 >>> 0 ? g6 + 1 | 0 : g6, TA2 = A8 = g6 - ((A8 >>> 0 < 4293918720) - 1 | 0) | 0, g6 = oA2, oA2 = (2097151 & A8) << 11 | (iA2 = C4 - -1048576 | 0) >>> 21, A8 = (A8 >>> 21 | 0) + sA2 | 0, sA2 = g6 = g6 + oA2 | 0, KA2 = A8 = g6 >>> 0 < oA2 >>> 0 ? A8 + 1 | 0 : A8, JA2 = A8 = A8 - ((g6 >>> 0 < 4293918720) - 1 | 0) | 0, DA2 = g6 - -1048576 | 0, g6 = (B4 = A8 >> 21) + WA2 | 0, g6 = (A8 = (oA2 = (2097151 & A8) << 11 | DA2 >>> 21) + UA2 | 0) >>> 0 < oA2 >>> 0 ? g6 + 1 | 0 : g6, B4 = A8, oA2 = A8 + gI2 | 0, A8 = g6 + dA2 | 0, A8 = B4 >>> 0 > oA2 >>> 0 ? A8 + 1 | 0 : A8, dA2 = oA2, oA2 = g6 - ((B4 >>> 0 < 4293918720) - 1 | 0) | 0, OA2 = dA2 - (g6 = -2097152 & (zA2 = B4 - -1048576 | 0)) | 0, xA2 = A8 - ((g6 >>> 0 > dA2 >>> 0) + oA2 | 0) | 0, g6 = qA(q4, kA2, -997805, -1), B4 = h3 + KA2 | 0, YA2 = A8 = g6 + sA2 | 0, dA2 = A8 >>> 0 < g6 >>> 0 ? B4 + 1 | 0 : B4, A8 = qA(j4, FA2, 470296, 0), B4 = h3, g6 = (sA2 = qA(K4, tA2, 666643, 0)) + A8 | 0, A8 = h3 + B4 | 0, A8 = (A8 = g6 >>> 0 < sA2 >>> 0 ? A8 + 1 | 0 : A8) + wA2 | 0, sA2 = (g6 = g6 + C4 | 0) - (B4 = -2097152 & iA2) | 0, wA2 = (A8 = g6 >>> 0 < C4 >>> 0 ? A8 + 1 | 0 : A8) - ((g6 >>> 0 < B4 >>> 0) + TA2 | 0) | 0, B4 = qA(j4, FA2, 666643, 0), g6 = h3 + yA2 | 0, yA2 = A8 = B4 + gA3 | 0, iA2 = A8 >>> 0 < B4 >>> 0 ? g6 + 1 | 0 : g6, A8 = qA(U4, 0, M4, 0), B4 = h3, g6 = (C4 = qA(G4, CA2, Y4, 0)) + A8 | 0, A8 = h3 + B4 | 0, A8 = g6 >>> 0 < C4 >>> 0 ? A8 + 1 | 0 : A8, B4 = qA(b4, 0, m4, 0), A8 = h3 + A8 | 0, A8 = (g6 = B4 + g6 | 0) >>> 0 < B4 >>> 0 ? A8 + 1 | 0 : A8, C4 = qA(S4, 0, v4, 0), B4 = h3 + A8 | 0, B4 = (g6 = C4 + g6 | 0) >>> 0 < C4 >>> 0 ? B4 + 1 | 0 : B4, A8 = (C4 = qA(D4, 0, P4, 0)) + g6 | 0, g6 = h3 + B4 | 0, g6 = A8 >>> 0 < C4 >>> 0 ? g6 + 1 | 0 : g6, B4 = qA(N4, 0, w4, CA2), g6 = h3 + g6 | 0, g6 = (A8 = B4 + A8 | 0) >>> 0 < B4 >>> 0 ? g6 + 1 | 0 : g6, B4 = A8, C4 = 2097151 & ((1 & (A8 = HA2)) << 31 | $A2 >>> 1), A8 = g6, HA2 = B4 = B4 + C4 | 0, gA3 = B4 >>> 0 < C4 >>> 0 ? A8 + 1 | 0 : A8, A8 = qA(b4, 0, M4, 0), B4 = h3, g6 = (C4 = qA(U4, 0, Y4, 0)) + A8 | 0, A8 = h3 + B4 | 0, A8 = g6 >>> 0 < C4 >>> 0 ? A8 + 1 | 0 : A8, B4 = (C4 = qA(m4, 0, v4, 0)) + g6 | 0, g6 = h3 + A8 | 0, g6 = B4 >>> 0 < C4 >>> 0 ? g6 + 1 | 0 : g6, A8 = (C4 = qA(S4, 0, P4, 0)) + B4 | 0, B4 = h3 + g6 | 0, B4 = A8 >>> 0 < C4 >>> 0 ? B4 + 1 | 0 : B4, C4 = qA(N4, 0, D4, 0), g6 = h3 + B4 | 0, B4 = A8 = C4 + A8 | 0, A8 = A8 >>> 0 < C4 >>> 0 ? g6 + 1 | 0 : g6, C4 = g6 = (g6 = B4) + (B4 = PA2 >>> 4 & 2097151) | 0, TA2 = A8 = g6 >>> 0 < B4 >>> 0 ? A8 + 1 | 0 : A8, KA2 = A8 = A8 - ((g6 >>> 0 < 4293918720) - 1 | 0) | 0, PA2 = g6 - -1048576 | 0, g6 = (B4 = A8 >>> 21 | 0) + gA3 | 0, gA3 = A8 = (UA2 = HA2) + (HA2 = (2097151 & A8) << 11 | PA2 >>> 21) | 0, UA2 = g6 = A8 >>> 0 < HA2 >>> 0 ? g6 + 1 | 0 : g6, $A2 = A8 = g6 - ((A8 >>> 0 < 4293918720) - 1 | 0) | 0, g6 = yA2, yA2 = (2097151 & A8) << 11 | (HA2 = gA3 - -1048576 | 0) >>> 21, A8 = (A8 >>> 21 | 0) + iA2 | 0, AI2 = A8 = (A8 = (g6 = g6 + yA2 | 0) >>> 0 < yA2 >>> 0 ? A8 + 1 | 0 : A8) - (((B4 = -2097152 & EA2) >>> 0 > g6 >>> 0) + mA2 | 0) | 0, gI2 = A8 = A8 - (((EA2 = g6 - B4 | 0) >>> 0 < 4293918720) - 1 | 0) | 0, B4 = (g6 = A8 >> 21) + wA2 | 0, mA2 = A8 = (iA2 = (2097151 & A8) << 11 | (yA2 = EA2 - -1048576 | 0) >>> 21) + sA2 | 0, WA2 = B4 = A8 >>> 0 < iA2 >>> 0 ? B4 + 1 | 0 : B4, ZA2 = A8 = B4 - ((A8 >>> 0 < 4293918720) - 1 | 0) | 0, sA2 = lA2 - (((g6 = -2097152 & aA2) >>> 0 > nA2 >>> 0) + VA2 | 0) | 0, X4 = nA2 - g6 | 0, nA2 = (2097151 & A8) << 11 | (wA2 = mA2 - -1048576 | 0) >>> 21, A8 = (A8 >> 21) + dA2 | 0, A8 = (B4 = nA2 + YA2 | 0) >>> 0 < nA2 >>> 0 ? A8 + 1 | 0 : A8, g6 = (iA2 = qA(V4, uA2, 136657, 0)) + (B4 - (nA2 = -2097152 & DA2) | 0) | 0, B4 = h3 + (A8 - ((B4 >>> 0 < nA2 >>> 0) + JA2 | 0) | 0) | 0, B4 = g6 >>> 0 < iA2 >>> 0 ? B4 + 1 | 0 : B4, nA2 = qA(X4, sA2, -683901, -1), A8 = h3 + B4 | 0, A8 = (g6 = nA2 + g6 | 0) >>> 0 < nA2 >>> 0 ? A8 + 1 | 0 : A8, nA2 = g6, VA2 = A8, dA2 = A8 = A8 - ((g6 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = (g6 = A8 >> 21) + xA2 | 0, B4 = (A8 = (iA2 = (2097151 & A8) << 11 | (DA2 = nA2 - -1048576 | 0) >>> 21) + OA2 | 0) >>> 0 < iA2 >>> 0 ? B4 + 1 | 0 : B4, iA2 = A8, JA2 = B4, OA2 = A8 = B4 - ((A8 >>> 0 < 4293918720) - 1 | 0) | 0, BI2 = (2097151 & A8) << 11 | (lA2 = iA2 - -1048576 | 0) >>> 21, xA2 = A8 >> 21, A8 = qA(y4, 0, M4, 0), B4 = h3, g6 = (aA2 = qA(t4, CA2, Y4, 0)) + A8 | 0, A8 = h3 + B4 | 0, A8 = g6 >>> 0 < aA2 >>> 0 ? A8 + 1 | 0 : A8, B4 = (aA2 = qA(k4, CA2, m4, 0)) + g6 | 0, g6 = h3 + A8 | 0, g6 = B4 >>> 0 < aA2 >>> 0 ? g6 + 1 | 0 : g6, A8 = (aA2 = qA(F4, CA2, S4, 0)) + B4 | 0, B4 = h3 + g6 | 0, B4 = A8 >>> 0 < aA2 >>> 0 ? B4 + 1 | 0 : B4, g6 = (aA2 = qA(D4, 0, H4, 0)) + A8 | 0, A8 = h3 + B4 | 0, A8 = g6 >>> 0 < aA2 >>> 0 ? A8 + 1 | 0 : A8, B4 = (aA2 = qA(w4, CA2, G4, CA2)) + g6 | 0, g6 = h3 + A8 | 0, g6 = B4 >>> 0 < aA2 >>> 0 ? g6 + 1 | 0 : g6, aA2 = qA(p4, 0, U4, 0), A8 = h3 + g6 | 0, A8 = (B4 = aA2 + B4 | 0) >>> 0 < aA2 >>> 0 ? A8 + 1 | 0 : A8, aA2 = qA(u4, CA2, v4, 0), g6 = h3 + A8 | 0, g6 = (B4 = aA2 + B4 | 0) >>> 0 < aA2 >>> 0 ? g6 + 1 | 0 : g6, A8 = (aA2 = qA(_4, CA2, b4, 0)) + B4 | 0, B4 = h3 + g6 | 0, B4 = A8 >>> 0 < aA2 >>> 0 ? B4 + 1 | 0 : B4, g6 = (aA2 = qA(c4, 0, P4, 0)) + A8 | 0, A8 = h3 + B4 | 0, A8 = g6 >>> 0 < aA2 >>> 0 ? A8 + 1 | 0 : A8, B4 = (aA2 = qA(N4, 0, e4, CA2)) + g6 | 0, g6 = h3 + A8 | 0, g6 = B4 >>> 0 < aA2 >>> 0 ? g6 + 1 | 0 : g6, YA2 = B4, B4 = uI(r4 + 26 | 0), aA2 = 2097151 & ((3 & (A8 = h3)) << 30 | B4 >>> 2), A8 = g6, A8 = (B4 = YA2 + aA2 | 0) >>> 0 < aA2 >>> 0 ? A8 + 1 | 0 : A8, aA2 = B4, YA2 = A8, A8 = qA(x4, cA2, 470296, 0), g6 = h3, B4 = qA(T4, eA2, 666643, 0), g6 = h3 + g6 | 0, g6 = (A8 = B4 + A8 | 0) >>> 0 < B4 >>> 0 ? g6 + 1 | 0 : g6, _A2 = qA(L4, fA2, 654183, 0), B4 = h3 + g6 | 0, B4 = (A8 = _A2 + A8 | 0) >>> 0 < _A2 >>> 0 ? B4 + 1 | 0 : B4, _A2 = qA(K4, tA2, -997805, -1), g6 = h3 + B4 | 0, g6 = (A8 = _A2 + A8 | 0) >>> 0 < _A2 >>> 0 ? g6 + 1 | 0 : g6, B4 = (_A2 = qA(j4, FA2, 136657, 0)) + A8 | 0, A8 = h3 + g6 | 0, A8 = (A8 = B4 >>> 0 < _A2 >>> 0 ? A8 + 1 | 0 : A8) + YA2 | 0, A8 = (g6 = B4 + aA2 | 0) >>> 0 < B4 >>> 0 ? A8 + 1 | 0 : A8, B4 = g6, aA2 = YA2 - (((g6 = aA2) >>> 0 < 4293918720) - 1 | 0) | 0, YA2 = g6 - -1048576 | 0, g6 = A8 + (g6 = rA2 >>> 21 | 0) | 0, g6 = (B4 = (rA2 = (2097151 & rA2) << 11 | XA2 >>> 21) + B4 | 0) >>> 0 < rA2 >>> 0 ? g6 + 1 | 0 : g6, B4 = (A8 = B4) - (XA2 = -2097152 & YA2) | 0, _A2 = qA(q4, kA2, -683901, -1), A8 = (g6 = g6 - ((A8 >>> 0 < XA2 >>> 0) + aA2 | 0) | 0) + h3 | 0, A8 = (rA2 = B4 + _A2 | 0) >>> 0 < _A2 >>> 0 ? A8 + 1 | 0 : A8, _A2 = rA2, rA2 = g6 - ((B4 >>> 0 < 4293918720) - 1 | 0) | 0, XA2 = B4 - -1048576 | 0, g6 = A8 + (g6 = oA2 >> 21) | 0, g6 = (B4 = (oA2 = (2097151 & oA2) << 11 | zA2 >>> 21) + _A2 | 0) >>> 0 < oA2 >>> 0 ? g6 + 1 | 0 : g6, B4 = (A8 = B4) - (zA2 = -2097152 & XA2) | 0, A8 = (_A2 = xA2) + (xA2 = g6 - ((A8 >>> 0 < zA2 >>> 0) + rA2 | 0) | 0) | 0, A8 = B4 >>> 0 > (oA2 = B4 + BI2 | 0) >>> 0 ? A8 + 1 | 0 : A8, g6 = oA2, oA2 = xA2 - ((B4 >>> 0 < 4293918720) - 1 | 0) | 0, zA2 = g6 - (B4 = -2097152 & (xA2 = B4 - -1048576 | 0)) | 0, BI2 = A8 - ((g6 >>> 0 < B4 >>> 0) + oA2 | 0) | 0, _A2 = iA2 - (A8 = -2097152 & lA2) | 0, JA2 = JA2 - ((A8 >>> 0 > iA2 >>> 0) + OA2 | 0) | 0, OA2 = nA2 - (A8 = -2097152 & DA2) | 0, VA2 = VA2 - ((A8 >>> 0 > nA2 >>> 0) + dA2 | 0) | 0, B4 = qA(q4, kA2, 654183, 0), A8 = h3 + WA2 | 0, A8 = (g6 = B4 + mA2 | 0) >>> 0 < B4 >>> 0 ? A8 + 1 | 0 : A8, B4 = (iA2 = qA(V4, uA2, -997805, -1)) + (g6 - (nA2 = -2097152 & wA2) | 0) | 0, g6 = h3 + (A8 - ((g6 >>> 0 < nA2 >>> 0) + ZA2 | 0) | 0) | 0, g6 = B4 >>> 0 < iA2 >>> 0 ? g6 + 1 | 0 : g6, nA2 = qA(X4, sA2, 136657, 0), A8 = h3 + g6 | 0, lA2 = B4 = nA2 + B4 | 0, DA2 = B4 >>> 0 < nA2 >>> 0 ? A8 + 1 | 0 : A8, iA2 = QA2 - (A8 = -2097152 & vA2) | 0, RA2 = RA2 - ((A8 >>> 0 > QA2 >>> 0) + jA2 | 0) | 0, A8 = qA(T4, eA2, -997805, -1), g6 = h3, QA2 = qA(J4, pA2, 654183, 0), B4 = h3 + g6 | 0, B4 = (A8 = QA2 + A8 | 0) >>> 0 < QA2 >>> 0 ? B4 + 1 | 0 : B4, QA2 = qA(x4, cA2, 136657, 0), g6 = h3 + B4 | 0, g6 = (A8 = QA2 + A8 | 0) >>> 0 < QA2 >>> 0 ? g6 + 1 | 0 : g6, B4 = (QA2 = qA(L4, fA2, -683901, -1)) + A8 | 0, A8 = h3 + g6 | 0, g6 = (A8 = B4 >>> 0 < QA2 >>> 0 ? A8 + 1 | 0 : A8) + bA2 | 0, g6 = (B4 = B4 + IA4 | 0) >>> 0 < IA4 >>> 0 ? g6 + 1 | 0 : g6, QA2 = (A8 = B4) - (B4 = -2097152 & GA2) | 0, bA2 = g6 - ((A8 >>> 0 < B4 >>> 0) + NA2 | 0) | 0, A8 = qA(T4, eA2, 654183, 0), g6 = h3, IA4 = qA(J4, pA2, 470296, 0), B4 = h3 + g6 | 0, B4 = (A8 = IA4 + A8 | 0) >>> 0 < IA4 >>> 0 ? B4 + 1 | 0 : B4, g6 = (IA4 = qA(x4, cA2, -997805, -1)) + A8 | 0, A8 = h3 + B4 | 0, B4 = g6 + a4 | 0, g6 = SA2 + (g6 >>> 0 < IA4 >>> 0 ? A8 + 1 | 0 : A8) | 0, g6 = B4 >>> 0 < a4 >>> 0 ? g6 + 1 | 0 : g6, A8 = B4, B4 = qA(L4, fA2, 136657, 0), g6 = h3 + g6 | 0, g6 = (A8 = A8 + B4 | 0) >>> 0 < B4 >>> 0 ? g6 + 1 | 0 : g6, B4 = (a4 = qA(K4, tA2, -683901, -1)) + A8 | 0, A8 = h3 + g6 | 0, A8 = B4 >>> 0 < a4 >>> 0 ? A8 + 1 | 0 : A8, IA4 = (g6 = B4) - (B4 = -2097152 & hA2) | 0, hA2 = A8 - ((g6 >>> 0 < B4 >>> 0) + LA2 | 0) | 0, A8 = qA(t4, CA2, M4, 0), B4 = h3, g6 = (a4 = qA(f4, 0, Y4, 0)) + A8 | 0, A8 = h3 + B4 | 0, A8 = g6 >>> 0 < a4 >>> 0 ? A8 + 1 | 0 : A8, B4 = (a4 = qA(y4, 0, m4, 0)) + g6 | 0, g6 = h3 + A8 | 0, g6 = B4 >>> 0 < a4 >>> 0 ? g6 + 1 | 0 : g6, a4 = qA(k4, CA2, S4, 0), A8 = h3 + g6 | 0, A8 = (B4 = a4 + B4 | 0) >>> 0 < a4 >>> 0 ? A8 + 1 | 0 : A8, a4 = qA(D4, 0, F4, CA2), g6 = h3 + A8 | 0, g6 = (B4 = a4 + B4 | 0) >>> 0 < a4 >>> 0 ? g6 + 1 | 0 : g6, A8 = (a4 = qA(w4, CA2, H4, 0)) + B4 | 0, B4 = h3 + g6 | 0, B4 = A8 >>> 0 < a4 >>> 0 ? B4 + 1 | 0 : B4, g6 = (a4 = qA(p4, 0, G4, CA2)) + A8 | 0, A8 = h3 + B4 | 0, A8 = g6 >>> 0 < a4 >>> 0 ? A8 + 1 | 0 : A8, B4 = (a4 = qA(u4, CA2, b4, 0)) + g6 | 0, g6 = h3 + A8 | 0, g6 = B4 >>> 0 < a4 >>> 0 ? g6 + 1 | 0 : g6, a4 = qA(_4, CA2, U4, 0), A8 = h3 + g6 | 0, A8 = (B4 = a4 + B4 | 0) >>> 0 < a4 >>> 0 ? A8 + 1 | 0 : A8, a4 = qA(c4, 0, v4, 0), g6 = h3 + A8 | 0, g6 = (B4 = a4 + B4 | 0) >>> 0 < a4 >>> 0 ? g6 + 1 | 0 : g6, A8 = (a4 = qA(N4, 0, o4, 0)) + B4 | 0, B4 = h3 + g6 | 0, B4 = A8 >>> 0 < a4 >>> 0 ? B4 + 1 | 0 : B4, g6 = (a4 = qA(e4, CA2, P4, 0)) + A8 | 0, A8 = h3 + B4 | 0, A8 = g6 >>> 0 < a4 >>> 0 ? A8 + 1 | 0 : A8, A8 = (aA2 >>> 21 | 0) + (g6 = (B4 = (a4 = (n3[r4 + 28 | 0] | n3[r4 + 29 | 0] << 8 | n3[r4 + 30 | 0] << 16 | n3[r4 + 31 | 0] << 24) >>> 7 | 0) + g6 | 0) >>> 0 < a4 >>> 0 ? A8 + 1 | 0 : A8) | 0, A8 = (B4 = (a4 = (2097151 & aA2) << 11 | YA2 >>> 21) + B4 | 0) >>> 0 < a4 >>> 0 ? A8 + 1 | 0 : A8, a4 = B4, GA2 = A8, vA2 = A8 = A8 - ((B4 >>> 0 < 4293918720) - 1 | 0) | 0, g6 = IA4, IA4 = (2097151 & A8) << 11 | (nA2 = B4 - -1048576 | 0) >>> 21, A8 = (A8 >> 21) + hA2 | 0, A8 = (B4 = g6 + IA4 | 0) >>> 0 < IA4 >>> 0 ? A8 + 1 | 0 : A8, IA4 = B4, mA2 = A8, wA2 = A8 = A8 - ((B4 >>> 0 < 4293918720) - 1 | 0) | 0, g6 = QA2, QA2 = (2097151 & A8) << 11 | (CA2 = B4 - -1048576 | 0) >>> 21, A8 = (A8 >> 21) + bA2 | 0, aA2 = A8 = (B4 = g6 + QA2 | 0) >>> 0 < QA2 >>> 0 ? A8 + 1 | 0 : A8, hA2 = A8 = A8 - ((B4 >>> 0 < 4293918720) - 1 | 0) | 0, SA2 = (2097151 & A8) << 11 | (QA2 = B4 - -1048576 | 0) >>> 21, A8 = (A8 >> 21) + RA2 | 0, bA2 = iA2 = SA2 + iA2 | 0, iA2 = A8 = iA2 >>> 0 < SA2 >>> 0 ? A8 + 1 | 0 : A8, A8 = (g6 = lA2) + (lA2 = qA(bA2, A8, -683901, -1)) | 0, g6 = h3 + DA2 | 0, SA2 = A8, DA2 = A8 >>> 0 < lA2 >>> 0 ? g6 + 1 | 0 : g6, aA2 = aA2 - (((A8 = -2097152 & QA2) >>> 0 > B4 >>> 0) + hA2 | 0) | 0, NA2 = B4 - A8 | 0, g6 = qA(q4, kA2, 470296, 0) + EA2 | 0, A8 = AI2 + h3 | 0, A8 = g6 >>> 0 < EA2 >>> 0 ? A8 + 1 | 0 : A8, B4 = (EA2 = qA(V4, uA2, 654183, 0)) + (g6 - (QA2 = -2097152 & yA2) | 0) | 0, g6 = h3 + (A8 - ((g6 >>> 0 < QA2 >>> 0) + gI2 | 0) | 0) | 0, g6 = B4 >>> 0 < EA2 >>> 0 ? g6 + 1 | 0 : g6, A8 = B4, B4 = qA(X4, sA2, -997805, -1), g6 = h3 + g6 | 0, g6 = (A8 = A8 + B4 | 0) >>> 0 < B4 >>> 0 ? g6 + 1 | 0 : g6, B4 = (QA2 = qA(bA2, iA2, 136657, 0)) + A8 | 0, A8 = h3 + g6 | 0, A8 = B4 >>> 0 < QA2 >>> 0 ? A8 + 1 | 0 : A8, g6 = (QA2 = qA(NA2, aA2, -683901, -1)) + B4 | 0, B4 = h3 + A8 | 0, yA2 = B4 = g6 >>> 0 < QA2 >>> 0 ? B4 + 1 | 0 : B4, lA2 = B4 = B4 - ((g6 >>> 0 < 4293918720) - 1 | 0) | 0, A8 = (A8 = B4 >> 21) + DA2 | 0, A8 = (B4 = (QA2 = (2097151 & B4) << 11 | (EA2 = g6 - -1048576 | 0) >>> 21) + SA2 | 0) >>> 0 < QA2 >>> 0 ? A8 + 1 | 0 : A8, QA2 = B4, DA2 = A8, SA2 = B4 = A8 - ((B4 >>> 0 < 4293918720) - 1 | 0) | 0, RA2 = (2097151 & B4) << 11 | (hA2 = QA2 - -1048576 | 0) >>> 21, B4 = (B4 >> 21) + VA2 | 0, B4 = RA2 >>> 0 > (LA2 = RA2 + OA2 | 0) >>> 0 ? B4 + 1 | 0 : B4, RA2 = LA2, LA2 = B4, jA2 = QA2 - (A8 = -2097152 & hA2) | 0, SA2 = DA2 - ((A8 >>> 0 > QA2 >>> 0) + SA2 | 0) | 0, DA2 = g6 - (A8 = -2097152 & EA2) | 0, yA2 = yA2 - ((A8 >>> 0 > g6 >>> 0) + lA2 | 0) | 0, A8 = (B4 = qA(q4, kA2, 666643, 0)) + (gA3 - (g6 = -2097152 & HA2) | 0) | 0, g6 = h3 + (UA2 - ((g6 >>> 0 > gA3 >>> 0) + $A2 | 0) | 0) | 0, g6 = A8 >>> 0 < B4 >>> 0 ? g6 + 1 | 0 : g6, QA2 = qA(V4, uA2, 470296, 0), B4 = h3 + g6 | 0, B4 = (A8 = QA2 + A8 | 0) >>> 0 < QA2 >>> 0 ? B4 + 1 | 0 : B4, g6 = (QA2 = qA(X4, sA2, 654183, 0)) + A8 | 0, A8 = h3 + B4 | 0, hA2 = g6, QA2 = g6 >>> 0 < QA2 >>> 0 ? A8 + 1 | 0 : A8, gA3 = IA4 - (A8 = -2097152 & CA2) | 0, IA4 = mA2 - ((A8 >>> 0 > IA4 >>> 0) + wA2 | 0) | 0, A8 = qA(T4, eA2, 470296, 0), B4 = h3, g6 = (EA2 = qA(J4, pA2, 666643, 0)) + A8 | 0, A8 = h3 + B4 | 0, A8 = g6 >>> 0 < EA2 >>> 0 ? A8 + 1 | 0 : A8, EA2 = qA(x4, cA2, 654183, 0), B4 = h3 + A8 | 0, B4 = (g6 = EA2 + g6 | 0) >>> 0 < EA2 >>> 0 ? B4 + 1 | 0 : B4, EA2 = qA(L4, fA2, -997805, -1), A8 = h3 + B4 | 0, A8 = (g6 = EA2 + g6 | 0) >>> 0 < EA2 >>> 0 ? A8 + 1 | 0 : A8, B4 = (EA2 = qA(K4, tA2, 136657, 0)) + g6 | 0, g6 = h3 + A8 | 0, g6 = B4 >>> 0 < EA2 >>> 0 ? g6 + 1 | 0 : g6, A8 = B4, B4 = qA(j4, FA2, -683901, -1), g6 = h3 + g6 | 0, g6 = (A8 = A8 + B4 | 0) >>> 0 < B4 >>> 0 ? g6 + 1 | 0 : g6, B4 = A8 + a4 | 0, A8 = g6 + GA2 | 0, A8 = B4 >>> 0 < a4 >>> 0 ? A8 + 1 | 0 : A8, a4 = (g6 = B4) - (B4 = -2097152 & nA2) | 0, B4 = A8 - ((g6 >>> 0 < B4 >>> 0) + vA2 | 0) | 0, g6 = (A8 = a4) + (a4 = (2097151 & rA2) << 11 | XA2 >>> 21) | 0, A8 = (rA2 >> 21) + B4 | 0, A8 = g6 >>> 0 < a4 >>> 0 ? A8 + 1 | 0 : A8, a4 = g6, kA2 = A8, fA2 = g6 = A8 - ((g6 >>> 0 < 4293918720) - 1 | 0) | 0, nA2 = (2097151 & g6) << 11 | (EA2 = a4 - -1048576 | 0) >>> 21, g6 = (g6 >> 21) + IA4 | 0, HA2 = B4 = nA2 + gA3 | 0, gA3 = g6 = B4 >>> 0 < nA2 >>> 0 ? g6 + 1 | 0 : g6, g6 = qA(B4, g6, -683901, -1), B4 = h3 + QA2 | 0, B4 = (A8 = g6 + hA2 | 0) >>> 0 < g6 >>> 0 ? B4 + 1 | 0 : B4, g6 = (IA4 = qA(bA2, iA2, -997805, -1)) + A8 | 0, A8 = h3 + B4 | 0, A8 = g6 >>> 0 < IA4 >>> 0 ? A8 + 1 | 0 : A8, B4 = (IA4 = qA(NA2, aA2, 136657, 0)) + g6 | 0, g6 = h3 + A8 | 0, vA2 = B4, cA2 = B4 >>> 0 < IA4 >>> 0 ? g6 + 1 | 0 : g6, A8 = qA(v4, 0, M4, 0), B4 = h3, g6 = (IA4 = qA(b4, 0, Y4, 0)) + A8 | 0, A8 = h3 + B4 | 0, A8 = g6 >>> 0 < IA4 >>> 0 ? A8 + 1 | 0 : A8, B4 = (IA4 = qA(m4, 0, P4, 0)) + g6 | 0, g6 = h3 + A8 | 0, g6 = B4 >>> 0 < IA4 >>> 0 ? g6 + 1 | 0 : g6, A8 = (IA4 = qA(N4, 0, S4, 0)) + B4 | 0, B4 = h3 + g6 | 0, g6 = A8, A8 = A8 >>> 0 < IA4 >>> 0 ? B4 + 1 | 0 : B4, CA2 = g6 = (B4 = AA4 >>> 7 & 2097151) + g6 | 0, QA2 = g6 >>> 0 < B4 >>> 0 ? A8 + 1 | 0 : A8, A8 = qA(M4, 0, P4, 0), g6 = h3, B4 = qA(v4, 0, Y4, 0), g6 = h3 + g6 | 0, g6 = (A8 = B4 + A8 | 0) >>> 0 < B4 >>> 0 ? g6 + 1 | 0 : g6, IA4 = qA(N4, 0, m4, 0), B4 = h3 + g6 | 0, B4 = (A8 = IA4 + A8 | 0) >>> 0 < IA4 >>> 0 ? B4 + 1 | 0 : B4, g6 = A8, IA4 = 2097151 & ((3 & (A8 = $4)) << 30 | Z4 >>> 2), A8 = B4, A8 = (g6 = g6 + IA4 | 0) >>> 0 < IA4 >>> 0 ? A8 + 1 | 0 : A8, IA4 = g6, nA2 = A8, tA2 = A8 = A8 - ((g6 >>> 0 < 4293918720) - 1 | 0) | 0, g6 = A8 >>> 21 | 0, A8 = (B4 = CA2) + (CA2 = (2097151 & A8) << 11 | (rA2 = IA4 - -1048576 | 0) >>> 21) | 0, B4 = g6 + QA2 | 0, QA2 = A8, FA2 = B4 = A8 >>> 0 < CA2 >>> 0 ? B4 + 1 | 0 : B4, hA2 = A8 = B4 - ((A8 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = C4 + ((2097151 & A8) << 11 | (CA2 = QA2 - -1048576 | 0) >>> 21) | 0, A8 = TA2 + (A8 >>> 21 | 0) | 0, A8 = B4 >>> 0 < C4 >>> 0 ? A8 + 1 | 0 : A8, g6 = (eA2 = qA(V4, uA2, 666643, 0)) + (B4 - (C4 = -2097152 & PA2) | 0) | 0, B4 = h3 + (A8 - ((B4 >>> 0 < C4 >>> 0) + KA2 | 0) | 0) | 0, A8 = (C4 = qA(X4, sA2, 470296, 0)) + g6 | 0, g6 = h3 + (g6 >>> 0 < eA2 >>> 0 ? B4 + 1 | 0 : B4) | 0, g6 = A8 >>> 0 < C4 >>> 0 ? g6 + 1 | 0 : g6, B4 = (C4 = qA(HA2, gA3, 136657, 0)) + A8 | 0, A8 = h3 + g6 | 0, A8 = B4 >>> 0 < C4 >>> 0 ? A8 + 1 | 0 : A8, g6 = B4, B4 = qA(bA2, iA2, 654183, 0), A8 = h3 + A8 | 0, A8 = (g6 = g6 + B4 | 0) >>> 0 < B4 >>> 0 ? A8 + 1 | 0 : A8, B4 = (C4 = qA(NA2, aA2, -997805, -1)) + g6 | 0, g6 = h3 + A8 | 0, eA2 = B4, uA2 = g6 = B4 >>> 0 < C4 >>> 0 ? g6 + 1 | 0 : g6, GA2 = g6 = g6 - ((B4 >>> 0 < 4293918720) - 1 | 0) | 0, C4 = (2097151 & g6) << 11 | (pA2 = B4 - -1048576 | 0) >>> 21, g6 = (g6 >> 21) + cA2 | 0, C4 = g6 = (B4 = C4 + vA2 | 0) >>> 0 < C4 >>> 0 ? g6 + 1 | 0 : g6, vA2 = g6 = g6 - ((B4 >>> 0 < 4293918720) - 1 | 0) | 0, PA2 = (2097151 & g6) << 11 | (cA2 = B4 - -1048576 | 0) >>> 21, g6 = (g6 >> 21) + yA2 | 0, mA2 = DA2 = PA2 + DA2 | 0, DA2 = DA2 >>> 0 < PA2 >>> 0 ? g6 + 1 | 0 : g6, PA2 = C4, g6 = a4 - (A8 = -2097152 & EA2) | 0, C4 = kA2 - ((A8 >>> 0 > a4 >>> 0) + fA2 | 0) | 0, A8 = (a4 = (2097151 & oA2) << 11 | xA2 >>> 21) + g6 | 0, g6 = (oA2 >> 21) + C4 | 0, C4 = A8, kA2 = g6 = A8 >>> 0 < a4 >>> 0 ? g6 + 1 | 0 : g6, fA2 = A8 = g6 - ((A8 >>> 0 < 4293918720) - 1 | 0) | 0, EA2 = g6 = A8 >> 21, a4 = B4, B4 = qA(yA2 = (2097151 & A8) << 11 | (oA2 = C4 - -1048576 | 0) >>> 21, g6, -683901, -1), A8 = h3 + PA2 | 0, A8 = (g6 = a4 + B4 | 0) >>> 0 < B4 >>> 0 ? A8 + 1 | 0 : A8, PA2 = g6 - (B4 = -2097152 & cA2) | 0, vA2 = A8 - ((g6 >>> 0 < B4 >>> 0) + vA2 | 0) | 0, B4 = qA(yA2, EA2, 136657, 0), g6 = h3 + uA2 | 0, g6 = (A8 = B4 + eA2 | 0) >>> 0 < B4 >>> 0 ? g6 + 1 | 0 : g6, wA2 = A8 - (B4 = -2097152 & pA2) | 0, lA2 = g6 - ((A8 >>> 0 < B4 >>> 0) + GA2 | 0) | 0, a4 = qA(X4, sA2, 666643, 0), B4 = h3 + (FA2 - (((g6 = -2097152 & CA2) >>> 0 > QA2 >>> 0) + hA2 | 0) | 0) | 0, B4 = (A8 = a4 + (QA2 - g6 | 0) | 0) >>> 0 < a4 >>> 0 ? B4 + 1 | 0 : B4, g6 = (a4 = qA(HA2, gA3, -997805, -1)) + A8 | 0, A8 = h3 + B4 | 0, A8 = g6 >>> 0 < a4 >>> 0 ? A8 + 1 | 0 : A8, B4 = (a4 = qA(bA2, iA2, 470296, 0)) + g6 | 0, g6 = h3 + A8 | 0, g6 = B4 >>> 0 < a4 >>> 0 ? g6 + 1 | 0 : g6, A8 = B4, B4 = qA(NA2, aA2, 654183, 0), g6 = h3 + g6 | 0, hA2 = A8 = A8 + B4 | 0, CA2 = A8 >>> 0 < B4 >>> 0 ? g6 + 1 | 0 : g6, eA2 = IA4, pA2 = nA2, A8 = qA(N4, 0, M4, 0), B4 = h3, g6 = (a4 = qA(P4, 0, Y4, 0)) + A8 | 0, A8 = h3 + B4 | 0, A8 = g6 >>> 0 < a4 >>> 0 ? A8 + 1 | 0 : A8, B4 = (g6 = (a4 = O4 >>> 5 & 2097151) + g6 | 0) >>> 0 < a4 >>> 0 ? A8 + 1 | 0 : A8, IA4 = g6, a4 = 2097151 & W4, g6 = qA(N4, 0, Y4, 0) + a4 | 0, A8 = h3, A8 = g6 >>> 0 < a4 >>> 0 ? A8 + 1 | 0 : A8, a4 = g6, cA2 = A8, uA2 = A8 = A8 - ((g6 >>> 0 < 4293918720) - 1 | 0) | 0, g6 = (g6 = A8 >>> 21 | 0) + B4 | 0, g6 = (A8 = (nA2 = IA4) + (IA4 = (2097151 & A8) << 11 | (QA2 = a4 - -1048576 | 0) >>> 21) | 0) >>> 0 < IA4 >>> 0 ? g6 + 1 | 0 : g6, IA4 = A8, FA2 = g6, sA2 = A8 = g6 - ((A8 >>> 0 < 4293918720) - 1 | 0) | 0, g6 = eA2, eA2 = (2097151 & A8) << 11 | (nA2 = IA4 - -1048576 | 0) >>> 21, A8 = (A8 >>> 21 | 0) + pA2 | 0, A8 = (B4 = g6 + eA2 | 0) >>> 0 < eA2 >>> 0 ? A8 + 1 | 0 : A8, B4 = (eA2 = qA(HA2, gA3, 654183, 0)) + ((g6 = B4) - (rA2 &= -2097152) | 0) | 0, g6 = h3 + (A8 - ((16383 & tA2) + (g6 >>> 0 < rA2 >>> 0) | 0) | 0) | 0, g6 = B4 >>> 0 < eA2 >>> 0 ? g6 + 1 | 0 : g6, A8 = B4, B4 = qA(bA2, iA2, 666643, 0), g6 = h3 + g6 | 0, g6 = (A8 = A8 + B4 | 0) >>> 0 < B4 >>> 0 ? g6 + 1 | 0 : g6, B4 = (iA2 = qA(NA2, aA2, 470296, 0)) + A8 | 0, A8 = h3 + g6 | 0, A8 = B4 >>> 0 < iA2 >>> 0 ? A8 + 1 | 0 : A8, iA2 = B4, eA2 = A8, pA2 = A8 = A8 - ((B4 >>> 0 < 4293918720) - 1 | 0) | 0, tA2 = (2097151 & A8) << 11 | (rA2 = B4 - -1048576 | 0) >>> 21, A8 = (A8 >> 21) + CA2 | 0, tA2 = A8 = (B4 = tA2 + hA2 | 0) >>> 0 < tA2 >>> 0 ? A8 + 1 | 0 : A8, hA2 = A8 = A8 - ((B4 >>> 0 < 4293918720) - 1 | 0) | 0, g6 = wA2, wA2 = (2097151 & A8) << 11 | (CA2 = B4 - -1048576 | 0) >>> 21, A8 = (A8 >> 21) + lA2 | 0, A8 = wA2 >>> 0 > (GA2 = g6 + wA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, wA2 = GA2, GA2 = A8, A8 = (g6 = qA(yA2, EA2, -997805, -1)) + B4 | 0, B4 = h3 + tA2 | 0, B4 = A8 >>> 0 < g6 >>> 0 ? B4 + 1 | 0 : B4, CA2 = A8 - (g6 = -2097152 & CA2) | 0, tA2 = B4 - ((A8 >>> 0 < g6 >>> 0) + hA2 | 0) | 0, B4 = qA(yA2, EA2, 654183, 0), g6 = h3 + eA2 | 0, g6 = (A8 = B4 + iA2 | 0) >>> 0 < B4 >>> 0 ? g6 + 1 | 0 : g6, eA2 = A8 - (B4 = -2097152 & rA2) | 0, pA2 = g6 - ((A8 >>> 0 < B4 >>> 0) + pA2 | 0) | 0, g6 = (B4 = qA(HA2, gA3, 470296, 0)) + (IA4 - (A8 = -2097152 & nA2) | 0) | 0, A8 = h3 + (FA2 - ((16383 & sA2) + (A8 >>> 0 > IA4 >>> 0) | 0) | 0) | 0, A8 = g6 >>> 0 < B4 >>> 0 ? A8 + 1 | 0 : A8, B4 = (IA4 = qA(NA2, aA2, 666643, 0)) + g6 | 0, g6 = h3 + A8 | 0, iA2 = B4, IA4 = B4 >>> 0 < IA4 >>> 0 ? g6 + 1 | 0 : g6, A8 = (B4 = qA(HA2, gA3, 666643, 0)) + (a4 - (g6 = -2097152 & QA2) | 0) | 0, g6 = h3 + (cA2 - ((4095 & uA2) + (g6 >>> 0 > a4 >>> 0) | 0) | 0) | 0, g6 = A8 >>> 0 < B4 >>> 0 ? g6 + 1 | 0 : g6, B4 = A8, nA2 = g6, gA3 = g6 = g6 - ((A8 >>> 0 < 4293918720) - 1 | 0) | 0, QA2 = iA2, iA2 = (2097151 & g6) << 11 | (a4 = A8 - -1048576 | 0) >>> 21, g6 = (g6 >> 21) + IA4 | 0, iA2 = g6 = (IA4 = QA2 = QA2 + iA2 | 0) >>> 0 < iA2 >>> 0 ? g6 + 1 | 0 : g6, rA2 = g6 = g6 - ((IA4 >>> 0 < 4293918720) - 1 | 0) | 0, A8 = eA2, eA2 = (2097151 & g6) << 11 | (QA2 = IA4 - -1048576 | 0) >>> 21, g6 = (g6 >> 21) + pA2 | 0, g6 = (aA2 = A8 + eA2 | 0) >>> 0 < eA2 >>> 0 ? g6 + 1 | 0 : g6, eA2 = aA2, aA2 = g6, g6 = (A8 = IA4) + (IA4 = qA(yA2, EA2, 470296, 0)) | 0, A8 = h3 + iA2 | 0, A8 = g6 >>> 0 < IA4 >>> 0 ? A8 + 1 | 0 : A8, QA2 = g6 - (IA4 = -2097152 & QA2) | 0, IA4 = A8 - ((g6 >>> 0 < IA4 >>> 0) + rA2 | 0) | 0, iA2 = QA2, A8 = (B4 - (g6 = -2097152 & a4) | 0) + (a4 = qA(yA2, EA2, 666643, 0)) | 0, g6 = h3 + (nA2 - ((g6 >>> 0 > B4 >>> 0) + gA3 | 0) | 0) | 0, QA2 = A8, B4 = A8, A8 = (A8 = (g6 = A8 >>> 0 < a4 >>> 0 ? g6 + 1 | 0 : g6) >> 21) + IA4 | 0, A8 = (g6 = iA2 + (B4 = (2097151 & g6) << 11 | B4 >>> 21) | 0) >>> 0 < B4 >>> 0 ? A8 + 1 | 0 : A8, nA2 = g6, B4 = g6, g6 = (g6 = A8 >> 21) + aA2 | 0, EA2 = A8 = (B4 = (2097151 & A8) << 11 | B4 >>> 21) + eA2 | 0, a4 = (2097151 & (g6 = A8 >>> 0 < B4 >>> 0 ? g6 + 1 | 0 : g6)) << 11 | (B4 = A8) >>> 21, B4 = (A8 = g6 >> 21) + tA2 | 0, iA2 = g6 = a4 + CA2 | 0, a4 = (2097151 & (B4 = (A8 = g6) >>> 0 < a4 >>> 0 ? B4 + 1 | 0 : B4)) << 11 | A8 >>> 21, A8 = (g6 = B4 >> 21) + GA2 | 0, rA2 = B4 = a4 + wA2 | 0, a4 = (2097151 & (A8 = (g6 = B4) >>> 0 < a4 >>> 0 ? A8 + 1 | 0 : A8)) << 11 | g6 >>> 21, g6 = (B4 = A8 >> 21) + vA2 | 0, aA2 = A8 = a4 + PA2 | 0, B4 = A8, A8 = (A8 = (g6 = A8 >>> 0 < a4 >>> 0 ? g6 + 1 | 0 : g6) >> 21) + DA2 | 0, A8 = (g6 = (B4 = (2097151 & g6) << 11 | B4 >>> 21) + mA2 | 0) >>> 0 < B4 >>> 0 ? A8 + 1 | 0 : A8, CA2 = g6, B4 = g6, g6 = (g6 = A8 >> 21) + SA2 | 0, eA2 = A8 = (B4 = (2097151 & A8) << 11 | B4 >>> 21) + jA2 | 0, a4 = (2097151 & (g6 = A8 >>> 0 < B4 >>> 0 ? g6 + 1 | 0 : g6)) << 11 | (B4 = A8) >>> 21, B4 = (A8 = g6 >> 21) + LA2 | 0, pA2 = g6 = a4 + RA2 | 0, a4 = (2097151 & (B4 = (A8 = g6) >>> 0 < a4 >>> 0 ? B4 + 1 | 0 : B4)) << 11 | A8 >>> 21, A8 = (g6 = B4 >> 21) + JA2 | 0, cA2 = B4 = a4 + _A2 | 0, a4 = (2097151 & (A8 = (g6 = B4) >>> 0 < a4 >>> 0 ? A8 + 1 | 0 : A8)) << 11 | g6 >>> 21, g6 = (B4 = A8 >> 21) + BI2 | 0, uA2 = A8 = a4 + zA2 | 0, B4 = A8, A8 = (g6 = A8 >>> 0 < a4 >>> 0 ? g6 + 1 | 0 : g6) >> 21, B4 = (2097151 & g6) << 11 | B4 >>> 21, a4 = C4 - (g6 = -2097152 & oA2) | 0, g6 = (kA2 - ((g6 >>> 0 > C4 >>> 0) + fA2 | 0) | 0) + A8 | 0, oA2 = B4 = B4 + a4 | 0, a4 = B4 = (g6 = (A8 = B4) >>> 0 < a4 >>> 0 ? g6 + 1 | 0 : g6) >> 21, A8 = qA(gA3 = (2097151 & g6) << 11 | A8 >>> 21, B4, 666643, 0), g6 = h3, IA4 = A8 = A8 + (B4 = 2097151 & QA2) | 0, C4 = g6 = A8 >>> 0 < B4 >>> 0 ? g6 + 1 | 0 : g6, Q3[0 | E4] = A8, Q3[E4 + 1 | 0] = (255 & g6) << 24 | A8 >>> 8, B4 = 2097151 & nA2, g6 = qA(gA3, a4, 470296, 0) + B4 | 0, A8 = h3, QA2 = (nA2 = (2097151 & C4) << 11 | IA4 >>> 21) + g6 | 0, g6 = (C4 >> 21) + (A8 = g6 >>> 0 < B4 >>> 0 ? A8 + 1 | 0 : A8) | 0, g6 = QA2 >>> 0 < nA2 >>> 0 ? g6 + 1 | 0 : g6, Q3[E4 + 4 | 0] = (2047 & g6) << 21 | QA2 >>> 11, A8 = g6, Q3[E4 + 3 | 0] = (7 & A8) << 29 | QA2 >>> 3, nA2 = 2097151 & EA2, B4 = qA(gA3, a4, 654183, 0) + nA2 | 0, g6 = h3, EA2 = (2097151 & A8) << 11 | QA2 >>> 21, A8 = (A8 >> 21) + (g6 = B4 >>> 0 < nA2 >>> 0 ? g6 + 1 | 0 : g6) | 0, g6 = A8 = EA2 >>> 0 > (B4 = nA2 = EA2 + B4 | 0) >>> 0 ? A8 + 1 | 0 : A8, Q3[E4 + 6 | 0] = (63 & A8) << 26 | B4 >>> 6, nA2 = 0, A8 = QA2 &= 2097151, Q3[E4 + 2 | 0] = 31 & ((65535 & C4) << 16 | IA4 >>> 16) | A8 << 5, IA4 = 2097151 & iA2, C4 = qA(gA3, a4, -997805, -1) + IA4 | 0, A8 = h3, EA2 = (2097151 & g6) << 11 | B4 >>> 21, g6 = (g6 >> 21) + (A8 = C4 >>> 0 < IA4 >>> 0 ? A8 + 1 | 0 : A8) | 0, g6 = (A8 = IA4 = EA2 + C4 | 0) >>> 0 < EA2 >>> 0 ? g6 + 1 | 0 : g6, Q3[E4 + 9 | 0] = (511 & g6) << 23 | A8 >>> 9, Q3[E4 + 8 | 0] = (1 & g6) << 31 | A8 >>> 1, C4 = 0, IA4 = (B4 = EA2 = 2097151 & B4) << 2, B4 = nA2, Q3[E4 + 5 | 0] = IA4 | (524287 & B4) << 13 | QA2 >>> 19, QA2 = 2097151 & rA2, IA4 = qA(gA3, a4, 136657, 0) + QA2 | 0, B4 = h3, B4 = IA4 >>> 0 < QA2 >>> 0 ? B4 + 1 | 0 : B4, QA2 = IA4, IA4 = B4, B4 = g6, g6 = (g6 >>= 21) + IA4 | 0, g6 = (B4 = (iA2 = QA2) + (QA2 = (2097151 & B4) << 11 | A8 >>> 21) | 0) >>> 0 < QA2 >>> 0 ? g6 + 1 | 0 : g6, Q3[E4 + 12 | 0] = (4095 & g6) << 20 | B4 >>> 12, Q3[E4 + 11 | 0] = (15 & g6) << 28 | B4 >>> 4, IA4 = 0, QA2 = (A8 = nA2 = 2097151 & A8) << 7, A8 = C4, C4 = EA2, Q3[E4 + 7 | 0] = QA2 | (16383 & A8) << 18 | C4 >>> 14, C4 = (A8 = qA(gA3, a4, -683901, -1)) + (a4 = 2097151 & aA2) | 0, A8 = h3, A8 = C4 >>> 0 < a4 >>> 0 ? A8 + 1 | 0 : A8, a4 = C4, C4 = A8, QA2 = (2097151 & (A8 = g6)) << 11 | B4 >>> 21, A8 = (g6 = A8 >> 21) + C4 | 0, A8 = (a4 = QA2 + a4 | 0) >>> 0 < QA2 >>> 0 ? A8 + 1 | 0 : A8, Q3[E4 + 14 | 0] = (127 & A8) << 25 | a4 >>> 7, QA2 = 0, B4 = (g6 = gA3 = 2097151 & B4) << 4, g6 = IA4, Q3[E4 + 10 | 0] = B4 | (131071 & g6) << 15 | nA2 >>> 17, g6 = A8, A8 >>= 21, C4 = B4 = (IA4 = (2097151 & g6) << 11 | a4 >>> 21) + (2097151 & CA2) | 0, g6 = B4 >>> 0 < IA4 >>> 0 ? A8 + 1 | 0 : A8, Q3[E4 + 17 | 0] = (1023 & g6) << 22 | B4 >>> 10, Q3[E4 + 16 | 0] = (3 & g6) << 30 | B4 >>> 2, IA4 = 0, a4 = (A8 = nA2 = 2097151 & a4) << 1, A8 = QA2, Q3[E4 + 13 | 0] = a4 | (1048575 & A8) << 12 | gA3 >>> 20, A8 = g6 >> 21, B4 = (g6 = (a4 = (2097151 & g6) << 11 | B4 >>> 21) + (2097151 & eA2) | 0) >>> 0 < a4 >>> 0 ? A8 + 1 | 0 : A8, a4 = g6, Q3[E4 + 20 | 0] = (8191 & B4) << 19 | g6 >>> 13, Q3[E4 + 19 | 0] = (31 & B4) << 27 | g6 >>> 5, g6 = (A8 = gA3 = 2097151 & C4) << 6, A8 = IA4, Q3[E4 + 15 | 0] = g6 | (32767 & A8) << 17 | nA2 >>> 15, g6 = B4 >> 21, nA2 = C4 = (IA4 = (2097151 & B4) << 11 | a4 >>> 21) + (2097151 & pA2) | 0, C4 = C4 >>> 0 < IA4 >>> 0 ? g6 + 1 | 0 : g6, Q3[E4 + 21 | 0] = nA2, g6 = (A8 = a4) << 3, A8 = QA2, Q3[E4 + 18 | 0] = g6 | (262143 & A8) << 14 | gA3 >>> 18, A8 = nA2, Q3[E4 + 22 | 0] = (255 & C4) << 24 | A8 >>> 8, g6 = C4 >> 21, g6 = (A8 = (a4 = (2097151 & C4) << 11 | A8 >>> 21) + (2097151 & cA2) | 0) >>> 0 < a4 >>> 0 ? g6 + 1 | 0 : g6, a4 = A8, Q3[E4 + 25 | 0] = (2047 & g6) << 21 | A8 >>> 11, Q3[E4 + 24 | 0] = (7 & g6) << 29 | A8 >>> 3, A8 = g6 >> 21, B4 = (g6 = (IA4 = (2097151 & g6) << 11 | a4 >>> 21) + (2097151 & uA2) | 0) >>> 0 < IA4 >>> 0 ? A8 + 1 | 0 : A8, IA4 = g6, Q3[E4 + 27 | 0] = (63 & B4) << 26 | g6 >>> 6, A8 = a4 &= 2097151, Q3[E4 + 23 | 0] = 31 & ((65535 & C4) << 16 | nA2 >>> 16) | A8 << 5, A8 = B4 >> 21, A8 = (g6 = (B4 = (2097151 & B4) << 11 | g6 >>> 21) + (2097151 & oA2) | 0) >>> 0 < B4 >>> 0 ? A8 + 1 | 0 : A8, Q3[E4 + 31 | 0] = (131071 & A8) << 15 | g6 >>> 17, Q3[E4 + 30 | 0] = (511 & A8) << 23 | g6 >>> 9, Q3[E4 + 29 | 0] = (1 & A8) << 31 | g6 >>> 1, C4 = 0, A8 = (B4 = IA4 &= 2097151) << 2, B4 = QA2, Q3[E4 + 26 | 0] = A8 | (524287 & B4) << 13 | a4 >>> 19, A8 = C4, Q3[E4 + 28 | 0] = (16383 & A8) << 18 | IA4 >>> 14 | g6 << 7, Dg(d4, 64), Dg(r4, 64), I7 && (i3[I7 >> 2] = 64, i3[I7 + 4 >> 2] = 0), s3 = R4 + 560 | 0, 0;
                      }
                      function F3(A8, I7, g6, B4) {
                        for (var C4 = 0, Q4 = 0, E4 = 0, a4 = 0, r4 = 0, o4 = 0, t4 = 0, e4 = 0, f4 = 0, c4 = 0, y4 = 0, s4 = 0, w4 = 0, D4 = 0, p4 = 0, u4 = 0, F4 = 0, l4 = 0, _4 = 0, k4 = 0, H4 = 0, G4 = 0, U4 = 0, S4 = 0, b4 = 0, m4 = 0, v4 = 0, M4 = 0, P4 = 0, Y4 = 0, N4 = 0, R4 = 0, d4 = 0, J4 = 0, x4 = 0, L4 = 0, K4 = 0, X4 = 0, T4 = 0, V4 = 0; a4 = (C4 = t4 << 3) + g6 | 0, k4 = n3[4 + (C4 = I7 + C4 | 0) | 0] | n3[C4 + 5 | 0] << 8 | n3[C4 + 6 | 0] << 16 | n3[C4 + 7 | 0] << 24, E4 = (o4 = c4 = n3[0 | C4] | n3[C4 + 1 | 0] << 8 | n3[C4 + 2 | 0] << 16 | n3[C4 + 3 | 0] << 24) << 24 | o4 << 8 & 16711680, i3[a4 >> 2] = -16777216 & ((255 & k4) << 24 | o4 >>> 8) | 16711680 & ((16777215 & k4) << 8 | o4 >>> 24) | k4 >>> 8 & 65280 | k4 >>> 24, C4 = 0, i3[a4 + 4 >> 2] = 65280 & (k4 << 24 | o4 >>> 8) | 255 & (k4 << 8 | o4 >>> 24) | E4 | C4 | C4, (0 | (t4 = t4 + 1 | 0)) != 16; )
                          ;
                        for (I7 = eI(B4, A8, 64); ; ) {
                          if (C4 = i3[(B4 = k4 = (H4 = L4 << 3) + g6 | 0) >> 2], B4 = i3[B4 + 4 >> 2], a4 = pA(w4 = i3[I7 + 32 >> 2], e4 = i3[I7 + 36 >> 2], 14), E4 = h3, a4 = pA(w4, e4, 18) ^ a4, E4 ^= h3, a4 = pA(w4, e4, 41) ^ a4, B4 = (h3 ^ E4) + B4 | 0, B4 = (C4 = a4 + C4 | 0) >>> 0 < a4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = i3[I7 + 48 >> 2], C4 = (E4 = i3[(a4 = H4 + 34144 | 0) >> 2]) + C4 | 0, B4 = i3[a4 + 4 >> 2] + B4 | 0, B4 = C4 >>> 0 < E4 >>> 0 ? B4 + 1 | 0 : B4, a4 = (E4 = Q4 ^ ((s4 = i3[I7 + 40 >> 2]) ^ Q4) & w4) + C4 | 0, C4 = (((D4 = i3[I7 + 52 >> 2]) ^ (p4 = i3[I7 + 44 >> 2])) & e4 ^ D4) + B4 | 0, C4 = E4 >>> 0 > a4 >>> 0 ? C4 + 1 | 0 : C4, a4 = (E4 = i3[I7 + 56 >> 2]) + a4 | 0, B4 = i3[I7 + 60 >> 2] + C4 | 0, B4 = E4 >>> 0 > a4 >>> 0 ? B4 + 1 | 0 : B4, E4 = a4 + (t4 = i3[I7 + 24 >> 2]) | 0, C4 = i3[I7 + 28 >> 2] + B4 | 0, o4 = E4, f4 = C4 = E4 >>> 0 < t4 >>> 0 ? C4 + 1 | 0 : C4, i3[I7 + 24 >> 2] = E4, i3[I7 + 28 >> 2] = C4, C4 = pA(F4 = i3[I7 >> 2], t4 = i3[I7 + 4 >> 2], 28), c4 = h3, C4 = pA(F4, t4, 34) ^ C4, E4 = h3 ^ c4, c4 = a4 + (pA(F4, t4, 39) ^ C4) | 0, C4 = B4 + (h3 ^ E4) | 0, C4 = a4 >>> 0 > c4 >>> 0 ? C4 + 1 | 0 : C4, c4 = (u4 = F4 & ((a4 = i3[I7 + 16 >> 2]) | (r4 = i3[I7 + 8 >> 2])) | a4 & r4) + c4 | 0, B4 = (B4 = C4) + (t4 & ((C4 = i3[I7 + 20 >> 2]) | (E4 = i3[I7 + 12 >> 2])) | C4 & E4) | 0, B4 = c4 >>> 0 < u4 >>> 0 ? B4 + 1 | 0 : B4, u4 = c4, c4 = B4, i3[I7 + 56 >> 2] = u4, i3[I7 + 60 >> 2] = B4, B4 = C4, C4 = pA(o4, f4, 14), y4 = h3, l4 = pA(o4, f4, 18) ^ C4, y4 ^= h3, S4 = a4, a4 = (C4 = Q4) + (Q4 = (s4 ^ w4) & o4 ^ s4) | 0, C4 = ((e4 ^ p4) & f4 ^ p4) + D4 | 0, C4 = a4 >>> 0 < Q4 >>> 0 ? C4 + 1 | 0 : C4, Q4 = pA(o4, f4, 41) ^ l4, C4 = (h3 ^ y4) + C4 | 0, C4 = (a4 = Q4 + a4 | 0) >>> 0 < Q4 >>> 0 ? C4 + 1 | 0 : C4, a4 = (y4 = i3[(D4 = v4 = (Q4 = 8 | H4) + g6 | 0) >> 2]) + a4 | 0, C4 = i3[D4 + 4 >> 2] + C4 | 0, C4 = a4 >>> 0 < y4 >>> 0 ? C4 + 1 | 0 : C4, a4 = (D4 = i3[(Q4 = Q4 + 34144 | 0) >> 2]) + a4 | 0, C4 = i3[Q4 + 4 >> 2] + C4 | 0, C4 = a4 >>> 0 < D4 >>> 0 ? C4 + 1 | 0 : C4, y4 = a4, D4 = B4, B4 = C4, C4 = D4 + C4 | 0, C4 = (a4 = S4 + (Q4 = a4) | 0) >>> 0 < Q4 >>> 0 ? C4 + 1 | 0 : C4, Q4 = a4, D4 = C4, i3[I7 + 16 >> 2] = Q4, i3[I7 + 20 >> 2] = C4, C4 = pA(u4, c4, 28), a4 = h3, l4 = pA(u4, c4, 34) ^ C4, _4 = h3 ^ a4, a4 = (C4 = y4) + (y4 = (r4 | F4) & u4 | r4 & F4) | 0, C4 = ((E4 | t4) & c4 | E4 & t4) + B4 | 0, C4 = a4 >>> 0 < y4 >>> 0 ? C4 + 1 | 0 : C4, y4 = pA(u4, c4, 39) ^ l4, B4 = (h3 ^ _4) + C4 | 0, B4 = (a4 = y4 + a4 | 0) >>> 0 < y4 >>> 0 ? B4 + 1 | 0 : B4, y4 = a4, a4 = B4, i3[I7 + 48 >> 2] = y4, i3[I7 + 52 >> 2] = B4, B4 = pA(Q4, D4, 14), C4 = h3, l4 = pA(Q4, D4, 18) ^ B4, _4 = h3 ^ C4, S4 = r4, C4 = ((e4 ^ f4) & D4 ^ e4) + p4 | 0, C4 = (B4 = (r4 = (o4 ^ w4) & Q4 ^ w4) + s4 | 0) >>> 0 < r4 >>> 0 ? C4 + 1 | 0 : C4, r4 = pA(Q4, D4, 41) ^ l4, C4 = (h3 ^ _4) + C4 | 0, C4 = (B4 = r4 + B4 | 0) >>> 0 < r4 >>> 0 ? C4 + 1 | 0 : C4, r4 = (r4 = B4) + (p4 = i3[(B4 = M4 = (s4 = 16 | H4) + g6 | 0) >> 2]) | 0, B4 = i3[B4 + 4 >> 2] + C4 | 0, B4 = r4 >>> 0 < p4 >>> 0 ? B4 + 1 | 0 : B4, r4 = (s4 = i3[(C4 = s4 + 34144 | 0) >> 2]) + r4 | 0, C4 = i3[C4 + 4 >> 2] + B4 | 0, C4 = r4 >>> 0 < s4 >>> 0 ? C4 + 1 | 0 : C4, p4 = r4, s4 = r4, B4 = C4, C4 = C4 + E4 | 0, s4 = C4 = (r4 = S4 + r4 | 0) >>> 0 < s4 >>> 0 ? C4 + 1 | 0 : C4, i3[I7 + 8 >> 2] = r4, i3[I7 + 12 >> 2] = C4, C4 = pA(y4, a4, 28), E4 = h3, l4 = pA(y4, a4, 34) ^ C4, E4 ^= h3, B4 = ((t4 | c4) & a4 | t4 & c4) + B4 | 0, B4 = (C4 = (C4 = p4) + (p4 = (u4 | F4) & y4 | u4 & F4) | 0) >>> 0 < p4 >>> 0 ? B4 + 1 | 0 : B4, p4 = pA(y4, a4, 39) ^ l4, B4 = (h3 ^ E4) + B4 | 0, B4 = (C4 = p4 + C4 | 0) >>> 0 < p4 >>> 0 ? B4 + 1 | 0 : B4, p4 = C4, E4 = B4, i3[I7 + 40 >> 2] = C4, i3[I7 + 44 >> 2] = B4, B4 = pA(r4, s4, 14), C4 = h3, l4 = pA(r4, s4, 18) ^ B4, _4 = h3 ^ C4, S4 = F4, C4 = (f4 ^ (f4 ^ D4) & s4) + e4 | 0, C4 = (B4 = (F4 = o4 ^ (Q4 ^ o4) & r4) + w4 | 0) >>> 0 < F4 >>> 0 ? C4 + 1 | 0 : C4, e4 = (F4 = pA(r4, s4, 41) ^ l4) + B4 | 0, B4 = (h3 ^ _4) + C4 | 0, B4 = e4 >>> 0 < F4 >>> 0 ? B4 + 1 | 0 : B4, e4 = (w4 = i3[(C4 = P4 = (F4 = 24 | H4) + g6 | 0) >> 2]) + e4 | 0, C4 = i3[C4 + 4 >> 2] + B4 | 0, C4 = e4 >>> 0 < w4 >>> 0 ? C4 + 1 | 0 : C4, B4 = (B4 = e4) + (F4 = i3[(e4 = F4 + 34144 | 0) >> 2]) | 0, C4 = i3[e4 + 4 >> 2] + C4 | 0, w4 = B4, e4 = S4 + B4 | 0, B4 = (C4 = B4 >>> 0 < F4 >>> 0 ? C4 + 1 | 0 : C4) + t4 | 0, F4 = B4 = e4 >>> 0 < w4 >>> 0 ? B4 + 1 | 0 : B4, i3[I7 >> 2] = e4, i3[I7 + 4 >> 2] = B4, B4 = pA(p4, E4, 28), t4 = h3, l4 = pA(p4, E4, 34) ^ B4, _4 = h3 ^ t4, C4 = ((a4 | c4) & E4 | a4 & c4) + C4 | 0, C4 = (B4 = (t4 = (y4 | u4) & p4 | y4 & u4) + w4 | 0) >>> 0 < t4 >>> 0 ? C4 + 1 | 0 : C4, t4 = (w4 = pA(p4, E4, 39) ^ l4) + B4 | 0, B4 = (h3 ^ _4) + C4 | 0, B4 = t4 >>> 0 < w4 >>> 0 ? B4 + 1 | 0 : B4, w4 = t4, t4 = B4, i3[I7 + 32 >> 2] = w4, i3[I7 + 36 >> 2] = B4, B4 = pA(e4, F4, 14), C4 = h3, l4 = pA(e4, F4, 18) ^ B4, _4 = h3 ^ C4, b4 = u4, C4 = f4 + (D4 ^ (s4 ^ D4) & F4) | 0, C4 = (B4 = o4 + (Q4 ^ (Q4 ^ r4) & e4) | 0) >>> 0 < o4 >>> 0 ? C4 + 1 | 0 : C4, o4 = pA(e4, F4, 41) ^ l4, C4 = (h3 ^ _4) + C4 | 0, C4 = (B4 = o4 + B4 | 0) >>> 0 < o4 >>> 0 ? C4 + 1 | 0 : C4, B4 = (u4 = i3[(f4 = S4 = (o4 = 32 | H4) + g6 | 0) >> 2]) + B4 | 0, C4 = i3[f4 + 4 >> 2] + C4 | 0, C4 = B4 >>> 0 < u4 >>> 0 ? C4 + 1 | 0 : C4, B4 = (f4 = i3[(o4 = o4 + 34144 | 0) >> 2]) + B4 | 0, C4 = i3[o4 + 4 >> 2] + C4 | 0, C4 = B4 >>> 0 < f4 >>> 0 ? C4 + 1 | 0 : C4, u4 = B4, f4 = B4, o4 = b4 + B4 | 0, B4 = C4, C4 = C4 + c4 | 0, f4 = C4 = o4 >>> 0 < f4 >>> 0 ? C4 + 1 | 0 : C4, i3[I7 + 56 >> 2] = o4, i3[I7 + 60 >> 2] = C4, C4 = pA(w4, t4, 28), c4 = h3, l4 = pA(w4, t4, 34) ^ C4, _4 = h3 ^ c4, c4 = (C4 = u4) + (u4 = (y4 | p4) & w4 | y4 & p4) | 0, C4 = ((E4 | a4) & t4 | E4 & a4) + B4 | 0, C4 = c4 >>> 0 < u4 >>> 0 ? C4 + 1 | 0 : C4, u4 = pA(w4, t4, 39) ^ l4, B4 = (h3 ^ _4) + C4 | 0, B4 = (c4 = u4 + c4 | 0) >>> 0 < u4 >>> 0 ? B4 + 1 | 0 : B4, u4 = c4, c4 = B4, i3[I7 + 24 >> 2] = u4, i3[I7 + 28 >> 2] = B4, B4 = pA(o4, f4, 14), C4 = h3, l4 = pA(o4, f4, 18) ^ B4, _4 = h3 ^ C4, b4 = y4, C4 = D4 + (s4 ^ (s4 ^ F4) & f4) | 0, C4 = (B4 = Q4 + (r4 ^ (r4 ^ e4) & o4) | 0) >>> 0 < Q4 >>> 0 ? C4 + 1 | 0 : C4, Q4 = pA(o4, f4, 41) ^ l4, C4 = (h3 ^ _4) + C4 | 0, C4 = (B4 = Q4 + B4 | 0) >>> 0 < Q4 >>> 0 ? C4 + 1 | 0 : C4, Q4 = (Q4 = B4) + (y4 = i3[(B4 = U4 = (D4 = 40 | H4) + g6 | 0) >> 2]) | 0, B4 = i3[B4 + 4 >> 2] + C4 | 0, B4 = Q4 >>> 0 < y4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = (D4 = i3[(C4 = D4 + 34144 | 0) >> 2]) + Q4 | 0, C4 = i3[C4 + 4 >> 2] + B4 | 0, y4 = Q4, B4 = C4 = Q4 >>> 0 < D4 >>> 0 ? C4 + 1 | 0 : C4, C4 = C4 + a4 | 0, D4 = C4 = (Q4 = b4 + Q4 | 0) >>> 0 < y4 >>> 0 ? C4 + 1 | 0 : C4, i3[I7 + 48 >> 2] = Q4, i3[I7 + 52 >> 2] = C4, C4 = pA(u4, c4, 28), a4 = h3, l4 = pA(u4, c4, 34) ^ C4, a4 ^= h3, B4 = ((E4 | t4) & c4 | E4 & t4) + B4 | 0, B4 = (C4 = (C4 = y4) + (y4 = (p4 | w4) & u4 | p4 & w4) | 0) >>> 0 < y4 >>> 0 ? B4 + 1 | 0 : B4, y4 = pA(u4, c4, 39) ^ l4, B4 = (h3 ^ a4) + B4 | 0, B4 = (C4 = y4 + C4 | 0) >>> 0 < y4 >>> 0 ? B4 + 1 | 0 : B4, y4 = C4, a4 = B4, i3[I7 + 16 >> 2] = C4, i3[I7 + 20 >> 2] = B4, B4 = pA(Q4, D4, 14), C4 = h3, l4 = pA(Q4, D4, 18) ^ B4, _4 = h3 ^ C4, G4 = p4, C4 = s4 + (F4 ^ (f4 ^ F4) & D4) | 0, C4 = (B4 = r4 + (e4 ^ (o4 ^ e4) & Q4) | 0) >>> 0 < r4 >>> 0 ? C4 + 1 | 0 : C4, r4 = (s4 = pA(Q4, D4, 41) ^ l4) + B4 | 0, B4 = (h3 ^ _4) + C4 | 0, B4 = r4 >>> 0 < s4 >>> 0 ? B4 + 1 | 0 : B4, r4 = (p4 = i3[(C4 = b4 = (s4 = 48 | H4) + g6 | 0) >> 2]) + r4 | 0, C4 = i3[C4 + 4 >> 2] + B4 | 0, C4 = r4 >>> 0 < p4 >>> 0 ? C4 + 1 | 0 : C4, B4 = (B4 = r4) + (s4 = i3[(r4 = s4 + 34144 | 0) >> 2]) | 0, C4 = i3[r4 + 4 >> 2] + C4 | 0, C4 = B4 >>> 0 < s4 >>> 0 ? C4 + 1 | 0 : C4, p4 = B4, s4 = B4, r4 = G4 + B4 | 0, B4 = C4 + E4 | 0, s4 = B4 = r4 >>> 0 < s4 >>> 0 ? B4 + 1 | 0 : B4, i3[I7 + 40 >> 2] = r4, i3[I7 + 44 >> 2] = B4, B4 = pA(y4, a4, 28), E4 = h3, l4 = pA(y4, a4, 34) ^ B4, _4 = h3 ^ E4, C4 = ((t4 | c4) & a4 | t4 & c4) + C4 | 0, C4 = (B4 = (E4 = (u4 | w4) & y4 | u4 & w4) + p4 | 0) >>> 0 < E4 >>> 0 ? C4 + 1 | 0 : C4, E4 = (p4 = pA(y4, a4, 39) ^ l4) + B4 | 0, B4 = (h3 ^ _4) + C4 | 0, B4 = E4 >>> 0 < p4 >>> 0 ? B4 + 1 | 0 : B4, p4 = E4, E4 = B4, i3[I7 + 8 >> 2] = p4, i3[I7 + 12 >> 2] = B4, B4 = pA(r4, s4, 14), C4 = h3, l4 = pA(r4, s4, 18) ^ B4, _4 = h3 ^ C4, G4 = w4, C4 = F4 + (f4 ^ (f4 ^ D4) & s4) | 0, C4 = (B4 = e4 + (o4 ^ (Q4 ^ o4) & r4) | 0) >>> 0 < e4 >>> 0 ? C4 + 1 | 0 : C4, e4 = pA(r4, s4, 41) ^ l4, C4 = (h3 ^ _4) + C4 | 0, C4 = (B4 = e4 + B4 | 0) >>> 0 < e4 >>> 0 ? C4 + 1 | 0 : C4, B4 = (w4 = i3[(F4 = R4 = (e4 = 56 | H4) + g6 | 0) >> 2]) + B4 | 0, C4 = i3[F4 + 4 >> 2] + C4 | 0, C4 = B4 >>> 0 < w4 >>> 0 ? C4 + 1 | 0 : C4, B4 = (F4 = i3[(e4 = e4 + 34144 | 0) >> 2]) + B4 | 0, C4 = i3[e4 + 4 >> 2] + C4 | 0, w4 = B4, e4 = G4 + B4 | 0, B4 = C4 = B4 >>> 0 < F4 >>> 0 ? C4 + 1 | 0 : C4, C4 = C4 + t4 | 0, F4 = C4 = e4 >>> 0 < w4 >>> 0 ? C4 + 1 | 0 : C4, i3[I7 + 32 >> 2] = e4, i3[I7 + 36 >> 2] = C4, C4 = pA(p4, E4, 28), t4 = h3, l4 = pA(p4, E4, 34) ^ C4, _4 = h3 ^ t4, t4 = (C4 = w4) + (w4 = (y4 | u4) & p4 | y4 & u4) | 0, C4 = ((a4 | c4) & E4 | a4 & c4) + B4 | 0, C4 = t4 >>> 0 < w4 >>> 0 ? C4 + 1 | 0 : C4, w4 = pA(p4, E4, 39) ^ l4, B4 = (h3 ^ _4) + C4 | 0, B4 = (t4 = w4 + t4 | 0) >>> 0 < w4 >>> 0 ? B4 + 1 | 0 : B4, w4 = t4, t4 = B4, i3[I7 >> 2] = w4, i3[I7 + 4 >> 2] = B4, B4 = pA(e4, F4, 14), C4 = h3, l4 = pA(e4, F4, 18) ^ B4, _4 = h3 ^ C4, G4 = u4, C4 = f4 + (D4 ^ (s4 ^ D4) & F4) | 0, C4 = (B4 = o4 + (Q4 ^ (Q4 ^ r4) & e4) | 0) >>> 0 < o4 >>> 0 ? C4 + 1 | 0 : C4, o4 = pA(e4, F4, 41) ^ l4, C4 = (h3 ^ _4) + C4 | 0, C4 = (B4 = o4 + B4 | 0) >>> 0 < o4 >>> 0 ? C4 + 1 | 0 : C4, o4 = (o4 = B4) + (u4 = i3[(B4 = K4 = (f4 = 64 | H4) + g6 | 0) >> 2]) | 0, B4 = i3[B4 + 4 >> 2] + C4 | 0, B4 = o4 >>> 0 < u4 >>> 0 ? B4 + 1 | 0 : B4, o4 = (f4 = i3[(C4 = f4 + 34144 | 0) >> 2]) + o4 | 0, C4 = i3[C4 + 4 >> 2] + B4 | 0, C4 = o4 >>> 0 < f4 >>> 0 ? C4 + 1 | 0 : C4, f4 = o4, B4 = C4, C4 = C4 + c4 | 0, u4 = C4 = (o4 = G4 + o4 | 0) >>> 0 < f4 >>> 0 ? C4 + 1 | 0 : C4, i3[I7 + 24 >> 2] = o4, i3[I7 + 28 >> 2] = C4, C4 = pA(w4, t4, 28), c4 = h3, l4 = pA(w4, t4, 34) ^ C4, c4 ^= h3, B4 = ((E4 | a4) & t4 | E4 & a4) + B4 | 0, B4 = (C4 = (C4 = f4) + (f4 = (y4 | p4) & w4 | y4 & p4) | 0) >>> 0 < f4 >>> 0 ? B4 + 1 | 0 : B4, f4 = pA(w4, t4, 39) ^ l4, B4 = (h3 ^ c4) + B4 | 0, l4 = C4 = f4 + C4 | 0, c4 = B4 = C4 >>> 0 < f4 >>> 0 ? B4 + 1 | 0 : B4, i3[I7 + 56 >> 2] = C4, i3[I7 + 60 >> 2] = B4, B4 = pA(o4, u4, 14), C4 = h3, f4 = pA(o4, u4, 18) ^ B4, _4 = h3 ^ C4, C4 = D4 + (s4 ^ (s4 ^ F4) & u4) | 0, C4 = (B4 = Q4 + (r4 ^ (r4 ^ e4) & o4) | 0) >>> 0 < Q4 >>> 0 ? C4 + 1 | 0 : C4, Q4 = (f4 = pA(o4, u4, 41) ^ f4) + B4 | 0, B4 = (h3 ^ _4) + C4 | 0, B4 = Q4 >>> 0 < f4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = (D4 = i3[(C4 = G4 = (f4 = 72 | H4) + g6 | 0) >> 2]) + Q4 | 0, C4 = i3[C4 + 4 >> 2] + B4 | 0, C4 = Q4 >>> 0 < D4 >>> 0 ? C4 + 1 | 0 : C4, B4 = (B4 = Q4) + (f4 = i3[(Q4 = f4 + 34144 | 0) >> 2]) | 0, C4 = i3[Q4 + 4 >> 2] + C4 | 0, C4 = B4 >>> 0 < f4 >>> 0 ? C4 + 1 | 0 : C4, f4 = B4, Q4 = B4 + y4 | 0, B4 = C4 + a4 | 0, y4 = B4 = Q4 >>> 0 < f4 >>> 0 ? B4 + 1 | 0 : B4, i3[I7 + 16 >> 2] = Q4, i3[I7 + 20 >> 2] = B4, B4 = pA(l4, c4, 28), a4 = h3, D4 = pA(l4, c4, 34) ^ B4, _4 = h3 ^ a4, C4 = ((E4 | t4) & c4 | E4 & t4) + C4 | 0, C4 = (B4 = (a4 = (p4 | w4) & l4 | p4 & w4) + f4 | 0) >>> 0 < a4 >>> 0 ? C4 + 1 | 0 : C4, a4 = (f4 = pA(l4, c4, 39) ^ D4) + B4 | 0, B4 = (h3 ^ _4) + C4 | 0, _4 = a4, a4 = B4 = a4 >>> 0 < f4 >>> 0 ? B4 + 1 | 0 : B4, i3[I7 + 48 >> 2] = _4, i3[I7 + 52 >> 2] = B4, B4 = pA(Q4, y4, 14), C4 = h3, f4 = pA(Q4, y4, 18) ^ B4, D4 = h3 ^ C4, C4 = s4 + (F4 ^ (u4 ^ F4) & y4) | 0, C4 = (B4 = r4 + (e4 ^ (o4 ^ e4) & Q4) | 0) >>> 0 < r4 >>> 0 ? C4 + 1 | 0 : C4, r4 = pA(Q4, y4, 41) ^ f4, C4 = (h3 ^ D4) + C4 | 0, C4 = (B4 = r4 + B4 | 0) >>> 0 < r4 >>> 0 ? C4 + 1 | 0 : C4, B4 = (D4 = i3[(f4 = m4 = (r4 = 80 | H4) + g6 | 0) >> 2]) + B4 | 0, C4 = i3[f4 + 4 >> 2] + C4 | 0, C4 = B4 >>> 0 < D4 >>> 0 ? C4 + 1 | 0 : C4, B4 = (f4 = i3[(r4 = r4 + 34144 | 0) >> 2]) + B4 | 0, C4 = i3[r4 + 4 >> 2] + C4 | 0, C4 = B4 >>> 0 < f4 >>> 0 ? C4 + 1 | 0 : C4, f4 = B4, r4 = B4 + p4 | 0, B4 = C4, C4 = C4 + E4 | 0, s4 = C4 = r4 >>> 0 < f4 >>> 0 ? C4 + 1 | 0 : C4, i3[I7 + 8 >> 2] = r4, i3[I7 + 12 >> 2] = C4, C4 = pA(_4, a4, 28), E4 = h3, D4 = pA(_4, a4, 34) ^ C4, p4 = h3 ^ E4, E4 = (C4 = f4) + (f4 = (w4 | l4) & _4 | w4 & l4) | 0, C4 = ((t4 | c4) & a4 | t4 & c4) + B4 | 0, C4 = E4 >>> 0 < f4 >>> 0 ? C4 + 1 | 0 : C4, f4 = pA(_4, a4, 39) ^ D4, B4 = (h3 ^ p4) + C4 | 0, f4 = B4 = (E4 = f4 + E4 | 0) >>> 0 < f4 >>> 0 ? B4 + 1 | 0 : B4, i3[I7 + 40 >> 2] = E4, i3[I7 + 44 >> 2] = B4, B4 = pA(r4, s4, 14), C4 = h3, D4 = pA(r4, s4, 18) ^ B4, p4 = h3 ^ C4, C4 = F4 + (u4 ^ (y4 ^ u4) & s4) | 0, C4 = (B4 = e4 + (o4 ^ (Q4 ^ o4) & r4) | 0) >>> 0 < e4 >>> 0 ? C4 + 1 | 0 : C4, e4 = pA(r4, s4, 41) ^ D4, C4 = (h3 ^ p4) + C4 | 0, C4 = (B4 = e4 + B4 | 0) >>> 0 < e4 >>> 0 ? C4 + 1 | 0 : C4, e4 = (e4 = B4) + (F4 = i3[(B4 = N4 = (D4 = 88 | H4) + g6 | 0) >> 2]) | 0, B4 = i3[B4 + 4 >> 2] + C4 | 0, B4 = e4 >>> 0 < F4 >>> 0 ? B4 + 1 | 0 : B4, e4 = (D4 = i3[(C4 = D4 + 34144 | 0) >> 2]) + e4 | 0, C4 = i3[C4 + 4 >> 2] + B4 | 0, C4 = e4 >>> 0 < D4 >>> 0 ? C4 + 1 | 0 : C4, D4 = e4, B4 = C4, C4 = C4 + t4 | 0, F4 = C4 = (e4 = e4 + w4 | 0) >>> 0 < D4 >>> 0 ? C4 + 1 | 0 : C4, i3[I7 >> 2] = e4, i3[I7 + 4 >> 2] = C4, C4 = pA(E4, f4, 28), t4 = h3, p4 = pA(E4, f4, 34) ^ C4, t4 ^= h3, B4 = ((a4 | c4) & f4 | a4 & c4) + B4 | 0, B4 = (C4 = (C4 = D4) + (D4 = (l4 | _4) & E4 | l4 & _4) | 0) >>> 0 < D4 >>> 0 ? B4 + 1 | 0 : B4, D4 = pA(E4, f4, 39) ^ p4, B4 = (h3 ^ t4) + B4 | 0, t4 = C4 = D4 + C4 | 0, D4 = B4 = C4 >>> 0 < D4 >>> 0 ? B4 + 1 | 0 : B4, i3[I7 + 32 >> 2] = C4, i3[I7 + 36 >> 2] = B4, B4 = pA(e4, F4, 14), C4 = h3, p4 = pA(e4, F4, 18) ^ B4, w4 = h3 ^ C4, C4 = u4 + (y4 ^ (s4 ^ y4) & F4) | 0, C4 = (B4 = o4 + (Q4 ^ (Q4 ^ r4) & e4) | 0) >>> 0 < o4 >>> 0 ? C4 + 1 | 0 : C4, o4 = (u4 = pA(e4, F4, 41) ^ p4) + B4 | 0, B4 = (h3 ^ w4) + C4 | 0, B4 = o4 >>> 0 < u4 >>> 0 ? B4 + 1 | 0 : B4, o4 = (p4 = i3[(C4 = X4 = (u4 = 96 | H4) + g6 | 0) >> 2]) + o4 | 0, C4 = i3[C4 + 4 >> 2] + B4 | 0, C4 = o4 >>> 0 < p4 >>> 0 ? C4 + 1 | 0 : C4, B4 = (B4 = o4) + (u4 = i3[(o4 = u4 + 34144 | 0) >> 2]) | 0, C4 = i3[o4 + 4 >> 2] + C4 | 0, C4 = B4 >>> 0 < u4 >>> 0 ? C4 + 1 | 0 : C4, u4 = B4, o4 = B4 + l4 | 0, B4 = C4 + c4 | 0, p4 = o4, o4 = B4 = o4 >>> 0 < u4 >>> 0 ? B4 + 1 | 0 : B4, i3[I7 + 56 >> 2] = p4, i3[I7 + 60 >> 2] = B4, B4 = pA(t4, D4, 28), c4 = h3, w4 = pA(t4, D4, 34) ^ B4, l4 = h3 ^ c4, C4 = ((a4 | f4) & D4 | a4 & f4) + C4 | 0, C4 = (B4 = (c4 = (E4 | _4) & t4 | E4 & _4) + u4 | 0) >>> 0 < c4 >>> 0 ? C4 + 1 | 0 : C4, c4 = (u4 = pA(t4, D4, 39) ^ w4) + B4 | 0, B4 = (h3 ^ l4) + C4 | 0, B4 = c4 >>> 0 < u4 >>> 0 ? B4 + 1 | 0 : B4, u4 = c4, c4 = B4, i3[I7 + 24 >> 2] = u4, i3[I7 + 28 >> 2] = B4, B4 = pA(p4, o4, 14), C4 = h3, w4 = pA(p4, o4, 18) ^ B4, l4 = h3 ^ C4, C4 = y4 + (s4 ^ (s4 ^ F4) & o4) | 0, C4 = (B4 = Q4 + (r4 ^ (r4 ^ e4) & p4) | 0) >>> 0 < Q4 >>> 0 ? C4 + 1 | 0 : C4, Q4 = pA(p4, o4, 41) ^ w4, C4 = (h3 ^ l4) + C4 | 0, C4 = (B4 = Q4 + B4 | 0) >>> 0 < Q4 >>> 0 ? C4 + 1 | 0 : C4, B4 = (w4 = i3[(y4 = T4 = (Q4 = 104 | H4) + g6 | 0) >> 2]) + B4 | 0, C4 = i3[y4 + 4 >> 2] + C4 | 0, C4 = B4 >>> 0 < w4 >>> 0 ? C4 + 1 | 0 : C4, B4 = (y4 = i3[(Q4 = Q4 + 34144 | 0) >> 2]) + B4 | 0, C4 = i3[Q4 + 4 >> 2] + C4 | 0, C4 = B4 >>> 0 < y4 >>> 0 ? C4 + 1 | 0 : C4, y4 = B4, Q4 = B4 + _4 | 0, B4 = C4, C4 = C4 + a4 | 0, w4 = Q4, Q4 = C4 = Q4 >>> 0 < y4 >>> 0 ? C4 + 1 | 0 : C4, i3[I7 + 48 >> 2] = w4, i3[I7 + 52 >> 2] = C4, C4 = pA(u4, c4, 28), a4 = h3, l4 = pA(u4, c4, 34) ^ C4, _4 = h3 ^ a4, a4 = (C4 = y4) + (y4 = (E4 | t4) & u4 | E4 & t4) | 0, C4 = ((f4 | D4) & c4 | f4 & D4) + B4 | 0, C4 = a4 >>> 0 < y4 >>> 0 ? C4 + 1 | 0 : C4, y4 = pA(u4, c4, 39) ^ l4, B4 = (h3 ^ _4) + C4 | 0, B4 = (a4 = y4 + a4 | 0) >>> 0 < y4 >>> 0 ? B4 + 1 | 0 : B4, y4 = a4, a4 = B4, i3[I7 + 16 >> 2] = y4, i3[I7 + 20 >> 2] = B4, B4 = pA(w4, Q4, 14), C4 = h3, l4 = pA(w4, Q4, 18) ^ B4, _4 = h3 ^ C4, C4 = s4 + (F4 ^ (o4 ^ F4) & Q4) | 0, C4 = (B4 = r4 + (e4 ^ (e4 ^ p4) & w4) | 0) >>> 0 < r4 >>> 0 ? C4 + 1 | 0 : C4, r4 = pA(w4, Q4, 41) ^ l4, C4 = (h3 ^ _4) + C4 | 0, C4 = (B4 = r4 + B4 | 0) >>> 0 < r4 >>> 0 ? C4 + 1 | 0 : C4, r4 = (r4 = B4) + (_4 = i3[(B4 = l4 = (s4 = 112 | H4) + g6 | 0) >> 2]) | 0, B4 = i3[B4 + 4 >> 2] + C4 | 0, B4 = r4 >>> 0 < _4 >>> 0 ? B4 + 1 | 0 : B4, r4 = (s4 = i3[(C4 = s4 + 34144 | 0) >> 2]) + r4 | 0, C4 = i3[C4 + 4 >> 2] + B4 | 0, C4 = r4 >>> 0 < s4 >>> 0 ? C4 + 1 | 0 : C4, s4 = r4, B4 = C4, C4 = f4 + C4 | 0, f4 = r4 = E4 + r4 | 0, E4 = C4 = E4 >>> 0 > r4 >>> 0 ? C4 + 1 | 0 : C4, i3[I7 + 40 >> 2] = r4, i3[I7 + 44 >> 2] = C4, C4 = pA(y4, a4, 28), r4 = h3, _4 = pA(y4, a4, 34) ^ C4, r4 ^= h3, B4 = ((c4 | D4) & a4 | c4 & D4) + B4 | 0, B4 = (C4 = (C4 = s4) + (s4 = (t4 | u4) & y4 | t4 & u4) | 0) >>> 0 < s4 >>> 0 ? B4 + 1 | 0 : B4, s4 = pA(y4, a4, 39) ^ _4, B4 = (h3 ^ r4) + B4 | 0, B4 = (C4 = s4 + C4 | 0) >>> 0 < s4 >>> 0 ? B4 + 1 | 0 : B4, s4 = C4, r4 = B4, i3[I7 + 8 >> 2] = C4, i3[I7 + 12 >> 2] = B4, B4 = pA(f4, E4, 14), C4 = h3, _4 = pA(f4, E4, 18) ^ B4, Y4 = h3 ^ C4, C4 = F4 + (o4 ^ (Q4 ^ o4) & E4) | 0, C4 = (B4 = e4 + (p4 ^ (p4 ^ w4) & f4) | 0) >>> 0 < e4 >>> 0 ? C4 + 1 | 0 : C4, E4 = (o4 = pA(f4, E4, 41) ^ _4) + B4 | 0, B4 = (h3 ^ Y4) + C4 | 0, B4 = E4 >>> 0 < o4 >>> 0 ? B4 + 1 | 0 : B4, E4 = (e4 = i3[(C4 = o4 = (Q4 = 120 | H4) + g6 | 0) >> 2]) + E4 | 0, C4 = i3[C4 + 4 >> 2] + B4 | 0, C4 = E4 >>> 0 < e4 >>> 0 ? C4 + 1 | 0 : C4, B4 = (B4 = E4) + (Q4 = i3[(E4 = Q4 + 34144 | 0) >> 2]) | 0, C4 = i3[E4 + 4 >> 2] + C4 | 0, C4 = B4 >>> 0 < Q4 >>> 0 ? C4 + 1 | 0 : C4, Q4 = B4, E4 = t4 + B4 | 0, B4 = C4 + D4 | 0, i3[I7 + 32 >> 2] = E4, i3[I7 + 36 >> 2] = E4 >>> 0 < t4 >>> 0 ? B4 + 1 | 0 : B4, B4 = pA(s4, r4, 28), E4 = h3, t4 = pA(s4, r4, 34) ^ B4, E4 ^= h3, C4 = ((a4 | c4) & r4 | a4 & c4) + C4 | 0, c4 = (B4 = (B4 = Q4) + (Q4 = (y4 | u4) & s4 | y4 & u4) | 0) + (a4 = pA(s4, r4, 39) ^ t4) | 0, B4 = (h3 ^ E4) + (B4 >>> 0 < Q4 >>> 0 ? C4 + 1 | 0 : C4) | 0, i3[I7 >> 2] = c4, i3[I7 + 4 >> 2] = a4 >>> 0 > c4 >>> 0 ? B4 + 1 | 0 : B4, (0 | L4) == 64) {
                            for (; g6 = (B4 = V4 << 3) + A8 | 0, B4 = (k4 = i3[(C4 = I7 + B4 | 0) >> 2]) + i3[g6 >> 2] | 0, C4 = i3[g6 + 4 >> 2] + i3[C4 + 4 >> 2] | 0, i3[g6 >> 2] = B4, i3[g6 + 4 >> 2] = B4 >>> 0 < k4 >>> 0 ? C4 + 1 | 0 : C4, (0 | (V4 = V4 + 1 | 0)) != 8; )
                              ;
                            break;
                          }
                          t4 = ((L4 = L4 + 16 | 0) << 3) + g6 | 0, f4 = B4 = i3[l4 + 4 >> 2], C4 = B4 >>> 6 | 0, B4 = ((63 & B4) << 26 | (Y4 = i3[l4 >> 2]) >>> 6) ^ pA(Y4, B4, 19), C4 ^= h3, B4 = (B4 = pA(Y4, f4, 61) ^ B4) + (c4 = d4 = i3[G4 >> 2]) | 0, C4 = (w4 = i3[G4 + 4 >> 2]) + (h3 ^ C4) | 0, C4 = B4 >>> 0 < c4 >>> 0 ? C4 + 1 | 0 : C4, B4 = (c4 = i3[k4 >> 2]) + B4 | 0, C4 = i3[k4 + 4 >> 2] + C4 | 0, Q4 = B4, B4 = B4 >>> 0 < c4 >>> 0 ? C4 + 1 | 0 : C4, C4 = (a4 = c4 = i3[v4 + 4 >> 2]) >>> 7 | 0, c4 = ((127 & a4) << 25 | (E4 = i3[v4 >> 2]) >>> 7) ^ pA(E4, a4, 1), C4 ^= h3, r4 = Q4, Q4 = pA(E4, a4, 8) ^ c4, C4 = (h3 ^ C4) + B4 | 0, G4 = c4 = r4 + Q4 | 0, c4 = C4 = Q4 >>> 0 > c4 >>> 0 ? C4 + 1 | 0 : C4, i3[t4 >> 2] = G4, i3[t4 + 4 >> 2] = C4, B4 = (B4 = E4) + (E4 = J4 = i3[m4 >> 2]) | 0, C4 = (l4 = i3[m4 + 4 >> 2]) + a4 | 0, C4 = B4 >>> 0 < E4 >>> 0 ? C4 + 1 | 0 : C4, E4 = B4, B4 = C4, D4 = a4 = i3[o4 + 4 >> 2], C4 = a4 >>> 6 | 0, a4 = ((63 & a4) << 26 | (m4 = i3[o4 >> 2]) >>> 6) ^ pA(m4, a4, 19), t4 = h3 ^ C4, a4 = pA(m4, D4, 61) ^ a4, B4 = (h3 ^ t4) + B4 | 0, o4 = C4 = a4 + E4 | 0, C4 = C4 >>> 0 < a4 >>> 0 ? B4 + 1 | 0 : B4, B4 = (E4 = a4 = i3[M4 + 4 >> 2]) >>> 7 | 0, a4 = ((127 & E4) << 25 | (t4 = i3[M4 >> 2]) >>> 7) ^ pA(t4, E4, 1), Q4 = h3 ^ B4, a4 = pA(t4, E4, 8) ^ a4, C4 = (h3 ^ Q4) + C4 | 0, p4 = B4 = a4 + o4 | 0, a4 = C4 = B4 >>> 0 < a4 >>> 0 ? C4 + 1 | 0 : C4, i3[k4 + 136 >> 2] = B4, i3[k4 + 140 >> 2] = C4, B4 = (_4 = i3[N4 + 4 >> 2]) + E4 | 0, E4 = C4 = (C4 = t4) + (t4 = x4 = i3[N4 >> 2]) | 0, C4 = C4 >>> 0 < t4 >>> 0 ? B4 + 1 | 0 : B4, B4 = pA(G4, c4, 19), t4 = h3, o4 = pA(G4, c4, 61) ^ ((63 & c4) << 26 | G4 >>> 6) ^ B4, C4 = (h3 ^ c4 >>> 6 ^ t4) + C4 | 0, Q4 = E4 = o4 + E4 | 0, B4 = E4 >>> 0 < o4 >>> 0 ? C4 + 1 | 0 : C4, t4 = E4 = i3[P4 + 4 >> 2], C4 = E4 >>> 7 | 0, E4 = ((127 & E4) << 25 | (o4 = i3[P4 >> 2]) >>> 7) ^ pA(o4, E4, 1), C4 ^= h3, r4 = Q4, Q4 = pA(o4, t4, 8) ^ E4, C4 = (h3 ^ C4) + B4 | 0, s4 = E4 = r4 + Q4 | 0, E4 = C4 = E4 >>> 0 < Q4 >>> 0 ? C4 + 1 | 0 : C4, i3[k4 + 144 >> 2] = s4, i3[k4 + 148 >> 2] = C4, B4 = (v4 = i3[X4 + 4 >> 2]) + t4 | 0, t4 = C4 = (C4 = o4) + (o4 = N4 = i3[X4 >> 2]) | 0, C4 = C4 >>> 0 < o4 >>> 0 ? B4 + 1 | 0 : B4, B4 = pA(p4, a4, 19), o4 = h3, Q4 = pA(p4, a4, 61) ^ ((63 & a4) << 26 | p4 >>> 6) ^ B4, C4 = (h3 ^ a4 >>> 6 ^ o4) + C4 | 0, B4 = Q4 >>> 0 > (r4 = t4 = Q4 + t4 | 0) >>> 0 ? C4 + 1 | 0 : C4, C4 = (o4 = t4 = i3[S4 + 4 >> 2]) >>> 7 | 0, t4 = ((127 & o4) << 25 | (Q4 = i3[S4 >> 2]) >>> 7) ^ pA(Q4, o4, 1), C4 ^= h3, y4 = r4, r4 = pA(Q4, o4, 8) ^ t4, C4 = (h3 ^ C4) + B4 | 0, F4 = t4 = y4 + r4 | 0, t4 = C4 = t4 >>> 0 < r4 >>> 0 ? C4 + 1 | 0 : C4, i3[k4 + 152 >> 2] = F4, i3[k4 + 156 >> 2] = C4, B4 = (P4 = i3[T4 + 4 >> 2]) + o4 | 0, o4 = C4 = (C4 = Q4) + (Q4 = M4 = i3[T4 >> 2]) | 0, C4 = C4 >>> 0 < Q4 >>> 0 ? B4 + 1 | 0 : B4, B4 = pA(s4, E4, 19), Q4 = h3, r4 = pA(s4, E4, 61) ^ ((63 & E4) << 26 | s4 >>> 6) ^ B4, B4 = (h3 ^ E4 >>> 6 ^ Q4) + C4 | 0, e4 = o4 = r4 + o4 | 0, C4 = o4 >>> 0 < r4 >>> 0 ? B4 + 1 | 0 : B4, r4 = o4 = i3[U4 + 4 >> 2], B4 = o4 >>> 7 | 0, o4 = ((127 & o4) << 25 | (Q4 = i3[U4 >> 2]) >>> 7) ^ pA(Q4, o4, 1), u4 = h3 ^ B4, o4 = pA(Q4, r4, 8) ^ o4, C4 = (h3 ^ u4) + C4 | 0, u4 = B4 = o4 + e4 | 0, o4 = C4 = B4 >>> 0 < o4 >>> 0 ? C4 + 1 | 0 : C4, i3[k4 + 160 >> 2] = B4, i3[k4 + 164 >> 2] = C4, B4 = r4 + f4 | 0, B4 = (C4 = Q4 + Y4 | 0) >>> 0 < Q4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = C4, C4 = B4, B4 = pA(F4, t4, 19), r4 = h3, e4 = pA(F4, t4, 61) ^ ((63 & t4) << 26 | F4 >>> 6) ^ B4, C4 = (h3 ^ t4 >>> 6 ^ r4) + C4 | 0, C4 = (Q4 = e4 + Q4 | 0) >>> 0 < e4 >>> 0 ? C4 + 1 | 0 : C4, e4 = Q4, Q4 = C4, C4 = (r4 = i3[b4 + 4 >> 2]) >>> 7 | 0, y4 = ((127 & r4) << 25 | (B4 = i3[b4 >> 2]) >>> 7) ^ pA(B4, r4, 1), C4 ^= h3, y4 = pA(B4, r4, 8) ^ y4, C4 = (h3 ^ C4) + Q4 | 0, C4 = (e4 = y4 + e4 | 0) >>> 0 < y4 >>> 0 ? C4 + 1 | 0 : C4, y4 = e4, Q4 = C4, i3[k4 + 168 >> 2] = e4, i3[k4 + 172 >> 2] = C4, C4 = B4, B4 = r4 + D4 | 0, C4 = C4 >>> 0 > (r4 = e4 = C4 + m4 | 0) >>> 0 ? B4 + 1 | 0 : B4, B4 = pA(u4, o4, 19), e4 = h3, H4 = pA(u4, o4, 61) ^ ((63 & o4) << 26 | u4 >>> 6) ^ B4, C4 = (h3 ^ o4 >>> 6 ^ e4) + C4 | 0, S4 = r4 = H4 + r4 | 0, B4 = r4 >>> 0 < H4 >>> 0 ? C4 + 1 | 0 : C4, H4 = r4 = i3[R4 + 4 >> 2], C4 = r4 >>> 7 | 0, r4 = ((127 & r4) << 25 | (e4 = i3[R4 >> 2]) >>> 7) ^ pA(e4, r4, 1), U4 = h3 ^ C4, r4 = pA(e4, H4, 8) ^ r4, B4 = (h3 ^ U4) + B4 | 0, S4 = C4 = r4 + S4 | 0, r4 = B4 = C4 >>> 0 < r4 >>> 0 ? B4 + 1 | 0 : B4, i3[k4 + 176 >> 2] = C4, i3[k4 + 180 >> 2] = B4, B4 = c4 + H4 | 0, B4 = (C4 = e4 + G4 | 0) >>> 0 < e4 >>> 0 ? B4 + 1 | 0 : B4, e4 = C4, C4 = B4, B4 = pA(y4, Q4, 19), H4 = h3, U4 = pA(y4, Q4, 61) ^ ((63 & Q4) << 26 | y4 >>> 6) ^ B4, C4 = (h3 ^ Q4 >>> 6 ^ H4) + C4 | 0, b4 = e4 = U4 + e4 | 0, e4 = e4 >>> 0 < U4 >>> 0 ? C4 + 1 | 0 : C4, U4 = H4 = i3[K4 + 4 >> 2], C4 = H4 >>> 7 | 0, H4 = ((127 & H4) << 25 | (B4 = i3[K4 >> 2]) >>> 7) ^ pA(B4, H4, 1), C4 ^= h3, R4 = b4, b4 = pA(B4, U4, 8) ^ H4, C4 = (h3 ^ C4) + e4 | 0, e4 = C4 = (H4 = R4 + b4 | 0) >>> 0 < b4 >>> 0 ? C4 + 1 | 0 : C4, i3[k4 + 184 >> 2] = H4, i3[k4 + 188 >> 2] = C4, C4 = B4, B4 = a4 + U4 | 0, C4 = C4 >>> 0 > (a4 = p4 = C4 + p4 | 0) >>> 0 ? B4 + 1 | 0 : B4, B4 = pA(S4, r4, 19), p4 = h3, U4 = pA(S4, r4, 61) ^ ((63 & r4) << 26 | S4 >>> 6) ^ B4, B4 = (h3 ^ r4 >>> 6 ^ p4) + C4 | 0, C4 = B4 = (a4 = U4 + a4 | 0) >>> 0 < U4 >>> 0 ? B4 + 1 | 0 : B4, B4 = pA(d4, w4, 1), p4 = h3, U4 = pA(d4, w4, 8) ^ ((127 & w4) << 25 | d4 >>> 7) ^ B4, C4 = (h3 ^ w4 >>> 7 ^ p4) + C4 | 0, p4 = a4 = U4 + a4 | 0, a4 = C4 = a4 >>> 0 < U4 >>> 0 ? C4 + 1 | 0 : C4, i3[k4 + 192 >> 2] = p4, i3[k4 + 196 >> 2] = C4, B4 = E4 + w4 | 0, E4 = C4 = s4 + d4 | 0, C4 = B4 = C4 >>> 0 < s4 >>> 0 ? B4 + 1 | 0 : B4, B4 = pA(H4, e4, 19), s4 = h3, w4 = pA(H4, e4, 61) ^ ((63 & e4) << 26 | H4 >>> 6) ^ B4, B4 = (h3 ^ e4 >>> 6 ^ s4) + C4 | 0, C4 = B4 = (E4 = w4 + E4 | 0) >>> 0 < w4 >>> 0 ? B4 + 1 | 0 : B4, B4 = pA(J4, l4, 1), s4 = h3, w4 = pA(J4, l4, 8) ^ ((127 & l4) << 25 | J4 >>> 7) ^ B4, C4 = (h3 ^ l4 >>> 7 ^ s4) + C4 | 0, s4 = E4 = w4 + E4 | 0, E4 = C4 = E4 >>> 0 < w4 >>> 0 ? C4 + 1 | 0 : C4, i3[k4 + 200 >> 2] = s4, i3[k4 + 204 >> 2] = C4, B4 = t4 + l4 | 0, t4 = C4 = F4 + J4 | 0, C4 = B4 = C4 >>> 0 < F4 >>> 0 ? B4 + 1 | 0 : B4, B4 = pA(p4, a4, 19), F4 = h3, w4 = pA(p4, a4, 61) ^ ((63 & a4) << 26 | p4 >>> 6) ^ B4, B4 = (h3 ^ a4 >>> 6 ^ F4) + C4 | 0, C4 = B4 = (t4 = w4 + t4 | 0) >>> 0 < w4 >>> 0 ? B4 + 1 | 0 : B4, B4 = pA(x4, _4, 1), F4 = h3, w4 = pA(x4, _4, 8) ^ ((127 & _4) << 25 | x4 >>> 7) ^ B4, C4 = (h3 ^ _4 >>> 7 ^ F4) + C4 | 0, F4 = t4 = w4 + t4 | 0, t4 = C4 = t4 >>> 0 < w4 >>> 0 ? C4 + 1 | 0 : C4, i3[k4 + 208 >> 2] = F4, i3[k4 + 212 >> 2] = C4, B4 = o4 + _4 | 0, o4 = C4 = u4 + x4 | 0, C4 = B4 = C4 >>> 0 < u4 >>> 0 ? B4 + 1 | 0 : B4, B4 = pA(s4, E4, 19), u4 = h3, w4 = o4, o4 = B4, B4 = E4 >>> 6 | 0, o4 = pA(s4, E4, 61) ^ o4 ^ ((63 & E4) << 26 | s4 >>> 6), B4 = (h3 ^ B4 ^ u4) + C4 | 0, C4 = B4 = (E4 = w4 + o4 | 0) >>> 0 < o4 >>> 0 ? B4 + 1 | 0 : B4, B4 = pA(N4, v4, 1), o4 = h3, s4 = pA(N4, v4, 8) ^ ((127 & v4) << 25 | N4 >>> 7) ^ B4, C4 = (h3 ^ v4 >>> 7 ^ o4) + C4 | 0, o4 = E4 = s4 + E4 | 0, E4 = C4 = E4 >>> 0 < s4 >>> 0 ? C4 + 1 | 0 : C4, i3[k4 + 216 >> 2] = o4, i3[k4 + 220 >> 2] = C4, B4 = Q4 + v4 | 0, Q4 = C4 = y4 + N4 | 0, C4 = B4 = C4 >>> 0 < y4 >>> 0 ? B4 + 1 | 0 : B4, B4 = pA(F4, t4, 19), s4 = h3, y4 = Q4, Q4 = B4, B4 = t4 >>> 6 | 0, Q4 = pA(F4, t4, 61) ^ Q4 ^ ((63 & t4) << 26 | F4 >>> 6), B4 = (h3 ^ B4 ^ s4) + C4 | 0, C4 = B4 = Q4 >>> 0 > (t4 = y4 + Q4 | 0) >>> 0 ? B4 + 1 | 0 : B4, B4 = pA(M4, P4, 1), Q4 = h3, s4 = pA(M4, P4, 8) ^ ((127 & P4) << 25 | M4 >>> 7) ^ B4, C4 = (h3 ^ P4 >>> 7 ^ Q4) + C4 | 0, t4 = C4 = (Q4 = t4 = s4 + t4 | 0) >>> 0 < s4 >>> 0 ? C4 + 1 | 0 : C4, i3[k4 + 224 >> 2] = Q4, i3[k4 + 228 >> 2] = C4, B4 = r4 + P4 | 0, r4 = C4 = S4 + M4 | 0, C4 = B4 = C4 >>> 0 < M4 >>> 0 ? B4 + 1 | 0 : B4, B4 = pA(o4, E4, 19), s4 = h3, y4 = B4, B4 = E4 >>> 6 | 0, o4 = pA(o4, E4, 61) ^ y4 ^ ((63 & E4) << 26 | o4 >>> 6), B4 = (h3 ^ B4 ^ s4) + C4 | 0, C4 = B4 = (E4 = o4 + r4 | 0) >>> 0 < o4 >>> 0 ? B4 + 1 | 0 : B4, B4 = pA(Y4, f4, 1), o4 = h3, r4 = pA(Y4, f4, 8) ^ ((127 & f4) << 25 | Y4 >>> 7) ^ B4, C4 = (h3 ^ f4 >>> 7 ^ o4) + C4 | 0, o4 = E4 = r4 + E4 | 0, E4 = C4 = E4 >>> 0 < r4 >>> 0 ? C4 + 1 | 0 : C4, i3[k4 + 232 >> 2] = o4, i3[k4 + 236 >> 2] = C4, B4 = e4 + f4 | 0, r4 = C4 = H4 + Y4 | 0, C4 = B4 = C4 >>> 0 < H4 >>> 0 ? B4 + 1 | 0 : B4, B4 = pA(Q4, t4, 19), e4 = h3, f4 = B4, B4 = t4 >>> 6 | 0, Q4 = pA(Q4, t4, 61) ^ f4 ^ ((63 & t4) << 26 | Q4 >>> 6), B4 = (h3 ^ B4 ^ e4) + C4 | 0, B4 = Q4 >>> 0 > (t4 = Q4 + r4 | 0) >>> 0 ? B4 + 1 | 0 : B4, Q4 = t4, C4 = B4, B4 = pA(m4, D4, 1), r4 = h3, Q4 = (e4 = pA(m4, D4, 8) ^ ((127 & D4) << 25 | m4 >>> 7) ^ B4) + Q4 | 0, C4 = (h3 ^ D4 >>> 7 ^ r4) + C4 | 0, i3[(t4 = k4) + 240 >> 2] = Q4, i3[t4 + 244 >> 2] = Q4 >>> 0 < e4 >>> 0 ? C4 + 1 | 0 : C4, B4 = a4 + D4 | 0, a4 = C4 = p4 + m4 | 0, C4 = B4 = C4 >>> 0 < p4 >>> 0 ? B4 + 1 | 0 : B4, B4 = pA(o4, E4, 19), t4 = h3, Q4 = B4, B4 = E4 >>> 6 | 0, E4 = pA(o4, E4, 61) ^ Q4 ^ ((63 & E4) << 26 | o4 >>> 6), B4 = (h3 ^ B4 ^ t4) + C4 | 0, C4 = B4 = E4 >>> 0 > (a4 = E4 + a4 | 0) >>> 0 ? B4 + 1 | 0 : B4, B4 = pA(G4, c4, 1), E4 = h3, t4 = B4, B4 = c4 >>> 7 | 0, c4 = (Q4 = a4) + (a4 = pA(G4, c4, 8) ^ t4 ^ ((127 & c4) << 25 | G4 >>> 7)) | 0, C4 = (h3 ^ B4 ^ E4) + C4 | 0, i3[k4 + 248 >> 2] = c4, i3[k4 + 252 >> 2] = a4 >>> 0 > c4 >>> 0 ? C4 + 1 | 0 : C4;
                        }
                      }
                      function l3(A8) {
                        var I7, g6, B4, C4, E4, i4, a4, r4, o4, t4, e4, f4, c4, y4, s4, w4, D4, p4 = 0, u4 = 0, F4 = 0, l4 = 0, _4 = 0, k4 = 0, H4 = 0, G4 = 0, U4 = 0, S4 = 0, b4 = 0, m4 = 0, v4 = 0, M4 = 0, P4 = 0, Y4 = 0, N4 = 0, R4 = 0, d4 = 0, J4 = 0, x4 = 0, L4 = 0, K4 = 0, X4 = 0, T4 = 0, V4 = 0, q4 = 0, z4 = 0, j4 = 0, W4 = 0, O4 = 0, Z4 = 0, $4 = 0, AA4 = 0, IA4 = 0, gA3 = 0, BA3 = 0, CA2 = 0, QA2 = 0, EA2 = 0;
                        f4 = uI(A8), gA3 = n3[A8 + 2 | 0] | n3[A8 + 3 | 0] << 8 | n3[A8 + 4 | 0] << 16 | n3[A8 + 5 | 0] << 24, c4 = uI(A8 + 5 | 0), z4 = h3, BA3 = n3[A8 + 7 | 0] | n3[A8 + 8 | 0] << 8 | n3[A8 + 9 | 0] << 16 | n3[A8 + 10 | 0] << 24, Z4 = n3[A8 + 10 | 0] | n3[A8 + 11 | 0] << 8 | n3[A8 + 12 | 0] << 16 | n3[A8 + 13 | 0] << 24, y4 = uI(A8 + 13 | 0), O4 = h3, L4 = n3[A8 + 15 | 0] | n3[A8 + 16 | 0] << 8 | n3[A8 + 17 | 0] << 16 | n3[A8 + 18 | 0] << 24, j4 = uI(A8 + 18 | 0), M4 = h3, G4 = uI(A8 + 21 | 0), k4 = n3[A8 + 23 | 0] | n3[A8 + 24 | 0] << 8 | n3[A8 + 25 | 0] << 16 | n3[A8 + 26 | 0] << 24, F4 = uI(A8 + 26 | 0), p4 = h3, K4 = n3[A8 + 28 | 0] | n3[A8 + 29 | 0] << 8 | n3[A8 + 30 | 0] << 16 | n3[A8 + 31 | 0] << 24, $4 = n3[A8 + 31 | 0] | n3[A8 + 32 | 0] << 8 | n3[A8 + 33 | 0] << 16 | n3[A8 + 34 | 0] << 24, s4 = uI(A8 + 34 | 0), q4 = h3, X4 = n3[A8 + 36 | 0] | n3[A8 + 37 | 0] << 8 | n3[A8 + 38 | 0] << 16 | n3[A8 + 39 | 0] << 24, W4 = uI(A8 + 39 | 0), Y4 = h3, H4 = uI(A8 + 42 | 0), l4 = n3[A8 + 44 | 0] | n3[A8 + 45 | 0] << 8 | n3[A8 + 46 | 0] << 16 | n3[A8 + 47 | 0] << 24, _4 = uI(A8 + 47 | 0), F4 = 2097151 & ((3 & p4) << 30 | F4 >>> 2), p4 = qA(I7 = 2097151 & ((3 & (u4 = h3)) << 30 | _4 >>> 2), 0, 136657, 0) + F4 | 0, u4 = h3, u4 = p4 >>> 0 < F4 >>> 0 ? u4 + 1 | 0 : u4, F4 = (_4 = qA(g6 = (n3[A8 + 49 | 0] | n3[A8 + 50 | 0] << 8 | n3[A8 + 51 | 0] << 16 | n3[A8 + 52 | 0] << 24) >>> 7 & 2097151, 0, -997805, -1)) + p4 | 0, p4 = h3 + u4 | 0, p4 = F4 >>> 0 < _4 >>> 0 ? p4 + 1 | 0 : p4, u4 = (_4 = qA(B4 = (n3[A8 + 52 | 0] | n3[A8 + 53 | 0] << 8 | n3[A8 + 54 | 0] << 16 | n3[A8 + 55 | 0] << 24) >>> 4 & 2097151, 0, 654183, 0)) + F4 | 0, F4 = h3 + p4 | 0, F4 = u4 >>> 0 < _4 >>> 0 ? F4 + 1 | 0 : F4, m4 = u4, u4 = uI(A8 + 55 | 0), _4 = qA(C4 = 2097151 & ((1 & (p4 = h3)) << 31 | u4 >>> 1), 0, 470296, 0), p4 = h3 + F4 | 0, p4 = (u4 = m4 + _4 | 0) >>> 0 < _4 >>> 0 ? p4 + 1 | 0 : p4, F4 = (_4 = qA(E4 = (n3[A8 + 57 | 0] | n3[A8 + 58 | 0] << 8 | n3[A8 + 59 | 0] << 16 | n3[A8 + 60 | 0] << 24) >>> 6 & 2097151, 0, 666643, 0)) + u4 | 0, u4 = h3 + p4 | 0, u4 = F4 >>> 0 < _4 >>> 0 ? u4 + 1 | 0 : u4, _4 = F4, U4 = u4, F4 = u4, b4 = l4 >>> 5 & 2097151, l4 = 2097151 & H4, u4 = qA(i4 = (n3[A8 + 60 | 0] | n3[A8 + 61 | 0] << 8 | n3[A8 + 62 | 0] << 16 | n3[A8 + 63 | 0] << 24) >>> 3 | 0, 0, -683901, -1) + l4 | 0, p4 = h3, p4 = u4 >>> 0 < l4 >>> 0 ? p4 + 1 | 0 : p4, l4 = u4, d4 = p4, T4 = u4 = p4 - ((u4 >>> 0 < 4293918720) - 1 | 0) | 0, p4 = b4, b4 = (2097151 & u4) << 11 | (m4 = l4 - -1048576 | 0) >>> 21, u4 >>= 21, r4 = H4 = p4 + b4 | 0, S4 = u4 = H4 >>> 0 < b4 >>> 0 ? u4 + 1 | 0 : u4, H4 = qA(H4, u4, -683901, -1), u4 = h3 + F4 | 0, J4 = p4 = H4 + _4 | 0, b4 = p4 >>> 0 < H4 >>> 0 ? u4 + 1 | 0 : u4, u4 = qA(I7, x4, -997805, -1), p4 = h3, p4 = (u4 = (F4 = k4 >>> 5 & 2097151) + u4 | 0) >>> 0 < F4 >>> 0 ? p4 + 1 | 0 : p4, k4 = qA(g6, 0, 654183, 0), F4 = h3 + p4 | 0, F4 = (u4 = k4 + u4 | 0) >>> 0 < k4 >>> 0 ? F4 + 1 | 0 : F4, p4 = (k4 = qA(B4, 0, 470296, 0)) + u4 | 0, u4 = h3 + F4 | 0, u4 = p4 >>> 0 < k4 >>> 0 ? u4 + 1 | 0 : u4, F4 = (k4 = qA(C4, P4, 666643, 0)) + p4 | 0, p4 = h3 + u4 | 0, H4 = F4, F4 = F4 >>> 0 < k4 >>> 0 ? p4 + 1 | 0 : p4, k4 = 2097151 & G4, p4 = qA(I7, x4, 654183, 0) + k4 | 0, u4 = h3, u4 = p4 >>> 0 < k4 >>> 0 ? u4 + 1 | 0 : u4, k4 = (G4 = qA(g6, 0, 470296, 0)) + p4 | 0, p4 = h3 + u4 | 0, p4 = k4 >>> 0 < G4 >>> 0 ? p4 + 1 | 0 : p4, G4 = qA(B4, 0, 666643, 0), u4 = h3 + p4 | 0, G4 = u4 = (k4 = G4 + k4 | 0) >>> 0 < G4 >>> 0 ? u4 + 1 | 0 : u4, V4 = u4 = u4 - ((k4 >>> 0 < 4293918720) - 1 | 0) | 0, F4 = (p4 = u4 >>> 21 | 0) + F4 | 0, F4 = (u4 = (N4 = H4) + (H4 = (2097151 & u4) << 11 | (v4 = k4 - -1048576 | 0) >>> 21) | 0) >>> 0 < H4 >>> 0 ? F4 + 1 | 0 : F4, H4 = u4, N4 = F4, R4 = u4 = F4 - ((u4 >>> 0 < 4293918720) - 1 | 0) | 0, U4 = U4 - ((_4 >>> 0 < 4293918720) - 1 | 0) | 0, t4 = _4 - -1048576 | 0, p4 = J4, J4 = (2097151 & u4) << 11 | (F4 = H4 - -1048576 | 0) >>> 21, u4 = (u4 >> 21) + b4 | 0, u4 = ((p4 = _4 = p4 + J4 | 0) >>> 0 < J4 >>> 0 ? u4 + 1 | 0 : u4) - (((_4 = -2097152 & t4) >>> 0 > p4 >>> 0) + U4 | 0) | 0, CA2 = (p4 = p4 - _4 | 0) - (_4 = -2097152 & (e4 = p4 - -1048576 | 0)) | 0, QA2 = u4 - ((b4 = u4 - ((p4 >>> 0 < 4293918720) - 1 | 0) | 0) + (p4 >>> 0 < _4 >>> 0) | 0) | 0, u4 = qA(r4, S4, 136657, 0) + H4 | 0, p4 = N4 + h3 | 0, J4 = u4 - (F4 &= -2097152) | 0, R4 = (p4 = u4 >>> 0 < H4 >>> 0 ? p4 + 1 | 0 : p4) - ((u4 >>> 0 < F4 >>> 0) + R4 | 0) | 0, m4 = l4 - (p4 = -2097152 & m4) | 0, AA4 = d4 - ((p4 >>> 0 > l4 >>> 0) + T4 | 0) | 0, F4 = 2097151 & ((7 & (p4 = Y4)) << 29 | W4 >>> 3), p4 = qA(i4, 0, 136657, 0) + F4 | 0, u4 = h3, u4 = p4 >>> 0 < F4 >>> 0 ? u4 + 1 | 0 : u4, F4 = (_4 = qA(E4, 0, -683901, -1)) + p4 | 0, p4 = h3 + u4 | 0, H4 = F4, l4 = F4 >>> 0 < _4 >>> 0 ? p4 + 1 | 0 : p4, p4 = qA(C4, P4, -683901, -1), u4 = h3, u4 = (p4 = (F4 = X4 >>> 6 & 2097151) + p4 | 0) >>> 0 < F4 >>> 0 ? u4 + 1 | 0 : u4, _4 = qA(i4, 0, -997805, -1), F4 = h3 + u4 | 0, F4 = (p4 = _4 + p4 | 0) >>> 0 < _4 >>> 0 ? F4 + 1 | 0 : F4, u4 = (_4 = qA(E4, 0, 136657, 0)) + p4 | 0, p4 = h3 + F4 | 0, p4 = u4 >>> 0 < _4 >>> 0 ? p4 + 1 | 0 : p4, _4 = u4, d4 = p4, T4 = p4 = p4 - ((u4 >>> 0 < 4293918720) - 1 | 0) | 0, X4 = u4 - -1048576 | 0, u4 = (F4 = p4 >> 21) + l4 | 0, l4 = p4 = (Y4 = H4) + (H4 = (2097151 & p4) << 11 | X4 >>> 21) | 0, Y4 = u4 = p4 >>> 0 < H4 >>> 0 ? u4 + 1 | 0 : u4, N4 = p4 = u4 - ((p4 >>> 0 < 4293918720) - 1 | 0) | 0, u4 = m4, m4 = (2097151 & p4) << 11 | (H4 = l4 - -1048576 | 0) >>> 21, p4 = (p4 >> 21) + AA4 | 0, o4 = u4 = u4 + m4 | 0, m4 = p4 = u4 >>> 0 < m4 >>> 0 ? p4 + 1 | 0 : p4, F4 = qA(u4, p4, -683901, -1), p4 = h3 + R4 | 0, EA2 = u4 = F4 + J4 | 0, R4 = u4 >>> 0 < F4 >>> 0 ? p4 + 1 | 0 : p4, W4 = k4, J4 = G4, F4 = 2097151 & ((7 & (p4 = M4)) << 29 | j4 >>> 3), p4 = qA(I7, x4, 470296, 0) + F4 | 0, u4 = h3, u4 = p4 >>> 0 < F4 >>> 0 ? u4 + 1 | 0 : u4, F4 = qA(g6, 0, 666643, 0), u4 = h3 + u4 | 0, G4 = p4 = F4 + p4 | 0, F4 = p4 >>> 0 < F4 >>> 0 ? u4 + 1 | 0 : u4, u4 = qA(I7, x4, 666643, 0), p4 = h3, p4 = (u4 = (k4 = L4 >>> 6 & 2097151) + u4 | 0) >>> 0 < k4 >>> 0 ? p4 + 1 | 0 : p4, k4 = u4, j4 = p4, AA4 = p4 = p4 - ((u4 >>> 0 < 4293918720) - 1 | 0) | 0, u4 = (u4 = p4 >>> 21 | 0) + F4 | 0, F4 = p4 = (M4 = G4) + (G4 = (2097151 & p4) << 11 | (L4 = k4 - -1048576 | 0) >>> 21) | 0, IA4 = u4 = p4 >>> 0 < G4 >>> 0 ? u4 + 1 | 0 : u4, w4 = p4 = u4 - ((p4 >>> 0 < 4293918720) - 1 | 0) | 0, G4 = Y4 - (((u4 = -2097152 & H4) >>> 0 > l4 >>> 0) + N4 | 0) | 0, a4 = l4 - u4 | 0, H4 = (2097151 & p4) << 11 | (M4 = F4 - -1048576 | 0) >>> 21, p4 = (p4 >>> 21 | 0) + J4 | 0, p4 = (l4 = H4 + W4 | 0) >>> 0 < H4 >>> 0 ? p4 + 1 | 0 : p4, l4 = ((u4 = l4) - (H4 = -2097152 & v4) | 0) + (v4 = qA(r4, S4, -997805, -1)) | 0, u4 = h3 + (p4 - ((8191 & V4) + (u4 >>> 0 < H4 >>> 0) | 0) | 0) | 0, u4 = l4 >>> 0 < v4 >>> 0 ? u4 + 1 | 0 : u4, p4 = l4, l4 = qA(o4, m4, 136657, 0), u4 = h3 + u4 | 0, u4 = (p4 = p4 + l4 | 0) >>> 0 < l4 >>> 0 ? u4 + 1 | 0 : u4, l4 = (H4 = qA(a4, G4, -683901, -1)) + p4 | 0, p4 = h3 + u4 | 0, V4 = p4 = l4 >>> 0 < H4 >>> 0 ? p4 + 1 | 0 : p4, N4 = u4 = p4 - ((l4 >>> 0 < 4293918720) - 1 | 0) | 0, Y4 = (2097151 & u4) << 11 | (v4 = l4 - -1048576 | 0) >>> 21, u4 = (u4 >> 21) + R4 | 0, R4 = u4 = (H4 = Y4 + EA2 | 0) >>> 0 < Y4 >>> 0 ? u4 + 1 | 0 : u4, p4 = (p4 = (u4 = u4 - ((H4 >>> 0 < 4293918720) - 1 | 0) | 0) >> 21) + QA2 | 0, p4 = (J4 = (2097151 & u4) << 11 | (Y4 = H4 - -1048576 | 0) >>> 21) >>> 0 > (W4 = J4 + CA2 | 0) >>> 0 ? p4 + 1 | 0 : p4, J4 = W4, W4 = p4, CA2 = H4 - (p4 = -2097152 & Y4) | 0, QA2 = R4 - ((p4 >>> 0 > H4 >>> 0) + u4 | 0) | 0, EA2 = l4 - (p4 = -2097152 & v4) | 0, D4 = V4 - ((p4 >>> 0 > l4 >>> 0) + N4 | 0) | 0, p4 = (l4 = qA(r4, S4, 654183, 0)) + (F4 - (u4 = -2097152 & M4) | 0) | 0, F4 = h3 + (IA4 - ((8191 & w4) + (u4 >>> 0 > F4 >>> 0) | 0) | 0) | 0, F4 = p4 >>> 0 < l4 >>> 0 ? F4 + 1 | 0 : F4, u4 = (l4 = qA(o4, m4, -997805, -1)) + p4 | 0, p4 = h3 + F4 | 0, p4 = u4 >>> 0 < l4 >>> 0 ? p4 + 1 | 0 : p4, F4 = (l4 = qA(a4, G4, 136657, 0)) + u4 | 0, u4 = h3 + p4 | 0, V4 = F4, M4 = F4 >>> 0 < l4 >>> 0 ? u4 + 1 | 0 : u4, H4 = _4 - (p4 = -2097152 & X4) | 0, T4 = d4 - ((p4 >>> 0 > _4 >>> 0) + T4 | 0) | 0, _4 = 2097151 & ((1 & (p4 = q4)) << 31 | s4 >>> 1), u4 = qA(B4, 0, -683901, -1) + _4 | 0, p4 = h3, p4 = u4 >>> 0 < _4 >>> 0 ? p4 + 1 | 0 : p4, F4 = qA(C4, P4, 136657, 0), p4 = h3 + p4 | 0, p4 = (u4 = F4 + u4 | 0) >>> 0 < F4 >>> 0 ? p4 + 1 | 0 : p4, F4 = (_4 = qA(i4, 0, 654183, 0)) + u4 | 0, u4 = h3 + p4 | 0, u4 = F4 >>> 0 < _4 >>> 0 ? u4 + 1 | 0 : u4, p4 = F4, F4 = qA(E4, 0, -997805, -1), u4 = h3 + u4 | 0, v4 = p4 = p4 + F4 | 0, l4 = p4 >>> 0 < F4 >>> 0 ? u4 + 1 | 0 : u4, p4 = qA(g6, 0, -683901, -1), F4 = h3, F4 = (p4 = (u4 = $4 >>> 4 & 2097151) + p4 | 0) >>> 0 < u4 >>> 0 ? F4 + 1 | 0 : F4, u4 = (_4 = qA(B4, 0, 136657, 0)) + p4 | 0, p4 = h3 + F4 | 0, p4 = u4 >>> 0 < _4 >>> 0 ? p4 + 1 | 0 : p4, F4 = (_4 = qA(C4, P4, -997805, -1)) + u4 | 0, u4 = h3 + p4 | 0, u4 = F4 >>> 0 < _4 >>> 0 ? u4 + 1 | 0 : u4, _4 = qA(i4, 0, 470296, 0), p4 = h3 + u4 | 0, p4 = (F4 = _4 + F4 | 0) >>> 0 < _4 >>> 0 ? p4 + 1 | 0 : p4, _4 = qA(E4, 0, 654183, 0), u4 = h3 + p4 | 0, u4 = (F4 = _4 + F4 | 0) >>> 0 < _4 >>> 0 ? u4 + 1 | 0 : u4, _4 = F4, Y4 = u4, $4 = u4 = u4 - ((F4 >>> 0 < 4293918720) - 1 | 0) | 0, p4 = (p4 = u4 >> 21) + l4 | 0, l4 = u4 = (F4 = (2097151 & u4) << 11 | (X4 = F4 - -1048576 | 0) >>> 21) + v4 | 0, q4 = p4 = u4 >>> 0 < F4 >>> 0 ? p4 + 1 | 0 : p4, d4 = u4 = p4 - ((u4 >>> 0 < 4293918720) - 1 | 0) | 0, p4 = H4, H4 = (2097151 & u4) << 11 | (v4 = l4 - -1048576 | 0) >>> 21, u4 = (u4 >> 21) + T4 | 0, N4 = F4 = p4 + H4 | 0, H4 = u4 = F4 >>> 0 < H4 >>> 0 ? u4 + 1 | 0 : u4, u4 = qA(F4, u4, -683901, -1), F4 = h3 + M4 | 0, T4 = p4 = u4 + V4 | 0, M4 = p4 >>> 0 < u4 >>> 0 ? F4 + 1 | 0 : F4, v4 = q4 - (((p4 = -2097152 & v4) >>> 0 > l4 >>> 0) + d4 | 0) | 0, R4 = l4 - p4 | 0, p4 = (F4 = qA(r4, S4, 470296, 0)) + (k4 - (u4 = -2097152 & L4) | 0) | 0, u4 = h3 + (j4 - ((2047 & AA4) + (u4 >>> 0 > k4 >>> 0) | 0) | 0) | 0, u4 = p4 >>> 0 < F4 >>> 0 ? u4 + 1 | 0 : u4, F4 = qA(o4, m4, 654183, 0), u4 = h3 + u4 | 0, u4 = (p4 = F4 + p4 | 0) >>> 0 < F4 >>> 0 ? u4 + 1 | 0 : u4, l4 = qA(a4, G4, -997805, -1), F4 = h3 + u4 | 0, F4 = (p4 = l4 + p4 | 0) >>> 0 < l4 >>> 0 ? F4 + 1 | 0 : F4, u4 = (l4 = qA(N4, H4, 136657, 0)) + p4 | 0, p4 = h3 + F4 | 0, p4 = u4 >>> 0 < l4 >>> 0 ? p4 + 1 | 0 : p4, F4 = (l4 = qA(R4, v4, -683901, -1)) + u4 | 0, u4 = h3 + p4 | 0, q4 = u4 = F4 >>> 0 < l4 >>> 0 ? u4 + 1 | 0 : u4, d4 = u4 = u4 - ((F4 >>> 0 < 4293918720) - 1 | 0) | 0, p4 = (p4 = u4 >> 21) + M4 | 0, p4 = (u4 = (l4 = (2097151 & u4) << 11 | (k4 = F4 - -1048576 | 0) >>> 21) + T4 | 0) >>> 0 < l4 >>> 0 ? p4 + 1 | 0 : p4, l4 = u4, M4 = p4, T4 = u4 = p4 - ((u4 >>> 0 < 4293918720) - 1 | 0) | 0, j4 = (2097151 & u4) << 11 | (L4 = l4 - -1048576 | 0) >>> 21, u4 = (u4 >> 21) + D4 | 0, u4 = (V4 = j4 + EA2 | 0) >>> 0 < j4 >>> 0 ? u4 + 1 | 0 : u4, j4 = V4, V4 = u4, AA4 = l4 - (p4 = -2097152 & L4) | 0, T4 = M4 - ((p4 >>> 0 > l4 >>> 0) + T4 | 0) | 0, IA4 = F4 - (p4 = -2097152 & k4) | 0, q4 = q4 - ((p4 >>> 0 > F4 >>> 0) + d4 | 0) | 0, l4 = 2097151 & ((1 & (p4 = O4)) << 31 | y4 >>> 1), u4 = qA(r4, S4, 666643, 0) + l4 | 0, p4 = h3, p4 = u4 >>> 0 < l4 >>> 0 ? p4 + 1 | 0 : p4, F4 = (l4 = qA(o4, m4, 470296, 0)) + u4 | 0, u4 = h3 + p4 | 0, u4 = F4 >>> 0 < l4 >>> 0 ? u4 + 1 | 0 : u4, l4 = qA(a4, G4, 654183, 0), p4 = h3 + u4 | 0, p4 = (F4 = l4 + F4 | 0) >>> 0 < l4 >>> 0 ? p4 + 1 | 0 : p4, u4 = (l4 = qA(N4, H4, -997805, -1)) + F4 | 0, F4 = h3 + p4 | 0, F4 = u4 >>> 0 < l4 >>> 0 ? F4 + 1 | 0 : F4, p4 = (l4 = qA(R4, v4, 136657, 0)) + u4 | 0, u4 = h3 + F4 | 0, k4 = p4, l4 = p4 >>> 0 < l4 >>> 0 ? u4 + 1 | 0 : u4, S4 = _4 - (p4 = -2097152 & X4) | 0, M4 = Y4 - ((p4 >>> 0 > _4 >>> 0) + $4 | 0) | 0, p4 = qA(I7, x4, -683901, -1), u4 = h3, u4 = (p4 = (F4 = K4 >>> 7 & 2097151) + p4 | 0) >>> 0 < F4 >>> 0 ? u4 + 1 | 0 : u4, _4 = qA(g6, 0, 136657, 0), F4 = h3 + u4 | 0, F4 = (p4 = _4 + p4 | 0) >>> 0 < _4 >>> 0 ? F4 + 1 | 0 : F4, u4 = (_4 = qA(B4, 0, -997805, -1)) + p4 | 0, p4 = h3 + F4 | 0, p4 = u4 >>> 0 < _4 >>> 0 ? p4 + 1 | 0 : p4, F4 = (_4 = qA(C4, P4, 654183, 0)) + u4 | 0, u4 = h3 + p4 | 0, u4 = F4 >>> 0 < _4 >>> 0 ? u4 + 1 | 0 : u4, _4 = qA(i4, 0, 666643, 0), p4 = h3 + u4 | 0, p4 = (F4 = _4 + F4 | 0) >>> 0 < _4 >>> 0 ? p4 + 1 | 0 : p4, _4 = qA(E4, 0, 470296, 0), u4 = h3 + p4 | 0, p4 = u4 = (F4 = _4 + F4 | 0) >>> 0 < _4 >>> 0 ? u4 + 1 | 0 : u4, u4 = U4 >> 21, _4 = (U4 = (2097151 & U4) << 11 | t4 >>> 21) + F4 | 0, F4 = p4 + u4 | 0, X4 = F4 = _4 >>> 0 < U4 >>> 0 ? F4 + 1 | 0 : F4, L4 = p4 = F4 - ((_4 >>> 0 < 4293918720) - 1 | 0) | 0, U4 = (2097151 & p4) << 11 | (x4 = _4 - -1048576 | 0) >>> 21, p4 = (p4 >> 21) + M4 | 0, O4 = F4 = U4 + S4 | 0, U4 = p4 = F4 >>> 0 < U4 >>> 0 ? p4 + 1 | 0 : p4, F4 = qA(F4, p4, -683901, -1), u4 = h3 + l4 | 0, k4 = p4 = F4 + k4 | 0, l4 = p4 >>> 0 < F4 >>> 0 ? u4 + 1 | 0 : u4, p4 = qA(o4, m4, 666643, 0), F4 = h3, F4 = (p4 = (u4 = Z4 >>> 4 & 2097151) + p4 | 0) >>> 0 < u4 >>> 0 ? F4 + 1 | 0 : F4, u4 = (P4 = qA(a4, G4, 470296, 0)) + p4 | 0, p4 = h3 + F4 | 0, p4 = u4 >>> 0 < P4 >>> 0 ? p4 + 1 | 0 : p4, F4 = (P4 = qA(N4, H4, 654183, 0)) + u4 | 0, u4 = h3 + p4 | 0, u4 = F4 >>> 0 < P4 >>> 0 ? u4 + 1 | 0 : u4, p4 = F4, F4 = qA(R4, v4, -997805, -1), u4 = h3 + u4 | 0, u4 = (p4 = p4 + F4 | 0) >>> 0 < F4 >>> 0 ? u4 + 1 | 0 : u4, F4 = (P4 = qA(O4, U4, 136657, 0)) + p4 | 0, p4 = h3 + u4 | 0, m4 = p4 = F4 >>> 0 < P4 >>> 0 ? p4 + 1 | 0 : p4, M4 = p4 = p4 - ((F4 >>> 0 < 4293918720) - 1 | 0) | 0, S4 = (2097151 & p4) << 11 | (P4 = F4 - -1048576 | 0) >>> 21, p4 = (p4 >> 21) + l4 | 0, k4 = p4 = (l4 = k4 = S4 + k4 | 0) >>> 0 < S4 >>> 0 ? p4 + 1 | 0 : p4, Y4 = p4 = p4 - ((l4 >>> 0 < 4293918720) - 1 | 0) | 0, K4 = (2097151 & p4) << 11 | (S4 = l4 - -1048576 | 0) >>> 21, p4 = (p4 >> 21) + q4 | 0, $4 = Z4 = K4 + IA4 | 0, Z4 = K4 >>> 0 > Z4 >>> 0 ? p4 + 1 | 0 : p4, u4 = _4 - (p4 = -2097152 & x4) | 0, _4 = X4 - ((p4 >>> 0 > _4 >>> 0) + L4 | 0) | 0, p4 = (p4 = b4 >> 21) + _4 | 0, _4 = u4 = (b4 = (2097151 & b4) << 11 | e4 >>> 21) + u4 | 0, X4 = p4 = u4 >>> 0 < b4 >>> 0 ? p4 + 1 | 0 : p4, L4 = u4 = p4 - ((u4 >>> 0 < 4293918720) - 1 | 0) | 0, b4 = p4 = u4 >> 21, d4 = l4, l4 = qA(K4 = (2097151 & u4) << 11 | (x4 = _4 - -1048576 | 0) >>> 21, p4, -683901, -1), u4 = h3 + k4 | 0, u4 = (p4 = d4 + l4 | 0) >>> 0 < l4 >>> 0 ? u4 + 1 | 0 : u4, q4 = p4 - (l4 = -2097152 & S4) | 0, Y4 = u4 - ((p4 >>> 0 < l4 >>> 0) + Y4 | 0) | 0, u4 = qA(K4, b4, 136657, 0) + F4 | 0, p4 = m4 + h3 | 0, p4 = u4 >>> 0 < F4 >>> 0 ? p4 + 1 | 0 : p4, d4 = u4 - (F4 = -2097152 & P4) | 0, IA4 = p4 - ((u4 >>> 0 < F4 >>> 0) + M4 | 0) | 0, p4 = qA(a4, G4, 666643, 0), u4 = h3, u4 = (p4 = (F4 = BA3 >>> 7 & 2097151) + p4 | 0) >>> 0 < F4 >>> 0 ? u4 + 1 | 0 : u4, l4 = qA(N4, H4, 470296, 0), F4 = h3 + u4 | 0, F4 = (p4 = l4 + p4 | 0) >>> 0 < l4 >>> 0 ? F4 + 1 | 0 : F4, u4 = (l4 = qA(R4, v4, 654183, 0)) + p4 | 0, p4 = h3 + F4 | 0, p4 = u4 >>> 0 < l4 >>> 0 ? p4 + 1 | 0 : p4, F4 = qA(O4, U4, -997805, -1), p4 = h3 + p4 | 0, S4 = u4 = F4 + u4 | 0, F4 = u4 >>> 0 < F4 >>> 0 ? p4 + 1 | 0 : p4, l4 = 2097151 & ((3 & (p4 = z4)) << 30 | c4 >>> 2), p4 = qA(N4, H4, 666643, 0) + l4 | 0, u4 = h3, u4 = p4 >>> 0 < l4 >>> 0 ? u4 + 1 | 0 : u4, l4 = qA(R4, v4, 470296, 0), u4 = h3 + u4 | 0, u4 = (p4 = l4 + p4 | 0) >>> 0 < l4 >>> 0 ? u4 + 1 | 0 : u4, l4 = (k4 = qA(O4, U4, 654183, 0)) + p4 | 0, p4 = h3 + u4 | 0, G4 = p4 = l4 >>> 0 < k4 >>> 0 ? p4 + 1 | 0 : p4, P4 = p4 = p4 - ((l4 >>> 0 < 4293918720) - 1 | 0) | 0, u4 = S4, S4 = (2097151 & p4) << 11 | (k4 = l4 - -1048576 | 0) >>> 21, p4 = (p4 >> 21) + F4 | 0, S4 = p4 = (F4 = H4 = u4 + S4 | 0) >>> 0 < S4 >>> 0 ? p4 + 1 | 0 : p4, m4 = p4 = p4 - ((F4 >>> 0 < 4293918720) - 1 | 0) | 0, z4 = (2097151 & p4) << 11 | (H4 = F4 - -1048576 | 0) >>> 21, p4 = (p4 >> 21) + IA4 | 0, p4 = (M4 = z4 + d4 | 0) >>> 0 < z4 >>> 0 ? p4 + 1 | 0 : p4, z4 = M4, M4 = p4, p4 = (u4 = qA(K4, b4, -997805, -1)) + F4 | 0, F4 = h3 + S4 | 0, F4 = p4 >>> 0 < u4 >>> 0 ? F4 + 1 | 0 : F4, BA3 = p4 - (u4 = -2097152 & H4) | 0, d4 = F4 - ((p4 >>> 0 < u4 >>> 0) + m4 | 0) | 0, p4 = qA(K4, b4, 654183, 0) + l4 | 0, u4 = G4 + h3 | 0, m4 = p4 - (F4 = -2097152 & k4) | 0, N4 = (u4 = p4 >>> 0 < l4 >>> 0 ? u4 + 1 | 0 : u4) - ((p4 >>> 0 < F4 >>> 0) + P4 | 0) | 0, p4 = qA(R4, v4, 666643, 0), F4 = h3, F4 = (p4 = (u4 = gA3 >>> 5 & 2097151) + p4 | 0) >>> 0 < u4 >>> 0 ? F4 + 1 | 0 : F4, u4 = (l4 = qA(O4, U4, 470296, 0)) + p4 | 0, p4 = h3 + F4 | 0, k4 = u4, F4 = u4 >>> 0 < l4 >>> 0 ? p4 + 1 | 0 : p4, l4 = 2097151 & f4, u4 = qA(O4, U4, 666643, 0) + l4 | 0, p4 = h3, p4 = u4 >>> 0 < l4 >>> 0 ? p4 + 1 | 0 : p4, l4 = u4, G4 = p4, U4 = p4 = p4 - ((u4 >>> 0 < 4293918720) - 1 | 0) | 0, F4 = (u4 = p4 >> 21) + F4 | 0, F4 = (p4 = (S4 = k4) + (k4 = (2097151 & p4) << 11 | (H4 = l4 - -1048576 | 0) >>> 21) | 0) >>> 0 < k4 >>> 0 ? F4 + 1 | 0 : F4, k4 = p4, P4 = F4, S4 = p4 = F4 - ((p4 >>> 0 < 4293918720) - 1 | 0) | 0, v4 = (2097151 & p4) << 11 | (F4 = k4 - -1048576 | 0) >>> 21, p4 = (p4 >> 21) + N4 | 0, p4 = (m4 = v4 + m4 | 0) >>> 0 < v4 >>> 0 ? p4 + 1 | 0 : p4, v4 = m4, m4 = p4, p4 = qA(K4, b4, 470296, 0) + k4 | 0, u4 = P4 + h3 | 0, u4 = p4 >>> 0 < k4 >>> 0 ? u4 + 1 | 0 : u4, k4 = p4 - (F4 &= -2097152) | 0, F4 = u4 - ((p4 >>> 0 < F4 >>> 0) + S4 | 0) | 0, S4 = k4, u4 = (k4 = qA(K4, b4, 666643, 0)) + (l4 - (p4 = -2097152 & H4) | 0) | 0, p4 = h3 + (G4 - ((p4 >>> 0 > l4 >>> 0) + U4 | 0) | 0) | 0, p4 = u4 >>> 0 < k4 >>> 0 ? p4 + 1 | 0 : p4, k4 = u4, l4 = u4, u4 = (u4 = p4 >> 21) + F4 | 0, H4 = p4 = S4 + (l4 = (2097151 & p4) << 11 | l4 >>> 21) | 0, l4 = (2097151 & (u4 = p4 >>> 0 < l4 >>> 0 ? u4 + 1 | 0 : u4)) << 11 | (F4 = p4) >>> 21, F4 = (p4 = u4 >> 21) + m4 | 0, G4 = u4 = l4 + v4 | 0, l4 = (2097151 & (F4 = (p4 = u4) >>> 0 < l4 >>> 0 ? F4 + 1 | 0 : F4)) << 11 | p4 >>> 21, p4 = (u4 = F4 >> 21) + d4 | 0, P4 = F4 = l4 + BA3 | 0, l4 = (2097151 & (p4 = (u4 = F4) >>> 0 < l4 >>> 0 ? p4 + 1 | 0 : p4)) << 11 | u4 >>> 21, u4 = (F4 = p4 >> 21) + M4 | 0, S4 = p4 = l4 + z4 | 0, F4 = p4, p4 = (p4 = (u4 = p4 >>> 0 < l4 >>> 0 ? u4 + 1 | 0 : u4) >> 21) + Y4 | 0, p4 = (u4 = (F4 = (2097151 & u4) << 11 | F4 >>> 21) + q4 | 0) >>> 0 < F4 >>> 0 ? p4 + 1 | 0 : p4, m4 = u4, F4 = u4, u4 = (u4 = p4 >> 21) + Z4 | 0, v4 = p4 = (F4 = (2097151 & p4) << 11 | F4 >>> 21) + $4 | 0, l4 = (2097151 & (u4 = p4 >>> 0 < F4 >>> 0 ? u4 + 1 | 0 : u4)) << 11 | (F4 = p4) >>> 21, F4 = (p4 = u4 >> 21) + T4 | 0, M4 = u4 = l4 + AA4 | 0, l4 = (2097151 & (F4 = (p4 = u4) >>> 0 < l4 >>> 0 ? F4 + 1 | 0 : F4)) << 11 | p4 >>> 21, p4 = (u4 = F4 >> 21) + V4 | 0, Y4 = F4 = l4 + j4 | 0, l4 = (2097151 & (p4 = (u4 = F4) >>> 0 < l4 >>> 0 ? p4 + 1 | 0 : p4)) << 11 | u4 >>> 21, u4 = (F4 = p4 >> 21) + QA2 | 0, gA3 = p4 = l4 + CA2 | 0, F4 = p4, p4 = (p4 = (u4 = p4 >>> 0 < l4 >>> 0 ? u4 + 1 | 0 : u4) >> 21) + W4 | 0, p4 = (u4 = (F4 = (2097151 & u4) << 11 | F4 >>> 21) + J4 | 0) >>> 0 < F4 >>> 0 ? p4 + 1 | 0 : p4, z4 = u4, F4 = u4, u4 = p4 >> 21, p4 = (2097151 & p4) << 11 | F4 >>> 21, l4 = _4 - (F4 = -2097152 & x4) | 0, F4 = (X4 - ((F4 >>> 0 > _4 >>> 0) + L4 | 0) | 0) + u4 | 0, x4 = p4 = p4 + l4 | 0, b4 = (2097151 & (F4 = p4 >>> 0 < l4 >>> 0 ? F4 + 1 | 0 : F4)) << 11 | p4 >>> 21, l4 = p4 = F4 >> 21, F4 = 2097151 & k4, u4 = qA(b4, p4, 666643, 0) + F4 | 0, p4 = h3, k4 = u4, _4 = p4 = u4 >>> 0 < F4 >>> 0 ? p4 + 1 | 0 : p4, Q3[0 | A8] = u4, Q3[A8 + 1 | 0] = (255 & p4) << 24 | u4 >>> 8, F4 = 2097151 & H4, p4 = qA(b4, l4, 470296, 0) + F4 | 0, u4 = h3, F4 = (_4 >> 21) + (u4 = p4 >>> 0 < F4 >>> 0 ? u4 + 1 | 0 : u4) | 0, F4 = (H4 = (U4 = (2097151 & _4) << 11 | k4 >>> 21) + p4 | 0) >>> 0 < U4 >>> 0 ? F4 + 1 | 0 : F4, Q3[A8 + 4 | 0] = (2047 & F4) << 21 | H4 >>> 11, Q3[A8 + 3 | 0] = (7 & F4) << 29 | H4 >>> 3, G4 &= 2097151, u4 = qA(b4, l4, 654183, 0) + G4 | 0, p4 = h3, p4 = u4 >>> 0 < G4 >>> 0 ? p4 + 1 | 0 : p4, G4 = u4, u4 = p4, u4 = (p4 = F4 >> 21) + u4 | 0, u4 = (F4 = (U4 = G4) + (G4 = (2097151 & F4) << 11 | H4 >>> 21) | 0) >>> 0 < G4 >>> 0 ? u4 + 1 | 0 : u4, G4 = F4, p4 = u4, Q3[A8 + 6 | 0] = (63 & p4) << 26 | F4 >>> 6, U4 = 0, F4 = 31 & ((65535 & _4) << 16 | k4 >>> 16), u4 = k4 = 2097151 & H4, Q3[A8 + 2 | 0] = F4 | u4 << 5, _4 = 2097151 & P4, F4 = qA(b4, l4, -997805, -1) + _4 | 0, u4 = h3, u4 = F4 >>> 0 < _4 >>> 0 ? u4 + 1 | 0 : u4, _4 = F4, F4 = u4, F4 = (u4 = p4 >> 21) + F4 | 0, u4 = p4 = (H4 = _4) + (_4 = (2097151 & p4) << 11 | G4 >>> 21) | 0, F4 = p4 >>> 0 < _4 >>> 0 ? F4 + 1 | 0 : F4, Q3[A8 + 9 | 0] = (511 & F4) << 23 | p4 >>> 9, Q3[A8 + 8 | 0] = (1 & F4) << 31 | p4 >>> 1, _4 = 0, H4 = (p4 = G4 &= 2097151) << 2, p4 = U4, Q3[A8 + 5 | 0] = H4 | (524287 & p4) << 13 | k4 >>> 19, H4 = 2097151 & S4, k4 = qA(b4, l4, 136657, 0) + H4 | 0, p4 = h3, p4 = k4 >>> 0 < H4 >>> 0 ? p4 + 1 | 0 : p4, H4 = k4, k4 = p4, U4 = (2097151 & (p4 = F4)) << 11 | u4 >>> 21, p4 = (F4 = p4 >> 21) + k4 | 0, p4 = (F4 = H4 = U4 + H4 | 0) >>> 0 < U4 >>> 0 ? p4 + 1 | 0 : p4, Q3[A8 + 12 | 0] = (4095 & p4) << 20 | F4 >>> 12, Q3[A8 + 11 | 0] = (15 & p4) << 28 | F4 >>> 4, k4 = 0, S4 = (u4 = H4 = 2097151 & u4) << 7, u4 = _4, _4 = G4, Q3[A8 + 7 | 0] = S4 | (16383 & u4) << 18 | _4 >>> 14, _4 = (u4 = qA(b4, l4, -683901, -1)) + (l4 = 2097151 & m4) | 0, u4 = h3, u4 = l4 >>> 0 > _4 >>> 0 ? u4 + 1 | 0 : u4, l4 = _4, _4 = u4, G4 = (2097151 & (u4 = p4)) << 11 | F4 >>> 21, u4 = (p4 >>= 21) + _4 | 0, u4 = (p4 = l4 = G4 + l4 | 0) >>> 0 < G4 >>> 0 ? u4 + 1 | 0 : u4, Q3[A8 + 14 | 0] = (127 & u4) << 25 | p4 >>> 7, l4 = (F4 = G4 = 2097151 & F4) << 4, F4 = k4, Q3[A8 + 10 | 0] = l4 | (131071 & F4) << 15 | H4 >>> 17, k4 = (2097151 & (F4 = u4)) << 11 | p4 >>> 21, F4 = (u4 >>= 21) + (l4 = 0) | 0, F4 = (_4 = k4 + (2097151 & v4) | 0) >>> 0 < k4 >>> 0 ? F4 + 1 | 0 : F4, Q3[A8 + 17 | 0] = (1023 & F4) << 22 | _4 >>> 10, Q3[A8 + 16 | 0] = (3 & F4) << 30 | _4 >>> 2, k4 = 0, u4 = (p4 = U4 = 2097151 & p4) << 1, p4 = l4, Q3[A8 + 13 | 0] = u4 | (1048575 & p4) << 12 | G4 >>> 20, p4 = u4 = F4 >> 21, p4 = (F4 = (l4 = (2097151 & F4) << 11 | _4 >>> 21) + (2097151 & M4) | 0) >>> 0 < l4 >>> 0 ? p4 + 1 | 0 : p4, l4 = F4, Q3[A8 + 20 | 0] = (8191 & p4) << 19 | F4 >>> 13, F4 = p4, Q3[A8 + 19 | 0] = (31 & p4) << 27 | l4 >>> 5, H4 = 0, u4 = (p4 = b4 = 2097151 & _4) << 6, p4 = k4, Q3[A8 + 15 | 0] = u4 | (32767 & p4) << 17 | U4 >>> 15, p4 = F4 >> 21, G4 = _4 = (k4 = (2097151 & F4) << 11 | l4 >>> 21) + (2097151 & Y4) | 0, _4 = _4 >>> 0 < k4 >>> 0 ? p4 + 1 | 0 : p4, Q3[A8 + 21 | 0] = G4, u4 = (p4 = l4) << 3, p4 = H4, Q3[A8 + 18 | 0] = u4 | (262143 & p4) << 14 | b4 >>> 18, u4 = G4, Q3[A8 + 22 | 0] = (255 & _4) << 24 | u4 >>> 8, F4 = _4 >> 21, F4 = (u4 = (l4 = (2097151 & _4) << 11 | u4 >>> 21) + (2097151 & gA3) | 0) >>> 0 < l4 >>> 0 ? F4 + 1 | 0 : F4, l4 = u4, Q3[A8 + 25 | 0] = (2047 & F4) << 21 | u4 >>> 11, Q3[A8 + 24 | 0] = (7 & F4) << 29 | u4 >>> 3, p4 = u4 = F4 >> 21, p4 = (F4 = (k4 = (2097151 & F4) << 11 | l4 >>> 21) + (2097151 & z4) | 0) >>> 0 < k4 >>> 0 ? p4 + 1 | 0 : p4, Q3[A8 + 27 | 0] = (63 & p4) << 26 | F4 >>> 6, k4 = 0, u4 = l4 &= 2097151, Q3[A8 + 23 | 0] = 31 & ((65535 & _4) << 16 | G4 >>> 16) | u4 << 5, u4 = p4 >> 21, u4 = (p4 = (H4 = (2097151 & p4) << 11 | F4 >>> 21) + (2097151 & x4) | 0) >>> 0 < H4 >>> 0 ? u4 + 1 | 0 : u4, Q3[A8 + 31 | 0] = (131071 & u4) << 15 | p4 >>> 17, Q3[A8 + 30 | 0] = (511 & u4) << 23 | p4 >>> 9, Q3[A8 + 29 | 0] = (1 & u4) << 31 | p4 >>> 1, _4 = 0, u4 = (F4 = H4 = 2097151 & F4) << 2, F4 = k4, Q3[A8 + 26 | 0] = u4 | (524287 & F4) << 13 | l4 >>> 19, u4 = A8, A8 = _4, Q3[u4 + 28 | 0] = p4 << 7 | (16383 & A8) << 18 | H4 >>> 14;
                      }
                      function _3(A8, I7, g6, B4, C4, E4, t4, e4, f4, c4, y4, p4) {
                        var u4, F4, l4 = 0, _4 = 0, H4 = 0, G4 = 0, U4 = 0, m4 = 0, M4 = 0, P4 = 0, Y4 = 0, N4 = 0, d4 = 0, J4 = 0, x4 = 0, L4 = 0, K4 = 0, X4 = 0, T4 = 0, V4 = 0, q4 = 0, z4 = 0, j4 = 0, W4 = 0, O4 = 0, $4 = 0, AA4 = 0, IA4 = 0, gA3 = 0, BA3 = 0, CA2 = 0, QA2 = 0, EA2 = 0, iA2 = 0, aA2 = 0, rA2 = 0, oA2 = 0, tA2 = 0, eA2 = 0, fA2 = 0, cA2 = 0, yA2 = 0, sA2 = 0, wA2 = 0, DA2 = 0, hA2 = 0, uA2 = 0;
                        if (s3 = u4 = s3 + -64 | 0, F4 = k3(f4)) {
                          if (i3[u4 + 32 >> 2] = 0, i3[u4 + 36 >> 2] = 0, i3[u4 + 24 >> 2] = 0, i3[u4 + 28 >> 2] = 0, i3[u4 + 20 >> 2] = t4, i3[u4 + 16 >> 2] = E4, i3[u4 + 12 >> 2] = C4, i3[u4 + 8 >> 2] = B4, i3[u4 + 4 >> 2] = f4, i3[u4 >> 2] = F4, i3[u4 + 56 >> 2] = 0, i3[u4 + 52 >> 2] = g6, i3[u4 + 48 >> 2] = g6, i3[u4 + 44 >> 2] = I7, i3[u4 + 40 >> 2] = A8, A8 = 0, s3 = U4 = s3 - 48 | 0, !((I7 = nA(u4)) || (I7 = -26, p4 - 3 >>> 0 < 4294967294))) {
                            if (g6 = i3[u4 + 44 >> 2], I7 = i3[u4 + 48 >> 2], i3[U4 >> 2] = 0, B4 = i3[u4 + 40 >> 2], i3[U4 + 28 >> 2] = I7, i3[U4 + 12 >> 2] = -1, i3[U4 + 8 >> 2] = B4, I7 = ((B4 = g6 >>> 0 > (B4 = I7 << 3) >>> 0 ? g6 : B4) >>> 0) / ((g6 = I7 << 2) >>> 0) | 0, i3[U4 + 20 >> 2] = I7, i3[U4 + 24 >> 2] = I7 << 2, i3[U4 + 16 >> 2] = r3(I7, g6), I7 = i3[u4 + 52 >> 2], i3[U4 + 36 >> 2] = p4, i3[U4 + 32 >> 2] = I7, s3 = B4 = s3 - 80 | 0, C4 = -25, !(!U4 | !u4))
                              if (I7 = k3(i3[U4 + 20 >> 2] << 3), i3[U4 + 4 >> 2] = I7, I7) {
                                s3 = t4 = s3 - 16 | 0, C4 = -22;
                                A:
                                  if (!(!U4 | !(I7 = i3[U4 + 16 >> 2])) && (((E4 = I7 << 10) >>> 0) / (I7 >>> 0) | 0) == 1024 && (I7 = k3(12), i3[U4 >> 2] = I7, I7)) {
                                    i3[I7 >> 2] = 0, i3[I7 + 4 >> 2] = 0, E4 >>> 0 > 4294967168 ? I7 = 48 : (E4 >>> 0 >= 4294967168 ? (i3[8952] = 48, g6 = 0) : (g6 = 0, (I7 = k3(76 + (x4 = E4 >>> 0 < 11 ? 16 : E4 + 11 & -8) | 0)) && (g6 = I7 - 8 | 0, 63 & I7 ? (d4 = (-8 & (M4 = i3[(H4 = I7 - 4 | 0) >> 2])) - (m4 = (I7 = ((I7 = (I7 + 63 & -64) - 8 | 0) - g6 >>> 0 > 15 ? 0 : 64) + I7 | 0) - g6 | 0) | 0, 3 & M4 ? (i3[I7 + 4 >> 2] = d4 | 1 & i3[I7 + 4 >> 2] | 2, i3[4 + (d4 = I7 + d4 | 0) >> 2] = 1 | i3[d4 + 4 >> 2], i3[H4 >> 2] = m4 | 1 & i3[H4 >> 2] | 2, i3[4 + (d4 = g6 + m4 | 0) >> 2] = 1 | i3[d4 + 4 >> 2], v3(g6, m4)) : (g6 = i3[g6 >> 2], i3[I7 + 4 >> 2] = d4, i3[I7 >> 2] = g6 + m4)) : I7 = g6, 3 & (g6 = i3[I7 + 4 >> 2]) && ((m4 = -8 & g6) >>> 0 <= x4 + 16 >>> 0 || (i3[I7 + 4 >> 2] = x4 | 1 & g6 | 2, g6 = I7 + x4 | 0, x4 = m4 - x4 | 0, i3[g6 + 4 >> 2] = 3 | x4, i3[4 + (m4 = I7 + m4 | 0) >> 2] = 1 | i3[m4 + 4 >> 2], v3(g6, x4))), g6 = I7 + 8 | 0)), (I7 = g6) ? (i3[t4 + 12 >> 2] = I7, I7 = 0) : I7 = 48), i3[8952] = I7;
                                    I: {
                                      if (I7)
                                        i3[t4 + 12 >> 2] = 0;
                                      else if (I7 = i3[t4 + 12 >> 2])
                                        break I;
                                      b3(i3[U4 >> 2]), i3[U4 >> 2] = 0;
                                      break A;
                                    }
                                    i3[i3[U4 >> 2] >> 2] = I7, i3[i3[U4 >> 2] + 4 >> 2] = I7, i3[i3[U4 >> 2] + 8 >> 2] = E4, C4 = 0;
                                  }
                                if (s3 = t4 + 16 | 0, C4)
                                  RA(U4, i3[u4 + 56 >> 2]);
                                else {
                                  if (E4 = i3[U4 + 36 >> 2], t4 = I7 = s3, s3 = I7 = I7 - 448 & -64, !B4 | !u4 || (OA(C4 = I7 - -64 | 0, 0, 0, 64), bI(g6 = I7 + 60 | 0, i3[u4 + 48 >> 2]), Cg(C4, g6, 4, 0), bI(g6, i3[u4 + 4 >> 2]), Cg(C4, g6, 4, 0), bI(g6, i3[u4 + 44 >> 2]), Cg(C4, g6, 4, 0), bI(g6, i3[u4 + 40 >> 2]), Cg(C4, g6, 4, 0), bI(g6, 19), Cg(C4, g6, 4, 0), bI(g6, E4), Cg(C4, g6, 4, 0), bI(g6, i3[u4 + 12 >> 2]), Cg(C4, g6, 4, 0), (g6 = i3[u4 + 8 >> 2]) && (Cg(I7 - -64 | 0, g6, i3[u4 + 12 >> 2], 0), 1 & Q3[u4 + 56 | 0] && (Dg(i3[u4 + 8 >> 2], i3[u4 + 12 >> 2]), i3[u4 + 12 >> 2] = 0)), bI(g6 = I7 + 60 | 0, i3[u4 + 20 >> 2]), Cg(I7 - -64 | 0, g6, 4, 0), (g6 = i3[u4 + 16 >> 2]) && Cg(I7 - -64 | 0, g6, i3[u4 + 20 >> 2], 0), bI(g6 = I7 + 60 | 0, i3[u4 + 28 >> 2]), Cg(I7 - -64 | 0, g6, 4, 0), (g6 = i3[u4 + 24 >> 2]) && (Cg(I7 - -64 | 0, g6, i3[u4 + 28 >> 2], 0), 2 & n3[u4 + 56 | 0] && (Dg(i3[u4 + 24 >> 2], i3[u4 + 28 >> 2]), i3[u4 + 28 >> 2] = 0)), bI(g6 = I7 + 60 | 0, i3[u4 + 36 >> 2]), Cg(I7 - -64 | 0, g6, 4, 0), (g6 = i3[u4 + 32 >> 2]) && Cg(I7 - -64 | 0, g6, i3[u4 + 36 >> 2], 0), UI(I7 - -64 | 0, B4, 64)), s3 = t4, Dg(B4 - -64 | 0, 8), C4 = 0, s3 = I7 = s3 - 1024 | 0, i3[U4 + 28 >> 2])
                                    for (E4 = B4 + 68 | 0, g6 = B4 - -64 | 0; bI(g6, 0), bI(E4, C4), R3(I7, 1024, B4, 72), KA(i3[i3[U4 >> 2] + 4 >> 2] + (r3(i3[U4 + 24 >> 2], C4) << 10) | 0, I7), bI(g6, 1), R3(I7, 1024, B4, 72), KA(1024 + (i3[i3[U4 >> 2] + 4 >> 2] + (r3(i3[U4 + 24 >> 2], C4) << 10) | 0) | 0, I7), (C4 = C4 + 1 | 0) >>> 0 < a3[U4 + 28 >> 2]; )
                                      ;
                                  Dg(I7, 1024), s3 = I7 + 1024 | 0, Dg(B4, 72), C4 = 0;
                                }
                              } else
                                C4 = -22;
                            if (s3 = B4 + 80 | 0, !(I7 = C4)) {
                              if (i3[U4 + 8 >> 2])
                                for (; ; ) {
                                  if (B4 = A8, cA2 = 0, s3 = C4 = s3 - 32 | 0, !(!U4 | !i3[U4 + 28 >> 2]))
                                    for (i3[C4 + 16 >> 2] = B4, I7 = 1; ; ) {
                                      if (Q3[C4 + 24 | 0] = cA2, yA2 = 0, A8 = 0, I7)
                                        for (; ; ) {
                                          i3[C4 + 28 >> 2] = 0, A8 = i3[C4 + 28 >> 2], i3[C4 + 8 >> 2] = i3[C4 + 24 >> 2], i3[C4 + 12 >> 2] = A8, i3[C4 + 20 >> 2] = yA2, A8 = i3[C4 + 20 >> 2], i3[C4 >> 2] = i3[C4 + 16 >> 2], i3[C4 + 4 >> 2] = A8, A8 = 0;
                                          A:
                                            if (U4) {
                                              I: {
                                                if (i3[U4 + 36 >> 2] == 2) {
                                                  if (sA2 = i3[U4 + 4 >> 2], wA2 = 1, (t4 = i3[C4 >> 2]) | (E4 = n3[C4 + 8 | 0]) >>> 0 > 1)
                                                    break I;
                                                } else
                                                  sA2 = i3[U4 + 4 >> 2];
                                                if (s3 = I7 = s3 - 4096 | 0, wg(I7 + 3072 | 0), wg(I7 + 2048 | 0), !(!U4 | !C4) && (i3[I7 + 2048 >> 2] = i3[C4 >> 2], i3[I7 + 2052 >> 2] = 0, i3[I7 + 2056 >> 2] = i3[C4 + 4 >> 2], i3[I7 + 2060 >> 2] = 0, i3[I7 + 2064 >> 2] = n3[C4 + 8 | 0], i3[I7 + 2068 >> 2] = 0, i3[I7 + 2072 >> 2] = i3[U4 + 16 >> 2], i3[I7 + 2076 >> 2] = 0, i3[I7 + 2080 >> 2] = i3[U4 + 8 >> 2], i3[I7 + 2084 >> 2] = 0, i3[I7 + 2088 >> 2] = i3[U4 + 36 >> 2], i3[I7 + 2092 >> 2] = 0, i3[U4 + 20 >> 2]))
                                                  for (; (g6 = 127 & A8) || (t4 = E4 = i3[I7 + 2100 >> 2], H4 = E4 + 1 | 0, t4 = (E4 = i3[I7 + 2096 >> 2] + 1 | 0) ? t4 : H4, i3[I7 + 2096 >> 2] = E4, i3[I7 + 2100 >> 2] = t4, wg(I7), wg(E4 = I7 + 1024 | 0), S3(t4 = I7 + 3072 | 0, I7 + 2048 | 0, I7), S3(t4, I7, E4)), E4 = i3[4 + (g6 = (I7 + 1024 | 0) + (g6 << 3) | 0) >> 2], i3[(t4 = (A8 << 3) + sA2 | 0) >> 2] = i3[g6 >> 2], i3[t4 + 4 >> 2] = E4, (A8 = A8 + 1 | 0) >>> 0 < a3[U4 + 20 >> 2]; )
                                                    ;
                                                s3 = I7 + 4096 | 0, E4 = n3[C4 + 8 | 0], t4 = i3[C4 >> 2], wA2 = 0;
                                              }
                                              if (A8 = 255 & E4, !((t4 = t4 ? 0 : !A8 << 1) >>> 0 >= (g6 = i3[U4 + 20 >> 2]) >>> 0))
                                                for (I7 = i3[U4 + 24 >> 2], A8 = (E4 = (r3(I7, i3[C4 + 4 >> 2]) + t4 | 0) + r3(A8, g6) | 0) + ((E4 >>> 0) % (I7 >>> 0) | 0 ? -1 : I7 - 1 | 0) | 0; ; ) {
                                                  DA2 = ((E4 >>> 0) % (I7 >>> 0) | 0) == 1 ? E4 - 1 | 0 : A8, x4 = i3[U4 + 28 >> 2], wA2 ? (A8 = i3[U4 >> 2], m4 = i3[A8 + 4 >> 2] + (DA2 << 10) | 0) : (A8 = i3[U4 >> 2], m4 = (t4 << 3) + sA2 | 0), g6 = i3[m4 >> 2], m4 = i3[m4 + 4 >> 2], i3[C4 + 12 >> 2] = t4, x4 = (m4 >>> 0) % (x4 >>> 0) | 0, m4 = i3[C4 + 4 >> 2], d4 = n3[C4 + 8 | 0] ? x4 : m4, _4 = i3[A8 + 4 >> 2], G4 = i3[C4 >> 2], Y4 = _4 + (r3(I7, A8 = G4 ? x4 : d4) << 10) | 0, A8 = (0 | A8) == (0 | m4);
                                                  I:
                                                    if (i3[C4 >> 2])
                                                      I7 = i3[U4 + 24 >> 2], x4 = i3[U4 + 20 >> 2], I7 = A8 ? i3[C4 + 12 >> 2] + (I7 + (-1 ^ x4) | 0) | 0 : (I7 - x4 | 0) - !i3[C4 + 12 >> 2] | 0, H4 = 0, (0 | (A8 = n3[C4 + 8 | 0])) != 3 && (H4 = r3(x4, A8 + 1 | 0));
                                                    else {
                                                      if (!(I7 = n3[C4 + 8 | 0])) {
                                                        I7 = i3[C4 + 12 >> 2] - 1 | 0, H4 = 0;
                                                        break I;
                                                      }
                                                      if (I7 = r3(I7, i3[U4 + 20 >> 2]), x4 = i3[C4 + 12 >> 2], A8) {
                                                        I7 = (I7 + x4 | 0) - 1 | 0, H4 = 0;
                                                        break I;
                                                      }
                                                      I7 = I7 - !x4 | 0, H4 = 0;
                                                    }
                                                  A8 = H4 + (d4 = I7 - 1 | 0) | 0, qA(g6, 0, g6, 0), qA(I7, 0, h3, 0), m4 = A8 - (I7 = h3) | 0, x4 = i3[U4 + 24 >> 2], l4 = 0;
                                                  I: {
                                                    g: {
                                                      B: {
                                                        C: {
                                                          Q: {
                                                            E: {
                                                              i: {
                                                                n: {
                                                                  a: {
                                                                    r: {
                                                                      if (I7 = (A8 >>> 0 < d4 >>> 0) - (A8 >>> 0 < I7 >>> 0) | 0) {
                                                                        if (!x4)
                                                                          break r;
                                                                        break a;
                                                                      }
                                                                      w3 = m4 - r3((m4 >>> 0) / (x4 >>> 0) | 0, x4) | 0, D3 = 0, h3 = 0;
                                                                      break I;
                                                                    }
                                                                    if (!m4)
                                                                      break n;
                                                                    break i;
                                                                  }
                                                                  if (!((A8 = x4 - 1 | 0) & x4))
                                                                    break E;
                                                                  H4 = 0 - (d4 = (o3(x4) + 33 | 0) - o3(I7) | 0) | 0;
                                                                  break C;
                                                                }
                                                                w3 = 0, D3 = I7, h3 = 0;
                                                                break I;
                                                              }
                                                              if ((A8 = 32 - o3(I7) | 0) >>> 0 < 31)
                                                                break Q;
                                                              break B;
                                                            }
                                                            if (w3 = A8 & m4, D3 = 0, (0 | x4) == 1)
                                                              break g;
                                                            A8 = x4 ? 31 - o3(x4 - 1 ^ x4) | 0 : 32, h3 = (63 & A8) >>> 0 >= 32 ? 0 : I7 >>> A8 | 0;
                                                            break I;
                                                          }
                                                          d4 = A8 + 1 | 0, H4 = 63 - A8 | 0;
                                                        }
                                                        if (g6 = 31 & (A8 = 63 & d4), A8 >>> 0 >= 32 ? (A8 = 0, M4 = I7 >>> g6 | 0) : (A8 = I7 >>> g6 | 0, M4 = ((1 << g6) - 1 & I7) << 32 - g6 | m4 >>> g6), g6 = A8, H4 = 31 & (A8 = 63 & H4), A8 >>> 0 >= 32 ? (A8 = m4 << H4, m4 = 0) : (A8 = (1 << H4) - 1 & m4 >>> 32 - H4 | I7 << H4, m4 <<= H4), I7 = A8, d4)
                                                          for (N4 = (0 | (H4 = x4 - 1 | 0)) != -1 ? 0 : -1; M4 = (A8 = M4 << 1 | I7 >>> 31) - (X4 = x4 & (L4 = N4 - ((g6 = g6 << 1 | M4 >>> 31) + (A8 >>> 0 > H4 >>> 0) | 0) >> 31)) | 0, g6 = g6 - (A8 >>> 0 < X4 >>> 0) | 0, I7 = I7 << 1 | m4 >>> 31, m4 = l4 | m4 << 1, l4 = 1 & L4, d4 = d4 - 1 | 0; )
                                                            ;
                                                        w3 = M4, D3 = g6, h3 = I7 << 1 | m4 >>> 31;
                                                        break I;
                                                      }
                                                      w3 = m4, D3 = I7, I7 = 0;
                                                    }
                                                    h3 = I7;
                                                  }
                                                  if (h3 = D3, A8 = (w3 << 10) + Y4 | 0, x4 = _4 + (DA2 << 10) | 0, g6 = _4 + (E4 << 10) | 0, G4)
                                                    S3(x4, A8, g6);
                                                  else {
                                                    for (s3 = I7 = s3 - 2048 | 0, yg(m4 = I7 + 1024 | 0, A8), AI(m4, x4), yg(I7, m4), x4 = 0, m4 = 0; H4 = i3[(d4 = (A8 = (I7 + 1024 | 0) + (m4 << 7) | 0) - -64 | 0) >> 2], M4 = i3[A8 + 100 >> 2], P4 = H4, N4 = i3[d4 + 4 >> 2], J4 = i3[A8 + 96 >> 2], H4 = i3[A8 + 32 >> 2], _4 = i3[A8 + 36 >> 2], M4 = pA(J4 ^ (l4 = CI(i3[A8 >> 2], i3[A8 + 4 >> 2], H4, _4)), M4 ^ (G4 = h3), 32), _4 = pA(P4 = (N4 = CI(P4, N4, M4, Y4 = h3)) ^ H4, _4 ^ (H4 = h3), 24), P4 = H4, AA4 = pA((X4 = CI(l4, G4, _4, H4 = h3)) ^ M4, (T4 = h3) ^ Y4, 16), H4 = pA(_4 ^ (gA3 = CI(N4, P4, AA4, IA4 = h3)), (rA2 = h3) ^ H4, 63), M4 = h3, _4 = i3[A8 + 108 >> 2], K4 = i3[A8 + 72 >> 2], J4 = i3[A8 + 76 >> 2], P4 = i3[A8 + 104 >> 2], l4 = i3[A8 + 40 >> 2], G4 = i3[A8 + 44 >> 2], _4 = pA(P4 ^ (Y4 = CI(i3[A8 + 8 >> 2], i3[A8 + 12 >> 2], l4, G4)), _4 ^ (N4 = h3), 32), G4 = pA(P4 = (BA3 = CI(K4, J4, _4, L4 = h3)) ^ l4, G4 ^ (l4 = h3), 24), J4 = BA3, tA2 = pA((P4 = _4) ^ (BA3 = CI(Y4, N4, G4, _4 = h3)), (oA2 = h3) ^ L4, 16), _4 = pA(G4 ^ (CA2 = CI(J4, l4, tA2, eA2 = h3)), (QA2 = h3) ^ _4, 63), l4 = h3, G4 = i3[A8 + 116 >> 2], K4 = i3[A8 + 80 >> 2], J4 = i3[A8 + 84 >> 2], P4 = i3[A8 + 112 >> 2], Y4 = i3[A8 + 48 >> 2], N4 = i3[A8 + 52 >> 2], G4 = pA(P4 ^ (L4 = CI(i3[A8 + 16 >> 2], i3[A8 + 20 >> 2], Y4, N4)), G4 ^ (j4 = h3), 32), N4 = pA(J4 = (P4 = CI(K4, J4, G4, EA2 = h3)) ^ Y4, N4 ^ (Y4 = h3), 24), K4 = P4, J4 = Y4, EA2 = pA(G4 ^ (j4 = CI(L4, j4, N4, Y4 = h3)), EA2 ^ (P4 = h3), 16), G4 = pA(N4 ^ (J4 = CI(K4, J4, EA2, iA2 = h3)), (W4 = h3) ^ Y4, 63), Y4 = h3, N4 = i3[A8 + 124 >> 2], aA2 = i3[A8 + 88 >> 2], O4 = i3[A8 + 92 >> 2], K4 = i3[A8 + 120 >> 2], L4 = i3[A8 + 56 >> 2], V4 = i3[A8 + 60 >> 2], N4 = pA(K4 ^ (q4 = CI(i3[A8 + 24 >> 2], i3[A8 + 28 >> 2], L4, V4)), N4 ^ (z4 = h3), 32), O4 = V4 = pA(K4 = (fA2 = CI(aA2, O4, N4, $4 = h3)) ^ L4, V4 ^ (L4 = h3), 24), z4 = pA((K4 = N4) ^ (V4 = CI(q4, z4, V4, N4 = h3)), (q4 = h3) ^ $4, 16), N4 = pA(O4 ^ (fA2 = CI(fA2, L4, z4, $4 = h3)), (aA2 = h3) ^ N4, 63), L4 = h3, O4 = J4, K4 = W4, J4 = pA(z4 ^ (X4 = CI(X4, T4, _4, l4)), $4 ^ (T4 = h3), 32), _4 = pA((z4 = CI(O4, K4, J4, W4 = h3)) ^ _4, (K4 = l4) ^ (l4 = h3), 24), T4 = CI(K4 = X4, T4, _4, X4 = h3), i3[A8 >> 2] = T4, $4 = h3, i3[A8 + 4 >> 2] = $4, T4 = pA(T4 ^ J4, W4 ^ $4, 16), i3[A8 + 120 >> 2] = T4, J4 = h3, i3[A8 + 124 >> 2] = J4, l4 = CI(z4, l4, T4, J4), i3[A8 + 80 >> 2] = l4, T4 = h3, i3[A8 + 84 >> 2] = T4, hA2 = A8, uA2 = pA(_4 ^ l4, X4 ^ T4, 63), i3[hA2 + 40 >> 2] = uA2, i3[A8 + 44 >> 2] = h3, T4 = pA(AA4 ^ (l4 = CI(BA3, oA2, G4, Y4)), IA4 ^ (X4 = h3), 32), _4 = pA(J4 = G4 ^ (IA4 = CI(fA2, aA2, T4, AA4 = h3)), Y4 ^ (G4 = h3), 24), Y4 = CI(J4 = l4, X4, _4, l4 = h3), i3[A8 + 8 >> 2] = Y4, X4 = h3, i3[A8 + 12 >> 2] = X4, Y4 = pA(Y4 ^ T4, X4 ^ AA4, 16), i3[A8 + 96 >> 2] = Y4, X4 = h3, i3[A8 + 100 >> 2] = X4, G4 = CI(IA4, G4, Y4, X4), i3[A8 + 88 >> 2] = G4, Y4 = h3, i3[A8 + 92 >> 2] = Y4, hA2 = A8, uA2 = pA(_4 ^ G4, l4 ^ Y4, 63), i3[hA2 + 48 >> 2] = uA2, i3[A8 + 52 >> 2] = h3, Y4 = pA(tA2 ^ (l4 = CI(j4, P4, N4, L4)), eA2 ^ (G4 = h3), 32), _4 = pA(P4 = N4 ^ (T4 = CI(gA3, rA2, Y4, X4 = h3)), L4 ^ (N4 = h3), 24), G4 = CI(P4 = l4, G4, _4, l4 = h3), i3[A8 + 16 >> 2] = G4, L4 = h3, i3[A8 + 20 >> 2] = L4, G4 = pA(G4 ^ Y4, L4 ^ X4, 16), i3[A8 + 104 >> 2] = G4, Y4 = h3, i3[A8 + 108 >> 2] = Y4, G4 = CI(T4, N4, G4, Y4), i3[d4 >> 2] = G4, P4 = d4, d4 = h3, i3[P4 + 4 >> 2] = d4, hA2 = A8, uA2 = pA(_4 ^ G4, l4 ^ d4, 63), i3[hA2 + 56 >> 2] = uA2, i3[A8 + 60 >> 2] = h3, _4 = CI(V4, q4, H4, M4), N4 = CI(CA2, QA2, G4 = pA(EA2 ^ _4, iA2 ^ (l4 = h3), 32), Y4 = h3), _4 = CI(_4, l4, d4 = pA(P4 = H4 ^ N4, M4 ^ (H4 = h3), 24), M4 = h3), i3[A8 + 24 >> 2] = _4, l4 = h3, i3[A8 + 28 >> 2] = l4, _4 = pA(_4 ^ G4, l4 ^ Y4, 16), i3[A8 + 112 >> 2] = _4, l4 = h3, i3[A8 + 116 >> 2] = l4, H4 = CI(N4, H4, _4, l4), i3[A8 + 72 >> 2] = H4, _4 = h3, i3[A8 + 76 >> 2] = _4, hA2 = A8, uA2 = pA(H4 ^ d4, _4 ^ M4, 63), i3[hA2 + 32 >> 2] = uA2, i3[A8 + 36 >> 2] = h3, (0 | (m4 = m4 + 1 | 0)) != 8; )
                                                      ;
                                                    for (; m4 = i3[512 + (A8 = (I7 + 1024 | 0) + (x4 << 4) | 0) >> 2], d4 = i3[A8 + 772 >> 2], P4 = m4, J4 = i3[A8 + 516 >> 2], l4 = i3[A8 + 768 >> 2], m4 = i3[A8 + 256 >> 2], H4 = i3[A8 + 260 >> 2], d4 = pA(l4 ^ (M4 = CI(i3[A8 >> 2], i3[A8 + 4 >> 2], m4, H4)), d4 ^ (_4 = h3), 32), H4 = pA(P4 = (G4 = CI(P4, J4, d4, l4 = h3)) ^ m4, H4 ^ (m4 = h3), 24), P4 = m4, X4 = pA((N4 = CI(M4, _4, H4, m4 = h3)) ^ d4, (L4 = h3) ^ l4, 16), m4 = pA(H4 ^ (AA4 = CI(G4, P4, X4, T4 = h3)), (IA4 = h3) ^ m4, 63), d4 = h3, H4 = i3[A8 + 780 >> 2], K4 = i3[A8 + 520 >> 2], J4 = i3[A8 + 524 >> 2], P4 = i3[A8 + 776 >> 2], M4 = i3[A8 + 264 >> 2], _4 = i3[A8 + 268 >> 2], H4 = pA(P4 ^ (l4 = CI(i3[A8 + 8 >> 2], i3[A8 + 12 >> 2], M4, _4)), H4 ^ (G4 = h3), 32), _4 = pA(P4 = (gA3 = CI(K4, J4, H4, Y4 = h3)) ^ M4, _4 ^ (M4 = h3), 24), J4 = gA3, BA3 = pA((P4 = H4) ^ (gA3 = CI(l4, G4, _4, H4 = h3)), (rA2 = h3) ^ Y4, 16), H4 = pA(_4 ^ (tA2 = CI(J4, M4, BA3, oA2 = h3)), (eA2 = h3) ^ H4, 63), M4 = h3, _4 = i3[A8 + 900 >> 2], K4 = i3[A8 + 640 >> 2], J4 = i3[A8 + 644 >> 2], P4 = i3[A8 + 896 >> 2], l4 = i3[A8 + 384 >> 2], G4 = i3[A8 + 388 >> 2], _4 = pA(P4 ^ (Y4 = CI(i3[A8 + 128 >> 2], i3[A8 + 132 >> 2], l4, G4)), _4 ^ (CA2 = h3), 32), G4 = pA(P4 = (j4 = CI(K4, J4, _4, QA2 = h3)) ^ l4, G4 ^ (l4 = h3), 24), J4 = j4, P4 = l4, QA2 = pA(_4 ^ (CA2 = CI(Y4, CA2, G4, l4 = h3)), QA2 ^ (j4 = h3), 16), _4 = pA(G4 ^ (P4 = CI(J4, P4, QA2, EA2 = h3)), (iA2 = h3) ^ l4, 63), l4 = h3, G4 = i3[A8 + 908 >> 2], aA2 = i3[A8 + 648 >> 2], O4 = i3[A8 + 652 >> 2], K4 = i3[A8 + 904 >> 2], Y4 = i3[A8 + 392 >> 2], J4 = i3[A8 + 396 >> 2], G4 = pA(K4 ^ (W4 = CI(i3[A8 + 136 >> 2], i3[A8 + 140 >> 2], Y4, J4)), G4 ^ (V4 = h3), 32), O4 = J4 = pA(K4 = (z4 = CI(aA2, O4, G4, q4 = h3)) ^ Y4, J4 ^ (Y4 = h3), 24), V4 = pA((K4 = G4) ^ (J4 = CI(W4, V4, J4, G4 = h3)), (W4 = h3) ^ q4, 16), G4 = pA(O4 ^ (z4 = CI(z4, Y4, V4, q4 = h3)), ($4 = h3) ^ G4, 63), Y4 = h3, O4 = P4, K4 = iA2, P4 = pA(V4 ^ (N4 = CI(N4, L4, H4, M4)), q4 ^ (L4 = h3), 32), H4 = pA((V4 = CI(O4, K4, P4, iA2 = h3)) ^ H4, (K4 = M4) ^ (M4 = h3), 24), L4 = CI(K4 = N4, L4, H4, N4 = h3), i3[A8 >> 2] = L4, q4 = h3, i3[A8 + 4 >> 2] = q4, L4 = pA(L4 ^ P4, q4 ^ iA2, 16), i3[A8 + 904 >> 2] = L4, P4 = h3, i3[A8 + 908 >> 2] = P4, M4 = CI(V4, M4, L4, P4), i3[A8 + 640 >> 2] = M4, L4 = h3, i3[A8 + 644 >> 2] = L4, hA2 = A8, uA2 = pA(H4 ^ M4, N4 ^ L4, 63), i3[hA2 + 264 >> 2] = uA2, i3[A8 + 268 >> 2] = h3, L4 = pA(X4 ^ (M4 = CI(gA3, rA2, _4, l4)), T4 ^ (N4 = h3), 32), H4 = pA(H4 = _4 ^ (T4 = CI(z4, $4, L4, X4 = h3)), l4 ^ (_4 = h3), 24), l4 = CI(l4 = M4, N4, H4, M4 = h3), i3[A8 + 8 >> 2] = l4, N4 = h3, i3[A8 + 12 >> 2] = N4, l4 = pA(l4 ^ L4, N4 ^ X4, 16), i3[A8 + 768 >> 2] = l4, N4 = h3, i3[A8 + 772 >> 2] = N4, _4 = CI(T4, _4, l4, N4), i3[A8 + 648 >> 2] = _4, l4 = h3, i3[A8 + 652 >> 2] = l4, hA2 = A8, uA2 = pA(_4 ^ H4, l4 ^ M4, 63), i3[hA2 + 384 >> 2] = uA2, i3[A8 + 388 >> 2] = h3, M4 = CI(CA2, j4, G4, Y4), L4 = CI(AA4, IA4, l4 = pA(BA3 ^ M4, oA2 ^ (_4 = h3), 32), N4 = h3), _4 = CI(P4 = M4, _4, H4 = pA(H4 = G4 ^ L4, Y4 ^ (G4 = h3), 24), M4 = h3), i3[A8 + 128 >> 2] = _4, Y4 = h3, i3[A8 + 132 >> 2] = Y4, _4 = pA(_4 ^ l4, Y4 ^ N4, 16), i3[A8 + 776 >> 2] = _4, l4 = h3, i3[A8 + 780 >> 2] = l4, _4 = CI(L4, G4, _4, l4), i3[A8 + 512 >> 2] = _4, l4 = h3, i3[A8 + 516 >> 2] = l4, hA2 = A8, uA2 = pA(_4 ^ H4, l4 ^ M4, 63), i3[hA2 + 392 >> 2] = uA2, i3[A8 + 396 >> 2] = h3, _4 = pA(QA2 ^ (H4 = CI(J4, W4, m4, d4)), EA2 ^ (M4 = h3), 32), m4 = pA((G4 = CI(tA2, eA2, _4, l4 = h3)) ^ m4, (P4 = d4) ^ (d4 = h3), 24), M4 = CI(P4 = H4, M4, m4, H4 = h3), i3[A8 + 136 >> 2] = M4, Y4 = h3, i3[A8 + 140 >> 2] = Y4, M4 = pA(_4 ^ M4, l4 ^ Y4, 16), i3[A8 + 896 >> 2] = M4, _4 = h3, i3[A8 + 900 >> 2] = _4, d4 = CI(G4, d4, M4, _4), i3[A8 + 520 >> 2] = d4, M4 = h3, i3[A8 + 524 >> 2] = M4, hA2 = A8, uA2 = pA(m4 ^ d4, H4 ^ M4, 63), i3[hA2 + 256 >> 2] = uA2, i3[A8 + 260 >> 2] = h3, (0 | (x4 = x4 + 1 | 0)) != 8; )
                                                      ;
                                                    yg(g6, I7), AI(g6, I7 + 1024 | 0), s3 = I7 + 2048 | 0;
                                                  }
                                                  if ((t4 = t4 + 1 | 0) >>> 0 >= a3[U4 + 20 >> 2])
                                                    break A;
                                                  E4 = E4 + 1 | 0, A8 = DA2 + 1 | 0, I7 = i3[U4 + 24 >> 2];
                                                }
                                            }
                                          if (!((A8 = i3[U4 + 28 >> 2]) >>> 0 > (yA2 = yA2 + 1 | 0) >>> 0))
                                            break;
                                        }
                                      if (I7 = A8, (0 | (cA2 = cA2 + 1 | 0)) == 4)
                                        break;
                                    }
                                  if (s3 = C4 + 32 | 0, !((A8 = B4 + 1 | 0) >>> 0 < a3[U4 + 8 >> 2]))
                                    break;
                                }
                              if (s3 = I7 = s3 - 2048 | 0, !(!u4 | !U4)) {
                                if (yg(I7 + 1024 | 0, (i3[i3[U4 >> 2] + 4 >> 2] + (i3[U4 + 24 >> 2] << 10) | 0) - 1024 | 0), a3[U4 + 28 >> 2] >= 2)
                                  for (A8 = 1; g6 = i3[U4 + 24 >> 2], AI(I7 + 1024 | 0, (i3[i3[U4 >> 2] + 4 >> 2] + (r3(g6, A8) + g6 << 10) | 0) - 1024 | 0), (A8 = A8 + 1 | 0) >>> 0 < a3[U4 + 28 >> 2]; )
                                    ;
                                for (g6 = I7 + 1024 | 0, A8 = 0; QI(C4 = (B4 = A8 << 3) + I7 | 0, i3[(B4 = g6 + B4 | 0) >> 2], i3[B4 + 4 >> 2]), (0 | (A8 = A8 + 1 | 0)) != 128; )
                                  ;
                                R3(i3[u4 >> 2], i3[u4 + 4 >> 2], I7, 1024), Dg(g6, 1024), Dg(I7, 1024), RA(U4, i3[u4 + 56 >> 2]);
                              }
                              s3 = I7 + 2048 | 0, I7 = 0;
                            }
                          }
                          s3 = U4 + 48 | 0, g6 = I7;
                          A:
                            if (I7)
                              Dg(F4, f4);
                            else {
                              if (!(!c4 | !y4)) {
                                s3 = A8 = s3 - 16 | 0, I7 = -31;
                                I: {
                                  g: {
                                    B: {
                                      C:
                                        switch (p4 - 1 | 0) {
                                          case 1:
                                            if (y4 >>> 0 < 13)
                                              break g;
                                            I7 = n3[1347] | n3[1348] << 8 | n3[1349] << 16 | n3[1350] << 24, g6 = n3[1343] | n3[1344] << 8 | n3[1345] << 16 | n3[1346] << 24, Q3[0 | c4] = g6, Q3[c4 + 1 | 0] = g6 >>> 8, Q3[c4 + 2 | 0] = g6 >>> 16, Q3[c4 + 3 | 0] = g6 >>> 24, Q3[c4 + 4 | 0] = I7, Q3[c4 + 5 | 0] = I7 >>> 8, Q3[c4 + 6 | 0] = I7 >>> 16, Q3[c4 + 7 | 0] = I7 >>> 24, I7 = n3[1352] | n3[1353] << 8 | n3[1354] << 16 | n3[1355] << 24, g6 = n3[1348] | n3[1349] << 8 | n3[1350] << 16 | n3[1351] << 24, Q3[c4 + 5 | 0] = g6, Q3[c4 + 6 | 0] = g6 >>> 8, Q3[c4 + 7 | 0] = g6 >>> 16, Q3[c4 + 8 | 0] = g6 >>> 24, Q3[c4 + 9 | 0] = I7, Q3[c4 + 10 | 0] = I7 >>> 8, Q3[c4 + 11 | 0] = I7 >>> 16, Q3[c4 + 12 | 0] = I7 >>> 24, B4 = -12, g6 = 12;
                                            break B;
                                          case 0:
                                            break C;
                                          default:
                                            break I;
                                        }
                                      if (y4 >>> 0 < 12)
                                        break g;
                                      I7 = n3[1335] | n3[1336] << 8 | n3[1337] << 16 | n3[1338] << 24, g6 = n3[1331] | n3[1332] << 8 | n3[1333] << 16 | n3[1334] << 24, Q3[0 | c4] = g6, Q3[c4 + 1 | 0] = g6 >>> 8, Q3[c4 + 2 | 0] = g6 >>> 16, Q3[c4 + 3 | 0] = g6 >>> 24, Q3[c4 + 4 | 0] = I7, Q3[c4 + 5 | 0] = I7 >>> 8, Q3[c4 + 6 | 0] = I7 >>> 16, Q3[c4 + 7 | 0] = I7 >>> 24, I7 = n3[1339] | n3[1340] << 8 | n3[1341] << 16 | n3[1342] << 24, Q3[c4 + 8 | 0] = I7, Q3[c4 + 9 | 0] = I7 >>> 8, Q3[c4 + 10 | 0] = I7 >>> 16, Q3[c4 + 11 | 0] = I7 >>> 24, B4 = -11, g6 = 11;
                                    }
                                    if (I7 = nA(u4))
                                      break I;
                                    if (dA(I7 = A8 + 5 | 0, 19), !((B4 = B4 + y4 | 0) >>> 0 <= (I7 = mA(I7)) >>> 0) && (g6 = eI(g6 + c4 | 0, A8 + 5 | 0, I7 + 1 | 0), !((B4 = B4 - I7 | 0) >>> 0 < 4) && (Q3[0 | (I7 = I7 + g6 | 0)] = 36, Q3[I7 + 1 | 0] = 109, Q3[I7 + 2 | 0] = 61, Q3[I7 + 3 | 0] = 0, dA(g6 = A8 + 5 | 0, i3[u4 + 44 >> 2]), !((B4 = B4 - 3 | 0) >>> 0 <= (g6 = mA(g6)) >>> 0) && (I7 = eI(I7 + 3 | 0, A8 + 5 | 0, g6 + 1 | 0), !((B4 = B4 - g6 | 0) >>> 0 < 4) && (Q3[0 | (I7 = I7 + g6 | 0)] = 44, Q3[I7 + 1 | 0] = 116, Q3[I7 + 2 | 0] = 61, Q3[I7 + 3 | 0] = 0, dA(g6 = A8 + 5 | 0, i3[u4 + 40 >> 2]), !((B4 = B4 - 3 | 0) >>> 0 <= (g6 = mA(g6)) >>> 0) && (I7 = eI(I7 + 3 | 0, A8 + 5 | 0, g6 + 1 | 0), !((B4 = B4 - g6 | 0) >>> 0 < 4) && (Q3[0 | (I7 = I7 + g6 | 0)] = 44, Q3[I7 + 1 | 0] = 112, Q3[I7 + 2 | 0] = 61, Q3[I7 + 3 | 0] = 0, dA(g6 = A8 + 5 | 0, i3[u4 + 48 >> 2]), !((B4 = B4 - 3 | 0) >>> 0 <= (g6 = mA(g6)) >>> 0) && (I7 = eI(I7 + 3 | 0, A8 + 5 | 0, g6 + 1 | 0), !((B4 = B4 - g6 | 0) >>> 0 < 2) && (Q3[0 | (I7 = I7 + g6 | 0)] = 36, Q3[I7 + 1 | 0] = 0, Z3(g6 = I7 + 1 | 0, B4 = B4 - 1 | 0, i3[u4 + 16 >> 2], i3[u4 + 20 >> 2], 3)))))))))) {
                                      if (I7 = -31, (C4 = (C4 = B4) - (B4 = mA(g6)) | 0) >>> 0 < 2)
                                        break I;
                                      Q3[0 | (I7 = g6 + B4 | 0)] = 36, Q3[I7 + 1 | 0] = 0, I7 = Z3(I7 + 1 | 0, C4 - 1 | 0, i3[u4 >> 2], i3[u4 + 4 >> 2], 3) ? 0 : -31;
                                      break I;
                                    }
                                  }
                                  I7 = -31;
                                }
                                if (s3 = A8 + 16 | 0, I7) {
                                  Dg(F4, f4), Dg(c4, y4), g6 = -31;
                                  break A;
                                }
                              }
                              e4 && eI(e4, F4, f4), Dg(F4, f4), g6 = 0;
                            }
                          b3(F4);
                        } else
                          g6 = -22;
                        return s3 = u4 - -64 | 0, g6;
                      }
                      function k3(A8) {
                        var I7, g6 = 0, B4 = 0, C4 = 0, Q4 = 0, E4 = 0, r4 = 0, o4 = 0, t4 = 0, e4 = 0, f4 = 0, c4 = 0, y4 = 0;
                        s3 = I7 = s3 - 16 | 0;
                        A: {
                          I: {
                            g: {
                              B: {
                                C: {
                                  Q: {
                                    E: {
                                      i: {
                                        n: {
                                          a: {
                                            r: {
                                              if ((A8 |= 0) >>> 0 <= 244) {
                                                if (3 & (g6 = (Q4 = i3[8965]) >>> (B4 = (r4 = A8 >>> 0 < 11 ? 16 : A8 + 11 & -8) >>> 3 | 0) | 0)) {
                                                  A8 = (E4 = i3[35908 + (g6 = (C4 = B4 + (1 & (-1 ^ g6)) | 0) << 3) >> 2]) + 8 | 0, (0 | (B4 = i3[E4 + 8 >> 2])) != (0 | (g6 = g6 + 35900 | 0)) ? (i3[B4 + 12 >> 2] = g6, i3[g6 + 8 >> 2] = B4) : (c4 = 35860, y4 = lI(-2, C4) & Q4, i3[c4 >> 2] = y4), g6 = C4 << 3, i3[E4 + 4 >> 2] = 3 | g6, i3[4 + (g6 = g6 + E4 | 0) >> 2] = 1 | i3[g6 + 4 >> 2];
                                                  break A;
                                                }
                                                if ((f4 = i3[8967]) >>> 0 >= r4 >>> 0)
                                                  break r;
                                                if (g6) {
                                                  B4 = A8 = (g6 = (0 - (A8 = (0 - (A8 = 2 << B4) | A8) & g6 << B4) & A8) - 1 | 0) >>> 12 & 16, B4 |= A8 = (g6 = g6 >>> A8 | 0) >>> 5 & 8, B4 |= A8 = (g6 = g6 >>> A8 | 0) >>> 2 & 4, e4 = i3[35908 + (A8 = (B4 = ((B4 |= A8 = (g6 = g6 >>> A8 | 0) >>> 1 & 2) | (A8 = (g6 = g6 >>> A8 | 0) >>> 1 & 1)) + (g6 >>> A8 | 0) | 0) << 3) >> 2], (0 | (g6 = i3[e4 + 8 >> 2])) != (0 | (A8 = A8 + 35900 | 0)) ? (i3[g6 + 12 >> 2] = A8, i3[A8 + 8 >> 2] = g6) : (Q4 = lI(-2, B4) & Q4, i3[8965] = Q4), A8 = e4 + 8 | 0, i3[e4 + 4 >> 2] = 3 | r4, E4 = (g6 = B4 << 3) - r4 | 0, i3[4 + (C4 = r4 + e4 | 0) >> 2] = 1 | E4, i3[g6 + e4 >> 2] = E4, f4 && (B4 = 35900 + ((g6 = f4 >>> 3 | 0) << 3) | 0, e4 = i3[8970], (g6 = 1 << g6) & Q4 ? g6 = i3[B4 + 8 >> 2] : (i3[8965] = g6 | Q4, g6 = B4), i3[B4 + 8 >> 2] = e4, i3[g6 + 12 >> 2] = e4, i3[e4 + 12 >> 2] = B4, i3[e4 + 8 >> 2] = g6), i3[8970] = C4, i3[8967] = E4;
                                                  break A;
                                                }
                                                if (!(o4 = i3[8966]))
                                                  break r;
                                                for (B4 = A8 = (g6 = (0 - o4 & o4) - 1 | 0) >>> 12 & 16, B4 |= A8 = (g6 = g6 >>> A8 | 0) >>> 5 & 8, B4 |= A8 = (g6 = g6 >>> A8 | 0) >>> 2 & 4, g6 = i3[36164 + (((B4 |= A8 = (g6 = g6 >>> A8 | 0) >>> 1 & 2) | (A8 = (g6 = g6 >>> A8 | 0) >>> 1 & 1)) + (g6 >>> A8 | 0) << 2) >> 2], C4 = (-8 & i3[g6 + 4 >> 2]) - r4 | 0, B4 = g6; (A8 = i3[B4 + 16 >> 2]) || (A8 = i3[B4 + 20 >> 2]); )
                                                  C4 = (E4 = (B4 = (-8 & i3[A8 + 4 >> 2]) - r4 | 0) >>> 0 < C4 >>> 0) ? B4 : C4, g6 = E4 ? A8 : g6, B4 = A8;
                                                if (t4 = i3[g6 + 24 >> 2], (0 | (E4 = i3[g6 + 12 >> 2])) != (0 | g6)) {
                                                  A8 = i3[g6 + 8 >> 2], i3[A8 + 12 >> 2] = E4, i3[E4 + 8 >> 2] = A8;
                                                  break I;
                                                }
                                                if (!(A8 = i3[(B4 = g6 + 20 | 0) >> 2])) {
                                                  if (!(A8 = i3[g6 + 16 >> 2]))
                                                    break a;
                                                  B4 = g6 + 16 | 0;
                                                }
                                                for (; e4 = B4, E4 = A8, (A8 = i3[(B4 = A8 + 20 | 0) >> 2]) || (B4 = E4 + 16 | 0, A8 = i3[E4 + 16 >> 2]); )
                                                  ;
                                                i3[e4 >> 2] = 0;
                                                break I;
                                              }
                                              if (r4 = -1, !(A8 >>> 0 > 4294967231) && (r4 = -8 & (A8 = A8 + 11 | 0), t4 = i3[8966])) {
                                                C4 = 0 - r4 | 0, Q4 = 0, r4 >>> 0 < 256 || (Q4 = 31, r4 >>> 0 > 16777215 || (A8 = A8 >>> 8 | 0, A8 <<= e4 = A8 + 1048320 >>> 16 & 8, Q4 = 28 + ((A8 = ((A8 <<= B4 = A8 + 520192 >>> 16 & 4) << (g6 = A8 + 245760 >>> 16 & 2) >>> 15 | 0) - (g6 | B4 | e4) | 0) << 1 | r4 >>> A8 + 21 & 1) | 0));
                                                o: {
                                                  t: {
                                                    if (B4 = i3[36164 + (Q4 << 2) >> 2])
                                                      for (A8 = 0, g6 = r4 << ((0 | Q4) == 31 ? 0 : 25 - (Q4 >>> 1 | 0) | 0); ; ) {
                                                        if (!((e4 = (o4 = -8 & i3[B4 + 4 >> 2]) - r4 | 0) >>> 0 >= C4 >>> 0) && (C4 = e4, E4 = B4, (0 | r4) == (0 | o4))) {
                                                          C4 = 0, A8 = B4;
                                                          break t;
                                                        }
                                                        if (e4 = i3[B4 + 20 >> 2], B4 = i3[16 + ((g6 >>> 29 & 4) + B4 | 0) >> 2], A8 = e4 ? (0 | e4) == (0 | B4) ? A8 : e4 : A8, g6 <<= 1, !B4)
                                                          break;
                                                      }
                                                    else
                                                      A8 = 0;
                                                    if (!(A8 | E4)) {
                                                      if (E4 = 0, !(A8 = (0 - (A8 = 2 << Q4) | A8) & t4))
                                                        break r;
                                                      B4 = A8 = (g6 = (A8 & 0 - A8) - 1 | 0) >>> 12 & 16, B4 |= A8 = (g6 = g6 >>> A8 | 0) >>> 5 & 8, B4 |= A8 = (g6 = g6 >>> A8 | 0) >>> 2 & 4, A8 = i3[36164 + (((B4 |= A8 = (g6 = g6 >>> A8 | 0) >>> 1 & 2) | (A8 = (g6 = g6 >>> A8 | 0) >>> 1 & 1)) + (g6 >>> A8 | 0) << 2) >> 2];
                                                    }
                                                    if (!A8)
                                                      break o;
                                                  }
                                                  for (; C4 = (B4 = (g6 = (-8 & i3[A8 + 4 >> 2]) - r4 | 0) >>> 0 < C4 >>> 0) ? g6 : C4, E4 = B4 ? A8 : E4, A8 = (g6 = i3[A8 + 16 >> 2]) || i3[A8 + 20 >> 2]; )
                                                    ;
                                                }
                                                if (!(!E4 | i3[8967] - r4 >>> 0 <= C4 >>> 0)) {
                                                  if (Q4 = i3[E4 + 24 >> 2], (0 | E4) != (0 | (g6 = i3[E4 + 12 >> 2]))) {
                                                    A8 = i3[E4 + 8 >> 2], i3[A8 + 12 >> 2] = g6, i3[g6 + 8 >> 2] = A8;
                                                    break g;
                                                  }
                                                  if (!(A8 = i3[(B4 = E4 + 20 | 0) >> 2])) {
                                                    if (!(A8 = i3[E4 + 16 >> 2]))
                                                      break n;
                                                    B4 = E4 + 16 | 0;
                                                  }
                                                  for (; e4 = B4, g6 = A8, (A8 = i3[(B4 = A8 + 20 | 0) >> 2]) || (B4 = g6 + 16 | 0, A8 = i3[g6 + 16 >> 2]); )
                                                    ;
                                                  i3[e4 >> 2] = 0;
                                                  break g;
                                                }
                                              }
                                            }
                                            if ((B4 = i3[8967]) >>> 0 >= r4 >>> 0) {
                                              C4 = i3[8970], (g6 = B4 - r4 | 0) >>> 0 >= 16 ? (i3[8967] = g6, A8 = C4 + r4 | 0, i3[8970] = A8, i3[A8 + 4 >> 2] = 1 | g6, i3[B4 + C4 >> 2] = g6, i3[C4 + 4 >> 2] = 3 | r4) : (i3[8970] = 0, i3[8967] = 0, i3[C4 + 4 >> 2] = 3 | B4, i3[4 + (A8 = B4 + C4 | 0) >> 2] = 1 | i3[A8 + 4 >> 2]), A8 = C4 + 8 | 0;
                                              break A;
                                            }
                                            if ((t4 = i3[8968]) >>> 0 > r4 >>> 0) {
                                              g6 = t4 - r4 | 0, i3[8968] = g6, A8 = (B4 = i3[8971]) + r4 | 0, i3[8971] = A8, i3[A8 + 4 >> 2] = 1 | g6, i3[B4 + 4 >> 2] = 3 | r4, A8 = B4 + 8 | 0;
                                              break A;
                                            }
                                            if (A8 = 0, o4 = r4 + 47 | 0, i3[9083] ? B4 = i3[9085] : (i3[9086] = -1, i3[9087] = -1, i3[9084] = 4096, i3[9085] = 4096, i3[9083] = I7 + 12 & -16 ^ 1431655768, i3[9088] = 0, i3[9076] = 0, B4 = 4096), (B4 = (e4 = o4 + B4 | 0) & (E4 = 0 - B4 | 0)) >>> 0 <= r4 >>> 0)
                                              break A;
                                            if ((C4 = i3[9075]) && (Q4 = (g6 = i3[9073]) + B4 | 0) >>> 0 > C4 >>> 0 | g6 >>> 0 >= Q4 >>> 0)
                                              break A;
                                            if (4 & n3[36304])
                                              break Q;
                                            r: {
                                              o: {
                                                if (C4 = i3[8971])
                                                  for (A8 = 36308; ; ) {
                                                    if ((g6 = i3[A8 >> 2]) >>> 0 <= C4 >>> 0 & C4 >>> 0 < g6 + i3[A8 + 4 >> 2] >>> 0)
                                                      break o;
                                                    if (!(A8 = i3[A8 + 8 >> 2]))
                                                      break;
                                                  }
                                                if ((0 | (g6 = $A(0))) == -1)
                                                  break E;
                                                if (Q4 = B4, (A8 = (C4 = i3[9084]) - 1 | 0) & g6 && (Q4 = (B4 - g6 | 0) + (A8 + g6 & 0 - C4) | 0), Q4 >>> 0 <= r4 >>> 0 | Q4 >>> 0 > 2147483646)
                                                  break E;
                                                if ((C4 = i3[9075]) && C4 >>> 0 < (E4 = (A8 = i3[9073]) + Q4 | 0) >>> 0 | A8 >>> 0 >= E4 >>> 0)
                                                  break E;
                                                if ((0 | g6) != (0 | (A8 = $A(Q4))))
                                                  break r;
                                                break C;
                                              }
                                              if ((Q4 = E4 & e4 - t4) >>> 0 > 2147483646)
                                                break E;
                                              if ((0 | (g6 = $A(Q4))) == (i3[A8 >> 2] + i3[A8 + 4 >> 2] | 0))
                                                break i;
                                              A8 = g6;
                                            }
                                            if (!((0 | A8) == -1 | r4 + 48 >>> 0 <= Q4 >>> 0)) {
                                              if ((g6 = (g6 = i3[9085]) + (o4 - Q4 | 0) & 0 - g6) >>> 0 > 2147483646) {
                                                g6 = A8;
                                                break C;
                                              }
                                              if ((0 | $A(g6)) != -1) {
                                                Q4 = g6 + Q4 | 0, g6 = A8;
                                                break C;
                                              }
                                              $A(0 - Q4 | 0);
                                              break E;
                                            }
                                            if (g6 = A8, (0 | A8) != -1)
                                              break C;
                                            break E;
                                          }
                                          E4 = 0;
                                          break I;
                                        }
                                        g6 = 0;
                                        break g;
                                      }
                                      if ((0 | g6) != -1)
                                        break C;
                                    }
                                    i3[9076] = 4 | i3[9076];
                                  }
                                  if (B4 >>> 0 > 2147483646)
                                    break B;
                                  if ((0 | (g6 = $A(B4))) == -1 | (0 | (A8 = $A(0))) == -1 | A8 >>> 0 <= g6 >>> 0)
                                    break B;
                                  if ((Q4 = A8 - g6 | 0) >>> 0 <= r4 + 40 >>> 0)
                                    break B;
                                }
                                A8 = i3[9073] + Q4 | 0, i3[9073] = A8, A8 >>> 0 > a3[9074] && (i3[9074] = A8);
                                C: {
                                  Q: {
                                    E: {
                                      if (o4 = i3[8971]) {
                                        for (A8 = 36308; ; ) {
                                          if (((C4 = i3[A8 >> 2]) + (B4 = i3[A8 + 4 >> 2]) | 0) == (0 | g6))
                                            break E;
                                          if (!(A8 = i3[A8 + 8 >> 2]))
                                            break;
                                        }
                                        break Q;
                                      }
                                      for ((A8 = i3[8969]) >>> 0 <= g6 >>> 0 && A8 || (i3[8969] = g6), A8 = 0, i3[9078] = Q4, i3[9077] = g6, i3[8973] = -1, i3[8974] = i3[9083], i3[9080] = 0; B4 = 35900 + (C4 = A8 << 3) | 0, i3[C4 + 35908 >> 2] = B4, i3[C4 + 35912 >> 2] = B4, (0 | (A8 = A8 + 1 | 0)) != 32; )
                                        ;
                                      B4 = (C4 = Q4 - 40 | 0) - (A8 = g6 + 8 & 7 ? -8 - g6 & 7 : 0) | 0, i3[8968] = B4, A8 = A8 + g6 | 0, i3[8971] = A8, i3[A8 + 4 >> 2] = 1 | B4, i3[4 + (g6 + C4 | 0) >> 2] = 40, i3[8972] = i3[9087];
                                      break C;
                                    }
                                    if (!(8 & n3[A8 + 12 | 0] | C4 >>> 0 > o4 >>> 0 | g6 >>> 0 <= o4 >>> 0)) {
                                      i3[A8 + 4 >> 2] = B4 + Q4, B4 = (A8 = o4 + 8 & 7 ? -8 - o4 & 7 : 0) + o4 | 0, i3[8971] = B4, A8 = (g6 = i3[8968] + Q4 | 0) - A8 | 0, i3[8968] = A8, i3[B4 + 4 >> 2] = 1 | A8, i3[4 + (g6 + o4 | 0) >> 2] = 40, i3[8972] = i3[9087];
                                      break C;
                                    }
                                  }
                                  a3[8969] > g6 >>> 0 && (i3[8969] = g6), B4 = g6 + Q4 | 0, A8 = 36308;
                                  Q: {
                                    E: {
                                      i: {
                                        n: {
                                          a: {
                                            r: {
                                              for (; ; ) {
                                                if ((0 | B4) != i3[A8 >> 2]) {
                                                  if (A8 = i3[A8 + 8 >> 2])
                                                    continue;
                                                  break r;
                                                }
                                                break;
                                              }
                                              if (!(8 & n3[A8 + 12 | 0]))
                                                break a;
                                            }
                                            for (A8 = 36308; ; ) {
                                              if ((B4 = i3[A8 >> 2]) >>> 0 <= o4 >>> 0 && (E4 = B4 + i3[A8 + 4 >> 2] | 0) >>> 0 > o4 >>> 0)
                                                break n;
                                              A8 = i3[A8 + 8 >> 2];
                                            }
                                          }
                                          if (i3[A8 >> 2] = g6, i3[A8 + 4 >> 2] = i3[A8 + 4 >> 2] + Q4, i3[4 + (e4 = (g6 + 8 & 7 ? -8 - g6 & 7 : 0) + g6 | 0) >> 2] = 3 | r4, r4 = (Q4 = B4 + (B4 + 8 & 7 ? -8 - B4 & 7 : 0) | 0) - (t4 = r4 + e4 | 0) | 0, (0 | Q4) == (0 | o4)) {
                                            i3[8971] = t4, A8 = i3[8968] + r4 | 0, i3[8968] = A8, i3[t4 + 4 >> 2] = 1 | A8;
                                            break E;
                                          }
                                          if (i3[8970] == (0 | Q4)) {
                                            i3[8970] = t4, A8 = i3[8967] + r4 | 0, i3[8967] = A8, i3[t4 + 4 >> 2] = 1 | A8, i3[A8 + t4 >> 2] = A8;
                                            break E;
                                          }
                                          if ((3 & (A8 = i3[Q4 + 4 >> 2])) == 1) {
                                            E4 = -8 & A8;
                                            a:
                                              if (A8 >>> 0 <= 255) {
                                                if (B4 = i3[Q4 + 8 >> 2], A8 = A8 >>> 3 | 0, (0 | (g6 = i3[Q4 + 12 >> 2])) == (0 | B4)) {
                                                  c4 = 35860, y4 = i3[8965] & lI(-2, A8), i3[c4 >> 2] = y4;
                                                  break a;
                                                }
                                                i3[B4 + 12 >> 2] = g6, i3[g6 + 8 >> 2] = B4;
                                              } else {
                                                if (o4 = i3[Q4 + 24 >> 2], (0 | Q4) == (0 | (g6 = i3[Q4 + 12 >> 2])))
                                                  if ((C4 = i3[(A8 = Q4 + 20 | 0) >> 2]) || (C4 = i3[(A8 = Q4 + 16 | 0) >> 2])) {
                                                    for (; B4 = A8, (C4 = i3[(A8 = (g6 = C4) + 20 | 0) >> 2]) || (A8 = g6 + 16 | 0, C4 = i3[g6 + 16 >> 2]); )
                                                      ;
                                                    i3[B4 >> 2] = 0;
                                                  } else
                                                    g6 = 0;
                                                else
                                                  A8 = i3[Q4 + 8 >> 2], i3[A8 + 12 >> 2] = g6, i3[g6 + 8 >> 2] = A8;
                                                if (o4) {
                                                  B4 = i3[Q4 + 28 >> 2];
                                                  r: {
                                                    if (i3[(A8 = 36164 + (B4 << 2) | 0) >> 2] == (0 | Q4)) {
                                                      if (i3[A8 >> 2] = g6, g6)
                                                        break r;
                                                      c4 = 35864, y4 = i3[8966] & lI(-2, B4), i3[c4 >> 2] = y4;
                                                      break a;
                                                    }
                                                    if (i3[o4 + (i3[o4 + 16 >> 2] == (0 | Q4) ? 16 : 20) >> 2] = g6, !g6)
                                                      break a;
                                                  }
                                                  i3[g6 + 24 >> 2] = o4, (A8 = i3[Q4 + 16 >> 2]) && (i3[g6 + 16 >> 2] = A8, i3[A8 + 24 >> 2] = g6), (A8 = i3[Q4 + 20 >> 2]) && (i3[g6 + 20 >> 2] = A8, i3[A8 + 24 >> 2] = g6);
                                                }
                                              }
                                            r4 = E4 + r4 | 0, Q4 = Q4 + E4 | 0;
                                          }
                                          if (i3[Q4 + 4 >> 2] = -2 & i3[Q4 + 4 >> 2], i3[t4 + 4 >> 2] = 1 | r4, i3[r4 + t4 >> 2] = r4, r4 >>> 0 <= 255) {
                                            g6 = 35900 + ((A8 = r4 >>> 3 | 0) << 3) | 0, (B4 = i3[8965]) & (A8 = 1 << A8) ? A8 = i3[g6 + 8 >> 2] : (i3[8965] = A8 | B4, A8 = g6), i3[g6 + 8 >> 2] = t4, i3[A8 + 12 >> 2] = t4, i3[t4 + 12 >> 2] = g6, i3[t4 + 8 >> 2] = A8;
                                            break E;
                                          }
                                          if (A8 = 31, r4 >>> 0 <= 16777215 && (A8 = r4 >>> 8 | 0, A8 <<= C4 = A8 + 1048320 >>> 16 & 8, A8 = 28 + ((A8 = ((A8 <<= B4 = A8 + 520192 >>> 16 & 4) << (g6 = A8 + 245760 >>> 16 & 2) >>> 15 | 0) - (g6 | B4 | C4) | 0) << 1 | r4 >>> A8 + 21 & 1) | 0), i3[t4 + 28 >> 2] = A8, i3[t4 + 16 >> 2] = 0, i3[t4 + 20 >> 2] = 0, C4 = 36164 + (A8 << 2) | 0, (B4 = i3[8966]) & (g6 = 1 << A8)) {
                                            for (A8 = r4 << ((0 | A8) == 31 ? 0 : 25 - (A8 >>> 1 | 0) | 0), g6 = i3[C4 >> 2]; ; ) {
                                              if (B4 = g6, (-8 & i3[g6 + 4 >> 2]) == (0 | r4))
                                                break i;
                                              if (g6 = A8 >>> 29 | 0, A8 <<= 1, !(g6 = i3[16 + (C4 = B4 + (4 & g6) | 0) >> 2]))
                                                break;
                                            }
                                            i3[C4 + 16 >> 2] = t4, i3[t4 + 24 >> 2] = B4;
                                          } else
                                            i3[8966] = g6 | B4, i3[C4 >> 2] = t4, i3[t4 + 24 >> 2] = C4;
                                          i3[t4 + 12 >> 2] = t4, i3[t4 + 8 >> 2] = t4;
                                          break E;
                                        }
                                        for (B4 = (C4 = Q4 - 40 | 0) - (A8 = g6 + 8 & 7 ? -8 - g6 & 7 : 0) | 0, i3[8968] = B4, A8 = A8 + g6 | 0, i3[8971] = A8, i3[A8 + 4 >> 2] = 1 | B4, i3[4 + (g6 + C4 | 0) >> 2] = 40, i3[8972] = i3[9087], i3[(B4 = (A8 = (E4 + (E4 - 39 & 7 ? 39 - E4 & 7 : 0) | 0) - 47 | 0) >>> 0 < o4 + 16 >>> 0 ? o4 : A8) + 4 >> 2] = 27, A8 = i3[9080], i3[B4 + 16 >> 2] = i3[9079], i3[B4 + 20 >> 2] = A8, A8 = i3[9078], i3[B4 + 8 >> 2] = i3[9077], i3[B4 + 12 >> 2] = A8, i3[9079] = B4 + 8, i3[9078] = Q4, i3[9077] = g6, i3[9080] = 0, A8 = B4 + 24 | 0; i3[A8 + 4 >> 2] = 7, g6 = A8 + 8 | 0, A8 = A8 + 4 | 0, g6 >>> 0 < E4 >>> 0; )
                                          ;
                                        if ((0 | B4) == (0 | o4))
                                          break C;
                                        if (i3[B4 + 4 >> 2] = -2 & i3[B4 + 4 >> 2], E4 = B4 - o4 | 0, i3[o4 + 4 >> 2] = 1 | E4, i3[B4 >> 2] = E4, E4 >>> 0 <= 255) {
                                          g6 = 35900 + ((A8 = E4 >>> 3 | 0) << 3) | 0, (B4 = i3[8965]) & (A8 = 1 << A8) ? A8 = i3[g6 + 8 >> 2] : (i3[8965] = A8 | B4, A8 = g6), i3[g6 + 8 >> 2] = o4, i3[A8 + 12 >> 2] = o4, i3[o4 + 12 >> 2] = g6, i3[o4 + 8 >> 2] = A8;
                                          break C;
                                        }
                                        if (A8 = 31, i3[o4 + 16 >> 2] = 0, i3[o4 + 20 >> 2] = 0, E4 >>> 0 <= 16777215 && (A8 = E4 >>> 8 | 0, A8 <<= C4 = A8 + 1048320 >>> 16 & 8, A8 = 28 + ((A8 = ((A8 <<= B4 = A8 + 520192 >>> 16 & 4) << (g6 = A8 + 245760 >>> 16 & 2) >>> 15 | 0) - (g6 | B4 | C4) | 0) << 1 | E4 >>> A8 + 21 & 1) | 0), i3[o4 + 28 >> 2] = A8, C4 = 36164 + (A8 << 2) | 0, (B4 = i3[8966]) & (g6 = 1 << A8)) {
                                          for (A8 = E4 << ((0 | A8) == 31 ? 0 : 25 - (A8 >>> 1 | 0) | 0), g6 = i3[C4 >> 2]; ; ) {
                                            if (B4 = g6, (0 | E4) == (-8 & i3[g6 + 4 >> 2]))
                                              break Q;
                                            if (g6 = A8 >>> 29 | 0, A8 <<= 1, !(g6 = i3[16 + (C4 = B4 + (4 & g6) | 0) >> 2]))
                                              break;
                                          }
                                          i3[C4 + 16 >> 2] = o4, i3[o4 + 24 >> 2] = B4;
                                        } else
                                          i3[8966] = g6 | B4, i3[C4 >> 2] = o4, i3[o4 + 24 >> 2] = C4;
                                        i3[o4 + 12 >> 2] = o4, i3[o4 + 8 >> 2] = o4;
                                        break C;
                                      }
                                      A8 = i3[B4 + 8 >> 2], i3[A8 + 12 >> 2] = t4, i3[B4 + 8 >> 2] = t4, i3[t4 + 24 >> 2] = 0, i3[t4 + 12 >> 2] = B4, i3[t4 + 8 >> 2] = A8;
                                    }
                                    A8 = e4 + 8 | 0;
                                    break A;
                                  }
                                  A8 = i3[B4 + 8 >> 2], i3[A8 + 12 >> 2] = o4, i3[B4 + 8 >> 2] = o4, i3[o4 + 24 >> 2] = 0, i3[o4 + 12 >> 2] = B4, i3[o4 + 8 >> 2] = A8;
                                }
                                if (!((A8 = i3[8968]) >>> 0 <= r4 >>> 0)) {
                                  g6 = A8 - r4 | 0, i3[8968] = g6, A8 = (B4 = i3[8971]) + r4 | 0, i3[8971] = A8, i3[A8 + 4 >> 2] = 1 | g6, i3[B4 + 4 >> 2] = 3 | r4, A8 = B4 + 8 | 0;
                                  break A;
                                }
                              }
                              i3[8952] = 48, A8 = 0;
                              break A;
                            }
                            g:
                              if (Q4) {
                                B4 = i3[E4 + 28 >> 2];
                                B: {
                                  if (i3[(A8 = 36164 + (B4 << 2) | 0) >> 2] == (0 | E4)) {
                                    if (i3[A8 >> 2] = g6, g6)
                                      break B;
                                    t4 = lI(-2, B4) & t4, i3[8966] = t4;
                                    break g;
                                  }
                                  if (i3[Q4 + (i3[Q4 + 16 >> 2] == (0 | E4) ? 16 : 20) >> 2] = g6, !g6)
                                    break g;
                                }
                                i3[g6 + 24 >> 2] = Q4, (A8 = i3[E4 + 16 >> 2]) && (i3[g6 + 16 >> 2] = A8, i3[A8 + 24 >> 2] = g6), (A8 = i3[E4 + 20 >> 2]) && (i3[g6 + 20 >> 2] = A8, i3[A8 + 24 >> 2] = g6);
                              }
                            g:
                              if (C4 >>> 0 <= 15)
                                A8 = C4 + r4 | 0, i3[E4 + 4 >> 2] = 3 | A8, i3[4 + (A8 = A8 + E4 | 0) >> 2] = 1 | i3[A8 + 4 >> 2];
                              else if (i3[E4 + 4 >> 2] = 3 | r4, i3[4 + (Q4 = E4 + r4 | 0) >> 2] = 1 | C4, i3[Q4 + C4 >> 2] = C4, C4 >>> 0 <= 255)
                                g6 = 35900 + ((A8 = C4 >>> 3 | 0) << 3) | 0, (B4 = i3[8965]) & (A8 = 1 << A8) ? A8 = i3[g6 + 8 >> 2] : (i3[8965] = A8 | B4, A8 = g6), i3[g6 + 8 >> 2] = Q4, i3[A8 + 12 >> 2] = Q4, i3[Q4 + 12 >> 2] = g6, i3[Q4 + 8 >> 2] = A8;
                              else {
                                A8 = 31, C4 >>> 0 <= 16777215 && (A8 = C4 >>> 8 | 0, A8 <<= e4 = A8 + 1048320 >>> 16 & 8, A8 = 28 + ((A8 = ((A8 <<= B4 = A8 + 520192 >>> 16 & 4) << (g6 = A8 + 245760 >>> 16 & 2) >>> 15 | 0) - (g6 | B4 | e4) | 0) << 1 | C4 >>> A8 + 21 & 1) | 0), i3[Q4 + 28 >> 2] = A8, i3[Q4 + 16 >> 2] = 0, i3[Q4 + 20 >> 2] = 0, g6 = 36164 + (A8 << 2) | 0;
                                B: {
                                  if ((B4 = 1 << A8) & t4) {
                                    for (A8 = C4 << ((0 | A8) == 31 ? 0 : 25 - (A8 >>> 1 | 0) | 0), B4 = i3[g6 >> 2]; ; ) {
                                      if ((-8 & i3[(g6 = B4) + 4 >> 2]) == (0 | C4))
                                        break B;
                                      if (B4 = A8 >>> 29 | 0, A8 <<= 1, !(B4 = i3[16 + (e4 = (4 & B4) + g6 | 0) >> 2]))
                                        break;
                                    }
                                    i3[e4 + 16 >> 2] = Q4;
                                  } else
                                    i3[8966] = B4 | t4, i3[g6 >> 2] = Q4;
                                  i3[Q4 + 24 >> 2] = g6, i3[Q4 + 12 >> 2] = Q4, i3[Q4 + 8 >> 2] = Q4;
                                  break g;
                                }
                                A8 = i3[g6 + 8 >> 2], i3[A8 + 12 >> 2] = Q4, i3[g6 + 8 >> 2] = Q4, i3[Q4 + 24 >> 2] = 0, i3[Q4 + 12 >> 2] = g6, i3[Q4 + 8 >> 2] = A8;
                              }
                            A8 = E4 + 8 | 0;
                            break A;
                          }
                          I:
                            if (t4) {
                              B4 = i3[g6 + 28 >> 2];
                              g: {
                                if (i3[(A8 = 36164 + (B4 << 2) | 0) >> 2] == (0 | g6)) {
                                  if (i3[A8 >> 2] = E4, E4)
                                    break g;
                                  c4 = 35864, y4 = lI(-2, B4) & o4, i3[c4 >> 2] = y4;
                                  break I;
                                }
                                if (i3[t4 + (i3[t4 + 16 >> 2] == (0 | g6) ? 16 : 20) >> 2] = E4, !E4)
                                  break I;
                              }
                              i3[E4 + 24 >> 2] = t4, (A8 = i3[g6 + 16 >> 2]) && (i3[E4 + 16 >> 2] = A8, i3[A8 + 24 >> 2] = E4), (A8 = i3[g6 + 20 >> 2]) && (i3[E4 + 20 >> 2] = A8, i3[A8 + 24 >> 2] = E4);
                            }
                          C4 >>> 0 <= 15 ? (A8 = C4 + r4 | 0, i3[g6 + 4 >> 2] = 3 | A8, i3[4 + (A8 = A8 + g6 | 0) >> 2] = 1 | i3[A8 + 4 >> 2]) : (i3[g6 + 4 >> 2] = 3 | r4, i3[4 + (E4 = g6 + r4 | 0) >> 2] = 1 | C4, i3[C4 + E4 >> 2] = C4, f4 && (B4 = 35900 + ((A8 = f4 >>> 3 | 0) << 3) | 0, e4 = i3[8970], (A8 = 1 << A8) & Q4 ? A8 = i3[B4 + 8 >> 2] : (i3[8965] = A8 | Q4, A8 = B4), i3[B4 + 8 >> 2] = e4, i3[A8 + 12 >> 2] = e4, i3[e4 + 12 >> 2] = B4, i3[e4 + 8 >> 2] = A8), i3[8970] = E4, i3[8967] = C4), A8 = g6 + 8 | 0;
                        }
                        return s3 = I7 + 16 | 0, 0 | A8;
                      }
                      function H3(A8, I7, g6) {
                        var B4, C4, Q4, E4, n4, a4, o4, t4, e4, f4, c4, y4, s4, w4, D4, p4, u4, F4, l4, _4, k4, H4, G4, U4, S4, b4, m4, v4, M4, P4, Y4, N4, R4, d4, J4, x4, L4, K4, X4, T4, V4, q4, z4, j4, W4, O4, Z4, $4, AA4, IA4, gA3, BA3, CA2 = 0, QA2 = 0, EA2 = 0, iA2 = 0, nA2 = 0, aA2 = 0, rA2 = 0, oA2 = 0, tA2 = 0, eA2 = 0, fA2 = 0, cA2 = 0, yA2 = 0, sA2 = 0, wA2 = 0, DA2 = 0, hA2 = 0, pA2 = 0, uA2 = 0, FA2 = 0, lA2 = 0, _A2 = 0, kA2 = 0, HA2 = 0, GA2 = 0, UA2 = 0;
                        B4 = CA2 = GA2 = i3[g6 + 4 >> 2], e4 = CA2 >> 31, d4 = CA2 = (FA2 = i3[I7 + 20 >> 2]) << 1, CA2 = qA(B4, e4, CA2, k4 = CA2 >> 31), EA2 = h3, QA2 = CA2, C4 = CA2 = i3[g6 >> 2], Q4 = CA2 >> 31, f4 = CA2 = i3[I7 + 24 >> 2], cA2 = qA(C4, Q4, CA2, E4 = CA2 >> 31), CA2 = h3 + EA2 | 0, CA2 = (QA2 = QA2 + cA2 | 0) >>> 0 < cA2 >>> 0 ? CA2 + 1 | 0 : CA2, EA2 = QA2, J4 = QA2 = iA2 = i3[g6 + 8 >> 2], p4 = QA2 >> 31, c4 = QA2 = i3[I7 + 16 >> 2], QA2 = EA2 + (cA2 = qA(iA2, p4, QA2, n4 = QA2 >> 31)) | 0, EA2 = h3 + CA2 | 0, EA2 = QA2 >>> 0 < cA2 >>> 0 ? EA2 + 1 | 0 : EA2, x4 = CA2 = nA2 = i3[g6 + 12 >> 2], u4 = CA2 >> 31, L4 = CA2 = (cA2 = i3[I7 + 12 >> 2]) << 1, CA2 = (yA2 = qA(nA2, u4, CA2, H4 = CA2 >> 31)) + QA2 | 0, QA2 = h3 + EA2 | 0, QA2 = CA2 >>> 0 < yA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = CA2, W4 = CA2 = DA2 = i3[g6 + 16 >> 2], l4 = CA2 >> 31, y4 = CA2 = i3[I7 + 8 >> 2], yA2 = qA(DA2, l4, CA2, a4 = CA2 >> 31), CA2 = h3 + QA2 | 0, CA2 = (EA2 = EA2 + yA2 | 0) >>> 0 < yA2 >>> 0 ? CA2 + 1 | 0 : CA2, lA2 = EA2, O4 = QA2 = oA2 = i3[g6 + 20 >> 2], G4 = QA2 >> 31, K4 = QA2 = (yA2 = i3[I7 + 4 >> 2]) << 1, EA2 = qA(oA2, G4, QA2, U4 = QA2 >> 31), CA2 = h3 + CA2 | 0, CA2 = (QA2 = lA2 + EA2 | 0) >>> 0 < EA2 >>> 0 ? CA2 + 1 | 0 : CA2, EA2 = QA2, Z4 = QA2 = tA2 = i3[g6 + 24 >> 2], X4 = QA2 >> 31, s4 = QA2 = i3[I7 >> 2], uA2 = qA(tA2, X4, QA2, o4 = QA2 >> 31), QA2 = h3 + CA2 | 0, QA2 = (EA2 = EA2 + uA2 | 0) >>> 0 < uA2 >>> 0 ? QA2 + 1 | 0 : QA2, S4 = i3[g6 + 28 >> 2], sA2 = CA2 = r3(S4, 19), F4 = CA2 >> 31, T4 = CA2 = (uA2 = i3[I7 + 36 >> 2]) << 1, CA2 = (wA2 = qA(sA2, F4, CA2, b4 = CA2 >> 31)) + EA2 | 0, EA2 = h3 + QA2 | 0, EA2 = CA2 >>> 0 < wA2 >>> 0 ? EA2 + 1 | 0 : EA2, QA2 = CA2, V4 = i3[g6 + 32 >> 2], eA2 = CA2 = r3(V4, 19), aA2 = CA2 >> 31, w4 = CA2 = i3[I7 + 32 >> 2], wA2 = qA(eA2, aA2, CA2, t4 = CA2 >> 31), CA2 = h3 + EA2 | 0, CA2 = (QA2 = QA2 + wA2 | 0) >>> 0 < wA2 >>> 0 ? CA2 + 1 | 0 : CA2, $4 = i3[g6 + 36 >> 2], fA2 = g6 = r3($4, 19), D4 = g6 >> 31, q4 = I7 = (wA2 = i3[I7 + 28 >> 2]) << 1, g6 = qA(g6, D4, I7, m4 = I7 >> 31), CA2 = h3 + CA2 | 0, HA2 = I7 = g6 + QA2 | 0, I7 = I7 >>> 0 < g6 >>> 0 ? CA2 + 1 | 0 : CA2, g6 = qA(c4, n4, B4, e4), CA2 = h3, QA2 = qA(C4, Q4, FA2, v4 = FA2 >> 31), EA2 = h3 + CA2 | 0, EA2 = (g6 = QA2 + g6 | 0) >>> 0 < QA2 >>> 0 ? EA2 + 1 | 0 : EA2, CA2 = qA(iA2, p4, cA2, M4 = cA2 >> 31), QA2 = h3 + EA2 | 0, QA2 = (g6 = CA2 + g6 | 0) >>> 0 < CA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = qA(y4, a4, nA2, u4), CA2 = h3 + QA2 | 0, CA2 = (g6 = EA2 + g6 | 0) >>> 0 < EA2 >>> 0 ? CA2 + 1 | 0 : CA2, QA2 = qA(DA2, l4, yA2, P4 = yA2 >> 31), CA2 = h3 + CA2 | 0, CA2 = (g6 = QA2 + g6 | 0) >>> 0 < QA2 >>> 0 ? CA2 + 1 | 0 : CA2, QA2 = qA(s4, o4, oA2, G4), CA2 = h3 + CA2 | 0, CA2 = (g6 = QA2 + g6 | 0) >>> 0 < QA2 >>> 0 ? CA2 + 1 | 0 : CA2, EA2 = g6, _A2 = g6 = r3(tA2, 19), g6 = EA2 + (QA2 = qA(g6, _4 = g6 >> 31, uA2, Y4 = uA2 >> 31)) | 0, EA2 = h3 + CA2 | 0, EA2 = g6 >>> 0 < QA2 >>> 0 ? EA2 + 1 | 0 : EA2, CA2 = qA(w4, t4, sA2, F4), QA2 = h3 + EA2 | 0, QA2 = (g6 = CA2 + g6 | 0) >>> 0 < CA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = qA(eA2, aA2, wA2, N4 = wA2 >> 31), CA2 = h3 + QA2 | 0, CA2 = (g6 = EA2 + g6 | 0) >>> 0 < EA2 >>> 0 ? CA2 + 1 | 0 : CA2, QA2 = qA(fA2, D4, f4, E4), CA2 = h3 + CA2 | 0, lA2 = g6 = QA2 + g6 | 0, g6 = g6 >>> 0 < QA2 >>> 0 ? CA2 + 1 | 0 : CA2, CA2 = qA(B4, e4, L4, H4), EA2 = h3, QA2 = (tA2 = qA(C4, Q4, c4, n4)) + CA2 | 0, CA2 = h3 + EA2 | 0, CA2 = QA2 >>> 0 < tA2 >>> 0 ? CA2 + 1 | 0 : CA2, tA2 = qA(y4, a4, iA2, p4), EA2 = h3 + CA2 | 0, EA2 = (QA2 = tA2 + QA2 | 0) >>> 0 < tA2 >>> 0 ? EA2 + 1 | 0 : EA2, CA2 = (tA2 = qA(nA2, u4, K4, U4)) + QA2 | 0, QA2 = h3 + EA2 | 0, QA2 = CA2 >>> 0 < tA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = (tA2 = qA(s4, o4, DA2, l4)) + CA2 | 0, CA2 = h3 + QA2 | 0, CA2 = EA2 >>> 0 < tA2 >>> 0 ? CA2 + 1 | 0 : CA2, hA2 = EA2, z4 = QA2 = r3(oA2, 19), EA2 = qA(QA2, R4 = QA2 >> 31, T4, b4), CA2 = h3 + CA2 | 0, CA2 = (QA2 = hA2 + EA2 | 0) >>> 0 < EA2 >>> 0 ? CA2 + 1 | 0 : CA2, EA2 = qA(w4, t4, _A2, _4), CA2 = h3 + CA2 | 0, CA2 = (QA2 = EA2 + QA2 | 0) >>> 0 < EA2 >>> 0 ? CA2 + 1 | 0 : CA2, oA2 = qA(sA2, F4, q4, m4), EA2 = h3 + CA2 | 0, EA2 = (QA2 = oA2 + QA2 | 0) >>> 0 < oA2 >>> 0 ? EA2 + 1 | 0 : EA2, CA2 = (oA2 = qA(eA2, aA2, f4, E4)) + QA2 | 0, QA2 = h3 + EA2 | 0, QA2 = CA2 >>> 0 < oA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = (oA2 = qA(fA2, D4, d4, k4)) + CA2 | 0, CA2 = h3 + QA2 | 0, CA2 = EA2 >>> 0 < oA2 >>> 0 ? CA2 + 1 | 0 : CA2, oA2 = EA2, IA4 = CA2, tA2 = QA2 = EA2 + 33554432 | 0, gA3 = CA2 = QA2 >>> 0 < 33554432 ? CA2 + 1 | 0 : CA2, EA2 = lA2, lA2 = (67108863 & CA2) << 6 | QA2 >>> 26, CA2 = (CA2 >> 26) + g6 | 0, CA2 = (EA2 = EA2 + lA2 | 0) >>> 0 < lA2 >>> 0 ? CA2 + 1 | 0 : CA2, BA3 = g6 = (lA2 = EA2) + 16777216 | 0, CA2 = I7 + (QA2 = (EA2 = g6 >>> 0 < 16777216 ? CA2 + 1 | 0 : CA2) >> 25) | 0, CA2 = (g6 = (EA2 = (33554431 & EA2) << 7 | g6 >>> 25) + HA2 | 0) >>> 0 < EA2 >>> 0 ? CA2 + 1 | 0 : CA2, kA2 = I7 = g6 + 33554432 | 0, I7 = CA2 = I7 >>> 0 < 33554432 ? CA2 + 1 | 0 : CA2, CA2 = -67108864 & kA2, i3[A8 + 24 >> 2] = g6 - CA2, g6 = qA(B4, e4, K4, U4), CA2 = h3, QA2 = qA(C4, Q4, y4, a4), EA2 = h3 + CA2 | 0, EA2 = (g6 = QA2 + g6 | 0) >>> 0 < QA2 >>> 0 ? EA2 + 1 | 0 : EA2, QA2 = qA(s4, o4, iA2, p4), CA2 = h3 + EA2 | 0, CA2 = (g6 = QA2 + g6 | 0) >>> 0 < QA2 >>> 0 ? CA2 + 1 | 0 : CA2, EA2 = g6, nA2 = g6 = r3(nA2, 19), QA2 = qA(g6, HA2 = g6 >> 31, T4, b4), CA2 = h3 + CA2 | 0, CA2 = (g6 = EA2 + QA2 | 0) >>> 0 < QA2 >>> 0 ? CA2 + 1 | 0 : CA2, QA2 = g6, AA4 = g6 = r3(DA2, 19), g6 = QA2 + (EA2 = qA(w4, t4, g6, j4 = g6 >> 31)) | 0, QA2 = h3 + CA2 | 0, QA2 = g6 >>> 0 < EA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = qA(q4, m4, z4, R4), CA2 = h3 + QA2 | 0, CA2 = (g6 = EA2 + g6 | 0) >>> 0 < EA2 >>> 0 ? CA2 + 1 | 0 : CA2, QA2 = qA(f4, E4, _A2, _4), EA2 = h3 + CA2 | 0, EA2 = (g6 = QA2 + g6 | 0) >>> 0 < QA2 >>> 0 ? EA2 + 1 | 0 : EA2, QA2 = qA(sA2, F4, d4, k4), CA2 = h3 + EA2 | 0, CA2 = (g6 = QA2 + g6 | 0) >>> 0 < QA2 >>> 0 ? CA2 + 1 | 0 : CA2, QA2 = qA(eA2, aA2, c4, n4), CA2 = h3 + CA2 | 0, CA2 = (g6 = QA2 + g6 | 0) >>> 0 < QA2 >>> 0 ? CA2 + 1 | 0 : CA2, EA2 = qA(fA2, D4, L4, H4), QA2 = h3 + CA2 | 0, hA2 = g6 = EA2 + g6 | 0, g6 = g6 >>> 0 < EA2 >>> 0 ? QA2 + 1 | 0 : QA2, CA2 = qA(s4, o4, B4, e4), EA2 = h3, QA2 = (DA2 = qA(C4, Q4, yA2, P4)) + CA2 | 0, CA2 = h3 + EA2 | 0, CA2 = QA2 >>> 0 < DA2 >>> 0 ? CA2 + 1 | 0 : CA2, EA2 = QA2, DA2 = QA2 = r3(iA2, 19), QA2 = EA2 + (iA2 = qA(QA2, rA2 = QA2 >> 31, uA2, Y4)) | 0, EA2 = h3 + CA2 | 0, EA2 = QA2 >>> 0 < iA2 >>> 0 ? EA2 + 1 | 0 : EA2, iA2 = qA(w4, t4, nA2, HA2), CA2 = h3 + EA2 | 0, CA2 = (QA2 = iA2 + QA2 | 0) >>> 0 < iA2 >>> 0 ? CA2 + 1 | 0 : CA2, EA2 = qA(AA4, j4, wA2, N4), CA2 = h3 + CA2 | 0, CA2 = (QA2 = EA2 + QA2 | 0) >>> 0 < EA2 >>> 0 ? CA2 + 1 | 0 : CA2, EA2 = (iA2 = qA(f4, E4, z4, R4)) + QA2 | 0, QA2 = h3 + CA2 | 0, QA2 = EA2 >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, iA2 = qA(_A2, _4, FA2, v4), CA2 = h3 + QA2 | 0, CA2 = (EA2 = iA2 + EA2 | 0) >>> 0 < iA2 >>> 0 ? CA2 + 1 | 0 : CA2, QA2 = (iA2 = qA(c4, n4, sA2, F4)) + EA2 | 0, EA2 = h3 + CA2 | 0, EA2 = QA2 >>> 0 < iA2 >>> 0 ? EA2 + 1 | 0 : EA2, iA2 = qA(eA2, aA2, cA2, M4), CA2 = h3 + EA2 | 0, CA2 = (QA2 = iA2 + QA2 | 0) >>> 0 < iA2 >>> 0 ? CA2 + 1 | 0 : CA2, EA2 = qA(fA2, D4, y4, a4), CA2 = h3 + CA2 | 0, UA2 = QA2 = EA2 + QA2 | 0, iA2 = QA2 >>> 0 < EA2 >>> 0 ? CA2 + 1 | 0 : CA2, CA2 = qA(CA2 = r3(B4, 19), CA2 >> 31, T4, b4), QA2 = h3, EA2 = qA(C4, Q4, s4, o4), QA2 = h3 + QA2 | 0, QA2 = (CA2 = EA2 + CA2 | 0) >>> 0 < EA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = (GA2 = qA(w4, t4, DA2, rA2)) + CA2 | 0, CA2 = h3 + QA2 | 0, QA2 = (nA2 = qA(nA2, HA2, q4, m4)) + EA2 | 0, EA2 = h3 + (EA2 >>> 0 < GA2 >>> 0 ? CA2 + 1 | 0 : CA2) | 0, EA2 = QA2 >>> 0 < nA2 >>> 0 ? EA2 + 1 | 0 : EA2, nA2 = qA(f4, E4, AA4, j4), CA2 = h3 + EA2 | 0, CA2 = (QA2 = nA2 + QA2 | 0) >>> 0 < nA2 >>> 0 ? CA2 + 1 | 0 : CA2, EA2 = qA(d4, k4, z4, R4), CA2 = h3 + CA2 | 0, CA2 = (QA2 = EA2 + QA2 | 0) >>> 0 < EA2 >>> 0 ? CA2 + 1 | 0 : CA2, EA2 = (nA2 = qA(c4, n4, _A2, _4)) + QA2 | 0, QA2 = h3 + CA2 | 0, QA2 = EA2 >>> 0 < nA2 >>> 0 ? QA2 + 1 | 0 : QA2, nA2 = qA(sA2, F4, L4, H4), CA2 = h3 + QA2 | 0, CA2 = (EA2 = nA2 + EA2 | 0) >>> 0 < nA2 >>> 0 ? CA2 + 1 | 0 : CA2, QA2 = (nA2 = qA(eA2, aA2, y4, a4)) + EA2 | 0, EA2 = h3 + CA2 | 0, EA2 = QA2 >>> 0 < nA2 >>> 0 ? EA2 + 1 | 0 : EA2, nA2 = qA(fA2, D4, K4, U4), CA2 = h3 + EA2 | 0, CA2 = (QA2 = nA2 + QA2 | 0) >>> 0 < nA2 >>> 0 ? CA2 + 1 | 0 : CA2, nA2 = QA2, GA2 = CA2, HA2 = QA2 = QA2 + 33554432 | 0, DA2 = CA2 = QA2 >>> 0 < 33554432 ? CA2 + 1 | 0 : CA2, rA2 = (67108863 & CA2) << 6 | QA2 >>> 26, QA2 = (EA2 = CA2 >> 26) + iA2 | 0, iA2 = CA2 = rA2 + UA2 | 0, CA2 = CA2 >>> 0 < rA2 >>> 0 ? QA2 + 1 | 0 : QA2, UA2 = QA2 = iA2 + 16777216 | 0, EA2 = hA2, hA2 = (33554431 & (CA2 = QA2 >>> 0 < 16777216 ? CA2 + 1 | 0 : CA2)) << 7 | QA2 >>> 25, CA2 = (CA2 >> 25) + g6 | 0, CA2 = (QA2 = EA2 + hA2 | 0) >>> 0 < hA2 >>> 0 ? CA2 + 1 | 0 : CA2, hA2 = g6 = QA2 + 33554432 | 0, g6 = CA2 = g6 >>> 0 < 33554432 ? CA2 + 1 | 0 : CA2, CA2 = -67108864 & hA2, i3[A8 + 8 >> 2] = QA2 - CA2, CA2 = qA(f4, E4, B4, e4), EA2 = h3, QA2 = (rA2 = qA(C4, Q4, wA2, N4)) + CA2 | 0, CA2 = h3 + EA2 | 0, CA2 = QA2 >>> 0 < rA2 >>> 0 ? CA2 + 1 | 0 : CA2, EA2 = qA(J4, p4, FA2, v4), CA2 = h3 + CA2 | 0, CA2 = (QA2 = EA2 + QA2 | 0) >>> 0 < EA2 >>> 0 ? CA2 + 1 | 0 : CA2, EA2 = qA(c4, n4, x4, u4), CA2 = h3 + CA2 | 0, CA2 = (QA2 = EA2 + QA2 | 0) >>> 0 < EA2 >>> 0 ? CA2 + 1 | 0 : CA2, rA2 = qA(W4, l4, cA2, M4), EA2 = h3 + CA2 | 0, EA2 = (QA2 = rA2 + QA2 | 0) >>> 0 < rA2 >>> 0 ? EA2 + 1 | 0 : EA2, CA2 = (rA2 = qA(y4, a4, O4, G4)) + QA2 | 0, QA2 = h3 + EA2 | 0, QA2 = CA2 >>> 0 < rA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = (rA2 = qA(yA2, P4, Z4, X4)) + CA2 | 0, CA2 = h3 + QA2 | 0, CA2 = EA2 >>> 0 < rA2 >>> 0 ? CA2 + 1 | 0 : CA2, QA2 = EA2, EA2 = qA(s4, o4, S4, rA2 = S4 >> 31), CA2 = h3 + CA2 | 0, CA2 = (QA2 = QA2 + EA2 | 0) >>> 0 < EA2 >>> 0 ? CA2 + 1 | 0 : CA2, EA2 = qA(eA2, aA2, uA2, Y4), CA2 = h3 + CA2 | 0, CA2 = (QA2 = EA2 + QA2 | 0) >>> 0 < EA2 >>> 0 ? CA2 + 1 | 0 : CA2, pA2 = qA(fA2, D4, w4, t4), EA2 = h3 + CA2 | 0, CA2 = I7 >> 26, I7 = (kA2 = (67108863 & I7) << 6 | kA2 >>> 26) + (QA2 = pA2 + QA2 | 0) | 0, QA2 = CA2 + (EA2 = QA2 >>> 0 < pA2 >>> 0 ? EA2 + 1 | 0 : EA2) | 0, CA2 = QA2 = I7 >>> 0 < kA2 >>> 0 ? QA2 + 1 | 0 : QA2, kA2 = I7 = (EA2 = I7) + 16777216 | 0, I7 = CA2 = I7 >>> 0 < 16777216 ? CA2 + 1 | 0 : CA2, CA2 = -33554432 & kA2, i3[A8 + 28 >> 2] = EA2 - CA2, CA2 = qA(y4, a4, B4, e4), QA2 = h3, pA2 = qA(C4, Q4, cA2, M4), EA2 = h3 + QA2 | 0, EA2 = (CA2 = pA2 + CA2 | 0) >>> 0 < pA2 >>> 0 ? EA2 + 1 | 0 : EA2, pA2 = qA(J4, p4, yA2, P4), QA2 = h3 + EA2 | 0, QA2 = (CA2 = pA2 + CA2 | 0) >>> 0 < pA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = (pA2 = qA(s4, o4, x4, u4)) + CA2 | 0, CA2 = h3 + QA2 | 0, CA2 = EA2 >>> 0 < pA2 >>> 0 ? CA2 + 1 | 0 : CA2, QA2 = EA2, EA2 = qA(AA4, j4, uA2, Y4), CA2 = h3 + CA2 | 0, CA2 = (QA2 = QA2 + EA2 | 0) >>> 0 < EA2 >>> 0 ? CA2 + 1 | 0 : CA2, EA2 = qA(w4, t4, z4, R4), CA2 = h3 + CA2 | 0, CA2 = (QA2 = EA2 + QA2 | 0) >>> 0 < EA2 >>> 0 ? CA2 + 1 | 0 : CA2, QA2 = (_A2 = qA(_A2, _4, wA2, N4)) + QA2 | 0, EA2 = h3 + CA2 | 0, CA2 = (sA2 = qA(f4, E4, sA2, F4)) + QA2 | 0, QA2 = h3 + (QA2 >>> 0 < _A2 >>> 0 ? EA2 + 1 | 0 : EA2) | 0, EA2 = (eA2 = qA(eA2, aA2, FA2, v4)) + CA2 | 0, CA2 = h3 + (CA2 >>> 0 < sA2 >>> 0 ? QA2 + 1 | 0 : QA2) | 0, CA2 = EA2 >>> 0 < eA2 >>> 0 ? CA2 + 1 | 0 : CA2, QA2 = EA2, EA2 = qA(fA2, D4, c4, n4), CA2 = h3 + CA2 | 0, eA2 = QA2 = QA2 + EA2 | 0, CA2 = (CA2 = QA2 >>> 0 < EA2 >>> 0 ? CA2 + 1 | 0 : CA2) + (QA2 = g6 >> 26) | 0, CA2 = (g6 = eA2 + (EA2 = (67108863 & g6) << 6 | hA2 >>> 26) | 0) >>> 0 < EA2 >>> 0 ? CA2 + 1 | 0 : CA2, eA2 = g6 = (QA2 = g6) + 16777216 | 0, g6 = EA2 = g6 >>> 0 < 16777216 ? CA2 + 1 | 0 : CA2, CA2 = -33554432 & eA2, i3[A8 + 12 >> 2] = QA2 - CA2, CA2 = qA(B4, e4, q4, m4), EA2 = h3, QA2 = (aA2 = qA(C4, Q4, w4, t4)) + CA2 | 0, CA2 = h3 + EA2 | 0, CA2 = QA2 >>> 0 < aA2 >>> 0 ? CA2 + 1 | 0 : CA2, EA2 = qA(f4, E4, J4, p4), CA2 = h3 + CA2 | 0, CA2 = (QA2 = EA2 + QA2 | 0) >>> 0 < EA2 >>> 0 ? CA2 + 1 | 0 : CA2, aA2 = qA(x4, u4, d4, k4), EA2 = h3 + CA2 | 0, EA2 = (QA2 = aA2 + QA2 | 0) >>> 0 < aA2 >>> 0 ? EA2 + 1 | 0 : EA2, CA2 = (aA2 = qA(c4, n4, W4, l4)) + QA2 | 0, QA2 = h3 + EA2 | 0, QA2 = CA2 >>> 0 < aA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = (aA2 = qA(L4, H4, O4, G4)) + CA2 | 0, CA2 = h3 + QA2 | 0, CA2 = EA2 >>> 0 < aA2 >>> 0 ? CA2 + 1 | 0 : CA2, QA2 = EA2, EA2 = qA(y4, a4, Z4, X4), CA2 = h3 + CA2 | 0, CA2 = (QA2 = QA2 + EA2 | 0) >>> 0 < EA2 >>> 0 ? CA2 + 1 | 0 : CA2, EA2 = qA(S4, rA2, K4, U4), CA2 = h3 + CA2 | 0, CA2 = (QA2 = EA2 + QA2 | 0) >>> 0 < EA2 >>> 0 ? CA2 + 1 | 0 : CA2, QA2 = (sA2 = qA(s4, o4, V4, aA2 = V4 >> 31)) + QA2 | 0, EA2 = h3 + CA2 | 0, CA2 = (fA2 = qA(fA2, D4, T4, b4)) + QA2 | 0, QA2 = h3 + (QA2 >>> 0 < sA2 >>> 0 ? EA2 + 1 | 0 : EA2) | 0, QA2 = CA2 >>> 0 < fA2 >>> 0 ? QA2 + 1 | 0 : QA2, hA2 = CA2, CA2 = (CA2 = I7 >> 25) + QA2 | 0, CA2 = (I7 = hA2 + (EA2 = (33554431 & I7) << 7 | kA2 >>> 25) | 0) >>> 0 < EA2 >>> 0 ? CA2 + 1 | 0 : CA2, fA2 = I7 = (QA2 = I7) + 33554432 | 0, I7 = CA2 = I7 >>> 0 < 33554432 ? CA2 + 1 | 0 : CA2, CA2 = -67108864 & fA2, i3[A8 + 32 >> 2] = QA2 - CA2, EA2 = QA2 = oA2 - (CA2 = -67108864 & tA2) | 0, CA2 = (CA2 = IA4 - ((CA2 >>> 0 > oA2 >>> 0) + gA3 | 0) | 0) + (QA2 = g6 >> 25) | 0, CA2 = (g6 = EA2 + (oA2 = (33554431 & g6) << 7 | eA2 >>> 25) | 0) >>> 0 < oA2 >>> 0 ? CA2 + 1 | 0 : CA2, CA2 = (lA2 - (-33554432 & BA3) | 0) + ((67108863 & (CA2 = (QA2 = g6 + 33554432 | 0) >>> 0 < 33554432 ? CA2 + 1 | 0 : CA2)) << 6 | QA2 >>> 26) | 0, i3[A8 + 20 >> 2] = CA2, CA2 = -67108864 & QA2, i3[A8 + 16 >> 2] = g6 - CA2, g6 = qA(w4, t4, B4, e4), CA2 = h3, QA2 = qA(C4, Q4, uA2, Y4), CA2 = h3 + CA2 | 0, CA2 = (g6 = QA2 + g6 | 0) >>> 0 < QA2 >>> 0 ? CA2 + 1 | 0 : CA2, EA2 = qA(J4, p4, wA2, N4), QA2 = h3 + CA2 | 0, QA2 = (g6 = EA2 + g6 | 0) >>> 0 < EA2 >>> 0 ? QA2 + 1 | 0 : QA2, CA2 = qA(f4, E4, x4, u4), EA2 = h3 + QA2 | 0, EA2 = (g6 = CA2 + g6 | 0) >>> 0 < CA2 >>> 0 ? EA2 + 1 | 0 : EA2, QA2 = qA(W4, l4, FA2, v4), CA2 = h3 + EA2 | 0, CA2 = (g6 = QA2 + g6 | 0) >>> 0 < QA2 >>> 0 ? CA2 + 1 | 0 : CA2, QA2 = qA(c4, n4, O4, G4), CA2 = h3 + CA2 | 0, CA2 = (g6 = QA2 + g6 | 0) >>> 0 < QA2 >>> 0 ? CA2 + 1 | 0 : CA2, QA2 = qA(cA2, M4, Z4, X4), CA2 = h3 + CA2 | 0, CA2 = (g6 = QA2 + g6 | 0) >>> 0 < QA2 >>> 0 ? CA2 + 1 | 0 : CA2, EA2 = qA(y4, a4, S4, rA2), QA2 = h3 + CA2 | 0, QA2 = (g6 = EA2 + g6 | 0) >>> 0 < EA2 >>> 0 ? QA2 + 1 | 0 : QA2, CA2 = qA(V4, aA2, yA2, P4), EA2 = h3 + QA2 | 0, EA2 = (g6 = CA2 + g6 | 0) >>> 0 < CA2 >>> 0 ? EA2 + 1 | 0 : EA2, QA2 = qA(s4, o4, $4, $4 >> 31), CA2 = h3 + EA2 | 0, CA2 = (CA2 = (g6 = QA2 + g6 | 0) >>> 0 < QA2 >>> 0 ? CA2 + 1 | 0 : CA2) + (QA2 = I7 >> 26) | 0, CA2 = (I7 = (EA2 = g6) + (g6 = (67108863 & I7) << 6 | fA2 >>> 26) | 0) >>> 0 < g6 >>> 0 ? CA2 + 1 | 0 : CA2, CA2 = (g6 = I7 + 16777216 | 0) >>> 0 < 16777216 ? CA2 + 1 | 0 : CA2, QA2 = -33554432 & g6, i3[A8 + 36 >> 2] = I7 - QA2, EA2 = iA2 - (-33554432 & UA2) | 0, QA2 = nA2 - (I7 = -67108864 & HA2) | 0, FA2 = GA2 - ((I7 >>> 0 > nA2 >>> 0) + DA2 | 0) | 0, I7 = (g6 = qA((33554431 & (I7 = CA2)) << 7 | g6 >>> 25, CA2 >>= 25, 19, 0)) + QA2 | 0, QA2 = h3 + FA2 | 0, CA2 = QA2 = I7 >>> 0 < g6 >>> 0 ? QA2 + 1 | 0 : QA2, g6 = ((67108863 & (CA2 = (g6 = I7 + 33554432 | 0) >>> 0 < 33554432 ? CA2 + 1 | 0 : CA2)) << 6 | (QA2 = g6) >>> 26) + EA2 | 0, i3[A8 + 4 >> 2] = g6, g6 = A8, A8 = -67108864 & QA2, i3[g6 >> 2] = I7 - A8;
                      }
                      function G3(A8, I7) {
                        var g6, B4, C4, Q4, E4, n4, a4, o4, t4, e4, f4, c4, y4, w4, D4, p4, u4, F4, l4, _4, k4, H4, G4, S4, b4, m4, v4, M4, P4, Y4, N4, R4, d4, J4, x4, L4, K4, X4, T4, V4, q4, z4 = 0, j4 = 0, W4 = 0, O4 = 0, Z4 = 0, $4 = 0, AA4 = 0, IA4 = 0, gA3 = 0, BA3 = 0, CA2 = 0, QA2 = 0, EA2 = 0, iA2 = 0, nA2 = 0, aA2 = 0, rA2 = 0, oA2 = 0, tA2 = 0, eA2 = 0, fA2 = 0;
                        s3 = H4 = s3 - 48 | 0, U3(A8, I7), U3(F4 = A8 + 80 | 0, N4 = I7 + 40 | 0), g6 = A8 + 120 | 0, a4 = z4 = (rA2 = i3[I7 + 92 >> 2]) << 1, o4 = z4 >> 31, t4 = z4 = (CA2 = i3[I7 + 84 >> 2]) << 1, z4 = qA(a4, o4, z4, B4 = z4 >> 31), Z4 = h3, j4 = z4, m4 = z4 = $4 = i3[I7 + 88 >> 2], W4 = qA(z4, AA4 = z4 >> 31, z4, AA4), z4 = h3 + Z4 | 0, z4 = (j4 = j4 + W4 | 0) >>> 0 < W4 >>> 0 ? z4 + 1 | 0 : z4, W4 = j4, C4 = j4 = i3[I7 + 96 >> 2], e4 = j4 >> 31, f4 = j4 = (EA2 = i3[I7 + 80 >> 2]) << 1, Z4 = qA(C4, e4, j4, Q4 = j4 >> 31), z4 = h3 + z4 | 0, z4 = (j4 = W4 + Z4 | 0) >>> 0 < Z4 >>> 0 ? z4 + 1 | 0 : z4, O4 = j4, Z4 = i3[I7 + 108 >> 2], G4 = j4 = r3(Z4, 38), R4 = Z4, W4 = qA(j4, l4 = j4 >> 31, Z4, v4 = Z4 >> 31), z4 = h3 + z4 | 0, z4 = (j4 = O4 + W4 | 0) >>> 0 < W4 >>> 0 ? z4 + 1 | 0 : z4, W4 = j4, D4 = i3[I7 + 112 >> 2], oA2 = qA(c4 = j4 = r3(D4, 19), y4 = j4 >> 31, j4 = (gA3 = i3[I7 + 104 >> 2]) << 1, j4 >> 31), j4 = h3 + z4 | 0, j4 = (W4 = W4 + oA2 | 0) >>> 0 < oA2 >>> 0 ? j4 + 1 | 0 : j4, O4 = W4, oA2 = i3[I7 + 116 >> 2], E4 = z4 = r3(oA2, 38), n4 = z4 >> 31, _4 = z4 = (W4 = i3[I7 + 100 >> 2]) << 1, aA2 = qA(E4, n4, z4, p4 = z4 >> 31), j4 = h3 + j4 | 0, j4 = (z4 = O4 + aA2 | 0) >>> 0 < aA2 >>> 0 ? j4 + 1 | 0 : j4, aA2 = z4, K4 = z4 = j4 << 1 | z4 >>> 31, d4 = j4 = 33554432 + (aA2 <<= 1) | 0, X4 = z4 = j4 >>> 0 < 33554432 ? z4 + 1 | 0 : z4, j4 = z4 >> 26, z4 = (67108863 & z4) << 6 | d4 >>> 26, tA2 = j4, j4 = qA(t4, B4, C4, e4), IA4 = h3, O4 = z4, k4 = z4 = $4 << 1, rA2 = qA(z4, u4 = z4 >> 31, $4 = rA2, M4 = $4 >> 31), z4 = h3 + IA4 | 0, z4 = (j4 = rA2 + j4 | 0) >>> 0 < rA2 >>> 0 ? z4 + 1 | 0 : z4, rA2 = W4, IA4 = (BA3 = qA(W4, S4 = W4 >> 31, f4, Q4)) + j4 | 0, j4 = h3 + z4 | 0, j4 = IA4 >>> 0 < BA3 >>> 0 ? j4 + 1 | 0 : j4, QA2 = IA4, J4 = z4 = Z4 << 1, IA4 = qA(c4, y4, z4, P4 = z4 >> 31), z4 = h3 + j4 | 0, z4 = (Z4 = QA2 + IA4 | 0) >>> 0 < IA4 >>> 0 ? z4 + 1 | 0 : z4, j4 = Z4, Z4 = qA(E4, n4, gA3, w4 = gA3 >> 31), z4 = h3 + z4 | 0, z4 = (j4 = j4 + Z4 | 0) >>> 0 < Z4 >>> 0 ? z4 + 1 | 0 : z4, Z4 = j4, j4 = (j4 = z4 << 1 | j4 >>> 31) + tA2 | 0, tA2 = z4 = O4 + (Z4 <<= 1) | 0, z4 = z4 >>> 0 < Z4 >>> 0 ? j4 + 1 | 0 : j4, T4 = j4 = tA2 + 16777216 | 0, Z4 = j4, j4 = (z4 = j4 >>> 0 < 16777216 ? z4 + 1 | 0 : z4) >> 25, z4 = (33554431 & z4) << 7 | Z4 >>> 25, Z4 = j4, j4 = qA(a4, o4, $4, M4), IA4 = h3, O4 = z4, BA3 = qA(C4, e4, k4, u4), z4 = h3 + IA4 | 0, z4 = (j4 = BA3 + j4 | 0) >>> 0 < BA3 >>> 0 ? z4 + 1 | 0 : z4, IA4 = qA(t4, B4, _4, p4), z4 = h3 + z4 | 0, z4 = (j4 = IA4 + j4 | 0) >>> 0 < IA4 >>> 0 ? z4 + 1 | 0 : z4, IA4 = (BA3 = qA(f4, Q4, gA3, w4)) + j4 | 0, j4 = h3 + z4 | 0, j4 = IA4 >>> 0 < BA3 >>> 0 ? j4 + 1 | 0 : j4, BA3 = qA(c4, y4, D4, b4 = D4 >> 31), z4 = h3 + j4 | 0, z4 = (IA4 = BA3 + IA4 | 0) >>> 0 < BA3 >>> 0 ? z4 + 1 | 0 : z4, BA3 = qA(E4, n4, J4, P4), j4 = h3 + z4 | 0, j4 = (IA4 = BA3 + IA4 | 0) >>> 0 < BA3 >>> 0 ? j4 + 1 | 0 : j4, BA3 = (z4 = IA4) << 1, z4 = (j4 << 1 | z4 >>> 31) + Z4 | 0, z4 = (IA4 = O4 + BA3 | 0) >>> 0 < BA3 >>> 0 ? z4 + 1 | 0 : z4, fA2 = Z4 = (j4 = IA4) + 33554432 | 0, Z4 = z4 = Z4 >>> 0 < 33554432 ? z4 + 1 | 0 : z4, z4 = -67108864 & fA2, i3[g6 + 24 >> 2] = j4 - z4, z4 = qA(z4 = r3(W4, 38), z4 >> 31, W4, S4), j4 = h3, O4 = z4, W4 = qA(EA2, z4 = EA2 >> 31, EA2, z4), j4 = h3 + j4 | 0, j4 = (z4 = O4 + W4 | 0) >>> 0 < W4 >>> 0 ? j4 + 1 | 0 : j4, W4 = z4, QA2 = z4 = r3(gA3, 19), nA2 = z4 >> 31, x4 = z4 = C4 << 1, EA2 = qA(QA2, nA2, z4, Y4 = z4 >> 31), z4 = h3 + j4 | 0, z4 = (W4 = W4 + EA2 | 0) >>> 0 < EA2 >>> 0 ? z4 + 1 | 0 : z4, j4 = W4, W4 = qA(a4, o4, G4, l4), z4 = h3 + z4 | 0, z4 = (j4 = j4 + W4 | 0) >>> 0 < W4 >>> 0 ? z4 + 1 | 0 : z4, W4 = (EA2 = qA(c4, y4, k4, u4)) + j4 | 0, j4 = h3 + z4 | 0, j4 = W4 >>> 0 < EA2 >>> 0 ? j4 + 1 | 0 : j4, EA2 = qA(t4, B4, E4, n4), z4 = h3 + j4 | 0, z4 = (W4 = EA2 + W4 | 0) >>> 0 < EA2 >>> 0 ? z4 + 1 | 0 : z4, EA2 = (j4 = W4) << 1, q4 = z4 = z4 << 1 | j4 >>> 31, j4 = z4, IA4 = z4 = EA2 + 33554432 | 0, BA3 = j4 = z4 >>> 0 < 33554432 ? j4 + 1 | 0 : j4, z4 = j4 >> 26, j4 = (67108863 & j4) << 6 | IA4 >>> 26, W4 = z4, z4 = qA(QA2, nA2, _4, p4), iA2 = h3, eA2 = j4, j4 = (CA2 = qA(f4, Q4, O4 = CA2, L4 = O4 >> 31)) + z4 | 0, z4 = h3 + iA2 | 0, z4 = j4 >>> 0 < CA2 >>> 0 ? z4 + 1 | 0 : z4, CA2 = (iA2 = qA(C4, e4, G4, l4)) + j4 | 0, j4 = h3 + z4 | 0, j4 = CA2 >>> 0 < iA2 >>> 0 ? j4 + 1 | 0 : j4, iA2 = qA(a4, o4, c4, y4), z4 = h3 + j4 | 0, z4 = (CA2 = iA2 + CA2 | 0) >>> 0 < iA2 >>> 0 ? z4 + 1 | 0 : z4, iA2 = qA(E4, n4, m4, AA4), j4 = h3 + z4 | 0, j4 = (CA2 = iA2 + CA2 | 0) >>> 0 < iA2 >>> 0 ? j4 + 1 | 0 : j4, iA2 = (z4 = CA2) << 1, z4 = (j4 << 1 | z4 >>> 31) + W4 | 0, z4 = (CA2 = eA2 + iA2 | 0) >>> 0 < iA2 >>> 0 ? z4 + 1 | 0 : z4, iA2 = j4 = CA2 + 16777216 | 0, W4 = j4, j4 = (z4 = j4 >>> 0 < 16777216 ? z4 + 1 | 0 : z4) >> 25, z4 = (33554431 & z4) << 7 | W4 >>> 25, W4 = j4, j4 = qA(f4, Q4, m4, AA4), V4 = h3, eA2 = z4, O4 = qA(O4, L4, t4, B4), z4 = h3 + V4 | 0, z4 = (j4 = O4 + j4 | 0) >>> 0 < O4 >>> 0 ? z4 + 1 | 0 : z4, O4 = (QA2 = qA(QA2, nA2, gA3, w4)) + j4 | 0, j4 = h3 + z4 | 0, j4 = O4 >>> 0 < QA2 >>> 0 ? j4 + 1 | 0 : j4, QA2 = qA(_4, p4, G4, l4), z4 = h3 + j4 | 0, z4 = (O4 = QA2 + O4 | 0) >>> 0 < QA2 >>> 0 ? z4 + 1 | 0 : z4, j4 = O4, O4 = qA(c4, y4, x4, Y4), z4 = h3 + z4 | 0, z4 = (j4 = j4 + O4 | 0) >>> 0 < O4 >>> 0 ? z4 + 1 | 0 : z4, O4 = (QA2 = qA(E4, n4, a4, o4)) + j4 | 0, j4 = h3 + z4 | 0, z4 = (z4 = (j4 = O4 >>> 0 < QA2 >>> 0 ? j4 + 1 | 0 : j4) << 1 | O4 >>> 31) + W4 | 0, z4 = (j4 = eA2 + (O4 <<= 1) | 0) >>> 0 < O4 >>> 0 ? z4 + 1 | 0 : z4, W4 = j4, O4 = j4, j4 = z4, QA2 = z4 = W4 + 33554432 | 0, W4 = j4 = z4 >>> 0 < 33554432 ? j4 + 1 | 0 : j4, z4 &= -67108864, i3[g6 + 8 >> 2] = O4 - z4, z4 = qA(k4, u4, rA2, S4), j4 = h3, O4 = qA(a4, o4, C4, e4), j4 = h3 + j4 | 0, j4 = (z4 = O4 + z4 | 0) >>> 0 < O4 >>> 0 ? j4 + 1 | 0 : j4, O4 = (nA2 = qA(t4, B4, gA3, w4)) + z4 | 0, z4 = h3 + j4 | 0, z4 = O4 >>> 0 < nA2 >>> 0 ? z4 + 1 | 0 : z4, nA2 = qA(f4, Q4, R4, v4), j4 = h3 + z4 | 0, j4 = (O4 = nA2 + O4 | 0) >>> 0 < nA2 >>> 0 ? j4 + 1 | 0 : j4, nA2 = qA(E4, n4, D4, b4), z4 = h3 + j4 | 0, eA2 = (j4 = O4 = nA2 + O4 | 0) << 1, z4 = (z4 = (j4 >>> 0 < nA2 >>> 0 ? z4 + 1 | 0 : z4) << 1 | j4 >>> 31) + (j4 = Z4 >> 26) | 0, z4 = (Z4 = eA2 + (O4 = (67108863 & Z4) << 6 | fA2 >>> 26) | 0) >>> 0 < O4 >>> 0 ? z4 + 1 | 0 : z4, O4 = Z4, j4 = z4, fA2 = z4 = Z4 + 16777216 | 0, Z4 = j4 = z4 >>> 0 < 16777216 ? j4 + 1 | 0 : j4, z4 &= -33554432, i3[g6 + 28 >> 2] = O4 - z4, z4 = qA(f4, Q4, $4, M4), $4 = h3, j4 = (AA4 = qA(t4, B4, m4, AA4)) + z4 | 0, z4 = h3 + $4 | 0, z4 = j4 >>> 0 < AA4 >>> 0 ? z4 + 1 | 0 : z4, AA4 = qA(gA3, w4, G4, l4), z4 = h3 + z4 | 0, z4 = (j4 = AA4 + j4 | 0) >>> 0 < AA4 >>> 0 ? z4 + 1 | 0 : z4, AA4 = ($4 = qA(c4, y4, _4, p4)) + j4 | 0, j4 = h3 + z4 | 0, j4 = $4 >>> 0 > AA4 >>> 0 ? j4 + 1 | 0 : j4, z4 = AA4, AA4 = qA(E4, n4, C4, e4), j4 = h3 + j4 | 0, j4 = (z4 = z4 + AA4 | 0) >>> 0 < AA4 >>> 0 ? j4 + 1 | 0 : j4, AA4 = z4, z4 = (z4 = j4 << 1 | z4 >>> 31) + (j4 = W4 >> 26) | 0, z4 = (W4 = (O4 = AA4 << 1) + (AA4 = (67108863 & W4) << 6 | QA2 >>> 26) | 0) >>> 0 < AA4 >>> 0 ? z4 + 1 | 0 : z4, AA4 = W4 = (j4 = W4) + 16777216 | 0, W4 = z4 = W4 >>> 0 < 16777216 ? z4 + 1 | 0 : z4, z4 = -33554432 & AA4, i3[g6 + 12 >> 2] = j4 - z4, z4 = qA(gA3, w4, k4, u4), $4 = h3, j4 = (O4 = qA(C4, e4, C4, e4)) + z4 | 0, z4 = h3 + $4 | 0, z4 = j4 >>> 0 < O4 >>> 0 ? z4 + 1 | 0 : z4, $4 = qA(a4, o4, _4, p4), z4 = h3 + z4 | 0, z4 = (j4 = $4 + j4 | 0) >>> 0 < $4 >>> 0 ? z4 + 1 | 0 : z4, $4 = qA(t4, B4, J4, P4), z4 = h3 + z4 | 0, z4 = (j4 = $4 + j4 | 0) >>> 0 < $4 >>> 0 ? z4 + 1 | 0 : z4, $4 = (O4 = qA(f4, Q4, D4, b4)) + j4 | 0, j4 = h3 + z4 | 0, j4 = O4 >>> 0 > $4 >>> 0 ? j4 + 1 | 0 : j4, z4 = $4, $4 = qA(E4, n4, oA2, O4 = oA2 >> 31), j4 = h3 + j4 | 0, j4 = (z4 = z4 + $4 | 0) >>> 0 < $4 >>> 0 ? j4 + 1 | 0 : j4, $4 = z4, z4 = (z4 = j4 << 1 | z4 >>> 31) + (j4 = Z4 >> 25) | 0, z4 = (Z4 = (QA2 = $4 << 1) + ($4 = (33554431 & Z4) << 7 | fA2 >>> 25) | 0) >>> 0 < $4 >>> 0 ? z4 + 1 | 0 : z4, $4 = Z4 = (j4 = Z4) + 33554432 | 0, Z4 = z4 = Z4 >>> 0 < 33554432 ? z4 + 1 | 0 : z4, z4 = -67108864 & $4, i3[g6 + 32 >> 2] = j4 - z4, j4 = aA2 - (z4 = -67108864 & d4) | 0, aA2 = K4 - ((z4 >>> 0 > aA2 >>> 0) + X4 | 0) | 0, z4 = W4 >> 25, W4 = (AA4 = (33554431 & W4) << 7 | AA4 >>> 25) + j4 | 0, j4 = z4 + aA2 | 0, z4 = j4 = W4 >>> 0 < AA4 >>> 0 ? j4 + 1 | 0 : j4, z4 = ((67108863 & (z4 = (j4 = W4 + 33554432 | 0) >>> 0 < 33554432 ? z4 + 1 | 0 : z4)) << 6 | j4 >>> 26) + (tA2 = tA2 - (-33554432 & T4) | 0) | 0, i3[g6 + 20 >> 2] = z4, z4 = -67108864 & j4, i3[g6 + 16 >> 2] = W4 - z4, z4 = qA(a4, o4, gA3, w4), j4 = h3, W4 = qA(rA2, S4, x4, Y4), j4 = h3 + j4 | 0, j4 = (z4 = W4 + z4 | 0) >>> 0 < W4 >>> 0 ? j4 + 1 | 0 : j4, W4 = (gA3 = qA(k4, u4, R4, v4)) + z4 | 0, z4 = h3 + j4 | 0, z4 = W4 >>> 0 < gA3 >>> 0 ? z4 + 1 | 0 : z4, gA3 = qA(t4, B4, D4, b4), j4 = h3 + z4 | 0, j4 = (W4 = gA3 + W4 | 0) >>> 0 < gA3 >>> 0 ? j4 + 1 | 0 : j4, gA3 = qA(f4, Q4, oA2, O4), z4 = h3 + j4 | 0, O4 = (j4 = W4 = gA3 + W4 | 0) << 1, z4 = (z4 = (j4 >>> 0 < gA3 >>> 0 ? z4 + 1 | 0 : z4) << 1 | j4 >>> 31) + (j4 = Z4 >> 26) | 0, j4 = z4 = (W4 = (67108863 & Z4) << 6 | $4 >>> 26) >>> 0 > (Z4 = O4 + W4 | 0) >>> 0 ? z4 + 1 | 0 : z4, j4 = (z4 = Z4 + 16777216 | 0) >>> 0 < 16777216 ? j4 + 1 | 0 : j4, W4 = -33554432 & z4, i3[g6 + 36 >> 2] = Z4 - W4, gA3 = qA((33554431 & j4) << 7 | z4 >>> 25, j4 >> 25, 19, 0), j4 = h3 + (q4 - (((W4 = -67108864 & IA4) >>> 0 > EA2 >>> 0) + BA3 | 0) | 0) | 0, j4 = (z4 = gA3 + (EA2 - W4 | 0) | 0) >>> 0 < gA3 >>> 0 ? j4 + 1 | 0 : j4, j4 = (CA2 - (-33554432 & iA2) | 0) + ((67108863 & (j4 = (Z4 = z4 + 33554432 | 0) >>> 0 < 33554432 ? j4 + 1 | 0 : j4)) << 6 | Z4 >>> 26) | 0, i3[g6 + 4 >> 2] = j4, j4 = -67108864 & Z4, i3[g6 >> 2] = z4 - j4, yA(z4 = A8 + 40 | 0, I7, N4), U3(H4, z4), yA(z4, F4, A8), cA(F4, F4, A8), cA(A8, H4, z4), cA(g6, g6, F4), s3 = H4 + 48 | 0;
                      }
                      function U3(A8, I7) {
                        var g6, B4, C4, Q4, E4, n4, a4, o4, t4, e4, f4, c4, y4, s4, w4, D4, p4, u4, F4, l4, _4, k4, H4, G4, U4, S4, b4, m4, v4, M4, P4, Y4, N4, R4, d4, J4 = 0, x4 = 0, L4 = 0, K4 = 0, X4 = 0, T4 = 0, V4 = 0, q4 = 0, z4 = 0, j4 = 0, W4 = 0, O4 = 0, Z4 = 0, $4 = 0, AA4 = 0, IA4 = 0, gA3 = 0, BA3 = 0, CA2 = 0;
                        e4 = x4 = (J4 = i3[I7 + 12 >> 2]) << 1, z4 = J4, J4 = qA(x4, E4 = x4 >> 31, J4, U4 = J4 >> 31), K4 = h3, x4 = J4, n4 = (J4 = g6 = i3[I7 + 16 >> 2]) >> 31, p4 = J4 = (V4 = i3[I7 + 8 >> 2]) << 1, L4 = qA(g6, n4, J4, y4 = J4 >> 31), J4 = h3 + K4 | 0, J4 = (x4 = x4 + L4 | 0) >>> 0 < L4 >>> 0 ? J4 + 1 | 0 : J4, K4 = x4, s4 = x4 = (L4 = i3[I7 + 20 >> 2]) << 1, w4 = x4 >> 31, a4 = x4 = (T4 = i3[I7 + 4 >> 2]) << 1, W4 = qA(s4, w4, x4, B4 = x4 >> 31), x4 = h3 + J4 | 0, x4 = (K4 = K4 + W4 | 0) >>> 0 < W4 >>> 0 ? x4 + 1 | 0 : x4, l4 = J4 = X4 = i3[I7 + 24 >> 2], f4 = J4 >> 31, o4 = J4 = (Z4 = i3[I7 >> 2]) << 1, W4 = qA(X4, f4, J4, C4 = J4 >> 31), J4 = h3 + x4 | 0, J4 = (K4 = W4 + K4 | 0) >>> 0 < W4 >>> 0 ? J4 + 1 | 0 : J4, j4 = K4, W4 = i3[I7 + 32 >> 2], D4 = x4 = r3(W4, 19), K4 = qA(x4, c4 = x4 >> 31, W4, _4 = W4 >> 31), J4 = h3 + J4 | 0, J4 = (x4 = j4 + K4 | 0) >>> 0 < K4 >>> 0 ? J4 + 1 | 0 : J4, j4 = x4, k4 = i3[I7 + 36 >> 2], t4 = x4 = r3(k4, 38), Q4 = x4 >> 31, M4 = I7 = (K4 = i3[I7 + 28 >> 2]) << 1, gA3 = qA(x4, Q4, I7, S4 = I7 >> 31), I7 = h3 + J4 | 0, j4 = x4 = j4 + gA3 | 0, O4 = x4 >>> 0 < gA3 >>> 0 ? I7 + 1 | 0 : I7, I7 = qA(a4, B4, g6, n4), J4 = h3, x4 = qA(p4, y4, z4, U4), J4 = h3 + J4 | 0, J4 = (I7 = x4 + I7 | 0) >>> 0 < x4 >>> 0 ? J4 + 1 | 0 : J4, gA3 = L4, q4 = qA(L4, H4 = L4 >> 31, o4, C4), x4 = h3 + J4 | 0, x4 = (I7 = q4 + I7 | 0) >>> 0 < q4 >>> 0 ? x4 + 1 | 0 : x4, q4 = qA(D4, c4, M4, S4), J4 = h3 + x4 | 0, J4 = (I7 = q4 + I7 | 0) >>> 0 < q4 >>> 0 ? J4 + 1 | 0 : J4, x4 = qA(t4, Q4, X4, f4), J4 = h3 + J4 | 0, $4 = I7 = x4 + I7 | 0, BA3 = I7 >>> 0 < x4 >>> 0 ? J4 + 1 | 0 : J4, I7 = qA(a4, B4, e4, E4), x4 = h3, J4 = (q4 = qA(V4, u4 = V4 >> 31, V4, u4)) + I7 | 0, I7 = h3 + x4 | 0, I7 = J4 >>> 0 < q4 >>> 0 ? I7 + 1 | 0 : I7, x4 = (q4 = qA(o4, C4, g6, n4)) + J4 | 0, J4 = h3 + I7 | 0, J4 = x4 >>> 0 < q4 >>> 0 ? J4 + 1 | 0 : J4, G4 = I7 = r3(K4, 38), q4 = K4, I7 = (K4 = qA(I7, F4 = I7 >> 31, K4, b4 = K4 >> 31)) + x4 | 0, x4 = h3 + J4 | 0, x4 = I7 >>> 0 < K4 >>> 0 ? x4 + 1 | 0 : x4, I7 = (J4 = I7) + (K4 = qA(D4, c4, I7 = X4 << 1, I7 >> 31)) | 0, J4 = h3 + x4 | 0, J4 = I7 >>> 0 < K4 >>> 0 ? J4 + 1 | 0 : J4, x4 = qA(t4, Q4, s4, w4), J4 = h3 + J4 | 0, m4 = I7 = x4 + I7 | 0, N4 = J4 = I7 >>> 0 < x4 >>> 0 ? J4 + 1 | 0 : J4, I7 = J4, P4 = J4 = m4 + 33554432 | 0, R4 = I7 = J4 >>> 0 < 33554432 ? I7 + 1 | 0 : I7, J4 = (J4 = I7 >> 26) + BA3 | 0, BA3 = I7 = (x4 = (67108863 & I7) << 6 | P4 >>> 26) + $4 | 0, x4 = I7 >>> 0 < x4 >>> 0 ? J4 + 1 | 0 : J4, d4 = I7 = I7 + 16777216 | 0, J4 = (J4 = (x4 = I7 >>> 0 < 16777216 ? x4 + 1 | 0 : x4) >> 25) + O4 | 0, J4 = (I7 = (x4 = (33554431 & x4) << 7 | I7 >>> 25) + j4 | 0) >>> 0 < x4 >>> 0 ? J4 + 1 | 0 : J4, x4 = I7, I7 = J4, AA4 = J4 = x4 + 33554432 | 0, K4 = I7 = J4 >>> 0 < 33554432 ? I7 + 1 | 0 : I7, I7 = -67108864 & J4, i3[A8 + 24 >> 2] = x4 - I7, I7 = qA(o4, C4, V4, u4), J4 = h3, j4 = qA(a4, B4, T4, O4 = T4 >> 31), x4 = h3 + J4 | 0, x4 = (I7 = j4 + I7 | 0) >>> 0 < j4 >>> 0 ? x4 + 1 | 0 : x4, J4 = I7, j4 = I7 = r3(X4, 19), I7 = J4 + (X4 = qA(I7, $4 = I7 >> 31, X4, f4)) | 0, J4 = h3 + x4 | 0, J4 = I7 >>> 0 < X4 >>> 0 ? J4 + 1 | 0 : J4, x4 = (X4 = qA(s4, w4, G4, F4)) + I7 | 0, I7 = h3 + J4 | 0, I7 = x4 >>> 0 < X4 >>> 0 ? I7 + 1 | 0 : I7, Y4 = J4 = g6 << 1, X4 = qA(D4, c4, J4, v4 = J4 >> 31), J4 = h3 + I7 | 0, J4 = (x4 = X4 + x4 | 0) >>> 0 < X4 >>> 0 ? J4 + 1 | 0 : J4, I7 = x4, x4 = qA(t4, Q4, e4, E4), J4 = h3 + J4 | 0, CA2 = I7 = I7 + x4 | 0, X4 = I7 >>> 0 < x4 >>> 0 ? J4 + 1 | 0 : J4, I7 = qA(s4, w4, j4, $4), J4 = h3, T4 = qA(o4, C4, T4, O4), x4 = h3 + J4 | 0, x4 = (I7 = T4 + I7 | 0) >>> 0 < T4 >>> 0 ? x4 + 1 | 0 : x4, T4 = qA(g6, n4, G4, F4), J4 = h3 + x4 | 0, J4 = (I7 = T4 + I7 | 0) >>> 0 < T4 >>> 0 ? J4 + 1 | 0 : J4, x4 = (T4 = qA(D4, c4, e4, E4)) + I7 | 0, I7 = h3 + J4 | 0, I7 = x4 >>> 0 < T4 >>> 0 ? I7 + 1 | 0 : I7, T4 = qA(t4, Q4, V4, u4), J4 = h3 + I7 | 0, IA4 = x4 = T4 + x4 | 0, O4 = x4 >>> 0 < T4 >>> 0 ? J4 + 1 | 0 : J4, I7 = qA(I7 = r3(L4, 38), I7 >> 31, L4, H4), J4 = h3, L4 = I7, x4 = qA(Z4, I7 = Z4 >> 31, Z4, I7), J4 = h3 + J4 | 0, J4 = (I7 = L4 + x4 | 0) >>> 0 < x4 >>> 0 ? J4 + 1 | 0 : J4, L4 = qA(j4, $4, Y4, v4), x4 = h3 + J4 | 0, x4 = (I7 = L4 + I7 | 0) >>> 0 < L4 >>> 0 ? x4 + 1 | 0 : x4, L4 = qA(e4, E4, G4, F4), J4 = h3 + x4 | 0, J4 = (I7 = L4 + I7 | 0) >>> 0 < L4 >>> 0 ? J4 + 1 | 0 : J4, x4 = (L4 = qA(D4, c4, p4, y4)) + I7 | 0, I7 = h3 + J4 | 0, I7 = x4 >>> 0 < L4 >>> 0 ? I7 + 1 | 0 : I7, L4 = qA(a4, B4, t4, Q4), J4 = h3 + I7 | 0, T4 = x4 = L4 + x4 | 0, j4 = J4 = x4 >>> 0 < L4 >>> 0 ? J4 + 1 | 0 : J4, Z4 = I7 = x4 + 33554432 | 0, $4 = J4 = I7 >>> 0 < 33554432 ? J4 + 1 | 0 : J4, x4 = (I7 = J4 >> 26) + O4 | 0, O4 = J4 = (L4 = (67108863 & J4) << 6 | Z4 >>> 26) + IA4 | 0, IA4 = CA2, J4 = J4 >>> 0 < L4 >>> 0 ? x4 + 1 | 0 : x4, CA2 = I7 = O4 + 16777216 | 0, L4 = (33554431 & (J4 = I7 >>> 0 < 16777216 ? J4 + 1 | 0 : J4)) << 7 | I7 >>> 25, J4 = (J4 >> 25) + X4 | 0, J4 = (x4 = IA4 + L4 | 0) >>> 0 < L4 >>> 0 ? J4 + 1 | 0 : J4, X4 = x4 = (I7 = x4) + 33554432 | 0, L4 = J4 = x4 >>> 0 < 33554432 ? J4 + 1 | 0 : J4, J4 = -67108864 & x4, i3[A8 + 8 >> 2] = I7 - J4, I7 = qA(p4, y4, gA3, H4), J4 = h3, x4 = qA(g6, n4, e4, E4), J4 = h3 + J4 | 0, J4 = (I7 = x4 + I7 | 0) >>> 0 < x4 >>> 0 ? J4 + 1 | 0 : J4, x4 = qA(a4, B4, l4, f4), J4 = h3 + J4 | 0, J4 = (I7 = x4 + I7 | 0) >>> 0 < x4 >>> 0 ? J4 + 1 | 0 : J4, x4 = qA(o4, C4, q4, b4), J4 = h3 + J4 | 0, J4 = (I7 = x4 + I7 | 0) >>> 0 < x4 >>> 0 ? J4 + 1 | 0 : J4, x4 = (IA4 = qA(t4, Q4, W4, _4)) + I7 | 0, I7 = h3 + J4 | 0, J4 = K4 >> 26, K4 = (AA4 = (67108863 & K4) << 6 | AA4 >>> 26) + x4 | 0, x4 = (I7 = x4 >>> 0 < IA4 >>> 0 ? I7 + 1 | 0 : I7) + J4 | 0, J4 = (I7 = K4) >>> 0 < AA4 >>> 0 ? x4 + 1 | 0 : x4, AA4 = x4 = I7 + 16777216 | 0, K4 = J4 = x4 >>> 0 < 16777216 ? J4 + 1 | 0 : J4, J4 = -33554432 & x4, i3[A8 + 28 >> 2] = I7 - J4, I7 = qA(o4, C4, z4, U4), x4 = h3, J4 = (V4 = qA(a4, B4, V4, u4)) + I7 | 0, I7 = h3 + x4 | 0, I7 = J4 >>> 0 < V4 >>> 0 ? I7 + 1 | 0 : I7, V4 = qA(l4, f4, G4, F4), x4 = h3 + I7 | 0, x4 = (J4 = V4 + J4 | 0) >>> 0 < V4 >>> 0 ? x4 + 1 | 0 : x4, I7 = (V4 = qA(D4, c4, s4, w4)) + J4 | 0, J4 = h3 + x4 | 0, J4 = I7 >>> 0 < V4 >>> 0 ? J4 + 1 | 0 : J4, x4 = qA(t4, Q4, g6, n4), J4 = h3 + J4 | 0, J4 = (J4 = (I7 = x4 + I7 | 0) >>> 0 < x4 >>> 0 ? J4 + 1 | 0 : J4) + (x4 = L4 >> 26) | 0, x4 = I7 = (L4 = (67108863 & L4) << 6 | X4 >>> 26) + I7 | 0, I7 = I7 >>> 0 < L4 >>> 0 ? J4 + 1 | 0 : J4, V4 = J4 = x4 + 16777216 | 0, L4 = I7 = J4 >>> 0 < 16777216 ? I7 + 1 | 0 : I7, I7 = -33554432 & J4, i3[A8 + 12 >> 2] = x4 - I7, I7 = qA(l4, f4, p4, y4), J4 = h3, x4 = qA(g6, n4, g6, n4), J4 = h3 + J4 | 0, J4 = (I7 = x4 + I7 | 0) >>> 0 < x4 >>> 0 ? J4 + 1 | 0 : J4, x4 = qA(e4, E4, s4, w4), J4 = h3 + J4 | 0, J4 = (I7 = x4 + I7 | 0) >>> 0 < x4 >>> 0 ? J4 + 1 | 0 : J4, x4 = (z4 = qA(a4, B4, M4, S4)) + I7 | 0, I7 = h3 + J4 | 0, I7 = x4 >>> 0 < z4 >>> 0 ? I7 + 1 | 0 : I7, J4 = (z4 = qA(o4, C4, W4, _4)) + x4 | 0, x4 = h3 + I7 | 0, x4 = J4 >>> 0 < z4 >>> 0 ? x4 + 1 | 0 : x4, I7 = (z4 = qA(t4, Q4, k4, X4 = k4 >> 31)) + J4 | 0, J4 = h3 + x4 | 0, J4 = I7 >>> 0 < z4 >>> 0 ? J4 + 1 | 0 : J4, x4 = I7, J4 = (I7 = K4 >> 25) + J4 | 0, J4 = (x4 = x4 + (K4 = (33554431 & K4) << 7 | AA4 >>> 25) | 0) >>> 0 < K4 >>> 0 ? J4 + 1 | 0 : J4, z4 = x4 = (I7 = x4) + 33554432 | 0, K4 = J4 = x4 >>> 0 < 33554432 ? J4 + 1 | 0 : J4, J4 = -67108864 & x4, i3[A8 + 32 >> 2] = I7 - J4, J4 = L4 >> 25, x4 = (L4 = (33554431 & L4) << 7 | V4 >>> 25) + (m4 - (I7 = -67108864 & P4) | 0) | 0, I7 = J4 + (N4 - ((I7 >>> 0 > m4 >>> 0) + R4 | 0) | 0) | 0, J4 = I7 = x4 >>> 0 < L4 >>> 0 ? I7 + 1 | 0 : I7, L4 = I7 = x4 + 33554432 | 0, I7 = ((67108863 & (J4 = I7 >>> 0 < 33554432 ? J4 + 1 | 0 : J4)) << 6 | I7 >>> 26) + (BA3 = BA3 - (-33554432 & d4) | 0) | 0, i3[A8 + 20 >> 2] = I7, I7 = -67108864 & L4, i3[A8 + 16 >> 2] = x4 - I7, I7 = qA(e4, E4, l4, f4), x4 = h3, J4 = (L4 = qA(gA3, H4, Y4, v4)) + I7 | 0, I7 = h3 + x4 | 0, I7 = J4 >>> 0 < L4 >>> 0 ? I7 + 1 | 0 : I7, x4 = (L4 = qA(p4, y4, q4, b4)) + J4 | 0, J4 = h3 + I7 | 0, J4 = x4 >>> 0 < L4 >>> 0 ? J4 + 1 | 0 : J4, I7 = (L4 = qA(a4, B4, W4, _4)) + x4 | 0, x4 = h3 + J4 | 0, x4 = I7 >>> 0 < L4 >>> 0 ? x4 + 1 | 0 : x4, L4 = qA(o4, C4, k4, X4), J4 = h3 + x4 | 0, x4 = I7 = L4 + I7 | 0, J4 = (I7 = I7 >>> 0 < L4 >>> 0 ? J4 + 1 | 0 : J4) + (J4 = K4 >> 26) | 0, I7 = J4 = (x4 = (K4 = (67108863 & K4) << 6 | z4 >>> 26) + x4 | 0) >>> 0 < K4 >>> 0 ? J4 + 1 | 0 : J4, I7 = (J4 = x4 + 16777216 | 0) >>> 0 < 16777216 ? I7 + 1 | 0 : I7, K4 = -33554432 & J4, i3[A8 + 36 >> 2] = x4 - K4, L4 = qA((33554431 & I7) << 7 | J4 >>> 25, I7 >> 25, 19, 0), J4 = h3 + (j4 - (((x4 = -67108864 & Z4) >>> 0 > T4 >>> 0) + $4 | 0) | 0) | 0, x4 = I7 = L4 + (T4 - x4 | 0) | 0, I7 = I7 >>> 0 < L4 >>> 0 ? J4 + 1 | 0 : J4, I7 = (O4 - (-33554432 & CA2) | 0) + ((67108863 & (I7 = (J4 = x4 + 33554432 | 0) >>> 0 < 33554432 ? I7 + 1 | 0 : I7)) << 6 | J4 >>> 26) | 0, i3[A8 + 4 >> 2] = I7, I7 = A8, A8 = -67108864 & J4, i3[I7 >> 2] = x4 - A8;
                      }
                      function S3(A8, I7, g6) {
                        var B4, C4 = 0, Q4 = 0, E4 = 0, n4 = 0, a4 = 0, r4 = 0, o4 = 0, t4 = 0, e4 = 0, f4 = 0, c4 = 0, y4 = 0, w4 = 0, D4 = 0, p4 = 0, u4 = 0, F4 = 0, l4 = 0, _4 = 0, k4 = 0, H4 = 0, G4 = 0, U4 = 0, S4 = 0, b4 = 0, m4 = 0, v4 = 0, M4 = 0, P4 = 0, Y4 = 0, N4 = 0, R4 = 0, d4 = 0, J4 = 0, x4 = 0, L4 = 0, K4 = 0, X4 = 0;
                        for (s3 = B4 = s3 - 2048 | 0, yg(w4 = B4 + 1024 | 0, I7), AI(w4, A8), yg(B4, w4), AI(B4, g6), I7 = 0, w4 = 0; r4 = i3[(f4 = (A8 = (B4 + 1024 | 0) + (w4 << 7) | 0) - -64 | 0) >> 2], Q4 = i3[A8 + 100 >> 2], a4 = r4, t4 = i3[f4 + 4 >> 2], o4 = i3[A8 + 96 >> 2], r4 = i3[A8 + 32 >> 2], E4 = i3[A8 + 36 >> 2], n4 = pA(o4 ^ (C4 = CI(i3[A8 >> 2], i3[A8 + 4 >> 2], r4, E4)), (n4 = Q4) ^ (Q4 = h3), 32), E4 = pA(t4 = (a4 = CI(a4, t4, n4, o4 = h3)) ^ r4, E4 ^ (r4 = h3), 24), t4 = r4, U4 = pA((p4 = CI(C4, Q4, E4, r4 = h3)) ^ n4, (D4 = h3) ^ o4, 16), r4 = pA(E4 ^ (b4 = CI(a4, t4, U4, S4 = h3)), (R4 = h3) ^ r4, 63), Q4 = h3, E4 = i3[A8 + 108 >> 2], t4 = i3[A8 + 72 >> 2], y4 = i3[A8 + 76 >> 2], c4 = i3[A8 + 104 >> 2], C4 = i3[A8 + 40 >> 2], n4 = i3[A8 + 44 >> 2], a4 = pA(c4 ^ (o4 = CI(i3[A8 + 8 >> 2], i3[A8 + 12 >> 2], C4, n4)), (a4 = E4) ^ (E4 = h3), 32), n4 = pA(t4 = (m4 = CI(t4, y4, a4, e4 = h3)) ^ C4, n4 ^ (C4 = h3), 24), t4 = m4, J4 = pA((m4 = CI(o4, y4 = E4, n4, E4 = h3)) ^ a4, (d4 = h3) ^ e4, 16), E4 = pA(n4 ^ (v4 = CI(t4, C4, J4, x4 = h3)), (M4 = h3) ^ E4, 63), C4 = h3, n4 = i3[A8 + 116 >> 2], c4 = i3[A8 + 80 >> 2], u4 = i3[A8 + 84 >> 2], y4 = i3[A8 + 112 >> 2], o4 = i3[A8 + 48 >> 2], a4 = i3[A8 + 52 >> 2], y4 = pA(y4 ^ (e4 = CI(i3[A8 + 16 >> 2], i3[A8 + 20 >> 2], o4, a4)), (t4 = n4) ^ (n4 = h3), 32), a4 = pA(t4 = (c4 = CI(c4, u4, y4, P4 = h3)) ^ o4, a4 ^ (o4 = h3), 24), t4 = c4, c4 = pA((c4 = y4) ^ (y4 = CI(e4, y4 = n4, a4, n4 = h3)), (e4 = P4) ^ (P4 = h3), 16), n4 = pA(a4 ^ (t4 = CI(t4, o4, c4, Y4 = h3)), (k4 = h3) ^ n4, 63), o4 = h3, a4 = i3[A8 + 124 >> 2], H4 = i3[A8 + 88 >> 2], N4 = i3[A8 + 92 >> 2], F4 = i3[A8 + 120 >> 2], e4 = i3[A8 + 56 >> 2], u4 = i3[A8 + 60 >> 2], F4 = pA(F4 ^ (l4 = CI(i3[A8 + 24 >> 2], i3[A8 + 28 >> 2], e4, u4)), (_4 = a4) ^ (a4 = h3), 32), _4 = u4 = pA(_4 = (N4 = CI(H4, N4, F4, G4 = h3)) ^ e4, u4 ^ (e4 = h3), 24), F4 = pA((u4 = CI(l4, H4 = a4, u4, a4 = h3)) ^ F4, (l4 = h3) ^ G4, 16), a4 = pA(_4 ^ (N4 = CI(N4, e4, F4, G4 = h3)), (L4 = h3) ^ a4, 63), e4 = h3, _4 = t4, H4 = k4, t4 = pA(F4 ^ (p4 = CI(p4, D4, E4, C4)), G4 ^ (D4 = h3), 32), E4 = pA((F4 = CI(_4, H4, t4, k4 = h3)) ^ E4, (G4 = h3) ^ C4, 24), C4 = CI(C4 = p4, D4, E4, p4 = h3), i3[A8 >> 2] = C4, D4 = h3, i3[A8 + 4 >> 2] = D4, C4 = pA(C4 ^ t4, D4 ^ k4, 16), i3[A8 + 120 >> 2] = C4, D4 = h3, i3[A8 + 124 >> 2] = D4, C4 = CI(F4, G4, C4, D4), i3[A8 + 80 >> 2] = C4, D4 = h3, i3[A8 + 84 >> 2] = D4, K4 = A8, X4 = pA(C4 ^ E4, D4 ^ p4, 63), i3[K4 + 40 >> 2] = X4, i3[A8 + 44 >> 2] = h3, E4 = n4, p4 = pA(U4 ^ (C4 = CI(m4, d4, n4, o4)), S4 ^ (n4 = h3), 32), E4 = pA(E4 ^ (U4 = CI(N4, L4, p4, D4 = h3)), (t4 = o4) ^ (o4 = h3), 24), C4 = CI(C4, t4 = n4, E4, n4 = h3), i3[A8 + 8 >> 2] = C4, S4 = h3, i3[A8 + 12 >> 2] = S4, C4 = pA(C4 ^ p4, D4 ^ S4, 16), i3[A8 + 96 >> 2] = C4, p4 = h3, i3[A8 + 100 >> 2] = p4, C4 = CI(U4, o4, C4, p4), i3[A8 + 88 >> 2] = C4, o4 = h3, i3[A8 + 92 >> 2] = o4, K4 = A8, X4 = pA(C4 ^ E4, n4 ^ o4, 63), i3[K4 + 48 >> 2] = X4, i3[A8 + 52 >> 2] = h3, E4 = a4, o4 = pA(J4 ^ (C4 = CI(y4, P4, a4, e4)), x4 ^ (n4 = h3), 32), E4 = pA(E4 ^ (p4 = CI(b4, R4, o4, a4 = h3)), (t4 = e4) ^ (e4 = h3), 24), C4 = CI(C4, t4 = n4, E4, n4 = h3), i3[A8 + 16 >> 2] = C4, D4 = h3, i3[A8 + 20 >> 2] = D4, C4 = pA(C4 ^ o4, a4 ^ D4, 16), i3[A8 + 104 >> 2] = C4, o4 = h3, i3[A8 + 108 >> 2] = o4, C4 = CI(p4, e4, C4, o4), i3[f4 >> 2] = C4, a4 = f4, f4 = h3, i3[a4 + 4 >> 2] = f4, K4 = A8, X4 = pA(C4 ^ E4, n4 ^ f4, 63), i3[K4 + 56 >> 2] = X4, i3[A8 + 60 >> 2] = h3, a4 = r4, C4 = pA(c4 ^ (r4 = CI(u4, l4, r4, Q4)), Y4 ^ (E4 = h3), 32), f4 = pA(a4 ^ (o4 = CI(v4, M4, C4, n4 = h3)), (f4 = Q4) ^ (Q4 = h3), 24), r4 = CI(r4, a4 = E4, f4, E4 = h3), i3[A8 + 24 >> 2] = r4, a4 = h3, i3[A8 + 28 >> 2] = a4, r4 = pA(C4 ^ r4, n4 ^ a4, 16), i3[A8 + 112 >> 2] = r4, C4 = h3, i3[A8 + 116 >> 2] = C4, r4 = CI(o4, Q4, r4, C4), i3[A8 + 72 >> 2] = r4, Q4 = h3, i3[A8 + 76 >> 2] = Q4, K4 = A8, X4 = pA(r4 ^ f4, E4 ^ Q4, 63), i3[K4 + 32 >> 2] = X4, i3[A8 + 36 >> 2] = h3, (0 | (w4 = w4 + 1 | 0)) != 8; )
                          ;
                        for (; f4 = i3[(w4 = 512 + (A8 = (B4 + 1024 | 0) + (I7 << 4) | 0) | 0) >> 2], r4 = i3[A8 + 772 >> 2], n4 = f4, a4 = i3[w4 + 4 >> 2], o4 = i3[A8 + 768 >> 2], w4 = i3[A8 + 256 >> 2], f4 = i3[A8 + 260 >> 2], E4 = pA(o4 ^ (Q4 = CI(i3[A8 >> 2], i3[A8 + 4 >> 2], w4, f4)), (E4 = r4) ^ (r4 = h3), 32), f4 = pA(a4 = (n4 = CI(n4, a4, E4, C4 = h3)) ^ w4, f4 ^ (w4 = h3), 24), o4 = w4, p4 = pA((a4 = CI(Q4, r4, f4, w4 = h3)) ^ E4, (e4 = h3) ^ C4, 16), w4 = pA(f4 ^ (U4 = CI(n4, o4, p4, D4 = h3)), (S4 = h3) ^ w4, 63), f4 = h3, r4 = i3[A8 + 780 >> 2], t4 = i3[A8 + 520 >> 2], y4 = i3[A8 + 524 >> 2], o4 = i3[A8 + 776 >> 2], Q4 = i3[A8 + 264 >> 2], E4 = i3[A8 + 268 >> 2], n4 = pA(o4 ^ (C4 = CI(i3[A8 + 8 >> 2], i3[A8 + 12 >> 2], Q4, E4)), (n4 = r4) ^ (r4 = h3), 32), E4 = pA(t4 = (b4 = CI(t4, y4, n4, o4 = h3)) ^ Q4, E4 ^ (Q4 = h3), 24), t4 = b4, m4 = pA((b4 = CI(C4, y4 = r4, E4, r4 = h3)) ^ n4, (R4 = h3) ^ o4, 16), r4 = pA(E4 ^ (J4 = CI(t4, Q4, m4, d4 = h3)), (x4 = h3) ^ r4, 63), Q4 = h3, E4 = i3[A8 + 900 >> 2], y4 = i3[A8 + 640 >> 2], c4 = i3[A8 + 644 >> 2], u4 = i3[A8 + 896 >> 2], C4 = i3[A8 + 384 >> 2], n4 = i3[A8 + 388 >> 2], v4 = pA(u4 ^ (o4 = CI(i3[A8 + 128 >> 2], i3[A8 + 132 >> 2], C4, n4)), (t4 = E4) ^ (E4 = h3), 32), n4 = pA(t4 = (y4 = CI(y4, c4, v4, M4 = h3)) ^ C4, n4 ^ (C4 = h3), 24), t4 = y4, y4 = pA((y4 = v4) ^ (v4 = CI(o4, c4 = E4, n4, E4 = h3)), (o4 = M4) ^ (M4 = h3), 16), E4 = pA(n4 ^ (c4 = CI(t4, C4, y4, P4 = h3)), (Y4 = h3) ^ E4, 63), C4 = h3, n4 = i3[A8 + 908 >> 2], _4 = i3[A8 + 648 >> 2], H4 = i3[A8 + 652 >> 2], l4 = i3[A8 + 904 >> 2], o4 = i3[A8 + 392 >> 2], t4 = i3[A8 + 396 >> 2], u4 = pA(l4 ^ (k4 = CI(i3[A8 + 136 >> 2], i3[A8 + 140 >> 2], o4, t4)), (u4 = n4) ^ (n4 = h3), 32), _4 = t4 = pA(_4 = (F4 = CI(_4, H4, u4, l4 = h3)) ^ o4, t4 ^ (o4 = h3), 24), u4 = pA((t4 = CI(k4, H4 = n4, t4, n4 = h3)) ^ u4, (k4 = h3) ^ l4, 16), n4 = pA(_4 ^ (F4 = CI(F4, o4, u4, l4 = h3)), (G4 = h3) ^ n4, 63), o4 = h3, _4 = c4, H4 = Y4, c4 = pA(u4 ^ (a4 = CI(a4, e4, r4, Q4)), l4 ^ (e4 = h3), 32), r4 = pA((u4 = CI(_4, H4, c4, Y4 = h3)) ^ r4, (l4 = h3) ^ Q4, 24), Q4 = CI(Q4 = a4, e4, r4, a4 = h3), i3[A8 >> 2] = Q4, e4 = h3, i3[A8 + 4 >> 2] = e4, Q4 = pA(Q4 ^ c4, e4 ^ Y4, 16), i3[A8 + 904 >> 2] = Q4, e4 = h3, i3[A8 + 908 >> 2] = e4, Q4 = CI(u4, l4, Q4, e4), i3[A8 + 640 >> 2] = Q4, e4 = h3, i3[A8 + 644 >> 2] = e4, K4 = A8, X4 = pA(Q4 ^ r4, a4 ^ e4, 63), i3[K4 + 264 >> 2] = X4, i3[A8 + 268 >> 2] = h3, r4 = E4, a4 = pA(p4 ^ (Q4 = CI(b4, R4, E4, C4)), D4 ^ (E4 = h3), 32), r4 = pA(r4 ^ (p4 = CI(F4, G4, a4, e4 = h3)), (c4 = C4) ^ (C4 = h3), 24), Q4 = CI(Q4, c4 = E4, r4, E4 = h3), i3[A8 + 8 >> 2] = Q4, D4 = h3, i3[A8 + 12 >> 2] = D4, Q4 = pA(Q4 ^ a4, e4 ^ D4, 16), i3[A8 + 768 >> 2] = Q4, a4 = h3, i3[A8 + 772 >> 2] = a4, Q4 = CI(p4, C4, Q4, a4), i3[A8 + 648 >> 2] = Q4, C4 = h3, i3[A8 + 652 >> 2] = C4, K4 = A8, X4 = pA(Q4 ^ r4, C4 ^ E4, 63), i3[K4 + 384 >> 2] = X4, i3[A8 + 388 >> 2] = h3, r4 = n4, C4 = pA(m4 ^ (Q4 = CI(v4, M4, n4, o4)), d4 ^ (E4 = h3), 32), r4 = pA(r4 ^ (a4 = CI(U4, S4, C4, n4 = h3)), (c4 = o4) ^ (o4 = h3), 24), Q4 = CI(Q4, c4 = E4, r4, E4 = h3), i3[A8 + 128 >> 2] = Q4, e4 = h3, i3[A8 + 132 >> 2] = e4, Q4 = pA(C4 ^ Q4, n4 ^ e4, 16), i3[A8 + 776 >> 2] = Q4, C4 = h3, i3[A8 + 780 >> 2] = C4, Q4 = CI(a4, o4, Q4, C4), i3[A8 + 512 >> 2] = Q4, C4 = h3, i3[A8 + 516 >> 2] = C4, K4 = A8, X4 = pA(Q4 ^ r4, C4 ^ E4, 63), i3[K4 + 392 >> 2] = X4, i3[A8 + 396 >> 2] = h3, r4 = CI(t4, k4, w4, f4), n4 = CI(J4, x4, E4 = pA(y4 ^ r4, P4 ^ (Q4 = h3), 32), C4 = h3), f4 = CI(a4 = r4, Q4, w4 = pA(n4 ^ w4, (o4 = h3) ^ f4, 24), r4 = h3), i3[A8 + 136 >> 2] = f4, Q4 = h3, i3[A8 + 140 >> 2] = Q4, f4 = pA(E4 ^ f4, C4 ^ Q4, 16), i3[A8 + 896 >> 2] = f4, Q4 = h3, i3[A8 + 900 >> 2] = Q4, f4 = CI(n4, o4, f4, Q4), i3[A8 + 520 >> 2] = f4, Q4 = h3, i3[A8 + 524 >> 2] = Q4, K4 = A8, X4 = pA(f4 ^ w4, Q4 ^ r4, 63), i3[K4 + 256 >> 2] = X4, i3[A8 + 260 >> 2] = h3, (0 | (I7 = I7 + 1 | 0)) != 8; )
                          ;
                        yg(g6, B4), AI(g6, B4 + 1024 | 0), s3 = B4 + 2048 | 0;
                      }
                      function b3(A8) {
                        var I7 = 0, g6 = 0, B4 = 0, C4 = 0, Q4 = 0, E4 = 0, n4 = 0, r4 = 0, o4 = 0;
                        A:
                          if (A8 |= 0) {
                            Q4 = (B4 = A8 - 8 | 0) + (A8 = -8 & (I7 = i3[A8 - 4 >> 2])) | 0;
                            I:
                              if (!(1 & I7)) {
                                if (!(3 & I7))
                                  break A;
                                if ((B4 = B4 - (I7 = i3[B4 >> 2]) | 0) >>> 0 < a3[8969])
                                  break A;
                                if (A8 = A8 + I7 | 0, i3[8970] == (0 | B4)) {
                                  if ((3 & (I7 = i3[Q4 + 4 >> 2])) == 3)
                                    return i3[8967] = A8, i3[Q4 + 4 >> 2] = -2 & I7, i3[B4 + 4 >> 2] = 1 | A8, void (i3[A8 + B4 >> 2] = A8);
                                } else {
                                  if (I7 >>> 0 <= 255) {
                                    if (C4 = i3[B4 + 8 >> 2], I7 = I7 >>> 3 | 0, (0 | (g6 = i3[B4 + 12 >> 2])) == (0 | C4)) {
                                      r4 = 35860, o4 = i3[8965] & lI(-2, I7), i3[r4 >> 2] = o4;
                                      break I;
                                    }
                                    i3[C4 + 12 >> 2] = g6, i3[g6 + 8 >> 2] = C4;
                                    break I;
                                  }
                                  if (n4 = i3[B4 + 24 >> 2], (0 | B4) == (0 | (I7 = i3[B4 + 12 >> 2])))
                                    if ((g6 = i3[(C4 = B4 + 20 | 0) >> 2]) || (g6 = i3[(C4 = B4 + 16 | 0) >> 2])) {
                                      for (; E4 = C4, (g6 = i3[(C4 = (I7 = g6) + 20 | 0) >> 2]) || (C4 = I7 + 16 | 0, g6 = i3[I7 + 16 >> 2]); )
                                        ;
                                      i3[E4 >> 2] = 0;
                                    } else
                                      I7 = 0;
                                  else
                                    g6 = i3[B4 + 8 >> 2], i3[g6 + 12 >> 2] = I7, i3[I7 + 8 >> 2] = g6;
                                  if (!n4)
                                    break I;
                                  C4 = i3[B4 + 28 >> 2];
                                  g: {
                                    if (i3[(g6 = 36164 + (C4 << 2) | 0) >> 2] == (0 | B4)) {
                                      if (i3[g6 >> 2] = I7, I7)
                                        break g;
                                      r4 = 35864, o4 = i3[8966] & lI(-2, C4), i3[r4 >> 2] = o4;
                                      break I;
                                    }
                                    if (i3[n4 + (i3[n4 + 16 >> 2] == (0 | B4) ? 16 : 20) >> 2] = I7, !I7)
                                      break I;
                                  }
                                  if (i3[I7 + 24 >> 2] = n4, (g6 = i3[B4 + 16 >> 2]) && (i3[I7 + 16 >> 2] = g6, i3[g6 + 24 >> 2] = I7), !(g6 = i3[B4 + 20 >> 2]))
                                    break I;
                                  i3[I7 + 20 >> 2] = g6, i3[g6 + 24 >> 2] = I7;
                                }
                              }
                            if (!(B4 >>> 0 >= Q4 >>> 0) && 1 & (I7 = i3[Q4 + 4 >> 2])) {
                              I: {
                                if (!(2 & I7)) {
                                  if (i3[8971] == (0 | Q4)) {
                                    if (i3[8971] = B4, A8 = i3[8968] + A8 | 0, i3[8968] = A8, i3[B4 + 4 >> 2] = 1 | A8, i3[8970] != (0 | B4))
                                      break A;
                                    return i3[8967] = 0, void (i3[8970] = 0);
                                  }
                                  if (i3[8970] == (0 | Q4))
                                    return i3[8970] = B4, A8 = i3[8967] + A8 | 0, i3[8967] = A8, i3[B4 + 4 >> 2] = 1 | A8, void (i3[A8 + B4 >> 2] = A8);
                                  A8 = (-8 & I7) + A8 | 0;
                                  g:
                                    if (I7 >>> 0 <= 255) {
                                      if (C4 = i3[Q4 + 8 >> 2], I7 = I7 >>> 3 | 0, (0 | (g6 = i3[Q4 + 12 >> 2])) == (0 | C4)) {
                                        r4 = 35860, o4 = i3[8965] & lI(-2, I7), i3[r4 >> 2] = o4;
                                        break g;
                                      }
                                      i3[C4 + 12 >> 2] = g6, i3[g6 + 8 >> 2] = C4;
                                    } else {
                                      if (n4 = i3[Q4 + 24 >> 2], (0 | Q4) == (0 | (I7 = i3[Q4 + 12 >> 2])))
                                        if ((g6 = i3[(C4 = Q4 + 20 | 0) >> 2]) || (g6 = i3[(C4 = Q4 + 16 | 0) >> 2])) {
                                          for (; E4 = C4, (g6 = i3[(C4 = (I7 = g6) + 20 | 0) >> 2]) || (C4 = I7 + 16 | 0, g6 = i3[I7 + 16 >> 2]); )
                                            ;
                                          i3[E4 >> 2] = 0;
                                        } else
                                          I7 = 0;
                                      else
                                        g6 = i3[Q4 + 8 >> 2], i3[g6 + 12 >> 2] = I7, i3[I7 + 8 >> 2] = g6;
                                      if (n4) {
                                        C4 = i3[Q4 + 28 >> 2];
                                        B: {
                                          if (i3[(g6 = 36164 + (C4 << 2) | 0) >> 2] == (0 | Q4)) {
                                            if (i3[g6 >> 2] = I7, I7)
                                              break B;
                                            r4 = 35864, o4 = i3[8966] & lI(-2, C4), i3[r4 >> 2] = o4;
                                            break g;
                                          }
                                          if (i3[n4 + (i3[n4 + 16 >> 2] == (0 | Q4) ? 16 : 20) >> 2] = I7, !I7)
                                            break g;
                                        }
                                        i3[I7 + 24 >> 2] = n4, (g6 = i3[Q4 + 16 >> 2]) && (i3[I7 + 16 >> 2] = g6, i3[g6 + 24 >> 2] = I7), (g6 = i3[Q4 + 20 >> 2]) && (i3[I7 + 20 >> 2] = g6, i3[g6 + 24 >> 2] = I7);
                                      }
                                    }
                                  if (i3[B4 + 4 >> 2] = 1 | A8, i3[A8 + B4 >> 2] = A8, i3[8970] != (0 | B4))
                                    break I;
                                  return void (i3[8967] = A8);
                                }
                                i3[Q4 + 4 >> 2] = -2 & I7, i3[B4 + 4 >> 2] = 1 | A8, i3[A8 + B4 >> 2] = A8;
                              }
                              if (A8 >>> 0 <= 255)
                                return I7 = 35900 + ((A8 = A8 >>> 3 | 0) << 3) | 0, (g6 = i3[8965]) & (A8 = 1 << A8) ? A8 = i3[I7 + 8 >> 2] : (i3[8965] = A8 | g6, A8 = I7), i3[I7 + 8 >> 2] = B4, i3[A8 + 12 >> 2] = B4, i3[B4 + 12 >> 2] = I7, void (i3[B4 + 8 >> 2] = A8);
                              C4 = 31, i3[B4 + 16 >> 2] = 0, i3[B4 + 20 >> 2] = 0, A8 >>> 0 <= 16777215 && (I7 = A8 >>> 8 | 0, I7 <<= E4 = I7 + 1048320 >>> 16 & 8, C4 = 28 + ((I7 = ((I7 <<= C4 = I7 + 520192 >>> 16 & 4) << (g6 = I7 + 245760 >>> 16 & 2) >>> 15 | 0) - (g6 | C4 | E4) | 0) << 1 | A8 >>> I7 + 21 & 1) | 0), i3[B4 + 28 >> 2] = C4, E4 = 36164 + (C4 << 2) | 0;
                              I: {
                                g: {
                                  if ((g6 = i3[8966]) & (I7 = 1 << C4)) {
                                    for (C4 = A8 << ((0 | C4) == 31 ? 0 : 25 - (C4 >>> 1 | 0) | 0), I7 = i3[E4 >> 2]; ; ) {
                                      if (g6 = I7, (-8 & i3[I7 + 4 >> 2]) == (0 | A8))
                                        break g;
                                      if (I7 = C4 >>> 29 | 0, C4 <<= 1, !(I7 = i3[16 + (E4 = g6 + (4 & I7) | 0) >> 2]))
                                        break;
                                    }
                                    i3[E4 + 16 >> 2] = B4, i3[B4 + 24 >> 2] = g6;
                                  } else
                                    i3[8966] = I7 | g6, i3[E4 >> 2] = B4, i3[B4 + 24 >> 2] = E4;
                                  i3[B4 + 12 >> 2] = B4, i3[B4 + 8 >> 2] = B4;
                                  break I;
                                }
                                A8 = i3[g6 + 8 >> 2], i3[A8 + 12 >> 2] = B4, i3[g6 + 8 >> 2] = B4, i3[B4 + 24 >> 2] = 0, i3[B4 + 12 >> 2] = g6, i3[B4 + 8 >> 2] = A8;
                              }
                              A8 = i3[8973] - 1 | 0, i3[8973] = A8 || -1;
                            }
                          }
                      }
                      function m3(A8, I7, g6, B4, C4) {
                        var E4, a4, r4, o4, t4, e4, f4, c4, y4, w4, D4, h4, p4, u4, F4, l4 = 0, _4 = 0, k4 = 0, H4 = 0, G4 = 0, U4 = 0, S4 = 0, b4 = 0, m4 = 0, v4 = 0, M4 = 0, P4 = 0, Y4 = 0, N4 = 0, R4 = 0, d4 = 0, J4 = 0, x4 = 0, L4 = 0, K4 = 0, X4 = 0, T4 = 0, V4 = 0, q4 = 0, z4 = 0, j4 = 0, W4 = 0, O4 = 0, Z4 = 0, $4 = 0, AA4 = 0, IA4 = 0, gA3 = 0, BA3 = 0;
                        for (s3 = E4 = s3 + -64 | 0, a4 = i3[A8 + 60 >> 2], r4 = i3[A8 + 56 >> 2], L4 = i3[A8 + 52 >> 2], J4 = i3[A8 + 48 >> 2], o4 = i3[A8 + 44 >> 2], t4 = i3[A8 + 40 >> 2], e4 = i3[A8 + 36 >> 2], f4 = i3[A8 + 32 >> 2], c4 = i3[A8 + 28 >> 2], y4 = i3[A8 + 24 >> 2], w4 = i3[A8 + 20 >> 2], D4 = i3[A8 + 16 >> 2], h4 = i3[A8 + 12 >> 2], p4 = i3[A8 + 8 >> 2], u4 = i3[A8 + 4 >> 2], F4 = i3[A8 >> 2]; ; ) {
                          if (!C4 & B4 >>> 0 > 63 | C4)
                            _4 = g6;
                          else {
                            if (H4 = 0, _4 = wI(E4, 0, 64), B4 | C4)
                              for (; Q3[_4 + H4 | 0] = n3[I7 + H4 | 0], !C4 & (H4 = H4 + 1 | 0) >>> 0 < B4 >>> 0 | C4; )
                                ;
                            I7 = _4, T4 = g6;
                          }
                          for (K4 = 20, b4 = F4, m4 = u4, v4 = p4, M4 = h4, H4 = D4, G4 = w4, g6 = y4, P4 = c4, U4 = f4, S4 = e4, Y4 = t4, N4 = a4, d4 = r4, l4 = L4, k4 = J4, x4 = o4; R4 = H4, b4 = cg((H4 = H4 + b4 | 0) ^ k4, 16), k4 = cg(R4 ^ (U4 = b4 + U4 | 0), 12), R4 = U4, U4 = cg((U4 = b4) ^ (b4 = H4 + k4 | 0), 8), H4 = cg(k4 ^ (R4 = R4 + U4 | 0), 7), k4 = G4, m4 = cg((G4 = G4 + m4 | 0) ^ l4, 16), l4 = cg(k4 ^ (S4 = m4 + S4 | 0), 12), k4 = S4, S4 = cg((S4 = m4) ^ (m4 = G4 + l4 | 0), 8), G4 = cg(l4 ^ (X4 = k4 + S4 | 0), 7), l4 = g6, v4 = cg((g6 = g6 + v4 | 0) ^ d4, 16), l4 = d4 = cg(l4 ^ (Y4 = v4 + Y4 | 0), 12), d4 = cg((k4 = v4) ^ (v4 = g6 + d4 | 0), 8), g6 = cg(l4 ^ (Y4 = d4 + Y4 | 0), 7), l4 = P4, M4 = cg((P4 = P4 + M4 | 0) ^ N4, 16), k4 = l4 = cg(l4 ^ (N4 = M4 + x4 | 0), 12), x4 = N4, N4 = cg((N4 = M4) ^ (M4 = P4 + l4 | 0), 8), P4 = cg(k4 ^ (l4 = x4 + N4 | 0), 7), k4 = Y4, Y4 = cg((b4 = G4 + b4 | 0) ^ N4, 16), G4 = cg((k4 = k4 + Y4 | 0) ^ G4, 12), N4 = cg(Y4 ^ (b4 = G4 + b4 | 0), 8), G4 = cg(G4 ^ (Y4 = k4 + N4 | 0), 7), U4 = cg((m4 = g6 + m4 | 0) ^ U4, 16), g6 = cg((l4 = U4 + l4 | 0) ^ g6, 12), k4 = cg(U4 ^ (m4 = g6 + m4 | 0), 8), g6 = cg(g6 ^ (x4 = l4 + k4 | 0), 7), U4 = cg((v4 = P4 + v4 | 0) ^ S4, 16), P4 = cg((S4 = U4 + R4 | 0) ^ P4, 12), l4 = cg(U4 ^ (v4 = P4 + v4 | 0), 8), P4 = cg(P4 ^ (U4 = S4 + l4 | 0), 7), S4 = cg((M4 = H4 + M4 | 0) ^ d4, 16), H4 = cg((R4 = S4 + X4 | 0) ^ H4, 12), d4 = cg(S4 ^ (M4 = H4 + M4 | 0), 8), H4 = cg(H4 ^ (S4 = R4 + d4 | 0), 7), K4 = K4 - 2 | 0; )
                            ;
                          if (K4 = n3[I7 + 4 | 0] | n3[I7 + 5 | 0] << 8 | n3[I7 + 6 | 0] << 16 | n3[I7 + 7 | 0] << 24, R4 = n3[I7 + 8 | 0] | n3[I7 + 9 | 0] << 8 | n3[I7 + 10 | 0] << 16 | n3[I7 + 11 | 0] << 24, X4 = n3[I7 + 12 | 0] | n3[I7 + 13 | 0] << 8 | n3[I7 + 14 | 0] << 16 | n3[I7 + 15 | 0] << 24, V4 = n3[I7 + 16 | 0] | n3[I7 + 17 | 0] << 8 | n3[I7 + 18 | 0] << 16 | n3[I7 + 19 | 0] << 24, q4 = n3[I7 + 20 | 0] | n3[I7 + 21 | 0] << 8 | n3[I7 + 22 | 0] << 16 | n3[I7 + 23 | 0] << 24, z4 = n3[I7 + 24 | 0] | n3[I7 + 25 | 0] << 8 | n3[I7 + 26 | 0] << 16 | n3[I7 + 27 | 0] << 24, j4 = n3[I7 + 28 | 0] | n3[I7 + 29 | 0] << 8 | n3[I7 + 30 | 0] << 16 | n3[I7 + 31 | 0] << 24, W4 = n3[I7 + 32 | 0] | n3[I7 + 33 | 0] << 8 | n3[I7 + 34 | 0] << 16 | n3[I7 + 35 | 0] << 24, O4 = n3[I7 + 36 | 0] | n3[I7 + 37 | 0] << 8 | n3[I7 + 38 | 0] << 16 | n3[I7 + 39 | 0] << 24, Z4 = n3[I7 + 40 | 0] | n3[I7 + 41 | 0] << 8 | n3[I7 + 42 | 0] << 16 | n3[I7 + 43 | 0] << 24, $4 = n3[I7 + 44 | 0] | n3[I7 + 45 | 0] << 8 | n3[I7 + 46 | 0] << 16 | n3[I7 + 47 | 0] << 24, AA4 = n3[I7 + 48 | 0] | n3[I7 + 49 | 0] << 8 | n3[I7 + 50 | 0] << 16 | n3[I7 + 51 | 0] << 24, IA4 = n3[I7 + 52 | 0] | n3[I7 + 53 | 0] << 8 | n3[I7 + 54 | 0] << 16 | n3[I7 + 55 | 0] << 24, gA3 = n3[I7 + 56 | 0] | n3[I7 + 57 | 0] << 8 | n3[I7 + 58 | 0] << 16 | n3[I7 + 59 | 0] << 24, BA3 = n3[I7 + 60 | 0] | n3[I7 + 61 | 0] << 8 | n3[I7 + 62 | 0] << 16 | n3[I7 + 63 | 0] << 24, bI(_4, b4 + F4 ^ (n3[0 | I7] | n3[I7 + 1 | 0] << 8 | n3[I7 + 2 | 0] << 16 | n3[I7 + 3 | 0] << 24)), bI(_4 + 4 | 0, m4 + u4 ^ K4), bI(_4 + 8 | 0, v4 + p4 ^ R4), bI(_4 + 12 | 0, M4 + h4 ^ X4), bI(_4 + 16 | 0, H4 + D4 ^ V4), bI(_4 + 20 | 0, G4 + w4 ^ q4), bI(_4 + 24 | 0, g6 + y4 ^ z4), bI(_4 + 28 | 0, P4 + c4 ^ j4), bI(_4 + 32 | 0, U4 + f4 ^ W4), bI(_4 + 36 | 0, S4 + e4 ^ O4), bI(_4 + 40 | 0, Z4 ^ Y4 + t4), bI(_4 + 44 | 0, $4 ^ x4 + o4), bI(_4 + 48 | 0, AA4 ^ k4 + J4), bI(_4 + 52 | 0, IA4 ^ l4 + L4), bI(_4 + 56 | 0, gA3 ^ d4 + r4), bI(_4 + 60 | 0, BA3 ^ N4 + a4), L4 = ((J4 = (g6 = J4) + 1 | 0) >>> 0 < g6 >>> 0) + L4 | 0, !C4 & B4 >>> 0 <= 64) {
                            if (!(!B4 | !C4 & B4 >>> 0 > 63 | (0 | C4) != 0))
                              for (G4 = 0; Q3[G4 + T4 | 0] = n3[_4 + G4 | 0], (0 | B4) != (0 | (G4 = G4 + 1 | 0)); )
                                ;
                            i3[A8 + 52 >> 2] = L4, i3[A8 + 48 >> 2] = J4, s3 = E4 - -64 | 0;
                            break;
                          }
                          I7 = I7 - -64 | 0, g6 = _4 - -64 | 0, C4 = C4 - 1 | 0, C4 = (B4 = B4 + -64 | 0) >>> 0 < 4294967232 ? C4 + 1 | 0 : C4;
                        }
                      }
                      function v3(A8, I7) {
                        var g6, B4 = 0, C4 = 0, Q4 = 0, E4 = 0, n4 = 0, a4 = 0, r4 = 0;
                        g6 = A8 + I7 | 0;
                        A: {
                          I:
                            if (!(1 & (B4 = i3[A8 + 4 >> 2]))) {
                              if (!(3 & B4))
                                break A;
                              I7 = (B4 = i3[A8 >> 2]) + I7 | 0;
                              g: {
                                if ((0 | (A8 = A8 - B4 | 0)) != i3[8970]) {
                                  if (B4 >>> 0 <= 255) {
                                    if (Q4 = i3[A8 + 8 >> 2], B4 = B4 >>> 3 | 0, (0 | (C4 = i3[A8 + 12 >> 2])) != (0 | Q4))
                                      break g;
                                    a4 = 35860, r4 = i3[8965] & lI(-2, B4), i3[a4 >> 2] = r4;
                                    break I;
                                  }
                                  if (n4 = i3[A8 + 24 >> 2], (0 | (B4 = i3[A8 + 12 >> 2])) == (0 | A8))
                                    if ((C4 = i3[(Q4 = A8 + 20 | 0) >> 2]) || (C4 = i3[(Q4 = A8 + 16 | 0) >> 2])) {
                                      for (; E4 = Q4, (C4 = i3[(Q4 = (B4 = C4) + 20 | 0) >> 2]) || (Q4 = B4 + 16 | 0, C4 = i3[B4 + 16 >> 2]); )
                                        ;
                                      i3[E4 >> 2] = 0;
                                    } else
                                      B4 = 0;
                                  else
                                    C4 = i3[A8 + 8 >> 2], i3[C4 + 12 >> 2] = B4, i3[B4 + 8 >> 2] = C4;
                                  if (!n4)
                                    break I;
                                  Q4 = i3[A8 + 28 >> 2];
                                  B: {
                                    if (i3[(C4 = 36164 + (Q4 << 2) | 0) >> 2] == (0 | A8)) {
                                      if (i3[C4 >> 2] = B4, B4)
                                        break B;
                                      a4 = 35864, r4 = i3[8966] & lI(-2, Q4), i3[a4 >> 2] = r4;
                                      break I;
                                    }
                                    if (i3[n4 + (i3[n4 + 16 >> 2] == (0 | A8) ? 16 : 20) >> 2] = B4, !B4)
                                      break I;
                                  }
                                  if (i3[B4 + 24 >> 2] = n4, (C4 = i3[A8 + 16 >> 2]) && (i3[B4 + 16 >> 2] = C4, i3[C4 + 24 >> 2] = B4), !(C4 = i3[A8 + 20 >> 2]))
                                    break I;
                                  i3[B4 + 20 >> 2] = C4, i3[C4 + 24 >> 2] = B4;
                                  break I;
                                }
                                if ((3 & (B4 = i3[g6 + 4 >> 2])) != 3)
                                  break I;
                                return i3[8967] = I7, i3[g6 + 4 >> 2] = -2 & B4, i3[A8 + 4 >> 2] = 1 | I7, void (i3[g6 >> 2] = I7);
                              }
                              i3[Q4 + 12 >> 2] = C4, i3[C4 + 8 >> 2] = Q4;
                            }
                          I: {
                            if (!(2 & (B4 = i3[g6 + 4 >> 2]))) {
                              if (i3[8971] == (0 | g6)) {
                                if (i3[8971] = A8, I7 = i3[8968] + I7 | 0, i3[8968] = I7, i3[A8 + 4 >> 2] = 1 | I7, i3[8970] != (0 | A8))
                                  break A;
                                return i3[8967] = 0, void (i3[8970] = 0);
                              }
                              if (i3[8970] == (0 | g6))
                                return i3[8970] = A8, I7 = i3[8967] + I7 | 0, i3[8967] = I7, i3[A8 + 4 >> 2] = 1 | I7, void (i3[A8 + I7 >> 2] = I7);
                              I7 = (-8 & B4) + I7 | 0;
                              g:
                                if (B4 >>> 0 <= 255) {
                                  if (Q4 = i3[g6 + 8 >> 2], B4 = B4 >>> 3 | 0, (0 | (C4 = i3[g6 + 12 >> 2])) == (0 | Q4)) {
                                    a4 = 35860, r4 = i3[8965] & lI(-2, B4), i3[a4 >> 2] = r4;
                                    break g;
                                  }
                                  i3[Q4 + 12 >> 2] = C4, i3[C4 + 8 >> 2] = Q4;
                                } else {
                                  if (n4 = i3[g6 + 24 >> 2], (0 | g6) == (0 | (B4 = i3[g6 + 12 >> 2])))
                                    if ((Q4 = i3[(C4 = g6 + 20 | 0) >> 2]) || (Q4 = i3[(C4 = g6 + 16 | 0) >> 2])) {
                                      for (; E4 = C4, (Q4 = i3[(C4 = (B4 = Q4) + 20 | 0) >> 2]) || (C4 = B4 + 16 | 0, Q4 = i3[B4 + 16 >> 2]); )
                                        ;
                                      i3[E4 >> 2] = 0;
                                    } else
                                      B4 = 0;
                                  else
                                    C4 = i3[g6 + 8 >> 2], i3[C4 + 12 >> 2] = B4, i3[B4 + 8 >> 2] = C4;
                                  if (n4) {
                                    Q4 = i3[g6 + 28 >> 2];
                                    B: {
                                      if (i3[(C4 = 36164 + (Q4 << 2) | 0) >> 2] == (0 | g6)) {
                                        if (i3[C4 >> 2] = B4, B4)
                                          break B;
                                        a4 = 35864, r4 = i3[8966] & lI(-2, Q4), i3[a4 >> 2] = r4;
                                        break g;
                                      }
                                      if (i3[n4 + (i3[n4 + 16 >> 2] == (0 | g6) ? 16 : 20) >> 2] = B4, !B4)
                                        break g;
                                    }
                                    i3[B4 + 24 >> 2] = n4, (C4 = i3[g6 + 16 >> 2]) && (i3[B4 + 16 >> 2] = C4, i3[C4 + 24 >> 2] = B4), (C4 = i3[g6 + 20 >> 2]) && (i3[B4 + 20 >> 2] = C4, i3[C4 + 24 >> 2] = B4);
                                  }
                                }
                              if (i3[A8 + 4 >> 2] = 1 | I7, i3[A8 + I7 >> 2] = I7, i3[8970] != (0 | A8))
                                break I;
                              return void (i3[8967] = I7);
                            }
                            i3[g6 + 4 >> 2] = -2 & B4, i3[A8 + 4 >> 2] = 1 | I7, i3[A8 + I7 >> 2] = I7;
                          }
                          if (I7 >>> 0 <= 255)
                            return B4 = 35900 + ((I7 = I7 >>> 3 | 0) << 3) | 0, (C4 = i3[8965]) & (I7 = 1 << I7) ? I7 = i3[B4 + 8 >> 2] : (i3[8965] = I7 | C4, I7 = B4), i3[B4 + 8 >> 2] = A8, i3[I7 + 12 >> 2] = A8, i3[A8 + 12 >> 2] = B4, void (i3[A8 + 8 >> 2] = I7);
                          Q4 = 31, i3[A8 + 16 >> 2] = 0, i3[A8 + 20 >> 2] = 0, I7 >>> 0 <= 16777215 && (B4 = I7 >>> 8 | 0, B4 <<= E4 = B4 + 1048320 >>> 16 & 8, Q4 = 28 + ((B4 = ((B4 <<= Q4 = B4 + 520192 >>> 16 & 4) << (C4 = B4 + 245760 >>> 16 & 2) >>> 15 | 0) - (C4 | Q4 | E4) | 0) << 1 | I7 >>> B4 + 21 & 1) | 0), i3[A8 + 28 >> 2] = Q4, E4 = 36164 + (Q4 << 2) | 0;
                          I: {
                            if ((C4 = i3[8966]) & (B4 = 1 << Q4)) {
                              for (Q4 = I7 << ((0 | Q4) == 31 ? 0 : 25 - (Q4 >>> 1 | 0) | 0), B4 = i3[E4 >> 2]; ; ) {
                                if (C4 = B4, (-8 & i3[B4 + 4 >> 2]) == (0 | I7))
                                  break I;
                                if (B4 = Q4 >>> 29 | 0, Q4 <<= 1, !(B4 = i3[16 + (E4 = C4 + (4 & B4) | 0) >> 2]))
                                  break;
                              }
                              i3[E4 + 16 >> 2] = A8, i3[A8 + 24 >> 2] = C4;
                            } else
                              i3[8966] = B4 | C4, i3[E4 >> 2] = A8, i3[A8 + 24 >> 2] = E4;
                            return i3[A8 + 12 >> 2] = A8, void (i3[A8 + 8 >> 2] = A8);
                          }
                          I7 = i3[C4 + 8 >> 2], i3[I7 + 12 >> 2] = A8, i3[C4 + 8 >> 2] = A8, i3[A8 + 24 >> 2] = 0, i3[A8 + 12 >> 2] = C4, i3[A8 + 8 >> 2] = I7;
                        }
                      }
                      function M3(A8, I7, g6, B4) {
                        var C4 = 0, Q4 = 0, E4 = 0, a4 = 0, o4 = 0, t4 = 0, e4 = 0, f4 = 0, c4 = 0, y4 = 0, s4 = 0, w4 = 0, D4 = 0, p4 = 0, u4 = 0, F4 = 0, l4 = 0, _4 = 0, k4 = 0, H4 = 0, G4 = 0, U4 = 0, S4 = 0, b4 = 0, m4 = 0;
                        if (c4 = i3[A8 + 36 >> 2], a4 = i3[A8 + 32 >> 2], E4 = i3[A8 + 28 >> 2], Q4 = i3[A8 + 24 >> 2], o4 = i3[A8 + 20 >> 2], !B4 & g6 >>> 0 >= 16 | B4)
                          for (G4 = !n3[A8 + 80 | 0] << 24, s4 = i3[A8 + 4 >> 2], U4 = r3(s4, 5), p4 = i3[A8 + 8 >> 2], H4 = r3(p4, 5), _4 = i3[A8 + 12 >> 2], k4 = r3(_4, 5), C4 = i3[A8 + 16 >> 2], u4 = r3(C4, 5), S4 = C4, w4 = i3[A8 >> 2]; C4 = qA(t4 = ((n3[I7 + 3 | 0] | n3[I7 + 4 | 0] << 8 | n3[I7 + 5 | 0] << 16 | n3[I7 + 6 | 0] << 24) >>> 2 & 67108863) + Q4 | 0, 0, _4, 0), e4 = h3, Q4 = (y4 = qA(o4 = (67108863 & (n3[0 | I7] | n3[I7 + 1 | 0] << 8 | n3[I7 + 2 | 0] << 16 | n3[I7 + 3 | 0] << 24)) + o4 | 0, 0, S4, 0)) + C4 | 0, C4 = h3 + e4 | 0, C4 = Q4 >>> 0 < y4 >>> 0 ? C4 + 1 | 0 : C4, f4 = Q4, Q4 = qA(e4 = ((n3[I7 + 6 | 0] | n3[I7 + 7 | 0] << 8 | n3[I7 + 8 | 0] << 16 | n3[I7 + 9 | 0] << 24) >>> 4 & 67108863) + E4 | 0, 0, p4, 0), C4 = h3 + C4 | 0, C4 = Q4 >>> 0 > (E4 = f4 + Q4 | 0) >>> 0 ? C4 + 1 | 0 : C4, Q4 = E4, E4 = qA(y4 = ((n3[I7 + 9 | 0] | n3[I7 + 10 | 0] << 8 | n3[I7 + 11 | 0] << 16 | n3[I7 + 12 | 0] << 24) >>> 6 | 0) + a4 | 0, 0, s4, 0), C4 = h3 + C4 | 0, C4 = E4 >>> 0 > (a4 = Q4 + E4 | 0) >>> 0 ? C4 + 1 | 0 : C4, Q4 = a4, a4 = qA(D4 = c4 + G4 + ((n3[I7 + 12 | 0] | n3[I7 + 13 | 0] << 8 | n3[I7 + 14 | 0] << 16 | n3[I7 + 15 | 0] << 24) >>> 8) | 0, 0, w4, 0), C4 = h3 + C4 | 0, b4 = c4 = Q4 + a4 | 0, c4 = a4 >>> 0 > c4 >>> 0 ? C4 + 1 | 0 : C4, C4 = qA(t4, 0, p4, 0), E4 = h3, a4 = (Q4 = qA(o4, 0, _4, 0)) + C4 | 0, C4 = h3 + E4 | 0, C4 = Q4 >>> 0 > a4 >>> 0 ? C4 + 1 | 0 : C4, E4 = qA(e4, 0, s4, 0), C4 = h3 + C4 | 0, C4 = E4 >>> 0 > (a4 = E4 + a4 | 0) >>> 0 ? C4 + 1 | 0 : C4, E4 = qA(y4, 0, w4, 0), C4 = h3 + C4 | 0, C4 = E4 >>> 0 > (a4 = E4 + a4 | 0) >>> 0 ? C4 + 1 | 0 : C4, E4 = qA(D4, 0, u4, 0), C4 = h3 + C4 | 0, m4 = a4 = E4 + a4 | 0, a4 = E4 >>> 0 > a4 >>> 0 ? C4 + 1 | 0 : C4, C4 = qA(t4, 0, s4, 0), Q4 = h3, E4 = (F4 = qA(o4, 0, p4, 0)) + C4 | 0, C4 = h3 + Q4 | 0, C4 = E4 >>> 0 < F4 >>> 0 ? C4 + 1 | 0 : C4, Q4 = qA(e4, 0, w4, 0), C4 = h3 + C4 | 0, C4 = Q4 >>> 0 > (E4 = Q4 + E4 | 0) >>> 0 ? C4 + 1 | 0 : C4, Q4 = qA(y4, 0, u4, 0), C4 = h3 + C4 | 0, C4 = Q4 >>> 0 > (E4 = Q4 + E4 | 0) >>> 0 ? C4 + 1 | 0 : C4, Q4 = qA(D4, 0, k4, 0), C4 = h3 + C4 | 0, F4 = E4 = Q4 + E4 | 0, E4 = Q4 >>> 0 > E4 >>> 0 ? C4 + 1 | 0 : C4, C4 = qA(t4, 0, w4, 0), f4 = h3, Q4 = (l4 = qA(o4, 0, s4, 0)) + C4 | 0, C4 = h3 + f4 | 0, C4 = Q4 >>> 0 < l4 >>> 0 ? C4 + 1 | 0 : C4, f4 = qA(e4, 0, u4, 0), C4 = h3 + C4 | 0, C4 = (Q4 = f4 + Q4 | 0) >>> 0 < f4 >>> 0 ? C4 + 1 | 0 : C4, f4 = qA(y4, 0, k4, 0), C4 = h3 + C4 | 0, C4 = (Q4 = f4 + Q4 | 0) >>> 0 < f4 >>> 0 ? C4 + 1 | 0 : C4, f4 = qA(D4, 0, H4, 0), C4 = h3 + C4 | 0, C4 = (Q4 = f4 + Q4 | 0) >>> 0 < f4 >>> 0 ? C4 + 1 | 0 : C4, f4 = Q4, Q4 = C4, C4 = qA(t4, 0, u4, 0), l4 = h3, t4 = (o4 = qA(o4, 0, w4, 0)) + C4 | 0, C4 = h3 + l4 | 0, C4 = t4 >>> 0 < o4 >>> 0 ? C4 + 1 | 0 : C4, o4 = qA(e4, 0, k4, 0), C4 = h3 + C4 | 0, C4 = (t4 = o4 + t4 | 0) >>> 0 < o4 >>> 0 ? C4 + 1 | 0 : C4, o4 = qA(y4, 0, H4, 0), C4 = h3 + C4 | 0, C4 = (t4 = o4 + t4 | 0) >>> 0 < o4 >>> 0 ? C4 + 1 | 0 : C4, o4 = qA(D4, 0, U4, 0), C4 = h3 + C4 | 0, C4 = (t4 = o4 + t4 | 0) >>> 0 < o4 >>> 0 ? C4 + 1 | 0 : C4, o4 = t4, e4 = (67108863 & C4) << 6 | t4 >>> 26, C4 = Q4, e4 = (67108863 & (C4 = (t4 = e4 + f4 | 0) >>> 0 < e4 >>> 0 ? C4 + 1 | 0 : C4)) << 6 | (Q4 = t4) >>> 26, C4 = E4, C4 = (Q4 = e4 + F4 | 0) >>> 0 < e4 >>> 0 ? C4 + 1 | 0 : C4, e4 = Q4, Q4 = (67108863 & C4) << 6 | Q4 >>> 26, C4 = a4, y4 = E4 = Q4 + m4 | 0, E4 = (67108863 & (C4 = Q4 >>> 0 > E4 >>> 0 ? C4 + 1 | 0 : C4)) << 6 | E4 >>> 26, C4 = c4, c4 = a4 = E4 + b4 | 0, Q4 = (67108863 & t4) + ((C4 = r3((67108863 & (E4 >>> 0 > a4 >>> 0 ? C4 + 1 | 0 : C4)) << 6 | a4 >>> 26, 5) + (67108863 & o4) | 0) >>> 26 | 0) | 0, E4 = 67108863 & e4, a4 = 67108863 & y4, c4 &= 67108863, o4 = 67108863 & C4, I7 = I7 + 16 | 0, !(B4 = B4 - (g6 >>> 0 < 16) | 0) & (g6 = g6 - 16 | 0) >>> 0 > 15 | B4; )
                            ;
                        i3[A8 + 20 >> 2] = o4, i3[A8 + 36 >> 2] = c4, i3[A8 + 32 >> 2] = a4, i3[A8 + 28 >> 2] = E4, i3[A8 + 24 >> 2] = Q4;
                      }
                      function P3(A8, I7, g6) {
                        var B4, C4, E4, i4, a4 = 0, r4 = 0, o4 = 0, t4 = 0, e4 = 0;
                        return s3 = E4 = s3 - 160 | 0, _I(I7, g6, 32, 0), Q3[0 | I7] = 248 & n3[0 | I7], Q3[I7 + 31 | 0] = 63 & n3[I7 + 31 | 0] | 64, BA2(E4, I7), II(A8, E4), r4 = n3[(C4 = g6) + 8 | 0] | n3[C4 + 9 | 0] << 8 | n3[C4 + 10 | 0] << 16 | n3[C4 + 11 | 0] << 24, a4 = n3[C4 + 12 | 0] | n3[C4 + 13 | 0] << 8 | n3[C4 + 14 | 0] << 16 | n3[C4 + 15 | 0] << 24, o4 = n3[C4 + 16 | 0] | n3[C4 + 17 | 0] << 8 | n3[C4 + 18 | 0] << 16 | n3[C4 + 19 | 0] << 24, t4 = n3[C4 + 20 | 0] | n3[C4 + 21 | 0] << 8 | n3[C4 + 22 | 0] << 16 | n3[C4 + 23 | 0] << 24, e4 = n3[0 | C4] | n3[C4 + 1 | 0] << 8 | n3[C4 + 2 | 0] << 16 | n3[C4 + 3 | 0] << 24, g6 = n3[C4 + 4 | 0] | n3[C4 + 5 | 0] << 8 | n3[C4 + 6 | 0] << 16 | n3[C4 + 7 | 0] << 24, i4 = n3[C4 + 28 | 0] | n3[C4 + 29 | 0] << 8 | n3[C4 + 30 | 0] << 16 | n3[C4 + 31 | 0] << 24, B4 = I7, I7 = n3[C4 + 24 | 0] | n3[C4 + 25 | 0] << 8 | n3[C4 + 26 | 0] << 16 | n3[C4 + 27 | 0] << 24, Q3[B4 + 24 | 0] = I7, Q3[B4 + 25 | 0] = I7 >>> 8, Q3[B4 + 26 | 0] = I7 >>> 16, Q3[B4 + 27 | 0] = I7 >>> 24, Q3[B4 + 28 | 0] = i4, Q3[B4 + 29 | 0] = i4 >>> 8, Q3[B4 + 30 | 0] = i4 >>> 16, Q3[B4 + 31 | 0] = i4 >>> 24, Q3[B4 + 16 | 0] = o4, Q3[B4 + 17 | 0] = o4 >>> 8, Q3[B4 + 18 | 0] = o4 >>> 16, Q3[B4 + 19 | 0] = o4 >>> 24, Q3[B4 + 20 | 0] = t4, Q3[B4 + 21 | 0] = t4 >>> 8, Q3[B4 + 22 | 0] = t4 >>> 16, Q3[B4 + 23 | 0] = t4 >>> 24, Q3[B4 + 8 | 0] = r4, Q3[B4 + 9 | 0] = r4 >>> 8, Q3[B4 + 10 | 0] = r4 >>> 16, Q3[B4 + 11 | 0] = r4 >>> 24, Q3[B4 + 12 | 0] = a4, Q3[B4 + 13 | 0] = a4 >>> 8, Q3[B4 + 14 | 0] = a4 >>> 16, Q3[B4 + 15 | 0] = a4 >>> 24, Q3[0 | B4] = e4, Q3[B4 + 1 | 0] = e4 >>> 8, Q3[B4 + 2 | 0] = e4 >>> 16, Q3[B4 + 3 | 0] = e4 >>> 24, Q3[B4 + 4 | 0] = g6, Q3[B4 + 5 | 0] = g6 >>> 8, Q3[B4 + 6 | 0] = g6 >>> 16, Q3[B4 + 7 | 0] = g6 >>> 24, o4 = n3[(a4 = A8) + 8 | 0] | n3[a4 + 9 | 0] << 8 | n3[a4 + 10 | 0] << 16 | n3[a4 + 11 | 0] << 24, t4 = n3[a4 + 12 | 0] | n3[a4 + 13 | 0] << 8 | n3[a4 + 14 | 0] << 16 | n3[a4 + 15 | 0] << 24, e4 = n3[a4 + 16 | 0] | n3[a4 + 17 | 0] << 8 | n3[a4 + 18 | 0] << 16 | n3[a4 + 19 | 0] << 24, g6 = n3[a4 + 20 | 0] | n3[a4 + 21 | 0] << 8 | n3[a4 + 22 | 0] << 16 | n3[a4 + 23 | 0] << 24, I7 = n3[0 | a4] | n3[a4 + 1 | 0] << 8 | n3[a4 + 2 | 0] << 16 | n3[a4 + 3 | 0] << 24, A8 = n3[a4 + 4 | 0] | n3[a4 + 5 | 0] << 8 | n3[a4 + 6 | 0] << 16 | n3[a4 + 7 | 0] << 24, r4 = n3[a4 + 28 | 0] | n3[a4 + 29 | 0] << 8 | n3[a4 + 30 | 0] << 16 | n3[a4 + 31 | 0] << 24, a4 = n3[a4 + 24 | 0] | n3[a4 + 25 | 0] << 8 | n3[a4 + 26 | 0] << 16 | n3[a4 + 27 | 0] << 24, Q3[B4 + 56 | 0] = a4, Q3[B4 + 57 | 0] = a4 >>> 8, Q3[B4 + 58 | 0] = a4 >>> 16, Q3[B4 + 59 | 0] = a4 >>> 24, Q3[B4 + 60 | 0] = r4, Q3[B4 + 61 | 0] = r4 >>> 8, Q3[B4 + 62 | 0] = r4 >>> 16, Q3[B4 + 63 | 0] = r4 >>> 24, Q3[B4 + 48 | 0] = e4, Q3[B4 + 49 | 0] = e4 >>> 8, Q3[B4 + 50 | 0] = e4 >>> 16, Q3[B4 + 51 | 0] = e4 >>> 24, Q3[B4 + 52 | 0] = g6, Q3[B4 + 53 | 0] = g6 >>> 8, Q3[B4 + 54 | 0] = g6 >>> 16, Q3[B4 + 55 | 0] = g6 >>> 24, Q3[B4 + 40 | 0] = o4, Q3[B4 + 41 | 0] = o4 >>> 8, Q3[B4 + 42 | 0] = o4 >>> 16, Q3[B4 + 43 | 0] = o4 >>> 24, Q3[B4 + 44 | 0] = t4, Q3[B4 + 45 | 0] = t4 >>> 8, Q3[B4 + 46 | 0] = t4 >>> 16, Q3[B4 + 47 | 0] = t4 >>> 24, Q3[B4 + 32 | 0] = I7, Q3[B4 + 33 | 0] = I7 >>> 8, Q3[B4 + 34 | 0] = I7 >>> 16, Q3[B4 + 35 | 0] = I7 >>> 24, Q3[B4 + 36 | 0] = A8, Q3[B4 + 37 | 0] = A8 >>> 8, Q3[B4 + 38 | 0] = A8 >>> 16, Q3[B4 + 39 | 0] = A8 >>> 24, s3 = E4 + 160 | 0, 0;
                      }
                      function Y3(A8, I7, g6) {
                        var B4, C4 = 0, E4 = 0;
                        s3 = B4 = s3 + -64 | 0;
                        A: {
                          if ((g6 - 65 & 255) >>> 0 > 191) {
                            if (C4 = -1, !(n3[A8 + 80 | 0] | n3[A8 + 81 | 0] << 8 | n3[A8 + 82 | 0] << 16 | n3[A8 + 83 | 0] << 24 | n3[A8 + 84 | 0] | n3[A8 + 85 | 0] << 8 | n3[A8 + 86 | 0] << 16 | n3[A8 + 87 | 0] << 24)) {
                              if ((C4 = n3[A8 + 352 | 0] | n3[A8 + 353 | 0] << 8 | n3[A8 + 354 | 0] << 16 | n3[A8 + 355 | 0] << 24) >>> 0 >= 129) {
                                if (CA(A8, 128), p3(A8, E4 = A8 + 96 | 0), C4 = (n3[A8 + 352 | 0] | n3[A8 + 353 | 0] << 8 | n3[A8 + 354 | 0] << 16 | n3[A8 + 355 | 0] << 24) - 128 | 0, Q3[A8 + 352 | 0] = C4, Q3[A8 + 353 | 0] = C4 >>> 8, Q3[A8 + 354 | 0] = C4 >>> 16, Q3[A8 + 355 | 0] = C4 >>> 24, C4 >>> 0 >= 129)
                                  break A;
                                eI(E4, A8 + 224 | 0, C4), C4 = n3[A8 + 352 | 0] | n3[A8 + 353 | 0] << 8 | n3[A8 + 354 | 0] << 16 | n3[A8 + 355 | 0] << 24;
                              }
                              CA(A8, C4), n3[A8 + 356 | 0] && (Q3[A8 + 88 | 0] = 255, Q3[A8 + 89 | 0] = 255, Q3[A8 + 90 | 0] = 255, Q3[A8 + 91 | 0] = 255, Q3[A8 + 92 | 0] = 255, Q3[A8 + 93 | 0] = 255, Q3[A8 + 94 | 0] = 255, Q3[A8 + 95 | 0] = 255), Q3[A8 + 80 | 0] = 255, Q3[A8 + 81 | 0] = 255, Q3[A8 + 82 | 0] = 255, Q3[A8 + 83 | 0] = 255, Q3[A8 + 84 | 0] = 255, Q3[A8 + 85 | 0] = 255, Q3[A8 + 86 | 0] = 255, Q3[A8 + 87 | 0] = 255, wI((C4 = A8 + 96 | 0) + (E4 = n3[A8 + 352 | 0] | n3[A8 + 353 | 0] << 8 | n3[A8 + 354 | 0] << 16 | n3[A8 + 355 | 0] << 24) | 0, 0, 256 - E4 | 0), p3(A8, C4), QI(B4, n3[0 | A8] | n3[A8 + 1 | 0] << 8 | n3[A8 + 2 | 0] << 16 | n3[A8 + 3 | 0] << 24, n3[A8 + 4 | 0] | n3[A8 + 5 | 0] << 8 | n3[A8 + 6 | 0] << 16 | n3[A8 + 7 | 0] << 24), QI(8 | B4, n3[A8 + 8 | 0] | n3[A8 + 9 | 0] << 8 | n3[A8 + 10 | 0] << 16 | n3[A8 + 11 | 0] << 24, n3[A8 + 12 | 0] | n3[A8 + 13 | 0] << 8 | n3[A8 + 14 | 0] << 16 | n3[A8 + 15 | 0] << 24), QI(B4 + 16 | 0, n3[A8 + 16 | 0] | n3[A8 + 17 | 0] << 8 | n3[A8 + 18 | 0] << 16 | n3[A8 + 19 | 0] << 24, n3[A8 + 20 | 0] | n3[A8 + 21 | 0] << 8 | n3[A8 + 22 | 0] << 16 | n3[A8 + 23 | 0] << 24), QI(B4 + 24 | 0, n3[A8 + 24 | 0] | n3[A8 + 25 | 0] << 8 | n3[A8 + 26 | 0] << 16 | n3[A8 + 27 | 0] << 24, n3[A8 + 28 | 0] | n3[A8 + 29 | 0] << 8 | n3[A8 + 30 | 0] << 16 | n3[A8 + 31 | 0] << 24), QI(B4 + 32 | 0, n3[A8 + 32 | 0] | n3[A8 + 33 | 0] << 8 | n3[A8 + 34 | 0] << 16 | n3[A8 + 35 | 0] << 24, n3[A8 + 36 | 0] | n3[A8 + 37 | 0] << 8 | n3[A8 + 38 | 0] << 16 | n3[A8 + 39 | 0] << 24), QI(B4 + 40 | 0, n3[A8 + 40 | 0] | n3[A8 + 41 | 0] << 8 | n3[A8 + 42 | 0] << 16 | n3[A8 + 43 | 0] << 24, n3[A8 + 44 | 0] | n3[A8 + 45 | 0] << 8 | n3[A8 + 46 | 0] << 16 | n3[A8 + 47 | 0] << 24), QI(B4 + 48 | 0, n3[A8 + 48 | 0] | n3[A8 + 49 | 0] << 8 | n3[A8 + 50 | 0] << 16 | n3[A8 + 51 | 0] << 24, n3[A8 + 52 | 0] | n3[A8 + 53 | 0] << 8 | n3[A8 + 54 | 0] << 16 | n3[A8 + 55 | 0] << 24), QI(B4 + 56 | 0, n3[A8 + 56 | 0] | n3[A8 + 57 | 0] << 8 | n3[A8 + 58 | 0] << 16 | n3[A8 + 59 | 0] << 24, n3[A8 + 60 | 0] | n3[A8 + 61 | 0] << 8 | n3[A8 + 62 | 0] << 16 | n3[A8 + 63 | 0] << 24), eI(I7, B4, g6), Dg(A8, 64), Dg(C4, 256), C4 = 0;
                            }
                            return s3 = B4 - -64 | 0, C4;
                          }
                          xI(), t3();
                        }
                        e3(1299, 1161, 306, 1086), t3();
                      }
                      function N3(A8, I7) {
                        var g6, B4, C4, Q4, E4, a4, r4, o4, t4, e4 = 0, f4 = 0, c4 = 0, y4 = 0, s4 = 0, w4 = 0, D4 = 0, p4 = 0, u4 = 0, F4 = 0;
                        g6 = n3[0 | I7] | n3[I7 + 1 | 0] << 8 | n3[I7 + 2 | 0] << 16 | n3[I7 + 3 | 0] << 24, u4 = uI(I7 + 4 | 0), e4 = h3, w4 = uI(I7 + 7 | 0), y4 = h3, p4 = uI(I7 + 10 | 0), f4 = h3, B4 = uI(I7 + 13 | 0), s4 = h3, c4 = n3[I7 + 16 | 0] | n3[I7 + 17 | 0] << 8 | n3[I7 + 18 | 0] << 16 | n3[I7 + 19 | 0] << 24, C4 = uI(I7 + 20 | 0), Q4 = h3, E4 = uI(I7 + 23 | 0), a4 = h3, r4 = uI(I7 + 26 | 0), o4 = h3, t4 = uI(I7 + 29 | 0), I7 = f4 << 3 | p4 >>> 29, F4 = f4 = p4 << 3, p4 = f4 = f4 + 16777216 | 0, f4 = I7 = f4 >>> 0 < 16777216 ? I7 + 1 | 0 : I7, D4 = w4 << 5, y4 = I7 = y4 << 5 | w4 >>> 27, e4 = I7 = e4 << 6 | (w4 = u4) >>> 26, u4 = I7 = 16777216 + (w4 <<= 6) | 0, I7 = (I7 = (e4 = I7 >>> 0 < 16777216 ? e4 + 1 | 0 : e4) >> 25) + y4 | 0, I7 = (e4 = D4 + (D4 = (33554431 & e4) << 7 | u4 >>> 25) | 0) >>> 0 < D4 >>> 0 ? I7 + 1 | 0 : I7, I7 = (F4 - (-33554432 & p4) | 0) + ((67108863 & (I7 = (y4 = e4 + 33554432 | 0) >>> 0 < 33554432 ? I7 + 1 | 0 : I7)) << 6 | y4 >>> 26) | 0, i3[A8 + 12 >> 2] = I7, I7 = -67108864 & y4, i3[A8 + 8 >> 2] = e4 - I7, I7 = 0, y4 = c4 = (e4 = c4) + 16777216 | 0, c4 = I7 = c4 >>> 0 < 16777216 ? 1 : I7, F4 = e4 - (-33554432 & y4) | 0, I7 = s4 << 2 | (e4 = B4) >>> 30, s4 = e4 << 2, e4 = I7, I7 = (I7 = f4 >> 25) + e4 | 0, e4 = I7 = (f4 = (D4 = s4) + (s4 = (33554431 & f4) << 7 | p4 >>> 25) | 0) >>> 0 < s4 >>> 0 ? I7 + 1 | 0 : I7, s4 = I7 = f4 + 33554432 | 0, I7 = ((67108863 & (e4 = I7 >>> 0 < 33554432 ? e4 + 1 | 0 : e4)) << 6 | I7 >>> 26) + F4 | 0, i3[A8 + 20 >> 2] = I7, I7 = -67108864 & s4, i3[A8 + 16 >> 2] = f4 - I7, f4 = (e4 = C4) << 7, I7 = (I7 = Q4 << 7 | e4 >>> 25) + (e4 = c4 >> 25) | 0, I7 = (f4 = f4 + (c4 = (33554431 & c4) << 7 | y4 >>> 25) | 0) >>> 0 < c4 >>> 0 ? I7 + 1 | 0 : I7, f4 = e4 = f4, c4 = e4 = e4 + 33554432 | 0, e4 = I7 = e4 >>> 0 < 33554432 ? I7 + 1 | 0 : I7, I7 = -67108864 & c4, i3[A8 + 24 >> 2] = f4 - I7, I7 = a4 << 5 | (f4 = E4) >>> 27, s4 = f4 <<= 5, y4 = f4 = f4 + 16777216 | 0, f4 = I7 = f4 >>> 0 < 16777216 ? I7 + 1 | 0 : I7, I7 = (s4 - (-33554432 & y4) | 0) + ((67108863 & e4) << 6 | c4 >>> 26) | 0, i3[A8 + 28 >> 2] = I7, c4 = (e4 = r4) << 4, e4 = I7 = o4 << 4 | e4 >>> 28, I7 = (I7 = f4 >> 25) + e4 | 0, I7 = (f4 = (s4 = c4) + (c4 = (33554431 & f4) << 7 | y4 >>> 25) | 0) >>> 0 < c4 >>> 0 ? I7 + 1 | 0 : I7, f4 = e4 = f4, c4 = e4 = e4 + 33554432 | 0, e4 = I7 = e4 >>> 0 < 33554432 ? I7 + 1 | 0 : I7, I7 = -67108864 & c4, i3[A8 + 32 >> 2] = f4 - I7, I7 = 0, y4 = f4 = (f4 = t4) << 2 & 33554428, I7 = (f4 = f4 + 16777216 | 0) >>> 0 < 16777216 ? I7 + 1 | 0 : I7, e4 = (y4 - (33554432 & f4) | 0) + ((67108863 & e4) << 6 | c4 >>> 26) | 0, i3[A8 + 36 >> 2] = e4, f4 = qA((33554431 & I7) << 7 | f4 >>> 25, I7 >>> 25 | 0, 19, 0), I7 = h3, I7 = (e4 = f4 + g6 | 0) >>> 0 < f4 >>> 0 ? I7 + 1 | 0 : I7, I7 = (w4 - (-33554432 & u4) | 0) + ((67108863 & (I7 = (f4 = e4 + 33554432 | 0) >>> 0 < 33554432 ? I7 + 1 | 0 : I7)) << 6 | f4 >>> 26) | 0, i3[A8 + 4 >> 2] = I7, I7 = A8, A8 = -67108864 & f4, i3[I7 >> 2] = e4 - A8;
                      }
                      function R3(A8, I7, g6, B4) {
                        var C4, E4 = 0;
                        C4 = E4 = s3, s3 = E4 = E4 - 576 & -64, i3[E4 + 188 >> 2] = 0, bI(E4 + 188 | 0, I7);
                        A:
                          if (I7 >>> 0 <= 64) {
                            if ((0 | OA(E4 + 192 | 0, 0, 0, I7)) < 0)
                              break A;
                            if ((0 | Cg(E4 + 192 | 0, E4 + 188 | 0, 4, 0)) < 0)
                              break A;
                            if ((0 | Cg(E4 + 192 | 0, g6, B4, 0)) < 0)
                              break A;
                            UI(E4 + 192 | 0, A8, I7);
                          } else if (!((0 | OA(E4 + 192 | 0, 0, 0, 64)) < 0 || (0 | Cg(E4 + 192 | 0, E4 + 188 | 0, 4, 0)) < 0 || (0 | Cg(E4 + 192 | 0, g6, B4, 0)) < 0 || (0 | UI(E4 + 192 | 0, E4 + 112 | 0, 64)) < 0)) {
                            if (g6 = i3[E4 + 116 >> 2], B4 = i3[E4 + 112 >> 2], Q3[0 | A8] = B4, Q3[A8 + 1 | 0] = B4 >>> 8, Q3[A8 + 2 | 0] = B4 >>> 16, Q3[A8 + 3 | 0] = B4 >>> 24, Q3[A8 + 4 | 0] = g6, Q3[A8 + 5 | 0] = g6 >>> 8, Q3[A8 + 6 | 0] = g6 >>> 16, Q3[A8 + 7 | 0] = g6 >>> 24, g6 = i3[E4 + 124 >> 2], B4 = i3[E4 + 120 >> 2], Q3[A8 + 8 | 0] = B4, Q3[A8 + 9 | 0] = B4 >>> 8, Q3[A8 + 10 | 0] = B4 >>> 16, Q3[A8 + 11 | 0] = B4 >>> 24, Q3[A8 + 12 | 0] = g6, Q3[A8 + 13 | 0] = g6 >>> 8, Q3[A8 + 14 | 0] = g6 >>> 16, Q3[A8 + 15 | 0] = g6 >>> 24, g6 = i3[E4 + 140 >> 2], B4 = i3[E4 + 136 >> 2], Q3[A8 + 24 | 0] = B4, Q3[A8 + 25 | 0] = B4 >>> 8, Q3[A8 + 26 | 0] = B4 >>> 16, Q3[A8 + 27 | 0] = B4 >>> 24, Q3[A8 + 28 | 0] = g6, Q3[A8 + 29 | 0] = g6 >>> 8, Q3[A8 + 30 | 0] = g6 >>> 16, Q3[A8 + 31 | 0] = g6 >>> 24, g6 = i3[E4 + 132 >> 2], B4 = i3[E4 + 128 >> 2], Q3[A8 + 16 | 0] = B4, Q3[A8 + 17 | 0] = B4 >>> 8, Q3[A8 + 18 | 0] = B4 >>> 16, Q3[A8 + 19 | 0] = B4 >>> 24, Q3[A8 + 20 | 0] = g6, Q3[A8 + 21 | 0] = g6 >>> 8, Q3[A8 + 22 | 0] = g6 >>> 16, Q3[A8 + 23 | 0] = g6 >>> 24, A8 = A8 + 32 | 0, (I7 = I7 - 32 | 0) >>> 0 >= 65)
                              for (; ; ) {
                                if (eI(g6 = E4 + 48 | 0, B4 = E4 + 112 | 0, 64), (0 | vA(B4, 64, g6, 64, 0, 0, 0)) < 0)
                                  break A;
                                if (g6 = i3[E4 + 116 >> 2], B4 = i3[E4 + 112 >> 2], Q3[0 | A8] = B4, Q3[A8 + 1 | 0] = B4 >>> 8, Q3[A8 + 2 | 0] = B4 >>> 16, Q3[A8 + 3 | 0] = B4 >>> 24, Q3[A8 + 4 | 0] = g6, Q3[A8 + 5 | 0] = g6 >>> 8, Q3[A8 + 6 | 0] = g6 >>> 16, Q3[A8 + 7 | 0] = g6 >>> 24, g6 = i3[E4 + 124 >> 2], B4 = i3[E4 + 120 >> 2], Q3[A8 + 8 | 0] = B4, Q3[A8 + 9 | 0] = B4 >>> 8, Q3[A8 + 10 | 0] = B4 >>> 16, Q3[A8 + 11 | 0] = B4 >>> 24, Q3[A8 + 12 | 0] = g6, Q3[A8 + 13 | 0] = g6 >>> 8, Q3[A8 + 14 | 0] = g6 >>> 16, Q3[A8 + 15 | 0] = g6 >>> 24, g6 = i3[E4 + 140 >> 2], B4 = i3[E4 + 136 >> 2], Q3[A8 + 24 | 0] = B4, Q3[A8 + 25 | 0] = B4 >>> 8, Q3[A8 + 26 | 0] = B4 >>> 16, Q3[A8 + 27 | 0] = B4 >>> 24, Q3[A8 + 28 | 0] = g6, Q3[A8 + 29 | 0] = g6 >>> 8, Q3[A8 + 30 | 0] = g6 >>> 16, Q3[A8 + 31 | 0] = g6 >>> 24, g6 = i3[E4 + 132 >> 2], B4 = i3[E4 + 128 >> 2], Q3[A8 + 16 | 0] = B4, Q3[A8 + 17 | 0] = B4 >>> 8, Q3[A8 + 18 | 0] = B4 >>> 16, Q3[A8 + 19 | 0] = B4 >>> 24, Q3[A8 + 20 | 0] = g6, Q3[A8 + 21 | 0] = g6 >>> 8, Q3[A8 + 22 | 0] = g6 >>> 16, Q3[A8 + 23 | 0] = g6 >>> 24, A8 = A8 + 32 | 0, !((I7 = I7 - 32 | 0) >>> 0 > 64))
                                  break;
                              }
                            eI(g6 = E4 + 48 | 0, B4 = E4 + 112 | 0, 64), (0 | vA(B4, I7, g6, 64, 0, 0, 0)) < 0 || eI(A8, E4 + 112 | 0, I7);
                          }
                        Dg(E4 + 192 | 0, 384), s3 = C4;
                      }
                      function d3(A8, I7, g6) {
                        var B4, C4, Q4, E4, i4, a4, r4, o4, t4, e4, f4, c4, y4 = 0, s4 = 0, w4 = 0, D4 = 0, h4 = 0, p4 = 0, u4 = 0, F4 = 0, l4 = 0, _4 = 0, k4 = 0, H4 = 0, G4 = 0, U4 = 0, S4 = 0, b4 = 0, m4 = 0, v4 = 0, M4 = 0, P4 = 0, Y4 = 0;
                        for (B4 = n3[g6 + 4 | 0] | n3[g6 + 5 | 0] << 8 | n3[g6 + 6 | 0] << 16 | n3[g6 + 7 | 0] << 24, C4 = n3[g6 + 8 | 0] | n3[g6 + 9 | 0] << 8 | n3[g6 + 10 | 0] << 16 | n3[g6 + 11 | 0] << 24, Q4 = n3[g6 + 12 | 0] | n3[g6 + 13 | 0] << 8 | n3[g6 + 14 | 0] << 16 | n3[g6 + 15 | 0] << 24, E4 = n3[g6 + 16 | 0] | n3[g6 + 17 | 0] << 8 | n3[g6 + 18 | 0] << 16 | n3[g6 + 19 | 0] << 24, i4 = n3[g6 + 20 | 0] | n3[g6 + 21 | 0] << 8 | n3[g6 + 22 | 0] << 16 | n3[g6 + 23 | 0] << 24, a4 = n3[g6 + 24 | 0] | n3[g6 + 25 | 0] << 8 | n3[g6 + 26 | 0] << 16 | n3[g6 + 27 | 0] << 24, r4 = n3[g6 + 28 | 0] | n3[g6 + 29 | 0] << 8 | n3[g6 + 30 | 0] << 16 | n3[g6 + 31 | 0] << 24, k4 = 1634760805, g6 = o4 = n3[0 | g6] | n3[g6 + 1 | 0] << 8 | n3[g6 + 2 | 0] << 16 | n3[g6 + 3 | 0] << 24, w4 = B4, S4 = C4, D4 = Q4, H4 = 857760878, h4 = t4 = n3[0 | I7] | n3[I7 + 1 | 0] << 8 | n3[I7 + 2 | 0] << 16 | n3[I7 + 3 | 0] << 24, p4 = e4 = n3[I7 + 4 | 0] | n3[I7 + 5 | 0] << 8 | n3[I7 + 6 | 0] << 16 | n3[I7 + 7 | 0] << 24, u4 = f4 = n3[I7 + 8 | 0] | n3[I7 + 9 | 0] << 8 | n3[I7 + 10 | 0] << 16 | n3[I7 + 11 | 0] << 24, _4 = c4 = n3[I7 + 12 | 0] | n3[I7 + 13 | 0] << 8 | n3[I7 + 14 | 0] << 16 | n3[I7 + 15 | 0] << 24, G4 = 2036477234, I7 = E4, F4 = 1797285236, l4 = r4, y4 = a4, s4 = i4; D4 = cg(s4 + k4 | 0, 7) ^ D4, u4 = cg(D4 + k4 | 0, 9) ^ u4, b4 = cg(u4 + D4 | 0, 13) ^ s4, M4 = cg(u4 + b4 | 0, 18), s4 = cg(g6 + H4 | 0, 7) ^ _4, U4 = cg(s4 + H4 | 0, 9) ^ y4, g6 = cg(s4 + U4 | 0, 13) ^ g6, _4 = cg(U4 + g6 | 0, 18), l4 = cg(h4 + G4 | 0, 7) ^ l4, w4 = cg(l4 + G4 | 0, 9) ^ w4, h4 = cg(l4 + w4 | 0, 13) ^ h4, P4 = cg(w4 + h4 | 0, 18), y4 = cg(I7 + F4 | 0, 7) ^ S4, p4 = cg(y4 + F4 | 0, 9) ^ p4, m4 = cg(y4 + p4 | 0, 13) ^ I7, Y4 = cg(p4 + m4 | 0, 18), g6 = cg((I7 = k4 ^ M4) + y4 | 0, 7) ^ g6, w4 = cg(g6 + I7 | 0, 9) ^ w4, S4 = cg(g6 + w4 | 0, 13) ^ y4, k4 = cg(w4 + S4 | 0, 18) ^ I7, h4 = cg((I7 = H4 ^ _4) + D4 | 0, 7) ^ h4, p4 = cg(h4 + I7 | 0, 9) ^ p4, D4 = cg(p4 + h4 | 0, 13) ^ D4, H4 = cg(p4 + D4 | 0, 18) ^ I7, I7 = cg((y4 = G4 ^ P4) + s4 | 0, 7) ^ m4, u4 = cg(I7 + y4 | 0, 9) ^ u4, _4 = cg(I7 + u4 | 0, 13) ^ s4, G4 = cg(u4 + _4 | 0, 18) ^ y4, s4 = cg((F4 ^= Y4) + l4 | 0, 7) ^ b4, y4 = cg(s4 + F4 | 0, 9) ^ U4, l4 = cg(y4 + s4 | 0, 13) ^ l4, F4 = cg(y4 + l4 | 0, 18) ^ F4, U4 = v4 >>> 0 < 18, v4 = v4 + 2 | 0, U4; )
                          ;
                        bI(A8, k4 + 1634760805 | 0), bI(A8 + 4 | 0, g6 + o4 | 0), bI(A8 + 8 | 0, w4 + B4 | 0), bI(A8 + 12 | 0, S4 + C4 | 0), bI(A8 + 16 | 0, D4 + Q4 | 0), bI(A8 + 20 | 0, H4 + 857760878 | 0), bI(A8 + 24 | 0, h4 + t4 | 0), bI(A8 + 28 | 0, p4 + e4 | 0), bI(A8 + 32 | 0, u4 + f4 | 0), bI(A8 + 36 | 0, _4 + c4 | 0), bI(A8 + 40 | 0, G4 + 2036477234 | 0), bI(A8 + 44 | 0, I7 + E4 | 0), bI(A8 + 48 | 0, s4 + i4 | 0), bI(A8 + 52 | 0, y4 + a4 | 0), bI(A8 + 56 | 0, l4 + r4 | 0), bI(A8 + 60 | 0, F4 + 1797285236 | 0);
                      }
                      function J3(A8, I7, g6, B4, C4, E4) {
                        var i4, a4 = 0, o4 = 0, t4 = 0, e4 = 0, f4 = 0, c4 = 0, y4 = 0, w4 = 0, D4 = 0;
                        for (s3 = i4 = s3 - 592 | 0, e4 = -1, f4 = A8 + 32 | 0, a4 = 32, o4 = 1; t4 = (c4 = n3[f4 + (a4 = a4 - 1 | 0) | 0]) - (y4 = n3[a4 + 2752 | 0]) >> 8 & o4 | 255 & t4, o4 &= 65535 + (c4 ^ y4) >>> 8, a4; )
                          ;
                        if (t4 && !sA(A8)) {
                          for (a4 = 127 & (-1 ^ n3[C4 + 31 | 0]), t4 = 30; a4 = -1 ^ n3[C4 + t4 | 0] | a4, t4 = t4 - 1 | 0; )
                            ;
                          if (((255 & a4) - 1 & 236 - n3[0 | C4]) << 23 >> 31 != -1 && !sA(C4) && !V3(i4 + 128 | 0, C4)) {
                            WI(a4 = i4 + 384 | 0, E4), z3(a4, A8, 32, 0), z3(a4, C4, 32, 0), z3(a4, I7, g6, B4), MA(a4, I7 = i4 + 320 | 0), l3(I7), s3 = B4 = s3 - 2272 | 0, oA(B4 + 2016 | 0, I7), oA(B4 + 1760 | 0, f4), DI(g6 = B4 + 480 | 0, C4 = i4 + 128 | 0), fI(I7 = B4 + 320 | 0, C4), tI(B4, I7), xA(I7, B4, g6), tI(g6 = B4 + 160 | 0, I7), DI(C4 = B4 + 640 | 0, g6), xA(I7, B4, C4), tI(g6, I7), DI(C4 = B4 + 800 | 0, g6), xA(I7, B4, C4), tI(g6, I7), DI(C4 = B4 + 960 | 0, g6), xA(I7, B4, C4), tI(g6, I7), DI(C4 = B4 + 1120 | 0, g6), xA(I7, B4, C4), tI(g6, I7), DI(C4 = B4 + 1280 | 0, g6), xA(I7, B4, C4), tI(g6, I7), DI(C4 = B4 + 1440 | 0, g6), xA(I7, B4, C4), tI(g6, I7), DI(B4 + 1600 | 0, g6), hg(E4 = i4 + 8 | 0), ng(E4 + 40 | 0), ng(E4 + 80 | 0), C4 = 255;
                            A: {
                              for (; ; ) {
                                if (!(n3[(I7 = C4) + (B4 + 2016 | 0) | 0] | n3[(B4 + 1760 | 0) + I7 | 0])) {
                                  if (C4 = I7 - 1 | 0, I7)
                                    continue;
                                  break A;
                                }
                                break;
                              }
                              if (!((0 | I7) < 0))
                                for (; G3(B4 + 320 | 0, E4), g6 = I7, (0 | (I7 = Q3[(B4 + 2016 | 0) + I7 | 0])) > 0 ? (tI(C4 = B4 + 160 | 0, a4 = B4 + 320 | 0), xA(a4, C4, (B4 + 480 | 0) + r3((254 & I7) >>> 1 | 0, 160) | 0)) : (0 | I7) >= 0 || (tI(C4 = B4 + 160 | 0, a4 = B4 + 320 | 0), JA(a4, C4, (B4 + 480 | 0) + r3((0 - I7 & 254) >>> 1 | 0, 160) | 0)), (0 | (o4 = Q3[g6 + (B4 + 1760 | 0) | 0])) > 0 ? (tI(I7 = B4 + 160 | 0, C4 = B4 + 320 | 0), TA(C4, I7, r3((254 & o4) >>> 1 | 0, 120) + 1568 | 0)) : (0 | o4) >= 0 || (tI(C4 = B4 + 160 | 0, I7 = B4 + 320 | 0), s3 = t4 = s3 - 48 | 0, yA(I7, e4 = C4 + 40 | 0, C4), cA(a4 = I7 + 40 | 0, e4, C4), H3(e4 = I7 + 80 | 0, I7, 40 + (f4 = r3((0 - o4 & 254) >>> 1 | 0, 120) + 1568 | 0) | 0), H3(a4, a4, f4), H3(o4 = I7 + 120 | 0, f4 + 80 | 0, C4 + 120 | 0), yA(t4, C4 = C4 + 80 | 0, C4), cA(I7, e4, a4), yA(a4, e4, a4), cA(e4, t4, o4), yA(o4, t4, o4), s3 = t4 + 48 | 0), hI(E4, B4 + 320 | 0), I7 = g6 - 1 | 0, (0 | g6) > 0; )
                                  ;
                            }
                            s3 = B4 + 2272 | 0, II(I7 = i4 + 288 | 0, E4), w4 = -1, D4 = eg(I7, A8), e4 = ((0 | A8) == (0 | I7) ? w4 : D4) | zA(A8, I7, 32);
                          }
                        }
                        return s3 = i4 + 592 | 0, e4;
                      }
                      function x3(A8, I7, g6) {
                        var B4 = 0, C4 = 0, Q4 = 0, E4 = 0, i4 = 0, a4 = 0, r4 = 0, o4 = 0, t4 = 0, e4 = 0, f4 = 0, c4 = 0, y4 = 0, s4 = 0, w4 = 0, D4 = 0, h4 = 0, p4 = 0, u4 = 0;
                        for (Q4 = 2036477234, t4 = 857760878, e4 = 1634760805, E4 = 1797285236, o4 = n3[0 | g6] | n3[g6 + 1 | 0] << 8 | n3[g6 + 2 | 0] << 16 | n3[g6 + 3 | 0] << 24, B4 = n3[g6 + 4 | 0] | n3[g6 + 5 | 0] << 8 | n3[g6 + 6 | 0] << 16 | n3[g6 + 7 | 0] << 24, C4 = n3[g6 + 8 | 0] | n3[g6 + 9 | 0] << 8 | n3[g6 + 10 | 0] << 16 | n3[g6 + 11 | 0] << 24, a4 = n3[g6 + 12 | 0] | n3[g6 + 13 | 0] << 8 | n3[g6 + 14 | 0] << 16 | n3[g6 + 15 | 0] << 24, c4 = n3[g6 + 16 | 0] | n3[g6 + 17 | 0] << 8 | n3[g6 + 18 | 0] << 16 | n3[g6 + 19 | 0] << 24, y4 = n3[g6 + 20 | 0] | n3[g6 + 21 | 0] << 8 | n3[g6 + 22 | 0] << 16 | n3[g6 + 23 | 0] << 24, w4 = n3[g6 + 24 | 0] | n3[g6 + 25 | 0] << 8 | n3[g6 + 26 | 0] << 16 | n3[g6 + 27 | 0] << 24, D4 = n3[g6 + 28 | 0] | n3[g6 + 29 | 0] << 8 | n3[g6 + 30 | 0] << 16 | n3[g6 + 31 | 0] << 24, g6 = n3[0 | I7] | n3[I7 + 1 | 0] << 8 | n3[I7 + 2 | 0] << 16 | n3[I7 + 3 | 0] << 24, f4 = n3[I7 + 4 | 0] | n3[I7 + 5 | 0] << 8 | n3[I7 + 6 | 0] << 16 | n3[I7 + 7 | 0] << 24, i4 = n3[I7 + 8 | 0] | n3[I7 + 9 | 0] << 8 | n3[I7 + 10 | 0] << 16 | n3[I7 + 11 | 0] << 24, I7 = n3[I7 + 12 | 0] | n3[I7 + 13 | 0] << 8 | n3[I7 + 14 | 0] << 16 | n3[I7 + 15 | 0] << 24; r4 = o4, e4 = cg((s4 = g6) ^ (g6 = o4 + e4 | 0), 16), r4 = c4 = cg(r4 ^ (o4 = e4 + c4 | 0), 12), c4 = cg((s4 = e4) ^ (e4 = g6 + c4 | 0), 8), o4 = cg(r4 ^ (h4 = c4 + o4 | 0), 7), r4 = B4, t4 = cg((g6 = B4 + t4 | 0) ^ f4, 16), r4 = f4 = cg(r4 ^ (B4 = t4 + y4 | 0), 12), f4 = cg((s4 = t4) ^ (t4 = g6 + f4 | 0), 8), g6 = cg(r4 ^ (y4 = f4 + B4 | 0), 7), r4 = C4, B4 = cg((Q4 = Q4 + C4 | 0) ^ i4, 16), r4 = i4 = cg(r4 ^ (C4 = B4 + w4 | 0), 12), s4 = cg(B4 ^ (i4 = Q4 + i4 | 0), 8), Q4 = cg(r4 ^ (B4 = s4 + C4 | 0), 7), E4 = cg((C4 = I7) ^ (I7 = E4 + a4 | 0), 16), a4 = cg((C4 = E4 + D4 | 0) ^ a4, 12), I7 = cg(E4 ^ (p4 = I7 + a4 | 0), 8), E4 = cg(a4 ^ (C4 = I7 + C4 | 0), 7), r4 = B4, B4 = cg((B4 = I7) ^ (I7 = g6 + e4 | 0), 16), g6 = cg((a4 = r4 + B4 | 0) ^ g6, 12), I7 = cg(B4 ^ (e4 = I7 + g6 | 0), 8), B4 = cg(g6 ^ (w4 = a4 + I7 | 0), 7), r4 = C4, C4 = cg((g6 = Q4 + t4 | 0) ^ c4, 16), Q4 = cg((a4 = r4 + C4 | 0) ^ Q4, 12), g6 = cg(C4 ^ (t4 = g6 + Q4 | 0), 8), C4 = cg(Q4 ^ (D4 = a4 + g6 | 0), 7), a4 = cg((Q4 = E4 + i4 | 0) ^ f4, 16), E4 = cg((i4 = a4 + h4 | 0) ^ E4, 12), f4 = cg(a4 ^ (Q4 = Q4 + E4 | 0), 8), a4 = cg(E4 ^ (c4 = i4 + f4 | 0), 7), i4 = cg((E4 = o4 + p4 | 0) ^ s4, 16), o4 = cg((y4 = i4 + y4 | 0) ^ o4, 12), i4 = cg(i4 ^ (E4 = E4 + o4 | 0), 8), o4 = cg(o4 ^ (y4 = y4 + i4 | 0), 7), (0 | (u4 = u4 + 1 | 0)) != 10; )
                          ;
                        bI(A8, e4), bI(A8 + 4 | 0, t4), bI(A8 + 8 | 0, Q4), bI(A8 + 12 | 0, E4), bI(A8 + 16 | 0, g6), bI(A8 + 20 | 0, f4), bI(A8 + 24 | 0, i4), bI(A8 + 28 | 0, I7);
                      }
                      function L3(A8, I7, g6, B4, C4, E4, n4, a4) {
                        A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0, C4 |= 0, E4 |= 0, n4 |= 0;
                        var r4, o4 = 0, t4 = 0, e4 = 0, f4 = 0, c4 = 0, y4 = 0, w4 = 0, D4 = 0, h4 = 0;
                        s3 = r4 = s3 - 16 | 0, ag(a4 |= 0);
                        A: {
                          I:
                            if (B4) {
                              D4 = 4 & a4;
                              g:
                                for (; ; ) {
                                  for (t4 = f4; ; ) {
                                    o4 = Q3[g6 + t4 | 0];
                                    B: {
                                      if (D4 ? (e4 = o4 + 4 & (o4 + 65488 >>> 8 ^ -1) & (57 - o4 >>> 8 ^ -1) & 255 | ((e4 = o4 - 65 | 0) >>> 8 ^ -1) & e4 & (90 - o4 >>> 8 ^ -1) & 255 | o4 + 185 & (o4 + 65439 >>> 8 ^ -1) & (122 - o4 >>> 8 ^ -1) & 255 | 63 & (1 + (16288 ^ o4) >>> 8 ^ -1) | 62 & (1 + (16338 ^ o4) >>> 8 ^ -1), e4 |= (0 - e4 >>> 8 ^ -1) & 1 + (65470 ^ o4) >>> 8 & 255) : (e4 = o4 + 4 & (o4 + 65488 >>> 8 ^ -1) & (57 - o4 >>> 8 ^ -1) & 255 | ((e4 = o4 - 65 | 0) >>> 8 ^ -1) & e4 & (90 - o4 >>> 8 ^ -1) & 255 | o4 + 185 & (o4 + 65439 >>> 8 ^ -1) & (122 - o4 >>> 8 ^ -1) & 255 | 63 & (1 + (16336 ^ o4) >>> 8 ^ -1) | 62 & (1 + (16340 ^ o4) >>> 8 ^ -1), e4 |= (0 - e4 >>> 8 ^ -1) & 1 + (65470 ^ o4) >>> 8 & 255), (0 | e4) == 255) {
                                        if (!C4)
                                          break I;
                                        if (DA(C4, o4))
                                          break B;
                                        f4 = t4;
                                        break I;
                                      }
                                      if (w4 = e4 + (w4 << 6) | 0, (f4 = c4 + 6 | 0) >>> 0 < 8)
                                        c4 = f4;
                                      else {
                                        if (c4 = c4 - 2 | 0, I7 >>> 0 <= y4 >>> 0) {
                                          i3[r4 + 12 >> 2] = t4, i3[8952] = 68, h4 = 1;
                                          break A;
                                        }
                                        Q3[A8 + y4 | 0] = w4 >>> c4, y4 = y4 + 1 | 0;
                                      }
                                      if ((f4 = t4 + 1 | 0) >>> 0 < B4 >>> 0)
                                        continue g;
                                      break I;
                                    }
                                    if (!((t4 = t4 + 1 | 0) >>> 0 < B4 >>> 0))
                                      break;
                                  }
                                  break;
                                }
                              f4 = (A8 = f4 + 1 | 0) >>> 0 < B4 >>> 0 ? B4 : A8;
                            }
                          i3[r4 + 12 >> 2] = f4;
                        }
                        A:
                          if (c4 >>> 0 > 4)
                            I7 = 0, A8 = -1;
                          else if (A8 = -1, I7 = 0, !((-1 << c4 ^ -1) & w4 | h4)) {
                            if (!(2 & a4)) {
                              I: {
                                g: {
                                  if (a4 = c4 >>> 1 | 0)
                                    for (A8 = i3[r4 + 12 >> 2]; ; ) {
                                      if (A8 >>> 0 >= B4 >>> 0) {
                                        t4 = 68;
                                        break g;
                                      }
                                      if ((0 | (f4 = Q3[A8 + g6 | 0])) != 61) {
                                        if (t4 = 28, !C4)
                                          break g;
                                        if (!DA(C4, f4))
                                          break g;
                                      } else
                                        a4 = a4 - 1 | 0;
                                      if (A8 = A8 + 1 | 0, i3[r4 + 12 >> 2] = A8, !a4)
                                        break;
                                    }
                                  A8 = 0;
                                  break I;
                                }
                                i3[8952] = t4, A8 = -1;
                              }
                              if (A8)
                                break A;
                            }
                            if (A8 = 0, C4) {
                              I:
                                if (!((t4 = i3[r4 + 12 >> 2]) >>> 0 >= B4 >>> 0)) {
                                  for (; ; ) {
                                    if (!DA(C4, Q3[g6 + t4 | 0]))
                                      break I;
                                    if ((0 | (t4 = t4 + 1 | 0)) == (0 | B4))
                                      break;
                                  }
                                  t4 = B4;
                                }
                              i3[r4 + 12 >> 2] = t4;
                            }
                            I7 = y4;
                          }
                        return C4 = i3[r4 + 12 >> 2], n4 ? i3[n4 >> 2] = g6 + C4 : (0 | B4) != (0 | C4) && (i3[8952] = 28, A8 = -1), E4 && (i3[E4 >> 2] = I7), s3 = r4 + 16 | 0, 0 | A8;
                      }
                      function K3(A8, I7, g6) {
                        var B4 = 0, C4 = 0, Q4 = 0, E4 = 0, i4 = 0, a4 = 0, r4 = 0, o4 = 0, t4 = 0, e4 = 0, f4 = 0, c4 = 0, y4 = 0, s4 = 0, w4 = 0, D4 = 0, h4 = 0, p4 = 0, u4 = 0, F4 = 0, l4 = 0;
                        for (C4 = 2036477234, Q4 = 857760878, E4 = 1634760805, i4 = 1797285236, w4 = 20, o4 = n3[0 | g6] | n3[g6 + 1 | 0] << 8 | n3[g6 + 2 | 0] << 16 | n3[g6 + 3 | 0] << 24, s4 = n3[g6 + 4 | 0] | n3[g6 + 5 | 0] << 8 | n3[g6 + 6 | 0] << 16 | n3[g6 + 7 | 0] << 24, D4 = n3[g6 + 8 | 0] | n3[g6 + 9 | 0] << 8 | n3[g6 + 10 | 0] << 16 | n3[g6 + 11 | 0] << 24, c4 = n3[g6 + 12 | 0] | n3[g6 + 13 | 0] << 8 | n3[g6 + 14 | 0] << 16 | n3[g6 + 15 | 0] << 24, t4 = n3[g6 + 16 | 0] | n3[g6 + 17 | 0] << 8 | n3[g6 + 18 | 0] << 16 | n3[g6 + 19 | 0] << 24, a4 = n3[g6 + 20 | 0] | n3[g6 + 21 | 0] << 8 | n3[g6 + 22 | 0] << 16 | n3[g6 + 23 | 0] << 24, e4 = n3[g6 + 24 | 0] | n3[g6 + 25 | 0] << 8 | n3[g6 + 26 | 0] << 16 | n3[g6 + 27 | 0] << 24, f4 = n3[g6 + 28 | 0] | n3[g6 + 29 | 0] << 8 | n3[g6 + 30 | 0] << 16 | n3[g6 + 31 | 0] << 24, g6 = n3[0 | I7] | n3[I7 + 1 | 0] << 8 | n3[I7 + 2 | 0] << 16 | n3[I7 + 3 | 0] << 24, r4 = n3[I7 + 4 | 0] | n3[I7 + 5 | 0] << 8 | n3[I7 + 6 | 0] << 16 | n3[I7 + 7 | 0] << 24, B4 = n3[I7 + 8 | 0] | n3[I7 + 9 | 0] << 8 | n3[I7 + 10 | 0] << 16 | n3[I7 + 11 | 0] << 24, I7 = n3[I7 + 12 | 0] | n3[I7 + 13 | 0] << 8 | n3[I7 + 14 | 0] << 16 | n3[I7 + 15 | 0] << 24; h4 = B4, B4 = cg(E4 + a4 | 0, 7) ^ c4, y4 = h4 ^ cg(B4 + E4 | 0, 9), p4 = cg(B4 + y4 | 0, 13) ^ a4, c4 = cg(y4 + p4 | 0, 18), I7 = cg(Q4 + o4 | 0, 7) ^ I7, e4 = cg(I7 + Q4 | 0, 9) ^ e4, o4 = cg(I7 + e4 | 0, 13) ^ o4, F4 = cg(e4 + o4 | 0, 18), f4 = cg(g6 + C4 | 0, 7) ^ f4, a4 = cg(f4 + C4 | 0, 9) ^ s4, u4 = cg(a4 + f4 | 0, 13) ^ g6, l4 = cg(a4 + u4 | 0, 18), g6 = cg(i4 + t4 | 0, 7) ^ D4, r4 = cg(g6 + i4 | 0, 9) ^ r4, t4 = cg(g6 + r4 | 0, 13) ^ t4, h4 = cg(r4 + t4 | 0, 18), o4 = cg((E4 ^= c4) + g6 | 0, 7) ^ o4, s4 = cg(o4 + E4 | 0, 9) ^ a4, D4 = cg(o4 + s4 | 0, 13) ^ g6, E4 = cg(s4 + D4 | 0, 18) ^ E4, g6 = cg((Q4 ^= F4) + B4 | 0, 7) ^ u4, r4 = cg(g6 + Q4 | 0, 9) ^ r4, c4 = cg(g6 + r4 | 0, 13) ^ B4, Q4 = cg(r4 + c4 | 0, 18) ^ Q4, t4 = cg((C4 ^= l4) + I7 | 0, 7) ^ t4, B4 = cg(t4 + C4 | 0, 9) ^ y4, I7 = cg(B4 + t4 | 0, 13) ^ I7, C4 = cg(I7 + B4 | 0, 18) ^ C4, a4 = cg((i4 ^= h4) + f4 | 0, 7) ^ p4, e4 = cg(a4 + i4 | 0, 9) ^ e4, f4 = cg(a4 + e4 | 0, 13) ^ f4, i4 = cg(e4 + f4 | 0, 18) ^ i4, y4 = w4 >>> 0 > 2, w4 = w4 - 2 | 0, y4; )
                          ;
                        return bI(A8, E4), bI(A8 + 4 | 0, Q4), bI(A8 + 8 | 0, C4), bI(A8 + 12 | 0, i4), bI(A8 + 16 | 0, g6), bI(A8 + 20 | 0, r4), bI(A8 + 24 | 0, B4), bI(A8 + 28 | 0, I7), 0;
                      }
                      function X3(A8) {
                        var I7, g6 = 0, B4 = 0;
                        s3 = I7 = s3 - 48 | 0, g6 = n3[28 + (A8 |= 0) | 0] | n3[A8 + 29 | 0] << 8 | n3[A8 + 30 | 0] << 16 | n3[A8 + 31 | 0] << 24, i3[I7 + 24 >> 2] = n3[A8 + 24 | 0] | n3[A8 + 25 | 0] << 8 | n3[A8 + 26 | 0] << 16 | n3[A8 + 27 | 0] << 24, i3[I7 + 28 >> 2] = g6, g6 = n3[A8 + 20 | 0] | n3[A8 + 21 | 0] << 8 | n3[A8 + 22 | 0] << 16 | n3[A8 + 23 | 0] << 24, i3[I7 + 16 >> 2] = n3[A8 + 16 | 0] | n3[A8 + 17 | 0] << 8 | n3[A8 + 18 | 0] << 16 | n3[A8 + 19 | 0] << 24, i3[I7 + 20 >> 2] = g6, g6 = n3[A8 + 4 | 0] | n3[A8 + 5 | 0] << 8 | n3[A8 + 6 | 0] << 16 | n3[A8 + 7 | 0] << 24, i3[I7 >> 2] = n3[0 | A8] | n3[A8 + 1 | 0] << 8 | n3[A8 + 2 | 0] << 16 | n3[A8 + 3 | 0] << 24, i3[I7 + 4 >> 2] = g6, g6 = n3[A8 + 12 | 0] | n3[A8 + 13 | 0] << 8 | n3[A8 + 14 | 0] << 16 | n3[A8 + 15 | 0] << 24, i3[I7 + 8 >> 2] = n3[A8 + 8 | 0] | n3[A8 + 9 | 0] << 8 | n3[A8 + 10 | 0] << 16 | n3[A8 + 11 | 0] << 24, i3[I7 + 12 >> 2] = g6, g6 = n3[A8 + 40 | 0] | n3[A8 + 41 | 0] << 8 | n3[A8 + 42 | 0] << 16 | n3[A8 + 43 | 0] << 24, i3[I7 + 32 >> 2] = n3[A8 + 36 | 0] | n3[A8 + 37 | 0] << 8 | n3[A8 + 38 | 0] << 16 | n3[A8 + 39 | 0] << 24, i3[I7 + 36 >> 2] = g6, vg[i3[8752]](I7, I7, 40, 0, A8 + 32 | 0, 0, A8), g6 = i3[I7 + 28 >> 2], B4 = i3[I7 + 24 >> 2], Q3[A8 + 24 | 0] = B4, Q3[A8 + 25 | 0] = B4 >>> 8, Q3[A8 + 26 | 0] = B4 >>> 16, Q3[A8 + 27 | 0] = B4 >>> 24, Q3[A8 + 28 | 0] = g6, Q3[A8 + 29 | 0] = g6 >>> 8, Q3[A8 + 30 | 0] = g6 >>> 16, Q3[A8 + 31 | 0] = g6 >>> 24, g6 = i3[I7 + 20 >> 2], B4 = i3[I7 + 16 >> 2], Q3[A8 + 16 | 0] = B4, Q3[A8 + 17 | 0] = B4 >>> 8, Q3[A8 + 18 | 0] = B4 >>> 16, Q3[A8 + 19 | 0] = B4 >>> 24, Q3[A8 + 20 | 0] = g6, Q3[A8 + 21 | 0] = g6 >>> 8, Q3[A8 + 22 | 0] = g6 >>> 16, Q3[A8 + 23 | 0] = g6 >>> 24, g6 = i3[I7 + 12 >> 2], B4 = i3[I7 + 8 >> 2], Q3[A8 + 8 | 0] = B4, Q3[A8 + 9 | 0] = B4 >>> 8, Q3[A8 + 10 | 0] = B4 >>> 16, Q3[A8 + 11 | 0] = B4 >>> 24, Q3[A8 + 12 | 0] = g6, Q3[A8 + 13 | 0] = g6 >>> 8, Q3[A8 + 14 | 0] = g6 >>> 16, Q3[A8 + 15 | 0] = g6 >>> 24, g6 = i3[I7 + 4 >> 2], B4 = i3[I7 >> 2], Q3[0 | A8] = B4, Q3[A8 + 1 | 0] = B4 >>> 8, Q3[A8 + 2 | 0] = B4 >>> 16, Q3[A8 + 3 | 0] = B4 >>> 24, Q3[A8 + 4 | 0] = g6, Q3[A8 + 5 | 0] = g6 >>> 8, Q3[A8 + 6 | 0] = g6 >>> 16, Q3[A8 + 7 | 0] = g6 >>> 24, g6 = i3[I7 + 36 >> 2], B4 = i3[I7 + 32 >> 2], Q3[A8 + 36 | 0] = B4, Q3[A8 + 37 | 0] = B4 >>> 8, Q3[A8 + 38 | 0] = B4 >>> 16, Q3[A8 + 39 | 0] = B4 >>> 24, Q3[A8 + 40 | 0] = g6, Q3[A8 + 41 | 0] = g6 >>> 8, Q3[A8 + 42 | 0] = g6 >>> 16, Q3[A8 + 43 | 0] = g6 >>> 24, YI(A8), s3 = I7 + 48 | 0;
                      }
                      function T3(A8, I7) {
                        var g6, B4, C4, E4, n4, a4, o4, t4, e4 = 0, f4 = 0;
                        s3 = g6 = s3 - 48 | 0, B4 = i3[I7 + 28 >> 2], C4 = i3[I7 + 24 >> 2], E4 = i3[I7 + 20 >> 2], n4 = i3[I7 + 16 >> 2], a4 = i3[I7 + 12 >> 2], o4 = i3[I7 + 8 >> 2], t4 = i3[I7 + 4 >> 2], e4 = i3[I7 >> 2], f4 = i3[I7 + 36 >> 2], I7 = i3[I7 + 32 >> 2], e4 = r3(((B4 + (C4 + (E4 + (n4 + (a4 + (o4 + (t4 + (e4 + (r3(f4, 19) + 16777216 >>> 25 | 0) >> 26) >> 25) >> 26) >> 25) >> 26) >> 25) >> 26) >> 25) + I7 >> 26) + f4 >> 25, 19) + e4 | 0, i3[g6 >> 2] = 67108863 & e4, e4 = t4 + (e4 >> 26) | 0, i3[g6 + 4 >> 2] = 33554431 & e4, e4 = o4 + (e4 >> 25) | 0, i3[g6 + 8 >> 2] = 67108863 & e4, e4 = a4 + (e4 >> 26) | 0, i3[g6 + 12 >> 2] = 33554431 & e4, e4 = n4 + (e4 >> 25) | 0, i3[g6 + 16 >> 2] = 67108863 & e4, e4 = E4 + (e4 >> 26) | 0, i3[g6 + 20 >> 2] = 33554431 & e4, e4 = C4 + (e4 >> 25) | 0, i3[g6 + 24 >> 2] = 67108863 & e4, e4 = B4 + (e4 >> 26) | 0, i3[g6 + 28 >> 2] = 33554431 & e4, I7 = I7 + (e4 >> 25) | 0, i3[g6 + 32 >> 2] = 67108863 & I7, i3[g6 + 36 >> 2] = f4 + (I7 >> 26) & 33554431, I7 = i3[g6 >> 2], Q3[0 | A8] = I7, Q3[A8 + 2 | 0] = I7 >>> 16, Q3[A8 + 1 | 0] = I7 >>> 8, f4 = i3[g6 + 4 >> 2], Q3[A8 + 5 | 0] = f4 >>> 14, Q3[A8 + 4 | 0] = f4 >>> 6, Q3[A8 + 3 | 0] = f4 << 2 | I7 >>> 24, I7 = i3[g6 + 8 >> 2], Q3[A8 + 8 | 0] = I7 >>> 13, Q3[A8 + 7 | 0] = I7 >>> 5, Q3[A8 + 6 | 0] = I7 << 3 | f4 >>> 22, f4 = i3[g6 + 12 >> 2], Q3[A8 + 11 | 0] = f4 >>> 11, Q3[A8 + 10 | 0] = f4 >>> 3, Q3[A8 + 9 | 0] = f4 << 5 | I7 >>> 21, I7 = i3[g6 + 16 >> 2], Q3[A8 + 15 | 0] = I7 >>> 18, Q3[A8 + 14 | 0] = I7 >>> 10, Q3[A8 + 13 | 0] = I7 >>> 2, Q3[A8 + 12 | 0] = I7 << 6 | f4 >>> 19, I7 = i3[g6 + 20 >> 2], Q3[A8 + 16 | 0] = I7, Q3[A8 + 18 | 0] = I7 >>> 16, Q3[A8 + 17 | 0] = I7 >>> 8, f4 = i3[g6 + 24 >> 2], Q3[A8 + 21 | 0] = f4 >>> 15, Q3[A8 + 20 | 0] = f4 >>> 7, Q3[A8 + 19 | 0] = f4 << 1 | I7 >>> 24, I7 = i3[g6 + 28 >> 2], Q3[A8 + 24 | 0] = I7 >>> 13, Q3[A8 + 23 | 0] = I7 >>> 5, Q3[A8 + 22 | 0] = I7 << 3 | f4 >>> 23, f4 = i3[g6 + 32 >> 2], Q3[A8 + 27 | 0] = f4 >>> 12, Q3[A8 + 26 | 0] = f4 >>> 4, Q3[A8 + 25 | 0] = f4 << 4 | I7 >>> 21, I7 = i3[g6 + 36 >> 2], Q3[A8 + 31 | 0] = I7 >>> 18, Q3[A8 + 30 | 0] = I7 >>> 10, Q3[A8 + 29 | 0] = I7 >>> 2, Q3[A8 + 28 | 0] = I7 << 6 | f4 >>> 20, s3 = g6 + 48 | 0;
                      }
                      function V3(A8, I7) {
                        var g6, B4, C4, Q4, E4, i4 = 0, a4 = 0, r4 = 0;
                        for (s3 = g6 = s3 - 288 | 0, N3(E4 = A8 + 40 | 0, I7), ng(a4 = A8 + 80 | 0), U3(B4 = g6 + 240 | 0, E4), H3(C4 = g6 + 192 | 0, B4, 1424), cA(B4, B4, a4), yA(C4, C4, a4), U3(Q4 = g6 + 144 | 0, C4), H3(Q4, Q4, C4), U3(A8, Q4), H3(A8, A8, C4), H3(A8, A8, B4), s3 = a4 = s3 - 144 | 0, U3(i4 = a4 + 96 | 0, A8), U3(r4 = a4 + 48 | 0, i4), U3(r4, r4), H3(r4, A8, r4), H3(i4, i4, r4), U3(i4, i4), H3(i4, r4, i4), U3(r4, i4), i4 = 1; U3(r4 = a4 + 48 | 0, r4), (0 | (i4 = i4 + 1 | 0)) != 5; )
                          ;
                        for (H3(i4 = a4 + 96 | 0, r4 = a4 + 48 | 0, i4), U3(r4, i4), i4 = 1; U3(r4 = a4 + 48 | 0, r4), (0 | (i4 = i4 + 1 | 0)) != 10; )
                          ;
                        for (H3(i4 = a4 + 48 | 0, i4, a4 + 96 | 0), U3(a4, i4), i4 = 1; U3(a4, a4), (0 | (i4 = i4 + 1 | 0)) != 20; )
                          ;
                        for (H3(i4 = a4 + 48 | 0, a4, i4), i4 = 1; U3(r4 = a4 + 48 | 0, r4), (0 | (i4 = i4 + 1 | 0)) != 11; )
                          ;
                        for (H3(i4 = a4 + 96 | 0, r4 = a4 + 48 | 0, i4), U3(r4, i4), i4 = 1; U3(r4 = a4 + 48 | 0, r4), (0 | (i4 = i4 + 1 | 0)) != 50; )
                          ;
                        for (H3(i4 = a4 + 48 | 0, i4, a4 + 96 | 0), U3(a4, i4), i4 = 1; U3(a4, a4), (0 | (i4 = i4 + 1 | 0)) != 100; )
                          ;
                        for (H3(i4 = a4 + 48 | 0, a4, i4), i4 = 1; U3(r4 = a4 + 48 | 0, r4), (0 | (i4 = i4 + 1 | 0)) != 51; )
                          ;
                        H3(i4 = a4 + 96 | 0, a4 + 48 | 0, i4), U3(i4, i4), U3(i4, i4), H3(A8, i4, A8), s3 = a4 + 144 | 0, H3(A8, A8, Q4), H3(A8, A8, B4), U3(a4 = g6 + 96 | 0, A8), H3(a4, a4, C4), cA(i4 = g6 + 48 | 0, a4, B4);
                        A: {
                          if (!mI(i4)) {
                            if (yA(g6, g6 + 96 | 0, g6 + 240 | 0), a4 = -1, !mI(g6))
                              break A;
                            H3(A8, A8, 1472);
                          }
                          (0 | vI(A8)) == (n3[I7 + 31 | 0] >>> 7 | 0) && kA(A8, A8), H3(A8 + 120 | 0, A8, E4), a4 = 0;
                        }
                        return s3 = g6 + 288 | 0, a4;
                      }
                      function q3(A8, I7, g6, B4, C4) {
                        var E4, a4, r4 = 0, o4 = 0, t4 = 0;
                        for (s3 = E4 = (s3 = a4 = s3 - 416 | 0) - 192 | 0, GI(a4), wI(E4 - -64 | 0, 54, 128), Q3[E4 + 64 | 0] = 54 ^ n3[0 | C4], r4 = 1; Q3[0 | (o4 = (E4 - -64 | 0) + r4 | 0)] = n3[0 | o4] ^ n3[C4 + r4 | 0], (0 | (r4 = r4 + 1 | 0)) != 32; )
                          ;
                        for (z3(a4, r4 = E4 - -64 | 0, 128, 0), GI(o4 = a4 + 208 | 0), wI(r4, 92, 128), Q3[E4 + 64 | 0] = 92 ^ n3[0 | C4], r4 = 1; Q3[0 | (t4 = (E4 - -64 | 0) + r4 | 0)] = n3[0 | t4] ^ n3[C4 + r4 | 0], (0 | (r4 = r4 + 1 | 0)) != 32; )
                          ;
                        return z3(o4, C4 = E4 - -64 | 0, 128, 0), Dg(C4, 128), Dg(E4, 64), s3 = E4 + 192 | 0, z3(a4, I7, g6, B4), s3 = g6 = (s3 = I7 = s3 + -64 | 0) - 64 | 0, MA(a4, g6), z3(B4 = a4 + 208 | 0, g6, 64, 0), MA(B4, I7), Dg(g6, 64), s3 = g6 - -64 | 0, g6 = i3[I7 + 28 >> 2], B4 = i3[I7 + 24 >> 2], Q3[A8 + 24 | 0] = B4, Q3[A8 + 25 | 0] = B4 >>> 8, Q3[A8 + 26 | 0] = B4 >>> 16, Q3[A8 + 27 | 0] = B4 >>> 24, Q3[A8 + 28 | 0] = g6, Q3[A8 + 29 | 0] = g6 >>> 8, Q3[A8 + 30 | 0] = g6 >>> 16, Q3[A8 + 31 | 0] = g6 >>> 24, g6 = i3[I7 + 20 >> 2], B4 = i3[I7 + 16 >> 2], Q3[A8 + 16 | 0] = B4, Q3[A8 + 17 | 0] = B4 >>> 8, Q3[A8 + 18 | 0] = B4 >>> 16, Q3[A8 + 19 | 0] = B4 >>> 24, Q3[A8 + 20 | 0] = g6, Q3[A8 + 21 | 0] = g6 >>> 8, Q3[A8 + 22 | 0] = g6 >>> 16, Q3[A8 + 23 | 0] = g6 >>> 24, g6 = i3[I7 + 12 >> 2], B4 = i3[I7 + 8 >> 2], Q3[A8 + 8 | 0] = B4, Q3[A8 + 9 | 0] = B4 >>> 8, Q3[A8 + 10 | 0] = B4 >>> 16, Q3[A8 + 11 | 0] = B4 >>> 24, Q3[A8 + 12 | 0] = g6, Q3[A8 + 13 | 0] = g6 >>> 8, Q3[A8 + 14 | 0] = g6 >>> 16, Q3[A8 + 15 | 0] = g6 >>> 24, g6 = i3[I7 + 4 >> 2], B4 = i3[I7 >> 2], Q3[0 | A8] = B4, Q3[A8 + 1 | 0] = B4 >>> 8, Q3[A8 + 2 | 0] = B4 >>> 16, Q3[A8 + 3 | 0] = B4 >>> 24, Q3[A8 + 4 | 0] = g6, Q3[A8 + 5 | 0] = g6 >>> 8, Q3[A8 + 6 | 0] = g6 >>> 16, Q3[A8 + 7 | 0] = g6 >>> 24, s3 = I7 - -64 | 0, s3 = a4 + 416 | 0, 0;
                      }
                      function z3(A8, I7, g6, B4) {
                        var C4, E4 = 0, a4 = 0, r4 = 0, o4 = 0, t4 = 0, e4 = 0;
                        s3 = C4 = s3 - 704 | 0;
                        A:
                          if (g6 | B4) {
                            if (r4 = B4 << 3 | (E4 = g6) >>> 29, a4 = (t4 = i3[A8 + 72 >> 2]) + (e4 = E4 << 3) | 0, E4 = r4 + (o4 = i3[A8 + 76 >> 2]) | 0, i3[A8 + 72 >> 2] = a4, E4 = a4 >>> 0 < e4 >>> 0 ? E4 + 1 | 0 : E4, i3[A8 + 76 >> 2] = E4, r4 = (e4 = (0 | E4) == (0 | o4) & a4 >>> 0 < t4 >>> 0 | E4 >>> 0 < o4 >>> 0) + i3[(a4 = A8 - -64 | 0) >> 2] | 0, E4 = i3[a4 + 4 >> 2], E4 = r4 >>> 0 < e4 >>> 0 ? E4 + 1 | 0 : E4, r4 = (e4 = B4 >>> 29 | 0) + r4 | 0, i3[a4 >> 2] = r4, i3[a4 + 4 >> 2] = r4 >>> 0 < e4 >>> 0 ? E4 + 1 | 0 : E4, a4 = 0, E4 = 0, (0 | (r4 = 0 - ((o4 = 127 & ((7 & o4) << 29 | t4 >>> 3)) >>> 0 > 128) | 0)) == (0 | B4) & g6 >>> 0 < (t4 = 128 - o4 | 0) >>> 0 | B4 >>> 0 < r4 >>> 0) {
                              for (; ; )
                                if (Q3[80 + (A8 + (t4 = a4 + o4 | 0) | 0) | 0] = n3[I7 + a4 | 0], !((0 | g6) != (0 | (a4 = a4 + 1 | 0)) | (0 | B4) != (0 | (E4 = a4 ? E4 : E4 + 1 | 0))))
                                  break A;
                            }
                            for (; Q3[80 + (A8 + (e4 = a4 + o4 | 0) | 0) | 0] = n3[I7 + a4 | 0], (0 | t4) != (0 | (a4 = a4 + 1 | 0)) | (0 | (E4 = a4 ? E4 : E4 + 1 | 0)) != (0 | r4); )
                              ;
                            if (F3(A8, A8 + 80 | 0, C4, E4 = C4 + 640 | 0), I7 = I7 + t4 | 0, !(B4 = B4 - ((g6 >>> 0 < t4 >>> 0) + r4 | 0) | 0) & (g6 = g6 - t4 | 0) >>> 0 > 127 | B4)
                              for (; F3(A8, I7, C4, E4), I7 = I7 + 128 | 0, !(B4 = B4 - (g6 >>> 0 < 128) | 0) & (g6 = g6 - 128 | 0) >>> 0 > 127 | B4; )
                                ;
                            if (g6 | B4)
                              for (a4 = 0, E4 = 0; Q3[80 + (A8 + a4 | 0) | 0] = n3[I7 + a4 | 0], (0 | g6) != (0 | (a4 = o4 = a4 + 1 | 0)) | (0 | B4) != (0 | (E4 = o4 ? E4 : E4 + 1 | 0)); )
                                ;
                            Dg(C4, 704);
                          }
                        return s3 = C4 + 704 | 0, 0;
                      }
                      function j3(A8, I7, g6) {
                        var B4, C4, Q4, E4 = 0;
                        s3 = B4 = s3 - 16 | 0, C4 = i3[A8 + 20 >> 2], i3[A8 + 20 >> 2] = 0, Q4 = i3[A8 + 4 >> 2], i3[A8 + 4 >> 2] = 0, E4 = -26;
                        A: {
                          I: {
                            g:
                              switch (g6 - 1 | 0) {
                                case 1:
                                  if (E4 = -32, LA(I7, 1109, 9))
                                    break A;
                                  I7 = I7 + 9 | 0;
                                  break I;
                                case 0:
                                  break g;
                                default:
                                  break A;
                              }
                            if (E4 = -32, LA(I7, 1100, 8))
                              break A;
                            I7 = I7 + 8 | 0;
                          }
                          if (!LA(I7, 1352, 3) && (I7 = _A(I7 + 3 | 0, B4 + 12 | 0))) {
                            if (E4 = -26, i3[B4 + 12 >> 2] != 19)
                              break A;
                            if (!LA(I7, 1364, 3) && (I7 = _A(I7 + 3 | 0, B4 + 12 | 0)) && (i3[A8 + 44 >> 2] = i3[B4 + 12 >> 2], !LA(I7, 1356, 3) && (I7 = _A(I7 + 3 | 0, B4 + 12 | 0)) && (i3[A8 + 40 >> 2] = i3[B4 + 12 >> 2], !LA(I7, 1360, 3) && (I7 = _A(I7 + 3 | 0, B4 + 12 | 0)) && (g6 = i3[B4 + 12 >> 2], i3[A8 + 48 >> 2] = g6, i3[A8 + 52 >> 2] = g6, (0 | (g6 = n3[0 | I7])) == 36 && (i3[B4 + 12 >> 2] = C4, I7 = I7 + ((0 | g6) == 36) | 0, !L3(i3[A8 + 16 >> 2], C4, I7, mA(I7), 0, B4 + 12 | 0, B4 + 8 | 0, 3) && (i3[A8 + 20 >> 2] = i3[B4 + 12 >> 2], I7 = i3[B4 + 8 >> 2], (0 | (g6 = n3[0 | I7])) == 36 && (i3[B4 + 12 >> 2] = Q4, I7 = I7 + ((0 | g6) == 36) | 0, !L3(i3[A8 >> 2], Q4, I7, mA(I7), 0, B4 + 12 | 0, B4 + 8 | 0, 3)))))))) {
                              if (i3[A8 + 4 >> 2] = i3[B4 + 12 >> 2], I7 = i3[B4 + 8 >> 2], E4 = nA(A8))
                                break A;
                              E4 = n3[0 | I7] ? -32 : 0;
                              break A;
                            }
                          }
                          E4 = -32;
                        }
                        return s3 = B4 + 16 | 0, E4;
                      }
                      function W3(A8, I7) {
                        var g6, B4, C4, E4, n4, a4, o4, t4, e4, f4, c4, y4 = 0, s4 = 0, w4 = 0, D4 = 0, h4 = 0, p4 = 0;
                        (s4 = i3[A8 + 56 >> 2]) | (y4 = i3[A8 + 60 >> 2]) && (Q3[(D4 = A8 + s4 | 0) - -64 | 0] = 1, !(y4 = (w4 = s4 + 1 | 0) ? y4 : y4 + 1 | 0) & w4 >>> 0 <= 15 && wI(D4 + 65 | 0, 0, 15 - s4 | 0), Q3[A8 + 80 | 0] = 1, M3(A8, A8 - -64 | 0, 16, 0)), e4 = i3[A8 + 52 >> 2], f4 = i3[A8 + 48 >> 2], c4 = i3[A8 + 44 >> 2], h4 = i3[A8 + 24 >> 2], w4 = i3[A8 + 28 >> 2] + (h4 >>> 26 | 0) | 0, s4 = i3[A8 + 32 >> 2] + (w4 >>> 26 | 0) | 0, C4 = i3[A8 + 36 >> 2] + (s4 >>> 26 | 0) | 0, a4 = 67108863 & s4, w4 = (s4 = (67108863 & h4) + ((y4 = i3[A8 + 20 >> 2] + r3(C4 >>> 26 | 0, 5) | 0) >>> 26 | 0) | 0) & (g6 = (E4 = (-67108864 | C4) + ((o4 = a4 + ((h4 = (p4 = 67108863 & w4) + ((y4 = s4 + ((n4 = 5 + (D4 = 67108863 & y4) | 0) >>> 26 | 0) | 0) >>> 26 | 0) | 0) >>> 26 | 0) | 0) >>> 26 | 0) | 0) >> 31) | (B4 = 67108863 & (t4 = (E4 >>> 31 | 0) - 1 | 0)) & y4, y4 = 0, y4 = (s4 = w4 << 26 | B4 & n4 | D4 & g6) >>> 0 > (D4 = s4 + i3[A8 + 40 >> 2] | 0) >>> 0 ? 1 : y4, bI(I7, D4), s4 = 0, s4 = (w4 = (p4 = p4 & g6 | h4 & B4) << 20 | w4 >>> 6) >>> 0 > (h4 = w4 + c4 | 0) >>> 0 ? 1 : s4, w4 = y4, h4 = y4 + h4 | 0, y4 = s4, y4 = w4 >>> 0 > h4 >>> 0 ? y4 + 1 | 0 : y4, bI(I7 + 4 | 0, h4), s4 = 0, s4 = (w4 = (D4 = g6 & a4 | B4 & o4) << 14 | p4 >>> 12) >>> 0 > (p4 = w4 + f4 | 0) >>> 0 ? 1 : s4, w4 = y4, p4 = y4 + p4 | 0, y4 = s4, y4 = w4 >>> 0 > p4 >>> 0 ? y4 + 1 | 0 : y4, bI(I7 + 8 | 0, p4), bI(s4 = I7 + 12 | 0, y4 = y4 + (D4 = (I7 = (E4 & t4 | g6 & C4) << 8 | D4 >>> 18) + e4 | 0) | 0), Dg(A8, 88);
                      }
                      function O3(A8, I7) {
                        var g6, B4, C4 = 0;
                        for (s3 = g6 = s3 - 192 | 0, U3(B4 = g6 + 144 | 0, I7), U3(C4 = g6 + 96 | 0, B4), U3(C4, C4), H3(C4, I7, C4), H3(B4, B4, C4), U3(I7 = g6 + 48 | 0, B4), H3(C4, C4, I7), U3(I7, C4), I7 = 1; U3(C4 = g6 + 48 | 0, C4), (0 | (I7 = I7 + 1 | 0)) != 5; )
                          ;
                        for (H3(I7 = g6 + 96 | 0, C4 = g6 + 48 | 0, I7), U3(C4, I7), I7 = 1; U3(C4 = g6 + 48 | 0, C4), (0 | (I7 = I7 + 1 | 0)) != 10; )
                          ;
                        for (H3(I7 = g6 + 48 | 0, I7, g6 + 96 | 0), U3(g6, I7), I7 = 1; U3(g6, g6), (0 | (I7 = I7 + 1 | 0)) != 20; )
                          ;
                        for (H3(I7 = g6 + 48 | 0, g6, I7), I7 = 1; U3(C4 = g6 + 48 | 0, C4), (0 | (I7 = I7 + 1 | 0)) != 11; )
                          ;
                        for (H3(I7 = g6 + 96 | 0, C4 = g6 + 48 | 0, I7), U3(C4, I7), I7 = 1; U3(C4 = g6 + 48 | 0, C4), (0 | (I7 = I7 + 1 | 0)) != 50; )
                          ;
                        for (H3(I7 = g6 + 48 | 0, I7, g6 + 96 | 0), U3(g6, I7), I7 = 1; U3(g6, g6), (0 | (I7 = I7 + 1 | 0)) != 100; )
                          ;
                        for (H3(I7 = g6 + 48 | 0, g6, I7), I7 = 1; U3(C4 = g6 + 48 | 0, C4), (0 | (I7 = I7 + 1 | 0)) != 51; )
                          ;
                        for (H3(I7 = g6 + 96 | 0, g6 + 48 | 0, I7), I7 = 1; U3(C4 = g6 + 96 | 0, C4), (0 | (I7 = I7 + 1 | 0)) != 6; )
                          ;
                        H3(A8, g6 + 96 | 0, g6 + 144 | 0), s3 = g6 + 192 | 0;
                      }
                      function Z3(A8, I7, g6, B4, C4) {
                        A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0;
                        var E4 = 0, i4 = 0, a4 = 0, o4 = 0, f4 = 0, c4 = 0, y4 = 0, s4 = 0;
                        ag(C4 |= 0), i4 = (E4 = (B4 >>> 0) / 3 | 0) << 2, (E4 = r3(E4, -3) + B4 | 0) && (i4 = 2 & C4 ? (2 | i4) + (E4 >>> 1 | 0) | 0 : i4 + 4 | 0);
                        A: {
                          I: {
                            g: {
                              if (I7 >>> 0 > i4 >>> 0) {
                                if (!(4 & C4)) {
                                  if (C4 = 0, !B4)
                                    break A;
                                  E4 = 0;
                                  break g;
                                }
                                if (C4 = 0, !B4)
                                  break A;
                                for (E4 = 0; ; ) {
                                  for (f4 = (o4 = n3[g6 + a4 | 0]) | f4 << 8, E4 = E4 + 8 | 0; c4 = E4, y4 = A8 + C4 | 0, s4 = Qg(f4 >>> (E4 = E4 - 6 | 0) & 63), Q3[0 | y4] = s4, C4 = C4 + 1 | 0, E4 >>> 0 > 5; )
                                    ;
                                  if ((0 | (a4 = a4 + 1 | 0)) == (0 | B4))
                                    break;
                                }
                                if (!E4)
                                  break A;
                                g6 = Qg(o4 << 12 - c4 & 63);
                                break I;
                              }
                              xI(), t3();
                            }
                            for (; ; ) {
                              for (f4 = (o4 = n3[g6 + a4 | 0]) | f4 << 8, E4 = E4 + 8 | 0; c4 = E4, y4 = A8 + C4 | 0, s4 = Eg(f4 >>> (E4 = E4 - 6 | 0) & 63), Q3[0 | y4] = s4, C4 = C4 + 1 | 0, E4 >>> 0 > 5; )
                                ;
                              if ((0 | (a4 = a4 + 1 | 0)) == (0 | B4))
                                break;
                            }
                            if (!E4)
                              break A;
                            g6 = Eg(o4 << 12 - c4 & 63);
                          }
                          Q3[A8 + C4 | 0] = g6, C4 = C4 + 1 | 0;
                        }
                        A: {
                          I: {
                            if (C4 >>> 0 <= i4 >>> 0) {
                              if (C4 >>> 0 < i4 >>> 0)
                                break I;
                              i4 = C4;
                              break A;
                            }
                            e3(1048, 1145, 230, 1375), t3();
                          }
                          wI(A8 + C4 | 0, 61, i4 - C4 | 0);
                        }
                        return wI(A8 + i4 | 0, 0, (I7 >>> 0 > (g6 = i4 + 1 | 0) >>> 0 ? I7 : g6) - i4 | 0), 0 | A8;
                      }
                      function $3(A8, I7, g6, B4) {
                        var C4 = 0, E4 = 0, a4 = 0, r4 = 0, o4 = 0, t4 = 0;
                        A: {
                          if ((r4 = i3[A8 + 56 >> 2]) | (o4 = i3[A8 + 60 >> 2])) {
                            if (t4 = C4 = (a4 = (0 | (C4 = 0 - ((r4 >>> 0 > 16) + o4 | 0) | 0)) == (0 | B4) & g6 >>> 0 > (E4 = 16 - r4 | 0) >>> 0 | B4 >>> 0 > C4 >>> 0) ? C4 : B4, C4 | (E4 = a4 ? E4 : g6))
                              for (a4 = 0, C4 = 0; Q3[(A8 + (o4 = a4 + r4 | 0) | 0) - -64 | 0] = n3[I7 + a4 | 0], r4 = i3[A8 + 56 >> 2], o4 = i3[A8 + 60 >> 2], (0 | E4) != (0 | (a4 = a4 + 1 | 0)) | (0 | (C4 = a4 ? C4 : C4 + 1 | 0)) != (0 | t4); )
                                ;
                            if (C4 = o4 + t4 | 0, C4 = (r4 = E4 + r4 | 0) >>> 0 < E4 >>> 0 ? C4 + 1 | 0 : C4, i3[A8 + 56 >> 2] = r4, i3[A8 + 60 >> 2] = C4, !C4 & r4 >>> 0 < 16)
                              break A;
                            M3(A8, A8 - -64 | 0, 16, 0), i3[A8 + 56 >> 2] = 0, i3[A8 + 60 >> 2] = 0, g6 = (C4 = g6) - E4 | 0, B4 = B4 - ((C4 >>> 0 < E4 >>> 0) + t4 | 0) | 0, I7 = I7 + E4 | 0;
                          }
                          if (!B4 & g6 >>> 0 >= 16 | B4 && (M3(A8, I7, C4 = -16 & g6, B4), g6 &= 15, B4 = 0, I7 = I7 + C4 | 0), g6 | B4) {
                            for (a4 = 0, C4 = 0; E4 = a4 + i3[A8 + 56 >> 2] | 0, Q3[(A8 + E4 | 0) - -64 | 0] = n3[I7 + a4 | 0], a4 = E4 = a4 + 1 | 0, (0 | g6) != (0 | E4) | (0 | B4) != (0 | (C4 = E4 ? C4 : C4 + 1 | 0)); )
                              ;
                            I7 = B4 + i3[A8 + 60 >> 2] | 0, I7 = (C4 = g6 + i3[A8 + 56 >> 2] | 0) >>> 0 < g6 >>> 0 ? I7 + 1 | 0 : I7, i3[A8 + 56 >> 2] = C4, i3[A8 + 60 >> 2] = I7;
                          }
                        }
                      }
                      function AA3(A8, I7, g6) {
                        var B4, C4, Q4, E4, n4, a4, r4, o4, t4, e4, f4, c4, y4 = 0, s4 = 0, w4 = 0, D4 = 0, h4 = 0, p4 = 0, u4 = 0, F4 = 0, l4 = 0;
                        B4 = i3[I7 + 4 >> 2], C4 = i3[A8 + 4 >> 2], Q4 = i3[I7 + 8 >> 2], s4 = i3[A8 + 8 >> 2], E4 = i3[I7 + 12 >> 2], w4 = i3[A8 + 12 >> 2], n4 = i3[I7 + 16 >> 2], D4 = i3[A8 + 16 >> 2], a4 = i3[I7 + 20 >> 2], h4 = i3[A8 + 20 >> 2], r4 = i3[I7 + 24 >> 2], p4 = i3[A8 + 24 >> 2], o4 = i3[I7 + 28 >> 2], u4 = i3[A8 + 28 >> 2], t4 = i3[I7 + 32 >> 2], F4 = i3[A8 + 32 >> 2], e4 = i3[I7 + 36 >> 2], l4 = i3[A8 + 36 >> 2], c4 = (g6 = 0 - g6 | 0) & ((f4 = i3[I7 >> 2]) ^ (y4 = i3[A8 >> 2])), i3[A8 >> 2] = c4 ^ y4, y4 = l4, l4 = g6 & (l4 ^ e4), i3[A8 + 36 >> 2] = y4 ^ l4, y4 = F4, F4 = g6 & (F4 ^ t4), i3[A8 + 32 >> 2] = y4 ^ F4, y4 = u4, u4 = g6 & (u4 ^ o4), i3[A8 + 28 >> 2] = y4 ^ u4, y4 = p4, p4 = g6 & (p4 ^ r4), i3[A8 + 24 >> 2] = y4 ^ p4, y4 = h4, h4 = g6 & (h4 ^ a4), i3[A8 + 20 >> 2] = y4 ^ h4, y4 = D4, D4 = g6 & (D4 ^ n4), i3[A8 + 16 >> 2] = y4 ^ D4, y4 = w4, w4 = g6 & (w4 ^ E4), i3[A8 + 12 >> 2] = y4 ^ w4, y4 = s4, s4 = g6 & (s4 ^ Q4), i3[A8 + 8 >> 2] = y4 ^ s4, y4 = A8, A8 = g6 & (B4 ^ C4), i3[y4 + 4 >> 2] = A8 ^ C4, i3[I7 + 36 >> 2] = l4 ^ e4, i3[I7 + 32 >> 2] = F4 ^ t4, i3[I7 + 28 >> 2] = u4 ^ o4, i3[I7 + 24 >> 2] = p4 ^ r4, i3[I7 + 20 >> 2] = h4 ^ a4, i3[I7 + 16 >> 2] = D4 ^ n4, i3[I7 + 12 >> 2] = w4 ^ E4, i3[I7 + 8 >> 2] = s4 ^ Q4, i3[I7 + 4 >> 2] = A8 ^ B4, i3[I7 >> 2] = f4 ^ c4;
                      }
                      function IA3(A8, I7) {
                        var g6;
                        i3[A8 >> 2] = 67108863 & (n3[0 | I7] | n3[I7 + 1 | 0] << 8 | n3[I7 + 2 | 0] << 16 | n3[I7 + 3 | 0] << 24), i3[A8 + 4 >> 2] = (n3[I7 + 3 | 0] | n3[I7 + 4 | 0] << 8 | n3[I7 + 5 | 0] << 16 | n3[I7 + 6 | 0] << 24) >>> 2 & 67108611, i3[A8 + 8 >> 2] = (n3[I7 + 6 | 0] | n3[I7 + 7 | 0] << 8 | n3[I7 + 8 | 0] << 16 | n3[I7 + 9 | 0] << 24) >>> 4 & 67092735, i3[A8 + 12 >> 2] = (n3[I7 + 9 | 0] | n3[I7 + 10 | 0] << 8 | n3[I7 + 11 | 0] << 16 | n3[I7 + 12 | 0] << 24) >>> 6 & 66076671, g6 = n3[I7 + 12 | 0] | n3[I7 + 13 | 0] << 8 | n3[I7 + 14 | 0] << 16 | n3[I7 + 15 | 0] << 24, i3[A8 + 20 >> 2] = 0, i3[A8 + 24 >> 2] = 0, i3[A8 + 28 >> 2] = 0, i3[A8 + 32 >> 2] = 0, i3[A8 + 36 >> 2] = 0, i3[A8 + 16 >> 2] = g6 >>> 8 & 1048575, i3[A8 + 40 >> 2] = n3[I7 + 16 | 0] | n3[I7 + 17 | 0] << 8 | n3[I7 + 18 | 0] << 16 | n3[I7 + 19 | 0] << 24, i3[A8 + 44 >> 2] = n3[I7 + 20 | 0] | n3[I7 + 21 | 0] << 8 | n3[I7 + 22 | 0] << 16 | n3[I7 + 23 | 0] << 24, i3[A8 + 48 >> 2] = n3[I7 + 24 | 0] | n3[I7 + 25 | 0] << 8 | n3[I7 + 26 | 0] << 16 | n3[I7 + 27 | 0] << 24, I7 = n3[I7 + 28 | 0] | n3[I7 + 29 | 0] << 8 | n3[I7 + 30 | 0] << 16 | n3[I7 + 31 | 0] << 24, Q3[A8 + 80 | 0] = 0, i3[A8 + 56 >> 2] = 0, i3[A8 + 60 >> 2] = 0, i3[A8 + 52 >> 2] = I7;
                      }
                      function gA2(A8, I7, g6, B4) {
                        var C4 = 0, E4 = 0, i4 = 0, a4 = 0, r4 = 0, o4 = 0;
                        if (g6 | B4) {
                          if (!B4 & (E4 = 256 - (C4 = n3[A8 + 352 | 0] | n3[A8 + 353 | 0] << 8 | n3[A8 + 354 | 0] << 16 | n3[A8 + 355 | 0] << 24) | 0) >>> 0 < g6 >>> 0 | B4)
                            for (o4 = A8 + 224 | 0, a4 = A8 + 96 | 0; eI(96 + (A8 + C4 | 0) | 0, I7, E4), i4 = (n3[A8 + 352 | 0] | n3[A8 + 353 | 0] << 8 | n3[A8 + 354 | 0] << 16 | n3[A8 + 355 | 0] << 24) + E4 | 0, Q3[A8 + 352 | 0] = i4, Q3[A8 + 353 | 0] = i4 >>> 8, Q3[A8 + 354 | 0] = i4 >>> 16, Q3[A8 + 355 | 0] = i4 >>> 24, CA(A8, 128), p3(A8, a4), eI(a4, o4, 128), C4 = (r4 = n3[A8 + 352 | 0] | n3[A8 + 353 | 0] << 8 | n3[A8 + 354 | 0] << 16 | n3[A8 + 355 | 0] << 24) - 128 | 0, Q3[A8 + 352 | 0] = C4, Q3[A8 + 353 | 0] = C4 >>> 8, Q3[A8 + 354 | 0] = C4 >>> 16, Q3[A8 + 355 | 0] = C4 >>> 24, I7 = I7 + E4 | 0, i4 = g6, g6 = g6 - E4 | 0, !(B4 = B4 - (E4 >>> 0 > i4 >>> 0) | 0) & (E4 = 384 - r4 | 0) >>> 0 < g6 >>> 0 | B4; )
                              ;
                          eI(96 + (A8 + C4 | 0) | 0, I7, g6), I7 = g6 + (n3[A8 + 352 | 0] | n3[A8 + 353 | 0] << 8 | n3[A8 + 354 | 0] << 16 | n3[A8 + 355 | 0] << 24) | 0, Q3[A8 + 352 | 0] = I7, Q3[A8 + 353 | 0] = I7 >>> 8, Q3[A8 + 354 | 0] = I7 >>> 16, Q3[A8 + 355 | 0] = I7 >>> 24;
                        }
                        return 0;
                      }
                      function BA2(A8, I7) {
                        var g6, B4 = 0, C4 = 0, E4 = 0, i4 = 0;
                        for (s3 = g6 = s3 - 464 | 0; C4 = (g6 + 400 | 0) + (B4 << 1) | 0, i4 = n3[I7 + B4 | 0], Q3[C4 + 1 | 0] = i4 >>> 4, Q3[0 | C4] = 15 & i4, (0 | (B4 = B4 + 1 | 0)) != 32; )
                          ;
                        for (B4 = 0; I7 = ((C4 = (I7 = B4) + n3[0 | (B4 = (g6 + 400 | 0) + E4 | 0)] | 0) << 24) - -134217728 | 0, Q3[0 | B4] = C4 - (I7 >> 24 & 240), B4 = I7 >> 28, (0 | (E4 = E4 + 1 | 0)) != 63; )
                          ;
                        for (Q3[g6 + 463 | 0] = n3[g6 + 463 | 0] + B4, LI(A8), B4 = 1; FA(g6, B4 >>> 1 | 0, Q3[(g6 + 400 | 0) + B4 | 0]), TA(I7 = g6 + 240 | 0, A8, g6), tI(A8, I7), I7 = B4 >>> 0 < 62, B4 = B4 + 2 | 0, I7; )
                          ;
                        for (fI(I7 = g6 + 240 | 0, A8), hI(B4 = g6 + 120 | 0, I7), G3(I7, B4), hI(B4, I7), G3(I7, B4), hI(B4, I7), G3(I7, B4), tI(A8, I7), B4 = 0; FA(g6, B4 >>> 1 | 0, Q3[(g6 + 400 | 0) + B4 | 0]), TA(I7 = g6 + 240 | 0, A8, g6), tI(A8, I7), I7 = B4 >>> 0 < 62, B4 = B4 + 2 | 0, I7; )
                          ;
                        s3 = g6 + 464 | 0;
                      }
                      function CA(A8, I7) {
                        var g6, B4, C4, E4 = 0, i4 = 0;
                        C4 = 1 + (i4 = g6 = n3[4 + (E4 = A8 - -64 | 0) | 0] | n3[E4 + 5 | 0] << 8 | n3[E4 + 6 | 0] << 16 | n3[E4 + 7 | 0] << 24) | 0, i4 = (I7 = I7 + (i4 = B4 = n3[0 | E4] | n3[E4 + 1 | 0] << 8 | n3[E4 + 2 | 0] << 16 | n3[E4 + 3 | 0] << 24) | 0) >>> 0 < i4 >>> 0 ? C4 : g6, Q3[0 | E4] = I7, Q3[E4 + 1 | 0] = I7 >>> 8, Q3[E4 + 2 | 0] = I7 >>> 16, Q3[E4 + 3 | 0] = I7 >>> 24, Q3[E4 + 4 | 0] = i4, Q3[E4 + 5 | 0] = i4 >>> 8, Q3[E4 + 6 | 0] = i4 >>> 16, Q3[E4 + 7 | 0] = i4 >>> 24, I7 = (E4 = (0 | i4) == (0 | g6) & I7 >>> 0 < B4 >>> 0 | i4 >>> 0 < g6 >>> 0) + (n3[A8 + 72 | 0] | n3[A8 + 73 | 0] << 8 | n3[A8 + 74 | 0] << 16 | n3[A8 + 75 | 0] << 24) | 0, i4 = n3[A8 + 76 | 0] | n3[A8 + 77 | 0] << 8 | n3[A8 + 78 | 0] << 16 | n3[A8 + 79 | 0] << 24, E4 = I7 >>> 0 < E4 >>> 0 ? i4 + 1 | 0 : i4, Q3[A8 + 72 | 0] = I7, Q3[A8 + 73 | 0] = I7 >>> 8, Q3[A8 + 74 | 0] = I7 >>> 16, Q3[A8 + 75 | 0] = I7 >>> 24, Q3[A8 + 76 | 0] = E4, Q3[A8 + 77 | 0] = E4 >>> 8, Q3[A8 + 78 | 0] = E4 >>> 16, Q3[A8 + 79 | 0] = E4 >>> 24;
                      }
                      function QA(A8, I7) {
                        i3[A8 >> 2] = 1634760805, i3[A8 + 4 >> 2] = 857760878, i3[A8 + 8 >> 2] = 2036477234, i3[A8 + 12 >> 2] = 1797285236, i3[A8 + 16 >> 2] = n3[0 | I7] | n3[I7 + 1 | 0] << 8 | n3[I7 + 2 | 0] << 16 | n3[I7 + 3 | 0] << 24, i3[A8 + 20 >> 2] = n3[I7 + 4 | 0] | n3[I7 + 5 | 0] << 8 | n3[I7 + 6 | 0] << 16 | n3[I7 + 7 | 0] << 24, i3[A8 + 24 >> 2] = n3[I7 + 8 | 0] | n3[I7 + 9 | 0] << 8 | n3[I7 + 10 | 0] << 16 | n3[I7 + 11 | 0] << 24, i3[A8 + 28 >> 2] = n3[I7 + 12 | 0] | n3[I7 + 13 | 0] << 8 | n3[I7 + 14 | 0] << 16 | n3[I7 + 15 | 0] << 24, i3[A8 + 32 >> 2] = n3[I7 + 16 | 0] | n3[I7 + 17 | 0] << 8 | n3[I7 + 18 | 0] << 16 | n3[I7 + 19 | 0] << 24, i3[A8 + 36 >> 2] = n3[I7 + 20 | 0] | n3[I7 + 21 | 0] << 8 | n3[I7 + 22 | 0] << 16 | n3[I7 + 23 | 0] << 24, i3[A8 + 40 >> 2] = n3[I7 + 24 | 0] | n3[I7 + 25 | 0] << 8 | n3[I7 + 26 | 0] << 16 | n3[I7 + 27 | 0] << 24, i3[A8 + 44 >> 2] = n3[I7 + 28 | 0] | n3[I7 + 29 | 0] << 8 | n3[I7 + 30 | 0] << 16 | n3[I7 + 31 | 0] << 24;
                      }
                      function EA(A8, I7, g6, B4, C4, Q4, E4) {
                        var n4, a4, r4, o4, t4, e4 = 0;
                        return s3 = n4 = s3 - 352 | 0, K3(n4, Q4, E4), !((!C4 & B4 >>> 0 > A8 - g6 >>> 0 | (0 | C4) != 0) & A8 >>> 0 > g6 >>> 0) & (!C4 & B4 >>> 0 <= g6 - A8 >>> 0 | A8 >>> 0 >= g6 >>> 0) || (g6 = gI(A8, g6, B4)), i3[n4 + 56 >> 2] = 0, i3[n4 + 60 >> 2] = 0, i3[n4 + 48 >> 2] = 0, i3[n4 + 52 >> 2] = 0, i3[n4 + 40 >> 2] = 0, i3[n4 + 44 >> 2] = 0, i3[n4 + 32 >> 2] = 0, i3[n4 + 36 >> 2] = 0, (r4 = !((E4 = (e4 = !C4 & B4 >>> 0 < 32) ? B4 : 32) | (e4 = e4 ? C4 : 0))) || eI(n4 - -64 | 0, g6, E4), o4 = Q4 + 16 | 0, XI(a4 = n4 + 32 | 0, a4, t4 = E4 + 32 | 0, Q4 = t4 >>> 0 < 32 ? e4 + 1 | 0 : e4, o4, n4), og(n4 + 96 | 0, a4), r4 || eI(A8, n4 - -64 | 0, E4), Dg(n4 + 32 | 0, 64), !C4 & B4 >>> 0 >= 33 | C4 && KI(A8 + E4 | 0, g6 + E4 | 0, B4 - E4 | 0, C4 - (e4 + (B4 >>> 0 < E4 >>> 0) | 0) | 0, o4, n4), Dg(n4, 32), gg(g6 = n4 + 96 | 0, A8, B4, C4), tg(g6, I7), Dg(g6, 256), s3 = n4 + 352 | 0, 0;
                      }
                      function iA(A8, I7, g6, B4, C4, Q4, E4) {
                        var n4, a4, r4 = 0, o4 = 0, t4 = 0;
                        s3 = n4 = s3 - 96 | 0, K3(n4, Q4, E4), E4 = n4 + 32 | 0, a4 = Q4 + 16 | 0, vg[i3[8760]](E4, 32, 0, a4, n4), Q4 = -1;
                        A: {
                          if (!(0 | vg[i3[8754]](g6, I7, B4, C4, E4))) {
                            if (Q4 = 0, !A8)
                              break A;
                            !((!C4 & B4 >>> 0 > I7 - A8 >>> 0 | (0 | C4) != 0) & A8 >>> 0 < I7 >>> 0) & (!C4 & B4 >>> 0 <= A8 - I7 >>> 0 | A8 >>> 0 <= I7 >>> 0) || (I7 = gI(A8, I7, B4)), g6 = (Q4 = !C4 & B4 >>> 0 < 32) ? B4 : 32, E4 = Q4 = Q4 ? C4 : 0, g6 | Q4 ? (o4 = eI(n4 - -64 | 0, I7, g6), r4 = Q4 = n4 + 32 | 0, Q4 = E4, XI(r4, r4, t4 = g6 + 32 | 0, Q4 = t4 >>> 0 < 32 ? Q4 + 1 | 0 : Q4, a4, n4), eI(A8, o4, g6)) : (r4 = Q4 = n4 + 32 | 0, Q4 = E4, XI(r4, r4, o4 = g6 + 32 | 0, Q4 = o4 >>> 0 < 32 ? Q4 + 1 | 0 : Q4, a4, n4)), Q4 = 0, !C4 & B4 >>> 0 < 33 || KI(A8 + g6 | 0, I7 + g6 | 0, B4 - g6 | 0, C4 - (E4 + (g6 >>> 0 > B4 >>> 0) | 0) | 0, a4, n4);
                          }
                          Dg(n4, 32);
                        }
                        return s3 = n4 + 96 | 0, Q4;
                      }
                      function nA(A8) {
                        var I7 = 0, g6 = 0, B4 = 0;
                        if (!A8)
                          return -25;
                        if (!i3[A8 >> 2])
                          return -1;
                        if (I7 = -2, !(a3[A8 + 4 >> 2] < 16) && (i3[A8 + 8 >> 2] || (I7 = -18, !i3[A8 + 12 >> 2]))) {
                          if (g6 = i3[A8 + 20 >> 2], !i3[A8 + 16 >> 2])
                            return g6 ? -19 : -6;
                          if (I7 = -6, !(g6 >>> 0 < 8) && (i3[A8 + 24 >> 2] || (I7 = -20, !i3[A8 + 28 >> 2])) && (i3[A8 + 32 >> 2] || (I7 = -21, !i3[A8 + 36 >> 2]))) {
                            if (!(g6 = i3[A8 + 48 >> 2]))
                              return -16;
                            if (I7 = -17, !(g6 >>> 0 > 16777215 || (I7 = -14, (B4 = i3[A8 + 44 >> 2]) >>> 0 < 8 || (I7 = -15, B4 >>> 0 > 2097152 || (I7 = -14, g6 << 3 >>> 0 > B4 >>> 0))))) {
                              if (!i3[A8 + 40 >> 2])
                                return -12;
                              if (!(A8 = i3[A8 + 52 >> 2]))
                                return -28;
                              I7 = A8 >>> 0 > 16777215 ? -29 : 0;
                            }
                          }
                        }
                        return I7;
                      }
                      function aA(A8, I7, g6) {
                        var B4, C4, Q4, E4, n4, a4, r4, o4, t4, e4, f4, c4, y4, s4, w4, D4, h4, p4, u4, F4;
                        f4 = i3[I7 + 4 >> 2], B4 = i3[A8 + 4 >> 2], c4 = i3[I7 + 8 >> 2], C4 = i3[A8 + 8 >> 2], y4 = i3[I7 + 12 >> 2], Q4 = i3[A8 + 12 >> 2], s4 = i3[I7 + 16 >> 2], E4 = i3[A8 + 16 >> 2], w4 = i3[I7 + 20 >> 2], n4 = i3[A8 + 20 >> 2], D4 = i3[I7 + 24 >> 2], a4 = i3[A8 + 24 >> 2], h4 = i3[I7 + 28 >> 2], r4 = i3[A8 + 28 >> 2], p4 = i3[I7 + 32 >> 2], o4 = i3[A8 + 32 >> 2], u4 = i3[I7 + 36 >> 2], t4 = i3[A8 + 36 >> 2], e4 = i3[A8 >> 2], F4 = i3[I7 >> 2] ^ e4, I7 = 0 - g6 | 0, i3[A8 >> 2] = e4 ^ F4 & I7, i3[A8 + 36 >> 2] = I7 & (t4 ^ u4) ^ t4, i3[A8 + 32 >> 2] = I7 & (o4 ^ p4) ^ o4, i3[A8 + 28 >> 2] = I7 & (r4 ^ h4) ^ r4, i3[A8 + 24 >> 2] = I7 & (a4 ^ D4) ^ a4, i3[A8 + 20 >> 2] = I7 & (n4 ^ w4) ^ n4, i3[A8 + 16 >> 2] = I7 & (E4 ^ s4) ^ E4, i3[A8 + 12 >> 2] = I7 & (Q4 ^ y4) ^ Q4, i3[A8 + 8 >> 2] = I7 & (C4 ^ c4) ^ C4, i3[A8 + 4 >> 2] = I7 & (B4 ^ f4) ^ B4;
                      }
                      function rA(A8, I7, g6, B4, C4, Q4, E4, a4, r4, o4) {
                        var t4, e4, f4, c4;
                        return s3 = t4 = s3 - 48 | 0, i3[t4 + 4 >> 2] = 0, x3(e4 = t4 + 16 | 0, r4, o4), o4 = n3[r4 + 20 | 0] | n3[r4 + 21 | 0] << 8 | n3[r4 + 22 | 0] << 16 | n3[r4 + 23 | 0] << 24, i3[t4 + 8 >> 2] = n3[r4 + 16 | 0] | n3[r4 + 17 | 0] << 8 | n3[r4 + 18 | 0] << 16 | n3[r4 + 19 | 0] << 24, i3[t4 + 12 >> 2] = o4, s3 = o4 = s3 - 352 | 0, $I(f4 = o4 + 32 | 0, 64, c4 = t4 + 4 | 0, e4), og(r4 = o4 + 96 | 0, f4), Dg(f4, 64), gg(r4, Q4, E4, a4), gg(r4, 34960, 0 - E4 & 15, 0), gg(r4, I7, g6, B4), gg(r4, 34960, 0 - g6 & 15, 0), QI(Q4 = o4 + 24 | 0, E4, a4), gg(r4, Q4, 8, 0), QI(Q4, g6, B4), gg(r4, Q4, 8, 0), tg(r4, o4), Dg(r4, 256), C4 = rg(o4, C4), Dg(o4, 16), A8 && (C4 ? (wI(A8, 0, g6), C4 = -1) : (kI(A8, I7, g6, B4, c4, 1, e4), C4 = 0)), s3 = o4 + 352 | 0, Dg(e4, 32), s3 = t4 + 48 | 0, C4;
                      }
                      function oA(A8, I7) {
                        for (var g6 = 0, B4 = 0, C4 = 0, E4 = 0, i4 = 0, a4 = 0, r4 = 0, o4 = 0; Q3[A8 + g6 | 0] = n3[(g6 >>> 3 | 0) + I7 | 0] >>> (7 & g6) & 1, (0 | (g6 = g6 + 1 | 0)) != 256; )
                          ;
                        for (; ; ) {
                          a4 = (I7 = a4) + 1 | 0;
                          A:
                            if (n3[0 | (i4 = A8 + I7 | 0)] && (g6 = a4, C4 = 1, !(I7 >>> 0 > 254)))
                              for (; ; ) {
                                I:
                                  if (E4 = Q3[0 | (B4 = A8 + g6 | 0)])
                                    if ((0 | (o4 = (r4 = Q3[0 | i4]) + (E4 <<= C4) | 0)) <= 15)
                                      Q3[0 | i4] = o4, Q3[0 | B4] = 0;
                                    else {
                                      if ((0 | (B4 = r4 - E4 | 0)) < -15)
                                        break A;
                                      for (Q3[0 | i4] = B4; ; ) {
                                        if (!n3[0 | (B4 = A8 + g6 | 0)]) {
                                          Q3[0 | B4] = 1;
                                          break I;
                                        }
                                        if (Q3[0 | B4] = 0, B4 = g6 >>> 0 < 255, g6 = g6 + 1 | 0, !B4)
                                          break;
                                      }
                                    }
                                if (C4 >>> 0 > 5)
                                  break A;
                                if (!((g6 = I7 + (C4 = C4 + 1 | 0) | 0) >>> 0 < 256))
                                  break;
                              }
                          if ((0 | a4) == 256)
                            break;
                        }
                      }
                      function tA(A8, I7, g6, B4) {
                        var C4, Q4, E4, n4, a4 = 0;
                        s3 = C4 = s3 + -64 | 0, wI(C4 + 8 | 0, 0, 52), a4 = mA(A8), i3[C4 + 20 >> 2] = a4, i3[C4 + 36 >> 2] = a4, i3[C4 + 4 >> 2] = a4, Q4 = k3(a4), i3[C4 + 32 >> 2] = Q4, E4 = k3(a4), i3[C4 + 16 >> 2] = E4, n4 = k3(a4), i3[C4 >> 2] = n4;
                        A:
                          if (!n4 | !Q4 | !E4 || !(a4 = k3(a4)))
                            b3(Q4), b3(E4), b3(n4), A8 = -22;
                          else {
                            if (A8 = j3(C4, A8, B4)) {
                              b3(i3[C4 + 32 >> 2]), b3(i3[C4 + 16 >> 2]), b3(i3[C4 >> 2]), b3(a4);
                              break A;
                            }
                            A8 = 0, I7 = _3(i3[C4 + 40 >> 2], i3[C4 + 44 >> 2], i3[C4 + 52 >> 2], I7, g6, i3[C4 + 16 >> 2], i3[C4 + 20 >> 2], a4, i3[C4 + 4 >> 2], 0, 0, B4), b3(i3[C4 + 32 >> 2]), b3(i3[C4 + 16 >> 2]), (I7 || zA(a4, i3[C4 >> 2], i3[C4 + 4 >> 2])) && (A8 = -35), b3(a4), b3(i3[C4 >> 2]);
                          }
                        return s3 = C4 - -64 | 0, A8;
                      }
                      function eA(A8, I7, g6, B4, C4) {
                        var Q4, E4 = 0, a4 = 0;
                        s3 = Q4 = s3 + -64 | 0;
                        A: {
                          I: {
                            if (!g6 & (a4 = mA(A8)) >>> 0 < 128) {
                              if (i3[Q4 + 56 >> 2] = 0, i3[Q4 + 48 >> 2] = 0, i3[Q4 + 52 >> 2] = 0, i3[Q4 + 40 >> 2] = 0, i3[Q4 + 44 >> 2] = 0, g6 = 0, a4 && (g6 = a4), !(E4 = k3(g6)) | !(3 & n3[E4 - 4 | 0]) || wI(E4, 0, g6), E4)
                                break I;
                            } else
                              i3[8952] = 28;
                            A8 = -1;
                            break A;
                          }
                          i3[Q4 + 32 >> 2] = 0, i3[Q4 + 36 >> 2] = 0, i3[Q4 + 8 >> 2] = E4, i3[Q4 + 16 >> 2] = E4, i3[Q4 + 20 >> 2] = a4, i3[Q4 >> 2] = E4, i3[Q4 + 12 >> 2] = a4, i3[Q4 + 24 >> 2] = 0, i3[Q4 + 28 >> 2] = 0, i3[Q4 + 4 >> 2] = a4, j3(Q4, A8, C4) ? (i3[8952] = 28, A8 = -1) : A8 = (0 | I7) != i3[Q4 + 40 >> 2] | i3[Q4 + 44 >> 2] != (B4 >>> 10 | 0), b3(E4);
                        }
                        return s3 = Q4 - -64 | 0, A8;
                      }
                      function fA(A8, I7, g6, B4, C4, Q4, E4, a4, r4, o4, t4) {
                        var e4, f4, c4, y4;
                        return s3 = e4 = s3 - 48 | 0, i3[e4 + 4 >> 2] = 0, x3(f4 = e4 + 16 | 0, o4, t4), t4 = n3[o4 + 20 | 0] | n3[o4 + 21 | 0] << 8 | n3[o4 + 22 | 0] << 16 | n3[o4 + 23 | 0] << 24, i3[e4 + 8 >> 2] = n3[o4 + 16 | 0] | n3[o4 + 17 | 0] << 8 | n3[o4 + 18 | 0] << 16 | n3[o4 + 19 | 0] << 24, i3[e4 + 12 >> 2] = t4, s3 = t4 = s3 - 336 | 0, $I(c4 = t4 + 16 | 0, 64, y4 = e4 + 4 | 0, f4), og(o4 = t4 + 80 | 0, c4), Dg(c4, 64), gg(o4, E4, a4, r4), gg(o4, 34960, 0 - a4 & 15, 0), kI(A8, B4, C4, Q4, y4, 1, f4), gg(o4, A8, C4, Q4), gg(o4, 34960, 0 - C4 & 15, 0), QI(A8 = t4 + 8 | 0, a4, r4), gg(o4, A8, 8, 0), QI(A8, C4, Q4), gg(o4, A8, 8, 0), tg(o4, I7), Dg(o4, 256), g6 && (i3[g6 >> 2] = 16, i3[g6 + 4 >> 2] = 0), s3 = t4 + 336 | 0, Dg(f4, 32), s3 = e4 + 48 | 0, 0;
                      }
                      function cA(A8, I7, g6) {
                        var B4, C4, Q4, E4, n4, a4, r4, o4, t4, e4, f4, c4, y4, s4, w4, D4, h4, p4;
                        B4 = i3[g6 + 4 >> 2], C4 = i3[I7 + 4 >> 2], Q4 = i3[g6 + 8 >> 2], E4 = i3[I7 + 8 >> 2], n4 = i3[g6 + 12 >> 2], a4 = i3[I7 + 12 >> 2], r4 = i3[g6 + 16 >> 2], o4 = i3[I7 + 16 >> 2], t4 = i3[g6 + 20 >> 2], e4 = i3[I7 + 20 >> 2], f4 = i3[g6 + 24 >> 2], c4 = i3[I7 + 24 >> 2], y4 = i3[g6 + 28 >> 2], s4 = i3[I7 + 28 >> 2], w4 = i3[g6 + 32 >> 2], D4 = i3[I7 + 32 >> 2], h4 = i3[g6 + 36 >> 2], p4 = i3[I7 + 36 >> 2], i3[A8 >> 2] = i3[I7 >> 2] - i3[g6 >> 2], i3[A8 + 36 >> 2] = p4 - h4, i3[A8 + 32 >> 2] = D4 - w4, i3[A8 + 28 >> 2] = s4 - y4, i3[A8 + 24 >> 2] = c4 - f4, i3[A8 + 20 >> 2] = e4 - t4, i3[A8 + 16 >> 2] = o4 - r4, i3[A8 + 12 >> 2] = a4 - n4, i3[A8 + 8 >> 2] = E4 - Q4, i3[A8 + 4 >> 2] = C4 - B4;
                      }
                      function yA(A8, I7, g6) {
                        var B4, C4, Q4, E4, n4, a4, r4, o4, t4, e4, f4, c4, y4, s4, w4, D4, h4, p4;
                        B4 = i3[g6 + 4 >> 2], C4 = i3[I7 + 4 >> 2], Q4 = i3[g6 + 8 >> 2], E4 = i3[I7 + 8 >> 2], n4 = i3[g6 + 12 >> 2], a4 = i3[I7 + 12 >> 2], r4 = i3[g6 + 16 >> 2], o4 = i3[I7 + 16 >> 2], t4 = i3[g6 + 20 >> 2], e4 = i3[I7 + 20 >> 2], f4 = i3[g6 + 24 >> 2], c4 = i3[I7 + 24 >> 2], y4 = i3[g6 + 28 >> 2], s4 = i3[I7 + 28 >> 2], w4 = i3[g6 + 32 >> 2], D4 = i3[I7 + 32 >> 2], h4 = i3[g6 + 36 >> 2], p4 = i3[I7 + 36 >> 2], i3[A8 >> 2] = i3[g6 >> 2] + i3[I7 >> 2], i3[A8 + 36 >> 2] = h4 + p4, i3[A8 + 32 >> 2] = w4 + D4, i3[A8 + 28 >> 2] = y4 + s4, i3[A8 + 24 >> 2] = f4 + c4, i3[A8 + 20 >> 2] = t4 + e4, i3[A8 + 16 >> 2] = r4 + o4, i3[A8 + 12 >> 2] = n4 + a4, i3[A8 + 8 >> 2] = Q4 + E4, i3[A8 + 4 >> 2] = B4 + C4;
                      }
                      function sA(A8) {
                        var I7, g6 = 0, B4 = 0, C4 = 0, E4 = 0;
                        for (Q3[11 + (I7 = s3 - 16 | 0) | 0] = 0, Q3[I7 + 12 | 0] = 0, Q3[I7 + 13 | 0] = 0, Q3[I7 + 14 | 0] = 0, i3[I7 + 8 >> 2] = 0; ; ) {
                          for (C4 = n3[A8 + B4 | 0], g6 = 0; Q3[0 | (E4 = (I7 + 8 | 0) + g6 | 0)] = n3[0 | E4] | C4 ^ n3[(2528 + (g6 << 5) | 0) + B4 | 0], (0 | (g6 = g6 + 1 | 0)) != 7; )
                            ;
                          if ((0 | (B4 = B4 + 1 | 0)) == 31)
                            break;
                        }
                        for (B4 = 127 & n3[A8 + 31 | 0], A8 = 0, g6 = 0; Q3[0 | (C4 = (I7 + 8 | 0) + g6 | 0)] = n3[0 | C4] | B4 ^ n3[2559 + (g6 << 5) | 0], (0 | (g6 = g6 + 1 | 0)) != 7; )
                          ;
                        for (g6 = 0; g6 = n3[(I7 + 8 | 0) + A8 | 0] - 1 | g6, (0 | (A8 = A8 + 1 | 0)) != 7; )
                          ;
                        return g6 >>> 8 & 1;
                      }
                      function wA(A8, I7) {
                        var g6 = 0, B4 = 0, C4 = 0, E4 = 0;
                        for (wI(eI(A8, 33984, 64) - -64 | 0, 0, 293); B4 = (g6 = E4 << 3) + A8 | 0, C4 = n3[0 | (g6 = I7 + g6 | 0)] | n3[g6 + 1 | 0] << 8 | n3[g6 + 2 | 0] << 16 | n3[g6 + 3 | 0] << 24, g6 = (n3[g6 + 4 | 0] | n3[g6 + 5 | 0] << 8 | n3[g6 + 6 | 0] << 16 | n3[g6 + 7 | 0] << 24) ^ (n3[B4 + 4 | 0] | n3[B4 + 5 | 0] << 8 | n3[B4 + 6 | 0] << 16 | n3[B4 + 7 | 0] << 24), C4 ^= n3[0 | B4] | n3[B4 + 1 | 0] << 8 | n3[B4 + 2 | 0] << 16 | n3[B4 + 3 | 0] << 24, Q3[0 | B4] = C4, Q3[B4 + 1 | 0] = C4 >>> 8, Q3[B4 + 2 | 0] = C4 >>> 16, Q3[B4 + 3 | 0] = C4 >>> 24, Q3[B4 + 4 | 0] = g6, Q3[B4 + 5 | 0] = g6 >>> 8, Q3[B4 + 6 | 0] = g6 >>> 16, Q3[B4 + 7 | 0] = g6 >>> 24, (0 | (E4 = E4 + 1 | 0)) != 8; )
                          ;
                      }
                      function DA(A8, I7) {
                        var g6 = 0, B4 = 0;
                        A:
                          if (B4 = 255 & I7) {
                            if (3 & A8)
                              for (; ; ) {
                                if (!(g6 = n3[0 | A8]) | (0 | g6) == (255 & I7))
                                  break A;
                                if (!(3 & (A8 = A8 + 1 | 0)))
                                  break;
                              }
                            I:
                              if (!((-1 ^ (g6 = i3[A8 >> 2])) & g6 - 16843009 & -2139062144))
                                for (B4 = r3(B4, 16843009); ; ) {
                                  if ((-1 ^ (g6 ^= B4)) & g6 - 16843009 & -2139062144)
                                    break I;
                                  if (g6 = i3[A8 + 4 >> 2], A8 = A8 + 4 | 0, g6 - 16843009 & (-1 ^ g6) & -2139062144)
                                    break;
                                }
                            for (; g6 = A8, (B4 = n3[0 | A8]) && (A8 = g6 + 1 | 0, (0 | B4) != (255 & I7)); )
                              ;
                            A8 = g6;
                          } else
                            A8 = mA(A8) + A8 | 0;
                        return n3[0 | A8] == (255 & I7) ? A8 : 0;
                      }
                      function hA(A8, I7, g6) {
                        var B4 = 0, C4 = 0, E4 = 0, n4 = 0, a4 = 0, r4 = 0;
                        if (g6 >>> 0 >= 8)
                          for (n4 = g6 >>> 3 | 0, g6 = 0; E4 = (B4 = g6 << 3) + A8 | 0, a4 = (B4 = i3[4 + (C4 = I7 + B4 | 0) >> 2]) << 24 | (C4 = i3[C4 >> 2]) >>> 8, r4 = B4 << 8 | C4 >>> 24, B4 = -16777216 & ((255 & B4) << 24 | C4 >>> 8) | 16711680 & ((16777215 & B4) << 8 | C4 >>> 24) | B4 >>> 8 & 65280 | B4 >>> 24, Q3[0 | E4] = B4, Q3[E4 + 1 | 0] = B4 >>> 8, Q3[E4 + 2 | 0] = B4 >>> 16, Q3[E4 + 3 | 0] = B4 >>> 24, B4 = C4 << 8 & 16711680 | C4 << 24 | 65280 & a4 | 255 & r4, Q3[E4 + 4 | 0] = B4, Q3[E4 + 5 | 0] = B4 >>> 8, Q3[E4 + 6 | 0] = B4 >>> 16, Q3[E4 + 7 | 0] = B4 >>> 24, (0 | n4) != (0 | (g6 = g6 + 1 | 0)); )
                            ;
                      }
                      function pA(A8, I7, g6) {
                        var B4, C4, Q4 = 0, E4 = 0, i4 = 0;
                        return B4 = A8, A8 = 31 & (Q4 = i4 = 63 & g6), Q4 >>> 0 >= 32 ? (A8 = -1 << A8, Q4 = 0) : A8 = (Q4 = -1 << A8) | (1 << A8) - 1 & -1 >>> 32 - A8, C4 = Q4 & B4, E4 = A8 & I7, Q4 = 31 & i4, i4 >>> 0 >= 32 ? (A8 = 0, i4 = E4 >>> Q4 | 0) : (A8 = E4 >>> Q4 | 0, i4 = ((1 << Q4) - 1 & E4) << 32 - Q4 | C4 >>> Q4), Q4 = A8, g6 = 31 & (E4 = 0 - g6 & 63), E4 >>> 0 >= 32 ? (A8 = 0, g6 = -1 >>> g6 | 0) : g6 = (A8 = -1 >>> g6 | 0) | (1 << g6) - 1 << 32 - g6, g6 &= B4, I7 &= A8, A8 = 31 & E4, E4 >>> 0 >= 32 ? (I7 = g6 << A8, A8 = 0) : (I7 = (1 << A8) - 1 & g6 >>> 32 - A8 | I7 << A8, A8 = g6 << A8), h3 = I7 | Q4, A8 | i4;
                      }
                      function uA(A8, I7, g6) {
                        var B4 = 0, C4 = 0, Q4 = 0, E4 = 0;
                        return E4 = A8, A8 = 0, C4 = 31 & (B4 = Q4 = 63 & g6), B4 = B4 >>> 0 >= 32 ? -1 >>> C4 | 0 : (A8 = -1 >>> C4 | 0) | (1 << C4) - 1 << 32 - C4, B4 &= E4, A8 &= I7, C4 = 31 & Q4, Q4 >>> 0 >= 32 ? (A8 = B4 << C4, B4 = 0) : (A8 = (1 << C4) - 1 & B4 >>> 32 - C4 | A8 << C4, B4 <<= C4), C4 = A8, A8 = 31 & (g6 = 0 - g6 & 63), g6 >>> 0 >= 32 ? (A8 = -1 << A8, Q4 = 0) : A8 = (Q4 = -1 << A8) | (1 << A8) - 1 & -1 >>> 32 - A8, E4 &= Q4, I7 &= A8, A8 = 31 & g6, g6 >>> 0 >= 32 ? (g6 = 0, A8 = I7 >>> A8 | 0) : (g6 = I7 >>> A8 | 0, A8 = ((1 << A8) - 1 & I7) << 32 - A8 | E4 >>> A8), h3 = g6 | C4, A8 | B4;
                      }
                      function FA(A8, I7, g6) {
                        var B4, C4, Q4, E4;
                        s3 = B4 = s3 - 128 | 0, ng(A8), ng(C4 = A8 + 40 | 0), hg(Q4 = A8 + 80 | 0), MI(A8, I7 = r3(I7, 960) + 2784 | 0, Ag(g6 = g6 - ((0 - (E4 = (128 & g6) >>> 7 | 0) & g6) << 1) << 24 >> 24, 1)), MI(A8, I7 + 120 | 0, Ag(g6, 2)), MI(A8, I7 + 240 | 0, Ag(g6, 3)), MI(A8, I7 + 360 | 0, Ag(g6, 4)), MI(A8, I7 + 480 | 0, Ag(g6, 5)), MI(A8, I7 + 600 | 0, Ag(g6, 6)), MI(A8, I7 + 720 | 0, Ag(g6, 7)), MI(A8, I7 + 840 | 0, Ag(g6, 8)), UA(I7 = B4 + 8 | 0, C4), UA(B4 + 48 | 0, A8), kA(B4 + 88 | 0, Q4), MI(A8, I7, E4), s3 = B4 + 128 | 0;
                      }
                      function lA(A8, I7, g6, B4, C4, Q4, E4, i4, n4, a4) {
                        var r4, o4, t4;
                        return s3 = o4 = s3 - 352 | 0, fg(t4 = o4 + 32 | 0, 64, n4, a4), og(r4 = o4 + 96 | 0, t4), Dg(t4, 64), gg(r4, Q4, E4, i4), gg(r4, 34064, 0 - E4 & 15, 0), gg(r4, I7, g6, B4), gg(r4, 34064, 0 - g6 & 15, 0), QI(Q4 = o4 + 24 | 0, E4, i4), gg(r4, Q4, 8, 0), QI(Q4, g6, B4), gg(r4, Q4, 8, 0), tg(r4, o4), Dg(r4, 256), C4 = rg(o4, C4), Dg(o4, 16), A8 && (C4 ? (wI(A8, 0, g6), C4 = -1) : (WA(A8, I7, g6, B4, n4, 1, a4), C4 = 0)), s3 = o4 + 352 | 0, C4;
                      }
                      function _A(A8, I7) {
                        var g6, B4 = 0, C4 = 0, Q4 = 0, E4 = 0, a4 = 0;
                        A:
                          if (!(((g6 = n3[0 | A8]) - 58 & 255) >>> 0 < 246)) {
                            for (C4 = g6, B4 = A8; ; ) {
                              if (E4 = B4, Q4 >>> 0 > 429496729)
                                break A;
                              if ((C4 = (255 & C4) - 48 | 0) >>> 0 > (-1 ^ (B4 = r3(Q4, 10))) >>> 0)
                                break A;
                              if (Q4 = B4 + C4 | 0, !(((C4 = n3[0 | (B4 = E4 + 1 | 0)]) - 58 & 255) >>> 0 > 245))
                                break;
                            }
                            (0 | g6) == 48 & (0 | A8) != (0 | E4) | (0 | A8) == (0 | B4) || (i3[I7 >> 2] = Q4, a4 = B4);
                          }
                        return a4;
                      }
                      function kA(A8, I7) {
                        var g6, B4, C4, Q4, E4, n4, a4, r4, o4;
                        g6 = i3[I7 + 4 >> 2], B4 = i3[I7 + 8 >> 2], C4 = i3[I7 + 12 >> 2], Q4 = i3[I7 + 16 >> 2], E4 = i3[I7 + 20 >> 2], n4 = i3[I7 + 24 >> 2], a4 = i3[I7 + 28 >> 2], r4 = i3[I7 + 32 >> 2], o4 = i3[I7 + 36 >> 2], i3[A8 >> 2] = 0 - i3[I7 >> 2], i3[A8 + 36 >> 2] = 0 - o4, i3[A8 + 32 >> 2] = 0 - r4, i3[A8 + 28 >> 2] = 0 - a4, i3[A8 + 24 >> 2] = 0 - n4, i3[A8 + 20 >> 2] = 0 - E4, i3[A8 + 16 >> 2] = 0 - Q4, i3[A8 + 12 >> 2] = 0 - C4, i3[A8 + 8 >> 2] = 0 - B4, i3[A8 + 4 >> 2] = 0 - g6;
                      }
                      function HA(A8, I7, g6, B4, C4, Q4, E4, n4, a4, r4, o4) {
                        var t4, e4, f4;
                        return s3 = e4 = s3 - 336 | 0, fg(f4 = e4 + 16 | 0, 64, r4, o4), og(t4 = e4 + 80 | 0, f4), Dg(f4, 64), gg(t4, E4, n4, a4), gg(t4, 34064, 0 - n4 & 15, 0), WA(A8, B4, C4, Q4, r4, 1, o4), gg(t4, A8, C4, Q4), gg(t4, 34064, 0 - C4 & 15, 0), QI(A8 = e4 + 8 | 0, n4, a4), gg(t4, A8, 8, 0), QI(A8, C4, Q4), gg(t4, A8, 8, 0), tg(t4, I7), Dg(t4, 256), g6 && (i3[g6 >> 2] = 16, i3[g6 + 4 >> 2] = 0), s3 = e4 + 336 | 0, 0;
                      }
                      function GA(A8, I7, g6, B4, C4, Q4, E4, i4, n4, a4) {
                        var r4, o4, t4;
                        return s3 = r4 = s3 - 352 | 0, Ig(t4 = r4 + 32 | 0, n4, a4), og(o4 = r4 + 96 | 0, t4), Dg(t4, 64), gg(o4, Q4, E4, i4), QI(Q4 = r4 + 24 | 0, E4, i4), gg(o4, Q4, 8, 0), gg(o4, I7, g6, B4), QI(Q4, g6, B4), gg(o4, Q4, 8, 0), tg(o4, r4), Dg(o4, 256), C4 = rg(r4, C4), Dg(r4, 16), A8 && (C4 ? (wI(A8, 0, g6), C4 = -1) : (HI(A8, I7, g6, B4, n4, a4), C4 = 0)), s3 = r4 + 352 | 0, C4;
                      }
                      function UA(A8, I7) {
                        var g6, B4, C4, Q4, E4, n4, a4, r4, o4;
                        g6 = i3[I7 + 8 >> 2], B4 = i3[I7 + 12 >> 2], C4 = i3[I7 + 16 >> 2], Q4 = i3[I7 + 20 >> 2], E4 = i3[I7 + 24 >> 2], n4 = i3[I7 + 28 >> 2], a4 = i3[I7 >> 2], r4 = i3[I7 + 4 >> 2], o4 = i3[I7 + 36 >> 2], i3[A8 + 32 >> 2] = i3[I7 + 32 >> 2], i3[A8 + 36 >> 2] = o4, i3[A8 + 24 >> 2] = E4, i3[A8 + 28 >> 2] = n4, i3[A8 + 16 >> 2] = C4, i3[A8 + 20 >> 2] = Q4, i3[A8 + 8 >> 2] = g6, i3[A8 + 12 >> 2] = B4, i3[A8 >> 2] = a4, i3[A8 + 4 >> 2] = r4;
                      }
                      function SA(A8, I7, g6) {
                        g6 ? (i3[A8 + 48 >> 2] = n3[0 | g6] | n3[g6 + 1 | 0] << 8 | n3[g6 + 2 | 0] << 16 | n3[g6 + 3 | 0] << 24, g6 = n3[g6 + 4 | 0] | n3[g6 + 5 | 0] << 8 | n3[g6 + 6 | 0] << 16 | n3[g6 + 7 | 0] << 24) : (i3[A8 + 48 >> 2] = 0, g6 = 0), i3[A8 + 52 >> 2] = g6, i3[A8 + 56 >> 2] = n3[0 | I7] | n3[I7 + 1 | 0] << 8 | n3[I7 + 2 | 0] << 16 | n3[I7 + 3 | 0] << 24, i3[A8 + 60 >> 2] = n3[I7 + 4 | 0] | n3[I7 + 5 | 0] << 8 | n3[I7 + 6 | 0] << 16 | n3[I7 + 7 | 0] << 24;
                      }
                      function bA(A8, I7, g6, B4) {
                        var C4;
                        if (s3 = C4 = s3 - 192 | 0, !(!g6 | (I7 - 65 & 255) >>> 0 <= 191 | (B4 - 65 & 255) >>> 0 <= 191))
                          return E3[C4 + 130 >> 1] = 257, Q3[C4 + 129 | 0] = B4, Q3[C4 + 128 | 0] = I7, RI(4 | (I7 = C4 + 128 | 0)), QI(8 | I7, 0, 0), wI(C4 + 144 | 0, 0, 48), wA(A8, I7), wI(B4 + C4 | 0, 0, B4 << 24 >> 24 < 0 ? 0 : 128 - B4 | 0), gA2(I7 = A8, A8 = eI(C4, g6, B4), 128, 0), Dg(A8, 128), s3 = A8 + 192 | 0, 0;
                        xI(), t3();
                      }
                      function mA(A8) {
                        var I7 = 0, g6 = 0, B4 = 0;
                        A: {
                          if (3 & (I7 = A8))
                            for (; ; ) {
                              if (!n3[0 | I7])
                                break A;
                              if (!(3 & (I7 = I7 + 1 | 0)))
                                break;
                            }
                          for (; g6 = I7, I7 = I7 + 4 | 0, !((-1 ^ (B4 = i3[g6 >> 2])) & B4 - 16843009 & -2139062144); )
                            ;
                          if (!(255 & B4))
                            return g6 - A8 | 0;
                          for (; B4 = n3[g6 + 1 | 0], g6 = I7 = g6 + 1 | 0, B4; )
                            ;
                        }
                        return I7 - A8 | 0;
                      }
                      function vA(A8, I7, g6, B4, C4, Q4, E4) {
                        var i4 = 0, n4 = 0;
                        return I7 - 65 >>> 0 < 4294967232 | E4 >>> 0 > 64 ? A8 = -1 : (n4 = i4 = s3, s3 = i4 = i4 - 384 & -64, !(!(B4 | C4) || g6) | !A8 | ((I7 &= 255) - 65 & 255) >>> 0 <= 191 | !(!(E4 &= 255) || Q4) | E4 >>> 0 >= 65 ? (xI(), t3()) : (E4 ? bA(i4, I7, Q4, E4) : jA(i4, I7), gA2(i4, g6, B4, C4), Y3(i4, A8, I7), s3 = n4), A8 = 0), A8;
                      }
                      function MA(A8, I7) {
                        var g6, B4, C4 = 0;
                        s3 = g6 = s3 - 704 | 0, (B4 = i3[A8 + 72 >> 2] >>> 3 & 127) >>> 0 <= 111 ? eI(80 + (A8 + B4 | 0) | 0, 34784, 112 - B4 | 0) : (eI((C4 = A8 + 80 | 0) + B4 | 0, 34784, 128 - B4 | 0), F3(A8, C4, g6, g6 + 640 | 0), wI(C4, 0, 112)), hA(A8 + 192 | 0, A8 - -64 | 0, 16), F3(A8, A8 + 80 | 0, g6, g6 + 640 | 0), hA(I7, A8, 64), Dg(g6, 704), Dg(A8, 208), s3 = g6 + 704 | 0;
                      }
                      function PA(A8, I7, g6, B4, C4, Q4, E4, n4, a4, r4, o4) {
                        var t4, e4, f4;
                        return s3 = e4 = s3 - 336 | 0, Ig(f4 = e4 + 16 | 0, r4, o4), og(t4 = e4 + 80 | 0, f4), Dg(f4, 64), gg(t4, E4, n4, a4), QI(E4 = e4 + 8 | 0, n4, a4), gg(t4, E4, 8, 0), HI(A8, B4, C4, Q4, r4, o4), gg(t4, A8, C4, Q4), QI(E4, C4, Q4), gg(t4, E4, 8, 0), tg(t4, I7), Dg(t4, 256), g6 && (i3[g6 >> 2] = 16, i3[g6 + 4 >> 2] = 0), s3 = e4 + 336 | 0, 0;
                      }
                      function YA(A8, I7, g6) {
                        i3[A8 + 48 >> 2] = g6 ? n3[0 | g6] | n3[g6 + 1 | 0] << 8 | n3[g6 + 2 | 0] << 16 | n3[g6 + 3 | 0] << 24 : 0, i3[A8 + 52 >> 2] = n3[0 | I7] | n3[I7 + 1 | 0] << 8 | n3[I7 + 2 | 0] << 16 | n3[I7 + 3 | 0] << 24, i3[A8 + 56 >> 2] = n3[I7 + 4 | 0] | n3[I7 + 5 | 0] << 8 | n3[I7 + 6 | 0] << 16 | n3[I7 + 7 | 0] << 24, i3[A8 + 60 >> 2] = n3[I7 + 8 | 0] | n3[I7 + 9 | 0] << 8 | n3[I7 + 10 | 0] << 16 | n3[I7 + 11 | 0] << 24;
                      }
                      function NA(A8, I7, g6, B4, C4, Q4, E4) {
                        var n4;
                        return s3 = n4 = s3 - 16 | 0, A8 = wI(A8, 0, 128), !(B4 | Q4) & E4 >>> 0 < 2147483649 ? !!(C4 | Q4) & E4 >>> 0 > 8191 ? (EI(n4, 16), A8 = _3(C4, E4 >>> 10 | 0, 1, I7, g6, n4, 16, 0, 32, A8, 128, 2) ? -1 : 0) : (i3[8952] = 28, A8 = -1) : (i3[8952] = 22, A8 = -1), s3 = n4 + 16 | 0, A8;
                      }
                      function RA(A8, I7) {
                        var g6 = 0;
                        4 & I7 && ((I7 = i3[A8 >> 2]) && Dg(i3[I7 + 4 >> 2], i3[A8 + 16 >> 2] << 10), (I7 = i3[A8 + 4 >> 2]) && Dg(I7, i3[A8 + 20 >> 2] << 3)), b3(i3[A8 + 4 >> 2]), i3[A8 + 4 >> 2] = 0, (I7 = i3[A8 >> 2]) && (g6 = i3[I7 >> 2]) && b3(g6), b3(I7), i3[A8 >> 2] = 0;
                      }
                      function dA(A8, I7) {
                        var g6, B4, C4 = 0, E4 = 0, i4 = 0, n4 = 0;
                        for (s3 = g6 = s3 - 16 | 0, C4 = 10; n4 = C4, i4 = (I7 >>> 0) / 10 | 0, Q3[0 | (E4 = (C4 = C4 - 1 | 0) + (g6 + 6 | 0) | 0)] = I7 - r3(i4, 10) | 48, !(I7 >>> 0 < 10) && (I7 = i4, C4); )
                          ;
                        B4 = eI(I7 = A8, E4, A8 = 11 - n4 | 0) + A8 | 0, Q3[0 | B4] = 0, s3 = g6 + 16 | 0;
                      }
                      function JA(A8, I7, g6) {
                        var B4, C4, Q4, E4 = 0;
                        s3 = C4 = s3 - 48 | 0, yA(A8, E4 = I7 + 40 | 0, I7), cA(B4 = A8 + 40 | 0, E4, I7), H3(E4 = A8 + 80 | 0, A8, g6 + 40 | 0), H3(B4, B4, g6), H3(Q4 = A8 + 120 | 0, g6 + 120 | 0, I7 + 120 | 0), H3(A8, I7 + 80 | 0, g6 + 80 | 0), yA(C4, A8, A8), cA(A8, E4, B4), yA(B4, E4, B4), cA(E4, C4, Q4), yA(Q4, C4, Q4), s3 = C4 + 48 | 0;
                      }
                      function xA(A8, I7, g6) {
                        var B4, C4, Q4, E4 = 0;
                        s3 = C4 = s3 - 48 | 0, yA(A8, E4 = I7 + 40 | 0, I7), cA(B4 = A8 + 40 | 0, E4, I7), H3(E4 = A8 + 80 | 0, A8, g6), H3(B4, B4, g6 + 40 | 0), H3(Q4 = A8 + 120 | 0, g6 + 120 | 0, I7 + 120 | 0), H3(A8, I7 + 80 | 0, g6 + 80 | 0), yA(C4, A8, A8), cA(A8, E4, B4), yA(B4, E4, B4), yA(E4, C4, Q4), cA(Q4, C4, Q4), s3 = C4 + 48 | 0;
                      }
                      function LA(A8, I7, g6) {
                        var B4 = 0, C4 = 0, Q4 = 0;
                        if (!g6)
                          return 0;
                        A:
                          if (B4 = n3[0 | A8]) {
                            for (; ; ) {
                              if ((C4 = n3[0 | I7]) && !(!(g6 = g6 - 1 | 0) | (0 | B4) != (0 | C4))) {
                                if (I7 = I7 + 1 | 0, B4 = n3[A8 + 1 | 0], A8 = A8 + 1 | 0, B4)
                                  continue;
                                break A;
                              }
                              break;
                            }
                            Q4 = B4;
                          }
                        return (255 & Q4) - n3[0 | I7] | 0;
                      }
                      function KA(A8, I7) {
                        for (var g6 = 0, B4 = 0, C4 = 0, Q4 = 0; C4 = (g6 = B4 << 3) + A8 | 0, Q4 = n3[0 | (g6 = I7 + g6 | 0)] | n3[g6 + 1 | 0] << 8 | n3[g6 + 2 | 0] << 16 | n3[g6 + 3 | 0] << 24, g6 = n3[g6 + 4 | 0] | n3[g6 + 5 | 0] << 8 | n3[g6 + 6 | 0] << 16 | n3[g6 + 7 | 0] << 24, i3[C4 >> 2] = Q4, i3[C4 + 4 >> 2] = g6, (0 | (B4 = B4 + 1 | 0)) != 128; )
                          ;
                      }
                      function XA(A8, I7, g6) {
                        var B4;
                        if (i3[12 + (B4 = s3 - 16 | 0) >> 2] = A8, i3[B4 + 8 >> 2] = I7, I7 = 0, i3[B4 + 4 >> 2] = 0, (0 | g6) > 0)
                          for (; i3[B4 + 4 >> 2] = i3[B4 + 4 >> 2] | n3[i3[B4 + 8 >> 2] + I7 | 0] ^ n3[i3[B4 + 12 >> 2] + I7 | 0], (0 | g6) != (0 | (I7 = I7 + 1 | 0)); )
                            ;
                        return (i3[B4 + 4 >> 2] - 1 >>> 8 & 1) - 1 | 0;
                      }
                      function TA(A8, I7, g6) {
                        var B4, C4, Q4, E4 = 0;
                        s3 = C4 = s3 - 48 | 0, yA(A8, E4 = I7 + 40 | 0, I7), cA(B4 = A8 + 40 | 0, E4, I7), H3(E4 = A8 + 80 | 0, A8, g6), H3(B4, B4, g6 + 40 | 0), H3(Q4 = A8 + 120 | 0, g6 + 80 | 0, I7 + 120 | 0), yA(C4, I7 = I7 + 80 | 0, I7), cA(A8, E4, B4), yA(B4, E4, B4), yA(E4, C4, Q4), cA(Q4, C4, Q4), s3 = C4 + 48 | 0;
                      }
                      function VA(A8, I7, g6) {
                        var B4, C4 = 0, E4 = 0;
                        if (s3 = B4 = s3 - 16 | 0, Q3[B4 + 15 | 0] = 0, E4 = -1, !(0 | vg[i3[8758]](A8, I7, g6))) {
                          for (; Q3[B4 + 15 | 0] = n3[A8 + C4 | 0] | n3[B4 + 15 | 0], (0 | (C4 = C4 + 1 | 0)) != 32; )
                            ;
                          E4 = (n3[B4 + 15 | 0] << 23) - 8388608 >> 31;
                        }
                        return s3 = B4 + 16 | 0, E4;
                      }
                      function qA(A8, I7, g6, B4) {
                        var C4, Q4, E4, i4, n4 = 0, a4 = 0;
                        return i4 = r3(n4 = g6 >>> 16 | 0, a4 = A8 >>> 16 | 0), n4 = (65535 & (a4 = ((E4 = r3(C4 = 65535 & g6, Q4 = 65535 & A8)) >>> 16 | 0) + r3(a4, C4) | 0)) + r3(n4, Q4) | 0, h3 = (r3(I7, g6) + i4 | 0) + r3(A8, B4) + (a4 >>> 16) + (n4 >>> 16) | 0, 65535 & E4 | n4 << 16;
                      }
                      function zA(A8, I7, g6) {
                        var B4;
                        if (i3[12 + (B4 = s3 - 16 | 0) >> 2] = A8, i3[B4 + 8 >> 2] = I7, I7 = 0, Q3[B4 + 7 | 0] = 0, g6)
                          for (; Q3[B4 + 7 | 0] = n3[B4 + 7 | 0] | n3[i3[B4 + 8 >> 2] + I7 | 0] ^ n3[i3[B4 + 12 >> 2] + I7 | 0], (0 | g6) != (0 | (I7 = I7 + 1 | 0)); )
                            ;
                        return (n3[B4 + 7 | 0] - 1 >>> 8 & 1) - 1 | 0;
                      }
                      function jA(A8, I7) {
                        var g6;
                        return s3 = g6 = s3 + -64 | 0, (I7 - 65 & 255) >>> 0 <= 191 && (xI(), t3()), Q3[g6 + 3 | 0] = 1, Q3[g6 + 1 | 0] = 0, Q3[g6 + 2 | 0] = 1, Q3[0 | g6] = I7, RI(4 | g6), QI(8 | g6, 0, 0), wI(g6 + 16 | 0, 0, 48), wA(A8, g6), s3 = g6 - -64 | 0, 0;
                      }
                      function WA(A8, I7, g6, B4, C4, Q4, E4) {
                        var i4 = 0, n4 = 0;
                        i4 = B4, (((i4 = (n4 = g6 + 63 | 0) >>> 0 < 63 ? i4 + 1 | 0 : i4) >>> 6 | 0) + ((0 | (i4 = (63 & i4) << 26 | n4 >>> 6)) != 0) | 0) == 1 & Q4 >>> 0 > (n4 = 0 - i4 | 0) >>> 0 && (xI(), t3()), kI(A8, I7, g6, B4, C4, Q4, E4);
                      }
                      function OA(A8, I7, g6, B4) {
                        var C4 = 0;
                        C4 = -1;
                        A:
                          if (!(B4 - 65 >>> 0 < 4294967232 | g6 >>> 0 > 64)) {
                            I: {
                              if (!g6 || !I7) {
                                if (!jA(A8, 255 & B4))
                                  break I;
                                break A;
                              }
                              if (bA(A8, 255 & B4, I7, 255 & g6))
                                break A;
                            }
                            C4 = 0;
                          }
                        return C4;
                      }
                      function ZA(A8, I7, g6, B4) {
                        return (B4 = (1 + (A8 ^ B4) >>> 8 ^ -1) & g6 | (1 + (16321 ^ A8) >>> 8 ^ -1) & I7 | (I7 = A8 + 65510 >>> 8 & 255) & A8 + 65) | (g6 = A8 + 65484 >>> 8 | 0) & A8 + 71 & (255 ^ I7) | A8 + 252 & A8 + 65474 >>> 8 & (-1 ^ g6) & 255;
                      }
                      function $A(A8) {
                        var I7, g6;
                        return (A8 = (I7 = i3[8748]) + (g6 = A8 + 3 & -4) | 0) >>> 0 <= I7 >>> 0 && g6 || A8 >>> 0 > Mg() << 16 >>> 0 && !(0 | c3(0 | A8)) ? (i3[8952] = 48, -1) : (i3[8748] = A8, I7);
                      }
                      function AI(A8, I7) {
                        for (var g6 = 0, B4 = 0, C4 = 0, Q4 = 0; B4 = (g6 = C4 << 3) + A8 | 0, Q4 = i3[(g6 = I7 + g6 | 0) >> 2], g6 = i3[B4 + 4 >> 2] ^ i3[g6 + 4 >> 2], i3[B4 >> 2] = i3[B4 >> 2] ^ Q4, i3[B4 + 4 >> 2] = g6, (0 | (C4 = C4 + 1 | 0)) != 128; )
                          ;
                      }
                      function II(A8, I7) {
                        var g6, B4, C4, E4, i4;
                        s3 = g6 = s3 - 144 | 0, O3(B4 = g6 + 96 | 0, I7 + 80 | 0), H3(C4 = g6 + 48 | 0, I7, B4), H3(g6, I7 + 40 | 0, B4), T3(A8, g6), E4 = A8, i4 = vI(C4) << 7 ^ n3[A8 + 31 | 0], Q3[E4 + 31 | 0] = i4, s3 = g6 + 144 | 0;
                      }
                      function gI(A8, I7, g6) {
                        var B4 = 0;
                        if (A8 >>> 0 < I7 >>> 0)
                          return eI(A8, I7, g6);
                        if (g6)
                          for (B4 = A8 + g6 | 0, I7 = I7 + g6 | 0; I7 = I7 - 1 | 0, Q3[0 | (B4 = B4 - 1 | 0)] = n3[0 | I7], g6 = g6 - 1 | 0; )
                            ;
                        return A8;
                      }
                      function BI(A8, I7) {
                        var g6, B4 = 0;
                        if (Q3[15 + (g6 = s3 - 16 | 0) | 0] = 0, I7)
                          for (; Q3[g6 + 15 | 0] = n3[A8 + B4 | 0] | n3[g6 + 15 | 0], (0 | (B4 = B4 + 1 | 0)) != (0 | I7); )
                            ;
                        return n3[g6 + 15 | 0] - 1 >>> 8 & 1;
                      }
                      function CI(A8, I7, g6, B4) {
                        var C4;
                        return B4 = I7 + B4 | 0, B4 = (C4 = A8 + g6 | 0) >>> 0 < g6 >>> 0 ? B4 + 1 | 0 : B4, g6 = qA(A8 << 1 & -2, 1 & (I7 = I7 << 1 | A8 >>> 31), g6, 0), A8 = h3 + B4 | 0, h3 = A8 = (I7 = g6 + C4 | 0) >>> 0 < g6 >>> 0 ? A8 + 1 | 0 : A8, I7;
                      }
                      function QI(A8, I7, g6) {
                        Q3[0 | A8] = I7, Q3[A8 + 1 | 0] = I7 >>> 8, Q3[A8 + 2 | 0] = I7 >>> 16, Q3[A8 + 3 | 0] = I7 >>> 24, Q3[A8 + 4 | 0] = g6, Q3[A8 + 5 | 0] = g6 >>> 8, Q3[A8 + 6 | 0] = g6 >>> 16, Q3[A8 + 7 | 0] = g6 >>> 24;
                      }
                      function EI(A8, I7) {
                        A8 |= 0;
                        var g6 = 0, B4 = 0, C4 = 0;
                        if (I7 |= 0)
                          for (; B4 = A8 + g6 | 0, C4 = FI(), Q3[0 | B4] = C4, (0 | (g6 = g6 + 1 | 0)) != (0 | I7); )
                            ;
                      }
                      function iI(A8, I7, g6, B4, C4) {
                        var Q4, E4;
                        return A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0, s3 = Q4 = (E4 = s3) - 128 & -64, IA3(Q4, C4 |= 0), $3(Q4, I7, g6, B4), W3(Q4, A8), s3 = E4, 0;
                      }
                      function nI(A8) {
                        var I7 = 0, g6 = 0, B4 = 0;
                        for (I7 = 1; I7 = n3[0 | (B4 = A8 + g6 | 0)] + I7 | 0, Q3[0 | B4] = I7, I7 = I7 >>> 8 | 0, (0 | (g6 = g6 + 1 | 0)) != 4; )
                          ;
                      }
                      function aI(A8, I7, g6, B4, C4, Q4, E4, i4) {
                        var n4, a4 = 0;
                        return s3 = n4 = s3 - 32 | 0, a4 = -1, oI(n4, E4, i4) || (a4 = zI(A8, I7, g6, B4, C4, Q4, n4), Dg(n4, 32)), s3 = n4 + 32 | 0, a4;
                      }
                      function rI(A8, I7, g6, B4, C4, Q4, E4, i4) {
                        var n4, a4 = 0;
                        return s3 = n4 = s3 - 32 | 0, a4 = -1, oI(n4, E4, i4) || (a4 = jI(A8, I7, g6, B4, C4, Q4, n4), Dg(n4, 32)), s3 = n4 + 32 | 0, a4;
                      }
                      function oI(A8, I7, g6) {
                        A8 |= 0;
                        var B4, C4 = 0;
                        return s3 = B4 = s3 - 32 | 0, C4 = -1, VA(B4, g6 |= 0, I7 |= 0) || (C4 = K3(A8, 34976, B4)), s3 = B4 + 32 | 0, 0 | C4;
                      }
                      function tI(A8, I7) {
                        var g6, B4, C4;
                        H3(A8, I7, g6 = I7 + 120 | 0), H3(A8 + 40 | 0, B4 = I7 + 40 | 0, C4 = I7 + 80 | 0), H3(A8 + 80 | 0, C4, g6), H3(A8 + 120 | 0, I7, B4);
                      }
                      function eI(A8, I7, g6) {
                        var B4 = 0;
                        if (g6)
                          for (B4 = A8; Q3[0 | B4] = n3[0 | I7], B4 = B4 + 1 | 0, I7 = I7 + 1 | 0, g6 = g6 - 1 | 0; )
                            ;
                        return A8;
                      }
                      function fI(A8, I7) {
                        var g6, B4;
                        s3 = B4 = s3 - 128 | 0, UA(g6 = B4 + 8 | 0, I7), UA(g6 + 40 | 0, I7 + 40 | 0), UA(g6 + 80 | 0, I7 + 80 | 0), G3(A8, g6), s3 = B4 + 128 | 0;
                      }
                      function cI(A8, I7, g6, B4, C4, Q4, E4) {
                        return !B4 & g6 >>> 0 >= 16 | B4 ? rI(A8, I7 + 16 | 0, I7, g6 - 16 | 0, B4 - (g6 >>> 0 < 16) | 0, C4, Q4, E4) : -1;
                      }
                      function yI(A8, I7) {
                        for (var g6 = 0, B4 = 0; Q3[0 | (B4 = A8 + g6 | 0)] = n3[0 | B4] ^ n3[I7 + g6 | 0], (0 | (g6 = g6 + 1 | 0)) != 8; )
                          ;
                      }
                      function sI(A8, I7, g6) {
                        var B4, C4;
                        s3 = B4 = (C4 = s3) - 384 & -64, PI(B4, 0, 0, 24), ig(B4, I7, 32, 0), ig(B4, g6, 32, 0), dI(B4, A8, 24), s3 = C4;
                      }
                      function wI(A8, I7, g6) {
                        var B4 = 0;
                        if (g6)
                          for (B4 = A8; Q3[0 | B4] = I7, B4 = B4 + 1 | 0, g6 = g6 - 1 | 0; )
                            ;
                        return A8;
                      }
                      function DI(A8, I7) {
                        var g6;
                        yA(A8, g6 = I7 + 40 | 0, I7), cA(A8 + 40 | 0, g6, I7), UA(A8 + 80 | 0, I7 + 80 | 0), H3(A8 + 120 | 0, I7 + 120 | 0, 1520);
                      }
                      function hI(A8, I7) {
                        var g6;
                        H3(A8, I7, g6 = I7 + 120 | 0), H3(A8 + 40 | 0, I7 + 40 | 0, I7 = I7 + 80 | 0), H3(A8 + 80 | 0, I7, g6);
                      }
                      function pI(A8, I7, g6, B4, C4, Q4, E4) {
                        return !B4 & g6 >>> 0 >= 4294967280 | B4 && (xI(), t3()), aI(A8 + 16 | 0, A8, I7, g6, B4, C4, Q4, E4);
                      }
                      function uI(A8) {
                        var I7;
                        return I7 = n3[0 | A8] | n3[A8 + 1 | 0] << 8, A8 = n3[A8 + 2 | 0], h3 = A8 >>> 16 | 0, I7 | A8 << 16;
                      }
                      function FI() {
                        var A8, I7;
                        return s3 = A8 = s3 - 16 | 0, Q3[A8 + 15 | 0] = 0, I7 = 0 | f3(35048, A8 + 15 | 0, 0), s3 = A8 + 16 | 0, 0 | I7;
                      }
                      function lI(A8, I7) {
                        var g6 = 0;
                        return (-1 >>> (g6 = 31 & I7) & A8) << g6 | ((g6 = A8) & -1 << (A8 = 0 - I7 & 31)) >>> A8;
                      }
                      function _I(A8, I7, g6, B4) {
                        var C4;
                        return s3 = C4 = s3 - 208 | 0, GI(C4), z3(C4, I7, g6, B4), MA(C4, A8), s3 = C4 + 208 | 0, 0;
                      }
                      function kI(A8, I7, g6, B4, C4, Q4, E4) {
                        (0 | B4) == 1 | B4 >>> 0 > 1 && (xI(), t3()), vg[i3[8752]](A8, I7, g6, B4, C4, Q4, E4);
                      }
                      function HI(A8, I7, g6, B4, C4, Q4) {
                        (0 | B4) == 1 | B4 >>> 0 > 1 && (xI(), t3()), vg[i3[8751]](A8, I7, g6, B4, C4, 1, 0, Q4);
                      }
                      function GI(A8) {
                        i3[A8 + 64 >> 2] = 0, i3[A8 + 68 >> 2] = 0, i3[A8 + 72 >> 2] = 0, i3[A8 + 76 >> 2] = 0, eI(A8, 34080, 64);
                      }
                      function UI(A8, I7, g6) {
                        return g6 >>> 0 >= 256 && (e3(1279, 1206, 107, 1067), t3()), Y3(A8, I7, 255 & g6);
                      }
                      function SI() {
                        var A8;
                        s3 = A8 = s3 - 16 | 0, Q3[A8 + 15 | 0] = 0, f3(35084, A8 + 15 | 0, 0), s3 = A8 + 16 | 0;
                      }
                      function bI(A8, I7) {
                        Q3[0 | A8] = I7, Q3[A8 + 1 | 0] = I7 >>> 8, Q3[A8 + 2 | 0] = I7 >>> 16, Q3[A8 + 3 | 0] = I7 >>> 24;
                      }
                      function mI(A8) {
                        var I7;
                        return s3 = I7 = s3 - 32 | 0, T3(I7, A8), A8 = BI(I7, 32), s3 = I7 + 32 | 0, A8;
                      }
                      function vI(A8) {
                        var I7;
                        return s3 = I7 = s3 - 32 | 0, T3(I7, A8), s3 = I7 + 32 | 0, 1 & Q3[0 | I7];
                      }
                      function MI(A8, I7, g6) {
                        aA(A8, I7, g6), aA(A8 + 40 | 0, I7 + 40 | 0, g6), aA(A8 + 80 | 0, I7 + 80 | 0, g6);
                      }
                      function PI(A8, I7, g6, B4) {
                        return 0 | OA(A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0);
                      }
                      function YI(A8) {
                        Q3[A8 + 32 | 0] = 1, Q3[A8 + 33 | 0] = 0, Q3[A8 + 34 | 0] = 0, Q3[A8 + 35 | 0] = 0;
                      }
                      function NI(A8) {
                        i3[A8 >> 2] = 0, i3[A8 + 4 >> 2] = 0, i3[A8 + 8 >> 2] = 0, i3[A8 + 12 >> 2] = 0;
                      }
                      function RI(A8) {
                        Q3[0 | A8] = 0, Q3[A8 + 1 | 0] = 0, Q3[A8 + 2 | 0] = 0, Q3[A8 + 3 | 0] = 0;
                      }
                      function dI(A8, I7, g6) {
                        return 0 | UI(A8 |= 0, I7 |= 0, g6 |= 0);
                      }
                      function JI(A8, I7, g6) {
                        return 0 | VA(A8 |= 0, I7 |= 0, g6 |= 0);
                      }
                      function xI() {
                        var A8;
                        (A8 = i3[9098]) && vg[0 | A8](), y3(), t3();
                      }
                      function LI(A8) {
                        hg(A8), ng(A8 + 40 | 0), ng(A8 + 80 | 0), hg(A8 + 120 | 0);
                      }
                      function KI(A8, I7, g6, B4, C4, Q4) {
                        vg[i3[8761]](A8, I7, g6, B4, C4, 1, 0, Q4);
                      }
                      function XI(A8, I7, g6, B4, C4, Q4) {
                        vg[i3[8761]](A8, I7, g6, B4, C4, 0, 0, Q4);
                      }
                      function TI(A8, I7) {
                        return A8 |= 0, EI(I7 |= 0, 32), 0 | Bg(A8, I7);
                      }
                      function VI(A8, I7, g6, B4, C4, Q4) {
                        return u3(A8, I7, g6, B4, C4, Q4, 0), 0;
                      }
                      function qI(A8, I7, g6, B4, C4, Q4, E4) {
                        return vA(A8, I7, g6, B4, C4, Q4, E4);
                      }
                      function zI(A8, I7, g6, B4, C4, Q4, E4) {
                        return EA(A8, I7, g6, B4, C4, Q4, E4);
                      }
                      function jI(A8, I7, g6, B4, C4, Q4, E4) {
                        return iA(A8, I7, g6, B4, C4, Q4, E4);
                      }
                      function WI(A8, I7) {
                        GI(A8), I7 && z3(A8, 34912, 34, 0);
                      }
                      function OI(A8, I7, g6, B4, C4) {
                        return J3(A8, I7, g6, B4, C4, 0);
                      }
                      function ZI(A8, I7) {
                        return 0 | Bg(A8 |= 0, I7 |= 0);
                      }
                      function $I(A8, I7, g6, B4) {
                        vg[i3[8750]](A8, I7, 0, g6, B4);
                      }
                      function Ag(A8, I7) {
                        return (255 & (A8 ^ I7)) - 1 >>> 31 | 0;
                      }
                      function Ig(A8, I7, g6) {
                        vg[i3[8749]](A8, 64, 0, I7, g6);
                      }
                      function gg(A8, I7, g6, B4) {
                        vg[i3[8756]](A8, I7, g6, B4);
                      }
                      function Bg(A8, I7) {
                        return 0 | vg[i3[8759]](A8, I7);
                      }
                      function Cg(A8, I7, g6, B4) {
                        return gA2(A8, I7, g6, B4);
                      }
                      function Qg(A8) {
                        return ZA(A8, 45, 95, 32704);
                      }
                      function Eg(A8) {
                        return ZA(A8, 43, 47, 16320);
                      }
                      function ig(A8, I7, g6, B4) {
                        return Cg(A8, I7, g6, B4);
                      }
                      function ng(A8) {
                        i3[A8 >> 2] = 1, wI(A8 + 4 | 0, 0, 36);
                      }
                      function ag(A8) {
                        (-7 & A8) != 1 && (xI(), t3());
                      }
                      function rg(A8, I7) {
                        return XA(A8, I7, 16);
                      }
                      function og(A8, I7) {
                        vg[i3[8755]](A8, I7);
                      }
                      function tg(A8, I7) {
                        vg[i3[8757]](A8, I7);
                      }
                      function eg(A8, I7) {
                        return XA(A8, I7, 32);
                      }
                      function fg(A8, I7, g6, B4) {
                        $I(A8, I7, g6, B4);
                      }
                      function cg(A8, I7) {
                        return lI(A8, I7);
                      }
                      function yg(A8, I7) {
                        eI(A8, I7, 1024);
                      }
                      function sg(A8) {
                        EI(A8 |= 0, 32);
                      }
                      function wg(A8) {
                        wI(A8, 0, 1024);
                      }
                      function Dg(A8, I7) {
                        wI(A8, 0, I7);
                      }
                      function hg(A8) {
                        wI(A8, 0, 40);
                      }
                      function pg() {
                        return 32;
                      }
                      function ug() {
                        return 24;
                      }
                      function Fg() {
                        return -17;
                      }
                      function lg() {
                        return 64;
                      }
                      function _g() {
                        return 16;
                      }
                      function kg() {
                        return 1;
                      }
                      function Hg() {
                        return 2;
                      }
                      function Gg() {
                        return 8;
                      }
                      function Ug() {
                        return 3;
                      }
                      function Sg() {
                        return 0;
                      }
                      function bg() {
                        return -1;
                      }
                      C3(I6 = n3, 1024, "TGlic29kaXVtRFJHcmFuZG9tYnl0ZXMAYjY0X3BvcyA8PSBiNjRfbGVuAGNyeXB0b19nZW5lcmljaGFzaF9ibGFrZTJiX2ZpbmFsACRhcmdvbjJpACRhcmdvbjJpZAByYW5kb21ieXRlcy9yYW5kb21ieXRlcy5jAHNvZGl1bS9jb2RlY3MuYwBjcnlwdG9fZ2VuZXJpY2hhc2gvYmxha2UyYi9yZWYvYmxha2UyYi1yZWYuYwBjcnlwdG9fZ2VuZXJpY2hhc2gvYmxha2UyYi9yZWYvZ2VuZXJpY2hhc2hfYmxha2UyYi5jAGJ1Zl9sZW4gPD0gU0laRV9NQVgAb3V0bGVuIDw9IFVJTlQ4X01BWABTLT5idWZsZW4gPD0gQkxBS0UyQl9CTE9DS0JZVEVTACRhcmdvbjJpJHY9ACRhcmdvbjJpZCR2PQAsdD0ALHA9ACRtPQAxLjAuMTgAc29kaXVtX2JpbjJiYXNlNjQAJGFyZ29uMmkkACRhcmdvbjJpZCQ="), C3(I6, 1424, "tnhZ/4Vy0wC9bhX/DwpqACnAAQCY6Hn/vDyg/5lxzv8At+L+tA1I/wAAAAAAAAAAsKAO/tPJhv+eGI8Af2k1AGAMvQCn1/v/n0yA/mpl4f8e/AQAkgyu"), C3(I6, 1520, "WfGy/grlpv973Sr+HhTUAFKAAwAw0fMAd3lA/zLjnP8AbsUBZxuQ"), C3(I6, 1568, "hTuMAb3xJP/4JcMBYNw3ALdMPv/DQj0AMkykAeGkTP9MPaP/dT4fAFGRQP92QQ4AonPW/waKLgB85vT/CoqPADQawgC49EwAgY8pAb70E/97qnr/YoFEAHnVkwBWZR7/oWebAIxZQ//v5b4BQwu1AMbwif7uRbz/Q5fuABMqbP/lVXEBMkSH/xFqCQAyZwH/UAGoASOYHv8QqLkBOFno/2XS/AAp+kcAzKpP/w4u7/9QTe8AvdZL/xGN+QAmUEz/vlV1AFbkqgCc2NABw8+k/5ZCTP+v4RD/jVBiAUzb8gDGonIALtqYAJsr8f6boGj/M7ulAAIRrwBCVKAB9zoeACNBNf5F7L8ALYb1AaN73QAgbhT/NBelALrWRwDpsGAA8u82ATlZigBTAFT/iKBkAFyOeP5ofL4AtbE+//opVQCYgioBYPz2AJeXP/7vhT4AIDicAC2nvf+OhbMBg1bTALuzlv76qg7/0qNOACU0lwBjTRoA7pzV/9XA0QFJLlQAFEEpATbOTwDJg5L+qm8Y/7EhMv6rJsv/Tvd0ANHdmQCFgLIBOiwZAMknOwG9E/wAMeXSAXW7dQC1s7gBAHLbADBekwD1KTgAfQ3M/vStdwAs3SD+VOoUAPmgxgHsfur/L2Oo/qrimf9ms9gA4o16/3pCmf629YYA4+QZAdY56//YrTj/tefSAHeAnf+BX4j/bn4zAAKpt/8HgmL+RbBe/3QE4wHZ8pH/yq0fAWkBJ/8ur0UA5C86/9fgRf7POEX/EP6L/xfP1P/KFH7/X9Vg/wmwIQDIBc//8SqA/iMhwP/45cQBgRF4APtnl/8HNHD/jDhC/yji9f/ZRiX+rNYJ/0hDhgGSwNb/LCZwAES4S//OWvsAleuNALWqOgB09O8AXJ0CAGatYgDpiWABfzHLAAWblAAXlAn/03oMACKGGv/bzIgAhggp/+BTK/5VGfcAbX8A/qmIMADud9v/563VAM4S/v4Iugf/fgkHAW8qSABvNOz+YD+NAJO/f/7NTsD/DmrtAbvbTACv87v+aVmtAFUZWQGi85QAAnbR/iGeCQCLoy7/XUYoAGwqjv5v/I7/m9+QADPlp/9J/Jv/XnQM/5ig2v+c7iX/s+rP/8UAs/+apI0A4cRoAAojGf7R1PL/Yf3e/rhl5QDeEn8BpIiH/x7PjP6SYfMAgcAa/slUIf9vCk7/k1Gy/wQEGACh7tf/Bo0hADXXDv8ptdD/54udALPL3f//uXEAveKs/3FC1v/KPi3/ZkAI/06uEP6FdUT/"), C3(I6, 2560, "AQ=="), C3(I6, 2592, "JuiVj8KyJ7BFw/SJ8u+Y8NXfrAXTxjM5sTgCiG1T/AXHF2pwPU3YT7o8C3YNEGcPKiBT+iw5zMZOx/13kqwDeuz///////////////////////////////////////9/7f///////////////////////////////////////3/u////////////////////////////////////////f+3T9VwaYxJY1pz3ot753hQ="), C3(I6, 2783, "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"), C3(I6, 33756, "AQ=="), C3(I6, 33792, "AQ=="), C3(I6, 33824, "4Ot6fDtBuK4WVuP68Z/EatoJjeucMrH9hmIFFl9JuABfnJW8o1CMJLHQsVWcg+9bBERcxFgcjobYIk7d0J8RV+z///////////////////////////////////////9/7f///////////////////////////////////////3/u////////////////////////////////////////fwjJvPNn5glqO6fKhIWuZ7sr+JT+cvNuPPE2HV869U+l0YLmrX9SDlEfbD4rjGgFm2u9Qfur2YMfeSF+ExnN4Fs="), C3(I6, 34080, "CMm882fmCWo7p8qEha5nuyv4lP5y82488TYdXzr1T6XRguatf1IOUR9sPiuMaAWba71B+6vZgx95IX4TGc3gWyKuKNeYL4pCzWXvI5FEN3EvO03sz/vAtbzbiYGl27XpOLVI81vCVjkZ0AW28RHxWZtPGa+kgj+SGIFt2tVeHKtCAgOjmKoH2L5vcEUBW4MSjLLkTr6FMSTitP/Vw30MVW+Je/J0Xb5ysZYWO/6x3oA1Esclpwbcm5Qmac908ZvB0krxnsFpm+TjJU84hke+77XVjIvGncEPZZysd8yhDCR1AitZbyzpLYPkpm6qhHRK1PtBvdypsFy1UxGD2oj5dqvfZu5SUT6YEDK0LW3GMag/IfuYyCcDsOQO777Hf1m/wo+oPfML4MYlpwqTR5Gn1W+CA+BRY8oGcG4OCmcpKRT8L9JGhQq3JybJJlw4IRsu7SrEWvxtLE3fs5WdEw04U95jr4tUcwplqLJ3PLsKanbmru1HLsnCgTs1ghSFLHKSZAPxTKHov6IBMEK8S2YaqJGX+NBwi0vCML5UBqNRbMcYUu/WGeiS0RCpZVUkBpnWKiBxV4U1DvS40bsycKBqEMjQ0rgWwaQZU6tBUQhsNx6Z647fTHdIJ6hIm+G1vLA0Y1rJxbMMHDnLikHjSqrYTnPjY3dPypxbo7iy1vNvLmj8su9d7oKPdGAvF0NvY6V4cqvwoRR4yITsOWQaCALHjCgeYyP6/76Q6b2C3utsUKQVecay96P5vitTcuPyeHHGnGEm6s4+J8oHwsAhx7iG0R7r4M3WfdrqeNFu7n9PffW6bxdyqmfwBqaYyKLFfWMKrg35vgSYPxEbRxwTNQtxG4R9BCP1d9sokyTHQHuryjK8vskVCr6ePEwNEJzEZx1DtkI+y77UxUwqfmX8nCl/Wez61jqrb8tfF1hHSowZRGyA"), C3(I6, 34912, "U2lnRWQyNTUxOSBubyBFZDI1NTE5IGNvbGxpc2lvbnMB"), C3(I6, 34992, "MI5QAAEAAAACAAAAAwAAAAQAAAAFAAAABgAAAAcAAAAIAAAACQAAAAoAAAALAAAADAAAAA0=");
                      var mg, vg = (mg = [null, function(A8, I7, g6, B4, C4) {
                        var Q4;
                        return A8 |= 0, B4 |= 0, s3 = Q4 = s3 + -64 | 0, (I7 |= 0) | (g6 |= 0) && (QA(Q4, C4 |= 0), SA(Q4, B4, 0), m3(Q4, A8 = wI(A8, 0, I7), A8, I7, g6), Dg(Q4, 64)), s3 = Q4 - -64 | 0, 0;
                      }, function(A8, I7, g6, B4, C4) {
                        var Q4;
                        return A8 |= 0, B4 |= 0, s3 = Q4 = s3 + -64 | 0, (I7 |= 0) | (g6 |= 0) && (QA(Q4, C4 |= 0), YA(Q4, B4, 0), m3(Q4, A8 = wI(A8, 0, I7), A8, I7, g6), Dg(Q4, 64)), s3 = Q4 - -64 | 0, 0;
                      }, function(A8, I7, g6, B4, C4, Q4, E4, i4) {
                        A8 |= 0, I7 |= 0, C4 |= 0, Q4 |= 0, E4 |= 0, i4 |= 0;
                        var n4, a4 = 0;
                        return s3 = n4 = s3 - 80 | 0, (g6 |= 0) | (B4 |= 0) && (bI(a4 = n4 + 8 | 0, Q4), bI(n4 + 12 | 0, E4), QA(Q4 = n4 + 16 | 0, i4), SA(Q4, C4, a4), m3(Q4, I7, A8, g6, B4), Dg(Q4, 64)), s3 = n4 + 80 | 0, 0;
                      }, function(A8, I7, g6, B4, C4, Q4, E4) {
                        A8 |= 0, I7 |= 0, C4 |= 0, Q4 |= 0, E4 |= 0;
                        var i4, n4 = 0;
                        return s3 = i4 = s3 - 80 | 0, (g6 |= 0) | (B4 |= 0) && (bI(n4 = i4 + 12 | 0, Q4), QA(Q4 = i4 + 16 | 0, E4), YA(Q4, C4, n4), m3(Q4, I7, A8, g6, B4), Dg(Q4, 64)), s3 = i4 + 80 | 0, 0;
                      }, iI, function(A8, I7, g6, B4, C4) {
                        var Q4;
                        return A8 |= 0, s3 = Q4 = s3 - 16 | 0, iI(Q4, I7 |= 0, g6 |= 0, B4 |= 0, C4 |= 0), A8 = rg(A8, Q4), s3 = Q4 + 16 | 0, 0 | A8;
                      }, function(A8, I7) {
                        return IA3(A8 |= 0, I7 |= 0), 0;
                      }, function(A8, I7, g6, B4) {
                        return $3(A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0), 0;
                      }, function(A8, I7) {
                        return W3(A8 |= 0, I7 |= 0), 0;
                      }, function(A8, I7, g6) {
                        A8 |= 0, I7 |= 0, g6 |= 0;
                        var B4, C4 = 0, E4 = 0, a4 = 0, r4 = 0, o4 = 0, t4 = 0, e4 = 0, f4 = 0, c4 = 0, y4 = 0, w4 = 0, D4 = 0, p4 = 0, u4 = 0, F4 = 0, l4 = 0, _4 = 0, k4 = 0, G4 = 0, S4 = 0, b4 = 0, m4 = 0, v4 = 0, M4 = 0, P4 = 0, Y4 = 0, R4 = 0, d4 = 0, J4 = 0;
                        for (r4 = -1, Q3[11 + (E4 = (s3 = B4 = s3 - 336 | 0) - 16 | 0) | 0] = 0, Q3[E4 + 12 | 0] = 0, Q3[E4 + 13 | 0] = 0, Q3[E4 + 14 | 0] = 0, i3[E4 + 8 >> 2] = 0; ; ) {
                          for (e4 = n3[g6 + a4 | 0], C4 = 0; Q3[0 | (o4 = (E4 + 8 | 0) + C4 | 0)] = n3[0 | o4] | e4 ^ n3[(33760 + (C4 << 5) | 0) + a4 | 0], (0 | (C4 = C4 + 1 | 0)) != 7; )
                            ;
                          if ((0 | (a4 = a4 + 1 | 0)) == 31)
                            break;
                        }
                        for (e4 = 127 & n3[g6 + 31 | 0], a4 = 0, C4 = 0; Q3[0 | (o4 = (E4 + 8 | 0) + C4 | 0)] = n3[0 | o4] | e4 ^ n3[33791 + (C4 << 5) | 0], (0 | (C4 = C4 + 1 | 0)) != 7; )
                          ;
                        for (C4 = 0; C4 = n3[(E4 + 8 | 0) + a4 | 0] - 1 | C4, (0 | (a4 = a4 + 1 | 0)) != 7; )
                          ;
                        if (!(C4 >>> 8 & 1)) {
                          for (r4 = 0; Q3[A8 + r4 | 0] = n3[I7 + r4 | 0], (0 | (r4 = r4 + 1 | 0)) != 32; )
                            ;
                          for (Q3[0 | A8] = 248 & n3[0 | A8], Q3[A8 + 31 | 0] = 63 & n3[A8 + 31 | 0] | 64, N3(I7 = B4 + 288 | 0, g6), ng(B4 + 240 | 0), hg(B4 + 192 | 0), UA(B4 + 144 | 0, I7), ng(B4 + 96 | 0), g6 = 254, I7 = 0; C4 = I7, AA3(E4 = B4 + 240 | 0, y4 = B4 + 144 | 0, C4 ^= I7 = n3[(g6 >>> 3 | 0) + A8 | 0] >>> (7 & g6) & 1), AA3(t4 = B4 + 192 | 0, r4 = B4 + 96 | 0, C4), m4 = g6, g6 = g6 - 1 | 0, cA(f4 = B4 + 48 | 0, y4, r4), cA(B4, E4, t4), yA(E4, E4, t4), yA(t4, y4, r4), H3(r4, f4, E4), H3(t4, t4, B4), U3(f4, B4), U3(B4, E4), yA(y4, r4, t4), cA(t4, r4, t4), H3(E4, B4, f4), cA(B4, B4, f4), U3(t4, t4), u4 = C4 = i3[B4 + 4 >> 2], F4 = C4 >> 31, l4 = C4 = i3[B4 + 8 >> 2], v4 = C4 >> 31, D4 = C4 = i3[B4 + 12 >> 2], p4 = C4 >> 31, _4 = C4 = i3[B4 + 16 >> 2], M4 = C4 >> 31, c4 = C4 = i3[B4 + 20 >> 2], w4 = C4 >> 31, k4 = C4 = i3[B4 + 24 >> 2], P4 = C4 >> 31, Y4 = C4 = i3[B4 >> 2], R4 = C4 >> 31, E4 = qA(C4 = i3[B4 + 36 >> 2], C4 >> 31, 121666, 0), C4 = h3, d4 = a4 = E4 + 16777216 | 0, e4 = C4 = a4 >>> 0 < 16777216 ? C4 + 1 | 0 : C4, G4 = E4 - (-33554432 & a4) | 0, C4 = qA(C4 = i3[B4 + 32 >> 2], C4 >> 31, 121666, 0), a4 = h3, o4 = qA(E4 = i3[B4 + 28 >> 2], E4 >> 31, 121666, 0), E4 = h3, J4 = C4, S4 = C4 = o4 + 16777216 | 0, a4 = (C4 = (E4 = C4 >>> 0 < 16777216 ? E4 + 1 | 0 : E4) >> 25) + a4 | 0, C4 = a4 = (E4 = J4 + (b4 = (33554431 & E4) << 7 | S4 >>> 25) | 0) >>> 0 < b4 >>> 0 ? a4 + 1 | 0 : a4, C4 = ((67108863 & (C4 = (a4 = E4 + 33554432 | 0) >>> 0 < 33554432 ? C4 + 1 | 0 : C4)) << 6 | a4 >>> 26) + G4 | 0, i3[r4 + 36 >> 2] = C4, C4 = -67108864 & a4, i3[r4 + 32 >> 2] = E4 - C4, G4 = o4 - (-33554432 & S4) | 0, E4 = qA(k4, P4, 121666, 0), k4 = h3, a4 = qA(c4, w4, 121666, 0), C4 = h3, o4 = E4, c4 = E4 = a4 + 16777216 | 0, w4 = (33554431 & (C4 = E4 >>> 0 < 16777216 ? C4 + 1 | 0 : C4)) << 7 | E4 >>> 25, C4 = (C4 >> 25) + k4 | 0, E4 = C4 = (o4 = o4 + w4 | 0) >>> 0 < w4 >>> 0 ? C4 + 1 | 0 : C4, w4 = C4 = o4 + 33554432 | 0, C4 = ((67108863 & (E4 = C4 >>> 0 < 33554432 ? E4 + 1 | 0 : E4)) << 6 | C4 >>> 26) + G4 | 0, i3[r4 + 28 >> 2] = C4, C4 = -67108864 & w4, i3[r4 + 24 >> 2] = o4 - C4, c4 = a4 - (-33554432 & c4) | 0, C4 = qA(_4, M4, 121666, 0), _4 = h3, o4 = qA(D4, p4, 121666, 0), E4 = h3, a4 = C4, D4 = C4 = o4 + 16777216 | 0, p4 = (33554431 & (E4 = C4 >>> 0 < 16777216 ? E4 + 1 | 0 : E4)) << 7 | C4 >>> 25, E4 = (E4 >> 25) + _4 | 0, a4 = C4 = a4 + p4 | 0, C4 = C4 >>> 0 < p4 >>> 0 ? E4 + 1 | 0 : E4, C4 = ((67108863 & (C4 = (E4 = a4 + 33554432 | 0) >>> 0 < 33554432 ? C4 + 1 | 0 : C4)) << 6 | E4 >>> 26) + c4 | 0, i3[r4 + 20 >> 2] = C4, C4 = -67108864 & E4, i3[r4 + 16 >> 2] = a4 - C4, D4 = o4 - (-33554432 & D4) | 0, C4 = qA(l4, v4, 121666, 0), l4 = h3, o4 = qA(u4, F4, 121666, 0), a4 = h3, c4 = C4, u4 = C4 = o4 + 16777216 | 0, E4 = C4, C4 = (C4 = (a4 = C4 >>> 0 < 16777216 ? a4 + 1 | 0 : a4) >> 25) + l4 | 0, C4 = (E4 = c4 + (a4 = (33554431 & a4) << 7 | E4 >>> 25) | 0) >>> 0 < a4 >>> 0 ? C4 + 1 | 0 : C4, a4 = E4, E4 = C4, F4 = C4 = a4 + 33554432 | 0, C4 = ((67108863 & (E4 = C4 >>> 0 < 33554432 ? E4 + 1 | 0 : E4)) << 6 | C4 >>> 26) + D4 | 0, i3[r4 + 12 >> 2] = C4, C4 = -67108864 & F4, i3[r4 + 8 >> 2] = a4 - C4, C4 = qA((33554431 & e4) << 7 | d4 >>> 25, e4 >> 25, 19, 0), a4 = h3, E4 = (e4 = qA(Y4, R4, 121666, 0)) + C4 | 0, C4 = h3 + a4 | 0, a4 = E4, E4 = E4 >>> 0 < e4 >>> 0 ? C4 + 1 | 0 : C4, e4 = C4 = a4 + 33554432 | 0, C4 = (o4 - (-33554432 & u4) | 0) + ((67108863 & (E4 = C4 >>> 0 < 33554432 ? E4 + 1 | 0 : E4)) << 6 | C4 >>> 26) | 0, i3[r4 + 4 >> 2] = C4, C4 = -67108864 & e4, i3[r4 >> 2] = a4 - C4, U3(y4, y4), yA(f4, f4, r4), H3(r4, B4 + 288 | 0, t4), H3(t4, B4, f4), m4; )
                            ;
                          AA3(g6 = B4 + 240 | 0, B4 + 144 | 0, I7), AA3(C4 = B4 + 192 | 0, B4 + 96 | 0, I7), O3(C4, C4), H3(g6, g6, C4), T3(A8, g6), r4 = 0;
                        }
                        return s3 = B4 + 336 | 0, 0 | r4;
                      }, function(A8, I7) {
                        A8 |= 0, I7 |= 0;
                        var g6, B4, C4, E4 = 0;
                        for (s3 = g6 = s3 - 208 | 0; Q3[A8 + E4 | 0] = n3[I7 + E4 | 0], (0 | (E4 = E4 + 1 | 0)) != 32; )
                          ;
                        return Q3[0 | A8] = 248 & n3[0 | A8], Q3[A8 + 31 | 0] = 63 & n3[A8 + 31 | 0] | 64, BA2(g6 + 48 | 0, A8), s3 = I7 = s3 - 96 | 0, yA(E4 = I7 + 48 | 0, B4 = g6 + 128 | 0, C4 = g6 + 88 | 0), cA(I7, B4, C4), O3(I7, I7), H3(g6, E4, I7), s3 = I7 + 96 | 0, T3(A8, g6), s3 = g6 + 208 | 0, 0;
                      }, function(A8, I7, g6, B4, C4) {
                        A8 |= 0, B4 |= 0, C4 |= 0;
                        var E4, a4 = 0;
                        if (s3 = E4 = s3 - 112 | 0, (I7 |= 0) | (g6 |= 0)) {
                          a4 = n3[C4 + 28 | 0] | n3[C4 + 29 | 0] << 8 | n3[C4 + 30 | 0] << 16 | n3[C4 + 31 | 0] << 24, i3[E4 + 24 >> 2] = n3[C4 + 24 | 0] | n3[C4 + 25 | 0] << 8 | n3[C4 + 26 | 0] << 16 | n3[C4 + 27 | 0] << 24, i3[E4 + 28 >> 2] = a4, a4 = n3[C4 + 20 | 0] | n3[C4 + 21 | 0] << 8 | n3[C4 + 22 | 0] << 16 | n3[C4 + 23 | 0] << 24, i3[E4 + 16 >> 2] = n3[C4 + 16 | 0] | n3[C4 + 17 | 0] << 8 | n3[C4 + 18 | 0] << 16 | n3[C4 + 19 | 0] << 24, i3[E4 + 20 >> 2] = a4, a4 = n3[C4 + 4 | 0] | n3[C4 + 5 | 0] << 8 | n3[C4 + 6 | 0] << 16 | n3[C4 + 7 | 0] << 24, i3[E4 >> 2] = n3[0 | C4] | n3[C4 + 1 | 0] << 8 | n3[C4 + 2 | 0] << 16 | n3[C4 + 3 | 0] << 24, i3[E4 + 4 >> 2] = a4, a4 = n3[C4 + 12 | 0] | n3[C4 + 13 | 0] << 8 | n3[C4 + 14 | 0] << 16 | n3[C4 + 15 | 0] << 24, i3[E4 + 8 >> 2] = n3[C4 + 8 | 0] | n3[C4 + 9 | 0] << 8 | n3[C4 + 10 | 0] << 16 | n3[C4 + 11 | 0] << 24, i3[E4 + 12 >> 2] = a4, C4 = n3[0 | B4] | n3[B4 + 1 | 0] << 8 | n3[B4 + 2 | 0] << 16 | n3[B4 + 3 | 0] << 24, B4 = n3[B4 + 4 | 0] | n3[B4 + 5 | 0] << 8 | n3[B4 + 6 | 0] << 16 | n3[B4 + 7 | 0] << 24, i3[E4 + 104 >> 2] = 0, i3[E4 + 108 >> 2] = 0, i3[E4 + 96 >> 2] = C4, i3[E4 + 100 >> 2] = B4;
                          A: {
                            if (!g6 & I7 >>> 0 >= 64 | g6) {
                              for (; ; ) {
                                for (d3(A8, E4 + 96 | 0, E4), C4 = 8, B4 = 1; B4 = n3[0 | (a4 = (E4 + 96 | 0) + C4 | 0)] + B4 | 0, Q3[0 | a4] = B4, B4 = B4 >>> 8 | 0, (0 | (C4 = C4 + 1 | 0)) != 16; )
                                  ;
                                if (A8 = A8 - -64 | 0, g6 = g6 - 1 | 0, !(!(g6 = (I7 = I7 + -64 | 0) >>> 0 < 4294967232 ? g6 + 1 | 0 : g6) & I7 >>> 0 > 63 | g6))
                                  break;
                              }
                              if (!(I7 | g6))
                                break A;
                            }
                            for (C4 = 0, d3(E4 + 32 | 0, E4 + 96 | 0, E4); Q3[A8 + C4 | 0] = n3[(E4 + 32 | 0) + C4 | 0], (0 | I7) != (0 | (C4 = C4 + 1 | 0)); )
                              ;
                          }
                          Dg(E4 + 32 | 0, 64), Dg(E4, 32);
                        }
                        return s3 = E4 + 112 | 0, 0;
                      }, function(A8, I7, g6, B4, C4, E4, a4, r4) {
                        A8 |= 0, I7 |= 0, C4 |= 0, E4 |= 0, a4 |= 0, r4 |= 0;
                        var o4, t4 = 0, e4 = 0;
                        if (s3 = o4 = s3 - 112 | 0, (g6 |= 0) | (B4 |= 0)) {
                          for (t4 = n3[r4 + 28 | 0] | n3[r4 + 29 | 0] << 8 | n3[r4 + 30 | 0] << 16 | n3[r4 + 31 | 0] << 24, i3[o4 + 24 >> 2] = n3[r4 + 24 | 0] | n3[r4 + 25 | 0] << 8 | n3[r4 + 26 | 0] << 16 | n3[r4 + 27 | 0] << 24, i3[o4 + 28 >> 2] = t4, t4 = n3[r4 + 20 | 0] | n3[r4 + 21 | 0] << 8 | n3[r4 + 22 | 0] << 16 | n3[r4 + 23 | 0] << 24, i3[o4 + 16 >> 2] = n3[r4 + 16 | 0] | n3[r4 + 17 | 0] << 8 | n3[r4 + 18 | 0] << 16 | n3[r4 + 19 | 0] << 24, i3[o4 + 20 >> 2] = t4, t4 = n3[r4 + 4 | 0] | n3[r4 + 5 | 0] << 8 | n3[r4 + 6 | 0] << 16 | n3[r4 + 7 | 0] << 24, i3[o4 >> 2] = n3[0 | r4] | n3[r4 + 1 | 0] << 8 | n3[r4 + 2 | 0] << 16 | n3[r4 + 3 | 0] << 24, i3[o4 + 4 >> 2] = t4, t4 = 8, e4 = n3[r4 + 12 | 0] | n3[r4 + 13 | 0] << 8 | n3[r4 + 14 | 0] << 16 | n3[r4 + 15 | 0] << 24, i3[o4 + 8 >> 2] = n3[r4 + 8 | 0] | n3[r4 + 9 | 0] << 8 | n3[r4 + 10 | 0] << 16 | n3[r4 + 11 | 0] << 24, i3[o4 + 12 >> 2] = e4, r4 = n3[C4 + 4 | 0] | n3[C4 + 5 | 0] << 8 | n3[C4 + 6 | 0] << 16 | n3[C4 + 7 | 0] << 24, i3[o4 + 96 >> 2] = n3[0 | C4] | n3[C4 + 1 | 0] << 8 | n3[C4 + 2 | 0] << 16 | n3[C4 + 3 | 0] << 24, i3[o4 + 100 >> 2] = r4; Q3[(o4 + 96 | 0) + t4 | 0] = E4, E4 = (255 & a4) << 24 | E4 >>> 8, a4 = a4 >>> 8 | 0, (0 | (t4 = t4 + 1 | 0)) != 16; )
                            ;
                          if (!B4 & g6 >>> 0 > 63 | B4)
                            for (; ; ) {
                              for (t4 = 0, d3(o4 + 32 | 0, o4 + 96 | 0, o4); Q3[A8 + t4 | 0] = n3[(o4 + 32 | 0) + t4 | 0] ^ n3[I7 + t4 | 0], r4 = 1, (0 | (t4 = t4 + 1 | 0)) != 64; )
                                ;
                              for (t4 = 8; C4 = n3[0 | (E4 = (o4 + 96 | 0) + t4 | 0)] + r4 | 0, Q3[0 | E4] = C4, r4 = C4 >>> 8 | 0, (0 | (t4 = t4 + 1 | 0)) != 16; )
                                ;
                              if (I7 = I7 - -64 | 0, A8 = A8 - -64 | 0, B4 = B4 - 1 | 0, !(!(B4 = (g6 = g6 + -64 | 0) >>> 0 < 4294967232 ? B4 + 1 | 0 : B4) & g6 >>> 0 > 63 | B4))
                                break;
                            }
                          if (g6 | B4)
                            for (t4 = 0, d3(o4 + 32 | 0, o4 + 96 | 0, o4); Q3[A8 + t4 | 0] = n3[(o4 + 32 | 0) + t4 | 0] ^ n3[I7 + t4 | 0], (0 | g6) != (0 | (t4 = t4 + 1 | 0)); )
                              ;
                          Dg(o4 + 32 | 0, 64), Dg(o4, 32);
                        }
                        return s3 = o4 + 112 | 0, 0;
                      }], mg.grow = function(A8) {
                        var I7 = this.length;
                        return this.length = this.length + A8, I7;
                      }, mg.set = function(A8, I7) {
                        this[A8] = I7;
                      }, mg.get = function(A8) {
                        return this[A8];
                      }, mg);
                      function Mg() {
                        return B3.byteLength / 65536 | 0;
                      }
                      return { f: function() {
                      }, g: function(A8, I7, g6, B4, C4, Q4, E4, i4, n4, a4, r4, o4) {
                        return 0 | PA(A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0, (A8 = 0) | (C4 |= 0), Q4 |= 0, E4 |= 0, A8 | (i4 |= 0), n4 |= 0, r4 |= 0, o4 |= 0);
                      }, h: function(A8, I7, g6, B4, C4, Q4, E4, n4, a4, r4, o4) {
                        return A8 |= 0, I7 |= 0, a4 |= 0, a4 = B4 |= 0, !(B4 = C4 |= 0) & (C4 = 0 | a4) >>> 0 < 4294967280 ? (PA(A8, A8 + C4 | 0, 0, g6 |= 0, C4, B4, Q4 |= 0, E4 |= 0, n4 |= 0, r4 |= 0, o4 |= 0), I7 && (B4 = (A8 = C4 + 16 | 0) >>> 0 < 16 ? B4 + 1 | 0 : B4, i3[I7 >> 2] = A8, i3[I7 + 4 >> 2] = B4)) : (xI(), t3()), 0;
                      }, i: function(A8, I7, g6, B4, C4, Q4, E4, i4, n4, a4, r4, o4) {
                        return 0 | HA(A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0, (A8 = 0) | (C4 |= 0), Q4 |= 0, E4 |= 0, A8 | (i4 |= 0), n4 |= 0, r4 |= 0, o4 |= 0);
                      }, j: function(A8, I7, g6, B4, C4, Q4, E4, n4, a4, r4, o4) {
                        return A8 |= 0, I7 |= 0, a4 |= 0, a4 = B4 |= 0, !(B4 = C4 |= 0) & (C4 = 0 | a4) >>> 0 < 4294967280 ? (HA(A8, A8 + C4 | 0, 0, g6 |= 0, C4, B4, Q4 |= 0, E4 |= 0, n4 |= 0, r4 |= 0, o4 |= 0), I7 && (B4 = (A8 = C4 + 16 | 0) >>> 0 < 16 ? B4 + 1 | 0 : B4, i3[I7 >> 2] = A8, i3[I7 + 4 >> 2] = B4)) : (xI(), t3()), 0;
                      }, k: function(A8, I7, g6, B4, C4, Q4, E4, i4, n4, a4, r4) {
                        return 0 | GA(A8 |= 0, g6 |= 0, (A8 = 0) | (B4 |= 0), C4 |= 0, Q4 |= 0, E4 |= 0, A8 | (i4 |= 0), n4 |= 0, a4 |= 0, r4 |= 0);
                      }, l: function(A8, I7, g6, B4, C4, Q4, E4, n4, a4, r4, o4) {
                        return I7 |= 0, g6 |= 0, B4 |= 0, C4 |= 0, n4 |= 0, n4 |= 0, g6 = -1, !(Q4 |= 0) & (C4 |= 0) >>> 0 >= 16 | Q4 && (g6 = GA(A8 |= 0, B4, C4 - 16 | 0, Q4 - (C4 >>> 0 < 16) | 0, (B4 + C4 | 0) - 16 | 0, E4 |= 0, n4, a4 |= 0, r4 |= 0, o4 |= 0)), I7 && (i3[I7 >> 2] = g6 ? 0 : C4 - 16 | 0, i3[I7 + 4 >> 2] = g6 ? 0 : Q4 - (C4 >>> 0 < 16) | 0), 0 | g6;
                      }, m: function(A8, I7, g6, B4, C4, Q4, E4, i4, n4, a4, r4) {
                        return 0 | lA(A8 |= 0, g6 |= 0, (A8 = 0) | (B4 |= 0), C4 |= 0, Q4 |= 0, E4 |= 0, A8 | (i4 |= 0), n4 |= 0, a4 |= 0, r4 |= 0);
                      }, n: function(A8, I7, g6, B4, C4, Q4, E4, n4, a4, r4, o4) {
                        return I7 |= 0, g6 |= 0, B4 |= 0, C4 |= 0, n4 |= 0, n4 |= 0, g6 = -1, !(Q4 |= 0) & (C4 |= 0) >>> 0 >= 16 | Q4 && (g6 = lA(A8 |= 0, B4, C4 - 16 | 0, Q4 - (C4 >>> 0 < 16) | 0, (B4 + C4 | 0) - 16 | 0, E4 |= 0, n4, a4 |= 0, r4 |= 0, o4 |= 0)), I7 && (i3[I7 >> 2] = g6 ? 0 : C4 - 16 | 0, i3[I7 + 4 >> 2] = g6 ? 0 : Q4 - (C4 >>> 0 < 16) | 0), 0 | g6;
                      }, o: pg, p: function() {
                        return 12;
                      }, q: Sg, r: _g, s: Fg, t: sg, u: pg, v: Gg, w: Sg, x: _g, y: Fg, z: sg, A: function(A8, I7, g6, B4, C4, Q4, E4, i4, n4, a4, r4, o4) {
                        return 0 | fA(A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0, (A8 = 0) | (C4 |= 0), Q4 |= 0, E4 |= 0, A8 | (i4 |= 0), n4 |= 0, r4 |= 0, o4 |= 0);
                      }, B: function(A8, I7, g6, B4, C4, Q4, E4, n4, a4, r4, o4) {
                        return A8 |= 0, I7 |= 0, a4 |= 0, a4 = B4 |= 0, !(B4 = C4 |= 0) & (C4 = 0 | a4) >>> 0 < 4294967280 ? (fA(A8, A8 + C4 | 0, 0, g6 |= 0, C4, B4, Q4 |= 0, E4 |= 0, n4 |= 0, r4 |= 0, o4 |= 0), I7 && (B4 = (A8 = C4 + 16 | 0) >>> 0 < 16 ? B4 + 1 | 0 : B4, i3[I7 >> 2] = A8, i3[I7 + 4 >> 2] = B4)) : (xI(), t3()), 0;
                      }, C: function(A8, I7, g6, B4, C4, Q4, E4, i4, n4, a4, r4) {
                        return 0 | rA(A8 |= 0, g6 |= 0, (A8 = 0) | (B4 |= 0), C4 |= 0, Q4 |= 0, E4 |= 0, A8 | (i4 |= 0), n4 |= 0, a4 |= 0, r4 |= 0);
                      }, D: function(A8, I7, g6, B4, C4, Q4, E4, n4, a4, r4, o4) {
                        return I7 |= 0, g6 |= 0, B4 |= 0, C4 |= 0, n4 |= 0, n4 |= 0, g6 = -1, !(Q4 |= 0) & (C4 |= 0) >>> 0 >= 16 | Q4 && (g6 = rA(A8 |= 0, B4, C4 - 16 | 0, Q4 - (C4 >>> 0 < 16) | 0, (B4 + C4 | 0) - 16 | 0, E4 |= 0, n4, a4 |= 0, r4 |= 0, o4 |= 0)), I7 && (i3[I7 >> 2] = g6 ? 0 : C4 - 16 | 0, i3[I7 + 4 >> 2] = g6 ? 0 : Q4 - (C4 >>> 0 < 16) | 0), 0 | g6;
                      }, E: pg, F: ug, G: Sg, H: _g, I: Fg, J: sg, K: pg, L: pg, M: function(A8, I7, g6, B4, C4) {
                        return 0 | q3(A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0, C4 |= 0);
                      }, N: function(A8, I7, g6, B4, C4) {
                        var Q4;
                        return A8 |= 0, s3 = Q4 = s3 - 32 | 0, q3(Q4, I7 |= 0, g6 |= 0, B4 |= 0, C4 |= 0), I7 = eg(A8, Q4), g6 = zA(Q4, A8, 32), s3 = Q4 + 32 | 0, g6 | ((0 | A8) == (0 | Q4) ? -1 : I7);
                      }, O: sg, P: pg, Q: pg, R: pg, S: pg, T: ug, U: _g, V: Fg, W: function(A8, I7, g6) {
                        A8 |= 0, I7 |= 0;
                        var B4, C4 = 0;
                        return s3 = B4 = s3 + -64 | 0, _I(B4, g6 |= 0, 32, 0), g6 = i3[B4 + 28 >> 2], C4 = i3[B4 + 24 >> 2], Q3[I7 + 24 | 0] = C4, Q3[I7 + 25 | 0] = C4 >>> 8, Q3[I7 + 26 | 0] = C4 >>> 16, Q3[I7 + 27 | 0] = C4 >>> 24, Q3[I7 + 28 | 0] = g6, Q3[I7 + 29 | 0] = g6 >>> 8, Q3[I7 + 30 | 0] = g6 >>> 16, Q3[I7 + 31 | 0] = g6 >>> 24, g6 = i3[B4 + 20 >> 2], C4 = i3[B4 + 16 >> 2], Q3[I7 + 16 | 0] = C4, Q3[I7 + 17 | 0] = C4 >>> 8, Q3[I7 + 18 | 0] = C4 >>> 16, Q3[I7 + 19 | 0] = C4 >>> 24, Q3[I7 + 20 | 0] = g6, Q3[I7 + 21 | 0] = g6 >>> 8, Q3[I7 + 22 | 0] = g6 >>> 16, Q3[I7 + 23 | 0] = g6 >>> 24, g6 = i3[B4 + 12 >> 2], C4 = i3[B4 + 8 >> 2], Q3[I7 + 8 | 0] = C4, Q3[I7 + 9 | 0] = C4 >>> 8, Q3[I7 + 10 | 0] = C4 >>> 16, Q3[I7 + 11 | 0] = C4 >>> 24, Q3[I7 + 12 | 0] = g6, Q3[I7 + 13 | 0] = g6 >>> 8, Q3[I7 + 14 | 0] = g6 >>> 16, Q3[I7 + 15 | 0] = g6 >>> 24, g6 = i3[B4 + 4 >> 2], C4 = i3[B4 >> 2], Q3[0 | I7] = C4, Q3[I7 + 1 | 0] = C4 >>> 8, Q3[I7 + 2 | 0] = C4 >>> 16, Q3[I7 + 3 | 0] = C4 >>> 24, Q3[I7 + 4 | 0] = g6, Q3[I7 + 5 | 0] = g6 >>> 8, Q3[I7 + 6 | 0] = g6 >>> 16, Q3[I7 + 7 | 0] = g6 >>> 24, Dg(B4, 64), A8 = Bg(A8, I7), s3 = B4 - -64 | 0, 0 | A8;
                      }, X: TI, Y: oI, Z: function(A8, I7, g6, B4, C4, Q4, E4) {
                        return 0 | zI(A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0, C4 |= 0, Q4 |= 0, E4 |= 0);
                      }, _: function(A8, I7, g6, B4, C4, Q4, E4, i4) {
                        return 0 | aI(A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0, C4 |= 0, Q4 |= 0, E4 |= 0, i4 |= 0);
                      }, $: function(A8, I7, g6, B4, C4, Q4) {
                        return A8 |= 0, I7 |= 0, C4 |= 0, Q4 |= 0, !(B4 |= 0) & (g6 |= 0) >>> 0 >= 4294967280 | B4 && (xI(), t3()), 0 | zI(A8 + 16 | 0, A8, I7, g6, B4, C4, Q4);
                      }, aa: function(A8, I7, g6, B4, C4, Q4, E4) {
                        return 0 | pI(A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0, C4 |= 0, Q4 |= 0, E4 |= 0);
                      }, ba: function(A8, I7, g6, B4, C4, Q4, E4) {
                        return 0 | jI(A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0, C4 |= 0, Q4 |= 0, E4 |= 0);
                      }, ca: function(A8, I7, g6, B4, C4, Q4, E4, i4) {
                        return 0 | rI(A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0, C4 |= 0, Q4 |= 0, E4 |= 0, i4 |= 0);
                      }, da: function(A8, I7, g6, B4, C4, Q4) {
                        return I7 |= 0, 0 | (!(B4 |= 0) & (g6 |= 0) >>> 0 >= 16 | B4 ? jI(A8 |= 0, I7 + 16 | 0, I7, g6 - 16 | 0, B4 - (g6 >>> 0 < 16) | 0, C4 |= 0, Q4 |= 0) : -1);
                      }, ea: function(A8, I7, g6, B4, C4, Q4, E4) {
                        return 0 | cI(A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0, C4 |= 0, Q4 |= 0, E4 |= 0);
                      }, fa: function(A8, I7, g6, B4, C4) {
                        A8 |= 0, I7 |= 0, C4 |= 0;
                        var E4, n4, a4 = 0, r4 = 0;
                        return n4 = g6 |= 0, g6 = B4 |= 0, s3 = E4 = s3 - 96 | 0, B4 = -1, TI(E4 + 32 | 0, E4) || (sI(a4 = E4 - -64 | 0, r4 = E4 + 32 | 0, C4), B4 = pI(A8 + 32 | 0, I7, n4, g6, a4, C4, E4), I7 = i3[E4 + 60 >> 2], g6 = i3[E4 + 56 >> 2], Q3[A8 + 24 | 0] = g6, Q3[A8 + 25 | 0] = g6 >>> 8, Q3[A8 + 26 | 0] = g6 >>> 16, Q3[A8 + 27 | 0] = g6 >>> 24, Q3[A8 + 28 | 0] = I7, Q3[A8 + 29 | 0] = I7 >>> 8, Q3[A8 + 30 | 0] = I7 >>> 16, Q3[A8 + 31 | 0] = I7 >>> 24, I7 = i3[E4 + 52 >> 2], g6 = i3[E4 + 48 >> 2], Q3[A8 + 16 | 0] = g6, Q3[A8 + 17 | 0] = g6 >>> 8, Q3[A8 + 18 | 0] = g6 >>> 16, Q3[A8 + 19 | 0] = g6 >>> 24, Q3[A8 + 20 | 0] = I7, Q3[A8 + 21 | 0] = I7 >>> 8, Q3[A8 + 22 | 0] = I7 >>> 16, Q3[A8 + 23 | 0] = I7 >>> 24, I7 = i3[E4 + 44 >> 2], g6 = i3[E4 + 40 >> 2], Q3[A8 + 8 | 0] = g6, Q3[A8 + 9 | 0] = g6 >>> 8, Q3[A8 + 10 | 0] = g6 >>> 16, Q3[A8 + 11 | 0] = g6 >>> 24, Q3[A8 + 12 | 0] = I7, Q3[A8 + 13 | 0] = I7 >>> 8, Q3[A8 + 14 | 0] = I7 >>> 16, Q3[A8 + 15 | 0] = I7 >>> 24, I7 = i3[E4 + 36 >> 2], g6 = i3[E4 + 32 >> 2], Q3[0 | A8] = g6, Q3[A8 + 1 | 0] = g6 >>> 8, Q3[A8 + 2 | 0] = g6 >>> 16, Q3[A8 + 3 | 0] = g6 >>> 24, Q3[A8 + 4 | 0] = I7, Q3[A8 + 5 | 0] = I7 >>> 8, Q3[A8 + 6 | 0] = I7 >>> 16, Q3[A8 + 7 | 0] = I7 >>> 24, Dg(E4, 32), Dg(r4, 32), Dg(a4, 24)), s3 = E4 + 96 | 0, 0 | B4;
                      }, ga: function(A8, I7, g6, B4, C4, Q4) {
                        A8 |= 0, I7 |= 0, Q4 |= 0;
                        var E4, i4 = 0;
                        return s3 = E4 = s3 - 32 | 0, i4 = -1, !(B4 |= 0) & (g6 |= 0) >>> 0 >= 48 | B4 && (sI(E4, I7, C4 |= 0), i4 = cI(A8, I7 + 32 | 0, g6 - 32 | 0, B4 - (g6 >>> 0 < 32) | 0, E4, I7, Q4)), s3 = E4 + 32 | 0, 0 | i4;
                      }, ha: function() {
                        return 48;
                      }, ia: _g, ja: lg, ka: pg, la: _g, ma: lg, na: pg, oa: function() {
                        return 384;
                      }, pa: function(A8, I7, g6, B4, C4, Q4, E4) {
                        return 0 | qI(A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0, C4 |= 0, Q4 |= 0, E4 |= 0);
                      }, qa: PI, ra: function(A8, I7, g6, B4) {
                        return 0 | ig(A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0);
                      }, sa: dI, ta: sg, ua: lg, va: function(A8, I7, g6, B4) {
                        return 0 | _I(A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0);
                      }, wa: _g, xa: lg, ya: Gg, za: pg, Aa: function(A8, I7, g6, B4, C4, a4) {
                        A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0, a4 |= 0;
                        var r4, o4 = 0, e4 = 0, f4 = 0, c4 = 0;
                        return s3 = r4 = s3 - 32 | 0, f4 = n3[0 | (C4 |= 0)] | n3[C4 + 1 | 0] << 8 | n3[C4 + 2 | 0] << 16 | n3[C4 + 3 | 0] << 24, C4 = n3[C4 + 4 | 0] | n3[C4 + 5 | 0] << 8 | n3[C4 + 6 | 0] << 16 | n3[C4 + 7 | 0] << 24, i3[r4 + 24 >> 2] = 0, i3[r4 + 28 >> 2] = 0, i3[r4 + 16 >> 2] = f4, i3[r4 + 20 >> 2] = C4, QI(r4, g6, B4), i3[r4 + 8 >> 2] = 0, i3[r4 + 12 >> 2] = 0, I7 - 65 >>> 0 <= 4294967246 ? (i3[8952] = 28, A8 = -1) : (g6 = r4 + 16 | 0, I7 - 65 >>> 0 < 4294967232 ? A8 = -1 : (s3 = c4 = (B4 = s3) - 384 & -64, !a4 | !A8 | ((C4 = 255 & I7) - 65 & 255) >>> 0 <= 191 ? (xI(), t3()) : (s3 = e4 = s3 - 192 | 0, !a4 | (C4 - 65 & 255) >>> 0 <= 191 ? (xI(), t3()) : (E3[e4 + 130 >> 1] = 257, Q3[e4 + 129 | 0] = 32, Q3[e4 + 128 | 0] = C4, RI(4 | (I7 = e4 + 128 | 0)), QI(8 | I7, 0, 0), i3[e4 + 152 >> 2] = 0, i3[e4 + 156 >> 2] = 0, i3[e4 + 144 >> 2] = 0, i3[e4 + 148 >> 2] = 0, r4 ? (f4 = n3[r4 + 4 | 0] | n3[r4 + 5 | 0] << 8 | n3[r4 + 6 | 0] << 16 | n3[r4 + 7 | 0] << 24, o4 = e4 + 128 | 0, I7 = n3[0 | r4] | n3[r4 + 1 | 0] << 8 | n3[r4 + 2 | 0] << 16 | n3[r4 + 3 | 0] << 24, Q3[o4 + 32 | 0] = I7, Q3[o4 + 33 | 0] = I7 >>> 8, Q3[o4 + 34 | 0] = I7 >>> 16, Q3[o4 + 35 | 0] = I7 >>> 24, Q3[o4 + 36 | 0] = f4, Q3[o4 + 37 | 0] = f4 >>> 8, Q3[o4 + 38 | 0] = f4 >>> 16, Q3[o4 + 39 | 0] = f4 >>> 24, f4 = n3[r4 + 12 | 0] | n3[r4 + 13 | 0] << 8 | n3[r4 + 14 | 0] << 16 | n3[r4 + 15 | 0] << 24, I7 = n3[r4 + 8 | 0] | n3[r4 + 9 | 0] << 8 | n3[r4 + 10 | 0] << 16 | n3[r4 + 11 | 0] << 24, Q3[o4 + 40 | 0] = I7, Q3[o4 + 41 | 0] = I7 >>> 8, Q3[o4 + 42 | 0] = I7 >>> 16, Q3[o4 + 43 | 0] = I7 >>> 24, Q3[o4 + 44 | 0] = f4, Q3[o4 + 45 | 0] = f4 >>> 8, Q3[o4 + 46 | 0] = f4 >>> 16, Q3[o4 + 47 | 0] = f4 >>> 24) : (i3[e4 + 168 >> 2] = 0, i3[e4 + 172 >> 2] = 0, i3[e4 + 160 >> 2] = 0, i3[e4 + 164 >> 2] = 0), g6 ? (f4 = n3[g6 + 4 | 0] | n3[g6 + 5 | 0] << 8 | n3[g6 + 6 | 0] << 16 | n3[g6 + 7 | 0] << 24, o4 = e4 + 128 | 0, I7 = n3[0 | g6] | n3[g6 + 1 | 0] << 8 | n3[g6 + 2 | 0] << 16 | n3[g6 + 3 | 0] << 24, Q3[o4 + 48 | 0] = I7, Q3[o4 + 49 | 0] = I7 >>> 8, Q3[o4 + 50 | 0] = I7 >>> 16, Q3[o4 + 51 | 0] = I7 >>> 24, Q3[o4 + 52 | 0] = f4, Q3[o4 + 53 | 0] = f4 >>> 8, Q3[o4 + 54 | 0] = f4 >>> 16, Q3[o4 + 55 | 0] = f4 >>> 24, f4 = n3[g6 + 12 | 0] | n3[g6 + 13 | 0] << 8 | n3[g6 + 14 | 0] << 16 | n3[g6 + 15 | 0] << 24, I7 = n3[g6 + 8 | 0] | n3[g6 + 9 | 0] << 8 | n3[g6 + 10 | 0] << 16 | n3[g6 + 11 | 0] << 24, Q3[o4 + 56 | 0] = I7, Q3[o4 + 57 | 0] = I7 >>> 8, Q3[o4 + 58 | 0] = I7 >>> 16, Q3[o4 + 59 | 0] = I7 >>> 24, Q3[o4 + 60 | 0] = f4, Q3[o4 + 61 | 0] = f4 >>> 8, Q3[o4 + 62 | 0] = f4 >>> 16, Q3[o4 + 63 | 0] = f4 >>> 24) : (i3[e4 + 184 >> 2] = 0, i3[e4 + 188 >> 2] = 0, i3[e4 + 176 >> 2] = 0, i3[e4 + 180 >> 2] = 0), wA(c4, e4 + 128 | 0), wI(e4 + 32 | 0, 0, 96), gA2(c4, I7 = eI(e4, a4, 32), 128, 0), Dg(I7, 128), s3 = I7 + 192 | 0), gA2(c4, 0, 0, 0), Y3(c4, A8, C4), s3 = B4), A8 = 0)), s3 = r4 + 32 | 0, 0 | A8;
                      }, Ba: sg, Ca: function(A8, I7, g6) {
                        return A8 |= 0, qI(I7 |= 0, 32, g6 |= 0, 32, 0, 0, 0), 0 | ZI(A8, I7);
                      }, Da: function(A8, I7) {
                        return A8 |= 0, EI(I7 |= 0, 32), 0 | ZI(A8, I7);
                      }, Ea: function(A8, I7, g6, B4, C4) {
                        I7 |= 0, g6 |= 0, B4 |= 0, C4 |= 0;
                        var E4, i4, a4 = 0, r4 = 0;
                        if (i4 = a4 = s3, s3 = a4 = a4 - 512 & -64, E4 = (A8 |= 0) || I7) {
                          if (r4 = -1, !JI(a4 + 96 | 0, B4, C4)) {
                            for (B4 = I7 || A8, A8 = 0, PI(I7 = a4 + 128 | 0, 0, 0, 64), ig(I7, r4 = a4 + 96 | 0, 32, 0), Dg(r4, 32), ig(I7, g6, 32, 0), ig(I7, C4, 32, 0), dI(I7, a4 + 32 | 0, 64), Dg(I7, 384); I7 = (a4 + 32 | 0) + A8 | 0, Q3[A8 + E4 | 0] = n3[0 | I7], Q3[A8 + B4 | 0] = n3[I7 + 32 | 0], (0 | (A8 = A8 + 1 | 0)) != 32; )
                              ;
                            Dg(a4 + 32 | 0, 64), r4 = 0;
                          }
                          return s3 = i4, 0 | r4;
                        }
                        xI(), t3();
                      }, Fa: function(A8, I7, g6, B4, C4) {
                        I7 |= 0, g6 |= 0, B4 |= 0, C4 |= 0;
                        var E4, i4, a4 = 0, r4 = 0;
                        if (i4 = a4 = s3, s3 = a4 = a4 - 512 & -64, E4 = (A8 |= 0) || I7) {
                          if (r4 = -1, !JI(a4 + 96 | 0, B4, C4)) {
                            for (B4 = I7 || A8, A8 = 0, PI(I7 = a4 + 128 | 0, 0, 0, 64), ig(I7, r4 = a4 + 96 | 0, 32, 0), Dg(r4, 32), ig(I7, C4, 32, 0), ig(I7, g6, 32, 0), dI(I7, a4 + 32 | 0, 64), Dg(I7, 384); I7 = (a4 + 32 | 0) + A8 | 0, Q3[A8 + B4 | 0] = n3[0 | I7], Q3[A8 + E4 | 0] = n3[I7 + 32 | 0], (0 | (A8 = A8 + 1 | 0)) != 32; )
                              ;
                            Dg(a4 + 32 | 0, 64), r4 = 0;
                          }
                          return s3 = i4, 0 | r4;
                        }
                        xI(), t3();
                      }, Ga: pg, Ha: pg, Ia: pg, Ja: pg, Ka: kg, La: Hg, Ma: Hg, Na: _g, Oa: bg, Pa: Sg, Qa: bg, Ra: _g, Sa: function() {
                        return 128;
                      }, Ta: function() {
                        return 1403;
                      }, Ua: kg, Va: bg, Wa: function() {
                        return 8192;
                      }, Xa: function() {
                        return -2147483648;
                      }, Ya: Hg, Za: function() {
                        return 67108864;
                      }, _a: Ug, $a: function() {
                        return 268435456;
                      }, ab: function() {
                        return 4;
                      }, bb: function() {
                        return 1073741824;
                      }, cb: function(A8, I7, g6, B4, C4, Q4, E4, n4, a4, r4, o4) {
                        var t4;
                        A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0, Q4 |= 0, E4 |= 0, a4 |= 0, r4 |= 0, I7 |= 0, t4 = 0 | (C4 |= 0), C4 = 0 | (n4 |= 0);
                        A: {
                          switch ((o4 |= 0) - 1 | 0) {
                            case 0:
                              A8 = wI(A8, 0, I7);
                              I: {
                                if ((0 | g6) == 1 | g6 >>> 0 > 1)
                                  i3[8952] = 22;
                                else if (!g6 & I7 >>> 0 <= 15)
                                  i3[8952] = 28;
                                else if (!(Q4 | a4) & r4 >>> 0 < 2147483649)
                                  if ((!a4 & C4 >>> 0 >= 3 | (0 | a4) != 0) & r4 >>> 0 > 8191) {
                                    if ((0 | A8) != (0 | B4)) {
                                      A8 = _3(C4, r4 >>> 10 | 0, 1, B4, t4, E4, 16, A8, I7, 0, 0, 1) ? -1 : 0;
                                      break I;
                                    }
                                    i3[8952] = 28;
                                  } else
                                    i3[8952] = 28;
                                else
                                  i3[8952] = 22;
                                A8 = -1;
                              }
                              break A;
                            case 1:
                              A8 = wI(A8, 0, I7);
                              I: {
                                if ((0 | g6) == 1 | g6 >>> 0 > 1)
                                  i3[8952] = 22;
                                else if (!g6 & I7 >>> 0 <= 15)
                                  i3[8952] = 28;
                                else if (!(Q4 | a4) & r4 >>> 0 < 2147483649)
                                  if (!!(C4 | a4) & r4 >>> 0 > 8191) {
                                    if ((0 | A8) != (0 | B4)) {
                                      A8 = _3(C4, r4 >>> 10 | 0, 1, B4, t4, E4, 16, A8, I7, 0, 0, 2) ? -1 : 0;
                                      break I;
                                    }
                                    i3[8952] = 28;
                                  } else
                                    i3[8952] = 28;
                                else
                                  i3[8952] = 22;
                                A8 = -1;
                              }
                              break A;
                          }
                          i3[8952] = 28, A8 = -1;
                        }
                        return 0 | A8;
                      }, db: function(A8, I7, g6, B4, C4, Q4, E4) {
                        return 0 | NA(A8 |= 0, I7 |= 0, (A8 = 0) | (g6 |= 0), B4 |= 0, A8 | (C4 |= 0), Q4 |= 0, E4 |= 0);
                      }, eb: function(A8, I7, g6, B4, C4, Q4, E4, n4) {
                        A8 |= 0, I7 |= 0, B4 |= 0, Q4 |= 0, E4 |= 0;
                        var a4 = 0;
                        a4 = g6 |= 0, a4 |= g6 = 0, g6 |= C4 |= 0;
                        A: {
                          switch ((n4 |= 0) - 1 | 0) {
                            case 1:
                              A8 = NA(A8, I7, a4, B4, g6, Q4, E4);
                              break A;
                            default:
                              xI(), t3();
                            case 0:
                          }
                          s3 = C4 = s3 - 16 | 0, A8 = wI(A8, 0, 128), !(B4 | Q4) & E4 >>> 0 < 2147483649 ? (!Q4 & g6 >>> 0 >= 3 | (0 | Q4) != 0) & E4 >>> 0 > 8191 ? (EI(C4, 16), A8 = _3(g6, E4 >>> 10 | 0, 1, I7, a4, C4, 16, 0, 32, A8, 128, 1) ? -1 : 0) : (i3[8952] = 28, A8 = -1) : (i3[8952] = 22, A8 = -1), s3 = C4 + 16 | 0;
                        }
                        return 0 | A8;
                      }, fb: function(A8, I7, g6, B4) {
                        I7 |= 0, g6 |= 0, B4 |= 0;
                        A:
                          if (LA(A8 |= 0, 1403, 10))
                            if (LA(A8, 1393, 9))
                              i3[8952] = 28, A8 = -1;
                            else {
                              if ((0 | B4) == 1 | B4 >>> 0 > 1)
                                i3[8952] = 22;
                              else {
                                if (!(A8 = tA(A8, I7, g6, 1)))
                                  break A;
                                (0 | A8) == -35 && (i3[8952] = 28);
                              }
                              A8 = -1;
                            }
                          else {
                            if ((0 | B4) == 1 | B4 >>> 0 > 1)
                              i3[8952] = 22;
                            else {
                              if (!(A8 = tA(A8, I7, g6, 2)))
                                break A;
                              (0 | A8) == -35 && (i3[8952] = 28);
                            }
                            A8 = -1;
                          }
                        return 0 | A8;
                      }, gb: function(A8, I7, g6, B4) {
                        return I7 |= 0, g6 |= 0, B4 |= 0, LA(A8 |= 0, 1403, 10) ? LA(A8, 1393, 9) ? (i3[8952] = 28, A8 = -1) : A8 = eA(A8, I7, g6, B4, 1) : A8 = eA(A8, I7, g6, B4, 2), 0 | A8;
                      }, hb: ZI, ib: JI, jb: pg, kb: pg, lb: pg, mb: ug, nb: _g, ob: Fg, pb: sg, qb: zI, rb: function(A8, I7, g6, B4, C4, Q4) {
                        return A8 |= 0, I7 |= 0, C4 |= 0, Q4 |= 0, !(B4 |= 0) & (g6 |= 0) >>> 0 >= 4294967280 | B4 && (xI(), t3()), EA(A8 + 16 | 0, A8, I7, g6, B4, C4, Q4), 0;
                      }, sb: jI, tb: function(A8, I7, g6, B4, C4, Q4) {
                        return I7 |= 0, 0 | (!(B4 |= 0) & (g6 |= 0) >>> 0 >= 16 | B4 ? iA(A8 |= 0, I7 + 16 | 0, I7, g6 - 16 | 0, B4 - (g6 >>> 0 < 16) | 0, C4 |= 0, Q4 |= 0) : -1);
                      }, ub: sg, vb: function(A8, I7, g6) {
                        return A8 |= 0, g6 |= 0, EI(I7 |= 0, 24), x3(A8, I7, g6), YI(A8), g6 = n3[I7 + 16 | 0] | n3[I7 + 17 | 0] << 8 | n3[I7 + 18 | 0] << 16 | n3[I7 + 19 | 0] << 24, I7 = n3[I7 + 20 | 0] | n3[I7 + 21 | 0] << 8 | n3[I7 + 22 | 0] << 16 | n3[I7 + 23 | 0] << 24, Q3[A8 + 44 | 0] = 0, Q3[A8 + 45 | 0] = 0, Q3[A8 + 46 | 0] = 0, Q3[A8 + 47 | 0] = 0, Q3[A8 + 48 | 0] = 0, Q3[A8 + 49 | 0] = 0, Q3[A8 + 50 | 0] = 0, Q3[A8 + 51 | 0] = 0, Q3[A8 + 36 | 0] = g6, Q3[A8 + 37 | 0] = g6 >>> 8, Q3[A8 + 38 | 0] = g6 >>> 16, Q3[A8 + 39 | 0] = g6 >>> 24, Q3[A8 + 40 | 0] = I7, Q3[A8 + 41 | 0] = I7 >>> 8, Q3[A8 + 42 | 0] = I7 >>> 16, Q3[A8 + 43 | 0] = I7 >>> 24, 0;
                      }, wb: function(A8, I7, g6) {
                        return x3(A8 |= 0, I7 |= 0, g6 |= 0), YI(A8), g6 = n3[I7 + 16 | 0] | n3[I7 + 17 | 0] << 8 | n3[I7 + 18 | 0] << 16 | n3[I7 + 19 | 0] << 24, I7 = n3[I7 + 20 | 0] | n3[I7 + 21 | 0] << 8 | n3[I7 + 22 | 0] << 16 | n3[I7 + 23 | 0] << 24, Q3[A8 + 44 | 0] = 0, Q3[A8 + 45 | 0] = 0, Q3[A8 + 46 | 0] = 0, Q3[A8 + 47 | 0] = 0, Q3[A8 + 48 | 0] = 0, Q3[A8 + 49 | 0] = 0, Q3[A8 + 50 | 0] = 0, Q3[A8 + 51 | 0] = 0, Q3[A8 + 36 | 0] = g6, Q3[A8 + 37 | 0] = g6 >>> 8, Q3[A8 + 38 | 0] = g6 >>> 16, Q3[A8 + 39 | 0] = g6 >>> 24, Q3[A8 + 40 | 0] = I7, Q3[A8 + 41 | 0] = I7 >>> 8, Q3[A8 + 42 | 0] = I7 >>> 16, Q3[A8 + 43 | 0] = I7 >>> 24, 0;
                      }, xb: X3, yb: function(A8, I7, g6, B4, C4, E4, a4, r4, o4, e4) {
                        A8 |= 0, I7 |= 0, B4 |= 0, a4 |= 0, r4 |= 0, o4 |= 0, e4 |= 0;
                        var f4 = 0, c4 = 0, y4 = 0, w4 = 0;
                        return c4 = C4 |= 0, C4 = E4 |= 0, E4 = 0 | c4, r4 |= f4, s3 = c4 = s3 - 336 | 0, (g6 |= 0) && (i3[g6 >> 2] = 0, i3[g6 + 4 >> 2] = 0), !C4 & E4 >>> 0 < 4294967279 ? (fg(y4 = c4 + 16 | 0, 64, w4 = A8 + 32 | 0, A8), og(f4 = c4 + 80 | 0, y4), Dg(y4, 64), gg(f4, a4, r4, o4), gg(f4, 34048, 0 - r4 & 15, 0), wI(y4, 0, 64), Q3[c4 + 16 | 0] = e4, WA(y4, y4, 64, 0, w4, 1, A8), gg(f4, y4, 64, 0), Q3[0 | I7] = n3[c4 + 16 | 0], WA(a4 = I7 + 1 | 0, B4, E4, C4, w4, 2, A8), gg(f4, a4, E4, C4), gg(f4, 34048, 15 & E4, 0), QI(I7 = c4 + 8 | 0, r4, o4), gg(f4, I7, 8, 0), QI(I7, E4 - -64 | 0, C4 - ((E4 >>> 0 < 4294967232) - 1 | 0) | 0), gg(f4, I7, 8, 0), tg(f4, I7 = E4 + a4 | 0), Dg(f4, 256), yI(A8 + 36 | 0, I7), nI(w4), (2 & e4 || BI(w4, 4)) && X3(A8), g6 && (C4 = (A8 = E4 + 17 | 0) >>> 0 < 17 ? C4 + 1 | 0 : C4, i3[g6 >> 2] = A8, i3[g6 + 4 >> 2] = C4), s3 = c4 + 336 | 0) : (xI(), t3()), 0;
                      }, zb: function(A8, I7, g6, B4, C4, E4, a4, r4, o4, e4) {
                        A8 |= 0, I7 |= 0, B4 |= 0, C4 |= 0, E4 |= 0, a4 |= 0, r4 |= 0, e4 |= 0;
                        var f4, c4 = 0, y4 = 0, w4 = 0, D4 = 0, h4 = 0, p4 = 0;
                        E4 |= 0, f4 = (o4 |= 0) | c4, s3 = c4 = s3 - 352 | 0, (g6 |= 0) && (i3[g6 >> 2] = 0, i3[g6 + 4 >> 2] = 0), B4 && (Q3[0 | B4] = 255), p4 = -1;
                        A: {
                          I: {
                            if (!(!a4 & E4 >>> 0 < 17)) {
                              if (!(o4 = a4 - (E4 >>> 0 < 17) | 0) & (D4 = E4 - 17 | 0) >>> 0 >= 4294967279 | o4)
                                break I;
                              fg(y4 = c4 + 32 | 0, 64, h4 = A8 + 32 | 0, A8), og(w4 = c4 + 96 | 0, y4), Dg(y4, 64), gg(w4, r4, f4, e4), gg(w4, 34048, 0 - f4 & 15, 0), wI(y4, 0, 64), Q3[c4 + 32 | 0] = n3[0 | C4], WA(y4, y4, 64, 0, h4, 1, A8), r4 = n3[c4 + 32 | 0], Q3[c4 + 32 | 0] = n3[0 | C4], gg(w4, y4, 64, 0), gg(w4, y4 = C4 + 1 | 0, D4, o4), gg(w4, 34048, E4 - 1 & 15, 0), QI(C4 = c4 + 24 | 0, f4, e4), gg(w4, C4, 8, 0), QI(C4, E4 = E4 + 47 | 0, a4 = E4 >>> 0 < 47 ? a4 + 1 | 0 : a4), gg(w4, C4, 8, 0), tg(w4, c4), Dg(w4, 256), zA(c4, y4 + D4 | 0, 16) ? Dg(c4, 16) : (WA(I7, y4, D4, o4, h4, 2, A8), yI(A8 + 36 | 0, c4), nI(h4), (2 & r4 || BI(h4, 4)) && X3(A8), g6 && (i3[g6 >> 2] = D4, i3[g6 + 4 >> 2] = o4), p4 = 0, B4 && (Q3[0 | B4] = r4));
                            }
                            s3 = c4 + 352 | 0;
                            break A;
                          }
                          xI(), t3();
                        }
                        return 0 | p4;
                      }, Ab: function() {
                        return 52;
                      }, Bb: function() {
                        return 17;
                      }, Cb: ug, Db: pg, Eb: function() {
                        return -18;
                      }, Fb: Sg, Gb: kg, Hb: Hg, Ib: Ug, Jb: Gg, Kb: _g, Lb: function(A8, I7, g6, B4, C4) {
                        A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0;
                        var Q4 = 0, E4 = 0, i4 = 0, a4 = 0, r4 = 0, o4 = 0, t4 = 0, e4 = 0, f4 = 0, c4 = 0, y4 = 0, s4 = 0, w4 = 0, D4 = 0, p4 = 0, u4 = 0;
                        if (E4 = C4 |= 0, C4 = n3[C4 + 4 | 0] | n3[C4 + 5 | 0] << 8 | n3[C4 + 6 | 0] << 16 | n3[C4 + 7 | 0] << 24, o4 = 1886610805 ^ (Q4 = n3[0 | E4] | n3[E4 + 1 | 0] << 8 | n3[E4 + 2 | 0] << 16 | n3[E4 + 3 | 0] << 24), r4 = 1936682341 ^ C4, Q4 ^= 1852142177, t4 = 1819895653 ^ C4, C4 = 1852075885 ^ (i4 = n3[E4 + 8 | 0] | n3[E4 + 9 | 0] << 8 | n3[E4 + 10 | 0] << 16 | n3[E4 + 11 | 0] << 24), a4 = 1685025377 ^ (E4 = n3[E4 + 12 | 0] | n3[E4 + 13 | 0] << 8 | n3[E4 + 14 | 0] << 16 | n3[E4 + 15 | 0] << 24), e4 = 2037671283 ^ i4, f4 = 1952801890 ^ E4, E4 = g6, (0 | (i4 = (I7 + g6 | 0) - (c4 = 7 & g6) | 0)) != (0 | I7)) {
                          for (; y4 = n3[0 | I7] | n3[I7 + 1 | 0] << 8 | n3[I7 + 2 | 0] << 16 | n3[I7 + 3 | 0] << 24, u4 = n3[I7 + 4 | 0] | n3[I7 + 5 | 0] << 8 | n3[I7 + 6 | 0] << 16 | n3[I7 + 7 | 0] << 24, w4 = uA(C4, a4, 13), B4 = h3, g6 = a4 + r4 | 0, a4 = g6 = (o4 = C4 + o4 | 0) >>> 0 < C4 >>> 0 ? g6 + 1 | 0 : g6, o4 = uA(r4 = o4, g6, 32), D4 = h3, e4 = uA(C4 = e4 ^ y4, g6 = f4 ^ u4, 16), g6 = g6 + t4 | 0, g6 = (C4 = C4 + Q4 | 0) >>> 0 < Q4 >>> 0 ? g6 + 1 | 0 : g6, Q4 = C4, e4 = uA(C4 ^= e4, t4 = g6 ^ (f4 = h3), 21), f4 = h3, w4 = uA(r4 ^= w4, B4 = a4 ^= B4, 17), p4 = h3, g6 = g6 + B4 | 0, Q4 = uA(a4 = Q4 + r4 | 0, g6 = a4 >>> 0 < Q4 >>> 0 ? g6 + 1 | 0 : g6, 32), B4 = h3, w4 = uA(r4 = a4 ^ w4, g6 ^= p4, 13), p4 = h3, a4 = g6, s4 = r4, g6 = t4 + D4 | 0, t4 = r4 = C4 + o4 | 0, C4 = g6 = r4 >>> 0 < C4 >>> 0 ? g6 + 1 | 0 : g6, g6 = g6 + a4 | 0, o4 = r4 = s4 + r4 | 0, a4 = g6 = r4 >>> 0 < t4 >>> 0 ? g6 + 1 | 0 : g6, g6 = uA(r4, g6, 32), D4 = h3, r4 = C4 ^= f4, C4 = uA(t4 ^= e4, C4, 16), e4 = h3, f4 = g6, s4 = C4, g6 = B4 + r4 | 0, Q4 = g6 = (C4 = Q4 + t4 | 0) >>> 0 < Q4 >>> 0 ? g6 + 1 | 0 : g6, g6 = (e4 ^= g6) + D4 | 0, B4 = r4 = f4 + (t4 = s4 ^ C4) | 0, e4 = uA(t4, e4, 21) ^ B4, f4 = (r4 = B4 >>> 0 < t4 >>> 0 ? g6 + 1 | 0 : g6) ^ h3, g6 = a4 ^ p4, o4 = uA(a4 = o4 ^ w4, g6, 17), g6 = g6 + Q4 | 0, g6 = (a4 = C4 + a4 | 0) >>> 0 < C4 >>> 0 ? g6 + 1 | 0 : g6, C4 = (Q4 = a4) ^ o4, a4 = g6 ^ (t4 = h3), o4 = B4 ^ y4, r4 ^= u4, Q4 = uA(Q4, g6, 32), t4 = h3, (0 | i4) != (0 | (I7 = I7 + 8 | 0)); )
                            ;
                          I7 = i4;
                        }
                        switch (g6 = E4 << 24, E4 = 0, B4 = g6, c4 - 1 | 0) {
                          case 6:
                            B4 |= n3[I7 + 6 | 0] << 16;
                          case 5:
                            B4 |= n3[I7 + 5 | 0] << 8;
                          case 4:
                            B4 |= n3[I7 + 4 | 0];
                          case 3:
                            E4 |= (i4 = n3[I7 + 3 | 0]) << 24, B4 |= g6 = i4 >>> 8 | 0;
                          case 2:
                            E4 |= (i4 = n3[I7 + 2 | 0]) << 16, B4 |= g6 = i4 >>> 16 | 0;
                          case 1:
                            E4 |= (i4 = n3[I7 + 1 | 0]) << 8, B4 |= g6 = i4 >>> 24 | 0;
                          case 0:
                            E4 = n3[0 | I7] | E4;
                        }
                        return c4 = uA(C4, a4, 13), y4 = h3, g6 = a4 + r4 | 0, i4 = I7 = C4 + o4 | 0, C4 = g6 = I7 >>> 0 < C4 >>> 0 ? g6 + 1 | 0 : g6, a4 = uA(I7, g6, 32), r4 = h3, f4 = I7 = uA(o4 = E4 ^ e4, g6 = I7 = B4 ^ f4, 16), g6 = g6 + t4 | 0, g6 = (I7 = Q4 + o4 | 0) >>> 0 < Q4 >>> 0 ? g6 + 1 | 0 : g6, Q4 = I7, t4 = uA(I7 ^= f4, o4 = g6 ^ (e4 = h3), 21), e4 = h3, c4 = uA(i4 ^= c4, C4 ^= y4, 17), y4 = h3, g6 = g6 + C4 | 0, g6 = (C4 = Q4 + i4 | 0) >>> 0 < Q4 >>> 0 ? g6 + 1 | 0 : g6, Q4 = C4, C4 = uA(C4, g6, 32), f4 = h3, c4 = uA(i4 = Q4 ^ c4, g6 ^= y4, 13), y4 = h3, Q4 = g6, s4 = i4, g6 = r4 + o4 | 0, a4 = i4 = I7 + a4 | 0, I7 = g6 = i4 >>> 0 < I7 >>> 0 ? g6 + 1 | 0 : g6, g6 = g6 + Q4 | 0, Q4 = g6 = (i4 = s4 + i4 | 0) >>> 0 < a4 >>> 0 ? g6 + 1 | 0 : g6, r4 = uA(i4, g6, 32), o4 = h3, e4 = I7 = uA(a4 ^= t4, g6 = I7 ^= e4, 16), g6 = g6 + f4 | 0, g6 = (I7 = C4 + a4 | 0) >>> 0 < C4 >>> 0 ? g6 + 1 | 0 : g6, C4 = I7, t4 = uA(I7 ^= e4, a4 = g6 ^ (t4 = h3), 21), e4 = h3, c4 = uA(i4 ^= c4, Q4 ^= y4, 17), y4 = h3, g6 = g6 + Q4 | 0, g6 = (Q4 = C4 + i4 | 0) >>> 0 < C4 >>> 0 ? g6 + 1 | 0 : g6, i4 = uA(C4 = Q4, g6, 32), f4 = h3, c4 = uA(Q4 = C4 ^ c4, g6 ^= y4, 13), y4 = h3, C4 = g6, s4 = Q4, g6 = a4 + o4 | 0, g6 = (Q4 = I7 + r4 | 0) >>> 0 < I7 >>> 0 ? g6 + 1 | 0 : g6, I7 = E4, E4 = Q4, a4 = I7 ^ Q4, I7 = g6, g6 = (g6 ^ B4) + C4 | 0, B4 = g6 = (Q4 = s4 + a4 | 0) >>> 0 < a4 >>> 0 ? g6 + 1 | 0 : g6, a4 = uA(Q4, g6, 32), r4 = h3, g6 = I7 ^ e4, C4 = uA(I7 = E4 ^ t4, g6, 16), E4 = h3, o4 = C4, g6 = g6 + f4 | 0, g6 = (C4 = I7 + (255 ^ i4) | 0) >>> 0 < I7 >>> 0 ? g6 + 1 | 0 : g6, i4 = uA(I7 = o4 ^ C4, E4 ^= g6, 21), o4 = h3, e4 = uA(Q4 ^= c4, B4 ^= y4, 17), f4 = h3, g6 = g6 + B4 | 0, g6 = (B4 = C4 + Q4 | 0) >>> 0 < C4 >>> 0 ? g6 + 1 | 0 : g6, B4 = uA(C4 = B4, g6, 32), t4 = h3, e4 = uA(Q4 = C4 ^ e4, g6 ^= f4, 13), f4 = h3, C4 = g6, s4 = Q4, g6 = E4 + r4 | 0, E4 = Q4 = I7 + a4 | 0, I7 = g6 = Q4 >>> 0 < I7 >>> 0 ? g6 + 1 | 0 : g6, g6 = g6 + C4 | 0, C4 = g6 = (Q4 = s4 + Q4 | 0) >>> 0 < E4 >>> 0 ? g6 + 1 | 0 : g6, a4 = uA(Q4, g6, 32), r4 = h3, o4 = I7 = uA(E4 ^= i4, g6 = I7 ^= o4, 16), g6 = g6 + t4 | 0, g6 = (I7 = B4 + E4 | 0) >>> 0 < B4 >>> 0 ? g6 + 1 | 0 : g6, B4 = I7, i4 = uA(I7 ^= o4, E4 = g6 ^ (i4 = h3), 21), o4 = h3, e4 = uA(Q4 ^= e4, C4 ^= f4, 17), f4 = h3, g6 = g6 + C4 | 0, B4 = uA(C4 = B4 + Q4 | 0, g6 = C4 >>> 0 < B4 >>> 0 ? g6 + 1 | 0 : g6, 32), t4 = h3, e4 = uA(Q4 = C4 ^ e4, g6 ^= f4, 13), f4 = h3, C4 = g6, s4 = Q4, g6 = E4 + r4 | 0, a4 = Q4 = I7 + a4 | 0, E4 = Q4, I7 = g6 = Q4 >>> 0 < I7 >>> 0 ? g6 + 1 | 0 : g6, g6 = g6 + C4 | 0, g6 = (Q4 = s4 + Q4 | 0) >>> 0 < E4 >>> 0 ? g6 + 1 | 0 : g6, E4 = Q4, C4 = g6, r4 = uA(Q4, g6, 32), c4 = h3, a4 = I7 = uA(Q4 = i4 ^ a4, g6 = I7 ^= o4, 16), g6 = g6 + t4 | 0, g6 = (I7 = B4 + Q4 | 0) >>> 0 < B4 >>> 0 ? g6 + 1 | 0 : g6, B4 = I7, I7 ^= a4, a4 = Q4 = g6 ^ (i4 = h3), i4 = uA(I7, Q4, 21), Q4 = h3, t4 = uA(E4 ^= e4, C4 ^= f4, 17), e4 = h3, g6 = g6 + C4 | 0, B4 = uA(C4 = B4 + E4 | 0, g6 = C4 >>> 0 < B4 >>> 0 ? g6 + 1 | 0 : g6, 32), o4 = h3, e4 = g6 ^= e4, t4 = uA(C4 ^= t4, g6, 13), E4 = h3, f4 = i4, g6 = a4 + c4 | 0, a4 = i4 = I7 + r4 | 0, I7 = g6 = i4 >>> 0 < I7 >>> 0 ? g6 + 1 | 0 : g6, f4 = Q4 = uA(i4 ^= f4, g6 ^= Q4, 16), g6 = g6 + o4 | 0, g6 = (Q4 = B4 + i4 | 0) >>> 0 < B4 >>> 0 ? g6 + 1 | 0 : g6, B4 = Q4, Q4 = g6, g6 = uA(f4 ^ B4, g6 ^ (r4 = h3), 21), r4 = h3, o4 = g6, g6 = I7 + e4 | 0, g6 = Q4 + (E4 ^= g6 = (i4 = C4 + a4 | 0) >>> 0 < C4 >>> 0 ? g6 + 1 | 0 : g6) | 0, g6 = (I7 = B4 + (C4 = i4 ^ t4) | 0) >>> 0 < B4 >>> 0 ? g6 + 1 | 0 : g6, B4 = o4 ^ I7 ^ uA(C4, E4, 17), C4 = h3 ^ g6 ^ r4, QI(A8, uA(I7, g6, 32) ^ B4, h3 ^ C4), 0;
                      }, Mb: function(A8) {
                        EI(A8 |= 0, 16);
                      }, Nb: function() {
                        return 208;
                      }, Ob: lg, Pb: pg, Qb: pg, Rb: lg, Sb: function() {
                        return -65;
                      }, Tb: function(A8, I7, g6) {
                        return 0 | P3(A8 |= 0, I7 |= 0, g6 |= 0);
                      }, Ub: function(A8, I7) {
                        var g6;
                        return A8 |= 0, I7 |= 0, s3 = g6 = s3 - 32 | 0, EI(g6, 32), P3(A8, I7, g6), Dg(g6, 32), s3 = g6 + 32 | 0, 0;
                      }, Vb: function(A8, I7, g6, B4, C4, Q4) {
                        var E4;
                        return I7 |= 0, C4 |= 0, Q4 |= 0, s3 = E4 = s3 - 16 | 0, VI(A8 |= 0, E4 + 8 | 0, gI(A8 - -64 | 0, g6 |= 0, g6 = B4 |= 0), g6, C4, Q4), i3[E4 + 8 >> 2] != 64 | i3[E4 + 12 >> 2] ? (I7 && (i3[I7 >> 2] = 0, i3[I7 + 4 >> 2] = 0), wI(A8, 0, g6 - -64 | 0), A8 = -1) : (A8 = 0, I7 && (i3[I7 >> 2] = g6 - -64, i3[I7 + 4 >> 2] = C4 - ((g6 >>> 0 < 4294967232) - 1 | 0))), s3 = E4 + 16 | 0, 0 | A8;
                      }, Wb: function(A8, I7, g6, B4, C4, Q4) {
                        A8 |= 0, I7 |= 0, g6 |= 0;
                        var E4 = 0;
                        A: {
                          I: {
                            if (E4 = B4 |= 0, !(!(C4 |= 0) & B4 >>> 0 < 64 || (B4 = C4 - 1 | 0, E4 = C4 = E4 + -64 | 0, !(B4 = C4 >>> 0 < 4294967232 ? B4 + 1 | 0 : B4) & C4 >>> 0 > 4294967231 | B4))) {
                              if (!OI(g6, C4 = g6 - -64 | 0, E4, B4, Q4 |= 0))
                                break I;
                              A8 && wI(A8, 0, E4);
                            }
                            if (g6 = -1, !I7)
                              break A;
                            i3[I7 >> 2] = 0, i3[I7 + 4 >> 2] = 0;
                            break A;
                          }
                          I7 && (i3[I7 >> 2] = E4, i3[I7 + 4 >> 2] = B4), g6 = 0, A8 && gI(A8, C4, E4);
                        }
                        return 0 | g6;
                      }, Xb: function(A8, I7, g6, B4, C4, Q4) {
                        return 0 | VI(A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0, C4 |= 0, Q4 |= 0);
                      }, Yb: function(A8, I7, g6, B4, C4) {
                        return 0 | OI(A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0, C4 |= 0);
                      }, Zb: function(A8) {
                        return GI(A8 |= 0), 0;
                      }, _b: function(A8, I7, g6, B4) {
                        return 0 | z3(A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0);
                      }, $b: function(A8, I7, g6, B4) {
                        var C4;
                        return I7 |= 0, g6 |= 0, B4 |= 0, s3 = C4 = s3 + -64 | 0, MA(A8 |= 0, C4), A8 = u3(I7, g6, C4, 64, 0, B4, 1), s3 = C4 - -64 | 0, 0 | A8;
                      }, ac: function(A8, I7, g6) {
                        var B4;
                        return I7 |= 0, g6 |= 0, s3 = B4 = s3 + -64 | 0, MA(A8 |= 0, B4), A8 = J3(I7, B4, 64, 0, g6, 1), s3 = B4 - -64 | 0, 0 | A8;
                      }, bc: function(A8, I7) {
                        A8 |= 0;
                        var g6, B4 = 0, C4 = 0, E4 = 0, i4 = 0, n4 = 0, a4 = 0;
                        if (s3 = g6 = s3 - 256 | 0, a4 = -1, !sA(I7 |= 0) && !V3(g6 + 96 | 0, I7)) {
                          for (s3 = B4 = (s3 = i4 = s3 - 160 | 0) - 1760 | 0, DI(E4 = B4 + 480 | 0, C4 = g6 + 96 | 0), fI(I7 = B4 + 320 | 0, C4), tI(B4, I7), xA(I7, B4, E4), tI(E4 = B4 + 160 | 0, I7), DI(C4 = B4 + 640 | 0, E4), xA(I7, B4, C4), tI(E4, I7), DI(C4 = B4 + 800 | 0, E4), xA(I7, B4, C4), tI(E4, I7), DI(C4 = B4 + 960 | 0, E4), xA(I7, B4, C4), tI(E4, I7), DI(C4 = B4 + 1120 | 0, E4), xA(I7, B4, C4), tI(E4, I7), DI(C4 = B4 + 1280 | 0, E4), xA(I7, B4, C4), tI(E4, I7), DI(C4 = B4 + 1440 | 0, E4), xA(I7, B4, C4), tI(E4, I7), DI(B4 + 1600 | 0, E4), LI(i4), I7 = 252; fI(B4 + 320 | 0, i4), E4 = I7, (0 | (I7 = Q3[I7 + 33504 | 0])) > 0 ? (tI(C4 = B4 + 160 | 0, n4 = B4 + 320 | 0), xA(n4, C4, (B4 + 480 | 0) + r3((254 & I7) >>> 1 | 0, 160) | 0)) : (0 | I7) >= 0 || (tI(C4 = B4 + 160 | 0, n4 = B4 + 320 | 0), JA(n4, C4, (B4 + 480 | 0) + r3((0 - I7 & 254) >>> 1 | 0, 160) | 0)), tI(i4, B4 + 320 | 0), I7 = E4 - 1 | 0, E4; )
                            ;
                          s3 = B4 + 1760 | 0, I7 = mI(i4), s3 = i4 + 160 | 0, I7 && (ng(g6), cA(g6, g6, E4 = g6 + 136 | 0), ng(I7 = g6 + 48 | 0), yA(I7, I7, E4), O3(g6, g6), H3(I7, I7, g6), T3(A8, I7), a4 = 0);
                        }
                        return s3 = g6 + 256 | 0, 0 | a4;
                      }, cc: function(A8, I7) {
                        A8 |= 0;
                        var g6, B4 = 0;
                        return s3 = g6 = s3 + -64 | 0, _I(g6, I7 |= 0, 32, 0), Q3[0 | g6] = 248 & n3[0 | g6], Q3[g6 + 31 | 0] = 63 & n3[g6 + 31 | 0] | 64, I7 = i3[g6 + 20 >> 2], B4 = i3[g6 + 16 >> 2], Q3[A8 + 16 | 0] = B4, Q3[A8 + 17 | 0] = B4 >>> 8, Q3[A8 + 18 | 0] = B4 >>> 16, Q3[A8 + 19 | 0] = B4 >>> 24, Q3[A8 + 20 | 0] = I7, Q3[A8 + 21 | 0] = I7 >>> 8, Q3[A8 + 22 | 0] = I7 >>> 16, Q3[A8 + 23 | 0] = I7 >>> 24, I7 = i3[g6 + 12 >> 2], B4 = i3[g6 + 8 >> 2], Q3[A8 + 8 | 0] = B4, Q3[A8 + 9 | 0] = B4 >>> 8, Q3[A8 + 10 | 0] = B4 >>> 16, Q3[A8 + 11 | 0] = B4 >>> 24, Q3[A8 + 12 | 0] = I7, Q3[A8 + 13 | 0] = I7 >>> 8, Q3[A8 + 14 | 0] = I7 >>> 16, Q3[A8 + 15 | 0] = I7 >>> 24, I7 = i3[g6 + 4 >> 2], B4 = i3[g6 >> 2], Q3[0 | A8] = B4, Q3[A8 + 1 | 0] = B4 >>> 8, Q3[A8 + 2 | 0] = B4 >>> 16, Q3[A8 + 3 | 0] = B4 >>> 24, Q3[A8 + 4 | 0] = I7, Q3[A8 + 5 | 0] = I7 >>> 8, Q3[A8 + 6 | 0] = I7 >>> 16, Q3[A8 + 7 | 0] = I7 >>> 24, I7 = i3[g6 + 28 >> 2], B4 = i3[g6 + 24 >> 2], Q3[A8 + 24 | 0] = B4, Q3[A8 + 25 | 0] = B4 >>> 8, Q3[A8 + 26 | 0] = B4 >>> 16, Q3[A8 + 27 | 0] = B4 >>> 24, Q3[A8 + 28 | 0] = I7, Q3[A8 + 29 | 0] = I7 >>> 8, Q3[A8 + 30 | 0] = I7 >>> 16, Q3[A8 + 31 | 0] = I7 >>> 24, Dg(g6, 64), s3 = g6 - -64 | 0, 0;
                      }, dc: FI, ec: SI, fc: function(A8) {
                        var I7 = 0, g6 = 0;
                        if ((A8 |= 0) >>> 0 >= 2) {
                          for (g6 = (0 - A8 >>> 0) % (A8 >>> 0) | 0; (I7 = FI()) >>> 0 < g6 >>> 0; )
                            ;
                          A8 = (I7 >>> 0) % (A8 >>> 0) | 0;
                        } else
                          A8 = 0;
                        return 0 | A8;
                      }, gc: EI, hc: function(A8, I7, g6) {
                        fg(A8 |= 0, I7 |= 0, 1024, g6 |= 0);
                      }, ic: pg, jc: function() {
                        var A8 = 0, I7 = 0;
                        return (A8 = i3[9096]) && (A8 = i3[A8 + 20 >> 2]) && (I7 = 0 | vg[0 | A8]()), 0 | I7;
                      }, kc: function(A8, I7, g6) {
                        A8 |= 0, I7 |= 0, (0 | (g6 |= 0)) == 1 | g6 >>> 0 > 1 && (e3(1259, 1119, 197, 1036), t3()), EI(A8, I7);
                      }, lc: function(A8, I7, g6, B4) {
                        A8 |= 0, g6 |= 0;
                        var C4 = 0, E4 = 0, i4 = 0;
                        if (!((B4 |= 0) >>> 0 > 2147483646 | B4 << 1 >>> 0 >= (I7 |= 0) >>> 0)) {
                          if (I7 = 0, B4) {
                            for (; C4 = (I7 << 1) + A8 | 0, E4 = 15 & (i4 = n3[I7 + g6 | 0]), Q3[C4 + 1 | 0] = 22272 + ((E4 << 8) + (E4 + 65526 & 55552) | 0) >>> 8, E4 = C4, C4 = i4 >>> 4 | 0, Q3[0 | E4] = 87 + ((C4 + 65526 >>> 8 & 217) + C4 | 0), (0 | B4) != (0 | (I7 = I7 + 1 | 0)); )
                              ;
                            I7 = B4 << 1;
                          } else
                            I7 = 0;
                          return Q3[I7 + A8 | 0] = 0, 0 | A8;
                        }
                        xI(), t3();
                      }, mc: function(A8, I7, g6, B4, C4, E4, a4) {
                        A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, E4 |= 0, a4 |= 0;
                        var r4 = 0, o4 = 0, t4 = 0, e4 = 0, f4 = 0, c4 = 0, y4 = 0, s4 = 0, w4 = 0, D4 = 0, h4 = 0;
                        A:
                          if (B4 |= 0) {
                            I: {
                              g: {
                                B:
                                  for (; ; ) {
                                    for (o4 = r4; ; ) {
                                      C: {
                                        if (!(255 & ((w4 = (65526 + (y4 = (223 & (c4 = n3[g6 + o4 | 0])) - 55 & 255) ^ y4 + 65520) >>> 8 | 0) | (t4 = 65526 + (D4 = 48 ^ c4) >>> 8 | 0)))) {
                                          if (t4 = 1, !C4 | 255 & f4)
                                            break g;
                                          if (DA(C4, c4))
                                            break C;
                                          r4 = o4;
                                          break A;
                                        }
                                        if (I7 >>> 0 <= e4 >>> 0) {
                                          i3[8952] = 68, t4 = 0;
                                          break g;
                                        }
                                        if (r4 = y4 & w4 | t4 & D4, 255 & f4 ? (Q3[A8 + e4 | 0] = r4 | h4, e4 = e4 + 1 | 0) : h4 = r4 << 4, f4 ^= -1, t4 = 1, (r4 = o4 + 1 | 0) >>> 0 < B4 >>> 0)
                                          continue B;
                                        break I;
                                      }
                                      if (f4 = 0, !((o4 = o4 + 1 | 0) >>> 0 < B4 >>> 0))
                                        break;
                                    }
                                    break;
                                  }
                                r4 = (A8 = r4 + 1 | 0) >>> 0 < B4 >>> 0 ? B4 : A8;
                                break A;
                              }
                              r4 = o4;
                            }
                            255 & f4 ? (i3[8952] = 28, s4 = -1, r4 = r4 - 1 | 0, e4 = 0) : t4 || (e4 = 0, s4 = -1);
                          }
                        return a4 ? i3[a4 >> 2] = g6 + r4 : (0 | B4) != (0 | r4) && (i3[8952] = 28, s4 = -1), E4 && (i3[E4 >> 2] = e4), 0 | s4;
                      }, nc: function(A8, I7) {
                        var g6;
                        return A8 |= 0, ag(I7 |= 0), A8 = r3(g6 = (A8 >>> 0) / 3 | 0, -3) + A8 | 0, 1 + (r3(1 & (A8 >>> 1 | A8), 2 & I7 ? A8 + 1 | 0 : 4) + (g6 << 2) | 0) | 0;
                      }, oc: Z3, pc: L3, qc: function() {
                        var A8 = 0;
                        return i3[9097] ? A8 = 1 : (i3[8954] = 0, s3 = A8 = s3 - 16 | 0, NI(A8), i3[A8 >> 2] && (NI(A8), wI(35820, 0, 40)), s3 = A8 + 16 | 0, i3[8953] = 1, SI(), EI(36368, 16), i3[9097] = 1, A8 = 0), 0 | A8;
                      }, rc: function(A8, I7, g6, B4, C4) {
                        A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0;
                        var E4, a4 = 0, r4 = 0, o4 = 0;
                        s3 = E4 = s3 - 16 | 0;
                        A: {
                          if (B4 |= 0) {
                            if (o4 = -1, (a4 = (a4 = B4 - 1 | 0) - (r4 = a4 & B4 ? (g6 >>> 0) % (B4 >>> 0) | 0 : g6 & a4) | 0) >>> 0 >= (-1 ^ g6) >>> 0)
                              break A;
                            if (!((g6 = g6 + a4 | 0) >>> 0 >= C4 >>> 0))
                              for (A8 && (i3[A8 >> 2] = g6 + 1), A8 = I7 + g6 | 0, o4 = 0, Q3[E4 + 15 | 0] = 0, g6 = 0; C4 = I7 = A8 - g6 | 0, r4 = n3[0 | I7] & n3[E4 + 15 | 0], I7 = (g6 ^ a4) - 1 >>> 24 | 0, Q3[0 | C4] = r4 | 128 & I7, Q3[E4 + 15 | 0] = I7 | n3[E4 + 15 | 0], (0 | B4) != (0 | (g6 = g6 + 1 | 0)); )
                                ;
                          } else
                            o4 = -1;
                          return s3 = E4 + 16 | 0, 0 | o4;
                        }
                        xI(), t3();
                      }, sc: function(A8, I7, g6, B4) {
                        A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0;
                        var C4, Q4 = 0, E4 = 0, a4 = 0, r4 = 0, o4 = 0;
                        if (i3[12 + (C4 = s3 - 16 | 0) >> 2] = 0, B4 - 1 >>> 0 < g6 >>> 0) {
                          for (o4 = (Q4 = g6 - 1 | 0) + I7 | 0, g6 = 0, I7 = 0; r4 = ((128 ^ (E4 = n3[o4 - g6 | 0])) - 1 & i3[C4 + 12 >> 2] - 1 & a4 - 1) >>> 8 & 1, i3[C4 + 12 >> 2] = i3[C4 + 12 >> 2] | 0 - r4 & g6, I7 |= r4, a4 |= E4, (0 | B4) != (0 | (g6 = g6 + 1 | 0)); )
                            ;
                          i3[A8 >> 2] = Q4 - i3[C4 + 12 >> 2], A8 = I7 - 1 | 0;
                        } else
                          A8 = -1;
                        return 0 | A8;
                      }, tc: function() {
                        return 1368;
                      }, uc: function() {
                        return 10;
                      }, vc: Ug, wc: kg, xc: k3, yc: b3, zc: vg };
                    }(A6);
                  }(gA);
                }, instantiate: function(A5, I5) {
                  return { then: function(I6) {
                    var g4 = new D2.Module(A5);
                    I6({ instance: new D2.Instance(g4) });
                  } };
                }, RuntimeError: Error };
                y2 = [], typeof D2 != "object" && d2("no native wasm support detected");
                var h2, p2, u2, F2, l2, _2, k2, H2 = false, G2 = typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : void 0;
                function U2(A5, I5) {
                  return A5 ? function(A6, I6, g4) {
                    for (var B2 = I6 + g4, C3 = I6; A6[C3] && !(C3 >= B2); )
                      ++C3;
                    if (C3 - I6 > 16 && A6.subarray && G2)
                      return G2.decode(A6.subarray(I6, C3));
                    for (var Q3 = ""; I6 < C3; ) {
                      var E3 = A6[I6++];
                      if (128 & E3) {
                        var i3 = 63 & A6[I6++];
                        if ((224 & E3) != 192) {
                          var n3 = 63 & A6[I6++];
                          if ((E3 = (240 & E3) == 224 ? (15 & E3) << 12 | i3 << 6 | n3 : (7 & E3) << 18 | i3 << 12 | n3 << 6 | 63 & A6[I6++]) < 65536)
                            Q3 += String.fromCharCode(E3);
                          else {
                            var a3 = E3 - 65536;
                            Q3 += String.fromCharCode(55296 | a3 >> 10, 56320 | 1023 & a3);
                          }
                        } else
                          Q3 += String.fromCharCode((31 & E3) << 6 | i3);
                      } else
                        Q3 += String.fromCharCode(E3);
                    }
                    return Q3;
                  }(u2, A5, I5) : "";
                }
                function S2(A5) {
                  h2 = A5, a2.HEAP8 = p2 = new Int8Array(A5), a2.HEAP16 = F2 = new Int16Array(A5), a2.HEAP32 = l2 = new Int32Array(A5), a2.HEAPU8 = u2 = new Uint8Array(A5), a2.HEAPU16 = new Uint16Array(A5), a2.HEAPU32 = new Uint32Array(A5), a2.HEAPF32 = _2 = new Float32Array(A5), a2.HEAPF64 = k2 = new Float64Array(A5);
                }
                var b2, m2 = a2.INITIAL_MEMORY || 16777216;
                (w2 = a2.wasmMemory ? a2.wasmMemory : new D2.Memory({ initial: m2 / 65536, maximum: 32768 })) && (h2 = w2.buffer), m2 = h2.byteLength, S2(h2);
                var v2 = [], M2 = [], P2 = [], Y2 = 0, N2 = null, R2 = null;
                function d2(A5) {
                  throw a2.onAbort && a2.onAbort(A5), s2(A5 = "Aborted(" + A5 + ")"), H2 = true, A5 += ". Build with -s ASSERTIONS=1 for more info.", new D2.RuntimeError(A5);
                }
                a2.preloadedImages = {}, a2.preloadedAudios = {};
                var J2, x2, L2, K2, X2 = "data:application/octet-stream;base64,";
                function T2(A5) {
                  return A5.startsWith(X2);
                }
                function V2(A5) {
                  return A5.startsWith("file://");
                }
                function q2(A5) {
                  try {
                    if (A5 == J2 && y2)
                      return new Uint8Array(y2);
                    var I5 = AA2(A5);
                    if (I5)
                      return I5;
                    if (Q2)
                      return Q2(A5);
                    throw "both async and sync fetching of the wasm failed";
                  } catch (A6) {
                    d2(A6);
                  }
                }
                T2(J2 = "<<< WASM_BINARY_FILE >>>") || (x2 = J2, J2 = a2.locateFile ? a2.locateFile(x2, c2) : c2 + x2);
                var z2 = { 35048: function() {
                  return a2.getRandomValue();
                }, 35084: function() {
                  if (a2.getRandomValue === void 0)
                    try {
                      var A5 = typeof window == "object" ? window : self, I5 = A5.crypto !== void 0 ? A5.crypto : A5.msCrypto, g4 = function() {
                        var A6 = new Uint32Array(1);
                        return I5.getRandomValues(A6), A6[0] >>> 0;
                      };
                      g4(), a2.getRandomValue = g4;
                    } catch (A6) {
                      try {
                        var B2 = __require("crypto"), C3 = function() {
                          var A7 = B2.randomBytes(4);
                          return (A7[0] << 24 | A7[1] << 16 | A7[2] << 8 | A7[3]) >>> 0;
                        };
                        C3(), a2.getRandomValue = C3;
                      } catch (A7) {
                        throw "No secure random number generator found";
                      }
                    }
                } };
                function j2(A5) {
                  for (; A5.length > 0; ) {
                    var I5 = A5.shift();
                    if (typeof I5 != "function") {
                      var g4 = I5.func;
                      typeof g4 == "number" ? I5.arg === void 0 ? W2(g4)() : W2(g4)(I5.arg) : g4(I5.arg === void 0 ? null : I5.arg);
                    } else
                      I5(a2);
                  }
                }
                function W2(A5) {
                  return b2.get(A5);
                }
                var O2 = [];
                function Z2(A5) {
                  try {
                    return w2.grow(A5 - h2.byteLength + 65535 >>> 16), S2(w2.buffer), 1;
                  } catch (A6) {
                  }
                }
                var $2 = typeof atob == "function" ? atob : function(A5) {
                  var I5, g4, B2, C3, Q3, E3, i3 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=", n3 = "", a3 = 0;
                  A5 = A5.replace(/[^A-Za-z0-9\+\/\=]/g, "");
                  do {
                    I5 = i3.indexOf(A5.charAt(a3++)) << 2 | (C3 = i3.indexOf(A5.charAt(a3++))) >> 4, g4 = (15 & C3) << 4 | (Q3 = i3.indexOf(A5.charAt(a3++))) >> 2, B2 = (3 & Q3) << 6 | (E3 = i3.indexOf(A5.charAt(a3++))), n3 += String.fromCharCode(I5), Q3 !== 64 && (n3 += String.fromCharCode(g4)), E3 !== 64 && (n3 += String.fromCharCode(B2));
                  } while (a3 < A5.length);
                  return n3;
                };
                function AA2(A5) {
                  if (T2(A5))
                    return function(A6) {
                      if (typeof f2 == "boolean" && f2) {
                        var I5 = Buffer.from(A6, "base64");
                        return new Uint8Array(I5.buffer, I5.byteOffset, I5.byteLength);
                      }
                      try {
                        for (var g4 = $2(A6), B2 = new Uint8Array(g4.length), C3 = 0; C3 < g4.length; ++C3)
                          B2[C3] = g4.charCodeAt(C3);
                        return B2;
                      } catch (A7) {
                        throw new Error("Converting base64 string to bytes failed.");
                      }
                    }(A5.slice(X2.length));
                }
                var IA2, gA = { b: function(A5, I5, g4, B2) {
                  d2("Assertion failed: " + U2(A5) + ", at: " + [I5 ? U2(I5) : "unknown filename", g4, B2 ? U2(B2) : "unknown function"]);
                }, e: function() {
                  d2("");
                }, c: function(A5, I5, g4) {
                  var B2 = function(A6, I6) {
                    var g5;
                    for (O2.length = 0, I6 >>= 2; g5 = u2[A6++]; ) {
                      var B3 = g5 < 105;
                      B3 && 1 & I6 && I6++, O2.push(B3 ? k2[I6++ >> 1] : l2[I6]), ++I6;
                    }
                    return O2;
                  }(I5, g4);
                  return z2[A5].apply(null, B2);
                }, d: function(A5) {
                  var I5, g4 = u2.length, B2 = 2147483648;
                  if ((A5 >>>= 0) > B2)
                    return false;
                  for (var C3 = 1; C3 <= 4; C3 *= 2) {
                    var Q3 = g4 * (1 + 0.2 / C3);
                    if (Q3 = Math.min(Q3, A5 + 100663296), Z2(Math.min(B2, (I5 = Math.max(A5, Q3)) + (65536 - I5 % 65536) % 65536)))
                      return true;
                  }
                  return false;
                }, a: w2 };
                function BA(A5) {
                  function I5() {
                    IA2 || (IA2 = true, a2.calledRun = true, H2 || (j2(M2), a2.onRuntimeInitialized && a2.onRuntimeInitialized(), function() {
                      if (a2.postRun)
                        for (typeof a2.postRun == "function" && (a2.postRun = [a2.postRun]); a2.postRun.length; )
                          A6 = a2.postRun.shift(), P2.unshift(A6);
                      var A6;
                      j2(P2);
                    }()));
                  }
                  A5 = A5 || o2, Y2 > 0 || (function() {
                    if (a2.preRun)
                      for (typeof a2.preRun == "function" && (a2.preRun = [a2.preRun]); a2.preRun.length; )
                        A6 = a2.preRun.shift(), v2.unshift(A6);
                    var A6;
                    j2(v2);
                  }(), Y2 > 0 || (a2.setStatus ? (a2.setStatus("Running..."), setTimeout(function() {
                    setTimeout(function() {
                      a2.setStatus("");
                    }, 1), I5();
                  }, 1)) : I5()));
                }
                if (function() {
                  var A5 = { a: gA };
                  function I5(A6, I6) {
                    var g5, B3 = A6.exports;
                    a2.asm = B3, b2 = a2.asm.zc, g5 = a2.asm.f, M2.unshift(g5), function(A7) {
                      if (Y2--, a2.monitorRunDependencies && a2.monitorRunDependencies(Y2), Y2 == 0 && (N2 !== null && (clearInterval(N2), N2 = null), R2)) {
                        var I7 = R2;
                        R2 = null, I7();
                      }
                    }();
                  }
                  function g4(A6) {
                    I5(A6.instance);
                  }
                  function B2(I6) {
                    return function() {
                      if (!y2 && (t2 || e2)) {
                        if (typeof fetch == "function" && !V2(J2))
                          return fetch(J2, { credentials: "same-origin" }).then(function(A6) {
                            if (!A6.ok)
                              throw "failed to load wasm binary file at '" + J2 + "'";
                            return A6.arrayBuffer();
                          }).catch(function() {
                            return q2(J2);
                          });
                        if (C2)
                          return new Promise(function(A6, I7) {
                            C2(J2, function(I8) {
                              A6(new Uint8Array(I8));
                            }, I7);
                          });
                      }
                      return Promise.resolve().then(function() {
                        return q2(J2);
                      });
                    }().then(function(I7) {
                      return D2.instantiate(I7, A5);
                    }).then(function(A6) {
                      return A6;
                    }).then(I6, function(A6) {
                      s2("failed to asynchronously prepare wasm: " + A6), d2(A6);
                    });
                  }
                  if (Y2++, a2.monitorRunDependencies && a2.monitorRunDependencies(Y2), a2.instantiateWasm)
                    try {
                      return a2.instantiateWasm(A5, I5);
                    } catch (A6) {
                      return s2("Module.instantiateWasm callback failed with error: " + A6), false;
                    }
                  y2 || typeof D2.instantiateStreaming != "function" || T2(J2) || V2(J2) || typeof fetch != "function" ? B2(g4) : fetch(J2, { credentials: "same-origin" }).then(function(I6) {
                    return D2.instantiateStreaming(I6, A5).then(g4, function(A6) {
                      return s2("wasm streaming compile failed: " + A6), s2("falling back to ArrayBuffer instantiation"), B2(g4);
                    });
                  });
                }(), a2.___wasm_call_ctors = function() {
                  return (a2.___wasm_call_ctors = a2.asm.f).apply(null, arguments);
                }, a2._crypto_aead_chacha20poly1305_encrypt_detached = function() {
                  return (a2._crypto_aead_chacha20poly1305_encrypt_detached = a2.asm.g).apply(null, arguments);
                }, a2._crypto_aead_chacha20poly1305_encrypt = function() {
                  return (a2._crypto_aead_chacha20poly1305_encrypt = a2.asm.h).apply(null, arguments);
                }, a2._crypto_aead_chacha20poly1305_ietf_encrypt_detached = function() {
                  return (a2._crypto_aead_chacha20poly1305_ietf_encrypt_detached = a2.asm.i).apply(null, arguments);
                }, a2._crypto_aead_chacha20poly1305_ietf_encrypt = function() {
                  return (a2._crypto_aead_chacha20poly1305_ietf_encrypt = a2.asm.j).apply(null, arguments);
                }, a2._crypto_aead_chacha20poly1305_decrypt_detached = function() {
                  return (a2._crypto_aead_chacha20poly1305_decrypt_detached = a2.asm.k).apply(null, arguments);
                }, a2._crypto_aead_chacha20poly1305_decrypt = function() {
                  return (a2._crypto_aead_chacha20poly1305_decrypt = a2.asm.l).apply(null, arguments);
                }, a2._crypto_aead_chacha20poly1305_ietf_decrypt_detached = function() {
                  return (a2._crypto_aead_chacha20poly1305_ietf_decrypt_detached = a2.asm.m).apply(null, arguments);
                }, a2._crypto_aead_chacha20poly1305_ietf_decrypt = function() {
                  return (a2._crypto_aead_chacha20poly1305_ietf_decrypt = a2.asm.n).apply(null, arguments);
                }, a2._crypto_aead_chacha20poly1305_ietf_keybytes = function() {
                  return (a2._crypto_aead_chacha20poly1305_ietf_keybytes = a2.asm.o).apply(null, arguments);
                }, a2._crypto_aead_chacha20poly1305_ietf_npubbytes = function() {
                  return (a2._crypto_aead_chacha20poly1305_ietf_npubbytes = a2.asm.p).apply(null, arguments);
                }, a2._crypto_aead_chacha20poly1305_ietf_nsecbytes = function() {
                  return (a2._crypto_aead_chacha20poly1305_ietf_nsecbytes = a2.asm.q).apply(null, arguments);
                }, a2._crypto_aead_chacha20poly1305_ietf_abytes = function() {
                  return (a2._crypto_aead_chacha20poly1305_ietf_abytes = a2.asm.r).apply(null, arguments);
                }, a2._crypto_aead_chacha20poly1305_ietf_messagebytes_max = function() {
                  return (a2._crypto_aead_chacha20poly1305_ietf_messagebytes_max = a2.asm.s).apply(null, arguments);
                }, a2._crypto_aead_chacha20poly1305_ietf_keygen = function() {
                  return (a2._crypto_aead_chacha20poly1305_ietf_keygen = a2.asm.t).apply(null, arguments);
                }, a2._crypto_aead_chacha20poly1305_keybytes = function() {
                  return (a2._crypto_aead_chacha20poly1305_keybytes = a2.asm.u).apply(null, arguments);
                }, a2._crypto_aead_chacha20poly1305_npubbytes = function() {
                  return (a2._crypto_aead_chacha20poly1305_npubbytes = a2.asm.v).apply(null, arguments);
                }, a2._crypto_aead_chacha20poly1305_nsecbytes = function() {
                  return (a2._crypto_aead_chacha20poly1305_nsecbytes = a2.asm.w).apply(null, arguments);
                }, a2._crypto_aead_chacha20poly1305_abytes = function() {
                  return (a2._crypto_aead_chacha20poly1305_abytes = a2.asm.x).apply(null, arguments);
                }, a2._crypto_aead_chacha20poly1305_messagebytes_max = function() {
                  return (a2._crypto_aead_chacha20poly1305_messagebytes_max = a2.asm.y).apply(null, arguments);
                }, a2._crypto_aead_chacha20poly1305_keygen = function() {
                  return (a2._crypto_aead_chacha20poly1305_keygen = a2.asm.z).apply(null, arguments);
                }, a2._crypto_aead_xchacha20poly1305_ietf_encrypt_detached = function() {
                  return (a2._crypto_aead_xchacha20poly1305_ietf_encrypt_detached = a2.asm.A).apply(null, arguments);
                }, a2._crypto_aead_xchacha20poly1305_ietf_encrypt = function() {
                  return (a2._crypto_aead_xchacha20poly1305_ietf_encrypt = a2.asm.B).apply(null, arguments);
                }, a2._crypto_aead_xchacha20poly1305_ietf_decrypt_detached = function() {
                  return (a2._crypto_aead_xchacha20poly1305_ietf_decrypt_detached = a2.asm.C).apply(null, arguments);
                }, a2._crypto_aead_xchacha20poly1305_ietf_decrypt = function() {
                  return (a2._crypto_aead_xchacha20poly1305_ietf_decrypt = a2.asm.D).apply(null, arguments);
                }, a2._crypto_aead_xchacha20poly1305_ietf_keybytes = function() {
                  return (a2._crypto_aead_xchacha20poly1305_ietf_keybytes = a2.asm.E).apply(null, arguments);
                }, a2._crypto_aead_xchacha20poly1305_ietf_npubbytes = function() {
                  return (a2._crypto_aead_xchacha20poly1305_ietf_npubbytes = a2.asm.F).apply(null, arguments);
                }, a2._crypto_aead_xchacha20poly1305_ietf_nsecbytes = function() {
                  return (a2._crypto_aead_xchacha20poly1305_ietf_nsecbytes = a2.asm.G).apply(null, arguments);
                }, a2._crypto_aead_xchacha20poly1305_ietf_abytes = function() {
                  return (a2._crypto_aead_xchacha20poly1305_ietf_abytes = a2.asm.H).apply(null, arguments);
                }, a2._crypto_aead_xchacha20poly1305_ietf_messagebytes_max = function() {
                  return (a2._crypto_aead_xchacha20poly1305_ietf_messagebytes_max = a2.asm.I).apply(null, arguments);
                }, a2._crypto_aead_xchacha20poly1305_ietf_keygen = function() {
                  return (a2._crypto_aead_xchacha20poly1305_ietf_keygen = a2.asm.J).apply(null, arguments);
                }, a2._crypto_auth_bytes = function() {
                  return (a2._crypto_auth_bytes = a2.asm.K).apply(null, arguments);
                }, a2._crypto_auth_keybytes = function() {
                  return (a2._crypto_auth_keybytes = a2.asm.L).apply(null, arguments);
                }, a2._crypto_auth = function() {
                  return (a2._crypto_auth = a2.asm.M).apply(null, arguments);
                }, a2._crypto_auth_verify = function() {
                  return (a2._crypto_auth_verify = a2.asm.N).apply(null, arguments);
                }, a2._crypto_auth_keygen = function() {
                  return (a2._crypto_auth_keygen = a2.asm.O).apply(null, arguments);
                }, a2._crypto_box_seedbytes = function() {
                  return (a2._crypto_box_seedbytes = a2.asm.P).apply(null, arguments);
                }, a2._crypto_box_publickeybytes = function() {
                  return (a2._crypto_box_publickeybytes = a2.asm.Q).apply(null, arguments);
                }, a2._crypto_box_secretkeybytes = function() {
                  return (a2._crypto_box_secretkeybytes = a2.asm.R).apply(null, arguments);
                }, a2._crypto_box_beforenmbytes = function() {
                  return (a2._crypto_box_beforenmbytes = a2.asm.S).apply(null, arguments);
                }, a2._crypto_box_noncebytes = function() {
                  return (a2._crypto_box_noncebytes = a2.asm.T).apply(null, arguments);
                }, a2._crypto_box_macbytes = function() {
                  return (a2._crypto_box_macbytes = a2.asm.U).apply(null, arguments);
                }, a2._crypto_box_messagebytes_max = function() {
                  return (a2._crypto_box_messagebytes_max = a2.asm.V).apply(null, arguments);
                }, a2._crypto_box_seed_keypair = function() {
                  return (a2._crypto_box_seed_keypair = a2.asm.W).apply(null, arguments);
                }, a2._crypto_box_keypair = function() {
                  return (a2._crypto_box_keypair = a2.asm.X).apply(null, arguments);
                }, a2._crypto_box_beforenm = function() {
                  return (a2._crypto_box_beforenm = a2.asm.Y).apply(null, arguments);
                }, a2._crypto_box_detached_afternm = function() {
                  return (a2._crypto_box_detached_afternm = a2.asm.Z).apply(null, arguments);
                }, a2._crypto_box_detached = function() {
                  return (a2._crypto_box_detached = a2.asm._).apply(null, arguments);
                }, a2._crypto_box_easy_afternm = function() {
                  return (a2._crypto_box_easy_afternm = a2.asm.$).apply(null, arguments);
                }, a2._crypto_box_easy = function() {
                  return (a2._crypto_box_easy = a2.asm.aa).apply(null, arguments);
                }, a2._crypto_box_open_detached_afternm = function() {
                  return (a2._crypto_box_open_detached_afternm = a2.asm.ba).apply(null, arguments);
                }, a2._crypto_box_open_detached = function() {
                  return (a2._crypto_box_open_detached = a2.asm.ca).apply(null, arguments);
                }, a2._crypto_box_open_easy_afternm = function() {
                  return (a2._crypto_box_open_easy_afternm = a2.asm.da).apply(null, arguments);
                }, a2._crypto_box_open_easy = function() {
                  return (a2._crypto_box_open_easy = a2.asm.ea).apply(null, arguments);
                }, a2._crypto_box_seal = function() {
                  return (a2._crypto_box_seal = a2.asm.fa).apply(null, arguments);
                }, a2._crypto_box_seal_open = function() {
                  return (a2._crypto_box_seal_open = a2.asm.ga).apply(null, arguments);
                }, a2._crypto_box_sealbytes = function() {
                  return (a2._crypto_box_sealbytes = a2.asm.ha).apply(null, arguments);
                }, a2._crypto_generichash_bytes_min = function() {
                  return (a2._crypto_generichash_bytes_min = a2.asm.ia).apply(null, arguments);
                }, a2._crypto_generichash_bytes_max = function() {
                  return (a2._crypto_generichash_bytes_max = a2.asm.ja).apply(null, arguments);
                }, a2._crypto_generichash_bytes = function() {
                  return (a2._crypto_generichash_bytes = a2.asm.ka).apply(null, arguments);
                }, a2._crypto_generichash_keybytes_min = function() {
                  return (a2._crypto_generichash_keybytes_min = a2.asm.la).apply(null, arguments);
                }, a2._crypto_generichash_keybytes_max = function() {
                  return (a2._crypto_generichash_keybytes_max = a2.asm.ma).apply(null, arguments);
                }, a2._crypto_generichash_keybytes = function() {
                  return (a2._crypto_generichash_keybytes = a2.asm.na).apply(null, arguments);
                }, a2._crypto_generichash_statebytes = function() {
                  return (a2._crypto_generichash_statebytes = a2.asm.oa).apply(null, arguments);
                }, a2._crypto_generichash = function() {
                  return (a2._crypto_generichash = a2.asm.pa).apply(null, arguments);
                }, a2._crypto_generichash_init = function() {
                  return (a2._crypto_generichash_init = a2.asm.qa).apply(null, arguments);
                }, a2._crypto_generichash_update = function() {
                  return (a2._crypto_generichash_update = a2.asm.ra).apply(null, arguments);
                }, a2._crypto_generichash_final = function() {
                  return (a2._crypto_generichash_final = a2.asm.sa).apply(null, arguments);
                }, a2._crypto_generichash_keygen = function() {
                  return (a2._crypto_generichash_keygen = a2.asm.ta).apply(null, arguments);
                }, a2._crypto_hash_bytes = function() {
                  return (a2._crypto_hash_bytes = a2.asm.ua).apply(null, arguments);
                }, a2._crypto_hash = function() {
                  return (a2._crypto_hash = a2.asm.va).apply(null, arguments);
                }, a2._crypto_kdf_bytes_min = function() {
                  return (a2._crypto_kdf_bytes_min = a2.asm.wa).apply(null, arguments);
                }, a2._crypto_kdf_bytes_max = function() {
                  return (a2._crypto_kdf_bytes_max = a2.asm.xa).apply(null, arguments);
                }, a2._crypto_kdf_contextbytes = function() {
                  return (a2._crypto_kdf_contextbytes = a2.asm.ya).apply(null, arguments);
                }, a2._crypto_kdf_keybytes = function() {
                  return (a2._crypto_kdf_keybytes = a2.asm.za).apply(null, arguments);
                }, a2._crypto_kdf_derive_from_key = function() {
                  return (a2._crypto_kdf_derive_from_key = a2.asm.Aa).apply(null, arguments);
                }, a2._crypto_kdf_keygen = function() {
                  return (a2._crypto_kdf_keygen = a2.asm.Ba).apply(null, arguments);
                }, a2._crypto_kx_seed_keypair = function() {
                  return (a2._crypto_kx_seed_keypair = a2.asm.Ca).apply(null, arguments);
                }, a2._crypto_kx_keypair = function() {
                  return (a2._crypto_kx_keypair = a2.asm.Da).apply(null, arguments);
                }, a2._crypto_kx_client_session_keys = function() {
                  return (a2._crypto_kx_client_session_keys = a2.asm.Ea).apply(null, arguments);
                }, a2._crypto_kx_server_session_keys = function() {
                  return (a2._crypto_kx_server_session_keys = a2.asm.Fa).apply(null, arguments);
                }, a2._crypto_kx_publickeybytes = function() {
                  return (a2._crypto_kx_publickeybytes = a2.asm.Ga).apply(null, arguments);
                }, a2._crypto_kx_secretkeybytes = function() {
                  return (a2._crypto_kx_secretkeybytes = a2.asm.Ha).apply(null, arguments);
                }, a2._crypto_kx_seedbytes = function() {
                  return (a2._crypto_kx_seedbytes = a2.asm.Ia).apply(null, arguments);
                }, a2._crypto_kx_sessionkeybytes = function() {
                  return (a2._crypto_kx_sessionkeybytes = a2.asm.Ja).apply(null, arguments);
                }, a2._crypto_pwhash_alg_argon2i13 = function() {
                  return (a2._crypto_pwhash_alg_argon2i13 = a2.asm.Ka).apply(null, arguments);
                }, a2._crypto_pwhash_alg_argon2id13 = function() {
                  return (a2._crypto_pwhash_alg_argon2id13 = a2.asm.La).apply(null, arguments);
                }, a2._crypto_pwhash_alg_default = function() {
                  return (a2._crypto_pwhash_alg_default = a2.asm.Ma).apply(null, arguments);
                }, a2._crypto_pwhash_bytes_min = function() {
                  return (a2._crypto_pwhash_bytes_min = a2.asm.Na).apply(null, arguments);
                }, a2._crypto_pwhash_bytes_max = function() {
                  return (a2._crypto_pwhash_bytes_max = a2.asm.Oa).apply(null, arguments);
                }, a2._crypto_pwhash_passwd_min = function() {
                  return (a2._crypto_pwhash_passwd_min = a2.asm.Pa).apply(null, arguments);
                }, a2._crypto_pwhash_passwd_max = function() {
                  return (a2._crypto_pwhash_passwd_max = a2.asm.Qa).apply(null, arguments);
                }, a2._crypto_pwhash_saltbytes = function() {
                  return (a2._crypto_pwhash_saltbytes = a2.asm.Ra).apply(null, arguments);
                }, a2._crypto_pwhash_strbytes = function() {
                  return (a2._crypto_pwhash_strbytes = a2.asm.Sa).apply(null, arguments);
                }, a2._crypto_pwhash_strprefix = function() {
                  return (a2._crypto_pwhash_strprefix = a2.asm.Ta).apply(null, arguments);
                }, a2._crypto_pwhash_opslimit_min = function() {
                  return (a2._crypto_pwhash_opslimit_min = a2.asm.Ua).apply(null, arguments);
                }, a2._crypto_pwhash_opslimit_max = function() {
                  return (a2._crypto_pwhash_opslimit_max = a2.asm.Va).apply(null, arguments);
                }, a2._crypto_pwhash_memlimit_min = function() {
                  return (a2._crypto_pwhash_memlimit_min = a2.asm.Wa).apply(null, arguments);
                }, a2._crypto_pwhash_memlimit_max = function() {
                  return (a2._crypto_pwhash_memlimit_max = a2.asm.Xa).apply(null, arguments);
                }, a2._crypto_pwhash_opslimit_interactive = function() {
                  return (a2._crypto_pwhash_opslimit_interactive = a2.asm.Ya).apply(null, arguments);
                }, a2._crypto_pwhash_memlimit_interactive = function() {
                  return (a2._crypto_pwhash_memlimit_interactive = a2.asm.Za).apply(null, arguments);
                }, a2._crypto_pwhash_opslimit_moderate = function() {
                  return (a2._crypto_pwhash_opslimit_moderate = a2.asm._a).apply(null, arguments);
                }, a2._crypto_pwhash_memlimit_moderate = function() {
                  return (a2._crypto_pwhash_memlimit_moderate = a2.asm.$a).apply(null, arguments);
                }, a2._crypto_pwhash_opslimit_sensitive = function() {
                  return (a2._crypto_pwhash_opslimit_sensitive = a2.asm.ab).apply(null, arguments);
                }, a2._crypto_pwhash_memlimit_sensitive = function() {
                  return (a2._crypto_pwhash_memlimit_sensitive = a2.asm.bb).apply(null, arguments);
                }, a2._crypto_pwhash = function() {
                  return (a2._crypto_pwhash = a2.asm.cb).apply(null, arguments);
                }, a2._crypto_pwhash_str = function() {
                  return (a2._crypto_pwhash_str = a2.asm.db).apply(null, arguments);
                }, a2._crypto_pwhash_str_alg = function() {
                  return (a2._crypto_pwhash_str_alg = a2.asm.eb).apply(null, arguments);
                }, a2._crypto_pwhash_str_verify = function() {
                  return (a2._crypto_pwhash_str_verify = a2.asm.fb).apply(null, arguments);
                }, a2._crypto_pwhash_str_needs_rehash = function() {
                  return (a2._crypto_pwhash_str_needs_rehash = a2.asm.gb).apply(null, arguments);
                }, a2._crypto_scalarmult_base = function() {
                  return (a2._crypto_scalarmult_base = a2.asm.hb).apply(null, arguments);
                }, a2._crypto_scalarmult = function() {
                  return (a2._crypto_scalarmult = a2.asm.ib).apply(null, arguments);
                }, a2._crypto_scalarmult_bytes = function() {
                  return (a2._crypto_scalarmult_bytes = a2.asm.jb).apply(null, arguments);
                }, a2._crypto_scalarmult_scalarbytes = function() {
                  return (a2._crypto_scalarmult_scalarbytes = a2.asm.kb).apply(null, arguments);
                }, a2._crypto_secretbox_keybytes = function() {
                  return (a2._crypto_secretbox_keybytes = a2.asm.lb).apply(null, arguments);
                }, a2._crypto_secretbox_noncebytes = function() {
                  return (a2._crypto_secretbox_noncebytes = a2.asm.mb).apply(null, arguments);
                }, a2._crypto_secretbox_macbytes = function() {
                  return (a2._crypto_secretbox_macbytes = a2.asm.nb).apply(null, arguments);
                }, a2._crypto_secretbox_messagebytes_max = function() {
                  return (a2._crypto_secretbox_messagebytes_max = a2.asm.ob).apply(null, arguments);
                }, a2._crypto_secretbox_keygen = function() {
                  return (a2._crypto_secretbox_keygen = a2.asm.pb).apply(null, arguments);
                }, a2._crypto_secretbox_detached = function() {
                  return (a2._crypto_secretbox_detached = a2.asm.qb).apply(null, arguments);
                }, a2._crypto_secretbox_easy = function() {
                  return (a2._crypto_secretbox_easy = a2.asm.rb).apply(null, arguments);
                }, a2._crypto_secretbox_open_detached = function() {
                  return (a2._crypto_secretbox_open_detached = a2.asm.sb).apply(null, arguments);
                }, a2._crypto_secretbox_open_easy = function() {
                  return (a2._crypto_secretbox_open_easy = a2.asm.tb).apply(null, arguments);
                }, a2._crypto_secretstream_xchacha20poly1305_keygen = function() {
                  return (a2._crypto_secretstream_xchacha20poly1305_keygen = a2.asm.ub).apply(null, arguments);
                }, a2._crypto_secretstream_xchacha20poly1305_init_push = function() {
                  return (a2._crypto_secretstream_xchacha20poly1305_init_push = a2.asm.vb).apply(null, arguments);
                }, a2._crypto_secretstream_xchacha20poly1305_init_pull = function() {
                  return (a2._crypto_secretstream_xchacha20poly1305_init_pull = a2.asm.wb).apply(null, arguments);
                }, a2._crypto_secretstream_xchacha20poly1305_rekey = function() {
                  return (a2._crypto_secretstream_xchacha20poly1305_rekey = a2.asm.xb).apply(null, arguments);
                }, a2._crypto_secretstream_xchacha20poly1305_push = function() {
                  return (a2._crypto_secretstream_xchacha20poly1305_push = a2.asm.yb).apply(null, arguments);
                }, a2._crypto_secretstream_xchacha20poly1305_pull = function() {
                  return (a2._crypto_secretstream_xchacha20poly1305_pull = a2.asm.zb).apply(null, arguments);
                }, a2._crypto_secretstream_xchacha20poly1305_statebytes = function() {
                  return (a2._crypto_secretstream_xchacha20poly1305_statebytes = a2.asm.Ab).apply(null, arguments);
                }, a2._crypto_secretstream_xchacha20poly1305_abytes = function() {
                  return (a2._crypto_secretstream_xchacha20poly1305_abytes = a2.asm.Bb).apply(null, arguments);
                }, a2._crypto_secretstream_xchacha20poly1305_headerbytes = function() {
                  return (a2._crypto_secretstream_xchacha20poly1305_headerbytes = a2.asm.Cb).apply(null, arguments);
                }, a2._crypto_secretstream_xchacha20poly1305_keybytes = function() {
                  return (a2._crypto_secretstream_xchacha20poly1305_keybytes = a2.asm.Db).apply(null, arguments);
                }, a2._crypto_secretstream_xchacha20poly1305_messagebytes_max = function() {
                  return (a2._crypto_secretstream_xchacha20poly1305_messagebytes_max = a2.asm.Eb).apply(null, arguments);
                }, a2._crypto_secretstream_xchacha20poly1305_tag_message = function() {
                  return (a2._crypto_secretstream_xchacha20poly1305_tag_message = a2.asm.Fb).apply(null, arguments);
                }, a2._crypto_secretstream_xchacha20poly1305_tag_push = function() {
                  return (a2._crypto_secretstream_xchacha20poly1305_tag_push = a2.asm.Gb).apply(null, arguments);
                }, a2._crypto_secretstream_xchacha20poly1305_tag_rekey = function() {
                  return (a2._crypto_secretstream_xchacha20poly1305_tag_rekey = a2.asm.Hb).apply(null, arguments);
                }, a2._crypto_secretstream_xchacha20poly1305_tag_final = function() {
                  return (a2._crypto_secretstream_xchacha20poly1305_tag_final = a2.asm.Ib).apply(null, arguments);
                }, a2._crypto_shorthash_bytes = function() {
                  return (a2._crypto_shorthash_bytes = a2.asm.Jb).apply(null, arguments);
                }, a2._crypto_shorthash_keybytes = function() {
                  return (a2._crypto_shorthash_keybytes = a2.asm.Kb).apply(null, arguments);
                }, a2._crypto_shorthash = function() {
                  return (a2._crypto_shorthash = a2.asm.Lb).apply(null, arguments);
                }, a2._crypto_shorthash_keygen = function() {
                  return (a2._crypto_shorthash_keygen = a2.asm.Mb).apply(null, arguments);
                }, a2._crypto_sign_statebytes = function() {
                  return (a2._crypto_sign_statebytes = a2.asm.Nb).apply(null, arguments);
                }, a2._crypto_sign_bytes = function() {
                  return (a2._crypto_sign_bytes = a2.asm.Ob).apply(null, arguments);
                }, a2._crypto_sign_seedbytes = function() {
                  return (a2._crypto_sign_seedbytes = a2.asm.Pb).apply(null, arguments);
                }, a2._crypto_sign_publickeybytes = function() {
                  return (a2._crypto_sign_publickeybytes = a2.asm.Qb).apply(null, arguments);
                }, a2._crypto_sign_secretkeybytes = function() {
                  return (a2._crypto_sign_secretkeybytes = a2.asm.Rb).apply(null, arguments);
                }, a2._crypto_sign_messagebytes_max = function() {
                  return (a2._crypto_sign_messagebytes_max = a2.asm.Sb).apply(null, arguments);
                }, a2._crypto_sign_seed_keypair = function() {
                  return (a2._crypto_sign_seed_keypair = a2.asm.Tb).apply(null, arguments);
                }, a2._crypto_sign_keypair = function() {
                  return (a2._crypto_sign_keypair = a2.asm.Ub).apply(null, arguments);
                }, a2._crypto_sign = function() {
                  return (a2._crypto_sign = a2.asm.Vb).apply(null, arguments);
                }, a2._crypto_sign_open = function() {
                  return (a2._crypto_sign_open = a2.asm.Wb).apply(null, arguments);
                }, a2._crypto_sign_detached = function() {
                  return (a2._crypto_sign_detached = a2.asm.Xb).apply(null, arguments);
                }, a2._crypto_sign_verify_detached = function() {
                  return (a2._crypto_sign_verify_detached = a2.asm.Yb).apply(null, arguments);
                }, a2._crypto_sign_init = function() {
                  return (a2._crypto_sign_init = a2.asm.Zb).apply(null, arguments);
                }, a2._crypto_sign_update = function() {
                  return (a2._crypto_sign_update = a2.asm._b).apply(null, arguments);
                }, a2._crypto_sign_final_create = function() {
                  return (a2._crypto_sign_final_create = a2.asm.$b).apply(null, arguments);
                }, a2._crypto_sign_final_verify = function() {
                  return (a2._crypto_sign_final_verify = a2.asm.ac).apply(null, arguments);
                }, a2._crypto_sign_ed25519_pk_to_curve25519 = function() {
                  return (a2._crypto_sign_ed25519_pk_to_curve25519 = a2.asm.bc).apply(null, arguments);
                }, a2._crypto_sign_ed25519_sk_to_curve25519 = function() {
                  return (a2._crypto_sign_ed25519_sk_to_curve25519 = a2.asm.cc).apply(null, arguments);
                }, a2._randombytes_random = function() {
                  return (a2._randombytes_random = a2.asm.dc).apply(null, arguments);
                }, a2._randombytes_stir = function() {
                  return (a2._randombytes_stir = a2.asm.ec).apply(null, arguments);
                }, a2._randombytes_uniform = function() {
                  return (a2._randombytes_uniform = a2.asm.fc).apply(null, arguments);
                }, a2._randombytes_buf = function() {
                  return (a2._randombytes_buf = a2.asm.gc).apply(null, arguments);
                }, a2._randombytes_buf_deterministic = function() {
                  return (a2._randombytes_buf_deterministic = a2.asm.hc).apply(null, arguments);
                }, a2._randombytes_seedbytes = function() {
                  return (a2._randombytes_seedbytes = a2.asm.ic).apply(null, arguments);
                }, a2._randombytes_close = function() {
                  return (a2._randombytes_close = a2.asm.jc).apply(null, arguments);
                }, a2._randombytes = function() {
                  return (a2._randombytes = a2.asm.kc).apply(null, arguments);
                }, a2._sodium_bin2hex = function() {
                  return (a2._sodium_bin2hex = a2.asm.lc).apply(null, arguments);
                }, a2._sodium_hex2bin = function() {
                  return (a2._sodium_hex2bin = a2.asm.mc).apply(null, arguments);
                }, a2._sodium_base64_encoded_len = function() {
                  return (a2._sodium_base64_encoded_len = a2.asm.nc).apply(null, arguments);
                }, a2._sodium_bin2base64 = function() {
                  return (a2._sodium_bin2base64 = a2.asm.oc).apply(null, arguments);
                }, a2._sodium_base642bin = function() {
                  return (a2._sodium_base642bin = a2.asm.pc).apply(null, arguments);
                }, a2._sodium_init = function() {
                  return (a2._sodium_init = a2.asm.qc).apply(null, arguments);
                }, a2._sodium_pad = function() {
                  return (a2._sodium_pad = a2.asm.rc).apply(null, arguments);
                }, a2._sodium_unpad = function() {
                  return (a2._sodium_unpad = a2.asm.sc).apply(null, arguments);
                }, a2._sodium_version_string = function() {
                  return (a2._sodium_version_string = a2.asm.tc).apply(null, arguments);
                }, a2._sodium_library_version_major = function() {
                  return (a2._sodium_library_version_major = a2.asm.uc).apply(null, arguments);
                }, a2._sodium_library_version_minor = function() {
                  return (a2._sodium_library_version_minor = a2.asm.vc).apply(null, arguments);
                }, a2._sodium_library_minimal = function() {
                  return (a2._sodium_library_minimal = a2.asm.wc).apply(null, arguments);
                }, a2._malloc = function() {
                  return (a2._malloc = a2.asm.xc).apply(null, arguments);
                }, a2._free = function() {
                  return (a2._free = a2.asm.yc).apply(null, arguments);
                }, a2.setValue = function(A5, I5, g4 = "i8", B2) {
                  switch (g4.charAt(g4.length - 1) === "*" && (g4 = "i32"), g4) {
                    case "i1":
                    case "i8":
                      p2[A5 >> 0] = I5;
                      break;
                    case "i16":
                      F2[A5 >> 1] = I5;
                      break;
                    case "i32":
                      l2[A5 >> 2] = I5;
                      break;
                    case "i64":
                      K2 = [I5 >>> 0, (L2 = I5, +Math.abs(L2) >= 1 ? L2 > 0 ? (0 | Math.min(+Math.floor(L2 / 4294967296), 4294967295)) >>> 0 : ~~+Math.ceil((L2 - +(~~L2 >>> 0)) / 4294967296) >>> 0 : 0)], l2[A5 >> 2] = K2[0], l2[A5 + 4 >> 2] = K2[1];
                      break;
                    case "float":
                      _2[A5 >> 2] = I5;
                      break;
                    case "double":
                      k2[A5 >> 3] = I5;
                      break;
                    default:
                      d2("invalid type for setValue: " + g4);
                  }
                }, a2.getValue = function(A5, I5 = "i8", g4) {
                  switch (I5.charAt(I5.length - 1) === "*" && (I5 = "i32"), I5) {
                    case "i1":
                    case "i8":
                      return p2[A5 >> 0];
                    case "i16":
                      return F2[A5 >> 1];
                    case "i32":
                    case "i64":
                      return l2[A5 >> 2];
                    case "float":
                      return _2[A5 >> 2];
                    case "double":
                      return Number(k2[A5 >> 3]);
                    default:
                      d2("invalid type for getValue: " + I5);
                  }
                  return null;
                }, a2.UTF8ToString = U2, R2 = function A5() {
                  IA2 || BA(), IA2 || (R2 = A5);
                }, a2.run = BA, a2.preInit)
                  for (typeof a2.preInit == "function" && (a2.preInit = [a2.preInit]); a2.preInit.length > 0; )
                    a2.preInit.pop()();
                BA();
              });
            };
            var g2, C, Q, E, i, n, a = a !== void 0 ? a : {}, r = Object.assign({}, a), o = [], t = typeof window == "object", e = typeof importScripts == "function", f = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string", c = "";
            f ? (c = e ? (init_path(), __toCommonJS(path_exports)).dirname(c) + "/" : __dirname + "/", n = () => {
              i || (E = require_fs(), i = (init_path(), __toCommonJS(path_exports)));
            }, g2 = function(A4, I4) {
              var g3 = Z(A4);
              return g3 ? I4 ? g3 : g3.toString() : (n(), A4 = i.normalize(A4), E.readFileSync(A4, I4 ? void 0 : "utf8"));
            }, Q = (A4) => {
              var I4 = g2(A4, true);
              return I4.buffer || (I4 = new Uint8Array(I4)), I4;
            }, C = (A4, I4, g3) => {
              var B2 = Z(A4);
              B2 && I4(B2), n(), A4 = i.normalize(A4), E.readFile(A4, function(A5, B3) {
                A5 ? g3(A5) : I4(B3.buffer);
              });
            }, process.argv.length > 1 && process.argv[1].replace(/\\/g, "/"), o = process.argv.slice(2), typeof module2 != "undefined" && (module2.exports = a), a.inspect = function() {
              return "[Emscripten Module object]";
            }) : (t || e) && (e ? c = self.location.href : typeof document != "undefined" && document.currentScript && (c = document.currentScript.src), c = c.indexOf("blob:") !== 0 ? c.substr(0, c.replace(/[?#].*/, "").lastIndexOf("/") + 1) : "", g2 = (A4) => {
              try {
                var I4 = new XMLHttpRequest();
                return I4.open("GET", A4, false), I4.send(null), I4.responseText;
              } catch (I5) {
                var g3 = Z(A4);
                if (g3)
                  return function(A5) {
                    for (var I6 = [], g4 = 0; g4 < A5.length; g4++) {
                      var B2 = A5[g4];
                      B2 > 255 && (B2 &= 255), I6.push(String.fromCharCode(B2));
                    }
                    return I6.join("");
                  }(g3);
                throw I5;
              }
            }, e && (Q = (A4) => {
              try {
                var I4 = new XMLHttpRequest();
                return I4.open("GET", A4, false), I4.responseType = "arraybuffer", I4.send(null), new Uint8Array(I4.response);
              } catch (I5) {
                var g3 = Z(A4);
                if (g3)
                  return g3;
                throw I5;
              }
            }), C = (A4, I4, g3) => {
              var B2 = new XMLHttpRequest();
              B2.open("GET", A4, true), B2.responseType = "arraybuffer", B2.onload = () => {
                if (B2.status == 200 || B2.status == 0 && B2.response)
                  I4(B2.response);
                else {
                  var C2 = Z(A4);
                  C2 ? I4(C2.buffer) : g3();
                }
              }, B2.onerror = g3, B2.send(null);
            }), a.print;
            var y, s, w = a.printErr || void 0;
            Object.assign(a, r), r = null, a.arguments && (o = a.arguments), a.thisProgram && a.thisProgram, a.quit && a.quit, a.wasmBinary && (y = a.wasmBinary), a.noExitRuntime, typeof WebAssembly != "object" && N("no native wasm support detected");
            var D, h, p, u, F, l, _, k = false, H = typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : void 0;
            function G(A4, I4) {
              return A4 ? function(A5, I5, g3) {
                for (var B2 = I5 + g3, C2 = I5; A5[C2] && !(C2 >= B2); )
                  ++C2;
                if (C2 - I5 > 16 && A5.subarray && H)
                  return H.decode(A5.subarray(I5, C2));
                for (var Q2 = ""; I5 < C2; ) {
                  var E2 = A5[I5++];
                  if (128 & E2) {
                    var i2 = 63 & A5[I5++];
                    if ((224 & E2) != 192) {
                      var n2 = 63 & A5[I5++];
                      if ((E2 = (240 & E2) == 224 ? (15 & E2) << 12 | i2 << 6 | n2 : (7 & E2) << 18 | i2 << 12 | n2 << 6 | 63 & A5[I5++]) < 65536)
                        Q2 += String.fromCharCode(E2);
                      else {
                        var a2 = E2 - 65536;
                        Q2 += String.fromCharCode(55296 | a2 >> 10, 56320 | 1023 & a2);
                      }
                    } else
                      Q2 += String.fromCharCode((31 & E2) << 6 | i2);
                  } else
                    Q2 += String.fromCharCode(E2);
                }
                return Q2;
              }(p, A4, I4) : "";
            }
            function U(A4) {
              D = A4, a.HEAP8 = h = new Int8Array(A4), a.HEAP16 = u = new Int16Array(A4), a.HEAP32 = F = new Int32Array(A4), a.HEAPU8 = p = new Uint8Array(A4), a.HEAPU16 = new Uint16Array(A4), a.HEAPU32 = new Uint32Array(A4), a.HEAPF32 = l = new Float32Array(A4), a.HEAPF64 = _ = new Float64Array(A4);
            }
            a.INITIAL_MEMORY;
            var S, b = [], m = [], v = [], M = 0, P = null, Y = null;
            function N(A4) {
              throw a.onAbort && a.onAbort(A4), w(A4 = "Aborted(" + A4 + ")"), k = true, A4 += ". Build with -s ASSERTIONS=1 for more info.", new WebAssembly.RuntimeError(A4);
            }
            a.preloadedImages = {}, a.preloadedAudios = {};
            var R, d, J, x, L = "data:application/octet-stream;base64,";
            function K(A4) {
              return A4.startsWith(L);
            }
            function X(A4) {
              return A4.startsWith("file://");
            }
            function T(A4) {
              try {
                if (A4 == R && y)
                  return new Uint8Array(y);
                var I4 = Z(A4);
                if (I4)
                  return I4;
                if (Q)
                  return Q(A4);
                throw "both async and sync fetching of the wasm failed";
              } catch (A5) {
                N(A5);
              }
            }
            K(R = "data:application/octet-stream;base64,AGFzbQEAAAABvgImYAJ/fwBgAAF/YAN/f38Bf2ACf38Bf2ADf39/AGABfwBgAX8Bf2AEf39/fwF/YAt/f39/f39/f39/fwF/YAV/f39/fwF/YAZ/f39/f38Bf2AHf39/f39/fwF/YAN/f34Bf2AEf35/fwF/YAZ/f39+f38Bf2AAAGAGf39+f39/AX9gBH9/fn8Bf2AGf39+f35/AX9gDH9/f39/f39/f39/fwF/YAh/f39/f39/fwF/YAR/f39/AGADf39+AGAFf39+f38AYAh/f35/f35/fwF/YAl/f39/fn9+f38Bf2ACfn8BfmACf34AYAZ/f35/f38AYAR/fn9/AGAHf39/fn9/fwF/YAp/f39/f39/f39/AX9gAn5+AX5gAX8BfmAEf39/fgBgBX9/fn5/AX9gBX9/fn9/AX9gBX9/f35/AX8CHwUBYQFhABUBYQFiAAIBYQFjAAYBYQFkAA8BYQFlAAIDkwKRAhogAwAABBYaACECGwIEAA8EAQwFAAQMBQABBgIGBAAADAMABQAGAAAAHAEFAAEdEwwFAQwEAAAAAwUAAwIHIgMAAhUBAQEEAgcEAgUGAAQABAYWBgQVARwdAgMODg4OAgIBFAkFAAEFBQEOAhsFAAADFwMPBAUABAADBgAAABYAEQMCAAAFDxcEBBAeEB4DEQQjDQcCGBkOBgYEESQlDgIEGBgZGQAFBwMXAgIDDAMRAQQGBAcJCgoKCR8fCgsKCwcHFAsICgcHCwoJCwoUCwsKFAsJCQgICBMICAgICBMIExAJCQMCAQEFARICAQEBAQEBAQENAQMLBwIHBgMCAQEDAw0BBwEBAQIJAgAAARINAwQEAXAADgUHAQGAAoCAAgYJAX8BQbCcwgILB8MHuAEBZgIAAWcAeAFoAOUBAWkA5AEBagDjAQFrAOIBAWwA4QEBbQDgAQFuAN8BAW8A3gEBcAAWAXEAiAIBcgAyAXMAHgF0ADcBdQAoAXYAFgF3AG4BeAAyAXkAHgF6ADcBQQAoAUIA3QEBQwDcAQFEANsBAUUA2gEBRgAWAUcASgFIADIBSQAeAUoANwFLACgBTAAWAU0AFgFOANkBAU8A2AEBUAAoAVEAFgFSABYBUwAWAVQAFgFVAEoBVgAeAVcANwFYAPABAVkAkwEBWgBkAV8A1wEBJADWAQJhYQDVAQJiYQDUAQJjYQDTAQJkYQDSAQJlYQDRAQJmYQDQAQJnYQDPAQJoYQDOAQJpYQDuAQJqYQAeAmthAC8CbGEAFgJtYQAeAm5hAC8Cb2EAFgJwYQD6AQJxYQDNAQJyYQBCAnNhAMwBAnRhAEECdWEAKAJ2YQAvAndhAMsBAnhhAB4CeWEALwJ6YQBuAkFhABYCQmEAygECQ2EAKAJEYQDqAQJFYQDpAQJGYQDoAQJHYQDnAQJIYQAWAklhABYCSmEAFgJLYQAWAkxhAEkCTWEASAJOYQBIAk9hAB4CUGEAZgJRYQAyAlJhAGYCU2EAHgJUYQD4AQJVYQD3AQJWYQBJAldhAGYCWGEA9gECWWEA9QECWmEASAJfYQD0AQIkYQBrAmFiAPMBAmJiAPIBAmNiAPEBAmRiAMkBAmViAMgBAmZiAMcBAmdiAMYBAmhiAMUBAmliAF8CamIAXgJrYgAWAmxiABYCbWIAFgJuYgBKAm9iAB4CcGIANwJxYgAoAnJiAMQBAnNiAMMBAnRiAMIBAnViAMEBAnZiACgCd2IAjwICeGIAjQICeWIAbAJ6YgDAAQJBYgC/AQJCYgCMAgJDYgCLAgJEYgBKAkViABYCRmIAigICR2IAMgJIYgBJAkliAEgCSmIAawJLYgBuAkxiAB4CTWIAvgECTmIA7QECT2IAhAICUGIALwJRYgAWAlJiABYCU2IALwJUYgCDAgJVYgCCAgJWYgCBAgJXYgC9AQJYYgC8AQJZYgC7AQJaYgC6AQJfYgCAAgIkYgC5AQJhYwD/AQJiYwD+AQJjYwCGAgJkYwCFAgJlYwBbAmZjAIsBAmdjALcBAmhjAB0CaWMAtgECamMAFgJrYwC1AQJsYwC4AQJtYwD9AQJuYwD8AQJvYwD7AQJwYwBoAnFjAGcCcmMAkgICc2MAjgICdGMAiQICdWMA7AECdmMA6wECd2MAawJ4YwBJAnljAB8CemMAGAJBYwEACSABAEEBCw2HAvkB7wHmAYUBtAGzAbIBsQGwAZUClAKTAgq2nASRAggAIAAgAa2KCx4AIAAgAXwgAEIBhkL+////H4MgAUL/////D4N+fAsHACAAIAF3CwsAIABBACABEA8aCwkAIAAgATYAAAudCQInfgx/IAAgAigCBCIqrCILIAEoAhQiK0EBdKwiFH4gAjQCACIDIAE0AhgiBn58IAIoAggiLKwiDSABNAIQIgd+fCACKAIMIi2sIhAgASgCDCIuQQF0rCIVfnwgAigCECIvrCIRIAE0AggiCH58IAIoAhQiMKwiFiABKAIEIjFBAXSsIhd+fCACKAIYIjKsIiAgATQCACIJfnwgAigCHCIzQRNsrCIMIAEoAiQiNEEBdKwiGH58IAIoAiAiNUETbKwiBCABNAIgIgp+fCACKAIkIgJBE2ysIgUgASgCHCIBQQF0rCIZfnwgByALfiADICusIhp+fCANIC6sIht+fCAIIBB+fCARIDGsIhx+fCAJIBZ+fCAyQRNsrCIOIDSsIh1+fCAKIAx+fCAEIAGsIh5+fCAFIAZ+fCALIBV+IAMgB358IAggDX58IBAgF358IAkgEX58IDBBE2ysIh8gGH58IAogDn58IAwgGX58IAQgBn58IAUgFH58IiJCgICAEHwiI0Iah3wiJEKAgIAIfCIlQhmHfCISIBJCgICAEHwiE0KAgIDgD4N9PgIYIAAgCyAXfiADIAh+fCAJIA1+fCAtQRNsrCIPIBh+fCAKIC9BE2ysIhJ+fCAZIB9+fCAGIA5+fCAMIBR+fCAEIAd+fCAFIBV+fCAJIAt+IAMgHH58ICxBE2ysIiEgHX58IAogD358IBIgHn58IAYgH358IA4gGn58IAcgDH58IAQgG358IAUgCH58ICpBE2ysIBh+IAMgCX58IAogIX58IA8gGX58IAYgEn58IBQgH358IAcgDn58IAwgFX58IAQgCH58IAUgF358IiFCgICAEHwiJkIah3wiJ0KAgIAIfCIoQhmHfCIPIA9CgICAEHwiKUKAgIDgD4N9PgIIIAAgBiALfiADIB5+fCANIBp+fCAHIBB+fCARIBt+fCAIIBZ+fCAcICB+fCAJIDOsIg9+fCAEIB1+fCAFIAp+fCATQhqHfCITIBNCgICACHwiE0KAgIDwD4N9PgIcIAAgCCALfiADIBt+fCANIBx+fCAJIBB+fCASIB1+fCAKIB9+fCAOIB5+fCAGIAx+fCAEIBp+fCAFIAd+fCApQhqHfCIEIARCgICACHwiBEKAgIDwD4N9PgIMIAAgCyAZfiADIAp+fCAGIA1+fCAQIBR+fCAHIBF+fCAVIBZ+fCAIICB+fCAPIBd+fCAJIDWsIgx+fCAFIBh+fCATQhmHfCIFIAVCgICAEHwiBUKAgIDgD4N9PgIgIAAgJCAlQoCAgPAPg30gIiAjQoCAgGCDfSAEQhmHfCIEQoCAgBB8Ig5CGoh8PgIUIAAgBCAOQoCAgOAPg30+AhAgACAKIAt+IAMgHX58IA0gHn58IAYgEH58IBEgGn58IAcgFn58IBsgIH58IAggD358IAwgHH58IAkgAqx+fCAFQhqHfCIDIANCgICACHwiA0KAgIDwD4N9PgIkIAAgJyAoQoCAgPAPg30gISAmQoCAgGCDfSADQhmHQhN+fCIDQoCAgBB8IgZCGoh8PgIEIAAgAyAGQoCAgOAPg30+AgALEwAgACABIAJB0JECKAIAEQwAGgsIACAAIAGtiQvLBgIbfgd/IAAgASgCDCIdQQF0rCIHIB2sIhN+IAEoAhAiIKwiBiABKAIIIiFBAXSsIgt+fCABKAIUIh1BAXSsIgggASgCBCIiQQF0rCICfnwgASgCGCIfrCIJIAEoAgAiI0EBdKwiBX58IAEoAiAiHkETbKwiAyAerCIQfnwgASgCJCIeQSZsrCIEIAEoAhwiAUEBdKwiFH58IAIgBn4gCyATfnwgHawiESAFfnwgAyAUfnwgBCAJfnwgAiAHfiAhrCIOIA5+fCAFIAZ+fCABQSZsrCIPIAGsIhV+fCADIB9BAXSsfnwgBCAIfnwiF0KAgIAQfCIYQhqHfCIZQoCAgAh8IhpCGYd8IgogCkKAgIAQfCIMQoCAgOAPg30+AhggACAFIA5+IAIgIqwiDX58IB9BE2ysIgogCX58IAggD358IAMgIEEBdKwiFn58IAQgB358IAggCn4gBSANfnwgBiAPfnwgAyAHfnwgBCAOfnwgHUEmbKwgEX4gI6wiDSANfnwgCiAWfnwgByAPfnwgAyALfnwgAiAEfnwiCkKAgIAQfCINQhqHfCIbQoCAgAh8IhxCGYd8IhIgEkKAgIAQfCISQoCAgOAPg30+AgggACALIBF+IAYgB358IAIgCX58IAUgFX58IAQgEH58IAxCGod8IgwgDEKAgIAIfCIMQoCAgPAPg30+AhwgACAFIBN+IAIgDn58IAkgD358IAMgCH58IAQgBn58IBJCGod8IgMgA0KAgIAIfCIDQoCAgPAPg30+AgwgACAJIAt+IAYgBn58IAcgCH58IAIgFH58IAUgEH58IAQgHqwiBn58IAxCGYd8IgQgBEKAgIAQfCIEQoCAgOAPg30+AiAgACAZIBpCgICA8A+DfSAXIBhCgICAYIN9IANCGYd8IgNCgICAEHwiCEIaiHw+AhQgACADIAhCgICA4A+DfT4CECAAIAcgCX4gESAWfnwgCyAVfnwgAiAQfnwgBSAGfnwgBEIah3wiAiACQoCAgAh8IgJCgICA8A+DfT4CJCAAIBsgHEKAgIDwD4N9IAogDUKAgIBgg30gAkIZh0ITfnwiAkKAgIAQfCIFQhqIfD4CBCAAIAIgBUKAgIDgD4N9PgIACxAAIAAzAAAgADEAAkIQhoQL8gICAn8BfgJAIAJFDQAgACABOgAAIAAgAmoiA0EBayABOgAAIAJBA0kNACAAIAE6AAIgACABOgABIANBA2sgAToAACADQQJrIAE6AAAgAkEHSQ0AIAAgAToAAyADQQRrIAE6AAAgAkEJSQ0AIABBACAAa0EDcSIEaiIDIAFB/wFxQYGChAhsIgE2AgAgAyACIARrQXxxIgRqIgJBBGsgATYCACAEQQlJDQAgAyABNgIIIAMgATYCBCACQQhrIAE2AgAgAkEMayABNgIAIARBGUkNACADIAE2AhggAyABNgIUIAMgATYCECADIAE2AgwgAkEQayABNgIAIAJBFGsgATYCACACQRhrIAE2AgAgAkEcayABNgIAIAQgA0EEcUEYciIEayICQSBJDQAgAa1CgYCAgBB+IQUgAyAEaiEBA0AgASAFNwMYIAEgBTcDECABIAU3AwggASAFNwMAIAFBIGohASACQSBrIgJBH0sNAAsLIAALCQAgACABNwAAC4EEAQN/IAJBgARPBEAgACABIAIQBBogAA8LIAAgAmohAwJAIAAgAXNBA3FFBEACQCAAQQNxRQRAIAAhAgwBCyACRQRAIAAhAgwBCyAAIQIDQCACIAEtAAA6AAAgAUEBaiEBIAJBAWoiAkEDcUUNASACIANJDQALCwJAIANBfHEiBEHAAEkNACACIARBQGoiBUsNAANAIAIgASgCADYCACACIAEoAgQ2AgQgAiABKAIINgIIIAIgASgCDDYCDCACIAEoAhA2AhAgAiABKAIUNgIUIAIgASgCGDYCGCACIAEoAhw2AhwgAiABKAIgNgIgIAIgASgCJDYCJCACIAEoAig2AiggAiABKAIsNgIsIAIgASgCMDYCMCACIAEoAjQ2AjQgAiABKAI4NgI4IAIgASgCPDYCPCABQUBrIQEgAkFAayICIAVNDQALCyACIARPDQEDQCACIAEoAgA2AgAgAUEEaiEBIAJBBGoiAiAESQ0ACwwBCyADQQRJBEAgACECDAELIAAgA0EEayIESwRAIAAhAgwBCyAAIQIDQCACIAEtAAA6AAAgAiABLQABOgABIAIgAS0AAjoAAiACIAEtAAM6AAMgAUEEaiEBIAJBBGoiAiAETQ0ACwsgAiADSQRAA0AgAiABLQAAOgAAIAFBAWohASACQQFqIgIgA0cNAAsLIAAL7AEBEn8gAigCBCEDIAEoAgQhBCACKAIIIQUgASgCCCEGIAIoAgwhByABKAIMIQggAigCECEJIAEoAhAhCiACKAIUIQsgASgCFCEMIAIoAhghDSABKAIYIQ4gAigCHCEPIAEoAhwhECACKAIgIREgASgCICESIAIoAiQhEyABKAIkIRQgACACKAIAIAEoAgBqNgIAIAAgEyAUajYCJCAAIBEgEmo2AiAgACAPIBBqNgIcIAAgDSAOajYCGCAAIAsgDGo2AhQgACAJIApqNgIQIAAgByAIajYCDCAAIAUgBmo2AgggACADIARqNgIEC0ABA38gACABIAFB+ABqIgIQCiAAQShqIAFBKGoiAyABQdAAaiIEEAogAEHQAGogBCACEAogAEH4AGogASADEAoLGAEBf0GonAIoAgAiAARAIAARDwALEAMAC+wBARJ/IAIoAgQhAyABKAIEIQQgAigCCCEFIAEoAgghBiACKAIMIQcgASgCDCEIIAIoAhAhCSABKAIQIQogAigCFCELIAEoAhQhDCACKAIYIQ0gASgCGCEOIAIoAhwhDyABKAIcIRAgAigCICERIAEoAiAhEiACKAIkIRMgASgCJCEUIAAgASgCACACKAIAazYCACAAIBQgE2s2AiQgACASIBFrNgIgIAAgECAPazYCHCAAIA4gDWs2AhggACAMIAtrNgIUIAAgCiAJazYCECAAIAggB2s2AgwgACAGIAVrNgIIIAAgBCADazYCBAsEAEEgCwoAIAAgASACEDgLzAwBB38CQCAARQ0AIABBCGsiAyAAQQRrKAIAIgFBeHEiAGohBQJAIAFBAXENACABQQNxRQ0BIAMgAygCACIBayIDQaSYAigCAEkNASAAIAFqIQAgA0GomAIoAgBHBEAgAUH/AU0EQCADKAIIIgIgAUEDdiIEQQN0QbyYAmpGGiACIAMoAgwiAUYEQEGUmAJBlJgCKAIAQX4gBHdxNgIADAMLIAIgATYCDCABIAI2AggMAgsgAygCGCEGAkAgAyADKAIMIgFHBEAgAygCCCICIAE2AgwgASACNgIIDAELAkAgA0EUaiICKAIAIgQNACADQRBqIgIoAgAiBA0AQQAhAQwBCwNAIAIhByAEIgFBFGoiAigCACIEDQAgAUEQaiECIAEoAhAiBA0ACyAHQQA2AgALIAZFDQECQCADIAMoAhwiAkECdEHEmgJqIgQoAgBGBEAgBCABNgIAIAENAUGYmAJBmJgCKAIAQX4gAndxNgIADAMLIAZBEEEUIAYoAhAgA0YbaiABNgIAIAFFDQILIAEgBjYCGCADKAIQIgIEQCABIAI2AhAgAiABNgIYCyADKAIUIgJFDQEgASACNgIUIAIgATYCGAwBCyAFKAIEIgFBA3FBA0cNAEGcmAIgADYCACAFIAFBfnE2AgQgAyAAQQFyNgIEIAAgA2ogADYCAA8LIAMgBU8NACAFKAIEIgFBAXFFDQACQCABQQJxRQRAIAVBrJgCKAIARgRAQayYAiADNgIAQaCYAkGgmAIoAgAgAGoiADYCACADIABBAXI2AgQgA0GomAIoAgBHDQNBnJgCQQA2AgBBqJgCQQA2AgAPCyAFQaiYAigCAEYEQEGomAIgAzYCAEGcmAJBnJgCKAIAIABqIgA2AgAgAyAAQQFyNgIEIAAgA2ogADYCAA8LIAFBeHEgAGohAAJAIAFB/wFNBEAgBSgCCCICIAFBA3YiBEEDdEG8mAJqRhogAiAFKAIMIgFGBEBBlJgCQZSYAigCAEF+IAR3cTYCAAwCCyACIAE2AgwgASACNgIIDAELIAUoAhghBgJAIAUgBSgCDCIBRwRAIAUoAggiAkGkmAIoAgBJGiACIAE2AgwgASACNgIIDAELAkAgBUEUaiICKAIAIgQNACAFQRBqIgIoAgAiBA0AQQAhAQwBCwNAIAIhByAEIgFBFGoiAigCACIEDQAgAUEQaiECIAEoAhAiBA0ACyAHQQA2AgALIAZFDQACQCAFIAUoAhwiAkECdEHEmgJqIgQoAgBGBEAgBCABNgIAIAENAUGYmAJBmJgCKAIAQX4gAndxNgIADAILIAZBEEEUIAYoAhAgBUYbaiABNgIAIAFFDQELIAEgBjYCGCAFKAIQIgIEQCABIAI2AhAgAiABNgIYCyAFKAIUIgJFDQAgASACNgIUIAIgATYCGAsgAyAAQQFyNgIEIAAgA2ogADYCACADQaiYAigCAEcNAUGcmAIgADYCAA8LIAUgAUF+cTYCBCADIABBAXI2AgQgACADaiAANgIACyAAQf8BTQRAIABBA3YiAUEDdEG8mAJqIQACf0GUmAIoAgAiAkEBIAF0IgFxRQRAQZSYAiABIAJyNgIAIAAMAQsgACgCCAshAiAAIAM2AgggAiADNgIMIAMgADYCDCADIAI2AggPC0EfIQIgA0IANwIQIABB////B00EQCAAQQh2IgEgAUGA/j9qQRB2QQhxIgF0IgIgAkGA4B9qQRB2QQRxIgJ0IgQgBEGAgA9qQRB2QQJxIgR0QQ92IAEgAnIgBHJrIgFBAXQgACABQRVqdkEBcXJBHGohAgsgAyACNgIcIAJBAnRBxJoCaiEBAkACQAJAQZiYAigCACIEQQEgAnQiB3FFBEBBmJgCIAQgB3I2AgAgASADNgIAIAMgATYCGAwBCyAAQQBBGSACQQF2ayACQR9GG3QhAiABKAIAIQEDQCABIgQoAgRBeHEgAEYNAiACQR12IQEgAkEBdCECIAQgAUEEcWoiB0EQaigCACIBDQALIAcgAzYCECADIAQ2AhgLIAMgAzYCDCADIAM2AggMAQsgBCgCCCIAIAM2AgwgBCADNgIIIANBADYCGCADIAQ2AgwgAyAANgIIC0G0mAJBtJgCKAIAQQFrIgBBfyAAGzYCAAsLOwEBfyAAIAFBKGoiAiABEBIgAEEoaiACIAEQFSAAQdAAaiABQdAAahApIABB+ABqIAFB+ABqQfALEAoLlQEBBH8jAEEwayIFJAAgACABQShqIgMgARASIABBKGoiBCADIAEQFSAAQdAAaiIDIAAgAhAKIAQgBCACQShqEAogAEH4AGoiBiACQfgAaiABQfgAahAKIAAgAUHQAGogAkHQAGoQCiAFIAAgABASIAAgAyAEEBUgBCADIAQQEiADIAUgBhASIAYgBSAGEBUgBUEwaiQAC7kCAgN+An8jAEHABWsiBiQAAkAgAlANACAAIAApA0giBCACQgOGfCIDNwNIIABBQGsiByAHKQMAIAMgBFStfCACQj2IfDcDAEIAIQMgAkKAASAEQgOIQv8AgyIFfSIEVARAA0AgACADIAV8p2ogASADp2otAAA6AFAgA0IBfCIDIAJSDQAMAgsACwNAIAAgAyAFfKdqIAEgA6dqLQAAOgBQIANCAXwiAyAEUg0ACyAAIABB0ABqIAYgBkGABWoiBxBHIAEgBKdqIQEgAiAEfSICQv8AVgRAA0AgACABIAYgBxBHIAFBgAFqIQEgAkKAAX0iAkL/AFYNAAsLIAJQRQRAQgAhAwNAIAAgA6ciB2ogASAHai0AADoAUCADQgF8IgMgAlINAAsLIAZBwAUQCAsgBkHABWokAEEACxUAIABBATYCACAAQQRqQQBBJBAPGgsiAQF/IAEEQANAIAAgAmoQWzoAACACQQFqIgIgAUcNAAsLCwQAQRALhy4BC38jAEEQayILJAACQAJAAkACQAJAAkACQAJAAkACQAJAIABB9AFNBEBBlJgCKAIAIgRBECAAQQtqQXhxIABBC0kbIgZBA3YiAHYiAUEDcQRAIAFBf3NBAXEgAGoiAkEDdCIFQcSYAmooAgAiAUEIaiEAAkAgASgCCCIDIAVBvJgCaiIFRgRAQZSYAiAEQX4gAndxNgIADAELIAMgBTYCDCAFIAM2AggLIAEgAkEDdCICQQNyNgIEIAEgAmoiASABKAIEQQFyNgIEDAwLIAZBnJgCKAIAIghNDQEgAQRAAkBBAiAAdCICQQAgAmtyIAEgAHRxIgBBACAAa3FBAWsiACAAQQx2QRBxIgB2IgFBBXZBCHEiAiAAciABIAJ2IgBBAnZBBHEiAXIgACABdiIAQQF2QQJxIgFyIAAgAXYiAEEBdkEBcSIBciAAIAF2aiICQQN0IgNBxJgCaigCACIBKAIIIgAgA0G8mAJqIgNGBEBBlJgCIARBfiACd3EiBDYCAAwBCyAAIAM2AgwgAyAANgIICyABQQhqIQAgASAGQQNyNgIEIAEgBmoiByACQQN0IgIgBmsiA0EBcjYCBCABIAJqIAM2AgAgCARAIAhBA3YiBUEDdEG8mAJqIQFBqJgCKAIAIQICfyAEQQEgBXQiBXFFBEBBlJgCIAQgBXI2AgAgAQwBCyABKAIICyEFIAEgAjYCCCAFIAI2AgwgAiABNgIMIAIgBTYCCAtBqJgCIAc2AgBBnJgCIAM2AgAMDAtBmJgCKAIAIgpFDQEgCkEAIAprcUEBayIAIABBDHZBEHEiAHYiAUEFdkEIcSICIAByIAEgAnYiAEECdkEEcSIBciAAIAF2IgBBAXZBAnEiAXIgACABdiIAQQF2QQFxIgFyIAAgAXZqQQJ0QcSaAmooAgAiASgCBEF4cSAGayEFIAEhAgNAAkAgAigCECIARQRAIAIoAhQiAEUNAQsgACgCBEF4cSAGayICIAUgAiAFSSICGyEFIAAgASACGyEBIAAhAgwBCwsgASgCGCEJIAEgASgCDCIDRwRAIAEoAggiAEGkmAIoAgBJGiAAIAM2AgwgAyAANgIIDAsLIAFBFGoiAigCACIARQRAIAEoAhAiAEUNAyABQRBqIQILA0AgAiEHIAAiA0EUaiICKAIAIgANACADQRBqIQIgAygCECIADQALIAdBADYCAAwKC0F/IQYgAEG/f0sNACAAQQtqIgBBeHEhBkGYmAIoAgAiB0UNAEEAIAZrIQUCQAJAAkACf0EAIAZBgAJJDQAaQR8gBkH///8HSw0AGiAAQQh2IgAgAEGA/j9qQRB2QQhxIgB0IgEgAUGA4B9qQRB2QQRxIgF0IgIgAkGAgA9qQRB2QQJxIgJ0QQ92IAAgAXIgAnJrIgBBAXQgBiAAQRVqdkEBcXJBHGoLIghBAnRBxJoCaigCACICRQRAQQAhAAwBC0EAIQAgBkEAQRkgCEEBdmsgCEEfRht0IQEDQAJAIAIoAgRBeHEiCSAGayIEIAVPDQAgBCEFIAIhAyAGIAlHDQBBACEFIAIhAAwDCyAAIAIoAhQiBCAEIAIgAUEddkEEcWooAhAiAkYbIAAgBBshACABQQF0IQEgAg0ACwsgACADckUEQEEAIQNBAiAIdCIAQQAgAGtyIAdxIgBFDQMgAEEAIABrcUEBayIAIABBDHZBEHEiAHYiAUEFdkEIcSICIAByIAEgAnYiAEECdkEEcSIBciAAIAF2IgBBAXZBAnEiAXIgACABdiIAQQF2QQFxIgFyIAAgAXZqQQJ0QcSaAmooAgAhAAsgAEUNAQsDQCAAKAIEQXhxIAZrIgIgBUkhASACIAUgARshBSAAIAMgARshAyAAKAIQIgEEfyABBSAAKAIUCyIADQALCyADRQ0AIAVBnJgCKAIAIAZrTw0AIAMoAhghCCADIAMoAgwiAUcEQCADKAIIIgBBpJgCKAIASRogACABNgIMIAEgADYCCAwJCyADQRRqIgIoAgAiAEUEQCADKAIQIgBFDQMgA0EQaiECCwNAIAIhBCAAIgFBFGoiAigCACIADQAgAUEQaiECIAEoAhAiAA0ACyAEQQA2AgAMCAsgBkGcmAIoAgAiAU0EQEGomAIoAgAhAAJAIAEgBmsiAkEQTwRAQZyYAiACNgIAQaiYAiAAIAZqIgM2AgAgAyACQQFyNgIEIAAgAWogAjYCACAAIAZBA3I2AgQMAQtBqJgCQQA2AgBBnJgCQQA2AgAgACABQQNyNgIEIAAgAWoiASABKAIEQQFyNgIECyAAQQhqIQAMCgsgBkGgmAIoAgAiAUkEQEGgmAIgASAGayIBNgIAQayYAkGsmAIoAgAiACAGaiICNgIAIAIgAUEBcjYCBCAAIAZBA3I2AgQgAEEIaiEADAoLQQAhACAGQS9qIgUCf0HsmwIoAgAEQEH0mwIoAgAMAQtB+JsCQn83AgBB8JsCQoCggICAgAQ3AgBB7JsCIAtBDGpBcHFB2KrVqgVzNgIAQYCcAkEANgIAQdCbAkEANgIAQYAgCyICaiIEQQAgAmsiB3EiAiAGTQ0JQcybAigCACIDBEBBxJsCKAIAIgggAmoiCSAITSADIAlJcg0KC0HQmwItAABBBHENBAJAAkBBrJgCKAIAIgMEQEHUmwIhAANAIAMgACgCACIITwRAIAggACgCBGogA0sNAwsgACgCCCIADQALC0EAECoiAUF/Rg0FIAIhBEHwmwIoAgAiAEEBayIDIAFxBEAgAiABayABIANqQQAgAGtxaiEECyAEIAZNIARB/v///wdLcg0FQcybAigCACIABEBBxJsCKAIAIgMgBGoiByADTSAAIAdJcg0GCyAEECoiACABRw0BDAcLIAQgAWsgB3EiBEH+////B0sNBCAEECoiASAAKAIAIAAoAgRqRg0DIAEhAAsgAEF/RiAGQTBqIARNckUEQEH0mwIoAgAiASAFIARrakEAIAFrcSIBQf7///8HSwRAIAAhAQwHCyABECpBf0cEQCABIARqIQQgACEBDAcLQQAgBGsQKhoMBAsgACIBQX9HDQUMAwtBACEDDAcLQQAhAQwFCyABQX9HDQILQdCbAkHQmwIoAgBBBHI2AgALIAJB/v///wdLDQEgAhAqIgFBf0ZBABAqIgBBf0ZyIAAgAU1yDQEgACABayIEIAZBKGpNDQELQcSbAkHEmwIoAgAgBGoiADYCAEHImwIoAgAgAEkEQEHImwIgADYCAAsCQAJAAkBBrJgCKAIAIgMEQEHUmwIhAANAIAEgACgCACICIAAoAgQiBWpGDQIgACgCCCIADQALDAILQaSYAigCACIAQQAgACABTRtFBEBBpJgCIAE2AgALQQAhAEHYmwIgBDYCAEHUmwIgATYCAEG0mAJBfzYCAEG4mAJB7JsCKAIANgIAQeCbAkEANgIAA0AgAEEDdCICQcSYAmogAkG8mAJqIgM2AgAgAkHImAJqIAM2AgAgAEEBaiIAQSBHDQALQaCYAiAEQShrIgBBeCABa0EHcUEAIAFBCGpBB3EbIgJrIgM2AgBBrJgCIAEgAmoiAjYCACACIANBAXI2AgQgACABakEoNgIEQbCYAkH8mwIoAgA2AgAMAgsgAC0ADEEIcSACIANLciABIANNcg0AIAAgBCAFajYCBEGsmAIgA0F4IANrQQdxQQAgA0EIakEHcRsiAGoiATYCAEGgmAJBoJgCKAIAIARqIgIgAGsiADYCACABIABBAXI2AgQgAiADakEoNgIEQbCYAkH8mwIoAgA2AgAMAQtBpJgCKAIAIAFLBEBBpJgCIAE2AgALIAEgBGohAkHUmwIhAAJAAkACQAJAAkACQANAIAIgACgCAEcEQCAAKAIIIgANAQwCCwsgAC0ADEEIcUUNAQtB1JsCIQADQCADIAAoAgAiAk8EQCACIAAoAgRqIgUgA0sNAwsgACgCCCEADAALAAsgACABNgIAIAAgACgCBCAEajYCBCABQXggAWtBB3FBACABQQhqQQdxG2oiCCAGQQNyNgIEIAJBeCACa0EHcUEAIAJBCGpBB3EbaiIEIAYgCGoiB2shBiADIARGBEBBrJgCIAc2AgBBoJgCQaCYAigCACAGaiIANgIAIAcgAEEBcjYCBAwDCyAEQaiYAigCAEYEQEGomAIgBzYCAEGcmAJBnJgCKAIAIAZqIgA2AgAgByAAQQFyNgIEIAAgB2ogADYCAAwDCyAEKAIEIgBBA3FBAUYEQCAAQXhxIQkCQCAAQf8BTQRAIAQoAggiASAAQQN2IgJBA3RBvJgCakYaIAEgBCgCDCIARgRAQZSYAkGUmAIoAgBBfiACd3E2AgAMAgsgASAANgIMIAAgATYCCAwBCyAEKAIYIQMCQCAEIAQoAgwiAUcEQCAEKAIIIgAgATYCDCABIAA2AggMAQsCQCAEQRRqIgAoAgAiBQ0AIARBEGoiACgCACIFDQBBACEBDAELA0AgACECIAUiAUEUaiIAKAIAIgUNACABQRBqIQAgASgCECIFDQALIAJBADYCAAsgA0UNAAJAIAQgBCgCHCIAQQJ0QcSaAmoiAigCAEYEQCACIAE2AgAgAQ0BQZiYAkGYmAIoAgBBfiAAd3E2AgAMAgsgA0EQQRQgAygCECAERhtqIAE2AgAgAUUNAQsgASADNgIYIAQoAhAiAARAIAEgADYCECAAIAE2AhgLIAQoAhQiAEUNACABIAA2AhQgACABNgIYCyAGIAlqIQYgBCAJaiEECyAEIAQoAgRBfnE2AgQgByAGQQFyNgIEIAYgB2ogBjYCACAGQf8BTQRAIAZBA3YiAUEDdEG8mAJqIQACf0GUmAIoAgAiAkEBIAF0IgFxRQRAQZSYAiABIAJyNgIAIAAMAQsgACgCCAshASAAIAc2AgggASAHNgIMIAcgADYCDCAHIAE2AggMAwtBHyEAIAZB////B00EQCAGQQh2IgAgAEGA/j9qQRB2QQhxIgB0IgEgAUGA4B9qQRB2QQRxIgF0IgIgAkGAgA9qQRB2QQJxIgJ0QQ92IAAgAXIgAnJrIgBBAXQgBiAAQRVqdkEBcXJBHGohAAsgByAANgIcIAdCADcCECAAQQJ0QcSaAmohAQJAQZiYAigCACICQQEgAHQiA3FFBEBBmJgCIAIgA3I2AgAgASAHNgIAIAcgATYCGAwBCyAGQQBBGSAAQQF2ayAAQR9GG3QhACABKAIAIQEDQCABIgIoAgRBeHEgBkYNAyAAQR12IQEgAEEBdCEAIAIgAUEEcWoiAygCECIBDQALIAMgBzYCECAHIAI2AhgLIAcgBzYCDCAHIAc2AggMAgtBoJgCIARBKGsiAEF4IAFrQQdxQQAgAUEIakEHcRsiAmsiBzYCAEGsmAIgASACaiICNgIAIAIgB0EBcjYCBCAAIAFqQSg2AgRBsJgCQfybAigCADYCACADIAVBJyAFa0EHcUEAIAVBJ2tBB3EbakEvayIAIAAgA0EQakkbIgJBGzYCBCACQdybAikCADcCECACQdSbAikCADcCCEHcmwIgAkEIajYCAEHYmwIgBDYCAEHUmwIgATYCAEHgmwJBADYCACACQRhqIQADQCAAQQc2AgQgAEEIaiEBIABBBGohACABIAVJDQALIAIgA0YNAyACIAIoAgRBfnE2AgQgAyACIANrIgVBAXI2AgQgAiAFNgIAIAVB/wFNBEAgBUEDdiIBQQN0QbyYAmohAAJ/QZSYAigCACICQQEgAXQiAXFFBEBBlJgCIAEgAnI2AgAgAAwBCyAAKAIICyEBIAAgAzYCCCABIAM2AgwgAyAANgIMIAMgATYCCAwEC0EfIQAgA0IANwIQIAVB////B00EQCAFQQh2IgAgAEGA/j9qQRB2QQhxIgB0IgEgAUGA4B9qQRB2QQRxIgF0IgIgAkGAgA9qQRB2QQJxIgJ0QQ92IAAgAXIgAnJrIgBBAXQgBSAAQRVqdkEBcXJBHGohAAsgAyAANgIcIABBAnRBxJoCaiEBAkBBmJgCKAIAIgJBASAAdCIEcUUEQEGYmAIgAiAEcjYCACABIAM2AgAgAyABNgIYDAELIAVBAEEZIABBAXZrIABBH0YbdCEAIAEoAgAhAQNAIAEiAigCBEF4cSAFRg0EIABBHXYhASAAQQF0IQAgAiABQQRxaiIEKAIQIgENAAsgBCADNgIQIAMgAjYCGAsgAyADNgIMIAMgAzYCCAwDCyACKAIIIgAgBzYCDCACIAc2AgggB0EANgIYIAcgAjYCDCAHIAA2AggLIAhBCGohAAwFCyACKAIIIgAgAzYCDCACIAM2AgggA0EANgIYIAMgAjYCDCADIAA2AggLQaCYAigCACIAIAZNDQBBoJgCIAAgBmsiATYCAEGsmAJBrJgCKAIAIgAgBmoiAjYCACACIAFBAXI2AgQgACAGQQNyNgIEIABBCGohAAwDC0HglwJBMDYCAEEAIQAMAgsCQCAIRQ0AAkAgAygCHCIAQQJ0QcSaAmoiAigCACADRgRAIAIgATYCACABDQFBmJgCIAdBfiAAd3EiBzYCAAwCCyAIQRBBFCAIKAIQIANGG2ogATYCACABRQ0BCyABIAg2AhggAygCECIABEAgASAANgIQIAAgATYCGAsgAygCFCIARQ0AIAEgADYCFCAAIAE2AhgLAkAgBUEPTQRAIAMgBSAGaiIAQQNyNgIEIAAgA2oiACAAKAIEQQFyNgIEDAELIAMgBkEDcjYCBCADIAZqIgQgBUEBcjYCBCAEIAVqIAU2AgAgBUH/AU0EQCAFQQN2IgFBA3RBvJgCaiEAAn9BlJgCKAIAIgJBASABdCIBcUUEQEGUmAIgASACcjYCACAADAELIAAoAggLIQEgACAENgIIIAEgBDYCDCAEIAA2AgwgBCABNgIIDAELQR8hACAFQf///wdNBEAgBUEIdiIAIABBgP4/akEQdkEIcSIAdCIBIAFBgOAfakEQdkEEcSIBdCICIAJBgIAPakEQdkECcSICdEEPdiAAIAFyIAJyayIAQQF0IAUgAEEVanZBAXFyQRxqIQALIAQgADYCHCAEQgA3AhAgAEECdEHEmgJqIQECQAJAIAdBASAAdCICcUUEQEGYmAIgAiAHcjYCACABIAQ2AgAMAQsgBUEAQRkgAEEBdmsgAEEfRht0IQAgASgCACECA0AgAiIBKAIEQXhxIAVGDQIgAEEddiECIABBAXQhACABIAJBBHFqIgcoAhAiAg0ACyAHIAQ2AhALIAQgATYCGCAEIAQ2AgwgBCAENgIIDAELIAEoAggiACAENgIMIAEgBDYCCCAEQQA2AhggBCABNgIMIAQgADYCCAsgA0EIaiEADAELAkAgCUUNAAJAIAEoAhwiAEECdEHEmgJqIgIoAgAgAUYEQCACIAM2AgAgAw0BQZiYAiAKQX4gAHdxNgIADAILIAlBEEEUIAkoAhAgAUYbaiADNgIAIANFDQELIAMgCTYCGCABKAIQIgAEQCADIAA2AhAgACADNgIYCyABKAIUIgBFDQAgAyAANgIUIAAgAzYCGAsCQCAFQQ9NBEAgASAFIAZqIgBBA3I2AgQgACABaiIAIAAoAgRBAXI2AgQMAQsgASAGQQNyNgIEIAEgBmoiAyAFQQFyNgIEIAMgBWogBTYCACAIBEAgCEEDdiIHQQN0QbyYAmohAEGomAIoAgAhAgJ/QQEgB3QiByAEcUUEQEGUmAIgBCAHcjYCACAADAELIAAoAggLIQQgACACNgIIIAQgAjYCDCACIAA2AgwgAiAENgIIC0GomAIgAzYCAEGcmAIgBTYCAAsgAUEIaiEACyALQRBqJAAgAAtlAQN/IAJFBEBBAA8LAkAgAC0AACIDRQ0AA0ACQCABLQAAIgVFDQAgAkEBayICRSADIAVHcg0AIAFBAWohASAALQABIQMgAEEBaiEAIAMNAQwCCwsgAyEECyAEQf8BcSABLQAAawt/AQN/IAAhAQJAIABBA3EEQANAIAEtAABFDQIgAUEBaiIBQQNxDQALCwNAIAEiAkEEaiEBIAIoAgAiA0F/cyADQYGChAhrcUGAgYKEeHFFDQALIANB/wFxRQRAIAIgAGsPCwNAIAItAAEhAyACQQFqIgEhAiADDQALCyABIABrCygAIAAgASACEFUgAEEoaiABQShqIAIQVSAAQdAAaiABQdAAaiACEFULEQAgACABQdSRAigCABEDABoLEQAgACABQcyRAigCABEDABoLCgAgACABIAIQFwsRACAAIAFzQf8BcUEBa0EfdguwAQEDfyMAQcAFayICJAACQCAAKAJIQQN2Qf8AcSIDQe8ATQRAIAAgA2pB0ABqQeCPAkHwACADaxARGgwBCyAAQdAAaiIEIANqQeCPAkGAASADaxARGiAAIAQgAiACQYAFahBHIARBAEHwABAPGgsgAEHAAWogAEFAa0EQEKUBIAAgAEHQAGogAiACQYAFahBHIAEgAEHAABClASACQcAFEAggAEHQARAIIAJBwAVqJAALCAAgAEEgEB0LRgEEfiABKQIIIQIgASkCECEDIAEpAhghBCABKQIAIQUgACABKQIgNwIgIAAgBDcCGCAAIAM3AhAgACACNwIIIAAgBTcCAAtSAQJ/QbCRAigCACIBIABBA2pBfHEiAmohAAJAIAJBACAAIAFNGw0AIAA/AEEQdEsEQCAAEAJFDQELQbCRAiAANgIAIAEPC0HglwJBMDYCAEF/CwwAIAAgAUGACBARGgv6BQEKfyMAQTBrIgIkACACIAEoAiAiAyABKAIcIgQgASgCGCIFIAEoAhQiBiABKAIQIgcgASgCDCIIIAEoAggiCSABKAIEIgogASgCACILIAEoAiQiAUETbEGAgIAIakEZdmpBGnVqQRl1akEadWpBGXVqQRp1akEZdWpBGnVqQRl1akEadSABakEZdUETbCALaiILQf///x9xNgIAIAIgCiALQRp1aiIKQf///w9xNgIEIAIgCSAKQRl1aiIJQf///x9xNgIIIAIgCCAJQRp1aiIIQf///w9xNgIMIAIgByAIQRl1aiIHQf///x9xNgIQIAIgBiAHQRp1aiIGQf///w9xNgIUIAIgBSAGQRl1aiIFQf///x9xNgIYIAIgBCAFQRp1aiIEQf///w9xNgIcIAIgAyAEQRl1aiIDQf///x9xNgIgIAIgASADQRp1akH///8PcTYCJCAAIAIoAgAiAToAACAAIAFBEHY6AAIgACABQQh2OgABIAAgAigCBCIDQQ52OgAFIAAgA0EGdjoABCAAIANBAnQgAUEYdnI6AAMgACACKAIIIgFBDXY6AAggACABQQV2OgAHIAAgAUEDdCADQRZ2cjoABiAAIAIoAgwiA0ELdjoACyAAIANBA3Y6AAogACADQQV0IAFBFXZyOgAJIAAgAigCECIBQRJ2OgAPIAAgAUEKdjoADiAAIAFBAnY6AA0gACABQQZ0IANBE3ZyOgAMIAAgAigCFCIBOgAQIAAgAUEQdjoAEiAAIAFBCHY6ABEgACACKAIYIgNBD3Y6ABUgACADQQd2OgAUIAAgA0EBdCABQRh2cjoAEyAAIAIoAhwiAUENdjoAGCAAIAFBBXY6ABcgACABQQN0IANBF3ZyOgAWIAAgAigCICIDQQx2OgAbIAAgA0EEdjoAGiAAIANBBHQgAUEVdnI6ABkgACACKAIkIgFBEnY6AB8gACABQQp2OgAeIAAgAUECdjoAHSAAIAFBBnQgA0EUdnI6ABwgAkEwaiQACzEBA38DQCAAIAJBA3QiA2oiBCAEKQMAIAEgA2opAwCFNwMAIAJBAWoiAkGAAUcNAAsLKQAgBK1CgICAgBAgAkI/fEIGiH1WBEAQFAALIAAgASACIAMgBCAFEFwLBQBBwAALCwAgAEEAQSgQDxoLyQcCHH4OfyMAQTBrIiEkACAAIAEQDSAAQdAAaiIgIAFBKGoiJRANIABB+ABqIh4gASgCXCImQQF0rCIHIAEoAlQiJ0EBdKwiBH4gASgCWCIorCIOIA5+fCABKAJgIimsIgggASgCUCIqQQF0rCIFfnwgASgCbCIiQSZsrCIPICKsIhN+fCABKAJwIitBE2ysIgkgASgCaCIjQQF0rH58IAEoAnQiH0EmbKwiBiABKAJkIiRBAXSsIgt+fEIBhiIWQoCAgBB8IhdCGocgBCAIfiAoQQF0rCIMICasIhR+fCAkrCIRIAV+fCAJICJBAXSsIhB+fCAGICOsIgp+fEIBhnwiGEKAgIAIfCIZQhmHIAcgFH4gCCAMfnwgBCALfnwgBSAKfnwgCSArrCISfnwgBiAQfnxCAYZ8IgIgAkKAgIAQfCINQoCAgOAPg30+AhggHiAkQSZsrCARfiAqrCICIAJ+fCAjQRNsrCIDIClBAXSsIhV+fCAHIA9+fCAJIAx+fCAEIAZ+fEIBhiIaQoCAgBB8IhtCGocgAyALfiAFICesIgJ+fCAIIA9+fCAHIAl+fCAGIA5+fEIBhnwiHEKAgIAIfCIdQhmHIAUgDn4gAiAEfnwgAyAKfnwgCyAPfnwgCSAVfnwgBiAHfnxCAYZ8IgIgAkKAgIAQfCIDQoCAgOAPg30+AgggHiAMIBF+IAcgCH58IAQgCn58IAUgE358IAYgEn58QgGGIA1CGod8IgIgAkKAgIAIfCINQoCAgPAPg30+AhwgHiAFIBR+IAQgDn58IAogD358IAkgC358IAYgCH58QgGGIANCGod8IgIgAkKAgIAIfCIDQoCAgPAPg30+AgwgHiAKIAx+IAggCH58IAcgC358IAQgEH58IAUgEn58IAYgH6wiEH58QgGGIA1CGYd8IgIgAkKAgIAQfCINQoCAgOAPg30+AiAgHiAYIBlCgICA8A+DfSAWIBdCgICAYIN9IANCGYd8IgNCgICAEHwiAkIaiHw+AhQgHiADIAJCgICA4A+DfT4CECAeIAcgCn4gESAVfnwgDCATfnwgBCASfnwgBSAQfnxCAYYgDUIah3wiAiACQoCAgAh8IgJCgICA8A+DfT4CJCAeIBwgHUKAgIDwD4N9IBogG0KAgIBgg30gAkIZh0ITfnwiA0KAgIAQfCICQhqIfD4CBCAeIAMgAkKAgIDgD4N9PgIAIABBKGoiHyABICUQEiAhIB8QDSAfICAgABASICAgICAAEBUgACAhIB8QFSAeIB4gIBAVICFBMGokAAsEAEEACxsAIAFCgICAgBBaBEAQFAALIAAgASACIAMQXQviJQIQfgt/IwBBQGoiHCQAAkAgCBAfIiJFBEBBaiECDAELIBxCADcDICAcQgA3AxggHCAGNgIUIBwgBTYCECAcIAQ2AgwgHCADNgIIIBwgCDYCBCAcICI2AgAgHEEANgI4IBwgAjYCNCAcIAI2AjAgHCABNgIsIBwgADYCKCMAQTBrIgIkAAJAIBwQWCIADQBBZiEAIAtBA2tBfkkNACAcKAIsIQEgHCgCMCEAIAJBADYCACAcKAIoIQMgAiAANgIcIAJBfzYCDCACIAM2AgggAiABIABBA3QiAyABIANLGyAAQQJ0IgFuIgA2AhQgAiAAQQJ0NgIYIAIgACABbDYCECAcKAI0IQAgAiALNgIkIAIgADYCICMAQdAAayIEJABBZyEDAkAgAkUgHEVyDQAgAiACKAIUQQN0EB8iADYCBCAARQRAQWohAwwBCyACKAIQIQAjAEEQayIGJABBaiEDAkAgAkUgAEVyDQAgAEEKdCIFIABuQYAIRw0AIAJBDBAfIgA2AgAgAEUNACAAQgA3AgBB4JcCIAVBgH9LBH9BMAUCfyAFQYB/TwRAQeCXAkEwNgIAQQAMAQtBAEEQIAVBC2pBeHEgBUELSRsiIEHMAGoQHyIARQ0AGiAAQQhrIQECQCAAQT9xRQRAIAEhAAwBCyAAQQRrIiMoAgAiHUF4cSAAQT9qQUBxQQhrIgBBAEHAACAAIAFrQQ9LG2oiACABayIeayEfIB1BA3FFBEAgASgCACEBIAAgHzYCBCAAIAEgHmo2AgAMAQsgACAfIAAoAgRBAXFyQQJyNgIEIAAgH2oiHyAfKAIEQQFyNgIEICMgHiAjKAIAQQFxckECcjYCACABIB5qIh8gHygCBEEBcjYCBCABIB4QfQsCQCAAKAIEIgFBA3FFDQAgAUF4cSIeICBBEGpNDQAgACAgIAFBAXFyQQJyNgIEIAAgIGoiASAeICBrIiBBA3I2AgQgACAeaiIeIB4oAgRBAXI2AgQgASAgEH0LIABBCGoLIgAEfyAGIAA2AgxBAAVBMAsLIgA2AgACQAJAIAAEQCAGQQA2AgwMAQsgBigCDCIADQELIAIoAgAQGCACQQA2AgAMAQsgAigCACAANgIAIAIoAgAgADYCBCACKAIAIAU2AghBACEDCyAGQRBqJAAgAwRAIAIgHCgCOBCJAQwBCyACKAIkIQUjACIAIQYgAEHAA2tBQHEiACQAIARFIBxFckUEQCAAQUBrIgNBAEEAQcAAEE0aIABBPGoiASAcKAIwEAkgAyABQgQQFxogASAcKAIEEAkgAyABQgQQFxogASAcKAIsEAkgAyABQgQQFxogASAcKAIoEAkgAyABQgQQFxogAUETEAkgAyABQgQQFxogASAFEAkgAEFAayAAQTxqQgQQFxogASAcKAIMEAkgAEFAayAAQTxqQgQQFxoCQCAcKAIIIgFFDQAgAEFAayABIBw1AgwQFxogHC0AOEEBcUUNACAcKAIIIBwoAgwQCCAcQQA2AgwLIABBPGoiASAcKAIUEAkgAEFAayABQgQQFxogHCgCECIBBEAgAEFAayABIBw1AhQQFxoLIABBPGoiASAcKAIcEAkgAEFAayABQgQQFxoCQCAcKAIYIgFFDQAgAEFAayABIBw1AhwQFxogHC0AOEECcUUNACAcKAIYIBwoAhwQCCAcQQA2AhwLIABBPGoiASAcKAIkEAkgAEFAayABQgQQFxogHCgCICIBBEAgAEFAayABIBw1AiQQFxoLIABBQGsgBEHAABBMGgsgBiQAIARBQGtBCBAIQQAhAyMAQYAIayIAJAAgAigCHARAIARBxABqIQUgBEFAayEBA0AgAUEAEAkgBSADEAkgAEGACCAEQcgAEFogAigCACgCBCACKAIYIANsQQp0aiAAEIgBIAFBARAJIABBgAggBEHIABBaIAIoAgAoAgQgAigCGCADbEEKdGpBgAhqIAAQiAEgA0EBaiIDIAIoAhxJDQALCyAAQYAIEAggAEGACGokACAEQcgAEAhBACEDCyAEQdAAaiQAIAMiAA0AIAIoAggEQANAQQAhICMAQSBrIgMkAAJAIAJFDQAgAigCHEUNACADICU2AhBBASEBA0AgAyAgOgAYQQAhHkEAIQAgAQRAA0AgA0EANgIcIAMgAykDGDcDCCADIB42AhQgAyADKQMQNwMAQQAhAQJAIAJFDQACfwJAIAIoAiRBAkcEQCACKAIEIR8MAQsgAigCBCEfQQEgAygCACIFIAMtAAgiBEEBS3INARoLIwBBgCBrIgAkACAAQYAYahA+IABBgBBqED4CQCACRSADRXINACAAIAM1AgA3A4AQIAAgAzUCBDcDiBAgACADMQAINwOQECAAIAI1AhA3A5gQIAAgAjUCCDcDoBAgACACNQIkNwOoECACKAIURQ0AA0AgAUH/AHEiBEUEQCAAIAApA7AQQgF8NwOwECAAED4gAEGACGoiBRA+IABBgBhqIgYgAEGAEGogABBZIAYgACAFEFkLIB8gAUEDdGogAEGACGogBEEDdGopAwA3AwAgAUEBaiIBIAIoAhRJDQALCyAAQYAgaiQAIAMtAAghBCADKAIAIQVBAAshJkEAIARB/wFxIgFFQQF0IAUbIgUgAigCFCIETw0AQX8gAigCGCIAQQFrIAUgACADKAIEbGogASAEbGoiBCAAcBsgBGohAQNAIARBAWsgASAEIABwQQFGGyEjIAIoAhwhHQJ/ICZFBEAgAigCACEBIB8gBUEDdGoMAQsgAigCACIBKAIEICNBCnRqCykDACEQIAMgBTYCDCABKAIEIgYgACAQQiCIpyAdcK0iDCAMIAM1AgQiDCADLQAIGyADKAIAIiEbIg2nbEEKdGoCfyAQpyEkIAwgDVEhAAJ+IAMoAgBFBEAgAy0ACCIBRQRAIAMoAgxBAWshAEIADAILIAIoAhQgAWwhASADKAIMIR0gAARAIAEgHWpBAWshAEIADAILIAEgHUVrIQBCAAwBCyACKAIUIQEgAigCGCEdAn8gAARAIAMoAgwgHSABQX9zamoMAQsgHSABayADKAIMRWsLIQBCACADLQAIIh1BA0YNABogASAdQQFqbK0LIRAgECAAQQFrrXwgAK0gJK0iECAQfkIgiH5CIIh9IAI1AhiCp0EKdAtqIQAgBiAjQQp0aiEBIAYgBEEKdGohHQJAICEEQCABIAAgHRBZDAELIwBBgBBrIgYkACAGQYAIaiIhIAAQKyAhIAEQLSAGICEQK0EAISFBACEAA0AgBkGACGogAEEHdGoiAUFAayIkKQMAIAEpA2AgASkDACABKQMgIhAQBiIMhUEgEAUiDRAGIg4gEIVBGBAFIRAgECAOIA0gDCAQEAYiD4VBEBAFIhIQBiIZhUE/EAUhECABKQNIIAEpA2ggASkDCCABKQMoIgwQBiINhUEgEAUiDhAGIhMgDIVBGBAFIQwgDCATIA4gDSAMEAYiE4VBEBAFIhoQBiIbhUE/EAUhDCABKQNQIAEpA3AgASkDECABKQMwIg0QBiIOhUEgEAUiFBAGIhUgDYVBGBAFIQ0gDSAVIBQgDiANEAYiFYVBEBAFIhQQBiIWhUE/EAUhDSABKQNYIAEpA3ggASkDGCABKQM4Ig4QBiIXhUEgEAUiERAGIhggDoVBGBAFIQ4gDiAYIBEgFyAOEAYiF4VBEBAFIhEQBiIYhUE/EAUhDiABIA8gDBAGIg8gDCAWIA8gEYVBIBAFIg8QBiIWhUEYEAUiDBAGIhE3AwAgASAPIBGFQRAQBSIPNwN4IAEgFiAPEAYiDzcDUCABIAwgD4VBPxAFNwMoIAEgEyANEAYiDCANIBggDCAShUEgEAUiDBAGIg+FQRgQBSINEAYiEjcDCCABIAwgEoVBEBAFIgw3A2AgASAPIAwQBiIMNwNYIAEgDCANhUE/EAU3AzAgASAVIA4QBiIMIA4gGSAMIBqFQSAQBSIMEAYiDYVBGBAFIg4QBiIPNwMQIAEgDCAPhUEQEAUiDDcDaCAkIA0gDBAGIgw3AwAgASAMIA6FQT8QBTcDOCABIBcgEBAGIgwgECAbIAwgFIVBIBAFIgwQBiINhUEYEAUiEBAGIg43AxggASAMIA6FQRAQBSIMNwNwIAEgDSAMEAYiDDcDSCABIAwgEIVBPxAFNwMgIABBAWoiAEEIRw0ACwNAIAZBgAhqICFBBHRqIgApA4AEIAApA4AGIAApAwAgACkDgAIiEBAGIgyFQSAQBSINEAYiDiAQhUEYEAUhECAQIA4gDSAMIBAQBiIPhUEQEAUiEhAGIhmFQT8QBSEQIAApA4gEIAApA4gGIAApAwggACkDiAIiDBAGIg2FQSAQBSIOEAYiEyAMhUEYEAUhDCAMIBMgDiANIAwQBiIThUEQEAUiGhAGIhuFQT8QBSEMIAApA4AFIAApA4AHIAApA4ABIAApA4ADIg0QBiIOhUEgEAUiFBAGIhUgDYVBGBAFIQ0gDSAVIBQgDiANEAYiFYVBEBAFIhQQBiIWhUE/EAUhDSAAKQOIBSAAKQOIByAAKQOIASAAKQOIAyIOEAYiF4VBIBAFIhEQBiIYIA6FQRgQBSEOIA4gGCARIBcgDhAGIheFQRAQBSIREAYiGIVBPxAFIQ4gACAPIAwQBiIPIAwgFiAPIBGFQSAQBSIPEAYiFoVBGBAFIgwQBiIRNwMAIAAgDyARhUEQEAUiDzcDiAcgACAWIA8QBiIPNwOABSAAIAwgD4VBPxAFNwOIAiAAIBMgDRAGIgwgDSAYIAwgEoVBIBAFIgwQBiIPhUEYEAUiDRAGIhI3AwggACAMIBKFQRAQBSIMNwOABiAAIA8gDBAGIgw3A4gFIAAgDCANhUE/EAU3A4ADIAAgFSAOEAYiDCAOIBkgDCAahUEgEAUiDBAGIg2FQRgQBSIOEAYiDzcDgAEgACAMIA+FQRAQBSIMNwOIBiAAIA0gDBAGIgw3A4AEIAAgDCAOhUE/EAU3A4gDIAAgFyAQEAYiDCAQIBsgDCAUhUEgEAUiDBAGIg2FQRgQBSIQEAYiDjcDiAEgACAMIA6FQRAQBSIMNwOAByAAIA0gDBAGIgw3A4gEIAAgDCAQhUE/EAU3A4ACICFBAWoiIUEIRw0ACyAdIAYQKyAdIAZBgAhqEC0gBkGAEGokAAsgBUEBaiIFIAIoAhRPDQEgBEEBaiEEICNBAWohASACKAIYIQAMAAsACyAeQQFqIh4gAigCHCIASQ0ACwsgACEBICBBAWoiIEEERw0ACwsgA0EgaiQAICVBAWoiJSACKAIISQ0ACwtBACEDIwBBgBBrIgEkACAcRSACRXJFBEAgAUGACGogAigCACgCBCACKAIYQQp0akGACGsQKyACKAIcQQJPBEBBASEAA0AgAUGACGogAigCACgCBCACKAIYIgQgACAEbGpBCnRqQYAIaxAtIABBAWoiACACKAIcSQ0ACwsgAUGACGohAANAIAEgA0EDdCIEaiAAIARqKQMAEBAgA0EBaiIDQYABRw0ACyAcKAIAIBwoAgQgAUGACBBaIABBgAgQCCABQYAIEAggAiAcKAI4EIkBCyABQYAQaiQAQQAhAAsgAkEwaiQAAkAgACICBEAgIiAIEAgMAQsCQCAJRSAKRXINACMAQRBrIgAkAEFhIQECQAJAAn8CQAJAIAtBAWsOAgEABAsgCkENSQ0CIAlBvwopAAA3AAAgCUHECikAADcABUEMIQJBdAwBCyAKQQxJDQEgCUGzCikAADcAACAJQbsKKAAANgAIQQshAkF1CyEDIBwQWCIBDQEgAEEFaiIBQRMQPyADIApqIgMgARAhIgFNDQAgAiAJaiAAQQVqIAFBAWoQESECIAMgAWsiA0EESQ0AIAEgAmoiAkGk2vUBNgAAIABBBWoiASAcKAIsED8gA0EDayIDIAEQISIBTQ0AIAJBA2ogAEEFaiABQQFqEBEhAiADIAFrIgNBBEkNACABIAJqIgJBrOj1ATYAACAAQQVqIgEgHCgCKBA/IANBA2siAyABECEiAU0NACACQQNqIABBBWogAUEBahARIQIgAyABayIDQQRJDQAgASACaiICQazg9QE2AAAgAEEFaiIBIBwoAjAQPyADQQNrIgMgARAhIgFNDQAgAkEDaiAAQQVqIAFBAWoQESECIAMgAWsiA0ECSQ0AIAEgAmoiAUEkOwAAIAFBAWoiAiADQQFrIgMgHCgCECAcKAIUQQMQaEUNAEFhIQEgAyACECEiA2siBEECSQ0BIAIgA2oiAUEkOwAAQQBBYSABQQFqIARBAWsgHCgCACAcKAIEQQMQaBshAQwBC0FhIQELIABBEGokACABRQ0AICIgCBAIIAkgChAIQWEhAgwBCyAHBEAgByAiIAgQERoLICIgCBAIQQAhAgsgIhAYCyAcQUBrJAAgAgsrAQF/IwBB0AFrIgMkACADEDYgAyABIAIQGxogAyAAECcgA0HQAWokAEEACxwAIABCADcDQCAAQgA3A0ggAEGgigJBwAAQERoLBABBbwvBAQIFfwF+IAJQRQRAIAJBgAIgACgA4AIiBGsiA60iCFYEQCAAQeABaiEGIABB4ABqIQUDQCAAIARqQeAAaiABIAMQERogACAAKADgAiADajYA4AIgAEKAARBxIAAgBRB0IAUgBkGAARARGiAAIAAoAOACIgdBgAFrIgQ2AOACIAEgA2ohASACIAh9IgJBgAMgB2siA60iCFYNAAsLIAAgBGpB4ABqIAEgAqciARARGiAAIAAoAOACIAFqNgDgAgtBAAupAwEVfyABKAIEIQsgACgCBCEMIAEoAgghDSAAKAIIIQ4gASgCDCEPIAAoAgwhAyABKAIQIRAgACgCECEEIAEoAhQhESAAKAIUIQUgASgCGCESIAAoAhghBiABKAIcIRMgACgCHCEHIAEoAiAhFCAAKAIgIQggASgCJCEVIAAoAiQhCSAAQQAgAmsiAiABKAIAIhYgACgCACIKc3EiFyAKczYCACAAIAkgCSAVcyACcSIKczYCJCAAIAggCCAUcyACcSIJczYCICAAIAcgByATcyACcSIIczYCHCAAIAYgBiAScyACcSIHczYCGCAAIAUgBSARcyACcSIGczYCFCAAIAQgBCAQcyACcSIFczYCECAAIAMgAyAPcyACcSIEczYCDCAAIA4gDSAOcyACcSIDczYCCCAAIAwgCyAMcyACcSIAczYCBCABIAogFXM2AiQgASAJIBRzNgIgIAEgCCATczYCHCABIAcgEnM2AhggASAGIBFzNgIUIAEgBSAQczYCECABIAQgD3M2AgwgASADIA1zNgIIIAEgACALczYCBCABIBYgF3M2AgALQQECfyMAQYABayIDJAAgA0EIaiICIAEQKSACQShqIAFBKGoQKSACQdAAaiABQdAAahApIAAgAhAxIANBgAFqJAALMgEBfyAAIAEgAUH4AGoiAhAKIABBKGogAUEoaiABQdAAaiIBEAogAEHQAGogASACEAoL4AMBA38jAEHAAWsiAiQAIAJBkAFqIgQgARANIAJB4ABqIgMgBBANIAMgAxANIAMgASADEAogBCAEIAMQCiACQTBqIgEgBBANIAMgAyABEAogASADEA1BASEBA0AgAkEwaiIDIAMQDSABQQFqIgFBBUcNAAsgAkHgAGoiASACQTBqIgMgARAKIAMgARANQQEhAQNAIAJBMGoiAyADEA0gAUEBaiIBQQpHDQALIAJBMGoiASABIAJB4ABqEAogAiABEA1BASEBA0AgAiACEA0gAUEBaiIBQRRHDQALIAJBMGoiASACIAEQCkEBIQEDQCACQTBqIgMgAxANIAFBAWoiAUELRw0ACyACQeAAaiIBIAJBMGoiAyABEAogAyABEA1BASEBA0AgAkEwaiIDIAMQDSABQQFqIgFBMkcNAAsgAkEwaiIBIAEgAkHgAGoQCiACIAEQDUEBIQEDQCACIAIQDSABQQFqIgFB5ABHDQALIAJBMGoiASACIAEQCkEBIQEDQCACQTBqIgMgAxANIAFBAWoiAUEzRw0ACyACQeAAaiIBIAJBMGogARAKQQEhAQNAIAJB4ABqIgMgAxANIAFBAWoiAUEGRw0ACyAAIAJB4ABqIAJBkAFqEAogAkHAAWokAAsLACAAIAFBEBCHAQsMACAAQQBBgAgQDxoLZgEFfyMAQRBrIgMkAEEKIQIDQAJAIAIiBEEBayICIANBBmpqIgUgASABQQpuIgZBCmxrQTByOgAAIAFBCkkNACAGIQEgAg0BCwsgACAFQQsgBGsiABARIABqQQA6AAAgA0EQaiQAC40BAQZ/AkAgAC0AACIGQTprQf8BcUH2AUkNACAGIQMgACECA0AgAiEHIARBmbPmzAFLDQEgA0H/AXFBMGsiAiAEQQpsIgNBf3NLDQEgAiADaiEEIAdBAWoiAi0AACIDQTprQf8BcUH1AUsNAAsgBkEwRiAAIAdHcSAAIAJGcg0AIAEgBDYCACACIQULIAULCgAgACABIAIQTAsMACAAIAEgAiADEE0L0gkBMX8jAEFAaiIcJAAgACgCPCEdIAAoAjghHiAAKAI0IRMgACgCMCEQIAAoAiwhHyAAKAIoISAgACgCJCEhIAAoAiAhIiAAKAIcISMgACgCGCEkIAAoAhQhJSAAKAIQISYgACgCDCEnIAAoAgghKCAAKAIEISkgACgCACEqA0ACQCADQj9WBEAgAiEEDAELQQAhBSAcQQBBwAAQDyEEIANQRQRAA0AgBCAFaiABIAVqLQAAOgAAIAMgBUEBaiIFrVYNAAsLIAQhASACISsLQRQhFSAqIQ0gKSEUICghESAnIQ4gJiEFICUhCSAkIQIgIyEPICIhCyAhIQogICEYIB0hEiAeIQcgEyEIIBAhBiAfIQwDQCAFIAsgBSANaiINIAZzQRAQByIFaiIGc0EMEAchCyALIAUgCyANaiINc0EIEAciGSAGaiIac0EHEAchFiAKIAkgFGoiCyAIc0EQEAciCGoiBiAJc0EMEAchCiAKIAggCiALaiIUc0EIEAciCyAGaiIbc0EHEAchCSACIAcgAiARaiIHc0EQEAciCCAYaiIGc0EMEAchAiACIAggAiAHaiIKc0EIEAciBSAGaiIHc0EHEAchFyAMIA4gD2oiBiASc0EQEAciAmoiDCAPc0EMEAchEiASIAwgAiAGIBJqIg5zQQgQByICaiIIc0EHEAchESAJIAIgCSANaiIGc0EQEAciDCAHaiICc0EMEAchByAHIAwgBiAHaiINc0EIEAciEiACaiIYc0EHEAchCSAXIBkgFCAXaiIGc0EQEAciDCAIaiICc0EMEAchCCAIIAwgBiAIaiIUc0EIEAciBiACaiIMc0EHEAchAiARIAsgCiARaiIKc0EQEAciCCAaaiIHc0EMEAchDyAPIAcgCCAKIA9qIhFzQQgQByIIaiILc0EHEAchDyAWIAUgDiAWaiIOc0EQEAciByAbaiIKc0EMEAchBSAFIAogByAFIA5qIg5zQQgQByIHaiIKc0EHEAchBSAVQQJrIhUNAAsgASgABCEsIAEoAAghLSABKAAMIS4gASgAECEvIAEoABQhMCABKAAYITEgASgAHCEyIAEoACAhMyABKAAkITQgASgAKCEVIAEoACwhFiABKAAwIRcgASgANCEZIAEoADghGiABKAA8IRsgBCABKAAAIA0gKmpzEAkgBEEEaiAsIBQgKWpzEAkgBEEIaiAtIBEgKGpzEAkgBEEMaiAuIA4gJ2pzEAkgBEEQaiAvIAUgJmpzEAkgBEEUaiAwIAkgJWpzEAkgBEEYaiAxIAIgJGpzEAkgBEEcaiAyIA8gI2pzEAkgBEEgaiAzIAsgImpzEAkgBEEkaiA0IAogIWpzEAkgBEEoaiAVIBggIGpzEAkgBEEsaiAWIAwgH2pzEAkgBEEwaiAXIAYgEGpzEAkgBEE0aiAZIAggE2pzEAkgBEE4aiAaIAcgHmpzEAkgBEE8aiAbIBIgHWpzEAkgEyAQIBBBAWoiEEtqIRMgA0LAAFgEQAJAIANCP1YNACADpyIBRQ0AQQAhCQNAIAkgK2ogBCAJai0AADoAACAJQQFqIgkgAUcNAAsLIAAgEzYCNCAAIBA2AjAgHEFAayQABSABQUBrIQEgBEFAayECIANCQHwhAwwBCwsL7wEBAn8CfwJAIAFB/wFxIgMEQCAAQQNxBEADQCAALQAAIgJFIAIgAUH/AXFGcg0DIABBAWoiAEEDcQ0ACwsCQCAAKAIAIgJBf3MgAkGBgoQIa3FBgIGChHhxDQAgA0GBgoQIbCEDA0AgAiADcyICQX9zIAJBgYKECGtxQYCBgoR4cQ0BIAAoAgQhAiAAQQRqIQAgAkGBgoQIayACQX9zcUGAgYKEeHFFDQALCwNAIAAiAi0AACIDBEAgAkEBaiEAIAMgAUH/AXFHDQELCyACDAILIAAQISAAagwBCyAACyIAQQAgAC0AACABQf8BcUYbC3EAIABC5fDBi+aNmZAzNwIAIABCstqIy8eumZDrADcCCCAAIAEoAAA2AhAgACABKAAENgIUIAAgASgACDYCGCAAIAEoAAw2AhwgACABKAAQNgIgIAAgASgAFDYCJCAAIAEoABg2AiggACABKAAcNgIsC+gCAQJ/AkAgACABRg0AIAEgACACaiIEa0EAIAJBAXRrTQRAIAAgASACEBEPCyAAIAFzQQNxIQMCQAJAIAAgAUkEQCADBEAgACEDDAMLIABBA3FFBEAgACEDDAILIAAhAwNAIAJFDQQgAyABLQAAOgAAIAFBAWohASACQQFrIQIgA0EBaiIDQQNxDQALDAELAkAgAw0AIARBA3EEQANAIAJFDQUgACACQQFrIgJqIgMgASACai0AADoAACADQQNxDQALCyACQQNNDQADQCAAIAJBBGsiAmogASACaigCADYCACACQQNLDQALCyACRQ0CA0AgACACQQFrIgJqIAEgAmotAAA6AAAgAg0ACwwCCyACQQNNDQADQCADIAEoAgA2AgAgAUEEaiEBIANBBGohAyACQQRrIgJBA0sNAAsLIAJFDQADQCADIAEtAAA6AAAgA0EBaiEDIAFBAWohASACQQFrIgINAAsLIAALiRgCEH4SfwNAIAIgFUEDdCIUaiABIBRqKQAAIgRCOIYgBEIohkKAgICAgIDA/wCDhCAEQhiGQoCAgICA4D+DIARCCIZCgICAgPAfg4SEIARCCIhCgICA+A+DIARCGIhCgID8B4OEIARCKIhCgP4DgyAEQjiIhISENwMAIBVBAWoiFUEQRw0ACyADIABBwAAQESEBA0AgASACIBZBA3QiA2oiFSkDACABKQMgIgpBDhAFIApBEhAFhSAKQSkQBYV8IANB4IoCaikDAHwgCiABKQMwIgcgASkDKCILhYMgB4V8IAEpAzh8IgQgASkDGHwiCDcDGCABIAEpAwAiBUEcEAUgBUEiEAWFIAVBJxAFhSAEfCABKQMQIgkgASkDCCIGhCAFgyAGIAmDhHwiBDcDOCABIAkgByALIAggCiALhYOFfCAIQQ4QBSAIQRIQBYUgCEEpEAWFfCACIANBCHIiFGoiGCkDAHwgFEHgigJqKQMAfCIHfCIJNwMQIAEgByAEIAUgBoSDIAUgBoOEfCAEQRwQBSAEQSIQBYUgBEEnEAWFfCIHNwMwIAEgBiALIAogCSAIIAqFg4V8IAlBDhAFIAlBEhAFhSAJQSkQBYV8IAIgA0EQciIUaiIZKQMAfCAUQeCKAmopAwB8Igx8Igs3AwggASAMIAcgBCAFhIMgBCAFg4R8IAdBHBAFIAdBIhAFhSAHQScQBYV8IgY3AyggASAFIAogCyAIIAmFgyAIhXwgC0EOEAUgC0ESEAWFIAtBKRAFhXwgAiADQRhyIhRqIhopAwB8IBRB4IoCaikDAHwiDHwiCjcDACABIAwgBiAEIAeEgyAEIAeDhHwgBkEcEAUgBkEiEAWFIAZBJxAFhXwiBTcDICABIAQgCiAJIAuFgyAJhSAIfCAKQQ4QBSAKQRIQBYUgCkEpEAWFfCACIANBIHIiFGoiGykDAHwgFEHgigJqKQMAfCIMfCIINwM4IAEgDCAFIAYgB4SDIAYgB4OEfCAFQRwQBSAFQSIQBYUgBUEnEAWFfCIENwMYIAEgByAIIAogC4WDIAuFIAl8IAhBDhAFIAhBEhAFhSAIQSkQBYV8IAIgA0EociIUaiIcKQMAfCAUQeCKAmopAwB8Igx8Igk3AzAgASAMIAQgBSAGhIMgBSAGg4R8IARBHBAFIARBIhAFhSAEQScQBYV8Igc3AxAgASAGIAkgCCAKhYMgCoUgC3wgCUEOEAUgCUESEAWFIAlBKRAFhXwgAiADQTByIhRqIh0pAwB8IBRB4IoCaikDAHwiDHwiCzcDKCABIAwgByAEIAWEgyAEIAWDhHwgB0EcEAUgB0EiEAWFIAdBJxAFhXwiBjcDCCABIAUgCyAIIAmFgyAIhSAKfCALQQ4QBSALQRIQBYUgC0EpEAWFfCACIANBOHIiFGoiHikDAHwgFEHgigJqKQMAfCIMfCIKNwMgIAEgDCAGIAQgB4SDIAQgB4OEfCAGQRwQBSAGQSIQBYUgBkEnEAWFfCIFNwMAIAEgBCAKIAkgC4WDIAmFIAh8IApBDhAFIApBEhAFhSAKQSkQBYV8IAIgA0HAAHIiFGoiHykDAHwgFEHgigJqKQMAfCIMfCIINwMYIAEgDCAFIAYgB4SDIAYgB4OEfCAFQRwQBSAFQSIQBYUgBUEnEAWFfCIENwM4IAEgByAIIAogC4WDIAuFIAl8IAhBDhAFIAhBEhAFhSAIQSkQBYV8IAIgA0HIAHIiFGoiICkDAHwgFEHgigJqKQMAfCIMfCIJNwMQIAEgDCAEIAUgBoSDIAUgBoOEfCAEQRwQBSAEQSIQBYUgBEEnEAWFfCIHNwMwIAEgBiAJIAggCoWDIAqFIAt8IAlBDhAFIAlBEhAFhSAJQSkQBYV8IAIgA0HQAHIiFGoiISkDAHwgFEHgigJqKQMAfCIMfCILNwMIIAEgDCAHIAQgBYSDIAQgBYOEfCAHQRwQBSAHQSIQBYUgB0EnEAWFfCIGNwMoIAEgBSALIAggCYWDIAiFIAp8IAtBDhAFIAtBEhAFhSALQSkQBYV8IAIgA0HYAHIiFGoiIikDAHwgFEHgigJqKQMAfCIMfCIKNwMAIAEgDCAGIAQgB4SDIAQgB4OEfCAGQRwQBSAGQSIQBYUgBkEnEAWFfCIFNwMgIAEgBCAKIAkgC4WDIAmFIAh8IApBDhAFIApBEhAFhSAKQSkQBYV8IAIgA0HgAHIiFGoiIykDAHwgFEHgigJqKQMAfCIMfCIINwM4IAEgDCAFIAYgB4SDIAYgB4OEfCAFQRwQBSAFQSIQBYUgBUEnEAWFfCIENwMYIAEgByAIIAogC4WDIAuFIAl8IAhBDhAFIAhBEhAFhSAIQSkQBYV8IAIgA0HoAHIiFGoiJCkDAHwgFEHgigJqKQMAfCIMfCIJNwMwIAEgDCAEIAUgBoSDIAUgBoOEfCAEQRwQBSAEQSIQBYUgBEEnEAWFfCIHNwMQIAEgCSAIIAqFgyAKhSALfCAJQQ4QBSAJQRIQBYUgCUEpEAWFfCACIANB8AByIhRqIiUpAwB8IBRB4IoCaikDAHwiCyAGfCIGNwMoIAEgCyAHIAQgBYSDIAQgBYOEfCAHQRwQBSAHQSIQBYUgB0EnEAWFfCILNwMIIAEgBiAIIAmFgyAIhSAKfCAGQQ4QBSAGQRIQBYUgBkEpEAWFfCACIANB+AByIgNqIhQpAwB8IANB4IoCaikDAHwiBiAFfDcDICABIAYgCyAEIAeEgyAEIAeDhHwgC0EcEAUgC0EiEAWFIAtBJxAFhXw3AwAgFkHAAEYEQANAIAAgF0EDdCICaiIDIAMpAwAgASACaikDAHw3AwAgF0EBaiIXQQhHDQALBSACIBZBEGoiFkEDdGogJSkDACIEQgaIIARBExAFhSAEQT0QBYUgICkDACIFfCAVKQMAfCAYKQMAIgZCB4ggBkEBEAWFIAZBCBAFhXwiBzcDACAVIAYgISkDACIIfCAUKQMAIgZCBoggBkETEAWFIAZBPRAFhXwgGSkDACIKQgeIIApBARAFhSAKQQgQBYV8Igk3A4gBIBUgCiAiKQMAIgt8IAdBExAFIAdCBoiFIAdBPRAFhXwgGikDACINQgeIIA1BARAFhSANQQgQBYV8Igo3A5ABIBUgDSAjKQMAIgx8IAlBExAFIAlCBoiFIAlBPRAFhXwgGykDACIOQgeIIA5BARAFhSAOQQgQBYV8Ig03A5gBIBUgDiAkKQMAIhJ8IApBExAFIApCBoiFIApBPRAFhXwgHCkDACIPQgeIIA9BARAFhSAPQQgQBYV8Ig43A6ABIBUgBCAPfCANQRMQBSANQgaIhSANQT0QBYV8IB0pAwAiEEIHiCAQQQEQBYUgEEEIEAWFfCIPNwOoASAVIAYgEHwgDkETEAUgDkIGiIUgDkE9EAWFfCAeKQMAIhFCB4ggEUEBEAWFIBFBCBAFhXwiEDcDsAEgFSAHIBF8IA9BExAFIA9CBoiFIA9BPRAFhXwgHykDACITQgeIIBNBARAFhSATQQgQBYV8IhE3A7gBIBUgCSATfCAQQRMQBSAQQgaIhSAQQT0QBYV8IAVBARAFIAVCB4iFIAVBCBAFhXwiCTcDwAEgFSAFIAp8IBFBExAFIBFCBoiFIBFBPRAFhXwgCEEBEAUgCEIHiIUgCEEIEAWFfCIFNwPIASAVIAggDXwgCUETEAUgCUIGiIUgCUE9EAWFfCALQQEQBSALQgeIhSALQQgQBYV8Igg3A9ABIBUgCyAOfCAFQRMQBSAFQgaIhSAFQT0QBYV8IAxBARAFIAxCB4iFIAxBCBAFhXwiBTcD2AEgFSAMIA98IAhBExAFIAhCBoiFIAhBPRAFhXwgEkEBEAUgEkIHiIUgEkEIEAWFfCIINwPgASAVIBAgEnwgBUETEAUgBUIGiIUgBUE9EAWFfCAEQQEQBSAEQgeIhSAEQQgQBYV8IgU3A+gBIBUgBCARfCAIQRMQBSAIQgaIhSAIQT0QBYV8IAZBARAFIAZCB4iFIAZBCBAFhXw3A/ABIBUgBiAJfCAFQRMQBSAFQgaIhSAFQT0QBYV8IAdBARAFIAdCB4iFIAdBCBAFhXw3A/gBDAELCwsEAEECCwQAQQELBABBGAusBQESf0Gy2ojLByEDQe7IgZkDIQxB5fDBiwYhDUH0yoHZBiEEIAIoAAAhBiACKAAEIQcgAigACCEFIAIoAAwhCCACKAAQIQogAigAFCELIAIoABghDyACKAAcIREgASgAACECIAEoAAQhDiABKAAIIQkgASgADCEBA0AgBiAKIAIgBiANaiINc0EQEAciEGoiCnNBDBAHIQIgAiAKIBAgAiANaiINc0EIEAciEGoiCnNBBxAHIQYgByAOIAcgDGoiDHNBEBAHIg4gC2oiC3NBDBAHIQIgAiAOIAIgDGoiDHNBCBAHIg4gC2oiC3NBBxAHIQIgBSAJIAMgBWoiB3NBEBAHIgkgD2oiD3NBDBAHIQMgAyAJIAMgB2oiEnNBCBAHIgkgD2oiB3NBBxAHIQMgCCABIAQgCGoiBHNBEBAHIgUgEWoiD3NBDBAHIQEgASAFIAEgBGoiE3NBCBAHIgUgD2oiCHNBBxAHIQQgAiAHIAUgAiANaiIBc0EQEAciBWoiB3NBDBAHIQIgAiAHIAUgASACaiINc0EIEAciAWoiD3NBBxAHIQcgAyAIIBAgAyAMaiICc0EQEAciBWoiCHNBDBAHIQMgAyAIIAUgAiADaiIMc0EIEAciAmoiEXNBBxAHIQUgBCAOIAQgEmoiA3NBEBAHIgggCmoiCnNBDBAHIQQgBCAKIAggAyAEaiIDc0EIEAciDmoiCnNBBxAHIQggBiAJIAYgE2oiBHNBEBAHIgkgC2oiC3NBDBAHIQYgBiAJIAQgBmoiBHNBCBAHIgkgC2oiC3NBBxAHIQYgFEEBaiIUQQpHDQALIAAgDRAJIABBBGogDBAJIABBCGogAxAJIABBDGogBBAJIABBEGogAhAJIABBFGogDhAJIABBGGogCRAJIABBHGogARAJCzEAIAJBgAJPBEBBACIAQf8JaiAAQbYJakHrACAAQasIahAAAAsgACABIAJB/wFxEHALVgEBf0F/IQQCQCADQcEAa0FASSACQcAAS3INAAJAIAFBACACG0UEQCAAIANB/wFxEK0BRQ0BDAILIAAgA0H/AXEgASACQf8BcRCsAQ0BC0EAIQQLIAQLmAYBIX8gAigABCESIAIoAAghEyACKAAMIRQgAigAECEVIAIoABQhFiACKAAYIRcgAigAHCEYQeXwwYsGIQwgAigAACIaIQIgEiEGIBMhESAUIQdB7siBmQMhDSABKAAAIhshCCABKAAEIhwhCSABKAAIIh0hCiABKAAMIh4hDkGy2ojLByEPIBUhAUH0yoHZBiEFIBghCyAXIQMgFiEEA0AgBCAMakEHEAcgB3MiByAMakEJEAcgCnMiCiAHakENEAcgBHMiHyAKakESEAchICACIA1qQQcQByAOcyIEIA1qQQkQByADcyIQIARqQQ0QByACcyICIBBqQRIQByEOIAggD2pBBxAHIAtzIgsgD2pBCRAHIAZzIgYgC2pBDRAHIAhzIgggBmpBEhAHISEgASAFakEHEAcgEXMiAyAFakEJEAcgCXMiCSADakENEAcgAXMiIiAJakESEAchIyADIAwgIHMiAWpBBxAHIAJzIgIgAWpBCRAHIAZzIgYgAmpBDRAHIANzIhEgBmpBEhAHIAFzIQwgDSAOcyIBIAdqQQcQByAIcyIIIAFqQQkQByAJcyIJIAhqQQ0QByAHcyIHIAlqQRIQByABcyENIA8gIXMiAyAEakEHEAcgInMiASADakEJEAcgCnMiCiABakENEAcgBHMiDiAKakESEAcgA3MhDyAFICNzIgUgC2pBBxAHIB9zIgQgBWpBCRAHIBBzIgMgBGpBDRAHIAtzIgsgA2pBEhAHIAVzIQUgGUESSSEQIBlBAmohGSAQDQALIAAgDEHl8MGLBmoQCSAAQQRqIAIgGmoQCSAAQQhqIAYgEmoQCSAAQQxqIBEgE2oQCSAAQRBqIAcgFGoQCSAAQRRqIA1B7siBmQNqEAkgAEEYaiAIIBtqEAkgAEEcaiAJIBxqEAkgAEEgaiAKIB1qEAkgAEEkaiAOIB5qEAkgAEEoaiAPQbLaiMsHahAJIABBLGogASAVahAJIABBMGogBCAWahAJIABBNGogAyAXahAJIABBOGogCyAYahAJIABBPGogBUH0yoHZBmoQCQtpAQF/IwBBEGsiAyAANgIMIAMgATYCCEEAIQEgA0EAOgAHIAIEQANAIAMgAy0AByADKAIIIAFqLQAAIAMoAgwgAWotAABzcjoAByABQQFqIgEgAkcNAAsLIAMtAAdBAWtBCHZBAXFBAWsLlRIBHn4gABAOIRAgADUAAiERIABBBWoQDiESIAA1AAchGSAANQAKIRogAEENahAOIRsgADUADyELIABBEmoQDiEKIABBFWoQDiEIIAA1ABchBSAAQRpqEA4hASAANQAcIRwgADUAHyETIABBImoQDiEUIAA1ACQhDCAAQSdqEA4hDyAAQSpqEA4hCSAANQAsIQYgACAAQS9qEA5CAohC////AIMiAkLRqwh+IAFCAohC////AIN8IAA1ADFCB4hC////AIMiAULTjEN+fCAANQA0QgSIQv///wCDIgNC5/YnfnwgAEE3ahAOQgGIQv///wCDIgRCmNocfnwgADUAOUIGiEL///8AgyIHQpPYKH58IhUgBkIFiEL///8AgyAANQA8QgOIIgZCg6FWfiAJQv///wCDfCINQoCAQH0iDkIVh3wiCUKDoVZ+fCACQtOMQ34gBUIFiEL///8Ag3wgAULn9id+fCADQpjaHH58IARCk9gofnwgAkLn9id+IAhC////AIN8IAFCmNocfnwgA0KT2Ch+fCIFQoCAQH0iFkIViHwiCEKAgEB9IhdCFYd8IBVCgIBAfSIVQoCAgH+DfSIYIBhCgIBAfSIYQoCAgH+DfSAJQtGrCH4gCHwgF0KAgIB/g30gDSAOQoCAgH+DfSAGQtGrCH4gD0IDiEL///8Ag3wgB0KDoVZ+fCAEQoOhVn4gDEIGiEL///8Ag3wgBkLTjEN+fCAHQtGrCH58IgxCgIBAfSIPQhWHfCINQoCAQH0iDkIVh3wiCEKDoVZ+fCAFIAJCmNocfiAKQgOIQv///wCDfCABQpPYKH58IAJCk9gofiALQgaIQv///wCDfCIXQoCAQH0iHUIViHwiCkKAgEB9Ih5CFYh8IBZCgICA////B4N9IAlC04xDfnwgCELRqwh+fCANIA5CgICAf4N9IgtCg6FWfnwiBUKAgEB9Ig1CFYd8Ig5CgIBAfSIWQhWHfCAOIBZCgICAf4N9IAUgDUKAgIB/g30gCiAeQoCAgP///weDfSAJQuf2J358IAhC04xDfnwgC0LRqwh+fCAMIA9CgICAf4N9IANCg6FWfiAUQgGIQv///wCDfCAEQtGrCH58IAZC5/YnfnwgB0LTjEN+fCABQoOhVn4gE0IEiEL///8Ag3wgA0LRqwh+fCAEQtOMQ358IAZCmNocfnwgB0Ln9id+fCITQoCAQH0iFEIVh3wiBUKAgEB9IgxCFYd8IgpCg6FWfnwgFyAdQoCAgP///wGDfSAJQpjaHH58IAhC5/YnfnwgC0LTjEN+fCAKQtGrCH58IAUgDEKAgIB/g30iBUKDoVZ+fCIMQoCAQH0iD0IVh3wiDUKAgEB9Ig5CFYd8IA0gDkKAgIB/g30gDCAPQoCAgH+DfSAJQpPYKH4gG0IBiEL///8Ag3wgCEKY2hx+fCALQuf2J358IApC04xDfnwgBULRqwh+fCATIBRCgICAf4N9IAJCg6FWfiAcQgeIQv///wCDfCABQtGrCH58IANC04xDfnwgBELn9id+fCAGQpPYKH58IAdCmNocfnwgFUIVh3wiAUKAgEB9IgNCFYd8IgJCg6FWfnwgCEKT2Ch+IBpCBIhC////AIN8IAtCmNocfnwgCkLn9id+fCAFQtOMQ358IAJC0asIfnwiBEKAgEB9IgdCFYd8IgZCgIBAfSIJQhWHfCAGIAEgA0KAgIB/g30gGEIVh3wiA0KAgEB9IghCFYciAUKDoVZ+fCAJQoCAgH+DfSABQtGrCH4gBHwgB0KAgIB/g30gC0KT2Ch+IBlCB4hC////AIN8IApCmNocfnwgBULn9id+fCACQtOMQ358IApCk9gofiASQgKIQv///wCDfCAFQpjaHH58IAJC5/YnfnwiBEKAgEB9IgdCFYd8IgZCgIBAfSIJQhWHfCAGIAFC04xDfnwgCUKAgIB/g30gAULn9id+IAR8IAdCgICAf4N9IAVCk9gofiARQgWIQv///wCDfCACQpjaHH58IAJCk9gofiAQQv///wCDfCICQoCAQH0iBEIVh3wiB0KAgEB9IgZCFYd8IAFCmNocfiAHfCAGQoCAgH+DfSACIARCgICAf4N9IAFCk9gofnwiAUIVh3wiBEIVh3wiB0IVh3wiBkIVh3wiCUIVh3wiC0IVh3wiCkIVh3wiBUIVh3wiEEIVh3wiEUIVh3wiEkIVhyADIAhCgICAf4N9fCIIQhWHIgJCk9gofiABQv///wCDfCIBPAAAIAAgAUIIiDwAASAAIAJCmNocfiAEQv///wCDfCABQhWHfCIDQguIPAAEIAAgA0IDiDwAAyAAIAJC5/YnfiAHQv///wCDfCADQhWHfCIEQgaIPAAGIAAgAUIQiEIfgyADQv///wCDIgNCBYaEPAACIAAgAkLTjEN+IAZC////AIN8IARCFYd8IgFCCYg8AAkgACABQgGIPAAIIAAgBEL///8AgyIEQgKGIANCE4iEPAAFIAAgAkLRqwh+IAlC////AIN8IAFCFYd8IgNCDIg8AAwgACADQgSIPAALIAAgAUL///8AgyIHQgeGIARCDoiEPAAHIAAgAkKDoVZ+IAtC////AIN8IANCFYd8IgFCB4g8AA4gACADQv///wCDIgNCBIYgB0IRiIQ8AAogACAKQv///wCDIAFCFYd8IgJCCog8ABEgACACQgKIPAAQIAAgAUL///8AgyIEQgGGIANCFIiEPAANIAAgBUL///8AgyACQhWHfCIBQg2IPAAUIAAgAUIFiDwAEyAAIAJC////AIMiA0IGhiAEQg+IhDwADyAAIBBC////AIMgAUIVh3wiAjwAFSAAIAFCA4YgA0ISiIQ8ABIgACACQgiIPAAWIAAgEUL///8AgyACQhWHfCIBQguIPAAZIAAgAUIDiDwAGCAAIBJC////AIMgAUIVh3wiA0IGiDwAGyAAIAJCEIhCH4MgAUL///8AgyIBQgWGhDwAFyAAIAhC////AIMgA0IVh3wiAkIRiDwAHyAAIAJCCYg8AB4gACACQgGIPAAdIAAgA0L///8AgyIDQgKGIAFCE4iEPAAaIAAgAkIHhiADQg6IhDwAHAvaAQEFfyMAQRBrIgNBADYACyADQQA2AggDQCAAIAJqLQAAIQRBACEBA0AgA0EIaiABaiIFIAUtAAAgAUEFdEHgE2ogAmotAAAgBHNyOgAAIAFBAWoiAUEHRw0ACyACQQFqIgJBH0cNAAsgAC0AH0H/AHEhAkEAIQBBACEBA0AgA0EIaiABaiIEIAQtAAAgAiABQQV0Qf8Tai0AAHNyOgAAIAFBAWoiAUEHRw0AC0EAIQEDQCADQQhqIABqLQAAQQFrIAFyIQEgAEEBaiIAQQdHDQALIAFBCHZBAXEL5wIBBX8jAEHQA2siAyQAA0AgA0GQA2ogAkEBdGoiBSABIAJqLQAAIgZBBHY6AAEgBSAGQQ9xOgAAIAJBAWoiAkEgRw0AC0EAIQIDQCADQZADaiAEaiIBIAEtAAAgAmoiASABQRh0QYCAgEBrIgFBGHVB8AFxazoAACABQRx1IQIgBEEBaiIEQT9HDQALIAMgAy0AzwMgAmo6AM8DIAAQekEBIQIDQCADIAJBAXYgA0GQA2ogAmosAAAQeSADQfABaiIBIAAgAxBTIAAgARATIAJBPkkhASACQQJqIQIgAQ0ACyADQfABaiIBIAAQOiADQfgAaiICIAEQOyABIAIQMSACIAEQOyABIAIQMSACIAEQOyABIAIQMSAAIAEQE0EAIQIDQCADIAJBAXYgA0GQA2ogAmosAAAQeSADQfABaiIBIAAgAxBTIAAgARATIAJBPkkhASACQQJqIQIgAQ0ACyADQdADaiQAC4sBAQR/IwBBMGsiBSQAIAAgAUEoaiIDIAEQEiAAQShqIgQgAyABEBUgAEHQAGoiAyAAIAIQCiAEIAQgAkEoahAKIABB+ABqIgYgAkHQAGogAUH4AGoQCiAFIAFB0ABqIgEgARASIAAgAyAEEBUgBCADIAQQEiADIAUgBhASIAYgBSAGEBUgBUEwaiQAC1YBA38jAEGQAWsiAiQAIAJB4ABqIgMgAUHQAGoQPCACQTBqIgQgASADEAogAiABQShqIAMQCiAAIAIQLCAAIAQQf0EHdCAALQAfczoAHyACQZABaiQAC68CARN/IAEoAgQhDCAAKAIEIQMgASgCCCENIAAoAgghBCABKAIMIQ4gACgCDCEFIAEoAhAhDyAAKAIQIQYgASgCFCEQIAAoAhQhByABKAIYIREgACgCGCEIIAEoAhwhEiAAKAIcIQkgASgCICETIAAoAiAhCiABKAIkIRQgACgCJCELIABBACACayICIAAoAgAiFSABKAIAc3EgFXM2AgAgACALIAsgFHMgAnFzNgIkIAAgCiAKIBNzIAJxczYCICAAIAkgCSAScyACcXM2AhwgACAIIAggEXMgAnFzNgIYIAAgByAHIBBzIAJxczYCFCAAIAYgBiAPcyACcXM2AhAgACAFIAUgDnMgAnFzNgIMIAAgBCAEIA1zIAJxczYCCCAAIAMgAyAMcyACcXM2AgQLJAEBfyMAQSBrIgEkACABIAAQLCABQSAQdSEAIAFBIGokACAAC6YEAg5+Cn8gACgCJCESIAAoAiAhEyAAKAIcIRQgACgCGCEVIAAoAhQhESACQhBaBEAgAC0AUEVBGHQhFiAAKAIEIhdBBWytIQ8gACgCCCIYQQVsrSENIAAoAgwiGUEFbK0hCyAAKAIQIhpBBWytIQkgGq0hECAZrSEOIBitIQwgF60hCiAANQIAIQgDQCABKAADQQJ2Qf///x9xIBVqrSIDIA5+IAEoAABB////H3EgEWqtIgQgEH58IAEoAAZBBHZB////H3EgFGqtIgUgDH58IAEoAAlBBnYgE2qtIgYgCn58IBIgFmogASgADEEIdmqtIgcgCH58IAMgDH4gBCAOfnwgBSAKfnwgBiAIfnwgByAJfnwgAyAKfiAEIAx+fCAFIAh+fCAGIAl+fCAHIAt+fCADIAh+IAQgCn58IAUgCX58IAYgC358IAcgDX58IAMgCX4gBCAIfnwgBSALfnwgBiANfnwgByAPfnwiA0IaiEL/////D4N8IgRCGohC/////w+DfCIFQhqIQv////8Pg3wiBkIaiEL/////D4N8IgdCGoinQQVsIAOnQf///x9xaiIRQRp2IASnQf///x9xaiEVIAWnQf///x9xIRQgBqdB////H3EhEyAHp0H///8fcSESIBFB////H3EhESABQRBqIQEgAkIQfSICQg9WDQALCyAAIBE2AhQgACASNgIkIAAgEzYCICAAIBQ2AhwgACAVNgIYC+8BAQJ/IABFBEBBZw8LIAAoAgBFBEBBfw8LAn9BfiAAKAIEQRBJDQAaIAAoAghFBEBBbiAAKAIMDQEaCyAAKAIUIQEgACgCEEUEQEFtQXogARsPC0F6IAFBCEkNABogACgCGEUEQEFsIAAoAhwNARoLIAAoAiBFBEBBayAAKAIkDQEaCyAAKAIwIgFFBEBBcA8LQW8gAUH///8HSw0AGkFyIAAoAiwiAkEISQ0AGkFxIAJBgICAAUsNABpBciACIAFBA3RJDQAaIAAoAihFBEBBdA8LIAAoAjQiAEUEQEFkDwtBY0EAIABB////B0sbCwvICwIQfgN/IwBBgBBrIhMkACATQYAIaiIUIAEQKyAUIAAQLSATIBQQKyATIAIQLUEAIQFBACEUA0AgE0GACGogFEEHdGoiAEFAayIVKQMAIAApA2AgACkDACAAKQMgIgcQBiIDhUEgEAUiBBAGIgUgB4VBGBAFIQcgByAFIAQgAyAHEAYiBoVBEBAFIgkQBiIQhUE/EAUhByAAKQNIIAApA2ggACkDCCAAKQMoIgMQBiIEhUEgEAUiBRAGIgogA4VBGBAFIQMgAyAKIAUgBCADEAYiCoVBEBAFIhEQBiIShUE/EAUhAyAAKQNQIAApA3AgACkDECAAKQMwIgQQBiIFhUEgEAUiCxAGIgwgBIVBGBAFIQQgBCAMIAsgBSAEEAYiDIVBEBAFIgsQBiINhUE/EAUhBCAAKQNYIAApA3ggACkDGCAAKQM4IgUQBiIOhUEgEAUiCBAGIg8gBYVBGBAFIQUgBSAPIAggDiAFEAYiDoVBEBAFIggQBiIPhUE/EAUhBSAAIAYgAxAGIgYgAyANIAYgCIVBIBAFIgYQBiINhUEYEAUiAxAGIgg3AwAgACAGIAiFQRAQBSIGNwN4IAAgDSAGEAYiBjcDUCAAIAMgBoVBPxAFNwMoIAAgCiAEEAYiAyAEIA8gAyAJhUEgEAUiAxAGIgaFQRgQBSIEEAYiCTcDCCAAIAMgCYVBEBAFIgM3A2AgACAGIAMQBiIDNwNYIAAgAyAEhUE/EAU3AzAgACAMIAUQBiIDIAUgECADIBGFQSAQBSIDEAYiBIVBGBAFIgUQBiIGNwMQIAAgAyAGhUEQEAUiAzcDaCAVIAQgAxAGIgM3AwAgACADIAWFQT8QBTcDOCAAIA4gBxAGIgMgByASIAMgC4VBIBAFIgMQBiIEhUEYEAUiBxAGIgU3AxggACADIAWFQRAQBSIDNwNwIAAgBCADEAYiAzcDSCAAIAMgB4VBPxAFNwMgIBRBAWoiFEEIRw0ACwNAIBNBgAhqIAFBBHRqIgBBgARqKQMAIAApA4AGIAApAwAgACkDgAIiBxAGIgOFQSAQBSIEEAYiBSAHhUEYEAUhByAHIAUgBCADIAcQBiIGhUEQEAUiCRAGIhCFQT8QBSEHIAApA4gEIAApA4gGIAApAwggACkDiAIiAxAGIgSFQSAQBSIFEAYiCiADhUEYEAUhAyADIAogBSAEIAMQBiIKhUEQEAUiERAGIhKFQT8QBSEDIAApA4AFIAApA4AHIAApA4ABIAApA4ADIgQQBiIFhUEgEAUiCxAGIgwgBIVBGBAFIQQgBCAMIAsgBSAEEAYiDIVBEBAFIgsQBiINhUE/EAUhBCAAKQOIBSAAKQOIByAAKQOIASAAKQOIAyIFEAYiDoVBIBAFIggQBiIPIAWFQRgQBSEFIAUgDyAIIA4gBRAGIg6FQRAQBSIIEAYiD4VBPxAFIQUgACAGIAMQBiIGIAMgDSAGIAiFQSAQBSIGEAYiDYVBGBAFIgMQBiIINwMAIAAgBiAIhUEQEAUiBjcDiAcgACANIAYQBiIGNwOABSAAIAMgBoVBPxAFNwOIAiAAIAogBBAGIgMgBCAPIAMgCYVBIBAFIgMQBiIGhUEYEAUiBBAGIgk3AwggACADIAmFQRAQBSIDNwOABiAAIAYgAxAGIgM3A4gFIAAgAyAEhUE/EAU3A4ADIAAgDCAFEAYiAyAFIBAgAyARhUEgEAUiAxAGIgSFQRgQBSIFEAYiBjcDgAEgACADIAaFQRAQBSIDNwOIBiAAIAQgAxAGIgM3A4AEIAAgAyAFhUE/EAU3A4gDIAAgDiAHEAYiAyAHIBIgAyALhUEgEAUiAxAGIgSFQRgQBSIHEAYiBTcDiAEgACADIAWFQRAQBSIDNwOAByAAIAQgAxAGIgM3A4gEIAAgAyAHhUE/EAU3A4ACIAFBAWoiAUEIRw0ACyACIBMQKyACIBNBgAhqEC0gE0GAEGokAAu+AwECfyMAIgQhBSAEQcAEa0FAcSIEJAAgBEEANgK8ASAEQbwBaiABEAkCQCABQcAATQRAIARBwAFqQQBBACABEE1BAEgNASAEQcABaiAEQbwBakIEEBdBAEgNASAEQcABaiACIAOtEBdBAEgNASAEQcABaiAAIAEQTBoMAQsgBEHAAWpBAEEAQcAAEE1BAEgNACAEQcABaiAEQbwBakIEEBdBAEgNACAEQcABaiACIAOtEBdBAEgNACAEQcABaiAEQfAAakHAABBMQQBIDQAgACAEKQNwNwAAIAAgBCkDeDcACCAAIAQpA4gBNwAYIAAgBCkDgAE3ABAgAEEgaiEAIAFBIGsiAUHBAE8EQANAIARBMGoiAiAEQfAAaiIDQcAAEBEaIANBwAAgAkLAAEEAQQAQb0EASA0CIAAgBCkDcDcAACAAIAQpA3g3AAggACAEKQOIATcAGCAAIAQpA4ABNwAQIABBIGohACABQSBrIgFBwABLDQALCyAEQTBqIgIgBEHwAGoiA0HAABARGiADIAEgAkLAAEEAQQAQb0EASA0AIAAgBEHwAGogARARGgsgBEHAAWpBgAMQCCAFJAALLAECfyMAQRBrIgAkACAAQQA6AA9B6JECIABBD2pBABABIQEgAEEQaiQAIAELKAAgAkKAgICAEFoEQBAUAAsgACABIAIgAyAEIAVBwJECKAIAERAAGgskACABQoCAgIAQWgRAEBQACyAAIAEgAiADQbiRAigCABENABoLCwAgACABIAIQrwELCAAgACABEHcLEAAgACABIAIgAyAEIAUQYgsQACAAIAEgAiADIAQgBRBjC5YCAgJ/AX4jAEHgAGsiBiQAIAYgBCAFEGUaIAZBIGoiB0IgIARBEGoiBSAGQeCRAigCABENABpBfyEEAkACQCACIAEgAyAHQciRAigCABERAA0AQQAhBCAARQ0BIAAgAUkgASAAa60gA1RxRSAAIAFNIAAgAWutIANacnFFBEAgACABIAOnEEYhAQsCQCADQiAgA0IgVBsiCFAEQCAGQSBqIgIgAiAIQiB8IAUgBhB2DAELIAZBQGsgASAIpyICEBEhBCAGQSBqIgcgByAIQiB8IAUgBhB2IAAgBCACEBEaC0EAIQQgA0IhVA0AIAAgCKciAmogASACaiADIAh9IAUgBhCuAQsgBkEgEAgLIAZB4ABqJAAgBAuQAgICfwF+IwBB4AJrIgYkACAGIAQgBRBlGiAAIAJLIAAgAmutIANUcUUgACACTyACIABrrSADWnJxRQRAIAAgAiADpxBGIQILIAZCADcDOCAGQgA3AzAgBkIANwMoIAZCADcDICADQiAgA0IgVBsiCFAiBUUEQCAGQUBrIAIgCKcQERoLIAZBIGoiByAHIAhCIHwgBEEQaiIEIAYQdiAGQeAAaiAHECQgBUUEQCAAIAZBQGsgCKcQERoLIAZBIGpBwAAQCCADQiFaBEAgACAIpyIFaiACIAVqIAMgCH0gBCAGEK4BCyAGQSAQCCAGQeAAaiICIAAgAxALIAIgARAjIAJBgAIQCCAGQeACaiQAQQALMwECfyMAQSBrIgMkAEF/IQQgAyACIAEQrwFFBEAgAEGgkQIgAxBlIQQLIANBIGokACAEC/AEARV/QbLaiMsHIQNB7siBmQMhBEHl8MGLBiEFQfTKgdkGIQZBFCEPIAIoAAAhCiACKAAEIRAgAigACCESIAIoAAwhCyACKAAQIQwgAigAFCEHIAIoABghDSACKAAcIQ4gASgAACECIAEoAAQhCCABKAAIIQkgASgADCEBA0AgBSAHakEHEAcgC3MiCyAFakEJEAcgCXMiCSALakENEAcgB3MiESAJakESEAchEyAEIApqQQcQByABcyIBIARqQQkQByANcyINIAFqQQ0QByAKcyIKIA1qQRIQByEUIAIgA2pBBxAHIA5zIg4gA2pBCRAHIBBzIgcgDmpBDRAHIAJzIhUgB2pBEhAHIRYgBiAMakEHEAcgEnMiAiAGakEJEAcgCHMiCCACakENEAcgDHMiDCAIakESEAchFyACIAUgE3MiBWpBBxAHIApzIgogBWpBCRAHIAdzIhAgCmpBDRAHIAJzIhIgEGpBEhAHIAVzIQUgBCAUcyIEIAtqQQcQByAVcyICIARqQQkQByAIcyIIIAJqQQ0QByALcyILIAhqQRIQByAEcyEEIAMgFnMiAyABakEHEAcgDHMiDCADakEJEAcgCXMiCSAMakENEAcgAXMiASAJakESEAcgA3MhAyAGIBdzIgYgDmpBBxAHIBFzIgcgBmpBCRAHIA1zIg0gB2pBDRAHIA5zIg4gDWpBEhAHIAZzIQYgD0ECSyERIA9BAmshDyARDQALIAAgBRAJIABBBGogBBAJIABBCGogAxAJIABBDGogBhAJIABBEGogAhAJIABBFGogCBAJIABBGGogCRAJIABBHGogARAJQQALBABBfwuNBwEKfyMAQRBrIgwkACAHEGkCQAJAIANFDQAgB0EEcSEQA0AgCiEJA0AgAiAJaiwAACEIAkACfyAQBEBBACAIQQRqIAhB0P8DakEIdkF/c3FBOSAIa0EIdkF/c3FB/wFxIAhBwQBrIgsgC0EIdkF/c3FB2gAgCGtBCHZBf3NxQf8BcSAIQbkBaiAIQZ//A2pBCHZBf3NxQfoAIAhrQQh2QX9zcUH/AXEgCEGg/wBzQQFqQQh2QX9zQT9xIAhB0v8Ac0EBakEIdkF/c0E+cXJycnIiC2tBCHZBf3MgCEG+/wNzQQFqQQh2cUH/AXEgC3IMAQtBACAIQQRqIAhB0P8DakEIdkF/c3FBOSAIa0EIdkF/c3FB/wFxIAhBwQBrIgsgC0EIdkF/c3FB2gAgCGtBCHZBf3NxQf8BcSAIQbkBaiAIQZ//A2pBCHZBf3NxQfoAIAhrQQh2QX9zcUH/AXEgCEHQ/wBzQQFqQQh2QX9zQT9xIAhB1P8Ac0EBakEIdkF/c0E+cXJycnIiC2tBCHZBf3MgCEG+/wNzQQFqQQh2cUH/AXEgC3ILIgtB/wFGBEAgBEUNBCAEIAgQRA0BIAkhCgwECyALIA9BBnRqIQ8CQCANQQZqIgpBCEkEQCAKIQ0MAQsgDUECayENIAEgDk0EQCAMIAk2AgxB4JcCQcQANgIAQQEhEQwGCyAAIA5qIA8gDXY6AAAgDkEBaiEOCyAJQQFqIgogA0kNAgwDCyAJQQFqIgkgA0kNAAsLIAMgCkEBaiIAIAAgA0kbIQoLIAwgCjYCDAsCQCANQQRLBEBBACEBQX8hAAwBC0F/IQBBACEBIBEgD0F/IA10QX9zcXINACAHQQJxRQRAAn8CQCANQQF2IgcEQCAMKAIMIQADQCAAIANPBEBBxAAhCQwDCwJAIAAgAmosAAAiCkE9RgRAIAdBAWshBwwBC0EcIQkgBEUNAyAEIAoQREUNAwsgDCAAQQFqIgA2AgwgBw0ACwtBAAwBC0HglwIgCTYCAEF/CyIADQELQQAhACAEBEACQCAMKAIMIgkgA08NAANAIAQgAiAJaiwAABBERQ0BIAlBAWoiCSADRw0ACyADIQkLIAwgCTYCDAsgDiEBCyAMKAIMIQQCQCAGBEAgBiACIARqNgIADAELIAMgBEYNAEHglwJBHDYCAEF/IQALIAUEQCAFIAE2AgALIAxBEGokACAAC84DAQZ/IAQQaSADQQNuIgVBAnQhBgJAIAVBfWwgA2oiBUUNACAEQQJxRQRAIAZBBGohBgwBCyAGQQJyIAVBAXZqIQYLAkACQAJ/AkACfwJAIAEgBksEQAJAIARBBHEEQEEAIANFDQYaQQAhBUEAIQQMAQtBACADRQ0FGkEAIQVBACEEDAILA0AgAiAIai0AACIJIAdBCHRyIQcgBUEIaiEFA0AgACAEaiAHIAUiCkEGayIFdkE/cRCeAToAACAEQQFqIQQgBUEFSw0ACyAIQQFqIgggA0cNAAsgBUUNAyAJQQwgCmt0QT9xEJ4BDAILEBQACwNAIAIgCGotAAAiCSAHQQh0ciEHIAVBCGohBQNAIAAgBGogByAFIgpBBmsiBXZBP3EQnQE6AAAgBEEBaiEEIAVBBUsNAAsgCEEBaiIIIANHDQALIAVFDQEgCUEMIAprdEE/cRCdAQshBSAAIARqIAU6AAAgBEEBagwBCyAECyIHIAZNBEAgBiAHSw0BIAchBgwCC0EAIgBBmAhqIABB+QhqQeYBIABB3wpqEAAACyAAIAdqQT0gBiAHaxAPGgsgACAGakEAIAEgBkEBaiICIAEgAksbIAZrEA8aIAALEAAgAEF5cUEBRwRAEBQACwsWACAAEDYgAQRAIABB4JACQiIQGxoLCwQAQQMLlgEBAX8jAEEwayIBJAAgASAAKQAYNwMYIAEgACkAEDcDECABIAApAAA3AwAgASAAKQAINwMIIAEgACkAJDcDICABIAFCKCAAQSBqQQAgAEHAkQIoAgAREAAaIAAgASkDGDcAGCAAIAEpAxA3ABAgACABKQMINwAIIAAgASkDADcAACAAIAEpAyA3ACQgABBtIAFBMGokAAsJACAAQQE2ACALBABBCAunAQECfyABQcEAa0FASSAFQcAAS3IEf0F/BQJ/IwAiBiEHIAZBgANrQUBxIgYkAEEBIAIgA1AbRSAARSABQf8BcSIBQcEAa0H/AXFBvwFNcnIgBEEBIAVB/wFxIgUbRSAFQcEAT3JyRQRAAkAgBQRAIAYgASAEIAUQrAEaDAELIAYgARCtARoLIAYgAiADEDgaIAYgACABEHAaIAckAEEADAELEBQACwsL0gIBA38jAEFAaiIEJAACQCACQcEAa0H/AXFBvwFLBEBBfyEDIAApAFBQBEAgACAAKADgAiIDQYEBTwR/IABCgAEQcSAAIABB4ABqIgUQdCAAIAAoAOACQYABayIDNgDgAiADQYEBTw0DIAUgAEHgAWogAxARGiAAKADgAgUgAwutEHEgAC0A5AIEQCAAQn83AFgLIABCfzcAUCAAQeAAaiIDIAAoAOACIgVqQQBBgAIgBWsQDxogACADEHQgBCAAKQAAEBAgBEEIciAAKQAIEBAgBEEQaiAAKQAQEBAgBEEYaiAAKQAYEBAgBEEgaiAAKQAgEBAgBEEoaiAAKQAoEBAgBEEwaiAAKQAwEBAgBEE4aiAAKQA4EBAgASAEIAIQERogAEHAABAIIANBgAIQCEEAIQMLIARBQGskACADDwsQFAALQZMKQYkJQbICQb4IEAAACy0CAX8BfiAAQUBrIgIgASACKQAAIgF8IgM3AAAgACAAKQBIIAEgA1atfDcASAsJACAAQQA2AAALRgEDfyAAQcCJAkHAABARQUBrQQBBpQIQDxoDQCAAIAJBA3QiA2oiBCABIANqKQAAIAQpAACFNwAAIAJBAWoiAkEIRw0ACwvuNgIefgN/IwBBgAJrIiAkAANAICFBA3QiIiAgQYABamogASAiaikAADcDACAhQQFqIiFBEEcNAAsgICAAQcAAEBEiASkDACABKQMgIh4gASkDgAF8fCIZIABBQGspAACFQtGFmu/6z5SH0QCFQSAQBSIXQoiS853/zPmE6gB8IhMgHoVBGBAFIRYgFiAXIAEpA4gBIh4gFiAZfHwiDoVBEBAFIgMgE3wiB4VBPxAFIRwgASkDCCABKQOQASINIAEpAygiFnx8IhkgACkASIVCn9j52cKR2oKbf4VBIBAFIhdCxbHV2aevlMzEAH0iEyAWhUEYEAUhFiAWIBcgASkDmAEgFiAZfHwiBoVBEBAFIhAgE3wiD4VBPxAFIRMgASkDECABKQOgASILIAEpAzAiFnx8IhcgACkAUIVC6/qG2r+19sEfhUEgEAUiGkKr8NP0r+68tzx8IhIgFoVBGBAFIRkgGSAaIAEpA6gBIhYgFyAZfHwiCYVBEBAFIgggEnwiBIVBPxAFIRogASkDGCABKQOwASIZIAEpAzgiF3x8IgIgACkAWIVC+cL4m5Gjs/DbAIVBIBAFIgVCj5KLh9rYgtjaAH0iCiAXhUEYEAUhEiASIAogBSABKQO4ASIXIAIgEnx8IhGFQRAQBSIMfCIKhUE/EAUhAiATIAQgDCABKQPAASIFIA4gE3x8IhKFQSAQBSIOfCIEhUEYEAUhEyATIA4gASkDyAEiDCASIBN8fCIUhUEQEAUiFSAEfCIdhUE/EAUhBCAaIAMgASkD0AEiEiAGIBp8fCIGhUEgEAUiAyAKfCIKhUEYEAUhEyATIAogAyABKQPYASIOIAYgE3x8IhiFQRAQBSIbfCIKhUE/EAUhAyACIAcgECABKQPgASITIAIgCXx8IgaFQSAQBSIQfCIHhUEYEAUhGiAaIAcgECABKQPoASICIAYgGnx8IgmFQRAQBSIQfCIfhUE/EAUhByAcIA8gCCABKQPwASIaIBEgHHx8IhGFQSAQBSIIfCIPhUEYEAUhBiAbIAYgDyAIIAEpA/gBIhwgBiARfHwiEYVBEBAFIgh8Ig+FQT8QBSIGIBQgGnx8IhSFQSAQBSIbIB98Ih8gBoVBGBAFIQYgBiAbIAYgEiAUfHwiFIVBEBAFIhsgH3wiH4VBPxAFIQYgBCAPIBAgBCALfCAYfCIPhUEgEAUiEHwiC4VBGBAFIQQgBCAQIAQgBSAPfHwiD4VBEBAFIhAgC3wiC4VBPxAFIQQgAyAIIAMgDHwgCXwiCYVBIBAFIgggHXwiDIVBGBAFIQMgAyAIIAMgCSAcfHwiCYVBEBAFIgggDHwiDIVBPxAFIQMgByAKIBUgAiAHfCARfCIRhUEgEAUiFXwiCoVBGBAFIQcgByAKIBUgByARIBl8fCIKhUEQEAUiEXwiFYVBPxAFIQcgBCAMIBEgBCAUIB58fCIUhUEgEAUiEXwiDIVBGBAFIQQgBCAMIBEgBCATIBR8fCIUhUEQEAUiEXwiDIVBPxAFIQQgAyAVIBsgASkDgAEiHSADIA98fCIPhUEgEAUiGHwiFYVBGBAFIQMgAyAVIBggAyANIA98fCIPhUEQEAUiGHwiFYVBPxAFIQMgByAQIAcgCSAOfHwiCYVBIBAFIhAgH3wiG4VBGBAFIQcgByAbIBAgByAJIBd8fCIJhUEQEAUiH3wiG4VBPxAFIQcgBiALIAggBiAWfCAKfCILhUEgEAUiCHwiCoVBGBAFIQYgGyAYIAYgCiAIIAEpA5gBIhAgBiALfHwiC4VBEBAFIgh8IgqFQT8QBSIGIA4gFHx8IhSFQSAQBSIYfCIbIAaFQRgQBSEGIAYgGCAGIAUgFHx8IhSFQRAQBSIYIBt8IhuFQT8QBSEFIAQgHyAEIBN8IA98IgaFQSAQBSIPIAp8IgqFQRgQBSEEIAQgDyAEIAYgHXx8IgaFQRAQBSIPIAp8IgqFQT8QBSEEIAMgCCADIBZ8IAl8IgmFQSAQBSIIIAx8IgyFQRgQBSEDIAMgCCADIAkgDXx8IgmFQRAQBSIIIAx8IgyFQT8QBSEDIAcgESAHIBx8IAt8IguFQSAQBSIRIBV8IhWFQRgQBSEHIAcgESAHIAIgC3x8IguFQRAQBSIRIBV8IhWFQT8QBSEHIAQgDCARIAQgEiAUfHwiDIVBIBAFIhF8IhSFQRgQBSEEIAQgESAEIAwgGnx8IgyFQRAQBSIRIBR8IhSFQT8QBSEEIAMgFSAYIAMgBiAQfHwiBoVBIBAFIh18IhWFQRgQBSEDIAMgFSAdIAMgBiAZfHwiGIVBEBAFIh18IhWFQT8QBSEDIAcgDyAHIAkgF3x8IgaFQSAQBSIPIBt8IgmFQRgQBSEHIAcgCSAPIAcgBiAefHwiG4VBEBAFIh98IgmFQT8QBSEHIAUgCiAIIAEpA8gBIgYgBSALfHwiC4VBIBAFIgh8IgqFQRgQBSEFIAkgHSAFIAogCCABKQOgASIPIAUgC3x8IguFQRAQBSIIfCIKhUE/EAUiBSAMIBd8fCIMhUEgEAUiHXwiCSAFhUEYEAUhBSAFIAkgHSAFIAYgDHx8IgyFQRAQBSIdfCIJhUE/EAUhBSAEIAogHyAEIBB8IBh8IhCFQSAQBSIKfCIYhUEYEAUhBCAEIAogBCAQIB58fCIQhUEQEAUiCiAYfCIYhUE/EAUhBCADIBQgCCACIAN8IBt8IhuFQSAQBSIIfCIUhUEYEAUhAiACIBQgCCACIBMgG3x8IhSFQRAQBSIIfCIbhUE/EAUhAiAHIBUgESAHIA58IAt8IguFQSAQBSIRfCIVhUEYEAUhAyADIBEgAyALIBp8fCILhUEQEAUiByAVfCIRhUE/EAUhAyAEIBsgByAEIAwgDXx8IgyFQSAQBSIHfCIVhUEYEAUhBCAEIBUgByAEIAwgGXx8IgyFQRAQBSIbfCIVhUE/EAUhBCACIB0gAiAQIBZ8fCIHhUEgEAUiECARfCIRhUEYEAUhAiACIBEgECACIAcgEnx8Ih2FQRAQBSIffCIRhUE/EAUhAiADIAkgCiADIA8gFHx8IhCFQSAQBSIJfCIKhUEYEAUhAyADIAogCSABKQOAASIHIAMgEHx8IhSFQRAQBSIJfCIKhUE/EAUhAyAFIBggCCAFIBx8IAt8IguFQSAQBSIIfCIQhUEYEAUhBSAKIB8gBSAQIAggASkDwAEiECAFIAt8fCILhUEQEAUiCHwiGIVBPxAFIgUgBiAMfHwiBoVBIBAFIgx8IgogBYVBGBAFIQUgBSAKIAwgBSAGIAd8fCIGhUEQEAUiCnwiDIVBPxAFIQUgBCAYIAkgBCAWfCAdfCIdhUEgEAUiCXwiGIVBGBAFIQQgBCAJIAQgFyAdfHwiHYVBEBAFIgkgGHwiGIVBPxAFIQQgAiAIIAIgDXwgFHwiFIVBIBAFIgggFXwiFYVBGBAFIQIgAiAIIAIgDyAUfHwiD4VBEBAFIgggFXwiFIVBPxAFIQIgAyARIBsgAyASfCALfCILhUEgEAUiFXwiEYVBGBAFIQMgAyARIBUgAyALIBx8fCILhUEQEAUiFXwiEYVBPxAFIQMgBCAUIBUgBCAGIBp8fCIGhUEgEAUiFXwiFIVBGBAFIQQgBCAUIBUgBCAGIB58fCIGhUEQEAUiFHwiFYVBPxAFIQQgAiARIAogAiAOIB18fCIRhUEgEAUiCnwiHYVBGBAFIQIgAiAKIAIgESATfHwiEYVBEBAFIgogHXwiHYVBPxAFIQIgAyAJIAMgDyAZfHwiD4VBIBAFIgkgDHwiDIVBGBAFIQMgAyAJIAMgDyAQfHwiD4VBEBAFIgkgDHwiDIVBPxAFIQMgBSAYIAggASkDmAEiGyAFIAt8fCILhUEgEAUiCHwiGIVBGBAFIQUgDCAKIAUgGCAIIAEpA+gBIh8gBSALfHwiC4VBEBAFIgh8IhiFQT8QBSIFIAYgDXx8IgaFQSAQBSIKfCIMIAWFQRgQBSENIA0gDCAKIA0gBiATfHwiBoVBEBAFIgp8IgyFQT8QBSENIAQgCSAEIBl8IBF8IhGFQSAQBSIJIBh8IhiFQRgQBSEFIAUgCSAFIBEgEnx8IgSFQRAQBSIJIBh8IhGFQT8QBSEFIAIgCCACIAd8IA98IgeFQSAQBSIPIBV8IgiFQRgQBSECIAIgDyACIAcgDnx8IgeFQRAQBSIPIAh8IgiFQT8QBSEOIAMgFCADIBB8IAt8IhCFQSAQBSILIB18IhSFQRgQBSECIAIgCyACIBAgG3x8IgOFQRAQBSIQIBR8IguFQT8QBSECIAUgCCAQIAEpA6ABIAUgBnx8IgaFQSAQBSIQfCIIhUEYEAUhBSAFIBAgBSAGIB98fCIGhUEQEAUiECAIfCIIhUE/EAUhBSAOIAsgCiAOIAQgF3x8IgSFQSAQBSILfCIKhUEYEAUhDiAOIAsgDiAEIBZ8fCIEhUEQEAUiCyAKfCIKhUE/EAUhDiACIAkgAiAHIBx8fCIHhUEgEAUiCSAMfCIMhUEYEAUhAiACIAkgAiAHIBp8fCIHhUEQEAUiCSAMfCIMhUE/EAUhAiANIA8gDSAefCADfCIDhUEgEAUiDyARfCIRhUEYEAUhDSAMIAsgDSAPIAEpA8gBIAMgDXx8IgOFQRAQBSIPIBF8IhGFQT8QBSINIAYgE3x8IgaFQSAQBSILfCIMIA2FQRgQBSENIA0gCyANIAYgFnx8IgaFQRAQBSILIAx8IgyFQT8QBSENIAUgCSAFIB58IAR8IgSFQSAQBSIJIBF8IhGFQRgQBSEFIAUgCSAFIAQgHHx8IgSFQRAQBSIJIBF8IhGFQT8QBSEFIA4gDyAOIBp8IAd8IgeFQSAQBSIPIAh8IgiFQRgQBSEOIA4gDyABKQPoASAHIA58fCIHhUEQEAUiDyAIfCIIhUE/EAUhDiACIBAgASkDoAEgAiADfHwiA4VBIBAFIhAgCnwiCoVBGBAFIQIgAiAQIAIgAyASfHwiA4VBEBAFIhAgCnwiCoVBPxAFIQIgBSAIIBAgASkDgAEgBSAGfHwiBoVBIBAFIhB8IgiFQRgQBSEFIAUgECAFIAYgF3x8IgaFQRAQBSIQIAh8IgiFQT8QBSEFIA4gCyAOIAQgGXx8IgSFQSAQBSILIAp8IgqFQRgQBSEOIA4gCyABKQOYASAEIA58fCIEhUEQEAUiCyAKfCIKhUE/EAUhDiACIAkgASkDyAEgAiAHfHwiB4VBIBAFIgkgDHwiDIVBGBAFIQIgAiAJIAEpA5ABIAIgB3x8IgeFQRAQBSIJIAx8IgyFQT8QBSECIA0gDyABKQPAASADIA18fCIDhUEgEAUiDyARfCIRhUEYEAUhDSANIBEgDyABKQPYASIUIAMgDXx8IgOFQRAQBSIPfCIRhUE/EAUhDSANIAsgASkD6AEgBiANfHwiBoVBIBAFIgsgDHwiDIVBGBAFIQ0gDSALIAYgDXwgFHwiBoVBEBAFIgsgDHwiDIVBPxAFIQ0gBSAJIAUgF3wgBHwiBIVBIBAFIgkgEXwiEYVBGBAFIQUgBSAJIAUgBCAafHwiBIVBEBAFIgkgEXwiEYVBPxAFIQUgDiAPIA4gE3wgB3wiB4VBIBAFIg8gCHwiCIVBGBAFIQ4gDiAPIA4gByAefHwiB4VBEBAFIg8gCHwiCIVBPxAFIQ4gAiAQIAEpA5gBIAIgA3x8IgOFQSAQBSIQIAp8IgqFQRgQBSECIAIgECABKQPIASACIAN8fCIDhUEQEAUiECAKfCIKhUE/EAUhAiAFIBAgBSAGIBZ8fCIGhUEgEAUiECAIfCIIhUEYEAUhBSAFIBAgASkDgAEgBSAGfHwiBoVBEBAFIhAgCHwiCIVBPxAFIQUgDiALIA4gBCAcfHwiBIVBIBAFIgsgCnwiCoVBGBAFIQ4gDiALIAEpA6ABIAQgDnx8IgSFQRAQBSILIAp8IgqFQT8QBSEOIAIgCSABKQPAASACIAd8fCIHhUEgEAUiCSAMfCIMhUEYEAUhAiACIAkgAiAHIBl8fCIHhUEQEAUiCSAMfCIMhUE/EAUhAiANIA8gASkDkAEgAyANfHwiA4VBIBAFIg8gEXwiEYVBGBAFIQ0gDCALIA0gDyANIAMgEnx8IgOFQRAQBSIPIBF8IhGFQT8QBSINIAYgGXx8IgaFQSAQBSILfCIMIA2FQRgQBSENIA0gCyANIAYgHHx8IgaFQRAQBSILIAx8IgyFQT8QBSENIAUgCSAFIBp8IAR8IgSFQSAQBSIJIBF8IhGFQRgQBSEFIAUgCSABKQPIASAEIAV8fCIEhUEQEAUiCSARfCIRhUE/EAUhBSAOIA8gASkD2AEgByAOfHwiB4VBIBAFIg8gCHwiCIVBGBAFIQ4gDiAPIAEpA5gBIAcgDnx8IgeFQRAQBSIPIAh8IgiFQT8QBSEOIAIgECABKQOAASACIAN8fCIDhUEgEAUiECAKfCIKhUEYEAUhAiACIBAgASkDwAEgAiADfHwiA4VBEBAFIhAgCnwiCoVBPxAFIQIgBSAQIAUgBiATfHwiBoVBIBAFIhAgCHwiCIVBGBAFIQUgBSAIIBAgASkDkAEiFCAFIAZ8fCIGhUEQEAUiEHwiCIVBPxAFIQUgDiALIAEpA+gBIAQgDnx8IgSFQSAQBSILIAp8IgqFQRgQBSEOIA4gCyAOIAQgF3x8IgSFQRAQBSILIAp8IgqFQT8QBSEOIAIgCSACIAcgHnx8IgeFQSAQBSIJIAx8IgyFQRgQBSECIAIgDCAJIAEpA6ABIhUgAiAHfHwiB4VBEBAFIgl8IgyFQT8QBSECIA0gDyANIBJ8IAN8IgOFQSAQBSIPIBF8IhGFQRgQBSENIAsgDSAPIA0gAyAWfHwiA4VBEBAFIg8gEXwiEYVBPxAFIg0gBiASfHwiBoVBIBAFIgsgDHwiDCANhUEYEAUhEiASIAwgCyAGIBJ8IBR8IgaFQRAQBSILfCIMhUE/EAUhEiAFIAkgASkDwAEgBCAFfHwiBIVBIBAFIgkgEXwiEYVBGBAFIQ0gDSAJIAQgDXwgFXwiBYVBEBAFIgQgEXwiCYVBPxAFIQ0gDiAPIA4gF3wgB3wiB4VBIBAFIg8gCHwiCIVBGBAFIQ4gDiAPIA4gByAZfHwiB4VBEBAFIg8gCHwiCIVBPxAFIQ4gAiAQIAIgHnwgA3wiA4VBIBAFIhAgCnwiCoVBGBAFIQIgAiAQIAIgAyAWfHwiA4VBEBAFIhAgCnwiCoVBPxAFIQIgDSAIIBAgDSAGIBx8fCIGhUEgEAUiEHwiCIVBGBAFIQ0gDSAQIAEpA9gBIAYgDXx8IgaFQRAQBSIQIAh8IgiFQT8QBSENIA4gCyABKQPIASAFIA58fCIFhUEgEAUiCyAKfCIKhUEYEAUhDiAOIAsgDiAFIBp8fCIFhUEQEAUiCyAKfCIKhUE/EAUhDiACIAwgBCABKQOYASIRIAIgB3x8IgeFQSAQBSIEfCIMhUEYEAUhAiACIAQgAiAHIBN8fCIHhUEQEAUiBCAMfCIMhUE/EAUhAiASIA8gASkD6AEgAyASfHwiA4VBIBAFIg8gCXwiCYVBGBAFIRIgEiAJIA8gASkDgAEiFCADIBJ8fCIDhUEQEAUiD3wiCYVBPxAFIRIgEiALIAYgEnwgFHwiBoVBIBAFIgsgDHwiDIVBGBAFIRIgEiALIBIgBiAefHwiBoVBEBAFIgsgDHwiDIVBPxAFIRIgDSAEIAEpA5ABIAUgDXx8IgWFQSAQBSIEIAl8IgmFQRgQBSENIA0gBCAFIA18IBF8IgWFQRAQBSIEIAl8IgmFQT8QBSENIA4gDyABKQOgASAHIA58fCIHhUEgEAUiDyAIfCIIhUEYEAUhDiAOIA8gDiAHIBZ8fCIHhUEQEAUiDyAIfCIIhUE/EAUhDiACIBAgAiAZfCADfCIDhUEgEAUiECAKfCIKhUEYEAUhAiACIBAgAiADIBd8fCIDhUEQEAUiECAKfCIKhUE/EAUhAiANIBAgASkDwAEgBiANfHwiBoVBIBAFIhAgCHwiCIVBGBAFIQ0gDSAQIAEpA8gBIAYgDXx8IgaFQRAQBSIQIAh8IgiFQT8QBSENIA4gCiALIAEpA9ABIhEgBSAOfHwiBYVBIBAFIgt8IgqFQRgQBSEOIA4gCyABKQPYASAFIA58fCIFhUEQEAUiCyAKfCIKhUE/EAUhDiACIAQgAiAHIBN8fCIHhUEgEAUiBCAMfCIMhUEYEAUhAiACIAQgASkD6AEgAiAHfHwiB4VBEBAFIgQgDHwiDIVBPxAFIQIgEiAPIBIgGnwgA3wiA4VBIBAFIg8gCXwiCYVBGBAFIRIgCyASIA8gEiADIBx8fCIDhUEQEAUiDyAJfCIJhUE/EAUiEiAGIBp8fCIGhUEgEAUiCyAMfCIMIBKFQRgQBSEaIBogCyAGIBp8IBF8IgaFQRAQBSILIAx8IhGFQT8QBSEaIA0gBCABKQOgASAFIA18fCIFhUEgEAUiBCAJfCIJhUEYEAUhEiASIAQgASkDwAEgBSASfHwiBYVBEBAFIgQgCXwiCYVBPxAFIRIgDiAPIAEpA8gBIAcgDnx8IgeFQSAQBSIPIAh8IgiFQRgQBSENIA0gDyANIAcgHHx8Ig6FQRAQBSIHIAh8Ig+FQT8QBSEcIAIgECABKQPoASACIAN8fCIDhUEgEAUiECAKfCIIhUEYEAUhDSANIBAgDSADIBl8fCIChUEQEAUiAyAIfCIQhUE/EAUhGSABIBIgBiAefHwiHiATfCASIAMgHoVBIBAFIhMgD3wiDYVBGBAFIhJ8Ih43AwAgASATIB6FQRAQBSITNwN4IAEgDSATfCITNwNQIAEgEiAThUE/EAU3AyggASAcIAsgASkDgAEgBSAcfHwiE4VBIBAFIhIgEHwiDYVBGBAFIhwgE3wgASkDkAF8IhM3AwggASASIBOFQRAQBSITNwNgIAEgDSATfCITNwNYIAEgEyAchUE/EAU3AzAgASAXIAEpA9gBIA4gGXx8IhN8IBkgBCAThUEgEAUiFyARfCIThUEYEAUiGXwiHDcDECABIBcgHIVBEBAFIhc3A2ggASATIBd8Ihc3A0AgASAXIBmFQT8QBTcDOCABIBogByAWIBp8IAJ8IhaFQSAQBSIZIAl8IheFQRgQBSITIBZ8IAEpA5gBfCIWNwMYIAEgFiAZhUEQEAUiFjcDcCABIBYgF3wiFjcDSCABIBMgFoVBPxAFNwMgIAAgASkDQCAeIAApAACFhTcAAEEBISEDQCAAICFBA3QiIGoiIiABICBqIiApAwAgIikAAIUgIEFAaykDAIU3AAAgIUEBaiIhQQhHDQALIAFBgAJqJAALRQECfyMAQRBrIgNBADoADyABBEADQCADIAAgAmotAAAgAy0AD3I6AA8gAkEBaiICIAFHDQALCyADLQAPQQFrQQh2QQFxCxkAIAAgASACIANCACAEQeSRAigCABESABoLEAAgACABQdyRAigCABEDAAsDAAEL9wEBBH8jAEGAAWsiAyQAIAAQHCAAQShqIgQQHCAAQdAAaiIFEDAgACABQcAHbEHgFWoiASACQQAgAkGAAXFBB3YiBmsgAnFBAXRrQRh0QRh1IgJBARAmECIgACABQfgAaiACQQIQJhAiIAAgAUHwAWogAkEDECYQIiAAIAFB6AJqIAJBBBAmECIgACABQeADaiACQQUQJhAiIAAgAUHYBGogAkEGECYQIiAAIAFB0AVqIAJBBxAmECIgACABQcgGaiACQQgQJhAiIANBCGoiASAEECkgA0EwaiAAECkgA0HYAGogBRCAASAAIAEgBhAiIANBgAFqJAALHQAgABAwIABBKGoQHCAAQdAAahAcIABB+ABqEDALgAIBCH8DQCAAIAJqIAEgAkEDdmotAAAgAkEHcXZBAXE6AAAgAkEBaiICQYACRw0ACwNAIAQiAUEBaiEEAkAgACABaiIGLQAARQ0AIAQhAkEBIQUgAUH+AUsNAANAAkAgACACaiIDLAAAIgdFDQAgByAFdCIHIAYsAAAiCGoiCUEPTARAIAYgCToAACADQQA6AAAMAQsgCCAHayIDQXFIDQIgBiADOgAAA0AgACACaiIDLQAARQRAIANBAToAAAwCCyADQQA6AAAgAkH/AUkhAyACQQFqIQIgAw0ACwsgBUEFSw0BIAVBAWoiBSABaiICQYACSQ0ACwsgBEGAAkcNAAsLlQEBBH8jAEEwayIFJAAgACABQShqIgMgARASIABBKGoiBCADIAEQFSAAQdAAaiIDIAAgAkEoahAKIAQgBCACEAogAEH4AGoiBiACQfgAaiABQfgAahAKIAAgAUHQAGogAkHQAGoQCiAFIAAgABASIAAgAyAEEBUgBCADIAQQEiADIAUgBhAVIAYgBSAGEBIgBUEwaiQAC4sMAQZ/IAAgAWohBQJAAkAgACgCBCICQQFxDQAgAkEDcUUNASAAKAIAIgIgAWohAQJAIAAgAmsiAEGomAIoAgBHBEAgAkH/AU0EQCAAKAIIIgQgAkEDdiICQQN0QbyYAmpGGiAAKAIMIgMgBEcNAkGUmAJBlJgCKAIAQX4gAndxNgIADAMLIAAoAhghBgJAIAAgACgCDCIDRwRAIAAoAggiAkGkmAIoAgBJGiACIAM2AgwgAyACNgIIDAELAkAgAEEUaiICKAIAIgQNACAAQRBqIgIoAgAiBA0AQQAhAwwBCwNAIAIhByAEIgNBFGoiAigCACIEDQAgA0EQaiECIAMoAhAiBA0ACyAHQQA2AgALIAZFDQICQCAAIAAoAhwiBEECdEHEmgJqIgIoAgBGBEAgAiADNgIAIAMNAUGYmAJBmJgCKAIAQX4gBHdxNgIADAQLIAZBEEEUIAYoAhAgAEYbaiADNgIAIANFDQMLIAMgBjYCGCAAKAIQIgIEQCADIAI2AhAgAiADNgIYCyAAKAIUIgJFDQIgAyACNgIUIAIgAzYCGAwCCyAFKAIEIgJBA3FBA0cNAUGcmAIgATYCACAFIAJBfnE2AgQgACABQQFyNgIEIAUgATYCAA8LIAQgAzYCDCADIAQ2AggLAkAgBSgCBCICQQJxRQRAIAVBrJgCKAIARgRAQayYAiAANgIAQaCYAkGgmAIoAgAgAWoiATYCACAAIAFBAXI2AgQgAEGomAIoAgBHDQNBnJgCQQA2AgBBqJgCQQA2AgAPCyAFQaiYAigCAEYEQEGomAIgADYCAEGcmAJBnJgCKAIAIAFqIgE2AgAgACABQQFyNgIEIAAgAWogATYCAA8LIAJBeHEgAWohAQJAIAJB/wFNBEAgBSgCCCIEIAJBA3YiAkEDdEG8mAJqRhogBCAFKAIMIgNGBEBBlJgCQZSYAigCAEF+IAJ3cTYCAAwCCyAEIAM2AgwgAyAENgIIDAELIAUoAhghBgJAIAUgBSgCDCIDRwRAIAUoAggiAkGkmAIoAgBJGiACIAM2AgwgAyACNgIIDAELAkAgBUEUaiIEKAIAIgINACAFQRBqIgQoAgAiAg0AQQAhAwwBCwNAIAQhByACIgNBFGoiBCgCACICDQAgA0EQaiEEIAMoAhAiAg0ACyAHQQA2AgALIAZFDQACQCAFIAUoAhwiBEECdEHEmgJqIgIoAgBGBEAgAiADNgIAIAMNAUGYmAJBmJgCKAIAQX4gBHdxNgIADAILIAZBEEEUIAYoAhAgBUYbaiADNgIAIANFDQELIAMgBjYCGCAFKAIQIgIEQCADIAI2AhAgAiADNgIYCyAFKAIUIgJFDQAgAyACNgIUIAIgAzYCGAsgACABQQFyNgIEIAAgAWogATYCACAAQaiYAigCAEcNAUGcmAIgATYCAA8LIAUgAkF+cTYCBCAAIAFBAXI2AgQgACABaiABNgIACyABQf8BTQRAIAFBA3YiAkEDdEG8mAJqIQECf0GUmAIoAgAiA0EBIAJ0IgJxRQRAQZSYAiACIANyNgIAIAEMAQsgASgCCAshAiABIAA2AgggAiAANgIMIAAgATYCDCAAIAI2AggPC0EfIQIgAEIANwIQIAFB////B00EQCABQQh2IgIgAkGA/j9qQRB2QQhxIgR0IgIgAkGA4B9qQRB2QQRxIgN0IgIgAkGAgA9qQRB2QQJxIgJ0QQ92IAMgBHIgAnJrIgJBAXQgASACQRVqdkEBcXJBHGohAgsgACACNgIcIAJBAnRBxJoCaiEHAkACQEGYmAIoAgAiBEEBIAJ0IgNxRQRAQZiYAiADIARyNgIAIAcgADYCACAAIAc2AhgMAQsgAUEAQRkgAkEBdmsgAkEfRht0IQIgBygCACEDA0AgAyIEKAIEQXhxIAFGDQIgAkEddiEDIAJBAXQhAiAEIANBBHFqIgdBEGooAgAiAw0ACyAHIAA2AhAgACAENgIYCyAAIAA2AgwgACAANgIIDwsgBCgCCCIBIAA2AgwgBCAANgIIIABBADYCGCAAIAQ2AgwgACABNgIICwvEBQEIfyMAQaACayIFJAAgAEEoaiIJIAEQgQEgAEHQAGoiAxAcIAVB8AFqIgYgCRANIAVBwAFqIgcgBkGQCxAKIAYgBiADEBUgByAHIAMQEiAFQZABaiIIIAcQDSAIIAggBxAKIAAgCBANIAAgACAHEAogACAAIAYQCiMAQZABayIDJAAgA0HgAGoiAiAAEA0gA0EwaiIEIAIQDSAEIAQQDSAEIAAgBBAKIAIgAiAEEAogAiACEA0gAiAEIAIQCiAEIAIQDUEBIQIDQCADQTBqIgQgBBANIAJBAWoiAkEFRw0ACyADQeAAaiICIANBMGoiBCACEAogBCACEA1BASECA0AgA0EwaiIEIAQQDSACQQFqIgJBCkcNAAsgA0EwaiICIAIgA0HgAGoQCiADIAIQDUEBIQIDQCADIAMQDSACQQFqIgJBFEcNAAsgA0EwaiICIAMgAhAKQQEhAgNAIANBMGoiBCAEEA0gAkEBaiICQQtHDQALIANB4ABqIgIgA0EwaiIEIAIQCiAEIAIQDUEBIQIDQCADQTBqIgQgBBANIAJBAWoiAkEyRw0ACyADQTBqIgIgAiADQeAAahAKIAMgAhANQQEhAgNAIAMgAxANIAJBAWoiAkHkAEcNAAsgA0EwaiICIAMgAhAKQQEhAgNAIANBMGoiBCAEEA0gAkEBaiICQTNHDQALIANB4ABqIgIgA0EwaiACEAogAiACEA0gAiACEA0gACACIAAQCiADQZABaiQAIAAgACAIEAogACAAIAYQCiAFQeAAaiIDIAAQDSADIAMgBxAKIAVBMGoiAiADIAYQFQJ/IAIQVkUEQCAFIAVB4ABqIAVB8AFqEBJBfyAFEFZFDQEaIAAgAEHACxAKCyAAEH8gAS0AH0EHdkYEQCAAIAAQgAELIABB+ABqIAAgCRAKQQALIQAgBUGgAmokACAACyYBAX8jAEEgayIBJAAgASAAECwgAS0AACEAIAFBIGokACAAQQFxC6oBAQl/IAEoAgQhAiABKAIIIQMgASgCDCEEIAEoAhAhBSABKAIUIQYgASgCGCEHIAEoAhwhCCABKAIgIQkgASgCJCEKIABBACABKAIAazYCACAAQQAgCms2AiQgAEEAIAlrNgIgIABBACAIazYCHCAAQQAgB2s2AhggAEEAIAZrNgIUIABBACAFazYCECAAQQAgBGs2AgwgAEEAIANrNgIIIABBACACazYCBAvCAwEMfiABNQAAIQQgAUEEahAOIQUgAUEHahAOIQYgAUEKahAOIQIgAUENahAOIQcgATUAECEDIAFBFGoQDiEIIAFBF2oQDiEJIAFBGmoQDiEKIAFBHWoQDiELIAAgAkIDhiICIAJCgICACHwiAkKAgIDwD4N9IAZCBYYgBUIGhiIFQoCAgAh8IgZCGYd8IgxCgICAEHwiDUIaiHw+AgwgACAMIA1CgICA4A+DfT4CCCAAIAMgA0KAgIAIfCIDQoCAgPAPg30gB0IChiACQhmHfCICQoCAgBB8IgdCGoh8PgIUIAAgAiAHQoCAgOAPg30+AhAgACAIQgeGIANCGYd8IgMgA0KAgIAQfCIDQoCAgOAPg30+AhggACAJQgWGIgIgAkKAgIAIfCICQoCAgPAPg30gA0IaiHw+AhwgACAKQgSGIAJCGYd8IgMgA0KAgIAQfCIDQoCAgOAPg30+AiAgACALQgKGQvz//w+DIgIgAkKAgIAIfCICQoCAgBCDfSADQhqIfD4CJCAAIAUgBkKAgIDwD4N9IAQgAkIZiEITfnwiA0KAgIAQfCIEQhqIfD4CBCAAIAMgBEKAgIDgD4N9PgIAC6sDAgx/BH4gACkDOCIOUEUEQCAAIA6nIgNqIgJBQGtBAToAACAOQgF8Qg9YBEAgAkHBAGpBAEEPIANrEA8aCyAAQQE6AFAgACAAQUBrQhAQVwsgADUCNCEOIAA1AjAhDyAANQIsIRAgASAANQIoIAAoAiQgACgCICAAKAIcIAAoAhgiA0EadmoiAkEadmoiBEEadmoiB0GAgIBgciAEQf///x9xIgggAkH///8fcSIFIAAoAhQgB0EadkEFbGoiAkH///8fcSIJQQVqIgpBGnYgA0H///8fcSACQRp2aiICaiIGQRp2aiILQRp2aiIMQRp2aiIEQR91IgMgAnEgBiAEQR92QQFrIgZB////H3EiAnFyIg1BGnQgAiAKcSADIAlxcnKtfCIRpxAJIAFBBGogECADIAVxIAIgC3FyIgVBFHQgDUEGdnKtfCARQiCIfCIQpxAJIAFBCGogDyADIAhxIAIgDHFyIgJBDnQgBUEMdnKtfCAQQiCIfCIPpxAJIAFBDGogDiAEIAZxIAMgB3FyQQh0IAJBEnZyrXwgD0IgiHynEAkgAEHYABAIC/MBAQN+AkAgACkDOCIEUEUEQEIQIAR9IgMgAiACIANWGyIFUEUEQEIAIQMDQCAAIAMgBHynakFAayABIAOnai0AADoAACAAKQM4IQQgA0IBfCIDIAVSDQALCyAAIAQgBXwiAzcDOCADQhBUDQEgACAAQUBrQhAQVyAAQgA3AzggAiAFfSECIAEgBadqIQELIAJCEFoEQCAAIAEgAkJwgyIDEFcgAkIPgyECIAEgA6dqIQELIAJQDQBCACEDA0AgACAAKQM4IAN8p2pBQGsgASADp2otAAA6AAAgA0IBfCIDIAJSDQALIAAgACkDOCACfDcDOAsLsgEBAX8gACABKAAAQf///x9xNgIAIAAgASgAA0ECdkGD/v8fcTYCBCAAIAEoAAZBBHZB/4H/H3E2AgggACABKAAJQQZ2Qf//wB9xNgIMIAEoAAwhAiAAQgA3AhQgAEIANwIcIABBADYCJCAAIAJBCHZB//8/cTYCECAAIAEoABA2AiggACABKAAUNgIsIAAgASgAGDYCMCABKAAcIQEgAEEAOgBQIABCADcDOCAAIAE2AjQLMAECfyMAIgVBgAFrQUBxIgQkACAEIAMQhAEgBCABIAIQgwEgBCAAEIIBIAUkAEEACwsAIAAgAUEgEIcBC2wBAX8jAEEQayIDIAA2AgwgAyABNgIIQQAhASADQQA2AgQgAkEASgRAA0AgAyADKAIEIAMoAgggAWotAAAgAygCDCABai0AAHNyNgIEIAFBAWoiASACRw0ACwsgAygCBEEBa0EIdkEBcUEBawspAQJ/A0AgACACQQN0IgNqIAEgA2opAAA3AwAgAkEBaiICQYABRw0ACwtyAQF/AkAgAUEEcUUNACAAKAIAIgEEQCABKAIEIAAoAhBBCnQQCAsgACgCBCIBRQ0AIAEgACgCFEEDdBAICyAAKAIEEBggAEEANgIEAkAgACgCACIBRQ0AIAEoAgAiAkUNACACEBgLIAEQGCAAQQA2AgALEAAgAEIANwIAIABCADcCCAspAQF/IwBBEGsiACQAIABBADoAD0GMkgIgAEEPakEAEAEaIABBEGokAAsoACACQoCAgIAQWgRAEBQACyAAIAEgAiADQgEgBEG8kQIoAgAREgAaCxYAIABCwAAgASACQbSRAigCABENABoLPQECfyMAIgRBgANrQUBxIgMkACADQQBBAEEYEEIaIAMgAUIgECUaIAMgAkIgECUaIAMgAEEYEEEaIAQkAAsqAQF/QX8hBiACQhBaBH8gACABQRBqIAEgAkIQfSADIAQgBRCQAQUgBgsLPAECfyMAQSBrIgckAEF/IQggByAFIAYQZEUEQCAAIAEgAiADIAQgBxBgIQggB0EgEAgLIAdBIGokACAICyUAIAJC8P///w9aBEAQFAALIABBEGogACABIAIgAyAEIAUQkgELPAECfyMAQSBrIgckAEF/IQggByAFIAYQZEUEQCAAIAEgAiADIAQgBxBhIQggB0EgEAgLIAdBIGokACAICw4AIAFBIBAdIAAgARB3C+cCAQV/IwBBoANrIgYkACMAQcABayIEJAAgBhA2IARBQGtBNkGAARAPGiAEIAMtAABBNnM6AEBBASEFA0AgBEFAayAFaiIHIActAAAgAyAFai0AAHM6AAAgBUEBaiIFQSBHDQALIAYgBEFAayIFQoABEBsaIAZB0AFqIgcQNiAFQdwAQYABEA8aIAQgAy0AAEHcAHM6AEBBASEFA0AgBEFAayAFaiIIIAgtAAAgAyAFai0AAHM6AAAgBUEBaiIFQSBHDQALIAcgBEFAayIDQoABEBsaIANBgAEQCCAEQcAAEAggBEHAAWokACAGIAEgAhAbGiMAQUBqIgEkACMAQUBqIgMkACAGIAMQJyAGQdABaiIEIANCwAAQGxogBCABECcgA0HAABAIIANBQGskACAAIAEpAxg3ABggACABKQMQNwAQIAAgASkDCDcACCAAIAEpAwA3AAAgAUFAayQAIAZBoANqJABBAAsyACAAIAIEfyACKAAABUEACzYCMCAAIAEoAAA2AjQgACABKAAENgI4IAAgASgACDYCPAuUAQEBfyMAQRBrIgUkACAAQQBBgAEQDyEAAn8gBEGBgICAeEkgAiADhEL/////D1hxRQRAQeCXAkEWNgIAQX8MAQsgA1BFIARB/z9LcUUEQEHglwJBHDYCAEF/DAELIAVBEBAdQX9BACADpyAEQQp2QQEgASACpyAFQRBBAEEgIABBgAFBAhA0GwshACAFQRBqJAAgAAugAgIEfwF+IwBBQGoiBCQAAkACQAJAIAAQISIGQYABSSABQv////8PWHFFBEBB4JcCQRw2AgAMAQsgBEEANgI4IARCADcDMCAEQgA3AygCQAJ/QQAgBkUNABogBq0iCKciBSAGQQFyQYCABEkNABpBfyAFIAhCIIinGwsiBxAfIgVFDQAgBUEEay0AAEEDcUUNACAFQQAgBxAPGgsgBQ0BC0F/IQAMAQsgBEIANwMgIAQgBTYCCCAEIAU2AhAgBCAGNgIUIAQgBTYCACAEIAY2AgwgBEIANwMYIAQgBjYCBAJ/IAQgACADEJkBBEBB4JcCQRw2AgBBfwwBCyAEKAIoIAGnRyAEKAIsIAJBCnZHcgshACAFEBgLIARBQGskACAAC5wCAQV/IwBBQGoiBCQAIARBCGpBAEE0EA8aIAQgABAhIgU2AhQgBCAFNgIkIAQgBTYCBCAEIAUQHyIGNgIgIAQgBRAfIgc2AhAgBCAFEB8iCDYCAAJAAkAgCEUgBkUgB0Vycg0AIAUQHyIFRQ0AIAQgACADEJkBIgAEQCAEKAIgEBggBCgCEBAYIAQoAgAQGCAFEBgMAgtBACEAIAQoAiggBCgCLCAEKAI0IAEgAiAEKAIQIAQoAhQgBSAEKAIEQQBBACADEDQhASAEKAIgEBggBCgCEBAYAkAgAUUEQCAFIAQoAgAgBCgCBBBPRQ0BC0FdIQALIAUQGCAEKAIAEBgMAQsgBhAYIAcQGCAIEBhBaiEACyAEQUBrJAAgAAvMAwEEfyMAQRBrIgMkACAAKAIUIQUgAEEANgIUIAAoAgQhBiAAQQA2AgRBZiEEAkACQAJ/AkACQCACQQFrDgIBAAQLQWAhBCABQdUIQQkQIA0DIAFBCWoMAQtBYCEEIAFBzAhBCBAgDQIgAUEIagsiBEHICkEDECANACAEQQNqIANBDGoQQCIBRQ0AQWYhBCADKAIMQRNHDQEgAUHUCkEDECANACABQQNqIANBDGoQQCIBRQ0AIAAgAygCDDYCLCABQcwKQQMQIA0AIAFBA2ogA0EMahBAIgFFDQAgACADKAIMNgIoIAFB0ApBAxAgDQAgAUEDaiADQQxqEEAiAUUNACAAIAMoAgwiAjYCMCAAIAI2AjQgAS0AACICQSRHDQAgAyAFNgIMIAAoAhAgBSABIAJBJEZqIgEgARAhQQAgA0EMaiADQQhqQQMQZw0AIAAgAygCDDYCFCADKAIIIgEtAAAiAkEkRw0AIAMgBjYCDCAAKAIAIAYgASACQSRGaiIBIAEQIUEAIANBDGogA0EIakEDEGcNACAAIAMoAgw2AgQgAygCCCEBIAAQWCIEDQFBYEEAIAEtAAAbIQQMAQtBYCEECyADQRBqJAAgBAuTAgEEfyMAQTBrIggkACAIQQA2AgQgCEEQaiIJIAYgBxBLIAggBikAEDcCCCMAQeACayIGJAAgBkEgaiIKQsAAIAhBBGoiCyAJEF0gBkHgAGoiByAKECQgCkHAABAIIAcgBCAFEAsgB0GQkQJCACAFfUIPgxALIAcgASACEAsgB0GQkQJCACACfUIPgxALIAZBGGoiBCAFEBAgByAEQggQCyAEIAIQECAHIARCCBALIAcgBhAjIAdBgAIQCCAGIAMQPSEDIAZBEBAIAkAgAEUNACADBEAgAEEAIAKnEA8aQX8hAwwBCyAAIAEgAiALQQEgCRBcQQAhAwsgBkHgAmokACADIQAgCUEgEAggCEEwaiQAIAAL7AEBBH8jAEEwayIJJAAgCUEANgIEIAlBEGoiCiAHIAgQSyAJIAcpABA3AggjAEHQAmsiCCQAIAhBEGoiC0LAACAJQQRqIgwgChBdIAhB0ABqIgcgCxAkIAtBwAAQCCAHIAUgBhALIAdBkJECQgAgBn1CD4MQCyAAIAMgBCAMQQEgChBcIAcgACAEEAsgB0GQkQJCACAEfUIPgxALIAhBCGoiACAGEBAgByAAQggQCyAAIAQQECAHIABCCBALIAcgARAjIAdBgAIQCCACBEAgAkIQNwMACyAIQdACaiQAIApBIBAIIAlBMGokAEEACxAAIAAgASACIAMgBCAFEG8LegECfyAAQcD/AHNBAWpBCHZBf3NBL3EgAEHB/wBzQQFqQQh2QX9zQStxIABB5v8DakEIdkH/AXEiASAAQcEAanFyciAAQcz/A2pBCHYiAiAAQccAanEgAUH/AXNxciAAQfwBaiAAQcL/A2pBCHZxIAJBf3NxQf8BcXILewECfyAAQcD/AXNBAWpBCHZBf3NB3wBxIABBwf8Ac0EBakEIdkF/c0EtcSAAQeb/A2pBCHZB/wFxIgEgAEHBAGpxcnIgAEHM/wNqQQh2IgIgAEHHAGpxIAFB/wFzcXIgAEH8AWogAEHC/wNqQQh2cSACQX9zcUH/AXFyCz0AIAACfyACBEAgACACKAAANgIwIAIoAAQMAQsgAEEANgIwQQALNgI0IAAgASgAADYCOCAAIAEoAAQ2AjwLDwAgACABIAIgA0EAEKEBC6sIAQh/IwBB0ARrIgkkAEF/IQogAEEgaiEHQSAhBUEBIQgDQCAHIAVBAWsiBWotAAAiCyAFQcAVai0AACIMa0EIdSAIcSAGQf8BcXIhBiALIAxzQf//A2pBCHYgCHEhCCAFDQALAkAgBkUNACAAEFENACADLQAfQX9zQf8AcSEFQR4hBgNAIAUgAyAGai0AAEF/c3IhBSAGQQFrIgYNAAsgBUH/AXFBAWtB7AEgAy0AAGtxQRd0QR91QX9GDQAgAxBRDQAgCUGAAWogAxB+DQAgCUGAA2oiBSAEEGogBSAAQiAQGxogBSADQiAQGxogBSABIAIQGxogBSAJQcACaiIBECcgARBQIwBB4BFrIgQkACAEQeAPaiABEHsgBEHgDWogBxB7IARB4ANqIgMgCUGAAWoiBRAZIARBwAJqIgEgBRA6IAQgARATIAEgBCADEBogBEGgAWoiAyABEBMgBEGABWoiBSADEBkgASAEIAUQGiADIAEQEyAEQaAGaiIFIAMQGSABIAQgBRAaIAMgARATIARBwAdqIgUgAxAZIAEgBCAFEBogAyABEBMgBEHgCGoiBSADEBkgASAEIAUQGiADIAEQEyAEQYAKaiIFIAMQGSABIAQgBRAaIAMgARATIARBoAtqIgUgAxAZIAEgBCAFEBogAyABEBMgBEHADGogAxAZIAlBCGoiCBAwIAhBKGoQHCAIQdAAahAcQf8BIQMCQANAAkAgAyIBIARB4A9qai0AAA0AIARB4A1qIAFqLQAADQAgAUEBayEDIAENAQwCCwsgAUEASA0AA0AgBEHAAmogCBAxAkAgASIDIARB4A9qaiwAACIBQQBKBEAgBEGgAWoiBSAEQcACaiIGEBMgBiAFIARB4ANqIAFB/gFxQQF2QaABbGoQGgwBCyABQQBODQAgBEGgAWoiBSAEQcACaiIGEBMgBiAFIARB4ANqQQAgAWtB/gFxQQF2QaABbGoQfAsCQCAEQeANaiADaiwAACIHQQBKBEAgBEGgAWoiASAEQcACaiIFEBMgBSABIAdB/gFxQQF2QfgAbEGgDGoQUwwBCyAHQQBODQAgBEGgAWoiBSAEQcACaiIBEBMjAEEwayIKJAAgASAFQShqIgsgBRASIAFBKGoiBiALIAUQFSABQdAAaiILIAFBACAHa0H+AXFBAXZB+ABsQaAMaiIMQShqEAogBiAGIAwQCiABQfgAaiIHIAxB0ABqIAVB+ABqEAogCiAFQdAAaiIFIAUQEiABIAsgBhAVIAYgCyAGEBIgCyAKIAcQFSAHIAogBxASIApBMGokAAsgCCAEQcACahA7IANBAWshASADQQBKDQALCyAEQeARaiQAIAlBoAJqIgEgCBBUQX8gASAAEIYBIAAgAUYbIAAgAUEgEE9yIQoLIAlB0ARqJAAgCgsUACAAIAEgAiADIARBABCjARpBAAvnIAI8fgR/IwBBsARrIkQkACBEQeACaiJFIAUQaiBEQaACaiJCIARCIBA1GiBFIERBwAJqQiAQGxogRSACIAMQGxogRSBEQeABaiJDECcgBCkAICEIIAQpACghByAEKQAwIQYgACAEKQA4NwA4IAAgBjcAMCAAIAc3ACggAEEgaiIEIAg3AAAgQxBQIEQgQxBSIAAgRBBUIEUgBRBqIEUgAELAABAbGiBFIAIgAxAbGiBFIERBoAFqIgAQJyAAEFAgQiBCLQAAQfgBcToAACBCIEItAB9BP3FBwAByOgAfIAAQDiEQIAA1AAIhLSAAQQVqEA4hLiAANQAHIS8gADUACiEwIABBDWoQDiE2IAA1AA8hNyAAQRJqEA4hOCAAQRVqEA4hOSAANQAXIQ8gAEEaahAOIQkgADUAHCEMIEIQDiExIEI1AAIhOiBCQQVqEA4hOyBCNQAHISogQjUACiErIEJBDWoQDiE8IEI1AA8hDiBCQRJqEA4hDSBCQRVqEA4hCCBCNQAXIQcgQkEaahAOIQYgQjUAHCEDIEMQDiE+IEM1AAIhPyBDQQVqEA4hQCBDNQAHIUEgQzUACiE9IENBDWoQDiERIEM1AA8hLCBDQRJqEA4hCiBDQRVqEA4hCyAEIANCB4giEiAJQgKIQv///wCDIhN+IAZCAohC////AIMiFCAMQgeIIhV+fCATIBR+IAdCBYhC////AIMiFiAVfnwgEiAPQgWIQv///wCDIhd+fCIYQoCAQH0iD0IVh3wiCUKAgEB9IgxCFYcgEiAVfiIDIANCgIBAfSIDQoCAgH+DfXwiMkKDoVZ+IANCFYciM0LRqwh+fCA8QgGIQv///wCDIhkgE34gK0IEiEL///8AgyIaIBV+fCAOQgaIQv///wCDIhsgF358IAhC////AIMiHCA4QgOIQv///wCDIh1+fCANQgOIQv///wCDIh4gOUL///8AgyIffnwgFiA3QgaIQv///wCDIiB+fCAUIDZCAYhC////AIMiIX58IBIgMEIEiEL///8AgyIifnwgEyAafiAqQgeIQv///wCDIiMgFX58IBcgGX58IBsgH358IBwgIH58IB0gHn58IBYgIX58IBQgIn58IBIgL0IHiEL///8AgyIkfnwiCEKAgEB9IgdCFYd8IgN8IANCgIBAfSIGQoCAgH+DfSAIIDNC04xDfnwgMkLRqwh+fCAJIAxCgICAf4N9IjRCg6FWfnwgB0KAgIB/g30gEyAjfiA7QgKIQv///wCDIiUgFX58IBcgGn58IBkgH358IBsgHX58IBwgIX58IB4gIH58IBYgIn58IBQgJH58IBIgLkICiEL///8AgyImfnwgEyAlfiA6QgWIQv///wCDIicgFX58IBcgI358IBogH358IBkgHX58IBsgIH58IBwgIn58IB4gIX58IBYgJH58IBQgJn58IBIgLUIFiEL///8AgyIofnwiNkKAgEB9IjdCFYd8IjhCgIBAfSI5QhWHfCI6QoCAQH0iO0IVh3wiKkKAgEB9IitCFYcgEyAbfiAVIBl+fCAcIB9+fCAXIB5+fCAWIB1+fCAUICB+fCASICF+fCIDIDNCg6FWfnwgA0KAgEB9IgdCgICAf4N9IAZCFYd8IgMgA0KAgEB9IgZCgICAf4N9fCI1QoOhVn4gFyAcfiAVIBt+fCATIB5+fCAWIB9+fCAUIB1+fCASICB+fCAHQhWHfCIDIANCgIBAfSINQoCAgH+DfSAGQhWHfCItQtGrCH58IB8gJ34gMUL///8AgyIpIBd+fCAdICV+fCAgICN+fCAaICF+fCAZICJ+fCAbICR+fCAcICh+fCAeICZ+fCAWIBBC////AIMiEH58IEM1ABdCBYhC////AIN8IB0gJ34gHyApfnwgICAlfnwgISAjfnwgGiAifnwgGSAkfnwgGyAmfnwgECAcfnwgHiAofnwgC0L///8Ag3wiC0KAgEB9IglCFYh8IgwgGCAPQoCAgH+DfSATIBZ+IBUgHH58IBQgF358IBIgH358IBUgHn4gEyAcfnwgFiAXfnwgFCAffnwgEiAdfnwiCEKAgEB9IgdCFYd8IgZCgIBAfSIDQhWHfCIuQpjaHH4gNEKT2Ch+fCAGIANCgICAf4N9Ii9C5/YnfnwgCCAHQoCAgH+DfSANQhWHfCIwQtOMQ358fCAMQoCAQH0iDkKAgIB/g30gL0KY2hx+IC5Ck9gofnwgMELn9id+fCALfCAJQoCAgH+DfSAgICd+IB0gKX58ICEgJX58ICIgI358IBogJH58IBkgJn58IBsgKH58IBAgHn58IApCA4hC////AIN8ICEgJ34gICApfnwgIiAlfnwgIyAkfnwgGiAmfnwgGSAofnwgECAbfnwgLEIGiEL///8Ag3wiC0KAgEB9IglCFYh8IgxCgIBAfSIIQhWIfCIHQoCAQH0iBkIVh3wiA3wgA0KAgEB9Ig9CgICAf4N9IAcgLULTjEN+fCAwQpjaHH4gL0KT2Ch+fCAMfCAIQoCAgH+DfSALIDBCk9gofnwgIiAnfiAhICl+fCAkICV+fCAjICZ+fCAaICh+fCAQIBl+fCARQgGIQv///wCDfCAkICd+ICIgKX58ICUgJn58ICMgKH58IBAgGn58ID1CBIhC////AIN8IjxCgIBAfSI9QhWIfCIRQoCAQH0iLEIViHwgCUKAgIB/g30iCkKAgEB9IhhCFYd8Ig1CgIBAfSILQhWHfCAGQoCAgH+DfSA1QtGrCH58ICogK0KAgIB/g30iMUKDoVZ+fCIJQoCAQH0iDEIVh3wiCEKAgEB9IgdCFYcgFyAnfiATICl+fCAfICV+fCAdICN+fCAaICB+fCAZICF+fCAbICJ+fCAcICZ+fCAeICR+fCAWICh+fCAQIBR+fCBDQRpqEA5CAohC////AIN8IgMgNEKY2hx+IDJCk9gofnwgLkLn9id+fCAvQtOMQ358IDBC0asIfnx8IA5CFYh8IANCgIBAfSIGQoCAgH+DfSIDIC1Cg6FWfnwgD0IVh3wgA0KAgEB9Ig9CgICAf4N9IgN8IANCgIBAfSIOQoCAgH+DfSAIIAdCgICAf4N9IAkgDEKAgIB/g30gDSAtQuf2J358IAtCgICAf4N9IDVC04xDfnwgMULRqwh+fCA6IDtCgICAf4N9IDJC04xDfiAzQuf2J358IDRC0asIfnwgLkKDoVZ+fCA4fCA5QoCAgH+DfSAyQuf2J34gM0KY2hx+fCA0QtOMQ358IDZ8IC5C0asIfnwgL0KDoVZ+fCA3QoCAgH+DfSATICd+IBUgKX58IBcgJX58IB8gI358IBogHX58IBkgIH58IBsgIX58IBwgJH58IB4gIn58IBYgJn58IBAgEn58IBQgKH58IEM1ABxCB4h8IAZCFYh8Ig1CgIBAfSILQhWHfCIJQoCAQH0iDEIVh3wiBkKAgEB9IgNCFYd8IipCg6FWfnwgLUKY2hx+IAp8IBhCgICAf4N9IDVC5/YnfnwgMULTjEN+fCAqQtGrCH58IAYgA0KAgIB/g30iK0KDoVZ+fCIIQoCAQH0iB0IVh3wiBkKAgEB9IgNCFYd8IAYgA0KAgIB/g30gCCAHQoCAgH+DfSARICxCgICAf4N9IC1Ck9gofnwgNUKY2hx+fCAxQuf2J358IAkgDEKAgIB/g30gMkKY2hx+IDNCk9gofnwgNELn9id+fCAuQtOMQ358IC9C0asIfnwgMEKDoVZ+fCANfCALQoCAgH+DfSAPQhWHfCINQoCAQH0iC0IVh3wiCkKDoVZ+fCAqQtOMQ358ICtC0asIfnwgJiAnfiAkICl+fCAlICh+fCAQICN+fCBBQgeIQv///wCDfCAnICh+ICYgKX58IBAgJX58IEBCAohC////AIN8IhhCgIBAfSIPQhWIfCIJQoCAQH0iDEIViCA8fCA9QoCAgH+DfSA1QpPYKH58IDFCmNocfnwgCkLRqwh+fCAqQuf2J358ICtC04xDfnwiCEKAgEB9IgdCFYd8IgZCgIBAfSIDQhWHfCAGIA0gC0KAgIB/g30gDkIVh3wiEUKAgEB9IixCFYciDkKDoVZ+fCADQoCAgH+DfSAIIA5C0asIfnwgB0KAgIB/g30gCSAMQoCAgH+DfSAxQpPYKH58IApC04xDfnwgKkKY2hx+fCArQuf2J358IBggECAnfiAoICl+fCA/QgWIQv///wCDfCAQICl+ID5C////AIN8Ig1CgIBAfSILQhWIfCIJQoCAQH0iDEIViHwgD0KAgID///8Pg30gCkLn9id+fCAqQpPYKH58ICtCmNocfnwiCEKAgEB9IgdCFYd8IgZCgIBAfSIDQhWHfCAGIA5C04xDfnwgA0KAgIB/g30gCCAOQuf2J358IAdCgICAf4N9IAkgDEKAgID///8Pg30gCkKY2hx+fCArQpPYKH58IA0gC0KAgID///8Dg30gCkKT2Ch+fCIIQoCAQH0iB0IVh3wiBkKAgEB9IgNCFYd8IAYgDkKY2hx+fCADQoCAgH+DfSAIIAdCgICAf4N9IA5Ck9gofnwiCkIVh3wiDkIVh3wiBkIVh3wiA0IVh3wiGEIVh3wiD0IVh3wiDUIVh3wiC0IVh3wiCUIVh3wiDEIVh3wiCEIVhyARICxCgICAf4N9fCIHQhWHIhFCk9gofiAKQv///wCDfCIsPAAAIAQgLEIIiDwAASAEIBFCmNocfiAOQv///wCDfCAsQhWHfCIKQguIPAAEIAQgCkIDiDwAAyAEIBFC5/YnfiAGQv///wCDfCAKQhWHfCIOQgaIPAAGIAQgLEIQiEIfgyAKQv///wCDIgZCBYaEPAACIAQgEULTjEN+IANC////AIN8IA5CFYd8IgpCCYg8AAkgBCAKQgGIPAAIIAQgDkL///8AgyIDQgKGIAZCE4iEPAAFIAQgEULRqwh+IBhC////AIN8IApCFYd8IhhCDIg8AAwgBCAYQgSIPAALIAQgCkL///8AgyIGQgeGIANCDoiEPAAHIAQgEUKDoVZ+IA9C////AIN8IBhCFYd8Ig9CB4g8AA4gBCAYQv///wCDIgNCBIYgBkIRiIQ8AAogBCANQv///wCDIA9CFYd8Ig1CCog8ABEgBCANQgKIPAAQIAQgD0L///8AgyIGQgGGIANCFIiEPAANIAQgC0L///8AgyANQhWHfCILQg2IPAAUIAQgC0IFiDwAEyAEIA1C////AIMiA0IGhiAGQg+IhDwADyAEIAlC////AIMgC0IVh3wiCTwAFSAEIAtCA4YgA0ISiIQ8ABIgBCAJQgiIPAAWIAQgDEL///8AgyAJQhWHfCIGQguIPAAZIAQgBkIDiDwAGCAEIAhC////AIMgBkIVh3wiA0IGiDwAGyAEIAlCEIhCH4MgBkL///8AgyIGQgWGhDwAFyAEIAdC////AIMgA0IVh3wiB0IRiDwAHyAEIAdCCYg8AB4gBCAHQgGIPAAdIAQgA0L///8AgyIDQgKGIAZCE4iEPAAaIAQgB0IHhiADQg6IhDwAHCBCQcAAEAggQ0HAABAIIAEEQCABQsAANwMACyBEQbAEaiQAQQALtgECAX8DfiMAQaABayIDJAAgASACQiAQNRogASABLQAAQfgBcToAACABIAEtAB9BP3FBwAByOgAfIAMgARBSIAAgAxBUIAIpAAghBCACKQAQIQUgAikAACEGIAEgAikAGDcAGCABIAU3ABAgASAENwAIIAEgBjcAACAAKQAIIQQgACkAECEFIAApAAAhBiABIAApABg3ADggASAFNwAwIAEgBDcAKCABIAY3ACAgA0GgAWokAEEAC5oBAgF+An8gAkEITwRAIAJBA3YhBEEAIQIDQCAAIAJBA3QiBWogASAFaikDACIDQiiGQoCAgICAgMD/AIMgA0I4hoQgA0IYhkKAgICAgOA/gyADQgiGQoCAgIDwH4OEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhDcAACACQQFqIgIgBEcNAAsLC9YBAQN/IwBB4AJrIgkkACAJQSBqIgpCwAAgBiAHEDMgCUHgAGoiCCAKECQgCkHAABAIIAggBCAFEAsgCEGQigJCACAFfUIPgxALIAggASACEAsgCEGQigJCACACfUIPgxALIAlBGGoiBCAFEBAgCCAEQggQCyAEIAIQECAIIARCCBALIAggCRAjIAhBgAIQCCAJIAMQPSEDIAlBEBAIAkAgAEUNACADBEAgAEEAIAKnEA8aQX8hAwwBCyAAIAEgAiAGQQEgBxAuQQAhAwsgCUHgAmokACADC7MBAQN/IwBB4AJrIggkACAIQSBqIgogBiAHEI0BIAhB4ABqIgkgChAkIApBwAAQCCAJIAQgBRALIAhBGGoiBCAFEBAgCSAEQggQCyAJIAEgAhALIAQgAhAQIAkgBEIIEAsgCSAIECMgCUGAAhAIIAggAxA9IQMgCEEQEAgCQCAARQ0AIAMEQCAAQQAgAqcQDxpBfyEDDAELIAAgASACIAYgBxCMAUEAIQMLIAhB4AJqJAAgAwuzAQEDfyMAQdACayIKJAAgCkEQaiILQsAAIAcgCBAzIApB0ABqIgkgCxAkIAtBwAAQCCAJIAUgBhALIAlBkIoCQgAgBn1CD4MQCyAAIAMgBCAHQQEgCBAuIAkgACAEEAsgCUGQigJCACAEfUIPgxALIApBCGoiACAGEBAgCSAAQggQCyAAIAQQECAJIABCCBALIAkgARAjIAlBgAIQCCACBEAgAkIQNwMACyAKQdACaiQAQQALkAEBA38jAEHQAmsiCiQAIApBEGoiCyAHIAgQjQEgCkHQAGoiCSALECQgC0HAABAIIAkgBSAGEAsgCkEIaiIFIAYQECAJIAVCCBALIAAgAyAEIAcgCBCMASAJIAAgBBALIAUgBBAQIAkgBUIIEAsgCSABECMgCUGAAhAIIAIEQCACQhA3AwALIApB0AJqJABBAAsrAQJ/A0AgACACaiIDIAMtAAAgASACai0AAHM6AAAgAkEBaiICQQhHDQALCzIBA39BASEBA0AgACACaiIDIAEgAy0AAGoiAToAACABQQh2IQEgAkEBaiICQQRHDQALC7oBAQF/IwBBwAFrIgQkACACRSABQcEAa0H/AXFBvwFNciADQcEAa0H/AXFBvwFNckUEQCAEQYECOwGCASAEIAM6AIEBIAQgAToAgAEgBEGAAWoiAUEEchByIAFBCHJCABAQIARBkAFqQQBBMBAPGiAAIAEQcyADIARqQQBBAEGAASADayADQRh0QRh1QQBIGxAPGiAAIAQgAiADEBEiAEKAARA4GiAAQYABEAggAEHAAWokAEEADwsQFAALYgEBfyMAQUBqIgIkACABQcEAa0H/AXFBvwFNBEAQFAALIAJBAToAAyACQYACOwABIAIgAToAACACQQRyEHIgAkEIckIAEBAgAkEQakEAQTAQDxogACACEHMgAkFAayQAQQALGQAgACABIAIgA0IBIARB5JECKAIAERIAGgtqAQN/IwBBEGsiAyQAIANBADoAD0F/IQUgACABIAJB2JECKAIAEQIARQRAA0AgAyAAIARqLQAAIAMtAA9yOgAPIARBAWoiBEEgRw0ACyADLQAPQRd0QYCAgARrQR91IQULIANBEGokACAFC8MIAgd/DH4jAEHQAmsiBCQAQX8hByMAQRBrIgZBADYACyAGQQA2AggDQCACIAVqLQAAIQhBACEDA0AgBkEIaiADaiIJIAktAAAgA0EFdEHghwJqIAVqLQAAIAhzcjoAACADQQFqIgNBB0cNAAsgBUEBaiIFQR9HDQALIAItAB9B/wBxIQhBACEFQQAhAwNAIAZBCGogA2oiCSAJLQAAIAggA0EFdEH/hwJqLQAAc3I6AAAgA0EBaiIDQQdHDQALQQAhAwNAIAZBCGogBWotAABBAWsgA3IhAyAFQQFqIgVBB0cNAAsgA0EIdkEBcUUEQEEAIQcDQCAAIAdqIAEgB2otAAA6AAAgB0EBaiIHQSBHDQALIAAgAC0AAEH4AXE6AAAgACAALQAfQT9xQcAAcjoAHyAEQaACaiIBIAIQgQEgBEHwAWoQHCAEQcABahAwIARBkAFqIAEQKSAEQeAAahAcQf4BIQJBACEBA0AgBEHwAWoiCCAEQZABaiIJIAEgACACIgdBA3ZqLQAAIAJBB3F2QQFxIgFzIgYQOSAEQcABaiIFIARB4ABqIgMgBhA5IAJBAWshAiAEQTBqIgYgCSADEBUgBCAIIAUQFSAIIAggBRASIAUgCSADEBIgAyAGIAgQCiAFIAUgBBAKIAYgBBANIAQgCBANIAkgAyAFEBIgBSADIAUQFSAIIAQgBhAKIAQgBCAGEBUgBSAFEA0gBDQCBCEKIAQ0AgghCyAENAIMIQwgBDQCECENIAQ0AhQhDiAENAIYIQ8gBDQCACETIAMgBDQCJELCtgd+IhAgEEKAgIAIfCIQQoCAgPAPg30gBDQCIELCtgd+IAQ0AhxCwrYHfiIRQoCAgAh8IhJCGYd8IhRCgICAEHwiFUIaiHw+AiQgAyAUIBVCgICA4A+DfT4CICADIBEgEkKAgIDwD4N9IA9CwrYHfiAOQsK2B34iDkKAgIAIfCIPQhmHfCIRQoCAgBB8IhJCGoh8PgIcIAMgESASQoCAgOAPg30+AhggAyAOIA9CgICA8A+DfSANQsK2B34gDELCtgd+IgxCgICACHwiDUIZh3wiDkKAgIAQfCIPQhqIfD4CFCADIA4gD0KAgIDgD4N9PgIQIAMgDCANQoCAgPAPg30gC0LCtgd+IApCwrYHfiIKQoCAgAh8IgtCGYd8IgxCgICAEHwiDUIaiHw+AgwgAyAMIA1CgICA4A+DfT4CCCADIAogC0KAgIDwD4N9IBBCGYdCE34gE0LCtgd+fCIKQoCAgBB8IgtCGoh8PgIEIAMgCiALQoCAgOAPg30+AgAgCSAJEA0gBiAGIAMQEiADIARBoAJqIAUQCiAFIAQgBhAKIAcNAAsgBEHwAWoiAiAEQZABaiABEDkgBEHAAWoiAyAEQeAAaiABEDkgAyADEDwgAiACIAMQCiAAIAIQLEEAIQcLIARB0AJqJAAgBwsLACAAIAEQggFBAAsNACAAIAEgAhCDAUEACwsAIAAgARCEAUEACyoBAX8jAEEQayIEJAAgBCABIAIgAxCFARogACAEED0hACAEQRBqJAAgAAsmAQJ/AkBBoJwCKAIAIgBFDQAgACgCFCIARQ0AIAARAQAhAQsgAQsOACAAIAGtQYAIIAIQMwsqAQJ/IABBAk8Ef0EAIABrIABwIQEDQBBbIgIgAUkNAAsgAiAAcAUgAQsLMAEBfiABrSACrUIghoQiA0KAgICAEFoEQEHrCUHfCEHFAUGMCBAAAAsgACADpxAdCxIAIAAgASACrSADrUIghoQQGwsVACAAIAEgAq0gA61CIIaEIAQQoAELFwAgACABIAIgA60gBK1CIIaEIAUQogELiQEBAX4CfwJAAkACQCADrSAErUIghoQiBkLAAFQNACAGQkB8IgZCv////w9WDQAgAiACQUBrIgMgBiAFEKABRQ0BIABFDQAgAEEAIAanEA8aC0F/IQIgAUUNASABQgA3AwBBfwwCCyABBEAgASAGNwMAC0EAIQIgAEUNACAAIAMgBqcQRhoLIAILC38CAX8BfiMAQRBrIgYkACAAIAZBCGogAEFAayACIAOtIAStQiCGhCIHpyICEEYgByAFEKIBGgJAIAYpAwhCwABSBEAgAQRAIAFCADcDAAsgAEEAIAJBQGsQDxpBfyEADAELQQAhACABRQ0AIAEgB0JAfTcDAAsgBkEQaiQAIAALqgcBCX4gBCkAACIFQvXKzYPXrNu38wCFIQYgBULh5JXz1uzZvOwAhSEHIAQpAAgiBULt3pHzlszct+QAhSEJIAVC88rRy6eM2bL0AIUhCiABIAEgAq0gA61CIIaEIginIgJqIAJBB3EiA2siAkcEQANAIAEpAAAhDSAJQQ0QDCEMIAYgCXwiBkEgEAwhCSAKIA2FIgVBEBAMIAUgB3wiB4UiC0EVEAwhCiAGIAyFIgVBERAMIQYgBSAHfCIFQSAQDCEHIAUgBoUiBkENEAwhDCAGIAkgC3wiBXwiC0EgEAwgBSAKhSIFQRAQDCAFIAd8IgeFIgV8IgYgBUEVEAyFIQogCyAMhSIFQREQDCAFIAd8IgWFIQkgBiANhSEGIAVBIBAMIQcgAUEIaiIBIAJHDQALIAIhAQsgCEI4hiEIAkACQAJAAkACQAJAAkACQCADQQFrDgcGBQQDAgEABwsgATEABkIwhiAIhCEICyABMQAFQiiGIAiEIQgLIAExAARCIIYgCIQhCAsgATEAA0IYhiAIhCEICyABMQACQhCGIAiEIQgLIAExAAFCCIYgCIQhCAsgCCABMQAAhCEICyAJQQ0QDCELIAYgCXwiBkEgEAwhCSAIIAqFIgVBEBAMIAUgB3wiB4UiCkEVEAwhDCAGIAuFIgVBERAMIQYgBSAHfCIFQSAQDCEHIAUgBoUiBkENEAwhCyAGIAkgCnwiBXwiBkEgEAwhCSAFIAyFIgVBEBAMIAUgB3wiB4UiCkEVEAwhDCAGIAuFIgVBERAMIQYgBSAHfCIFQSAQDCEHIAUgBoUiBkENEAwhCyAGIAggCSAKfCIFhXwiBkEgEAwhCSAFIAyFIgVBEBAMIAdC/wGFIAV8IgeFIgpBFRAMIQwgBiALhSIFQREQDCEGIAUgB3wiBUEgEAwhByAFIAaFIgZBDRAMIQsgBiAJIAp8IgV8IgZBIBAMIQkgBSAMhSIFQRAQDCAFIAd8IgeFIgpBFRAMIQwgBiALhSIFQREQDCEGIAUgB3wiBUEgEAwhByAFIAaFIgZBDRAMIQsgBiAJIAp8IgV8IgZBIBAMIQggBSAMhSIFQRAQDCAFIAd8IgeFIglBFRAMIQogBiALhSIFQREQDCEGIAUgB3wiBUEgEAwhDCAFIAaFIgtBDRAMIQcgACAKIAggCXwiBoUiBUEQEAwgBSAMfCIFhUEVEAwgByAGIAt8hSIGIAV8IgWFIAZBERAMhSAFQSAQDIUQEEEAC6gDAgN+AX8CfyAFrSAGrUIghoQhCiAIrSAJrUIghoQhDCMAQeACayIFJAAgAgRAIAJCADcDAAsgAwRAIANB/wE6AAALQX8hDQJAAkAgCkIRVA0AIApCEX0iC0Lv////D1oNASAFQSBqIghCwAAgAEEgaiIJIAAQMyAFQeAAaiIGIAgQJCAIQcAAEAggBiAHIAwQCyAGQYCKAkIAIAx9Qg+DEAsgCEEAQcAAEA8aIAUgBC0AADoAICAIIAhCwAAgCUEBIAAQLiAFLQAgIQcgBSAELQAAOgAgIAYgCELAABALIAYgBEEBaiIEIAsQCyAGQYCKAiAKQgF9Qg+DEAsgBUEYaiIIIAwQECAGIAhCCBALIAggCkIvfBAQIAYgCEIIEAsgBiAFECMgBkGAAhAIIAUgBCALp2pBEBBPBEAgBUEQEAgMAQsgASAEIAsgCUECIAAQLiAAQSRqIAUQqgEgCRCrAQJAIAdBAnFFBEAgCUEEEHVFDQELIAAQbAsgAgRAIAIgCzcDAAtBACENIANFDQAgAyAHOgAACyAFQeACaiQAIA0MAQsQFAALC9kCAQJ+An8gBK0gBa1CIIaEIQogB60gCK1CIIaEIQsjAEHQAmsiBCQAIAIEQCACQgA3AwALIApC7////w9UBEAgBEEQaiIHQsAAIABBIGoiCCAAEDMgBEHQAGoiBSAHECQgB0HAABAIIAUgBiALEAsgBUGAigJCACALfUIPgxALIAdBAEHAABAPGiAEIAk6ABAgByAHQsAAIAhBASAAEC4gBSAHQsAAEAsgASAELQAQOgAAIAFBAWoiASADIAogCEECIAAQLiAFIAEgChALIAVBgIoCIApCD4MQCyAEQQhqIgMgCxAQIAUgA0IIEAsgAyAKQkB9EBAgBSADQggQCyAFIAEgCqdqIgEQIyAFQYACEAggAEEkaiABEKoBIAgQqwECQCAJQQJxRQRAIAhBBBB1RQ0BCyAAEGwLIAIEQCACIApCEXw3AwALIARB0AJqJABBAAwBCxAUAAsLLQEBfiACrSADrUIghoQiBkIQWgR/IAAgAUEQaiABIAZCEH0gBCAFEGIFQX8LCxgAIAAgASACIAOtIAStQiCGhCAFIAYQYgsxAQF+IAKtIAOtQiCGhCIGQvD///8PWgRAEBQACyAAQRBqIAAgASAGIAQgBRBjGkEACxgAIAAgASACIAOtIAStQiCGhCAFIAYQYwtSAQF+An8gAa0gAq1CIIaEIQQgAEH7CkEKECBFBEAgACAEIANBAhCXAQwBCyAAQfEKQQkQIEUEQCAAIAQgA0EBEJcBDAELQeCXAkEcNgIAQX8LC8QBAQF+An8gAq0gA61CIIaEIQQgAEH7CkEKECBFBEACQAJAIARCgICAgBBaBEBB4JcCQRY2AgAMAQsgACABIASnQQIQmAEiAEUNASAAQV1HDQBB4JcCQRw2AgALQX8hAAsgAAwBCyAAQfEKQQkQIEUEQAJAAkAgBEKAgICAEFoEQEHglwJBFjYCAAwBCyAAIAEgBKdBARCYASIARQ0BIABBXUcNAEHglwJBHDYCAAtBfyEACyAADAELQeCXAkEcNgIAQX8LC9UBAQJ+An8gAq0gA61CIIaEIQkgBK0gBa1CIIaEIQgCQAJAAkAgB0EBaw4CAgABCyAAIAEgCSAIIAYQlgEMAgsQFAALIwBBEGsiAiQAIABBAEGAARAPIQACfyAGQYGAgIB4SSAIIAmEQv////8PWHFFBEBB4JcCQRY2AgBBfwwBCyAGQf8/SyAIQgNacUUEQEHglwJBHDYCAEF/DAELIAJBEBAdQX9BACAIpyAGQQp2QQEgASAJpyACQRBBAEEgIABBgAFBARA0GwshACACQRBqJAAgAAsLHwAgACABIAKtIAOtQiCGhCAErSAFrUIghoQgBhCWAQu8AwEDfgJ/IAGtIAKtQiCGhCELIAStIAWtQiCGhCENIAetIAitQiCGhCEMAkACQAJAIApBAWsOAgABAgsCfyAAQQAgC6ciARAPIQACQCALQoCAgIAQWgRAQeCXAkEWNgIADAELIAtCD1gEQEHglwJBHDYCAAwBCyAJQYGAgIB4SSAMIA2EQv////8PWHFFBEBB4JcCQRY2AgAMAQsgCUH/P0sgDEIDWnFFBEBB4JcCQRw2AgAMAQsgACADRgRAQeCXAkEcNgIADAELQX9BACAMpyAJQQp2QQEgAyANpyAGQRAgACABQQBBAEEBEDQbDAELQX8LDAILAn8gAEEAIAunIgEQDyEAAkAgC0KAgICAEFoEQEHglwJBFjYCAAwBCyALQg9YBEBB4JcCQRw2AgAMAQsgCUGBgICAeEkgDCANhEL/////D1hxRQRAQeCXAkEWNgIADAELIAxQRSAJQf8/S3FFBEBB4JcCQRw2AgAMAQsgACADRgRAQeCXAkEcNgIADAELQX9BACAMpyAJQQp2QQEgAyANpyAGQRAgACABQQBBAEECEDQbDAELQX8LDAELQeCXAkEcNgIAQX8LC7IDAgN/AX4jAEEgayIGJAAgBCkAACEJIAZCADcDGCAGIAk3AxAgBiACrSADrUIghoQQECAGQgA3AwgCfyABQcEAa0FOTQRAQeCXAkEcNgIAQX8MAQsgBkEQaiEEIAFBwQBrQUBJBH9BfwUCfyMAIgIhByACQYADa0FAcSICJAAgBUUgAEUgAUH/AXEiA0HBAGtB/wFxQb8BTXJyRQRAIwBBwAFrIgEkAAJAIAVFIANBwQBrQf8BcUG/AU1yRQRAIAFBgQI7AYIBIAFBIDoAgQEgASADOgCAASABQYABaiIIQQRyEHIgCEEIckIAEBAgAUIANwOYASABQgA3A5ABAkAgBgRAIAFBgAFqIAYQkQIMAQsgAUIANwOoASABQgA3A6ABCwJAIAQEQCABQYABaiAEEJACDAELIAFCADcDuAEgAUIANwOwAQsgAiABQYABahBzIAFBIGpBAEHgABAPGiACIAEgBUEgEBEiAUKAARA4GiABQYABEAggAUHAAWokAAwBCxAUAAsgAkEAQgAQOBogAiAAIAMQcBogByQAQQAMAQsQFAALCwshACAGQSBqJAAgAAsSACAAIAEgAq0gA61CIIaEEDULEgAgACABIAKtIAOtQiCGhBAlCxkAIAAgASACIAOtIAStQiCGhCAFIAYQnAELTgICfwF+IwBBIGsiBiQAQX8hByACrSADrUIghoQiCEIwWgRAIAYgASAEEI4BIAAgAUEgaiAIQiB9IAYgASAFEI8BIQcLIAZBIGokACAHC5kBAgJ/AX4gAq0gA61CIIaEIQcjAEHgAGsiAiQAQX8hAyACQSBqIAIQkwFFBEAgAkFAayIFIAJBIGoiBiAEEI4BIABBIGogASAHIAUgBCACEJEBIQMgACACKQM4NwAYIAAgAikDMDcAECAAIAIpAyg3AAggACACKQMgNwAAIAJBIBAIIAZBIBAIIAVBGBAICyACQeAAaiQAIAMLGQAgACABIAKtIAOtQiCGhCAEIAUgBhCPAQstAQF+IAKtIAOtQiCGhCIGQhBaBH8gACABQRBqIAEgBkIQfSAEIAUQYAVBfwsLGwAgACABIAIgA60gBK1CIIaEIAUgBiAHEJABCxgAIAAgASACIAOtIAStQiCGhCAFIAYQYAsZACAAIAEgAq0gA61CIIaEIAQgBSAGEJEBCy4BAX4gAq0gA61CIIaEIgZC8P///w9aBEAQFAALIABBEGogACABIAYgBCAFEGELGwAgACABIAIgA60gBK1CIIaEIAUgBiAHEJIBCxgAIAAgASACIAOtIAStQiCGhCAFIAYQYQtIAQF/IwBBIGsiBSQAIAUgASACrSADrUIghoQgBBCUARogACAFEIYBIQEgBSAAQSAQTyECIAVBIGokACACQX8gASAAIAVGG3ILFQAgACABIAKtIAOtQiCGhCAEEJQBC1sBAn4gB60gCK1CIIaEIQxBfyECIAStIAWtQiCGhCILQhBaBEAgACADIAtCEH0gAyALp2pBEGsgBiAMIAkgChCaASECCyABBEAgAUIAIAtCEH0gAhs3AwALIAILJQAgACACIAOtIAStQiCGhCAFIAYgB60gCK1CIIaEIAkgChCaAQtZAQJ+An8gBq0gB61CIIaEIQwgA60gBK1CIIaEIgtC8P///w9UBEAgACAAIAunakEAIAIgCyAFIAwgCSAKEJsBGiABBEAgASALQhB8NwMAC0EADAELEBQACwsnACAAIAEgAiADIAStIAWtQiCGhCAGIAetIAitQiCGhCAKIAsQmwELWwECfiAHrSAIrUIghoQhDEF/IQIgBK0gBa1CIIaEIgtCEFoEQCAAIAMgC0IQfSADIAunakEQayAGIAwgCSAKEKYBIQILIAEEQCABQgAgC0IQfSACGzcDAAsgAgslACAAIAIgA60gBK1CIIaEIAUgBiAHrSAIrUIghoQgCSAKEKYBC1sBAn4gB60gCK1CIIaEIQxBfyECIAStIAWtQiCGhCILQhBaBEAgACADIAtCEH0gAyALp2pBEGsgBiAMIAkgChCnASECCyABBEAgAUIAIAtCEH0gAhs3AwALIAILJQAgACACIAOtIAStQiCGhCAFIAYgB60gCK1CIIaEIAkgChCnAQtZAQJ+An8gBq0gB61CIIaEIQwgA60gBK1CIIaEIgtC8P///w9UBEAgACAAIAunakEAIAIgCyAFIAwgCSAKEKgBGiABBEAgASALQhB8NwMAC0EADAELEBQACwsnACAAIAEgAiADIAStIAWtQiCGhCAGIAetIAitQiCGhCAKIAsQqAELWQECfgJ/IAatIAetQiCGhCEMIAOtIAStQiCGhCILQvD///8PVARAIAAgACALp2pBACACIAsgBSAMIAkgChCpARogAQRAIAEgC0IQfDcDAAtBAAwBCxAUAAsLJwAgACABIAIgAyAErSAFrUIghoQgBiAHrSAIrUIghoQgCiALEKkBC08BAn8jAEHQAGsiBiQAIAJQRQRAIAZBDGoiByAEEAkgBkEQaiIEIAUQRSAEIAMgBxCVASAEIAEgACACEEMgBEHAABAICyAGQdAAaiQAQQAL2gEBBH8jACIFIQcgBUGABGtBQHEiBSQAIAAgASAAGyIIBEBBfyEGIAVB4ABqIAMgBBBeRQRAIAEgACABGyEBQQAhACAFQYABaiIDQQBBAEHAABBCGiADIAVB4ABqIgZCIBAlGiAGQSAQCCADIARCIBAlGiADIAJCIBAlGiADIAVBIGpBwAAQQRogA0GAAxAIA0AgACABaiAFQSBqIABqIgItAAA6AAAgACAIaiACLQAgOgAAIABBAWoiAEEgRw0ACyAFQSBqQcAAEAhBACEGCyAHJAAgBg8LEBQAC9oBAQR/IwAiBSEHIAVBgARrQUBxIgUkACAAIAEgABsiCARAQX8hBiAFQeAAaiADIAQQXkUEQCABIAAgARshAUEAIQAgBUGAAWoiA0EAQQBBwAAQQhogAyAFQeAAaiIGQiAQJRogBkEgEAggAyACQiAQJRogAyAEQiAQJRogAyAFQSBqQcAAEEEaIANBgAMQCANAIAAgCGogBUEgaiAAaiICLQAAOgAAIAAgAWogAi0AIDoAACAAQQFqIgBBIEcNAAsgBUEgakHAABAIQQAhBgsgByQAIAYPCxAUAAsOACABQSAQHSAAIAEQXwsYACABQSAgAkIgQQBBABCcARogACABEF8LBABBCgsFAEHYCgsIACAAQRAQHQsEAEEwC10BA38jAEHQAGsiBiQAIAJQRQRAIAZBCGoiCCAEpxAJIAZBDGogBEIgiKcQCSAGQRBqIgcgBRBFIAcgAyAIEJ8BIAcgASAAIAIQQyAHQcAAEAgLIAZB0ABqJABBAAtWAQF/IwBBQGoiAyQAIAMgAkIgEDUaIAEgAykDGDcAGCABIAMpAxA3ABAgASADKQMINwAIIAEgAykDADcAACADQcAAEAggACABEHchACADQUBrJAAgAAsIAEGAgICABAsEAEEECwgAQYCAgIABCwcAQYCAgCALCABBgICAgHgLBgBBgMAACwUAQfsKCwUAQYABC0YBAX8jAEFAaiIEJAAgAVBFBEAgBCADEEUgBCACQQAQlQEgBCAAQQAgAacQDyIAIAAgARBDIARBwAAQCAsgBEFAayQAQQALBQBBgAMLNwEBfyABEGkgAEEDbiICQX1sIABqIgBBAXYgAHJBAXEgAEEBakEEIAFBAnEbbCACQQJ0akEBagv0AgELfwJAIANFDQACQAJAA0AgByEIA0ACQCACIAhqLQAAIg1B3wFxQTdrQf8BcSIOQfb/A2ogDkHw/wNqc0EIdiIPIA1BMHMiEEH2/wNqQQh2IgpyQf8BcUUEQEEBIQogBEUgC0H/AXFyDQQgBCANEEQNASAIIQcMBgsgASAJTQRAQeCXAkHEADYCAEEAIQoMBAsgDiAPcSAKIBBxciEHAkAgC0H/AXFFBEAgB0EEdCERDAELIAAgCWogByARcjoAACAJQQFqIQkLIAtBf3MhC0EBIQogCEEBaiIHIANJDQIMBAtBACELIAhBAWoiCCADSQ0ACwsgAyAHQQFqIgAgACADSRshBwwCCyAIIQcLIAtB/wFxBEBB4JcCQRw2AgBBfyEMIAdBAWshB0EAIQkMAQsgCg0AQQAhCUF/IQwLAkAgBgRAIAYgAiAHajYCAAwBCyADIAdGDQBB4JcCQRw2AgBBfyEMCyAFBEAgBSAJNgIACyAMC5sBAQN/IANB/v///wdLIANBAXQgAU9yRQRAQQAhASADBH8DQCAAIAFBAXRqIgQgASACai0AACIFQQ9xIgZBCHQgBkH2/wNqQYCyA3FqQYCuAWpBCHY6AAEgBCAFQQR2IgQgBEH2/wNqQQh2QdkBcWpB1wBqOgAAIAFBAWoiASADRw0ACyADQQF0BSABCyAAakEAOgAAIAAPCxAUAAssAQF/IwBBQGoiAyQAIAAgAxAnIAEgA0LAACACQQEQoQEhACADQUBrJAAgAAsuAQF/IwBBQGoiBCQAIAAgBBAnIAEgAiAEQsAAIANBARCjASEAIARBQGskACAACwgAIAAQNkEACywBAX8jAEEgayICJAAgAkEgEB0gACABIAIQpAEaIAJBIBAIIAJBIGokAEEACwsAIAAgASACEKQBCwUAQb9/CwUAQdABC20BAX8jAEFAaiICJAAgAiABQiAQNRogAiACLQAAQfgBcToAACACIAItAB9BP3FBwAByOgAfIAAgAikDEDcAECAAIAIpAwg3AAggACACKQMANwAAIAAgAikDGDcAGCACQcAAEAggAkFAayQAQQALnwQBB38jAEGAAmsiBSQAQX8hCAJAIAEQUQ0AIAVB4ABqIAEQfg0AIwBBoAFrIgYkACMAQeANayICJAAgAkHgA2oiAyAFQeAAaiIEEBkgAkHAAmoiASAEEDogAiABEBMgASACIAMQGiACQaABaiIDIAEQEyACQYAFaiIEIAMQGSABIAIgBBAaIAMgARATIAJBoAZqIgQgAxAZIAEgAiAEEBogAyABEBMgAkHAB2oiBCADEBkgASACIAQQGiADIAEQEyACQeAIaiIEIAMQGSABIAIgBBAaIAMgARATIAJBgApqIgQgAxAZIAEgAiAEEBogAyABEBMgAkGgC2oiBCADEBkgASACIAQQGiADIAEQEyACQcAMaiADEBkgBhB6QfwBIQEDQCACQcACaiAGEDoCQCABIgNB4IUCaiwAACIBQQBKBEAgAkGgAWoiBCACQcACaiIHEBMgByAEIAJB4ANqIAFB/gFxQQF2QaABbGoQGgwBCyABQQBODQAgAkGgAWoiBCACQcACaiIHEBMgByAEIAJB4ANqQQAgAWtB/gFxQQF2QaABbGoQfAsgBiACQcACahATIANBAWshASADDQALIAJB4A1qJAAgBhBWIQEgBkGgAWokACABRQ0AIAUQHCAFIAUgBUGIAWoiAxAVIAVBMGoiARAcIAEgASADEBIgBSAFEDwgASABIAUQCiAAIAEQLEEAIQgLIAVBgAJqJAAgCAtGAQF/IwBBQGoiBCQAIAFQRQRAIAQgAxBFIAQgAkEAEJ8BIAQgAEEAIAGnEA8iACAAIAEQQyAEQcAAEAgLIARBQGskAEEACwQAQQwLogEBBn8jAEEQayIFQQA2AgxBfyEEIAIgA0EBa0sEfyABIAJBAWsiBmohB0EAIQJBACEBQQAhBANAIAUgBSgCDCACQQAgByACay0AACIIQYABc0EBayAFKAIMQQFrIARBAWtxcUEIdkEBcSIJa3FyNgIMIAEgCXIhASAEIAhyIQQgAkEBaiICIANHDQALIAAgBiAFKAIMazYCACABQQFrBSAECwsEAEFuCwQAQRELBABBNAsnAQF+IAAgASACEEsgABBtIAEpABAhAyAAQgA3ACwgACADNwAkQQAL0gEBBH8jAEEQayIFJAACQAJAIANFBEBBfyEHDAELAn8gAyADQQFrIgZxRQRAIAIgBnEMAQsgAiADcAshCEF/IQcgBiAIayIGIAJBf3NPDQEgAiAGaiICIARPDQAgAARAIAAgAkEBajYCAAsgASACaiEAQQAhByAFQQA6AA9BACECA0AgACACayIBIAEtAAAgBS0AD3EgAiAGc0EBa0EYdiIBQYABcXI6AAAgBSAFLQAPIAFyOgAPIAJBAWoiAiADRw0ACwsgBUEQaiQAIAcPCxAUAAstAQF+IAFBGBAdIAAgASACEEsgABBtIAEpABAhAyAAQgA3ACwgACADNwAkQQALFgAgACABKQAANwAwIAAgASkACDcAOAsWACAAIAEpAAA3ACAgACABKQAINwAoC2wBAX9BpJwCKAIABH9BAQVB6JcCQQA2AgAjAEEQayIAJAAgABCKASAAKAIABH8gABCKAUHslwJBAEEoEA8aQQAFQX8LGiAAQRBqJABB5JcCQQE2AgAQiwFBkJwCQRAQHUGknAJBATYCAEEACwvtAgECfyMAQfAAayIHJAAgAlBFBEAgByAFKQAYNwMYIAcgBSkAEDcDECAHIAUpAAA3AwBBCCEGIAcgBSkACDcDCCAHIAMpAAA3A2ADQCAHQeAAaiAGaiAEPAAAIARCCIghBCAGQQFqIgZBEEcNAAsgAkI/VgRAA0BBACEGIAdBIGogB0HgAGogBxBOA0AgACAGaiAHQSBqIAZqLQAAIAEgBmotAABzOgAAQQEhBSAGQQFqIgZBwABHDQALQQghBgNAIAdB4ABqIAZqIgMgBSADLQAAaiIDOgAAIANBCHYhBSAGQQFqIgZBEEcNAAsgAUFAayEBIABBQGshACACQkB8IgJCP1YNAAsLIAJQRQRAQQAhBiAHQSBqIAdB4ABqIAcQTiACpyEDA0AgACAGaiAHQSBqIAZqLQAAIAEgBmotAABzOgAAIAZBAWoiBiADRw0ACwsgB0EgakHAABAIIAdBIBAICyAHQfAAaiQAQQALkQICAn8BfiMAQfAAayIEJAAgAVBFBEAgBCADKQAYNwMYIAQgAykAEDcDECAEIAMpAAA3AwAgBCADKQAINwMIIAIpAAAhBiAEQgA3A2ggBCAGNwNgAkAgAULAAFoEQANAIAAgBEHgAGogBBBOQQghA0EBIQIDQCAEQeAAaiADaiIFIAIgBS0AAGoiAjoAACACQQh2IQIgA0EBaiIDQRBHDQALIABBQGshACABQkB8IgFCP1YNAAsgAVANAQtBACEDIARBIGogBEHgAGogBBBOIAGnIQIDQCAAIANqIARBIGogA2otAAA6AAAgA0EBaiIDIAJHDQALCyAEQSBqQcAAEAggBEEgEAgLIARB8ABqJABBAAumAQEEfyMAQdABayICJAADQCAAIANqIAEgA2otAAA6AAAgA0EBaiIDQSBHDQALIAAgAC0AAEH4AXE6AAAgACAALQAfQT9xQcAAcjoAHyACQTBqIAAQUiMAQeAAayIBJAAgAUEwaiIDIAJBgAFqIgQgAkHYAGoiBRASIAEgBCAFEBUgASABEDwgAiADIAEQCiABQeAAaiQAIAAgAhAsIAJB0AFqJABBAAsLxYYCDQBBgAgLhQNMaWJzb2RpdW1EUkdyYW5kb21ieXRlcwBiNjRfcG9zIDw9IGI2NF9sZW4AY3J5cHRvX2dlbmVyaWNoYXNoX2JsYWtlMmJfZmluYWwAJGFyZ29uMmkAJGFyZ29uMmlkAHJhbmRvbWJ5dGVzL3JhbmRvbWJ5dGVzLmMAc29kaXVtL2NvZGVjcy5jAGNyeXB0b19nZW5lcmljaGFzaC9ibGFrZTJiL3JlZi9ibGFrZTJiLXJlZi5jAGNyeXB0b19nZW5lcmljaGFzaC9ibGFrZTJiL3JlZi9nZW5lcmljaGFzaF9ibGFrZTJiLmMAYnVmX2xlbiA8PSBTSVpFX01BWABvdXRsZW4gPD0gVUlOVDhfTUFYAFMtPmJ1ZmxlbiA8PSBCTEFLRTJCX0JMT0NLQllURVMAJGFyZ29uMmkkdj0AJGFyZ29uMmlkJHY9ACx0PQAscD0AJG09ADEuMC4xOABzb2RpdW1fYmluMmJhc2U2NAAkYXJnb24yaSQAJGFyZ29uMmlkJABBkAsLV7Z4Wf+FctMAvW4V/w8KagApwAEAmOh5/7w8oP+Zcc7/ALfi/rQNSP8AAAAAAAAAALCgDv7TyYb/nhiPAH9pNQBgDL0Ap9f7/59MgP5qZeH/HvwEAJIMrgBB8AsLJ1nxsv4K5ab/e90q/h4U1ABSgAMAMNHzAHd5QP8y45z/AG7FAWcbkABBoAwLwAeFO4wBvfEk//glwwFg3DcAt0w+/8NCPQAyTKQB4aRM/0w9o/91Ph8AUZFA/3ZBDgCic9b/BoouAHzm9P8Kio8ANBrCALj0TACBjykBvvQT/3uqev9igUQAedWTAFZlHv+hZ5sAjFlD/+/lvgFDC7UAxvCJ/u5FvP9Dl+4AEyps/+VVcQEyRIf/EWoJADJnAf9QAagBI5ge/xCouQE4Wej/ZdL8ACn6RwDMqk//Di7v/1BN7wC91kv/EY35ACZQTP++VXUAVuSqAJzY0AHDz6T/lkJM/6/hEP+NUGIBTNvyAMaicgAu2pgAmyvx/pugaP8zu6UAAhGvAEJUoAH3Oh4AI0E1/kXsvwAthvUBo3vdACBuFP80F6UAutZHAOmwYADy7zYBOVmKAFMAVP+IoGQAXI54/mh8vgC1sT7/+ilVAJiCKgFg/PYAl5c//u+FPgAgOJwALae9/46FswGDVtMAu7OW/vqqDv/So04AJTSXAGNNGgDunNX/1cDRAUkuVAAUQSkBNs5PAMmDkv6qbxj/sSEy/qsmy/9O93QA0d2ZAIWAsgE6LBkAySc7Ab0T/AAx5dIBdbt1ALWzuAEActsAMF6TAPUpOAB9Dcz+9K13ACzdIP5U6hQA+aDGAex+6v8vY6j+quKZ/2az2ADijXr/ekKZ/rb1hgDj5BkB1jnr/9itOP+159IAd4Cd/4FfiP9ufjMAAqm3/weCYv5FsF7/dATjAdnykf/KrR8BaQEn/y6vRQDkLzr/1+BF/s84Rf8Q/ov/F8/U/8oUfv9f1WD/CbAhAMgFz//xKoD+IyHA//jlxAGBEXgA+2eX/wc0cP+MOEL/KOL1/9lGJf6s1gn/SEOGAZLA1v8sJnAARLhL/85a+wCV640Atao6AHT07wBcnQIAZq1iAOmJYAF/McsABZuUABeUCf/TegwAIoYa/9vMiACGCCn/4FMr/lUZ9wBtfwD+qYgwAO532//nrdUAzhL+/gi6B/9+CQcBbypIAG807P5gP40Ak79//s1OwP8Oau0Bu9tMAK/zu/5pWa0AVRlZAaLzlAACdtH+IZ4JAIujLv9dRigAbCqO/m/8jv+b35AAM+Wn/0n8m/9edAz/mKDa/5zuJf+z6s//xQCz/5qkjQDhxGgACiMZ/tHU8v9h/d7+uGXlAN4SfwGkiIf/Hs+M/pJh8wCBwBr+yVQh/28KTv+TUbL/BAQYAKHu1/8GjSEANdcO/ym10P/ni50As8vd//+5cQC94qz/cULW/8o+Lf9mQAj/Tq4Q/oV1RP8AQYAUCwEBAEGgFAuwASbolY/CsiewRcP0ifLvmPDV36wF08YzObE4AohtU/wFxxdqcD1N2E+6PAt2DRBnDyogU/osOczGTsf9d5KsA3rs////////////////////////////////////////f+3///////////////////////////////////////9/7v///////////////////////////////////////3/t0/VcGmMSWNac96Le+d4UAEHfFQv88AEQhTuMAb3xJP/4JcMBYNw3ALdMPv/DQj0AMkykAeGkTP9MPaP/dT4fAFGRQP92QQ4AonPW/waKLgB85vT/CoqPADQawgC49EwAgY8pAb70E/97qnr/YoFEAHnVkwBWZR7/oWebAIxZQ//v5b4BQwu1AMbwif7uRbz/6nE8/yX/Of9Fsrb+gNCzAHYaff4DB9b/8TJN/1XLxf/Th/r/GTBk/7vVtP4RWGkAU9GeAQVzYgAErjz+qzdu/9m1Ef8UvKoAkpxm/lfWrv9yepsB6SyqAH8I7wHW7OoArwXbADFqPf8GQtD/Ampu/1HqE//Xa8D/Q5fuABMqbP/lVXEBMkSH/xFqCQAyZwH/UAGoASOYHv8QqLkBOFno/2XS/AAp+kcAzKpP/w4u7/9QTe8AvdZL/xGN+QAmUEz/vlV1AFbkqgCc2NABw8+k/5ZCTP+v4RD/jVBiAUzb8gDGonIALtqYAJsr8f6boGj/sgn8/mRu1AAOBacA6e+j/xyXnQFlkgr//p5G/kf55ABYHjIARDqg/78YaAGBQoH/wDJV/wiziv8m+skAc1CgAIPmcQB9WJMAWkTHAP1MngAc/3YAcfr+AEJLLgDm2isA5Xi6AZREKwCIfO4Bu2vF/1Q19v8zdP7/M7ulAAIRrwBCVKAB9zoeACNBNf5F7L8ALYb1AaN73QAgbhT/NBelALrWRwDpsGAA8u82ATlZigBTAFT/iKBkAFyOeP5ofL4AtbE+//opVQCYgioBYPz2AJeXP/7vhT4AIDicAC2nvf+OhbMBg1bTALuzlv76qg7/RHEV/966O/9CB/EBRQZIAFacbP43p1kAbTTb/g2wF//ELGr/75VH/6SMff+frQEAMynnAJE+IQCKb10BuVNFAJBzLgBhlxD/GOQaADHZ4gBxS+r+wZkM/7YwYP8ODRoAgMP5/kXBOwCEJVH+fWo8ANbwqQGk40IA0qNOACU0lwBjTRoA7pzV/9XA0QFJLlQAFEEpATbOTwDJg5L+qm8Y/7EhMv6rJsv/Tvd0ANHdmQCFgLIBOiwZAMknOwG9E/wAMeXSAXW7dQC1s7gBAHLbADBekwD1KTgAfQ3M/vStdwAs3SD+VOoUAPmgxgHsfur/jz7dAIFZ1v83iwX+RBS//w7MsgEjw9kALzPOASb2pQDOGwb+nlckANk0kv99e9f/VTwf/6sNBwDa9Vj+/CM8ADfWoP+FZTgA4CAT/pNA6gAakaIBcnZ9APj8+gBlXsT/xo3i/jMqtgCHDAn+bazS/8XswgHxQZoAMJwv/5lDN//apSL+SrSzANpCRwFYemMA1LXb/1wq5//vAJoA9U23/15RqgES1dgAq11HADRe+AASl6H+xdFC/670D/6iMLcAMT3w/rZdwwDH5AYByAUR/4kt7f9slAQAWk/t/yc/Tf81Us8BjhZ2/2XoEgFcGkMABchY/yGoiv+V4UgAAtEb/yz1qAHc7RH/HtNp/o3u3QCAUPX+b/4OAN5fvgHfCfEAkkzU/2zNaP8/dZkAkEUwACPkbwDAIcH/cNa+/nOYlwAXZlgAM0r4AOLHj/7MomX/0GG9AfVoEgDm9h7/F5RFAG5YNP7itVn/0C9a/nKhUP8hdPgAs5hX/0WQsQFY7hr/OiBxAQFNRQA7eTT/mO5TADQIwQDnJ+n/xyKKAN5ErQBbOfL+3NJ//8AH9v6XI7sAw+ylAG9dzgDU94UBmoXR/5vnCgBATiYAevlkAR4TYf8+W/kB+IVNAMU/qP50ClIAuOxx/tTLwv89ZPz+JAXK/3dbmf+BTx0AZ2er/u3Xb//YNUUA7/AXAMKV3f8m4d4A6P+0/nZShf850bEBi+iFAJ6wLv7Ccy4AWPflARxnvwDd3q/+lessAJfkGf7aaWcAjlXSAJWBvv/VQV7+dYbg/1LGdQCd3dwAo2UkAMVyJQBorKb+C7YAAFFIvP9hvBD/RQYKAMeTkf8ICXMBQdav/9mt0QBQf6YA9+UE/qe3fP9aHMz+rzvw/wsp+AFsKDP/kLHD/pb6fgCKW0EBeDze//XB7wAd1r3/gAIZAFCaogBN3GsB6s1K/zamZ/90SAkA5F4v/x7IGf8j1ln/PbCM/1Pio/9LgqwAgCYRAF+JmP/XfJ8BT10AAJRSnf7Dgvv/KMpM//t+4ACdYz7+zwfh/2BEwwCMup3/gxPn/yqA/gA02z3+ZstIAI0HC/+6pNUAH3p3AIXykQDQ/Oj/W9W2/48E+v7510oApR5vAasJ3wDleyIBXIIa/02bLQHDixz/O+BOAIgR9wBseSAAT/q9/2Dj/P4m8T4APq59/5tvXf8K5s4BYcUo/wAxOf5B+g0AEvuW/9xt0v8Frqb+LIG9AOsjk/8l943/SI0E/2dr/wD3WgQANSwqAAIe8AAEOz8AWE4kAHGntAC+R8H/x56k/zoIrABNIQwAQT8DAJlNIf+s/mYB5N0E/1ce/gGSKVb/iszv/myNEf+78ocA0tB/AEQtDv5JYD4AUTwY/6oGJP8D+RoAI9VtABaBNv8VI+H/6j04/zrZBgCPfFgA7H5CANEmt/8i7gb/rpFmAF8W0wDED5n+LlTo/3UikgHn+kr/G4ZkAVy7w/+qxnAAeBwqANFGQwAdUR8AHahkAamtoABrI3UAPmA7/1EMRQGH777/3PwSAKPcOv+Jibz/U2ZtAGAGTADq3tL/ua7NATye1f8N8dYArIGMAF1o8gDAnPsAK3UeAOFRngB/6NoA4hzLAOkbl/91KwX/8g4v/yEUBgCJ+yz+Gx/1/7fWff4oeZUAup7V/1kI4wBFWAD+y4fhAMmuywCTR7gAEnkp/l4FTgDg1vD+JAW0APuH5wGjitQA0vl0/liBuwATCDH+Pg6Q/59M0wDWM1IAbXXk/mffy/9L/A8Bmkfc/xcNWwGNqGD/tbaFAPozNwDq6tT+rz+eACfwNAGevST/1ShVASC09/8TZhoBVBhh/0UV3gCUi3r/3NXrAejL/wB5OZMA4weaADUWkwFIAeEAUoYw/lM8nf+RSKkAImfvAMbpLwB0EwT/uGoJ/7eBUwAksOYBImdIANuihgD1Kp4AIJVg/qUskADK70j+15YFACpCJAGE168AVq5W/xrFnP8x6If+Z7ZSAP2AsAGZsnoA9foKAOwYsgCJaoQAKB0pADIemP98aSYA5r9LAI8rqgAsgxT/LA0X/+3/mwGfbWT/cLUY/2jcbAA304MAYwzV/5iXkf/uBZ8AYZsIACFsUQABA2cAPm0i//qbtAAgR8P/JkaRAZ9f9QBF5WUBiBzwAE/gGQBObnn/+Kh8ALuA9wACk+v+TwuEAEY6DAG1CKP/T4mF/yWqC/+N81X/sOfX/8yWpP/v1yf/Llec/gijWP+sIugAQixm/xs2Kf7sY1f/KXupATRyKwB1higAm4YaAOfPW/4jhCb/E2Z9/iTjhf92A3H/HQ18AJhgSgFYks7/p7/c/qISWP+2ZBcAH3U0AFEuagEMAgcARVDJAdH2rAAMMI0B4NNYAHTinwB6YoIAQezqAeHiCf/P4nsBWdY7AHCHWAFa9Mv/MQsmAYFsugBZcA8BZS7M/3/MLf5P/93/M0kS/38qZf/xFcoAoOMHAGky7ABPNMX/aMrQAbQPEABlxU7/Yk3LACm58QEjwXwAI5sX/881wAALfaMB+Z65/wSDMAAVXW//PXnnAUXIJP+5MLn/b+4V/ycyGf9j16P/V9Qe/6STBf+ABiMBbN9u/8JMsgBKZbQA8y8wAK4ZK/9Srf0BNnLA/yg3WwDXbLD/CzgHAODpTADRYsr+8hl9ACzBXf7LCLEAh7ATAHBH1f/OO7ABBEMaAA6P1f4qN9D/PEN4AMEVowBjpHMAChR2AJzU3v6gB9n/cvVMAXU7ewCwwlb+1Q+wAE7Oz/7VgTsA6fsWAWA3mP/s/w//xVlU/12VhQCuoHEA6mOp/5h0WACQpFP/Xx3G/yIvD/9jeIb/BezBAPn3fv+Tux4AMuZ1/2zZ2/+jUab/SBmp/pt5T/8cm1n+B34RAJNBIQEv6v0AGjMSAGlTx/+jxOYAcfikAOL+2gC90cv/pPfe/v8jpQAEvPMBf7NHACXt/v9kuvAABTlH/mdISf/0ElH+5dKE/+4GtP8L5a7/493AARExHACj18T+CXYE/zPwRwBxgW3/TPDnALyxfwB9RywBGq/zAF6pGf4b5h0AD4t3Aaiquv+sxUz//Eu8AIl8xABIFmD/LZf5AdyRZABAwJ//eO/iAIGykgAAwH0A64rqALedkgBTx8D/uKxI/0nhgABNBvr/ukFDAGj2zwC8IIr/2hjyAEOKUf7tgXn/FM+WASnHEP8GFIAAn3YFALUQj//cJg8AF0CT/kkaDQBX5DkBzHyAACsY3wDbY8cAFksU/xMbfgCdPtcAbh3mALOn/wE2/L4A3cy2/rOeQf9RnQMAwtqfAKrfAADgCyD/JsViAKikJQAXWAcBpLpuAGAkhgDq8uUA+nkTAPL+cP8DL14BCe8G/1GGmf7W/aj/Q3zgAPVfSgAcHiz+AW3c/7JZWQD8JEwAGMYu/0xNbwCG6oj/J14dALlI6v9GRIf/52YH/k3njACnLzoBlGF2/xAb4QGmzo//brLW/7SDogCPjeEBDdpO/3KZIQFiaMwAr3J1AafOSwDKxFMBOkBDAIovbwHE94D/ieDg/p5wzwCaZP8BhiVrAMaAT/9/0Zv/o/65/jwO8wAf23D+HdlBAMgNdP57PMT/4Du4/vJZxAB7EEv+lRDOAEX+MAHndN//0aBBAchQYgAlwrj+lD8iAIvwQf/ZkIT/OCYt/sd40gBssab/oN4EANx+d/6la6D/Utz4AfGviACQjRf/qYpUAKCJTv/idlD/NBuE/z9gi/+Y+icAvJsPAOgzlv4oD+j/8OUJ/4mvG/9LSWEB2tQLAIcFogFrudUAAvlr/yjyRgDbyBkAGZ0NAENSUP/E+Rf/kRSVADJIkgBeTJQBGPtBAB/AFwC41Mn/e+miAfetSACiV9v+foZZAJ8LDP6maR0ASRvkAXF4t/9Co20B1I8L/5/nqAH/gFoAOQ46/lk0Cv/9CKMBAJHS/wqBVQEutRsAZ4ig/n680f8iI28A19sY/9QL1v5lBXYA6MWF/9+nbf/tUFb/RoteAJ7BvwGbDzP/D75zAE6Hz//5ChsBtX3pAF+sDf6q1aH/J+yK/19dV/++gF8AfQ/OAKaWnwDjD57/zp54/yqNgABlsngBnG2DANoOLP73qM7/1HAcAHAR5P9aECUBxd5sAP7PU/8JWvP/8/SsABpYc//NdHoAv+bBALRkCwHZJWD/mk6cAOvqH//OsrL/lcD7ALb6hwD2FmkAfMFt/wLSlf+pEaoAAGBu/3UJCAEyeyj/wb1jACLjoAAwUEb+0zPsAC169f4srggArSXp/55BqwB6Rdf/WlAC/4NqYP7jcocAzTF3/rA+QP9SMxH/8RTz/4INCP6A2fP/ohsB/lp28QD2xvb/NxB2/8ifnQCjEQEAjGt5AFWhdv8mAJUAnC/uAAmmpgFLYrX/MkoZAEIPLwCL4Z8ATAOO/w7uuAALzzX/t8C6Aasgrv+/TN0B96rbABmsMv7ZCekAy35E/7dcMAB/p7cBQTH+ABA/fwH+Far/O+B//hYwP/8bToL+KMMdAPqEcP4jy5AAaKmoAM/9Hv9oKCb+XuRYAM4QgP/UN3r/3xbqAN/FfwD9tbUBkWZ2AOyZJP/U2Uj/FCYY/oo+PgCYjAQA5txj/wEV1P+UyecA9HsJ/gCr0gAzOiX/Af8O//S3kf4A8qYAFkqEAHnYKQBfw3L+hRiX/5zi5//3BU3/9pRz/uFcUf/eUPb+qntZ/0rHjQAdFAj/iohG/11LXADdkzH+NH7iAOV8FwAuCbUAzUA0AYP+HACXntQAg0BOAM4ZqwAA5osAv/1u/mf3pwBAKCgBKqXx/ztL5P58873/xFyy/4KMVv+NWTgBk8YF/8v4nv6Qoo0AC6ziAIIqFf8Bp4//kCQk/zBYpP6oqtwAYkfWAFvQTwCfTMkBpirW/0X/AP8GgH3/vgGMAJJT2v/X7kgBen81AL10pf9UCEL/1gPQ/9VuhQDDqCwBnudFAKJAyP5bOmgAtjq7/vnkiADLhkz+Y93pAEv+1v5QRZoAQJj4/uyIyv+daZn+la8UABYjE/98eekAuvrG/oTliwCJUK7/pX1EAJDKlP7r7/gAh7h2AGVeEf96SEb+RYKSAH/e+AFFf3b/HlLX/rxKE//lp8L+dRlC/0HqOP7VFpwAlztd/i0cG/+6fqT/IAbvAH9yYwHbNAL/Y2Cm/j6+fv9s3qgBS+KuAObixwA8ddr//PgUAda8zAAfwob+e0XA/6mtJP43YlsA3ypm/okBZgCdWhkA73pA//wG6QAHNhT/UnSuAIclNv8Pun0A43Cv/2S04f8q7fT/9K3i/vgSIQCrY5b/Susy/3VSIP5qqO0Az23QAeQJugCHPKn+s1yPAPSqaP/rLXz/RmO6AHWJtwDgH9cAKAlkABoQXwFE2VcACJcU/xpkOv+wpcsBNHZGAAcg/v70/vX/p5DC/31xF/+webUAiFTRAIoGHv9ZMBwAIZsO/xnwmgCNzW0BRnM+/xQoa/6Kmsf/Xt/i/52rJgCjsRn+LXYD/w7eFwHRvlH/dnvoAQ3VZf97N3v+G/alADJjTP+M1iD/YUFD/xgMHACuVk4BQPdgAKCHQwBCN/P/k8xg/xoGIf9iM1MBmdXQ/wK4Nv8Z2gsAMUP2/hKVSP8NGUgAKk/WACoEJgEbi5D/lbsXABKkhAD1VLj+eMZo/37aYAA4der/DR3W/kQvCv+nmoT+mCbGAEKyWf/ILqv/DWNT/9K7/f+qLSoBitF8ANaijQAM5pwAZiRw/gOTQwA013v/6as2/2KJPgD32if/59rsAPe/fwDDklQApbBc/xPUXv8RSuMAWCiZAcaTAf/OQ/X+8APa/z2N1f9ht2oAw+jr/l9WmgDRMM3+dtHx//B43wHVHZ8Ao3+T/w3aXQBVGET+RhRQ/70FjAFSYf7/Y2O//4RUhf9r2nT/cHouAGkRIADCoD//RN4nAdj9XACxac3/lcnDACrhC/8oonMACQdRAKXa2wC0FgD+HZL8/5LP4QG0h2AAH6NwALEL2/+FDMH+K04yAEFxeQE72Qb/bl4YAXCsbwAHD2AAJFV7AEeWFf/QSbwAwAunAdX1IgAJ5lwAoo4n/9daGwBiYVkAXk/TAFqd8ABf3H4BZrDiACQe4P4jH38A5+hzAVVTggDSSfX/L49y/0RBxQA7SD7/t4Wt/l15dv87sVH/6kWt/82AsQDc9DMAGvTRAUneTf+jCGD+lpXTAJ7+ywE2f4sAoeA7AARtFv/eKi3/0JJm/+yOuwAyzfX/CkpZ/jBPjgDeTIL/HqY/AOwMDf8xuPQAu3FmANpl/QCZObb+IJYqABnGkgHt8TgAjEQFAFukrP9Okbr+QzTNANvPgQFtcxEANo86ARX4eP+z/x4AwexC/wH/B//9wDD/E0XZAQPWAP9AZZIB330j/+tJs//5p+IA4a8KAWGiOgBqcKsBVKwF/4WMsv+G9Y4AYVp9/7rLuf/fTRf/wFxqAA/Gc//ZmPgAq7J4/+SGNQCwNsEB+vs1ANUKZAEix2oAlx/0/qzgV/8O7Rf//VUa/38ndP+saGQA+w5G/9TQiv/90/oAsDGlAA9Me/8l2qD/XIcQAQp+cv9GBeD/9/mNAEQUPAHx0r3/w9m7AZcDcQCXXK4A5z6y/9u34QAXFyH/zbVQADm4+P9DtAH/Wntd/ycAov9g+DT/VEKMACJ/5P/CigcBpm68ABURmwGavsb/1lA7/xIHjwBIHeIBx9n5AOihRwGVvskA2a9f/nGTQ/+Kj8f/f8wBAB22UwHO5pv/usw8AAp9Vf/oYBn//1n3/9X+rwHowVEAHCuc/gxFCACTGPgAEsYxAIY8IwB29hL/MVj+/uQVuv+2QXAB2xYB/xZ+NP+9NTH/cBmPACZ/N//iZaP+0IU9/4lFrgG+dpH/PGLb/9kN9f/6iAoAVP7iAMkffQHwM/v/H4OC/wKKMv/X17EB3wzu//yVOP98W0T/SH6q/nf/ZACCh+j/Dk+yAPqDxQCKxtAAediL/ncSJP8dwXoAECot/9Xw6wHmvqn/xiPk/m6tSADW3fH/OJSHAMB1Tv6NXc//j0GVABUSYv9fLPQBar9NAP5VCP7WbrD/Sa0T/qDEx//tWpAAwaxx/8ibiP7kWt0AiTFKAaTd1//RvQX/aew3/yofgQHB/+wALtk8AIpYu//iUuz/UUWX/46+EAENhggAf3ow/1FAnACr84sA7SP2AHqPwf7UepIAXyn/AVeETQAE1B8AER9OACctrf4Yjtn/XwkG/+NTBgBiO4L+Ph4hAAhz0wGiYYD/B7gX/nQcqP/4ipf/YvTwALp2ggBy+Ov/aa3IAaB8R/9eJKQBr0GS/+7xqv7KxsUA5EeK/i32bf/CNJ4AhbuwAFP8mv5Zvd3/qkn8AJQ6fQAkRDP+KkWx/6hMVv8mZMz/JjUjAK8TYQDh7v3/UVGHANIb//7rSWsACM9zAFJ/iABUYxX+zxOIAGSkZQBQ0E3/hM/t/w8DD/8hpm4AnF9V/yW5bwGWaiP/ppdMAHJXh/+fwkAADHof/+gHZf6td2IAmkfc/r85Nf+o6KD/4CBj/9qcpQCXmaMA2Q2UAcVxWQCVHKH+zxceAGmE4/825l7/ha3M/1y3nf9YkPz+ZiFaAJ9hAwC12pv/8HJ3AGrWNf+lvnMBmFvh/1hqLP/QPXEAlzR8AL8bnP9uNuwBDh6m/yd/zwHlxxwAvOS8/mSd6wD22rcBaxbB/86gXwBM75MAz6F1ADOmAv80dQr+STjj/5jB4QCEXoj/Zb/RACBr5f/GK7QBZNJ2AHJDmf8XWBr/WZpcAdx4jP+Qcs///HP6/yLOSACKhX//CLJ8AVdLYQAP5Vz+8EOD/3Z74/6SeGj/kdX/AYG7Rv/bdzYAAROtAC2WlAH4U0gAy+mpAY5rOAD3+SYBLfJQ/x7pZwBgUkYAF8lvAFEnHv+ht07/wuoh/0TjjP7YznQARhvr/2iQTwCk5l3+1oecAJq78v68FIP/JG2uAJ9w8QAFbpUBJKXaAKYdEwGyLkkAXSsg/vi97QBmm40AyV3D//GL/f8Pb2L/bEGj/ptPvv9JrsH+9igw/2tYC/7KYVX//cwS/3HyQgBuoML+0BK6AFEVPAC8aKf/fKZh/tKFjgA48on+KW+CAG+XOgFv1Y3/t6zx/yYGxP+5B3v/Lgv2APVpdwEPAqH/CM4t/xLKSv9TfHMB1I2dAFMI0f6LD+j/rDat/jL3hADWvdUAkLhpAN/++AD/k/D/F7xIAAczNgC8GbT+3LQA/1OgFACjvfP/OtHC/1dJPABqGDEA9fncABatpwB2C8P/E37tAG6fJf87Ui8AtLtWALyU0AFkJYX/B3DBAIG8nP9UaoH/heHKAA7sb/8oFGUArKwx/jM2Sv/7ubj/XZvg/7T54AHmspIASDk2/rI+uAB3zUgAue/9/z0P2gDEQzj/6iCrAS7b5ADQbOr/FD/o/6U1xwGF5AX/NM1rAErujP+WnNv+76yy//u93/4gjtP/2g+KAfHEUAAcJGL+FurHAD3t3P/2OSUAjhGO/50+GgAr7l/+A9kG/9UZ8AEn3K7/ms0w/hMNwP/0Ijb+jBCbAPC1Bf6bwTwApoAE/ySROP+W8NsAeDORAFKZKgGM7JIAa1z4Ab0KAwA/iPIA0ycYABPKoQGtG7r/0szv/inRov+2/p//rHQ0AMNn3v7NRTsANRYpAdowwgBQ0vIA0rzPALuhof7YEQEAiOFxAPq4PwDfHmL+TaiiADs1rwATyQr/i+DCAJPBmv/UvQz+Aciu/zKFcQFes1oArbaHAF6xcQArWdf/iPxq/3uGU/4F9UL/UjEnAdwC4ABhgbEATTtZAD0dmwHLq9z/XE6LAJEhtf+pGI0BN5azAIs8UP/aJ2EAApNr/zz4SACt5i8BBlO2/xBpov6J1FH/tLiGASfepP/dafsB73B9AD8HYQA/aOP/lDoMAFo84P9U1PwAT9eoAPjdxwFzeQEAJKx4ACCiu/85azH/kyoVAGrGKwE5SlcAfstR/4GHwwCMH7EA3YvCAAPe1wCDROcAsVay/nyXtAC4fCYBRqMRAPn7tQEqN+MA4qEsABfsbgAzlY4BXQXsANq3av5DGE0AKPXR/955mQClOR4AU308AEYmUgHlBrwAbd6d/zd2P//Nl7oA4yGV//6w9gHjseMAImqj/rArTwBqX04BufF6/7kOPQAkAcoADbKi//cLhACh5lwBQQG5/9QypQGNkkD/nvLaABWkfQDVi3oBQ0dXAMuesgGXXCsAmG8F/ycD7//Z//r/sD9H/0r1TQH6rhL/IjHj//Yu+/+aIzABfZ09/2okTv9h7JkAiLt4/3GGq/8T1dn+2F7R//wFPQBeA8oAAxq3/0C/K/8eFxUAgY1N/2Z4BwHCTIwAvK80/xFRlADoVjcB4TCsAIYqKv/uMi8AqRL+ABSTV/8Ow+//RfcXAO7lgP+xMXAAqGL7/3lH+ADzCJH+9uOZ/9upsf77i6X/DKO5/6Qoq/+Znxv+821b/94YcAES1ucAa521/sOTAP/CY2j/WYy+/7FCfv5quUIAMdofAPyungC8T+YB7ingANTqCAGIC7UApnVT/0TDXgAuhMkA8JhYAKQ5Rf6g4Cr/O9dD/3fDjf8ktHn+zy8I/67S3wBlxUT//1KNAfqJ6QBhVoUBEFBFAISDnwB0XWQALY2LAJisnf9aK1sAR5kuACcQcP/ZiGH/3MYZ/rE1MQDeWIb/gA88AM/Aqf/AdNH/ak7TAcjVt/8HDHr+3ss8/yFux/77anUA5OEEAXg6B//dwVT+cIUbAL3Iyf+Lh5YA6jew/z0yQQCYbKn/3FUB/3CH4wCiGroAz2C5/vSIawBdmTIBxmGXAG4LVv+Pda7/c9TIAAXKtwDtpAr+ue8+AOx4Ev5ie2P/qMnC/i7q1gC/hTH/Y6l3AL67IwFzFS3/+YNIAHAGe//WMbX+pukiAFzFZv795M3/AzvJASpiLgDbJSP/qcMmAF58wQGcK98AX0iF/njOvwB6xe//sbtP//4uAgH6p74AVIETAMtxpv/5H73+SJ3K/9BHSf/PGEgAChASAdJRTP9Y0MD/fvNr/+6NeP/Heer/iQw7/yTce/+Uszz+8AwdAEIAYQEkHib/cwFd/2Bn5//FnjsBwKTwAMrKOf8YrjAAWU2bASpM1wD0l+kAFzBRAO9/NP7jgiX/+HRdAXyEdgCt/sABButT/26v5wH7HLYAgfld/lS4gABMtT4Ar4C6AGQ1iP5tHeIA3ek6ARRjSgAAFqAAhg0VAAk0N/8RWYwAryI7AFSld//g4ur/B0im/3tz/wES1vYA+gdHAdncuQDUI0z/Jn2vAL1h0gBy7iz/Kbyp/i26mgBRXBYAhKDBAHnQYv8NUSz/y5xSAEc6Ff/Qcr/+MiaTAJrYwwBlGRIAPPrX/+mE6/9nr44BEA5cAI0fbv7u8S3/mdnvAWGoL//5VRABHK8+/zn+NgDe534Api11/hK9YP/kTDIAyPReAMaYeAFEIkX/DEGg/mUTWgCnxXj/RDa5/ynavABxqDAAWGm9ARpSIP+5XaQB5PDt/0K2NQCrxVz/awnpAcd4kP9OMQr/bapp/1oEH/8c9HH/SjoLAD7c9v95msj+kNKy/345gQEr+g7/ZW8cAS9W8f89Rpb/NUkF/x4angDRGlYAiu1KAKRfvACOPB3+onT4/7uvoACXEhAA0W9B/suGJ/9YbDH/gxpH/90b1/5oaV3/H+wf/ocA0/+Pf24B1EnlAOlDp/7DAdD/hBHd/zPZWgBD6zL/39KPALM1ggHpasYA2a3c/3DlGP+vml3+R8v2/zBChf8DiOb/F91x/utv1QCqeF/++90CAC2Cnv5pXtn/8jS0/tVELf9oJhwA9J5MAKHIYP/PNQ3/u0OUAKo2+AB3orL/UxQLACoqwAGSn6P/t+hvAE3lFf9HNY8AG0wiAPaIL//bJ7b/XODJAROODv9FtvH/o3b1AAltagGqtff/Ti/u/1TSsP/Va4sAJyYLAEgVlgBIgkUAzU2b/o6FFQBHb6z+4io7/7MA1wEhgPEA6vwNAbhPCABuHkn/9o29AKrP2gFKmkX/ivYx/5sgZAB9Smn/WlU9/yPlsf8+fcH/mVa8AUl41ADRe/b+h9Em/5c6LAFcRdb/DgxY//yZpv/9z3D/PE5T/+N8bgC0YPz/NXUh/qTcUv8pARv/JqSm/6Rjqf49kEb/wKYSAGv6QgDFQTIAAbMS//9oAf8rmSP/UG+oAG6vqAApaS3/2w7N/6TpjP4rAXYA6UPDALJSn/+KV3r/1O5a/5AjfP4ZjKQA+9cs/oVGa/9l41D+XKk3ANcqMQBytFX/IegbAazVGQA+sHv+IIUY/+G/PgBdRpkAtSpoARa/4P/IyIz/+eolAJU5jQDDOND//oJG/yCt8P8d3McAbmRz/4Tl+QDk6d//JdjR/rKx0f+3LaX+4GFyAIlhqP/h3qwApQ0xAdLrzP/8BBz+RqCXAOi+NP5T+F3/PtdNAa+vs/+gMkIAeTDQAD+p0f8A0sgA4LssAUmiUgAJsI//E0zB/x07pwEYK5oAHL6+AI28gQDo68v/6gBt/zZBnwA8WOj/ef2W/vzpg//GbikBU01H/8gWO/5q/fL/FQzP/+1CvQBaxsoB4ax/ADUWygA45oQAAVa3AG2+KgDzRK4BbeSaAMixegEjoLf/sTBV/1raqf/4mE4Ayv5uAAY0KwCOYkH/P5EWAEZqXQDoimsBbrM9/9OB2gHy0VwAI1rZAbaPav90Zdn/cvrd/63MBgA8lqMASaws/+9uUP/tTJn+oYz5AJXo5QCFHyj/rqR3AHEz1gCB5AL+QCLzAGvj9P+uasj/VJlGATIjEAD6Stj+7L1C/5n5DQDmsgT/3SnuAHbjef9eV4z+/ndcAEnv9v51V4AAE9OR/7Eu/ADlW/YBRYD3/8pNNgEICwn/mWCmANnWrf+GwAIBAM8AAL2uawGMhmQAnsHzAbZmqwDrmjMAjgV7/zyoWQHZDlz/E9YFAdOn/gAsBsr+eBLs/w9xuP+434sAKLF3/rZ7Wv+wpbAA903CABvqeADnANb/OyceAH1jkf+WREQBjd74AJl70v9uf5j/5SHWAYfdxQCJYQIADI/M/1EpvABzT4L/XgOEAJivu/98jQr/fsCz/wtnxgCVBi0A21W7AeYSsv9ItpgAA8a4/4Bw4AFhoeYA/mMm/zqfxQCXQtsAO0WP/7lw+QB3iC//e4KEAKhHX/9xsCgB6LmtAM9ddQFEnWz/ZgWT/jFhIQBZQW/+9x6j/3zZ3QFm+tgAxq5L/jk3EgDjBewB5dWtAMlt2gEx6e8AHjeeARmyagCbb7wBXn6MANcf7gFN8BAA1fIZASZHqADNul3+MdOM/9sAtP+GdqUAoJOG/266I//G8yoA85J3AIbrowEE8Yf/wS7B/me0T//hBLj+8naCAJKHsAHqbx4ARULV/ilgewB5Xir/sr/D/y6CKgB1VAj/6THW/u56bQAGR1kB7NN7APQNMP53lA4AchxW/0vtGf+R5RD+gWQ1/4aWeP6onTIAF0ho/+AxDgD/exb/l7mX/6pQuAGGthQAKWRlAZkhEABMmm8BVs7q/8CgpP6le13/Adik/kMRr/+pCzv/nik9/0m8Dv/DBon/FpMd/xRnA//2guP/eiiAAOIvGP4jJCAAmLq3/0XKFADDhcMA3jP3AKmrXgG3AKD/QM0SAZxTD//FOvn++1lu/zIKWP4zK9gAYvLGAfWXcQCr7MIBxR/H/+VRJgEpOxQA/WjmAJhdDv/28pL+1qnw//BmbP6gp+wAmtq8AJbpyv8bE/oBAkeF/68MPwGRt8YAaHhz/4L79wAR1Kf/PnuE//dkvQCb35gAj8UhAJs7LP+WXfABfwNX/19HzwGnVQH/vJh0/woXFwCJw10BNmJhAPAAqP+UvH8AhmuXAEz9qwBahMAAkhY2AOBCNv7muuX/J7bEAJT7gv9Bg2z+gAGgAKkxp/7H/pT/+waDALv+gf9VUj4Ashc6//6EBQCk1ScAhvyS/iU1Uf+bhlIAzafu/14ttP+EKKEA/m9wATZL2QCz5t0B616//xfzMAHKkcv/J3Yq/3WN/QD+AN4AK/syADap6gFQRNAAlMvz/pEHhwAG/gAA/Ll/AGIIgf8mI0j/0yTcASgaWQCoQMX+A97v/wJT1/60n2kAOnPCALp0av/l99v/gXbBAMqutwGmoUgAyWuT/u2ISgDp5moBaW+oAEDgHgEB5QMAZpev/8Lu5P/++tQAu+15AEP7YAHFHgsAt1/MAM1ZigBA3SUB/98e/7Iw0//xyFr/p9Fg/zmC3QAucsj/PbhCADe2GP5utiEAq77o/3JeHwAS3QgAL+f+AP9wUwB2D9f/rRko/sDBH//uFZL/q8F2/2XqNf6D1HAAWcBrAQjQGwC12Q//55XoAIzsfgCQCcf/DE+1/pO2yv8Tbbb/MdThAEqjywCv6ZQAGnAzAMHBCf8Ph/kAluOCAMwA2wEY8s0A7tB1/xb0cAAa5SIAJVC8/yYtzv7wWuH/HQMv/yrgTAC686cAIIQP/wUzfQCLhxgABvHbAKzlhf/21jIA5wvP/79+UwG0o6r/9TgYAbKk0/8DEMoBYjl2/42DWf4hMxgA85Vb//00DgAjqUP+MR5Y/7MbJP+ljLcAOr2XAFgfAABLqUIAQmXH/xjYxwF5xBr/Dk/L/vDiUf9eHAr/U8Hw/8zBg/9eD1YA2iidADPB0QAA8rEAZrn3AJ5tdAAmh1sA36+VANxCAf9WPOgAGWAl/+F6ogHXu6j/np0uADirogDo8GUBehYJADMJFf81Ge7/2R7o/n2plAAN6GYAlAklAKVhjQHkgykA3g/z//4SEQAGPO0BagNxADuEvQBccB4AadDVADBUs/+7eef+G9ht/6Lda/5J78P/+h85/5WHWf+5F3MBA6Od/xJw+gAZObv/oWCkAC8Q8wAMjfv+Q+q4/ykSoQCvBmD/oKw0/hiwt//GwVUBfHmJ/5cycv/cyzz/z+8FAQAma/837l7+RpheANXcTQF4EUX/VaS+/8vqUQAmMSX+PZB8AIlOMf6o9zAAX6T8AGmphwD95IYAQKZLAFFJFP/P0goA6mqW/14iWv/+nzn+3IVjAIuTtP4YF7kAKTke/71hTABBu9//4Kwl/yI+XwHnkPAATWp+/kCYWwAdYpsA4vs1/+rTBf+Qy97/pLDd/gXnGACzes0AJAGG/31Gl/5h5PwArIEX/jBa0f+W4FIBVIYeAPHELgBncer/LmV5/ih8+v+HLfL+Cfmo/4xsg/+Po6sAMq3H/1jejv/IX54AjsCj/wd1hwBvfBYA7AxB/kQmQf/jrv4A9PUmAPAy0P+hP/oAPNHvAHojEwAOIeb+Ap9xAGoUf//kzWAAidKu/rTUkP9ZYpoBIliLAKeicAFBbsUA8SWpAEI4g/8KyVP+hf27/7FwLf7E+wAAxPqX/+7o1v+W0c0AHPB2AEdMUwHsY1sAKvqDAWASQP923iMAcdbL/3p3uP9CEyQAzED5AJJZiwCGPocBaOllALxUGgAx+YEA0NZL/8+CTf9zr+sAqwKJ/6+RugE39Yf/mla1AWQ69v9txzz/UsyG/9cx5gGM5cD/3sH7/1GID/+zlaL/Fycd/wdfS/6/Ud4A8VFa/2sxyf/0050A3oyV/0HbOP699lr/sjudATDbNABiItcAHBG7/6+pGABcT6H/7MjCAZOP6gDl4QcBxagOAOszNQH9eK4AxQao/8p1qwCjFc4AclVa/w8pCv/CE2MAQTfY/qKSdAAyztT/QJId/56egwFkpYL/rBeB/301Cf8PwRIBGjEL/7WuyQGHyQ7/ZBOVANtiTwAqY4/+YAAw/8X5U/5olU//626I/lKALP9BKST+WNMKALt5uwBihscAq7yz/tIL7v9Ce4L+NOo9ADBxF/4GVnj/d7L1AFeByQDyjdEAynJVAJQWoQBnwzAAGTGr/4pDggC2SXr+lBiCANPlmgAgm54AVGk9ALHCCf+mWVYBNlO7APkodf9tA9f/NZIsAT8vswDC2AP+DlSIAIixDf9I87r/dRF9/9M60/9dT98AWlj1/4vRb/9G3i8ACvZP/8bZsgDj4QsBTn6z/z4rfgBnlCMAgQil/vXwlAA9M44AUdCGAA+Jc//Td+z/n/X4/wKGiP/mizoBoKT+AHJVjf8xprb/kEZUAVW2BwAuNV0ACaah/zeisv8tuLwAkhws/qlaMQB4svEBDnt//wfxxwG9QjL/xo9l/r3zh/+NGBj+S2FXAHb7mgHtNpwAq5LP/4PE9v+IQHEBl+g5APDacwAxPRv/QIFJAfypG/8ohAoBWsnB//x58AG6zikAK8ZhAJFktwDM2FD+rJZBAPnlxP5oe0n/TWhg/oK0CABoezkA3Mrl/2b50wBWDuj/tk7RAO/hpABqDSD/eEkR/4ZD6QBT/rUAt+xwATBAg//x2PP/QcHiAM7xZP5khqb/7crFADcNUQAgfGb/KOSxAHa1HwHnoIb/d7vKAACOPP+AJr3/psmWAM94GgE2uKwADPLM/oVC5gAiJh8BuHBQACAzpf6/8zcAOkmS/punzf9kaJj/xf7P/60T9wDuCsoA75fyAF47J//wHWb/Clya/+VU2/+hgVAA0FrMAfDbrv+eZpEBNbJM/zRsqAFT3msA0yRtAHY6OAAIHRYA7aDHAKrRnQCJRy8Aj1YgAMbyAgDUMIgBXKy6AOaXaQFgv+UAilC//vDYgv9iKwb+qMQxAP0SWwGQSXkAPZInAT9oGP+4pXD+futiAFDVYv97PFf/Uoz1Ad94rf8PxoYBzjzvAOfqXP8h7hP/pXGOAbB3JgCgK6b+71tpAGs9wgEZBEQAD4szAKSEav8idC7+qF/FAInUFwBInDoAiXBF/pZpmv/syZ0AF9Sa/4hS4/7iO93/X5XAAFF2NP8hK9cBDpNL/1mcef4OEk8Ak9CLAZfaPv+cWAgB0rhi/xSve/9mU+UA3EF0AZb6BP9cjtz/IvdC/8zhs/6XUZcARyjs/4o/PgAGT/D/t7m1AHYyGwA/48AAe2M6ATLgm/8R4d/+3OBN/w4sewGNgK8A+NTIAJY7t/+TYR0Alsy1AP0lRwCRVXcAmsi6AAKA+f9TGHwADlePAKgz9QF8l+f/0PDFAXy+uQAwOvYAFOnoAH0SYv8N/h//9bGC/2yOIwCrffL+jAwi/6WhogDOzWUA9xkiAWSROQAnRjkAdszL//IAogCl9B4AxnTiAIBvmf+MNrYBPHoP/5s6OQE2MsYAq9Md/2uKp/+ta8f/baHBAFlI8v/Oc1n/+v6O/rHKXv9RWTIAB2lC/xn+//7LQBf/T95s/yf5SwDxfDIA75iFAN3xaQCTl2IA1aF5/vIxiQDpJfn+KrcbALh35v/ZIKP/0PvkAYk+g/9PQAn+XjBxABGKMv7B/xYA9xLFAUM3aAAQzV//MCVCADecPwFAUkr/yDVH/u9DfQAa4N4A34ld/x7gyv8J3IQAxibrAWaNVgA8K1EBiBwaAOkkCP7P8pQApKI/ADMu4P9yME//Ca/iAN4Dwf8voOj//11p/g4q5gAailIB0Cv0ABsnJv9i0H//QJW2/wX60QC7PBz+MRna/6l0zf93EngAnHST/4Q1bf8NCsoAblOnAJ3bif8GA4L/Mqce/zyfL/+BgJ3+XgO9AAOmRABT39cAllrCAQ+oQQDjUzP/zatC/za7PAGYZi3/d5rhAPD3iABkxbL/i0ff/8xSEAEpzir/nMDd/9h79P/a2rn/u7rv//ysoP/DNBYAkK61/rtkc//TTrD/GwfBAJPVaP9ayQr/UHtCARYhugABB2P+Hs4KAOXqBQA1HtIAigjc/kc3pwBI4VYBdr68AP7BZQGr+az/Xp63/l0CbP+wXUz/SWNP/0pAgf72LkEAY/F//vaXZv8sNdD+O2bqAJqvpP9Y8iAAbyYBAP+2vv9zsA/+qTyBAHrt8QBaTD8APkp4/3rDbgB3BLIA3vLSAIIhLv6cKCkAp5JwATGjb/95sOsATM8O/wMZxgEp69UAVSTWATFcbf/IGB7+qOzDAJEnfAHsw5UAWiS4/0NVqv8mIxr+g3xE/++bI/82yaQAxBZ1/zEPzQAY4B0BfnGQAHUVtgDLn40A34dNALDmsP++5df/YyW1/zMViv8ZvVn/MTCl/pgt9wCqbN4AUMoFABtFZ/7MFoH/tPw+/tIBW/+Sbv7/26IcAN/81QE7CCEAzhD0AIHTMABroNAAcDvRAG1N2P4iFbn/9mM4/7OLE/+5HTL/VFkTAEr6Yv/hKsj/wNnN/9IQpwBjhF8BK+Y5AP4Ly/9jvD//d8H7/lBpNgDotb0Bt0Vw/9Crpf8vbbT/e1OlAJKiNP+aCwT/l+Na/5KJYf496Sn/Xio3/2yk7ACYRP4ACoyD/wpqT/7znokAQ7JC/rF7xv8PPiIAxVgq/5Vfsf+YAMb/lf5x/+Fao/992fcAEhHgAIBCeP7AGQn/Mt3NADHURgDp/6QAAtEJAN002/6s4PT/XjjOAfKzAv8fW6QB5i6K/73m3AA5Lz3/bwudALFbmAAc5mIAYVd+AMZZkf+nT2sA+U2gAR3p5v+WFVb+PAvBAJclJP65lvP/5NRTAayXtADJqZsA9DzqAI7rBAFD2jwAwHFLAXTzz/9BrJsAUR6c/1BIIf4S523/jmsV/n0ahP+wEDv/lsk6AM6pyQDQeeIAKKwO/5Y9Xv84OZz/jTyR/y1slf/ukZv/0VUf/sAM0gBjYl3+mBCXAOG53ACN6yz/oKwV/kcaH/8NQF3+HDjGALE++AG2CPEApmWU/05Rhf+B3tcBvKmB/+gHYQAxcDz/2eX7AHdsigAnE3v+gzHrAIRUkQCC5pT/GUq7AAX1Nv+52/EBEsLk//HKZgBpccoAm+tPABUJsv+cAe8AyJQ9AHP30v8x3YcAOr0IASMuCQBRQQX/NJ65/310Lv9KjA3/0lys/pMXRwDZ4P3+c2y0/5E6MP7bsRj/nP88AZqT8gD9hlcANUvlADDD3v8frzL/nNJ4/9Aj3v8S+LMBAgpl/53C+P+ezGX/aP7F/08+BACyrGUBYJL7/0EKnAACiaX/dATnAPLXAQATIx3/K6FPADuV9gH7QrAAyCED/1Bujv/DoREB5DhC/3svkf6EBKQAQ66sABn9cgBXYVcB+txUAGBbyP8lfTsAE0F2AKE08f/trAb/sL///wFBgv7fvuYAZf3n/5IjbQD6HU0BMQATAHtamwEWViD/2tVBAG9dfwA8Xan/CH+2ABG6Dv79ifb/1Rkw/kzuAP/4XEb/Y+CLALgJ/wEHpNAAzYPGAVfWxwCC1l8A3ZXeABcmq/7FbtUAK3OM/texdgBgNEIBdZ7tAA5Atv8uP67/nl++/+HNsf8rBY7/rGPU//S7kwAdM5n/5HQY/h5lzwAT9pb/hucFAH2G4gFNQWIA7IIh/wVuPgBFbH//B3EWAJEUU/7Coef/g7U8ANnRsf/llNT+A4O4AHWxuwEcDh//sGZQADJUl/99Hzb/FZ2F/xOziwHg6BoAInWq/6f8q/9Jjc7+gfojAEhP7AHc5RT/Kcqt/2NM7v/GFuD/bMbD/ySNYAHsnjv/amRXAG7iAgDj6t4Aml13/0pwpP9DWwL/FZEh/2bWif+v5mf+o/amAF33dP6n4Bz/3AI5AavOVAB75BH/G3h3AHcLkwG0L+H/aMi5/qUCcgBNTtQALZqx/xjEef5SnbYAWhC+AQyTxQBf75j/C+tHAFaSd/+shtYAPIPEAKHhgQAfgnj+X8gzAGnn0v86CZT/K6jd/3ztjgDG0zL+LvVnAKT4VACYRtD/tHWxAEZPuQDzSiAAlZzPAMXEoQH1Ne8AD132/ovwMf/EWCT/oiZ7AIDInQGuTGf/raki/tgBq/9yMxEAiOTCAG6WOP5q9p8AE7hP/5ZN8P+bUKIAADWp/x2XVgBEXhAAXAdu/mJ1lf/5Teb//QqMANZ8XP4jdusAWTA5ARY1pgC4kD3/s//CANb4Pf47bvYAeRVR/qYD5ABqQBr/ReiG//LcNf4u3FUAcZX3/2GzZ/++fwsAh9G2AF80gQGqkM7/esjM/6hkkgA8kJX+RjwoAHo0sf/202X/ru0IAAczeAATH60Afu+c/4+9ywDEgFj/6YXi/x59rf/JbDIAe2Q7//6jAwHdlLX/1og5/t60if/PWDb/HCH7/0PWNAHS0GQAUapeAJEoNQDgb+f+Ixz0/+LHw/7uEeYA2dmk/qmd3QDaLqIBx8+j/2xzogEOYLv/djxMALifmADR50f+KqS6/7qZM/7dq7b/oo6tAOsvwQAHixABX6RA/xDdpgDbxRAAhB0s/2RFdf8861j+KFGtAEe+Pf+7WJ0A5wsXAO11pADhqN//mnJ0/6OY8gEYIKoAfWJx/qgTTAARndz+mzQFABNvof9HWvz/rW7wAArGef/9//D/QnvSAN3C1/55oxH/4QdjAL4xtgBzCYUB6BqK/9VEhAAsd3r/s2IzAJVaagBHMub/Cpl2/7FGGQClV80AN4rqAO4eYQBxm88AYpl/ACJr2/51cqz/TLT//vI5s//dIqz+OKIx/1MD//9x3b3/vBnk/hBYWf9HHMb+FhGV//N5/v9rymP/Cc4OAdwvmQBriScBYTHC/5Uzxf66Ogv/ayvoAcgGDv+1hUH+3eSr/3s+5wHj6rP/Ir3U/vS7+QC+DVABglkBAN+FrQAJ3sb/Qn9KAKfYXf+bqMYBQpEAAERmLgGsWpoA2IBL/6AoMwCeERsBfPAxAOzKsP+XfMD/JsG+AF+2PQCjk3z//6Uz/xwoEf7XYE4AVpHa/h8kyv9WCQUAbynI/+1sYQA5PiwAdbgPAS3xdACYAdz/naW8APoPgwE8LH3/Qdz7/0syuAA1WoD/51DC/4iBfwEVErv/LTqh/0eTIgCu+Qv+I40dAO9Esf9zbjoA7r6xAVf1pv++Mff/klO4/60OJ/+S12gAjt94AJXIm//Uz5EBELXZAK0gV///I7UAd9+hAcjfXv9GBrr/wENV/zKpmACQGnv/OPOz/hREiAAnjLz+/dAF/8hzhwErrOX/nGi7AJf7pwA0hxcAl5lIAJPFa/6UngX/7o/OAH6Zif9YmMX+B0SnAPyfpf/vTjb/GD83/ybeXgDttwz/zszSABMn9v4eSucAh2wdAbNzAAB1dnQBhAb8/5GBoQFpQ40AUiXi/+7i5P/M1oH+ontk/7l56gAtbOcAQgg4/4SIgACs4EL+r528AObf4v7y20UAuA53AVKiOAByexQAomdV/zHvY/6ch9cAb/+n/ifE1gCQJk8B+ah9AJthnP8XNNv/lhaQACyVpf8of7cAxE3p/3aB0v+qh+b/1nfGAOnwIwD9NAf/dWYw/xXMmv+ziLH/FwIDAZWCWf/8EZ8BRjwaAJBrEQC0vjz/OLY7/25HNv/GEoH/leBX/98VmP+KFrb/+pzNAOwt0P9PlPIBZUbRAGdOrgBlkKz/mIjtAb/CiABxUH0BmASNAJuWNf/EdPUA73JJ/hNSEf98fer/KDS/ACrSnv+bhKUAsgUqAUBcKP8kVU3/suR2AIlCYP5z4kIAbvBF/pdvUACnruz/42xr/7zyQf+3Uf8AOc61/y8itf/V8J4BR0tfAJwoGP9m0lEAq8fk/5oiKQDjr0sAFe/DAIrlXwFMwDEAdXtXAePhggB9Pj//AsarAP4kDf6Rus4AlP/0/yMApgAeltsBXOTUAFzGPP4+hcj/ySk7AH3ubf+0o+4BjHpSAAkWWP/FnS//mV45AFgetgBUoVUAspJ8AKamB/8V0N8AnLbyAJt5uQBTnK7+mhB2/7pT6AHfOnn/HRdYACN9f/+qBZX+pAyC/5vEHQChYIgAByMdAaIl+wADLvL/ANm8ADmu4gHO6QIAObuI/nu9Cf/JdX//uiTMAOcZ2ABQTmkAE4aB/5TLRACNUX3++KXI/9aQhwCXN6b/JutbABUumgDf/pb/I5m0/32wHQErYh7/2Hrm/+mgDAA5uQz+8HEH/wUJEP4aW2wAbcbLAAiTKACBhuT/fLoo/3JihP6mhBcAY0UsAAny7v+4NTsAhIFm/zQg8/6T38j/e1Oz/oeQyf+NJTgBlzzj/1pJnAHLrLsAUJcv/16J5/8kvzv/4dG1/0rX1f4GdrP/mTbBATIA5wBonUgBjOOa/7biEP5g4Vz/cxSq/gb6TgD4S63/NVkG/wC0dgBIrQEAQAjOAa6F3wC5PoX/1gtiAMUf0ACrp/T/Fue1AZbauQD3qWEBpYv3/y94lQFn+DMAPEUc/hmzxAB8B9r+OmtRALjpnP/8SiQAdrxDAI1fNf/eXqX+Lj01AM47c/8v7Pr/SgUgAYGa7v9qIOIAebs9/wOm8f5Dqqz/Hdiy/xfJ/AD9bvMAyH05AG3AYP80c+4AJnnz/8k4IQDCdoIAS2AZ/6oe5v4nP/0AJC36//sB7wCg1FwBLdHtAPMhV/7tVMn/1BKd/tRjf//ZYhD+i6zvAKjJgv+Pwan/7pfBAddoKQDvPaX+AgPyABbLsf6xzBYAlYHV/h8LKf8An3n+oBly/6JQyACdlwsAmoZOAdg2/AAwZ4UAadzFAP2oTf41sxcAGHnwAf8uYP9rPIf+Ys35/z/5d/94O9P/crQ3/ltV7QCV1E0BOEkxAFbGlgBd0aAARc22//RaKwAUJLAAenTdADOnJwHnAT//DcWGAAPRIv+HO8oAp2ROAC/fTAC5PD4AsqZ7AYQMof89risAw0WQAH8vvwEiLE4AOeo0Af8WKP/2XpIAU+SAADxO4P8AYNL/ma/sAJ8VSQC0c8T+g+FqAP+nhgCfCHD/eETC/7DExv92MKj/XakBAHDIZgFKGP4AE40E/o4+PwCDs7v/TZyb/3dWpACq0JL/0IWa/5SbOv+ieOj+/NWbAPENKgBeMoMAs6pwAIxTl/83d1QBjCPv/5ktQwHsrycANpdn/54qQf/E74f+VjXLAJVhL/7YIxH/RgNGAWckWv8oGq0AuDANAKPb2f9RBgH/3aps/unQXQBkyfn+ViQj/9GaHgHjyfv/Ar2n/mQ5AwANgCkAxWRLAJbM6/+RrjsAePiV/1U34QBy0jX+x8x3AA73SgE/+4EAQ2iXAYeCUABPWTf/dead/xlgjwDVkQUARfF4AZXzX/9yKhQAg0gCAJo1FP9JPm0AxGaYACkMzP96JgsB+gqRAM99lAD29N7/KSBVAXDVfgCi+VYBR8Z//1EJFQFiJwT/zEctAUtviQDqO+cAIDBf/8wfcgEdxLX/M/Gn/l1tjgBokC0A6wy1/zRwpABM/sr/rg6iAD3rk/8rQLn+6X3ZAPNYp/5KMQgAnMxCAHzWewAm3XYBknDsAHJisQCXWccAV8VwALmVoQAsYKUA+LMU/7zb2P4oPg0A846NAOXjzv+syiP/dbDh/1JuJgEq9Q7/FFNhADGrCgDyd3gAGeg9ANTwk/8Eczj/kRHv/soR+//5EvX/Y3XvALgEs//27TP/Je+J/6Zwpv9RvCH/ufqO/za7rQDQcMkA9ivkAWi4WP/UNMT/M3Vs//51mwAuWw//Vw6Q/1fjzABTGlMBn0zjAJ8b1QEYl2wAdZCz/onRUgAmnwoAc4XJAN+2nAFuxF3/OTzpAAWnaf+axaQAYCK6/5OFJQHcY74AAadU/xSRqwDCxfv+X06F//z48//hXYP/u4bE/9iZqgAUdp7+jAF2AFaeDwEt0yn/kwFk/nF0TP/Tf2wBZw8wAMEQZgFFM1//a4CdAImr6QBafJABaqG2AK9M7AHIjaz/ozpoAOm0NP/w/Q7/onH+/ybviv40LqYA8WUh/oO6nABv0D7/fF6g/x+s/gBwrjj/vGMb/0OK+wB9OoABnJiu/7IM9//8VJ4AUsUO/qzIU/8lJy4Bas+nABi9IgCDspAAztUEAKHi0gBIM2n/YS27/0643/+wHfsAT6BW/3QlsgBSTdUBUlSN/+Jl1AGvWMf/9V73Aax2bf+mub4Ag7V4AFf+Xf+G8En/IPWP/4uiZ/+zYhL+2cxwAJPfeP81CvMApoyWAH1QyP8Obdv/W9oB//z8L/5tnHT/czF/AcxX0/+Uytn/GlX5/w71hgFMWan/8i3mADtirP9ySYT+Tpsx/55+VAAxryv/ELZU/51nIwBowW3/Q92aAMmsAf4IolgApQEd/32b5f8emtwBZ+9cANwBbf/KxgEAXgKOASQ2LADr4p7/qvvW/7lNCQBhSvIA26OV//Ajdv/fclj+wMcDAGolGP/JoXb/YVljAeA6Z/9lx5P+3jxjAOoZOwE0hxsAZgNb/qjY6wDl6IgAaDyBAC6o7gAnv0MAS6MvAI9hYv842KgBqOn8/yNvFv9cVCsAGshXAVv9mADKOEYAjghNAFAKrwH8x0wAFm5S/4EBwgALgD0BVw6R//3evgEPSK4AVaNW/jpjLP8tGLz+Gs0PABPl0v74Q8MAY0e4AJrHJf+X83n/JjNL/8lVgv4sQfoAOZPz/pIrO/9ZHDUAIVQY/7MzEv69RlMAC5yzAWKGdwCeb28Ad5pJ/8g/jP4tDQ3/msAC/lFIKgAuoLn+LHAGAJLXlQEasGgARBxXAewymf+zgPr+zsG//6Zcif41KO8A0gHM/qitIwCN8y0BJDJt/w/ywv/jn3r/sK/K/kY5SAAo3zgA0KI6/7diXQAPbwwAHghM/4R/9v8t8mcARbUP/wrRHgADs3kA8ejaAXvHWP8C0soBvIJR/15l0AFnJC0ATMEYAV8a8f+lorsAJHKMAMpCBf8lOJMAmAvzAX9V6P/6h9QBubFxAFrcS/9F+JIAMm8yAFwWUAD0JHP+o2RS/xnBBgF/PSQA/UMe/kHsqv+hEdf+P6+MADd/BABPcOkAbaAoAI9TB/9BGu7/2amM/05evf8Ak77/k0e6/mpNf//pnekBh1ft/9AN7AGbbST/tGTaALSjEgC+bgkBET97/7OItP+le3v/kLxR/kfwbP8ZcAv/49oz/6cy6v9yT2z/HxNz/7fwYwDjV4//SNn4/2apXwGBlZUA7oUMAePMIwDQcxoBZgjqAHBYjwGQ+Q4A8J6s/mRwdwDCjZn+KDhT/3mwLgAqNUz/nr+aAFvRXACtDRABBUji/8z+lQBQuM8AZAl6/nZlq//8ywD+oM82ADhI+QE4jA3/CkBr/ltlNP/htfgBi/+EAOaREQDpOBcAdwHx/9Wpl/9jYwn+uQ+//61nbQGuDfv/slgH/hs7RP8KIQL/+GE7ABoekgGwkwoAX3nPAbxYGAC5Xv7+czfJABgyRgB4NQYAjkKSAOTi+f9owN4BrUTbAKK4JP+PZon/nQsXAH0tYgDrXeH+OHCg/0Z08wGZ+Tf/gScRAfFQ9ABXRRUBXuRJ/05CQf/C4+cAPZJX/62bF/9wdNv+2CYL/4O6hQBe1LsAZC9bAMz+r//eEtf+rURs/+PkT/8m3dUAo+OW/h++EgCgswsBClpe/9yuWACj0+X/x4g0AIJf3f+MvOf+i3GA/3Wr7P4x3BT/OxSr/+RtvAAU4SD+wxCuAOP+iAGHJ2kAlk3O/9Lu4gA31IT+7zl8AKrCXf/5EPf/GJc+/wqXCgBPi7L/ePLKABrb1QA+fSP/kAJs/+YhU/9RLdgB4D4RANbZfQBimZn/s7Bq/oNdiv9tPiT/snkg/3j8RgDc+CUAzFhnAYDc+//s4wcBajHG/zw4awBjcu4A3MxeAUm7AQBZmiIATtml/w7D+f8J5v3/zYf1ABr8B/9UzRsBhgJwACWeIADnW+3/v6rM/5gH3gBtwDEAwaaS/+gTtf9pjjT/ZxAbAf3IpQDD2QT/NL2Q/3uboP5Xgjb/Tng9/w44KQAZKX3/V6j1ANalRgDUqQb/29PC/khdpP/FIWf/K46NAIPhrAD0aRwAREThAIhUDf+COSj+i004AFSWNQA2X50AkA2x/l9zugB1F3b/9Kbx/wu6hwCyasv/YdpdACv9LQCkmAQAi3bvAGABGP7rmdP/qG4U/zLvsAByKegAwfo1AP6gb/6Iein/YWxDANeYF/+M0dQAKr2jAMoqMv9qar3/vkTZ/+k6dQDl3PMBxQMEACV4Nv4EnIb/JD2r/qWIZP/U6A4AWq4KANjGQf8MA0AAdHFz//hnCADnfRL/oBzFAB64IwHfSfn/exQu/oc4Jf+tDeUBd6Ei//U9SQDNfXAAiWiGANn2Hv/tjo8AQZ9m/2ykvgDbda3/IiV4/shFUAAffNr+Shug/7qax/9Hx/wAaFGfARHIJwDTPcABGu5bAJTZDAA7W9X/C1G3/4Hmev9yy5EBd7RC/0iKtADglWoAd1Jo/9CMKwBiCbb/zWWG/xJlJgBfxab/y/GTAD7Qkf+F9vsAAqkOAA33uACOB/4AJMgX/1jN3wBbgTT/FboeAI/k0gH36vj/5kUf/rC6h//uzTQBi08rABGw2f4g80MA8m/pACwjCf/jclEBBEcM/yZpvwAHdTL/UU8QAD9EQf+dJG7/TfED/+It+wGOGc4AeHvRARz+7v8FgH7/W97X/6IPvwBW8EkAh7lR/izxowDU29L/cKKbAM9ldgCoSDj/xAU0AEis8v9+Fp3/kmA7/6J5mP6MEF8Aw/7I/lKWogB3K5H+zKxO/6bgnwBoE+3/9X7Q/+I71QB12cUAmEjtANwfF/4OWuf/vNRAATxl9v9VGFYAAbFtAJJTIAFLtsAAd/HgALntG/+4ZVIB6yVN//2GEwDo9noAPGqzAMMLDABtQusBfXE7AD0opACvaPAAAi+7/zIMjQDCi7X/h/poAGFc3v/Zlcn/y/F2/0+XQwB6jtr/lfXvAIoqyP5QJWH/fHCn/ySKV/+CHZP/8VdO/8xhEwGx0Rb/9+N//mN3U//UGcYBELOzAJFNrP5ZmQ7/2r2nAGvpO/8jIfP+LHBw/6F/TwHMrwoAKBWK/mh05ADHX4n/hb6o/5Kl6gG3YycAt9w2/v/ehQCi23n+P+8GAOFmNv/7EvYABCKBAYckgwDOMjsBD2G3AKvYh/9lmCv/lvtbACaRXwAizCb+soxT/xmB8/9MkCUAaiQa/naQrP9EuuX/a6HV/y6jRP+Vqv0AuxEPANqgpf+rI/YBYA0TAKXLdQDWa8D/9HuxAWQDaACy8mH/+0yC/9NNKgH6T0b/P/RQAWll9gA9iDoB7lvVAA47Yv+nVE0AEYQu/jmvxf+5PrgATEDPAKyv0P6vSiUAihvT/pR9wgAKWVEAqMtl/yvV0QHr9TYAHiPi/wl+RgDifV7+nHUU/zn4cAHmMED/pFymAeDW5v8keI8ANwgr//sB9QFqYqUASmtq/jUENv9aspYBA3h7//QFWQFy+j3//plSAU0PEQA57loBX9/mAOw0L/5nlKT/ec8kARIQuf9LFEoAuwtlAC4wgf8W79L/TeyB/29NzP89SGH/x9n7/yrXzACFkcn/OeaSAetkxgCSSSP+bMYU/7ZP0v9SZ4gA9mywACIRPP8TSnL+qKpO/53vFP+VKagAOnkcAE+zhv/neYf/rtFi//N6vgCrps0A1HQwAB1sQv+i3rYBDncVANUn+f/+3+T/t6XGAIW+MAB80G3/d69V/wnReQEwq73/w0eGAYjbM/+2W43+MZ9IACN29f9wuuP/O4kfAIksowByZzz+CNWWAKIKcf/CaEgA3IN0/7JPXADL+tX+XcG9/4L/Iv7UvJcAiBEU/xRlU//UzqYA5e5J/5dKA/+oV9cAm7yF/6aBSQDwT4X/stNR/8tIo/7BqKUADqTH/h7/zABBSFsBpkpm/8gqAP/CceP/QhfQAOXYZP8Y7xoACuk+/3sKsgEaJK7/d9vHAS2jvgAQqCoApjnG/xwaGgB+pecA+2xk/z3lef86dooATM8RAA0icP5ZEKgAJdBp/yPJ1/8oamX+Bu9yAChn4v72f27/P6c6AITwjgAFnlj/gUme/15ZkgDmNpIACC2tAE+pAQBzuvcAVECDAEPg/f/PvUAAmhxRAS24Nv9X1OD/AGBJ/4Eh6wE0QlD/+66b/wSzJQDqpF3+Xa/9AMZFV//gai4AYx3SAD68cv8s6ggAqa/3/xdtif/lticAwKVe/vVl2QC/WGAAxF5j/2ruC/41fvMAXgFl/y6TAgDJfHz/jQzaAA2mnQEw++3/m/p8/2qUkv+2DcoAHD2nANmYCP7cgi3/yOb/ATdBV/9dv2H+cvsOACBpXAEaz40AGM8N/hUyMP+6lHT/0yvhACUiov6k0ir/RBdg/7bWCP/1dYn/QsMyAEsMU/5QjKQACaUkAeRu4wDxEVoBGTTUAAbfDP+L8zkADHFLAfa3v//Vv0X/5g+OAAHDxP+Kqy//QD9qARCp1v/PrjgBWEmF/7aFjACxDhn/k7g1/wrjof942PT/SU3pAJ3uiwE7QekARvvYASm4mf8gy3AAkpP9AFdlbQEsUoX/9JY1/16Y6P87XSf/WJPc/05RDQEgL/z/oBNy/11rJ/92ENMBuXfR/+Pbf/5Yaez/om4X/ySmbv9b7N3/Qup0AG8T9P4K6RoAILcG/gK/8gDanDX+KTxG/6jsbwB5uX7/7o7P/zd+NADcgdD+UMyk/0MXkP7aKGz/f8qkAMshA/8CngAAJWC8/8AxSgBtBAAAb6cK/lvah//LQq3/lsLiAMn9Bv+uZnkAzb9uADXCBABRKC3+I2aP/wxsxv8QG+j//Ee6AbBucgCOA3UBcU2OABOcxQFcL/wANegWATYS6wAuI73/7NSBAAJg0P7I7sf/O6+k/5Ir5wDC2TT/A98MAIo2sv5V688A6M8iADE0Mv+mcVn/Ci3Y/z6tHABvpfYAdnNb/4BUPACnkMsAVw3zABYe5AGxcZL/garm/vyZgf+R4SsARucF/3ppfv5W9pT/biWa/tEDWwBEkT4A5BCl/zfd+f6y0lsAU5Li/kWSugBd0mj+EBmtAOe6JgC9eoz/+w1w/2luXQD7SKoAwBff/xgDygHhXeQAmZPH/m2qFgD4Zfb/snwM/7L+Zv43BEEAfda0ALdgkwAtdRf+hL/5AI+wy/6Itzb/kuqxAJJlVv8se48BIdGYAMBaKf5TD33/1axSANepkAAQDSIAINFk/1QS+QHFEez/2brmADGgsP9vdmH/7WjrAE87XP5F+Qv/I6xKARN2RADefKX/tEIj/1au9gArSm//fpBW/+TqWwDy1Rj+RSzr/9y0IwAI+Af/Zi9c//DNZv9x5qsBH7nJ/8L2Rv96EbsAhkbH/5UDlv91P2cAQWh7/9Q2EwEGjVgAU4bz/4g1ZwCpG7QAsTEYAG82pwDDPdf/HwFsATwqRgC5A6L/wpUo//Z/Jv6+dyb/PXcIAWCh2/8qy90BsfKk//WfCgB0xAAABV3N/oB/swB97fb/laLZ/1clFP6M7sAACQnBAGEB4gAdJgoAAIg//+VI0v4mhlz/TtrQAWgkVP8MBcH/8q89/7+pLgGzk5P/cb6L/n2sHwADS/z+1yQPAMEbGAH/RZX/boF2AMtd+QCKiUD+JkYGAJl03gChSnsAwWNP/3Y7Xv89DCsBkrGdAC6TvwAQ/yYACzMfATw6Yv9vwk0Bmlv0AIwokAGtCvsAy9Ey/myCTgDktFoArgf6AB+uPAApqx4AdGNS/3bBi/+7rcb+2m84ALl72AD5njQANLRd/8kJW/84Lab+hJvL/zrobgA001n//QCiAQlXtwCRiCwBXnr1AFW8qwGTXMYAAAhoAB5frgDd5jQB9/fr/4muNf8jFcz/R+PWAehSwgALMOP/qkm4/8b7/P4scCIAg2WD/0iouwCEh33/imhh/+64qP/zaFT/h9ji/4uQ7QC8iZYBUDiM/1app//CThn/3BG0/xENwQB1idT/jeCXADH0rwDBY6//E2OaAf9BPv+c0jf/8vQD//oOlQCeWNn/nc+G/vvoHAAunPv/qzi4/+8z6gCOioP/Gf7zAQrJwgA/YUsA0u+iAMDIHwF11vMAGEfe/jYo6P9Mt2/+kA5X/9ZPiP/YxNQAhBuM/oMF/QB8bBP/HNdLAEzeN/7ptj8ARKu//jRv3v8KaU3/UKrrAI8YWP8t53kAlIHgAT32VAD9Ltv/70whADGUEv7mJUUAQ4YW/o6bXgAfndP+1Soe/wTk9/78sA3/JwAf/vH0//+qLQr+/d75AN5yhAD/Lwb/tKOzAVRel/9Z0VL+5TSp/9XsAAHWOOT/h3eX/3DJwQBToDX+BpdCABKiEQDpYVsAgwVOAbV4Nf91Xz//7XW5AL9+iP+Qd+kAtzlhAS/Ju/+npXcBLWR+ABViBv6Rll//eDaYANFiaACPbx7+uJT5AOvYLgD4ypT/OV8WAPLhowDp9+j/R6sT/2f0Mf9UZ13/RHn0AVLgDQApTyv/+c6n/9c0Ff7AIBb/9288AGVKJv8WW1T+HRwN/8bn1/70msgA34ntANOEDgBfQM7/ET73/+mDeQFdF00Azcw0/lG9iAC024oBjxJeAMwrjP68r9sAb2KP/5c/ov/TMkf+E5I1AJItU/6yUu7/EIVU/+LGXf/JYRT/eHYj/3Iy5/+i5Zz/0xoMAHInc//O1IYAxdmg/3SBXv7H19v/S9/5Af10tf/o12j/5IL2/7l1VgAOBQgA7x09Ae1Xhf99kon+zKjfAC6o9QCaaRYA3NSh/2tFGP+J2rX/8VTG/4J60/+NCJn/vrF2AGBZsgD/EDD+emBp/3U26P8ifmn/zEOmAOg0iv/TkwwAGTYHACwP1/4z7C0AvkSBAWqT4QAcXS3+7I0P/xE9oQDcc8AA7JEY/m+oqQDgOj//f6S8AFLqSwHgnoYA0URuAdmm2QBG4aYBu8GP/xAHWP8KzYwAdcCcARE4JgAbfGwBq9c3/1/91ACbh6j/9rKZ/ppESgDoPWD+aYQ7ACFMxwG9sIL/CWgZ/kvGZv/pAXAAbNwU/3LmRgCMwoX/OZ6k/pIGUP+pxGEBVbeCAEae3gE77er/YBka/+ivYf8Lefj+WCPCANu0/P5KCOMAw+NJAbhuof8x6aQBgDUvAFIOef/BvjoAMK51/4QXIAAoCoYBFjMZ//ALsP9uOZIAdY/vAZ1ldv82VEwAzbgS/y8ESP9OcFX/wTJCAV0QNP8IaYYADG1I/zqc+wCQI8wALKB1/jJrwgABRKX/b26iAJ5TKP5M1uoAOtjN/6tgk/8o43IBsOPxAEb5twGIVIv/PHr3/o8Jdf+xron+SfePAOy5fv8+Gff/LUA4/6H0BgAiOTgBacpTAICT0AAGZwr/SopB/2FQZP/WriH/MoZK/26Xgv5vVKwAVMdL/vg7cP8I2LIBCbdfAO4bCP6qzdwAw+WHAGJM7f/iWxoBUtsn/+G+xwHZyHn/UbMI/4xBzgCyz1f++vwu/2hZbgH9vZ7/kNae/6D1Nv81t1wBFcjC/5IhcQHRAf8A62or/6c06ACd5d0AMx4ZAPrdGwFBk1f/T3vEAEHE3/9MLBEBVfFEAMq3+f9B1NT/CSGaAUc7UACvwjv/jUgJAGSg9ADm0DgAOxlL/lDCwgASA8j+oJ9zAISP9wFvXTn/Ou0LAYbeh/96o2wBeyu+//u9zv5Qtkj/0PbgARE8CQChzyYAjW1bANgP0/+ITm4AYqNo/xVQef+tsrcBf48EAGg8Uv7WEA3/YO4hAZ6U5v9/gT7/M//S/z6N7P6dN+D/cif0AMC8+v/kTDUAYlRR/63LPf6TMjf/zOu/ADTF9ABYK9P+G793ALznmgBCUaEAXMGgAfrjeAB7N+IAuBFIAIWoCv4Wh5z/KRln/zDKOgC6lVH/vIbvAOu1vf7Zi7z/SjBSAC7a5QC9/fsAMuUM/9ONvwGA9Bn/qed6/lYvvf+Etxf/JbKW/zOJ/QDITh8AFmkyAII8AACEo1v+F+e7AMBP7wCdZqT/wFIUARi1Z//wCeoAAXuk/4XpAP/K8vIAPLr1APEQx//gdJ7+v31b/+BWzwB5Jef/4wnG/w+Z7/956Nn+S3BSAF8MOf4z1mn/lNxhAcdiJACc0Qz+CtQ0ANm0N/7Uquj/2BRU/536hwCdY3/+Ac4pAJUkRgE2xMn/V3QA/uurlgAbo+oAyoe0ANBfAP57nF0Atz5LAInrtgDM4f//1ovS/wJzCP8dDG8ANJwBAP0V+/8lpR/+DILTAGoSNf4qY5oADtk9/tgLXP/IxXD+kybHACT8eP5rqU0AAXuf/89LZgCjr8QALAHwAHi6sP4NYkz/7Xzx/+iSvP/IYOAAzB8pANDIDQAV4WD/r5zEAPfQfgA+uPT+AqtRAFVzngA2QC3/E4pyAIdHzQDjL5MB2udCAP3RHAD0D63/Bg92/hCW0P+5FjL/VnDP/0tx1wE/kiv/BOET/uMXPv8O/9b+LQjN/1fFl/7SUtf/9fj3/4D4RgDh91cAWnhGANX1XAANheIAL7UFAVyjaf8GHoX+6LI9/+aVGP8SMZ4A5GQ9/nTz+/9NS1wBUduT/0yj/v6N1fYA6CWY/mEsZADJJTIB1PQ5AK6rt//5SnAAppweAN7dYf/zXUn++2Vk/9jZXf/+irv/jr40/zvLsf/IXjQAc3Ke/6WYaAF+Y+L/dp30AWvIEADBWuUAeQZYAJwgXf598dP/Du2d/6WaFf+44Bb/+hiY/3FNHwD3qxf/7bHM/zSJkf/CtnIA4OqVAApvZwHJgQQA7o5OADQGKP9u1aX+PM/9AD7XRQBgYQD/MS3KAHh5Fv/rizABxi0i/7YyGwGD0lv/LjaAAK97af/GjU7+Q/Tv//U2Z/5OJvL/Alz5/vuuV/+LP5AAGGwb/yJmEgEiFpgAQuV2/jKPYwCQqZUBdh6YALIIeQEInxIAWmXm/4EddwBEJAsB6Lc3ABf/YP+hKcH/P4veAA+z8wD/ZA//UjWHAIk5lQFj8Kr/Fubk/jG0Uv89UisAbvXZAMd9PQAu/TQAjcXbANOfwQA3eWn+txSBAKl3qv/Lsov/hyi2/6wNyv9BspQACM8rAHo1fwFKoTAA49aA/lYL8/9kVgcB9USG/z0rFQGYVF7/vjz6/u926P/WiCUBcUxr/11oZAGQzhf/bpaaAeRnuQDaMTL+h02L/7kBTgAAoZT/YR3p/8+Ulf+gqAAAW4Cr/wYcE/4Lb/cAJ7uW/4rolQB1PkT/P9i8/+vqIP4dOaD/GQzxAak8vwAgg43/7Z97/17FXv50/gP/XLNh/nlhXP+qcA4AFZX4APjjAwBQYG0AS8BKAQxa4v+hakQB0HJ//3Iq//5KGkr/97OW/nmMPACTRsj/1iih/6G8yf+NQYf/8nP8AD4vygC0lf/+gjftAKURuv8KqcIAnG3a/3CMe/9ogN/+sY5s/3kl2/+ATRL/b2wXAVvASwCu9Rb/BOw+/ytAmQHjrf4A7XqEAX9Zuv+OUoD+/FSuAFqzsQHz1lf/Zzyi/9CCDv8LgosAzoHb/17Znf/v5ub/dHOf/qRrXwAz2gIB2H3G/4zKgP4LX0T/Nwld/q6ZBv/MrGAARaBuANUmMf4bUNUAdn1yAEZGQ/8Pjkn/g3q5//MUMv6C7SgA0p+MAcWXQf9UmUIAw35aABDu7AF2u2b/AxiF/7tF5gA4xVwB1UVe/1CK5QHOB+YA3m/mAVvpd/8JWQcBAmIBAJRKhf8z9rT/5LFwATq9bP/Cy+3+FdHDAJMKIwFWneIAH6OL/jgHS/8+WnQAtTypAIqi1P5Rpx8AzVpw/yFw4wBTl3UBseBJ/66Q2f/mzE//Fk3o/3JO6gDgOX7+CTGNAPKTpQFotoz/p4QMAXtEfwDhVycB+2wIAMbBjwF5h8//rBZGADJEdP9lryj/+GnpAKbLBwBuxdoA1/4a/qji/QAfj2AAC2cpALeBy/5k90r/1X6EANKTLADH6hsBlC+1AJtbngE2aa//Ak6R/maaXwCAz3/+NHzs/4JURwDd89MAmKrPAN5qxwC3VF7+XMg4/4q2cwGOYJIAhYjkAGESlgA3+0IAjGYEAMpnlwAeE/j/M7jPAMrGWQA3xeH+qV/5/0JBRP+86n4Apt9kAXDv9ACQF8IAOie2APQsGP6vRLP/mHaaAbCiggDZcsz+rX5O/yHeHv8kAlv/Ao/zAAnr1wADq5cBGNf1/6gvpP7xks8ARYG0AETzcQCQNUj++y0OABduqABERE//bkZf/q5bkP8hzl//iSkH/xO7mf4j/3D/CZG5/jKdJQALcDEBZgi+/+rzqQE8VRcASie9AHQx7wCt1dIALqFs/5+WJQDEeLn/ImIG/5nDPv9h5kf/Zj1MABrU7P+kYRAAxjuSAKMXxAA4GD0AtWLBAPuT5f9ivRj/LjbO/+pS9gC3ZyYBbT7MAArw4ACSFnX/jpp4AEXUIwDQY3YBef8D/0gGwgB1EcX/fQ8XAJpPmQDWXsX/uTeT/z7+Tv5/UpkAbmY//2xSof9pu9QBUIonADz/Xf9IDLoA0vsfAb6nkP/kLBP+gEPoANb5a/6IkVb/hC6wAL274//QFowA2dN0ADJRuv6L+h8AHkDGAYebZACgzhf+u6LT/xC8PwD+0DEAVVS/APHA8v+ZfpEB6qKi/+Zh2AFAh34AvpTfATQAK/8cJ70BQIjuAK/EuQBi4tX/f5/0AeKvPACg6Y4BtPPP/0WYWQEfZRUAkBmk/ou/0QBbGXkAIJMFACe6e/8/c+b/XafG/4/V3P+znBP/GUJ6ANag2f8CLT7/ak+S/jOJY/9XZOf/r5Ho/2W4Af+uCX0AUiWhASRyjf8w3o7/9bqaAAWu3f4/cpv/hzegAVAfhwB++rMB7NotABQckQEQk0kA+b2EARG9wP/fjsb/SBQP//o17f4PCxIAG9Nx/tVrOP+uk5L/YH4wABfBbQElol4Ax535/hiAu//NMbL+XaQq/yt36wFYt+3/2tIB/2v+KgDmCmP/ogDiANvtWwCBsssA0DJf/s7QX//3v1n+bupP/6U98wAUenD/9va5/mcEewDpY+YB21v8/8feFv+z9en/0/HqAG/6wP9VVIgAZToy/4OtnP53LTP/dukQ/vJa1gBen9sBAwPq/2JMXP5QNuYABeTn/jUY3/9xOHYBFIQB/6vS7AA48Z7/unMT/wjlrgAwLAABcnKm/wZJ4v/NWfQAieNLAfitOABKePb+dwML/1F4xv+IemL/kvHdAW3CTv/f8UYB1sip/2G+L/8vZ67/Y1xI/nbptP/BI+n+GuUg/978xgDMK0f/x1SsAIZmvgBv7mH+5ijmAOPNQP7IDOEAphneAHFFM/+PnxgAp7hKAB3gdP6e0OkAwXR+/9QLhf8WOowBzCQz/+geKwDrRrX/QDiS/qkSVP/iAQ3/yDKw/zTV9f6o0WEAv0c3ACJOnADokDoBuUq9ALqOlf5ARX//ocuT/7CXvwCI58v+o7aJAKF++/7pIEIARM9CAB4cJQBdcmAB/lz3/yyrRQDKdwv/vHYyAf9TiP9HUhoARuMCACDreQG1KZoAR4bl/sr/JAApmAUAmj9J/yK2fAB53Zb/GszVASmsVwBanZL/bYIUAEdryP/zZr0AAcOR/i5YdQAIzuMAv279/22AFP6GVTP/ibFwAdgiFv+DEND/eZWqAHITFwGmUB//cfB6AOiz+gBEbrT+0qp3AN9spP/PT+n/G+Xi/tFiUf9PRAcAg7lkAKodov8Romv/ORULAWTItf9/QaYBpYbMAGinqAABpE8Akoc7AUYygP9mdw3+4waHAKKOs/+gZN4AG+DbAZ5dw//qjYkAEBh9/+7OL/9hEWL/dG4M/2BzTQBb4+j/+P5P/1zlBv5YxosAzkuBAPpNzv+N9HsBikXcACCXBgGDpxb/7USn/se9lgCjq4r/M7wG/18dif6U4rMAtWvQ/4YfUv+XZS3/gcrhAOBIkwAwipf/w0DO/u3angBqHYn+/b3p/2cPEf/CYf8Asi2p/sbhmwAnMHX/h2pzAGEmtQCWL0H/U4Ll/vYmgQBc75r+W2N/AKFvIf/u2fL/g7nD/9W/nv8pltoAhKmDAFlU/AGrRoD/o/jL/gEytP98TFUB+29QAGNC7/+a7bb/3X6F/krMY/9Bk3f/Yzin/0/4lf90m+T/7SsO/kWJC/8W+vEBW3qP/8358wDUGjz/MLawATAXv//LeZj+LUrV/z5aEv71o+b/uWp0/1MjnwAMIQL/UCI+ABBXrv+tZVUAyiRR/qBFzP9A4bsAOs5eAFaQLwDlVvUAP5G+ASUFJwBt+xoAiZPqAKJ5kf+QdM7/xei5/7e+jP9JDP7/ixTy/6pa7/9hQrv/9bWH/t6INAD1BTP+yy9OAJhl2ABJF30A/mAhAevSSf8r0VgBB4FtAHpo5P6q8ssA8syH/8oc6f9BBn8An5BHAGSMXwBOlg0A+2t2AbY6ff8BJmz/jb3R/wibfQFxo1v/eU++/4bvbP9ML/gAo+TvABFvCgBYlUv/1+vvAKefGP8vl2z/a9G8AOnnY/4cypT/riOK/24YRP8CRbUAa2ZSAGbtBwBcJO3/3aJTATfKBv+H6of/GPreAEFeqP71+NL/p2zJ/v+hbwDNCP4AiA10AGSwhP8r137/sYWC/55PlABD4CUBDM4V/z4ibgHtaK//UIRv/46uSABU5bT+abOMAED4D//pihAA9UN7/tp51P8/X9oB1YWJ/4+2Uv8wHAsA9HKNAdGvTP+dtZb/uuUD/6SdbwHnvYsAd8q+/9pqQP9E6z/+YBqs/7svCwHXEvv/UVRZAEQ6gABecQUBXIHQ/2EPU/4JHLwA7wmkADzNmADAo2L/uBI8ANm2iwBtO3j/BMD7AKnS8P8lrFz+lNP1/7NBNAD9DXMAua7OAXK8lf/tWq0AK8fA/1hscQA0I0wAQhmU/90EB/+X8XL/vtHoAGIyxwCXltX/EkokATUoBwATh0H/GqxFAK7tVQBjXykAAzgQACegsf/Iatr+uURU/1u6Pf5Dj43/DfSm/2NyxgDHbqP/wRK6AHzv9gFuRBYAAusuAdQ8awBpKmkBDuaYAAcFgwCNaJr/1QMGAIPkov+zZBwB53tV/84O3wH9YOYAJpiVAWKJegDWzQP/4piz/waFiQCeRYz/caKa/7TzrP8bvXP/jy7c/9WG4f9+HUUAvCuJAfJGCQBazP//56qTABc4E/44fZ3/MLPa/0+2/f8m1L8BKet8AGCXHACHlL4Azfkn/jRgiP/ULIj/Q9GD//yCF//bgBT/xoF2AGxlCwCyBZIBPgdk/7XsXv4cGqQATBZw/3hmTwDKwOUByLDXAClA9P/OuE4Apy0/AaAjAP87DI7/zAmQ/9te5QF6G3AAvWlt/0DQSv/7fzcBAuLGACxM0QCXmE3/0hcuAcmrRf8s0+cAviXg//XEPv+ptd7/ItMRAHfxxf/lI5gBFUUo/7LioQCUs8EA28L+ASjOM//nXPoBQ5mqABWU8QCqRVL/eRLn/1xyAwC4PuYA4clX/5Jgov+18twArbvdAeI+qv84ftkBdQ3j/7Ms7wCdjZv/kN1TAOvR0AAqEaUB+1GFAHz1yf5h0xj/U9amAJokCf/4L38AWtuM/6HZJv7Ukz//QlSUAc8DAQDmhlkBf056/+CbAf9SiEoAspzQ/7oZMf/eA9IB5Za+/1WiNP8pVI3/SXtU/l0RlgB3ExwBIBbX/xwXzP+O8TT/5DR9AB1MzwDXp/r+r6TmADfPaQFtu/X/oSzcASllgP+nEF4AXdZr/3ZIAP5QPer/ea99AIup+wBhJ5P++sQx/6Wzbv7fRrv/Fo59AZqziv92sCoBCq6ZAJxcZgCoDaH/jxAgAPrFtP/LoywBVyAkAKGZFP97/A8AGeNQADxYjgARFskBms1N/yc/LwAIeo0AgBe2/swnE/8EcB3/FySM/9LqdP41Mj//eato/6DbXgBXUg7+5yoFAKWLf/5WTiYAgjxC/sseLf8uxHoB+TWi/4iPZ/7X0nIA5weg/qmYKv9vLfYAjoOH/4NHzP8k4gsAABzy/+GK1f/3Ltj+9QO3AGz8SgHOGjD/zTb2/9PGJP95IzIANNjK/yaLgf7ySZQAQ+eN/yovzABOdBkBBOG//waT5AA6WLEAeqXl//xTyf/gp2ABsbie//JpswH4xvAAhULLAf4kLwAtGHP/dz7+AMThuv57jawAGlUp/+JvtwDV55cABDsH/+6KlABCkyH/H/aN/9GNdP9ocB8AWKGsAFPX5v4vb5cALSY0AYQtzACKgG3+6XWG//O+rf7x7PAAUn/s/ijfof9utuH/e67vAIfykQEz0ZoAlgNz/tmk/P83nEUBVF7//+hJLQEUE9T/YMU7/mD7IQAmx0kBQKz3/3V0OP/kERIAPopnAfblpP/0dsn+ViCf/20iiQFV07oACsHB/nrCsQB67mb/otqrAGzZoQGeqiIAsC+bAbXkC/8InAAAEEtdAM5i/wE6miMADPO4/kN1Qv/m5XsAySpuAIbksv66bHb/OhOa/1KpPv9yj3MB78Qy/60wwf+TAlT/loaT/l/oSQBt4zT+v4kKACjMHv5MNGH/pOt+AP58vABKthUBeR0j//EeB/5V2tb/B1SW/lEbdf+gn5j+Qhjd/+MKPAGNh2YA0L2WAXWzXACEFoj/eMccABWBT/62CUEA2qOpAPaTxv9rJpABTq/N/9YF+v4vWB3/pC/M/ys3Bv+Dhs/+dGTWAGCMSwFq3JAAwyAcAaxRBf/HszT/JVTLAKpwrgALBFsARfQbAXWDXAAhmK//jJlr//uHK/5XigT/xuqT/nmYVP/NZZsBnQkZAEhqEf5smQD/veW6AMEIsP+uldEA7oIdAOnWfgE94mYAOaMEAcZvM/8tT04Bc9IK/9oJGf+ei8b/01K7/lCFUwCdgeYB84WG/yiIEABNa0//t1VcAbHMygCjR5P/mEW+AKwzvAH60qz/0/JxAVlZGv9AQm/+dJgqAKEnG/82UP4AatFzAWd8YQDd5mL/H+cGALLAeP4P2cv/fJ5PAHCR9wBc+jABo7XB/yUvjv6QvaX/LpLwAAZLgAApncj+V3nVAAFx7AAFLfoAkAxSAB9s5wDh73f/pwe9/7vkhP9uvSIAXizMAaI0xQBOvPH+ORSNAPSSLwHOZDMAfWuU/hvDTQCY/VoBB4+Q/zMlHwAidyb/B8V2AJm80wCXFHT+9UE0/7T9bgEvsdEAoWMR/3beygB9s/wBezZ+/5E5vwA3unkACvOKAM3T5f99nPH+lJy5/+MTvP98KSD/HyLO/hE5UwDMFiX/KmBiAHdmuAEDvhwAblLa/8jMwP/JkXYAdcySAIQgYgHAwnkAaqH4Ae1YfAAX1BoAzata//gw2AGNJeb/fMsA/p6oHv/W+BUAcLsH/0uF7/9K4/P/+pNGANZ4ogCnCbP/Fp4SANpN0QFhbVH/9CGz/zk0Of9BrNL/+UfR/46p7gCevZn/rv5n/mIhDgCNTOb/cYs0/w861ACo18n/+MzXAd9EoP85mrf+L+d5AGqmiQBRiIoApSszAOeLPQA5Xzv+dmIZ/5c/7AFevvr/qblyAQX6Ov9LaWEB19+GAHFjowGAPnAAY2qTAKPDCgAhzbYA1g6u/4Em5/81tt8AYiqf//cNKAC80rEBBhUA//89lP6JLYH/WRp0/n4mcgD7MvL+eYaA/8z5p/6l69cAyrHzAIWNPgDwgr4Bbq//AAAUkgEl0nn/ByeCAI76VP+NyM8ACV9o/wv0rgCG6H4ApwF7/hDBlf/o6e8B1UZw//x0oP7y3tz/zVXjAAe5OgB29z8BdE2x/z71yP4/EiX/azXo/jLd0wCi2wf+Al4rALY+tv6gTsj/h4yqAOu45ACvNYr+UDpN/5jJAgE/xCIABR64AKuwmgB5O84AJmMnAKxQTf4AhpcAuiHx/l793/8scvwAbH45/8koDf8n5Rv/J+8XAZd5M/+ZlvgACuqu/3b2BP7I9SYARaHyARCylgBxOIIAqx9pABpYbP8xKmoA+6lCAEVdlQAUOf4ApBlvAFq8Wv/MBMUAKNUyAdRghP9YirT+5JJ8/7j29wBBdVb//WbS/v55JACJcwP/PBjYAIYSHQA74mEAsI5HAAfRoQC9VDP+m/pIANVU6/8t3uAA7pSP/6oqNf9Op3UAugAo/32xZ/9F4UIA4wdYAUusBgCpLeMBECRG/zICCf+LwRYAj7fn/tpFMgDsOKEB1YMqAIqRLP6I5Sj/MT8j/z2R9f9lwAL+6KdxAJhoJgF5udoAeYvT/nfwIwBBvdn+u7Oi/6C75gA++A7/PE5hAP/3o//hO1v/a0c6//EvIQEydewA27E//vRaswAjwtf/vUMy/xeHgQBovSX/uTnCACM+5//c+GwADOeyAI9QWwGDXWX/kCcCAf/6sgAFEez+iyAuAMy8Jv71czT/v3FJ/r9sRf8WRfUBF8uyAKpjqgBB+G8AJWyZ/0AlRQAAWD7+WZSQ/79E4AHxJzUAKcvt/5F+wv/dKv3/GWOXAGH93wFKczH/Bq9I/zuwywB8t/kB5ORjAIEMz/6owMP/zLAQ/pjqqwBNJVX/IXiH/47C4wEf1joA1bt9/+guPP++dCr+l7IT/zM+7f7M7MEAwug8AKwinf+9ELj+ZwNf/43pJP4pGQv/FcOmAHb1LQBD1ZX/nwwS/7uk4wGgGQUADE7DASvF4QAwjin+xJs8/9/HEgGRiJwA/HWp/pHi7gDvF2sAbbW8/+ZwMf5Jqu3/57fj/1DcFADCa38Bf81lAC40xQHSqyT/WANa/ziXjQBgu///Kk7IAP5GRgH0fagAzESKAXzXRgBmQsj+ETTkAHXcj/7L+HsAOBKu/7qXpP8z6NABoOQr//kdGQFEvj8ADQAAAAD/AAAAAPUAAAAAAAD7AAAAAAAA/QAAAADzAAAAAAcAAAAAAAMAAAAA8wAAAAAFAAAAAAAAAAALAAAAAAALAAAAAPMAAAAAAAD9AAAAAAD/AAAAAAMAAAAA9QAAAAAAAAAPAAAAAAD/AAAAAP8AAAAABwAAAAAFAEHchwILAQEAQYCIAgsBAQBBoIgCC+AB4Ot6fDtBuK4WVuP68Z/EatoJjeucMrH9hmIFFl9JuABfnJW8o1CMJLHQsVWcg+9bBERcxFgcjobYIk7d0J8RV+z///////////////////////////////////////9/7f///////////////////////////////////////3/u////////////////////////////////////////fwjJvPNn5glqO6fKhIWuZ7sr+JT+cvNuPPE2HV869U+l0YLmrX9SDlEfbD4rjGgFm2u9Qfur2YMfeSF+ExnN4FsAQaCKAgvBBQjJvPNn5glqO6fKhIWuZ7sr+JT+cvNuPPE2HV869U+l0YLmrX9SDlEfbD4rjGgFm2u9Qfur2YMfeSF+ExnN4FsirijXmC+KQs1l7yORRDdxLztN7M/7wLW824mBpdu16Ti1SPNbwlY5GdAFtvER8VmbTxmvpII/khiBbdrVXhyrQgIDo5iqB9i+b3BFAVuDEoyy5E6+hTEk4rT/1cN9DFVviXvydF2+crGWFjv+sd6ANRLHJacG3JuUJmnPdPGbwdJK8Z7BaZvk4yVPOIZHvu+11YyLxp3BD2WcrHfMoQwkdQIrWW8s6S2D5KZuqoR0StT7Qb3cqbBctVMRg9qI+Xar32buUlE+mBAytC1txjGoPyH7mMgnA7DkDu++x39Zv8KPqD3zC+DGJacKk0eRp9VvggPgUWPKBnBuDgpnKSkU/C/SRoUKtycmySZcOCEbLu0qxFr8bSxN37OVnRMNOFPeY6+LVHMKZaiydzy7Cmp25q7tRy7JwoE7NYIUhSxykmQD8Uyh6L+iATBCvEtmGqiRl/jQcItLwjC+VAajUWzHGFLv1hnoktEQqWVVJAaZ1iogcVeFNQ70uNG7MnCgahDI0NK4FsGkGVOrQVEIbDcemeuO30x3SCeoSJvhtbywNGNaycWzDBw5y4pB40qq2E5z42N3T8qcW6O4stbzby5o/LLvXe6Cj3RgLxdDb2OleHKr8KEUeMiE7DlkGggCx4woHmMj+v++kOm9gt7rbFCkFXnGsvej+b4rU3Lj8nhxxpxhJurOPifKB8LAIce4htEe6+DN1n3a6njRbu5/T331um8Xcqpn8AammMiixX1jCq4N+b4EmD8RG0ccEzULcRuEfQQj9XfbKJMkx0B7q8oyvL7JFQq+njxMDRCcxGcdQ7ZCPsu+1MVMKn5l/Jwpf1ns+tY6q2/LXxdYR0qMGURsgABB4JACCyFTaWdFZDI1NTE5IG5vIEVkMjU1MTkgY29sbGlzaW9ucwEAQbCRAgs1MI5QAAEAAAACAAAAAwAAAAQAAAAFAAAABgAAAAcAAAAIAAAACQAAAAoAAAALAAAADAAAAA0=") || (d = R, R = a.locateFile ? a.locateFile(d, c) : c + d);
            var V = { 35048: function() {
              return a.getRandomValue();
            }, 35084: function() {
              if (a.getRandomValue === void 0)
                try {
                  var A4 = typeof window == "object" ? window : self, I4 = A4.crypto !== void 0 ? A4.crypto : A4.msCrypto, g3 = function() {
                    var A5 = new Uint32Array(1);
                    return I4.getRandomValues(A5), A5[0] >>> 0;
                  };
                  g3(), a.getRandomValue = g3;
                } catch (A5) {
                  try {
                    var B2 = __require("crypto"), C2 = function() {
                      var A6 = B2.randomBytes(4);
                      return (A6[0] << 24 | A6[1] << 16 | A6[2] << 8 | A6[3]) >>> 0;
                    };
                    C2(), a.getRandomValue = C2;
                  } catch (A6) {
                    throw "No secure random number generator found";
                  }
                }
            } };
            function q(A4) {
              for (; A4.length > 0; ) {
                var I4 = A4.shift();
                if (typeof I4 != "function") {
                  var g3 = I4.func;
                  typeof g3 == "number" ? I4.arg === void 0 ? z(g3)() : z(g3)(I4.arg) : g3(I4.arg === void 0 ? null : I4.arg);
                } else
                  I4(a);
              }
            }
            function z(A4) {
              return S.get(A4);
            }
            var j = [];
            function W(A4) {
              try {
                return s.grow(A4 - D.byteLength + 65535 >>> 16), U(s.buffer), 1;
              } catch (A5) {
              }
            }
            var O = typeof atob == "function" ? atob : function(A4) {
              var I4, g3, B2, C2, Q2, E2, i2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=", n2 = "", a2 = 0;
              A4 = A4.replace(/[^A-Za-z0-9\+\/\=]/g, "");
              do {
                I4 = i2.indexOf(A4.charAt(a2++)) << 2 | (C2 = i2.indexOf(A4.charAt(a2++))) >> 4, g3 = (15 & C2) << 4 | (Q2 = i2.indexOf(A4.charAt(a2++))) >> 2, B2 = (3 & Q2) << 6 | (E2 = i2.indexOf(A4.charAt(a2++))), n2 += String.fromCharCode(I4), Q2 !== 64 && (n2 += String.fromCharCode(g3)), E2 !== 64 && (n2 += String.fromCharCode(B2));
              } while (a2 < A4.length);
              return n2;
            };
            function Z(A4) {
              if (K(A4))
                return function(A5) {
                  if (typeof f == "boolean" && f) {
                    var I4 = Buffer.from(A5, "base64");
                    return new Uint8Array(I4.buffer, I4.byteOffset, I4.byteLength);
                  }
                  try {
                    for (var g3 = O(A5), B2 = new Uint8Array(g3.length), C2 = 0; C2 < g3.length; ++C2)
                      B2[C2] = g3.charCodeAt(C2);
                    return B2;
                  } catch (A6) {
                    throw new Error("Converting base64 string to bytes failed.");
                  }
                }(A4.slice(L.length));
            }
            var $, AA = { a: function(A4, I4, g3, B2) {
              N("Assertion failed: " + G(A4) + ", at: " + [I4 ? G(I4) : "unknown filename", g3, B2 ? G(B2) : "unknown function"]);
            }, d: function() {
              N("");
            }, b: function(A4, I4, g3) {
              var B2 = function(A5, I5) {
                var g4;
                for (j.length = 0, I5 >>= 2; g4 = p[A5++]; ) {
                  var B3 = g4 < 105;
                  B3 && 1 & I5 && I5++, j.push(B3 ? _[I5++ >> 1] : F[I5]), ++I5;
                }
                return j;
              }(I4, g3);
              return V[A4].apply(null, B2);
            }, e: function(A4, I4, g3) {
              p.copyWithin(A4, I4, I4 + g3);
            }, c: function(A4) {
              var I4, g3 = p.length, B2 = 2147483648;
              if ((A4 >>>= 0) > B2)
                return false;
              for (var C2 = 1; C2 <= 4; C2 *= 2) {
                var Q2 = g3 * (1 + 0.2 / C2);
                if (Q2 = Math.min(Q2, A4 + 100663296), W(Math.min(B2, (I4 = Math.max(A4, Q2)) + (65536 - I4 % 65536) % 65536)))
                  return true;
              }
              return false;
            } };
            function IA(A4) {
              function I4() {
                $ || ($ = true, a.calledRun = true, k || (q(m), a.onRuntimeInitialized && a.onRuntimeInitialized(), function() {
                  if (a.postRun)
                    for (typeof a.postRun == "function" && (a.postRun = [a.postRun]); a.postRun.length; )
                      A5 = a.postRun.shift(), v.unshift(A5);
                  var A5;
                  q(v);
                }()));
              }
              A4 = A4 || o, M > 0 || (function() {
                if (a.preRun)
                  for (typeof a.preRun == "function" && (a.preRun = [a.preRun]); a.preRun.length; )
                    A5 = a.preRun.shift(), b.unshift(A5);
                var A5;
                q(b);
              }(), M > 0 || (a.setStatus ? (a.setStatus("Running..."), setTimeout(function() {
                setTimeout(function() {
                  a.setStatus("");
                }, 1), I4();
              }, 1)) : I4()));
            }
            if (function() {
              var A4 = { a: AA };
              function I4(A5, I5) {
                var g4, B3 = A5.exports;
                a.asm = B3, U((s = a.asm.f).buffer), S = a.asm.Ac, g4 = a.asm.g, m.unshift(g4), function(A6) {
                  if (M--, a.monitorRunDependencies && a.monitorRunDependencies(M), M == 0 && (P !== null && (clearInterval(P), P = null), Y)) {
                    var I6 = Y;
                    Y = null, I6();
                  }
                }();
              }
              function g3(A5) {
                I4(A5.instance);
              }
              function B2(I5) {
                return function() {
                  if (!y && (t || e)) {
                    if (typeof fetch == "function" && !X(R))
                      return fetch(R, { credentials: "same-origin" }).then(function(A5) {
                        if (!A5.ok)
                          throw "failed to load wasm binary file at '" + R + "'";
                        return A5.arrayBuffer();
                      }).catch(function() {
                        return T(R);
                      });
                    if (C)
                      return new Promise(function(A5, I6) {
                        C(R, function(I7) {
                          A5(new Uint8Array(I7));
                        }, I6);
                      });
                  }
                  return Promise.resolve().then(function() {
                    return T(R);
                  });
                }().then(function(I6) {
                  return WebAssembly.instantiate(I6, A4);
                }).then(function(A5) {
                  return A5;
                }).then(I5, function(A5) {
                  w("failed to asynchronously prepare wasm: " + A5), N(A5);
                });
              }
              if (M++, a.monitorRunDependencies && a.monitorRunDependencies(M), a.instantiateWasm)
                try {
                  return a.instantiateWasm(A4, I4);
                } catch (A5) {
                  return w("Module.instantiateWasm callback failed with error: " + A5), false;
                }
              y || typeof WebAssembly.instantiateStreaming != "function" || K(R) || X(R) || typeof fetch != "function" ? B2(g3) : fetch(R, { credentials: "same-origin" }).then(function(I5) {
                return WebAssembly.instantiateStreaming(I5, A4).then(g3, function(A5) {
                  return w("wasm streaming compile failed: " + A5), w("falling back to ArrayBuffer instantiation"), B2(g3);
                });
              });
            }(), a.___wasm_call_ctors = function() {
              return (a.___wasm_call_ctors = a.asm.g).apply(null, arguments);
            }, a._crypto_aead_chacha20poly1305_encrypt_detached = function() {
              return (a._crypto_aead_chacha20poly1305_encrypt_detached = a.asm.h).apply(null, arguments);
            }, a._crypto_aead_chacha20poly1305_encrypt = function() {
              return (a._crypto_aead_chacha20poly1305_encrypt = a.asm.i).apply(null, arguments);
            }, a._crypto_aead_chacha20poly1305_ietf_encrypt_detached = function() {
              return (a._crypto_aead_chacha20poly1305_ietf_encrypt_detached = a.asm.j).apply(null, arguments);
            }, a._crypto_aead_chacha20poly1305_ietf_encrypt = function() {
              return (a._crypto_aead_chacha20poly1305_ietf_encrypt = a.asm.k).apply(null, arguments);
            }, a._crypto_aead_chacha20poly1305_decrypt_detached = function() {
              return (a._crypto_aead_chacha20poly1305_decrypt_detached = a.asm.l).apply(null, arguments);
            }, a._crypto_aead_chacha20poly1305_decrypt = function() {
              return (a._crypto_aead_chacha20poly1305_decrypt = a.asm.m).apply(null, arguments);
            }, a._crypto_aead_chacha20poly1305_ietf_decrypt_detached = function() {
              return (a._crypto_aead_chacha20poly1305_ietf_decrypt_detached = a.asm.n).apply(null, arguments);
            }, a._crypto_aead_chacha20poly1305_ietf_decrypt = function() {
              return (a._crypto_aead_chacha20poly1305_ietf_decrypt = a.asm.o).apply(null, arguments);
            }, a._crypto_aead_chacha20poly1305_ietf_keybytes = function() {
              return (a._crypto_aead_chacha20poly1305_ietf_keybytes = a.asm.p).apply(null, arguments);
            }, a._crypto_aead_chacha20poly1305_ietf_npubbytes = function() {
              return (a._crypto_aead_chacha20poly1305_ietf_npubbytes = a.asm.q).apply(null, arguments);
            }, a._crypto_aead_chacha20poly1305_ietf_nsecbytes = function() {
              return (a._crypto_aead_chacha20poly1305_ietf_nsecbytes = a.asm.r).apply(null, arguments);
            }, a._crypto_aead_chacha20poly1305_ietf_abytes = function() {
              return (a._crypto_aead_chacha20poly1305_ietf_abytes = a.asm.s).apply(null, arguments);
            }, a._crypto_aead_chacha20poly1305_ietf_messagebytes_max = function() {
              return (a._crypto_aead_chacha20poly1305_ietf_messagebytes_max = a.asm.t).apply(null, arguments);
            }, a._crypto_aead_chacha20poly1305_ietf_keygen = function() {
              return (a._crypto_aead_chacha20poly1305_ietf_keygen = a.asm.u).apply(null, arguments);
            }, a._crypto_aead_chacha20poly1305_keybytes = function() {
              return (a._crypto_aead_chacha20poly1305_keybytes = a.asm.v).apply(null, arguments);
            }, a._crypto_aead_chacha20poly1305_npubbytes = function() {
              return (a._crypto_aead_chacha20poly1305_npubbytes = a.asm.w).apply(null, arguments);
            }, a._crypto_aead_chacha20poly1305_nsecbytes = function() {
              return (a._crypto_aead_chacha20poly1305_nsecbytes = a.asm.x).apply(null, arguments);
            }, a._crypto_aead_chacha20poly1305_abytes = function() {
              return (a._crypto_aead_chacha20poly1305_abytes = a.asm.y).apply(null, arguments);
            }, a._crypto_aead_chacha20poly1305_messagebytes_max = function() {
              return (a._crypto_aead_chacha20poly1305_messagebytes_max = a.asm.z).apply(null, arguments);
            }, a._crypto_aead_chacha20poly1305_keygen = function() {
              return (a._crypto_aead_chacha20poly1305_keygen = a.asm.A).apply(null, arguments);
            }, a._crypto_aead_xchacha20poly1305_ietf_encrypt_detached = function() {
              return (a._crypto_aead_xchacha20poly1305_ietf_encrypt_detached = a.asm.B).apply(null, arguments);
            }, a._crypto_aead_xchacha20poly1305_ietf_encrypt = function() {
              return (a._crypto_aead_xchacha20poly1305_ietf_encrypt = a.asm.C).apply(null, arguments);
            }, a._crypto_aead_xchacha20poly1305_ietf_decrypt_detached = function() {
              return (a._crypto_aead_xchacha20poly1305_ietf_decrypt_detached = a.asm.D).apply(null, arguments);
            }, a._crypto_aead_xchacha20poly1305_ietf_decrypt = function() {
              return (a._crypto_aead_xchacha20poly1305_ietf_decrypt = a.asm.E).apply(null, arguments);
            }, a._crypto_aead_xchacha20poly1305_ietf_keybytes = function() {
              return (a._crypto_aead_xchacha20poly1305_ietf_keybytes = a.asm.F).apply(null, arguments);
            }, a._crypto_aead_xchacha20poly1305_ietf_npubbytes = function() {
              return (a._crypto_aead_xchacha20poly1305_ietf_npubbytes = a.asm.G).apply(null, arguments);
            }, a._crypto_aead_xchacha20poly1305_ietf_nsecbytes = function() {
              return (a._crypto_aead_xchacha20poly1305_ietf_nsecbytes = a.asm.H).apply(null, arguments);
            }, a._crypto_aead_xchacha20poly1305_ietf_abytes = function() {
              return (a._crypto_aead_xchacha20poly1305_ietf_abytes = a.asm.I).apply(null, arguments);
            }, a._crypto_aead_xchacha20poly1305_ietf_messagebytes_max = function() {
              return (a._crypto_aead_xchacha20poly1305_ietf_messagebytes_max = a.asm.J).apply(null, arguments);
            }, a._crypto_aead_xchacha20poly1305_ietf_keygen = function() {
              return (a._crypto_aead_xchacha20poly1305_ietf_keygen = a.asm.K).apply(null, arguments);
            }, a._crypto_auth_bytes = function() {
              return (a._crypto_auth_bytes = a.asm.L).apply(null, arguments);
            }, a._crypto_auth_keybytes = function() {
              return (a._crypto_auth_keybytes = a.asm.M).apply(null, arguments);
            }, a._crypto_auth = function() {
              return (a._crypto_auth = a.asm.N).apply(null, arguments);
            }, a._crypto_auth_verify = function() {
              return (a._crypto_auth_verify = a.asm.O).apply(null, arguments);
            }, a._crypto_auth_keygen = function() {
              return (a._crypto_auth_keygen = a.asm.P).apply(null, arguments);
            }, a._crypto_box_seedbytes = function() {
              return (a._crypto_box_seedbytes = a.asm.Q).apply(null, arguments);
            }, a._crypto_box_publickeybytes = function() {
              return (a._crypto_box_publickeybytes = a.asm.R).apply(null, arguments);
            }, a._crypto_box_secretkeybytes = function() {
              return (a._crypto_box_secretkeybytes = a.asm.S).apply(null, arguments);
            }, a._crypto_box_beforenmbytes = function() {
              return (a._crypto_box_beforenmbytes = a.asm.T).apply(null, arguments);
            }, a._crypto_box_noncebytes = function() {
              return (a._crypto_box_noncebytes = a.asm.U).apply(null, arguments);
            }, a._crypto_box_macbytes = function() {
              return (a._crypto_box_macbytes = a.asm.V).apply(null, arguments);
            }, a._crypto_box_messagebytes_max = function() {
              return (a._crypto_box_messagebytes_max = a.asm.W).apply(null, arguments);
            }, a._crypto_box_seed_keypair = function() {
              return (a._crypto_box_seed_keypair = a.asm.X).apply(null, arguments);
            }, a._crypto_box_keypair = function() {
              return (a._crypto_box_keypair = a.asm.Y).apply(null, arguments);
            }, a._crypto_box_beforenm = function() {
              return (a._crypto_box_beforenm = a.asm.Z).apply(null, arguments);
            }, a._crypto_box_detached_afternm = function() {
              return (a._crypto_box_detached_afternm = a.asm._).apply(null, arguments);
            }, a._crypto_box_detached = function() {
              return (a._crypto_box_detached = a.asm.$).apply(null, arguments);
            }, a._crypto_box_easy_afternm = function() {
              return (a._crypto_box_easy_afternm = a.asm.aa).apply(null, arguments);
            }, a._crypto_box_easy = function() {
              return (a._crypto_box_easy = a.asm.ba).apply(null, arguments);
            }, a._crypto_box_open_detached_afternm = function() {
              return (a._crypto_box_open_detached_afternm = a.asm.ca).apply(null, arguments);
            }, a._crypto_box_open_detached = function() {
              return (a._crypto_box_open_detached = a.asm.da).apply(null, arguments);
            }, a._crypto_box_open_easy_afternm = function() {
              return (a._crypto_box_open_easy_afternm = a.asm.ea).apply(null, arguments);
            }, a._crypto_box_open_easy = function() {
              return (a._crypto_box_open_easy = a.asm.fa).apply(null, arguments);
            }, a._crypto_box_seal = function() {
              return (a._crypto_box_seal = a.asm.ga).apply(null, arguments);
            }, a._crypto_box_seal_open = function() {
              return (a._crypto_box_seal_open = a.asm.ha).apply(null, arguments);
            }, a._crypto_box_sealbytes = function() {
              return (a._crypto_box_sealbytes = a.asm.ia).apply(null, arguments);
            }, a._crypto_generichash_bytes_min = function() {
              return (a._crypto_generichash_bytes_min = a.asm.ja).apply(null, arguments);
            }, a._crypto_generichash_bytes_max = function() {
              return (a._crypto_generichash_bytes_max = a.asm.ka).apply(null, arguments);
            }, a._crypto_generichash_bytes = function() {
              return (a._crypto_generichash_bytes = a.asm.la).apply(null, arguments);
            }, a._crypto_generichash_keybytes_min = function() {
              return (a._crypto_generichash_keybytes_min = a.asm.ma).apply(null, arguments);
            }, a._crypto_generichash_keybytes_max = function() {
              return (a._crypto_generichash_keybytes_max = a.asm.na).apply(null, arguments);
            }, a._crypto_generichash_keybytes = function() {
              return (a._crypto_generichash_keybytes = a.asm.oa).apply(null, arguments);
            }, a._crypto_generichash_statebytes = function() {
              return (a._crypto_generichash_statebytes = a.asm.pa).apply(null, arguments);
            }, a._crypto_generichash = function() {
              return (a._crypto_generichash = a.asm.qa).apply(null, arguments);
            }, a._crypto_generichash_init = function() {
              return (a._crypto_generichash_init = a.asm.ra).apply(null, arguments);
            }, a._crypto_generichash_update = function() {
              return (a._crypto_generichash_update = a.asm.sa).apply(null, arguments);
            }, a._crypto_generichash_final = function() {
              return (a._crypto_generichash_final = a.asm.ta).apply(null, arguments);
            }, a._crypto_generichash_keygen = function() {
              return (a._crypto_generichash_keygen = a.asm.ua).apply(null, arguments);
            }, a._crypto_hash_bytes = function() {
              return (a._crypto_hash_bytes = a.asm.va).apply(null, arguments);
            }, a._crypto_hash = function() {
              return (a._crypto_hash = a.asm.wa).apply(null, arguments);
            }, a._crypto_kdf_bytes_min = function() {
              return (a._crypto_kdf_bytes_min = a.asm.xa).apply(null, arguments);
            }, a._crypto_kdf_bytes_max = function() {
              return (a._crypto_kdf_bytes_max = a.asm.ya).apply(null, arguments);
            }, a._crypto_kdf_contextbytes = function() {
              return (a._crypto_kdf_contextbytes = a.asm.za).apply(null, arguments);
            }, a._crypto_kdf_keybytes = function() {
              return (a._crypto_kdf_keybytes = a.asm.Aa).apply(null, arguments);
            }, a._crypto_kdf_derive_from_key = function() {
              return (a._crypto_kdf_derive_from_key = a.asm.Ba).apply(null, arguments);
            }, a._crypto_kdf_keygen = function() {
              return (a._crypto_kdf_keygen = a.asm.Ca).apply(null, arguments);
            }, a._crypto_kx_seed_keypair = function() {
              return (a._crypto_kx_seed_keypair = a.asm.Da).apply(null, arguments);
            }, a._crypto_kx_keypair = function() {
              return (a._crypto_kx_keypair = a.asm.Ea).apply(null, arguments);
            }, a._crypto_kx_client_session_keys = function() {
              return (a._crypto_kx_client_session_keys = a.asm.Fa).apply(null, arguments);
            }, a._crypto_kx_server_session_keys = function() {
              return (a._crypto_kx_server_session_keys = a.asm.Ga).apply(null, arguments);
            }, a._crypto_kx_publickeybytes = function() {
              return (a._crypto_kx_publickeybytes = a.asm.Ha).apply(null, arguments);
            }, a._crypto_kx_secretkeybytes = function() {
              return (a._crypto_kx_secretkeybytes = a.asm.Ia).apply(null, arguments);
            }, a._crypto_kx_seedbytes = function() {
              return (a._crypto_kx_seedbytes = a.asm.Ja).apply(null, arguments);
            }, a._crypto_kx_sessionkeybytes = function() {
              return (a._crypto_kx_sessionkeybytes = a.asm.Ka).apply(null, arguments);
            }, a._crypto_pwhash_alg_argon2i13 = function() {
              return (a._crypto_pwhash_alg_argon2i13 = a.asm.La).apply(null, arguments);
            }, a._crypto_pwhash_alg_argon2id13 = function() {
              return (a._crypto_pwhash_alg_argon2id13 = a.asm.Ma).apply(null, arguments);
            }, a._crypto_pwhash_alg_default = function() {
              return (a._crypto_pwhash_alg_default = a.asm.Na).apply(null, arguments);
            }, a._crypto_pwhash_bytes_min = function() {
              return (a._crypto_pwhash_bytes_min = a.asm.Oa).apply(null, arguments);
            }, a._crypto_pwhash_bytes_max = function() {
              return (a._crypto_pwhash_bytes_max = a.asm.Pa).apply(null, arguments);
            }, a._crypto_pwhash_passwd_min = function() {
              return (a._crypto_pwhash_passwd_min = a.asm.Qa).apply(null, arguments);
            }, a._crypto_pwhash_passwd_max = function() {
              return (a._crypto_pwhash_passwd_max = a.asm.Ra).apply(null, arguments);
            }, a._crypto_pwhash_saltbytes = function() {
              return (a._crypto_pwhash_saltbytes = a.asm.Sa).apply(null, arguments);
            }, a._crypto_pwhash_strbytes = function() {
              return (a._crypto_pwhash_strbytes = a.asm.Ta).apply(null, arguments);
            }, a._crypto_pwhash_strprefix = function() {
              return (a._crypto_pwhash_strprefix = a.asm.Ua).apply(null, arguments);
            }, a._crypto_pwhash_opslimit_min = function() {
              return (a._crypto_pwhash_opslimit_min = a.asm.Va).apply(null, arguments);
            }, a._crypto_pwhash_opslimit_max = function() {
              return (a._crypto_pwhash_opslimit_max = a.asm.Wa).apply(null, arguments);
            }, a._crypto_pwhash_memlimit_min = function() {
              return (a._crypto_pwhash_memlimit_min = a.asm.Xa).apply(null, arguments);
            }, a._crypto_pwhash_memlimit_max = function() {
              return (a._crypto_pwhash_memlimit_max = a.asm.Ya).apply(null, arguments);
            }, a._crypto_pwhash_opslimit_interactive = function() {
              return (a._crypto_pwhash_opslimit_interactive = a.asm.Za).apply(null, arguments);
            }, a._crypto_pwhash_memlimit_interactive = function() {
              return (a._crypto_pwhash_memlimit_interactive = a.asm._a).apply(null, arguments);
            }, a._crypto_pwhash_opslimit_moderate = function() {
              return (a._crypto_pwhash_opslimit_moderate = a.asm.$a).apply(null, arguments);
            }, a._crypto_pwhash_memlimit_moderate = function() {
              return (a._crypto_pwhash_memlimit_moderate = a.asm.ab).apply(null, arguments);
            }, a._crypto_pwhash_opslimit_sensitive = function() {
              return (a._crypto_pwhash_opslimit_sensitive = a.asm.bb).apply(null, arguments);
            }, a._crypto_pwhash_memlimit_sensitive = function() {
              return (a._crypto_pwhash_memlimit_sensitive = a.asm.cb).apply(null, arguments);
            }, a._crypto_pwhash = function() {
              return (a._crypto_pwhash = a.asm.db).apply(null, arguments);
            }, a._crypto_pwhash_str = function() {
              return (a._crypto_pwhash_str = a.asm.eb).apply(null, arguments);
            }, a._crypto_pwhash_str_alg = function() {
              return (a._crypto_pwhash_str_alg = a.asm.fb).apply(null, arguments);
            }, a._crypto_pwhash_str_verify = function() {
              return (a._crypto_pwhash_str_verify = a.asm.gb).apply(null, arguments);
            }, a._crypto_pwhash_str_needs_rehash = function() {
              return (a._crypto_pwhash_str_needs_rehash = a.asm.hb).apply(null, arguments);
            }, a._crypto_scalarmult_base = function() {
              return (a._crypto_scalarmult_base = a.asm.ib).apply(null, arguments);
            }, a._crypto_scalarmult = function() {
              return (a._crypto_scalarmult = a.asm.jb).apply(null, arguments);
            }, a._crypto_scalarmult_bytes = function() {
              return (a._crypto_scalarmult_bytes = a.asm.kb).apply(null, arguments);
            }, a._crypto_scalarmult_scalarbytes = function() {
              return (a._crypto_scalarmult_scalarbytes = a.asm.lb).apply(null, arguments);
            }, a._crypto_secretbox_keybytes = function() {
              return (a._crypto_secretbox_keybytes = a.asm.mb).apply(null, arguments);
            }, a._crypto_secretbox_noncebytes = function() {
              return (a._crypto_secretbox_noncebytes = a.asm.nb).apply(null, arguments);
            }, a._crypto_secretbox_macbytes = function() {
              return (a._crypto_secretbox_macbytes = a.asm.ob).apply(null, arguments);
            }, a._crypto_secretbox_messagebytes_max = function() {
              return (a._crypto_secretbox_messagebytes_max = a.asm.pb).apply(null, arguments);
            }, a._crypto_secretbox_keygen = function() {
              return (a._crypto_secretbox_keygen = a.asm.qb).apply(null, arguments);
            }, a._crypto_secretbox_detached = function() {
              return (a._crypto_secretbox_detached = a.asm.rb).apply(null, arguments);
            }, a._crypto_secretbox_easy = function() {
              return (a._crypto_secretbox_easy = a.asm.sb).apply(null, arguments);
            }, a._crypto_secretbox_open_detached = function() {
              return (a._crypto_secretbox_open_detached = a.asm.tb).apply(null, arguments);
            }, a._crypto_secretbox_open_easy = function() {
              return (a._crypto_secretbox_open_easy = a.asm.ub).apply(null, arguments);
            }, a._crypto_secretstream_xchacha20poly1305_keygen = function() {
              return (a._crypto_secretstream_xchacha20poly1305_keygen = a.asm.vb).apply(null, arguments);
            }, a._crypto_secretstream_xchacha20poly1305_init_push = function() {
              return (a._crypto_secretstream_xchacha20poly1305_init_push = a.asm.wb).apply(null, arguments);
            }, a._crypto_secretstream_xchacha20poly1305_init_pull = function() {
              return (a._crypto_secretstream_xchacha20poly1305_init_pull = a.asm.xb).apply(null, arguments);
            }, a._crypto_secretstream_xchacha20poly1305_rekey = function() {
              return (a._crypto_secretstream_xchacha20poly1305_rekey = a.asm.yb).apply(null, arguments);
            }, a._crypto_secretstream_xchacha20poly1305_push = function() {
              return (a._crypto_secretstream_xchacha20poly1305_push = a.asm.zb).apply(null, arguments);
            }, a._crypto_secretstream_xchacha20poly1305_pull = function() {
              return (a._crypto_secretstream_xchacha20poly1305_pull = a.asm.Ab).apply(null, arguments);
            }, a._crypto_secretstream_xchacha20poly1305_statebytes = function() {
              return (a._crypto_secretstream_xchacha20poly1305_statebytes = a.asm.Bb).apply(null, arguments);
            }, a._crypto_secretstream_xchacha20poly1305_abytes = function() {
              return (a._crypto_secretstream_xchacha20poly1305_abytes = a.asm.Cb).apply(null, arguments);
            }, a._crypto_secretstream_xchacha20poly1305_headerbytes = function() {
              return (a._crypto_secretstream_xchacha20poly1305_headerbytes = a.asm.Db).apply(null, arguments);
            }, a._crypto_secretstream_xchacha20poly1305_keybytes = function() {
              return (a._crypto_secretstream_xchacha20poly1305_keybytes = a.asm.Eb).apply(null, arguments);
            }, a._crypto_secretstream_xchacha20poly1305_messagebytes_max = function() {
              return (a._crypto_secretstream_xchacha20poly1305_messagebytes_max = a.asm.Fb).apply(null, arguments);
            }, a._crypto_secretstream_xchacha20poly1305_tag_message = function() {
              return (a._crypto_secretstream_xchacha20poly1305_tag_message = a.asm.Gb).apply(null, arguments);
            }, a._crypto_secretstream_xchacha20poly1305_tag_push = function() {
              return (a._crypto_secretstream_xchacha20poly1305_tag_push = a.asm.Hb).apply(null, arguments);
            }, a._crypto_secretstream_xchacha20poly1305_tag_rekey = function() {
              return (a._crypto_secretstream_xchacha20poly1305_tag_rekey = a.asm.Ib).apply(null, arguments);
            }, a._crypto_secretstream_xchacha20poly1305_tag_final = function() {
              return (a._crypto_secretstream_xchacha20poly1305_tag_final = a.asm.Jb).apply(null, arguments);
            }, a._crypto_shorthash_bytes = function() {
              return (a._crypto_shorthash_bytes = a.asm.Kb).apply(null, arguments);
            }, a._crypto_shorthash_keybytes = function() {
              return (a._crypto_shorthash_keybytes = a.asm.Lb).apply(null, arguments);
            }, a._crypto_shorthash = function() {
              return (a._crypto_shorthash = a.asm.Mb).apply(null, arguments);
            }, a._crypto_shorthash_keygen = function() {
              return (a._crypto_shorthash_keygen = a.asm.Nb).apply(null, arguments);
            }, a._crypto_sign_statebytes = function() {
              return (a._crypto_sign_statebytes = a.asm.Ob).apply(null, arguments);
            }, a._crypto_sign_bytes = function() {
              return (a._crypto_sign_bytes = a.asm.Pb).apply(null, arguments);
            }, a._crypto_sign_seedbytes = function() {
              return (a._crypto_sign_seedbytes = a.asm.Qb).apply(null, arguments);
            }, a._crypto_sign_publickeybytes = function() {
              return (a._crypto_sign_publickeybytes = a.asm.Rb).apply(null, arguments);
            }, a._crypto_sign_secretkeybytes = function() {
              return (a._crypto_sign_secretkeybytes = a.asm.Sb).apply(null, arguments);
            }, a._crypto_sign_messagebytes_max = function() {
              return (a._crypto_sign_messagebytes_max = a.asm.Tb).apply(null, arguments);
            }, a._crypto_sign_seed_keypair = function() {
              return (a._crypto_sign_seed_keypair = a.asm.Ub).apply(null, arguments);
            }, a._crypto_sign_keypair = function() {
              return (a._crypto_sign_keypair = a.asm.Vb).apply(null, arguments);
            }, a._crypto_sign = function() {
              return (a._crypto_sign = a.asm.Wb).apply(null, arguments);
            }, a._crypto_sign_open = function() {
              return (a._crypto_sign_open = a.asm.Xb).apply(null, arguments);
            }, a._crypto_sign_detached = function() {
              return (a._crypto_sign_detached = a.asm.Yb).apply(null, arguments);
            }, a._crypto_sign_verify_detached = function() {
              return (a._crypto_sign_verify_detached = a.asm.Zb).apply(null, arguments);
            }, a._crypto_sign_init = function() {
              return (a._crypto_sign_init = a.asm._b).apply(null, arguments);
            }, a._crypto_sign_update = function() {
              return (a._crypto_sign_update = a.asm.$b).apply(null, arguments);
            }, a._crypto_sign_final_create = function() {
              return (a._crypto_sign_final_create = a.asm.ac).apply(null, arguments);
            }, a._crypto_sign_final_verify = function() {
              return (a._crypto_sign_final_verify = a.asm.bc).apply(null, arguments);
            }, a._crypto_sign_ed25519_pk_to_curve25519 = function() {
              return (a._crypto_sign_ed25519_pk_to_curve25519 = a.asm.cc).apply(null, arguments);
            }, a._crypto_sign_ed25519_sk_to_curve25519 = function() {
              return (a._crypto_sign_ed25519_sk_to_curve25519 = a.asm.dc).apply(null, arguments);
            }, a._randombytes_random = function() {
              return (a._randombytes_random = a.asm.ec).apply(null, arguments);
            }, a._randombytes_stir = function() {
              return (a._randombytes_stir = a.asm.fc).apply(null, arguments);
            }, a._randombytes_uniform = function() {
              return (a._randombytes_uniform = a.asm.gc).apply(null, arguments);
            }, a._randombytes_buf = function() {
              return (a._randombytes_buf = a.asm.hc).apply(null, arguments);
            }, a._randombytes_buf_deterministic = function() {
              return (a._randombytes_buf_deterministic = a.asm.ic).apply(null, arguments);
            }, a._randombytes_seedbytes = function() {
              return (a._randombytes_seedbytes = a.asm.jc).apply(null, arguments);
            }, a._randombytes_close = function() {
              return (a._randombytes_close = a.asm.kc).apply(null, arguments);
            }, a._randombytes = function() {
              return (a._randombytes = a.asm.lc).apply(null, arguments);
            }, a._sodium_bin2hex = function() {
              return (a._sodium_bin2hex = a.asm.mc).apply(null, arguments);
            }, a._sodium_hex2bin = function() {
              return (a._sodium_hex2bin = a.asm.nc).apply(null, arguments);
            }, a._sodium_base64_encoded_len = function() {
              return (a._sodium_base64_encoded_len = a.asm.oc).apply(null, arguments);
            }, a._sodium_bin2base64 = function() {
              return (a._sodium_bin2base64 = a.asm.pc).apply(null, arguments);
            }, a._sodium_base642bin = function() {
              return (a._sodium_base642bin = a.asm.qc).apply(null, arguments);
            }, a._sodium_init = function() {
              return (a._sodium_init = a.asm.rc).apply(null, arguments);
            }, a._sodium_pad = function() {
              return (a._sodium_pad = a.asm.sc).apply(null, arguments);
            }, a._sodium_unpad = function() {
              return (a._sodium_unpad = a.asm.tc).apply(null, arguments);
            }, a._sodium_version_string = function() {
              return (a._sodium_version_string = a.asm.uc).apply(null, arguments);
            }, a._sodium_library_version_major = function() {
              return (a._sodium_library_version_major = a.asm.vc).apply(null, arguments);
            }, a._sodium_library_version_minor = function() {
              return (a._sodium_library_version_minor = a.asm.wc).apply(null, arguments);
            }, a._sodium_library_minimal = function() {
              return (a._sodium_library_minimal = a.asm.xc).apply(null, arguments);
            }, a._malloc = function() {
              return (a._malloc = a.asm.yc).apply(null, arguments);
            }, a._free = function() {
              return (a._free = a.asm.zc).apply(null, arguments);
            }, a.setValue = function(A4, I4, g3 = "i8", B2) {
              switch (g3.charAt(g3.length - 1) === "*" && (g3 = "i32"), g3) {
                case "i1":
                case "i8":
                  h[A4 >> 0] = I4;
                  break;
                case "i16":
                  u[A4 >> 1] = I4;
                  break;
                case "i32":
                  F[A4 >> 2] = I4;
                  break;
                case "i64":
                  x = [I4 >>> 0, (J = I4, +Math.abs(J) >= 1 ? J > 0 ? (0 | Math.min(+Math.floor(J / 4294967296), 4294967295)) >>> 0 : ~~+Math.ceil((J - +(~~J >>> 0)) / 4294967296) >>> 0 : 0)], F[A4 >> 2] = x[0], F[A4 + 4 >> 2] = x[1];
                  break;
                case "float":
                  l[A4 >> 2] = I4;
                  break;
                case "double":
                  _[A4 >> 3] = I4;
                  break;
                default:
                  N("invalid type for setValue: " + g3);
              }
            }, a.getValue = function(A4, I4 = "i8", g3) {
              switch (I4.charAt(I4.length - 1) === "*" && (I4 = "i32"), I4) {
                case "i1":
                case "i8":
                  return h[A4 >> 0];
                case "i16":
                  return u[A4 >> 1];
                case "i32":
                case "i64":
                  return F[A4 >> 2];
                case "float":
                  return l[A4 >> 2];
                case "double":
                  return Number(_[A4 >> 3]);
                default:
                  N("invalid type for getValue: " + I4);
              }
              return null;
            }, a.UTF8ToString = G, Y = function A4() {
              $ || IA(), $ || (Y = A4);
            }, a.run = IA, a.preInit)
              for (typeof a.preInit == "function" && (a.preInit = [a.preInit]); a.preInit.length > 0; )
                a.preInit.pop()();
            IA();
          }).catch(function() {
            return B.useBackupModule();
          }), I2;
        }
        typeof define == "function" && define.amd ? define(["exports"], I) : typeof exports2 == "object" && typeof exports2.nodeName != "string" ? I(exports2) : A.libsodium = I(A.libsodium_mod || (A.commonJsStrict = {}));
      }(exports2);
    }
  });

  // node_modules/libsodium-wrappers/dist/modules/libsodium-wrappers.js
  var require_libsodium_wrappers = __commonJS({
    "node_modules/libsodium-wrappers/dist/modules/libsodium-wrappers.js"(exports2) {
      !function(e) {
        function r(e2, r2) {
          "use strict";
          var t2, a = r2.ready.then(function() {
            function a2() {
              if (t2._sodium_init() !== 0)
                throw new Error("libsodium was not correctly initialized.");
              for (var r3 = ["crypto_aead_chacha20poly1305_decrypt", "crypto_aead_chacha20poly1305_decrypt_detached", "crypto_aead_chacha20poly1305_encrypt", "crypto_aead_chacha20poly1305_encrypt_detached", "crypto_aead_chacha20poly1305_ietf_decrypt", "crypto_aead_chacha20poly1305_ietf_decrypt_detached", "crypto_aead_chacha20poly1305_ietf_encrypt", "crypto_aead_chacha20poly1305_ietf_encrypt_detached", "crypto_aead_chacha20poly1305_ietf_keygen", "crypto_aead_chacha20poly1305_keygen", "crypto_aead_xchacha20poly1305_ietf_decrypt", "crypto_aead_xchacha20poly1305_ietf_decrypt_detached", "crypto_aead_xchacha20poly1305_ietf_encrypt", "crypto_aead_xchacha20poly1305_ietf_encrypt_detached", "crypto_aead_xchacha20poly1305_ietf_keygen", "crypto_auth", "crypto_auth_hmacsha256", "crypto_auth_hmacsha256_final", "crypto_auth_hmacsha256_init", "crypto_auth_hmacsha256_keygen", "crypto_auth_hmacsha256_update", "crypto_auth_hmacsha256_verify", "crypto_auth_hmacsha512", "crypto_auth_hmacsha512_final", "crypto_auth_hmacsha512_init", "crypto_auth_hmacsha512_keygen", "crypto_auth_hmacsha512_update", "crypto_auth_hmacsha512_verify", "crypto_auth_keygen", "crypto_auth_verify", "crypto_box_beforenm", "crypto_box_curve25519xchacha20poly1305_keypair", "crypto_box_curve25519xchacha20poly1305_seal", "crypto_box_curve25519xchacha20poly1305_seal_open", "crypto_box_detached", "crypto_box_easy", "crypto_box_easy_afternm", "crypto_box_keypair", "crypto_box_open_detached", "crypto_box_open_easy", "crypto_box_open_easy_afternm", "crypto_box_seal", "crypto_box_seal_open", "crypto_box_seed_keypair", "crypto_core_ed25519_add", "crypto_core_ed25519_from_hash", "crypto_core_ed25519_from_uniform", "crypto_core_ed25519_is_valid_point", "crypto_core_ed25519_random", "crypto_core_ed25519_scalar_add", "crypto_core_ed25519_scalar_complement", "crypto_core_ed25519_scalar_invert", "crypto_core_ed25519_scalar_mul", "crypto_core_ed25519_scalar_negate", "crypto_core_ed25519_scalar_random", "crypto_core_ed25519_scalar_reduce", "crypto_core_ed25519_scalar_sub", "crypto_core_ed25519_sub", "crypto_core_hchacha20", "crypto_core_hsalsa20", "crypto_core_ristretto255_add", "crypto_core_ristretto255_from_hash", "crypto_core_ristretto255_is_valid_point", "crypto_core_ristretto255_random", "crypto_core_ristretto255_scalar_add", "crypto_core_ristretto255_scalar_complement", "crypto_core_ristretto255_scalar_invert", "crypto_core_ristretto255_scalar_mul", "crypto_core_ristretto255_scalar_negate", "crypto_core_ristretto255_scalar_random", "crypto_core_ristretto255_scalar_reduce", "crypto_core_ristretto255_scalar_sub", "crypto_core_ristretto255_sub", "crypto_generichash", "crypto_generichash_blake2b_salt_personal", "crypto_generichash_final", "crypto_generichash_init", "crypto_generichash_keygen", "crypto_generichash_update", "crypto_hash", "crypto_hash_sha256", "crypto_hash_sha256_final", "crypto_hash_sha256_init", "crypto_hash_sha256_update", "crypto_hash_sha512", "crypto_hash_sha512_final", "crypto_hash_sha512_init", "crypto_hash_sha512_update", "crypto_kdf_derive_from_key", "crypto_kdf_keygen", "crypto_kx_client_session_keys", "crypto_kx_keypair", "crypto_kx_seed_keypair", "crypto_kx_server_session_keys", "crypto_onetimeauth", "crypto_onetimeauth_final", "crypto_onetimeauth_init", "crypto_onetimeauth_keygen", "crypto_onetimeauth_update", "crypto_onetimeauth_verify", "crypto_pwhash", "crypto_pwhash_scryptsalsa208sha256", "crypto_pwhash_scryptsalsa208sha256_ll", "crypto_pwhash_scryptsalsa208sha256_str", "crypto_pwhash_scryptsalsa208sha256_str_verify", "crypto_pwhash_str", "crypto_pwhash_str_needs_rehash", "crypto_pwhash_str_verify", "crypto_scalarmult", "crypto_scalarmult_base", "crypto_scalarmult_ed25519", "crypto_scalarmult_ed25519_base", "crypto_scalarmult_ed25519_base_noclamp", "crypto_scalarmult_ed25519_noclamp", "crypto_scalarmult_ristretto255", "crypto_scalarmult_ristretto255_base", "crypto_secretbox_detached", "crypto_secretbox_easy", "crypto_secretbox_keygen", "crypto_secretbox_open_detached", "crypto_secretbox_open_easy", "crypto_secretstream_xchacha20poly1305_init_pull", "crypto_secretstream_xchacha20poly1305_init_push", "crypto_secretstream_xchacha20poly1305_keygen", "crypto_secretstream_xchacha20poly1305_pull", "crypto_secretstream_xchacha20poly1305_push", "crypto_secretstream_xchacha20poly1305_rekey", "crypto_shorthash", "crypto_shorthash_keygen", "crypto_shorthash_siphashx24", "crypto_sign", "crypto_sign_detached", "crypto_sign_ed25519_pk_to_curve25519", "crypto_sign_ed25519_sk_to_curve25519", "crypto_sign_ed25519_sk_to_pk", "crypto_sign_ed25519_sk_to_seed", "crypto_sign_final_create", "crypto_sign_final_verify", "crypto_sign_init", "crypto_sign_keypair", "crypto_sign_open", "crypto_sign_seed_keypair", "crypto_sign_update", "crypto_sign_verify_detached", "crypto_stream_chacha20", "crypto_stream_chacha20_ietf_xor", "crypto_stream_chacha20_ietf_xor_ic", "crypto_stream_chacha20_keygen", "crypto_stream_chacha20_xor", "crypto_stream_chacha20_xor_ic", "crypto_stream_keygen", "crypto_stream_xchacha20_keygen", "crypto_stream_xchacha20_xor", "crypto_stream_xchacha20_xor_ic", "randombytes_buf", "randombytes_buf_deterministic", "randombytes_close", "randombytes_random", "randombytes_set_implementation", "randombytes_stir", "randombytes_uniform", "sodium_version_string"], a3 = [E, x, k, S, T, w, Y, B, A, K, M, I, N, L, U, O, C, R, P, G, X, D, F, V, H, q, j, z, W, J, Q, Z, $, ee, re, te, ae, _e, se, ne, ce, oe, he, pe, ye, ie, le, ue, de, ve, ge, be, fe, me, Ee, xe, ke, Se, Te, we, Ye, Be, Ae, Ke, Me, Ie, Ne, Le, Ue, Oe, Ce, Re, Pe, Ge, Xe, De, Fe, Ve, He, qe, je, ze, We, Je, Qe, Ze, $e, er, rr, tr, ar, _r, sr, nr, cr, or, hr, pr, yr, ir, lr, ur, dr, vr, gr, br, fr, mr, Er, xr, kr, Sr, Tr, wr, Yr, Br, Ar, Kr, Mr, Ir, Nr, Lr, Ur, Or, Cr, Rr, Pr, Gr, Xr, Dr, Fr, Vr, Hr, qr, jr, zr, Wr, Jr, Qr, Zr, $r, et, rt, tt, at, _t, st, nt, ct, ot, ht, pt, yt, it, lt, ut, dt, vt, gt, bt, ft, mt], _3 = 0; _3 < a3.length; _3++)
                typeof t2["_" + r3[_3]] == "function" && (e2[r3[_3]] = a3[_3]);
              var s3 = ["SODIUM_LIBRARY_VERSION_MAJOR", "SODIUM_LIBRARY_VERSION_MINOR", "crypto_aead_chacha20poly1305_ABYTES", "crypto_aead_chacha20poly1305_IETF_ABYTES", "crypto_aead_chacha20poly1305_IETF_KEYBYTES", "crypto_aead_chacha20poly1305_IETF_MESSAGEBYTES_MAX", "crypto_aead_chacha20poly1305_IETF_NPUBBYTES", "crypto_aead_chacha20poly1305_IETF_NSECBYTES", "crypto_aead_chacha20poly1305_KEYBYTES", "crypto_aead_chacha20poly1305_MESSAGEBYTES_MAX", "crypto_aead_chacha20poly1305_NPUBBYTES", "crypto_aead_chacha20poly1305_NSECBYTES", "crypto_aead_chacha20poly1305_ietf_ABYTES", "crypto_aead_chacha20poly1305_ietf_KEYBYTES", "crypto_aead_chacha20poly1305_ietf_MESSAGEBYTES_MAX", "crypto_aead_chacha20poly1305_ietf_NPUBBYTES", "crypto_aead_chacha20poly1305_ietf_NSECBYTES", "crypto_aead_xchacha20poly1305_IETF_ABYTES", "crypto_aead_xchacha20poly1305_IETF_KEYBYTES", "crypto_aead_xchacha20poly1305_IETF_MESSAGEBYTES_MAX", "crypto_aead_xchacha20poly1305_IETF_NPUBBYTES", "crypto_aead_xchacha20poly1305_IETF_NSECBYTES", "crypto_aead_xchacha20poly1305_ietf_ABYTES", "crypto_aead_xchacha20poly1305_ietf_KEYBYTES", "crypto_aead_xchacha20poly1305_ietf_MESSAGEBYTES_MAX", "crypto_aead_xchacha20poly1305_ietf_NPUBBYTES", "crypto_aead_xchacha20poly1305_ietf_NSECBYTES", "crypto_auth_BYTES", "crypto_auth_KEYBYTES", "crypto_auth_hmacsha256_BYTES", "crypto_auth_hmacsha256_KEYBYTES", "crypto_auth_hmacsha512256_BYTES", "crypto_auth_hmacsha512256_KEYBYTES", "crypto_auth_hmacsha512_BYTES", "crypto_auth_hmacsha512_KEYBYTES", "crypto_box_BEFORENMBYTES", "crypto_box_MACBYTES", "crypto_box_MESSAGEBYTES_MAX", "crypto_box_NONCEBYTES", "crypto_box_PUBLICKEYBYTES", "crypto_box_SEALBYTES", "crypto_box_SECRETKEYBYTES", "crypto_box_SEEDBYTES", "crypto_box_curve25519xchacha20poly1305_BEFORENMBYTES", "crypto_box_curve25519xchacha20poly1305_MACBYTES", "crypto_box_curve25519xchacha20poly1305_MESSAGEBYTES_MAX", "crypto_box_curve25519xchacha20poly1305_NONCEBYTES", "crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES", "crypto_box_curve25519xchacha20poly1305_SEALBYTES", "crypto_box_curve25519xchacha20poly1305_SECRETKEYBYTES", "crypto_box_curve25519xchacha20poly1305_SEEDBYTES", "crypto_box_curve25519xsalsa20poly1305_BEFORENMBYTES", "crypto_box_curve25519xsalsa20poly1305_MACBYTES", "crypto_box_curve25519xsalsa20poly1305_MESSAGEBYTES_MAX", "crypto_box_curve25519xsalsa20poly1305_NONCEBYTES", "crypto_box_curve25519xsalsa20poly1305_PUBLICKEYBYTES", "crypto_box_curve25519xsalsa20poly1305_SECRETKEYBYTES", "crypto_box_curve25519xsalsa20poly1305_SEEDBYTES", "crypto_core_ed25519_BYTES", "crypto_core_ed25519_HASHBYTES", "crypto_core_ed25519_NONREDUCEDSCALARBYTES", "crypto_core_ed25519_SCALARBYTES", "crypto_core_ed25519_UNIFORMBYTES", "crypto_core_hchacha20_CONSTBYTES", "crypto_core_hchacha20_INPUTBYTES", "crypto_core_hchacha20_KEYBYTES", "crypto_core_hchacha20_OUTPUTBYTES", "crypto_core_hsalsa20_CONSTBYTES", "crypto_core_hsalsa20_INPUTBYTES", "crypto_core_hsalsa20_KEYBYTES", "crypto_core_hsalsa20_OUTPUTBYTES", "crypto_core_ristretto255_BYTES", "crypto_core_ristretto255_HASHBYTES", "crypto_core_ristretto255_NONREDUCEDSCALARBYTES", "crypto_core_ristretto255_SCALARBYTES", "crypto_core_salsa2012_CONSTBYTES", "crypto_core_salsa2012_INPUTBYTES", "crypto_core_salsa2012_KEYBYTES", "crypto_core_salsa2012_OUTPUTBYTES", "crypto_core_salsa20_CONSTBYTES", "crypto_core_salsa20_INPUTBYTES", "crypto_core_salsa20_KEYBYTES", "crypto_core_salsa20_OUTPUTBYTES", "crypto_generichash_BYTES", "crypto_generichash_BYTES_MAX", "crypto_generichash_BYTES_MIN", "crypto_generichash_KEYBYTES", "crypto_generichash_KEYBYTES_MAX", "crypto_generichash_KEYBYTES_MIN", "crypto_generichash_blake2b_BYTES", "crypto_generichash_blake2b_BYTES_MAX", "crypto_generichash_blake2b_BYTES_MIN", "crypto_generichash_blake2b_KEYBYTES", "crypto_generichash_blake2b_KEYBYTES_MAX", "crypto_generichash_blake2b_KEYBYTES_MIN", "crypto_generichash_blake2b_PERSONALBYTES", "crypto_generichash_blake2b_SALTBYTES", "crypto_hash_BYTES", "crypto_hash_sha256_BYTES", "crypto_hash_sha512_BYTES", "crypto_kdf_BYTES_MAX", "crypto_kdf_BYTES_MIN", "crypto_kdf_CONTEXTBYTES", "crypto_kdf_KEYBYTES", "crypto_kdf_blake2b_BYTES_MAX", "crypto_kdf_blake2b_BYTES_MIN", "crypto_kdf_blake2b_CONTEXTBYTES", "crypto_kdf_blake2b_KEYBYTES", "crypto_kx_PUBLICKEYBYTES", "crypto_kx_SECRETKEYBYTES", "crypto_kx_SEEDBYTES", "crypto_kx_SESSIONKEYBYTES", "crypto_onetimeauth_BYTES", "crypto_onetimeauth_KEYBYTES", "crypto_onetimeauth_poly1305_BYTES", "crypto_onetimeauth_poly1305_KEYBYTES", "crypto_pwhash_ALG_ARGON2I13", "crypto_pwhash_ALG_ARGON2ID13", "crypto_pwhash_ALG_DEFAULT", "crypto_pwhash_BYTES_MAX", "crypto_pwhash_BYTES_MIN", "crypto_pwhash_MEMLIMIT_INTERACTIVE", "crypto_pwhash_MEMLIMIT_MAX", "crypto_pwhash_MEMLIMIT_MIN", "crypto_pwhash_MEMLIMIT_MODERATE", "crypto_pwhash_MEMLIMIT_SENSITIVE", "crypto_pwhash_OPSLIMIT_INTERACTIVE", "crypto_pwhash_OPSLIMIT_MAX", "crypto_pwhash_OPSLIMIT_MIN", "crypto_pwhash_OPSLIMIT_MODERATE", "crypto_pwhash_OPSLIMIT_SENSITIVE", "crypto_pwhash_PASSWD_MAX", "crypto_pwhash_PASSWD_MIN", "crypto_pwhash_SALTBYTES", "crypto_pwhash_STRBYTES", "crypto_pwhash_argon2i_BYTES_MAX", "crypto_pwhash_argon2i_BYTES_MIN", "crypto_pwhash_argon2i_SALTBYTES", "crypto_pwhash_argon2i_STRBYTES", "crypto_pwhash_argon2id_BYTES_MAX", "crypto_pwhash_argon2id_BYTES_MIN", "crypto_pwhash_argon2id_SALTBYTES", "crypto_pwhash_argon2id_STRBYTES", "crypto_pwhash_scryptsalsa208sha256_BYTES_MAX", "crypto_pwhash_scryptsalsa208sha256_BYTES_MIN", "crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_INTERACTIVE", "crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX", "crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN", "crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_SENSITIVE", "crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_INTERACTIVE", "crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX", "crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN", "crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_SENSITIVE", "crypto_pwhash_scryptsalsa208sha256_SALTBYTES", "crypto_pwhash_scryptsalsa208sha256_STRBYTES", "crypto_scalarmult_BYTES", "crypto_scalarmult_SCALARBYTES", "crypto_scalarmult_curve25519_BYTES", "crypto_scalarmult_curve25519_SCALARBYTES", "crypto_scalarmult_ed25519_BYTES", "crypto_scalarmult_ed25519_SCALARBYTES", "crypto_scalarmult_ristretto255_BYTES", "crypto_scalarmult_ristretto255_SCALARBYTES", "crypto_secretbox_KEYBYTES", "crypto_secretbox_MACBYTES", "crypto_secretbox_MESSAGEBYTES_MAX", "crypto_secretbox_NONCEBYTES", "crypto_secretbox_xchacha20poly1305_KEYBYTES", "crypto_secretbox_xchacha20poly1305_MACBYTES", "crypto_secretbox_xchacha20poly1305_MESSAGEBYTES_MAX", "crypto_secretbox_xchacha20poly1305_NONCEBYTES", "crypto_secretbox_xsalsa20poly1305_KEYBYTES", "crypto_secretbox_xsalsa20poly1305_MACBYTES", "crypto_secretbox_xsalsa20poly1305_MESSAGEBYTES_MAX", "crypto_secretbox_xsalsa20poly1305_NONCEBYTES", "crypto_secretstream_xchacha20poly1305_ABYTES", "crypto_secretstream_xchacha20poly1305_HEADERBYTES", "crypto_secretstream_xchacha20poly1305_KEYBYTES", "crypto_secretstream_xchacha20poly1305_MESSAGEBYTES_MAX", "crypto_secretstream_xchacha20poly1305_TAG_FINAL", "crypto_secretstream_xchacha20poly1305_TAG_MESSAGE", "crypto_secretstream_xchacha20poly1305_TAG_PUSH", "crypto_secretstream_xchacha20poly1305_TAG_REKEY", "crypto_shorthash_BYTES", "crypto_shorthash_KEYBYTES", "crypto_shorthash_siphash24_BYTES", "crypto_shorthash_siphash24_KEYBYTES", "crypto_shorthash_siphashx24_BYTES", "crypto_shorthash_siphashx24_KEYBYTES", "crypto_sign_BYTES", "crypto_sign_MESSAGEBYTES_MAX", "crypto_sign_PUBLICKEYBYTES", "crypto_sign_SECRETKEYBYTES", "crypto_sign_SEEDBYTES", "crypto_sign_ed25519_BYTES", "crypto_sign_ed25519_MESSAGEBYTES_MAX", "crypto_sign_ed25519_PUBLICKEYBYTES", "crypto_sign_ed25519_SECRETKEYBYTES", "crypto_sign_ed25519_SEEDBYTES", "crypto_stream_KEYBYTES", "crypto_stream_MESSAGEBYTES_MAX", "crypto_stream_NONCEBYTES", "crypto_stream_chacha20_IETF_KEYBYTES", "crypto_stream_chacha20_IETF_MESSAGEBYTES_MAX", "crypto_stream_chacha20_IETF_NONCEBYTES", "crypto_stream_chacha20_KEYBYTES", "crypto_stream_chacha20_MESSAGEBYTES_MAX", "crypto_stream_chacha20_NONCEBYTES", "crypto_stream_chacha20_ietf_KEYBYTES", "crypto_stream_chacha20_ietf_MESSAGEBYTES_MAX", "crypto_stream_chacha20_ietf_NONCEBYTES", "crypto_stream_salsa2012_KEYBYTES", "crypto_stream_salsa2012_MESSAGEBYTES_MAX", "crypto_stream_salsa2012_NONCEBYTES", "crypto_stream_salsa208_KEYBYTES", "crypto_stream_salsa208_MESSAGEBYTES_MAX", "crypto_stream_salsa208_NONCEBYTES", "crypto_stream_salsa20_KEYBYTES", "crypto_stream_salsa20_MESSAGEBYTES_MAX", "crypto_stream_salsa20_NONCEBYTES", "crypto_stream_xchacha20_KEYBYTES", "crypto_stream_xchacha20_MESSAGEBYTES_MAX", "crypto_stream_xchacha20_NONCEBYTES", "crypto_stream_xsalsa20_KEYBYTES", "crypto_stream_xsalsa20_MESSAGEBYTES_MAX", "crypto_stream_xsalsa20_NONCEBYTES", "crypto_verify_16_BYTES", "crypto_verify_32_BYTES", "crypto_verify_64_BYTES"];
              for (_3 = 0; _3 < s3.length; _3++)
                typeof (c3 = t2["_" + s3[_3].toLowerCase()]) == "function" && (e2[s3[_3]] = c3());
              var n3 = ["SODIUM_VERSION_STRING", "crypto_pwhash_STRPREFIX", "crypto_pwhash_scryptsalsa208sha256_STRPREFIX"];
              for (_3 = 0; _3 < n3.length; _3++) {
                var c3;
                typeof (c3 = t2["_" + n3[_3].toLowerCase()]) == "function" && (e2[n3[_3]] = t2.UTF8ToString(c3()));
              }
            }
            t2 = r2;
            try {
              a2();
              var _2 = new Uint8Array([98, 97, 108, 108, 115]), s2 = e2.randombytes_buf(e2.crypto_secretbox_NONCEBYTES), n2 = e2.randombytes_buf(e2.crypto_secretbox_KEYBYTES), c2 = e2.crypto_secretbox_easy(_2, s2, n2), o2 = e2.crypto_secretbox_open_easy(c2, s2, n2);
              if (e2.memcmp(_2, o2))
                return;
            } catch (e3) {
              if (t2.useBackupModule == null)
                throw new Error("Both wasm and asm failed to load" + e3);
            }
            t2.useBackupModule(), a2();
          });
          function _(e3) {
            if (typeof TextEncoder == "function")
              return new TextEncoder().encode(e3);
            e3 = unescape(encodeURIComponent(e3));
            for (var r3 = new Uint8Array(e3.length), t3 = 0, a2 = e3.length; t3 < a2; t3++)
              r3[t3] = e3.charCodeAt(t3);
            return r3;
          }
          function s(e3) {
            if (typeof TextDecoder == "function")
              return new TextDecoder("utf-8", { fatal: true }).decode(e3);
            var r3 = 8192, t3 = Math.ceil(e3.length / r3);
            if (t3 <= 1)
              try {
                return decodeURIComponent(escape(String.fromCharCode.apply(null, e3)));
              } catch (e4) {
                throw new TypeError("The encoded data was not valid.");
              }
            for (var a2 = "", _2 = 0, n2 = 0; n2 < t3; n2++) {
              var c2 = Array.prototype.slice.call(e3, n2 * r3 + _2, (n2 + 1) * r3 + _2);
              if (c2.length != 0) {
                var o2, h2 = c2.length, p2 = 0;
                do {
                  var y2 = c2[--h2];
                  y2 >= 240 ? (p2 = 4, o2 = true) : y2 >= 224 ? (p2 = 3, o2 = true) : y2 >= 192 ? (p2 = 2, o2 = true) : y2 < 128 && (p2 = 1, o2 = true);
                } while (!o2);
                for (var i2 = p2 - (c2.length - h2), l2 = 0; l2 < i2; l2++)
                  _2--, c2.pop();
                a2 += s(c2);
              }
            }
            return a2;
          }
          function n(e3) {
            e3 = m(null, e3, "input");
            for (var r3, t3, a2, _2 = "", s2 = 0; s2 < e3.length; s2++)
              a2 = 87 + (t3 = 15 & e3[s2]) + (t3 - 10 >> 8 & -39) << 8 | 87 + (r3 = e3[s2] >>> 4) + (r3 - 10 >> 8 & -39), _2 += String.fromCharCode(255 & a2) + String.fromCharCode(a2 >>> 8);
            return _2;
          }
          var c = { ORIGINAL: 1, ORIGINAL_NO_PADDING: 3, URLSAFE: 5, URLSAFE_NO_PADDING: 7 };
          function o(e3) {
            if (e3 == null)
              return c.URLSAFE_NO_PADDING;
            if (e3 !== c.ORIGINAL && e3 !== c.ORIGINAL_NO_PADDING && e3 !== c.URLSAFE && e3 != c.URLSAFE_NO_PADDING)
              throw new Error("unsupported base64 variant");
            return e3;
          }
          function h(e3, r3) {
            r3 = o(r3), e3 = m(_2, e3, "input");
            var a2, _2 = [], n2 = 0 | Math.floor(e3.length / 3), c2 = e3.length - 3 * n2, h2 = 4 * n2 + (c2 !== 0 ? (2 & r3) == 0 ? 4 : 2 + (c2 >>> 1) : 0), p2 = new l(h2 + 1), y2 = u(e3);
            return _2.push(y2), _2.push(p2.address), t2._sodium_bin2base64(p2.address, p2.length, y2, e3.length, r3) === 0 && g(_2, "conversion failed"), p2.length = h2, a2 = s(p2.to_Uint8Array()), v(_2), a2;
          }
          function p(e3, r3) {
            var t3 = r3 || "uint8array";
            if (!y(t3))
              throw new Error(t3 + " output format is not available");
            if (e3 instanceof l) {
              if (t3 === "uint8array")
                return e3.to_Uint8Array();
              if (t3 === "text")
                return s(e3.to_Uint8Array());
              if (t3 === "hex")
                return n(e3.to_Uint8Array());
              if (t3 === "base64")
                return h(e3.to_Uint8Array(), c.URLSAFE_NO_PADDING);
              throw new Error('What is output format "' + t3 + '"?');
            }
            if (typeof e3 == "object") {
              for (var a2 = Object.keys(e3), _2 = {}, o2 = 0; o2 < a2.length; o2++)
                _2[a2[o2]] = p(e3[a2[o2]], t3);
              return _2;
            }
            if (typeof e3 == "string")
              return e3;
            throw new TypeError("Cannot format output");
          }
          function y(e3) {
            for (var r3 = ["uint8array", "text", "hex", "base64"], t3 = 0; t3 < r3.length; t3++)
              if (r3[t3] === e3)
                return true;
            return false;
          }
          function i(e3) {
            if (e3) {
              if (typeof e3 != "string")
                throw new TypeError("When defined, the output format must be a string");
              if (!y(e3))
                throw new Error(e3 + " is not a supported output format");
            }
          }
          function l(e3) {
            this.length = e3, this.address = d(e3);
          }
          function u(e3) {
            var r3 = d(e3.length);
            return t2.HEAPU8.set(e3, r3), r3;
          }
          function d(e3) {
            var r3 = t2._malloc(e3);
            if (r3 === 0)
              throw { message: "_malloc() failed", length: e3 };
            return r3;
          }
          function v(e3) {
            if (e3)
              for (var r3 = 0; r3 < e3.length; r3++)
                a2 = e3[r3], t2._free(a2);
            var a2;
          }
          function g(e3, r3) {
            throw v(e3), new Error(r3);
          }
          function b(e3, r3) {
            throw v(e3), new TypeError(r3);
          }
          function f(e3, r3, t3) {
            r3 == null && b(e3, t3 + " cannot be null or undefined");
          }
          function m(e3, r3, t3) {
            return f(e3, r3, t3), r3 instanceof Uint8Array ? r3 : typeof r3 == "string" ? _(r3) : void b(e3, "unsupported input type for " + t3);
          }
          function E(e3, r3, a2, _2, s2, n2) {
            var c2 = [];
            i(n2);
            var o2 = null;
            e3 != null && (o2 = u(e3 = m(c2, e3, "secret_nonce")), e3.length, c2.push(o2)), r3 = m(c2, r3, "ciphertext");
            var h2, y2 = t2._crypto_aead_chacha20poly1305_abytes(), d2 = r3.length;
            d2 < y2 && b(c2, "ciphertext is too short"), h2 = u(r3), c2.push(h2);
            var f2 = null, E2 = 0;
            a2 != null && (f2 = u(a2 = m(c2, a2, "additional_data")), E2 = a2.length, c2.push(f2)), _2 = m(c2, _2, "public_nonce");
            var x2, k2 = 0 | t2._crypto_aead_chacha20poly1305_npubbytes();
            _2.length !== k2 && b(c2, "invalid public_nonce length"), x2 = u(_2), c2.push(x2), s2 = m(c2, s2, "key");
            var S2, T2 = 0 | t2._crypto_aead_chacha20poly1305_keybytes();
            s2.length !== T2 && b(c2, "invalid key length"), S2 = u(s2), c2.push(S2);
            var w2 = new l(d2 - t2._crypto_aead_chacha20poly1305_abytes() | 0), Y2 = w2.address;
            if (c2.push(Y2), t2._crypto_aead_chacha20poly1305_decrypt(Y2, null, o2, h2, d2, 0, f2, E2, 0, x2, S2) === 0) {
              var B2 = p(w2, n2);
              return v(c2), B2;
            }
            g(c2, "ciphertext cannot be decrypted using that key");
          }
          function x(e3, r3, a2, _2, s2, n2, c2) {
            var o2 = [];
            i(c2);
            var h2 = null;
            e3 != null && (h2 = u(e3 = m(o2, e3, "secret_nonce")), e3.length, o2.push(h2));
            var y2 = u(r3 = m(o2, r3, "ciphertext")), d2 = r3.length;
            o2.push(y2), a2 = m(o2, a2, "mac");
            var f2, E2 = 0 | t2._crypto_box_macbytes();
            a2.length !== E2 && b(o2, "invalid mac length"), f2 = u(a2), o2.push(f2);
            var x2 = null, k2 = 0;
            _2 != null && (x2 = u(_2 = m(o2, _2, "additional_data")), k2 = _2.length, o2.push(x2)), s2 = m(o2, s2, "public_nonce");
            var S2, T2 = 0 | t2._crypto_aead_chacha20poly1305_npubbytes();
            s2.length !== T2 && b(o2, "invalid public_nonce length"), S2 = u(s2), o2.push(S2), n2 = m(o2, n2, "key");
            var w2, Y2 = 0 | t2._crypto_aead_chacha20poly1305_keybytes();
            n2.length !== Y2 && b(o2, "invalid key length"), w2 = u(n2), o2.push(w2);
            var B2 = new l(0 | d2), A2 = B2.address;
            if (o2.push(A2), t2._crypto_aead_chacha20poly1305_decrypt_detached(A2, h2, y2, d2, 0, f2, x2, k2, 0, S2, w2) === 0) {
              var K2 = p(B2, c2);
              return v(o2), K2;
            }
            g(o2, "ciphertext cannot be decrypted using that key");
          }
          function k(e3, r3, a2, _2, s2, n2) {
            var c2 = [];
            i(n2);
            var o2 = u(e3 = m(c2, e3, "message")), h2 = e3.length;
            c2.push(o2);
            var y2 = null, d2 = 0;
            r3 != null && (y2 = u(r3 = m(c2, r3, "additional_data")), d2 = r3.length, c2.push(y2));
            var f2 = null;
            a2 != null && (f2 = u(a2 = m(c2, a2, "secret_nonce")), a2.length, c2.push(f2)), _2 = m(c2, _2, "public_nonce");
            var E2, x2 = 0 | t2._crypto_aead_chacha20poly1305_npubbytes();
            _2.length !== x2 && b(c2, "invalid public_nonce length"), E2 = u(_2), c2.push(E2), s2 = m(c2, s2, "key");
            var k2, S2 = 0 | t2._crypto_aead_chacha20poly1305_keybytes();
            s2.length !== S2 && b(c2, "invalid key length"), k2 = u(s2), c2.push(k2);
            var T2 = new l(h2 + t2._crypto_aead_chacha20poly1305_abytes() | 0), w2 = T2.address;
            if (c2.push(w2), t2._crypto_aead_chacha20poly1305_encrypt(w2, null, o2, h2, 0, y2, d2, 0, f2, E2, k2) === 0) {
              var Y2 = p(T2, n2);
              return v(c2), Y2;
            }
            g(c2, "invalid usage");
          }
          function S(e3, r3, a2, _2, s2, n2) {
            var c2 = [];
            i(n2);
            var o2 = u(e3 = m(c2, e3, "message")), h2 = e3.length;
            c2.push(o2);
            var y2 = null, d2 = 0;
            r3 != null && (y2 = u(r3 = m(c2, r3, "additional_data")), d2 = r3.length, c2.push(y2));
            var f2 = null;
            a2 != null && (f2 = u(a2 = m(c2, a2, "secret_nonce")), a2.length, c2.push(f2)), _2 = m(c2, _2, "public_nonce");
            var E2, x2 = 0 | t2._crypto_aead_chacha20poly1305_npubbytes();
            _2.length !== x2 && b(c2, "invalid public_nonce length"), E2 = u(_2), c2.push(E2), s2 = m(c2, s2, "key");
            var k2, S2 = 0 | t2._crypto_aead_chacha20poly1305_keybytes();
            s2.length !== S2 && b(c2, "invalid key length"), k2 = u(s2), c2.push(k2);
            var T2 = new l(0 | h2), w2 = T2.address;
            c2.push(w2);
            var Y2 = new l(0 | t2._crypto_aead_chacha20poly1305_abytes()), B2 = Y2.address;
            if (c2.push(B2), t2._crypto_aead_chacha20poly1305_encrypt_detached(w2, B2, null, o2, h2, 0, y2, d2, 0, f2, E2, k2) === 0) {
              var A2 = p({ ciphertext: T2, mac: Y2 }, n2);
              return v(c2), A2;
            }
            g(c2, "invalid usage");
          }
          function T(e3, r3, a2, _2, s2, n2) {
            var c2 = [];
            i(n2);
            var o2 = null;
            e3 != null && (o2 = u(e3 = m(c2, e3, "secret_nonce")), e3.length, c2.push(o2)), r3 = m(c2, r3, "ciphertext");
            var h2, y2 = t2._crypto_aead_chacha20poly1305_ietf_abytes(), d2 = r3.length;
            d2 < y2 && b(c2, "ciphertext is too short"), h2 = u(r3), c2.push(h2);
            var f2 = null, E2 = 0;
            a2 != null && (f2 = u(a2 = m(c2, a2, "additional_data")), E2 = a2.length, c2.push(f2)), _2 = m(c2, _2, "public_nonce");
            var x2, k2 = 0 | t2._crypto_aead_chacha20poly1305_ietf_npubbytes();
            _2.length !== k2 && b(c2, "invalid public_nonce length"), x2 = u(_2), c2.push(x2), s2 = m(c2, s2, "key");
            var S2, T2 = 0 | t2._crypto_aead_chacha20poly1305_ietf_keybytes();
            s2.length !== T2 && b(c2, "invalid key length"), S2 = u(s2), c2.push(S2);
            var w2 = new l(d2 - t2._crypto_aead_chacha20poly1305_ietf_abytes() | 0), Y2 = w2.address;
            if (c2.push(Y2), t2._crypto_aead_chacha20poly1305_ietf_decrypt(Y2, null, o2, h2, d2, 0, f2, E2, 0, x2, S2) === 0) {
              var B2 = p(w2, n2);
              return v(c2), B2;
            }
            g(c2, "ciphertext cannot be decrypted using that key");
          }
          function w(e3, r3, a2, _2, s2, n2, c2) {
            var o2 = [];
            i(c2);
            var h2 = null;
            e3 != null && (h2 = u(e3 = m(o2, e3, "secret_nonce")), e3.length, o2.push(h2));
            var y2 = u(r3 = m(o2, r3, "ciphertext")), d2 = r3.length;
            o2.push(y2), a2 = m(o2, a2, "mac");
            var f2, E2 = 0 | t2._crypto_box_macbytes();
            a2.length !== E2 && b(o2, "invalid mac length"), f2 = u(a2), o2.push(f2);
            var x2 = null, k2 = 0;
            _2 != null && (x2 = u(_2 = m(o2, _2, "additional_data")), k2 = _2.length, o2.push(x2)), s2 = m(o2, s2, "public_nonce");
            var S2, T2 = 0 | t2._crypto_aead_chacha20poly1305_ietf_npubbytes();
            s2.length !== T2 && b(o2, "invalid public_nonce length"), S2 = u(s2), o2.push(S2), n2 = m(o2, n2, "key");
            var w2, Y2 = 0 | t2._crypto_aead_chacha20poly1305_ietf_keybytes();
            n2.length !== Y2 && b(o2, "invalid key length"), w2 = u(n2), o2.push(w2);
            var B2 = new l(0 | d2), A2 = B2.address;
            if (o2.push(A2), t2._crypto_aead_chacha20poly1305_ietf_decrypt_detached(A2, h2, y2, d2, 0, f2, x2, k2, 0, S2, w2) === 0) {
              var K2 = p(B2, c2);
              return v(o2), K2;
            }
            g(o2, "ciphertext cannot be decrypted using that key");
          }
          function Y(e3, r3, a2, _2, s2, n2) {
            var c2 = [];
            i(n2);
            var o2 = u(e3 = m(c2, e3, "message")), h2 = e3.length;
            c2.push(o2);
            var y2 = null, d2 = 0;
            r3 != null && (y2 = u(r3 = m(c2, r3, "additional_data")), d2 = r3.length, c2.push(y2));
            var f2 = null;
            a2 != null && (f2 = u(a2 = m(c2, a2, "secret_nonce")), a2.length, c2.push(f2)), _2 = m(c2, _2, "public_nonce");
            var E2, x2 = 0 | t2._crypto_aead_chacha20poly1305_ietf_npubbytes();
            _2.length !== x2 && b(c2, "invalid public_nonce length"), E2 = u(_2), c2.push(E2), s2 = m(c2, s2, "key");
            var k2, S2 = 0 | t2._crypto_aead_chacha20poly1305_ietf_keybytes();
            s2.length !== S2 && b(c2, "invalid key length"), k2 = u(s2), c2.push(k2);
            var T2 = new l(h2 + t2._crypto_aead_chacha20poly1305_ietf_abytes() | 0), w2 = T2.address;
            if (c2.push(w2), t2._crypto_aead_chacha20poly1305_ietf_encrypt(w2, null, o2, h2, 0, y2, d2, 0, f2, E2, k2) === 0) {
              var Y2 = p(T2, n2);
              return v(c2), Y2;
            }
            g(c2, "invalid usage");
          }
          function B(e3, r3, a2, _2, s2, n2) {
            var c2 = [];
            i(n2);
            var o2 = u(e3 = m(c2, e3, "message")), h2 = e3.length;
            c2.push(o2);
            var y2 = null, d2 = 0;
            r3 != null && (y2 = u(r3 = m(c2, r3, "additional_data")), d2 = r3.length, c2.push(y2));
            var f2 = null;
            a2 != null && (f2 = u(a2 = m(c2, a2, "secret_nonce")), a2.length, c2.push(f2)), _2 = m(c2, _2, "public_nonce");
            var E2, x2 = 0 | t2._crypto_aead_chacha20poly1305_ietf_npubbytes();
            _2.length !== x2 && b(c2, "invalid public_nonce length"), E2 = u(_2), c2.push(E2), s2 = m(c2, s2, "key");
            var k2, S2 = 0 | t2._crypto_aead_chacha20poly1305_ietf_keybytes();
            s2.length !== S2 && b(c2, "invalid key length"), k2 = u(s2), c2.push(k2);
            var T2 = new l(0 | h2), w2 = T2.address;
            c2.push(w2);
            var Y2 = new l(0 | t2._crypto_aead_chacha20poly1305_ietf_abytes()), B2 = Y2.address;
            if (c2.push(B2), t2._crypto_aead_chacha20poly1305_ietf_encrypt_detached(w2, B2, null, o2, h2, 0, y2, d2, 0, f2, E2, k2) === 0) {
              var A2 = p({ ciphertext: T2, mac: Y2 }, n2);
              return v(c2), A2;
            }
            g(c2, "invalid usage");
          }
          function A(e3) {
            var r3 = [];
            i(e3);
            var a2 = new l(0 | t2._crypto_aead_chacha20poly1305_ietf_keybytes()), _2 = a2.address;
            r3.push(_2), t2._crypto_aead_chacha20poly1305_ietf_keygen(_2);
            var s2 = p(a2, e3);
            return v(r3), s2;
          }
          function K(e3) {
            var r3 = [];
            i(e3);
            var a2 = new l(0 | t2._crypto_aead_chacha20poly1305_keybytes()), _2 = a2.address;
            r3.push(_2), t2._crypto_aead_chacha20poly1305_keygen(_2);
            var s2 = p(a2, e3);
            return v(r3), s2;
          }
          function M(e3, r3, a2, _2, s2, n2) {
            var c2 = [];
            i(n2);
            var o2 = null;
            e3 != null && (o2 = u(e3 = m(c2, e3, "secret_nonce")), e3.length, c2.push(o2)), r3 = m(c2, r3, "ciphertext");
            var h2, y2 = t2._crypto_aead_xchacha20poly1305_ietf_abytes(), d2 = r3.length;
            d2 < y2 && b(c2, "ciphertext is too short"), h2 = u(r3), c2.push(h2);
            var f2 = null, E2 = 0;
            a2 != null && (f2 = u(a2 = m(c2, a2, "additional_data")), E2 = a2.length, c2.push(f2)), _2 = m(c2, _2, "public_nonce");
            var x2, k2 = 0 | t2._crypto_aead_xchacha20poly1305_ietf_npubbytes();
            _2.length !== k2 && b(c2, "invalid public_nonce length"), x2 = u(_2), c2.push(x2), s2 = m(c2, s2, "key");
            var S2, T2 = 0 | t2._crypto_aead_xchacha20poly1305_ietf_keybytes();
            s2.length !== T2 && b(c2, "invalid key length"), S2 = u(s2), c2.push(S2);
            var w2 = new l(d2 - t2._crypto_aead_xchacha20poly1305_ietf_abytes() | 0), Y2 = w2.address;
            if (c2.push(Y2), t2._crypto_aead_xchacha20poly1305_ietf_decrypt(Y2, null, o2, h2, d2, 0, f2, E2, 0, x2, S2) === 0) {
              var B2 = p(w2, n2);
              return v(c2), B2;
            }
            g(c2, "ciphertext cannot be decrypted using that key");
          }
          function I(e3, r3, a2, _2, s2, n2, c2) {
            var o2 = [];
            i(c2);
            var h2 = null;
            e3 != null && (h2 = u(e3 = m(o2, e3, "secret_nonce")), e3.length, o2.push(h2));
            var y2 = u(r3 = m(o2, r3, "ciphertext")), d2 = r3.length;
            o2.push(y2), a2 = m(o2, a2, "mac");
            var f2, E2 = 0 | t2._crypto_box_macbytes();
            a2.length !== E2 && b(o2, "invalid mac length"), f2 = u(a2), o2.push(f2);
            var x2 = null, k2 = 0;
            _2 != null && (x2 = u(_2 = m(o2, _2, "additional_data")), k2 = _2.length, o2.push(x2)), s2 = m(o2, s2, "public_nonce");
            var S2, T2 = 0 | t2._crypto_aead_xchacha20poly1305_ietf_npubbytes();
            s2.length !== T2 && b(o2, "invalid public_nonce length"), S2 = u(s2), o2.push(S2), n2 = m(o2, n2, "key");
            var w2, Y2 = 0 | t2._crypto_aead_xchacha20poly1305_ietf_keybytes();
            n2.length !== Y2 && b(o2, "invalid key length"), w2 = u(n2), o2.push(w2);
            var B2 = new l(0 | d2), A2 = B2.address;
            if (o2.push(A2), t2._crypto_aead_xchacha20poly1305_ietf_decrypt_detached(A2, h2, y2, d2, 0, f2, x2, k2, 0, S2, w2) === 0) {
              var K2 = p(B2, c2);
              return v(o2), K2;
            }
            g(o2, "ciphertext cannot be decrypted using that key");
          }
          function N(e3, r3, a2, _2, s2, n2) {
            var c2 = [];
            i(n2);
            var o2 = u(e3 = m(c2, e3, "message")), h2 = e3.length;
            c2.push(o2);
            var y2 = null, d2 = 0;
            r3 != null && (y2 = u(r3 = m(c2, r3, "additional_data")), d2 = r3.length, c2.push(y2));
            var f2 = null;
            a2 != null && (f2 = u(a2 = m(c2, a2, "secret_nonce")), a2.length, c2.push(f2)), _2 = m(c2, _2, "public_nonce");
            var E2, x2 = 0 | t2._crypto_aead_xchacha20poly1305_ietf_npubbytes();
            _2.length !== x2 && b(c2, "invalid public_nonce length"), E2 = u(_2), c2.push(E2), s2 = m(c2, s2, "key");
            var k2, S2 = 0 | t2._crypto_aead_xchacha20poly1305_ietf_keybytes();
            s2.length !== S2 && b(c2, "invalid key length"), k2 = u(s2), c2.push(k2);
            var T2 = new l(h2 + t2._crypto_aead_xchacha20poly1305_ietf_abytes() | 0), w2 = T2.address;
            if (c2.push(w2), t2._crypto_aead_xchacha20poly1305_ietf_encrypt(w2, null, o2, h2, 0, y2, d2, 0, f2, E2, k2) === 0) {
              var Y2 = p(T2, n2);
              return v(c2), Y2;
            }
            g(c2, "invalid usage");
          }
          function L(e3, r3, a2, _2, s2, n2) {
            var c2 = [];
            i(n2);
            var o2 = u(e3 = m(c2, e3, "message")), h2 = e3.length;
            c2.push(o2);
            var y2 = null, d2 = 0;
            r3 != null && (y2 = u(r3 = m(c2, r3, "additional_data")), d2 = r3.length, c2.push(y2));
            var f2 = null;
            a2 != null && (f2 = u(a2 = m(c2, a2, "secret_nonce")), a2.length, c2.push(f2)), _2 = m(c2, _2, "public_nonce");
            var E2, x2 = 0 | t2._crypto_aead_xchacha20poly1305_ietf_npubbytes();
            _2.length !== x2 && b(c2, "invalid public_nonce length"), E2 = u(_2), c2.push(E2), s2 = m(c2, s2, "key");
            var k2, S2 = 0 | t2._crypto_aead_xchacha20poly1305_ietf_keybytes();
            s2.length !== S2 && b(c2, "invalid key length"), k2 = u(s2), c2.push(k2);
            var T2 = new l(0 | h2), w2 = T2.address;
            c2.push(w2);
            var Y2 = new l(0 | t2._crypto_aead_xchacha20poly1305_ietf_abytes()), B2 = Y2.address;
            if (c2.push(B2), t2._crypto_aead_xchacha20poly1305_ietf_encrypt_detached(w2, B2, null, o2, h2, 0, y2, d2, 0, f2, E2, k2) === 0) {
              var A2 = p({ ciphertext: T2, mac: Y2 }, n2);
              return v(c2), A2;
            }
            g(c2, "invalid usage");
          }
          function U(e3) {
            var r3 = [];
            i(e3);
            var a2 = new l(0 | t2._crypto_aead_xchacha20poly1305_ietf_keybytes()), _2 = a2.address;
            r3.push(_2), t2._crypto_aead_xchacha20poly1305_ietf_keygen(_2);
            var s2 = p(a2, e3);
            return v(r3), s2;
          }
          function O(e3, r3, a2) {
            var _2 = [];
            i(a2);
            var s2 = u(e3 = m(_2, e3, "message")), n2 = e3.length;
            _2.push(s2), r3 = m(_2, r3, "key");
            var c2, o2 = 0 | t2._crypto_auth_keybytes();
            r3.length !== o2 && b(_2, "invalid key length"), c2 = u(r3), _2.push(c2);
            var h2 = new l(0 | t2._crypto_auth_bytes()), y2 = h2.address;
            if (_2.push(y2), (0 | t2._crypto_auth(y2, s2, n2, 0, c2)) == 0) {
              var d2 = p(h2, a2);
              return v(_2), d2;
            }
            g(_2, "invalid usage");
          }
          function C(e3, r3, a2) {
            var _2 = [];
            i(a2);
            var s2 = u(e3 = m(_2, e3, "message")), n2 = e3.length;
            _2.push(s2), r3 = m(_2, r3, "key");
            var c2, o2 = 0 | t2._crypto_auth_hmacsha256_keybytes();
            r3.length !== o2 && b(_2, "invalid key length"), c2 = u(r3), _2.push(c2);
            var h2 = new l(0 | t2._crypto_auth_hmacsha256_bytes()), y2 = h2.address;
            if (_2.push(y2), (0 | t2._crypto_auth_hmacsha256(y2, s2, n2, 0, c2)) == 0) {
              var d2 = p(h2, a2);
              return v(_2), d2;
            }
            g(_2, "invalid usage");
          }
          function R(e3, r3) {
            var a2 = [];
            i(r3), f(a2, e3, "state_address");
            var _2 = new l(0 | t2._crypto_auth_hmacsha256_bytes()), s2 = _2.address;
            if (a2.push(s2), (0 | t2._crypto_auth_hmacsha256_final(e3, s2)) == 0) {
              var n2 = (t2._free(e3), p(_2, r3));
              return v(a2), n2;
            }
            g(a2, "invalid usage");
          }
          function P(e3, r3) {
            var a2 = [];
            i(r3);
            var _2 = null, s2 = 0;
            e3 != null && (_2 = u(e3 = m(a2, e3, "key")), s2 = e3.length, a2.push(_2));
            var n2 = new l(208).address;
            if ((0 | t2._crypto_auth_hmacsha256_init(n2, _2, s2)) == 0) {
              var c2 = n2;
              return v(a2), c2;
            }
            g(a2, "invalid usage");
          }
          function G(e3) {
            var r3 = [];
            i(e3);
            var a2 = new l(0 | t2._crypto_auth_hmacsha256_keybytes()), _2 = a2.address;
            r3.push(_2), t2._crypto_auth_hmacsha256_keygen(_2);
            var s2 = p(a2, e3);
            return v(r3), s2;
          }
          function X(e3, r3, a2) {
            var _2 = [];
            i(a2), f(_2, e3, "state_address");
            var s2 = u(r3 = m(_2, r3, "message_chunk")), n2 = r3.length;
            _2.push(s2), (0 | t2._crypto_auth_hmacsha256_update(e3, s2, n2)) != 0 && g(_2, "invalid usage"), v(_2);
          }
          function D(e3, r3, a2) {
            var _2 = [];
            e3 = m(_2, e3, "tag");
            var s2, n2 = 0 | t2._crypto_auth_hmacsha256_bytes();
            e3.length !== n2 && b(_2, "invalid tag length"), s2 = u(e3), _2.push(s2);
            var c2 = u(r3 = m(_2, r3, "message")), o2 = r3.length;
            _2.push(c2), a2 = m(_2, a2, "key");
            var h2, p2 = 0 | t2._crypto_auth_hmacsha256_keybytes();
            a2.length !== p2 && b(_2, "invalid key length"), h2 = u(a2), _2.push(h2);
            var y2 = (0 | t2._crypto_auth_hmacsha256_verify(s2, c2, o2, 0, h2)) == 0;
            return v(_2), y2;
          }
          function F(e3, r3, a2) {
            var _2 = [];
            i(a2);
            var s2 = u(e3 = m(_2, e3, "message")), n2 = e3.length;
            _2.push(s2), r3 = m(_2, r3, "key");
            var c2, o2 = 0 | t2._crypto_auth_hmacsha512_keybytes();
            r3.length !== o2 && b(_2, "invalid key length"), c2 = u(r3), _2.push(c2);
            var h2 = new l(0 | t2._crypto_auth_hmacsha512_bytes()), y2 = h2.address;
            if (_2.push(y2), (0 | t2._crypto_auth_hmacsha512(y2, s2, n2, 0, c2)) == 0) {
              var d2 = p(h2, a2);
              return v(_2), d2;
            }
            g(_2, "invalid usage");
          }
          function V(e3, r3) {
            var a2 = [];
            i(r3), f(a2, e3, "state_address");
            var _2 = new l(0 | t2._crypto_auth_hmacsha512_bytes()), s2 = _2.address;
            if (a2.push(s2), (0 | t2._crypto_auth_hmacsha512_final(e3, s2)) == 0) {
              var n2 = (t2._free(e3), p(_2, r3));
              return v(a2), n2;
            }
            g(a2, "invalid usage");
          }
          function H(e3, r3) {
            var a2 = [];
            i(r3);
            var _2 = null, s2 = 0;
            e3 != null && (_2 = u(e3 = m(a2, e3, "key")), s2 = e3.length, a2.push(_2));
            var n2 = new l(416).address;
            if ((0 | t2._crypto_auth_hmacsha512_init(n2, _2, s2)) == 0) {
              var c2 = n2;
              return v(a2), c2;
            }
            g(a2, "invalid usage");
          }
          function q(e3) {
            var r3 = [];
            i(e3);
            var a2 = new l(0 | t2._crypto_auth_hmacsha512_keybytes()), _2 = a2.address;
            r3.push(_2), t2._crypto_auth_hmacsha512_keygen(_2);
            var s2 = p(a2, e3);
            return v(r3), s2;
          }
          function j(e3, r3, a2) {
            var _2 = [];
            i(a2), f(_2, e3, "state_address");
            var s2 = u(r3 = m(_2, r3, "message_chunk")), n2 = r3.length;
            _2.push(s2), (0 | t2._crypto_auth_hmacsha512_update(e3, s2, n2)) != 0 && g(_2, "invalid usage"), v(_2);
          }
          function z(e3, r3, a2) {
            var _2 = [];
            e3 = m(_2, e3, "tag");
            var s2, n2 = 0 | t2._crypto_auth_hmacsha512_bytes();
            e3.length !== n2 && b(_2, "invalid tag length"), s2 = u(e3), _2.push(s2);
            var c2 = u(r3 = m(_2, r3, "message")), o2 = r3.length;
            _2.push(c2), a2 = m(_2, a2, "key");
            var h2, p2 = 0 | t2._crypto_auth_hmacsha512_keybytes();
            a2.length !== p2 && b(_2, "invalid key length"), h2 = u(a2), _2.push(h2);
            var y2 = (0 | t2._crypto_auth_hmacsha512_verify(s2, c2, o2, 0, h2)) == 0;
            return v(_2), y2;
          }
          function W(e3) {
            var r3 = [];
            i(e3);
            var a2 = new l(0 | t2._crypto_auth_keybytes()), _2 = a2.address;
            r3.push(_2), t2._crypto_auth_keygen(_2);
            var s2 = p(a2, e3);
            return v(r3), s2;
          }
          function J(e3, r3, a2) {
            var _2 = [];
            e3 = m(_2, e3, "tag");
            var s2, n2 = 0 | t2._crypto_auth_bytes();
            e3.length !== n2 && b(_2, "invalid tag length"), s2 = u(e3), _2.push(s2);
            var c2 = u(r3 = m(_2, r3, "message")), o2 = r3.length;
            _2.push(c2), a2 = m(_2, a2, "key");
            var h2, p2 = 0 | t2._crypto_auth_keybytes();
            a2.length !== p2 && b(_2, "invalid key length"), h2 = u(a2), _2.push(h2);
            var y2 = (0 | t2._crypto_auth_verify(s2, c2, o2, 0, h2)) == 0;
            return v(_2), y2;
          }
          function Q(e3, r3, a2) {
            var _2 = [];
            i(a2), e3 = m(_2, e3, "publicKey");
            var s2, n2 = 0 | t2._crypto_box_publickeybytes();
            e3.length !== n2 && b(_2, "invalid publicKey length"), s2 = u(e3), _2.push(s2), r3 = m(_2, r3, "privateKey");
            var c2, o2 = 0 | t2._crypto_box_secretkeybytes();
            r3.length !== o2 && b(_2, "invalid privateKey length"), c2 = u(r3), _2.push(c2);
            var h2 = new l(0 | t2._crypto_box_beforenmbytes()), y2 = h2.address;
            if (_2.push(y2), (0 | t2._crypto_box_beforenm(y2, s2, c2)) == 0) {
              var d2 = p(h2, a2);
              return v(_2), d2;
            }
            g(_2, "invalid usage");
          }
          function Z(e3) {
            var r3 = [];
            i(e3);
            var a2 = new l(0 | t2._crypto_box_curve25519xchacha20poly1305_publickeybytes()), _2 = a2.address;
            r3.push(_2);
            var s2 = new l(0 | t2._crypto_box_curve25519xchacha20poly1305_secretkeybytes()), n2 = s2.address;
            r3.push(n2), t2._crypto_box_curve25519xchacha20poly1305_keypair(_2, n2);
            var c2 = p({ publicKey: a2, privateKey: s2, keyType: "curve25519" }, e3);
            return v(r3), c2;
          }
          function $(e3, r3, a2) {
            var _2 = [];
            i(a2);
            var s2 = u(e3 = m(_2, e3, "message")), n2 = e3.length;
            _2.push(s2), r3 = m(_2, r3, "publicKey");
            var c2, o2 = 0 | t2._crypto_box_curve25519xchacha20poly1305_publickeybytes();
            r3.length !== o2 && b(_2, "invalid publicKey length"), c2 = u(r3), _2.push(c2);
            var h2 = new l(n2 + t2._crypto_box_curve25519xchacha20poly1305_sealbytes() | 0), y2 = h2.address;
            _2.push(y2), t2._crypto_box_curve25519xchacha20poly1305_seal(y2, s2, n2, 0, c2);
            var d2 = p(h2, a2);
            return v(_2), d2;
          }
          function ee(e3, r3, a2, _2) {
            var s2 = [];
            i(_2), e3 = m(s2, e3, "ciphertext");
            var n2, c2 = t2._crypto_box_curve25519xchacha20poly1305_sealbytes(), o2 = e3.length;
            o2 < c2 && b(s2, "ciphertext is too short"), n2 = u(e3), s2.push(n2), r3 = m(s2, r3, "publicKey");
            var h2, y2 = 0 | t2._crypto_box_curve25519xchacha20poly1305_publickeybytes();
            r3.length !== y2 && b(s2, "invalid publicKey length"), h2 = u(r3), s2.push(h2), a2 = m(s2, a2, "secretKey");
            var d2, g2 = 0 | t2._crypto_box_curve25519xchacha20poly1305_secretkeybytes();
            a2.length !== g2 && b(s2, "invalid secretKey length"), d2 = u(a2), s2.push(d2);
            var f2 = new l(o2 - t2._crypto_box_curve25519xchacha20poly1305_sealbytes() | 0), E2 = f2.address;
            s2.push(E2), t2._crypto_box_curve25519xchacha20poly1305_seal_open(E2, n2, o2, 0, h2, d2);
            var x2 = p(f2, _2);
            return v(s2), x2;
          }
          function re(e3, r3, a2, _2, s2) {
            var n2 = [];
            i(s2);
            var c2 = u(e3 = m(n2, e3, "message")), o2 = e3.length;
            n2.push(c2), r3 = m(n2, r3, "nonce");
            var h2, y2 = 0 | t2._crypto_box_noncebytes();
            r3.length !== y2 && b(n2, "invalid nonce length"), h2 = u(r3), n2.push(h2), a2 = m(n2, a2, "publicKey");
            var d2, f2 = 0 | t2._crypto_box_publickeybytes();
            a2.length !== f2 && b(n2, "invalid publicKey length"), d2 = u(a2), n2.push(d2), _2 = m(n2, _2, "privateKey");
            var E2, x2 = 0 | t2._crypto_box_secretkeybytes();
            _2.length !== x2 && b(n2, "invalid privateKey length"), E2 = u(_2), n2.push(E2);
            var k2 = new l(0 | o2), S2 = k2.address;
            n2.push(S2);
            var T2 = new l(0 | t2._crypto_box_macbytes()), w2 = T2.address;
            if (n2.push(w2), (0 | t2._crypto_box_detached(S2, w2, c2, o2, 0, h2, d2, E2)) == 0) {
              var Y2 = p({ ciphertext: k2, mac: T2 }, s2);
              return v(n2), Y2;
            }
            g(n2, "invalid usage");
          }
          function te(e3, r3, a2, _2, s2) {
            var n2 = [];
            i(s2);
            var c2 = u(e3 = m(n2, e3, "message")), o2 = e3.length;
            n2.push(c2), r3 = m(n2, r3, "nonce");
            var h2, y2 = 0 | t2._crypto_box_noncebytes();
            r3.length !== y2 && b(n2, "invalid nonce length"), h2 = u(r3), n2.push(h2), a2 = m(n2, a2, "publicKey");
            var d2, f2 = 0 | t2._crypto_box_publickeybytes();
            a2.length !== f2 && b(n2, "invalid publicKey length"), d2 = u(a2), n2.push(d2), _2 = m(n2, _2, "privateKey");
            var E2, x2 = 0 | t2._crypto_box_secretkeybytes();
            _2.length !== x2 && b(n2, "invalid privateKey length"), E2 = u(_2), n2.push(E2);
            var k2 = new l(o2 + t2._crypto_box_macbytes() | 0), S2 = k2.address;
            if (n2.push(S2), (0 | t2._crypto_box_easy(S2, c2, o2, 0, h2, d2, E2)) == 0) {
              var T2 = p(k2, s2);
              return v(n2), T2;
            }
            g(n2, "invalid usage");
          }
          function ae(e3, r3, a2, _2) {
            var s2 = [];
            i(_2);
            var n2 = u(e3 = m(s2, e3, "message")), c2 = e3.length;
            s2.push(n2), r3 = m(s2, r3, "nonce");
            var o2, h2 = 0 | t2._crypto_box_noncebytes();
            r3.length !== h2 && b(s2, "invalid nonce length"), o2 = u(r3), s2.push(o2), a2 = m(s2, a2, "sharedKey");
            var y2, d2 = 0 | t2._crypto_box_beforenmbytes();
            a2.length !== d2 && b(s2, "invalid sharedKey length"), y2 = u(a2), s2.push(y2);
            var f2 = new l(c2 + t2._crypto_box_macbytes() | 0), E2 = f2.address;
            if (s2.push(E2), (0 | t2._crypto_box_easy_afternm(E2, n2, c2, 0, o2, y2)) == 0) {
              var x2 = p(f2, _2);
              return v(s2), x2;
            }
            g(s2, "invalid usage");
          }
          function _e(e3) {
            var r3 = [];
            i(e3);
            var a2 = new l(0 | t2._crypto_box_publickeybytes()), _2 = a2.address;
            r3.push(_2);
            var s2 = new l(0 | t2._crypto_box_secretkeybytes()), n2 = s2.address;
            if (r3.push(n2), (0 | t2._crypto_box_keypair(_2, n2)) == 0) {
              var c2 = { publicKey: p(a2, e3), privateKey: p(s2, e3), keyType: "x25519" };
              return v(r3), c2;
            }
            g(r3, "internal error");
          }
          function se(e3, r3, a2, _2, s2, n2) {
            var c2 = [];
            i(n2);
            var o2 = u(e3 = m(c2, e3, "ciphertext")), h2 = e3.length;
            c2.push(o2), r3 = m(c2, r3, "mac");
            var y2, d2 = 0 | t2._crypto_box_macbytes();
            r3.length !== d2 && b(c2, "invalid mac length"), y2 = u(r3), c2.push(y2), a2 = m(c2, a2, "nonce");
            var f2, E2 = 0 | t2._crypto_box_noncebytes();
            a2.length !== E2 && b(c2, "invalid nonce length"), f2 = u(a2), c2.push(f2), _2 = m(c2, _2, "publicKey");
            var x2, k2 = 0 | t2._crypto_box_publickeybytes();
            _2.length !== k2 && b(c2, "invalid publicKey length"), x2 = u(_2), c2.push(x2), s2 = m(c2, s2, "privateKey");
            var S2, T2 = 0 | t2._crypto_box_secretkeybytes();
            s2.length !== T2 && b(c2, "invalid privateKey length"), S2 = u(s2), c2.push(S2);
            var w2 = new l(0 | h2), Y2 = w2.address;
            if (c2.push(Y2), (0 | t2._crypto_box_open_detached(Y2, o2, y2, h2, 0, f2, x2, S2)) == 0) {
              var B2 = p(w2, n2);
              return v(c2), B2;
            }
            g(c2, "incorrect key pair for the given ciphertext");
          }
          function ne(e3, r3, a2, _2, s2) {
            var n2 = [];
            i(s2), e3 = m(n2, e3, "ciphertext");
            var c2, o2 = t2._crypto_box_macbytes(), h2 = e3.length;
            h2 < o2 && b(n2, "ciphertext is too short"), c2 = u(e3), n2.push(c2), r3 = m(n2, r3, "nonce");
            var y2, d2 = 0 | t2._crypto_box_noncebytes();
            r3.length !== d2 && b(n2, "invalid nonce length"), y2 = u(r3), n2.push(y2), a2 = m(n2, a2, "publicKey");
            var f2, E2 = 0 | t2._crypto_box_publickeybytes();
            a2.length !== E2 && b(n2, "invalid publicKey length"), f2 = u(a2), n2.push(f2), _2 = m(n2, _2, "privateKey");
            var x2, k2 = 0 | t2._crypto_box_secretkeybytes();
            _2.length !== k2 && b(n2, "invalid privateKey length"), x2 = u(_2), n2.push(x2);
            var S2 = new l(h2 - t2._crypto_box_macbytes() | 0), T2 = S2.address;
            if (n2.push(T2), (0 | t2._crypto_box_open_easy(T2, c2, h2, 0, y2, f2, x2)) == 0) {
              var w2 = p(S2, s2);
              return v(n2), w2;
            }
            g(n2, "incorrect key pair for the given ciphertext");
          }
          function ce(e3, r3, a2, _2) {
            var s2 = [];
            i(_2);
            var n2 = u(e3 = m(s2, e3, "ciphertext")), c2 = e3.length;
            s2.push(n2), r3 = m(s2, r3, "nonce");
            var o2, h2 = 0 | t2._crypto_box_noncebytes();
            r3.length !== h2 && b(s2, "invalid nonce length"), o2 = u(r3), s2.push(o2), a2 = m(s2, a2, "sharedKey");
            var y2, d2 = 0 | t2._crypto_box_beforenmbytes();
            a2.length !== d2 && b(s2, "invalid sharedKey length"), y2 = u(a2), s2.push(y2);
            var f2 = new l(c2 - t2._crypto_box_macbytes() | 0), E2 = f2.address;
            if (s2.push(E2), (0 | t2._crypto_box_open_easy_afternm(E2, n2, c2, 0, o2, y2)) == 0) {
              var x2 = p(f2, _2);
              return v(s2), x2;
            }
            g(s2, "incorrect secret key for the given ciphertext");
          }
          function oe(e3, r3, a2) {
            var _2 = [];
            i(a2);
            var s2 = u(e3 = m(_2, e3, "message")), n2 = e3.length;
            _2.push(s2), r3 = m(_2, r3, "publicKey");
            var c2, o2 = 0 | t2._crypto_box_publickeybytes();
            r3.length !== o2 && b(_2, "invalid publicKey length"), c2 = u(r3), _2.push(c2);
            var h2 = new l(n2 + t2._crypto_box_sealbytes() | 0), y2 = h2.address;
            if (_2.push(y2), (0 | t2._crypto_box_seal(y2, s2, n2, 0, c2)) == 0) {
              var d2 = p(h2, a2);
              return v(_2), d2;
            }
            g(_2, "invalid usage");
          }
          function he(e3, r3, a2, _2) {
            var s2 = [];
            i(_2), e3 = m(s2, e3, "ciphertext");
            var n2, c2 = t2._crypto_box_sealbytes(), o2 = e3.length;
            o2 < c2 && b(s2, "ciphertext is too short"), n2 = u(e3), s2.push(n2), r3 = m(s2, r3, "publicKey");
            var h2, y2 = 0 | t2._crypto_box_publickeybytes();
            r3.length !== y2 && b(s2, "invalid publicKey length"), h2 = u(r3), s2.push(h2), a2 = m(s2, a2, "privateKey");
            var d2, f2 = 0 | t2._crypto_box_secretkeybytes();
            a2.length !== f2 && b(s2, "invalid privateKey length"), d2 = u(a2), s2.push(d2);
            var E2 = new l(o2 - t2._crypto_box_sealbytes() | 0), x2 = E2.address;
            if (s2.push(x2), (0 | t2._crypto_box_seal_open(x2, n2, o2, 0, h2, d2)) == 0) {
              var k2 = p(E2, _2);
              return v(s2), k2;
            }
            g(s2, "incorrect key pair for the given ciphertext");
          }
          function pe(e3, r3) {
            var a2 = [];
            i(r3), e3 = m(a2, e3, "seed");
            var _2, s2 = 0 | t2._crypto_box_seedbytes();
            e3.length !== s2 && b(a2, "invalid seed length"), _2 = u(e3), a2.push(_2);
            var n2 = new l(0 | t2._crypto_box_publickeybytes()), c2 = n2.address;
            a2.push(c2);
            var o2 = new l(0 | t2._crypto_box_secretkeybytes()), h2 = o2.address;
            if (a2.push(h2), (0 | t2._crypto_box_seed_keypair(c2, h2, _2)) == 0) {
              var y2 = { publicKey: p(n2, r3), privateKey: p(o2, r3), keyType: "x25519" };
              return v(a2), y2;
            }
            g(a2, "invalid usage");
          }
          function ye(e3, r3, a2) {
            var _2 = [];
            i(a2), e3 = m(_2, e3, "p");
            var s2, n2 = 0 | t2._crypto_core_ed25519_bytes();
            e3.length !== n2 && b(_2, "invalid p length"), s2 = u(e3), _2.push(s2), r3 = m(_2, r3, "q");
            var c2, o2 = 0 | t2._crypto_core_ed25519_bytes();
            r3.length !== o2 && b(_2, "invalid q length"), c2 = u(r3), _2.push(c2);
            var h2 = new l(0 | t2._crypto_core_ed25519_bytes()), y2 = h2.address;
            if (_2.push(y2), (0 | t2._crypto_core_ed25519_add(y2, s2, c2)) == 0) {
              var d2 = p(h2, a2);
              return v(_2), d2;
            }
            g(_2, "input is an invalid element");
          }
          function ie(e3, r3) {
            var a2 = [];
            i(r3);
            var _2 = u(e3 = m(a2, e3, "r"));
            e3.length, a2.push(_2);
            var s2 = new l(0 | t2._crypto_core_ed25519_bytes()), n2 = s2.address;
            if (a2.push(n2), (0 | t2._crypto_core_ed25519_from_hash(n2, _2)) == 0) {
              var c2 = p(s2, r3);
              return v(a2), c2;
            }
            g(a2, "invalid usage");
          }
          function le(e3, r3) {
            var a2 = [];
            i(r3);
            var _2 = u(e3 = m(a2, e3, "r"));
            e3.length, a2.push(_2);
            var s2 = new l(0 | t2._crypto_core_ed25519_bytes()), n2 = s2.address;
            if (a2.push(n2), (0 | t2._crypto_core_ed25519_from_uniform(n2, _2)) == 0) {
              var c2 = p(s2, r3);
              return v(a2), c2;
            }
            g(a2, "invalid usage");
          }
          function ue(e3, r3) {
            var a2 = [];
            i(r3), e3 = m(a2, e3, "repr");
            var _2, s2 = 0 | t2._crypto_core_ed25519_bytes();
            e3.length !== s2 && b(a2, "invalid repr length"), _2 = u(e3), a2.push(_2);
            var n2 = (0 | t2._crypto_core_ed25519_is_valid_point(_2)) == 1;
            return v(a2), n2;
          }
          function de(e3) {
            var r3 = [];
            i(e3);
            var a2 = new l(0 | t2._crypto_core_ed25519_bytes()), _2 = a2.address;
            r3.push(_2), t2._crypto_core_ed25519_random(_2);
            var s2 = p(a2, e3);
            return v(r3), s2;
          }
          function ve(e3, r3, a2) {
            var _2 = [];
            i(a2), e3 = m(_2, e3, "x");
            var s2, n2 = 0 | t2._crypto_core_ed25519_scalarbytes();
            e3.length !== n2 && b(_2, "invalid x length"), s2 = u(e3), _2.push(s2), r3 = m(_2, r3, "y");
            var c2, o2 = 0 | t2._crypto_core_ed25519_scalarbytes();
            r3.length !== o2 && b(_2, "invalid y length"), c2 = u(r3), _2.push(c2);
            var h2 = new l(0 | t2._crypto_core_ed25519_scalarbytes()), y2 = h2.address;
            _2.push(y2), t2._crypto_core_ed25519_scalar_add(y2, s2, c2);
            var d2 = p(h2, a2);
            return v(_2), d2;
          }
          function ge(e3, r3) {
            var a2 = [];
            i(r3), e3 = m(a2, e3, "s");
            var _2, s2 = 0 | t2._crypto_core_ed25519_scalarbytes();
            e3.length !== s2 && b(a2, "invalid s length"), _2 = u(e3), a2.push(_2);
            var n2 = new l(0 | t2._crypto_core_ed25519_scalarbytes()), c2 = n2.address;
            a2.push(c2), t2._crypto_core_ed25519_scalar_complement(c2, _2);
            var o2 = p(n2, r3);
            return v(a2), o2;
          }
          function be(e3, r3) {
            var a2 = [];
            i(r3), e3 = m(a2, e3, "s");
            var _2, s2 = 0 | t2._crypto_core_ed25519_scalarbytes();
            e3.length !== s2 && b(a2, "invalid s length"), _2 = u(e3), a2.push(_2);
            var n2 = new l(0 | t2._crypto_core_ed25519_scalarbytes()), c2 = n2.address;
            if (a2.push(c2), (0 | t2._crypto_core_ed25519_scalar_invert(c2, _2)) == 0) {
              var o2 = p(n2, r3);
              return v(a2), o2;
            }
            g(a2, "invalid reciprocate");
          }
          function fe(e3, r3, a2) {
            var _2 = [];
            i(a2), e3 = m(_2, e3, "x");
            var s2, n2 = 0 | t2._crypto_core_ed25519_scalarbytes();
            e3.length !== n2 && b(_2, "invalid x length"), s2 = u(e3), _2.push(s2), r3 = m(_2, r3, "y");
            var c2, o2 = 0 | t2._crypto_core_ed25519_scalarbytes();
            r3.length !== o2 && b(_2, "invalid y length"), c2 = u(r3), _2.push(c2);
            var h2 = new l(0 | t2._crypto_core_ed25519_scalarbytes()), y2 = h2.address;
            _2.push(y2), t2._crypto_core_ed25519_scalar_mul(y2, s2, c2);
            var d2 = p(h2, a2);
            return v(_2), d2;
          }
          function me(e3, r3) {
            var a2 = [];
            i(r3), e3 = m(a2, e3, "s");
            var _2, s2 = 0 | t2._crypto_core_ed25519_scalarbytes();
            e3.length !== s2 && b(a2, "invalid s length"), _2 = u(e3), a2.push(_2);
            var n2 = new l(0 | t2._crypto_core_ed25519_scalarbytes()), c2 = n2.address;
            a2.push(c2), t2._crypto_core_ed25519_scalar_negate(c2, _2);
            var o2 = p(n2, r3);
            return v(a2), o2;
          }
          function Ee(e3) {
            var r3 = [];
            i(e3);
            var a2 = new l(0 | t2._crypto_core_ed25519_scalarbytes()), _2 = a2.address;
            r3.push(_2), t2._crypto_core_ed25519_scalar_random(_2);
            var s2 = p(a2, e3);
            return v(r3), s2;
          }
          function xe(e3, r3) {
            var a2 = [];
            i(r3), e3 = m(a2, e3, "sample");
            var _2, s2 = 0 | t2._crypto_core_ed25519_nonreducedscalarbytes();
            e3.length !== s2 && b(a2, "invalid sample length"), _2 = u(e3), a2.push(_2);
            var n2 = new l(0 | t2._crypto_core_ed25519_scalarbytes()), c2 = n2.address;
            a2.push(c2), t2._crypto_core_ed25519_scalar_reduce(c2, _2);
            var o2 = p(n2, r3);
            return v(a2), o2;
          }
          function ke(e3, r3, a2) {
            var _2 = [];
            i(a2), e3 = m(_2, e3, "x");
            var s2, n2 = 0 | t2._crypto_core_ed25519_scalarbytes();
            e3.length !== n2 && b(_2, "invalid x length"), s2 = u(e3), _2.push(s2), r3 = m(_2, r3, "y");
            var c2, o2 = 0 | t2._crypto_core_ed25519_scalarbytes();
            r3.length !== o2 && b(_2, "invalid y length"), c2 = u(r3), _2.push(c2);
            var h2 = new l(0 | t2._crypto_core_ed25519_scalarbytes()), y2 = h2.address;
            _2.push(y2), t2._crypto_core_ed25519_scalar_sub(y2, s2, c2);
            var d2 = p(h2, a2);
            return v(_2), d2;
          }
          function Se(e3, r3, a2) {
            var _2 = [];
            i(a2), e3 = m(_2, e3, "p");
            var s2, n2 = 0 | t2._crypto_core_ed25519_bytes();
            e3.length !== n2 && b(_2, "invalid p length"), s2 = u(e3), _2.push(s2), r3 = m(_2, r3, "q");
            var c2, o2 = 0 | t2._crypto_core_ed25519_bytes();
            r3.length !== o2 && b(_2, "invalid q length"), c2 = u(r3), _2.push(c2);
            var h2 = new l(0 | t2._crypto_core_ed25519_bytes()), y2 = h2.address;
            if (_2.push(y2), (0 | t2._crypto_core_ed25519_sub(y2, s2, c2)) == 0) {
              var d2 = p(h2, a2);
              return v(_2), d2;
            }
            g(_2, "input is an invalid element");
          }
          function Te(e3, r3, a2, _2) {
            var s2 = [];
            i(_2), e3 = m(s2, e3, "input");
            var n2, c2 = 0 | t2._crypto_core_hchacha20_inputbytes();
            e3.length !== c2 && b(s2, "invalid input length"), n2 = u(e3), s2.push(n2), r3 = m(s2, r3, "privateKey");
            var o2, h2 = 0 | t2._crypto_core_hchacha20_keybytes();
            r3.length !== h2 && b(s2, "invalid privateKey length"), o2 = u(r3), s2.push(o2);
            var y2 = null;
            a2 != null && (y2 = u(a2 = m(s2, a2, "constant")), a2.length, s2.push(y2));
            var d2 = new l(0 | t2._crypto_core_hchacha20_outputbytes()), f2 = d2.address;
            if (s2.push(f2), (0 | t2._crypto_core_hchacha20(f2, n2, o2, y2)) == 0) {
              var E2 = p(d2, _2);
              return v(s2), E2;
            }
            g(s2, "invalid usage");
          }
          function we(e3, r3, a2, _2) {
            var s2 = [];
            i(_2), e3 = m(s2, e3, "input");
            var n2, c2 = 0 | t2._crypto_core_hsalsa20_inputbytes();
            e3.length !== c2 && b(s2, "invalid input length"), n2 = u(e3), s2.push(n2), r3 = m(s2, r3, "privateKey");
            var o2, h2 = 0 | t2._crypto_core_hsalsa20_keybytes();
            r3.length !== h2 && b(s2, "invalid privateKey length"), o2 = u(r3), s2.push(o2);
            var y2 = null;
            a2 != null && (y2 = u(a2 = m(s2, a2, "constant")), a2.length, s2.push(y2));
            var d2 = new l(0 | t2._crypto_core_hsalsa20_outputbytes()), f2 = d2.address;
            if (s2.push(f2), (0 | t2._crypto_core_hsalsa20(f2, n2, o2, y2)) == 0) {
              var E2 = p(d2, _2);
              return v(s2), E2;
            }
            g(s2, "invalid usage");
          }
          function Ye(e3, r3, a2) {
            var _2 = [];
            i(a2), e3 = m(_2, e3, "p");
            var s2, n2 = 0 | t2._crypto_core_ristretto255_bytes();
            e3.length !== n2 && b(_2, "invalid p length"), s2 = u(e3), _2.push(s2), r3 = m(_2, r3, "q");
            var c2, o2 = 0 | t2._crypto_core_ristretto255_bytes();
            r3.length !== o2 && b(_2, "invalid q length"), c2 = u(r3), _2.push(c2);
            var h2 = new l(0 | t2._crypto_core_ristretto255_bytes()), y2 = h2.address;
            if (_2.push(y2), (0 | t2._crypto_core_ristretto255_add(y2, s2, c2)) == 0) {
              var d2 = p(h2, a2);
              return v(_2), d2;
            }
            g(_2, "input is an invalid element");
          }
          function Be(e3, r3) {
            var a2 = [];
            i(r3);
            var _2 = u(e3 = m(a2, e3, "r"));
            e3.length, a2.push(_2);
            var s2 = new l(0 | t2._crypto_core_ristretto255_bytes()), n2 = s2.address;
            if (a2.push(n2), (0 | t2._crypto_core_ristretto255_from_hash(n2, _2)) == 0) {
              var c2 = p(s2, r3);
              return v(a2), c2;
            }
            g(a2, "invalid usage");
          }
          function Ae(e3, r3) {
            var a2 = [];
            i(r3), e3 = m(a2, e3, "repr");
            var _2, s2 = 0 | t2._crypto_core_ristretto255_bytes();
            e3.length !== s2 && b(a2, "invalid repr length"), _2 = u(e3), a2.push(_2);
            var n2 = (0 | t2._crypto_core_ristretto255_is_valid_point(_2)) == 1;
            return v(a2), n2;
          }
          function Ke(e3) {
            var r3 = [];
            i(e3);
            var a2 = new l(0 | t2._crypto_core_ristretto255_bytes()), _2 = a2.address;
            r3.push(_2), t2._crypto_core_ristretto255_random(_2);
            var s2 = p(a2, e3);
            return v(r3), s2;
          }
          function Me(e3, r3, a2) {
            var _2 = [];
            i(a2), e3 = m(_2, e3, "x");
            var s2, n2 = 0 | t2._crypto_core_ristretto255_scalarbytes();
            e3.length !== n2 && b(_2, "invalid x length"), s2 = u(e3), _2.push(s2), r3 = m(_2, r3, "y");
            var c2, o2 = 0 | t2._crypto_core_ristretto255_scalarbytes();
            r3.length !== o2 && b(_2, "invalid y length"), c2 = u(r3), _2.push(c2);
            var h2 = new l(0 | t2._crypto_core_ristretto255_scalarbytes()), y2 = h2.address;
            _2.push(y2), t2._crypto_core_ristretto255_scalar_add(y2, s2, c2);
            var d2 = p(h2, a2);
            return v(_2), d2;
          }
          function Ie(e3, r3) {
            var a2 = [];
            i(r3), e3 = m(a2, e3, "s");
            var _2, s2 = 0 | t2._crypto_core_ristretto255_scalarbytes();
            e3.length !== s2 && b(a2, "invalid s length"), _2 = u(e3), a2.push(_2);
            var n2 = new l(0 | t2._crypto_core_ristretto255_scalarbytes()), c2 = n2.address;
            a2.push(c2), t2._crypto_core_ristretto255_scalar_complement(c2, _2);
            var o2 = p(n2, r3);
            return v(a2), o2;
          }
          function Ne(e3, r3) {
            var a2 = [];
            i(r3), e3 = m(a2, e3, "s");
            var _2, s2 = 0 | t2._crypto_core_ristretto255_scalarbytes();
            e3.length !== s2 && b(a2, "invalid s length"), _2 = u(e3), a2.push(_2);
            var n2 = new l(0 | t2._crypto_core_ristretto255_scalarbytes()), c2 = n2.address;
            if (a2.push(c2), (0 | t2._crypto_core_ristretto255_scalar_invert(c2, _2)) == 0) {
              var o2 = p(n2, r3);
              return v(a2), o2;
            }
            g(a2, "invalid reciprocate");
          }
          function Le(e3, r3, a2) {
            var _2 = [];
            i(a2), e3 = m(_2, e3, "x");
            var s2, n2 = 0 | t2._crypto_core_ristretto255_scalarbytes();
            e3.length !== n2 && b(_2, "invalid x length"), s2 = u(e3), _2.push(s2), r3 = m(_2, r3, "y");
            var c2, o2 = 0 | t2._crypto_core_ristretto255_scalarbytes();
            r3.length !== o2 && b(_2, "invalid y length"), c2 = u(r3), _2.push(c2);
            var h2 = new l(0 | t2._crypto_core_ristretto255_scalarbytes()), y2 = h2.address;
            _2.push(y2), t2._crypto_core_ristretto255_scalar_mul(y2, s2, c2);
            var d2 = p(h2, a2);
            return v(_2), d2;
          }
          function Ue(e3, r3) {
            var a2 = [];
            i(r3), e3 = m(a2, e3, "s");
            var _2, s2 = 0 | t2._crypto_core_ristretto255_scalarbytes();
            e3.length !== s2 && b(a2, "invalid s length"), _2 = u(e3), a2.push(_2);
            var n2 = new l(0 | t2._crypto_core_ristretto255_scalarbytes()), c2 = n2.address;
            a2.push(c2), t2._crypto_core_ristretto255_scalar_negate(c2, _2);
            var o2 = p(n2, r3);
            return v(a2), o2;
          }
          function Oe(e3) {
            var r3 = [];
            i(e3);
            var a2 = new l(0 | t2._crypto_core_ristretto255_scalarbytes()), _2 = a2.address;
            r3.push(_2), t2._crypto_core_ristretto255_scalar_random(_2);
            var s2 = p(a2, e3);
            return v(r3), s2;
          }
          function Ce(e3, r3) {
            var a2 = [];
            i(r3), e3 = m(a2, e3, "sample");
            var _2, s2 = 0 | t2._crypto_core_ristretto255_nonreducedscalarbytes();
            e3.length !== s2 && b(a2, "invalid sample length"), _2 = u(e3), a2.push(_2);
            var n2 = new l(0 | t2._crypto_core_ristretto255_scalarbytes()), c2 = n2.address;
            a2.push(c2), t2._crypto_core_ristretto255_scalar_reduce(c2, _2);
            var o2 = p(n2, r3);
            return v(a2), o2;
          }
          function Re(e3, r3, a2) {
            var _2 = [];
            i(a2), e3 = m(_2, e3, "x");
            var s2, n2 = 0 | t2._crypto_core_ristretto255_scalarbytes();
            e3.length !== n2 && b(_2, "invalid x length"), s2 = u(e3), _2.push(s2), r3 = m(_2, r3, "y");
            var c2, o2 = 0 | t2._crypto_core_ristretto255_scalarbytes();
            r3.length !== o2 && b(_2, "invalid y length"), c2 = u(r3), _2.push(c2);
            var h2 = new l(0 | t2._crypto_core_ristretto255_scalarbytes()), y2 = h2.address;
            _2.push(y2), t2._crypto_core_ristretto255_scalar_sub(y2, s2, c2);
            var d2 = p(h2, a2);
            return v(_2), d2;
          }
          function Pe(e3, r3, a2) {
            var _2 = [];
            i(a2), e3 = m(_2, e3, "p");
            var s2, n2 = 0 | t2._crypto_core_ristretto255_bytes();
            e3.length !== n2 && b(_2, "invalid p length"), s2 = u(e3), _2.push(s2), r3 = m(_2, r3, "q");
            var c2, o2 = 0 | t2._crypto_core_ristretto255_bytes();
            r3.length !== o2 && b(_2, "invalid q length"), c2 = u(r3), _2.push(c2);
            var h2 = new l(0 | t2._crypto_core_ristretto255_bytes()), y2 = h2.address;
            if (_2.push(y2), (0 | t2._crypto_core_ristretto255_sub(y2, s2, c2)) == 0) {
              var d2 = p(h2, a2);
              return v(_2), d2;
            }
            g(_2, "input is an invalid element");
          }
          function Ge(e3, r3, a2, _2) {
            var s2 = [];
            i(_2), f(s2, e3, "hash_length"), (typeof e3 != "number" || (0 | e3) !== e3 || e3 < 0) && b(s2, "hash_length must be an unsigned integer");
            var n2 = u(r3 = m(s2, r3, "message")), c2 = r3.length;
            s2.push(n2);
            var o2 = null, h2 = 0;
            a2 != null && (o2 = u(a2 = m(s2, a2, "key")), h2 = a2.length, s2.push(o2));
            var y2 = new l(e3 |= 0), d2 = y2.address;
            if (s2.push(d2), (0 | t2._crypto_generichash(d2, e3, n2, c2, 0, o2, h2)) == 0) {
              var E2 = p(y2, _2);
              return v(s2), E2;
            }
            g(s2, "invalid usage");
          }
          function Xe(e3, r3, a2, _2, s2) {
            var n2 = [];
            i(s2), f(n2, e3, "subkey_len"), (typeof e3 != "number" || (0 | e3) !== e3 || e3 < 0) && b(n2, "subkey_len must be an unsigned integer");
            var c2 = null, o2 = 0;
            r3 != null && (c2 = u(r3 = m(n2, r3, "key")), o2 = r3.length, n2.push(c2)), a2 = m(n2, a2, "id");
            var h2, y2 = 0 | t2._crypto_generichash_blake2b_saltbytes();
            a2.length !== y2 && b(n2, "invalid id length"), h2 = u(a2), n2.push(h2), _2 = m(n2, _2, "ctx");
            var d2, E2 = 0 | t2._crypto_generichash_blake2b_personalbytes();
            _2.length !== E2 && b(n2, "invalid ctx length"), d2 = u(_2), n2.push(d2);
            var x2 = new l(0 | e3), k2 = x2.address;
            if (n2.push(k2), (0 | t2._crypto_generichash_blake2b_salt_personal(k2, e3, null, 0, 0, c2, o2, h2, d2)) == 0) {
              var S2 = p(x2, s2);
              return v(n2), S2;
            }
            g(n2, "invalid usage");
          }
          function De(e3, r3, a2) {
            var _2 = [];
            i(a2), f(_2, e3, "state_address"), f(_2, r3, "hash_length"), (typeof r3 != "number" || (0 | r3) !== r3 || r3 < 0) && b(_2, "hash_length must be an unsigned integer");
            var s2 = new l(r3 |= 0), n2 = s2.address;
            if (_2.push(n2), (0 | t2._crypto_generichash_final(e3, n2, r3)) == 0) {
              var c2 = (t2._free(e3), p(s2, a2));
              return v(_2), c2;
            }
            g(_2, "invalid usage");
          }
          function Fe(e3, r3, a2) {
            var _2 = [];
            i(a2);
            var s2 = null, n2 = 0;
            e3 != null && (s2 = u(e3 = m(_2, e3, "key")), n2 = e3.length, _2.push(s2)), f(_2, r3, "hash_length"), (typeof r3 != "number" || (0 | r3) !== r3 || r3 < 0) && b(_2, "hash_length must be an unsigned integer");
            var c2 = new l(357).address;
            if ((0 | t2._crypto_generichash_init(c2, s2, n2, r3)) == 0) {
              var o2 = c2;
              return v(_2), o2;
            }
            g(_2, "invalid usage");
          }
          function Ve(e3) {
            var r3 = [];
            i(e3);
            var a2 = new l(0 | t2._crypto_generichash_keybytes()), _2 = a2.address;
            r3.push(_2), t2._crypto_generichash_keygen(_2);
            var s2 = p(a2, e3);
            return v(r3), s2;
          }
          function He(e3, r3, a2) {
            var _2 = [];
            i(a2), f(_2, e3, "state_address");
            var s2 = u(r3 = m(_2, r3, "message_chunk")), n2 = r3.length;
            _2.push(s2), (0 | t2._crypto_generichash_update(e3, s2, n2)) != 0 && g(_2, "invalid usage"), v(_2);
          }
          function qe(e3, r3) {
            var a2 = [];
            i(r3);
            var _2 = u(e3 = m(a2, e3, "message")), s2 = e3.length;
            a2.push(_2);
            var n2 = new l(0 | t2._crypto_hash_bytes()), c2 = n2.address;
            if (a2.push(c2), (0 | t2._crypto_hash(c2, _2, s2, 0)) == 0) {
              var o2 = p(n2, r3);
              return v(a2), o2;
            }
            g(a2, "invalid usage");
          }
          function je(e3, r3) {
            var a2 = [];
            i(r3);
            var _2 = u(e3 = m(a2, e3, "message")), s2 = e3.length;
            a2.push(_2);
            var n2 = new l(0 | t2._crypto_hash_sha256_bytes()), c2 = n2.address;
            if (a2.push(c2), (0 | t2._crypto_hash_sha256(c2, _2, s2, 0)) == 0) {
              var o2 = p(n2, r3);
              return v(a2), o2;
            }
            g(a2, "invalid usage");
          }
          function ze(e3, r3) {
            var a2 = [];
            i(r3), f(a2, e3, "state_address");
            var _2 = new l(0 | t2._crypto_hash_sha256_bytes()), s2 = _2.address;
            if (a2.push(s2), (0 | t2._crypto_hash_sha256_final(e3, s2)) == 0) {
              var n2 = (t2._free(e3), p(_2, r3));
              return v(a2), n2;
            }
            g(a2, "invalid usage");
          }
          function We(e3) {
            var r3 = [];
            i(e3);
            var a2 = new l(104).address;
            if ((0 | t2._crypto_hash_sha256_init(a2)) == 0) {
              var _2 = a2;
              return v(r3), _2;
            }
            g(r3, "invalid usage");
          }
          function Je(e3, r3, a2) {
            var _2 = [];
            i(a2), f(_2, e3, "state_address");
            var s2 = u(r3 = m(_2, r3, "message_chunk")), n2 = r3.length;
            _2.push(s2), (0 | t2._crypto_hash_sha256_update(e3, s2, n2)) != 0 && g(_2, "invalid usage"), v(_2);
          }
          function Qe(e3, r3) {
            var a2 = [];
            i(r3);
            var _2 = u(e3 = m(a2, e3, "message")), s2 = e3.length;
            a2.push(_2);
            var n2 = new l(0 | t2._crypto_hash_sha512_bytes()), c2 = n2.address;
            if (a2.push(c2), (0 | t2._crypto_hash_sha512(c2, _2, s2, 0)) == 0) {
              var o2 = p(n2, r3);
              return v(a2), o2;
            }
            g(a2, "invalid usage");
          }
          function Ze(e3, r3) {
            var a2 = [];
            i(r3), f(a2, e3, "state_address");
            var _2 = new l(0 | t2._crypto_hash_sha512_bytes()), s2 = _2.address;
            if (a2.push(s2), (0 | t2._crypto_hash_sha512_final(e3, s2)) == 0) {
              var n2 = (t2._free(e3), p(_2, r3));
              return v(a2), n2;
            }
            g(a2, "invalid usage");
          }
          function $e(e3) {
            var r3 = [];
            i(e3);
            var a2 = new l(208).address;
            if ((0 | t2._crypto_hash_sha512_init(a2)) == 0) {
              var _2 = a2;
              return v(r3), _2;
            }
            g(r3, "invalid usage");
          }
          function er(e3, r3, a2) {
            var _2 = [];
            i(a2), f(_2, e3, "state_address");
            var s2 = u(r3 = m(_2, r3, "message_chunk")), n2 = r3.length;
            _2.push(s2), (0 | t2._crypto_hash_sha512_update(e3, s2, n2)) != 0 && g(_2, "invalid usage"), v(_2);
          }
          function rr(e3, r3, a2, s2, n2) {
            var c2 = [];
            i(n2), f(c2, e3, "subkey_len"), (typeof e3 != "number" || (0 | e3) !== e3 || e3 < 0) && b(c2, "subkey_len must be an unsigned integer"), f(c2, r3, "subkey_id"), (typeof r3 != "number" || (0 | r3) !== r3 || r3 < 0) && b(c2, "subkey_id must be an unsigned integer"), typeof a2 != "string" && b(c2, "ctx must be a string"), a2 = _(a2 + "\0"), h2 != null && a2.length - 1 !== h2 && b(c2, "invalid ctx length");
            var o2 = u(a2), h2 = a2.length - 1;
            c2.push(o2), s2 = m(c2, s2, "key");
            var y2, d2 = 0 | t2._crypto_kdf_keybytes();
            s2.length !== d2 && b(c2, "invalid key length"), y2 = u(s2), c2.push(y2);
            var g2 = new l(0 | e3), E2 = g2.address;
            c2.push(E2), t2._crypto_kdf_derive_from_key(E2, e3, r3, r3 >>> 24 >>> 8, o2, y2);
            var x2 = p(g2, n2);
            return v(c2), x2;
          }
          function tr(e3) {
            var r3 = [];
            i(e3);
            var a2 = new l(0 | t2._crypto_kdf_keybytes()), _2 = a2.address;
            r3.push(_2), t2._crypto_kdf_keygen(_2);
            var s2 = p(a2, e3);
            return v(r3), s2;
          }
          function ar(e3, r3, a2, _2) {
            var s2 = [];
            i(_2), e3 = m(s2, e3, "clientPublicKey");
            var n2, c2 = 0 | t2._crypto_kx_publickeybytes();
            e3.length !== c2 && b(s2, "invalid clientPublicKey length"), n2 = u(e3), s2.push(n2), r3 = m(s2, r3, "clientSecretKey");
            var o2, h2 = 0 | t2._crypto_kx_secretkeybytes();
            r3.length !== h2 && b(s2, "invalid clientSecretKey length"), o2 = u(r3), s2.push(o2), a2 = m(s2, a2, "serverPublicKey");
            var y2, d2 = 0 | t2._crypto_kx_publickeybytes();
            a2.length !== d2 && b(s2, "invalid serverPublicKey length"), y2 = u(a2), s2.push(y2);
            var f2 = new l(0 | t2._crypto_kx_sessionkeybytes()), E2 = f2.address;
            s2.push(E2);
            var x2 = new l(0 | t2._crypto_kx_sessionkeybytes()), k2 = x2.address;
            if (s2.push(k2), (0 | t2._crypto_kx_client_session_keys(E2, k2, n2, o2, y2)) == 0) {
              var S2 = p({ sharedRx: f2, sharedTx: x2 }, _2);
              return v(s2), S2;
            }
            g(s2, "invalid usage");
          }
          function _r(e3) {
            var r3 = [];
            i(e3);
            var a2 = new l(0 | t2._crypto_kx_publickeybytes()), _2 = a2.address;
            r3.push(_2);
            var s2 = new l(0 | t2._crypto_kx_secretkeybytes()), n2 = s2.address;
            if (r3.push(n2), (0 | t2._crypto_kx_keypair(_2, n2)) == 0) {
              var c2 = { publicKey: p(a2, e3), privateKey: p(s2, e3), keyType: "x25519" };
              return v(r3), c2;
            }
            g(r3, "internal error");
          }
          function sr(e3, r3) {
            var a2 = [];
            i(r3), e3 = m(a2, e3, "seed");
            var _2, s2 = 0 | t2._crypto_kx_seedbytes();
            e3.length !== s2 && b(a2, "invalid seed length"), _2 = u(e3), a2.push(_2);
            var n2 = new l(0 | t2._crypto_kx_publickeybytes()), c2 = n2.address;
            a2.push(c2);
            var o2 = new l(0 | t2._crypto_kx_secretkeybytes()), h2 = o2.address;
            if (a2.push(h2), (0 | t2._crypto_kx_seed_keypair(c2, h2, _2)) == 0) {
              var y2 = { publicKey: p(n2, r3), privateKey: p(o2, r3), keyType: "x25519" };
              return v(a2), y2;
            }
            g(a2, "internal error");
          }
          function nr(e3, r3, a2, _2) {
            var s2 = [];
            i(_2), e3 = m(s2, e3, "serverPublicKey");
            var n2, c2 = 0 | t2._crypto_kx_publickeybytes();
            e3.length !== c2 && b(s2, "invalid serverPublicKey length"), n2 = u(e3), s2.push(n2), r3 = m(s2, r3, "serverSecretKey");
            var o2, h2 = 0 | t2._crypto_kx_secretkeybytes();
            r3.length !== h2 && b(s2, "invalid serverSecretKey length"), o2 = u(r3), s2.push(o2), a2 = m(s2, a2, "clientPublicKey");
            var y2, d2 = 0 | t2._crypto_kx_publickeybytes();
            a2.length !== d2 && b(s2, "invalid clientPublicKey length"), y2 = u(a2), s2.push(y2);
            var f2 = new l(0 | t2._crypto_kx_sessionkeybytes()), E2 = f2.address;
            s2.push(E2);
            var x2 = new l(0 | t2._crypto_kx_sessionkeybytes()), k2 = x2.address;
            if (s2.push(k2), (0 | t2._crypto_kx_server_session_keys(E2, k2, n2, o2, y2)) == 0) {
              var S2 = p({ sharedRx: f2, sharedTx: x2 }, _2);
              return v(s2), S2;
            }
            g(s2, "invalid usage");
          }
          function cr(e3, r3, a2) {
            var _2 = [];
            i(a2);
            var s2 = u(e3 = m(_2, e3, "message")), n2 = e3.length;
            _2.push(s2), r3 = m(_2, r3, "key");
            var c2, o2 = 0 | t2._crypto_onetimeauth_keybytes();
            r3.length !== o2 && b(_2, "invalid key length"), c2 = u(r3), _2.push(c2);
            var h2 = new l(0 | t2._crypto_onetimeauth_bytes()), y2 = h2.address;
            if (_2.push(y2), (0 | t2._crypto_onetimeauth(y2, s2, n2, 0, c2)) == 0) {
              var d2 = p(h2, a2);
              return v(_2), d2;
            }
            g(_2, "invalid usage");
          }
          function or(e3, r3) {
            var a2 = [];
            i(r3), f(a2, e3, "state_address");
            var _2 = new l(0 | t2._crypto_onetimeauth_bytes()), s2 = _2.address;
            if (a2.push(s2), (0 | t2._crypto_onetimeauth_final(e3, s2)) == 0) {
              var n2 = (t2._free(e3), p(_2, r3));
              return v(a2), n2;
            }
            g(a2, "invalid usage");
          }
          function hr(e3, r3) {
            var a2 = [];
            i(r3);
            var _2 = null;
            e3 != null && (_2 = u(e3 = m(a2, e3, "key")), e3.length, a2.push(_2));
            var s2 = new l(144).address;
            if ((0 | t2._crypto_onetimeauth_init(s2, _2)) == 0) {
              var n2 = s2;
              return v(a2), n2;
            }
            g(a2, "invalid usage");
          }
          function pr(e3) {
            var r3 = [];
            i(e3);
            var a2 = new l(0 | t2._crypto_onetimeauth_keybytes()), _2 = a2.address;
            r3.push(_2), t2._crypto_onetimeauth_keygen(_2);
            var s2 = p(a2, e3);
            return v(r3), s2;
          }
          function yr(e3, r3, a2) {
            var _2 = [];
            i(a2), f(_2, e3, "state_address");
            var s2 = u(r3 = m(_2, r3, "message_chunk")), n2 = r3.length;
            _2.push(s2), (0 | t2._crypto_onetimeauth_update(e3, s2, n2)) != 0 && g(_2, "invalid usage"), v(_2);
          }
          function ir(e3, r3, a2) {
            var _2 = [];
            e3 = m(_2, e3, "hash");
            var s2, n2 = 0 | t2._crypto_onetimeauth_bytes();
            e3.length !== n2 && b(_2, "invalid hash length"), s2 = u(e3), _2.push(s2);
            var c2 = u(r3 = m(_2, r3, "message")), o2 = r3.length;
            _2.push(c2), a2 = m(_2, a2, "key");
            var h2, p2 = 0 | t2._crypto_onetimeauth_keybytes();
            a2.length !== p2 && b(_2, "invalid key length"), h2 = u(a2), _2.push(h2);
            var y2 = (0 | t2._crypto_onetimeauth_verify(s2, c2, o2, 0, h2)) == 0;
            return v(_2), y2;
          }
          function lr(e3, r3, a2, _2, s2, n2, c2) {
            var o2 = [];
            i(c2), f(o2, e3, "keyLength"), (typeof e3 != "number" || (0 | e3) !== e3 || e3 < 0) && b(o2, "keyLength must be an unsigned integer");
            var h2 = u(r3 = m(o2, r3, "password")), y2 = r3.length;
            o2.push(h2), a2 = m(o2, a2, "salt");
            var d2, E2 = 0 | t2._crypto_pwhash_saltbytes();
            a2.length !== E2 && b(o2, "invalid salt length"), d2 = u(a2), o2.push(d2), f(o2, _2, "opsLimit"), (typeof _2 != "number" || (0 | _2) !== _2 || _2 < 0) && b(o2, "opsLimit must be an unsigned integer"), f(o2, s2, "memLimit"), (typeof s2 != "number" || (0 | s2) !== s2 || s2 < 0) && b(o2, "memLimit must be an unsigned integer"), f(o2, n2, "algorithm"), (typeof n2 != "number" || (0 | n2) !== n2 || n2 < 0) && b(o2, "algorithm must be an unsigned integer");
            var x2 = new l(0 | e3), k2 = x2.address;
            if (o2.push(k2), (0 | t2._crypto_pwhash(k2, e3, 0, h2, y2, 0, d2, _2, 0, s2, n2)) == 0) {
              var S2 = p(x2, c2);
              return v(o2), S2;
            }
            g(o2, "invalid usage");
          }
          function ur(e3, r3, a2, _2, s2, n2) {
            var c2 = [];
            i(n2), f(c2, e3, "keyLength"), (typeof e3 != "number" || (0 | e3) !== e3 || e3 < 0) && b(c2, "keyLength must be an unsigned integer");
            var o2 = u(r3 = m(c2, r3, "password")), h2 = r3.length;
            c2.push(o2), a2 = m(c2, a2, "salt");
            var y2, d2 = 0 | t2._crypto_pwhash_scryptsalsa208sha256_saltbytes();
            a2.length !== d2 && b(c2, "invalid salt length"), y2 = u(a2), c2.push(y2), f(c2, _2, "opsLimit"), (typeof _2 != "number" || (0 | _2) !== _2 || _2 < 0) && b(c2, "opsLimit must be an unsigned integer"), f(c2, s2, "memLimit"), (typeof s2 != "number" || (0 | s2) !== s2 || s2 < 0) && b(c2, "memLimit must be an unsigned integer");
            var E2 = new l(0 | e3), x2 = E2.address;
            if (c2.push(x2), (0 | t2._crypto_pwhash_scryptsalsa208sha256(x2, e3, 0, o2, h2, 0, y2, _2, 0, s2)) == 0) {
              var k2 = p(E2, n2);
              return v(c2), k2;
            }
            g(c2, "invalid usage");
          }
          function dr(e3, r3, a2, _2, s2, n2, c2) {
            var o2 = [];
            i(c2);
            var h2 = u(e3 = m(o2, e3, "password")), y2 = e3.length;
            o2.push(h2);
            var d2 = u(r3 = m(o2, r3, "salt")), E2 = r3.length;
            o2.push(d2), f(o2, a2, "opsLimit"), (typeof a2 != "number" || (0 | a2) !== a2 || a2 < 0) && b(o2, "opsLimit must be an unsigned integer"), f(o2, _2, "r"), (typeof _2 != "number" || (0 | _2) !== _2 || _2 < 0) && b(o2, "r must be an unsigned integer"), f(o2, s2, "p"), (typeof s2 != "number" || (0 | s2) !== s2 || s2 < 0) && b(o2, "p must be an unsigned integer"), f(o2, n2, "keyLength"), (typeof n2 != "number" || (0 | n2) !== n2 || n2 < 0) && b(o2, "keyLength must be an unsigned integer");
            var x2 = new l(0 | n2), k2 = x2.address;
            if (o2.push(k2), (0 | t2._crypto_pwhash_scryptsalsa208sha256_ll(h2, y2, d2, E2, a2, 0, _2, s2, k2, n2)) == 0) {
              var S2 = p(x2, c2);
              return v(o2), S2;
            }
            g(o2, "invalid usage");
          }
          function vr(e3, r3, a2, _2) {
            var s2 = [];
            i(_2);
            var n2 = u(e3 = m(s2, e3, "password")), c2 = e3.length;
            s2.push(n2), f(s2, r3, "opsLimit"), (typeof r3 != "number" || (0 | r3) !== r3 || r3 < 0) && b(s2, "opsLimit must be an unsigned integer"), f(s2, a2, "memLimit"), (typeof a2 != "number" || (0 | a2) !== a2 || a2 < 0) && b(s2, "memLimit must be an unsigned integer");
            var o2 = new l(0 | t2._crypto_pwhash_scryptsalsa208sha256_strbytes()).address;
            if (s2.push(o2), (0 | t2._crypto_pwhash_scryptsalsa208sha256_str(o2, n2, c2, 0, r3, 0, a2)) == 0) {
              var h2 = t2.UTF8ToString(o2);
              return v(s2), h2;
            }
            g(s2, "invalid usage");
          }
          function gr(e3, r3, a2) {
            var s2 = [];
            i(a2), typeof e3 != "string" && b(s2, "hashed_password must be a string"), e3 = _(e3 + "\0"), c2 != null && e3.length - 1 !== c2 && b(s2, "invalid hashed_password length");
            var n2 = u(e3), c2 = e3.length - 1;
            s2.push(n2);
            var o2 = u(r3 = m(s2, r3, "password")), h2 = r3.length;
            s2.push(o2);
            var p2 = (0 | t2._crypto_pwhash_scryptsalsa208sha256_str_verify(n2, o2, h2, 0)) == 0;
            return v(s2), p2;
          }
          function br(e3, r3, a2, _2) {
            var s2 = [];
            i(_2);
            var n2 = u(e3 = m(s2, e3, "password")), c2 = e3.length;
            s2.push(n2), f(s2, r3, "opsLimit"), (typeof r3 != "number" || (0 | r3) !== r3 || r3 < 0) && b(s2, "opsLimit must be an unsigned integer"), f(s2, a2, "memLimit"), (typeof a2 != "number" || (0 | a2) !== a2 || a2 < 0) && b(s2, "memLimit must be an unsigned integer");
            var o2 = new l(0 | t2._crypto_pwhash_strbytes()).address;
            if (s2.push(o2), (0 | t2._crypto_pwhash_str(o2, n2, c2, 0, r3, 0, a2)) == 0) {
              var h2 = t2.UTF8ToString(o2);
              return v(s2), h2;
            }
            g(s2, "invalid usage");
          }
          function fr(e3, r3, a2, s2) {
            var n2 = [];
            i(s2), typeof e3 != "string" && b(n2, "hashed_password must be a string"), e3 = _(e3 + "\0"), o2 != null && e3.length - 1 !== o2 && b(n2, "invalid hashed_password length");
            var c2 = u(e3), o2 = e3.length - 1;
            n2.push(c2), f(n2, r3, "opsLimit"), (typeof r3 != "number" || (0 | r3) !== r3 || r3 < 0) && b(n2, "opsLimit must be an unsigned integer"), f(n2, a2, "memLimit"), (typeof a2 != "number" || (0 | a2) !== a2 || a2 < 0) && b(n2, "memLimit must be an unsigned integer");
            var h2 = (0 | t2._crypto_pwhash_str_needs_rehash(c2, r3, 0, a2)) != 0;
            return v(n2), h2;
          }
          function mr(e3, r3, a2) {
            var s2 = [];
            i(a2), typeof e3 != "string" && b(s2, "hashed_password must be a string"), e3 = _(e3 + "\0"), c2 != null && e3.length - 1 !== c2 && b(s2, "invalid hashed_password length");
            var n2 = u(e3), c2 = e3.length - 1;
            s2.push(n2);
            var o2 = u(r3 = m(s2, r3, "password")), h2 = r3.length;
            s2.push(o2);
            var p2 = (0 | t2._crypto_pwhash_str_verify(n2, o2, h2, 0)) == 0;
            return v(s2), p2;
          }
          function Er(e3, r3, a2) {
            var _2 = [];
            i(a2), e3 = m(_2, e3, "privateKey");
            var s2, n2 = 0 | t2._crypto_scalarmult_scalarbytes();
            e3.length !== n2 && b(_2, "invalid privateKey length"), s2 = u(e3), _2.push(s2), r3 = m(_2, r3, "publicKey");
            var c2, o2 = 0 | t2._crypto_scalarmult_bytes();
            r3.length !== o2 && b(_2, "invalid publicKey length"), c2 = u(r3), _2.push(c2);
            var h2 = new l(0 | t2._crypto_scalarmult_bytes()), y2 = h2.address;
            if (_2.push(y2), (0 | t2._crypto_scalarmult(y2, s2, c2)) == 0) {
              var d2 = p(h2, a2);
              return v(_2), d2;
            }
            g(_2, "weak public key");
          }
          function xr(e3, r3) {
            var a2 = [];
            i(r3), e3 = m(a2, e3, "privateKey");
            var _2, s2 = 0 | t2._crypto_scalarmult_scalarbytes();
            e3.length !== s2 && b(a2, "invalid privateKey length"), _2 = u(e3), a2.push(_2);
            var n2 = new l(0 | t2._crypto_scalarmult_bytes()), c2 = n2.address;
            if (a2.push(c2), (0 | t2._crypto_scalarmult_base(c2, _2)) == 0) {
              var o2 = p(n2, r3);
              return v(a2), o2;
            }
            g(a2, "unknown error");
          }
          function kr(e3, r3, a2) {
            var _2 = [];
            i(a2), e3 = m(_2, e3, "n");
            var s2, n2 = 0 | t2._crypto_scalarmult_ed25519_scalarbytes();
            e3.length !== n2 && b(_2, "invalid n length"), s2 = u(e3), _2.push(s2), r3 = m(_2, r3, "p");
            var c2, o2 = 0 | t2._crypto_scalarmult_ed25519_bytes();
            r3.length !== o2 && b(_2, "invalid p length"), c2 = u(r3), _2.push(c2);
            var h2 = new l(0 | t2._crypto_scalarmult_ed25519_bytes()), y2 = h2.address;
            if (_2.push(y2), (0 | t2._crypto_scalarmult_ed25519(y2, s2, c2)) == 0) {
              var d2 = p(h2, a2);
              return v(_2), d2;
            }
            g(_2, "invalid point or scalar is 0");
          }
          function Sr(e3, r3) {
            var a2 = [];
            i(r3), e3 = m(a2, e3, "scalar");
            var _2, s2 = 0 | t2._crypto_scalarmult_ed25519_scalarbytes();
            e3.length !== s2 && b(a2, "invalid scalar length"), _2 = u(e3), a2.push(_2);
            var n2 = new l(0 | t2._crypto_scalarmult_ed25519_bytes()), c2 = n2.address;
            if (a2.push(c2), (0 | t2._crypto_scalarmult_ed25519_base(c2, _2)) == 0) {
              var o2 = p(n2, r3);
              return v(a2), o2;
            }
            g(a2, "scalar is 0");
          }
          function Tr(e3, r3) {
            var a2 = [];
            i(r3), e3 = m(a2, e3, "scalar");
            var _2, s2 = 0 | t2._crypto_scalarmult_ed25519_scalarbytes();
            e3.length !== s2 && b(a2, "invalid scalar length"), _2 = u(e3), a2.push(_2);
            var n2 = new l(0 | t2._crypto_scalarmult_ed25519_bytes()), c2 = n2.address;
            if (a2.push(c2), (0 | t2._crypto_scalarmult_ed25519_base_noclamp(c2, _2)) == 0) {
              var o2 = p(n2, r3);
              return v(a2), o2;
            }
            g(a2, "scalar is 0");
          }
          function wr(e3, r3, a2) {
            var _2 = [];
            i(a2), e3 = m(_2, e3, "n");
            var s2, n2 = 0 | t2._crypto_scalarmult_ed25519_scalarbytes();
            e3.length !== n2 && b(_2, "invalid n length"), s2 = u(e3), _2.push(s2), r3 = m(_2, r3, "p");
            var c2, o2 = 0 | t2._crypto_scalarmult_ed25519_bytes();
            r3.length !== o2 && b(_2, "invalid p length"), c2 = u(r3), _2.push(c2);
            var h2 = new l(0 | t2._crypto_scalarmult_ed25519_bytes()), y2 = h2.address;
            if (_2.push(y2), (0 | t2._crypto_scalarmult_ed25519_noclamp(y2, s2, c2)) == 0) {
              var d2 = p(h2, a2);
              return v(_2), d2;
            }
            g(_2, "invalid point or scalar is 0");
          }
          function Yr(e3, r3, a2) {
            var _2 = [];
            i(a2), e3 = m(_2, e3, "scalar");
            var s2, n2 = 0 | t2._crypto_scalarmult_ristretto255_scalarbytes();
            e3.length !== n2 && b(_2, "invalid scalar length"), s2 = u(e3), _2.push(s2), r3 = m(_2, r3, "element");
            var c2, o2 = 0 | t2._crypto_scalarmult_ristretto255_bytes();
            r3.length !== o2 && b(_2, "invalid element length"), c2 = u(r3), _2.push(c2);
            var h2 = new l(0 | t2._crypto_scalarmult_ristretto255_bytes()), y2 = h2.address;
            if (_2.push(y2), (0 | t2._crypto_scalarmult_ristretto255(y2, s2, c2)) == 0) {
              var d2 = p(h2, a2);
              return v(_2), d2;
            }
            g(_2, "result is identity element");
          }
          function Br(e3, r3) {
            var a2 = [];
            i(r3), e3 = m(a2, e3, "scalar");
            var _2, s2 = 0 | t2._crypto_core_ristretto255_scalarbytes();
            e3.length !== s2 && b(a2, "invalid scalar length"), _2 = u(e3), a2.push(_2);
            var n2 = new l(0 | t2._crypto_core_ristretto255_bytes()), c2 = n2.address;
            if (a2.push(c2), (0 | t2._crypto_scalarmult_ristretto255_base(c2, _2)) == 0) {
              var o2 = p(n2, r3);
              return v(a2), o2;
            }
            g(a2, "scalar is 0");
          }
          function Ar(e3, r3, a2, _2) {
            var s2 = [];
            i(_2);
            var n2 = u(e3 = m(s2, e3, "message")), c2 = e3.length;
            s2.push(n2), r3 = m(s2, r3, "nonce");
            var o2, h2 = 0 | t2._crypto_secretbox_noncebytes();
            r3.length !== h2 && b(s2, "invalid nonce length"), o2 = u(r3), s2.push(o2), a2 = m(s2, a2, "key");
            var y2, d2 = 0 | t2._crypto_secretbox_keybytes();
            a2.length !== d2 && b(s2, "invalid key length"), y2 = u(a2), s2.push(y2);
            var f2 = new l(0 | c2), E2 = f2.address;
            s2.push(E2);
            var x2 = new l(0 | t2._crypto_secretbox_macbytes()), k2 = x2.address;
            if (s2.push(k2), (0 | t2._crypto_secretbox_detached(E2, k2, n2, c2, 0, o2, y2)) == 0) {
              var S2 = p({ mac: x2, cipher: f2 }, _2);
              return v(s2), S2;
            }
            g(s2, "invalid usage");
          }
          function Kr(e3, r3, a2, _2) {
            var s2 = [];
            i(_2);
            var n2 = u(e3 = m(s2, e3, "message")), c2 = e3.length;
            s2.push(n2), r3 = m(s2, r3, "nonce");
            var o2, h2 = 0 | t2._crypto_secretbox_noncebytes();
            r3.length !== h2 && b(s2, "invalid nonce length"), o2 = u(r3), s2.push(o2), a2 = m(s2, a2, "key");
            var y2, d2 = 0 | t2._crypto_secretbox_keybytes();
            a2.length !== d2 && b(s2, "invalid key length"), y2 = u(a2), s2.push(y2);
            var f2 = new l(c2 + t2._crypto_secretbox_macbytes() | 0), E2 = f2.address;
            if (s2.push(E2), (0 | t2._crypto_secretbox_easy(E2, n2, c2, 0, o2, y2)) == 0) {
              var x2 = p(f2, _2);
              return v(s2), x2;
            }
            g(s2, "invalid usage");
          }
          function Mr(e3) {
            var r3 = [];
            i(e3);
            var a2 = new l(0 | t2._crypto_secretbox_keybytes()), _2 = a2.address;
            r3.push(_2), t2._crypto_secretbox_keygen(_2);
            var s2 = p(a2, e3);
            return v(r3), s2;
          }
          function Ir(e3, r3, a2, _2, s2) {
            var n2 = [];
            i(s2);
            var c2 = u(e3 = m(n2, e3, "ciphertext")), o2 = e3.length;
            n2.push(c2), r3 = m(n2, r3, "mac");
            var h2, y2 = 0 | t2._crypto_secretbox_macbytes();
            r3.length !== y2 && b(n2, "invalid mac length"), h2 = u(r3), n2.push(h2), a2 = m(n2, a2, "nonce");
            var d2, f2 = 0 | t2._crypto_secretbox_noncebytes();
            a2.length !== f2 && b(n2, "invalid nonce length"), d2 = u(a2), n2.push(d2), _2 = m(n2, _2, "key");
            var E2, x2 = 0 | t2._crypto_secretbox_keybytes();
            _2.length !== x2 && b(n2, "invalid key length"), E2 = u(_2), n2.push(E2);
            var k2 = new l(0 | o2), S2 = k2.address;
            if (n2.push(S2), (0 | t2._crypto_secretbox_open_detached(S2, c2, h2, o2, 0, d2, E2)) == 0) {
              var T2 = p(k2, s2);
              return v(n2), T2;
            }
            g(n2, "wrong secret key for the given ciphertext");
          }
          function Nr(e3, r3, a2, _2) {
            var s2 = [];
            i(_2), e3 = m(s2, e3, "ciphertext");
            var n2, c2 = t2._crypto_secretbox_macbytes(), o2 = e3.length;
            o2 < c2 && b(s2, "ciphertext is too short"), n2 = u(e3), s2.push(n2), r3 = m(s2, r3, "nonce");
            var h2, y2 = 0 | t2._crypto_secretbox_noncebytes();
            r3.length !== y2 && b(s2, "invalid nonce length"), h2 = u(r3), s2.push(h2), a2 = m(s2, a2, "key");
            var d2, f2 = 0 | t2._crypto_secretbox_keybytes();
            a2.length !== f2 && b(s2, "invalid key length"), d2 = u(a2), s2.push(d2);
            var E2 = new l(o2 - t2._crypto_secretbox_macbytes() | 0), x2 = E2.address;
            if (s2.push(x2), (0 | t2._crypto_secretbox_open_easy(x2, n2, o2, 0, h2, d2)) == 0) {
              var k2 = p(E2, _2);
              return v(s2), k2;
            }
            g(s2, "wrong secret key for the given ciphertext");
          }
          function Lr(e3, r3, a2) {
            var _2 = [];
            i(a2), e3 = m(_2, e3, "header");
            var s2, n2 = 0 | t2._crypto_secretstream_xchacha20poly1305_headerbytes();
            e3.length !== n2 && b(_2, "invalid header length"), s2 = u(e3), _2.push(s2), r3 = m(_2, r3, "key");
            var c2, o2 = 0 | t2._crypto_secretstream_xchacha20poly1305_keybytes();
            r3.length !== o2 && b(_2, "invalid key length"), c2 = u(r3), _2.push(c2);
            var h2 = new l(52).address;
            if ((0 | t2._crypto_secretstream_xchacha20poly1305_init_pull(h2, s2, c2)) == 0) {
              var p2 = h2;
              return v(_2), p2;
            }
            g(_2, "invalid usage");
          }
          function Ur(e3, r3) {
            var a2 = [];
            i(r3), e3 = m(a2, e3, "key");
            var _2, s2 = 0 | t2._crypto_secretstream_xchacha20poly1305_keybytes();
            e3.length !== s2 && b(a2, "invalid key length"), _2 = u(e3), a2.push(_2);
            var n2 = new l(52).address, c2 = new l(0 | t2._crypto_secretstream_xchacha20poly1305_headerbytes()), o2 = c2.address;
            if (a2.push(o2), (0 | t2._crypto_secretstream_xchacha20poly1305_init_push(n2, o2, _2)) == 0) {
              var h2 = { state: n2, header: p(c2, r3) };
              return v(a2), h2;
            }
            g(a2, "invalid usage");
          }
          function Or(e3) {
            var r3 = [];
            i(e3);
            var a2 = new l(0 | t2._crypto_secretstream_xchacha20poly1305_keybytes()), _2 = a2.address;
            r3.push(_2), t2._crypto_secretstream_xchacha20poly1305_keygen(_2);
            var s2 = p(a2, e3);
            return v(r3), s2;
          }
          function Cr(e3, r3, a2, _2) {
            var s2 = [];
            i(_2), f(s2, e3, "state_address"), r3 = m(s2, r3, "cipher");
            var n2, c2 = t2._crypto_secretstream_xchacha20poly1305_abytes(), o2 = r3.length;
            o2 < c2 && b(s2, "cipher is too short"), n2 = u(r3), s2.push(n2);
            var h2 = null, y2 = 0;
            a2 != null && (h2 = u(a2 = m(s2, a2, "ad")), y2 = a2.length, s2.push(h2));
            var g2 = new l(o2 - t2._crypto_secretstream_xchacha20poly1305_abytes() | 0), E2 = g2.address;
            s2.push(E2);
            var x2, k2 = (x2 = d(1), s2.push(x2), (k2 = t2._crypto_secretstream_xchacha20poly1305_pull(e3, E2, 0, x2, n2, o2, 0, h2, y2) === 0 && { tag: t2.HEAPU8[x2], message: g2 }) && { message: p(k2.message, _2), tag: k2.tag });
            return v(s2), k2;
          }
          function Rr(e3, r3, a2, _2, s2) {
            var n2 = [];
            i(s2), f(n2, e3, "state_address");
            var c2 = u(r3 = m(n2, r3, "message_chunk")), o2 = r3.length;
            n2.push(c2);
            var h2 = null, y2 = 0;
            a2 != null && (h2 = u(a2 = m(n2, a2, "ad")), y2 = a2.length, n2.push(h2)), f(n2, _2, "tag"), (typeof _2 != "number" || (0 | _2) !== _2 || _2 < 0) && b(n2, "tag must be an unsigned integer");
            var d2 = new l(o2 + t2._crypto_secretstream_xchacha20poly1305_abytes() | 0), E2 = d2.address;
            if (n2.push(E2), (0 | t2._crypto_secretstream_xchacha20poly1305_push(e3, E2, 0, c2, o2, 0, h2, y2, 0, _2)) == 0) {
              var x2 = p(d2, s2);
              return v(n2), x2;
            }
            g(n2, "invalid usage");
          }
          function Pr(e3, r3) {
            var a2 = [];
            return i(r3), f(a2, e3, "state_address"), t2._crypto_secretstream_xchacha20poly1305_rekey(e3), v(a2), true;
          }
          function Gr(e3, r3, a2) {
            var _2 = [];
            i(a2);
            var s2 = u(e3 = m(_2, e3, "message")), n2 = e3.length;
            _2.push(s2), r3 = m(_2, r3, "key");
            var c2, o2 = 0 | t2._crypto_shorthash_keybytes();
            r3.length !== o2 && b(_2, "invalid key length"), c2 = u(r3), _2.push(c2);
            var h2 = new l(0 | t2._crypto_shorthash_bytes()), y2 = h2.address;
            if (_2.push(y2), (0 | t2._crypto_shorthash(y2, s2, n2, 0, c2)) == 0) {
              var d2 = p(h2, a2);
              return v(_2), d2;
            }
            g(_2, "invalid usage");
          }
          function Xr(e3) {
            var r3 = [];
            i(e3);
            var a2 = new l(0 | t2._crypto_shorthash_keybytes()), _2 = a2.address;
            r3.push(_2), t2._crypto_shorthash_keygen(_2);
            var s2 = p(a2, e3);
            return v(r3), s2;
          }
          function Dr(e3, r3, a2) {
            var _2 = [];
            i(a2);
            var s2 = u(e3 = m(_2, e3, "message")), n2 = e3.length;
            _2.push(s2), r3 = m(_2, r3, "key");
            var c2, o2 = 0 | t2._crypto_shorthash_siphashx24_keybytes();
            r3.length !== o2 && b(_2, "invalid key length"), c2 = u(r3), _2.push(c2);
            var h2 = new l(0 | t2._crypto_shorthash_siphashx24_bytes()), y2 = h2.address;
            if (_2.push(y2), (0 | t2._crypto_shorthash_siphashx24(y2, s2, n2, 0, c2)) == 0) {
              var d2 = p(h2, a2);
              return v(_2), d2;
            }
            g(_2, "invalid usage");
          }
          function Fr(e3, r3, a2) {
            var _2 = [];
            i(a2);
            var s2 = u(e3 = m(_2, e3, "message")), n2 = e3.length;
            _2.push(s2), r3 = m(_2, r3, "privateKey");
            var c2, o2 = 0 | t2._crypto_sign_secretkeybytes();
            r3.length !== o2 && b(_2, "invalid privateKey length"), c2 = u(r3), _2.push(c2);
            var h2 = new l(e3.length + t2._crypto_sign_bytes() | 0), y2 = h2.address;
            if (_2.push(y2), (0 | t2._crypto_sign(y2, null, s2, n2, 0, c2)) == 0) {
              var d2 = p(h2, a2);
              return v(_2), d2;
            }
            g(_2, "invalid usage");
          }
          function Vr(e3, r3, a2) {
            var _2 = [];
            i(a2);
            var s2 = u(e3 = m(_2, e3, "message")), n2 = e3.length;
            _2.push(s2), r3 = m(_2, r3, "privateKey");
            var c2, o2 = 0 | t2._crypto_sign_secretkeybytes();
            r3.length !== o2 && b(_2, "invalid privateKey length"), c2 = u(r3), _2.push(c2);
            var h2 = new l(0 | t2._crypto_sign_bytes()), y2 = h2.address;
            if (_2.push(y2), (0 | t2._crypto_sign_detached(y2, null, s2, n2, 0, c2)) == 0) {
              var d2 = p(h2, a2);
              return v(_2), d2;
            }
            g(_2, "invalid usage");
          }
          function Hr(e3, r3) {
            var a2 = [];
            i(r3), e3 = m(a2, e3, "edPk");
            var _2, s2 = 0 | t2._crypto_sign_publickeybytes();
            e3.length !== s2 && b(a2, "invalid edPk length"), _2 = u(e3), a2.push(_2);
            var n2 = new l(0 | t2._crypto_scalarmult_scalarbytes()), c2 = n2.address;
            if (a2.push(c2), (0 | t2._crypto_sign_ed25519_pk_to_curve25519(c2, _2)) == 0) {
              var o2 = p(n2, r3);
              return v(a2), o2;
            }
            g(a2, "invalid key");
          }
          function qr(e3, r3) {
            var a2 = [];
            i(r3), e3 = m(a2, e3, "edSk");
            var _2, s2 = 0 | t2._crypto_sign_secretkeybytes();
            e3.length !== s2 && b(a2, "invalid edSk length"), _2 = u(e3), a2.push(_2);
            var n2 = new l(0 | t2._crypto_scalarmult_scalarbytes()), c2 = n2.address;
            if (a2.push(c2), (0 | t2._crypto_sign_ed25519_sk_to_curve25519(c2, _2)) == 0) {
              var o2 = p(n2, r3);
              return v(a2), o2;
            }
            g(a2, "invalid key");
          }
          function jr(e3, r3) {
            var a2 = [];
            i(r3), e3 = m(a2, e3, "privateKey");
            var _2, s2 = 0 | t2._crypto_sign_secretkeybytes();
            e3.length !== s2 && b(a2, "invalid privateKey length"), _2 = u(e3), a2.push(_2);
            var n2 = new l(0 | t2._crypto_sign_publickeybytes()), c2 = n2.address;
            if (a2.push(c2), (0 | t2._crypto_sign_ed25519_sk_to_pk(c2, _2)) == 0) {
              var o2 = p(n2, r3);
              return v(a2), o2;
            }
            g(a2, "invalid key");
          }
          function zr(e3, r3) {
            var a2 = [];
            i(r3), e3 = m(a2, e3, "privateKey");
            var _2, s2 = 0 | t2._crypto_sign_secretkeybytes();
            e3.length !== s2 && b(a2, "invalid privateKey length"), _2 = u(e3), a2.push(_2);
            var n2 = new l(0 | t2._crypto_sign_seedbytes()), c2 = n2.address;
            if (a2.push(c2), (0 | t2._crypto_sign_ed25519_sk_to_seed(c2, _2)) == 0) {
              var o2 = p(n2, r3);
              return v(a2), o2;
            }
            g(a2, "invalid key");
          }
          function Wr(e3, r3, a2) {
            var _2 = [];
            i(a2), f(_2, e3, "state_address"), r3 = m(_2, r3, "privateKey");
            var s2, n2 = 0 | t2._crypto_sign_secretkeybytes();
            r3.length !== n2 && b(_2, "invalid privateKey length"), s2 = u(r3), _2.push(s2);
            var c2 = new l(0 | t2._crypto_sign_bytes()), o2 = c2.address;
            if (_2.push(o2), (0 | t2._crypto_sign_final_create(e3, o2, null, s2)) == 0) {
              var h2 = (t2._free(e3), p(c2, a2));
              return v(_2), h2;
            }
            g(_2, "invalid usage");
          }
          function Jr(e3, r3, a2, _2) {
            var s2 = [];
            i(_2), f(s2, e3, "state_address"), r3 = m(s2, r3, "signature");
            var n2, c2 = 0 | t2._crypto_sign_bytes();
            r3.length !== c2 && b(s2, "invalid signature length"), n2 = u(r3), s2.push(n2), a2 = m(s2, a2, "publicKey");
            var o2, h2 = 0 | t2._crypto_sign_publickeybytes();
            a2.length !== h2 && b(s2, "invalid publicKey length"), o2 = u(a2), s2.push(o2);
            var p2 = (0 | t2._crypto_sign_final_verify(e3, n2, o2)) == 0;
            return v(s2), p2;
          }
          function Qr(e3) {
            var r3 = [];
            i(e3);
            var a2 = new l(208).address;
            if ((0 | t2._crypto_sign_init(a2)) == 0) {
              var _2 = a2;
              return v(r3), _2;
            }
            g(r3, "internal error");
          }
          function Zr(e3) {
            var r3 = [];
            i(e3);
            var a2 = new l(0 | t2._crypto_sign_publickeybytes()), _2 = a2.address;
            r3.push(_2);
            var s2 = new l(0 | t2._crypto_sign_secretkeybytes()), n2 = s2.address;
            if (r3.push(n2), (0 | t2._crypto_sign_keypair(_2, n2)) == 0) {
              var c2 = { publicKey: p(a2, e3), privateKey: p(s2, e3), keyType: "ed25519" };
              return v(r3), c2;
            }
            g(r3, "internal error");
          }
          function $r(e3, r3, a2) {
            var _2 = [];
            i(a2), e3 = m(_2, e3, "signedMessage");
            var s2, n2 = t2._crypto_sign_bytes(), c2 = e3.length;
            c2 < n2 && b(_2, "signedMessage is too short"), s2 = u(e3), _2.push(s2), r3 = m(_2, r3, "publicKey");
            var o2, h2 = 0 | t2._crypto_sign_publickeybytes();
            r3.length !== h2 && b(_2, "invalid publicKey length"), o2 = u(r3), _2.push(o2);
            var y2 = new l(c2 - t2._crypto_sign_bytes() | 0), d2 = y2.address;
            if (_2.push(d2), (0 | t2._crypto_sign_open(d2, null, s2, c2, 0, o2)) == 0) {
              var f2 = p(y2, a2);
              return v(_2), f2;
            }
            g(_2, "incorrect signature for the given public key");
          }
          function et(e3, r3) {
            var a2 = [];
            i(r3), e3 = m(a2, e3, "seed");
            var _2, s2 = 0 | t2._crypto_sign_seedbytes();
            e3.length !== s2 && b(a2, "invalid seed length"), _2 = u(e3), a2.push(_2);
            var n2 = new l(0 | t2._crypto_sign_publickeybytes()), c2 = n2.address;
            a2.push(c2);
            var o2 = new l(0 | t2._crypto_sign_secretkeybytes()), h2 = o2.address;
            if (a2.push(h2), (0 | t2._crypto_sign_seed_keypair(c2, h2, _2)) == 0) {
              var y2 = { publicKey: p(n2, r3), privateKey: p(o2, r3), keyType: "ed25519" };
              return v(a2), y2;
            }
            g(a2, "invalid usage");
          }
          function rt(e3, r3, a2) {
            var _2 = [];
            i(a2), f(_2, e3, "state_address");
            var s2 = u(r3 = m(_2, r3, "message_chunk")), n2 = r3.length;
            _2.push(s2), (0 | t2._crypto_sign_update(e3, s2, n2, 0)) != 0 && g(_2, "invalid usage"), v(_2);
          }
          function tt(e3, r3, a2) {
            var _2 = [];
            e3 = m(_2, e3, "signature");
            var s2, n2 = 0 | t2._crypto_sign_bytes();
            e3.length !== n2 && b(_2, "invalid signature length"), s2 = u(e3), _2.push(s2);
            var c2 = u(r3 = m(_2, r3, "message")), o2 = r3.length;
            _2.push(c2), a2 = m(_2, a2, "publicKey");
            var h2, p2 = 0 | t2._crypto_sign_publickeybytes();
            a2.length !== p2 && b(_2, "invalid publicKey length"), h2 = u(a2), _2.push(h2);
            var y2 = (0 | t2._crypto_sign_verify_detached(s2, c2, o2, 0, h2)) == 0;
            return v(_2), y2;
          }
          function at(e3, r3, a2, _2) {
            var s2 = [];
            i(_2), f(s2, e3, "outLength"), (typeof e3 != "number" || (0 | e3) !== e3 || e3 < 0) && b(s2, "outLength must be an unsigned integer"), r3 = m(s2, r3, "key");
            var n2, c2 = 0 | t2._crypto_stream_chacha20_keybytes();
            r3.length !== c2 && b(s2, "invalid key length"), n2 = u(r3), s2.push(n2), a2 = m(s2, a2, "nonce");
            var o2, h2 = 0 | t2._crypto_stream_chacha20_noncebytes();
            a2.length !== h2 && b(s2, "invalid nonce length"), o2 = u(a2), s2.push(o2);
            var y2 = new l(0 | e3), d2 = y2.address;
            s2.push(d2), t2._crypto_stream_chacha20(d2, e3, 0, o2, n2);
            var g2 = p(y2, _2);
            return v(s2), g2;
          }
          function _t(e3, r3, a2, _2) {
            var s2 = [];
            i(_2);
            var n2 = u(e3 = m(s2, e3, "input_message")), c2 = e3.length;
            s2.push(n2), r3 = m(s2, r3, "nonce");
            var o2, h2 = 0 | t2._crypto_stream_chacha20_ietf_noncebytes();
            r3.length !== h2 && b(s2, "invalid nonce length"), o2 = u(r3), s2.push(o2), a2 = m(s2, a2, "key");
            var y2, d2 = 0 | t2._crypto_stream_chacha20_ietf_keybytes();
            a2.length !== d2 && b(s2, "invalid key length"), y2 = u(a2), s2.push(y2);
            var f2 = new l(0 | c2), E2 = f2.address;
            if (s2.push(E2), t2._crypto_stream_chacha20_ietf_xor(E2, n2, c2, 0, o2, y2) === 0) {
              var x2 = p(f2, _2);
              return v(s2), x2;
            }
            g(s2, "invalid usage");
          }
          function st(e3, r3, a2, _2, s2) {
            var n2 = [];
            i(s2);
            var c2 = u(e3 = m(n2, e3, "input_message")), o2 = e3.length;
            n2.push(c2), r3 = m(n2, r3, "nonce");
            var h2, y2 = 0 | t2._crypto_stream_chacha20_ietf_noncebytes();
            r3.length !== y2 && b(n2, "invalid nonce length"), h2 = u(r3), n2.push(h2), f(n2, a2, "nonce_increment"), (typeof a2 != "number" || (0 | a2) !== a2 || a2 < 0) && b(n2, "nonce_increment must be an unsigned integer"), _2 = m(n2, _2, "key");
            var d2, E2 = 0 | t2._crypto_stream_chacha20_ietf_keybytes();
            _2.length !== E2 && b(n2, "invalid key length"), d2 = u(_2), n2.push(d2);
            var x2 = new l(0 | o2), k2 = x2.address;
            if (n2.push(k2), t2._crypto_stream_chacha20_ietf_xor_ic(k2, c2, o2, 0, h2, a2, d2) === 0) {
              var S2 = p(x2, s2);
              return v(n2), S2;
            }
            g(n2, "invalid usage");
          }
          function nt(e3) {
            var r3 = [];
            i(e3);
            var a2 = new l(0 | t2._crypto_stream_chacha20_keybytes()), _2 = a2.address;
            r3.push(_2), t2._crypto_stream_chacha20_keygen(_2);
            var s2 = p(a2, e3);
            return v(r3), s2;
          }
          function ct(e3, r3, a2, _2) {
            var s2 = [];
            i(_2);
            var n2 = u(e3 = m(s2, e3, "input_message")), c2 = e3.length;
            s2.push(n2), r3 = m(s2, r3, "nonce");
            var o2, h2 = 0 | t2._crypto_stream_chacha20_noncebytes();
            r3.length !== h2 && b(s2, "invalid nonce length"), o2 = u(r3), s2.push(o2), a2 = m(s2, a2, "key");
            var y2, d2 = 0 | t2._crypto_stream_chacha20_keybytes();
            a2.length !== d2 && b(s2, "invalid key length"), y2 = u(a2), s2.push(y2);
            var f2 = new l(0 | c2), E2 = f2.address;
            if (s2.push(E2), t2._crypto_stream_chacha20_xor(E2, n2, c2, 0, o2, y2) === 0) {
              var x2 = p(f2, _2);
              return v(s2), x2;
            }
            g(s2, "invalid usage");
          }
          function ot(e3, r3, a2, _2, s2) {
            var n2 = [];
            i(s2);
            var c2 = u(e3 = m(n2, e3, "input_message")), o2 = e3.length;
            n2.push(c2), r3 = m(n2, r3, "nonce");
            var h2, y2 = 0 | t2._crypto_stream_chacha20_noncebytes();
            r3.length !== y2 && b(n2, "invalid nonce length"), h2 = u(r3), n2.push(h2), f(n2, a2, "nonce_increment"), (typeof a2 != "number" || (0 | a2) !== a2 || a2 < 0) && b(n2, "nonce_increment must be an unsigned integer"), _2 = m(n2, _2, "key");
            var d2, E2 = 0 | t2._crypto_stream_chacha20_keybytes();
            _2.length !== E2 && b(n2, "invalid key length"), d2 = u(_2), n2.push(d2);
            var x2 = new l(0 | o2), k2 = x2.address;
            if (n2.push(k2), t2._crypto_stream_chacha20_xor_ic(k2, c2, o2, 0, h2, a2, 0, d2) === 0) {
              var S2 = p(x2, s2);
              return v(n2), S2;
            }
            g(n2, "invalid usage");
          }
          function ht(e3) {
            var r3 = [];
            i(e3);
            var a2 = new l(0 | t2._crypto_stream_keybytes()), _2 = a2.address;
            r3.push(_2), t2._crypto_stream_keygen(_2);
            var s2 = p(a2, e3);
            return v(r3), s2;
          }
          function pt(e3) {
            var r3 = [];
            i(e3);
            var a2 = new l(0 | t2._crypto_stream_xchacha20_keybytes()), _2 = a2.address;
            r3.push(_2), t2._crypto_stream_xchacha20_keygen(_2);
            var s2 = p(a2, e3);
            return v(r3), s2;
          }
          function yt(e3, r3, a2, _2) {
            var s2 = [];
            i(_2);
            var n2 = u(e3 = m(s2, e3, "input_message")), c2 = e3.length;
            s2.push(n2), r3 = m(s2, r3, "nonce");
            var o2, h2 = 0 | t2._crypto_stream_xchacha20_noncebytes();
            r3.length !== h2 && b(s2, "invalid nonce length"), o2 = u(r3), s2.push(o2), a2 = m(s2, a2, "key");
            var y2, d2 = 0 | t2._crypto_stream_xchacha20_keybytes();
            a2.length !== d2 && b(s2, "invalid key length"), y2 = u(a2), s2.push(y2);
            var f2 = new l(0 | c2), E2 = f2.address;
            if (s2.push(E2), t2._crypto_stream_xchacha20_xor(E2, n2, c2, 0, o2, y2) === 0) {
              var x2 = p(f2, _2);
              return v(s2), x2;
            }
            g(s2, "invalid usage");
          }
          function it(e3, r3, a2, _2, s2) {
            var n2 = [];
            i(s2);
            var c2 = u(e3 = m(n2, e3, "input_message")), o2 = e3.length;
            n2.push(c2), r3 = m(n2, r3, "nonce");
            var h2, y2 = 0 | t2._crypto_stream_xchacha20_noncebytes();
            r3.length !== y2 && b(n2, "invalid nonce length"), h2 = u(r3), n2.push(h2), f(n2, a2, "nonce_increment"), (typeof a2 != "number" || (0 | a2) !== a2 || a2 < 0) && b(n2, "nonce_increment must be an unsigned integer"), _2 = m(n2, _2, "key");
            var d2, E2 = 0 | t2._crypto_stream_xchacha20_keybytes();
            _2.length !== E2 && b(n2, "invalid key length"), d2 = u(_2), n2.push(d2);
            var x2 = new l(0 | o2), k2 = x2.address;
            if (n2.push(k2), t2._crypto_stream_xchacha20_xor_ic(k2, c2, o2, 0, h2, a2, 0, d2) === 0) {
              var S2 = p(x2, s2);
              return v(n2), S2;
            }
            g(n2, "invalid usage");
          }
          function lt(e3, r3) {
            var a2 = [];
            i(r3), f(a2, e3, "length"), (typeof e3 != "number" || (0 | e3) !== e3 || e3 < 0) && b(a2, "length must be an unsigned integer");
            var _2 = new l(0 | e3), s2 = _2.address;
            a2.push(s2), t2._randombytes_buf(s2, e3);
            var n2 = p(_2, r3);
            return v(a2), n2;
          }
          function ut(e3, r3, a2) {
            var _2 = [];
            i(a2), f(_2, e3, "length"), (typeof e3 != "number" || (0 | e3) !== e3 || e3 < 0) && b(_2, "length must be an unsigned integer"), r3 = m(_2, r3, "seed");
            var s2, n2 = 0 | t2._randombytes_seedbytes();
            r3.length !== n2 && b(_2, "invalid seed length"), s2 = u(r3), _2.push(s2);
            var c2 = new l(0 | e3), o2 = c2.address;
            _2.push(o2), t2._randombytes_buf_deterministic(o2, e3, s2);
            var h2 = p(c2, a2);
            return v(_2), h2;
          }
          function dt(e3) {
            i(e3), t2._randombytes_close();
          }
          function vt(e3) {
            i(e3);
            var r3 = t2._randombytes_random() >>> 0;
            return v([]), r3;
          }
          function gt(e3, r3) {
            var a2 = [];
            i(r3);
            for (var _2 = t2._malloc(24), s2 = 0; s2 < 6; s2++)
              t2.setValue(_2 + 4 * s2, t2.Runtime.addFunction(e3[["implementation_name", "random", "stir", "uniform", "buf", "close"][s2]]), "i32");
            (0 | t2._randombytes_set_implementation(_2)) != 0 && g(a2, "unsupported implementation"), v(a2);
          }
          function bt(e3) {
            i(e3), t2._randombytes_stir();
          }
          function ft(e3, r3) {
            var a2 = [];
            i(r3), f(a2, e3, "upper_bound"), (typeof e3 != "number" || (0 | e3) !== e3 || e3 < 0) && b(a2, "upper_bound must be an unsigned integer");
            var _2 = t2._randombytes_uniform(e3) >>> 0;
            return v(a2), _2;
          }
          function mt() {
            var e3 = t2._sodium_version_string(), r3 = t2.UTF8ToString(e3);
            return v([]), r3;
          }
          return l.prototype.to_Uint8Array = function() {
            var e3 = new Uint8Array(this.length);
            return e3.set(t2.HEAPU8.subarray(this.address, this.address + this.length)), e3;
          }, e2.add = function(e3, r3) {
            if (!(e3 instanceof Uint8Array && r3 instanceof Uint8Array))
              throw new TypeError("Only Uint8Array instances can added");
            var t3 = e3.length, a2 = 0, _2 = 0;
            if (r3.length != e3.length)
              throw new TypeError("Arguments must have the same length");
            for (_2 = 0; _2 < t3; _2++)
              a2 >>= 8, a2 += e3[_2] + r3[_2], e3[_2] = 255 & a2;
          }, e2.base64_variants = c, e2.compare = function(e3, r3) {
            if (!(e3 instanceof Uint8Array && r3 instanceof Uint8Array))
              throw new TypeError("Only Uint8Array instances can be compared");
            if (e3.length !== r3.length)
              throw new TypeError("Only instances of identical length can be compared");
            for (var t3 = 0, a2 = 1, _2 = e3.length; _2-- > 0; )
              t3 |= r3[_2] - e3[_2] >> 8 & a2, a2 &= (r3[_2] ^ e3[_2]) - 1 >> 8;
            return t3 + t3 + a2 - 1;
          }, e2.from_base64 = function(e3, r3) {
            r3 = o(r3);
            var a2, _2 = [], s2 = new l(3 * (e3 = m(_2, e3, "input")).length / 4), n2 = u(e3), c2 = d(4), h2 = d(4);
            return _2.push(n2), _2.push(s2.address), _2.push(s2.result_bin_len_p), _2.push(s2.b64_end_p), t2._sodium_base642bin(s2.address, s2.length, n2, e3.length, 0, c2, h2, r3) !== 0 && g(_2, "invalid input"), t2.getValue(h2, "i32") - n2 !== e3.length && g(_2, "incomplete input"), s2.length = t2.getValue(c2, "i32"), a2 = s2.to_Uint8Array(), v(_2), a2;
          }, e2.from_hex = function(e3) {
            var r3, a2 = [], _2 = new l((e3 = m(a2, e3, "input")).length / 2), s2 = u(e3), n2 = d(4);
            return a2.push(s2), a2.push(_2.address), a2.push(_2.hex_end_p), t2._sodium_hex2bin(_2.address, _2.length, s2, e3.length, 0, 0, n2) !== 0 && g(a2, "invalid input"), t2.getValue(n2, "i32") - s2 !== e3.length && g(a2, "incomplete input"), r3 = _2.to_Uint8Array(), v(a2), r3;
          }, e2.from_string = _, e2.increment = function(e3) {
            if (!(e3 instanceof Uint8Array))
              throw new TypeError("Only Uint8Array instances can be incremented");
            for (var r3 = 256, t3 = 0, a2 = e3.length; t3 < a2; t3++)
              r3 >>= 8, r3 += e3[t3], e3[t3] = 255 & r3;
          }, e2.is_zero = function(e3) {
            if (!(e3 instanceof Uint8Array))
              throw new TypeError("Only Uint8Array instances can be checked");
            for (var r3 = 0, t3 = 0, a2 = e3.length; t3 < a2; t3++)
              r3 |= e3[t3];
            return r3 === 0;
          }, e2.libsodium = r2, e2.memcmp = function(e3, r3) {
            if (!(e3 instanceof Uint8Array && r3 instanceof Uint8Array))
              throw new TypeError("Only Uint8Array instances can be compared");
            if (e3.length !== r3.length)
              throw new TypeError("Only instances of identical length can be compared");
            for (var t3 = 0, a2 = 0, _2 = e3.length; a2 < _2; a2++)
              t3 |= e3[a2] ^ r3[a2];
            return t3 === 0;
          }, e2.memzero = function(e3) {
            if (!(e3 instanceof Uint8Array))
              throw new TypeError("Only Uint8Array instances can be wiped");
            for (var r3 = 0, t3 = e3.length; r3 < t3; r3++)
              e3[r3] = 0;
          }, e2.output_formats = function() {
            return ["uint8array", "text", "hex", "base64"];
          }, e2.pad = function(e3, r3) {
            if (!(e3 instanceof Uint8Array))
              throw new TypeError("buffer must be a Uint8Array");
            if ((r3 |= 0) <= 0)
              throw new Error("block size must be > 0");
            var a2, _2 = [], s2 = d(4), n2 = 1, c2 = 0, o2 = 0 | e3.length, h2 = new l(o2 + r3);
            _2.push(s2), _2.push(h2.address);
            for (var p2 = h2.address, y2 = h2.address + o2 + r3; p2 < y2; p2++)
              t2.HEAPU8[p2] = e3[c2], c2 += n2 = 1 & ~((65535 & ((o2 -= n2) >>> 48 | o2 >>> 32 | o2 >>> 16 | o2)) - 1 >> 16);
            return t2._sodium_pad(s2, h2.address, e3.length, r3, h2.length) !== 0 && g(_2, "internal error"), h2.length = t2.getValue(s2, "i32"), a2 = h2.to_Uint8Array(), v(_2), a2;
          }, e2.unpad = function(e3, r3) {
            if (!(e3 instanceof Uint8Array))
              throw new TypeError("buffer must be a Uint8Array");
            if ((r3 |= 0) <= 0)
              throw new Error("block size must be > 0");
            var a2 = [], _2 = u(e3), s2 = d(4);
            return a2.push(_2), a2.push(s2), t2._sodium_unpad(s2, _2, e3.length, r3) !== 0 && g(a2, "unsupported/invalid padding"), e3 = (e3 = new Uint8Array(e3)).subarray(0, t2.getValue(s2, "i32")), v(a2), e3;
          }, e2.ready = a, e2.symbols = function() {
            return Object.keys(e2).sort();
          }, e2.to_base64 = h, e2.to_hex = n, e2.to_string = s, e2;
        }
        var t = typeof e.sodium == "object" && typeof e.sodium.onload == "function" ? e.sodium.onload : null;
        typeof define == "function" && define.amd ? define(["exports", "libsodium"], r) : typeof exports2 == "object" && typeof exports2.nodeName != "string" ? r(exports2, require_libsodium()) : e.sodium = r(e.commonJsStrict = {}, e.libsodium), t && e.sodium.ready.then(function() {
          t(e.sodium);
        });
      }(exports2);
    }
  });

  // node_modules/@cosmjs/crypto/build/libsodium.js
  var require_libsodium2 = __commonJS({
    "node_modules/@cosmjs/crypto/build/libsodium.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.Xchacha20poly1305Ietf = exports2.xchacha20NonceLength = exports2.Ed25519 = exports2.Ed25519Keypair = exports2.Argon2id = exports2.isArgon2idOptions = void 0;
      var utils_1 = require_build3();
      var libsodium_wrappers_1 = __importDefault(require_libsodium_wrappers());
      function isArgon2idOptions(thing) {
        if (!(0, utils_1.isNonNullObject)(thing))
          return false;
        if (typeof thing.outputLength !== "number")
          return false;
        if (typeof thing.opsLimit !== "number")
          return false;
        if (typeof thing.memLimitKib !== "number")
          return false;
        return true;
      }
      exports2.isArgon2idOptions = isArgon2idOptions;
      var Argon2id = class {
        static async execute(password, salt, options) {
          await libsodium_wrappers_1.default.ready;
          return libsodium_wrappers_1.default.crypto_pwhash(options.outputLength, password, salt, options.opsLimit, options.memLimitKib * 1024, libsodium_wrappers_1.default.crypto_pwhash_ALG_ARGON2ID13);
        }
      };
      exports2.Argon2id = Argon2id;
      var Ed25519Keypair = class {
        constructor(privkey, pubkey) {
          this.privkey = privkey;
          this.pubkey = pubkey;
        }
        static fromLibsodiumPrivkey(libsodiumPrivkey) {
          if (libsodiumPrivkey.length !== 64) {
            throw new Error(`Unexpected key length ${libsodiumPrivkey.length}. Must be 64.`);
          }
          return new Ed25519Keypair(libsodiumPrivkey.slice(0, 32), libsodiumPrivkey.slice(32, 64));
        }
        toLibsodiumPrivkey() {
          return new Uint8Array([...this.privkey, ...this.pubkey]);
        }
      };
      exports2.Ed25519Keypair = Ed25519Keypair;
      var Ed25519 = class {
        static async makeKeypair(seed) {
          await libsodium_wrappers_1.default.ready;
          const keypair = libsodium_wrappers_1.default.crypto_sign_seed_keypair(seed);
          return Ed25519Keypair.fromLibsodiumPrivkey(keypair.privateKey);
        }
        static async createSignature(message, keyPair) {
          await libsodium_wrappers_1.default.ready;
          return libsodium_wrappers_1.default.crypto_sign_detached(message, keyPair.toLibsodiumPrivkey());
        }
        static async verifySignature(signature, message, pubkey) {
          await libsodium_wrappers_1.default.ready;
          return libsodium_wrappers_1.default.crypto_sign_verify_detached(signature, message, pubkey);
        }
      };
      exports2.Ed25519 = Ed25519;
      exports2.xchacha20NonceLength = 24;
      var Xchacha20poly1305Ietf = class {
        static async encrypt(message, key, nonce) {
          await libsodium_wrappers_1.default.ready;
          const additionalData = null;
          return libsodium_wrappers_1.default.crypto_aead_xchacha20poly1305_ietf_encrypt(message, additionalData, null, nonce, key);
        }
        static async decrypt(ciphertext, key, nonce) {
          await libsodium_wrappers_1.default.ready;
          const additionalData = null;
          return libsodium_wrappers_1.default.crypto_aead_xchacha20poly1305_ietf_decrypt(null, ciphertext, additionalData, nonce, key);
        }
      };
      exports2.Xchacha20poly1305Ietf = Xchacha20poly1305Ietf;
    }
  });

  // node_modules/@cosmjs/crypto/build/random.js
  var require_random = __commonJS({
    "node_modules/@cosmjs/crypto/build/random.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.Random = void 0;
      var Random = class {
        static getBytes(count) {
          try {
            const globalObject = typeof window === "object" ? window : self;
            const cryptoApi = typeof globalObject.crypto !== "undefined" ? globalObject.crypto : globalObject.msCrypto;
            const out = new Uint8Array(count);
            cryptoApi.getRandomValues(out);
            return out;
          } catch (_a) {
            try {
              const crypto = require_crypto_browserify();
              return new Uint8Array([...crypto.randomBytes(count)]);
            } catch (_b) {
              throw new Error("No secure random number generator found");
            }
          }
        }
      };
      exports2.Random = Random;
    }
  });

  // node_modules/@noble/hashes/ripemd160.js
  var require_ripemd1602 = __commonJS({
    "node_modules/@noble/hashes/ripemd160.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.ripemd160 = exports2.RIPEMD160 = void 0;
      var _sha2_js_1 = require_sha2();
      var utils_js_1 = require_utils();
      var Rho = new Uint8Array([7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8]);
      var Id = Uint8Array.from({ length: 16 }, (_, i) => i);
      var Pi = Id.map((i) => (9 * i + 5) % 16);
      var idxL = [Id];
      var idxR = [Pi];
      for (let i = 0; i < 4; i++)
        for (let j of [idxL, idxR])
          j.push(j[i].map((k) => Rho[k]));
      var shifts = [
        [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8],
        [12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7],
        [13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9],
        [14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6],
        [15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5]
      ].map((i) => new Uint8Array(i));
      var shiftsL = idxL.map((idx, i) => idx.map((j) => shifts[i][j]));
      var shiftsR = idxR.map((idx, i) => idx.map((j) => shifts[i][j]));
      var Kl = new Uint32Array([0, 1518500249, 1859775393, 2400959708, 2840853838]);
      var Kr = new Uint32Array([1352829926, 1548603684, 1836072691, 2053994217, 0]);
      var rotl = (word, shift) => word << shift | word >>> 32 - shift;
      function f(group, x, y, z) {
        if (group === 0)
          return x ^ y ^ z;
        else if (group === 1)
          return x & y | ~x & z;
        else if (group === 2)
          return (x | ~y) ^ z;
        else if (group === 3)
          return x & z | y & ~z;
        else
          return x ^ (y | ~z);
      }
      var BUF = new Uint32Array(16);
      var RIPEMD160 = class extends _sha2_js_1.SHA2 {
        constructor() {
          super(64, 20, 8, true);
          this.h0 = 1732584193 | 0;
          this.h1 = 4023233417 | 0;
          this.h2 = 2562383102 | 0;
          this.h3 = 271733878 | 0;
          this.h4 = 3285377520 | 0;
        }
        get() {
          const { h0, h1, h2, h3, h4 } = this;
          return [h0, h1, h2, h3, h4];
        }
        set(h0, h1, h2, h3, h4) {
          this.h0 = h0 | 0;
          this.h1 = h1 | 0;
          this.h2 = h2 | 0;
          this.h3 = h3 | 0;
          this.h4 = h4 | 0;
        }
        process(view, offset) {
          for (let i = 0; i < 16; i++, offset += 4)
            BUF[i] = view.getUint32(offset, true);
          let al = this.h0 | 0, ar = al, bl = this.h1 | 0, br = bl, cl = this.h2 | 0, cr = cl, dl = this.h3 | 0, dr = dl, el = this.h4 | 0, er = el;
          for (let group = 0; group < 5; group++) {
            const rGroup = 4 - group;
            const hbl = Kl[group], hbr = Kr[group];
            const rl = idxL[group], rr = idxR[group];
            const sl = shiftsL[group], sr = shiftsR[group];
            for (let i = 0; i < 16; i++) {
              const tl = rotl(al + f(group, bl, cl, dl) + BUF[rl[i]] + hbl, sl[i]) + el | 0;
              al = el, el = dl, dl = rotl(cl, 10) | 0, cl = bl, bl = tl;
            }
            for (let i = 0; i < 16; i++) {
              const tr = rotl(ar + f(rGroup, br, cr, dr) + BUF[rr[i]] + hbr, sr[i]) + er | 0;
              ar = er, er = dr, dr = rotl(cr, 10) | 0, cr = br, br = tr;
            }
          }
          this.set(this.h1 + cl + dr | 0, this.h2 + dl + er | 0, this.h3 + el + ar | 0, this.h4 + al + br | 0, this.h0 + bl + cr | 0);
        }
        roundClean() {
          BUF.fill(0);
        }
        destroy() {
          this.destroyed = true;
          this.buffer.fill(0);
          this.set(0, 0, 0, 0, 0);
        }
      };
      exports2.RIPEMD160 = RIPEMD160;
      exports2.ripemd160 = (0, utils_js_1.wrapConstructor)(() => new RIPEMD160());
    }
  });

  // node_modules/@cosmjs/crypto/build/ripemd.js
  var require_ripemd2 = __commonJS({
    "node_modules/@cosmjs/crypto/build/ripemd.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.ripemd160 = exports2.Ripemd160 = void 0;
      var ripemd160_1 = require_ripemd1602();
      var utils_1 = require_utils6();
      var Ripemd160 = class {
        constructor(firstData) {
          this.blockSize = 512 / 8;
          this.impl = ripemd160_1.ripemd160.create();
          if (firstData) {
            this.update(firstData);
          }
        }
        update(data) {
          this.impl.update((0, utils_1.toRealUint8Array)(data));
          return this;
        }
        digest() {
          return this.impl.digest();
        }
      };
      exports2.Ripemd160 = Ripemd160;
      function ripemd160(data) {
        return new Ripemd160(data).digest();
      }
      exports2.ripemd160 = ripemd160;
    }
  });

  // node_modules/@cosmjs/crypto/node_modules/bn.js/lib/bn.js
  var require_bn5 = __commonJS({
    "node_modules/@cosmjs/crypto/node_modules/bn.js/lib/bn.js"(exports2, module2) {
      (function(module3, exports3) {
        "use strict";
        function assert(val, msg) {
          if (!val)
            throw new Error(msg || "Assertion failed");
        }
        function inherits(ctor, superCtor) {
          ctor.super_ = superCtor;
          var TempCtor = function() {
          };
          TempCtor.prototype = superCtor.prototype;
          ctor.prototype = new TempCtor();
          ctor.prototype.constructor = ctor;
        }
        function BN(number, base, endian) {
          if (BN.isBN(number)) {
            return number;
          }
          this.negative = 0;
          this.words = null;
          this.length = 0;
          this.red = null;
          if (number !== null) {
            if (base === "le" || base === "be") {
              endian = base;
              base = 10;
            }
            this._init(number || 0, base || 10, endian || "be");
          }
        }
        if (typeof module3 === "object") {
          module3.exports = BN;
        } else {
          exports3.BN = BN;
        }
        BN.BN = BN;
        BN.wordSize = 26;
        var Buffer2;
        try {
          if (typeof window !== "undefined" && typeof window.Buffer !== "undefined") {
            Buffer2 = window.Buffer;
          } else {
            Buffer2 = require_buffer().Buffer;
          }
        } catch (e) {
        }
        BN.isBN = function isBN(num) {
          if (num instanceof BN) {
            return true;
          }
          return num !== null && typeof num === "object" && num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);
        };
        BN.max = function max(left, right) {
          if (left.cmp(right) > 0)
            return left;
          return right;
        };
        BN.min = function min(left, right) {
          if (left.cmp(right) < 0)
            return left;
          return right;
        };
        BN.prototype._init = function init(number, base, endian) {
          if (typeof number === "number") {
            return this._initNumber(number, base, endian);
          }
          if (typeof number === "object") {
            return this._initArray(number, base, endian);
          }
          if (base === "hex") {
            base = 16;
          }
          assert(base === (base | 0) && base >= 2 && base <= 36);
          number = number.toString().replace(/\s+/g, "");
          var start2 = 0;
          if (number[0] === "-") {
            start2++;
            this.negative = 1;
          }
          if (start2 < number.length) {
            if (base === 16) {
              this._parseHex(number, start2, endian);
            } else {
              this._parseBase(number, base, start2);
              if (endian === "le") {
                this._initArray(this.toArray(), base, endian);
              }
            }
          }
        };
        BN.prototype._initNumber = function _initNumber(number, base, endian) {
          if (number < 0) {
            this.negative = 1;
            number = -number;
          }
          if (number < 67108864) {
            this.words = [number & 67108863];
            this.length = 1;
          } else if (number < 4503599627370496) {
            this.words = [
              number & 67108863,
              number / 67108864 & 67108863
            ];
            this.length = 2;
          } else {
            assert(number < 9007199254740992);
            this.words = [
              number & 67108863,
              number / 67108864 & 67108863,
              1
            ];
            this.length = 3;
          }
          if (endian !== "le")
            return;
          this._initArray(this.toArray(), base, endian);
        };
        BN.prototype._initArray = function _initArray(number, base, endian) {
          assert(typeof number.length === "number");
          if (number.length <= 0) {
            this.words = [0];
            this.length = 1;
            return this;
          }
          this.length = Math.ceil(number.length / 3);
          this.words = new Array(this.length);
          for (var i = 0; i < this.length; i++) {
            this.words[i] = 0;
          }
          var j, w;
          var off = 0;
          if (endian === "be") {
            for (i = number.length - 1, j = 0; i >= 0; i -= 3) {
              w = number[i] | number[i - 1] << 8 | number[i - 2] << 16;
              this.words[j] |= w << off & 67108863;
              this.words[j + 1] = w >>> 26 - off & 67108863;
              off += 24;
              if (off >= 26) {
                off -= 26;
                j++;
              }
            }
          } else if (endian === "le") {
            for (i = 0, j = 0; i < number.length; i += 3) {
              w = number[i] | number[i + 1] << 8 | number[i + 2] << 16;
              this.words[j] |= w << off & 67108863;
              this.words[j + 1] = w >>> 26 - off & 67108863;
              off += 24;
              if (off >= 26) {
                off -= 26;
                j++;
              }
            }
          }
          return this._strip();
        };
        function parseHex4Bits(string, index) {
          var c = string.charCodeAt(index);
          if (c >= 48 && c <= 57) {
            return c - 48;
          } else if (c >= 65 && c <= 70) {
            return c - 55;
          } else if (c >= 97 && c <= 102) {
            return c - 87;
          } else {
            assert(false, "Invalid character in " + string);
          }
        }
        function parseHexByte(string, lowerBound, index) {
          var r = parseHex4Bits(string, index);
          if (index - 1 >= lowerBound) {
            r |= parseHex4Bits(string, index - 1) << 4;
          }
          return r;
        }
        BN.prototype._parseHex = function _parseHex(number, start2, endian) {
          this.length = Math.ceil((number.length - start2) / 6);
          this.words = new Array(this.length);
          for (var i = 0; i < this.length; i++) {
            this.words[i] = 0;
          }
          var off = 0;
          var j = 0;
          var w;
          if (endian === "be") {
            for (i = number.length - 1; i >= start2; i -= 2) {
              w = parseHexByte(number, start2, i) << off;
              this.words[j] |= w & 67108863;
              if (off >= 18) {
                off -= 18;
                j += 1;
                this.words[j] |= w >>> 26;
              } else {
                off += 8;
              }
            }
          } else {
            var parseLength = number.length - start2;
            for (i = parseLength % 2 === 0 ? start2 + 1 : start2; i < number.length; i += 2) {
              w = parseHexByte(number, start2, i) << off;
              this.words[j] |= w & 67108863;
              if (off >= 18) {
                off -= 18;
                j += 1;
                this.words[j] |= w >>> 26;
              } else {
                off += 8;
              }
            }
          }
          this._strip();
        };
        function parseBase(str, start2, end, mul) {
          var r = 0;
          var b = 0;
          var len = Math.min(str.length, end);
          for (var i = start2; i < len; i++) {
            var c = str.charCodeAt(i) - 48;
            r *= mul;
            if (c >= 49) {
              b = c - 49 + 10;
            } else if (c >= 17) {
              b = c - 17 + 10;
            } else {
              b = c;
            }
            assert(c >= 0 && b < mul, "Invalid character");
            r += b;
          }
          return r;
        }
        BN.prototype._parseBase = function _parseBase(number, base, start2) {
          this.words = [0];
          this.length = 1;
          for (var limbLen = 0, limbPow = 1; limbPow <= 67108863; limbPow *= base) {
            limbLen++;
          }
          limbLen--;
          limbPow = limbPow / base | 0;
          var total = number.length - start2;
          var mod2 = total % limbLen;
          var end = Math.min(total, total - mod2) + start2;
          var word = 0;
          for (var i = start2; i < end; i += limbLen) {
            word = parseBase(number, i, i + limbLen, base);
            this.imuln(limbPow);
            if (this.words[0] + word < 67108864) {
              this.words[0] += word;
            } else {
              this._iaddn(word);
            }
          }
          if (mod2 !== 0) {
            var pow = 1;
            word = parseBase(number, i, number.length, base);
            for (i = 0; i < mod2; i++) {
              pow *= base;
            }
            this.imuln(pow);
            if (this.words[0] + word < 67108864) {
              this.words[0] += word;
            } else {
              this._iaddn(word);
            }
          }
          this._strip();
        };
        BN.prototype.copy = function copy(dest) {
          dest.words = new Array(this.length);
          for (var i = 0; i < this.length; i++) {
            dest.words[i] = this.words[i];
          }
          dest.length = this.length;
          dest.negative = this.negative;
          dest.red = this.red;
        };
        function move(dest, src) {
          dest.words = src.words;
          dest.length = src.length;
          dest.negative = src.negative;
          dest.red = src.red;
        }
        BN.prototype._move = function _move(dest) {
          move(dest, this);
        };
        BN.prototype.clone = function clone() {
          var r = new BN(null);
          this.copy(r);
          return r;
        };
        BN.prototype._expand = function _expand(size) {
          while (this.length < size) {
            this.words[this.length++] = 0;
          }
          return this;
        };
        BN.prototype._strip = function strip() {
          while (this.length > 1 && this.words[this.length - 1] === 0) {
            this.length--;
          }
          return this._normSign();
        };
        BN.prototype._normSign = function _normSign() {
          if (this.length === 1 && this.words[0] === 0) {
            this.negative = 0;
          }
          return this;
        };
        if (typeof Symbol !== "undefined" && typeof Symbol.for === "function") {
          try {
            BN.prototype[Symbol.for("nodejs.util.inspect.custom")] = inspect;
          } catch (e) {
            BN.prototype.inspect = inspect;
          }
        } else {
          BN.prototype.inspect = inspect;
        }
        function inspect() {
          return (this.red ? "<BN-R: " : "<BN: ") + this.toString(16) + ">";
        }
        var zeros = [
          "",
          "0",
          "00",
          "000",
          "0000",
          "00000",
          "000000",
          "0000000",
          "00000000",
          "000000000",
          "0000000000",
          "00000000000",
          "000000000000",
          "0000000000000",
          "00000000000000",
          "000000000000000",
          "0000000000000000",
          "00000000000000000",
          "000000000000000000",
          "0000000000000000000",
          "00000000000000000000",
          "000000000000000000000",
          "0000000000000000000000",
          "00000000000000000000000",
          "000000000000000000000000",
          "0000000000000000000000000"
        ];
        var groupSizes = [
          0,
          0,
          25,
          16,
          12,
          11,
          10,
          9,
          8,
          8,
          7,
          7,
          7,
          7,
          6,
          6,
          6,
          6,
          6,
          6,
          6,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5,
          5
        ];
        var groupBases = [
          0,
          0,
          33554432,
          43046721,
          16777216,
          48828125,
          60466176,
          40353607,
          16777216,
          43046721,
          1e7,
          19487171,
          35831808,
          62748517,
          7529536,
          11390625,
          16777216,
          24137569,
          34012224,
          47045881,
          64e6,
          4084101,
          5153632,
          6436343,
          7962624,
          9765625,
          11881376,
          14348907,
          17210368,
          20511149,
          243e5,
          28629151,
          33554432,
          39135393,
          45435424,
          52521875,
          60466176
        ];
        BN.prototype.toString = function toString(base, padding) {
          base = base || 10;
          padding = padding | 0 || 1;
          var out;
          if (base === 16 || base === "hex") {
            out = "";
            var off = 0;
            var carry = 0;
            for (var i = 0; i < this.length; i++) {
              var w = this.words[i];
              var word = ((w << off | carry) & 16777215).toString(16);
              carry = w >>> 24 - off & 16777215;
              if (carry !== 0 || i !== this.length - 1) {
                out = zeros[6 - word.length] + word + out;
              } else {
                out = word + out;
              }
              off += 2;
              if (off >= 26) {
                off -= 26;
                i--;
              }
            }
            if (carry !== 0) {
              out = carry.toString(16) + out;
            }
            while (out.length % padding !== 0) {
              out = "0" + out;
            }
            if (this.negative !== 0) {
              out = "-" + out;
            }
            return out;
          }
          if (base === (base | 0) && base >= 2 && base <= 36) {
            var groupSize = groupSizes[base];
            var groupBase = groupBases[base];
            out = "";
            var c = this.clone();
            c.negative = 0;
            while (!c.isZero()) {
              var r = c.modrn(groupBase).toString(base);
              c = c.idivn(groupBase);
              if (!c.isZero()) {
                out = zeros[groupSize - r.length] + r + out;
              } else {
                out = r + out;
              }
            }
            if (this.isZero()) {
              out = "0" + out;
            }
            while (out.length % padding !== 0) {
              out = "0" + out;
            }
            if (this.negative !== 0) {
              out = "-" + out;
            }
            return out;
          }
          assert(false, "Base should be between 2 and 36");
        };
        BN.prototype.toNumber = function toNumber() {
          var ret = this.words[0];
          if (this.length === 2) {
            ret += this.words[1] * 67108864;
          } else if (this.length === 3 && this.words[2] === 1) {
            ret += 4503599627370496 + this.words[1] * 67108864;
          } else if (this.length > 2) {
            assert(false, "Number can only safely store up to 53 bits");
          }
          return this.negative !== 0 ? -ret : ret;
        };
        BN.prototype.toJSON = function toJSON() {
          return this.toString(16, 2);
        };
        if (Buffer2) {
          BN.prototype.toBuffer = function toBuffer(endian, length) {
            return this.toArrayLike(Buffer2, endian, length);
          };
        }
        BN.prototype.toArray = function toArray(endian, length) {
          return this.toArrayLike(Array, endian, length);
        };
        var allocate = function allocate2(ArrayType, size) {
          if (ArrayType.allocUnsafe) {
            return ArrayType.allocUnsafe(size);
          }
          return new ArrayType(size);
        };
        BN.prototype.toArrayLike = function toArrayLike(ArrayType, endian, length) {
          this._strip();
          var byteLength = this.byteLength();
          var reqLength = length || Math.max(1, byteLength);
          assert(byteLength <= reqLength, "byte array longer than desired length");
          assert(reqLength > 0, "Requested array length <= 0");
          var res = allocate(ArrayType, reqLength);
          var postfix = endian === "le" ? "LE" : "BE";
          this["_toArrayLike" + postfix](res, byteLength);
          return res;
        };
        BN.prototype._toArrayLikeLE = function _toArrayLikeLE(res, byteLength) {
          var position = 0;
          var carry = 0;
          for (var i = 0, shift = 0; i < this.length; i++) {
            var word = this.words[i] << shift | carry;
            res[position++] = word & 255;
            if (position < res.length) {
              res[position++] = word >> 8 & 255;
            }
            if (position < res.length) {
              res[position++] = word >> 16 & 255;
            }
            if (shift === 6) {
              if (position < res.length) {
                res[position++] = word >> 24 & 255;
              }
              carry = 0;
              shift = 0;
            } else {
              carry = word >>> 24;
              shift += 2;
            }
          }
          if (position < res.length) {
            res[position++] = carry;
            while (position < res.length) {
              res[position++] = 0;
            }
          }
        };
        BN.prototype._toArrayLikeBE = function _toArrayLikeBE(res, byteLength) {
          var position = res.length - 1;
          var carry = 0;
          for (var i = 0, shift = 0; i < this.length; i++) {
            var word = this.words[i] << shift | carry;
            res[position--] = word & 255;
            if (position >= 0) {
              res[position--] = word >> 8 & 255;
            }
            if (position >= 0) {
              res[position--] = word >> 16 & 255;
            }
            if (shift === 6) {
              if (position >= 0) {
                res[position--] = word >> 24 & 255;
              }
              carry = 0;
              shift = 0;
            } else {
              carry = word >>> 24;
              shift += 2;
            }
          }
          if (position >= 0) {
            res[position--] = carry;
            while (position >= 0) {
              res[position--] = 0;
            }
          }
        };
        if (Math.clz32) {
          BN.prototype._countBits = function _countBits(w) {
            return 32 - Math.clz32(w);
          };
        } else {
          BN.prototype._countBits = function _countBits(w) {
            var t = w;
            var r = 0;
            if (t >= 4096) {
              r += 13;
              t >>>= 13;
            }
            if (t >= 64) {
              r += 7;
              t >>>= 7;
            }
            if (t >= 8) {
              r += 4;
              t >>>= 4;
            }
            if (t >= 2) {
              r += 2;
              t >>>= 2;
            }
            return r + t;
          };
        }
        BN.prototype._zeroBits = function _zeroBits(w) {
          if (w === 0)
            return 26;
          var t = w;
          var r = 0;
          if ((t & 8191) === 0) {
            r += 13;
            t >>>= 13;
          }
          if ((t & 127) === 0) {
            r += 7;
            t >>>= 7;
          }
          if ((t & 15) === 0) {
            r += 4;
            t >>>= 4;
          }
          if ((t & 3) === 0) {
            r += 2;
            t >>>= 2;
          }
          if ((t & 1) === 0) {
            r++;
          }
          return r;
        };
        BN.prototype.bitLength = function bitLength() {
          var w = this.words[this.length - 1];
          var hi = this._countBits(w);
          return (this.length - 1) * 26 + hi;
        };
        function toBitArray(num) {
          var w = new Array(num.bitLength());
          for (var bit = 0; bit < w.length; bit++) {
            var off = bit / 26 | 0;
            var wbit = bit % 26;
            w[bit] = num.words[off] >>> wbit & 1;
          }
          return w;
        }
        BN.prototype.zeroBits = function zeroBits() {
          if (this.isZero())
            return 0;
          var r = 0;
          for (var i = 0; i < this.length; i++) {
            var b = this._zeroBits(this.words[i]);
            r += b;
            if (b !== 26)
              break;
          }
          return r;
        };
        BN.prototype.byteLength = function byteLength() {
          return Math.ceil(this.bitLength() / 8);
        };
        BN.prototype.toTwos = function toTwos(width) {
          if (this.negative !== 0) {
            return this.abs().inotn(width).iaddn(1);
          }
          return this.clone();
        };
        BN.prototype.fromTwos = function fromTwos(width) {
          if (this.testn(width - 1)) {
            return this.notn(width).iaddn(1).ineg();
          }
          return this.clone();
        };
        BN.prototype.isNeg = function isNeg() {
          return this.negative !== 0;
        };
        BN.prototype.neg = function neg() {
          return this.clone().ineg();
        };
        BN.prototype.ineg = function ineg() {
          if (!this.isZero()) {
            this.negative ^= 1;
          }
          return this;
        };
        BN.prototype.iuor = function iuor(num) {
          while (this.length < num.length) {
            this.words[this.length++] = 0;
          }
          for (var i = 0; i < num.length; i++) {
            this.words[i] = this.words[i] | num.words[i];
          }
          return this._strip();
        };
        BN.prototype.ior = function ior(num) {
          assert((this.negative | num.negative) === 0);
          return this.iuor(num);
        };
        BN.prototype.or = function or(num) {
          if (this.length > num.length)
            return this.clone().ior(num);
          return num.clone().ior(this);
        };
        BN.prototype.uor = function uor(num) {
          if (this.length > num.length)
            return this.clone().iuor(num);
          return num.clone().iuor(this);
        };
        BN.prototype.iuand = function iuand(num) {
          var b;
          if (this.length > num.length) {
            b = num;
          } else {
            b = this;
          }
          for (var i = 0; i < b.length; i++) {
            this.words[i] = this.words[i] & num.words[i];
          }
          this.length = b.length;
          return this._strip();
        };
        BN.prototype.iand = function iand(num) {
          assert((this.negative | num.negative) === 0);
          return this.iuand(num);
        };
        BN.prototype.and = function and(num) {
          if (this.length > num.length)
            return this.clone().iand(num);
          return num.clone().iand(this);
        };
        BN.prototype.uand = function uand(num) {
          if (this.length > num.length)
            return this.clone().iuand(num);
          return num.clone().iuand(this);
        };
        BN.prototype.iuxor = function iuxor(num) {
          var a;
          var b;
          if (this.length > num.length) {
            a = this;
            b = num;
          } else {
            a = num;
            b = this;
          }
          for (var i = 0; i < b.length; i++) {
            this.words[i] = a.words[i] ^ b.words[i];
          }
          if (this !== a) {
            for (; i < a.length; i++) {
              this.words[i] = a.words[i];
            }
          }
          this.length = a.length;
          return this._strip();
        };
        BN.prototype.ixor = function ixor(num) {
          assert((this.negative | num.negative) === 0);
          return this.iuxor(num);
        };
        BN.prototype.xor = function xor(num) {
          if (this.length > num.length)
            return this.clone().ixor(num);
          return num.clone().ixor(this);
        };
        BN.prototype.uxor = function uxor(num) {
          if (this.length > num.length)
            return this.clone().iuxor(num);
          return num.clone().iuxor(this);
        };
        BN.prototype.inotn = function inotn(width) {
          assert(typeof width === "number" && width >= 0);
          var bytesNeeded = Math.ceil(width / 26) | 0;
          var bitsLeft = width % 26;
          this._expand(bytesNeeded);
          if (bitsLeft > 0) {
            bytesNeeded--;
          }
          for (var i = 0; i < bytesNeeded; i++) {
            this.words[i] = ~this.words[i] & 67108863;
          }
          if (bitsLeft > 0) {
            this.words[i] = ~this.words[i] & 67108863 >> 26 - bitsLeft;
          }
          return this._strip();
        };
        BN.prototype.notn = function notn(width) {
          return this.clone().inotn(width);
        };
        BN.prototype.setn = function setn(bit, val) {
          assert(typeof bit === "number" && bit >= 0);
          var off = bit / 26 | 0;
          var wbit = bit % 26;
          this._expand(off + 1);
          if (val) {
            this.words[off] = this.words[off] | 1 << wbit;
          } else {
            this.words[off] = this.words[off] & ~(1 << wbit);
          }
          return this._strip();
        };
        BN.prototype.iadd = function iadd(num) {
          var r;
          if (this.negative !== 0 && num.negative === 0) {
            this.negative = 0;
            r = this.isub(num);
            this.negative ^= 1;
            return this._normSign();
          } else if (this.negative === 0 && num.negative !== 0) {
            num.negative = 0;
            r = this.isub(num);
            num.negative = 1;
            return r._normSign();
          }
          var a, b;
          if (this.length > num.length) {
            a = this;
            b = num;
          } else {
            a = num;
            b = this;
          }
          var carry = 0;
          for (var i = 0; i < b.length; i++) {
            r = (a.words[i] | 0) + (b.words[i] | 0) + carry;
            this.words[i] = r & 67108863;
            carry = r >>> 26;
          }
          for (; carry !== 0 && i < a.length; i++) {
            r = (a.words[i] | 0) + carry;
            this.words[i] = r & 67108863;
            carry = r >>> 26;
          }
          this.length = a.length;
          if (carry !== 0) {
            this.words[this.length] = carry;
            this.length++;
          } else if (a !== this) {
            for (; i < a.length; i++) {
              this.words[i] = a.words[i];
            }
          }
          return this;
        };
        BN.prototype.add = function add(num) {
          var res;
          if (num.negative !== 0 && this.negative === 0) {
            num.negative = 0;
            res = this.sub(num);
            num.negative ^= 1;
            return res;
          } else if (num.negative === 0 && this.negative !== 0) {
            this.negative = 0;
            res = num.sub(this);
            this.negative = 1;
            return res;
          }
          if (this.length > num.length)
            return this.clone().iadd(num);
          return num.clone().iadd(this);
        };
        BN.prototype.isub = function isub(num) {
          if (num.negative !== 0) {
            num.negative = 0;
            var r = this.iadd(num);
            num.negative = 1;
            return r._normSign();
          } else if (this.negative !== 0) {
            this.negative = 0;
            this.iadd(num);
            this.negative = 1;
            return this._normSign();
          }
          var cmp = this.cmp(num);
          if (cmp === 0) {
            this.negative = 0;
            this.length = 1;
            this.words[0] = 0;
            return this;
          }
          var a, b;
          if (cmp > 0) {
            a = this;
            b = num;
          } else {
            a = num;
            b = this;
          }
          var carry = 0;
          for (var i = 0; i < b.length; i++) {
            r = (a.words[i] | 0) - (b.words[i] | 0) + carry;
            carry = r >> 26;
            this.words[i] = r & 67108863;
          }
          for (; carry !== 0 && i < a.length; i++) {
            r = (a.words[i] | 0) + carry;
            carry = r >> 26;
            this.words[i] = r & 67108863;
          }
          if (carry === 0 && i < a.length && a !== this) {
            for (; i < a.length; i++) {
              this.words[i] = a.words[i];
            }
          }
          this.length = Math.max(this.length, i);
          if (a !== this) {
            this.negative = 1;
          }
          return this._strip();
        };
        BN.prototype.sub = function sub(num) {
          return this.clone().isub(num);
        };
        function smallMulTo(self2, num, out) {
          out.negative = num.negative ^ self2.negative;
          var len = self2.length + num.length | 0;
          out.length = len;
          len = len - 1 | 0;
          var a = self2.words[0] | 0;
          var b = num.words[0] | 0;
          var r = a * b;
          var lo = r & 67108863;
          var carry = r / 67108864 | 0;
          out.words[0] = lo;
          for (var k = 1; k < len; k++) {
            var ncarry = carry >>> 26;
            var rword = carry & 67108863;
            var maxJ = Math.min(k, num.length - 1);
            for (var j = Math.max(0, k - self2.length + 1); j <= maxJ; j++) {
              var i = k - j | 0;
              a = self2.words[i] | 0;
              b = num.words[j] | 0;
              r = a * b + rword;
              ncarry += r / 67108864 | 0;
              rword = r & 67108863;
            }
            out.words[k] = rword | 0;
            carry = ncarry | 0;
          }
          if (carry !== 0) {
            out.words[k] = carry | 0;
          } else {
            out.length--;
          }
          return out._strip();
        }
        var comb10MulTo = function comb10MulTo2(self2, num, out) {
          var a = self2.words;
          var b = num.words;
          var o = out.words;
          var c = 0;
          var lo;
          var mid;
          var hi;
          var a0 = a[0] | 0;
          var al0 = a0 & 8191;
          var ah0 = a0 >>> 13;
          var a1 = a[1] | 0;
          var al1 = a1 & 8191;
          var ah1 = a1 >>> 13;
          var a2 = a[2] | 0;
          var al2 = a2 & 8191;
          var ah2 = a2 >>> 13;
          var a3 = a[3] | 0;
          var al3 = a3 & 8191;
          var ah3 = a3 >>> 13;
          var a4 = a[4] | 0;
          var al4 = a4 & 8191;
          var ah4 = a4 >>> 13;
          var a5 = a[5] | 0;
          var al5 = a5 & 8191;
          var ah5 = a5 >>> 13;
          var a6 = a[6] | 0;
          var al6 = a6 & 8191;
          var ah6 = a6 >>> 13;
          var a7 = a[7] | 0;
          var al7 = a7 & 8191;
          var ah7 = a7 >>> 13;
          var a8 = a[8] | 0;
          var al8 = a8 & 8191;
          var ah8 = a8 >>> 13;
          var a9 = a[9] | 0;
          var al9 = a9 & 8191;
          var ah9 = a9 >>> 13;
          var b0 = b[0] | 0;
          var bl0 = b0 & 8191;
          var bh0 = b0 >>> 13;
          var b1 = b[1] | 0;
          var bl1 = b1 & 8191;
          var bh1 = b1 >>> 13;
          var b2 = b[2] | 0;
          var bl2 = b2 & 8191;
          var bh2 = b2 >>> 13;
          var b3 = b[3] | 0;
          var bl3 = b3 & 8191;
          var bh3 = b3 >>> 13;
          var b4 = b[4] | 0;
          var bl4 = b4 & 8191;
          var bh4 = b4 >>> 13;
          var b5 = b[5] | 0;
          var bl5 = b5 & 8191;
          var bh5 = b5 >>> 13;
          var b6 = b[6] | 0;
          var bl6 = b6 & 8191;
          var bh6 = b6 >>> 13;
          var b7 = b[7] | 0;
          var bl7 = b7 & 8191;
          var bh7 = b7 >>> 13;
          var b8 = b[8] | 0;
          var bl8 = b8 & 8191;
          var bh8 = b8 >>> 13;
          var b9 = b[9] | 0;
          var bl9 = b9 & 8191;
          var bh9 = b9 >>> 13;
          out.negative = self2.negative ^ num.negative;
          out.length = 19;
          lo = Math.imul(al0, bl0);
          mid = Math.imul(al0, bh0);
          mid = mid + Math.imul(ah0, bl0) | 0;
          hi = Math.imul(ah0, bh0);
          var w0 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w0 >>> 26) | 0;
          w0 &= 67108863;
          lo = Math.imul(al1, bl0);
          mid = Math.imul(al1, bh0);
          mid = mid + Math.imul(ah1, bl0) | 0;
          hi = Math.imul(ah1, bh0);
          lo = lo + Math.imul(al0, bl1) | 0;
          mid = mid + Math.imul(al0, bh1) | 0;
          mid = mid + Math.imul(ah0, bl1) | 0;
          hi = hi + Math.imul(ah0, bh1) | 0;
          var w1 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w1 >>> 26) | 0;
          w1 &= 67108863;
          lo = Math.imul(al2, bl0);
          mid = Math.imul(al2, bh0);
          mid = mid + Math.imul(ah2, bl0) | 0;
          hi = Math.imul(ah2, bh0);
          lo = lo + Math.imul(al1, bl1) | 0;
          mid = mid + Math.imul(al1, bh1) | 0;
          mid = mid + Math.imul(ah1, bl1) | 0;
          hi = hi + Math.imul(ah1, bh1) | 0;
          lo = lo + Math.imul(al0, bl2) | 0;
          mid = mid + Math.imul(al0, bh2) | 0;
          mid = mid + Math.imul(ah0, bl2) | 0;
          hi = hi + Math.imul(ah0, bh2) | 0;
          var w2 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w2 >>> 26) | 0;
          w2 &= 67108863;
          lo = Math.imul(al3, bl0);
          mid = Math.imul(al3, bh0);
          mid = mid + Math.imul(ah3, bl0) | 0;
          hi = Math.imul(ah3, bh0);
          lo = lo + Math.imul(al2, bl1) | 0;
          mid = mid + Math.imul(al2, bh1) | 0;
          mid = mid + Math.imul(ah2, bl1) | 0;
          hi = hi + Math.imul(ah2, bh1) | 0;
          lo = lo + Math.imul(al1, bl2) | 0;
          mid = mid + Math.imul(al1, bh2) | 0;
          mid = mid + Math.imul(ah1, bl2) | 0;
          hi = hi + Math.imul(ah1, bh2) | 0;
          lo = lo + Math.imul(al0, bl3) | 0;
          mid = mid + Math.imul(al0, bh3) | 0;
          mid = mid + Math.imul(ah0, bl3) | 0;
          hi = hi + Math.imul(ah0, bh3) | 0;
          var w3 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w3 >>> 26) | 0;
          w3 &= 67108863;
          lo = Math.imul(al4, bl0);
          mid = Math.imul(al4, bh0);
          mid = mid + Math.imul(ah4, bl0) | 0;
          hi = Math.imul(ah4, bh0);
          lo = lo + Math.imul(al3, bl1) | 0;
          mid = mid + Math.imul(al3, bh1) | 0;
          mid = mid + Math.imul(ah3, bl1) | 0;
          hi = hi + Math.imul(ah3, bh1) | 0;
          lo = lo + Math.imul(al2, bl2) | 0;
          mid = mid + Math.imul(al2, bh2) | 0;
          mid = mid + Math.imul(ah2, bl2) | 0;
          hi = hi + Math.imul(ah2, bh2) | 0;
          lo = lo + Math.imul(al1, bl3) | 0;
          mid = mid + Math.imul(al1, bh3) | 0;
          mid = mid + Math.imul(ah1, bl3) | 0;
          hi = hi + Math.imul(ah1, bh3) | 0;
          lo = lo + Math.imul(al0, bl4) | 0;
          mid = mid + Math.imul(al0, bh4) | 0;
          mid = mid + Math.imul(ah0, bl4) | 0;
          hi = hi + Math.imul(ah0, bh4) | 0;
          var w4 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w4 >>> 26) | 0;
          w4 &= 67108863;
          lo = Math.imul(al5, bl0);
          mid = Math.imul(al5, bh0);
          mid = mid + Math.imul(ah5, bl0) | 0;
          hi = Math.imul(ah5, bh0);
          lo = lo + Math.imul(al4, bl1) | 0;
          mid = mid + Math.imul(al4, bh1) | 0;
          mid = mid + Math.imul(ah4, bl1) | 0;
          hi = hi + Math.imul(ah4, bh1) | 0;
          lo = lo + Math.imul(al3, bl2) | 0;
          mid = mid + Math.imul(al3, bh2) | 0;
          mid = mid + Math.imul(ah3, bl2) | 0;
          hi = hi + Math.imul(ah3, bh2) | 0;
          lo = lo + Math.imul(al2, bl3) | 0;
          mid = mid + Math.imul(al2, bh3) | 0;
          mid = mid + Math.imul(ah2, bl3) | 0;
          hi = hi + Math.imul(ah2, bh3) | 0;
          lo = lo + Math.imul(al1, bl4) | 0;
          mid = mid + Math.imul(al1, bh4) | 0;
          mid = mid + Math.imul(ah1, bl4) | 0;
          hi = hi + Math.imul(ah1, bh4) | 0;
          lo = lo + Math.imul(al0, bl5) | 0;
          mid = mid + Math.imul(al0, bh5) | 0;
          mid = mid + Math.imul(ah0, bl5) | 0;
          hi = hi + Math.imul(ah0, bh5) | 0;
          var w5 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w5 >>> 26) | 0;
          w5 &= 67108863;
          lo = Math.imul(al6, bl0);
          mid = Math.imul(al6, bh0);
          mid = mid + Math.imul(ah6, bl0) | 0;
          hi = Math.imul(ah6, bh0);
          lo = lo + Math.imul(al5, bl1) | 0;
          mid = mid + Math.imul(al5, bh1) | 0;
          mid = mid + Math.imul(ah5, bl1) | 0;
          hi = hi + Math.imul(ah5, bh1) | 0;
          lo = lo + Math.imul(al4, bl2) | 0;
          mid = mid + Math.imul(al4, bh2) | 0;
          mid = mid + Math.imul(ah4, bl2) | 0;
          hi = hi + Math.imul(ah4, bh2) | 0;
          lo = lo + Math.imul(al3, bl3) | 0;
          mid = mid + Math.imul(al3, bh3) | 0;
          mid = mid + Math.imul(ah3, bl3) | 0;
          hi = hi + Math.imul(ah3, bh3) | 0;
          lo = lo + Math.imul(al2, bl4) | 0;
          mid = mid + Math.imul(al2, bh4) | 0;
          mid = mid + Math.imul(ah2, bl4) | 0;
          hi = hi + Math.imul(ah2, bh4) | 0;
          lo = lo + Math.imul(al1, bl5) | 0;
          mid = mid + Math.imul(al1, bh5) | 0;
          mid = mid + Math.imul(ah1, bl5) | 0;
          hi = hi + Math.imul(ah1, bh5) | 0;
          lo = lo + Math.imul(al0, bl6) | 0;
          mid = mid + Math.imul(al0, bh6) | 0;
          mid = mid + Math.imul(ah0, bl6) | 0;
          hi = hi + Math.imul(ah0, bh6) | 0;
          var w6 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w6 >>> 26) | 0;
          w6 &= 67108863;
          lo = Math.imul(al7, bl0);
          mid = Math.imul(al7, bh0);
          mid = mid + Math.imul(ah7, bl0) | 0;
          hi = Math.imul(ah7, bh0);
          lo = lo + Math.imul(al6, bl1) | 0;
          mid = mid + Math.imul(al6, bh1) | 0;
          mid = mid + Math.imul(ah6, bl1) | 0;
          hi = hi + Math.imul(ah6, bh1) | 0;
          lo = lo + Math.imul(al5, bl2) | 0;
          mid = mid + Math.imul(al5, bh2) | 0;
          mid = mid + Math.imul(ah5, bl2) | 0;
          hi = hi + Math.imul(ah5, bh2) | 0;
          lo = lo + Math.imul(al4, bl3) | 0;
          mid = mid + Math.imul(al4, bh3) | 0;
          mid = mid + Math.imul(ah4, bl3) | 0;
          hi = hi + Math.imul(ah4, bh3) | 0;
          lo = lo + Math.imul(al3, bl4) | 0;
          mid = mid + Math.imul(al3, bh4) | 0;
          mid = mid + Math.imul(ah3, bl4) | 0;
          hi = hi + Math.imul(ah3, bh4) | 0;
          lo = lo + Math.imul(al2, bl5) | 0;
          mid = mid + Math.imul(al2, bh5) | 0;
          mid = mid + Math.imul(ah2, bl5) | 0;
          hi = hi + Math.imul(ah2, bh5) | 0;
          lo = lo + Math.imul(al1, bl6) | 0;
          mid = mid + Math.imul(al1, bh6) | 0;
          mid = mid + Math.imul(ah1, bl6) | 0;
          hi = hi + Math.imul(ah1, bh6) | 0;
          lo = lo + Math.imul(al0, bl7) | 0;
          mid = mid + Math.imul(al0, bh7) | 0;
          mid = mid + Math.imul(ah0, bl7) | 0;
          hi = hi + Math.imul(ah0, bh7) | 0;
          var w7 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w7 >>> 26) | 0;
          w7 &= 67108863;
          lo = Math.imul(al8, bl0);
          mid = Math.imul(al8, bh0);
          mid = mid + Math.imul(ah8, bl0) | 0;
          hi = Math.imul(ah8, bh0);
          lo = lo + Math.imul(al7, bl1) | 0;
          mid = mid + Math.imul(al7, bh1) | 0;
          mid = mid + Math.imul(ah7, bl1) | 0;
          hi = hi + Math.imul(ah7, bh1) | 0;
          lo = lo + Math.imul(al6, bl2) | 0;
          mid = mid + Math.imul(al6, bh2) | 0;
          mid = mid + Math.imul(ah6, bl2) | 0;
          hi = hi + Math.imul(ah6, bh2) | 0;
          lo = lo + Math.imul(al5, bl3) | 0;
          mid = mid + Math.imul(al5, bh3) | 0;
          mid = mid + Math.imul(ah5, bl3) | 0;
          hi = hi + Math.imul(ah5, bh3) | 0;
          lo = lo + Math.imul(al4, bl4) | 0;
          mid = mid + Math.imul(al4, bh4) | 0;
          mid = mid + Math.imul(ah4, bl4) | 0;
          hi = hi + Math.imul(ah4, bh4) | 0;
          lo = lo + Math.imul(al3, bl5) | 0;
          mid = mid + Math.imul(al3, bh5) | 0;
          mid = mid + Math.imul(ah3, bl5) | 0;
          hi = hi + Math.imul(ah3, bh5) | 0;
          lo = lo + Math.imul(al2, bl6) | 0;
          mid = mid + Math.imul(al2, bh6) | 0;
          mid = mid + Math.imul(ah2, bl6) | 0;
          hi = hi + Math.imul(ah2, bh6) | 0;
          lo = lo + Math.imul(al1, bl7) | 0;
          mid = mid + Math.imul(al1, bh7) | 0;
          mid = mid + Math.imul(ah1, bl7) | 0;
          hi = hi + Math.imul(ah1, bh7) | 0;
          lo = lo + Math.imul(al0, bl8) | 0;
          mid = mid + Math.imul(al0, bh8) | 0;
          mid = mid + Math.imul(ah0, bl8) | 0;
          hi = hi + Math.imul(ah0, bh8) | 0;
          var w8 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w8 >>> 26) | 0;
          w8 &= 67108863;
          lo = Math.imul(al9, bl0);
          mid = Math.imul(al9, bh0);
          mid = mid + Math.imul(ah9, bl0) | 0;
          hi = Math.imul(ah9, bh0);
          lo = lo + Math.imul(al8, bl1) | 0;
          mid = mid + Math.imul(al8, bh1) | 0;
          mid = mid + Math.imul(ah8, bl1) | 0;
          hi = hi + Math.imul(ah8, bh1) | 0;
          lo = lo + Math.imul(al7, bl2) | 0;
          mid = mid + Math.imul(al7, bh2) | 0;
          mid = mid + Math.imul(ah7, bl2) | 0;
          hi = hi + Math.imul(ah7, bh2) | 0;
          lo = lo + Math.imul(al6, bl3) | 0;
          mid = mid + Math.imul(al6, bh3) | 0;
          mid = mid + Math.imul(ah6, bl3) | 0;
          hi = hi + Math.imul(ah6, bh3) | 0;
          lo = lo + Math.imul(al5, bl4) | 0;
          mid = mid + Math.imul(al5, bh4) | 0;
          mid = mid + Math.imul(ah5, bl4) | 0;
          hi = hi + Math.imul(ah5, bh4) | 0;
          lo = lo + Math.imul(al4, bl5) | 0;
          mid = mid + Math.imul(al4, bh5) | 0;
          mid = mid + Math.imul(ah4, bl5) | 0;
          hi = hi + Math.imul(ah4, bh5) | 0;
          lo = lo + Math.imul(al3, bl6) | 0;
          mid = mid + Math.imul(al3, bh6) | 0;
          mid = mid + Math.imul(ah3, bl6) | 0;
          hi = hi + Math.imul(ah3, bh6) | 0;
          lo = lo + Math.imul(al2, bl7) | 0;
          mid = mid + Math.imul(al2, bh7) | 0;
          mid = mid + Math.imul(ah2, bl7) | 0;
          hi = hi + Math.imul(ah2, bh7) | 0;
          lo = lo + Math.imul(al1, bl8) | 0;
          mid = mid + Math.imul(al1, bh8) | 0;
          mid = mid + Math.imul(ah1, bl8) | 0;
          hi = hi + Math.imul(ah1, bh8) | 0;
          lo = lo + Math.imul(al0, bl9) | 0;
          mid = mid + Math.imul(al0, bh9) | 0;
          mid = mid + Math.imul(ah0, bl9) | 0;
          hi = hi + Math.imul(ah0, bh9) | 0;
          var w9 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w9 >>> 26) | 0;
          w9 &= 67108863;
          lo = Math.imul(al9, bl1);
          mid = Math.imul(al9, bh1);
          mid = mid + Math.imul(ah9, bl1) | 0;
          hi = Math.imul(ah9, bh1);
          lo = lo + Math.imul(al8, bl2) | 0;
          mid = mid + Math.imul(al8, bh2) | 0;
          mid = mid + Math.imul(ah8, bl2) | 0;
          hi = hi + Math.imul(ah8, bh2) | 0;
          lo = lo + Math.imul(al7, bl3) | 0;
          mid = mid + Math.imul(al7, bh3) | 0;
          mid = mid + Math.imul(ah7, bl3) | 0;
          hi = hi + Math.imul(ah7, bh3) | 0;
          lo = lo + Math.imul(al6, bl4) | 0;
          mid = mid + Math.imul(al6, bh4) | 0;
          mid = mid + Math.imul(ah6, bl4) | 0;
          hi = hi + Math.imul(ah6, bh4) | 0;
          lo = lo + Math.imul(al5, bl5) | 0;
          mid = mid + Math.imul(al5, bh5) | 0;
          mid = mid + Math.imul(ah5, bl5) | 0;
          hi = hi + Math.imul(ah5, bh5) | 0;
          lo = lo + Math.imul(al4, bl6) | 0;
          mid = mid + Math.imul(al4, bh6) | 0;
          mid = mid + Math.imul(ah4, bl6) | 0;
          hi = hi + Math.imul(ah4, bh6) | 0;
          lo = lo + Math.imul(al3, bl7) | 0;
          mid = mid + Math.imul(al3, bh7) | 0;
          mid = mid + Math.imul(ah3, bl7) | 0;
          hi = hi + Math.imul(ah3, bh7) | 0;
          lo = lo + Math.imul(al2, bl8) | 0;
          mid = mid + Math.imul(al2, bh8) | 0;
          mid = mid + Math.imul(ah2, bl8) | 0;
          hi = hi + Math.imul(ah2, bh8) | 0;
          lo = lo + Math.imul(al1, bl9) | 0;
          mid = mid + Math.imul(al1, bh9) | 0;
          mid = mid + Math.imul(ah1, bl9) | 0;
          hi = hi + Math.imul(ah1, bh9) | 0;
          var w10 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w10 >>> 26) | 0;
          w10 &= 67108863;
          lo = Math.imul(al9, bl2);
          mid = Math.imul(al9, bh2);
          mid = mid + Math.imul(ah9, bl2) | 0;
          hi = Math.imul(ah9, bh2);
          lo = lo + Math.imul(al8, bl3) | 0;
          mid = mid + Math.imul(al8, bh3) | 0;
          mid = mid + Math.imul(ah8, bl3) | 0;
          hi = hi + Math.imul(ah8, bh3) | 0;
          lo = lo + Math.imul(al7, bl4) | 0;
          mid = mid + Math.imul(al7, bh4) | 0;
          mid = mid + Math.imul(ah7, bl4) | 0;
          hi = hi + Math.imul(ah7, bh4) | 0;
          lo = lo + Math.imul(al6, bl5) | 0;
          mid = mid + Math.imul(al6, bh5) | 0;
          mid = mid + Math.imul(ah6, bl5) | 0;
          hi = hi + Math.imul(ah6, bh5) | 0;
          lo = lo + Math.imul(al5, bl6) | 0;
          mid = mid + Math.imul(al5, bh6) | 0;
          mid = mid + Math.imul(ah5, bl6) | 0;
          hi = hi + Math.imul(ah5, bh6) | 0;
          lo = lo + Math.imul(al4, bl7) | 0;
          mid = mid + Math.imul(al4, bh7) | 0;
          mid = mid + Math.imul(ah4, bl7) | 0;
          hi = hi + Math.imul(ah4, bh7) | 0;
          lo = lo + Math.imul(al3, bl8) | 0;
          mid = mid + Math.imul(al3, bh8) | 0;
          mid = mid + Math.imul(ah3, bl8) | 0;
          hi = hi + Math.imul(ah3, bh8) | 0;
          lo = lo + Math.imul(al2, bl9) | 0;
          mid = mid + Math.imul(al2, bh9) | 0;
          mid = mid + Math.imul(ah2, bl9) | 0;
          hi = hi + Math.imul(ah2, bh9) | 0;
          var w11 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w11 >>> 26) | 0;
          w11 &= 67108863;
          lo = Math.imul(al9, bl3);
          mid = Math.imul(al9, bh3);
          mid = mid + Math.imul(ah9, bl3) | 0;
          hi = Math.imul(ah9, bh3);
          lo = lo + Math.imul(al8, bl4) | 0;
          mid = mid + Math.imul(al8, bh4) | 0;
          mid = mid + Math.imul(ah8, bl4) | 0;
          hi = hi + Math.imul(ah8, bh4) | 0;
          lo = lo + Math.imul(al7, bl5) | 0;
          mid = mid + Math.imul(al7, bh5) | 0;
          mid = mid + Math.imul(ah7, bl5) | 0;
          hi = hi + Math.imul(ah7, bh5) | 0;
          lo = lo + Math.imul(al6, bl6) | 0;
          mid = mid + Math.imul(al6, bh6) | 0;
          mid = mid + Math.imul(ah6, bl6) | 0;
          hi = hi + Math.imul(ah6, bh6) | 0;
          lo = lo + Math.imul(al5, bl7) | 0;
          mid = mid + Math.imul(al5, bh7) | 0;
          mid = mid + Math.imul(ah5, bl7) | 0;
          hi = hi + Math.imul(ah5, bh7) | 0;
          lo = lo + Math.imul(al4, bl8) | 0;
          mid = mid + Math.imul(al4, bh8) | 0;
          mid = mid + Math.imul(ah4, bl8) | 0;
          hi = hi + Math.imul(ah4, bh8) | 0;
          lo = lo + Math.imul(al3, bl9) | 0;
          mid = mid + Math.imul(al3, bh9) | 0;
          mid = mid + Math.imul(ah3, bl9) | 0;
          hi = hi + Math.imul(ah3, bh9) | 0;
          var w12 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w12 >>> 26) | 0;
          w12 &= 67108863;
          lo = Math.imul(al9, bl4);
          mid = Math.imul(al9, bh4);
          mid = mid + Math.imul(ah9, bl4) | 0;
          hi = Math.imul(ah9, bh4);
          lo = lo + Math.imul(al8, bl5) | 0;
          mid = mid + Math.imul(al8, bh5) | 0;
          mid = mid + Math.imul(ah8, bl5) | 0;
          hi = hi + Math.imul(ah8, bh5) | 0;
          lo = lo + Math.imul(al7, bl6) | 0;
          mid = mid + Math.imul(al7, bh6) | 0;
          mid = mid + Math.imul(ah7, bl6) | 0;
          hi = hi + Math.imul(ah7, bh6) | 0;
          lo = lo + Math.imul(al6, bl7) | 0;
          mid = mid + Math.imul(al6, bh7) | 0;
          mid = mid + Math.imul(ah6, bl7) | 0;
          hi = hi + Math.imul(ah6, bh7) | 0;
          lo = lo + Math.imul(al5, bl8) | 0;
          mid = mid + Math.imul(al5, bh8) | 0;
          mid = mid + Math.imul(ah5, bl8) | 0;
          hi = hi + Math.imul(ah5, bh8) | 0;
          lo = lo + Math.imul(al4, bl9) | 0;
          mid = mid + Math.imul(al4, bh9) | 0;
          mid = mid + Math.imul(ah4, bl9) | 0;
          hi = hi + Math.imul(ah4, bh9) | 0;
          var w13 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w13 >>> 26) | 0;
          w13 &= 67108863;
          lo = Math.imul(al9, bl5);
          mid = Math.imul(al9, bh5);
          mid = mid + Math.imul(ah9, bl5) | 0;
          hi = Math.imul(ah9, bh5);
          lo = lo + Math.imul(al8, bl6) | 0;
          mid = mid + Math.imul(al8, bh6) | 0;
          mid = mid + Math.imul(ah8, bl6) | 0;
          hi = hi + Math.imul(ah8, bh6) | 0;
          lo = lo + Math.imul(al7, bl7) | 0;
          mid = mid + Math.imul(al7, bh7) | 0;
          mid = mid + Math.imul(ah7, bl7) | 0;
          hi = hi + Math.imul(ah7, bh7) | 0;
          lo = lo + Math.imul(al6, bl8) | 0;
          mid = mid + Math.imul(al6, bh8) | 0;
          mid = mid + Math.imul(ah6, bl8) | 0;
          hi = hi + Math.imul(ah6, bh8) | 0;
          lo = lo + Math.imul(al5, bl9) | 0;
          mid = mid + Math.imul(al5, bh9) | 0;
          mid = mid + Math.imul(ah5, bl9) | 0;
          hi = hi + Math.imul(ah5, bh9) | 0;
          var w14 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w14 >>> 26) | 0;
          w14 &= 67108863;
          lo = Math.imul(al9, bl6);
          mid = Math.imul(al9, bh6);
          mid = mid + Math.imul(ah9, bl6) | 0;
          hi = Math.imul(ah9, bh6);
          lo = lo + Math.imul(al8, bl7) | 0;
          mid = mid + Math.imul(al8, bh7) | 0;
          mid = mid + Math.imul(ah8, bl7) | 0;
          hi = hi + Math.imul(ah8, bh7) | 0;
          lo = lo + Math.imul(al7, bl8) | 0;
          mid = mid + Math.imul(al7, bh8) | 0;
          mid = mid + Math.imul(ah7, bl8) | 0;
          hi = hi + Math.imul(ah7, bh8) | 0;
          lo = lo + Math.imul(al6, bl9) | 0;
          mid = mid + Math.imul(al6, bh9) | 0;
          mid = mid + Math.imul(ah6, bl9) | 0;
          hi = hi + Math.imul(ah6, bh9) | 0;
          var w15 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w15 >>> 26) | 0;
          w15 &= 67108863;
          lo = Math.imul(al9, bl7);
          mid = Math.imul(al9, bh7);
          mid = mid + Math.imul(ah9, bl7) | 0;
          hi = Math.imul(ah9, bh7);
          lo = lo + Math.imul(al8, bl8) | 0;
          mid = mid + Math.imul(al8, bh8) | 0;
          mid = mid + Math.imul(ah8, bl8) | 0;
          hi = hi + Math.imul(ah8, bh8) | 0;
          lo = lo + Math.imul(al7, bl9) | 0;
          mid = mid + Math.imul(al7, bh9) | 0;
          mid = mid + Math.imul(ah7, bl9) | 0;
          hi = hi + Math.imul(ah7, bh9) | 0;
          var w16 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w16 >>> 26) | 0;
          w16 &= 67108863;
          lo = Math.imul(al9, bl8);
          mid = Math.imul(al9, bh8);
          mid = mid + Math.imul(ah9, bl8) | 0;
          hi = Math.imul(ah9, bh8);
          lo = lo + Math.imul(al8, bl9) | 0;
          mid = mid + Math.imul(al8, bh9) | 0;
          mid = mid + Math.imul(ah8, bl9) | 0;
          hi = hi + Math.imul(ah8, bh9) | 0;
          var w17 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w17 >>> 26) | 0;
          w17 &= 67108863;
          lo = Math.imul(al9, bl9);
          mid = Math.imul(al9, bh9);
          mid = mid + Math.imul(ah9, bl9) | 0;
          hi = Math.imul(ah9, bh9);
          var w18 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
          c = (hi + (mid >>> 13) | 0) + (w18 >>> 26) | 0;
          w18 &= 67108863;
          o[0] = w0;
          o[1] = w1;
          o[2] = w2;
          o[3] = w3;
          o[4] = w4;
          o[5] = w5;
          o[6] = w6;
          o[7] = w7;
          o[8] = w8;
          o[9] = w9;
          o[10] = w10;
          o[11] = w11;
          o[12] = w12;
          o[13] = w13;
          o[14] = w14;
          o[15] = w15;
          o[16] = w16;
          o[17] = w17;
          o[18] = w18;
          if (c !== 0) {
            o[19] = c;
            out.length++;
          }
          return out;
        };
        if (!Math.imul) {
          comb10MulTo = smallMulTo;
        }
        function bigMulTo(self2, num, out) {
          out.negative = num.negative ^ self2.negative;
          out.length = self2.length + num.length;
          var carry = 0;
          var hncarry = 0;
          for (var k = 0; k < out.length - 1; k++) {
            var ncarry = hncarry;
            hncarry = 0;
            var rword = carry & 67108863;
            var maxJ = Math.min(k, num.length - 1);
            for (var j = Math.max(0, k - self2.length + 1); j <= maxJ; j++) {
              var i = k - j;
              var a = self2.words[i] | 0;
              var b = num.words[j] | 0;
              var r = a * b;
              var lo = r & 67108863;
              ncarry = ncarry + (r / 67108864 | 0) | 0;
              lo = lo + rword | 0;
              rword = lo & 67108863;
              ncarry = ncarry + (lo >>> 26) | 0;
              hncarry += ncarry >>> 26;
              ncarry &= 67108863;
            }
            out.words[k] = rword;
            carry = ncarry;
            ncarry = hncarry;
          }
          if (carry !== 0) {
            out.words[k] = carry;
          } else {
            out.length--;
          }
          return out._strip();
        }
        function jumboMulTo(self2, num, out) {
          return bigMulTo(self2, num, out);
        }
        BN.prototype.mulTo = function mulTo(num, out) {
          var res;
          var len = this.length + num.length;
          if (this.length === 10 && num.length === 10) {
            res = comb10MulTo(this, num, out);
          } else if (len < 63) {
            res = smallMulTo(this, num, out);
          } else if (len < 1024) {
            res = bigMulTo(this, num, out);
          } else {
            res = jumboMulTo(this, num, out);
          }
          return res;
        };
        function FFTM(x, y) {
          this.x = x;
          this.y = y;
        }
        FFTM.prototype.makeRBT = function makeRBT(N) {
          var t = new Array(N);
          var l = BN.prototype._countBits(N) - 1;
          for (var i = 0; i < N; i++) {
            t[i] = this.revBin(i, l, N);
          }
          return t;
        };
        FFTM.prototype.revBin = function revBin(x, l, N) {
          if (x === 0 || x === N - 1)
            return x;
          var rb = 0;
          for (var i = 0; i < l; i++) {
            rb |= (x & 1) << l - i - 1;
            x >>= 1;
          }
          return rb;
        };
        FFTM.prototype.permute = function permute(rbt, rws, iws, rtws, itws, N) {
          for (var i = 0; i < N; i++) {
            rtws[i] = rws[rbt[i]];
            itws[i] = iws[rbt[i]];
          }
        };
        FFTM.prototype.transform = function transform(rws, iws, rtws, itws, N, rbt) {
          this.permute(rbt, rws, iws, rtws, itws, N);
          for (var s = 1; s < N; s <<= 1) {
            var l = s << 1;
            var rtwdf = Math.cos(2 * Math.PI / l);
            var itwdf = Math.sin(2 * Math.PI / l);
            for (var p = 0; p < N; p += l) {
              var rtwdf_ = rtwdf;
              var itwdf_ = itwdf;
              for (var j = 0; j < s; j++) {
                var re = rtws[p + j];
                var ie = itws[p + j];
                var ro = rtws[p + j + s];
                var io = itws[p + j + s];
                var rx = rtwdf_ * ro - itwdf_ * io;
                io = rtwdf_ * io + itwdf_ * ro;
                ro = rx;
                rtws[p + j] = re + ro;
                itws[p + j] = ie + io;
                rtws[p + j + s] = re - ro;
                itws[p + j + s] = ie - io;
                if (j !== l) {
                  rx = rtwdf * rtwdf_ - itwdf * itwdf_;
                  itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;
                  rtwdf_ = rx;
                }
              }
            }
          }
        };
        FFTM.prototype.guessLen13b = function guessLen13b(n, m) {
          var N = Math.max(m, n) | 1;
          var odd = N & 1;
          var i = 0;
          for (N = N / 2 | 0; N; N = N >>> 1) {
            i++;
          }
          return 1 << i + 1 + odd;
        };
        FFTM.prototype.conjugate = function conjugate(rws, iws, N) {
          if (N <= 1)
            return;
          for (var i = 0; i < N / 2; i++) {
            var t = rws[i];
            rws[i] = rws[N - i - 1];
            rws[N - i - 1] = t;
            t = iws[i];
            iws[i] = -iws[N - i - 1];
            iws[N - i - 1] = -t;
          }
        };
        FFTM.prototype.normalize13b = function normalize13b(ws, N) {
          var carry = 0;
          for (var i = 0; i < N / 2; i++) {
            var w = Math.round(ws[2 * i + 1] / N) * 8192 + Math.round(ws[2 * i] / N) + carry;
            ws[i] = w & 67108863;
            if (w < 67108864) {
              carry = 0;
            } else {
              carry = w / 67108864 | 0;
            }
          }
          return ws;
        };
        FFTM.prototype.convert13b = function convert13b(ws, len, rws, N) {
          var carry = 0;
          for (var i = 0; i < len; i++) {
            carry = carry + (ws[i] | 0);
            rws[2 * i] = carry & 8191;
            carry = carry >>> 13;
            rws[2 * i + 1] = carry & 8191;
            carry = carry >>> 13;
          }
          for (i = 2 * len; i < N; ++i) {
            rws[i] = 0;
          }
          assert(carry === 0);
          assert((carry & ~8191) === 0);
        };
        FFTM.prototype.stub = function stub(N) {
          var ph = new Array(N);
          for (var i = 0; i < N; i++) {
            ph[i] = 0;
          }
          return ph;
        };
        FFTM.prototype.mulp = function mulp(x, y, out) {
          var N = 2 * this.guessLen13b(x.length, y.length);
          var rbt = this.makeRBT(N);
          var _ = this.stub(N);
          var rws = new Array(N);
          var rwst = new Array(N);
          var iwst = new Array(N);
          var nrws = new Array(N);
          var nrwst = new Array(N);
          var niwst = new Array(N);
          var rmws = out.words;
          rmws.length = N;
          this.convert13b(x.words, x.length, rws, N);
          this.convert13b(y.words, y.length, nrws, N);
          this.transform(rws, _, rwst, iwst, N, rbt);
          this.transform(nrws, _, nrwst, niwst, N, rbt);
          for (var i = 0; i < N; i++) {
            var rx = rwst[i] * nrwst[i] - iwst[i] * niwst[i];
            iwst[i] = rwst[i] * niwst[i] + iwst[i] * nrwst[i];
            rwst[i] = rx;
          }
          this.conjugate(rwst, iwst, N);
          this.transform(rwst, iwst, rmws, _, N, rbt);
          this.conjugate(rmws, _, N);
          this.normalize13b(rmws, N);
          out.negative = x.negative ^ y.negative;
          out.length = x.length + y.length;
          return out._strip();
        };
        BN.prototype.mul = function mul(num) {
          var out = new BN(null);
          out.words = new Array(this.length + num.length);
          return this.mulTo(num, out);
        };
        BN.prototype.mulf = function mulf(num) {
          var out = new BN(null);
          out.words = new Array(this.length + num.length);
          return jumboMulTo(this, num, out);
        };
        BN.prototype.imul = function imul(num) {
          return this.clone().mulTo(num, this);
        };
        BN.prototype.imuln = function imuln(num) {
          var isNegNum = num < 0;
          if (isNegNum)
            num = -num;
          assert(typeof num === "number");
          assert(num < 67108864);
          var carry = 0;
          for (var i = 0; i < this.length; i++) {
            var w = (this.words[i] | 0) * num;
            var lo = (w & 67108863) + (carry & 67108863);
            carry >>= 26;
            carry += w / 67108864 | 0;
            carry += lo >>> 26;
            this.words[i] = lo & 67108863;
          }
          if (carry !== 0) {
            this.words[i] = carry;
            this.length++;
          }
          return isNegNum ? this.ineg() : this;
        };
        BN.prototype.muln = function muln(num) {
          return this.clone().imuln(num);
        };
        BN.prototype.sqr = function sqr() {
          return this.mul(this);
        };
        BN.prototype.isqr = function isqr() {
          return this.imul(this.clone());
        };
        BN.prototype.pow = function pow(num) {
          var w = toBitArray(num);
          if (w.length === 0)
            return new BN(1);
          var res = this;
          for (var i = 0; i < w.length; i++, res = res.sqr()) {
            if (w[i] !== 0)
              break;
          }
          if (++i < w.length) {
            for (var q = res.sqr(); i < w.length; i++, q = q.sqr()) {
              if (w[i] === 0)
                continue;
              res = res.mul(q);
            }
          }
          return res;
        };
        BN.prototype.iushln = function iushln(bits) {
          assert(typeof bits === "number" && bits >= 0);
          var r = bits % 26;
          var s = (bits - r) / 26;
          var carryMask = 67108863 >>> 26 - r << 26 - r;
          var i;
          if (r !== 0) {
            var carry = 0;
            for (i = 0; i < this.length; i++) {
              var newCarry = this.words[i] & carryMask;
              var c = (this.words[i] | 0) - newCarry << r;
              this.words[i] = c | carry;
              carry = newCarry >>> 26 - r;
            }
            if (carry) {
              this.words[i] = carry;
              this.length++;
            }
          }
          if (s !== 0) {
            for (i = this.length - 1; i >= 0; i--) {
              this.words[i + s] = this.words[i];
            }
            for (i = 0; i < s; i++) {
              this.words[i] = 0;
            }
            this.length += s;
          }
          return this._strip();
        };
        BN.prototype.ishln = function ishln(bits) {
          assert(this.negative === 0);
          return this.iushln(bits);
        };
        BN.prototype.iushrn = function iushrn(bits, hint, extended) {
          assert(typeof bits === "number" && bits >= 0);
          var h;
          if (hint) {
            h = (hint - hint % 26) / 26;
          } else {
            h = 0;
          }
          var r = bits % 26;
          var s = Math.min((bits - r) / 26, this.length);
          var mask = 67108863 ^ 67108863 >>> r << r;
          var maskedWords = extended;
          h -= s;
          h = Math.max(0, h);
          if (maskedWords) {
            for (var i = 0; i < s; i++) {
              maskedWords.words[i] = this.words[i];
            }
            maskedWords.length = s;
          }
          if (s === 0) {
          } else if (this.length > s) {
            this.length -= s;
            for (i = 0; i < this.length; i++) {
              this.words[i] = this.words[i + s];
            }
          } else {
            this.words[0] = 0;
            this.length = 1;
          }
          var carry = 0;
          for (i = this.length - 1; i >= 0 && (carry !== 0 || i >= h); i--) {
            var word = this.words[i] | 0;
            this.words[i] = carry << 26 - r | word >>> r;
            carry = word & mask;
          }
          if (maskedWords && carry !== 0) {
            maskedWords.words[maskedWords.length++] = carry;
          }
          if (this.length === 0) {
            this.words[0] = 0;
            this.length = 1;
          }
          return this._strip();
        };
        BN.prototype.ishrn = function ishrn(bits, hint, extended) {
          assert(this.negative === 0);
          return this.iushrn(bits, hint, extended);
        };
        BN.prototype.shln = function shln(bits) {
          return this.clone().ishln(bits);
        };
        BN.prototype.ushln = function ushln(bits) {
          return this.clone().iushln(bits);
        };
        BN.prototype.shrn = function shrn(bits) {
          return this.clone().ishrn(bits);
        };
        BN.prototype.ushrn = function ushrn(bits) {
          return this.clone().iushrn(bits);
        };
        BN.prototype.testn = function testn(bit) {
          assert(typeof bit === "number" && bit >= 0);
          var r = bit % 26;
          var s = (bit - r) / 26;
          var q = 1 << r;
          if (this.length <= s)
            return false;
          var w = this.words[s];
          return !!(w & q);
        };
        BN.prototype.imaskn = function imaskn(bits) {
          assert(typeof bits === "number" && bits >= 0);
          var r = bits % 26;
          var s = (bits - r) / 26;
          assert(this.negative === 0, "imaskn works only with positive numbers");
          if (this.length <= s) {
            return this;
          }
          if (r !== 0) {
            s++;
          }
          this.length = Math.min(s, this.length);
          if (r !== 0) {
            var mask = 67108863 ^ 67108863 >>> r << r;
            this.words[this.length - 1] &= mask;
          }
          return this._strip();
        };
        BN.prototype.maskn = function maskn(bits) {
          return this.clone().imaskn(bits);
        };
        BN.prototype.iaddn = function iaddn(num) {
          assert(typeof num === "number");
          assert(num < 67108864);
          if (num < 0)
            return this.isubn(-num);
          if (this.negative !== 0) {
            if (this.length === 1 && (this.words[0] | 0) <= num) {
              this.words[0] = num - (this.words[0] | 0);
              this.negative = 0;
              return this;
            }
            this.negative = 0;
            this.isubn(num);
            this.negative = 1;
            return this;
          }
          return this._iaddn(num);
        };
        BN.prototype._iaddn = function _iaddn(num) {
          this.words[0] += num;
          for (var i = 0; i < this.length && this.words[i] >= 67108864; i++) {
            this.words[i] -= 67108864;
            if (i === this.length - 1) {
              this.words[i + 1] = 1;
            } else {
              this.words[i + 1]++;
            }
          }
          this.length = Math.max(this.length, i + 1);
          return this;
        };
        BN.prototype.isubn = function isubn(num) {
          assert(typeof num === "number");
          assert(num < 67108864);
          if (num < 0)
            return this.iaddn(-num);
          if (this.negative !== 0) {
            this.negative = 0;
            this.iaddn(num);
            this.negative = 1;
            return this;
          }
          this.words[0] -= num;
          if (this.length === 1 && this.words[0] < 0) {
            this.words[0] = -this.words[0];
            this.negative = 1;
          } else {
            for (var i = 0; i < this.length && this.words[i] < 0; i++) {
              this.words[i] += 67108864;
              this.words[i + 1] -= 1;
            }
          }
          return this._strip();
        };
        BN.prototype.addn = function addn(num) {
          return this.clone().iaddn(num);
        };
        BN.prototype.subn = function subn(num) {
          return this.clone().isubn(num);
        };
        BN.prototype.iabs = function iabs() {
          this.negative = 0;
          return this;
        };
        BN.prototype.abs = function abs() {
          return this.clone().iabs();
        };
        BN.prototype._ishlnsubmul = function _ishlnsubmul(num, mul, shift) {
          var len = num.length + shift;
          var i;
          this._expand(len);
          var w;
          var carry = 0;
          for (i = 0; i < num.length; i++) {
            w = (this.words[i + shift] | 0) + carry;
            var right = (num.words[i] | 0) * mul;
            w -= right & 67108863;
            carry = (w >> 26) - (right / 67108864 | 0);
            this.words[i + shift] = w & 67108863;
          }
          for (; i < this.length - shift; i++) {
            w = (this.words[i + shift] | 0) + carry;
            carry = w >> 26;
            this.words[i + shift] = w & 67108863;
          }
          if (carry === 0)
            return this._strip();
          assert(carry === -1);
          carry = 0;
          for (i = 0; i < this.length; i++) {
            w = -(this.words[i] | 0) + carry;
            carry = w >> 26;
            this.words[i] = w & 67108863;
          }
          this.negative = 1;
          return this._strip();
        };
        BN.prototype._wordDiv = function _wordDiv(num, mode) {
          var shift = this.length - num.length;
          var a = this.clone();
          var b = num;
          var bhi = b.words[b.length - 1] | 0;
          var bhiBits = this._countBits(bhi);
          shift = 26 - bhiBits;
          if (shift !== 0) {
            b = b.ushln(shift);
            a.iushln(shift);
            bhi = b.words[b.length - 1] | 0;
          }
          var m = a.length - b.length;
          var q;
          if (mode !== "mod") {
            q = new BN(null);
            q.length = m + 1;
            q.words = new Array(q.length);
            for (var i = 0; i < q.length; i++) {
              q.words[i] = 0;
            }
          }
          var diff = a.clone()._ishlnsubmul(b, 1, m);
          if (diff.negative === 0) {
            a = diff;
            if (q) {
              q.words[m] = 1;
            }
          }
          for (var j = m - 1; j >= 0; j--) {
            var qj = (a.words[b.length + j] | 0) * 67108864 + (a.words[b.length + j - 1] | 0);
            qj = Math.min(qj / bhi | 0, 67108863);
            a._ishlnsubmul(b, qj, j);
            while (a.negative !== 0) {
              qj--;
              a.negative = 0;
              a._ishlnsubmul(b, 1, j);
              if (!a.isZero()) {
                a.negative ^= 1;
              }
            }
            if (q) {
              q.words[j] = qj;
            }
          }
          if (q) {
            q._strip();
          }
          a._strip();
          if (mode !== "div" && shift !== 0) {
            a.iushrn(shift);
          }
          return {
            div: q || null,
            mod: a
          };
        };
        BN.prototype.divmod = function divmod(num, mode, positive) {
          assert(!num.isZero());
          if (this.isZero()) {
            return {
              div: new BN(0),
              mod: new BN(0)
            };
          }
          var div, mod2, res;
          if (this.negative !== 0 && num.negative === 0) {
            res = this.neg().divmod(num, mode);
            if (mode !== "mod") {
              div = res.div.neg();
            }
            if (mode !== "div") {
              mod2 = res.mod.neg();
              if (positive && mod2.negative !== 0) {
                mod2.iadd(num);
              }
            }
            return {
              div,
              mod: mod2
            };
          }
          if (this.negative === 0 && num.negative !== 0) {
            res = this.divmod(num.neg(), mode);
            if (mode !== "mod") {
              div = res.div.neg();
            }
            return {
              div,
              mod: res.mod
            };
          }
          if ((this.negative & num.negative) !== 0) {
            res = this.neg().divmod(num.neg(), mode);
            if (mode !== "div") {
              mod2 = res.mod.neg();
              if (positive && mod2.negative !== 0) {
                mod2.isub(num);
              }
            }
            return {
              div: res.div,
              mod: mod2
            };
          }
          if (num.length > this.length || this.cmp(num) < 0) {
            return {
              div: new BN(0),
              mod: this
            };
          }
          if (num.length === 1) {
            if (mode === "div") {
              return {
                div: this.divn(num.words[0]),
                mod: null
              };
            }
            if (mode === "mod") {
              return {
                div: null,
                mod: new BN(this.modrn(num.words[0]))
              };
            }
            return {
              div: this.divn(num.words[0]),
              mod: new BN(this.modrn(num.words[0]))
            };
          }
          return this._wordDiv(num, mode);
        };
        BN.prototype.div = function div(num) {
          return this.divmod(num, "div", false).div;
        };
        BN.prototype.mod = function mod2(num) {
          return this.divmod(num, "mod", false).mod;
        };
        BN.prototype.umod = function umod(num) {
          return this.divmod(num, "mod", true).mod;
        };
        BN.prototype.divRound = function divRound(num) {
          var dm = this.divmod(num);
          if (dm.mod.isZero())
            return dm.div;
          var mod2 = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;
          var half = num.ushrn(1);
          var r2 = num.andln(1);
          var cmp = mod2.cmp(half);
          if (cmp < 0 || r2 === 1 && cmp === 0)
            return dm.div;
          return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
        };
        BN.prototype.modrn = function modrn(num) {
          var isNegNum = num < 0;
          if (isNegNum)
            num = -num;
          assert(num <= 67108863);
          var p = (1 << 26) % num;
          var acc = 0;
          for (var i = this.length - 1; i >= 0; i--) {
            acc = (p * acc + (this.words[i] | 0)) % num;
          }
          return isNegNum ? -acc : acc;
        };
        BN.prototype.modn = function modn(num) {
          return this.modrn(num);
        };
        BN.prototype.idivn = function idivn(num) {
          var isNegNum = num < 0;
          if (isNegNum)
            num = -num;
          assert(num <= 67108863);
          var carry = 0;
          for (var i = this.length - 1; i >= 0; i--) {
            var w = (this.words[i] | 0) + carry * 67108864;
            this.words[i] = w / num | 0;
            carry = w % num;
          }
          this._strip();
          return isNegNum ? this.ineg() : this;
        };
        BN.prototype.divn = function divn(num) {
          return this.clone().idivn(num);
        };
        BN.prototype.egcd = function egcd(p) {
          assert(p.negative === 0);
          assert(!p.isZero());
          var x = this;
          var y = p.clone();
          if (x.negative !== 0) {
            x = x.umod(p);
          } else {
            x = x.clone();
          }
          var A = new BN(1);
          var B = new BN(0);
          var C = new BN(0);
          var D = new BN(1);
          var g = 0;
          while (x.isEven() && y.isEven()) {
            x.iushrn(1);
            y.iushrn(1);
            ++g;
          }
          var yp = y.clone();
          var xp = x.clone();
          while (!x.isZero()) {
            for (var i = 0, im = 1; (x.words[0] & im) === 0 && i < 26; ++i, im <<= 1)
              ;
            if (i > 0) {
              x.iushrn(i);
              while (i-- > 0) {
                if (A.isOdd() || B.isOdd()) {
                  A.iadd(yp);
                  B.isub(xp);
                }
                A.iushrn(1);
                B.iushrn(1);
              }
            }
            for (var j = 0, jm = 1; (y.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1)
              ;
            if (j > 0) {
              y.iushrn(j);
              while (j-- > 0) {
                if (C.isOdd() || D.isOdd()) {
                  C.iadd(yp);
                  D.isub(xp);
                }
                C.iushrn(1);
                D.iushrn(1);
              }
            }
            if (x.cmp(y) >= 0) {
              x.isub(y);
              A.isub(C);
              B.isub(D);
            } else {
              y.isub(x);
              C.isub(A);
              D.isub(B);
            }
          }
          return {
            a: C,
            b: D,
            gcd: y.iushln(g)
          };
        };
        BN.prototype._invmp = function _invmp(p) {
          assert(p.negative === 0);
          assert(!p.isZero());
          var a = this;
          var b = p.clone();
          if (a.negative !== 0) {
            a = a.umod(p);
          } else {
            a = a.clone();
          }
          var x1 = new BN(1);
          var x2 = new BN(0);
          var delta = b.clone();
          while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {
            for (var i = 0, im = 1; (a.words[0] & im) === 0 && i < 26; ++i, im <<= 1)
              ;
            if (i > 0) {
              a.iushrn(i);
              while (i-- > 0) {
                if (x1.isOdd()) {
                  x1.iadd(delta);
                }
                x1.iushrn(1);
              }
            }
            for (var j = 0, jm = 1; (b.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1)
              ;
            if (j > 0) {
              b.iushrn(j);
              while (j-- > 0) {
                if (x2.isOdd()) {
                  x2.iadd(delta);
                }
                x2.iushrn(1);
              }
            }
            if (a.cmp(b) >= 0) {
              a.isub(b);
              x1.isub(x2);
            } else {
              b.isub(a);
              x2.isub(x1);
            }
          }
          var res;
          if (a.cmpn(1) === 0) {
            res = x1;
          } else {
            res = x2;
          }
          if (res.cmpn(0) < 0) {
            res.iadd(p);
          }
          return res;
        };
        BN.prototype.gcd = function gcd(num) {
          if (this.isZero())
            return num.abs();
          if (num.isZero())
            return this.abs();
          var a = this.clone();
          var b = num.clone();
          a.negative = 0;
          b.negative = 0;
          for (var shift = 0; a.isEven() && b.isEven(); shift++) {
            a.iushrn(1);
            b.iushrn(1);
          }
          do {
            while (a.isEven()) {
              a.iushrn(1);
            }
            while (b.isEven()) {
              b.iushrn(1);
            }
            var r = a.cmp(b);
            if (r < 0) {
              var t = a;
              a = b;
              b = t;
            } else if (r === 0 || b.cmpn(1) === 0) {
              break;
            }
            a.isub(b);
          } while (true);
          return b.iushln(shift);
        };
        BN.prototype.invm = function invm(num) {
          return this.egcd(num).a.umod(num);
        };
        BN.prototype.isEven = function isEven() {
          return (this.words[0] & 1) === 0;
        };
        BN.prototype.isOdd = function isOdd() {
          return (this.words[0] & 1) === 1;
        };
        BN.prototype.andln = function andln(num) {
          return this.words[0] & num;
        };
        BN.prototype.bincn = function bincn(bit) {
          assert(typeof bit === "number");
          var r = bit % 26;
          var s = (bit - r) / 26;
          var q = 1 << r;
          if (this.length <= s) {
            this._expand(s + 1);
            this.words[s] |= q;
            return this;
          }
          var carry = q;
          for (var i = s; carry !== 0 && i < this.length; i++) {
            var w = this.words[i] | 0;
            w += carry;
            carry = w >>> 26;
            w &= 67108863;
            this.words[i] = w;
          }
          if (carry !== 0) {
            this.words[i] = carry;
            this.length++;
          }
          return this;
        };
        BN.prototype.isZero = function isZero() {
          return this.length === 1 && this.words[0] === 0;
        };
        BN.prototype.cmpn = function cmpn(num) {
          var negative = num < 0;
          if (this.negative !== 0 && !negative)
            return -1;
          if (this.negative === 0 && negative)
            return 1;
          this._strip();
          var res;
          if (this.length > 1) {
            res = 1;
          } else {
            if (negative) {
              num = -num;
            }
            assert(num <= 67108863, "Number is too big");
            var w = this.words[0] | 0;
            res = w === num ? 0 : w < num ? -1 : 1;
          }
          if (this.negative !== 0)
            return -res | 0;
          return res;
        };
        BN.prototype.cmp = function cmp(num) {
          if (this.negative !== 0 && num.negative === 0)
            return -1;
          if (this.negative === 0 && num.negative !== 0)
            return 1;
          var res = this.ucmp(num);
          if (this.negative !== 0)
            return -res | 0;
          return res;
        };
        BN.prototype.ucmp = function ucmp(num) {
          if (this.length > num.length)
            return 1;
          if (this.length < num.length)
            return -1;
          var res = 0;
          for (var i = this.length - 1; i >= 0; i--) {
            var a = this.words[i] | 0;
            var b = num.words[i] | 0;
            if (a === b)
              continue;
            if (a < b) {
              res = -1;
            } else if (a > b) {
              res = 1;
            }
            break;
          }
          return res;
        };
        BN.prototype.gtn = function gtn(num) {
          return this.cmpn(num) === 1;
        };
        BN.prototype.gt = function gt(num) {
          return this.cmp(num) === 1;
        };
        BN.prototype.gten = function gten(num) {
          return this.cmpn(num) >= 0;
        };
        BN.prototype.gte = function gte(num) {
          return this.cmp(num) >= 0;
        };
        BN.prototype.ltn = function ltn(num) {
          return this.cmpn(num) === -1;
        };
        BN.prototype.lt = function lt(num) {
          return this.cmp(num) === -1;
        };
        BN.prototype.lten = function lten(num) {
          return this.cmpn(num) <= 0;
        };
        BN.prototype.lte = function lte(num) {
          return this.cmp(num) <= 0;
        };
        BN.prototype.eqn = function eqn(num) {
          return this.cmpn(num) === 0;
        };
        BN.prototype.eq = function eq(num) {
          return this.cmp(num) === 0;
        };
        BN.red = function red(num) {
          return new Red(num);
        };
        BN.prototype.toRed = function toRed(ctx) {
          assert(!this.red, "Already a number in reduction context");
          assert(this.negative === 0, "red works only with positives");
          return ctx.convertTo(this)._forceRed(ctx);
        };
        BN.prototype.fromRed = function fromRed() {
          assert(this.red, "fromRed works only with numbers in reduction context");
          return this.red.convertFrom(this);
        };
        BN.prototype._forceRed = function _forceRed(ctx) {
          this.red = ctx;
          return this;
        };
        BN.prototype.forceRed = function forceRed(ctx) {
          assert(!this.red, "Already a number in reduction context");
          return this._forceRed(ctx);
        };
        BN.prototype.redAdd = function redAdd(num) {
          assert(this.red, "redAdd works only with red numbers");
          return this.red.add(this, num);
        };
        BN.prototype.redIAdd = function redIAdd(num) {
          assert(this.red, "redIAdd works only with red numbers");
          return this.red.iadd(this, num);
        };
        BN.prototype.redSub = function redSub(num) {
          assert(this.red, "redSub works only with red numbers");
          return this.red.sub(this, num);
        };
        BN.prototype.redISub = function redISub(num) {
          assert(this.red, "redISub works only with red numbers");
          return this.red.isub(this, num);
        };
        BN.prototype.redShl = function redShl(num) {
          assert(this.red, "redShl works only with red numbers");
          return this.red.shl(this, num);
        };
        BN.prototype.redMul = function redMul(num) {
          assert(this.red, "redMul works only with red numbers");
          this.red._verify2(this, num);
          return this.red.mul(this, num);
        };
        BN.prototype.redIMul = function redIMul(num) {
          assert(this.red, "redMul works only with red numbers");
          this.red._verify2(this, num);
          return this.red.imul(this, num);
        };
        BN.prototype.redSqr = function redSqr() {
          assert(this.red, "redSqr works only with red numbers");
          this.red._verify1(this);
          return this.red.sqr(this);
        };
        BN.prototype.redISqr = function redISqr() {
          assert(this.red, "redISqr works only with red numbers");
          this.red._verify1(this);
          return this.red.isqr(this);
        };
        BN.prototype.redSqrt = function redSqrt() {
          assert(this.red, "redSqrt works only with red numbers");
          this.red._verify1(this);
          return this.red.sqrt(this);
        };
        BN.prototype.redInvm = function redInvm() {
          assert(this.red, "redInvm works only with red numbers");
          this.red._verify1(this);
          return this.red.invm(this);
        };
        BN.prototype.redNeg = function redNeg() {
          assert(this.red, "redNeg works only with red numbers");
          this.red._verify1(this);
          return this.red.neg(this);
        };
        BN.prototype.redPow = function redPow(num) {
          assert(this.red && !num.red, "redPow(normalNum)");
          this.red._verify1(this);
          return this.red.pow(this, num);
        };
        var primes = {
          k256: null,
          p224: null,
          p192: null,
          p25519: null
        };
        function MPrime(name, p) {
          this.name = name;
          this.p = new BN(p, 16);
          this.n = this.p.bitLength();
          this.k = new BN(1).iushln(this.n).isub(this.p);
          this.tmp = this._tmp();
        }
        MPrime.prototype._tmp = function _tmp() {
          var tmp = new BN(null);
          tmp.words = new Array(Math.ceil(this.n / 13));
          return tmp;
        };
        MPrime.prototype.ireduce = function ireduce(num) {
          var r = num;
          var rlen;
          do {
            this.split(r, this.tmp);
            r = this.imulK(r);
            r = r.iadd(this.tmp);
            rlen = r.bitLength();
          } while (rlen > this.n);
          var cmp = rlen < this.n ? -1 : r.ucmp(this.p);
          if (cmp === 0) {
            r.words[0] = 0;
            r.length = 1;
          } else if (cmp > 0) {
            r.isub(this.p);
          } else {
            if (r.strip !== void 0) {
              r.strip();
            } else {
              r._strip();
            }
          }
          return r;
        };
        MPrime.prototype.split = function split(input, out) {
          input.iushrn(this.n, 0, out);
        };
        MPrime.prototype.imulK = function imulK(num) {
          return num.imul(this.k);
        };
        function K256() {
          MPrime.call(this, "k256", "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f");
        }
        inherits(K256, MPrime);
        K256.prototype.split = function split(input, output) {
          var mask = 4194303;
          var outLen = Math.min(input.length, 9);
          for (var i = 0; i < outLen; i++) {
            output.words[i] = input.words[i];
          }
          output.length = outLen;
          if (input.length <= 9) {
            input.words[0] = 0;
            input.length = 1;
            return;
          }
          var prev = input.words[9];
          output.words[output.length++] = prev & mask;
          for (i = 10; i < input.length; i++) {
            var next = input.words[i] | 0;
            input.words[i - 10] = (next & mask) << 4 | prev >>> 22;
            prev = next;
          }
          prev >>>= 22;
          input.words[i - 10] = prev;
          if (prev === 0 && input.length > 10) {
            input.length -= 10;
          } else {
            input.length -= 9;
          }
        };
        K256.prototype.imulK = function imulK(num) {
          num.words[num.length] = 0;
          num.words[num.length + 1] = 0;
          num.length += 2;
          var lo = 0;
          for (var i = 0; i < num.length; i++) {
            var w = num.words[i] | 0;
            lo += w * 977;
            num.words[i] = lo & 67108863;
            lo = w * 64 + (lo / 67108864 | 0);
          }
          if (num.words[num.length - 1] === 0) {
            num.length--;
            if (num.words[num.length - 1] === 0) {
              num.length--;
            }
          }
          return num;
        };
        function P224() {
          MPrime.call(this, "p224", "ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001");
        }
        inherits(P224, MPrime);
        function P192() {
          MPrime.call(this, "p192", "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff");
        }
        inherits(P192, MPrime);
        function P25519() {
          MPrime.call(this, "25519", "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed");
        }
        inherits(P25519, MPrime);
        P25519.prototype.imulK = function imulK(num) {
          var carry = 0;
          for (var i = 0; i < num.length; i++) {
            var hi = (num.words[i] | 0) * 19 + carry;
            var lo = hi & 67108863;
            hi >>>= 26;
            num.words[i] = lo;
            carry = hi;
          }
          if (carry !== 0) {
            num.words[num.length++] = carry;
          }
          return num;
        };
        BN._prime = function prime(name) {
          if (primes[name])
            return primes[name];
          var prime2;
          if (name === "k256") {
            prime2 = new K256();
          } else if (name === "p224") {
            prime2 = new P224();
          } else if (name === "p192") {
            prime2 = new P192();
          } else if (name === "p25519") {
            prime2 = new P25519();
          } else {
            throw new Error("Unknown prime " + name);
          }
          primes[name] = prime2;
          return prime2;
        };
        function Red(m) {
          if (typeof m === "string") {
            var prime = BN._prime(m);
            this.m = prime.p;
            this.prime = prime;
          } else {
            assert(m.gtn(1), "modulus must be greater than 1");
            this.m = m;
            this.prime = null;
          }
        }
        Red.prototype._verify1 = function _verify1(a) {
          assert(a.negative === 0, "red works only with positives");
          assert(a.red, "red works only with red numbers");
        };
        Red.prototype._verify2 = function _verify2(a, b) {
          assert((a.negative | b.negative) === 0, "red works only with positives");
          assert(a.red && a.red === b.red, "red works only with red numbers");
        };
        Red.prototype.imod = function imod(a) {
          if (this.prime)
            return this.prime.ireduce(a)._forceRed(this);
          move(a, a.umod(this.m)._forceRed(this));
          return a;
        };
        Red.prototype.neg = function neg(a) {
          if (a.isZero()) {
            return a.clone();
          }
          return this.m.sub(a)._forceRed(this);
        };
        Red.prototype.add = function add(a, b) {
          this._verify2(a, b);
          var res = a.add(b);
          if (res.cmp(this.m) >= 0) {
            res.isub(this.m);
          }
          return res._forceRed(this);
        };
        Red.prototype.iadd = function iadd(a, b) {
          this._verify2(a, b);
          var res = a.iadd(b);
          if (res.cmp(this.m) >= 0) {
            res.isub(this.m);
          }
          return res;
        };
        Red.prototype.sub = function sub(a, b) {
          this._verify2(a, b);
          var res = a.sub(b);
          if (res.cmpn(0) < 0) {
            res.iadd(this.m);
          }
          return res._forceRed(this);
        };
        Red.prototype.isub = function isub(a, b) {
          this._verify2(a, b);
          var res = a.isub(b);
          if (res.cmpn(0) < 0) {
            res.iadd(this.m);
          }
          return res;
        };
        Red.prototype.shl = function shl(a, num) {
          this._verify1(a);
          return this.imod(a.ushln(num));
        };
        Red.prototype.imul = function imul(a, b) {
          this._verify2(a, b);
          return this.imod(a.imul(b));
        };
        Red.prototype.mul = function mul(a, b) {
          this._verify2(a, b);
          return this.imod(a.mul(b));
        };
        Red.prototype.isqr = function isqr(a) {
          return this.imul(a, a.clone());
        };
        Red.prototype.sqr = function sqr(a) {
          return this.mul(a, a);
        };
        Red.prototype.sqrt = function sqrt(a) {
          if (a.isZero())
            return a.clone();
          var mod3 = this.m.andln(3);
          assert(mod3 % 2 === 1);
          if (mod3 === 3) {
            var pow = this.m.add(new BN(1)).iushrn(2);
            return this.pow(a, pow);
          }
          var q = this.m.subn(1);
          var s = 0;
          while (!q.isZero() && q.andln(1) === 0) {
            s++;
            q.iushrn(1);
          }
          assert(!q.isZero());
          var one = new BN(1).toRed(this);
          var nOne = one.redNeg();
          var lpow = this.m.subn(1).iushrn(1);
          var z = this.m.bitLength();
          z = new BN(2 * z * z).toRed(this);
          while (this.pow(z, lpow).cmp(nOne) !== 0) {
            z.redIAdd(nOne);
          }
          var c = this.pow(z, q);
          var r = this.pow(a, q.addn(1).iushrn(1));
          var t = this.pow(a, q);
          var m = s;
          while (t.cmp(one) !== 0) {
            var tmp = t;
            for (var i = 0; tmp.cmp(one) !== 0; i++) {
              tmp = tmp.redSqr();
            }
            assert(i < m);
            var b = this.pow(c, new BN(1).iushln(m - i - 1));
            r = r.redMul(b);
            c = b.redSqr();
            t = t.redMul(c);
            m = i;
          }
          return r;
        };
        Red.prototype.invm = function invm(a) {
          var inv = a._invmp(this.m);
          if (inv.negative !== 0) {
            inv.negative = 0;
            return this.imod(inv).redNeg();
          } else {
            return this.imod(inv);
          }
        };
        Red.prototype.pow = function pow(a, num) {
          if (num.isZero())
            return new BN(1).toRed(this);
          if (num.cmpn(1) === 0)
            return a.clone();
          var windowSize = 4;
          var wnd = new Array(1 << windowSize);
          wnd[0] = new BN(1).toRed(this);
          wnd[1] = a;
          for (var i = 2; i < wnd.length; i++) {
            wnd[i] = this.mul(wnd[i - 1], a);
          }
          var res = wnd[0];
          var current = 0;
          var currentLen = 0;
          var start2 = num.bitLength() % 26;
          if (start2 === 0) {
            start2 = 26;
          }
          for (i = num.length - 1; i >= 0; i--) {
            var word = num.words[i];
            for (var j = start2 - 1; j >= 0; j--) {
              var bit = word >> j & 1;
              if (res !== wnd[0]) {
                res = this.sqr(res);
              }
              if (bit === 0 && current === 0) {
                currentLen = 0;
                continue;
              }
              current <<= 1;
              current |= bit;
              currentLen++;
              if (currentLen !== windowSize && (i !== 0 || j !== 0))
                continue;
              res = this.mul(res, wnd[current]);
              currentLen = 0;
              current = 0;
            }
            start2 = 26;
          }
          return res;
        };
        Red.prototype.convertTo = function convertTo(num) {
          var r = num.umod(this.m);
          return r === num ? r.clone() : r;
        };
        Red.prototype.convertFrom = function convertFrom(num) {
          var res = num.clone();
          res.red = null;
          return res;
        };
        BN.mont = function mont(num) {
          return new Mont(num);
        };
        function Mont(m) {
          Red.call(this, m);
          this.shift = this.m.bitLength();
          if (this.shift % 26 !== 0) {
            this.shift += 26 - this.shift % 26;
          }
          this.r = new BN(1).iushln(this.shift);
          this.r2 = this.imod(this.r.sqr());
          this.rinv = this.r._invmp(this.m);
          this.minv = this.rinv.mul(this.r).isubn(1).div(this.m);
          this.minv = this.minv.umod(this.r);
          this.minv = this.r.sub(this.minv);
        }
        inherits(Mont, Red);
        Mont.prototype.convertTo = function convertTo(num) {
          return this.imod(num.ushln(this.shift));
        };
        Mont.prototype.convertFrom = function convertFrom(num) {
          var r = this.imod(num.mul(this.rinv));
          r.red = null;
          return r;
        };
        Mont.prototype.imul = function imul(a, b) {
          if (a.isZero() || b.isZero()) {
            a.words[0] = 0;
            a.length = 1;
            return a;
          }
          var t = a.imul(b);
          var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
          var u = t.isub(c).iushrn(this.shift);
          var res = u;
          if (u.cmp(this.m) >= 0) {
            res = u.isub(this.m);
          } else if (u.cmpn(0) < 0) {
            res = u.iadd(this.m);
          }
          return res._forceRed(this);
        };
        Mont.prototype.mul = function mul(a, b) {
          if (a.isZero() || b.isZero())
            return new BN(0)._forceRed(this);
          var t = a.mul(b);
          var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
          var u = t.isub(c).iushrn(this.shift);
          var res = u;
          if (u.cmp(this.m) >= 0) {
            res = u.isub(this.m);
          } else if (u.cmpn(0) < 0) {
            res = u.iadd(this.m);
          }
          return res._forceRed(this);
        };
        Mont.prototype.invm = function invm(a) {
          var res = this.imod(a._invmp(this.m).mul(this.r2));
          return res._forceRed(this);
        };
      })(typeof module2 === "undefined" || module2, exports2);
    }
  });

  // node_modules/@cosmjs/crypto/build/secp256k1signature.js
  var require_secp256k1signature = __commonJS({
    "node_modules/@cosmjs/crypto/build/secp256k1signature.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.ExtendedSecp256k1Signature = exports2.Secp256k1Signature = void 0;
      function trimLeadingNullBytes(inData) {
        let numberOfLeadingNullBytes = 0;
        for (const byte of inData) {
          if (byte === 0) {
            numberOfLeadingNullBytes++;
          } else {
            break;
          }
        }
        return inData.slice(numberOfLeadingNullBytes);
      }
      var derTagInteger = 2;
      var Secp256k1Signature = class {
        constructor(r, s) {
          if (r.length > 32 || r.length === 0 || r[0] === 0) {
            throw new Error("Unsigned integer r must be encoded as unpadded big endian.");
          }
          if (s.length > 32 || s.length === 0 || s[0] === 0) {
            throw new Error("Unsigned integer s must be encoded as unpadded big endian.");
          }
          this.data = {
            r,
            s
          };
        }
        static fromFixedLength(data) {
          if (data.length !== 64) {
            throw new Error(`Got invalid data length: ${data.length}. Expected 2x 32 bytes for the pair (r, s)`);
          }
          return new Secp256k1Signature(trimLeadingNullBytes(data.slice(0, 32)), trimLeadingNullBytes(data.slice(32, 64)));
        }
        static fromDer(data) {
          let pos = 0;
          if (data[pos++] !== 48) {
            throw new Error("Prefix 0x30 expected");
          }
          const bodyLength = data[pos++];
          if (data.length - pos !== bodyLength) {
            throw new Error("Data length mismatch detected");
          }
          const rTag = data[pos++];
          if (rTag !== derTagInteger) {
            throw new Error("INTEGER tag expected");
          }
          const rLength = data[pos++];
          if (rLength >= 128) {
            throw new Error("Decoding length values above 127 not supported");
          }
          const rData = data.slice(pos, pos + rLength);
          pos += rLength;
          const sTag = data[pos++];
          if (sTag !== derTagInteger) {
            throw new Error("INTEGER tag expected");
          }
          const sLength = data[pos++];
          if (sLength >= 128) {
            throw new Error("Decoding length values above 127 not supported");
          }
          const sData = data.slice(pos, pos + sLength);
          pos += sLength;
          return new Secp256k1Signature(trimLeadingNullBytes(rData), trimLeadingNullBytes(sData));
        }
        r(length) {
          if (length === void 0) {
            return this.data.r;
          } else {
            const paddingLength = length - this.data.r.length;
            if (paddingLength < 0) {
              throw new Error("Length too small to hold parameter r");
            }
            const padding = new Uint8Array(paddingLength);
            return new Uint8Array([...padding, ...this.data.r]);
          }
        }
        s(length) {
          if (length === void 0) {
            return this.data.s;
          } else {
            const paddingLength = length - this.data.s.length;
            if (paddingLength < 0) {
              throw new Error("Length too small to hold parameter s");
            }
            const padding = new Uint8Array(paddingLength);
            return new Uint8Array([...padding, ...this.data.s]);
          }
        }
        toFixedLength() {
          return new Uint8Array([...this.r(32), ...this.s(32)]);
        }
        toDer() {
          const rEncoded = this.data.r[0] >= 128 ? new Uint8Array([0, ...this.data.r]) : this.data.r;
          const sEncoded = this.data.s[0] >= 128 ? new Uint8Array([0, ...this.data.s]) : this.data.s;
          const rLength = rEncoded.length;
          const sLength = sEncoded.length;
          const data = new Uint8Array([derTagInteger, rLength, ...rEncoded, derTagInteger, sLength, ...sEncoded]);
          return new Uint8Array([48, data.length, ...data]);
        }
      };
      exports2.Secp256k1Signature = Secp256k1Signature;
      var ExtendedSecp256k1Signature = class extends Secp256k1Signature {
        constructor(r, s, recovery) {
          super(r, s);
          if (!Number.isInteger(recovery)) {
            throw new Error("The recovery parameter must be an integer.");
          }
          if (recovery < 0 || recovery > 4) {
            throw new Error("The recovery parameter must be one of 0, 1, 2, 3.");
          }
          this.recovery = recovery;
        }
        static fromFixedLength(data) {
          if (data.length !== 65) {
            throw new Error(`Got invalid data length ${data.length}. Expected 32 + 32 + 1`);
          }
          return new ExtendedSecp256k1Signature(trimLeadingNullBytes(data.slice(0, 32)), trimLeadingNullBytes(data.slice(32, 64)), data[64]);
        }
        toFixedLength() {
          return new Uint8Array([...this.r(32), ...this.s(32), this.recovery]);
        }
      };
      exports2.ExtendedSecp256k1Signature = ExtendedSecp256k1Signature;
    }
  });

  // node_modules/@cosmjs/crypto/build/secp256k1.js
  var require_secp256k12 = __commonJS({
    "node_modules/@cosmjs/crypto/build/secp256k1.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.Secp256k1 = void 0;
      var encoding_1 = require_build2();
      var bn_js_1 = __importDefault(require_bn5());
      var elliptic_1 = __importDefault(require_elliptic());
      var secp256k1signature_1 = require_secp256k1signature();
      var secp256k1 = new elliptic_1.default.ec("secp256k1");
      var secp256k1N = new bn_js_1.default("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141", "hex");
      var Secp256k1 = class {
        static async makeKeypair(privkey) {
          if (privkey.length !== 32) {
            throw new Error("input data is not a valid secp256k1 private key");
          }
          const keypair = secp256k1.keyFromPrivate(privkey);
          if (keypair.validate().result !== true) {
            throw new Error("input data is not a valid secp256k1 private key");
          }
          const privkeyAsBigInteger = new bn_js_1.default(privkey);
          if (privkeyAsBigInteger.gte(secp256k1N)) {
            throw new Error("input data is not a valid secp256k1 private key");
          }
          const out = {
            privkey: (0, encoding_1.fromHex)(keypair.getPrivate("hex")),
            pubkey: Uint8Array.from(keypair.getPublic("array"))
          };
          return out;
        }
        static async createSignature(messageHash, privkey) {
          if (messageHash.length === 0) {
            throw new Error("Message hash must not be empty");
          }
          if (messageHash.length > 32) {
            throw new Error("Message hash length must not exceed 32 bytes");
          }
          const keypair = secp256k1.keyFromPrivate(privkey);
          const { r, s, recoveryParam } = keypair.sign(messageHash, { canonical: true });
          if (typeof recoveryParam !== "number")
            throw new Error("Recovery param missing");
          return new secp256k1signature_1.ExtendedSecp256k1Signature(Uint8Array.from(r.toArray()), Uint8Array.from(s.toArray()), recoveryParam);
        }
        static async verifySignature(signature, messageHash, pubkey) {
          if (messageHash.length === 0) {
            throw new Error("Message hash must not be empty");
          }
          if (messageHash.length > 32) {
            throw new Error("Message hash length must not exceed 32 bytes");
          }
          const keypair = secp256k1.keyFromPublic(pubkey);
          try {
            return keypair.verify(messageHash, signature.toDer());
          } catch (error) {
            return false;
          }
        }
        static recoverPubkey(signature, messageHash) {
          const signatureForElliptic = { r: (0, encoding_1.toHex)(signature.r()), s: (0, encoding_1.toHex)(signature.s()) };
          const point = secp256k1.recoverPubKey(messageHash, signatureForElliptic, signature.recovery);
          const keypair = secp256k1.keyFromPublic(point);
          return (0, encoding_1.fromHex)(keypair.getPublic(false, "hex"));
        }
        static compressPubkey(pubkey) {
          switch (pubkey.length) {
            case 33:
              return pubkey;
            case 65:
              return Uint8Array.from(secp256k1.keyFromPublic(pubkey).getPublic(true, "array"));
            default:
              throw new Error("Invalid pubkey length");
          }
        }
        static uncompressPubkey(pubkey) {
          switch (pubkey.length) {
            case 33:
              return Uint8Array.from(secp256k1.keyFromPublic(pubkey).getPublic(false, "array"));
            case 65:
              return pubkey;
            default:
              throw new Error("Invalid pubkey length");
          }
        }
        static trimRecoveryByte(signature) {
          switch (signature.length) {
            case 64:
              return signature;
            case 65:
              return signature.slice(0, 64);
            default:
              throw new Error("Invalid signature length");
          }
        }
      };
      exports2.Secp256k1 = Secp256k1;
    }
  });

  // node_modules/@cosmjs/crypto/build/slip10.js
  var require_slip10 = __commonJS({
    "node_modules/@cosmjs/crypto/build/slip10.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.stringToPath = exports2.pathToString = exports2.Slip10 = exports2.Slip10RawIndex = exports2.slip10CurveFromString = exports2.Slip10Curve = void 0;
      var encoding_1 = require_build2();
      var math_1 = require_build();
      var bn_js_1 = __importDefault(require_bn5());
      var elliptic_1 = __importDefault(require_elliptic());
      var hmac_1 = require_hmac3();
      var sha_1 = require_sha5();
      var Slip10Curve;
      (function(Slip10Curve2) {
        Slip10Curve2["Secp256k1"] = "Bitcoin seed";
        Slip10Curve2["Ed25519"] = "ed25519 seed";
      })(Slip10Curve = exports2.Slip10Curve || (exports2.Slip10Curve = {}));
      function slip10CurveFromString(curveString) {
        switch (curveString) {
          case Slip10Curve.Ed25519:
            return Slip10Curve.Ed25519;
          case Slip10Curve.Secp256k1:
            return Slip10Curve.Secp256k1;
          default:
            throw new Error(`Unknown curve string: '${curveString}'`);
        }
      }
      exports2.slip10CurveFromString = slip10CurveFromString;
      var Slip10RawIndex = class extends math_1.Uint32 {
        static hardened(hardenedIndex) {
          return new Slip10RawIndex(hardenedIndex + 2 ** 31);
        }
        static normal(normalIndex) {
          return new Slip10RawIndex(normalIndex);
        }
        isHardened() {
          return this.data >= 2 ** 31;
        }
      };
      exports2.Slip10RawIndex = Slip10RawIndex;
      var secp256k1 = new elliptic_1.default.ec("secp256k1");
      var Slip10 = class {
        static derivePath(curve, seed, path) {
          let result = this.master(curve, seed);
          for (const rawIndex of path) {
            result = this.child(curve, result.privkey, result.chainCode, rawIndex);
          }
          return result;
        }
        static master(curve, seed) {
          const i = new hmac_1.Hmac(sha_1.Sha512, (0, encoding_1.toAscii)(curve)).update(seed).digest();
          const il = i.slice(0, 32);
          const ir = i.slice(32, 64);
          if (curve !== Slip10Curve.Ed25519 && (this.isZero(il) || this.isGteN(curve, il))) {
            return this.master(curve, i);
          }
          return {
            chainCode: ir,
            privkey: il
          };
        }
        static child(curve, parentPrivkey, parentChainCode, rawIndex) {
          let i;
          if (rawIndex.isHardened()) {
            const payload = new Uint8Array([0, ...parentPrivkey, ...rawIndex.toBytesBigEndian()]);
            i = new hmac_1.Hmac(sha_1.Sha512, parentChainCode).update(payload).digest();
          } else {
            if (curve === Slip10Curve.Ed25519) {
              throw new Error("Normal keys are not allowed with ed25519");
            } else {
              const data = new Uint8Array([
                ...Slip10.serializedPoint(curve, new bn_js_1.default(parentPrivkey)),
                ...rawIndex.toBytesBigEndian()
              ]);
              i = new hmac_1.Hmac(sha_1.Sha512, parentChainCode).update(data).digest();
            }
          }
          return this.childImpl(curve, parentPrivkey, parentChainCode, rawIndex, i);
        }
        static serializedPoint(curve, p) {
          switch (curve) {
            case Slip10Curve.Secp256k1:
              return (0, encoding_1.fromHex)(secp256k1.g.mul(p).encodeCompressed("hex"));
            default:
              throw new Error("curve not supported");
          }
        }
        static childImpl(curve, parentPrivkey, parentChainCode, rawIndex, i) {
          const il = i.slice(0, 32);
          const ir = i.slice(32, 64);
          const returnChainCode = ir;
          if (curve === Slip10Curve.Ed25519) {
            return {
              chainCode: returnChainCode,
              privkey: il
            };
          }
          const n = this.n(curve);
          const returnChildKeyAsNumber = new bn_js_1.default(il).add(new bn_js_1.default(parentPrivkey)).mod(n);
          const returnChildKey = Uint8Array.from(returnChildKeyAsNumber.toArray("be", 32));
          if (this.isGteN(curve, il) || this.isZero(returnChildKey)) {
            const newI = new hmac_1.Hmac(sha_1.Sha512, parentChainCode).update(new Uint8Array([1, ...ir, ...rawIndex.toBytesBigEndian()])).digest();
            return this.childImpl(curve, parentPrivkey, parentChainCode, rawIndex, newI);
          }
          return {
            chainCode: returnChainCode,
            privkey: returnChildKey
          };
        }
        static isZero(privkey) {
          return privkey.every((byte) => byte === 0);
        }
        static isGteN(curve, privkey) {
          const keyAsNumber = new bn_js_1.default(privkey);
          return keyAsNumber.gte(this.n(curve));
        }
        static n(curve) {
          switch (curve) {
            case Slip10Curve.Secp256k1:
              return new bn_js_1.default("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141", 16);
            default:
              throw new Error("curve not supported");
          }
        }
      };
      exports2.Slip10 = Slip10;
      function pathToString(path) {
        return path.reduce((current, component) => {
          const componentString = component.isHardened() ? `${component.toNumber() - 2 ** 31}'` : component.toString();
          return current + "/" + componentString;
        }, "m");
      }
      exports2.pathToString = pathToString;
      function stringToPath(input) {
        if (!input.startsWith("m"))
          throw new Error("Path string must start with 'm'");
        let rest = input.slice(1);
        const out = new Array();
        while (rest) {
          const match = rest.match(/^\/([0-9]+)('?)/);
          if (!match)
            throw new Error("Syntax error while reading path component");
          const [fullMatch, numberString, apostrophe] = match;
          const value = math_1.Uint53.fromString(numberString).toNumber();
          if (value >= 2 ** 31)
            throw new Error("Component value too high. Must not exceed 2**31-1.");
          if (apostrophe)
            out.push(Slip10RawIndex.hardened(value));
          else
            out.push(Slip10RawIndex.normal(value));
          rest = rest.slice(fullMatch.length);
        }
        return out;
      }
      exports2.stringToPath = stringToPath;
    }
  });

  // node_modules/@cosmjs/crypto/build/index.js
  var require_build4 = __commonJS({
    "node_modules/@cosmjs/crypto/build/index.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.stringToPath = exports2.Slip10RawIndex = exports2.slip10CurveFromString = exports2.Slip10Curve = exports2.Slip10 = exports2.pathToString = exports2.sha512 = exports2.Sha512 = exports2.sha256 = exports2.Sha256 = exports2.Secp256k1Signature = exports2.ExtendedSecp256k1Signature = exports2.Secp256k1 = exports2.ripemd160 = exports2.Ripemd160 = exports2.Random = exports2.Xchacha20poly1305Ietf = exports2.xchacha20NonceLength = exports2.isArgon2idOptions = exports2.Ed25519Keypair = exports2.Ed25519 = exports2.Argon2id = exports2.keccak256 = exports2.Keccak256 = exports2.Hmac = exports2.EnglishMnemonic = exports2.Bip39 = void 0;
      var bip39_1 = require_bip39();
      Object.defineProperty(exports2, "Bip39", { enumerable: true, get: function() {
        return bip39_1.Bip39;
      } });
      Object.defineProperty(exports2, "EnglishMnemonic", { enumerable: true, get: function() {
        return bip39_1.EnglishMnemonic;
      } });
      var hmac_1 = require_hmac3();
      Object.defineProperty(exports2, "Hmac", { enumerable: true, get: function() {
        return hmac_1.Hmac;
      } });
      var keccak_1 = require_keccak();
      Object.defineProperty(exports2, "Keccak256", { enumerable: true, get: function() {
        return keccak_1.Keccak256;
      } });
      Object.defineProperty(exports2, "keccak256", { enumerable: true, get: function() {
        return keccak_1.keccak256;
      } });
      var libsodium_1 = require_libsodium2();
      Object.defineProperty(exports2, "Argon2id", { enumerable: true, get: function() {
        return libsodium_1.Argon2id;
      } });
      Object.defineProperty(exports2, "Ed25519", { enumerable: true, get: function() {
        return libsodium_1.Ed25519;
      } });
      Object.defineProperty(exports2, "Ed25519Keypair", { enumerable: true, get: function() {
        return libsodium_1.Ed25519Keypair;
      } });
      Object.defineProperty(exports2, "isArgon2idOptions", { enumerable: true, get: function() {
        return libsodium_1.isArgon2idOptions;
      } });
      Object.defineProperty(exports2, "xchacha20NonceLength", { enumerable: true, get: function() {
        return libsodium_1.xchacha20NonceLength;
      } });
      Object.defineProperty(exports2, "Xchacha20poly1305Ietf", { enumerable: true, get: function() {
        return libsodium_1.Xchacha20poly1305Ietf;
      } });
      var random_1 = require_random();
      Object.defineProperty(exports2, "Random", { enumerable: true, get: function() {
        return random_1.Random;
      } });
      var ripemd_1 = require_ripemd2();
      Object.defineProperty(exports2, "Ripemd160", { enumerable: true, get: function() {
        return ripemd_1.Ripemd160;
      } });
      Object.defineProperty(exports2, "ripemd160", { enumerable: true, get: function() {
        return ripemd_1.ripemd160;
      } });
      var secp256k1_1 = require_secp256k12();
      Object.defineProperty(exports2, "Secp256k1", { enumerable: true, get: function() {
        return secp256k1_1.Secp256k1;
      } });
      var secp256k1signature_1 = require_secp256k1signature();
      Object.defineProperty(exports2, "ExtendedSecp256k1Signature", { enumerable: true, get: function() {
        return secp256k1signature_1.ExtendedSecp256k1Signature;
      } });
      Object.defineProperty(exports2, "Secp256k1Signature", { enumerable: true, get: function() {
        return secp256k1signature_1.Secp256k1Signature;
      } });
      var sha_1 = require_sha5();
      Object.defineProperty(exports2, "Sha256", { enumerable: true, get: function() {
        return sha_1.Sha256;
      } });
      Object.defineProperty(exports2, "sha256", { enumerable: true, get: function() {
        return sha_1.sha256;
      } });
      Object.defineProperty(exports2, "Sha512", { enumerable: true, get: function() {
        return sha_1.Sha512;
      } });
      Object.defineProperty(exports2, "sha512", { enumerable: true, get: function() {
        return sha_1.sha512;
      } });
      var slip10_1 = require_slip10();
      Object.defineProperty(exports2, "pathToString", { enumerable: true, get: function() {
        return slip10_1.pathToString;
      } });
      Object.defineProperty(exports2, "Slip10", { enumerable: true, get: function() {
        return slip10_1.Slip10;
      } });
      Object.defineProperty(exports2, "Slip10Curve", { enumerable: true, get: function() {
        return slip10_1.Slip10Curve;
      } });
      Object.defineProperty(exports2, "slip10CurveFromString", { enumerable: true, get: function() {
        return slip10_1.slip10CurveFromString;
      } });
      Object.defineProperty(exports2, "Slip10RawIndex", { enumerable: true, get: function() {
        return slip10_1.Slip10RawIndex;
      } });
      Object.defineProperty(exports2, "stringToPath", { enumerable: true, get: function() {
        return slip10_1.stringToPath;
      } });
    }
  });

  // node_modules/@cosmjs/amino/build/pubkeys.js
  var require_pubkeys = __commonJS({
    "node_modules/@cosmjs/amino/build/pubkeys.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.isMultisigThresholdPubkey = exports2.isSinglePubkey = exports2.pubkeyType = exports2.isSecp256k1Pubkey = exports2.isEd25519Pubkey = void 0;
      function isEd25519Pubkey(pubkey) {
        return pubkey.type === "tendermint/PubKeyEd25519";
      }
      exports2.isEd25519Pubkey = isEd25519Pubkey;
      function isSecp256k1Pubkey(pubkey) {
        return pubkey.type === "tendermint/PubKeySecp256k1";
      }
      exports2.isSecp256k1Pubkey = isSecp256k1Pubkey;
      exports2.pubkeyType = {
        secp256k1: "tendermint/PubKeySecp256k1",
        ed25519: "tendermint/PubKeyEd25519",
        sr25519: "tendermint/PubKeySr25519",
        multisigThreshold: "tendermint/PubKeyMultisigThreshold"
      };
      function isSinglePubkey(pubkey) {
        const singPubkeyTypes = [exports2.pubkeyType.ed25519, exports2.pubkeyType.secp256k1, exports2.pubkeyType.sr25519];
        return singPubkeyTypes.includes(pubkey.type);
      }
      exports2.isSinglePubkey = isSinglePubkey;
      function isMultisigThresholdPubkey(pubkey) {
        return pubkey.type === "tendermint/PubKeyMultisigThreshold";
      }
      exports2.isMultisigThresholdPubkey = isMultisigThresholdPubkey;
    }
  });

  // node_modules/@cosmjs/amino/build/encoding.js
  var require_encoding = __commonJS({
    "node_modules/@cosmjs/amino/build/encoding.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.encodeBech32Pubkey = exports2.encodeAminoPubkey = exports2.decodeBech32Pubkey = exports2.decodeAminoPubkey = exports2.encodeSecp256k1Pubkey = void 0;
      var encoding_1 = require_build2();
      var math_1 = require_build();
      var utils_1 = require_build3();
      var pubkeys_1 = require_pubkeys();
      function encodeSecp256k1Pubkey(pubkey) {
        if (pubkey.length !== 33 || pubkey[0] !== 2 && pubkey[0] !== 3) {
          throw new Error("Public key must be compressed secp256k1, i.e. 33 bytes starting with 0x02 or 0x03");
        }
        return {
          type: pubkeys_1.pubkeyType.secp256k1,
          value: (0, encoding_1.toBase64)(pubkey)
        };
      }
      exports2.encodeSecp256k1Pubkey = encodeSecp256k1Pubkey;
      var pubkeyAminoPrefixSecp256k1 = (0, encoding_1.fromHex)("eb5ae98721");
      var pubkeyAminoPrefixEd25519 = (0, encoding_1.fromHex)("1624de6420");
      var pubkeyAminoPrefixSr25519 = (0, encoding_1.fromHex)("0dfb100520");
      var pubkeyAminoPrefixMultisigThreshold = (0, encoding_1.fromHex)("22c1f7e2");
      function decodeAminoPubkey(data) {
        if ((0, utils_1.arrayContentStartsWith)(data, pubkeyAminoPrefixSecp256k1)) {
          const rest = data.slice(pubkeyAminoPrefixSecp256k1.length);
          if (rest.length !== 33) {
            throw new Error("Invalid rest data length. Expected 33 bytes (compressed secp256k1 pubkey).");
          }
          return {
            type: pubkeys_1.pubkeyType.secp256k1,
            value: (0, encoding_1.toBase64)(rest)
          };
        } else if ((0, utils_1.arrayContentStartsWith)(data, pubkeyAminoPrefixEd25519)) {
          const rest = data.slice(pubkeyAminoPrefixEd25519.length);
          if (rest.length !== 32) {
            throw new Error("Invalid rest data length. Expected 32 bytes (Ed25519 pubkey).");
          }
          return {
            type: pubkeys_1.pubkeyType.ed25519,
            value: (0, encoding_1.toBase64)(rest)
          };
        } else if ((0, utils_1.arrayContentStartsWith)(data, pubkeyAminoPrefixSr25519)) {
          const rest = data.slice(pubkeyAminoPrefixSr25519.length);
          if (rest.length !== 32) {
            throw new Error("Invalid rest data length. Expected 32 bytes (Sr25519 pubkey).");
          }
          return {
            type: pubkeys_1.pubkeyType.sr25519,
            value: (0, encoding_1.toBase64)(rest)
          };
        } else if ((0, utils_1.arrayContentStartsWith)(data, pubkeyAminoPrefixMultisigThreshold)) {
          return decodeMultisigPubkey(data);
        } else {
          throw new Error("Unsupported public key type. Amino data starts with: " + (0, encoding_1.toHex)(data.slice(0, 5)));
        }
      }
      exports2.decodeAminoPubkey = decodeAminoPubkey;
      function decodeBech32Pubkey(bechEncoded) {
        const { data } = (0, encoding_1.fromBech32)(bechEncoded);
        return decodeAminoPubkey(data);
      }
      exports2.decodeBech32Pubkey = decodeBech32Pubkey;
      function decodeUvarint(reader) {
        if (reader.length < 1) {
          throw new Error("Can't decode varint. EOF");
        }
        if (reader[0] > 127) {
          throw new Error("Decoding numbers > 127 is not supported here. Please tell those lazy CosmJS maintainers to port the binary.Varint implementation from the Go standard library and write some tests.");
        }
        return [reader[0], 1];
      }
      function decodeMultisigPubkey(data) {
        const reader = Array.from(data);
        const prefixFromReader = reader.splice(0, pubkeyAminoPrefixMultisigThreshold.length);
        if (!(0, utils_1.arrayContentStartsWith)(prefixFromReader, pubkeyAminoPrefixMultisigThreshold)) {
          throw new Error("Invalid multisig prefix.");
        }
        if (reader.shift() != 8) {
          throw new Error("Invalid multisig data. Expecting 0x08 prefix before threshold.");
        }
        const [threshold, thresholdBytesLength] = decodeUvarint(reader);
        reader.splice(0, thresholdBytesLength);
        const pubkeys = [];
        while (reader.length > 0) {
          if (reader.shift() != 18) {
            throw new Error("Invalid multisig data. Expecting 0x12 prefix before participant pubkey length.");
          }
          const [pubkeyLength, pubkeyLengthBytesSize] = decodeUvarint(reader);
          reader.splice(0, pubkeyLengthBytesSize);
          if (reader.length < pubkeyLength) {
            throw new Error("Invalid multisig data length.");
          }
          const encodedPubkey = reader.splice(0, pubkeyLength);
          const pubkey = decodeAminoPubkey(Uint8Array.from(encodedPubkey));
          pubkeys.push(pubkey);
        }
        return {
          type: pubkeys_1.pubkeyType.multisigThreshold,
          value: {
            threshold: threshold.toString(),
            pubkeys
          }
        };
      }
      function encodeUvarint(value) {
        const checked = math_1.Uint53.fromString(value.toString()).toNumber();
        if (checked > 127) {
          throw new Error("Encoding numbers > 127 is not supported here. Please tell those lazy CosmJS maintainers to port the binary.PutUvarint implementation from the Go standard library and write some tests.");
        }
        return [checked];
      }
      function encodeAminoPubkey(pubkey) {
        if ((0, pubkeys_1.isMultisigThresholdPubkey)(pubkey)) {
          const out = Array.from(pubkeyAminoPrefixMultisigThreshold);
          out.push(8);
          out.push(...encodeUvarint(pubkey.value.threshold));
          for (const pubkeyData of pubkey.value.pubkeys.map((p) => encodeAminoPubkey(p))) {
            out.push(18);
            out.push(...encodeUvarint(pubkeyData.length));
            out.push(...pubkeyData);
          }
          return new Uint8Array(out);
        } else if ((0, pubkeys_1.isEd25519Pubkey)(pubkey)) {
          return new Uint8Array([...pubkeyAminoPrefixEd25519, ...(0, encoding_1.fromBase64)(pubkey.value)]);
        } else if ((0, pubkeys_1.isSecp256k1Pubkey)(pubkey)) {
          return new Uint8Array([...pubkeyAminoPrefixSecp256k1, ...(0, encoding_1.fromBase64)(pubkey.value)]);
        } else {
          throw new Error("Unsupported pubkey type");
        }
      }
      exports2.encodeAminoPubkey = encodeAminoPubkey;
      function encodeBech32Pubkey(pubkey, prefix) {
        return (0, encoding_1.toBech32)(prefix, encodeAminoPubkey(pubkey));
      }
      exports2.encodeBech32Pubkey = encodeBech32Pubkey;
    }
  });

  // node_modules/@cosmjs/amino/build/addresses.js
  var require_addresses = __commonJS({
    "node_modules/@cosmjs/amino/build/addresses.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.pubkeyToAddress = exports2.pubkeyToRawAddress = exports2.rawSecp256k1PubkeyToRawAddress = exports2.rawEd25519PubkeyToRawAddress = void 0;
      var crypto_1 = require_build4();
      var encoding_1 = require_build2();
      var encoding_2 = require_encoding();
      var pubkeys_1 = require_pubkeys();
      function rawEd25519PubkeyToRawAddress(pubkeyData) {
        if (pubkeyData.length !== 32) {
          throw new Error(`Invalid Ed25519 pubkey length: ${pubkeyData.length}`);
        }
        return (0, crypto_1.sha256)(pubkeyData).slice(0, 20);
      }
      exports2.rawEd25519PubkeyToRawAddress = rawEd25519PubkeyToRawAddress;
      function rawSecp256k1PubkeyToRawAddress(pubkeyData) {
        if (pubkeyData.length !== 33) {
          throw new Error(`Invalid Secp256k1 pubkey length (compressed): ${pubkeyData.length}`);
        }
        return (0, crypto_1.ripemd160)((0, crypto_1.sha256)(pubkeyData));
      }
      exports2.rawSecp256k1PubkeyToRawAddress = rawSecp256k1PubkeyToRawAddress;
      function pubkeyToRawAddress(pubkey) {
        if ((0, pubkeys_1.isSecp256k1Pubkey)(pubkey)) {
          const pubkeyData = (0, encoding_1.fromBase64)(pubkey.value);
          return rawSecp256k1PubkeyToRawAddress(pubkeyData);
        } else if ((0, pubkeys_1.isEd25519Pubkey)(pubkey)) {
          const pubkeyData = (0, encoding_1.fromBase64)(pubkey.value);
          return rawEd25519PubkeyToRawAddress(pubkeyData);
        } else if ((0, pubkeys_1.isMultisigThresholdPubkey)(pubkey)) {
          const pubkeyData = (0, encoding_2.encodeAminoPubkey)(pubkey);
          return (0, crypto_1.sha256)(pubkeyData).slice(0, 20);
        } else {
          throw new Error("Unsupported public key type");
        }
      }
      exports2.pubkeyToRawAddress = pubkeyToRawAddress;
      function pubkeyToAddress(pubkey, prefix) {
        return (0, encoding_1.toBech32)(prefix, pubkeyToRawAddress(pubkey));
      }
      exports2.pubkeyToAddress = pubkeyToAddress;
    }
  });

  // node_modules/@cosmjs/amino/build/coins.js
  var require_coins2 = __commonJS({
    "node_modules/@cosmjs/amino/build/coins.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.addCoins = exports2.parseCoins = exports2.coins = exports2.coin = void 0;
      var math_1 = require_build();
      function coin(amount, denom) {
        let outAmount;
        if (typeof amount === "number") {
          try {
            outAmount = new math_1.Uint53(amount).toString();
          } catch (_err) {
            throw new Error("Given amount is not a safe integer. Consider using a string instead to overcome the limitations of JS numbers.");
          }
        } else {
          if (!amount.match(/^[0-9]+$/)) {
            throw new Error("Invalid unsigned integer string format");
          }
          outAmount = amount.replace(/^0*/, "") || "0";
        }
        return {
          amount: outAmount,
          denom
        };
      }
      exports2.coin = coin;
      function coins(amount, denom) {
        return [coin(amount, denom)];
      }
      exports2.coins = coins;
      function parseCoins(input) {
        return input.replace(/\s/g, "").split(",").filter(Boolean).map((part) => {
          const match = part.match(/^([0-9]+)([a-zA-Z]+)/);
          if (!match)
            throw new Error("Got an invalid coin string");
          return {
            amount: math_1.Uint64.fromString(match[1]).toString(),
            denom: match[2]
          };
        });
      }
      exports2.parseCoins = parseCoins;
      function addCoins(lhs, rhs) {
        if (lhs.denom !== rhs.denom)
          throw new Error("Trying to add two coins with different denoms");
        return {
          amount: math_1.Decimal.fromAtomics(lhs.amount, 0).plus(math_1.Decimal.fromAtomics(rhs.amount, 0)).atomics,
          denom: lhs.denom
        };
      }
      exports2.addCoins = addCoins;
    }
  });

  // node_modules/@cosmjs/amino/build/multisig.js
  var require_multisig2 = __commonJS({
    "node_modules/@cosmjs/amino/build/multisig.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.createMultisigThresholdPubkey = exports2.compareArrays = void 0;
      var encoding_1 = require_build2();
      var math_1 = require_build();
      var addresses_1 = require_addresses();
      function compareArrays(a, b) {
        const aHex = (0, encoding_1.toHex)(a);
        const bHex = (0, encoding_1.toHex)(b);
        return aHex === bHex ? 0 : aHex < bHex ? -1 : 1;
      }
      exports2.compareArrays = compareArrays;
      function createMultisigThresholdPubkey(pubkeys, threshold, nosort = false) {
        const uintThreshold = new math_1.Uint53(threshold);
        if (uintThreshold.toNumber() > pubkeys.length) {
          throw new Error(`Threshold k = ${uintThreshold.toNumber()} exceeds number of keys n = ${pubkeys.length}`);
        }
        const outPubkeys = nosort ? pubkeys : Array.from(pubkeys).sort((lhs, rhs) => {
          const addressLhs = (0, addresses_1.pubkeyToRawAddress)(lhs);
          const addressRhs = (0, addresses_1.pubkeyToRawAddress)(rhs);
          return compareArrays(addressLhs, addressRhs);
        });
        return {
          type: "tendermint/PubKeyMultisigThreshold",
          value: {
            threshold: uintThreshold.toString(),
            pubkeys: outPubkeys
          }
        };
      }
      exports2.createMultisigThresholdPubkey = createMultisigThresholdPubkey;
    }
  });

  // node_modules/@cosmjs/amino/build/paths.js
  var require_paths = __commonJS({
    "node_modules/@cosmjs/amino/build/paths.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.makeCosmoshubPath = void 0;
      var crypto_1 = require_build4();
      function makeCosmoshubPath(a) {
        return [
          crypto_1.Slip10RawIndex.hardened(44),
          crypto_1.Slip10RawIndex.hardened(118),
          crypto_1.Slip10RawIndex.hardened(0),
          crypto_1.Slip10RawIndex.normal(0),
          crypto_1.Slip10RawIndex.normal(a)
        ];
      }
      exports2.makeCosmoshubPath = makeCosmoshubPath;
    }
  });

  // node_modules/@cosmjs/amino/build/signature.js
  var require_signature3 = __commonJS({
    "node_modules/@cosmjs/amino/build/signature.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.decodeSignature = exports2.encodeSecp256k1Signature = void 0;
      var encoding_1 = require_build2();
      var encoding_2 = require_encoding();
      var pubkeys_1 = require_pubkeys();
      function encodeSecp256k1Signature(pubkey, signature) {
        if (signature.length !== 64) {
          throw new Error("Signature must be 64 bytes long. Cosmos SDK uses a 2x32 byte fixed length encoding for the secp256k1 signature integers r and s.");
        }
        return {
          pub_key: (0, encoding_2.encodeSecp256k1Pubkey)(pubkey),
          signature: (0, encoding_1.toBase64)(signature)
        };
      }
      exports2.encodeSecp256k1Signature = encodeSecp256k1Signature;
      function decodeSignature(signature) {
        switch (signature.pub_key.type) {
          case pubkeys_1.pubkeyType.secp256k1:
            return {
              pubkey: (0, encoding_1.fromBase64)(signature.pub_key.value),
              signature: (0, encoding_1.fromBase64)(signature.signature)
            };
          default:
            throw new Error("Unsupported pubkey type");
        }
      }
      exports2.decodeSignature = decodeSignature;
    }
  });

  // node_modules/@cosmjs/amino/build/signdoc.js
  var require_signdoc = __commonJS({
    "node_modules/@cosmjs/amino/build/signdoc.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.serializeSignDoc = exports2.makeSignDoc = exports2.sortedJsonStringify = void 0;
      var encoding_1 = require_build2();
      var math_1 = require_build();
      function sortedObject(obj) {
        if (typeof obj !== "object" || obj === null) {
          return obj;
        }
        if (Array.isArray(obj)) {
          return obj.map(sortedObject);
        }
        const sortedKeys = Object.keys(obj).sort();
        const result = {};
        sortedKeys.forEach((key) => {
          result[key] = sortedObject(obj[key]);
        });
        return result;
      }
      function sortedJsonStringify(obj) {
        return JSON.stringify(sortedObject(obj));
      }
      exports2.sortedJsonStringify = sortedJsonStringify;
      function makeSignDoc(msgs, fee, chainId, memo, accountNumber, sequence) {
        return {
          chain_id: chainId,
          account_number: math_1.Uint53.fromString(accountNumber.toString()).toString(),
          sequence: math_1.Uint53.fromString(sequence.toString()).toString(),
          fee,
          msgs,
          memo: memo || ""
        };
      }
      exports2.makeSignDoc = makeSignDoc;
      function serializeSignDoc(signDoc) {
        return (0, encoding_1.toUtf8)(sortedJsonStringify(signDoc));
      }
      exports2.serializeSignDoc = serializeSignDoc;
    }
  });

  // node_modules/@cosmjs/amino/build/wallet.js
  var require_wallet = __commonJS({
    "node_modules/@cosmjs/amino/build/wallet.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.decrypt = exports2.encrypt = exports2.supportedAlgorithms = exports2.executeKdf = exports2.cosmjsSalt = void 0;
      var crypto_1 = require_build4();
      var encoding_1 = require_build2();
      exports2.cosmjsSalt = (0, encoding_1.toAscii)("The CosmJS salt.");
      async function executeKdf(password, configuration) {
        switch (configuration.algorithm) {
          case "argon2id": {
            const options = configuration.params;
            if (!(0, crypto_1.isArgon2idOptions)(options))
              throw new Error("Invalid format of argon2id params");
            return crypto_1.Argon2id.execute(password, exports2.cosmjsSalt, options);
          }
          default:
            throw new Error("Unsupported KDF algorithm");
        }
      }
      exports2.executeKdf = executeKdf;
      exports2.supportedAlgorithms = {
        xchacha20poly1305Ietf: "xchacha20poly1305-ietf"
      };
      async function encrypt(plaintext, encryptionKey, config) {
        switch (config.algorithm) {
          case exports2.supportedAlgorithms.xchacha20poly1305Ietf: {
            const nonce = crypto_1.Random.getBytes(crypto_1.xchacha20NonceLength);
            return new Uint8Array([
              ...nonce,
              ...await crypto_1.Xchacha20poly1305Ietf.encrypt(plaintext, encryptionKey, nonce)
            ]);
          }
          default:
            throw new Error(`Unsupported encryption algorithm: '${config.algorithm}'`);
        }
      }
      exports2.encrypt = encrypt;
      async function decrypt(ciphertext, encryptionKey, config) {
        switch (config.algorithm) {
          case exports2.supportedAlgorithms.xchacha20poly1305Ietf: {
            const nonce = ciphertext.slice(0, crypto_1.xchacha20NonceLength);
            return crypto_1.Xchacha20poly1305Ietf.decrypt(ciphertext.slice(crypto_1.xchacha20NonceLength), encryptionKey, nonce);
          }
          default:
            throw new Error(`Unsupported encryption algorithm: '${config.algorithm}'`);
        }
      }
      exports2.decrypt = decrypt;
    }
  });

  // node_modules/@cosmjs/amino/build/secp256k1hdwallet.js
  var require_secp256k1hdwallet = __commonJS({
    "node_modules/@cosmjs/amino/build/secp256k1hdwallet.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.Secp256k1HdWallet = exports2.extractKdfConfiguration = void 0;
      var crypto_1 = require_build4();
      var encoding_1 = require_build2();
      var utils_1 = require_build3();
      var addresses_1 = require_addresses();
      var paths_1 = require_paths();
      var signature_1 = require_signature3();
      var signdoc_1 = require_signdoc();
      var wallet_1 = require_wallet();
      var serializationTypeV1 = "secp256k1wallet-v1";
      var basicPasswordHashingOptions = {
        algorithm: "argon2id",
        params: {
          outputLength: 32,
          opsLimit: 24,
          memLimitKib: 12 * 1024
        }
      };
      function isDerivationJson(thing) {
        if (!(0, utils_1.isNonNullObject)(thing))
          return false;
        if (typeof thing.hdPath !== "string")
          return false;
        if (typeof thing.prefix !== "string")
          return false;
        return true;
      }
      function extractKdfConfigurationV1(doc) {
        return doc.kdf;
      }
      function extractKdfConfiguration(serialization) {
        const root = JSON.parse(serialization);
        if (!(0, utils_1.isNonNullObject)(root))
          throw new Error("Root document is not an object.");
        switch (root.type) {
          case serializationTypeV1:
            return extractKdfConfigurationV1(root);
          default:
            throw new Error("Unsupported serialization type");
        }
      }
      exports2.extractKdfConfiguration = extractKdfConfiguration;
      var defaultOptions2 = {
        bip39Password: "",
        hdPaths: [(0, paths_1.makeCosmoshubPath)(0)],
        prefix: "cosmos"
      };
      var Secp256k1HdWallet = class {
        constructor(mnemonic, options) {
          var _a, _b;
          const hdPaths = (_a = options.hdPaths) !== null && _a !== void 0 ? _a : defaultOptions2.hdPaths;
          const prefix = (_b = options.prefix) !== null && _b !== void 0 ? _b : defaultOptions2.prefix;
          this.secret = mnemonic;
          this.seed = options.seed;
          this.accounts = hdPaths.map((hdPath) => ({
            hdPath,
            prefix
          }));
        }
        static async fromMnemonic(mnemonic, options = {}) {
          const mnemonicChecked = new crypto_1.EnglishMnemonic(mnemonic);
          const seed = await crypto_1.Bip39.mnemonicToSeed(mnemonicChecked, options.bip39Password);
          return new Secp256k1HdWallet(mnemonicChecked, {
            ...options,
            seed
          });
        }
        static async generate(length = 12, options = {}) {
          const entropyLength = 4 * Math.floor(11 * length / 33);
          const entropy = crypto_1.Random.getBytes(entropyLength);
          const mnemonic = crypto_1.Bip39.encode(entropy);
          return Secp256k1HdWallet.fromMnemonic(mnemonic.toString(), options);
        }
        static async deserialize(serialization, password) {
          const root = JSON.parse(serialization);
          if (!(0, utils_1.isNonNullObject)(root))
            throw new Error("Root document is not an object.");
          switch (root.type) {
            case serializationTypeV1:
              return Secp256k1HdWallet.deserializeTypeV1(serialization, password);
            default:
              throw new Error("Unsupported serialization type");
          }
        }
        static async deserializeWithEncryptionKey(serialization, encryptionKey) {
          const root = JSON.parse(serialization);
          if (!(0, utils_1.isNonNullObject)(root))
            throw new Error("Root document is not an object.");
          const untypedRoot = root;
          switch (untypedRoot.type) {
            case serializationTypeV1: {
              const decryptedBytes = await (0, wallet_1.decrypt)((0, encoding_1.fromBase64)(untypedRoot.data), encryptionKey, untypedRoot.encryption);
              const decryptedDocument = JSON.parse((0, encoding_1.fromUtf8)(decryptedBytes));
              const { mnemonic, accounts } = decryptedDocument;
              (0, utils_1.assert)(typeof mnemonic === "string");
              if (!Array.isArray(accounts))
                throw new Error("Property 'accounts' is not an array");
              if (!accounts.every((account) => isDerivationJson(account))) {
                throw new Error("Account is not in the correct format.");
              }
              const firstPrefix = accounts[0].prefix;
              if (!accounts.every(({ prefix }) => prefix === firstPrefix)) {
                throw new Error("Accounts do not all have the same prefix");
              }
              const hdPaths = accounts.map(({ hdPath }) => (0, crypto_1.stringToPath)(hdPath));
              return Secp256k1HdWallet.fromMnemonic(mnemonic, {
                hdPaths,
                prefix: firstPrefix
              });
            }
            default:
              throw new Error("Unsupported serialization type");
          }
        }
        static async deserializeTypeV1(serialization, password) {
          const root = JSON.parse(serialization);
          if (!(0, utils_1.isNonNullObject)(root))
            throw new Error("Root document is not an object.");
          const encryptionKey = await (0, wallet_1.executeKdf)(password, root.kdf);
          return Secp256k1HdWallet.deserializeWithEncryptionKey(serialization, encryptionKey);
        }
        get mnemonic() {
          return this.secret.toString();
        }
        async getAccounts() {
          const accountsWithPrivkeys = await this.getAccountsWithPrivkeys();
          return accountsWithPrivkeys.map(({ algo, pubkey, address }) => ({
            algo,
            pubkey,
            address
          }));
        }
        async signAmino(signerAddress, signDoc) {
          const accounts = await this.getAccountsWithPrivkeys();
          const account = accounts.find(({ address }) => address === signerAddress);
          if (account === void 0) {
            throw new Error(`Address ${signerAddress} not found in wallet`);
          }
          const { privkey, pubkey } = account;
          const message = (0, crypto_1.sha256)((0, signdoc_1.serializeSignDoc)(signDoc));
          const signature = await crypto_1.Secp256k1.createSignature(message, privkey);
          const signatureBytes = new Uint8Array([...signature.r(32), ...signature.s(32)]);
          return {
            signed: signDoc,
            signature: (0, signature_1.encodeSecp256k1Signature)(pubkey, signatureBytes)
          };
        }
        async serialize(password) {
          const kdfConfiguration = basicPasswordHashingOptions;
          const encryptionKey = await (0, wallet_1.executeKdf)(password, kdfConfiguration);
          return this.serializeWithEncryptionKey(encryptionKey, kdfConfiguration);
        }
        async serializeWithEncryptionKey(encryptionKey, kdfConfiguration) {
          const dataToEncrypt = {
            mnemonic: this.mnemonic,
            accounts: this.accounts.map(({ hdPath, prefix }) => ({
              hdPath: (0, crypto_1.pathToString)(hdPath),
              prefix
            }))
          };
          const dataToEncryptRaw = (0, encoding_1.toUtf8)(JSON.stringify(dataToEncrypt));
          const encryptionConfiguration = {
            algorithm: wallet_1.supportedAlgorithms.xchacha20poly1305Ietf
          };
          const encryptedData = await (0, wallet_1.encrypt)(dataToEncryptRaw, encryptionKey, encryptionConfiguration);
          const out = {
            type: serializationTypeV1,
            kdf: kdfConfiguration,
            encryption: encryptionConfiguration,
            data: (0, encoding_1.toBase64)(encryptedData)
          };
          return JSON.stringify(out);
        }
        async getKeyPair(hdPath) {
          const { privkey } = crypto_1.Slip10.derivePath(crypto_1.Slip10Curve.Secp256k1, this.seed, hdPath);
          const { pubkey } = await crypto_1.Secp256k1.makeKeypair(privkey);
          return {
            privkey,
            pubkey: crypto_1.Secp256k1.compressPubkey(pubkey)
          };
        }
        async getAccountsWithPrivkeys() {
          return Promise.all(this.accounts.map(async ({ hdPath, prefix }) => {
            const { privkey, pubkey } = await this.getKeyPair(hdPath);
            const address = (0, encoding_1.toBech32)(prefix, (0, addresses_1.rawSecp256k1PubkeyToRawAddress)(pubkey));
            return {
              algo: "secp256k1",
              privkey,
              pubkey,
              address
            };
          }));
        }
      };
      exports2.Secp256k1HdWallet = Secp256k1HdWallet;
    }
  });

  // node_modules/@cosmjs/amino/build/secp256k1wallet.js
  var require_secp256k1wallet = __commonJS({
    "node_modules/@cosmjs/amino/build/secp256k1wallet.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.Secp256k1Wallet = void 0;
      var crypto_1 = require_build4();
      var encoding_1 = require_build2();
      var addresses_1 = require_addresses();
      var signature_1 = require_signature3();
      var signdoc_1 = require_signdoc();
      var Secp256k1Wallet = class {
        constructor(privkey, pubkey, prefix) {
          this.privkey = privkey;
          this.pubkey = pubkey;
          this.prefix = prefix;
        }
        static async fromKey(privkey, prefix = "cosmos") {
          const uncompressed = (await crypto_1.Secp256k1.makeKeypair(privkey)).pubkey;
          return new Secp256k1Wallet(privkey, crypto_1.Secp256k1.compressPubkey(uncompressed), prefix);
        }
        get address() {
          return (0, encoding_1.toBech32)(this.prefix, (0, addresses_1.rawSecp256k1PubkeyToRawAddress)(this.pubkey));
        }
        async getAccounts() {
          return [
            {
              algo: "secp256k1",
              address: this.address,
              pubkey: this.pubkey
            }
          ];
        }
        async signAmino(signerAddress, signDoc) {
          if (signerAddress !== this.address) {
            throw new Error(`Address ${signerAddress} not found in wallet`);
          }
          const message = new crypto_1.Sha256((0, signdoc_1.serializeSignDoc)(signDoc)).digest();
          const signature = await crypto_1.Secp256k1.createSignature(message, this.privkey);
          const signatureBytes = new Uint8Array([...signature.r(32), ...signature.s(32)]);
          return {
            signed: signDoc,
            signature: (0, signature_1.encodeSecp256k1Signature)(this.pubkey, signatureBytes)
          };
        }
      };
      exports2.Secp256k1Wallet = Secp256k1Wallet;
    }
  });

  // node_modules/@cosmjs/amino/build/stdtx.js
  var require_stdtx = __commonJS({
    "node_modules/@cosmjs/amino/build/stdtx.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.makeStdTx = exports2.isStdTx = void 0;
      function isStdTx(txValue) {
        const { memo, msg, fee, signatures } = txValue;
        return typeof memo === "string" && Array.isArray(msg) && typeof fee === "object" && Array.isArray(signatures);
      }
      exports2.isStdTx = isStdTx;
      function makeStdTx(content, signatures) {
        return {
          msg: content.msgs,
          fee: content.fee,
          memo: content.memo,
          signatures: Array.isArray(signatures) ? signatures : [signatures]
        };
      }
      exports2.makeStdTx = makeStdTx;
    }
  });

  // node_modules/@cosmjs/amino/build/index.js
  var require_build5 = __commonJS({
    "node_modules/@cosmjs/amino/build/index.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.executeKdf = exports2.makeStdTx = exports2.isStdTx = exports2.serializeSignDoc = exports2.makeSignDoc = exports2.encodeSecp256k1Signature = exports2.decodeSignature = exports2.Secp256k1Wallet = exports2.Secp256k1HdWallet = exports2.extractKdfConfiguration = exports2.pubkeyType = exports2.isSinglePubkey = exports2.isSecp256k1Pubkey = exports2.isMultisigThresholdPubkey = exports2.isEd25519Pubkey = exports2.makeCosmoshubPath = exports2.createMultisigThresholdPubkey = exports2.encodeSecp256k1Pubkey = exports2.encodeBech32Pubkey = exports2.encodeAminoPubkey = exports2.decodeBech32Pubkey = exports2.decodeAminoPubkey = exports2.parseCoins = exports2.coins = exports2.coin = exports2.addCoins = exports2.rawSecp256k1PubkeyToRawAddress = exports2.rawEd25519PubkeyToRawAddress = exports2.pubkeyToRawAddress = exports2.pubkeyToAddress = void 0;
      var addresses_1 = require_addresses();
      Object.defineProperty(exports2, "pubkeyToAddress", { enumerable: true, get: function() {
        return addresses_1.pubkeyToAddress;
      } });
      Object.defineProperty(exports2, "pubkeyToRawAddress", { enumerable: true, get: function() {
        return addresses_1.pubkeyToRawAddress;
      } });
      Object.defineProperty(exports2, "rawEd25519PubkeyToRawAddress", { enumerable: true, get: function() {
        return addresses_1.rawEd25519PubkeyToRawAddress;
      } });
      Object.defineProperty(exports2, "rawSecp256k1PubkeyToRawAddress", { enumerable: true, get: function() {
        return addresses_1.rawSecp256k1PubkeyToRawAddress;
      } });
      var coins_1 = require_coins2();
      Object.defineProperty(exports2, "addCoins", { enumerable: true, get: function() {
        return coins_1.addCoins;
      } });
      Object.defineProperty(exports2, "coin", { enumerable: true, get: function() {
        return coins_1.coin;
      } });
      Object.defineProperty(exports2, "coins", { enumerable: true, get: function() {
        return coins_1.coins;
      } });
      Object.defineProperty(exports2, "parseCoins", { enumerable: true, get: function() {
        return coins_1.parseCoins;
      } });
      var encoding_1 = require_encoding();
      Object.defineProperty(exports2, "decodeAminoPubkey", { enumerable: true, get: function() {
        return encoding_1.decodeAminoPubkey;
      } });
      Object.defineProperty(exports2, "decodeBech32Pubkey", { enumerable: true, get: function() {
        return encoding_1.decodeBech32Pubkey;
      } });
      Object.defineProperty(exports2, "encodeAminoPubkey", { enumerable: true, get: function() {
        return encoding_1.encodeAminoPubkey;
      } });
      Object.defineProperty(exports2, "encodeBech32Pubkey", { enumerable: true, get: function() {
        return encoding_1.encodeBech32Pubkey;
      } });
      Object.defineProperty(exports2, "encodeSecp256k1Pubkey", { enumerable: true, get: function() {
        return encoding_1.encodeSecp256k1Pubkey;
      } });
      var multisig_1 = require_multisig2();
      Object.defineProperty(exports2, "createMultisigThresholdPubkey", { enumerable: true, get: function() {
        return multisig_1.createMultisigThresholdPubkey;
      } });
      var paths_1 = require_paths();
      Object.defineProperty(exports2, "makeCosmoshubPath", { enumerable: true, get: function() {
        return paths_1.makeCosmoshubPath;
      } });
      var pubkeys_1 = require_pubkeys();
      Object.defineProperty(exports2, "isEd25519Pubkey", { enumerable: true, get: function() {
        return pubkeys_1.isEd25519Pubkey;
      } });
      Object.defineProperty(exports2, "isMultisigThresholdPubkey", { enumerable: true, get: function() {
        return pubkeys_1.isMultisigThresholdPubkey;
      } });
      Object.defineProperty(exports2, "isSecp256k1Pubkey", { enumerable: true, get: function() {
        return pubkeys_1.isSecp256k1Pubkey;
      } });
      Object.defineProperty(exports2, "isSinglePubkey", { enumerable: true, get: function() {
        return pubkeys_1.isSinglePubkey;
      } });
      Object.defineProperty(exports2, "pubkeyType", { enumerable: true, get: function() {
        return pubkeys_1.pubkeyType;
      } });
      var secp256k1hdwallet_1 = require_secp256k1hdwallet();
      Object.defineProperty(exports2, "extractKdfConfiguration", { enumerable: true, get: function() {
        return secp256k1hdwallet_1.extractKdfConfiguration;
      } });
      Object.defineProperty(exports2, "Secp256k1HdWallet", { enumerable: true, get: function() {
        return secp256k1hdwallet_1.Secp256k1HdWallet;
      } });
      var secp256k1wallet_1 = require_secp256k1wallet();
      Object.defineProperty(exports2, "Secp256k1Wallet", { enumerable: true, get: function() {
        return secp256k1wallet_1.Secp256k1Wallet;
      } });
      var signature_1 = require_signature3();
      Object.defineProperty(exports2, "decodeSignature", { enumerable: true, get: function() {
        return signature_1.decodeSignature;
      } });
      Object.defineProperty(exports2, "encodeSecp256k1Signature", { enumerable: true, get: function() {
        return signature_1.encodeSecp256k1Signature;
      } });
      var signdoc_1 = require_signdoc();
      Object.defineProperty(exports2, "makeSignDoc", { enumerable: true, get: function() {
        return signdoc_1.makeSignDoc;
      } });
      Object.defineProperty(exports2, "serializeSignDoc", { enumerable: true, get: function() {
        return signdoc_1.serializeSignDoc;
      } });
      var stdtx_1 = require_stdtx();
      Object.defineProperty(exports2, "isStdTx", { enumerable: true, get: function() {
        return stdtx_1.isStdTx;
      } });
      Object.defineProperty(exports2, "makeStdTx", { enumerable: true, get: function() {
        return stdtx_1.makeStdTx;
      } });
      var wallet_1 = require_wallet();
      Object.defineProperty(exports2, "executeKdf", { enumerable: true, get: function() {
        return wallet_1.executeKdf;
      } });
    }
  });

  // node_modules/@cosmjs/proto-signing/build/signing.js
  var require_signing2 = __commonJS({
    "node_modules/@cosmjs/proto-signing/build/signing.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.makeSignBytes = exports2.makeSignDoc = exports2.makeAuthInfoBytes = void 0;
      var signing_1 = require_signing();
      var tx_1 = require_tx();
      var long_1 = __importDefault(require_long());
      function makeSignerInfos(signers, signMode) {
        return signers.map(({ pubkey, sequence }) => ({
          publicKey: pubkey,
          modeInfo: {
            single: { mode: signMode }
          },
          sequence: long_1.default.fromNumber(sequence)
        }));
      }
      function makeAuthInfoBytes(signers, feeAmount, gasLimit, signMode = signing_1.SignMode.SIGN_MODE_DIRECT) {
        const authInfo = {
          signerInfos: makeSignerInfos(signers, signMode),
          fee: {
            amount: [...feeAmount],
            gasLimit: long_1.default.fromNumber(gasLimit)
          }
        };
        return tx_1.AuthInfo.encode(tx_1.AuthInfo.fromPartial(authInfo)).finish();
      }
      exports2.makeAuthInfoBytes = makeAuthInfoBytes;
      function makeSignDoc(bodyBytes, authInfoBytes, chainId, accountNumber) {
        return {
          bodyBytes,
          authInfoBytes,
          chainId,
          accountNumber: long_1.default.fromNumber(accountNumber)
        };
      }
      exports2.makeSignDoc = makeSignDoc;
      function makeSignBytes({ accountNumber, authInfoBytes, bodyBytes, chainId }) {
        const signDoc = tx_1.SignDoc.fromPartial({
          accountNumber,
          authInfoBytes,
          bodyBytes,
          chainId
        });
        return tx_1.SignDoc.encode(signDoc).finish();
      }
      exports2.makeSignBytes = makeSignBytes;
    }
  });

  // node_modules/@cosmjs/proto-signing/build/wallet.js
  var require_wallet2 = __commonJS({
    "node_modules/@cosmjs/proto-signing/build/wallet.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.decrypt = exports2.encrypt = exports2.supportedAlgorithms = exports2.executeKdf = exports2.cosmjsSalt = void 0;
      var crypto_1 = require_build4();
      var encoding_1 = require_build2();
      exports2.cosmjsSalt = (0, encoding_1.toAscii)("The CosmJS salt.");
      async function executeKdf(password, configuration) {
        switch (configuration.algorithm) {
          case "argon2id": {
            const options = configuration.params;
            if (!(0, crypto_1.isArgon2idOptions)(options))
              throw new Error("Invalid format of argon2id params");
            return crypto_1.Argon2id.execute(password, exports2.cosmjsSalt, options);
          }
          default:
            throw new Error("Unsupported KDF algorithm");
        }
      }
      exports2.executeKdf = executeKdf;
      exports2.supportedAlgorithms = {
        xchacha20poly1305Ietf: "xchacha20poly1305-ietf"
      };
      async function encrypt(plaintext, encryptionKey, config) {
        switch (config.algorithm) {
          case exports2.supportedAlgorithms.xchacha20poly1305Ietf: {
            const nonce = crypto_1.Random.getBytes(crypto_1.xchacha20NonceLength);
            return new Uint8Array([
              ...nonce,
              ...await crypto_1.Xchacha20poly1305Ietf.encrypt(plaintext, encryptionKey, nonce)
            ]);
          }
          default:
            throw new Error(`Unsupported encryption algorithm: '${config.algorithm}'`);
        }
      }
      exports2.encrypt = encrypt;
      async function decrypt(ciphertext, encryptionKey, config) {
        switch (config.algorithm) {
          case exports2.supportedAlgorithms.xchacha20poly1305Ietf: {
            const nonce = ciphertext.slice(0, crypto_1.xchacha20NonceLength);
            return crypto_1.Xchacha20poly1305Ietf.decrypt(ciphertext.slice(crypto_1.xchacha20NonceLength), encryptionKey, nonce);
          }
          default:
            throw new Error(`Unsupported encryption algorithm: '${config.algorithm}'`);
        }
      }
      exports2.decrypt = decrypt;
    }
  });

  // node_modules/@cosmjs/proto-signing/build/directsecp256k1hdwallet.js
  var require_directsecp256k1hdwallet = __commonJS({
    "node_modules/@cosmjs/proto-signing/build/directsecp256k1hdwallet.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.DirectSecp256k1HdWallet = exports2.extractKdfConfiguration = void 0;
      var amino_1 = require_build5();
      var crypto_1 = require_build4();
      var encoding_1 = require_build2();
      var utils_1 = require_build3();
      var signing_1 = require_signing2();
      var wallet_1 = require_wallet2();
      var serializationTypeV1 = "directsecp256k1hdwallet-v1";
      var basicPasswordHashingOptions = {
        algorithm: "argon2id",
        params: {
          outputLength: 32,
          opsLimit: 24,
          memLimitKib: 12 * 1024
        }
      };
      function isDerivationJson(thing) {
        if (!(0, utils_1.isNonNullObject)(thing))
          return false;
        if (typeof thing.hdPath !== "string")
          return false;
        if (typeof thing.prefix !== "string")
          return false;
        return true;
      }
      function extractKdfConfigurationV1(doc) {
        return doc.kdf;
      }
      function extractKdfConfiguration(serialization) {
        const root = JSON.parse(serialization);
        if (!(0, utils_1.isNonNullObject)(root))
          throw new Error("Root document is not an object.");
        switch (root.type) {
          case serializationTypeV1:
            return extractKdfConfigurationV1(root);
          default:
            throw new Error("Unsupported serialization type");
        }
      }
      exports2.extractKdfConfiguration = extractKdfConfiguration;
      var defaultOptions2 = {
        bip39Password: "",
        hdPaths: [(0, amino_1.makeCosmoshubPath)(0)],
        prefix: "cosmos"
      };
      var DirectSecp256k1HdWallet = class {
        constructor(mnemonic, options) {
          var _a, _b;
          const prefix = (_a = options.prefix) !== null && _a !== void 0 ? _a : defaultOptions2.prefix;
          const hdPaths = (_b = options.hdPaths) !== null && _b !== void 0 ? _b : defaultOptions2.hdPaths;
          this.secret = mnemonic;
          this.seed = options.seed;
          this.accounts = hdPaths.map((hdPath) => ({
            hdPath,
            prefix
          }));
        }
        static async fromMnemonic(mnemonic, options = {}) {
          const mnemonicChecked = new crypto_1.EnglishMnemonic(mnemonic);
          const seed = await crypto_1.Bip39.mnemonicToSeed(mnemonicChecked, options.bip39Password);
          return new DirectSecp256k1HdWallet(mnemonicChecked, {
            ...options,
            seed
          });
        }
        static async generate(length = 12, options = {}) {
          const entropyLength = 4 * Math.floor(11 * length / 33);
          const entropy = crypto_1.Random.getBytes(entropyLength);
          const mnemonic = crypto_1.Bip39.encode(entropy);
          return DirectSecp256k1HdWallet.fromMnemonic(mnemonic.toString(), options);
        }
        static async deserialize(serialization, password) {
          const root = JSON.parse(serialization);
          if (!(0, utils_1.isNonNullObject)(root))
            throw new Error("Root document is not an object.");
          switch (root.type) {
            case serializationTypeV1:
              return DirectSecp256k1HdWallet.deserializeTypeV1(serialization, password);
            default:
              throw new Error("Unsupported serialization type");
          }
        }
        static async deserializeWithEncryptionKey(serialization, encryptionKey) {
          const root = JSON.parse(serialization);
          if (!(0, utils_1.isNonNullObject)(root))
            throw new Error("Root document is not an object.");
          const untypedRoot = root;
          switch (untypedRoot.type) {
            case serializationTypeV1: {
              const decryptedBytes = await (0, wallet_1.decrypt)((0, encoding_1.fromBase64)(untypedRoot.data), encryptionKey, untypedRoot.encryption);
              const decryptedDocument = JSON.parse((0, encoding_1.fromUtf8)(decryptedBytes));
              const { mnemonic, accounts } = decryptedDocument;
              (0, utils_1.assert)(typeof mnemonic === "string");
              if (!Array.isArray(accounts))
                throw new Error("Property 'accounts' is not an array");
              if (!accounts.every((account) => isDerivationJson(account))) {
                throw new Error("Account is not in the correct format.");
              }
              const firstPrefix = accounts[0].prefix;
              if (!accounts.every(({ prefix }) => prefix === firstPrefix)) {
                throw new Error("Accounts do not all have the same prefix");
              }
              const hdPaths = accounts.map(({ hdPath }) => (0, crypto_1.stringToPath)(hdPath));
              return DirectSecp256k1HdWallet.fromMnemonic(mnemonic, {
                hdPaths,
                prefix: firstPrefix
              });
            }
            default:
              throw new Error("Unsupported serialization type");
          }
        }
        static async deserializeTypeV1(serialization, password) {
          const root = JSON.parse(serialization);
          if (!(0, utils_1.isNonNullObject)(root))
            throw new Error("Root document is not an object.");
          const encryptionKey = await (0, wallet_1.executeKdf)(password, root.kdf);
          return DirectSecp256k1HdWallet.deserializeWithEncryptionKey(serialization, encryptionKey);
        }
        get mnemonic() {
          return this.secret.toString();
        }
        async getAccounts() {
          const accountsWithPrivkeys = await this.getAccountsWithPrivkeys();
          return accountsWithPrivkeys.map(({ algo, pubkey, address }) => ({
            algo,
            pubkey,
            address
          }));
        }
        async signDirect(signerAddress, signDoc) {
          const accounts = await this.getAccountsWithPrivkeys();
          const account = accounts.find(({ address }) => address === signerAddress);
          if (account === void 0) {
            throw new Error(`Address ${signerAddress} not found in wallet`);
          }
          const { privkey, pubkey } = account;
          const signBytes = (0, signing_1.makeSignBytes)(signDoc);
          const hashedMessage = (0, crypto_1.sha256)(signBytes);
          const signature = await crypto_1.Secp256k1.createSignature(hashedMessage, privkey);
          const signatureBytes = new Uint8Array([...signature.r(32), ...signature.s(32)]);
          const stdSignature = (0, amino_1.encodeSecp256k1Signature)(pubkey, signatureBytes);
          return {
            signed: signDoc,
            signature: stdSignature
          };
        }
        async serialize(password) {
          const kdfConfiguration = basicPasswordHashingOptions;
          const encryptionKey = await (0, wallet_1.executeKdf)(password, kdfConfiguration);
          return this.serializeWithEncryptionKey(encryptionKey, kdfConfiguration);
        }
        async serializeWithEncryptionKey(encryptionKey, kdfConfiguration) {
          const dataToEncrypt = {
            mnemonic: this.mnemonic,
            accounts: this.accounts.map(({ hdPath, prefix }) => ({
              hdPath: (0, crypto_1.pathToString)(hdPath),
              prefix
            }))
          };
          const dataToEncryptRaw = (0, encoding_1.toUtf8)(JSON.stringify(dataToEncrypt));
          const encryptionConfiguration = {
            algorithm: wallet_1.supportedAlgorithms.xchacha20poly1305Ietf
          };
          const encryptedData = await (0, wallet_1.encrypt)(dataToEncryptRaw, encryptionKey, encryptionConfiguration);
          const out = {
            type: serializationTypeV1,
            kdf: kdfConfiguration,
            encryption: encryptionConfiguration,
            data: (0, encoding_1.toBase64)(encryptedData)
          };
          return JSON.stringify(out);
        }
        async getKeyPair(hdPath) {
          const { privkey } = crypto_1.Slip10.derivePath(crypto_1.Slip10Curve.Secp256k1, this.seed, hdPath);
          const { pubkey } = await crypto_1.Secp256k1.makeKeypair(privkey);
          return {
            privkey,
            pubkey: crypto_1.Secp256k1.compressPubkey(pubkey)
          };
        }
        async getAccountsWithPrivkeys() {
          return Promise.all(this.accounts.map(async ({ hdPath, prefix }) => {
            const { privkey, pubkey } = await this.getKeyPair(hdPath);
            const address = (0, encoding_1.toBech32)(prefix, (0, amino_1.rawSecp256k1PubkeyToRawAddress)(pubkey));
            return {
              algo: "secp256k1",
              privkey,
              pubkey,
              address
            };
          }));
        }
      };
      exports2.DirectSecp256k1HdWallet = DirectSecp256k1HdWallet;
    }
  });

  // node_modules/@cosmjs/proto-signing/build/directsecp256k1wallet.js
  var require_directsecp256k1wallet = __commonJS({
    "node_modules/@cosmjs/proto-signing/build/directsecp256k1wallet.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.DirectSecp256k1Wallet = void 0;
      var amino_1 = require_build5();
      var crypto_1 = require_build4();
      var encoding_1 = require_build2();
      var signing_1 = require_signing2();
      var DirectSecp256k1Wallet = class {
        constructor(privkey, pubkey, prefix) {
          this.privkey = privkey;
          this.pubkey = pubkey;
          this.prefix = prefix;
        }
        static async fromKey(privkey, prefix = "cosmos") {
          const uncompressed = (await crypto_1.Secp256k1.makeKeypair(privkey)).pubkey;
          return new DirectSecp256k1Wallet(privkey, crypto_1.Secp256k1.compressPubkey(uncompressed), prefix);
        }
        get address() {
          return (0, encoding_1.toBech32)(this.prefix, (0, amino_1.rawSecp256k1PubkeyToRawAddress)(this.pubkey));
        }
        async getAccounts() {
          return [
            {
              algo: "secp256k1",
              address: this.address,
              pubkey: this.pubkey
            }
          ];
        }
        async signDirect(address, signDoc) {
          const signBytes = (0, signing_1.makeSignBytes)(signDoc);
          if (address !== this.address) {
            throw new Error(`Address ${address} not found in wallet`);
          }
          const hashedMessage = (0, crypto_1.sha256)(signBytes);
          const signature = await crypto_1.Secp256k1.createSignature(hashedMessage, this.privkey);
          const signatureBytes = new Uint8Array([...signature.r(32), ...signature.s(32)]);
          const stdSignature = (0, amino_1.encodeSecp256k1Signature)(this.pubkey, signatureBytes);
          return {
            signed: signDoc,
            signature: stdSignature
          };
        }
      };
      exports2.DirectSecp256k1Wallet = DirectSecp256k1Wallet;
    }
  });

  // node_modules/@cosmjs/proto-signing/build/paths.js
  var require_paths2 = __commonJS({
    "node_modules/@cosmjs/proto-signing/build/paths.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.makeCosmoshubPath = void 0;
      var crypto_1 = require_build4();
      function makeCosmoshubPath(a) {
        return [
          crypto_1.Slip10RawIndex.hardened(44),
          crypto_1.Slip10RawIndex.hardened(118),
          crypto_1.Slip10RawIndex.hardened(0),
          crypto_1.Slip10RawIndex.normal(0),
          crypto_1.Slip10RawIndex.normal(a)
        ];
      }
      exports2.makeCosmoshubPath = makeCosmoshubPath;
    }
  });

  // node_modules/cosmjs-types/cosmos/crypto/multisig/keys.js
  var require_keys = __commonJS({
    "node_modules/cosmjs-types/cosmos/crypto/multisig/keys.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.LegacyAminoPubKey = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var any_1 = require_any();
      exports2.protobufPackage = "cosmos.crypto.multisig";
      var baseLegacyAminoPubKey = { threshold: 0 };
      exports2.LegacyAminoPubKey = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.threshold !== 0) {
            writer.uint32(8).uint32(message.threshold);
          }
          for (const v of message.publicKeys) {
            any_1.Any.encode(v, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseLegacyAminoPubKey);
          message.publicKeys = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.threshold = reader.uint32();
                break;
              case 2:
                message.publicKeys.push(any_1.Any.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseLegacyAminoPubKey);
          message.threshold = object.threshold !== void 0 && object.threshold !== null ? Number(object.threshold) : 0;
          message.publicKeys = ((_a = object.publicKeys) !== null && _a !== void 0 ? _a : []).map((e) => any_1.Any.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.threshold !== void 0 && (obj.threshold = message.threshold);
          if (message.publicKeys) {
            obj.publicKeys = message.publicKeys.map((e) => e ? any_1.Any.toJSON(e) : void 0);
          } else {
            obj.publicKeys = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseLegacyAminoPubKey);
          message.threshold = (_a = object.threshold) !== null && _a !== void 0 ? _a : 0;
          message.publicKeys = ((_b = object.publicKeys) === null || _b === void 0 ? void 0 : _b.map((e) => any_1.Any.fromPartial(e))) || [];
          return message;
        }
      };
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/cosmjs-types/cosmos/crypto/secp256k1/keys.js
  var require_keys2 = __commonJS({
    "node_modules/cosmjs-types/cosmos/crypto/secp256k1/keys.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.PrivKey = exports2.PubKey = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      exports2.protobufPackage = "cosmos.crypto.secp256k1";
      var basePubKey = {};
      exports2.PubKey = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.key.length !== 0) {
            writer.uint32(10).bytes(message.key);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, basePubKey);
          message.key = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.key = reader.bytes();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, basePubKey);
          message.key = object.key !== void 0 && object.key !== null ? bytesFromBase64(object.key) : new Uint8Array();
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.key !== void 0 && (obj.key = base64FromBytes(message.key !== void 0 ? message.key : new Uint8Array()));
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, basePubKey);
          message.key = (_a = object.key) !== null && _a !== void 0 ? _a : new Uint8Array();
          return message;
        }
      };
      var basePrivKey = {};
      exports2.PrivKey = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.key.length !== 0) {
            writer.uint32(10).bytes(message.key);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, basePrivKey);
          message.key = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.key = reader.bytes();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, basePrivKey);
          message.key = object.key !== void 0 && object.key !== null ? bytesFromBase64(object.key) : new Uint8Array();
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.key !== void 0 && (obj.key = base64FromBytes(message.key !== void 0 ? message.key : new Uint8Array()));
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, basePrivKey);
          message.key = (_a = object.key) !== null && _a !== void 0 ? _a : new Uint8Array();
          return message;
        }
      };
      var globalThis2 = (() => {
        if (typeof globalThis2 !== "undefined")
          return globalThis2;
        if (typeof self !== "undefined")
          return self;
        if (typeof window !== "undefined")
          return window;
        if (typeof global !== "undefined")
          return global;
        throw "Unable to locate global object";
      })();
      var atob2 = globalThis2.atob || ((b64) => globalThis2.Buffer.from(b64, "base64").toString("binary"));
      function bytesFromBase64(b64) {
        const bin = atob2(b64);
        const arr = new Uint8Array(bin.length);
        for (let i = 0; i < bin.length; ++i) {
          arr[i] = bin.charCodeAt(i);
        }
        return arr;
      }
      var btoa2 = globalThis2.btoa || ((bin) => globalThis2.Buffer.from(bin, "binary").toString("base64"));
      function base64FromBytes(arr) {
        const bin = [];
        for (const byte of arr) {
          bin.push(String.fromCharCode(byte));
        }
        return btoa2(bin.join(""));
      }
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/@cosmjs/proto-signing/build/pubkey.js
  var require_pubkey = __commonJS({
    "node_modules/@cosmjs/proto-signing/build/pubkey.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.decodePubkey = exports2.encodePubkey = void 0;
      var amino_1 = require_build5();
      var encoding_1 = require_build2();
      var math_1 = require_build();
      var keys_1 = require_keys();
      var keys_2 = require_keys2();
      var any_1 = require_any();
      function encodePubkey(pubkey) {
        if ((0, amino_1.isSecp256k1Pubkey)(pubkey)) {
          const pubkeyProto = keys_2.PubKey.fromPartial({
            key: (0, encoding_1.fromBase64)(pubkey.value)
          });
          return any_1.Any.fromPartial({
            typeUrl: "/cosmos.crypto.secp256k1.PubKey",
            value: Uint8Array.from(keys_2.PubKey.encode(pubkeyProto).finish())
          });
        } else if ((0, amino_1.isMultisigThresholdPubkey)(pubkey)) {
          const pubkeyProto = keys_1.LegacyAminoPubKey.fromPartial({
            threshold: math_1.Uint53.fromString(pubkey.value.threshold).toNumber(),
            publicKeys: pubkey.value.pubkeys.map(encodePubkey)
          });
          return any_1.Any.fromPartial({
            typeUrl: "/cosmos.crypto.multisig.LegacyAminoPubKey",
            value: Uint8Array.from(keys_1.LegacyAminoPubKey.encode(pubkeyProto).finish())
          });
        } else {
          throw new Error(`Pubkey type ${pubkey.type} not recognized`);
        }
      }
      exports2.encodePubkey = encodePubkey;
      function decodeSinglePubkey(pubkey) {
        switch (pubkey.typeUrl) {
          case "/cosmos.crypto.secp256k1.PubKey": {
            const { key } = keys_2.PubKey.decode(pubkey.value);
            return (0, amino_1.encodeSecp256k1Pubkey)(key);
          }
          default:
            throw new Error(`Pubkey type_url ${pubkey.typeUrl} not recognized as single public key type`);
        }
      }
      function decodePubkey(pubkey) {
        if (!pubkey || !pubkey.value) {
          return null;
        }
        switch (pubkey.typeUrl) {
          case "/cosmos.crypto.secp256k1.PubKey": {
            return decodeSinglePubkey(pubkey);
          }
          case "/cosmos.crypto.multisig.LegacyAminoPubKey": {
            const { threshold, publicKeys } = keys_1.LegacyAminoPubKey.decode(pubkey.value);
            const out = {
              type: "tendermint/PubKeyMultisigThreshold",
              value: {
                threshold: threshold.toString(),
                pubkeys: publicKeys.map(decodeSinglePubkey)
              }
            };
            return out;
          }
          default:
            throw new Error(`Pubkey type_url ${pubkey.typeUrl} not recognized`);
        }
      }
      exports2.decodePubkey = decodePubkey;
    }
  });

  // node_modules/cosmjs-types/cosmos/bank/v1beta1/bank.js
  var require_bank = __commonJS({
    "node_modules/cosmjs-types/cosmos/bank/v1beta1/bank.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.Metadata = exports2.DenomUnit = exports2.Supply = exports2.Output = exports2.Input = exports2.SendEnabled = exports2.Params = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var coin_1 = require_coin();
      exports2.protobufPackage = "cosmos.bank.v1beta1";
      var baseParams = { defaultSendEnabled: false };
      exports2.Params = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.sendEnabled) {
            exports2.SendEnabled.encode(v, writer.uint32(10).fork()).ldelim();
          }
          if (message.defaultSendEnabled === true) {
            writer.uint32(16).bool(message.defaultSendEnabled);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseParams);
          message.sendEnabled = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.sendEnabled.push(exports2.SendEnabled.decode(reader, reader.uint32()));
                break;
              case 2:
                message.defaultSendEnabled = reader.bool();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseParams);
          message.sendEnabled = ((_a = object.sendEnabled) !== null && _a !== void 0 ? _a : []).map((e) => exports2.SendEnabled.fromJSON(e));
          message.defaultSendEnabled = object.defaultSendEnabled !== void 0 && object.defaultSendEnabled !== null ? Boolean(object.defaultSendEnabled) : false;
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.sendEnabled) {
            obj.sendEnabled = message.sendEnabled.map((e) => e ? exports2.SendEnabled.toJSON(e) : void 0);
          } else {
            obj.sendEnabled = [];
          }
          message.defaultSendEnabled !== void 0 && (obj.defaultSendEnabled = message.defaultSendEnabled);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseParams);
          message.sendEnabled = ((_a = object.sendEnabled) === null || _a === void 0 ? void 0 : _a.map((e) => exports2.SendEnabled.fromPartial(e))) || [];
          message.defaultSendEnabled = (_b = object.defaultSendEnabled) !== null && _b !== void 0 ? _b : false;
          return message;
        }
      };
      var baseSendEnabled = { denom: "", enabled: false };
      exports2.SendEnabled = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.denom !== "") {
            writer.uint32(10).string(message.denom);
          }
          if (message.enabled === true) {
            writer.uint32(16).bool(message.enabled);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseSendEnabled);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.denom = reader.string();
                break;
              case 2:
                message.enabled = reader.bool();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseSendEnabled);
          message.denom = object.denom !== void 0 && object.denom !== null ? String(object.denom) : "";
          message.enabled = object.enabled !== void 0 && object.enabled !== null ? Boolean(object.enabled) : false;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.denom !== void 0 && (obj.denom = message.denom);
          message.enabled !== void 0 && (obj.enabled = message.enabled);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseSendEnabled);
          message.denom = (_a = object.denom) !== null && _a !== void 0 ? _a : "";
          message.enabled = (_b = object.enabled) !== null && _b !== void 0 ? _b : false;
          return message;
        }
      };
      var baseInput = { address: "" };
      exports2.Input = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.address !== "") {
            writer.uint32(10).string(message.address);
          }
          for (const v of message.coins) {
            coin_1.Coin.encode(v, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseInput);
          message.coins = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.address = reader.string();
                break;
              case 2:
                message.coins.push(coin_1.Coin.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseInput);
          message.address = object.address !== void 0 && object.address !== null ? String(object.address) : "";
          message.coins = ((_a = object.coins) !== null && _a !== void 0 ? _a : []).map((e) => coin_1.Coin.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.address !== void 0 && (obj.address = message.address);
          if (message.coins) {
            obj.coins = message.coins.map((e) => e ? coin_1.Coin.toJSON(e) : void 0);
          } else {
            obj.coins = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseInput);
          message.address = (_a = object.address) !== null && _a !== void 0 ? _a : "";
          message.coins = ((_b = object.coins) === null || _b === void 0 ? void 0 : _b.map((e) => coin_1.Coin.fromPartial(e))) || [];
          return message;
        }
      };
      var baseOutput = { address: "" };
      exports2.Output = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.address !== "") {
            writer.uint32(10).string(message.address);
          }
          for (const v of message.coins) {
            coin_1.Coin.encode(v, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseOutput);
          message.coins = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.address = reader.string();
                break;
              case 2:
                message.coins.push(coin_1.Coin.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseOutput);
          message.address = object.address !== void 0 && object.address !== null ? String(object.address) : "";
          message.coins = ((_a = object.coins) !== null && _a !== void 0 ? _a : []).map((e) => coin_1.Coin.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.address !== void 0 && (obj.address = message.address);
          if (message.coins) {
            obj.coins = message.coins.map((e) => e ? coin_1.Coin.toJSON(e) : void 0);
          } else {
            obj.coins = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseOutput);
          message.address = (_a = object.address) !== null && _a !== void 0 ? _a : "";
          message.coins = ((_b = object.coins) === null || _b === void 0 ? void 0 : _b.map((e) => coin_1.Coin.fromPartial(e))) || [];
          return message;
        }
      };
      var baseSupply = {};
      exports2.Supply = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.total) {
            coin_1.Coin.encode(v, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseSupply);
          message.total = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.total.push(coin_1.Coin.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseSupply);
          message.total = ((_a = object.total) !== null && _a !== void 0 ? _a : []).map((e) => coin_1.Coin.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.total) {
            obj.total = message.total.map((e) => e ? coin_1.Coin.toJSON(e) : void 0);
          } else {
            obj.total = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseSupply);
          message.total = ((_a = object.total) === null || _a === void 0 ? void 0 : _a.map((e) => coin_1.Coin.fromPartial(e))) || [];
          return message;
        }
      };
      var baseDenomUnit = { denom: "", exponent: 0, aliases: "" };
      exports2.DenomUnit = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.denom !== "") {
            writer.uint32(10).string(message.denom);
          }
          if (message.exponent !== 0) {
            writer.uint32(16).uint32(message.exponent);
          }
          for (const v of message.aliases) {
            writer.uint32(26).string(v);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseDenomUnit);
          message.aliases = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.denom = reader.string();
                break;
              case 2:
                message.exponent = reader.uint32();
                break;
              case 3:
                message.aliases.push(reader.string());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseDenomUnit);
          message.denom = object.denom !== void 0 && object.denom !== null ? String(object.denom) : "";
          message.exponent = object.exponent !== void 0 && object.exponent !== null ? Number(object.exponent) : 0;
          message.aliases = ((_a = object.aliases) !== null && _a !== void 0 ? _a : []).map((e) => String(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.denom !== void 0 && (obj.denom = message.denom);
          message.exponent !== void 0 && (obj.exponent = message.exponent);
          if (message.aliases) {
            obj.aliases = message.aliases.map((e) => e);
          } else {
            obj.aliases = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseDenomUnit);
          message.denom = (_a = object.denom) !== null && _a !== void 0 ? _a : "";
          message.exponent = (_b = object.exponent) !== null && _b !== void 0 ? _b : 0;
          message.aliases = ((_c = object.aliases) === null || _c === void 0 ? void 0 : _c.map((e) => e)) || [];
          return message;
        }
      };
      var baseMetadata = { description: "", base: "", display: "", name: "", symbol: "" };
      exports2.Metadata = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.description !== "") {
            writer.uint32(10).string(message.description);
          }
          for (const v of message.denomUnits) {
            exports2.DenomUnit.encode(v, writer.uint32(18).fork()).ldelim();
          }
          if (message.base !== "") {
            writer.uint32(26).string(message.base);
          }
          if (message.display !== "") {
            writer.uint32(34).string(message.display);
          }
          if (message.name !== "") {
            writer.uint32(42).string(message.name);
          }
          if (message.symbol !== "") {
            writer.uint32(50).string(message.symbol);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMetadata);
          message.denomUnits = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.description = reader.string();
                break;
              case 2:
                message.denomUnits.push(exports2.DenomUnit.decode(reader, reader.uint32()));
                break;
              case 3:
                message.base = reader.string();
                break;
              case 4:
                message.display = reader.string();
                break;
              case 5:
                message.name = reader.string();
                break;
              case 6:
                message.symbol = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseMetadata);
          message.description = object.description !== void 0 && object.description !== null ? String(object.description) : "";
          message.denomUnits = ((_a = object.denomUnits) !== null && _a !== void 0 ? _a : []).map((e) => exports2.DenomUnit.fromJSON(e));
          message.base = object.base !== void 0 && object.base !== null ? String(object.base) : "";
          message.display = object.display !== void 0 && object.display !== null ? String(object.display) : "";
          message.name = object.name !== void 0 && object.name !== null ? String(object.name) : "";
          message.symbol = object.symbol !== void 0 && object.symbol !== null ? String(object.symbol) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.description !== void 0 && (obj.description = message.description);
          if (message.denomUnits) {
            obj.denomUnits = message.denomUnits.map((e) => e ? exports2.DenomUnit.toJSON(e) : void 0);
          } else {
            obj.denomUnits = [];
          }
          message.base !== void 0 && (obj.base = message.base);
          message.display !== void 0 && (obj.display = message.display);
          message.name !== void 0 && (obj.name = message.name);
          message.symbol !== void 0 && (obj.symbol = message.symbol);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c, _d, _e, _f;
          const message = Object.assign({}, baseMetadata);
          message.description = (_a = object.description) !== null && _a !== void 0 ? _a : "";
          message.denomUnits = ((_b = object.denomUnits) === null || _b === void 0 ? void 0 : _b.map((e) => exports2.DenomUnit.fromPartial(e))) || [];
          message.base = (_c = object.base) !== null && _c !== void 0 ? _c : "";
          message.display = (_d = object.display) !== null && _d !== void 0 ? _d : "";
          message.name = (_e = object.name) !== null && _e !== void 0 ? _e : "";
          message.symbol = (_f = object.symbol) !== null && _f !== void 0 ? _f : "";
          return message;
        }
      };
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/cosmjs-types/cosmos/bank/v1beta1/tx.js
  var require_tx2 = __commonJS({
    "node_modules/cosmjs-types/cosmos/bank/v1beta1/tx.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.MsgClientImpl = exports2.MsgMultiSendResponse = exports2.MsgMultiSend = exports2.MsgSendResponse = exports2.MsgSend = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var coin_1 = require_coin();
      var bank_1 = require_bank();
      exports2.protobufPackage = "cosmos.bank.v1beta1";
      var baseMsgSend = { fromAddress: "", toAddress: "" };
      exports2.MsgSend = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.fromAddress !== "") {
            writer.uint32(10).string(message.fromAddress);
          }
          if (message.toAddress !== "") {
            writer.uint32(18).string(message.toAddress);
          }
          for (const v of message.amount) {
            coin_1.Coin.encode(v, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgSend);
          message.amount = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.fromAddress = reader.string();
                break;
              case 2:
                message.toAddress = reader.string();
                break;
              case 3:
                message.amount.push(coin_1.Coin.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseMsgSend);
          message.fromAddress = object.fromAddress !== void 0 && object.fromAddress !== null ? String(object.fromAddress) : "";
          message.toAddress = object.toAddress !== void 0 && object.toAddress !== null ? String(object.toAddress) : "";
          message.amount = ((_a = object.amount) !== null && _a !== void 0 ? _a : []).map((e) => coin_1.Coin.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.fromAddress !== void 0 && (obj.fromAddress = message.fromAddress);
          message.toAddress !== void 0 && (obj.toAddress = message.toAddress);
          if (message.amount) {
            obj.amount = message.amount.map((e) => e ? coin_1.Coin.toJSON(e) : void 0);
          } else {
            obj.amount = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseMsgSend);
          message.fromAddress = (_a = object.fromAddress) !== null && _a !== void 0 ? _a : "";
          message.toAddress = (_b = object.toAddress) !== null && _b !== void 0 ? _b : "";
          message.amount = ((_c = object.amount) === null || _c === void 0 ? void 0 : _c.map((e) => coin_1.Coin.fromPartial(e))) || [];
          return message;
        }
      };
      var baseMsgSendResponse = {};
      exports2.MsgSendResponse = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgSendResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseMsgSendResponse);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseMsgSendResponse);
          return message;
        }
      };
      var baseMsgMultiSend = {};
      exports2.MsgMultiSend = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.inputs) {
            bank_1.Input.encode(v, writer.uint32(10).fork()).ldelim();
          }
          for (const v of message.outputs) {
            bank_1.Output.encode(v, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgMultiSend);
          message.inputs = [];
          message.outputs = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.inputs.push(bank_1.Input.decode(reader, reader.uint32()));
                break;
              case 2:
                message.outputs.push(bank_1.Output.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a, _b;
          const message = Object.assign({}, baseMsgMultiSend);
          message.inputs = ((_a = object.inputs) !== null && _a !== void 0 ? _a : []).map((e) => bank_1.Input.fromJSON(e));
          message.outputs = ((_b = object.outputs) !== null && _b !== void 0 ? _b : []).map((e) => bank_1.Output.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.inputs) {
            obj.inputs = message.inputs.map((e) => e ? bank_1.Input.toJSON(e) : void 0);
          } else {
            obj.inputs = [];
          }
          if (message.outputs) {
            obj.outputs = message.outputs.map((e) => e ? bank_1.Output.toJSON(e) : void 0);
          } else {
            obj.outputs = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseMsgMultiSend);
          message.inputs = ((_a = object.inputs) === null || _a === void 0 ? void 0 : _a.map((e) => bank_1.Input.fromPartial(e))) || [];
          message.outputs = ((_b = object.outputs) === null || _b === void 0 ? void 0 : _b.map((e) => bank_1.Output.fromPartial(e))) || [];
          return message;
        }
      };
      var baseMsgMultiSendResponse = {};
      exports2.MsgMultiSendResponse = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgMultiSendResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseMsgMultiSendResponse);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseMsgMultiSendResponse);
          return message;
        }
      };
      var MsgClientImpl = class {
        constructor(rpc) {
          this.rpc = rpc;
          this.Send = this.Send.bind(this);
          this.MultiSend = this.MultiSend.bind(this);
        }
        Send(request) {
          const data = exports2.MsgSend.encode(request).finish();
          const promise = this.rpc.request("cosmos.bank.v1beta1.Msg", "Send", data);
          return promise.then((data2) => exports2.MsgSendResponse.decode(new minimal_1.default.Reader(data2)));
        }
        MultiSend(request) {
          const data = exports2.MsgMultiSend.encode(request).finish();
          const promise = this.rpc.request("cosmos.bank.v1beta1.Msg", "MultiSend", data);
          return promise.then((data2) => exports2.MsgMultiSendResponse.decode(new minimal_1.default.Reader(data2)));
        }
      };
      exports2.MsgClientImpl = MsgClientImpl;
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/@cosmjs/proto-signing/build/registry.js
  var require_registry = __commonJS({
    "node_modules/@cosmjs/proto-signing/build/registry.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.Registry = exports2.isTxBodyEncodeObject = exports2.isPbjsGeneratedType = exports2.isTsProtoGeneratedType = void 0;
      var tx_1 = require_tx2();
      var coin_1 = require_coin();
      var tx_2 = require_tx();
      var any_1 = require_any();
      function isTsProtoGeneratedType(type) {
        return typeof type.fromPartial === "function";
      }
      exports2.isTsProtoGeneratedType = isTsProtoGeneratedType;
      function isPbjsGeneratedType(type) {
        return !isTsProtoGeneratedType(type);
      }
      exports2.isPbjsGeneratedType = isPbjsGeneratedType;
      var defaultTypeUrls = {
        cosmosCoin: "/cosmos.base.v1beta1.Coin",
        cosmosMsgSend: "/cosmos.bank.v1beta1.MsgSend",
        cosmosTxBody: "/cosmos.tx.v1beta1.TxBody",
        googleAny: "/google.protobuf.Any"
      };
      function isTxBodyEncodeObject(encodeObject) {
        return encodeObject.typeUrl === "/cosmos.tx.v1beta1.TxBody";
      }
      exports2.isTxBodyEncodeObject = isTxBodyEncodeObject;
      var Registry = class {
        constructor(customTypes) {
          const { cosmosCoin, cosmosMsgSend } = defaultTypeUrls;
          this.types = customTypes ? new Map([...customTypes]) : /* @__PURE__ */ new Map([
            [cosmosCoin, coin_1.Coin],
            [cosmosMsgSend, tx_1.MsgSend]
          ]);
        }
        register(typeUrl, type) {
          this.types.set(typeUrl, type);
        }
        lookupType(typeUrl) {
          return this.types.get(typeUrl);
        }
        lookupTypeWithError(typeUrl) {
          const type = this.lookupType(typeUrl);
          if (!type) {
            throw new Error(`Unregistered type url: ${typeUrl}`);
          }
          return type;
        }
        encode(encodeObject) {
          const { value, typeUrl } = encodeObject;
          if (isTxBodyEncodeObject(encodeObject)) {
            return this.encodeTxBody(value);
          }
          const type = this.lookupTypeWithError(typeUrl);
          const instance = isTsProtoGeneratedType(type) ? type.fromPartial(value) : type.create(value);
          return type.encode(instance).finish();
        }
        encodeAsAny(encodeObject) {
          const binaryValue = this.encode(encodeObject);
          return any_1.Any.fromPartial({
            typeUrl: encodeObject.typeUrl,
            value: binaryValue
          });
        }
        encodeTxBody(txBodyFields) {
          const wrappedMessages = txBodyFields.messages.map((message) => this.encodeAsAny(message));
          const txBody = tx_2.TxBody.fromPartial({
            ...txBodyFields,
            messages: wrappedMessages
          });
          return tx_2.TxBody.encode(txBody).finish();
        }
        decode({ typeUrl, value }) {
          if (typeUrl === defaultTypeUrls.cosmosTxBody) {
            return this.decodeTxBody(value);
          }
          const type = this.lookupTypeWithError(typeUrl);
          const decoded = type.decode(value);
          Object.entries(decoded).forEach(([key, val]) => {
            if (typeof Buffer !== "undefined" && typeof Buffer.isBuffer !== "undefined" && Buffer.isBuffer(val)) {
              decoded[key] = Uint8Array.from(val);
            }
          });
          return decoded;
        }
        decodeTxBody(txBody) {
          const decodedTxBody = tx_2.TxBody.decode(txBody);
          return {
            ...decodedTxBody,
            messages: decodedTxBody.messages.map(({ typeUrl, value }) => {
              if (!typeUrl) {
                throw new Error("Missing type_url in Any");
              }
              if (!value) {
                throw new Error("Missing value in Any");
              }
              return this.decode({ typeUrl, value });
            })
          };
        }
      };
      exports2.Registry = Registry;
    }
  });

  // node_modules/@cosmjs/proto-signing/build/signer.js
  var require_signer = __commonJS({
    "node_modules/@cosmjs/proto-signing/build/signer.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.isOfflineDirectSigner = void 0;
      function isOfflineDirectSigner(signer) {
        return signer.signDirect !== void 0;
      }
      exports2.isOfflineDirectSigner = isOfflineDirectSigner;
    }
  });

  // node_modules/@cosmjs/proto-signing/build/index.js
  var require_build6 = __commonJS({
    "node_modules/@cosmjs/proto-signing/build/index.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.coins = exports2.coin = exports2.executeKdf = exports2.makeSignDoc = exports2.makeSignBytes = exports2.makeAuthInfoBytes = exports2.isOfflineDirectSigner = exports2.Registry = exports2.isTxBodyEncodeObject = exports2.isTsProtoGeneratedType = exports2.isPbjsGeneratedType = exports2.encodePubkey = exports2.decodePubkey = exports2.makeCosmoshubPath = exports2.DirectSecp256k1Wallet = exports2.extractKdfConfiguration = exports2.DirectSecp256k1HdWallet = exports2.decodeTxRaw = exports2.parseCoins = void 0;
      var coins_1 = require_coins();
      Object.defineProperty(exports2, "parseCoins", { enumerable: true, get: function() {
        return coins_1.parseCoins;
      } });
      var decode_1 = require_decode();
      Object.defineProperty(exports2, "decodeTxRaw", { enumerable: true, get: function() {
        return decode_1.decodeTxRaw;
      } });
      var directsecp256k1hdwallet_1 = require_directsecp256k1hdwallet();
      Object.defineProperty(exports2, "DirectSecp256k1HdWallet", { enumerable: true, get: function() {
        return directsecp256k1hdwallet_1.DirectSecp256k1HdWallet;
      } });
      Object.defineProperty(exports2, "extractKdfConfiguration", { enumerable: true, get: function() {
        return directsecp256k1hdwallet_1.extractKdfConfiguration;
      } });
      var directsecp256k1wallet_1 = require_directsecp256k1wallet();
      Object.defineProperty(exports2, "DirectSecp256k1Wallet", { enumerable: true, get: function() {
        return directsecp256k1wallet_1.DirectSecp256k1Wallet;
      } });
      var paths_1 = require_paths2();
      Object.defineProperty(exports2, "makeCosmoshubPath", { enumerable: true, get: function() {
        return paths_1.makeCosmoshubPath;
      } });
      var pubkey_1 = require_pubkey();
      Object.defineProperty(exports2, "decodePubkey", { enumerable: true, get: function() {
        return pubkey_1.decodePubkey;
      } });
      Object.defineProperty(exports2, "encodePubkey", { enumerable: true, get: function() {
        return pubkey_1.encodePubkey;
      } });
      var registry_1 = require_registry();
      Object.defineProperty(exports2, "isPbjsGeneratedType", { enumerable: true, get: function() {
        return registry_1.isPbjsGeneratedType;
      } });
      Object.defineProperty(exports2, "isTsProtoGeneratedType", { enumerable: true, get: function() {
        return registry_1.isTsProtoGeneratedType;
      } });
      Object.defineProperty(exports2, "isTxBodyEncodeObject", { enumerable: true, get: function() {
        return registry_1.isTxBodyEncodeObject;
      } });
      Object.defineProperty(exports2, "Registry", { enumerable: true, get: function() {
        return registry_1.Registry;
      } });
      var signer_1 = require_signer();
      Object.defineProperty(exports2, "isOfflineDirectSigner", { enumerable: true, get: function() {
        return signer_1.isOfflineDirectSigner;
      } });
      var signing_1 = require_signing2();
      Object.defineProperty(exports2, "makeAuthInfoBytes", { enumerable: true, get: function() {
        return signing_1.makeAuthInfoBytes;
      } });
      Object.defineProperty(exports2, "makeSignBytes", { enumerable: true, get: function() {
        return signing_1.makeSignBytes;
      } });
      Object.defineProperty(exports2, "makeSignDoc", { enumerable: true, get: function() {
        return signing_1.makeSignDoc;
      } });
      var wallet_1 = require_wallet2();
      Object.defineProperty(exports2, "executeKdf", { enumerable: true, get: function() {
        return wallet_1.executeKdf;
      } });
      var amino_1 = require_build5();
      Object.defineProperty(exports2, "coin", { enumerable: true, get: function() {
        return amino_1.coin;
      } });
      Object.defineProperty(exports2, "coins", { enumerable: true, get: function() {
        return amino_1.coins;
      } });
    }
  });

  // node_modules/cosmjs-types/cosmos/auth/v1beta1/auth.js
  var require_auth = __commonJS({
    "node_modules/cosmjs-types/cosmos/auth/v1beta1/auth.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.Params = exports2.ModuleAccount = exports2.BaseAccount = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var any_1 = require_any();
      exports2.protobufPackage = "cosmos.auth.v1beta1";
      var baseBaseAccount = { address: "", accountNumber: long_1.default.UZERO, sequence: long_1.default.UZERO };
      exports2.BaseAccount = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.address !== "") {
            writer.uint32(10).string(message.address);
          }
          if (message.pubKey !== void 0) {
            any_1.Any.encode(message.pubKey, writer.uint32(18).fork()).ldelim();
          }
          if (!message.accountNumber.isZero()) {
            writer.uint32(24).uint64(message.accountNumber);
          }
          if (!message.sequence.isZero()) {
            writer.uint32(32).uint64(message.sequence);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseBaseAccount);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.address = reader.string();
                break;
              case 2:
                message.pubKey = any_1.Any.decode(reader, reader.uint32());
                break;
              case 3:
                message.accountNumber = reader.uint64();
                break;
              case 4:
                message.sequence = reader.uint64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseBaseAccount);
          message.address = object.address !== void 0 && object.address !== null ? String(object.address) : "";
          message.pubKey = object.pubKey !== void 0 && object.pubKey !== null ? any_1.Any.fromJSON(object.pubKey) : void 0;
          message.accountNumber = object.accountNumber !== void 0 && object.accountNumber !== null ? long_1.default.fromString(object.accountNumber) : long_1.default.UZERO;
          message.sequence = object.sequence !== void 0 && object.sequence !== null ? long_1.default.fromString(object.sequence) : long_1.default.UZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.address !== void 0 && (obj.address = message.address);
          message.pubKey !== void 0 && (obj.pubKey = message.pubKey ? any_1.Any.toJSON(message.pubKey) : void 0);
          message.accountNumber !== void 0 && (obj.accountNumber = (message.accountNumber || long_1.default.UZERO).toString());
          message.sequence !== void 0 && (obj.sequence = (message.sequence || long_1.default.UZERO).toString());
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseBaseAccount);
          message.address = (_a = object.address) !== null && _a !== void 0 ? _a : "";
          message.pubKey = object.pubKey !== void 0 && object.pubKey !== null ? any_1.Any.fromPartial(object.pubKey) : void 0;
          message.accountNumber = object.accountNumber !== void 0 && object.accountNumber !== null ? long_1.default.fromValue(object.accountNumber) : long_1.default.UZERO;
          message.sequence = object.sequence !== void 0 && object.sequence !== null ? long_1.default.fromValue(object.sequence) : long_1.default.UZERO;
          return message;
        }
      };
      var baseModuleAccount = { name: "", permissions: "" };
      exports2.ModuleAccount = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.baseAccount !== void 0) {
            exports2.BaseAccount.encode(message.baseAccount, writer.uint32(10).fork()).ldelim();
          }
          if (message.name !== "") {
            writer.uint32(18).string(message.name);
          }
          for (const v of message.permissions) {
            writer.uint32(26).string(v);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseModuleAccount);
          message.permissions = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.baseAccount = exports2.BaseAccount.decode(reader, reader.uint32());
                break;
              case 2:
                message.name = reader.string();
                break;
              case 3:
                message.permissions.push(reader.string());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseModuleAccount);
          message.baseAccount = object.baseAccount !== void 0 && object.baseAccount !== null ? exports2.BaseAccount.fromJSON(object.baseAccount) : void 0;
          message.name = object.name !== void 0 && object.name !== null ? String(object.name) : "";
          message.permissions = ((_a = object.permissions) !== null && _a !== void 0 ? _a : []).map((e) => String(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.baseAccount !== void 0 && (obj.baseAccount = message.baseAccount ? exports2.BaseAccount.toJSON(message.baseAccount) : void 0);
          message.name !== void 0 && (obj.name = message.name);
          if (message.permissions) {
            obj.permissions = message.permissions.map((e) => e);
          } else {
            obj.permissions = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseModuleAccount);
          message.baseAccount = object.baseAccount !== void 0 && object.baseAccount !== null ? exports2.BaseAccount.fromPartial(object.baseAccount) : void 0;
          message.name = (_a = object.name) !== null && _a !== void 0 ? _a : "";
          message.permissions = ((_b = object.permissions) === null || _b === void 0 ? void 0 : _b.map((e) => e)) || [];
          return message;
        }
      };
      var baseParams = {
        maxMemoCharacters: long_1.default.UZERO,
        txSigLimit: long_1.default.UZERO,
        txSizeCostPerByte: long_1.default.UZERO,
        sigVerifyCostEd25519: long_1.default.UZERO,
        sigVerifyCostSecp256k1: long_1.default.UZERO
      };
      exports2.Params = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.maxMemoCharacters.isZero()) {
            writer.uint32(8).uint64(message.maxMemoCharacters);
          }
          if (!message.txSigLimit.isZero()) {
            writer.uint32(16).uint64(message.txSigLimit);
          }
          if (!message.txSizeCostPerByte.isZero()) {
            writer.uint32(24).uint64(message.txSizeCostPerByte);
          }
          if (!message.sigVerifyCostEd25519.isZero()) {
            writer.uint32(32).uint64(message.sigVerifyCostEd25519);
          }
          if (!message.sigVerifyCostSecp256k1.isZero()) {
            writer.uint32(40).uint64(message.sigVerifyCostSecp256k1);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseParams);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.maxMemoCharacters = reader.uint64();
                break;
              case 2:
                message.txSigLimit = reader.uint64();
                break;
              case 3:
                message.txSizeCostPerByte = reader.uint64();
                break;
              case 4:
                message.sigVerifyCostEd25519 = reader.uint64();
                break;
              case 5:
                message.sigVerifyCostSecp256k1 = reader.uint64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseParams);
          message.maxMemoCharacters = object.maxMemoCharacters !== void 0 && object.maxMemoCharacters !== null ? long_1.default.fromString(object.maxMemoCharacters) : long_1.default.UZERO;
          message.txSigLimit = object.txSigLimit !== void 0 && object.txSigLimit !== null ? long_1.default.fromString(object.txSigLimit) : long_1.default.UZERO;
          message.txSizeCostPerByte = object.txSizeCostPerByte !== void 0 && object.txSizeCostPerByte !== null ? long_1.default.fromString(object.txSizeCostPerByte) : long_1.default.UZERO;
          message.sigVerifyCostEd25519 = object.sigVerifyCostEd25519 !== void 0 && object.sigVerifyCostEd25519 !== null ? long_1.default.fromString(object.sigVerifyCostEd25519) : long_1.default.UZERO;
          message.sigVerifyCostSecp256k1 = object.sigVerifyCostSecp256k1 !== void 0 && object.sigVerifyCostSecp256k1 !== null ? long_1.default.fromString(object.sigVerifyCostSecp256k1) : long_1.default.UZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.maxMemoCharacters !== void 0 && (obj.maxMemoCharacters = (message.maxMemoCharacters || long_1.default.UZERO).toString());
          message.txSigLimit !== void 0 && (obj.txSigLimit = (message.txSigLimit || long_1.default.UZERO).toString());
          message.txSizeCostPerByte !== void 0 && (obj.txSizeCostPerByte = (message.txSizeCostPerByte || long_1.default.UZERO).toString());
          message.sigVerifyCostEd25519 !== void 0 && (obj.sigVerifyCostEd25519 = (message.sigVerifyCostEd25519 || long_1.default.UZERO).toString());
          message.sigVerifyCostSecp256k1 !== void 0 && (obj.sigVerifyCostSecp256k1 = (message.sigVerifyCostSecp256k1 || long_1.default.UZERO).toString());
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseParams);
          message.maxMemoCharacters = object.maxMemoCharacters !== void 0 && object.maxMemoCharacters !== null ? long_1.default.fromValue(object.maxMemoCharacters) : long_1.default.UZERO;
          message.txSigLimit = object.txSigLimit !== void 0 && object.txSigLimit !== null ? long_1.default.fromValue(object.txSigLimit) : long_1.default.UZERO;
          message.txSizeCostPerByte = object.txSizeCostPerByte !== void 0 && object.txSizeCostPerByte !== null ? long_1.default.fromValue(object.txSizeCostPerByte) : long_1.default.UZERO;
          message.sigVerifyCostEd25519 = object.sigVerifyCostEd25519 !== void 0 && object.sigVerifyCostEd25519 !== null ? long_1.default.fromValue(object.sigVerifyCostEd25519) : long_1.default.UZERO;
          message.sigVerifyCostSecp256k1 = object.sigVerifyCostSecp256k1 !== void 0 && object.sigVerifyCostSecp256k1 !== null ? long_1.default.fromValue(object.sigVerifyCostSecp256k1) : long_1.default.UZERO;
          return message;
        }
      };
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/cosmjs-types/cosmos/vesting/v1beta1/vesting.js
  var require_vesting = __commonJS({
    "node_modules/cosmjs-types/cosmos/vesting/v1beta1/vesting.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.PermanentLockedAccount = exports2.PeriodicVestingAccount = exports2.Period = exports2.DelayedVestingAccount = exports2.ContinuousVestingAccount = exports2.BaseVestingAccount = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var auth_1 = require_auth();
      var coin_1 = require_coin();
      exports2.protobufPackage = "cosmos.vesting.v1beta1";
      var baseBaseVestingAccount = { endTime: long_1.default.ZERO };
      exports2.BaseVestingAccount = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.baseAccount !== void 0) {
            auth_1.BaseAccount.encode(message.baseAccount, writer.uint32(10).fork()).ldelim();
          }
          for (const v of message.originalVesting) {
            coin_1.Coin.encode(v, writer.uint32(18).fork()).ldelim();
          }
          for (const v of message.delegatedFree) {
            coin_1.Coin.encode(v, writer.uint32(26).fork()).ldelim();
          }
          for (const v of message.delegatedVesting) {
            coin_1.Coin.encode(v, writer.uint32(34).fork()).ldelim();
          }
          if (!message.endTime.isZero()) {
            writer.uint32(40).int64(message.endTime);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseBaseVestingAccount);
          message.originalVesting = [];
          message.delegatedFree = [];
          message.delegatedVesting = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.baseAccount = auth_1.BaseAccount.decode(reader, reader.uint32());
                break;
              case 2:
                message.originalVesting.push(coin_1.Coin.decode(reader, reader.uint32()));
                break;
              case 3:
                message.delegatedFree.push(coin_1.Coin.decode(reader, reader.uint32()));
                break;
              case 4:
                message.delegatedVesting.push(coin_1.Coin.decode(reader, reader.uint32()));
                break;
              case 5:
                message.endTime = reader.int64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseBaseVestingAccount);
          message.baseAccount = object.baseAccount !== void 0 && object.baseAccount !== null ? auth_1.BaseAccount.fromJSON(object.baseAccount) : void 0;
          message.originalVesting = ((_a = object.originalVesting) !== null && _a !== void 0 ? _a : []).map((e) => coin_1.Coin.fromJSON(e));
          message.delegatedFree = ((_b = object.delegatedFree) !== null && _b !== void 0 ? _b : []).map((e) => coin_1.Coin.fromJSON(e));
          message.delegatedVesting = ((_c = object.delegatedVesting) !== null && _c !== void 0 ? _c : []).map((e) => coin_1.Coin.fromJSON(e));
          message.endTime = object.endTime !== void 0 && object.endTime !== null ? long_1.default.fromString(object.endTime) : long_1.default.ZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.baseAccount !== void 0 && (obj.baseAccount = message.baseAccount ? auth_1.BaseAccount.toJSON(message.baseAccount) : void 0);
          if (message.originalVesting) {
            obj.originalVesting = message.originalVesting.map((e) => e ? coin_1.Coin.toJSON(e) : void 0);
          } else {
            obj.originalVesting = [];
          }
          if (message.delegatedFree) {
            obj.delegatedFree = message.delegatedFree.map((e) => e ? coin_1.Coin.toJSON(e) : void 0);
          } else {
            obj.delegatedFree = [];
          }
          if (message.delegatedVesting) {
            obj.delegatedVesting = message.delegatedVesting.map((e) => e ? coin_1.Coin.toJSON(e) : void 0);
          } else {
            obj.delegatedVesting = [];
          }
          message.endTime !== void 0 && (obj.endTime = (message.endTime || long_1.default.ZERO).toString());
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseBaseVestingAccount);
          message.baseAccount = object.baseAccount !== void 0 && object.baseAccount !== null ? auth_1.BaseAccount.fromPartial(object.baseAccount) : void 0;
          message.originalVesting = ((_a = object.originalVesting) === null || _a === void 0 ? void 0 : _a.map((e) => coin_1.Coin.fromPartial(e))) || [];
          message.delegatedFree = ((_b = object.delegatedFree) === null || _b === void 0 ? void 0 : _b.map((e) => coin_1.Coin.fromPartial(e))) || [];
          message.delegatedVesting = ((_c = object.delegatedVesting) === null || _c === void 0 ? void 0 : _c.map((e) => coin_1.Coin.fromPartial(e))) || [];
          message.endTime = object.endTime !== void 0 && object.endTime !== null ? long_1.default.fromValue(object.endTime) : long_1.default.ZERO;
          return message;
        }
      };
      var baseContinuousVestingAccount = { startTime: long_1.default.ZERO };
      exports2.ContinuousVestingAccount = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.baseVestingAccount !== void 0) {
            exports2.BaseVestingAccount.encode(message.baseVestingAccount, writer.uint32(10).fork()).ldelim();
          }
          if (!message.startTime.isZero()) {
            writer.uint32(16).int64(message.startTime);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseContinuousVestingAccount);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.baseVestingAccount = exports2.BaseVestingAccount.decode(reader, reader.uint32());
                break;
              case 2:
                message.startTime = reader.int64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseContinuousVestingAccount);
          message.baseVestingAccount = object.baseVestingAccount !== void 0 && object.baseVestingAccount !== null ? exports2.BaseVestingAccount.fromJSON(object.baseVestingAccount) : void 0;
          message.startTime = object.startTime !== void 0 && object.startTime !== null ? long_1.default.fromString(object.startTime) : long_1.default.ZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.baseVestingAccount !== void 0 && (obj.baseVestingAccount = message.baseVestingAccount ? exports2.BaseVestingAccount.toJSON(message.baseVestingAccount) : void 0);
          message.startTime !== void 0 && (obj.startTime = (message.startTime || long_1.default.ZERO).toString());
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseContinuousVestingAccount);
          message.baseVestingAccount = object.baseVestingAccount !== void 0 && object.baseVestingAccount !== null ? exports2.BaseVestingAccount.fromPartial(object.baseVestingAccount) : void 0;
          message.startTime = object.startTime !== void 0 && object.startTime !== null ? long_1.default.fromValue(object.startTime) : long_1.default.ZERO;
          return message;
        }
      };
      var baseDelayedVestingAccount = {};
      exports2.DelayedVestingAccount = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.baseVestingAccount !== void 0) {
            exports2.BaseVestingAccount.encode(message.baseVestingAccount, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseDelayedVestingAccount);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.baseVestingAccount = exports2.BaseVestingAccount.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseDelayedVestingAccount);
          message.baseVestingAccount = object.baseVestingAccount !== void 0 && object.baseVestingAccount !== null ? exports2.BaseVestingAccount.fromJSON(object.baseVestingAccount) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.baseVestingAccount !== void 0 && (obj.baseVestingAccount = message.baseVestingAccount ? exports2.BaseVestingAccount.toJSON(message.baseVestingAccount) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseDelayedVestingAccount);
          message.baseVestingAccount = object.baseVestingAccount !== void 0 && object.baseVestingAccount !== null ? exports2.BaseVestingAccount.fromPartial(object.baseVestingAccount) : void 0;
          return message;
        }
      };
      var basePeriod = { length: long_1.default.ZERO };
      exports2.Period = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.length.isZero()) {
            writer.uint32(8).int64(message.length);
          }
          for (const v of message.amount) {
            coin_1.Coin.encode(v, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, basePeriod);
          message.amount = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.length = reader.int64();
                break;
              case 2:
                message.amount.push(coin_1.Coin.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, basePeriod);
          message.length = object.length !== void 0 && object.length !== null ? long_1.default.fromString(object.length) : long_1.default.ZERO;
          message.amount = ((_a = object.amount) !== null && _a !== void 0 ? _a : []).map((e) => coin_1.Coin.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.length !== void 0 && (obj.length = (message.length || long_1.default.ZERO).toString());
          if (message.amount) {
            obj.amount = message.amount.map((e) => e ? coin_1.Coin.toJSON(e) : void 0);
          } else {
            obj.amount = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, basePeriod);
          message.length = object.length !== void 0 && object.length !== null ? long_1.default.fromValue(object.length) : long_1.default.ZERO;
          message.amount = ((_a = object.amount) === null || _a === void 0 ? void 0 : _a.map((e) => coin_1.Coin.fromPartial(e))) || [];
          return message;
        }
      };
      var basePeriodicVestingAccount = { startTime: long_1.default.ZERO };
      exports2.PeriodicVestingAccount = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.baseVestingAccount !== void 0) {
            exports2.BaseVestingAccount.encode(message.baseVestingAccount, writer.uint32(10).fork()).ldelim();
          }
          if (!message.startTime.isZero()) {
            writer.uint32(16).int64(message.startTime);
          }
          for (const v of message.vestingPeriods) {
            exports2.Period.encode(v, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, basePeriodicVestingAccount);
          message.vestingPeriods = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.baseVestingAccount = exports2.BaseVestingAccount.decode(reader, reader.uint32());
                break;
              case 2:
                message.startTime = reader.int64();
                break;
              case 3:
                message.vestingPeriods.push(exports2.Period.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, basePeriodicVestingAccount);
          message.baseVestingAccount = object.baseVestingAccount !== void 0 && object.baseVestingAccount !== null ? exports2.BaseVestingAccount.fromJSON(object.baseVestingAccount) : void 0;
          message.startTime = object.startTime !== void 0 && object.startTime !== null ? long_1.default.fromString(object.startTime) : long_1.default.ZERO;
          message.vestingPeriods = ((_a = object.vestingPeriods) !== null && _a !== void 0 ? _a : []).map((e) => exports2.Period.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.baseVestingAccount !== void 0 && (obj.baseVestingAccount = message.baseVestingAccount ? exports2.BaseVestingAccount.toJSON(message.baseVestingAccount) : void 0);
          message.startTime !== void 0 && (obj.startTime = (message.startTime || long_1.default.ZERO).toString());
          if (message.vestingPeriods) {
            obj.vestingPeriods = message.vestingPeriods.map((e) => e ? exports2.Period.toJSON(e) : void 0);
          } else {
            obj.vestingPeriods = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, basePeriodicVestingAccount);
          message.baseVestingAccount = object.baseVestingAccount !== void 0 && object.baseVestingAccount !== null ? exports2.BaseVestingAccount.fromPartial(object.baseVestingAccount) : void 0;
          message.startTime = object.startTime !== void 0 && object.startTime !== null ? long_1.default.fromValue(object.startTime) : long_1.default.ZERO;
          message.vestingPeriods = ((_a = object.vestingPeriods) === null || _a === void 0 ? void 0 : _a.map((e) => exports2.Period.fromPartial(e))) || [];
          return message;
        }
      };
      var basePermanentLockedAccount = {};
      exports2.PermanentLockedAccount = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.baseVestingAccount !== void 0) {
            exports2.BaseVestingAccount.encode(message.baseVestingAccount, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, basePermanentLockedAccount);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.baseVestingAccount = exports2.BaseVestingAccount.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, basePermanentLockedAccount);
          message.baseVestingAccount = object.baseVestingAccount !== void 0 && object.baseVestingAccount !== null ? exports2.BaseVestingAccount.fromJSON(object.baseVestingAccount) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.baseVestingAccount !== void 0 && (obj.baseVestingAccount = message.baseVestingAccount ? exports2.BaseVestingAccount.toJSON(message.baseVestingAccount) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, basePermanentLockedAccount);
          message.baseVestingAccount = object.baseVestingAccount !== void 0 && object.baseVestingAccount !== null ? exports2.BaseVestingAccount.fromPartial(object.baseVestingAccount) : void 0;
          return message;
        }
      };
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/@cosmjs/stargate/build/accounts.js
  var require_accounts = __commonJS({
    "node_modules/@cosmjs/stargate/build/accounts.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.accountFromAny = void 0;
      var math_1 = require_build();
      var proto_signing_1 = require_build6();
      var utils_1 = require_build3();
      var auth_1 = require_auth();
      var vesting_1 = require_vesting();
      function uint64FromProto(input) {
        return math_1.Uint64.fromString(input.toString());
      }
      function accountFromBaseAccount(input) {
        const { address, pubKey, accountNumber, sequence } = input;
        const pubkey = (0, proto_signing_1.decodePubkey)(pubKey);
        return {
          address,
          pubkey,
          accountNumber: uint64FromProto(accountNumber).toNumber(),
          sequence: uint64FromProto(sequence).toNumber()
        };
      }
      function accountFromAny(input) {
        var _a, _b, _c, _d, _e, _f, _g;
        const { typeUrl, value } = input;
        switch (typeUrl) {
          case "/cosmos.auth.v1beta1.BaseAccount":
            return accountFromBaseAccount(auth_1.BaseAccount.decode(value));
          case "/cosmos.auth.v1beta1.ModuleAccount": {
            const baseAccount = auth_1.ModuleAccount.decode(value).baseAccount;
            (0, utils_1.assert)(baseAccount);
            return accountFromBaseAccount(baseAccount);
          }
          case "/cosmos.vesting.v1beta1.BaseVestingAccount": {
            const baseAccount = (_a = vesting_1.BaseVestingAccount.decode(value)) === null || _a === void 0 ? void 0 : _a.baseAccount;
            (0, utils_1.assert)(baseAccount);
            return accountFromBaseAccount(baseAccount);
          }
          case "/cosmos.vesting.v1beta1.ContinuousVestingAccount": {
            const baseAccount = (_c = (_b = vesting_1.ContinuousVestingAccount.decode(value)) === null || _b === void 0 ? void 0 : _b.baseVestingAccount) === null || _c === void 0 ? void 0 : _c.baseAccount;
            (0, utils_1.assert)(baseAccount);
            return accountFromBaseAccount(baseAccount);
          }
          case "/cosmos.vesting.v1beta1.DelayedVestingAccount": {
            const baseAccount = (_e = (_d = vesting_1.DelayedVestingAccount.decode(value)) === null || _d === void 0 ? void 0 : _d.baseVestingAccount) === null || _e === void 0 ? void 0 : _e.baseAccount;
            (0, utils_1.assert)(baseAccount);
            return accountFromBaseAccount(baseAccount);
          }
          case "/cosmos.vesting.v1beta1.PeriodicVestingAccount": {
            const baseAccount = (_g = (_f = vesting_1.PeriodicVestingAccount.decode(value)) === null || _f === void 0 ? void 0 : _f.baseVestingAccount) === null || _g === void 0 ? void 0 : _g.baseAccount;
            (0, utils_1.assert)(baseAccount);
            return accountFromBaseAccount(baseAccount);
          }
          default:
            throw new Error(`Unsupported type: '${typeUrl}'`);
        }
      }
      exports2.accountFromAny = accountFromAny;
    }
  });

  // node_modules/@cosmjs/stargate/build/aminotypes.js
  var require_aminotypes = __commonJS({
    "node_modules/@cosmjs/stargate/build/aminotypes.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.AminoTypes = void 0;
      function isAminoConverter(converter) {
        return typeof converter[1] !== "string";
      }
      var AminoTypes = class {
        constructor(types) {
          this.register = types;
        }
        toAmino({ typeUrl, value }) {
          const converter = this.register[typeUrl];
          if (converter === "not_supported_by_chain") {
            throw new Error(`The message type '${typeUrl}' cannot be signed using the Amino JSON sign mode because this is not supported by chain.`);
          }
          if (!converter) {
            throw new Error(`Type URL '${typeUrl}' does not exist in the Amino message type register. If you need support for this message type, you can pass in additional entries to the AminoTypes constructor. If you think this message type should be included by default, please open an issue at https://github.com/cosmos/cosmjs/issues.`);
          }
          return {
            type: converter.aminoType,
            value: converter.toAmino(value)
          };
        }
        fromAmino({ type, value }) {
          const matches = Object.entries(this.register).filter(isAminoConverter).filter(([_typeUrl, { aminoType }]) => aminoType === type);
          switch (matches.length) {
            case 0: {
              throw new Error(`Amino type identifier '${type}' does not exist in the Amino message type register. If you need support for this message type, you can pass in additional entries to the AminoTypes constructor. If you think this message type should be included by default, please open an issue at https://github.com/cosmos/cosmjs/issues.`);
            }
            case 1: {
              const [typeUrl, converter] = matches[0];
              return {
                typeUrl,
                value: converter.fromAmino(value)
              };
            }
            default:
              throw new Error(`Multiple types are registered with Amino type identifier '${type}': '` + matches.map(([key, _value]) => key).sort().join("', '") + "'. Thus fromAmino cannot be performed.");
          }
        }
      };
      exports2.AminoTypes = AminoTypes;
    }
  });

  // node_modules/@cosmjs/stargate/build/fee.js
  var require_fee = __commonJS({
    "node_modules/@cosmjs/stargate/build/fee.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.calculateFee = exports2.GasPrice = void 0;
      var math_1 = require_build();
      var proto_signing_1 = require_build6();
      function checkDenom(denom) {
        if (denom.length < 3 || denom.length > 128) {
          throw new Error("Denom must be between 3 and 128 characters");
        }
      }
      var GasPrice = class {
        constructor(amount, denom) {
          this.amount = amount;
          this.denom = denom;
        }
        static fromString(gasPrice) {
          const matchResult = gasPrice.match(/^([0-9.]+)([a-z][a-z0-9]*)$/i);
          if (!matchResult) {
            throw new Error("Invalid gas price string");
          }
          const [_, amount, denom] = matchResult;
          checkDenom(denom);
          const fractionalDigits = 18;
          const decimalAmount = math_1.Decimal.fromUserInput(amount, fractionalDigits);
          return new GasPrice(decimalAmount, denom);
        }
        toString() {
          return this.amount.toString() + this.denom;
        }
      };
      exports2.GasPrice = GasPrice;
      function calculateFee(gasLimit, gasPrice) {
        const processedGasPrice = typeof gasPrice === "string" ? GasPrice.fromString(gasPrice) : gasPrice;
        const { denom, amount: gasPriceAmount } = processedGasPrice;
        const amount = Math.ceil(gasPriceAmount.multiply(new math_1.Uint53(gasLimit)).toFloatApproximation());
        return {
          amount: (0, proto_signing_1.coins)(amount, denom),
          gas: gasLimit.toString()
        };
      }
      exports2.calculateFee = calculateFee;
    }
  });

  // node_modules/@cosmjs/stargate/build/logs.js
  var require_logs = __commonJS({
    "node_modules/@cosmjs/stargate/build/logs.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.findAttribute = exports2.parseRawLog = exports2.parseLogs = exports2.parseLog = exports2.parseEvent = exports2.parseAttribute = void 0;
      var utils_1 = require_build3();
      function parseAttribute(input) {
        if (!(0, utils_1.isNonNullObject)(input))
          throw new Error("Attribute must be a non-null object");
        const { key, value } = input;
        if (typeof key !== "string" || !key)
          throw new Error("Attribute's key must be a non-empty string");
        if (typeof value !== "string" && typeof value !== "undefined") {
          throw new Error("Attribute's value must be a string or unset");
        }
        return {
          key,
          value: value || ""
        };
      }
      exports2.parseAttribute = parseAttribute;
      function parseEvent(input) {
        if (!(0, utils_1.isNonNullObject)(input))
          throw new Error("Event must be a non-null object");
        const { type, attributes } = input;
        if (typeof type !== "string" || type === "") {
          throw new Error(`Event type must be a non-empty string`);
        }
        if (!Array.isArray(attributes))
          throw new Error("Event's attributes must be an array");
        return {
          type,
          attributes: attributes.map(parseAttribute)
        };
      }
      exports2.parseEvent = parseEvent;
      function parseLog(input) {
        if (!(0, utils_1.isNonNullObject)(input))
          throw new Error("Log must be a non-null object");
        const { msg_index, log, events } = input;
        if (typeof msg_index !== "number")
          throw new Error("Log's msg_index must be a number");
        if (typeof log !== "string")
          throw new Error("Log's log must be a string");
        if (!Array.isArray(events))
          throw new Error("Log's events must be an array");
        return {
          msg_index,
          log,
          events: events.map(parseEvent)
        };
      }
      exports2.parseLog = parseLog;
      function parseLogs(input) {
        if (!Array.isArray(input))
          throw new Error("Logs must be an array");
        return input.map(parseLog);
      }
      exports2.parseLogs = parseLogs;
      function parseRawLog(input = "[]") {
        const logsToParse = JSON.parse(input).map(({ events }, i) => ({
          msg_index: i,
          events,
          log: ""
        }));
        return parseLogs(logsToParse);
      }
      exports2.parseRawLog = parseRawLog;
      function findAttribute(logs, eventType, attrKey) {
        var _a;
        const firstLogs = logs.find(() => true);
        const out = (_a = firstLogs === null || firstLogs === void 0 ? void 0 : firstLogs.events.find((event) => event.type === eventType)) === null || _a === void 0 ? void 0 : _a.attributes.find((attr) => attr.key === attrKey);
        if (!out) {
          throw new Error(`Could not find attribute '${attrKey}' in first event of type '${eventType}' in first log.`);
        }
        return out;
      }
      exports2.findAttribute = findAttribute;
    }
  });

  // node_modules/cosmjs-types/cosmos/base/query/v1beta1/pagination.js
  var require_pagination = __commonJS({
    "node_modules/cosmjs-types/cosmos/base/query/v1beta1/pagination.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.PageResponse = exports2.PageRequest = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      exports2.protobufPackage = "cosmos.base.query.v1beta1";
      var basePageRequest = { offset: long_1.default.UZERO, limit: long_1.default.UZERO, countTotal: false, reverse: false };
      exports2.PageRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.key.length !== 0) {
            writer.uint32(10).bytes(message.key);
          }
          if (!message.offset.isZero()) {
            writer.uint32(16).uint64(message.offset);
          }
          if (!message.limit.isZero()) {
            writer.uint32(24).uint64(message.limit);
          }
          if (message.countTotal === true) {
            writer.uint32(32).bool(message.countTotal);
          }
          if (message.reverse === true) {
            writer.uint32(40).bool(message.reverse);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, basePageRequest);
          message.key = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.key = reader.bytes();
                break;
              case 2:
                message.offset = reader.uint64();
                break;
              case 3:
                message.limit = reader.uint64();
                break;
              case 4:
                message.countTotal = reader.bool();
                break;
              case 5:
                message.reverse = reader.bool();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, basePageRequest);
          message.key = object.key !== void 0 && object.key !== null ? bytesFromBase64(object.key) : new Uint8Array();
          message.offset = object.offset !== void 0 && object.offset !== null ? long_1.default.fromString(object.offset) : long_1.default.UZERO;
          message.limit = object.limit !== void 0 && object.limit !== null ? long_1.default.fromString(object.limit) : long_1.default.UZERO;
          message.countTotal = object.countTotal !== void 0 && object.countTotal !== null ? Boolean(object.countTotal) : false;
          message.reverse = object.reverse !== void 0 && object.reverse !== null ? Boolean(object.reverse) : false;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.key !== void 0 && (obj.key = base64FromBytes(message.key !== void 0 ? message.key : new Uint8Array()));
          message.offset !== void 0 && (obj.offset = (message.offset || long_1.default.UZERO).toString());
          message.limit !== void 0 && (obj.limit = (message.limit || long_1.default.UZERO).toString());
          message.countTotal !== void 0 && (obj.countTotal = message.countTotal);
          message.reverse !== void 0 && (obj.reverse = message.reverse);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, basePageRequest);
          message.key = (_a = object.key) !== null && _a !== void 0 ? _a : new Uint8Array();
          message.offset = object.offset !== void 0 && object.offset !== null ? long_1.default.fromValue(object.offset) : long_1.default.UZERO;
          message.limit = object.limit !== void 0 && object.limit !== null ? long_1.default.fromValue(object.limit) : long_1.default.UZERO;
          message.countTotal = (_b = object.countTotal) !== null && _b !== void 0 ? _b : false;
          message.reverse = (_c = object.reverse) !== null && _c !== void 0 ? _c : false;
          return message;
        }
      };
      var basePageResponse = { total: long_1.default.UZERO };
      exports2.PageResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.nextKey.length !== 0) {
            writer.uint32(10).bytes(message.nextKey);
          }
          if (!message.total.isZero()) {
            writer.uint32(16).uint64(message.total);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, basePageResponse);
          message.nextKey = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.nextKey = reader.bytes();
                break;
              case 2:
                message.total = reader.uint64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, basePageResponse);
          message.nextKey = object.nextKey !== void 0 && object.nextKey !== null ? bytesFromBase64(object.nextKey) : new Uint8Array();
          message.total = object.total !== void 0 && object.total !== null ? long_1.default.fromString(object.total) : long_1.default.UZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.nextKey !== void 0 && (obj.nextKey = base64FromBytes(message.nextKey !== void 0 ? message.nextKey : new Uint8Array()));
          message.total !== void 0 && (obj.total = (message.total || long_1.default.UZERO).toString());
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, basePageResponse);
          message.nextKey = (_a = object.nextKey) !== null && _a !== void 0 ? _a : new Uint8Array();
          message.total = object.total !== void 0 && object.total !== null ? long_1.default.fromValue(object.total) : long_1.default.UZERO;
          return message;
        }
      };
      var globalThis2 = (() => {
        if (typeof globalThis2 !== "undefined")
          return globalThis2;
        if (typeof self !== "undefined")
          return self;
        if (typeof window !== "undefined")
          return window;
        if (typeof global !== "undefined")
          return global;
        throw "Unable to locate global object";
      })();
      var atob2 = globalThis2.atob || ((b64) => globalThis2.Buffer.from(b64, "base64").toString("binary"));
      function bytesFromBase64(b64) {
        const bin = atob2(b64);
        const arr = new Uint8Array(bin.length);
        for (let i = 0; i < bin.length; ++i) {
          arr[i] = bin.charCodeAt(i);
        }
        return arr;
      }
      var btoa2 = globalThis2.btoa || ((bin) => globalThis2.Buffer.from(bin, "binary").toString("base64"));
      function base64FromBytes(arr) {
        const bin = [];
        for (const byte of arr) {
          bin.push(String.fromCharCode(byte));
        }
        return btoa2(bin.join(""));
      }
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/cosmjs-types/cosmos/auth/v1beta1/query.js
  var require_query = __commonJS({
    "node_modules/cosmjs-types/cosmos/auth/v1beta1/query.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.QueryClientImpl = exports2.QueryParamsResponse = exports2.QueryParamsRequest = exports2.QueryAccountResponse = exports2.QueryAccountRequest = exports2.QueryAccountsResponse = exports2.QueryAccountsRequest = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var pagination_1 = require_pagination();
      var any_1 = require_any();
      var auth_1 = require_auth();
      exports2.protobufPackage = "cosmos.auth.v1beta1";
      var baseQueryAccountsRequest = {};
      exports2.QueryAccountsRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.pagination !== void 0) {
            pagination_1.PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryAccountsRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.pagination = pagination_1.PageRequest.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryAccountsRequest);
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageRequest.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryAccountsRequest);
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryAccountsResponse = {};
      exports2.QueryAccountsResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.accounts) {
            any_1.Any.encode(v, writer.uint32(10).fork()).ldelim();
          }
          if (message.pagination !== void 0) {
            pagination_1.PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryAccountsResponse);
          message.accounts = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.accounts.push(any_1.Any.decode(reader, reader.uint32()));
                break;
              case 2:
                message.pagination = pagination_1.PageResponse.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseQueryAccountsResponse);
          message.accounts = ((_a = object.accounts) !== null && _a !== void 0 ? _a : []).map((e) => any_1.Any.fromJSON(e));
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.accounts) {
            obj.accounts = message.accounts.map((e) => e ? any_1.Any.toJSON(e) : void 0);
          } else {
            obj.accounts = [];
          }
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageResponse.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryAccountsResponse);
          message.accounts = ((_a = object.accounts) === null || _a === void 0 ? void 0 : _a.map((e) => any_1.Any.fromPartial(e))) || [];
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryAccountRequest = { address: "" };
      exports2.QueryAccountRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.address !== "") {
            writer.uint32(10).string(message.address);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryAccountRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.address = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryAccountRequest);
          message.address = object.address !== void 0 && object.address !== null ? String(object.address) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.address !== void 0 && (obj.address = message.address);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryAccountRequest);
          message.address = (_a = object.address) !== null && _a !== void 0 ? _a : "";
          return message;
        }
      };
      var baseQueryAccountResponse = {};
      exports2.QueryAccountResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.account !== void 0) {
            any_1.Any.encode(message.account, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryAccountResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.account = any_1.Any.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryAccountResponse);
          message.account = object.account !== void 0 && object.account !== null ? any_1.Any.fromJSON(object.account) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.account !== void 0 && (obj.account = message.account ? any_1.Any.toJSON(message.account) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryAccountResponse);
          message.account = object.account !== void 0 && object.account !== null ? any_1.Any.fromPartial(object.account) : void 0;
          return message;
        }
      };
      var baseQueryParamsRequest = {};
      exports2.QueryParamsRequest = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryParamsRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseQueryParamsRequest);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseQueryParamsRequest);
          return message;
        }
      };
      var baseQueryParamsResponse = {};
      exports2.QueryParamsResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.params !== void 0) {
            auth_1.Params.encode(message.params, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryParamsResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.params = auth_1.Params.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryParamsResponse);
          message.params = object.params !== void 0 && object.params !== null ? auth_1.Params.fromJSON(object.params) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.params !== void 0 && (obj.params = message.params ? auth_1.Params.toJSON(message.params) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryParamsResponse);
          message.params = object.params !== void 0 && object.params !== null ? auth_1.Params.fromPartial(object.params) : void 0;
          return message;
        }
      };
      var QueryClientImpl = class {
        constructor(rpc) {
          this.rpc = rpc;
          this.Accounts = this.Accounts.bind(this);
          this.Account = this.Account.bind(this);
          this.Params = this.Params.bind(this);
        }
        Accounts(request) {
          const data = exports2.QueryAccountsRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.auth.v1beta1.Query", "Accounts", data);
          return promise.then((data2) => exports2.QueryAccountsResponse.decode(new minimal_1.default.Reader(data2)));
        }
        Account(request) {
          const data = exports2.QueryAccountRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.auth.v1beta1.Query", "Account", data);
          return promise.then((data2) => exports2.QueryAccountResponse.decode(new minimal_1.default.Reader(data2)));
        }
        Params(request) {
          const data = exports2.QueryParamsRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.auth.v1beta1.Query", "Params", data);
          return promise.then((data2) => exports2.QueryParamsResponse.decode(new minimal_1.default.Reader(data2)));
        }
      };
      exports2.QueryClientImpl = QueryClientImpl;
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/protobufjs/src/util/longbits.js
  var require_longbits2 = __commonJS({
    "node_modules/protobufjs/src/util/longbits.js"(exports2, module2) {
      "use strict";
      module2.exports = LongBits;
      var util = require_minimal3();
      function LongBits(lo, hi) {
        this.lo = lo >>> 0;
        this.hi = hi >>> 0;
      }
      var zero = LongBits.zero = new LongBits(0, 0);
      zero.toNumber = function() {
        return 0;
      };
      zero.zzEncode = zero.zzDecode = function() {
        return this;
      };
      zero.length = function() {
        return 1;
      };
      var zeroHash = LongBits.zeroHash = "\0\0\0\0\0\0\0\0";
      LongBits.fromNumber = function fromNumber(value) {
        if (value === 0)
          return zero;
        var sign = value < 0;
        if (sign)
          value = -value;
        var lo = value >>> 0, hi = (value - lo) / 4294967296 >>> 0;
        if (sign) {
          hi = ~hi >>> 0;
          lo = ~lo >>> 0;
          if (++lo > 4294967295) {
            lo = 0;
            if (++hi > 4294967295)
              hi = 0;
          }
        }
        return new LongBits(lo, hi);
      };
      LongBits.from = function from(value) {
        if (typeof value === "number")
          return LongBits.fromNumber(value);
        if (util.isString(value)) {
          if (util.Long)
            value = util.Long.fromString(value);
          else
            return LongBits.fromNumber(parseInt(value, 10));
        }
        return value.low || value.high ? new LongBits(value.low >>> 0, value.high >>> 0) : zero;
      };
      LongBits.prototype.toNumber = function toNumber(unsigned) {
        if (!unsigned && this.hi >>> 31) {
          var lo = ~this.lo + 1 >>> 0, hi = ~this.hi >>> 0;
          if (!lo)
            hi = hi + 1 >>> 0;
          return -(lo + hi * 4294967296);
        }
        return this.lo + this.hi * 4294967296;
      };
      LongBits.prototype.toLong = function toLong(unsigned) {
        return util.Long ? new util.Long(this.lo | 0, this.hi | 0, Boolean(unsigned)) : { low: this.lo | 0, high: this.hi | 0, unsigned: Boolean(unsigned) };
      };
      var charCodeAt = String.prototype.charCodeAt;
      LongBits.fromHash = function fromHash(hash) {
        if (hash === zeroHash)
          return zero;
        return new LongBits((charCodeAt.call(hash, 0) | charCodeAt.call(hash, 1) << 8 | charCodeAt.call(hash, 2) << 16 | charCodeAt.call(hash, 3) << 24) >>> 0, (charCodeAt.call(hash, 4) | charCodeAt.call(hash, 5) << 8 | charCodeAt.call(hash, 6) << 16 | charCodeAt.call(hash, 7) << 24) >>> 0);
      };
      LongBits.prototype.toHash = function toHash() {
        return String.fromCharCode(this.lo & 255, this.lo >>> 8 & 255, this.lo >>> 16 & 255, this.lo >>> 24, this.hi & 255, this.hi >>> 8 & 255, this.hi >>> 16 & 255, this.hi >>> 24);
      };
      LongBits.prototype.zzEncode = function zzEncode() {
        var mask = this.hi >> 31;
        this.hi = ((this.hi << 1 | this.lo >>> 31) ^ mask) >>> 0;
        this.lo = (this.lo << 1 ^ mask) >>> 0;
        return this;
      };
      LongBits.prototype.zzDecode = function zzDecode() {
        var mask = -(this.lo & 1);
        this.lo = ((this.lo >>> 1 | this.hi << 31) ^ mask) >>> 0;
        this.hi = (this.hi >>> 1 ^ mask) >>> 0;
        return this;
      };
      LongBits.prototype.length = function length() {
        var part0 = this.lo, part1 = (this.lo >>> 28 | this.hi << 4) >>> 0, part2 = this.hi >>> 24;
        return part2 === 0 ? part1 === 0 ? part0 < 16384 ? part0 < 128 ? 1 : 2 : part0 < 2097152 ? 3 : 4 : part1 < 16384 ? part1 < 128 ? 5 : 6 : part1 < 2097152 ? 7 : 8 : part2 < 128 ? 9 : 10;
      };
    }
  });

  // node_modules/protobufjs/src/util/minimal.js
  var require_minimal3 = __commonJS({
    "node_modules/protobufjs/src/util/minimal.js"(exports2) {
      "use strict";
      var util = exports2;
      util.asPromise = require_aspromise();
      util.base64 = require_base64();
      util.EventEmitter = require_eventemitter();
      util.float = require_float();
      util.inquire = require_inquire();
      util.utf8 = require_utf8();
      util.pool = require_pool();
      util.LongBits = require_longbits2();
      util.isNode = Boolean(typeof global !== "undefined" && global && global.process && global.process.versions && global.process.versions.node);
      util.global = util.isNode && global || typeof window !== "undefined" && window || typeof self !== "undefined" && self || exports2;
      util.emptyArray = Object.freeze ? Object.freeze([]) : [];
      util.emptyObject = Object.freeze ? Object.freeze({}) : {};
      util.isInteger = Number.isInteger || function isInteger(value) {
        return typeof value === "number" && isFinite(value) && Math.floor(value) === value;
      };
      util.isString = function isString(value) {
        return typeof value === "string" || value instanceof String;
      };
      util.isObject = function isObject(value) {
        return value && typeof value === "object";
      };
      util.isset = util.isSet = function isSet(obj, prop) {
        var value = obj[prop];
        if (value != null && obj.hasOwnProperty(prop))
          return typeof value !== "object" || (Array.isArray(value) ? value.length : Object.keys(value).length) > 0;
        return false;
      };
      util.Buffer = function() {
        try {
          var Buffer2 = util.inquire("buffer").Buffer;
          return Buffer2.prototype.utf8Write ? Buffer2 : null;
        } catch (e) {
          return null;
        }
      }();
      util._Buffer_from = null;
      util._Buffer_allocUnsafe = null;
      util.newBuffer = function newBuffer(sizeOrArray) {
        return typeof sizeOrArray === "number" ? util.Buffer ? util._Buffer_allocUnsafe(sizeOrArray) : new util.Array(sizeOrArray) : util.Buffer ? util._Buffer_from(sizeOrArray) : typeof Uint8Array === "undefined" ? sizeOrArray : new Uint8Array(sizeOrArray);
      };
      util.Array = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
      util.Long = util.global.dcodeIO && util.global.dcodeIO.Long || util.global.Long || util.inquire("long");
      util.key2Re = /^true|false|0|1$/;
      util.key32Re = /^-?(?:0|[1-9][0-9]*)$/;
      util.key64Re = /^(?:[\\x00-\\xff]{8}|-?(?:0|[1-9][0-9]*))$/;
      util.longToHash = function longToHash(value) {
        return value ? util.LongBits.from(value).toHash() : util.LongBits.zeroHash;
      };
      util.longFromHash = function longFromHash(hash, unsigned) {
        var bits = util.LongBits.fromHash(hash);
        if (util.Long)
          return util.Long.fromBits(bits.lo, bits.hi, unsigned);
        return bits.toNumber(Boolean(unsigned));
      };
      function merge(dst, src, ifNotSet) {
        for (var keys = Object.keys(src), i = 0; i < keys.length; ++i)
          if (dst[keys[i]] === void 0 || !ifNotSet)
            dst[keys[i]] = src[keys[i]];
        return dst;
      }
      util.merge = merge;
      util.lcFirst = function lcFirst(str) {
        return str.charAt(0).toLowerCase() + str.substring(1);
      };
      function newError(name) {
        function CustomError(message, properties) {
          if (!(this instanceof CustomError))
            return new CustomError(message, properties);
          Object.defineProperty(this, "message", { get: function() {
            return message;
          } });
          if (Error.captureStackTrace)
            Error.captureStackTrace(this, CustomError);
          else
            Object.defineProperty(this, "stack", { value: new Error().stack || "" });
          if (properties)
            merge(this, properties);
        }
        (CustomError.prototype = Object.create(Error.prototype)).constructor = CustomError;
        Object.defineProperty(CustomError.prototype, "name", { get: function() {
          return name;
        } });
        CustomError.prototype.toString = function toString() {
          return this.name + ": " + this.message;
        };
        return CustomError;
      }
      util.newError = newError;
      util.ProtocolError = newError("ProtocolError");
      util.oneOfGetter = function getOneOf(fieldNames) {
        var fieldMap = {};
        for (var i = 0; i < fieldNames.length; ++i)
          fieldMap[fieldNames[i]] = 1;
        return function() {
          for (var keys = Object.keys(this), i2 = keys.length - 1; i2 > -1; --i2)
            if (fieldMap[keys[i2]] === 1 && this[keys[i2]] !== void 0 && this[keys[i2]] !== null)
              return keys[i2];
        };
      };
      util.oneOfSetter = function setOneOf(fieldNames) {
        return function(name) {
          for (var i = 0; i < fieldNames.length; ++i)
            if (fieldNames[i] !== name)
              delete this[fieldNames[i]];
        };
      };
      util.toJSONOptions = {
        longs: String,
        enums: String,
        bytes: String,
        json: true
      };
      util._configure = function() {
        var Buffer2 = util.Buffer;
        if (!Buffer2) {
          util._Buffer_from = util._Buffer_allocUnsafe = null;
          return;
        }
        util._Buffer_from = Buffer2.from !== Uint8Array.from && Buffer2.from || function Buffer_from(value, encoding) {
          return new Buffer2(value, encoding);
        };
        util._Buffer_allocUnsafe = Buffer2.allocUnsafe || function Buffer_allocUnsafe(size) {
          return new Buffer2(size);
        };
      };
    }
  });

  // node_modules/protobufjs/src/writer.js
  var require_writer2 = __commonJS({
    "node_modules/protobufjs/src/writer.js"(exports2, module2) {
      "use strict";
      module2.exports = Writer;
      var util = require_minimal3();
      var BufferWriter;
      var LongBits = util.LongBits;
      var base64 = util.base64;
      var utf8 = util.utf8;
      function Op(fn, len, val) {
        this.fn = fn;
        this.len = len;
        this.next = void 0;
        this.val = val;
      }
      function noop() {
      }
      function State(writer) {
        this.head = writer.head;
        this.tail = writer.tail;
        this.len = writer.len;
        this.next = writer.states;
      }
      function Writer() {
        this.len = 0;
        this.head = new Op(noop, 0, 0);
        this.tail = this.head;
        this.states = null;
      }
      var create = function create2() {
        return util.Buffer ? function create_buffer_setup() {
          return (Writer.create = function create_buffer() {
            return new BufferWriter();
          })();
        } : function create_array() {
          return new Writer();
        };
      };
      Writer.create = create();
      Writer.alloc = function alloc(size) {
        return new util.Array(size);
      };
      if (util.Array !== Array)
        Writer.alloc = util.pool(Writer.alloc, util.Array.prototype.subarray);
      Writer.prototype._push = function push(fn, len, val) {
        this.tail = this.tail.next = new Op(fn, len, val);
        this.len += len;
        return this;
      };
      function writeByte(val, buf, pos) {
        buf[pos] = val & 255;
      }
      function writeVarint32(val, buf, pos) {
        while (val > 127) {
          buf[pos++] = val & 127 | 128;
          val >>>= 7;
        }
        buf[pos] = val;
      }
      function VarintOp(len, val) {
        this.len = len;
        this.next = void 0;
        this.val = val;
      }
      VarintOp.prototype = Object.create(Op.prototype);
      VarintOp.prototype.fn = writeVarint32;
      Writer.prototype.uint32 = function write_uint32(value) {
        this.len += (this.tail = this.tail.next = new VarintOp((value = value >>> 0) < 128 ? 1 : value < 16384 ? 2 : value < 2097152 ? 3 : value < 268435456 ? 4 : 5, value)).len;
        return this;
      };
      Writer.prototype.int32 = function write_int32(value) {
        return value < 0 ? this._push(writeVarint64, 10, LongBits.fromNumber(value)) : this.uint32(value);
      };
      Writer.prototype.sint32 = function write_sint32(value) {
        return this.uint32((value << 1 ^ value >> 31) >>> 0);
      };
      function writeVarint64(val, buf, pos) {
        while (val.hi) {
          buf[pos++] = val.lo & 127 | 128;
          val.lo = (val.lo >>> 7 | val.hi << 25) >>> 0;
          val.hi >>>= 7;
        }
        while (val.lo > 127) {
          buf[pos++] = val.lo & 127 | 128;
          val.lo = val.lo >>> 7;
        }
        buf[pos++] = val.lo;
      }
      Writer.prototype.uint64 = function write_uint64(value) {
        var bits = LongBits.from(value);
        return this._push(writeVarint64, bits.length(), bits);
      };
      Writer.prototype.int64 = Writer.prototype.uint64;
      Writer.prototype.sint64 = function write_sint64(value) {
        var bits = LongBits.from(value).zzEncode();
        return this._push(writeVarint64, bits.length(), bits);
      };
      Writer.prototype.bool = function write_bool(value) {
        return this._push(writeByte, 1, value ? 1 : 0);
      };
      function writeFixed32(val, buf, pos) {
        buf[pos] = val & 255;
        buf[pos + 1] = val >>> 8 & 255;
        buf[pos + 2] = val >>> 16 & 255;
        buf[pos + 3] = val >>> 24;
      }
      Writer.prototype.fixed32 = function write_fixed32(value) {
        return this._push(writeFixed32, 4, value >>> 0);
      };
      Writer.prototype.sfixed32 = Writer.prototype.fixed32;
      Writer.prototype.fixed64 = function write_fixed64(value) {
        var bits = LongBits.from(value);
        return this._push(writeFixed32, 4, bits.lo)._push(writeFixed32, 4, bits.hi);
      };
      Writer.prototype.sfixed64 = Writer.prototype.fixed64;
      Writer.prototype.float = function write_float(value) {
        return this._push(util.float.writeFloatLE, 4, value);
      };
      Writer.prototype.double = function write_double(value) {
        return this._push(util.float.writeDoubleLE, 8, value);
      };
      var writeBytes = util.Array.prototype.set ? function writeBytes_set(val, buf, pos) {
        buf.set(val, pos);
      } : function writeBytes_for(val, buf, pos) {
        for (var i = 0; i < val.length; ++i)
          buf[pos + i] = val[i];
      };
      Writer.prototype.bytes = function write_bytes(value) {
        var len = value.length >>> 0;
        if (!len)
          return this._push(writeByte, 1, 0);
        if (util.isString(value)) {
          var buf = Writer.alloc(len = base64.length(value));
          base64.decode(value, buf, 0);
          value = buf;
        }
        return this.uint32(len)._push(writeBytes, len, value);
      };
      Writer.prototype.string = function write_string(value) {
        var len = utf8.length(value);
        return len ? this.uint32(len)._push(utf8.write, len, value) : this._push(writeByte, 1, 0);
      };
      Writer.prototype.fork = function fork() {
        this.states = new State(this);
        this.head = this.tail = new Op(noop, 0, 0);
        this.len = 0;
        return this;
      };
      Writer.prototype.reset = function reset() {
        if (this.states) {
          this.head = this.states.head;
          this.tail = this.states.tail;
          this.len = this.states.len;
          this.states = this.states.next;
        } else {
          this.head = this.tail = new Op(noop, 0, 0);
          this.len = 0;
        }
        return this;
      };
      Writer.prototype.ldelim = function ldelim() {
        var head = this.head, tail = this.tail, len = this.len;
        this.reset().uint32(len);
        if (len) {
          this.tail.next = head.next;
          this.tail = tail;
          this.len += len;
        }
        return this;
      };
      Writer.prototype.finish = function finish() {
        var head = this.head.next, buf = this.constructor.alloc(this.len), pos = 0;
        while (head) {
          head.fn(head.val, buf, pos);
          pos += head.len;
          head = head.next;
        }
        return buf;
      };
      Writer._configure = function(BufferWriter_) {
        BufferWriter = BufferWriter_;
        Writer.create = create();
        BufferWriter._configure();
      };
    }
  });

  // node_modules/protobufjs/src/writer_buffer.js
  var require_writer_buffer2 = __commonJS({
    "node_modules/protobufjs/src/writer_buffer.js"(exports2, module2) {
      "use strict";
      module2.exports = BufferWriter;
      var Writer = require_writer2();
      (BufferWriter.prototype = Object.create(Writer.prototype)).constructor = BufferWriter;
      var util = require_minimal3();
      function BufferWriter() {
        Writer.call(this);
      }
      BufferWriter._configure = function() {
        BufferWriter.alloc = util._Buffer_allocUnsafe;
        BufferWriter.writeBytesBuffer = util.Buffer && util.Buffer.prototype instanceof Uint8Array && util.Buffer.prototype.set.name === "set" ? function writeBytesBuffer_set(val, buf, pos) {
          buf.set(val, pos);
        } : function writeBytesBuffer_copy(val, buf, pos) {
          if (val.copy)
            val.copy(buf, pos, 0, val.length);
          else
            for (var i = 0; i < val.length; )
              buf[pos++] = val[i++];
        };
      };
      BufferWriter.prototype.bytes = function write_bytes_buffer(value) {
        if (util.isString(value))
          value = util._Buffer_from(value, "base64");
        var len = value.length >>> 0;
        this.uint32(len);
        if (len)
          this._push(BufferWriter.writeBytesBuffer, len, value);
        return this;
      };
      function writeStringBuffer(val, buf, pos) {
        if (val.length < 40)
          util.utf8.write(val, buf, pos);
        else if (buf.utf8Write)
          buf.utf8Write(val, pos);
        else
          buf.write(val, pos);
      }
      BufferWriter.prototype.string = function write_string_buffer(value) {
        var len = util.Buffer.byteLength(value);
        this.uint32(len);
        if (len)
          this._push(writeStringBuffer, len, value);
        return this;
      };
      BufferWriter._configure();
    }
  });

  // node_modules/protobufjs/src/reader.js
  var require_reader2 = __commonJS({
    "node_modules/protobufjs/src/reader.js"(exports2, module2) {
      "use strict";
      module2.exports = Reader;
      var util = require_minimal3();
      var BufferReader;
      var LongBits = util.LongBits;
      var utf8 = util.utf8;
      function indexOutOfRange(reader, writeLength) {
        return RangeError("index out of range: " + reader.pos + " + " + (writeLength || 1) + " > " + reader.len);
      }
      function Reader(buffer) {
        this.buf = buffer;
        this.pos = 0;
        this.len = buffer.length;
      }
      var create_array = typeof Uint8Array !== "undefined" ? function create_typed_array(buffer) {
        if (buffer instanceof Uint8Array || Array.isArray(buffer))
          return new Reader(buffer);
        throw Error("illegal buffer");
      } : function create_array2(buffer) {
        if (Array.isArray(buffer))
          return new Reader(buffer);
        throw Error("illegal buffer");
      };
      var create = function create2() {
        return util.Buffer ? function create_buffer_setup(buffer) {
          return (Reader.create = function create_buffer(buffer2) {
            return util.Buffer.isBuffer(buffer2) ? new BufferReader(buffer2) : create_array(buffer2);
          })(buffer);
        } : create_array;
      };
      Reader.create = create();
      Reader.prototype._slice = util.Array.prototype.subarray || util.Array.prototype.slice;
      Reader.prototype.uint32 = function read_uint32_setup() {
        var value = 4294967295;
        return function read_uint32() {
          value = (this.buf[this.pos] & 127) >>> 0;
          if (this.buf[this.pos++] < 128)
            return value;
          value = (value | (this.buf[this.pos] & 127) << 7) >>> 0;
          if (this.buf[this.pos++] < 128)
            return value;
          value = (value | (this.buf[this.pos] & 127) << 14) >>> 0;
          if (this.buf[this.pos++] < 128)
            return value;
          value = (value | (this.buf[this.pos] & 127) << 21) >>> 0;
          if (this.buf[this.pos++] < 128)
            return value;
          value = (value | (this.buf[this.pos] & 15) << 28) >>> 0;
          if (this.buf[this.pos++] < 128)
            return value;
          if ((this.pos += 5) > this.len) {
            this.pos = this.len;
            throw indexOutOfRange(this, 10);
          }
          return value;
        };
      }();
      Reader.prototype.int32 = function read_int32() {
        return this.uint32() | 0;
      };
      Reader.prototype.sint32 = function read_sint32() {
        var value = this.uint32();
        return value >>> 1 ^ -(value & 1) | 0;
      };
      function readLongVarint() {
        var bits = new LongBits(0, 0);
        var i = 0;
        if (this.len - this.pos > 4) {
          for (; i < 4; ++i) {
            bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
            if (this.buf[this.pos++] < 128)
              return bits;
          }
          bits.lo = (bits.lo | (this.buf[this.pos] & 127) << 28) >>> 0;
          bits.hi = (bits.hi | (this.buf[this.pos] & 127) >> 4) >>> 0;
          if (this.buf[this.pos++] < 128)
            return bits;
          i = 0;
        } else {
          for (; i < 3; ++i) {
            if (this.pos >= this.len)
              throw indexOutOfRange(this);
            bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
            if (this.buf[this.pos++] < 128)
              return bits;
          }
          bits.lo = (bits.lo | (this.buf[this.pos++] & 127) << i * 7) >>> 0;
          return bits;
        }
        if (this.len - this.pos > 4) {
          for (; i < 5; ++i) {
            bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;
            if (this.buf[this.pos++] < 128)
              return bits;
          }
        } else {
          for (; i < 5; ++i) {
            if (this.pos >= this.len)
              throw indexOutOfRange(this);
            bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;
            if (this.buf[this.pos++] < 128)
              return bits;
          }
        }
        throw Error("invalid varint encoding");
      }
      Reader.prototype.bool = function read_bool() {
        return this.uint32() !== 0;
      };
      function readFixed32_end(buf, end) {
        return (buf[end - 4] | buf[end - 3] << 8 | buf[end - 2] << 16 | buf[end - 1] << 24) >>> 0;
      }
      Reader.prototype.fixed32 = function read_fixed32() {
        if (this.pos + 4 > this.len)
          throw indexOutOfRange(this, 4);
        return readFixed32_end(this.buf, this.pos += 4);
      };
      Reader.prototype.sfixed32 = function read_sfixed32() {
        if (this.pos + 4 > this.len)
          throw indexOutOfRange(this, 4);
        return readFixed32_end(this.buf, this.pos += 4) | 0;
      };
      function readFixed64() {
        if (this.pos + 8 > this.len)
          throw indexOutOfRange(this, 8);
        return new LongBits(readFixed32_end(this.buf, this.pos += 4), readFixed32_end(this.buf, this.pos += 4));
      }
      Reader.prototype.float = function read_float() {
        if (this.pos + 4 > this.len)
          throw indexOutOfRange(this, 4);
        var value = util.float.readFloatLE(this.buf, this.pos);
        this.pos += 4;
        return value;
      };
      Reader.prototype.double = function read_double() {
        if (this.pos + 8 > this.len)
          throw indexOutOfRange(this, 4);
        var value = util.float.readDoubleLE(this.buf, this.pos);
        this.pos += 8;
        return value;
      };
      Reader.prototype.bytes = function read_bytes() {
        var length = this.uint32(), start2 = this.pos, end = this.pos + length;
        if (end > this.len)
          throw indexOutOfRange(this, length);
        this.pos += length;
        if (Array.isArray(this.buf))
          return this.buf.slice(start2, end);
        return start2 === end ? new this.buf.constructor(0) : this._slice.call(this.buf, start2, end);
      };
      Reader.prototype.string = function read_string() {
        var bytes = this.bytes();
        return utf8.read(bytes, 0, bytes.length);
      };
      Reader.prototype.skip = function skip(length) {
        if (typeof length === "number") {
          if (this.pos + length > this.len)
            throw indexOutOfRange(this, length);
          this.pos += length;
        } else {
          do {
            if (this.pos >= this.len)
              throw indexOutOfRange(this);
          } while (this.buf[this.pos++] & 128);
        }
        return this;
      };
      Reader.prototype.skipType = function(wireType) {
        switch (wireType) {
          case 0:
            this.skip();
            break;
          case 1:
            this.skip(8);
            break;
          case 2:
            this.skip(this.uint32());
            break;
          case 3:
            while ((wireType = this.uint32() & 7) !== 4) {
              this.skipType(wireType);
            }
            break;
          case 5:
            this.skip(4);
            break;
          default:
            throw Error("invalid wire type " + wireType + " at offset " + this.pos);
        }
        return this;
      };
      Reader._configure = function(BufferReader_) {
        BufferReader = BufferReader_;
        Reader.create = create();
        BufferReader._configure();
        var fn = util.Long ? "toLong" : "toNumber";
        util.merge(Reader.prototype, {
          int64: function read_int64() {
            return readLongVarint.call(this)[fn](false);
          },
          uint64: function read_uint64() {
            return readLongVarint.call(this)[fn](true);
          },
          sint64: function read_sint64() {
            return readLongVarint.call(this).zzDecode()[fn](false);
          },
          fixed64: function read_fixed64() {
            return readFixed64.call(this)[fn](true);
          },
          sfixed64: function read_sfixed64() {
            return readFixed64.call(this)[fn](false);
          }
        });
      };
    }
  });

  // node_modules/protobufjs/src/reader_buffer.js
  var require_reader_buffer2 = __commonJS({
    "node_modules/protobufjs/src/reader_buffer.js"(exports2, module2) {
      "use strict";
      module2.exports = BufferReader;
      var Reader = require_reader2();
      (BufferReader.prototype = Object.create(Reader.prototype)).constructor = BufferReader;
      var util = require_minimal3();
      function BufferReader(buffer) {
        Reader.call(this, buffer);
      }
      BufferReader._configure = function() {
        if (util.Buffer)
          BufferReader.prototype._slice = util.Buffer.prototype.slice;
      };
      BufferReader.prototype.string = function read_string_buffer() {
        var len = this.uint32();
        return this.buf.utf8Slice ? this.buf.utf8Slice(this.pos, this.pos = Math.min(this.pos + len, this.len)) : this.buf.toString("utf-8", this.pos, this.pos = Math.min(this.pos + len, this.len));
      };
      BufferReader._configure();
    }
  });

  // node_modules/protobufjs/src/rpc/service.js
  var require_service2 = __commonJS({
    "node_modules/protobufjs/src/rpc/service.js"(exports2, module2) {
      "use strict";
      module2.exports = Service;
      var util = require_minimal3();
      (Service.prototype = Object.create(util.EventEmitter.prototype)).constructor = Service;
      function Service(rpcImpl, requestDelimited, responseDelimited) {
        if (typeof rpcImpl !== "function")
          throw TypeError("rpcImpl must be a function");
        util.EventEmitter.call(this);
        this.rpcImpl = rpcImpl;
        this.requestDelimited = Boolean(requestDelimited);
        this.responseDelimited = Boolean(responseDelimited);
      }
      Service.prototype.rpcCall = function rpcCall(method, requestCtor, responseCtor, request, callback) {
        if (!request)
          throw TypeError("request must be specified");
        var self2 = this;
        if (!callback)
          return util.asPromise(rpcCall, self2, method, requestCtor, responseCtor, request);
        if (!self2.rpcImpl) {
          setTimeout(function() {
            callback(Error("already ended"));
          }, 0);
          return void 0;
        }
        try {
          return self2.rpcImpl(method, requestCtor[self2.requestDelimited ? "encodeDelimited" : "encode"](request).finish(), function rpcCallback(err, response) {
            if (err) {
              self2.emit("error", err, method);
              return callback(err);
            }
            if (response === null) {
              self2.end(true);
              return void 0;
            }
            if (!(response instanceof responseCtor)) {
              try {
                response = responseCtor[self2.responseDelimited ? "decodeDelimited" : "decode"](response);
              } catch (err2) {
                self2.emit("error", err2, method);
                return callback(err2);
              }
            }
            self2.emit("data", response, method);
            return callback(null, response);
          });
        } catch (err) {
          self2.emit("error", err, method);
          setTimeout(function() {
            callback(err);
          }, 0);
          return void 0;
        }
      };
      Service.prototype.end = function end(endedByRPC) {
        if (this.rpcImpl) {
          if (!endedByRPC)
            this.rpcImpl(null, null, null);
          this.rpcImpl = null;
          this.emit("end").off();
        }
        return this;
      };
    }
  });

  // node_modules/protobufjs/src/rpc.js
  var require_rpc2 = __commonJS({
    "node_modules/protobufjs/src/rpc.js"(exports2) {
      "use strict";
      var rpc = exports2;
      rpc.Service = require_service2();
    }
  });

  // node_modules/protobufjs/src/roots.js
  var require_roots2 = __commonJS({
    "node_modules/protobufjs/src/roots.js"(exports2, module2) {
      "use strict";
      module2.exports = {};
    }
  });

  // node_modules/protobufjs/src/index-minimal.js
  var require_index_minimal2 = __commonJS({
    "node_modules/protobufjs/src/index-minimal.js"(exports2) {
      "use strict";
      var protobuf = exports2;
      protobuf.build = "minimal";
      protobuf.Writer = require_writer2();
      protobuf.BufferWriter = require_writer_buffer2();
      protobuf.Reader = require_reader2();
      protobuf.BufferReader = require_reader_buffer2();
      protobuf.util = require_minimal3();
      protobuf.rpc = require_rpc2();
      protobuf.roots = require_roots2();
      protobuf.configure = configure;
      function configure() {
        protobuf.util._configure();
        protobuf.Writer._configure(protobuf.BufferWriter);
        protobuf.Reader._configure(protobuf.BufferReader);
      }
      configure();
    }
  });

  // node_modules/protobufjs/minimal.js
  var require_minimal4 = __commonJS({
    "node_modules/protobufjs/minimal.js"(exports2, module2) {
      "use strict";
      module2.exports = require_index_minimal2();
    }
  });

  // node_modules/@confio/ics23/build/generated/codecimpl.js
  var require_codecimpl = __commonJS({
    "node_modules/@confio/ics23/build/generated/codecimpl.js"(exports2, module2) {
      "use strict";
      var $protobuf = require_minimal4();
      var $Reader = $protobuf.Reader;
      var $Writer = $protobuf.Writer;
      var $util = $protobuf.util;
      var $root = $protobuf.roots["default"] || ($protobuf.roots["default"] = {});
      $root.ics23 = function() {
        var ics23 = {};
        ics23.HashOp = function() {
          var valuesById = {}, values = Object.create(valuesById);
          values[valuesById[0] = "NO_HASH"] = 0;
          values[valuesById[1] = "SHA256"] = 1;
          values[valuesById[2] = "SHA512"] = 2;
          values[valuesById[3] = "KECCAK"] = 3;
          values[valuesById[4] = "RIPEMD160"] = 4;
          values[valuesById[5] = "BITCOIN"] = 5;
          values[valuesById[6] = "SHA512_256"] = 6;
          return values;
        }();
        ics23.LengthOp = function() {
          var valuesById = {}, values = Object.create(valuesById);
          values[valuesById[0] = "NO_PREFIX"] = 0;
          values[valuesById[1] = "VAR_PROTO"] = 1;
          values[valuesById[2] = "VAR_RLP"] = 2;
          values[valuesById[3] = "FIXED32_BIG"] = 3;
          values[valuesById[4] = "FIXED32_LITTLE"] = 4;
          values[valuesById[5] = "FIXED64_BIG"] = 5;
          values[valuesById[6] = "FIXED64_LITTLE"] = 6;
          values[valuesById[7] = "REQUIRE_32_BYTES"] = 7;
          values[valuesById[8] = "REQUIRE_64_BYTES"] = 8;
          return values;
        }();
        ics23.ExistenceProof = function() {
          function ExistenceProof(properties) {
            this.path = [];
            if (properties) {
              for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                  this[keys[i]] = properties[keys[i]];
            }
          }
          ExistenceProof.prototype.key = $util.newBuffer([]);
          ExistenceProof.prototype.value = $util.newBuffer([]);
          ExistenceProof.prototype.leaf = null;
          ExistenceProof.prototype.path = $util.emptyArray;
          ExistenceProof.create = function create(properties) {
            return new ExistenceProof(properties);
          };
          ExistenceProof.encode = function encode(message, writer) {
            if (!writer)
              writer = $Writer.create();
            if (message.key != null && message.hasOwnProperty("key"))
              writer.uint32(10).bytes(message.key);
            if (message.value != null && message.hasOwnProperty("value"))
              writer.uint32(18).bytes(message.value);
            if (message.leaf != null && message.hasOwnProperty("leaf"))
              $root.ics23.LeafOp.encode(message.leaf, writer.uint32(26).fork()).ldelim();
            if (message.path != null && message.path.length)
              for (var i = 0; i < message.path.length; ++i)
                $root.ics23.InnerOp.encode(message.path[i], writer.uint32(34).fork()).ldelim();
            return writer;
          };
          ExistenceProof.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
          };
          ExistenceProof.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
              reader = $Reader.create(reader);
            var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.ics23.ExistenceProof();
            while (reader.pos < end) {
              var tag = reader.uint32();
              switch (tag >>> 3) {
                case 1:
                  message.key = reader.bytes();
                  break;
                case 2:
                  message.value = reader.bytes();
                  break;
                case 3:
                  message.leaf = $root.ics23.LeafOp.decode(reader, reader.uint32());
                  break;
                case 4:
                  if (!(message.path && message.path.length))
                    message.path = [];
                  message.path.push($root.ics23.InnerOp.decode(reader, reader.uint32()));
                  break;
                default:
                  reader.skipType(tag & 7);
                  break;
              }
            }
            return message;
          };
          ExistenceProof.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
              reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
          };
          ExistenceProof.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
              return "object expected";
            if (message.key != null && message.hasOwnProperty("key")) {
              if (!(message.key && typeof message.key.length === "number" || $util.isString(message.key)))
                return "key: buffer expected";
            }
            if (message.value != null && message.hasOwnProperty("value")) {
              if (!(message.value && typeof message.value.length === "number" || $util.isString(message.value)))
                return "value: buffer expected";
            }
            if (message.leaf != null && message.hasOwnProperty("leaf")) {
              var error = $root.ics23.LeafOp.verify(message.leaf);
              if (error)
                return "leaf." + error;
            }
            if (message.path != null && message.hasOwnProperty("path")) {
              if (!Array.isArray(message.path))
                return "path: array expected";
              for (var i = 0; i < message.path.length; ++i) {
                var error = $root.ics23.InnerOp.verify(message.path[i]);
                if (error)
                  return "path." + error;
              }
            }
            return null;
          };
          ExistenceProof.fromObject = function fromObject(object) {
            if (object instanceof $root.ics23.ExistenceProof)
              return object;
            var message = new $root.ics23.ExistenceProof();
            if (object.key != null) {
              if (typeof object.key === "string")
                $util.base64.decode(object.key, message.key = $util.newBuffer($util.base64.length(object.key)), 0);
              else if (object.key.length)
                message.key = object.key;
            }
            if (object.value != null) {
              if (typeof object.value === "string")
                $util.base64.decode(object.value, message.value = $util.newBuffer($util.base64.length(object.value)), 0);
              else if (object.value.length)
                message.value = object.value;
            }
            if (object.leaf != null) {
              if (typeof object.leaf !== "object")
                throw TypeError(".ics23.ExistenceProof.leaf: object expected");
              message.leaf = $root.ics23.LeafOp.fromObject(object.leaf);
            }
            if (object.path) {
              if (!Array.isArray(object.path))
                throw TypeError(".ics23.ExistenceProof.path: array expected");
              message.path = [];
              for (var i = 0; i < object.path.length; ++i) {
                if (typeof object.path[i] !== "object")
                  throw TypeError(".ics23.ExistenceProof.path: object expected");
                message.path[i] = $root.ics23.InnerOp.fromObject(object.path[i]);
              }
            }
            return message;
          };
          ExistenceProof.toObject = function toObject(message, options) {
            if (!options)
              options = {};
            var object = {};
            if (options.arrays || options.defaults)
              object.path = [];
            if (options.defaults) {
              if (options.bytes === String)
                object.key = "";
              else {
                object.key = [];
                if (options.bytes !== Array)
                  object.key = $util.newBuffer(object.key);
              }
              if (options.bytes === String)
                object.value = "";
              else {
                object.value = [];
                if (options.bytes !== Array)
                  object.value = $util.newBuffer(object.value);
              }
              object.leaf = null;
            }
            if (message.key != null && message.hasOwnProperty("key"))
              object.key = options.bytes === String ? $util.base64.encode(message.key, 0, message.key.length) : options.bytes === Array ? Array.prototype.slice.call(message.key) : message.key;
            if (message.value != null && message.hasOwnProperty("value"))
              object.value = options.bytes === String ? $util.base64.encode(message.value, 0, message.value.length) : options.bytes === Array ? Array.prototype.slice.call(message.value) : message.value;
            if (message.leaf != null && message.hasOwnProperty("leaf"))
              object.leaf = $root.ics23.LeafOp.toObject(message.leaf, options);
            if (message.path && message.path.length) {
              object.path = [];
              for (var j = 0; j < message.path.length; ++j)
                object.path[j] = $root.ics23.InnerOp.toObject(message.path[j], options);
            }
            return object;
          };
          ExistenceProof.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
          };
          return ExistenceProof;
        }();
        ics23.NonExistenceProof = function() {
          function NonExistenceProof(properties) {
            if (properties) {
              for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                  this[keys[i]] = properties[keys[i]];
            }
          }
          NonExistenceProof.prototype.key = $util.newBuffer([]);
          NonExistenceProof.prototype.left = null;
          NonExistenceProof.prototype.right = null;
          NonExistenceProof.create = function create(properties) {
            return new NonExistenceProof(properties);
          };
          NonExistenceProof.encode = function encode(message, writer) {
            if (!writer)
              writer = $Writer.create();
            if (message.key != null && message.hasOwnProperty("key"))
              writer.uint32(10).bytes(message.key);
            if (message.left != null && message.hasOwnProperty("left"))
              $root.ics23.ExistenceProof.encode(message.left, writer.uint32(18).fork()).ldelim();
            if (message.right != null && message.hasOwnProperty("right"))
              $root.ics23.ExistenceProof.encode(message.right, writer.uint32(26).fork()).ldelim();
            return writer;
          };
          NonExistenceProof.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
          };
          NonExistenceProof.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
              reader = $Reader.create(reader);
            var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.ics23.NonExistenceProof();
            while (reader.pos < end) {
              var tag = reader.uint32();
              switch (tag >>> 3) {
                case 1:
                  message.key = reader.bytes();
                  break;
                case 2:
                  message.left = $root.ics23.ExistenceProof.decode(reader, reader.uint32());
                  break;
                case 3:
                  message.right = $root.ics23.ExistenceProof.decode(reader, reader.uint32());
                  break;
                default:
                  reader.skipType(tag & 7);
                  break;
              }
            }
            return message;
          };
          NonExistenceProof.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
              reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
          };
          NonExistenceProof.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
              return "object expected";
            if (message.key != null && message.hasOwnProperty("key")) {
              if (!(message.key && typeof message.key.length === "number" || $util.isString(message.key)))
                return "key: buffer expected";
            }
            if (message.left != null && message.hasOwnProperty("left")) {
              var error = $root.ics23.ExistenceProof.verify(message.left);
              if (error)
                return "left." + error;
            }
            if (message.right != null && message.hasOwnProperty("right")) {
              var error = $root.ics23.ExistenceProof.verify(message.right);
              if (error)
                return "right." + error;
            }
            return null;
          };
          NonExistenceProof.fromObject = function fromObject(object) {
            if (object instanceof $root.ics23.NonExistenceProof)
              return object;
            var message = new $root.ics23.NonExistenceProof();
            if (object.key != null) {
              if (typeof object.key === "string")
                $util.base64.decode(object.key, message.key = $util.newBuffer($util.base64.length(object.key)), 0);
              else if (object.key.length)
                message.key = object.key;
            }
            if (object.left != null) {
              if (typeof object.left !== "object")
                throw TypeError(".ics23.NonExistenceProof.left: object expected");
              message.left = $root.ics23.ExistenceProof.fromObject(object.left);
            }
            if (object.right != null) {
              if (typeof object.right !== "object")
                throw TypeError(".ics23.NonExistenceProof.right: object expected");
              message.right = $root.ics23.ExistenceProof.fromObject(object.right);
            }
            return message;
          };
          NonExistenceProof.toObject = function toObject(message, options) {
            if (!options)
              options = {};
            var object = {};
            if (options.defaults) {
              if (options.bytes === String)
                object.key = "";
              else {
                object.key = [];
                if (options.bytes !== Array)
                  object.key = $util.newBuffer(object.key);
              }
              object.left = null;
              object.right = null;
            }
            if (message.key != null && message.hasOwnProperty("key"))
              object.key = options.bytes === String ? $util.base64.encode(message.key, 0, message.key.length) : options.bytes === Array ? Array.prototype.slice.call(message.key) : message.key;
            if (message.left != null && message.hasOwnProperty("left"))
              object.left = $root.ics23.ExistenceProof.toObject(message.left, options);
            if (message.right != null && message.hasOwnProperty("right"))
              object.right = $root.ics23.ExistenceProof.toObject(message.right, options);
            return object;
          };
          NonExistenceProof.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
          };
          return NonExistenceProof;
        }();
        ics23.CommitmentProof = function() {
          function CommitmentProof(properties) {
            if (properties) {
              for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                  this[keys[i]] = properties[keys[i]];
            }
          }
          CommitmentProof.prototype.exist = null;
          CommitmentProof.prototype.nonexist = null;
          CommitmentProof.prototype.batch = null;
          CommitmentProof.prototype.compressed = null;
          var $oneOfFields;
          Object.defineProperty(CommitmentProof.prototype, "proof", {
            get: $util.oneOfGetter($oneOfFields = ["exist", "nonexist", "batch", "compressed"]),
            set: $util.oneOfSetter($oneOfFields)
          });
          CommitmentProof.create = function create(properties) {
            return new CommitmentProof(properties);
          };
          CommitmentProof.encode = function encode(message, writer) {
            if (!writer)
              writer = $Writer.create();
            if (message.exist != null && message.hasOwnProperty("exist"))
              $root.ics23.ExistenceProof.encode(message.exist, writer.uint32(10).fork()).ldelim();
            if (message.nonexist != null && message.hasOwnProperty("nonexist"))
              $root.ics23.NonExistenceProof.encode(message.nonexist, writer.uint32(18).fork()).ldelim();
            if (message.batch != null && message.hasOwnProperty("batch"))
              $root.ics23.BatchProof.encode(message.batch, writer.uint32(26).fork()).ldelim();
            if (message.compressed != null && message.hasOwnProperty("compressed"))
              $root.ics23.CompressedBatchProof.encode(message.compressed, writer.uint32(34).fork()).ldelim();
            return writer;
          };
          CommitmentProof.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
          };
          CommitmentProof.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
              reader = $Reader.create(reader);
            var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.ics23.CommitmentProof();
            while (reader.pos < end) {
              var tag = reader.uint32();
              switch (tag >>> 3) {
                case 1:
                  message.exist = $root.ics23.ExistenceProof.decode(reader, reader.uint32());
                  break;
                case 2:
                  message.nonexist = $root.ics23.NonExistenceProof.decode(reader, reader.uint32());
                  break;
                case 3:
                  message.batch = $root.ics23.BatchProof.decode(reader, reader.uint32());
                  break;
                case 4:
                  message.compressed = $root.ics23.CompressedBatchProof.decode(reader, reader.uint32());
                  break;
                default:
                  reader.skipType(tag & 7);
                  break;
              }
            }
            return message;
          };
          CommitmentProof.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
              reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
          };
          CommitmentProof.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
              return "object expected";
            var properties = {};
            if (message.exist != null && message.hasOwnProperty("exist")) {
              properties.proof = 1;
              {
                var error = $root.ics23.ExistenceProof.verify(message.exist);
                if (error)
                  return "exist." + error;
              }
            }
            if (message.nonexist != null && message.hasOwnProperty("nonexist")) {
              if (properties.proof === 1)
                return "proof: multiple values";
              properties.proof = 1;
              {
                var error = $root.ics23.NonExistenceProof.verify(message.nonexist);
                if (error)
                  return "nonexist." + error;
              }
            }
            if (message.batch != null && message.hasOwnProperty("batch")) {
              if (properties.proof === 1)
                return "proof: multiple values";
              properties.proof = 1;
              {
                var error = $root.ics23.BatchProof.verify(message.batch);
                if (error)
                  return "batch." + error;
              }
            }
            if (message.compressed != null && message.hasOwnProperty("compressed")) {
              if (properties.proof === 1)
                return "proof: multiple values";
              properties.proof = 1;
              {
                var error = $root.ics23.CompressedBatchProof.verify(message.compressed);
                if (error)
                  return "compressed." + error;
              }
            }
            return null;
          };
          CommitmentProof.fromObject = function fromObject(object) {
            if (object instanceof $root.ics23.CommitmentProof)
              return object;
            var message = new $root.ics23.CommitmentProof();
            if (object.exist != null) {
              if (typeof object.exist !== "object")
                throw TypeError(".ics23.CommitmentProof.exist: object expected");
              message.exist = $root.ics23.ExistenceProof.fromObject(object.exist);
            }
            if (object.nonexist != null) {
              if (typeof object.nonexist !== "object")
                throw TypeError(".ics23.CommitmentProof.nonexist: object expected");
              message.nonexist = $root.ics23.NonExistenceProof.fromObject(object.nonexist);
            }
            if (object.batch != null) {
              if (typeof object.batch !== "object")
                throw TypeError(".ics23.CommitmentProof.batch: object expected");
              message.batch = $root.ics23.BatchProof.fromObject(object.batch);
            }
            if (object.compressed != null) {
              if (typeof object.compressed !== "object")
                throw TypeError(".ics23.CommitmentProof.compressed: object expected");
              message.compressed = $root.ics23.CompressedBatchProof.fromObject(object.compressed);
            }
            return message;
          };
          CommitmentProof.toObject = function toObject(message, options) {
            if (!options)
              options = {};
            var object = {};
            if (message.exist != null && message.hasOwnProperty("exist")) {
              object.exist = $root.ics23.ExistenceProof.toObject(message.exist, options);
              if (options.oneofs)
                object.proof = "exist";
            }
            if (message.nonexist != null && message.hasOwnProperty("nonexist")) {
              object.nonexist = $root.ics23.NonExistenceProof.toObject(message.nonexist, options);
              if (options.oneofs)
                object.proof = "nonexist";
            }
            if (message.batch != null && message.hasOwnProperty("batch")) {
              object.batch = $root.ics23.BatchProof.toObject(message.batch, options);
              if (options.oneofs)
                object.proof = "batch";
            }
            if (message.compressed != null && message.hasOwnProperty("compressed")) {
              object.compressed = $root.ics23.CompressedBatchProof.toObject(message.compressed, options);
              if (options.oneofs)
                object.proof = "compressed";
            }
            return object;
          };
          CommitmentProof.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
          };
          return CommitmentProof;
        }();
        ics23.LeafOp = function() {
          function LeafOp(properties) {
            if (properties) {
              for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                  this[keys[i]] = properties[keys[i]];
            }
          }
          LeafOp.prototype.hash = 0;
          LeafOp.prototype.prehashKey = 0;
          LeafOp.prototype.prehashValue = 0;
          LeafOp.prototype.length = 0;
          LeafOp.prototype.prefix = $util.newBuffer([]);
          LeafOp.create = function create(properties) {
            return new LeafOp(properties);
          };
          LeafOp.encode = function encode(message, writer) {
            if (!writer)
              writer = $Writer.create();
            if (message.hash != null && message.hasOwnProperty("hash"))
              writer.uint32(8).int32(message.hash);
            if (message.prehashKey != null && message.hasOwnProperty("prehashKey"))
              writer.uint32(16).int32(message.prehashKey);
            if (message.prehashValue != null && message.hasOwnProperty("prehashValue"))
              writer.uint32(24).int32(message.prehashValue);
            if (message.length != null && message.hasOwnProperty("length"))
              writer.uint32(32).int32(message.length);
            if (message.prefix != null && message.hasOwnProperty("prefix"))
              writer.uint32(42).bytes(message.prefix);
            return writer;
          };
          LeafOp.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
          };
          LeafOp.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
              reader = $Reader.create(reader);
            var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.ics23.LeafOp();
            while (reader.pos < end) {
              var tag = reader.uint32();
              switch (tag >>> 3) {
                case 1:
                  message.hash = reader.int32();
                  break;
                case 2:
                  message.prehashKey = reader.int32();
                  break;
                case 3:
                  message.prehashValue = reader.int32();
                  break;
                case 4:
                  message.length = reader.int32();
                  break;
                case 5:
                  message.prefix = reader.bytes();
                  break;
                default:
                  reader.skipType(tag & 7);
                  break;
              }
            }
            return message;
          };
          LeafOp.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
              reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
          };
          LeafOp.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
              return "object expected";
            if (message.hash != null && message.hasOwnProperty("hash"))
              switch (message.hash) {
                default:
                  return "hash: enum value expected";
                case 0:
                case 1:
                case 2:
                case 3:
                case 4:
                case 5:
                case 6:
                  break;
              }
            if (message.prehashKey != null && message.hasOwnProperty("prehashKey"))
              switch (message.prehashKey) {
                default:
                  return "prehashKey: enum value expected";
                case 0:
                case 1:
                case 2:
                case 3:
                case 4:
                case 5:
                case 6:
                  break;
              }
            if (message.prehashValue != null && message.hasOwnProperty("prehashValue"))
              switch (message.prehashValue) {
                default:
                  return "prehashValue: enum value expected";
                case 0:
                case 1:
                case 2:
                case 3:
                case 4:
                case 5:
                case 6:
                  break;
              }
            if (message.length != null && message.hasOwnProperty("length"))
              switch (message.length) {
                default:
                  return "length: enum value expected";
                case 0:
                case 1:
                case 2:
                case 3:
                case 4:
                case 5:
                case 6:
                case 7:
                case 8:
                  break;
              }
            if (message.prefix != null && message.hasOwnProperty("prefix")) {
              if (!(message.prefix && typeof message.prefix.length === "number" || $util.isString(message.prefix)))
                return "prefix: buffer expected";
            }
            return null;
          };
          LeafOp.fromObject = function fromObject(object) {
            if (object instanceof $root.ics23.LeafOp)
              return object;
            var message = new $root.ics23.LeafOp();
            switch (object.hash) {
              case "NO_HASH":
              case 0:
                message.hash = 0;
                break;
              case "SHA256":
              case 1:
                message.hash = 1;
                break;
              case "SHA512":
              case 2:
                message.hash = 2;
                break;
              case "KECCAK":
              case 3:
                message.hash = 3;
                break;
              case "RIPEMD160":
              case 4:
                message.hash = 4;
                break;
              case "BITCOIN":
              case 5:
                message.hash = 5;
                break;
              case "SHA512_256":
              case 6:
                message.hash = 6;
                break;
            }
            switch (object.prehashKey) {
              case "NO_HASH":
              case 0:
                message.prehashKey = 0;
                break;
              case "SHA256":
              case 1:
                message.prehashKey = 1;
                break;
              case "SHA512":
              case 2:
                message.prehashKey = 2;
                break;
              case "KECCAK":
              case 3:
                message.prehashKey = 3;
                break;
              case "RIPEMD160":
              case 4:
                message.prehashKey = 4;
                break;
              case "BITCOIN":
              case 5:
                message.prehashKey = 5;
                break;
              case "SHA512_256":
              case 6:
                message.prehashKey = 6;
                break;
            }
            switch (object.prehashValue) {
              case "NO_HASH":
              case 0:
                message.prehashValue = 0;
                break;
              case "SHA256":
              case 1:
                message.prehashValue = 1;
                break;
              case "SHA512":
              case 2:
                message.prehashValue = 2;
                break;
              case "KECCAK":
              case 3:
                message.prehashValue = 3;
                break;
              case "RIPEMD160":
              case 4:
                message.prehashValue = 4;
                break;
              case "BITCOIN":
              case 5:
                message.prehashValue = 5;
                break;
              case "SHA512_256":
              case 6:
                message.prehashValue = 6;
                break;
            }
            switch (object.length) {
              case "NO_PREFIX":
              case 0:
                message.length = 0;
                break;
              case "VAR_PROTO":
              case 1:
                message.length = 1;
                break;
              case "VAR_RLP":
              case 2:
                message.length = 2;
                break;
              case "FIXED32_BIG":
              case 3:
                message.length = 3;
                break;
              case "FIXED32_LITTLE":
              case 4:
                message.length = 4;
                break;
              case "FIXED64_BIG":
              case 5:
                message.length = 5;
                break;
              case "FIXED64_LITTLE":
              case 6:
                message.length = 6;
                break;
              case "REQUIRE_32_BYTES":
              case 7:
                message.length = 7;
                break;
              case "REQUIRE_64_BYTES":
              case 8:
                message.length = 8;
                break;
            }
            if (object.prefix != null) {
              if (typeof object.prefix === "string")
                $util.base64.decode(object.prefix, message.prefix = $util.newBuffer($util.base64.length(object.prefix)), 0);
              else if (object.prefix.length)
                message.prefix = object.prefix;
            }
            return message;
          };
          LeafOp.toObject = function toObject(message, options) {
            if (!options)
              options = {};
            var object = {};
            if (options.defaults) {
              object.hash = options.enums === String ? "NO_HASH" : 0;
              object.prehashKey = options.enums === String ? "NO_HASH" : 0;
              object.prehashValue = options.enums === String ? "NO_HASH" : 0;
              object.length = options.enums === String ? "NO_PREFIX" : 0;
              if (options.bytes === String)
                object.prefix = "";
              else {
                object.prefix = [];
                if (options.bytes !== Array)
                  object.prefix = $util.newBuffer(object.prefix);
              }
            }
            if (message.hash != null && message.hasOwnProperty("hash"))
              object.hash = options.enums === String ? $root.ics23.HashOp[message.hash] : message.hash;
            if (message.prehashKey != null && message.hasOwnProperty("prehashKey"))
              object.prehashKey = options.enums === String ? $root.ics23.HashOp[message.prehashKey] : message.prehashKey;
            if (message.prehashValue != null && message.hasOwnProperty("prehashValue"))
              object.prehashValue = options.enums === String ? $root.ics23.HashOp[message.prehashValue] : message.prehashValue;
            if (message.length != null && message.hasOwnProperty("length"))
              object.length = options.enums === String ? $root.ics23.LengthOp[message.length] : message.length;
            if (message.prefix != null && message.hasOwnProperty("prefix"))
              object.prefix = options.bytes === String ? $util.base64.encode(message.prefix, 0, message.prefix.length) : options.bytes === Array ? Array.prototype.slice.call(message.prefix) : message.prefix;
            return object;
          };
          LeafOp.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
          };
          return LeafOp;
        }();
        ics23.InnerOp = function() {
          function InnerOp(properties) {
            if (properties) {
              for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                  this[keys[i]] = properties[keys[i]];
            }
          }
          InnerOp.prototype.hash = 0;
          InnerOp.prototype.prefix = $util.newBuffer([]);
          InnerOp.prototype.suffix = $util.newBuffer([]);
          InnerOp.create = function create(properties) {
            return new InnerOp(properties);
          };
          InnerOp.encode = function encode(message, writer) {
            if (!writer)
              writer = $Writer.create();
            if (message.hash != null && message.hasOwnProperty("hash"))
              writer.uint32(8).int32(message.hash);
            if (message.prefix != null && message.hasOwnProperty("prefix"))
              writer.uint32(18).bytes(message.prefix);
            if (message.suffix != null && message.hasOwnProperty("suffix"))
              writer.uint32(26).bytes(message.suffix);
            return writer;
          };
          InnerOp.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
          };
          InnerOp.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
              reader = $Reader.create(reader);
            var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.ics23.InnerOp();
            while (reader.pos < end) {
              var tag = reader.uint32();
              switch (tag >>> 3) {
                case 1:
                  message.hash = reader.int32();
                  break;
                case 2:
                  message.prefix = reader.bytes();
                  break;
                case 3:
                  message.suffix = reader.bytes();
                  break;
                default:
                  reader.skipType(tag & 7);
                  break;
              }
            }
            return message;
          };
          InnerOp.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
              reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
          };
          InnerOp.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
              return "object expected";
            if (message.hash != null && message.hasOwnProperty("hash"))
              switch (message.hash) {
                default:
                  return "hash: enum value expected";
                case 0:
                case 1:
                case 2:
                case 3:
                case 4:
                case 5:
                case 6:
                  break;
              }
            if (message.prefix != null && message.hasOwnProperty("prefix")) {
              if (!(message.prefix && typeof message.prefix.length === "number" || $util.isString(message.prefix)))
                return "prefix: buffer expected";
            }
            if (message.suffix != null && message.hasOwnProperty("suffix")) {
              if (!(message.suffix && typeof message.suffix.length === "number" || $util.isString(message.suffix)))
                return "suffix: buffer expected";
            }
            return null;
          };
          InnerOp.fromObject = function fromObject(object) {
            if (object instanceof $root.ics23.InnerOp)
              return object;
            var message = new $root.ics23.InnerOp();
            switch (object.hash) {
              case "NO_HASH":
              case 0:
                message.hash = 0;
                break;
              case "SHA256":
              case 1:
                message.hash = 1;
                break;
              case "SHA512":
              case 2:
                message.hash = 2;
                break;
              case "KECCAK":
              case 3:
                message.hash = 3;
                break;
              case "RIPEMD160":
              case 4:
                message.hash = 4;
                break;
              case "BITCOIN":
              case 5:
                message.hash = 5;
                break;
              case "SHA512_256":
              case 6:
                message.hash = 6;
                break;
            }
            if (object.prefix != null) {
              if (typeof object.prefix === "string")
                $util.base64.decode(object.prefix, message.prefix = $util.newBuffer($util.base64.length(object.prefix)), 0);
              else if (object.prefix.length)
                message.prefix = object.prefix;
            }
            if (object.suffix != null) {
              if (typeof object.suffix === "string")
                $util.base64.decode(object.suffix, message.suffix = $util.newBuffer($util.base64.length(object.suffix)), 0);
              else if (object.suffix.length)
                message.suffix = object.suffix;
            }
            return message;
          };
          InnerOp.toObject = function toObject(message, options) {
            if (!options)
              options = {};
            var object = {};
            if (options.defaults) {
              object.hash = options.enums === String ? "NO_HASH" : 0;
              if (options.bytes === String)
                object.prefix = "";
              else {
                object.prefix = [];
                if (options.bytes !== Array)
                  object.prefix = $util.newBuffer(object.prefix);
              }
              if (options.bytes === String)
                object.suffix = "";
              else {
                object.suffix = [];
                if (options.bytes !== Array)
                  object.suffix = $util.newBuffer(object.suffix);
              }
            }
            if (message.hash != null && message.hasOwnProperty("hash"))
              object.hash = options.enums === String ? $root.ics23.HashOp[message.hash] : message.hash;
            if (message.prefix != null && message.hasOwnProperty("prefix"))
              object.prefix = options.bytes === String ? $util.base64.encode(message.prefix, 0, message.prefix.length) : options.bytes === Array ? Array.prototype.slice.call(message.prefix) : message.prefix;
            if (message.suffix != null && message.hasOwnProperty("suffix"))
              object.suffix = options.bytes === String ? $util.base64.encode(message.suffix, 0, message.suffix.length) : options.bytes === Array ? Array.prototype.slice.call(message.suffix) : message.suffix;
            return object;
          };
          InnerOp.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
          };
          return InnerOp;
        }();
        ics23.ProofSpec = function() {
          function ProofSpec(properties) {
            if (properties) {
              for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                  this[keys[i]] = properties[keys[i]];
            }
          }
          ProofSpec.prototype.leafSpec = null;
          ProofSpec.prototype.innerSpec = null;
          ProofSpec.prototype.maxDepth = 0;
          ProofSpec.prototype.minDepth = 0;
          ProofSpec.create = function create(properties) {
            return new ProofSpec(properties);
          };
          ProofSpec.encode = function encode(message, writer) {
            if (!writer)
              writer = $Writer.create();
            if (message.leafSpec != null && message.hasOwnProperty("leafSpec"))
              $root.ics23.LeafOp.encode(message.leafSpec, writer.uint32(10).fork()).ldelim();
            if (message.innerSpec != null && message.hasOwnProperty("innerSpec"))
              $root.ics23.InnerSpec.encode(message.innerSpec, writer.uint32(18).fork()).ldelim();
            if (message.maxDepth != null && message.hasOwnProperty("maxDepth"))
              writer.uint32(24).int32(message.maxDepth);
            if (message.minDepth != null && message.hasOwnProperty("minDepth"))
              writer.uint32(32).int32(message.minDepth);
            return writer;
          };
          ProofSpec.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
          };
          ProofSpec.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
              reader = $Reader.create(reader);
            var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.ics23.ProofSpec();
            while (reader.pos < end) {
              var tag = reader.uint32();
              switch (tag >>> 3) {
                case 1:
                  message.leafSpec = $root.ics23.LeafOp.decode(reader, reader.uint32());
                  break;
                case 2:
                  message.innerSpec = $root.ics23.InnerSpec.decode(reader, reader.uint32());
                  break;
                case 3:
                  message.maxDepth = reader.int32();
                  break;
                case 4:
                  message.minDepth = reader.int32();
                  break;
                default:
                  reader.skipType(tag & 7);
                  break;
              }
            }
            return message;
          };
          ProofSpec.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
              reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
          };
          ProofSpec.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
              return "object expected";
            if (message.leafSpec != null && message.hasOwnProperty("leafSpec")) {
              var error = $root.ics23.LeafOp.verify(message.leafSpec);
              if (error)
                return "leafSpec." + error;
            }
            if (message.innerSpec != null && message.hasOwnProperty("innerSpec")) {
              var error = $root.ics23.InnerSpec.verify(message.innerSpec);
              if (error)
                return "innerSpec." + error;
            }
            if (message.maxDepth != null && message.hasOwnProperty("maxDepth")) {
              if (!$util.isInteger(message.maxDepth))
                return "maxDepth: integer expected";
            }
            if (message.minDepth != null && message.hasOwnProperty("minDepth")) {
              if (!$util.isInteger(message.minDepth))
                return "minDepth: integer expected";
            }
            return null;
          };
          ProofSpec.fromObject = function fromObject(object) {
            if (object instanceof $root.ics23.ProofSpec)
              return object;
            var message = new $root.ics23.ProofSpec();
            if (object.leafSpec != null) {
              if (typeof object.leafSpec !== "object")
                throw TypeError(".ics23.ProofSpec.leafSpec: object expected");
              message.leafSpec = $root.ics23.LeafOp.fromObject(object.leafSpec);
            }
            if (object.innerSpec != null) {
              if (typeof object.innerSpec !== "object")
                throw TypeError(".ics23.ProofSpec.innerSpec: object expected");
              message.innerSpec = $root.ics23.InnerSpec.fromObject(object.innerSpec);
            }
            if (object.maxDepth != null)
              message.maxDepth = object.maxDepth | 0;
            if (object.minDepth != null)
              message.minDepth = object.minDepth | 0;
            return message;
          };
          ProofSpec.toObject = function toObject(message, options) {
            if (!options)
              options = {};
            var object = {};
            if (options.defaults) {
              object.leafSpec = null;
              object.innerSpec = null;
              object.maxDepth = 0;
              object.minDepth = 0;
            }
            if (message.leafSpec != null && message.hasOwnProperty("leafSpec"))
              object.leafSpec = $root.ics23.LeafOp.toObject(message.leafSpec, options);
            if (message.innerSpec != null && message.hasOwnProperty("innerSpec"))
              object.innerSpec = $root.ics23.InnerSpec.toObject(message.innerSpec, options);
            if (message.maxDepth != null && message.hasOwnProperty("maxDepth"))
              object.maxDepth = message.maxDepth;
            if (message.minDepth != null && message.hasOwnProperty("minDepth"))
              object.minDepth = message.minDepth;
            return object;
          };
          ProofSpec.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
          };
          return ProofSpec;
        }();
        ics23.InnerSpec = function() {
          function InnerSpec(properties) {
            this.childOrder = [];
            if (properties) {
              for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                  this[keys[i]] = properties[keys[i]];
            }
          }
          InnerSpec.prototype.childOrder = $util.emptyArray;
          InnerSpec.prototype.childSize = 0;
          InnerSpec.prototype.minPrefixLength = 0;
          InnerSpec.prototype.maxPrefixLength = 0;
          InnerSpec.prototype.emptyChild = $util.newBuffer([]);
          InnerSpec.prototype.hash = 0;
          InnerSpec.create = function create(properties) {
            return new InnerSpec(properties);
          };
          InnerSpec.encode = function encode(message, writer) {
            if (!writer)
              writer = $Writer.create();
            if (message.childOrder != null && message.childOrder.length) {
              writer.uint32(10).fork();
              for (var i = 0; i < message.childOrder.length; ++i)
                writer.int32(message.childOrder[i]);
              writer.ldelim();
            }
            if (message.childSize != null && message.hasOwnProperty("childSize"))
              writer.uint32(16).int32(message.childSize);
            if (message.minPrefixLength != null && message.hasOwnProperty("minPrefixLength"))
              writer.uint32(24).int32(message.minPrefixLength);
            if (message.maxPrefixLength != null && message.hasOwnProperty("maxPrefixLength"))
              writer.uint32(32).int32(message.maxPrefixLength);
            if (message.emptyChild != null && message.hasOwnProperty("emptyChild"))
              writer.uint32(42).bytes(message.emptyChild);
            if (message.hash != null && message.hasOwnProperty("hash"))
              writer.uint32(48).int32(message.hash);
            return writer;
          };
          InnerSpec.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
          };
          InnerSpec.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
              reader = $Reader.create(reader);
            var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.ics23.InnerSpec();
            while (reader.pos < end) {
              var tag = reader.uint32();
              switch (tag >>> 3) {
                case 1:
                  if (!(message.childOrder && message.childOrder.length))
                    message.childOrder = [];
                  if ((tag & 7) === 2) {
                    var end2 = reader.uint32() + reader.pos;
                    while (reader.pos < end2)
                      message.childOrder.push(reader.int32());
                  } else
                    message.childOrder.push(reader.int32());
                  break;
                case 2:
                  message.childSize = reader.int32();
                  break;
                case 3:
                  message.minPrefixLength = reader.int32();
                  break;
                case 4:
                  message.maxPrefixLength = reader.int32();
                  break;
                case 5:
                  message.emptyChild = reader.bytes();
                  break;
                case 6:
                  message.hash = reader.int32();
                  break;
                default:
                  reader.skipType(tag & 7);
                  break;
              }
            }
            return message;
          };
          InnerSpec.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
              reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
          };
          InnerSpec.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
              return "object expected";
            if (message.childOrder != null && message.hasOwnProperty("childOrder")) {
              if (!Array.isArray(message.childOrder))
                return "childOrder: array expected";
              for (var i = 0; i < message.childOrder.length; ++i)
                if (!$util.isInteger(message.childOrder[i]))
                  return "childOrder: integer[] expected";
            }
            if (message.childSize != null && message.hasOwnProperty("childSize")) {
              if (!$util.isInteger(message.childSize))
                return "childSize: integer expected";
            }
            if (message.minPrefixLength != null && message.hasOwnProperty("minPrefixLength")) {
              if (!$util.isInteger(message.minPrefixLength))
                return "minPrefixLength: integer expected";
            }
            if (message.maxPrefixLength != null && message.hasOwnProperty("maxPrefixLength")) {
              if (!$util.isInteger(message.maxPrefixLength))
                return "maxPrefixLength: integer expected";
            }
            if (message.emptyChild != null && message.hasOwnProperty("emptyChild")) {
              if (!(message.emptyChild && typeof message.emptyChild.length === "number" || $util.isString(message.emptyChild)))
                return "emptyChild: buffer expected";
            }
            if (message.hash != null && message.hasOwnProperty("hash"))
              switch (message.hash) {
                default:
                  return "hash: enum value expected";
                case 0:
                case 1:
                case 2:
                case 3:
                case 4:
                case 5:
                case 6:
                  break;
              }
            return null;
          };
          InnerSpec.fromObject = function fromObject(object) {
            if (object instanceof $root.ics23.InnerSpec)
              return object;
            var message = new $root.ics23.InnerSpec();
            if (object.childOrder) {
              if (!Array.isArray(object.childOrder))
                throw TypeError(".ics23.InnerSpec.childOrder: array expected");
              message.childOrder = [];
              for (var i = 0; i < object.childOrder.length; ++i)
                message.childOrder[i] = object.childOrder[i] | 0;
            }
            if (object.childSize != null)
              message.childSize = object.childSize | 0;
            if (object.minPrefixLength != null)
              message.minPrefixLength = object.minPrefixLength | 0;
            if (object.maxPrefixLength != null)
              message.maxPrefixLength = object.maxPrefixLength | 0;
            if (object.emptyChild != null) {
              if (typeof object.emptyChild === "string")
                $util.base64.decode(object.emptyChild, message.emptyChild = $util.newBuffer($util.base64.length(object.emptyChild)), 0);
              else if (object.emptyChild.length)
                message.emptyChild = object.emptyChild;
            }
            switch (object.hash) {
              case "NO_HASH":
              case 0:
                message.hash = 0;
                break;
              case "SHA256":
              case 1:
                message.hash = 1;
                break;
              case "SHA512":
              case 2:
                message.hash = 2;
                break;
              case "KECCAK":
              case 3:
                message.hash = 3;
                break;
              case "RIPEMD160":
              case 4:
                message.hash = 4;
                break;
              case "BITCOIN":
              case 5:
                message.hash = 5;
                break;
              case "SHA512_256":
              case 6:
                message.hash = 6;
                break;
            }
            return message;
          };
          InnerSpec.toObject = function toObject(message, options) {
            if (!options)
              options = {};
            var object = {};
            if (options.arrays || options.defaults)
              object.childOrder = [];
            if (options.defaults) {
              object.childSize = 0;
              object.minPrefixLength = 0;
              object.maxPrefixLength = 0;
              if (options.bytes === String)
                object.emptyChild = "";
              else {
                object.emptyChild = [];
                if (options.bytes !== Array)
                  object.emptyChild = $util.newBuffer(object.emptyChild);
              }
              object.hash = options.enums === String ? "NO_HASH" : 0;
            }
            if (message.childOrder && message.childOrder.length) {
              object.childOrder = [];
              for (var j = 0; j < message.childOrder.length; ++j)
                object.childOrder[j] = message.childOrder[j];
            }
            if (message.childSize != null && message.hasOwnProperty("childSize"))
              object.childSize = message.childSize;
            if (message.minPrefixLength != null && message.hasOwnProperty("minPrefixLength"))
              object.minPrefixLength = message.minPrefixLength;
            if (message.maxPrefixLength != null && message.hasOwnProperty("maxPrefixLength"))
              object.maxPrefixLength = message.maxPrefixLength;
            if (message.emptyChild != null && message.hasOwnProperty("emptyChild"))
              object.emptyChild = options.bytes === String ? $util.base64.encode(message.emptyChild, 0, message.emptyChild.length) : options.bytes === Array ? Array.prototype.slice.call(message.emptyChild) : message.emptyChild;
            if (message.hash != null && message.hasOwnProperty("hash"))
              object.hash = options.enums === String ? $root.ics23.HashOp[message.hash] : message.hash;
            return object;
          };
          InnerSpec.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
          };
          return InnerSpec;
        }();
        ics23.BatchProof = function() {
          function BatchProof(properties) {
            this.entries = [];
            if (properties) {
              for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                  this[keys[i]] = properties[keys[i]];
            }
          }
          BatchProof.prototype.entries = $util.emptyArray;
          BatchProof.create = function create(properties) {
            return new BatchProof(properties);
          };
          BatchProof.encode = function encode(message, writer) {
            if (!writer)
              writer = $Writer.create();
            if (message.entries != null && message.entries.length)
              for (var i = 0; i < message.entries.length; ++i)
                $root.ics23.BatchEntry.encode(message.entries[i], writer.uint32(10).fork()).ldelim();
            return writer;
          };
          BatchProof.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
          };
          BatchProof.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
              reader = $Reader.create(reader);
            var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.ics23.BatchProof();
            while (reader.pos < end) {
              var tag = reader.uint32();
              switch (tag >>> 3) {
                case 1:
                  if (!(message.entries && message.entries.length))
                    message.entries = [];
                  message.entries.push($root.ics23.BatchEntry.decode(reader, reader.uint32()));
                  break;
                default:
                  reader.skipType(tag & 7);
                  break;
              }
            }
            return message;
          };
          BatchProof.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
              reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
          };
          BatchProof.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
              return "object expected";
            if (message.entries != null && message.hasOwnProperty("entries")) {
              if (!Array.isArray(message.entries))
                return "entries: array expected";
              for (var i = 0; i < message.entries.length; ++i) {
                var error = $root.ics23.BatchEntry.verify(message.entries[i]);
                if (error)
                  return "entries." + error;
              }
            }
            return null;
          };
          BatchProof.fromObject = function fromObject(object) {
            if (object instanceof $root.ics23.BatchProof)
              return object;
            var message = new $root.ics23.BatchProof();
            if (object.entries) {
              if (!Array.isArray(object.entries))
                throw TypeError(".ics23.BatchProof.entries: array expected");
              message.entries = [];
              for (var i = 0; i < object.entries.length; ++i) {
                if (typeof object.entries[i] !== "object")
                  throw TypeError(".ics23.BatchProof.entries: object expected");
                message.entries[i] = $root.ics23.BatchEntry.fromObject(object.entries[i]);
              }
            }
            return message;
          };
          BatchProof.toObject = function toObject(message, options) {
            if (!options)
              options = {};
            var object = {};
            if (options.arrays || options.defaults)
              object.entries = [];
            if (message.entries && message.entries.length) {
              object.entries = [];
              for (var j = 0; j < message.entries.length; ++j)
                object.entries[j] = $root.ics23.BatchEntry.toObject(message.entries[j], options);
            }
            return object;
          };
          BatchProof.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
          };
          return BatchProof;
        }();
        ics23.BatchEntry = function() {
          function BatchEntry(properties) {
            if (properties) {
              for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                  this[keys[i]] = properties[keys[i]];
            }
          }
          BatchEntry.prototype.exist = null;
          BatchEntry.prototype.nonexist = null;
          var $oneOfFields;
          Object.defineProperty(BatchEntry.prototype, "proof", {
            get: $util.oneOfGetter($oneOfFields = ["exist", "nonexist"]),
            set: $util.oneOfSetter($oneOfFields)
          });
          BatchEntry.create = function create(properties) {
            return new BatchEntry(properties);
          };
          BatchEntry.encode = function encode(message, writer) {
            if (!writer)
              writer = $Writer.create();
            if (message.exist != null && message.hasOwnProperty("exist"))
              $root.ics23.ExistenceProof.encode(message.exist, writer.uint32(10).fork()).ldelim();
            if (message.nonexist != null && message.hasOwnProperty("nonexist"))
              $root.ics23.NonExistenceProof.encode(message.nonexist, writer.uint32(18).fork()).ldelim();
            return writer;
          };
          BatchEntry.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
          };
          BatchEntry.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
              reader = $Reader.create(reader);
            var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.ics23.BatchEntry();
            while (reader.pos < end) {
              var tag = reader.uint32();
              switch (tag >>> 3) {
                case 1:
                  message.exist = $root.ics23.ExistenceProof.decode(reader, reader.uint32());
                  break;
                case 2:
                  message.nonexist = $root.ics23.NonExistenceProof.decode(reader, reader.uint32());
                  break;
                default:
                  reader.skipType(tag & 7);
                  break;
              }
            }
            return message;
          };
          BatchEntry.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
              reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
          };
          BatchEntry.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
              return "object expected";
            var properties = {};
            if (message.exist != null && message.hasOwnProperty("exist")) {
              properties.proof = 1;
              {
                var error = $root.ics23.ExistenceProof.verify(message.exist);
                if (error)
                  return "exist." + error;
              }
            }
            if (message.nonexist != null && message.hasOwnProperty("nonexist")) {
              if (properties.proof === 1)
                return "proof: multiple values";
              properties.proof = 1;
              {
                var error = $root.ics23.NonExistenceProof.verify(message.nonexist);
                if (error)
                  return "nonexist." + error;
              }
            }
            return null;
          };
          BatchEntry.fromObject = function fromObject(object) {
            if (object instanceof $root.ics23.BatchEntry)
              return object;
            var message = new $root.ics23.BatchEntry();
            if (object.exist != null) {
              if (typeof object.exist !== "object")
                throw TypeError(".ics23.BatchEntry.exist: object expected");
              message.exist = $root.ics23.ExistenceProof.fromObject(object.exist);
            }
            if (object.nonexist != null) {
              if (typeof object.nonexist !== "object")
                throw TypeError(".ics23.BatchEntry.nonexist: object expected");
              message.nonexist = $root.ics23.NonExistenceProof.fromObject(object.nonexist);
            }
            return message;
          };
          BatchEntry.toObject = function toObject(message, options) {
            if (!options)
              options = {};
            var object = {};
            if (message.exist != null && message.hasOwnProperty("exist")) {
              object.exist = $root.ics23.ExistenceProof.toObject(message.exist, options);
              if (options.oneofs)
                object.proof = "exist";
            }
            if (message.nonexist != null && message.hasOwnProperty("nonexist")) {
              object.nonexist = $root.ics23.NonExistenceProof.toObject(message.nonexist, options);
              if (options.oneofs)
                object.proof = "nonexist";
            }
            return object;
          };
          BatchEntry.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
          };
          return BatchEntry;
        }();
        ics23.CompressedBatchProof = function() {
          function CompressedBatchProof(properties) {
            this.entries = [];
            this.lookupInners = [];
            if (properties) {
              for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                  this[keys[i]] = properties[keys[i]];
            }
          }
          CompressedBatchProof.prototype.entries = $util.emptyArray;
          CompressedBatchProof.prototype.lookupInners = $util.emptyArray;
          CompressedBatchProof.create = function create(properties) {
            return new CompressedBatchProof(properties);
          };
          CompressedBatchProof.encode = function encode(message, writer) {
            if (!writer)
              writer = $Writer.create();
            if (message.entries != null && message.entries.length)
              for (var i = 0; i < message.entries.length; ++i)
                $root.ics23.CompressedBatchEntry.encode(message.entries[i], writer.uint32(10).fork()).ldelim();
            if (message.lookupInners != null && message.lookupInners.length)
              for (var i = 0; i < message.lookupInners.length; ++i)
                $root.ics23.InnerOp.encode(message.lookupInners[i], writer.uint32(18).fork()).ldelim();
            return writer;
          };
          CompressedBatchProof.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
          };
          CompressedBatchProof.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
              reader = $Reader.create(reader);
            var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.ics23.CompressedBatchProof();
            while (reader.pos < end) {
              var tag = reader.uint32();
              switch (tag >>> 3) {
                case 1:
                  if (!(message.entries && message.entries.length))
                    message.entries = [];
                  message.entries.push($root.ics23.CompressedBatchEntry.decode(reader, reader.uint32()));
                  break;
                case 2:
                  if (!(message.lookupInners && message.lookupInners.length))
                    message.lookupInners = [];
                  message.lookupInners.push($root.ics23.InnerOp.decode(reader, reader.uint32()));
                  break;
                default:
                  reader.skipType(tag & 7);
                  break;
              }
            }
            return message;
          };
          CompressedBatchProof.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
              reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
          };
          CompressedBatchProof.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
              return "object expected";
            if (message.entries != null && message.hasOwnProperty("entries")) {
              if (!Array.isArray(message.entries))
                return "entries: array expected";
              for (var i = 0; i < message.entries.length; ++i) {
                var error = $root.ics23.CompressedBatchEntry.verify(message.entries[i]);
                if (error)
                  return "entries." + error;
              }
            }
            if (message.lookupInners != null && message.hasOwnProperty("lookupInners")) {
              if (!Array.isArray(message.lookupInners))
                return "lookupInners: array expected";
              for (var i = 0; i < message.lookupInners.length; ++i) {
                var error = $root.ics23.InnerOp.verify(message.lookupInners[i]);
                if (error)
                  return "lookupInners." + error;
              }
            }
            return null;
          };
          CompressedBatchProof.fromObject = function fromObject(object) {
            if (object instanceof $root.ics23.CompressedBatchProof)
              return object;
            var message = new $root.ics23.CompressedBatchProof();
            if (object.entries) {
              if (!Array.isArray(object.entries))
                throw TypeError(".ics23.CompressedBatchProof.entries: array expected");
              message.entries = [];
              for (var i = 0; i < object.entries.length; ++i) {
                if (typeof object.entries[i] !== "object")
                  throw TypeError(".ics23.CompressedBatchProof.entries: object expected");
                message.entries[i] = $root.ics23.CompressedBatchEntry.fromObject(object.entries[i]);
              }
            }
            if (object.lookupInners) {
              if (!Array.isArray(object.lookupInners))
                throw TypeError(".ics23.CompressedBatchProof.lookupInners: array expected");
              message.lookupInners = [];
              for (var i = 0; i < object.lookupInners.length; ++i) {
                if (typeof object.lookupInners[i] !== "object")
                  throw TypeError(".ics23.CompressedBatchProof.lookupInners: object expected");
                message.lookupInners[i] = $root.ics23.InnerOp.fromObject(object.lookupInners[i]);
              }
            }
            return message;
          };
          CompressedBatchProof.toObject = function toObject(message, options) {
            if (!options)
              options = {};
            var object = {};
            if (options.arrays || options.defaults) {
              object.entries = [];
              object.lookupInners = [];
            }
            if (message.entries && message.entries.length) {
              object.entries = [];
              for (var j = 0; j < message.entries.length; ++j)
                object.entries[j] = $root.ics23.CompressedBatchEntry.toObject(message.entries[j], options);
            }
            if (message.lookupInners && message.lookupInners.length) {
              object.lookupInners = [];
              for (var j = 0; j < message.lookupInners.length; ++j)
                object.lookupInners[j] = $root.ics23.InnerOp.toObject(message.lookupInners[j], options);
            }
            return object;
          };
          CompressedBatchProof.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
          };
          return CompressedBatchProof;
        }();
        ics23.CompressedBatchEntry = function() {
          function CompressedBatchEntry(properties) {
            if (properties) {
              for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                  this[keys[i]] = properties[keys[i]];
            }
          }
          CompressedBatchEntry.prototype.exist = null;
          CompressedBatchEntry.prototype.nonexist = null;
          var $oneOfFields;
          Object.defineProperty(CompressedBatchEntry.prototype, "proof", {
            get: $util.oneOfGetter($oneOfFields = ["exist", "nonexist"]),
            set: $util.oneOfSetter($oneOfFields)
          });
          CompressedBatchEntry.create = function create(properties) {
            return new CompressedBatchEntry(properties);
          };
          CompressedBatchEntry.encode = function encode(message, writer) {
            if (!writer)
              writer = $Writer.create();
            if (message.exist != null && message.hasOwnProperty("exist"))
              $root.ics23.CompressedExistenceProof.encode(message.exist, writer.uint32(10).fork()).ldelim();
            if (message.nonexist != null && message.hasOwnProperty("nonexist"))
              $root.ics23.CompressedNonExistenceProof.encode(message.nonexist, writer.uint32(18).fork()).ldelim();
            return writer;
          };
          CompressedBatchEntry.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
          };
          CompressedBatchEntry.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
              reader = $Reader.create(reader);
            var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.ics23.CompressedBatchEntry();
            while (reader.pos < end) {
              var tag = reader.uint32();
              switch (tag >>> 3) {
                case 1:
                  message.exist = $root.ics23.CompressedExistenceProof.decode(reader, reader.uint32());
                  break;
                case 2:
                  message.nonexist = $root.ics23.CompressedNonExistenceProof.decode(reader, reader.uint32());
                  break;
                default:
                  reader.skipType(tag & 7);
                  break;
              }
            }
            return message;
          };
          CompressedBatchEntry.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
              reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
          };
          CompressedBatchEntry.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
              return "object expected";
            var properties = {};
            if (message.exist != null && message.hasOwnProperty("exist")) {
              properties.proof = 1;
              {
                var error = $root.ics23.CompressedExistenceProof.verify(message.exist);
                if (error)
                  return "exist." + error;
              }
            }
            if (message.nonexist != null && message.hasOwnProperty("nonexist")) {
              if (properties.proof === 1)
                return "proof: multiple values";
              properties.proof = 1;
              {
                var error = $root.ics23.CompressedNonExistenceProof.verify(message.nonexist);
                if (error)
                  return "nonexist." + error;
              }
            }
            return null;
          };
          CompressedBatchEntry.fromObject = function fromObject(object) {
            if (object instanceof $root.ics23.CompressedBatchEntry)
              return object;
            var message = new $root.ics23.CompressedBatchEntry();
            if (object.exist != null) {
              if (typeof object.exist !== "object")
                throw TypeError(".ics23.CompressedBatchEntry.exist: object expected");
              message.exist = $root.ics23.CompressedExistenceProof.fromObject(object.exist);
            }
            if (object.nonexist != null) {
              if (typeof object.nonexist !== "object")
                throw TypeError(".ics23.CompressedBatchEntry.nonexist: object expected");
              message.nonexist = $root.ics23.CompressedNonExistenceProof.fromObject(object.nonexist);
            }
            return message;
          };
          CompressedBatchEntry.toObject = function toObject(message, options) {
            if (!options)
              options = {};
            var object = {};
            if (message.exist != null && message.hasOwnProperty("exist")) {
              object.exist = $root.ics23.CompressedExistenceProof.toObject(message.exist, options);
              if (options.oneofs)
                object.proof = "exist";
            }
            if (message.nonexist != null && message.hasOwnProperty("nonexist")) {
              object.nonexist = $root.ics23.CompressedNonExistenceProof.toObject(message.nonexist, options);
              if (options.oneofs)
                object.proof = "nonexist";
            }
            return object;
          };
          CompressedBatchEntry.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
          };
          return CompressedBatchEntry;
        }();
        ics23.CompressedExistenceProof = function() {
          function CompressedExistenceProof(properties) {
            this.path = [];
            if (properties) {
              for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                  this[keys[i]] = properties[keys[i]];
            }
          }
          CompressedExistenceProof.prototype.key = $util.newBuffer([]);
          CompressedExistenceProof.prototype.value = $util.newBuffer([]);
          CompressedExistenceProof.prototype.leaf = null;
          CompressedExistenceProof.prototype.path = $util.emptyArray;
          CompressedExistenceProof.create = function create(properties) {
            return new CompressedExistenceProof(properties);
          };
          CompressedExistenceProof.encode = function encode(message, writer) {
            if (!writer)
              writer = $Writer.create();
            if (message.key != null && message.hasOwnProperty("key"))
              writer.uint32(10).bytes(message.key);
            if (message.value != null && message.hasOwnProperty("value"))
              writer.uint32(18).bytes(message.value);
            if (message.leaf != null && message.hasOwnProperty("leaf"))
              $root.ics23.LeafOp.encode(message.leaf, writer.uint32(26).fork()).ldelim();
            if (message.path != null && message.path.length) {
              writer.uint32(34).fork();
              for (var i = 0; i < message.path.length; ++i)
                writer.int32(message.path[i]);
              writer.ldelim();
            }
            return writer;
          };
          CompressedExistenceProof.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
          };
          CompressedExistenceProof.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
              reader = $Reader.create(reader);
            var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.ics23.CompressedExistenceProof();
            while (reader.pos < end) {
              var tag = reader.uint32();
              switch (tag >>> 3) {
                case 1:
                  message.key = reader.bytes();
                  break;
                case 2:
                  message.value = reader.bytes();
                  break;
                case 3:
                  message.leaf = $root.ics23.LeafOp.decode(reader, reader.uint32());
                  break;
                case 4:
                  if (!(message.path && message.path.length))
                    message.path = [];
                  if ((tag & 7) === 2) {
                    var end2 = reader.uint32() + reader.pos;
                    while (reader.pos < end2)
                      message.path.push(reader.int32());
                  } else
                    message.path.push(reader.int32());
                  break;
                default:
                  reader.skipType(tag & 7);
                  break;
              }
            }
            return message;
          };
          CompressedExistenceProof.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
              reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
          };
          CompressedExistenceProof.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
              return "object expected";
            if (message.key != null && message.hasOwnProperty("key")) {
              if (!(message.key && typeof message.key.length === "number" || $util.isString(message.key)))
                return "key: buffer expected";
            }
            if (message.value != null && message.hasOwnProperty("value")) {
              if (!(message.value && typeof message.value.length === "number" || $util.isString(message.value)))
                return "value: buffer expected";
            }
            if (message.leaf != null && message.hasOwnProperty("leaf")) {
              var error = $root.ics23.LeafOp.verify(message.leaf);
              if (error)
                return "leaf." + error;
            }
            if (message.path != null && message.hasOwnProperty("path")) {
              if (!Array.isArray(message.path))
                return "path: array expected";
              for (var i = 0; i < message.path.length; ++i)
                if (!$util.isInteger(message.path[i]))
                  return "path: integer[] expected";
            }
            return null;
          };
          CompressedExistenceProof.fromObject = function fromObject(object) {
            if (object instanceof $root.ics23.CompressedExistenceProof)
              return object;
            var message = new $root.ics23.CompressedExistenceProof();
            if (object.key != null) {
              if (typeof object.key === "string")
                $util.base64.decode(object.key, message.key = $util.newBuffer($util.base64.length(object.key)), 0);
              else if (object.key.length)
                message.key = object.key;
            }
            if (object.value != null) {
              if (typeof object.value === "string")
                $util.base64.decode(object.value, message.value = $util.newBuffer($util.base64.length(object.value)), 0);
              else if (object.value.length)
                message.value = object.value;
            }
            if (object.leaf != null) {
              if (typeof object.leaf !== "object")
                throw TypeError(".ics23.CompressedExistenceProof.leaf: object expected");
              message.leaf = $root.ics23.LeafOp.fromObject(object.leaf);
            }
            if (object.path) {
              if (!Array.isArray(object.path))
                throw TypeError(".ics23.CompressedExistenceProof.path: array expected");
              message.path = [];
              for (var i = 0; i < object.path.length; ++i)
                message.path[i] = object.path[i] | 0;
            }
            return message;
          };
          CompressedExistenceProof.toObject = function toObject(message, options) {
            if (!options)
              options = {};
            var object = {};
            if (options.arrays || options.defaults)
              object.path = [];
            if (options.defaults) {
              if (options.bytes === String)
                object.key = "";
              else {
                object.key = [];
                if (options.bytes !== Array)
                  object.key = $util.newBuffer(object.key);
              }
              if (options.bytes === String)
                object.value = "";
              else {
                object.value = [];
                if (options.bytes !== Array)
                  object.value = $util.newBuffer(object.value);
              }
              object.leaf = null;
            }
            if (message.key != null && message.hasOwnProperty("key"))
              object.key = options.bytes === String ? $util.base64.encode(message.key, 0, message.key.length) : options.bytes === Array ? Array.prototype.slice.call(message.key) : message.key;
            if (message.value != null && message.hasOwnProperty("value"))
              object.value = options.bytes === String ? $util.base64.encode(message.value, 0, message.value.length) : options.bytes === Array ? Array.prototype.slice.call(message.value) : message.value;
            if (message.leaf != null && message.hasOwnProperty("leaf"))
              object.leaf = $root.ics23.LeafOp.toObject(message.leaf, options);
            if (message.path && message.path.length) {
              object.path = [];
              for (var j = 0; j < message.path.length; ++j)
                object.path[j] = message.path[j];
            }
            return object;
          };
          CompressedExistenceProof.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
          };
          return CompressedExistenceProof;
        }();
        ics23.CompressedNonExistenceProof = function() {
          function CompressedNonExistenceProof(properties) {
            if (properties) {
              for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                  this[keys[i]] = properties[keys[i]];
            }
          }
          CompressedNonExistenceProof.prototype.key = $util.newBuffer([]);
          CompressedNonExistenceProof.prototype.left = null;
          CompressedNonExistenceProof.prototype.right = null;
          CompressedNonExistenceProof.create = function create(properties) {
            return new CompressedNonExistenceProof(properties);
          };
          CompressedNonExistenceProof.encode = function encode(message, writer) {
            if (!writer)
              writer = $Writer.create();
            if (message.key != null && message.hasOwnProperty("key"))
              writer.uint32(10).bytes(message.key);
            if (message.left != null && message.hasOwnProperty("left"))
              $root.ics23.CompressedExistenceProof.encode(message.left, writer.uint32(18).fork()).ldelim();
            if (message.right != null && message.hasOwnProperty("right"))
              $root.ics23.CompressedExistenceProof.encode(message.right, writer.uint32(26).fork()).ldelim();
            return writer;
          };
          CompressedNonExistenceProof.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
          };
          CompressedNonExistenceProof.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
              reader = $Reader.create(reader);
            var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.ics23.CompressedNonExistenceProof();
            while (reader.pos < end) {
              var tag = reader.uint32();
              switch (tag >>> 3) {
                case 1:
                  message.key = reader.bytes();
                  break;
                case 2:
                  message.left = $root.ics23.CompressedExistenceProof.decode(reader, reader.uint32());
                  break;
                case 3:
                  message.right = $root.ics23.CompressedExistenceProof.decode(reader, reader.uint32());
                  break;
                default:
                  reader.skipType(tag & 7);
                  break;
              }
            }
            return message;
          };
          CompressedNonExistenceProof.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
              reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
          };
          CompressedNonExistenceProof.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
              return "object expected";
            if (message.key != null && message.hasOwnProperty("key")) {
              if (!(message.key && typeof message.key.length === "number" || $util.isString(message.key)))
                return "key: buffer expected";
            }
            if (message.left != null && message.hasOwnProperty("left")) {
              var error = $root.ics23.CompressedExistenceProof.verify(message.left);
              if (error)
                return "left." + error;
            }
            if (message.right != null && message.hasOwnProperty("right")) {
              var error = $root.ics23.CompressedExistenceProof.verify(message.right);
              if (error)
                return "right." + error;
            }
            return null;
          };
          CompressedNonExistenceProof.fromObject = function fromObject(object) {
            if (object instanceof $root.ics23.CompressedNonExistenceProof)
              return object;
            var message = new $root.ics23.CompressedNonExistenceProof();
            if (object.key != null) {
              if (typeof object.key === "string")
                $util.base64.decode(object.key, message.key = $util.newBuffer($util.base64.length(object.key)), 0);
              else if (object.key.length)
                message.key = object.key;
            }
            if (object.left != null) {
              if (typeof object.left !== "object")
                throw TypeError(".ics23.CompressedNonExistenceProof.left: object expected");
              message.left = $root.ics23.CompressedExistenceProof.fromObject(object.left);
            }
            if (object.right != null) {
              if (typeof object.right !== "object")
                throw TypeError(".ics23.CompressedNonExistenceProof.right: object expected");
              message.right = $root.ics23.CompressedExistenceProof.fromObject(object.right);
            }
            return message;
          };
          CompressedNonExistenceProof.toObject = function toObject(message, options) {
            if (!options)
              options = {};
            var object = {};
            if (options.defaults) {
              if (options.bytes === String)
                object.key = "";
              else {
                object.key = [];
                if (options.bytes !== Array)
                  object.key = $util.newBuffer(object.key);
              }
              object.left = null;
              object.right = null;
            }
            if (message.key != null && message.hasOwnProperty("key"))
              object.key = options.bytes === String ? $util.base64.encode(message.key, 0, message.key.length) : options.bytes === Array ? Array.prototype.slice.call(message.key) : message.key;
            if (message.left != null && message.hasOwnProperty("left"))
              object.left = $root.ics23.CompressedExistenceProof.toObject(message.left, options);
            if (message.right != null && message.hasOwnProperty("right"))
              object.right = $root.ics23.CompressedExistenceProof.toObject(message.right, options);
            return object;
          };
          CompressedNonExistenceProof.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
          };
          return CompressedNonExistenceProof;
        }();
        return ics23;
      }();
      module2.exports = $root;
    }
  });

  // node_modules/@confio/ics23/build/compress.js
  var require_compress = __commonJS({
    "node_modules/@confio/ics23/build/compress.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.decompress = exports2.compress = void 0;
      var codecimpl_1 = require_codecimpl();
      function compress(proof) {
        if (!proof.batch) {
          return proof;
        }
        return { compressed: compressBatch(proof.batch) };
      }
      exports2.compress = compress;
      function decompress(proof) {
        if (!proof.compressed) {
          return proof;
        }
        return { batch: decompressBatch(proof.compressed) };
      }
      exports2.decompress = decompress;
      function compressBatch(proof) {
        const centries = [];
        const lookup = [];
        const registry = /* @__PURE__ */ new Map();
        for (const entry of proof.entries) {
          if (entry.exist) {
            const centry = { exist: compressExist(entry.exist, lookup, registry) };
            centries.push(centry);
          } else if (entry.nonexist) {
            const non = entry.nonexist;
            const centry = {
              nonexist: {
                key: non.key,
                left: compressExist(non.left, lookup, registry),
                right: compressExist(non.right, lookup, registry)
              }
            };
            centries.push(centry);
          } else {
            throw new Error("Unexpected batch entry during compress");
          }
        }
        return {
          entries: centries,
          lookupInners: lookup
        };
      }
      function compressExist(exist, lookup, registry) {
        if (!exist) {
          return void 0;
        }
        const path = exist.path.map((inner) => {
          const sig = codecimpl_1.ics23.InnerOp.encode(inner).finish();
          let idx = registry.get(sig);
          if (idx === void 0) {
            idx = lookup.length;
            lookup.push(inner);
            registry.set(sig, idx);
          }
          return idx;
        });
        return {
          key: exist.key,
          value: exist.value,
          leaf: exist.leaf,
          path
        };
      }
      function decompressBatch(proof) {
        const lookup = proof.lookupInners;
        const entries = proof.entries.map((comp) => {
          if (comp.exist) {
            return { exist: decompressExist(comp.exist, lookup) };
          } else if (comp.nonexist) {
            const non = comp.nonexist;
            return {
              nonexist: {
                key: non.key,
                left: decompressExist(non.left, lookup),
                right: decompressExist(non.right, lookup)
              }
            };
          } else {
            throw new Error("Unexpected batch entry during compress");
          }
        });
        return {
          entries
        };
      }
      function decompressExist(exist, lookup) {
        if (!exist) {
          return void 0;
        }
        const { key, value, leaf, path } = exist;
        const newPath = (path || []).map((idx) => lookup[idx]);
        return { key, value, leaf, path: newPath };
      }
    }
  });

  // node_modules/@confio/ics23/build/ops.js
  var require_ops = __commonJS({
    "node_modules/@confio/ics23/build/ops.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.doHash = exports2.applyInner = exports2.applyLeaf = void 0;
      var ripemd160_1 = require_ripemd1602();
      var sha256_1 = require_sha2562();
      var sha512_1 = require_sha512();
      var codecimpl_1 = require_codecimpl();
      function applyLeaf(leaf, key, value) {
        if (key.length === 0) {
          throw new Error("Missing key");
        }
        if (value.length === 0) {
          throw new Error("Missing value");
        }
        const pkey = prepareLeafData(ensureHash(leaf.prehashKey), ensureLength(leaf.length), key);
        const pvalue = prepareLeafData(ensureHash(leaf.prehashValue), ensureLength(leaf.length), value);
        const data = new Uint8Array([
          ...ensureBytes(leaf.prefix),
          ...pkey,
          ...pvalue
        ]);
        return doHash(ensureHash(leaf.hash), data);
      }
      exports2.applyLeaf = applyLeaf;
      function applyInner(inner, child) {
        if (child.length === 0) {
          throw new Error("Inner op needs child value");
        }
        const preimage = new Uint8Array([
          ...ensureBytes(inner.prefix),
          ...child,
          ...ensureBytes(inner.suffix)
        ]);
        return doHash(ensureHash(inner.hash), preimage);
      }
      exports2.applyInner = applyInner;
      function ensure(maybe, value) {
        return maybe === void 0 || maybe === null ? value : maybe;
      }
      var ensureHash = (h) => ensure(h, codecimpl_1.ics23.HashOp.NO_HASH);
      var ensureLength = (l) => ensure(l, codecimpl_1.ics23.LengthOp.NO_PREFIX);
      var ensureBytes = (b) => ensure(b, new Uint8Array([]));
      function prepareLeafData(hashOp, lengthOp, data) {
        const h = doHashOrNoop(hashOp, data);
        return doLengthOp(lengthOp, h);
      }
      function doHashOrNoop(hashOp, preimage) {
        if (hashOp === codecimpl_1.ics23.HashOp.NO_HASH) {
          return preimage;
        }
        return doHash(hashOp, preimage);
      }
      function doHash(hashOp, preimage) {
        switch (hashOp) {
          case codecimpl_1.ics23.HashOp.SHA256:
            return (0, sha256_1.sha256)(preimage);
          case codecimpl_1.ics23.HashOp.SHA512:
            return (0, sha512_1.sha512)(preimage);
          case codecimpl_1.ics23.HashOp.RIPEMD160:
            return (0, ripemd160_1.ripemd160)(preimage);
          case codecimpl_1.ics23.HashOp.BITCOIN:
            return (0, ripemd160_1.ripemd160)((0, sha256_1.sha256)(preimage));
          case codecimpl_1.ics23.HashOp.SHA512_256:
            return (0, sha512_1.sha512_256)(preimage);
        }
        throw new Error(`Unsupported hashop: ${hashOp}`);
      }
      exports2.doHash = doHash;
      function doLengthOp(lengthOp, data) {
        switch (lengthOp) {
          case codecimpl_1.ics23.LengthOp.NO_PREFIX:
            return data;
          case codecimpl_1.ics23.LengthOp.VAR_PROTO:
            return new Uint8Array([...encodeVarintProto(data.length), ...data]);
          case codecimpl_1.ics23.LengthOp.REQUIRE_32_BYTES:
            if (data.length !== 32) {
              throw new Error(`Length is ${data.length}, not 32 bytes`);
            }
            return data;
          case codecimpl_1.ics23.LengthOp.REQUIRE_64_BYTES:
            if (data.length !== 64) {
              throw new Error(`Length is ${data.length}, not 64 bytes`);
            }
            return data;
          case codecimpl_1.ics23.LengthOp.FIXED32_LITTLE:
            return new Uint8Array([...encodeFixed32Le(data.length), ...data]);
        }
        throw new Error(`Unsupported lengthop: ${lengthOp}`);
      }
      function encodeVarintProto(n) {
        let enc = [];
        let l = n;
        while (l >= 128) {
          const b = l % 128 + 128;
          enc = [...enc, b];
          l = l / 128;
        }
        enc = [...enc, l];
        return new Uint8Array(enc);
      }
      function encodeFixed32Le(n) {
        const enc = new Uint8Array(4);
        let l = n;
        for (let i = enc.length; i > 0; i--) {
          enc[Math.abs(i - enc.length)] = l % 256;
          l = Math.floor(l / 256);
        }
        return enc;
      }
    }
  });

  // node_modules/@confio/ics23/build/specs.js
  var require_specs = __commonJS({
    "node_modules/@confio/ics23/build/specs.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.bytesBefore = exports2.ensureBytesBefore = exports2.bytesEqual = exports2.ensureBytesEqual = exports2.ensureInner = exports2.ensureLeaf = void 0;
      function ensureLeaf(leaf, spec) {
        if (leaf.hash !== spec.hash) {
          throw new Error(`Unexpected hashOp: ${leaf.hash}`);
        }
        if (leaf.prehashKey !== spec.prehashKey) {
          throw new Error(`Unexpected prehashKey: ${leaf.prehashKey}`);
        }
        if (leaf.prehashValue !== spec.prehashValue) {
          throw new Error(`Unexpected prehashValue: ${leaf.prehashValue}`);
        }
        if (leaf.length !== spec.length) {
          throw new Error(`Unexpected length op: ${leaf.length}`);
        }
        ensurePrefix(leaf.prefix, spec.prefix);
      }
      exports2.ensureLeaf = ensureLeaf;
      function ensureInner(inner, prefix, spec) {
        if (inner.hash !== spec.hash) {
          throw new Error(`Unexpected hashOp: ${inner.hash}`);
        }
        if (!inner.prefix) {
          throw new Error("No prefix set for inner node");
        }
        if (hasPrefix(inner.prefix, prefix)) {
          throw new Error(`Inner node has leaf prefix`);
        }
        if (inner.prefix.length < (spec.minPrefixLength || 0)) {
          throw new Error(`Prefix too short: ${inner.prefix.length} bytes`);
        }
        const maxLeftChildBytes = (spec.childOrder.length - 1) * spec.childSize;
        if (inner.prefix.length > (spec.maxPrefixLength || 0) + maxLeftChildBytes) {
          throw new Error(`Prefix too long: ${inner.prefix.length} bytes`);
        }
      }
      exports2.ensureInner = ensureInner;
      function ensurePrefix(check, prefix) {
        if (!prefix || prefix.length === 0) {
          return;
        }
        if (!check) {
          throw new Error(`Target bytes missing`);
        }
        ensureBytesEqual(prefix, check.slice(0, prefix.length));
      }
      function ensureBytesEqual(a, b) {
        if (a.length !== b.length) {
          throw new Error(`Different lengths ${a.length} vs ${b.length}`);
        }
        for (let i = 0; i < a.length; i++) {
          if (a[i] !== b[i]) {
            throw new Error(`Arrays differ at index ${i}: ${a[i]} vs ${b[i]}`);
          }
        }
      }
      exports2.ensureBytesEqual = ensureBytesEqual;
      function bytesEqual(a, b) {
        if (a.length !== b.length) {
          return false;
        }
        for (let i = 0; i < a.length; i++) {
          if (a[i] !== b[i]) {
            return false;
          }
        }
        return true;
      }
      exports2.bytesEqual = bytesEqual;
      function hasPrefix(check, prefix) {
        if (!prefix || prefix.length === 0) {
          return false;
        }
        if (!check) {
          return false;
        }
        if (check.length <= prefix.length) {
          return false;
        }
        for (let i = 0; i < prefix.length; i++) {
          if (check[i] !== prefix[i]) {
            return false;
          }
        }
        throw true;
      }
      function ensureBytesBefore(first, last) {
        if (!bytesBefore(first, last)) {
          throw new Error("first is after last");
        }
      }
      exports2.ensureBytesBefore = ensureBytesBefore;
      function bytesBefore(first, last) {
        const min = first.length < last.length ? first.length : last.length;
        for (let i = 0; i < min; i++) {
          if (first[i] < last[i]) {
            return true;
          }
          if (first[i] > last[i]) {
            return false;
          }
        }
        return first.length < last.length;
      }
      exports2.bytesBefore = bytesBefore;
    }
  });

  // node_modules/@confio/ics23/build/proofs.js
  var require_proofs = __commonJS({
    "node_modules/@confio/ics23/build/proofs.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.ensureLeftNeighbor = exports2.ensureSpec = exports2.calculateExistenceRoot = exports2.verifyNonExistence = exports2.verifyExistence = exports2.smtSpec = exports2.tendermintSpec = exports2.iavlSpec = void 0;
      var codecimpl_1 = require_codecimpl();
      var ops_1 = require_ops();
      var specs_1 = require_specs();
      exports2.iavlSpec = {
        leafSpec: {
          prefix: Uint8Array.from([0]),
          hash: codecimpl_1.ics23.HashOp.SHA256,
          prehashValue: codecimpl_1.ics23.HashOp.SHA256,
          prehashKey: codecimpl_1.ics23.HashOp.NO_HASH,
          length: codecimpl_1.ics23.LengthOp.VAR_PROTO
        },
        innerSpec: {
          childOrder: [0, 1],
          minPrefixLength: 4,
          maxPrefixLength: 12,
          childSize: 33,
          hash: codecimpl_1.ics23.HashOp.SHA256
        }
      };
      exports2.tendermintSpec = {
        leafSpec: {
          prefix: Uint8Array.from([0]),
          hash: codecimpl_1.ics23.HashOp.SHA256,
          prehashValue: codecimpl_1.ics23.HashOp.SHA256,
          prehashKey: codecimpl_1.ics23.HashOp.NO_HASH,
          length: codecimpl_1.ics23.LengthOp.VAR_PROTO
        },
        innerSpec: {
          childOrder: [0, 1],
          minPrefixLength: 1,
          maxPrefixLength: 1,
          childSize: 32,
          hash: codecimpl_1.ics23.HashOp.SHA256
        }
      };
      exports2.smtSpec = {
        leafSpec: {
          hash: codecimpl_1.ics23.HashOp.SHA256,
          prehashKey: codecimpl_1.ics23.HashOp.NO_HASH,
          prehashValue: codecimpl_1.ics23.HashOp.SHA256,
          length: codecimpl_1.ics23.LengthOp.NO_PREFIX,
          prefix: Uint8Array.from([0])
        },
        innerSpec: {
          childOrder: [0, 1],
          childSize: 32,
          minPrefixLength: 1,
          maxPrefixLength: 1,
          emptyChild: new Uint8Array(32),
          hash: codecimpl_1.ics23.HashOp.SHA256
        },
        maxDepth: 256
      };
      function verifyExistence(proof, spec, root, key, value) {
        ensureSpec(proof, spec);
        const calc = calculateExistenceRoot(proof);
        (0, specs_1.ensureBytesEqual)(calc, root);
        (0, specs_1.ensureBytesEqual)(key, proof.key);
        (0, specs_1.ensureBytesEqual)(value, proof.value);
      }
      exports2.verifyExistence = verifyExistence;
      function verifyNonExistence(proof, spec, root, key) {
        let leftKey;
        let rightKey;
        if (proof.left) {
          verifyExistence(proof.left, spec, root, proof.left.key, proof.left.value);
          leftKey = proof.left.key;
        }
        if (proof.right) {
          verifyExistence(proof.right, spec, root, proof.right.key, proof.right.value);
          rightKey = proof.right.key;
        }
        if (!leftKey && !rightKey) {
          throw new Error("neither left nor right proof defined");
        }
        if (leftKey) {
          (0, specs_1.ensureBytesBefore)(leftKey, key);
        }
        if (rightKey) {
          (0, specs_1.ensureBytesBefore)(key, rightKey);
        }
        if (!spec.innerSpec) {
          throw new Error("no inner spec");
        }
        if (!leftKey) {
          ensureLeftMost(spec.innerSpec, proof.right.path);
        } else if (!rightKey) {
          ensureRightMost(spec.innerSpec, proof.left.path);
        } else {
          ensureLeftNeighbor(spec.innerSpec, proof.left.path, proof.right.path);
        }
        return;
      }
      exports2.verifyNonExistence = verifyNonExistence;
      function calculateExistenceRoot(proof) {
        if (!proof.key || !proof.value) {
          throw new Error("Existence proof needs key and value set");
        }
        if (!proof.leaf) {
          throw new Error("Existence proof must start with a leaf operation");
        }
        const path = proof.path || [];
        let res = (0, ops_1.applyLeaf)(proof.leaf, proof.key, proof.value);
        for (const inner of path) {
          res = (0, ops_1.applyInner)(inner, res);
        }
        return res;
      }
      exports2.calculateExistenceRoot = calculateExistenceRoot;
      function ensureSpec(proof, spec) {
        if (!proof.leaf) {
          throw new Error("Existence proof must start with a leaf operation");
        }
        if (!spec.leafSpec) {
          throw new Error("Spec must include leafSpec");
        }
        if (!spec.innerSpec) {
          throw new Error("Spec must include innerSpec");
        }
        (0, specs_1.ensureLeaf)(proof.leaf, spec.leafSpec);
        const path = proof.path || [];
        if (spec.minDepth && path.length < spec.minDepth) {
          throw new Error(`Too few inner nodes ${path.length}`);
        }
        if (spec.maxDepth && path.length > spec.maxDepth) {
          throw new Error(`Too many inner nodes ${path.length}`);
        }
        for (const inner of path) {
          (0, specs_1.ensureInner)(inner, spec.leafSpec.prefix, spec.innerSpec);
        }
      }
      exports2.ensureSpec = ensureSpec;
      function ensureLeftMost(spec, path) {
        const { minPrefix, maxPrefix, suffix } = getPadding(spec, 0);
        for (const step of path) {
          if (!hasPadding(step, minPrefix, maxPrefix, suffix)) {
            throw new Error("Step not leftmost");
          }
        }
      }
      function ensureRightMost(spec, path) {
        const len = spec.childOrder.length - 1;
        const { minPrefix, maxPrefix, suffix } = getPadding(spec, len);
        for (const step of path) {
          if (!hasPadding(step, minPrefix, maxPrefix, suffix)) {
            throw new Error("Step not leftmost");
          }
        }
      }
      function ensureLeftNeighbor(spec, left, right) {
        const mutleft = [...left];
        const mutright = [...right];
        let topleft = mutleft.pop();
        let topright = mutright.pop();
        while ((0, specs_1.bytesEqual)(topleft.prefix, topright.prefix) && (0, specs_1.bytesEqual)(topleft.suffix, topright.suffix)) {
          topleft = mutleft.pop();
          topright = mutright.pop();
        }
        if (!isLeftStep(spec, topleft, topright)) {
          throw new Error(`Not left neightbor at first divergent step`);
        }
        ensureRightMost(spec, mutleft);
        ensureLeftMost(spec, mutright);
      }
      exports2.ensureLeftNeighbor = ensureLeftNeighbor;
      function isLeftStep(spec, left, right) {
        const leftidx = orderFromPadding(spec, left);
        const rightidx = orderFromPadding(spec, right);
        return rightidx === leftidx + 1;
      }
      function orderFromPadding(spec, inner) {
        for (let branch = 0; branch < spec.childOrder.length; branch++) {
          const { minPrefix, maxPrefix, suffix } = getPadding(spec, branch);
          if (hasPadding(inner, minPrefix, maxPrefix, suffix)) {
            return branch;
          }
        }
        throw new Error(`Cannot find any valid spacing for this node`);
      }
      function hasPadding(op, minPrefix, maxPrefix, suffix) {
        if ((op.prefix || []).length < minPrefix) {
          return false;
        }
        if ((op.prefix || []).length > maxPrefix) {
          return false;
        }
        return (op.suffix || []).length === suffix;
      }
      function getPadding(spec, branch) {
        const idx = getPosition(spec.childOrder, branch);
        const prefix = idx * spec.childSize;
        const minPrefix = prefix + spec.minPrefixLength;
        const maxPrefix = prefix + spec.maxPrefixLength;
        const suffix = (spec.childOrder.length - 1 - idx) * spec.childSize;
        return { minPrefix, maxPrefix, suffix };
      }
      function getPosition(order, branch) {
        if (branch < 0 || branch >= order.length) {
          throw new Error(`Invalid branch: ${branch}`);
        }
        return order.findIndex((val) => val === branch);
      }
    }
  });

  // node_modules/@confio/ics23/build/ics23.js
  var require_ics23 = __commonJS({
    "node_modules/@confio/ics23/build/ics23.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.batchVerifyNonMembership = exports2.batchVerifyMembership = exports2.verifyNonMembership = exports2.verifyMembership = void 0;
      var compress_1 = require_compress();
      var proofs_1 = require_proofs();
      var specs_1 = require_specs();
      function verifyMembership(proof, spec, root, key, value) {
        const norm = (0, compress_1.decompress)(proof);
        const exist = getExistForKey(norm, key);
        if (!exist) {
          return false;
        }
        try {
          (0, proofs_1.verifyExistence)(exist, spec, root, key, value);
          return true;
        } catch (_a) {
          return false;
        }
      }
      exports2.verifyMembership = verifyMembership;
      function verifyNonMembership(proof, spec, root, key) {
        const norm = (0, compress_1.decompress)(proof);
        const nonexist = getNonExistForKey(norm, key);
        if (!nonexist) {
          return false;
        }
        try {
          (0, proofs_1.verifyNonExistence)(nonexist, spec, root, key);
          return true;
        } catch (_a) {
          return false;
        }
      }
      exports2.verifyNonMembership = verifyNonMembership;
      function batchVerifyMembership(proof, spec, root, items) {
        const norm = (0, compress_1.decompress)(proof);
        for (const [key, value] of items.entries()) {
          if (!verifyMembership(norm, spec, root, key, value)) {
            return false;
          }
        }
        return true;
      }
      exports2.batchVerifyMembership = batchVerifyMembership;
      function batchVerifyNonMembership(proof, spec, root, keys) {
        const norm = (0, compress_1.decompress)(proof);
        for (const key of keys) {
          if (!verifyNonMembership(norm, spec, root, key)) {
            return false;
          }
        }
        return true;
      }
      exports2.batchVerifyNonMembership = batchVerifyNonMembership;
      function getExistForKey(proof, key) {
        const match = (p) => !!p && (0, specs_1.bytesEqual)(key, p.key);
        if (match(proof.exist)) {
          return proof.exist;
        } else if (proof.batch) {
          return proof.batch.entries.map((x) => x.exist || null).find(match);
        }
        return void 0;
      }
      function getNonExistForKey(proof, key) {
        const match = (p) => {
          return !!p && (!p.left || (0, specs_1.bytesBefore)(p.left.key, key)) && (!p.right || (0, specs_1.bytesBefore)(key, p.right.key));
        };
        if (match(proof.nonexist)) {
          return proof.nonexist;
        } else if (proof.batch) {
          return proof.batch.entries.map((x) => x.nonexist || null).find(match);
        }
        return void 0;
      }
    }
  });

  // node_modules/@confio/ics23/build/index.js
  var require_build7 = __commonJS({
    "node_modules/@confio/ics23/build/index.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.verifyNonExistence = exports2.verifyExistence = exports2.tendermintSpec = exports2.iavlSpec = exports2.calculateExistenceRoot = exports2.verifyNonMembership = exports2.verifyMembership = exports2.ics23 = void 0;
      var codecimpl_1 = require_codecimpl();
      Object.defineProperty(exports2, "ics23", { enumerable: true, get: function() {
        return codecimpl_1.ics23;
      } });
      var ics23_1 = require_ics23();
      Object.defineProperty(exports2, "verifyMembership", { enumerable: true, get: function() {
        return ics23_1.verifyMembership;
      } });
      Object.defineProperty(exports2, "verifyNonMembership", { enumerable: true, get: function() {
        return ics23_1.verifyNonMembership;
      } });
      var proofs_1 = require_proofs();
      Object.defineProperty(exports2, "calculateExistenceRoot", { enumerable: true, get: function() {
        return proofs_1.calculateExistenceRoot;
      } });
      Object.defineProperty(exports2, "iavlSpec", { enumerable: true, get: function() {
        return proofs_1.iavlSpec;
      } });
      Object.defineProperty(exports2, "tendermintSpec", { enumerable: true, get: function() {
        return proofs_1.tendermintSpec;
      } });
      Object.defineProperty(exports2, "verifyExistence", { enumerable: true, get: function() {
        return proofs_1.verifyExistence;
      } });
      Object.defineProperty(exports2, "verifyNonExistence", { enumerable: true, get: function() {
        return proofs_1.verifyNonExistence;
      } });
    }
  });

  // node_modules/symbol-observable/lib/ponyfill.js
  var require_ponyfill = __commonJS({
    "node_modules/symbol-observable/lib/ponyfill.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", {
        value: true
      });
      exports2["default"] = symbolObservablePonyfill;
      function symbolObservablePonyfill(root) {
        var result;
        var _Symbol = root.Symbol;
        if (typeof _Symbol === "function") {
          if (_Symbol.observable) {
            result = _Symbol.observable;
          } else {
            result = _Symbol["for"]("https://github.com/benlesh/symbol-observable");
            try {
              _Symbol.observable = result;
            } catch (err) {
            }
          }
        } else {
          result = "@@observable";
        }
        return result;
      }
    }
  });

  // node_modules/symbol-observable/ponyfill.js
  var require_ponyfill2 = __commonJS({
    "node_modules/symbol-observable/ponyfill.js"(exports2, module2) {
      module2.exports = require_ponyfill();
    }
  });

  // node_modules/object-keys/isArguments.js
  var require_isArguments = __commonJS({
    "node_modules/object-keys/isArguments.js"(exports2, module2) {
      "use strict";
      var toStr = Object.prototype.toString;
      module2.exports = function isArguments(value) {
        var str = toStr.call(value);
        var isArgs = str === "[object Arguments]";
        if (!isArgs) {
          isArgs = str !== "[object Array]" && value !== null && typeof value === "object" && typeof value.length === "number" && value.length >= 0 && toStr.call(value.callee) === "[object Function]";
        }
        return isArgs;
      };
    }
  });

  // node_modules/object-keys/implementation.js
  var require_implementation = __commonJS({
    "node_modules/object-keys/implementation.js"(exports2, module2) {
      "use strict";
      var keysShim;
      if (!Object.keys) {
        has = Object.prototype.hasOwnProperty;
        toStr = Object.prototype.toString;
        isArgs = require_isArguments();
        isEnumerable = Object.prototype.propertyIsEnumerable;
        hasDontEnumBug = !isEnumerable.call({ toString: null }, "toString");
        hasProtoEnumBug = isEnumerable.call(function() {
        }, "prototype");
        dontEnums = [
          "toString",
          "toLocaleString",
          "valueOf",
          "hasOwnProperty",
          "isPrototypeOf",
          "propertyIsEnumerable",
          "constructor"
        ];
        equalsConstructorPrototype = function(o) {
          var ctor = o.constructor;
          return ctor && ctor.prototype === o;
        };
        excludedKeys = {
          $applicationCache: true,
          $console: true,
          $external: true,
          $frame: true,
          $frameElement: true,
          $frames: true,
          $innerHeight: true,
          $innerWidth: true,
          $onmozfullscreenchange: true,
          $onmozfullscreenerror: true,
          $outerHeight: true,
          $outerWidth: true,
          $pageXOffset: true,
          $pageYOffset: true,
          $parent: true,
          $scrollLeft: true,
          $scrollTop: true,
          $scrollX: true,
          $scrollY: true,
          $self: true,
          $webkitIndexedDB: true,
          $webkitStorageInfo: true,
          $window: true
        };
        hasAutomationEqualityBug = function() {
          if (typeof window === "undefined") {
            return false;
          }
          for (var k in window) {
            try {
              if (!excludedKeys["$" + k] && has.call(window, k) && window[k] !== null && typeof window[k] === "object") {
                try {
                  equalsConstructorPrototype(window[k]);
                } catch (e) {
                  return true;
                }
              }
            } catch (e) {
              return true;
            }
          }
          return false;
        }();
        equalsConstructorPrototypeIfNotBuggy = function(o) {
          if (typeof window === "undefined" || !hasAutomationEqualityBug) {
            return equalsConstructorPrototype(o);
          }
          try {
            return equalsConstructorPrototype(o);
          } catch (e) {
            return false;
          }
        };
        keysShim = function keys(object) {
          var isObject = object !== null && typeof object === "object";
          var isFunction = toStr.call(object) === "[object Function]";
          var isArguments = isArgs(object);
          var isString = isObject && toStr.call(object) === "[object String]";
          var theKeys = [];
          if (!isObject && !isFunction && !isArguments) {
            throw new TypeError("Object.keys called on a non-object");
          }
          var skipProto = hasProtoEnumBug && isFunction;
          if (isString && object.length > 0 && !has.call(object, 0)) {
            for (var i = 0; i < object.length; ++i) {
              theKeys.push(String(i));
            }
          }
          if (isArguments && object.length > 0) {
            for (var j = 0; j < object.length; ++j) {
              theKeys.push(String(j));
            }
          } else {
            for (var name in object) {
              if (!(skipProto && name === "prototype") && has.call(object, name)) {
                theKeys.push(String(name));
              }
            }
          }
          if (hasDontEnumBug) {
            var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);
            for (var k = 0; k < dontEnums.length; ++k) {
              if (!(skipConstructor && dontEnums[k] === "constructor") && has.call(object, dontEnums[k])) {
                theKeys.push(dontEnums[k]);
              }
            }
          }
          return theKeys;
        };
      }
      var has;
      var toStr;
      var isArgs;
      var isEnumerable;
      var hasDontEnumBug;
      var hasProtoEnumBug;
      var dontEnums;
      var equalsConstructorPrototype;
      var excludedKeys;
      var hasAutomationEqualityBug;
      var equalsConstructorPrototypeIfNotBuggy;
      module2.exports = keysShim;
    }
  });

  // node_modules/object-keys/index.js
  var require_object_keys = __commonJS({
    "node_modules/object-keys/index.js"(exports2, module2) {
      "use strict";
      var slice = Array.prototype.slice;
      var isArgs = require_isArguments();
      var origKeys = Object.keys;
      var keysShim = origKeys ? function keys(o) {
        return origKeys(o);
      } : require_implementation();
      var originalKeys = Object.keys;
      keysShim.shim = function shimObjectKeys() {
        if (Object.keys) {
          var keysWorksWithArguments = function() {
            var args = Object.keys(arguments);
            return args && args.length === arguments.length;
          }(1, 2);
          if (!keysWorksWithArguments) {
            Object.keys = function keys(object) {
              if (isArgs(object)) {
                return originalKeys(slice.call(object));
              }
              return originalKeys(object);
            };
          }
        } else {
          Object.keys = keysShim;
        }
        return Object.keys || keysShim;
      };
      module2.exports = keysShim;
    }
  });

  // node_modules/define-properties/index.js
  var require_define_properties = __commonJS({
    "node_modules/define-properties/index.js"(exports2, module2) {
      "use strict";
      var keys = require_object_keys();
      var hasSymbols = typeof Symbol === "function" && typeof Symbol("foo") === "symbol";
      var toStr = Object.prototype.toString;
      var concat = Array.prototype.concat;
      var origDefineProperty = Object.defineProperty;
      var isFunction = function(fn) {
        return typeof fn === "function" && toStr.call(fn) === "[object Function]";
      };
      var arePropertyDescriptorsSupported = function() {
        var obj = {};
        try {
          origDefineProperty(obj, "x", { enumerable: false, value: obj });
          for (var _ in obj) {
            return false;
          }
          return obj.x === obj;
        } catch (e) {
          return false;
        }
      };
      var supportsDescriptors = origDefineProperty && arePropertyDescriptorsSupported();
      var defineProperty = function(object, name, value, predicate) {
        if (name in object && (!isFunction(predicate) || !predicate())) {
          return;
        }
        if (supportsDescriptors) {
          origDefineProperty(object, name, {
            configurable: true,
            enumerable: false,
            value,
            writable: true
          });
        } else {
          object[name] = value;
        }
      };
      var defineProperties = function(object, map) {
        var predicates = arguments.length > 2 ? arguments[2] : {};
        var props = keys(map);
        if (hasSymbols) {
          props = concat.call(props, Object.getOwnPropertySymbols(map));
        }
        for (var i = 0; i < props.length; i += 1) {
          defineProperty(object, props[i], map[props[i]], predicates[props[i]]);
        }
      };
      defineProperties.supportsDescriptors = !!supportsDescriptors;
      module2.exports = defineProperties;
    }
  });

  // node_modules/globalthis/implementation.browser.js
  var require_implementation_browser = __commonJS({
    "node_modules/globalthis/implementation.browser.js"(exports2, module2) {
      "use strict";
      if (typeof self !== "undefined") {
        module2.exports = self;
      } else if (typeof window !== "undefined") {
        module2.exports = window;
      } else {
        module2.exports = Function("return this")();
      }
    }
  });

  // node_modules/globalthis/polyfill.js
  var require_polyfill = __commonJS({
    "node_modules/globalthis/polyfill.js"(exports2, module2) {
      "use strict";
      var implementation = require_implementation_browser();
      module2.exports = function getPolyfill() {
        if (typeof global !== "object" || !global || global.Math !== Math || global.Array !== Array) {
          return implementation;
        }
        return global;
      };
    }
  });

  // node_modules/globalthis/shim.js
  var require_shim = __commonJS({
    "node_modules/globalthis/shim.js"(exports2, module2) {
      "use strict";
      var define2 = require_define_properties();
      var getPolyfill = require_polyfill();
      module2.exports = function shimGlobal() {
        var polyfill = getPolyfill();
        if (define2.supportsDescriptors) {
          var descriptor = Object.getOwnPropertyDescriptor(polyfill, "globalThis");
          if (!descriptor || descriptor.configurable && (descriptor.enumerable || descriptor.writable || globalThis !== polyfill)) {
            Object.defineProperty(polyfill, "globalThis", {
              configurable: true,
              enumerable: false,
              value: polyfill,
              writable: false
            });
          }
        } else if (typeof globalThis !== "object" || globalThis !== polyfill) {
          polyfill.globalThis = polyfill;
        }
        return polyfill;
      };
    }
  });

  // node_modules/globalthis/index.js
  var require_globalthis = __commonJS({
    "node_modules/globalthis/index.js"(exports2, module2) {
      "use strict";
      var defineProperties = require_define_properties();
      var implementation = require_implementation_browser();
      var getPolyfill = require_polyfill();
      var shim = require_shim();
      var polyfill = getPolyfill();
      var getGlobal = function() {
        return polyfill;
      };
      defineProperties(getGlobal, {
        getPolyfill,
        implementation,
        shim
      });
      module2.exports = getGlobal;
    }
  });

  // node_modules/xstream/index.js
  var require_xstream = __commonJS({
    "node_modules/xstream/index.js"(exports2) {
      "use strict";
      var __extends = exports2 && exports2.__extends || function() {
        var extendStatics = function(d, b) {
          extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
            d2.__proto__ = b2;
          } || function(d2, b2) {
            for (var p in b2)
              if (b2.hasOwnProperty(p))
                d2[p] = b2[p];
          };
          return extendStatics(d, b);
        };
        return function(d, b) {
          extendStatics(d, b);
          function __() {
            this.constructor = d;
          }
          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
        };
      }();
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.NO_IL = exports2.NO = exports2.MemoryStream = exports2.Stream = void 0;
      var ponyfill_1 = require_ponyfill2();
      var globalthis_1 = require_globalthis();
      var $$observable = ponyfill_1.default(globalthis_1.getPolyfill());
      var NO = {};
      exports2.NO = NO;
      function noop() {
      }
      function cp(a) {
        var l = a.length;
        var b = Array(l);
        for (var i = 0; i < l; ++i)
          b[i] = a[i];
        return b;
      }
      function and(f1, f2) {
        return function andFn(t) {
          return f1(t) && f2(t);
        };
      }
      function _try(c, t, u) {
        try {
          return c.f(t);
        } catch (e) {
          u._e(e);
          return NO;
        }
      }
      var NO_IL = {
        _n: noop,
        _e: noop,
        _c: noop
      };
      exports2.NO_IL = NO_IL;
      function internalizeProducer(producer) {
        producer._start = function _start(il) {
          il.next = il._n;
          il.error = il._e;
          il.complete = il._c;
          this.start(il);
        };
        producer._stop = producer.stop;
      }
      var StreamSub = function() {
        function StreamSub2(_stream, _listener) {
          this._stream = _stream;
          this._listener = _listener;
        }
        StreamSub2.prototype.unsubscribe = function() {
          this._stream._remove(this._listener);
        };
        return StreamSub2;
      }();
      var Observer = function() {
        function Observer2(_listener) {
          this._listener = _listener;
        }
        Observer2.prototype.next = function(value) {
          this._listener._n(value);
        };
        Observer2.prototype.error = function(err) {
          this._listener._e(err);
        };
        Observer2.prototype.complete = function() {
          this._listener._c();
        };
        return Observer2;
      }();
      var FromObservable = function() {
        function FromObservable2(observable) {
          this.type = "fromObservable";
          this.ins = observable;
          this.active = false;
        }
        FromObservable2.prototype._start = function(out) {
          this.out = out;
          this.active = true;
          this._sub = this.ins.subscribe(new Observer(out));
          if (!this.active)
            this._sub.unsubscribe();
        };
        FromObservable2.prototype._stop = function() {
          if (this._sub)
            this._sub.unsubscribe();
          this.active = false;
        };
        return FromObservable2;
      }();
      var Merge = function() {
        function Merge2(insArr) {
          this.type = "merge";
          this.insArr = insArr;
          this.out = NO;
          this.ac = 0;
        }
        Merge2.prototype._start = function(out) {
          this.out = out;
          var s = this.insArr;
          var L = s.length;
          this.ac = L;
          for (var i = 0; i < L; i++)
            s[i]._add(this);
        };
        Merge2.prototype._stop = function() {
          var s = this.insArr;
          var L = s.length;
          for (var i = 0; i < L; i++)
            s[i]._remove(this);
          this.out = NO;
        };
        Merge2.prototype._n = function(t) {
          var u = this.out;
          if (u === NO)
            return;
          u._n(t);
        };
        Merge2.prototype._e = function(err) {
          var u = this.out;
          if (u === NO)
            return;
          u._e(err);
        };
        Merge2.prototype._c = function() {
          if (--this.ac <= 0) {
            var u = this.out;
            if (u === NO)
              return;
            u._c();
          }
        };
        return Merge2;
      }();
      var CombineListener = function() {
        function CombineListener2(i, out, p) {
          this.i = i;
          this.out = out;
          this.p = p;
          p.ils.push(this);
        }
        CombineListener2.prototype._n = function(t) {
          var p = this.p, out = this.out;
          if (out === NO)
            return;
          if (p.up(t, this.i)) {
            var b = cp(p.vals);
            out._n(b);
          }
        };
        CombineListener2.prototype._e = function(err) {
          var out = this.out;
          if (out === NO)
            return;
          out._e(err);
        };
        CombineListener2.prototype._c = function() {
          var p = this.p;
          if (p.out === NO)
            return;
          if (--p.Nc === 0)
            p.out._c();
        };
        return CombineListener2;
      }();
      var Combine = function() {
        function Combine2(insArr) {
          this.type = "combine";
          this.insArr = insArr;
          this.out = NO;
          this.ils = [];
          this.Nc = this.Nn = 0;
          this.vals = [];
        }
        Combine2.prototype.up = function(t, i) {
          var v = this.vals[i];
          var Nn = !this.Nn ? 0 : v === NO ? --this.Nn : this.Nn;
          this.vals[i] = t;
          return Nn === 0;
        };
        Combine2.prototype._start = function(out) {
          this.out = out;
          var s = this.insArr;
          var n = this.Nc = this.Nn = s.length;
          var vals = this.vals = new Array(n);
          if (n === 0) {
            out._n([]);
            out._c();
          } else {
            for (var i = 0; i < n; i++) {
              vals[i] = NO;
              s[i]._add(new CombineListener(i, out, this));
            }
          }
        };
        Combine2.prototype._stop = function() {
          var s = this.insArr;
          var n = s.length;
          var ils = this.ils;
          for (var i = 0; i < n; i++)
            s[i]._remove(ils[i]);
          this.out = NO;
          this.ils = [];
          this.vals = [];
        };
        return Combine2;
      }();
      var FromArray = function() {
        function FromArray2(a) {
          this.type = "fromArray";
          this.a = a;
        }
        FromArray2.prototype._start = function(out) {
          var a = this.a;
          for (var i = 0, n = a.length; i < n; i++)
            out._n(a[i]);
          out._c();
        };
        FromArray2.prototype._stop = function() {
        };
        return FromArray2;
      }();
      var FromPromise = function() {
        function FromPromise2(p) {
          this.type = "fromPromise";
          this.on = false;
          this.p = p;
        }
        FromPromise2.prototype._start = function(out) {
          var prod = this;
          this.on = true;
          this.p.then(function(v) {
            if (prod.on) {
              out._n(v);
              out._c();
            }
          }, function(e) {
            out._e(e);
          }).then(noop, function(err) {
            setTimeout(function() {
              throw err;
            });
          });
        };
        FromPromise2.prototype._stop = function() {
          this.on = false;
        };
        return FromPromise2;
      }();
      var Periodic = function() {
        function Periodic2(period) {
          this.type = "periodic";
          this.period = period;
          this.intervalID = -1;
          this.i = 0;
        }
        Periodic2.prototype._start = function(out) {
          var self2 = this;
          function intervalHandler() {
            out._n(self2.i++);
          }
          this.intervalID = setInterval(intervalHandler, this.period);
        };
        Periodic2.prototype._stop = function() {
          if (this.intervalID !== -1)
            clearInterval(this.intervalID);
          this.intervalID = -1;
          this.i = 0;
        };
        return Periodic2;
      }();
      var Debug = function() {
        function Debug2(ins, arg) {
          this.type = "debug";
          this.ins = ins;
          this.out = NO;
          this.s = noop;
          this.l = "";
          if (typeof arg === "string")
            this.l = arg;
          else if (typeof arg === "function")
            this.s = arg;
        }
        Debug2.prototype._start = function(out) {
          this.out = out;
          this.ins._add(this);
        };
        Debug2.prototype._stop = function() {
          this.ins._remove(this);
          this.out = NO;
        };
        Debug2.prototype._n = function(t) {
          var u = this.out;
          if (u === NO)
            return;
          var s = this.s, l = this.l;
          if (s !== noop) {
            try {
              s(t);
            } catch (e) {
              u._e(e);
            }
          } else if (l)
            console.log(l + ":", t);
          else
            console.log(t);
          u._n(t);
        };
        Debug2.prototype._e = function(err) {
          var u = this.out;
          if (u === NO)
            return;
          u._e(err);
        };
        Debug2.prototype._c = function() {
          var u = this.out;
          if (u === NO)
            return;
          u._c();
        };
        return Debug2;
      }();
      var Drop = function() {
        function Drop2(max, ins) {
          this.type = "drop";
          this.ins = ins;
          this.out = NO;
          this.max = max;
          this.dropped = 0;
        }
        Drop2.prototype._start = function(out) {
          this.out = out;
          this.dropped = 0;
          this.ins._add(this);
        };
        Drop2.prototype._stop = function() {
          this.ins._remove(this);
          this.out = NO;
        };
        Drop2.prototype._n = function(t) {
          var u = this.out;
          if (u === NO)
            return;
          if (this.dropped++ >= this.max)
            u._n(t);
        };
        Drop2.prototype._e = function(err) {
          var u = this.out;
          if (u === NO)
            return;
          u._e(err);
        };
        Drop2.prototype._c = function() {
          var u = this.out;
          if (u === NO)
            return;
          u._c();
        };
        return Drop2;
      }();
      var EndWhenListener = function() {
        function EndWhenListener2(out, op) {
          this.out = out;
          this.op = op;
        }
        EndWhenListener2.prototype._n = function() {
          this.op.end();
        };
        EndWhenListener2.prototype._e = function(err) {
          this.out._e(err);
        };
        EndWhenListener2.prototype._c = function() {
          this.op.end();
        };
        return EndWhenListener2;
      }();
      var EndWhen = function() {
        function EndWhen2(o, ins) {
          this.type = "endWhen";
          this.ins = ins;
          this.out = NO;
          this.o = o;
          this.oil = NO_IL;
        }
        EndWhen2.prototype._start = function(out) {
          this.out = out;
          this.o._add(this.oil = new EndWhenListener(out, this));
          this.ins._add(this);
        };
        EndWhen2.prototype._stop = function() {
          this.ins._remove(this);
          this.o._remove(this.oil);
          this.out = NO;
          this.oil = NO_IL;
        };
        EndWhen2.prototype.end = function() {
          var u = this.out;
          if (u === NO)
            return;
          u._c();
        };
        EndWhen2.prototype._n = function(t) {
          var u = this.out;
          if (u === NO)
            return;
          u._n(t);
        };
        EndWhen2.prototype._e = function(err) {
          var u = this.out;
          if (u === NO)
            return;
          u._e(err);
        };
        EndWhen2.prototype._c = function() {
          this.end();
        };
        return EndWhen2;
      }();
      var Filter = function() {
        function Filter2(passes, ins) {
          this.type = "filter";
          this.ins = ins;
          this.out = NO;
          this.f = passes;
        }
        Filter2.prototype._start = function(out) {
          this.out = out;
          this.ins._add(this);
        };
        Filter2.prototype._stop = function() {
          this.ins._remove(this);
          this.out = NO;
        };
        Filter2.prototype._n = function(t) {
          var u = this.out;
          if (u === NO)
            return;
          var r = _try(this, t, u);
          if (r === NO || !r)
            return;
          u._n(t);
        };
        Filter2.prototype._e = function(err) {
          var u = this.out;
          if (u === NO)
            return;
          u._e(err);
        };
        Filter2.prototype._c = function() {
          var u = this.out;
          if (u === NO)
            return;
          u._c();
        };
        return Filter2;
      }();
      var FlattenListener = function() {
        function FlattenListener2(out, op) {
          this.out = out;
          this.op = op;
        }
        FlattenListener2.prototype._n = function(t) {
          this.out._n(t);
        };
        FlattenListener2.prototype._e = function(err) {
          this.out._e(err);
        };
        FlattenListener2.prototype._c = function() {
          this.op.inner = NO;
          this.op.less();
        };
        return FlattenListener2;
      }();
      var Flatten = function() {
        function Flatten2(ins) {
          this.type = "flatten";
          this.ins = ins;
          this.out = NO;
          this.open = true;
          this.inner = NO;
          this.il = NO_IL;
        }
        Flatten2.prototype._start = function(out) {
          this.out = out;
          this.open = true;
          this.inner = NO;
          this.il = NO_IL;
          this.ins._add(this);
        };
        Flatten2.prototype._stop = function() {
          this.ins._remove(this);
          if (this.inner !== NO)
            this.inner._remove(this.il);
          this.out = NO;
          this.open = true;
          this.inner = NO;
          this.il = NO_IL;
        };
        Flatten2.prototype.less = function() {
          var u = this.out;
          if (u === NO)
            return;
          if (!this.open && this.inner === NO)
            u._c();
        };
        Flatten2.prototype._n = function(s) {
          var u = this.out;
          if (u === NO)
            return;
          var _a = this, inner = _a.inner, il = _a.il;
          if (inner !== NO && il !== NO_IL)
            inner._remove(il);
          (this.inner = s)._add(this.il = new FlattenListener(u, this));
        };
        Flatten2.prototype._e = function(err) {
          var u = this.out;
          if (u === NO)
            return;
          u._e(err);
        };
        Flatten2.prototype._c = function() {
          this.open = false;
          this.less();
        };
        return Flatten2;
      }();
      var Fold = function() {
        function Fold2(f, seed, ins) {
          var _this = this;
          this.type = "fold";
          this.ins = ins;
          this.out = NO;
          this.f = function(t) {
            return f(_this.acc, t);
          };
          this.acc = this.seed = seed;
        }
        Fold2.prototype._start = function(out) {
          this.out = out;
          this.acc = this.seed;
          out._n(this.acc);
          this.ins._add(this);
        };
        Fold2.prototype._stop = function() {
          this.ins._remove(this);
          this.out = NO;
          this.acc = this.seed;
        };
        Fold2.prototype._n = function(t) {
          var u = this.out;
          if (u === NO)
            return;
          var r = _try(this, t, u);
          if (r === NO)
            return;
          u._n(this.acc = r);
        };
        Fold2.prototype._e = function(err) {
          var u = this.out;
          if (u === NO)
            return;
          u._e(err);
        };
        Fold2.prototype._c = function() {
          var u = this.out;
          if (u === NO)
            return;
          u._c();
        };
        return Fold2;
      }();
      var Last = function() {
        function Last2(ins) {
          this.type = "last";
          this.ins = ins;
          this.out = NO;
          this.has = false;
          this.val = NO;
        }
        Last2.prototype._start = function(out) {
          this.out = out;
          this.has = false;
          this.ins._add(this);
        };
        Last2.prototype._stop = function() {
          this.ins._remove(this);
          this.out = NO;
          this.val = NO;
        };
        Last2.prototype._n = function(t) {
          this.has = true;
          this.val = t;
        };
        Last2.prototype._e = function(err) {
          var u = this.out;
          if (u === NO)
            return;
          u._e(err);
        };
        Last2.prototype._c = function() {
          var u = this.out;
          if (u === NO)
            return;
          if (this.has) {
            u._n(this.val);
            u._c();
          } else
            u._e(new Error("last() failed because input stream completed"));
        };
        return Last2;
      }();
      var MapOp = function() {
        function MapOp2(project, ins) {
          this.type = "map";
          this.ins = ins;
          this.out = NO;
          this.f = project;
        }
        MapOp2.prototype._start = function(out) {
          this.out = out;
          this.ins._add(this);
        };
        MapOp2.prototype._stop = function() {
          this.ins._remove(this);
          this.out = NO;
        };
        MapOp2.prototype._n = function(t) {
          var u = this.out;
          if (u === NO)
            return;
          var r = _try(this, t, u);
          if (r === NO)
            return;
          u._n(r);
        };
        MapOp2.prototype._e = function(err) {
          var u = this.out;
          if (u === NO)
            return;
          u._e(err);
        };
        MapOp2.prototype._c = function() {
          var u = this.out;
          if (u === NO)
            return;
          u._c();
        };
        return MapOp2;
      }();
      var Remember = function() {
        function Remember2(ins) {
          this.type = "remember";
          this.ins = ins;
          this.out = NO;
        }
        Remember2.prototype._start = function(out) {
          this.out = out;
          this.ins._add(out);
        };
        Remember2.prototype._stop = function() {
          this.ins._remove(this.out);
          this.out = NO;
        };
        return Remember2;
      }();
      var ReplaceError = function() {
        function ReplaceError2(replacer, ins) {
          this.type = "replaceError";
          this.ins = ins;
          this.out = NO;
          this.f = replacer;
        }
        ReplaceError2.prototype._start = function(out) {
          this.out = out;
          this.ins._add(this);
        };
        ReplaceError2.prototype._stop = function() {
          this.ins._remove(this);
          this.out = NO;
        };
        ReplaceError2.prototype._n = function(t) {
          var u = this.out;
          if (u === NO)
            return;
          u._n(t);
        };
        ReplaceError2.prototype._e = function(err) {
          var u = this.out;
          if (u === NO)
            return;
          try {
            this.ins._remove(this);
            (this.ins = this.f(err))._add(this);
          } catch (e) {
            u._e(e);
          }
        };
        ReplaceError2.prototype._c = function() {
          var u = this.out;
          if (u === NO)
            return;
          u._c();
        };
        return ReplaceError2;
      }();
      var StartWith = function() {
        function StartWith2(ins, val) {
          this.type = "startWith";
          this.ins = ins;
          this.out = NO;
          this.val = val;
        }
        StartWith2.prototype._start = function(out) {
          this.out = out;
          this.out._n(this.val);
          this.ins._add(out);
        };
        StartWith2.prototype._stop = function() {
          this.ins._remove(this.out);
          this.out = NO;
        };
        return StartWith2;
      }();
      var Take = function() {
        function Take2(max, ins) {
          this.type = "take";
          this.ins = ins;
          this.out = NO;
          this.max = max;
          this.taken = 0;
        }
        Take2.prototype._start = function(out) {
          this.out = out;
          this.taken = 0;
          if (this.max <= 0)
            out._c();
          else
            this.ins._add(this);
        };
        Take2.prototype._stop = function() {
          this.ins._remove(this);
          this.out = NO;
        };
        Take2.prototype._n = function(t) {
          var u = this.out;
          if (u === NO)
            return;
          var m = ++this.taken;
          if (m < this.max)
            u._n(t);
          else if (m === this.max) {
            u._n(t);
            u._c();
          }
        };
        Take2.prototype._e = function(err) {
          var u = this.out;
          if (u === NO)
            return;
          u._e(err);
        };
        Take2.prototype._c = function() {
          var u = this.out;
          if (u === NO)
            return;
          u._c();
        };
        return Take2;
      }();
      var Stream = function() {
        function Stream2(producer) {
          this._prod = producer || NO;
          this._ils = [];
          this._stopID = NO;
          this._dl = NO;
          this._d = false;
          this._target = null;
          this._err = NO;
        }
        Stream2.prototype._n = function(t) {
          var a = this._ils;
          var L = a.length;
          if (this._d)
            this._dl._n(t);
          if (L == 1)
            a[0]._n(t);
          else if (L == 0)
            return;
          else {
            var b = cp(a);
            for (var i = 0; i < L; i++)
              b[i]._n(t);
          }
        };
        Stream2.prototype._e = function(err) {
          if (this._err !== NO)
            return;
          this._err = err;
          var a = this._ils;
          var L = a.length;
          this._x();
          if (this._d)
            this._dl._e(err);
          if (L == 1)
            a[0]._e(err);
          else if (L == 0)
            return;
          else {
            var b = cp(a);
            for (var i = 0; i < L; i++)
              b[i]._e(err);
          }
          if (!this._d && L == 0)
            throw this._err;
        };
        Stream2.prototype._c = function() {
          var a = this._ils;
          var L = a.length;
          this._x();
          if (this._d)
            this._dl._c();
          if (L == 1)
            a[0]._c();
          else if (L == 0)
            return;
          else {
            var b = cp(a);
            for (var i = 0; i < L; i++)
              b[i]._c();
          }
        };
        Stream2.prototype._x = function() {
          if (this._ils.length === 0)
            return;
          if (this._prod !== NO)
            this._prod._stop();
          this._err = NO;
          this._ils = [];
        };
        Stream2.prototype._stopNow = function() {
          this._prod._stop();
          this._err = NO;
          this._stopID = NO;
        };
        Stream2.prototype._add = function(il) {
          var ta = this._target;
          if (ta)
            return ta._add(il);
          var a = this._ils;
          a.push(il);
          if (a.length > 1)
            return;
          if (this._stopID !== NO) {
            clearTimeout(this._stopID);
            this._stopID = NO;
          } else {
            var p = this._prod;
            if (p !== NO)
              p._start(this);
          }
        };
        Stream2.prototype._remove = function(il) {
          var _this = this;
          var ta = this._target;
          if (ta)
            return ta._remove(il);
          var a = this._ils;
          var i = a.indexOf(il);
          if (i > -1) {
            a.splice(i, 1);
            if (this._prod !== NO && a.length <= 0) {
              this._err = NO;
              this._stopID = setTimeout(function() {
                return _this._stopNow();
              });
            } else if (a.length === 1) {
              this._pruneCycles();
            }
          }
        };
        Stream2.prototype._pruneCycles = function() {
          if (this._hasNoSinks(this, []))
            this._remove(this._ils[0]);
        };
        Stream2.prototype._hasNoSinks = function(x, trace) {
          if (trace.indexOf(x) !== -1)
            return true;
          else if (x.out === this)
            return true;
          else if (x.out && x.out !== NO)
            return this._hasNoSinks(x.out, trace.concat(x));
          else if (x._ils) {
            for (var i = 0, N = x._ils.length; i < N; i++)
              if (!this._hasNoSinks(x._ils[i], trace.concat(x)))
                return false;
            return true;
          } else
            return false;
        };
        Stream2.prototype.ctor = function() {
          return this instanceof MemoryStream ? MemoryStream : Stream2;
        };
        Stream2.prototype.addListener = function(listener) {
          listener._n = listener.next || noop;
          listener._e = listener.error || noop;
          listener._c = listener.complete || noop;
          this._add(listener);
        };
        Stream2.prototype.removeListener = function(listener) {
          this._remove(listener);
        };
        Stream2.prototype.subscribe = function(listener) {
          this.addListener(listener);
          return new StreamSub(this, listener);
        };
        Stream2.prototype[$$observable] = function() {
          return this;
        };
        Stream2.create = function(producer) {
          if (producer) {
            if (typeof producer.start !== "function" || typeof producer.stop !== "function")
              throw new Error("producer requires both start and stop functions");
            internalizeProducer(producer);
          }
          return new Stream2(producer);
        };
        Stream2.createWithMemory = function(producer) {
          if (producer)
            internalizeProducer(producer);
          return new MemoryStream(producer);
        };
        Stream2.never = function() {
          return new Stream2({ _start: noop, _stop: noop });
        };
        Stream2.empty = function() {
          return new Stream2({
            _start: function(il) {
              il._c();
            },
            _stop: noop
          });
        };
        Stream2.throw = function(error) {
          return new Stream2({
            _start: function(il) {
              il._e(error);
            },
            _stop: noop
          });
        };
        Stream2.from = function(input) {
          if (typeof input[$$observable] === "function")
            return Stream2.fromObservable(input);
          else if (typeof input.then === "function")
            return Stream2.fromPromise(input);
          else if (Array.isArray(input))
            return Stream2.fromArray(input);
          throw new TypeError("Type of input to from() must be an Array, Promise, or Observable");
        };
        Stream2.of = function() {
          var items = [];
          for (var _i = 0; _i < arguments.length; _i++) {
            items[_i] = arguments[_i];
          }
          return Stream2.fromArray(items);
        };
        Stream2.fromArray = function(array) {
          return new Stream2(new FromArray(array));
        };
        Stream2.fromPromise = function(promise) {
          return new Stream2(new FromPromise(promise));
        };
        Stream2.fromObservable = function(obs) {
          if (obs.endWhen !== void 0)
            return obs;
          var o = typeof obs[$$observable] === "function" ? obs[$$observable]() : obs;
          return new Stream2(new FromObservable(o));
        };
        Stream2.periodic = function(period) {
          return new Stream2(new Periodic(period));
        };
        Stream2.prototype._map = function(project) {
          return new (this.ctor())(new MapOp(project, this));
        };
        Stream2.prototype.map = function(project) {
          return this._map(project);
        };
        Stream2.prototype.mapTo = function(projectedValue) {
          var s = this.map(function() {
            return projectedValue;
          });
          var op = s._prod;
          op.type = "mapTo";
          return s;
        };
        Stream2.prototype.filter = function(passes) {
          var p = this._prod;
          if (p instanceof Filter)
            return new Stream2(new Filter(and(p.f, passes), p.ins));
          return new Stream2(new Filter(passes, this));
        };
        Stream2.prototype.take = function(amount) {
          return new (this.ctor())(new Take(amount, this));
        };
        Stream2.prototype.drop = function(amount) {
          return new Stream2(new Drop(amount, this));
        };
        Stream2.prototype.last = function() {
          return new Stream2(new Last(this));
        };
        Stream2.prototype.startWith = function(initial) {
          return new MemoryStream(new StartWith(this, initial));
        };
        Stream2.prototype.endWhen = function(other) {
          return new (this.ctor())(new EndWhen(other, this));
        };
        Stream2.prototype.fold = function(accumulate, seed) {
          return new MemoryStream(new Fold(accumulate, seed, this));
        };
        Stream2.prototype.replaceError = function(replace) {
          return new (this.ctor())(new ReplaceError(replace, this));
        };
        Stream2.prototype.flatten = function() {
          return new Stream2(new Flatten(this));
        };
        Stream2.prototype.compose = function(operator) {
          return operator(this);
        };
        Stream2.prototype.remember = function() {
          return new MemoryStream(new Remember(this));
        };
        Stream2.prototype.debug = function(labelOrSpy) {
          return new (this.ctor())(new Debug(this, labelOrSpy));
        };
        Stream2.prototype.imitate = function(target) {
          if (target instanceof MemoryStream)
            throw new Error("A MemoryStream was given to imitate(), but it only supports a Stream. Read more about this restriction here: https://github.com/staltz/xstream#faq");
          this._target = target;
          for (var ils = this._ils, N = ils.length, i = 0; i < N; i++)
            target._add(ils[i]);
          this._ils = [];
        };
        Stream2.prototype.shamefullySendNext = function(value) {
          this._n(value);
        };
        Stream2.prototype.shamefullySendError = function(error) {
          this._e(error);
        };
        Stream2.prototype.shamefullySendComplete = function() {
          this._c();
        };
        Stream2.prototype.setDebugListener = function(listener) {
          if (!listener) {
            this._d = false;
            this._dl = NO;
          } else {
            this._d = true;
            listener._n = listener.next || noop;
            listener._e = listener.error || noop;
            listener._c = listener.complete || noop;
            this._dl = listener;
          }
        };
        Stream2.merge = function merge() {
          var streams = [];
          for (var _i = 0; _i < arguments.length; _i++) {
            streams[_i] = arguments[_i];
          }
          return new Stream2(new Merge(streams));
        };
        Stream2.combine = function combine() {
          var streams = [];
          for (var _i = 0; _i < arguments.length; _i++) {
            streams[_i] = arguments[_i];
          }
          return new Stream2(new Combine(streams));
        };
        return Stream2;
      }();
      exports2.Stream = Stream;
      var MemoryStream = function(_super) {
        __extends(MemoryStream2, _super);
        function MemoryStream2(producer) {
          var _this = _super.call(this, producer) || this;
          _this._has = false;
          return _this;
        }
        MemoryStream2.prototype._n = function(x) {
          this._v = x;
          this._has = true;
          _super.prototype._n.call(this, x);
        };
        MemoryStream2.prototype._add = function(il) {
          var ta = this._target;
          if (ta)
            return ta._add(il);
          var a = this._ils;
          a.push(il);
          if (a.length > 1) {
            if (this._has)
              il._n(this._v);
            return;
          }
          if (this._stopID !== NO) {
            if (this._has)
              il._n(this._v);
            clearTimeout(this._stopID);
            this._stopID = NO;
          } else if (this._has)
            il._n(this._v);
          else {
            var p = this._prod;
            if (p !== NO)
              p._start(this);
          }
        };
        MemoryStream2.prototype._stopNow = function() {
          this._has = false;
          _super.prototype._stopNow.call(this);
        };
        MemoryStream2.prototype._x = function() {
          this._has = false;
          _super.prototype._x.call(this);
        };
        MemoryStream2.prototype.map = function(project) {
          return this._map(project);
        };
        MemoryStream2.prototype.mapTo = function(projectedValue) {
          return _super.prototype.mapTo.call(this, projectedValue);
        };
        MemoryStream2.prototype.take = function(amount) {
          return _super.prototype.take.call(this, amount);
        };
        MemoryStream2.prototype.endWhen = function(other) {
          return _super.prototype.endWhen.call(this, other);
        };
        MemoryStream2.prototype.replaceError = function(replace) {
          return _super.prototype.replaceError.call(this, replace);
        };
        MemoryStream2.prototype.remember = function() {
          return this;
        };
        MemoryStream2.prototype.debug = function(labelOrSpy) {
          return _super.prototype.debug.call(this, labelOrSpy);
        };
        return MemoryStream2;
      }(Stream);
      exports2.MemoryStream = MemoryStream;
      var xs = Stream;
      exports2.default = xs;
    }
  });

  // node_modules/@cosmjs/stream/build/concat.js
  var require_concat = __commonJS({
    "node_modules/@cosmjs/stream/build/concat.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.concat = void 0;
      var xstream_1 = require_xstream();
      function concat(...streams) {
        const subscriptions = new Array();
        const queues = new Array();
        const completedStreams = /* @__PURE__ */ new Set();
        let activeStreamIndex = 0;
        function reset() {
          while (subscriptions.length > 0) {
            const subscription = subscriptions.shift();
            subscription.unsubscribe();
          }
          queues.length = 0;
          completedStreams.clear();
          activeStreamIndex = 0;
        }
        const producer = {
          start: (listener) => {
            streams.forEach((_) => queues.push([]));
            function emitAllQueuesEvents(streamIndex) {
              while (true) {
                const element = queues[streamIndex].shift();
                if (element === void 0) {
                  return;
                }
                listener.next(element);
              }
            }
            function isDone() {
              return activeStreamIndex >= streams.length;
            }
            if (isDone()) {
              listener.complete();
              return;
            }
            streams.forEach((stream, index) => {
              subscriptions.push(stream.subscribe({
                next: (value) => {
                  if (index === activeStreamIndex) {
                    listener.next(value);
                  } else {
                    queues[index].push(value);
                  }
                },
                complete: () => {
                  completedStreams.add(index);
                  while (completedStreams.has(activeStreamIndex)) {
                    emitAllQueuesEvents(activeStreamIndex);
                    activeStreamIndex++;
                  }
                  if (isDone()) {
                    listener.complete();
                  } else {
                    emitAllQueuesEvents(activeStreamIndex);
                  }
                },
                error: (error) => {
                  listener.error(error);
                  reset();
                }
              }));
            });
          },
          stop: () => {
            reset();
          }
        };
        return xstream_1.Stream.create(producer);
      }
      exports2.concat = concat;
    }
  });

  // node_modules/@cosmjs/stream/build/defaultvalueproducer.js
  var require_defaultvalueproducer = __commonJS({
    "node_modules/@cosmjs/stream/build/defaultvalueproducer.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.DefaultValueProducer = void 0;
      var DefaultValueProducer = class {
        constructor(value, callbacks) {
          this.callbacks = callbacks;
          this.internalValue = value;
        }
        get value() {
          return this.internalValue;
        }
        update(value) {
          this.internalValue = value;
          if (this.listener) {
            this.listener.next(value);
          }
        }
        error(error) {
          if (this.listener) {
            this.listener.error(error);
          }
        }
        start(listener) {
          this.listener = listener;
          listener.next(this.internalValue);
          if (this.callbacks) {
            this.callbacks.onStarted();
          }
        }
        stop() {
          if (this.callbacks) {
            this.callbacks.onStop();
          }
          this.listener = void 0;
        }
      };
      exports2.DefaultValueProducer = DefaultValueProducer;
    }
  });

  // node_modules/@cosmjs/stream/build/dropduplicates.js
  var require_dropduplicates = __commonJS({
    "node_modules/@cosmjs/stream/build/dropduplicates.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.dropDuplicates = void 0;
      function dropDuplicates(valueToKey) {
        const operand = (instream) => {
          const emittedKeys = /* @__PURE__ */ new Set();
          const deduplicatedStream = instream.filter((value) => !emittedKeys.has(valueToKey(value))).debug((value) => emittedKeys.add(valueToKey(value)));
          return deduplicatedStream;
        };
        return operand;
      }
      exports2.dropDuplicates = dropDuplicates;
    }
  });

  // node_modules/@cosmjs/stream/build/promise.js
  var require_promise = __commonJS({
    "node_modules/@cosmjs/stream/build/promise.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.firstEvent = exports2.toListPromise = exports2.fromListPromise = void 0;
      var xstream_1 = require_xstream();
      function fromListPromise(promise) {
        const producer = {
          start: (listener) => {
            promise.then((iterable) => {
              for (const element of iterable) {
                listener.next(element);
              }
              listener.complete();
            }).catch((error) => listener.error(error));
          },
          stop: () => {
          }
        };
        return xstream_1.Stream.create(producer);
      }
      exports2.fromListPromise = fromListPromise;
      async function toListPromise(stream, count) {
        return new Promise((resolve, reject) => {
          if (count === 0) {
            resolve([]);
            return;
          }
          const events = new Array();
          stream.take(count).subscribe({
            next: (event) => {
              events.push(event);
              if (events.length === count) {
                resolve(events);
              }
            },
            complete: () => {
              reject(`Stream completed before all events could be collected. Collected ${events.length}, expected ${count}`);
            },
            error: (error) => reject(error)
          });
        });
      }
      exports2.toListPromise = toListPromise;
      async function firstEvent(stream) {
        return (await toListPromise(stream, 1))[0];
      }
      exports2.firstEvent = firstEvent;
    }
  });

  // node_modules/@cosmjs/stream/build/reducer.js
  var require_reducer = __commonJS({
    "node_modules/@cosmjs/stream/build/reducer.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.lastValue = exports2.asArray = exports2.countStream = exports2.Reducer = void 0;
      var Reducer = class {
        constructor(stream, reducer, initState) {
          this.stream = stream;
          this.reducer = reducer;
          this.state = initState;
          this.completed = new Promise((resolve, reject) => {
            const subscription = this.stream.subscribe({
              next: (evt) => {
                this.state = this.reducer(this.state, evt);
              },
              complete: () => {
                resolve();
                subscription.unsubscribe();
              },
              error: (err) => {
                reject(err);
                subscription.unsubscribe();
              }
            });
          });
        }
        value() {
          return this.state;
        }
        async finished() {
          return this.completed;
        }
      };
      exports2.Reducer = Reducer;
      function increment(sum, _) {
        return sum + 1;
      }
      function countStream(stream) {
        return new Reducer(stream, increment, 0);
      }
      exports2.countStream = countStream;
      function append(list, evt) {
        return [...list, evt];
      }
      function asArray(stream) {
        return new Reducer(stream, append, []);
      }
      exports2.asArray = asArray;
      function last(_, event) {
        return event;
      }
      function lastValue(stream) {
        return new Reducer(stream, last, void 0);
      }
      exports2.lastValue = lastValue;
    }
  });

  // node_modules/@cosmjs/stream/build/valueandupdates.js
  var require_valueandupdates = __commonJS({
    "node_modules/@cosmjs/stream/build/valueandupdates.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.ValueAndUpdates = void 0;
      var xstream_1 = require_xstream();
      var ValueAndUpdates = class {
        constructor(producer) {
          this.producer = producer;
          this.updates = xstream_1.MemoryStream.createWithMemory(this.producer);
        }
        get value() {
          return this.producer.value;
        }
        async waitFor(search) {
          const searchImplementation = typeof search === "function" ? search : (value) => value === search;
          return new Promise((resolve, reject) => {
            const subscription = this.updates.subscribe({
              next: (newValue) => {
                if (searchImplementation(newValue)) {
                  resolve(newValue);
                  setTimeout(() => subscription.unsubscribe(), 0);
                }
              },
              complete: () => {
                subscription.unsubscribe();
                reject("Update stream completed without expected value");
              },
              error: (error) => {
                reject(error);
              }
            });
          });
        }
      };
      exports2.ValueAndUpdates = ValueAndUpdates;
    }
  });

  // node_modules/@cosmjs/stream/build/index.js
  var require_build8 = __commonJS({
    "node_modules/@cosmjs/stream/build/index.js"(exports2) {
      "use strict";
      var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
        if (k2 === void 0)
          k2 = k;
        Object.defineProperty(o, k2, { enumerable: true, get: function() {
          return m[k];
        } });
      } : function(o, m, k, k2) {
        if (k2 === void 0)
          k2 = k;
        o[k2] = m[k];
      });
      var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
        for (var p in m)
          if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p))
            __createBinding(exports3, m, p);
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.ValueAndUpdates = exports2.toListPromise = exports2.fromListPromise = exports2.firstEvent = exports2.dropDuplicates = exports2.DefaultValueProducer = exports2.concat = void 0;
      var concat_1 = require_concat();
      Object.defineProperty(exports2, "concat", { enumerable: true, get: function() {
        return concat_1.concat;
      } });
      var defaultvalueproducer_1 = require_defaultvalueproducer();
      Object.defineProperty(exports2, "DefaultValueProducer", { enumerable: true, get: function() {
        return defaultvalueproducer_1.DefaultValueProducer;
      } });
      var dropduplicates_1 = require_dropduplicates();
      Object.defineProperty(exports2, "dropDuplicates", { enumerable: true, get: function() {
        return dropduplicates_1.dropDuplicates;
      } });
      var promise_1 = require_promise();
      Object.defineProperty(exports2, "firstEvent", { enumerable: true, get: function() {
        return promise_1.firstEvent;
      } });
      Object.defineProperty(exports2, "fromListPromise", { enumerable: true, get: function() {
        return promise_1.fromListPromise;
      } });
      Object.defineProperty(exports2, "toListPromise", { enumerable: true, get: function() {
        return promise_1.toListPromise;
      } });
      __exportStar(require_reducer(), exports2);
      var valueandupdates_1 = require_valueandupdates();
      Object.defineProperty(exports2, "ValueAndUpdates", { enumerable: true, get: function() {
        return valueandupdates_1.ValueAndUpdates;
      } });
    }
  });

  // node_modules/@cosmjs/stargate/build/queryclient/queryclient.js
  var require_queryclient = __commonJS({
    "node_modules/@cosmjs/stargate/build/queryclient/queryclient.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.QueryClient = void 0;
      var ics23_1 = require_build7();
      var encoding_1 = require_build2();
      var stream_1 = require_build8();
      var utils_1 = require_build3();
      function checkAndParseOp(op, kind, key) {
        if (op.type !== kind) {
          throw new Error(`Op expected to be ${kind}, got "${op.type}`);
        }
        if (!(0, utils_1.arrayContentEquals)(key, op.key)) {
          throw new Error(`Proven key different than queried key.
Query: ${(0, encoding_1.toHex)(key)}
Proven: ${(0, encoding_1.toHex)(op.key)}`);
        }
        return ics23_1.ics23.CommitmentProof.decode(op.data);
      }
      var QueryClient = class {
        constructor(tmClient) {
          this.tmClient = tmClient;
        }
        static withExtensions(tmClient, ...extensionSetups) {
          const client = new QueryClient(tmClient);
          const extensions = extensionSetups.map((setupExtension) => setupExtension(client));
          for (const extension of extensions) {
            (0, utils_1.assert)((0, utils_1.isNonNullObject)(extension), `Extension must be a non-null object`);
            for (const [moduleKey, moduleValue] of Object.entries(extension)) {
              (0, utils_1.assert)((0, utils_1.isNonNullObject)(moduleValue), `Module must be a non-null object. Found type ${typeof moduleValue} for module "${moduleKey}".`);
              const current = client[moduleKey] || {};
              client[moduleKey] = {
                ...current,
                ...moduleValue
              };
            }
          }
          return client;
        }
        async queryVerified(store, key, desiredHeight) {
          const { height, proof, value } = await this.queryRawProof(store, key, desiredHeight);
          const subProof = checkAndParseOp(proof.ops[0], "ics23:iavl", key);
          const storeProof = checkAndParseOp(proof.ops[1], "ics23:simple", (0, encoding_1.toAscii)(store));
          (0, utils_1.assert)(storeProof.exist);
          (0, utils_1.assert)(storeProof.exist.value);
          if (!value || value.length === 0) {
            (0, utils_1.assert)(subProof.nonexist);
            (0, ics23_1.verifyNonExistence)(subProof.nonexist, ics23_1.iavlSpec, storeProof.exist.value, key);
          } else {
            (0, utils_1.assert)(subProof.exist);
            (0, utils_1.assert)(subProof.exist.value);
            (0, ics23_1.verifyExistence)(subProof.exist, ics23_1.iavlSpec, storeProof.exist.value, key, value);
          }
          const header = await this.getNextHeader(height);
          (0, ics23_1.verifyExistence)(storeProof.exist, ics23_1.tendermintSpec, header.appHash, (0, encoding_1.toAscii)(store), storeProof.exist.value);
          return value;
        }
        async queryRawProof(store, queryKey, desiredHeight) {
          var _a;
          const { key, value, height, proof, code, log } = await this.tmClient.abciQuery({
            path: `/store/${store}/key`,
            data: queryKey,
            prove: true,
            height: desiredHeight
          });
          if (code) {
            throw new Error(`Query failed with (${code}): ${log}`);
          }
          if (!(0, utils_1.arrayContentEquals)(queryKey, key)) {
            throw new Error(`Response key ${(0, encoding_1.toHex)(key)} doesn't match query key ${(0, encoding_1.toHex)(queryKey)}`);
          }
          if (!height) {
            throw new Error("No query height returned");
          }
          if (!proof || proof.ops.length !== 2) {
            throw new Error(`Expected 2 proof ops, got ${(_a = proof === null || proof === void 0 ? void 0 : proof.ops.length) !== null && _a !== void 0 ? _a : 0}. Are you using stargate?`);
          }
          checkAndParseOp(proof.ops[0], "ics23:iavl", key);
          checkAndParseOp(proof.ops[1], "ics23:simple", (0, encoding_1.toAscii)(store));
          return {
            key,
            value,
            height,
            proof: {
              ops: [...proof.ops]
            }
          };
        }
        async queryUnverified(path, request) {
          const response = await this.tmClient.abciQuery({
            path,
            data: request,
            prove: false
          });
          if (response.code) {
            throw new Error(`Query failed with (${response.code}): ${response.log}`);
          }
          return response.value;
        }
        async getNextHeader(height) {
          (0, utils_1.assertDefined)(height);
          if (height === 0) {
            throw new Error("Query returned height 0, cannot prove it");
          }
          const searchHeight = height + 1;
          let nextHeader;
          let headersSubscription;
          try {
            headersSubscription = this.tmClient.subscribeNewBlockHeader();
          } catch (_a) {
          }
          if (headersSubscription) {
            const firstHeader = await (0, stream_1.firstEvent)(headersSubscription);
            if (firstHeader.height === searchHeight) {
              nextHeader = firstHeader;
            }
          }
          while (!nextHeader) {
            const correctHeader = (await this.tmClient.blockchain(height, searchHeight)).blockMetas.map((meta) => meta.header).find((h) => h.height === searchHeight);
            if (correctHeader) {
              nextHeader = correctHeader;
            } else {
              await (0, utils_1.sleep)(1e3);
            }
          }
          (0, utils_1.assert)(nextHeader.height === searchHeight, "Got wrong header. This is a bug in the logic above.");
          return nextHeader;
        }
      };
      exports2.QueryClient = QueryClient;
    }
  });

  // node_modules/@cosmjs/stargate/build/queryclient/utils.js
  var require_utils7 = __commonJS({
    "node_modules/@cosmjs/stargate/build/queryclient/utils.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.decodeCosmosSdkDecFromProto = exports2.longify = exports2.createProtobufRpcClient = exports2.createPagination = exports2.toAccAddress = void 0;
      var encoding_1 = require_build2();
      var math_1 = require_build();
      var pagination_1 = require_pagination();
      var long_1 = __importDefault(require_long());
      function toAccAddress(address) {
        return (0, encoding_1.fromBech32)(address).data;
      }
      exports2.toAccAddress = toAccAddress;
      function createPagination(paginationKey) {
        return paginationKey ? pagination_1.PageRequest.fromPartial({
          key: paginationKey,
          offset: long_1.default.fromNumber(0, true),
          limit: long_1.default.fromNumber(0, true),
          countTotal: false
        }) : void 0;
      }
      exports2.createPagination = createPagination;
      function createProtobufRpcClient(base) {
        return {
          request: (service, method, data) => {
            const path = `/${service}/${method}`;
            return base.queryUnverified(path, data);
          }
        };
      }
      exports2.createProtobufRpcClient = createProtobufRpcClient;
      function longify(value) {
        const checkedValue = math_1.Uint64.fromString(value.toString());
        return long_1.default.fromBytesBE([...checkedValue.toBytesBigEndian()], true);
      }
      exports2.longify = longify;
      function decodeCosmosSdkDecFromProto(input) {
        const asString = typeof input === "string" ? input : (0, encoding_1.fromAscii)(input);
        return math_1.Decimal.fromAtomics(asString, 18);
      }
      exports2.decodeCosmosSdkDecFromProto = decodeCosmosSdkDecFromProto;
    }
  });

  // node_modules/@cosmjs/stargate/build/queryclient/index.js
  var require_queryclient2 = __commonJS({
    "node_modules/@cosmjs/stargate/build/queryclient/index.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.longify = exports2.decodeCosmosSdkDecFromProto = exports2.createProtobufRpcClient = exports2.createPagination = exports2.QueryClient = void 0;
      var queryclient_1 = require_queryclient();
      Object.defineProperty(exports2, "QueryClient", { enumerable: true, get: function() {
        return queryclient_1.QueryClient;
      } });
      var utils_1 = require_utils7();
      Object.defineProperty(exports2, "createPagination", { enumerable: true, get: function() {
        return utils_1.createPagination;
      } });
      Object.defineProperty(exports2, "createProtobufRpcClient", { enumerable: true, get: function() {
        return utils_1.createProtobufRpcClient;
      } });
      Object.defineProperty(exports2, "decodeCosmosSdkDecFromProto", { enumerable: true, get: function() {
        return utils_1.decodeCosmosSdkDecFromProto;
      } });
      Object.defineProperty(exports2, "longify", { enumerable: true, get: function() {
        return utils_1.longify;
      } });
    }
  });

  // node_modules/@cosmjs/stargate/build/modules/auth/queries.js
  var require_queries = __commonJS({
    "node_modules/@cosmjs/stargate/build/modules/auth/queries.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.setupAuthExtension = void 0;
      var query_1 = require_query();
      var queryclient_1 = require_queryclient2();
      function setupAuthExtension(base) {
        const rpc = (0, queryclient_1.createProtobufRpcClient)(base);
        const queryService = new query_1.QueryClientImpl(rpc);
        return {
          auth: {
            account: async (address) => {
              const { account } = await queryService.Account({ address });
              return account !== null && account !== void 0 ? account : null;
            }
          }
        };
      }
      exports2.setupAuthExtension = setupAuthExtension;
    }
  });

  // node_modules/@cosmjs/stargate/build/modules/authz/aminomessages.js
  var require_aminomessages = __commonJS({
    "node_modules/@cosmjs/stargate/build/modules/authz/aminomessages.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.createAuthzAminoConverters = void 0;
      function createAuthzAminoConverters() {
        return {
          "/cosmos.authz.v1beta1.MsgGrant": "not_supported_by_chain",
          "/cosmos.authz.v1beta1.MsgExec": "not_supported_by_chain",
          "/cosmos.authz.v1beta1.MsgRevoke": "not_supported_by_chain"
        };
      }
      exports2.createAuthzAminoConverters = createAuthzAminoConverters;
    }
  });

  // node_modules/cosmjs-types/google/protobuf/timestamp.js
  var require_timestamp = __commonJS({
    "node_modules/cosmjs-types/google/protobuf/timestamp.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.Timestamp = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      exports2.protobufPackage = "google.protobuf";
      var baseTimestamp = { seconds: long_1.default.ZERO, nanos: 0 };
      exports2.Timestamp = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.seconds.isZero()) {
            writer.uint32(8).int64(message.seconds);
          }
          if (message.nanos !== 0) {
            writer.uint32(16).int32(message.nanos);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseTimestamp);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.seconds = reader.int64();
                break;
              case 2:
                message.nanos = reader.int32();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseTimestamp);
          message.seconds = object.seconds !== void 0 && object.seconds !== null ? long_1.default.fromString(object.seconds) : long_1.default.ZERO;
          message.nanos = object.nanos !== void 0 && object.nanos !== null ? Number(object.nanos) : 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.seconds !== void 0 && (obj.seconds = (message.seconds || long_1.default.ZERO).toString());
          message.nanos !== void 0 && (obj.nanos = message.nanos);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseTimestamp);
          message.seconds = object.seconds !== void 0 && object.seconds !== null ? long_1.default.fromValue(object.seconds) : long_1.default.ZERO;
          message.nanos = (_a = object.nanos) !== null && _a !== void 0 ? _a : 0;
          return message;
        }
      };
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/cosmjs-types/cosmos/authz/v1beta1/authz.js
  var require_authz = __commonJS({
    "node_modules/cosmjs-types/cosmos/authz/v1beta1/authz.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.Grant = exports2.GenericAuthorization = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var any_1 = require_any();
      var timestamp_1 = require_timestamp();
      exports2.protobufPackage = "cosmos.authz.v1beta1";
      var baseGenericAuthorization = { msg: "" };
      exports2.GenericAuthorization = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.msg !== "") {
            writer.uint32(10).string(message.msg);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseGenericAuthorization);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.msg = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseGenericAuthorization);
          message.msg = object.msg !== void 0 && object.msg !== null ? String(object.msg) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.msg !== void 0 && (obj.msg = message.msg);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseGenericAuthorization);
          message.msg = (_a = object.msg) !== null && _a !== void 0 ? _a : "";
          return message;
        }
      };
      var baseGrant = {};
      exports2.Grant = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.authorization !== void 0) {
            any_1.Any.encode(message.authorization, writer.uint32(10).fork()).ldelim();
          }
          if (message.expiration !== void 0) {
            timestamp_1.Timestamp.encode(message.expiration, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseGrant);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.authorization = any_1.Any.decode(reader, reader.uint32());
                break;
              case 2:
                message.expiration = timestamp_1.Timestamp.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseGrant);
          message.authorization = object.authorization !== void 0 && object.authorization !== null ? any_1.Any.fromJSON(object.authorization) : void 0;
          message.expiration = object.expiration !== void 0 && object.expiration !== null ? fromJsonTimestamp(object.expiration) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.authorization !== void 0 && (obj.authorization = message.authorization ? any_1.Any.toJSON(message.authorization) : void 0);
          message.expiration !== void 0 && (obj.expiration = fromTimestamp(message.expiration).toISOString());
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseGrant);
          message.authorization = object.authorization !== void 0 && object.authorization !== null ? any_1.Any.fromPartial(object.authorization) : void 0;
          message.expiration = object.expiration !== void 0 && object.expiration !== null ? timestamp_1.Timestamp.fromPartial(object.expiration) : void 0;
          return message;
        }
      };
      function toTimestamp(date) {
        const seconds = numberToLong(date.getTime() / 1e3);
        const nanos = date.getTime() % 1e3 * 1e6;
        return { seconds, nanos };
      }
      function fromTimestamp(t) {
        let millis = t.seconds.toNumber() * 1e3;
        millis += t.nanos / 1e6;
        return new Date(millis);
      }
      function fromJsonTimestamp(o) {
        if (o instanceof Date) {
          return toTimestamp(o);
        } else if (typeof o === "string") {
          return toTimestamp(new Date(o));
        } else {
          return timestamp_1.Timestamp.fromJSON(o);
        }
      }
      function numberToLong(number) {
        return long_1.default.fromNumber(number);
      }
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/cosmjs-types/cosmos/authz/v1beta1/tx.js
  var require_tx3 = __commonJS({
    "node_modules/cosmjs-types/cosmos/authz/v1beta1/tx.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.MsgClientImpl = exports2.MsgRevokeResponse = exports2.MsgRevoke = exports2.MsgGrantResponse = exports2.MsgExec = exports2.MsgExecResponse = exports2.MsgGrant = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var authz_1 = require_authz();
      var any_1 = require_any();
      exports2.protobufPackage = "cosmos.authz.v1beta1";
      var baseMsgGrant = { granter: "", grantee: "" };
      exports2.MsgGrant = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.granter !== "") {
            writer.uint32(10).string(message.granter);
          }
          if (message.grantee !== "") {
            writer.uint32(18).string(message.grantee);
          }
          if (message.grant !== void 0) {
            authz_1.Grant.encode(message.grant, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgGrant);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.granter = reader.string();
                break;
              case 2:
                message.grantee = reader.string();
                break;
              case 3:
                message.grant = authz_1.Grant.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMsgGrant);
          message.granter = object.granter !== void 0 && object.granter !== null ? String(object.granter) : "";
          message.grantee = object.grantee !== void 0 && object.grantee !== null ? String(object.grantee) : "";
          message.grant = object.grant !== void 0 && object.grant !== null ? authz_1.Grant.fromJSON(object.grant) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.granter !== void 0 && (obj.granter = message.granter);
          message.grantee !== void 0 && (obj.grantee = message.grantee);
          message.grant !== void 0 && (obj.grant = message.grant ? authz_1.Grant.toJSON(message.grant) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseMsgGrant);
          message.granter = (_a = object.granter) !== null && _a !== void 0 ? _a : "";
          message.grantee = (_b = object.grantee) !== null && _b !== void 0 ? _b : "";
          message.grant = object.grant !== void 0 && object.grant !== null ? authz_1.Grant.fromPartial(object.grant) : void 0;
          return message;
        }
      };
      var baseMsgExecResponse = {};
      exports2.MsgExecResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.results) {
            writer.uint32(10).bytes(v);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgExecResponse);
          message.results = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.results.push(reader.bytes());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseMsgExecResponse);
          message.results = ((_a = object.results) !== null && _a !== void 0 ? _a : []).map((e) => bytesFromBase64(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.results) {
            obj.results = message.results.map((e) => base64FromBytes(e !== void 0 ? e : new Uint8Array()));
          } else {
            obj.results = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseMsgExecResponse);
          message.results = ((_a = object.results) === null || _a === void 0 ? void 0 : _a.map((e) => e)) || [];
          return message;
        }
      };
      var baseMsgExec = { grantee: "" };
      exports2.MsgExec = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.grantee !== "") {
            writer.uint32(10).string(message.grantee);
          }
          for (const v of message.msgs) {
            any_1.Any.encode(v, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgExec);
          message.msgs = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.grantee = reader.string();
                break;
              case 2:
                message.msgs.push(any_1.Any.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseMsgExec);
          message.grantee = object.grantee !== void 0 && object.grantee !== null ? String(object.grantee) : "";
          message.msgs = ((_a = object.msgs) !== null && _a !== void 0 ? _a : []).map((e) => any_1.Any.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.grantee !== void 0 && (obj.grantee = message.grantee);
          if (message.msgs) {
            obj.msgs = message.msgs.map((e) => e ? any_1.Any.toJSON(e) : void 0);
          } else {
            obj.msgs = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseMsgExec);
          message.grantee = (_a = object.grantee) !== null && _a !== void 0 ? _a : "";
          message.msgs = ((_b = object.msgs) === null || _b === void 0 ? void 0 : _b.map((e) => any_1.Any.fromPartial(e))) || [];
          return message;
        }
      };
      var baseMsgGrantResponse = {};
      exports2.MsgGrantResponse = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgGrantResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseMsgGrantResponse);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseMsgGrantResponse);
          return message;
        }
      };
      var baseMsgRevoke = { granter: "", grantee: "", msgTypeUrl: "" };
      exports2.MsgRevoke = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.granter !== "") {
            writer.uint32(10).string(message.granter);
          }
          if (message.grantee !== "") {
            writer.uint32(18).string(message.grantee);
          }
          if (message.msgTypeUrl !== "") {
            writer.uint32(26).string(message.msgTypeUrl);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgRevoke);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.granter = reader.string();
                break;
              case 2:
                message.grantee = reader.string();
                break;
              case 3:
                message.msgTypeUrl = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMsgRevoke);
          message.granter = object.granter !== void 0 && object.granter !== null ? String(object.granter) : "";
          message.grantee = object.grantee !== void 0 && object.grantee !== null ? String(object.grantee) : "";
          message.msgTypeUrl = object.msgTypeUrl !== void 0 && object.msgTypeUrl !== null ? String(object.msgTypeUrl) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.granter !== void 0 && (obj.granter = message.granter);
          message.grantee !== void 0 && (obj.grantee = message.grantee);
          message.msgTypeUrl !== void 0 && (obj.msgTypeUrl = message.msgTypeUrl);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseMsgRevoke);
          message.granter = (_a = object.granter) !== null && _a !== void 0 ? _a : "";
          message.grantee = (_b = object.grantee) !== null && _b !== void 0 ? _b : "";
          message.msgTypeUrl = (_c = object.msgTypeUrl) !== null && _c !== void 0 ? _c : "";
          return message;
        }
      };
      var baseMsgRevokeResponse = {};
      exports2.MsgRevokeResponse = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgRevokeResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseMsgRevokeResponse);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseMsgRevokeResponse);
          return message;
        }
      };
      var MsgClientImpl = class {
        constructor(rpc) {
          this.rpc = rpc;
          this.Grant = this.Grant.bind(this);
          this.Exec = this.Exec.bind(this);
          this.Revoke = this.Revoke.bind(this);
        }
        Grant(request) {
          const data = exports2.MsgGrant.encode(request).finish();
          const promise = this.rpc.request("cosmos.authz.v1beta1.Msg", "Grant", data);
          return promise.then((data2) => exports2.MsgGrantResponse.decode(new minimal_1.default.Reader(data2)));
        }
        Exec(request) {
          const data = exports2.MsgExec.encode(request).finish();
          const promise = this.rpc.request("cosmos.authz.v1beta1.Msg", "Exec", data);
          return promise.then((data2) => exports2.MsgExecResponse.decode(new minimal_1.default.Reader(data2)));
        }
        Revoke(request) {
          const data = exports2.MsgRevoke.encode(request).finish();
          const promise = this.rpc.request("cosmos.authz.v1beta1.Msg", "Revoke", data);
          return promise.then((data2) => exports2.MsgRevokeResponse.decode(new minimal_1.default.Reader(data2)));
        }
      };
      exports2.MsgClientImpl = MsgClientImpl;
      var globalThis2 = (() => {
        if (typeof globalThis2 !== "undefined")
          return globalThis2;
        if (typeof self !== "undefined")
          return self;
        if (typeof window !== "undefined")
          return window;
        if (typeof global !== "undefined")
          return global;
        throw "Unable to locate global object";
      })();
      var atob2 = globalThis2.atob || ((b64) => globalThis2.Buffer.from(b64, "base64").toString("binary"));
      function bytesFromBase64(b64) {
        const bin = atob2(b64);
        const arr = new Uint8Array(bin.length);
        for (let i = 0; i < bin.length; ++i) {
          arr[i] = bin.charCodeAt(i);
        }
        return arr;
      }
      var btoa2 = globalThis2.btoa || ((bin) => globalThis2.Buffer.from(bin, "binary").toString("base64"));
      function base64FromBytes(arr) {
        const bin = [];
        for (const byte of arr) {
          bin.push(String.fromCharCode(byte));
        }
        return btoa2(bin.join(""));
      }
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/@cosmjs/stargate/build/modules/authz/messages.js
  var require_messages = __commonJS({
    "node_modules/@cosmjs/stargate/build/modules/authz/messages.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.authzTypes = void 0;
      var tx_1 = require_tx3();
      exports2.authzTypes = [
        ["/cosmos.authz.v1beta1.MsgExec", tx_1.MsgExec],
        ["/cosmos.authz.v1beta1.MsgGrant", tx_1.MsgGrant],
        ["/cosmos.authz.v1beta1.MsgRevoke", tx_1.MsgRevoke]
      ];
    }
  });

  // node_modules/@cosmjs/stargate/build/modules/bank/aminomessages.js
  var require_aminomessages2 = __commonJS({
    "node_modules/@cosmjs/stargate/build/modules/bank/aminomessages.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.createBankAminoConverters = exports2.isAminoMsgMultiSend = exports2.isAminoMsgSend = void 0;
      function isAminoMsgSend(msg) {
        return msg.type === "cosmos-sdk/MsgSend";
      }
      exports2.isAminoMsgSend = isAminoMsgSend;
      function isAminoMsgMultiSend(msg) {
        return msg.type === "cosmos-sdk/MsgMultiSend";
      }
      exports2.isAminoMsgMultiSend = isAminoMsgMultiSend;
      function createBankAminoConverters() {
        return {
          "/cosmos.bank.v1beta1.MsgSend": {
            aminoType: "cosmos-sdk/MsgSend",
            toAmino: ({ fromAddress, toAddress, amount }) => ({
              from_address: fromAddress,
              to_address: toAddress,
              amount: [...amount]
            }),
            fromAmino: ({ from_address, to_address, amount }) => ({
              fromAddress: from_address,
              toAddress: to_address,
              amount: [...amount]
            })
          },
          "/cosmos.bank.v1beta1.MsgMultiSend": {
            aminoType: "cosmos-sdk/MsgMultiSend",
            toAmino: ({ inputs, outputs }) => ({
              inputs: inputs.map((input) => ({
                address: input.address,
                coins: [...input.coins]
              })),
              outputs: outputs.map((output) => ({
                address: output.address,
                coins: [...output.coins]
              }))
            }),
            fromAmino: ({ inputs, outputs }) => ({
              inputs: inputs.map((input) => ({
                address: input.address,
                coins: [...input.coins]
              })),
              outputs: outputs.map((output) => ({
                address: output.address,
                coins: [...output.coins]
              }))
            })
          }
        };
      }
      exports2.createBankAminoConverters = createBankAminoConverters;
    }
  });

  // node_modules/@cosmjs/stargate/build/modules/bank/messages.js
  var require_messages2 = __commonJS({
    "node_modules/@cosmjs/stargate/build/modules/bank/messages.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.isMsgSendEncodeObject = exports2.bankTypes = void 0;
      var tx_1 = require_tx2();
      exports2.bankTypes = [
        ["/cosmos.bank.v1beta1.MsgMultiSend", tx_1.MsgMultiSend],
        ["/cosmos.bank.v1beta1.MsgSend", tx_1.MsgSend]
      ];
      function isMsgSendEncodeObject(encodeObject) {
        return encodeObject.typeUrl === "/cosmos.bank.v1beta1.MsgSend";
      }
      exports2.isMsgSendEncodeObject = isMsgSendEncodeObject;
    }
  });

  // node_modules/cosmjs-types/cosmos/bank/v1beta1/query.js
  var require_query2 = __commonJS({
    "node_modules/cosmjs-types/cosmos/bank/v1beta1/query.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.QueryClientImpl = exports2.QueryDenomMetadataResponse = exports2.QueryDenomMetadataRequest = exports2.QueryDenomsMetadataResponse = exports2.QueryDenomsMetadataRequest = exports2.QueryParamsResponse = exports2.QueryParamsRequest = exports2.QuerySupplyOfResponse = exports2.QuerySupplyOfRequest = exports2.QueryTotalSupplyResponse = exports2.QueryTotalSupplyRequest = exports2.QueryAllBalancesResponse = exports2.QueryAllBalancesRequest = exports2.QueryBalanceResponse = exports2.QueryBalanceRequest = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var coin_1 = require_coin();
      var pagination_1 = require_pagination();
      var bank_1 = require_bank();
      exports2.protobufPackage = "cosmos.bank.v1beta1";
      var baseQueryBalanceRequest = { address: "", denom: "" };
      exports2.QueryBalanceRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.address !== "") {
            writer.uint32(10).string(message.address);
          }
          if (message.denom !== "") {
            writer.uint32(18).string(message.denom);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryBalanceRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.address = reader.string();
                break;
              case 2:
                message.denom = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryBalanceRequest);
          message.address = object.address !== void 0 && object.address !== null ? String(object.address) : "";
          message.denom = object.denom !== void 0 && object.denom !== null ? String(object.denom) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.address !== void 0 && (obj.address = message.address);
          message.denom !== void 0 && (obj.denom = message.denom);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseQueryBalanceRequest);
          message.address = (_a = object.address) !== null && _a !== void 0 ? _a : "";
          message.denom = (_b = object.denom) !== null && _b !== void 0 ? _b : "";
          return message;
        }
      };
      var baseQueryBalanceResponse = {};
      exports2.QueryBalanceResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.balance !== void 0) {
            coin_1.Coin.encode(message.balance, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryBalanceResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.balance = coin_1.Coin.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryBalanceResponse);
          message.balance = object.balance !== void 0 && object.balance !== null ? coin_1.Coin.fromJSON(object.balance) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.balance !== void 0 && (obj.balance = message.balance ? coin_1.Coin.toJSON(message.balance) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryBalanceResponse);
          message.balance = object.balance !== void 0 && object.balance !== null ? coin_1.Coin.fromPartial(object.balance) : void 0;
          return message;
        }
      };
      var baseQueryAllBalancesRequest = { address: "" };
      exports2.QueryAllBalancesRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.address !== "") {
            writer.uint32(10).string(message.address);
          }
          if (message.pagination !== void 0) {
            pagination_1.PageRequest.encode(message.pagination, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryAllBalancesRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.address = reader.string();
                break;
              case 2:
                message.pagination = pagination_1.PageRequest.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryAllBalancesRequest);
          message.address = object.address !== void 0 && object.address !== null ? String(object.address) : "";
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.address !== void 0 && (obj.address = message.address);
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageRequest.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryAllBalancesRequest);
          message.address = (_a = object.address) !== null && _a !== void 0 ? _a : "";
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryAllBalancesResponse = {};
      exports2.QueryAllBalancesResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.balances) {
            coin_1.Coin.encode(v, writer.uint32(10).fork()).ldelim();
          }
          if (message.pagination !== void 0) {
            pagination_1.PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryAllBalancesResponse);
          message.balances = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.balances.push(coin_1.Coin.decode(reader, reader.uint32()));
                break;
              case 2:
                message.pagination = pagination_1.PageResponse.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseQueryAllBalancesResponse);
          message.balances = ((_a = object.balances) !== null && _a !== void 0 ? _a : []).map((e) => coin_1.Coin.fromJSON(e));
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.balances) {
            obj.balances = message.balances.map((e) => e ? coin_1.Coin.toJSON(e) : void 0);
          } else {
            obj.balances = [];
          }
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageResponse.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryAllBalancesResponse);
          message.balances = ((_a = object.balances) === null || _a === void 0 ? void 0 : _a.map((e) => coin_1.Coin.fromPartial(e))) || [];
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryTotalSupplyRequest = {};
      exports2.QueryTotalSupplyRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.pagination !== void 0) {
            pagination_1.PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryTotalSupplyRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.pagination = pagination_1.PageRequest.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryTotalSupplyRequest);
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageRequest.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryTotalSupplyRequest);
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryTotalSupplyResponse = {};
      exports2.QueryTotalSupplyResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.supply) {
            coin_1.Coin.encode(v, writer.uint32(10).fork()).ldelim();
          }
          if (message.pagination !== void 0) {
            pagination_1.PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryTotalSupplyResponse);
          message.supply = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.supply.push(coin_1.Coin.decode(reader, reader.uint32()));
                break;
              case 2:
                message.pagination = pagination_1.PageResponse.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseQueryTotalSupplyResponse);
          message.supply = ((_a = object.supply) !== null && _a !== void 0 ? _a : []).map((e) => coin_1.Coin.fromJSON(e));
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.supply) {
            obj.supply = message.supply.map((e) => e ? coin_1.Coin.toJSON(e) : void 0);
          } else {
            obj.supply = [];
          }
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageResponse.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryTotalSupplyResponse);
          message.supply = ((_a = object.supply) === null || _a === void 0 ? void 0 : _a.map((e) => coin_1.Coin.fromPartial(e))) || [];
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQuerySupplyOfRequest = { denom: "" };
      exports2.QuerySupplyOfRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.denom !== "") {
            writer.uint32(10).string(message.denom);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQuerySupplyOfRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.denom = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQuerySupplyOfRequest);
          message.denom = object.denom !== void 0 && object.denom !== null ? String(object.denom) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.denom !== void 0 && (obj.denom = message.denom);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQuerySupplyOfRequest);
          message.denom = (_a = object.denom) !== null && _a !== void 0 ? _a : "";
          return message;
        }
      };
      var baseQuerySupplyOfResponse = {};
      exports2.QuerySupplyOfResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.amount !== void 0) {
            coin_1.Coin.encode(message.amount, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQuerySupplyOfResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.amount = coin_1.Coin.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQuerySupplyOfResponse);
          message.amount = object.amount !== void 0 && object.amount !== null ? coin_1.Coin.fromJSON(object.amount) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.amount !== void 0 && (obj.amount = message.amount ? coin_1.Coin.toJSON(message.amount) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQuerySupplyOfResponse);
          message.amount = object.amount !== void 0 && object.amount !== null ? coin_1.Coin.fromPartial(object.amount) : void 0;
          return message;
        }
      };
      var baseQueryParamsRequest = {};
      exports2.QueryParamsRequest = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryParamsRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseQueryParamsRequest);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseQueryParamsRequest);
          return message;
        }
      };
      var baseQueryParamsResponse = {};
      exports2.QueryParamsResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.params !== void 0) {
            bank_1.Params.encode(message.params, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryParamsResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.params = bank_1.Params.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryParamsResponse);
          message.params = object.params !== void 0 && object.params !== null ? bank_1.Params.fromJSON(object.params) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.params !== void 0 && (obj.params = message.params ? bank_1.Params.toJSON(message.params) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryParamsResponse);
          message.params = object.params !== void 0 && object.params !== null ? bank_1.Params.fromPartial(object.params) : void 0;
          return message;
        }
      };
      var baseQueryDenomsMetadataRequest = {};
      exports2.QueryDenomsMetadataRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.pagination !== void 0) {
            pagination_1.PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryDenomsMetadataRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.pagination = pagination_1.PageRequest.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryDenomsMetadataRequest);
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageRequest.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryDenomsMetadataRequest);
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryDenomsMetadataResponse = {};
      exports2.QueryDenomsMetadataResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.metadatas) {
            bank_1.Metadata.encode(v, writer.uint32(10).fork()).ldelim();
          }
          if (message.pagination !== void 0) {
            pagination_1.PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryDenomsMetadataResponse);
          message.metadatas = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.metadatas.push(bank_1.Metadata.decode(reader, reader.uint32()));
                break;
              case 2:
                message.pagination = pagination_1.PageResponse.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseQueryDenomsMetadataResponse);
          message.metadatas = ((_a = object.metadatas) !== null && _a !== void 0 ? _a : []).map((e) => bank_1.Metadata.fromJSON(e));
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.metadatas) {
            obj.metadatas = message.metadatas.map((e) => e ? bank_1.Metadata.toJSON(e) : void 0);
          } else {
            obj.metadatas = [];
          }
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageResponse.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryDenomsMetadataResponse);
          message.metadatas = ((_a = object.metadatas) === null || _a === void 0 ? void 0 : _a.map((e) => bank_1.Metadata.fromPartial(e))) || [];
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryDenomMetadataRequest = { denom: "" };
      exports2.QueryDenomMetadataRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.denom !== "") {
            writer.uint32(10).string(message.denom);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryDenomMetadataRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.denom = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryDenomMetadataRequest);
          message.denom = object.denom !== void 0 && object.denom !== null ? String(object.denom) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.denom !== void 0 && (obj.denom = message.denom);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryDenomMetadataRequest);
          message.denom = (_a = object.denom) !== null && _a !== void 0 ? _a : "";
          return message;
        }
      };
      var baseQueryDenomMetadataResponse = {};
      exports2.QueryDenomMetadataResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.metadata !== void 0) {
            bank_1.Metadata.encode(message.metadata, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryDenomMetadataResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.metadata = bank_1.Metadata.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryDenomMetadataResponse);
          message.metadata = object.metadata !== void 0 && object.metadata !== null ? bank_1.Metadata.fromJSON(object.metadata) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.metadata !== void 0 && (obj.metadata = message.metadata ? bank_1.Metadata.toJSON(message.metadata) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryDenomMetadataResponse);
          message.metadata = object.metadata !== void 0 && object.metadata !== null ? bank_1.Metadata.fromPartial(object.metadata) : void 0;
          return message;
        }
      };
      var QueryClientImpl = class {
        constructor(rpc) {
          this.rpc = rpc;
          this.Balance = this.Balance.bind(this);
          this.AllBalances = this.AllBalances.bind(this);
          this.TotalSupply = this.TotalSupply.bind(this);
          this.SupplyOf = this.SupplyOf.bind(this);
          this.Params = this.Params.bind(this);
          this.DenomMetadata = this.DenomMetadata.bind(this);
          this.DenomsMetadata = this.DenomsMetadata.bind(this);
        }
        Balance(request) {
          const data = exports2.QueryBalanceRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "Balance", data);
          return promise.then((data2) => exports2.QueryBalanceResponse.decode(new minimal_1.default.Reader(data2)));
        }
        AllBalances(request) {
          const data = exports2.QueryAllBalancesRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "AllBalances", data);
          return promise.then((data2) => exports2.QueryAllBalancesResponse.decode(new minimal_1.default.Reader(data2)));
        }
        TotalSupply(request) {
          const data = exports2.QueryTotalSupplyRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "TotalSupply", data);
          return promise.then((data2) => exports2.QueryTotalSupplyResponse.decode(new minimal_1.default.Reader(data2)));
        }
        SupplyOf(request) {
          const data = exports2.QuerySupplyOfRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "SupplyOf", data);
          return promise.then((data2) => exports2.QuerySupplyOfResponse.decode(new minimal_1.default.Reader(data2)));
        }
        Params(request) {
          const data = exports2.QueryParamsRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "Params", data);
          return promise.then((data2) => exports2.QueryParamsResponse.decode(new minimal_1.default.Reader(data2)));
        }
        DenomMetadata(request) {
          const data = exports2.QueryDenomMetadataRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "DenomMetadata", data);
          return promise.then((data2) => exports2.QueryDenomMetadataResponse.decode(new minimal_1.default.Reader(data2)));
        }
        DenomsMetadata(request) {
          const data = exports2.QueryDenomsMetadataRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "DenomsMetadata", data);
          return promise.then((data2) => exports2.QueryDenomsMetadataResponse.decode(new minimal_1.default.Reader(data2)));
        }
      };
      exports2.QueryClientImpl = QueryClientImpl;
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/@cosmjs/stargate/build/modules/bank/queries.js
  var require_queries2 = __commonJS({
    "node_modules/@cosmjs/stargate/build/modules/bank/queries.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.setupBankExtension = void 0;
      var utils_1 = require_build3();
      var query_1 = require_query2();
      var queryclient_1 = require_queryclient2();
      function setupBankExtension(base) {
        const rpc = (0, queryclient_1.createProtobufRpcClient)(base);
        const queryService = new query_1.QueryClientImpl(rpc);
        return {
          bank: {
            balance: async (address, denom) => {
              const { balance } = await queryService.Balance({ address, denom });
              (0, utils_1.assert)(balance);
              return balance;
            },
            allBalances: async (address) => {
              const { balances } = await queryService.AllBalances({ address });
              return balances;
            },
            totalSupply: async () => {
              const { supply } = await queryService.TotalSupply({});
              return supply;
            },
            supplyOf: async (denom) => {
              const { amount } = await queryService.SupplyOf({ denom });
              (0, utils_1.assert)(amount);
              return amount;
            },
            denomMetadata: async (denom) => {
              const { metadata } = await queryService.DenomMetadata({ denom });
              (0, utils_1.assert)(metadata);
              return metadata;
            },
            denomsMetadata: async () => {
              const { metadatas } = await queryService.DenomsMetadata({
                pagination: void 0
              });
              return metadatas;
            }
          }
        };
      }
      exports2.setupBankExtension = setupBankExtension;
    }
  });

  // node_modules/@cosmjs/stargate/build/modules/crisis/aminomessages.js
  var require_aminomessages3 = __commonJS({
    "node_modules/@cosmjs/stargate/build/modules/crisis/aminomessages.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.createCrysisAminoConverters = exports2.isAminoMsgVerifyInvariant = void 0;
      function isAminoMsgVerifyInvariant(msg) {
        return msg.type === "cosmos-sdk/MsgVerifyInvariant";
      }
      exports2.isAminoMsgVerifyInvariant = isAminoMsgVerifyInvariant;
      function createCrysisAminoConverters() {
        throw new Error("Not implemented");
      }
      exports2.createCrysisAminoConverters = createCrysisAminoConverters;
    }
  });

  // node_modules/@cosmjs/stargate/build/modules/distribution/aminomessages.js
  var require_aminomessages4 = __commonJS({
    "node_modules/@cosmjs/stargate/build/modules/distribution/aminomessages.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.createDistributionAminoConverters = exports2.isAminoMsgFundCommunityPool = exports2.isAminoMsgWithdrawValidatorCommission = exports2.isAminoMsgWithdrawDelegatorReward = exports2.isAminoMsgSetWithdrawAddress = void 0;
      function isAminoMsgSetWithdrawAddress(msg) {
        return msg.type === "cosmos-sdk/MsgModifyWithdrawAddress";
      }
      exports2.isAminoMsgSetWithdrawAddress = isAminoMsgSetWithdrawAddress;
      function isAminoMsgWithdrawDelegatorReward(msg) {
        return msg.type === "cosmos-sdk/MsgWithdrawDelegationReward";
      }
      exports2.isAminoMsgWithdrawDelegatorReward = isAminoMsgWithdrawDelegatorReward;
      function isAminoMsgWithdrawValidatorCommission(msg) {
        return msg.type === "cosmos-sdk/MsgWithdrawValidatorCommission";
      }
      exports2.isAminoMsgWithdrawValidatorCommission = isAminoMsgWithdrawValidatorCommission;
      function isAminoMsgFundCommunityPool(msg) {
        return msg.type === "cosmos-sdk/MsgFundCommunityPool";
      }
      exports2.isAminoMsgFundCommunityPool = isAminoMsgFundCommunityPool;
      function createDistributionAminoConverters() {
        return {
          "/cosmos.distribution.v1beta1.MsgFundCommunityPool": {
            aminoType: "cosmos-sdk/MsgFundCommunityPool",
            toAmino: ({ amount, depositor }) => ({
              amount: [...amount],
              depositor
            }),
            fromAmino: ({ amount, depositor }) => ({
              amount: [...amount],
              depositor
            })
          },
          "/cosmos.distribution.v1beta1.MsgSetWithdrawAddress": {
            aminoType: "cosmos-sdk/MsgModifyWithdrawAddress",
            toAmino: ({ delegatorAddress, withdrawAddress }) => ({
              delegator_address: delegatorAddress,
              withdraw_address: withdrawAddress
            }),
            fromAmino: ({ delegator_address, withdraw_address }) => ({
              delegatorAddress: delegator_address,
              withdrawAddress: withdraw_address
            })
          },
          "/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward": {
            aminoType: "cosmos-sdk/MsgWithdrawDelegationReward",
            toAmino: ({ delegatorAddress, validatorAddress }) => ({
              delegator_address: delegatorAddress,
              validator_address: validatorAddress
            }),
            fromAmino: ({ delegator_address, validator_address }) => ({
              delegatorAddress: delegator_address,
              validatorAddress: validator_address
            })
          },
          "/cosmos.distribution.v1beta1.MsgWithdrawValidatorCommission": {
            aminoType: "cosmos-sdk/MsgWithdrawValidatorCommission",
            toAmino: ({ validatorAddress }) => ({
              validator_address: validatorAddress
            }),
            fromAmino: ({ validator_address }) => ({
              validatorAddress: validator_address
            })
          }
        };
      }
      exports2.createDistributionAminoConverters = createDistributionAminoConverters;
    }
  });

  // node_modules/cosmjs-types/cosmos/distribution/v1beta1/tx.js
  var require_tx4 = __commonJS({
    "node_modules/cosmjs-types/cosmos/distribution/v1beta1/tx.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.MsgClientImpl = exports2.MsgFundCommunityPoolResponse = exports2.MsgFundCommunityPool = exports2.MsgWithdrawValidatorCommissionResponse = exports2.MsgWithdrawValidatorCommission = exports2.MsgWithdrawDelegatorRewardResponse = exports2.MsgWithdrawDelegatorReward = exports2.MsgSetWithdrawAddressResponse = exports2.MsgSetWithdrawAddress = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var coin_1 = require_coin();
      exports2.protobufPackage = "cosmos.distribution.v1beta1";
      var baseMsgSetWithdrawAddress = { delegatorAddress: "", withdrawAddress: "" };
      exports2.MsgSetWithdrawAddress = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.delegatorAddress !== "") {
            writer.uint32(10).string(message.delegatorAddress);
          }
          if (message.withdrawAddress !== "") {
            writer.uint32(18).string(message.withdrawAddress);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgSetWithdrawAddress);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.delegatorAddress = reader.string();
                break;
              case 2:
                message.withdrawAddress = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMsgSetWithdrawAddress);
          message.delegatorAddress = object.delegatorAddress !== void 0 && object.delegatorAddress !== null ? String(object.delegatorAddress) : "";
          message.withdrawAddress = object.withdrawAddress !== void 0 && object.withdrawAddress !== null ? String(object.withdrawAddress) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.delegatorAddress !== void 0 && (obj.delegatorAddress = message.delegatorAddress);
          message.withdrawAddress !== void 0 && (obj.withdrawAddress = message.withdrawAddress);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseMsgSetWithdrawAddress);
          message.delegatorAddress = (_a = object.delegatorAddress) !== null && _a !== void 0 ? _a : "";
          message.withdrawAddress = (_b = object.withdrawAddress) !== null && _b !== void 0 ? _b : "";
          return message;
        }
      };
      var baseMsgSetWithdrawAddressResponse = {};
      exports2.MsgSetWithdrawAddressResponse = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgSetWithdrawAddressResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseMsgSetWithdrawAddressResponse);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseMsgSetWithdrawAddressResponse);
          return message;
        }
      };
      var baseMsgWithdrawDelegatorReward = { delegatorAddress: "", validatorAddress: "" };
      exports2.MsgWithdrawDelegatorReward = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.delegatorAddress !== "") {
            writer.uint32(10).string(message.delegatorAddress);
          }
          if (message.validatorAddress !== "") {
            writer.uint32(18).string(message.validatorAddress);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgWithdrawDelegatorReward);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.delegatorAddress = reader.string();
                break;
              case 2:
                message.validatorAddress = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMsgWithdrawDelegatorReward);
          message.delegatorAddress = object.delegatorAddress !== void 0 && object.delegatorAddress !== null ? String(object.delegatorAddress) : "";
          message.validatorAddress = object.validatorAddress !== void 0 && object.validatorAddress !== null ? String(object.validatorAddress) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.delegatorAddress !== void 0 && (obj.delegatorAddress = message.delegatorAddress);
          message.validatorAddress !== void 0 && (obj.validatorAddress = message.validatorAddress);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseMsgWithdrawDelegatorReward);
          message.delegatorAddress = (_a = object.delegatorAddress) !== null && _a !== void 0 ? _a : "";
          message.validatorAddress = (_b = object.validatorAddress) !== null && _b !== void 0 ? _b : "";
          return message;
        }
      };
      var baseMsgWithdrawDelegatorRewardResponse = {};
      exports2.MsgWithdrawDelegatorRewardResponse = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgWithdrawDelegatorRewardResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseMsgWithdrawDelegatorRewardResponse);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseMsgWithdrawDelegatorRewardResponse);
          return message;
        }
      };
      var baseMsgWithdrawValidatorCommission = { validatorAddress: "" };
      exports2.MsgWithdrawValidatorCommission = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.validatorAddress !== "") {
            writer.uint32(10).string(message.validatorAddress);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgWithdrawValidatorCommission);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.validatorAddress = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMsgWithdrawValidatorCommission);
          message.validatorAddress = object.validatorAddress !== void 0 && object.validatorAddress !== null ? String(object.validatorAddress) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.validatorAddress !== void 0 && (obj.validatorAddress = message.validatorAddress);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseMsgWithdrawValidatorCommission);
          message.validatorAddress = (_a = object.validatorAddress) !== null && _a !== void 0 ? _a : "";
          return message;
        }
      };
      var baseMsgWithdrawValidatorCommissionResponse = {};
      exports2.MsgWithdrawValidatorCommissionResponse = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgWithdrawValidatorCommissionResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseMsgWithdrawValidatorCommissionResponse);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseMsgWithdrawValidatorCommissionResponse);
          return message;
        }
      };
      var baseMsgFundCommunityPool = { depositor: "" };
      exports2.MsgFundCommunityPool = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.amount) {
            coin_1.Coin.encode(v, writer.uint32(10).fork()).ldelim();
          }
          if (message.depositor !== "") {
            writer.uint32(18).string(message.depositor);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgFundCommunityPool);
          message.amount = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.amount.push(coin_1.Coin.decode(reader, reader.uint32()));
                break;
              case 2:
                message.depositor = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseMsgFundCommunityPool);
          message.amount = ((_a = object.amount) !== null && _a !== void 0 ? _a : []).map((e) => coin_1.Coin.fromJSON(e));
          message.depositor = object.depositor !== void 0 && object.depositor !== null ? String(object.depositor) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.amount) {
            obj.amount = message.amount.map((e) => e ? coin_1.Coin.toJSON(e) : void 0);
          } else {
            obj.amount = [];
          }
          message.depositor !== void 0 && (obj.depositor = message.depositor);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseMsgFundCommunityPool);
          message.amount = ((_a = object.amount) === null || _a === void 0 ? void 0 : _a.map((e) => coin_1.Coin.fromPartial(e))) || [];
          message.depositor = (_b = object.depositor) !== null && _b !== void 0 ? _b : "";
          return message;
        }
      };
      var baseMsgFundCommunityPoolResponse = {};
      exports2.MsgFundCommunityPoolResponse = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgFundCommunityPoolResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseMsgFundCommunityPoolResponse);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseMsgFundCommunityPoolResponse);
          return message;
        }
      };
      var MsgClientImpl = class {
        constructor(rpc) {
          this.rpc = rpc;
          this.SetWithdrawAddress = this.SetWithdrawAddress.bind(this);
          this.WithdrawDelegatorReward = this.WithdrawDelegatorReward.bind(this);
          this.WithdrawValidatorCommission = this.WithdrawValidatorCommission.bind(this);
          this.FundCommunityPool = this.FundCommunityPool.bind(this);
        }
        SetWithdrawAddress(request) {
          const data = exports2.MsgSetWithdrawAddress.encode(request).finish();
          const promise = this.rpc.request("cosmos.distribution.v1beta1.Msg", "SetWithdrawAddress", data);
          return promise.then((data2) => exports2.MsgSetWithdrawAddressResponse.decode(new minimal_1.default.Reader(data2)));
        }
        WithdrawDelegatorReward(request) {
          const data = exports2.MsgWithdrawDelegatorReward.encode(request).finish();
          const promise = this.rpc.request("cosmos.distribution.v1beta1.Msg", "WithdrawDelegatorReward", data);
          return promise.then((data2) => exports2.MsgWithdrawDelegatorRewardResponse.decode(new minimal_1.default.Reader(data2)));
        }
        WithdrawValidatorCommission(request) {
          const data = exports2.MsgWithdrawValidatorCommission.encode(request).finish();
          const promise = this.rpc.request("cosmos.distribution.v1beta1.Msg", "WithdrawValidatorCommission", data);
          return promise.then((data2) => exports2.MsgWithdrawValidatorCommissionResponse.decode(new minimal_1.default.Reader(data2)));
        }
        FundCommunityPool(request) {
          const data = exports2.MsgFundCommunityPool.encode(request).finish();
          const promise = this.rpc.request("cosmos.distribution.v1beta1.Msg", "FundCommunityPool", data);
          return promise.then((data2) => exports2.MsgFundCommunityPoolResponse.decode(new minimal_1.default.Reader(data2)));
        }
      };
      exports2.MsgClientImpl = MsgClientImpl;
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/@cosmjs/stargate/build/modules/distribution/messages.js
  var require_messages3 = __commonJS({
    "node_modules/@cosmjs/stargate/build/modules/distribution/messages.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.isMsgWithdrawDelegatorRewardEncodeObject = exports2.distributionTypes = void 0;
      var tx_1 = require_tx4();
      exports2.distributionTypes = [
        ["/cosmos.distribution.v1beta1.MsgFundCommunityPool", tx_1.MsgFundCommunityPool],
        ["/cosmos.distribution.v1beta1.MsgSetWithdrawAddress", tx_1.MsgSetWithdrawAddress],
        ["/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward", tx_1.MsgWithdrawDelegatorReward],
        ["/cosmos.distribution.v1beta1.MsgWithdrawValidatorCommission", tx_1.MsgWithdrawValidatorCommission]
      ];
      function isMsgWithdrawDelegatorRewardEncodeObject(object) {
        return object.typeUrl === "/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward";
      }
      exports2.isMsgWithdrawDelegatorRewardEncodeObject = isMsgWithdrawDelegatorRewardEncodeObject;
    }
  });

  // node_modules/cosmjs-types/cosmos/distribution/v1beta1/distribution.js
  var require_distribution = __commonJS({
    "node_modules/cosmjs-types/cosmos/distribution/v1beta1/distribution.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.CommunityPoolSpendProposalWithDeposit = exports2.DelegationDelegatorReward = exports2.DelegatorStartingInfo = exports2.CommunityPoolSpendProposal = exports2.FeePool = exports2.ValidatorSlashEvents = exports2.ValidatorSlashEvent = exports2.ValidatorOutstandingRewards = exports2.ValidatorAccumulatedCommission = exports2.ValidatorCurrentRewards = exports2.ValidatorHistoricalRewards = exports2.Params = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var coin_1 = require_coin();
      exports2.protobufPackage = "cosmos.distribution.v1beta1";
      var baseParams = {
        communityTax: "",
        baseProposerReward: "",
        bonusProposerReward: "",
        withdrawAddrEnabled: false
      };
      exports2.Params = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.communityTax !== "") {
            writer.uint32(10).string(message.communityTax);
          }
          if (message.baseProposerReward !== "") {
            writer.uint32(18).string(message.baseProposerReward);
          }
          if (message.bonusProposerReward !== "") {
            writer.uint32(26).string(message.bonusProposerReward);
          }
          if (message.withdrawAddrEnabled === true) {
            writer.uint32(32).bool(message.withdrawAddrEnabled);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseParams);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.communityTax = reader.string();
                break;
              case 2:
                message.baseProposerReward = reader.string();
                break;
              case 3:
                message.bonusProposerReward = reader.string();
                break;
              case 4:
                message.withdrawAddrEnabled = reader.bool();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseParams);
          message.communityTax = object.communityTax !== void 0 && object.communityTax !== null ? String(object.communityTax) : "";
          message.baseProposerReward = object.baseProposerReward !== void 0 && object.baseProposerReward !== null ? String(object.baseProposerReward) : "";
          message.bonusProposerReward = object.bonusProposerReward !== void 0 && object.bonusProposerReward !== null ? String(object.bonusProposerReward) : "";
          message.withdrawAddrEnabled = object.withdrawAddrEnabled !== void 0 && object.withdrawAddrEnabled !== null ? Boolean(object.withdrawAddrEnabled) : false;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.communityTax !== void 0 && (obj.communityTax = message.communityTax);
          message.baseProposerReward !== void 0 && (obj.baseProposerReward = message.baseProposerReward);
          message.bonusProposerReward !== void 0 && (obj.bonusProposerReward = message.bonusProposerReward);
          message.withdrawAddrEnabled !== void 0 && (obj.withdrawAddrEnabled = message.withdrawAddrEnabled);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c, _d;
          const message = Object.assign({}, baseParams);
          message.communityTax = (_a = object.communityTax) !== null && _a !== void 0 ? _a : "";
          message.baseProposerReward = (_b = object.baseProposerReward) !== null && _b !== void 0 ? _b : "";
          message.bonusProposerReward = (_c = object.bonusProposerReward) !== null && _c !== void 0 ? _c : "";
          message.withdrawAddrEnabled = (_d = object.withdrawAddrEnabled) !== null && _d !== void 0 ? _d : false;
          return message;
        }
      };
      var baseValidatorHistoricalRewards = { referenceCount: 0 };
      exports2.ValidatorHistoricalRewards = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.cumulativeRewardRatio) {
            coin_1.DecCoin.encode(v, writer.uint32(10).fork()).ldelim();
          }
          if (message.referenceCount !== 0) {
            writer.uint32(16).uint32(message.referenceCount);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseValidatorHistoricalRewards);
          message.cumulativeRewardRatio = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.cumulativeRewardRatio.push(coin_1.DecCoin.decode(reader, reader.uint32()));
                break;
              case 2:
                message.referenceCount = reader.uint32();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseValidatorHistoricalRewards);
          message.cumulativeRewardRatio = ((_a = object.cumulativeRewardRatio) !== null && _a !== void 0 ? _a : []).map((e) => coin_1.DecCoin.fromJSON(e));
          message.referenceCount = object.referenceCount !== void 0 && object.referenceCount !== null ? Number(object.referenceCount) : 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.cumulativeRewardRatio) {
            obj.cumulativeRewardRatio = message.cumulativeRewardRatio.map((e) => e ? coin_1.DecCoin.toJSON(e) : void 0);
          } else {
            obj.cumulativeRewardRatio = [];
          }
          message.referenceCount !== void 0 && (obj.referenceCount = message.referenceCount);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseValidatorHistoricalRewards);
          message.cumulativeRewardRatio = ((_a = object.cumulativeRewardRatio) === null || _a === void 0 ? void 0 : _a.map((e) => coin_1.DecCoin.fromPartial(e))) || [];
          message.referenceCount = (_b = object.referenceCount) !== null && _b !== void 0 ? _b : 0;
          return message;
        }
      };
      var baseValidatorCurrentRewards = { period: long_1.default.UZERO };
      exports2.ValidatorCurrentRewards = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.rewards) {
            coin_1.DecCoin.encode(v, writer.uint32(10).fork()).ldelim();
          }
          if (!message.period.isZero()) {
            writer.uint32(16).uint64(message.period);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseValidatorCurrentRewards);
          message.rewards = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.rewards.push(coin_1.DecCoin.decode(reader, reader.uint32()));
                break;
              case 2:
                message.period = reader.uint64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseValidatorCurrentRewards);
          message.rewards = ((_a = object.rewards) !== null && _a !== void 0 ? _a : []).map((e) => coin_1.DecCoin.fromJSON(e));
          message.period = object.period !== void 0 && object.period !== null ? long_1.default.fromString(object.period) : long_1.default.UZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.rewards) {
            obj.rewards = message.rewards.map((e) => e ? coin_1.DecCoin.toJSON(e) : void 0);
          } else {
            obj.rewards = [];
          }
          message.period !== void 0 && (obj.period = (message.period || long_1.default.UZERO).toString());
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseValidatorCurrentRewards);
          message.rewards = ((_a = object.rewards) === null || _a === void 0 ? void 0 : _a.map((e) => coin_1.DecCoin.fromPartial(e))) || [];
          message.period = object.period !== void 0 && object.period !== null ? long_1.default.fromValue(object.period) : long_1.default.UZERO;
          return message;
        }
      };
      var baseValidatorAccumulatedCommission = {};
      exports2.ValidatorAccumulatedCommission = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.commission) {
            coin_1.DecCoin.encode(v, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseValidatorAccumulatedCommission);
          message.commission = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.commission.push(coin_1.DecCoin.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseValidatorAccumulatedCommission);
          message.commission = ((_a = object.commission) !== null && _a !== void 0 ? _a : []).map((e) => coin_1.DecCoin.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.commission) {
            obj.commission = message.commission.map((e) => e ? coin_1.DecCoin.toJSON(e) : void 0);
          } else {
            obj.commission = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseValidatorAccumulatedCommission);
          message.commission = ((_a = object.commission) === null || _a === void 0 ? void 0 : _a.map((e) => coin_1.DecCoin.fromPartial(e))) || [];
          return message;
        }
      };
      var baseValidatorOutstandingRewards = {};
      exports2.ValidatorOutstandingRewards = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.rewards) {
            coin_1.DecCoin.encode(v, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseValidatorOutstandingRewards);
          message.rewards = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.rewards.push(coin_1.DecCoin.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseValidatorOutstandingRewards);
          message.rewards = ((_a = object.rewards) !== null && _a !== void 0 ? _a : []).map((e) => coin_1.DecCoin.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.rewards) {
            obj.rewards = message.rewards.map((e) => e ? coin_1.DecCoin.toJSON(e) : void 0);
          } else {
            obj.rewards = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseValidatorOutstandingRewards);
          message.rewards = ((_a = object.rewards) === null || _a === void 0 ? void 0 : _a.map((e) => coin_1.DecCoin.fromPartial(e))) || [];
          return message;
        }
      };
      var baseValidatorSlashEvent = { validatorPeriod: long_1.default.UZERO, fraction: "" };
      exports2.ValidatorSlashEvent = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.validatorPeriod.isZero()) {
            writer.uint32(8).uint64(message.validatorPeriod);
          }
          if (message.fraction !== "") {
            writer.uint32(18).string(message.fraction);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseValidatorSlashEvent);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.validatorPeriod = reader.uint64();
                break;
              case 2:
                message.fraction = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseValidatorSlashEvent);
          message.validatorPeriod = object.validatorPeriod !== void 0 && object.validatorPeriod !== null ? long_1.default.fromString(object.validatorPeriod) : long_1.default.UZERO;
          message.fraction = object.fraction !== void 0 && object.fraction !== null ? String(object.fraction) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.validatorPeriod !== void 0 && (obj.validatorPeriod = (message.validatorPeriod || long_1.default.UZERO).toString());
          message.fraction !== void 0 && (obj.fraction = message.fraction);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseValidatorSlashEvent);
          message.validatorPeriod = object.validatorPeriod !== void 0 && object.validatorPeriod !== null ? long_1.default.fromValue(object.validatorPeriod) : long_1.default.UZERO;
          message.fraction = (_a = object.fraction) !== null && _a !== void 0 ? _a : "";
          return message;
        }
      };
      var baseValidatorSlashEvents = {};
      exports2.ValidatorSlashEvents = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.validatorSlashEvents) {
            exports2.ValidatorSlashEvent.encode(v, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseValidatorSlashEvents);
          message.validatorSlashEvents = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.validatorSlashEvents.push(exports2.ValidatorSlashEvent.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseValidatorSlashEvents);
          message.validatorSlashEvents = ((_a = object.validatorSlashEvents) !== null && _a !== void 0 ? _a : []).map((e) => exports2.ValidatorSlashEvent.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.validatorSlashEvents) {
            obj.validatorSlashEvents = message.validatorSlashEvents.map((e) => e ? exports2.ValidatorSlashEvent.toJSON(e) : void 0);
          } else {
            obj.validatorSlashEvents = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseValidatorSlashEvents);
          message.validatorSlashEvents = ((_a = object.validatorSlashEvents) === null || _a === void 0 ? void 0 : _a.map((e) => exports2.ValidatorSlashEvent.fromPartial(e))) || [];
          return message;
        }
      };
      var baseFeePool = {};
      exports2.FeePool = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.communityPool) {
            coin_1.DecCoin.encode(v, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseFeePool);
          message.communityPool = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.communityPool.push(coin_1.DecCoin.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseFeePool);
          message.communityPool = ((_a = object.communityPool) !== null && _a !== void 0 ? _a : []).map((e) => coin_1.DecCoin.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.communityPool) {
            obj.communityPool = message.communityPool.map((e) => e ? coin_1.DecCoin.toJSON(e) : void 0);
          } else {
            obj.communityPool = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseFeePool);
          message.communityPool = ((_a = object.communityPool) === null || _a === void 0 ? void 0 : _a.map((e) => coin_1.DecCoin.fromPartial(e))) || [];
          return message;
        }
      };
      var baseCommunityPoolSpendProposal = { title: "", description: "", recipient: "" };
      exports2.CommunityPoolSpendProposal = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.title !== "") {
            writer.uint32(10).string(message.title);
          }
          if (message.description !== "") {
            writer.uint32(18).string(message.description);
          }
          if (message.recipient !== "") {
            writer.uint32(26).string(message.recipient);
          }
          for (const v of message.amount) {
            coin_1.Coin.encode(v, writer.uint32(34).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseCommunityPoolSpendProposal);
          message.amount = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.title = reader.string();
                break;
              case 2:
                message.description = reader.string();
                break;
              case 3:
                message.recipient = reader.string();
                break;
              case 4:
                message.amount.push(coin_1.Coin.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseCommunityPoolSpendProposal);
          message.title = object.title !== void 0 && object.title !== null ? String(object.title) : "";
          message.description = object.description !== void 0 && object.description !== null ? String(object.description) : "";
          message.recipient = object.recipient !== void 0 && object.recipient !== null ? String(object.recipient) : "";
          message.amount = ((_a = object.amount) !== null && _a !== void 0 ? _a : []).map((e) => coin_1.Coin.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.title !== void 0 && (obj.title = message.title);
          message.description !== void 0 && (obj.description = message.description);
          message.recipient !== void 0 && (obj.recipient = message.recipient);
          if (message.amount) {
            obj.amount = message.amount.map((e) => e ? coin_1.Coin.toJSON(e) : void 0);
          } else {
            obj.amount = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c, _d;
          const message = Object.assign({}, baseCommunityPoolSpendProposal);
          message.title = (_a = object.title) !== null && _a !== void 0 ? _a : "";
          message.description = (_b = object.description) !== null && _b !== void 0 ? _b : "";
          message.recipient = (_c = object.recipient) !== null && _c !== void 0 ? _c : "";
          message.amount = ((_d = object.amount) === null || _d === void 0 ? void 0 : _d.map((e) => coin_1.Coin.fromPartial(e))) || [];
          return message;
        }
      };
      var baseDelegatorStartingInfo = { previousPeriod: long_1.default.UZERO, stake: "", height: long_1.default.UZERO };
      exports2.DelegatorStartingInfo = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.previousPeriod.isZero()) {
            writer.uint32(8).uint64(message.previousPeriod);
          }
          if (message.stake !== "") {
            writer.uint32(18).string(message.stake);
          }
          if (!message.height.isZero()) {
            writer.uint32(24).uint64(message.height);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseDelegatorStartingInfo);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.previousPeriod = reader.uint64();
                break;
              case 2:
                message.stake = reader.string();
                break;
              case 3:
                message.height = reader.uint64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseDelegatorStartingInfo);
          message.previousPeriod = object.previousPeriod !== void 0 && object.previousPeriod !== null ? long_1.default.fromString(object.previousPeriod) : long_1.default.UZERO;
          message.stake = object.stake !== void 0 && object.stake !== null ? String(object.stake) : "";
          message.height = object.height !== void 0 && object.height !== null ? long_1.default.fromString(object.height) : long_1.default.UZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.previousPeriod !== void 0 && (obj.previousPeriod = (message.previousPeriod || long_1.default.UZERO).toString());
          message.stake !== void 0 && (obj.stake = message.stake);
          message.height !== void 0 && (obj.height = (message.height || long_1.default.UZERO).toString());
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseDelegatorStartingInfo);
          message.previousPeriod = object.previousPeriod !== void 0 && object.previousPeriod !== null ? long_1.default.fromValue(object.previousPeriod) : long_1.default.UZERO;
          message.stake = (_a = object.stake) !== null && _a !== void 0 ? _a : "";
          message.height = object.height !== void 0 && object.height !== null ? long_1.default.fromValue(object.height) : long_1.default.UZERO;
          return message;
        }
      };
      var baseDelegationDelegatorReward = { validatorAddress: "" };
      exports2.DelegationDelegatorReward = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.validatorAddress !== "") {
            writer.uint32(10).string(message.validatorAddress);
          }
          for (const v of message.reward) {
            coin_1.DecCoin.encode(v, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseDelegationDelegatorReward);
          message.reward = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.validatorAddress = reader.string();
                break;
              case 2:
                message.reward.push(coin_1.DecCoin.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseDelegationDelegatorReward);
          message.validatorAddress = object.validatorAddress !== void 0 && object.validatorAddress !== null ? String(object.validatorAddress) : "";
          message.reward = ((_a = object.reward) !== null && _a !== void 0 ? _a : []).map((e) => coin_1.DecCoin.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.validatorAddress !== void 0 && (obj.validatorAddress = message.validatorAddress);
          if (message.reward) {
            obj.reward = message.reward.map((e) => e ? coin_1.DecCoin.toJSON(e) : void 0);
          } else {
            obj.reward = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseDelegationDelegatorReward);
          message.validatorAddress = (_a = object.validatorAddress) !== null && _a !== void 0 ? _a : "";
          message.reward = ((_b = object.reward) === null || _b === void 0 ? void 0 : _b.map((e) => coin_1.DecCoin.fromPartial(e))) || [];
          return message;
        }
      };
      var baseCommunityPoolSpendProposalWithDeposit = {
        title: "",
        description: "",
        recipient: "",
        amount: "",
        deposit: ""
      };
      exports2.CommunityPoolSpendProposalWithDeposit = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.title !== "") {
            writer.uint32(10).string(message.title);
          }
          if (message.description !== "") {
            writer.uint32(18).string(message.description);
          }
          if (message.recipient !== "") {
            writer.uint32(26).string(message.recipient);
          }
          if (message.amount !== "") {
            writer.uint32(34).string(message.amount);
          }
          if (message.deposit !== "") {
            writer.uint32(42).string(message.deposit);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseCommunityPoolSpendProposalWithDeposit);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.title = reader.string();
                break;
              case 2:
                message.description = reader.string();
                break;
              case 3:
                message.recipient = reader.string();
                break;
              case 4:
                message.amount = reader.string();
                break;
              case 5:
                message.deposit = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseCommunityPoolSpendProposalWithDeposit);
          message.title = object.title !== void 0 && object.title !== null ? String(object.title) : "";
          message.description = object.description !== void 0 && object.description !== null ? String(object.description) : "";
          message.recipient = object.recipient !== void 0 && object.recipient !== null ? String(object.recipient) : "";
          message.amount = object.amount !== void 0 && object.amount !== null ? String(object.amount) : "";
          message.deposit = object.deposit !== void 0 && object.deposit !== null ? String(object.deposit) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.title !== void 0 && (obj.title = message.title);
          message.description !== void 0 && (obj.description = message.description);
          message.recipient !== void 0 && (obj.recipient = message.recipient);
          message.amount !== void 0 && (obj.amount = message.amount);
          message.deposit !== void 0 && (obj.deposit = message.deposit);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c, _d, _e;
          const message = Object.assign({}, baseCommunityPoolSpendProposalWithDeposit);
          message.title = (_a = object.title) !== null && _a !== void 0 ? _a : "";
          message.description = (_b = object.description) !== null && _b !== void 0 ? _b : "";
          message.recipient = (_c = object.recipient) !== null && _c !== void 0 ? _c : "";
          message.amount = (_d = object.amount) !== null && _d !== void 0 ? _d : "";
          message.deposit = (_e = object.deposit) !== null && _e !== void 0 ? _e : "";
          return message;
        }
      };
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/cosmjs-types/cosmos/distribution/v1beta1/query.js
  var require_query3 = __commonJS({
    "node_modules/cosmjs-types/cosmos/distribution/v1beta1/query.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.QueryClientImpl = exports2.QueryCommunityPoolResponse = exports2.QueryCommunityPoolRequest = exports2.QueryDelegatorWithdrawAddressResponse = exports2.QueryDelegatorWithdrawAddressRequest = exports2.QueryDelegatorValidatorsResponse = exports2.QueryDelegatorValidatorsRequest = exports2.QueryDelegationTotalRewardsResponse = exports2.QueryDelegationTotalRewardsRequest = exports2.QueryDelegationRewardsResponse = exports2.QueryDelegationRewardsRequest = exports2.QueryValidatorSlashesResponse = exports2.QueryValidatorSlashesRequest = exports2.QueryValidatorCommissionResponse = exports2.QueryValidatorCommissionRequest = exports2.QueryValidatorOutstandingRewardsResponse = exports2.QueryValidatorOutstandingRewardsRequest = exports2.QueryParamsResponse = exports2.QueryParamsRequest = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var distribution_1 = require_distribution();
      var pagination_1 = require_pagination();
      var coin_1 = require_coin();
      exports2.protobufPackage = "cosmos.distribution.v1beta1";
      var baseQueryParamsRequest = {};
      exports2.QueryParamsRequest = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryParamsRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseQueryParamsRequest);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseQueryParamsRequest);
          return message;
        }
      };
      var baseQueryParamsResponse = {};
      exports2.QueryParamsResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.params !== void 0) {
            distribution_1.Params.encode(message.params, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryParamsResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.params = distribution_1.Params.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryParamsResponse);
          message.params = object.params !== void 0 && object.params !== null ? distribution_1.Params.fromJSON(object.params) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.params !== void 0 && (obj.params = message.params ? distribution_1.Params.toJSON(message.params) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryParamsResponse);
          message.params = object.params !== void 0 && object.params !== null ? distribution_1.Params.fromPartial(object.params) : void 0;
          return message;
        }
      };
      var baseQueryValidatorOutstandingRewardsRequest = { validatorAddress: "" };
      exports2.QueryValidatorOutstandingRewardsRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.validatorAddress !== "") {
            writer.uint32(10).string(message.validatorAddress);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryValidatorOutstandingRewardsRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.validatorAddress = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryValidatorOutstandingRewardsRequest);
          message.validatorAddress = object.validatorAddress !== void 0 && object.validatorAddress !== null ? String(object.validatorAddress) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.validatorAddress !== void 0 && (obj.validatorAddress = message.validatorAddress);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryValidatorOutstandingRewardsRequest);
          message.validatorAddress = (_a = object.validatorAddress) !== null && _a !== void 0 ? _a : "";
          return message;
        }
      };
      var baseQueryValidatorOutstandingRewardsResponse = {};
      exports2.QueryValidatorOutstandingRewardsResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.rewards !== void 0) {
            distribution_1.ValidatorOutstandingRewards.encode(message.rewards, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryValidatorOutstandingRewardsResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.rewards = distribution_1.ValidatorOutstandingRewards.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryValidatorOutstandingRewardsResponse);
          message.rewards = object.rewards !== void 0 && object.rewards !== null ? distribution_1.ValidatorOutstandingRewards.fromJSON(object.rewards) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.rewards !== void 0 && (obj.rewards = message.rewards ? distribution_1.ValidatorOutstandingRewards.toJSON(message.rewards) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryValidatorOutstandingRewardsResponse);
          message.rewards = object.rewards !== void 0 && object.rewards !== null ? distribution_1.ValidatorOutstandingRewards.fromPartial(object.rewards) : void 0;
          return message;
        }
      };
      var baseQueryValidatorCommissionRequest = { validatorAddress: "" };
      exports2.QueryValidatorCommissionRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.validatorAddress !== "") {
            writer.uint32(10).string(message.validatorAddress);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryValidatorCommissionRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.validatorAddress = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryValidatorCommissionRequest);
          message.validatorAddress = object.validatorAddress !== void 0 && object.validatorAddress !== null ? String(object.validatorAddress) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.validatorAddress !== void 0 && (obj.validatorAddress = message.validatorAddress);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryValidatorCommissionRequest);
          message.validatorAddress = (_a = object.validatorAddress) !== null && _a !== void 0 ? _a : "";
          return message;
        }
      };
      var baseQueryValidatorCommissionResponse = {};
      exports2.QueryValidatorCommissionResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.commission !== void 0) {
            distribution_1.ValidatorAccumulatedCommission.encode(message.commission, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryValidatorCommissionResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.commission = distribution_1.ValidatorAccumulatedCommission.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryValidatorCommissionResponse);
          message.commission = object.commission !== void 0 && object.commission !== null ? distribution_1.ValidatorAccumulatedCommission.fromJSON(object.commission) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.commission !== void 0 && (obj.commission = message.commission ? distribution_1.ValidatorAccumulatedCommission.toJSON(message.commission) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryValidatorCommissionResponse);
          message.commission = object.commission !== void 0 && object.commission !== null ? distribution_1.ValidatorAccumulatedCommission.fromPartial(object.commission) : void 0;
          return message;
        }
      };
      var baseQueryValidatorSlashesRequest = {
        validatorAddress: "",
        startingHeight: long_1.default.UZERO,
        endingHeight: long_1.default.UZERO
      };
      exports2.QueryValidatorSlashesRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.validatorAddress !== "") {
            writer.uint32(10).string(message.validatorAddress);
          }
          if (!message.startingHeight.isZero()) {
            writer.uint32(16).uint64(message.startingHeight);
          }
          if (!message.endingHeight.isZero()) {
            writer.uint32(24).uint64(message.endingHeight);
          }
          if (message.pagination !== void 0) {
            pagination_1.PageRequest.encode(message.pagination, writer.uint32(34).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryValidatorSlashesRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.validatorAddress = reader.string();
                break;
              case 2:
                message.startingHeight = reader.uint64();
                break;
              case 3:
                message.endingHeight = reader.uint64();
                break;
              case 4:
                message.pagination = pagination_1.PageRequest.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryValidatorSlashesRequest);
          message.validatorAddress = object.validatorAddress !== void 0 && object.validatorAddress !== null ? String(object.validatorAddress) : "";
          message.startingHeight = object.startingHeight !== void 0 && object.startingHeight !== null ? long_1.default.fromString(object.startingHeight) : long_1.default.UZERO;
          message.endingHeight = object.endingHeight !== void 0 && object.endingHeight !== null ? long_1.default.fromString(object.endingHeight) : long_1.default.UZERO;
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.validatorAddress !== void 0 && (obj.validatorAddress = message.validatorAddress);
          message.startingHeight !== void 0 && (obj.startingHeight = (message.startingHeight || long_1.default.UZERO).toString());
          message.endingHeight !== void 0 && (obj.endingHeight = (message.endingHeight || long_1.default.UZERO).toString());
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageRequest.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryValidatorSlashesRequest);
          message.validatorAddress = (_a = object.validatorAddress) !== null && _a !== void 0 ? _a : "";
          message.startingHeight = object.startingHeight !== void 0 && object.startingHeight !== null ? long_1.default.fromValue(object.startingHeight) : long_1.default.UZERO;
          message.endingHeight = object.endingHeight !== void 0 && object.endingHeight !== null ? long_1.default.fromValue(object.endingHeight) : long_1.default.UZERO;
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryValidatorSlashesResponse = {};
      exports2.QueryValidatorSlashesResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.slashes) {
            distribution_1.ValidatorSlashEvent.encode(v, writer.uint32(10).fork()).ldelim();
          }
          if (message.pagination !== void 0) {
            pagination_1.PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryValidatorSlashesResponse);
          message.slashes = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.slashes.push(distribution_1.ValidatorSlashEvent.decode(reader, reader.uint32()));
                break;
              case 2:
                message.pagination = pagination_1.PageResponse.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseQueryValidatorSlashesResponse);
          message.slashes = ((_a = object.slashes) !== null && _a !== void 0 ? _a : []).map((e) => distribution_1.ValidatorSlashEvent.fromJSON(e));
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.slashes) {
            obj.slashes = message.slashes.map((e) => e ? distribution_1.ValidatorSlashEvent.toJSON(e) : void 0);
          } else {
            obj.slashes = [];
          }
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageResponse.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryValidatorSlashesResponse);
          message.slashes = ((_a = object.slashes) === null || _a === void 0 ? void 0 : _a.map((e) => distribution_1.ValidatorSlashEvent.fromPartial(e))) || [];
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryDelegationRewardsRequest = { delegatorAddress: "", validatorAddress: "" };
      exports2.QueryDelegationRewardsRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.delegatorAddress !== "") {
            writer.uint32(10).string(message.delegatorAddress);
          }
          if (message.validatorAddress !== "") {
            writer.uint32(18).string(message.validatorAddress);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryDelegationRewardsRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.delegatorAddress = reader.string();
                break;
              case 2:
                message.validatorAddress = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryDelegationRewardsRequest);
          message.delegatorAddress = object.delegatorAddress !== void 0 && object.delegatorAddress !== null ? String(object.delegatorAddress) : "";
          message.validatorAddress = object.validatorAddress !== void 0 && object.validatorAddress !== null ? String(object.validatorAddress) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.delegatorAddress !== void 0 && (obj.delegatorAddress = message.delegatorAddress);
          message.validatorAddress !== void 0 && (obj.validatorAddress = message.validatorAddress);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseQueryDelegationRewardsRequest);
          message.delegatorAddress = (_a = object.delegatorAddress) !== null && _a !== void 0 ? _a : "";
          message.validatorAddress = (_b = object.validatorAddress) !== null && _b !== void 0 ? _b : "";
          return message;
        }
      };
      var baseQueryDelegationRewardsResponse = {};
      exports2.QueryDelegationRewardsResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.rewards) {
            coin_1.DecCoin.encode(v, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryDelegationRewardsResponse);
          message.rewards = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.rewards.push(coin_1.DecCoin.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseQueryDelegationRewardsResponse);
          message.rewards = ((_a = object.rewards) !== null && _a !== void 0 ? _a : []).map((e) => coin_1.DecCoin.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.rewards) {
            obj.rewards = message.rewards.map((e) => e ? coin_1.DecCoin.toJSON(e) : void 0);
          } else {
            obj.rewards = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryDelegationRewardsResponse);
          message.rewards = ((_a = object.rewards) === null || _a === void 0 ? void 0 : _a.map((e) => coin_1.DecCoin.fromPartial(e))) || [];
          return message;
        }
      };
      var baseQueryDelegationTotalRewardsRequest = { delegatorAddress: "" };
      exports2.QueryDelegationTotalRewardsRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.delegatorAddress !== "") {
            writer.uint32(10).string(message.delegatorAddress);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryDelegationTotalRewardsRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.delegatorAddress = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryDelegationTotalRewardsRequest);
          message.delegatorAddress = object.delegatorAddress !== void 0 && object.delegatorAddress !== null ? String(object.delegatorAddress) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.delegatorAddress !== void 0 && (obj.delegatorAddress = message.delegatorAddress);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryDelegationTotalRewardsRequest);
          message.delegatorAddress = (_a = object.delegatorAddress) !== null && _a !== void 0 ? _a : "";
          return message;
        }
      };
      var baseQueryDelegationTotalRewardsResponse = {};
      exports2.QueryDelegationTotalRewardsResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.rewards) {
            distribution_1.DelegationDelegatorReward.encode(v, writer.uint32(10).fork()).ldelim();
          }
          for (const v of message.total) {
            coin_1.DecCoin.encode(v, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryDelegationTotalRewardsResponse);
          message.rewards = [];
          message.total = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.rewards.push(distribution_1.DelegationDelegatorReward.decode(reader, reader.uint32()));
                break;
              case 2:
                message.total.push(coin_1.DecCoin.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a, _b;
          const message = Object.assign({}, baseQueryDelegationTotalRewardsResponse);
          message.rewards = ((_a = object.rewards) !== null && _a !== void 0 ? _a : []).map((e) => distribution_1.DelegationDelegatorReward.fromJSON(e));
          message.total = ((_b = object.total) !== null && _b !== void 0 ? _b : []).map((e) => coin_1.DecCoin.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.rewards) {
            obj.rewards = message.rewards.map((e) => e ? distribution_1.DelegationDelegatorReward.toJSON(e) : void 0);
          } else {
            obj.rewards = [];
          }
          if (message.total) {
            obj.total = message.total.map((e) => e ? coin_1.DecCoin.toJSON(e) : void 0);
          } else {
            obj.total = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseQueryDelegationTotalRewardsResponse);
          message.rewards = ((_a = object.rewards) === null || _a === void 0 ? void 0 : _a.map((e) => distribution_1.DelegationDelegatorReward.fromPartial(e))) || [];
          message.total = ((_b = object.total) === null || _b === void 0 ? void 0 : _b.map((e) => coin_1.DecCoin.fromPartial(e))) || [];
          return message;
        }
      };
      var baseQueryDelegatorValidatorsRequest = { delegatorAddress: "" };
      exports2.QueryDelegatorValidatorsRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.delegatorAddress !== "") {
            writer.uint32(10).string(message.delegatorAddress);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryDelegatorValidatorsRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.delegatorAddress = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryDelegatorValidatorsRequest);
          message.delegatorAddress = object.delegatorAddress !== void 0 && object.delegatorAddress !== null ? String(object.delegatorAddress) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.delegatorAddress !== void 0 && (obj.delegatorAddress = message.delegatorAddress);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryDelegatorValidatorsRequest);
          message.delegatorAddress = (_a = object.delegatorAddress) !== null && _a !== void 0 ? _a : "";
          return message;
        }
      };
      var baseQueryDelegatorValidatorsResponse = { validators: "" };
      exports2.QueryDelegatorValidatorsResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.validators) {
            writer.uint32(10).string(v);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryDelegatorValidatorsResponse);
          message.validators = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.validators.push(reader.string());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseQueryDelegatorValidatorsResponse);
          message.validators = ((_a = object.validators) !== null && _a !== void 0 ? _a : []).map((e) => String(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.validators) {
            obj.validators = message.validators.map((e) => e);
          } else {
            obj.validators = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryDelegatorValidatorsResponse);
          message.validators = ((_a = object.validators) === null || _a === void 0 ? void 0 : _a.map((e) => e)) || [];
          return message;
        }
      };
      var baseQueryDelegatorWithdrawAddressRequest = { delegatorAddress: "" };
      exports2.QueryDelegatorWithdrawAddressRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.delegatorAddress !== "") {
            writer.uint32(10).string(message.delegatorAddress);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryDelegatorWithdrawAddressRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.delegatorAddress = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryDelegatorWithdrawAddressRequest);
          message.delegatorAddress = object.delegatorAddress !== void 0 && object.delegatorAddress !== null ? String(object.delegatorAddress) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.delegatorAddress !== void 0 && (obj.delegatorAddress = message.delegatorAddress);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryDelegatorWithdrawAddressRequest);
          message.delegatorAddress = (_a = object.delegatorAddress) !== null && _a !== void 0 ? _a : "";
          return message;
        }
      };
      var baseQueryDelegatorWithdrawAddressResponse = { withdrawAddress: "" };
      exports2.QueryDelegatorWithdrawAddressResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.withdrawAddress !== "") {
            writer.uint32(10).string(message.withdrawAddress);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryDelegatorWithdrawAddressResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.withdrawAddress = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryDelegatorWithdrawAddressResponse);
          message.withdrawAddress = object.withdrawAddress !== void 0 && object.withdrawAddress !== null ? String(object.withdrawAddress) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.withdrawAddress !== void 0 && (obj.withdrawAddress = message.withdrawAddress);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryDelegatorWithdrawAddressResponse);
          message.withdrawAddress = (_a = object.withdrawAddress) !== null && _a !== void 0 ? _a : "";
          return message;
        }
      };
      var baseQueryCommunityPoolRequest = {};
      exports2.QueryCommunityPoolRequest = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryCommunityPoolRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseQueryCommunityPoolRequest);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseQueryCommunityPoolRequest);
          return message;
        }
      };
      var baseQueryCommunityPoolResponse = {};
      exports2.QueryCommunityPoolResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.pool) {
            coin_1.DecCoin.encode(v, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryCommunityPoolResponse);
          message.pool = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.pool.push(coin_1.DecCoin.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseQueryCommunityPoolResponse);
          message.pool = ((_a = object.pool) !== null && _a !== void 0 ? _a : []).map((e) => coin_1.DecCoin.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.pool) {
            obj.pool = message.pool.map((e) => e ? coin_1.DecCoin.toJSON(e) : void 0);
          } else {
            obj.pool = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryCommunityPoolResponse);
          message.pool = ((_a = object.pool) === null || _a === void 0 ? void 0 : _a.map((e) => coin_1.DecCoin.fromPartial(e))) || [];
          return message;
        }
      };
      var QueryClientImpl = class {
        constructor(rpc) {
          this.rpc = rpc;
          this.Params = this.Params.bind(this);
          this.ValidatorOutstandingRewards = this.ValidatorOutstandingRewards.bind(this);
          this.ValidatorCommission = this.ValidatorCommission.bind(this);
          this.ValidatorSlashes = this.ValidatorSlashes.bind(this);
          this.DelegationRewards = this.DelegationRewards.bind(this);
          this.DelegationTotalRewards = this.DelegationTotalRewards.bind(this);
          this.DelegatorValidators = this.DelegatorValidators.bind(this);
          this.DelegatorWithdrawAddress = this.DelegatorWithdrawAddress.bind(this);
          this.CommunityPool = this.CommunityPool.bind(this);
        }
        Params(request) {
          const data = exports2.QueryParamsRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.distribution.v1beta1.Query", "Params", data);
          return promise.then((data2) => exports2.QueryParamsResponse.decode(new minimal_1.default.Reader(data2)));
        }
        ValidatorOutstandingRewards(request) {
          const data = exports2.QueryValidatorOutstandingRewardsRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.distribution.v1beta1.Query", "ValidatorOutstandingRewards", data);
          return promise.then((data2) => exports2.QueryValidatorOutstandingRewardsResponse.decode(new minimal_1.default.Reader(data2)));
        }
        ValidatorCommission(request) {
          const data = exports2.QueryValidatorCommissionRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.distribution.v1beta1.Query", "ValidatorCommission", data);
          return promise.then((data2) => exports2.QueryValidatorCommissionResponse.decode(new minimal_1.default.Reader(data2)));
        }
        ValidatorSlashes(request) {
          const data = exports2.QueryValidatorSlashesRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.distribution.v1beta1.Query", "ValidatorSlashes", data);
          return promise.then((data2) => exports2.QueryValidatorSlashesResponse.decode(new minimal_1.default.Reader(data2)));
        }
        DelegationRewards(request) {
          const data = exports2.QueryDelegationRewardsRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.distribution.v1beta1.Query", "DelegationRewards", data);
          return promise.then((data2) => exports2.QueryDelegationRewardsResponse.decode(new minimal_1.default.Reader(data2)));
        }
        DelegationTotalRewards(request) {
          const data = exports2.QueryDelegationTotalRewardsRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.distribution.v1beta1.Query", "DelegationTotalRewards", data);
          return promise.then((data2) => exports2.QueryDelegationTotalRewardsResponse.decode(new minimal_1.default.Reader(data2)));
        }
        DelegatorValidators(request) {
          const data = exports2.QueryDelegatorValidatorsRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.distribution.v1beta1.Query", "DelegatorValidators", data);
          return promise.then((data2) => exports2.QueryDelegatorValidatorsResponse.decode(new minimal_1.default.Reader(data2)));
        }
        DelegatorWithdrawAddress(request) {
          const data = exports2.QueryDelegatorWithdrawAddressRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.distribution.v1beta1.Query", "DelegatorWithdrawAddress", data);
          return promise.then((data2) => exports2.QueryDelegatorWithdrawAddressResponse.decode(new minimal_1.default.Reader(data2)));
        }
        CommunityPool(request) {
          const data = exports2.QueryCommunityPoolRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.distribution.v1beta1.Query", "CommunityPool", data);
          return promise.then((data2) => exports2.QueryCommunityPoolResponse.decode(new minimal_1.default.Reader(data2)));
        }
      };
      exports2.QueryClientImpl = QueryClientImpl;
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/@cosmjs/stargate/build/modules/distribution/queries.js
  var require_queries3 = __commonJS({
    "node_modules/@cosmjs/stargate/build/modules/distribution/queries.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.setupDistributionExtension = void 0;
      var query_1 = require_query3();
      var long_1 = __importDefault(require_long());
      var queryclient_1 = require_queryclient2();
      function setupDistributionExtension(base) {
        const rpc = (0, queryclient_1.createProtobufRpcClient)(base);
        const queryService = new query_1.QueryClientImpl(rpc);
        return {
          distribution: {
            communityPool: async () => {
              const response = await queryService.CommunityPool({});
              return response;
            },
            delegationRewards: async (delegatorAddress, validatorAddress) => {
              const response = await queryService.DelegationRewards({
                delegatorAddress,
                validatorAddress
              });
              return response;
            },
            delegationTotalRewards: async (delegatorAddress) => {
              const response = await queryService.DelegationTotalRewards({
                delegatorAddress
              });
              return response;
            },
            delegatorValidators: async (delegatorAddress) => {
              const response = await queryService.DelegatorValidators({
                delegatorAddress
              });
              return response;
            },
            delegatorWithdrawAddress: async (delegatorAddress) => {
              const response = await queryService.DelegatorWithdrawAddress({
                delegatorAddress
              });
              return response;
            },
            params: async () => {
              const response = await queryService.Params({});
              return response;
            },
            validatorCommission: async (validatorAddress) => {
              const response = await queryService.ValidatorCommission({
                validatorAddress
              });
              return response;
            },
            validatorOutstandingRewards: async (validatorAddress) => {
              const response = await queryService.ValidatorOutstandingRewards({
                validatorAddress
              });
              return response;
            },
            validatorSlashes: async (validatorAddress, startingHeight, endingHeight, paginationKey) => {
              const response = await queryService.ValidatorSlashes({
                validatorAddress,
                startingHeight: long_1.default.fromNumber(startingHeight, true),
                endingHeight: long_1.default.fromNumber(endingHeight, true),
                pagination: (0, queryclient_1.createPagination)(paginationKey)
              });
              return response;
            }
          }
        };
      }
      exports2.setupDistributionExtension = setupDistributionExtension;
    }
  });

  // node_modules/@cosmjs/stargate/build/modules/evidence/aminomessages.js
  var require_aminomessages5 = __commonJS({
    "node_modules/@cosmjs/stargate/build/modules/evidence/aminomessages.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.createEvidenceAminoConverters = exports2.isAminoMsgSubmitEvidence = void 0;
      function isAminoMsgSubmitEvidence(msg) {
        return msg.type === "cosmos-sdk/MsgSubmitEvidence";
      }
      exports2.isAminoMsgSubmitEvidence = isAminoMsgSubmitEvidence;
      function createEvidenceAminoConverters() {
        throw new Error("Not implemented");
      }
      exports2.createEvidenceAminoConverters = createEvidenceAminoConverters;
    }
  });

  // node_modules/@cosmjs/stargate/build/modules/feegrant/aminomessages.js
  var require_aminomessages6 = __commonJS({
    "node_modules/@cosmjs/stargate/build/modules/feegrant/aminomessages.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.createFreegrantAminoConverters = void 0;
      function createFreegrantAminoConverters() {
        return {
          "/cosmos.feegrant.v1beta1.MsgGrantAllowance": "not_supported_by_chain",
          "/cosmos.feegrant.v1beta1.MsgRevokeAllowance": "not_supported_by_chain"
        };
      }
      exports2.createFreegrantAminoConverters = createFreegrantAminoConverters;
    }
  });

  // node_modules/cosmjs-types/cosmos/feegrant/v1beta1/tx.js
  var require_tx5 = __commonJS({
    "node_modules/cosmjs-types/cosmos/feegrant/v1beta1/tx.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.MsgClientImpl = exports2.MsgRevokeAllowanceResponse = exports2.MsgRevokeAllowance = exports2.MsgGrantAllowanceResponse = exports2.MsgGrantAllowance = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var any_1 = require_any();
      exports2.protobufPackage = "cosmos.feegrant.v1beta1";
      var baseMsgGrantAllowance = { granter: "", grantee: "" };
      exports2.MsgGrantAllowance = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.granter !== "") {
            writer.uint32(10).string(message.granter);
          }
          if (message.grantee !== "") {
            writer.uint32(18).string(message.grantee);
          }
          if (message.allowance !== void 0) {
            any_1.Any.encode(message.allowance, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgGrantAllowance);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.granter = reader.string();
                break;
              case 2:
                message.grantee = reader.string();
                break;
              case 3:
                message.allowance = any_1.Any.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMsgGrantAllowance);
          message.granter = object.granter !== void 0 && object.granter !== null ? String(object.granter) : "";
          message.grantee = object.grantee !== void 0 && object.grantee !== null ? String(object.grantee) : "";
          message.allowance = object.allowance !== void 0 && object.allowance !== null ? any_1.Any.fromJSON(object.allowance) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.granter !== void 0 && (obj.granter = message.granter);
          message.grantee !== void 0 && (obj.grantee = message.grantee);
          message.allowance !== void 0 && (obj.allowance = message.allowance ? any_1.Any.toJSON(message.allowance) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseMsgGrantAllowance);
          message.granter = (_a = object.granter) !== null && _a !== void 0 ? _a : "";
          message.grantee = (_b = object.grantee) !== null && _b !== void 0 ? _b : "";
          message.allowance = object.allowance !== void 0 && object.allowance !== null ? any_1.Any.fromPartial(object.allowance) : void 0;
          return message;
        }
      };
      var baseMsgGrantAllowanceResponse = {};
      exports2.MsgGrantAllowanceResponse = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgGrantAllowanceResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseMsgGrantAllowanceResponse);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseMsgGrantAllowanceResponse);
          return message;
        }
      };
      var baseMsgRevokeAllowance = { granter: "", grantee: "" };
      exports2.MsgRevokeAllowance = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.granter !== "") {
            writer.uint32(10).string(message.granter);
          }
          if (message.grantee !== "") {
            writer.uint32(18).string(message.grantee);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgRevokeAllowance);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.granter = reader.string();
                break;
              case 2:
                message.grantee = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMsgRevokeAllowance);
          message.granter = object.granter !== void 0 && object.granter !== null ? String(object.granter) : "";
          message.grantee = object.grantee !== void 0 && object.grantee !== null ? String(object.grantee) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.granter !== void 0 && (obj.granter = message.granter);
          message.grantee !== void 0 && (obj.grantee = message.grantee);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseMsgRevokeAllowance);
          message.granter = (_a = object.granter) !== null && _a !== void 0 ? _a : "";
          message.grantee = (_b = object.grantee) !== null && _b !== void 0 ? _b : "";
          return message;
        }
      };
      var baseMsgRevokeAllowanceResponse = {};
      exports2.MsgRevokeAllowanceResponse = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgRevokeAllowanceResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseMsgRevokeAllowanceResponse);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseMsgRevokeAllowanceResponse);
          return message;
        }
      };
      var MsgClientImpl = class {
        constructor(rpc) {
          this.rpc = rpc;
          this.GrantAllowance = this.GrantAllowance.bind(this);
          this.RevokeAllowance = this.RevokeAllowance.bind(this);
        }
        GrantAllowance(request) {
          const data = exports2.MsgGrantAllowance.encode(request).finish();
          const promise = this.rpc.request("cosmos.feegrant.v1beta1.Msg", "GrantAllowance", data);
          return promise.then((data2) => exports2.MsgGrantAllowanceResponse.decode(new minimal_1.default.Reader(data2)));
        }
        RevokeAllowance(request) {
          const data = exports2.MsgRevokeAllowance.encode(request).finish();
          const promise = this.rpc.request("cosmos.feegrant.v1beta1.Msg", "RevokeAllowance", data);
          return promise.then((data2) => exports2.MsgRevokeAllowanceResponse.decode(new minimal_1.default.Reader(data2)));
        }
      };
      exports2.MsgClientImpl = MsgClientImpl;
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/@cosmjs/stargate/build/modules/feegrant/messages.js
  var require_messages4 = __commonJS({
    "node_modules/@cosmjs/stargate/build/modules/feegrant/messages.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.feegrantTypes = void 0;
      var tx_1 = require_tx5();
      exports2.feegrantTypes = [
        ["/cosmos.feegrant.v1beta1.MsgGrantAllowance", tx_1.MsgGrantAllowance],
        ["/cosmos.feegrant.v1beta1.MsgRevokeAllowance", tx_1.MsgRevokeAllowance]
      ];
    }
  });

  // node_modules/cosmjs-types/google/protobuf/duration.js
  var require_duration = __commonJS({
    "node_modules/cosmjs-types/google/protobuf/duration.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.Duration = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      exports2.protobufPackage = "google.protobuf";
      var baseDuration = { seconds: long_1.default.ZERO, nanos: 0 };
      exports2.Duration = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.seconds.isZero()) {
            writer.uint32(8).int64(message.seconds);
          }
          if (message.nanos !== 0) {
            writer.uint32(16).int32(message.nanos);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseDuration);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.seconds = reader.int64();
                break;
              case 2:
                message.nanos = reader.int32();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseDuration);
          message.seconds = object.seconds !== void 0 && object.seconds !== null ? long_1.default.fromString(object.seconds) : long_1.default.ZERO;
          message.nanos = object.nanos !== void 0 && object.nanos !== null ? Number(object.nanos) : 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.seconds !== void 0 && (obj.seconds = (message.seconds || long_1.default.ZERO).toString());
          message.nanos !== void 0 && (obj.nanos = message.nanos);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseDuration);
          message.seconds = object.seconds !== void 0 && object.seconds !== null ? long_1.default.fromValue(object.seconds) : long_1.default.ZERO;
          message.nanos = (_a = object.nanos) !== null && _a !== void 0 ? _a : 0;
          return message;
        }
      };
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/cosmjs-types/cosmos/gov/v1beta1/gov.js
  var require_gov = __commonJS({
    "node_modules/cosmjs-types/cosmos/gov/v1beta1/gov.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.TallyParams = exports2.VotingParams = exports2.DepositParams = exports2.Vote = exports2.TallyResult = exports2.Proposal = exports2.Deposit = exports2.TextProposal = exports2.WeightedVoteOption = exports2.proposalStatusToJSON = exports2.proposalStatusFromJSON = exports2.ProposalStatus = exports2.voteOptionToJSON = exports2.voteOptionFromJSON = exports2.VoteOption = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var any_1 = require_any();
      var timestamp_1 = require_timestamp();
      var duration_1 = require_duration();
      var coin_1 = require_coin();
      exports2.protobufPackage = "cosmos.gov.v1beta1";
      var VoteOption;
      (function(VoteOption2) {
        VoteOption2[VoteOption2["VOTE_OPTION_UNSPECIFIED"] = 0] = "VOTE_OPTION_UNSPECIFIED";
        VoteOption2[VoteOption2["VOTE_OPTION_YES"] = 1] = "VOTE_OPTION_YES";
        VoteOption2[VoteOption2["VOTE_OPTION_ABSTAIN"] = 2] = "VOTE_OPTION_ABSTAIN";
        VoteOption2[VoteOption2["VOTE_OPTION_NO"] = 3] = "VOTE_OPTION_NO";
        VoteOption2[VoteOption2["VOTE_OPTION_NO_WITH_VETO"] = 4] = "VOTE_OPTION_NO_WITH_VETO";
        VoteOption2[VoteOption2["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
      })(VoteOption = exports2.VoteOption || (exports2.VoteOption = {}));
      function voteOptionFromJSON(object) {
        switch (object) {
          case 0:
          case "VOTE_OPTION_UNSPECIFIED":
            return VoteOption.VOTE_OPTION_UNSPECIFIED;
          case 1:
          case "VOTE_OPTION_YES":
            return VoteOption.VOTE_OPTION_YES;
          case 2:
          case "VOTE_OPTION_ABSTAIN":
            return VoteOption.VOTE_OPTION_ABSTAIN;
          case 3:
          case "VOTE_OPTION_NO":
            return VoteOption.VOTE_OPTION_NO;
          case 4:
          case "VOTE_OPTION_NO_WITH_VETO":
            return VoteOption.VOTE_OPTION_NO_WITH_VETO;
          case -1:
          case "UNRECOGNIZED":
          default:
            return VoteOption.UNRECOGNIZED;
        }
      }
      exports2.voteOptionFromJSON = voteOptionFromJSON;
      function voteOptionToJSON(object) {
        switch (object) {
          case VoteOption.VOTE_OPTION_UNSPECIFIED:
            return "VOTE_OPTION_UNSPECIFIED";
          case VoteOption.VOTE_OPTION_YES:
            return "VOTE_OPTION_YES";
          case VoteOption.VOTE_OPTION_ABSTAIN:
            return "VOTE_OPTION_ABSTAIN";
          case VoteOption.VOTE_OPTION_NO:
            return "VOTE_OPTION_NO";
          case VoteOption.VOTE_OPTION_NO_WITH_VETO:
            return "VOTE_OPTION_NO_WITH_VETO";
          default:
            return "UNKNOWN";
        }
      }
      exports2.voteOptionToJSON = voteOptionToJSON;
      var ProposalStatus;
      (function(ProposalStatus2) {
        ProposalStatus2[ProposalStatus2["PROPOSAL_STATUS_UNSPECIFIED"] = 0] = "PROPOSAL_STATUS_UNSPECIFIED";
        ProposalStatus2[ProposalStatus2["PROPOSAL_STATUS_DEPOSIT_PERIOD"] = 1] = "PROPOSAL_STATUS_DEPOSIT_PERIOD";
        ProposalStatus2[ProposalStatus2["PROPOSAL_STATUS_VOTING_PERIOD"] = 2] = "PROPOSAL_STATUS_VOTING_PERIOD";
        ProposalStatus2[ProposalStatus2["PROPOSAL_STATUS_PASSED"] = 3] = "PROPOSAL_STATUS_PASSED";
        ProposalStatus2[ProposalStatus2["PROPOSAL_STATUS_REJECTED"] = 4] = "PROPOSAL_STATUS_REJECTED";
        ProposalStatus2[ProposalStatus2["PROPOSAL_STATUS_FAILED"] = 5] = "PROPOSAL_STATUS_FAILED";
        ProposalStatus2[ProposalStatus2["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
      })(ProposalStatus = exports2.ProposalStatus || (exports2.ProposalStatus = {}));
      function proposalStatusFromJSON(object) {
        switch (object) {
          case 0:
          case "PROPOSAL_STATUS_UNSPECIFIED":
            return ProposalStatus.PROPOSAL_STATUS_UNSPECIFIED;
          case 1:
          case "PROPOSAL_STATUS_DEPOSIT_PERIOD":
            return ProposalStatus.PROPOSAL_STATUS_DEPOSIT_PERIOD;
          case 2:
          case "PROPOSAL_STATUS_VOTING_PERIOD":
            return ProposalStatus.PROPOSAL_STATUS_VOTING_PERIOD;
          case 3:
          case "PROPOSAL_STATUS_PASSED":
            return ProposalStatus.PROPOSAL_STATUS_PASSED;
          case 4:
          case "PROPOSAL_STATUS_REJECTED":
            return ProposalStatus.PROPOSAL_STATUS_REJECTED;
          case 5:
          case "PROPOSAL_STATUS_FAILED":
            return ProposalStatus.PROPOSAL_STATUS_FAILED;
          case -1:
          case "UNRECOGNIZED":
          default:
            return ProposalStatus.UNRECOGNIZED;
        }
      }
      exports2.proposalStatusFromJSON = proposalStatusFromJSON;
      function proposalStatusToJSON(object) {
        switch (object) {
          case ProposalStatus.PROPOSAL_STATUS_UNSPECIFIED:
            return "PROPOSAL_STATUS_UNSPECIFIED";
          case ProposalStatus.PROPOSAL_STATUS_DEPOSIT_PERIOD:
            return "PROPOSAL_STATUS_DEPOSIT_PERIOD";
          case ProposalStatus.PROPOSAL_STATUS_VOTING_PERIOD:
            return "PROPOSAL_STATUS_VOTING_PERIOD";
          case ProposalStatus.PROPOSAL_STATUS_PASSED:
            return "PROPOSAL_STATUS_PASSED";
          case ProposalStatus.PROPOSAL_STATUS_REJECTED:
            return "PROPOSAL_STATUS_REJECTED";
          case ProposalStatus.PROPOSAL_STATUS_FAILED:
            return "PROPOSAL_STATUS_FAILED";
          default:
            return "UNKNOWN";
        }
      }
      exports2.proposalStatusToJSON = proposalStatusToJSON;
      var baseWeightedVoteOption = { option: 0, weight: "" };
      exports2.WeightedVoteOption = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.option !== 0) {
            writer.uint32(8).int32(message.option);
          }
          if (message.weight !== "") {
            writer.uint32(18).string(message.weight);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseWeightedVoteOption);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.option = reader.int32();
                break;
              case 2:
                message.weight = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseWeightedVoteOption);
          message.option = object.option !== void 0 && object.option !== null ? voteOptionFromJSON(object.option) : 0;
          message.weight = object.weight !== void 0 && object.weight !== null ? String(object.weight) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.option !== void 0 && (obj.option = voteOptionToJSON(message.option));
          message.weight !== void 0 && (obj.weight = message.weight);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseWeightedVoteOption);
          message.option = (_a = object.option) !== null && _a !== void 0 ? _a : 0;
          message.weight = (_b = object.weight) !== null && _b !== void 0 ? _b : "";
          return message;
        }
      };
      var baseTextProposal = { title: "", description: "" };
      exports2.TextProposal = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.title !== "") {
            writer.uint32(10).string(message.title);
          }
          if (message.description !== "") {
            writer.uint32(18).string(message.description);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseTextProposal);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.title = reader.string();
                break;
              case 2:
                message.description = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseTextProposal);
          message.title = object.title !== void 0 && object.title !== null ? String(object.title) : "";
          message.description = object.description !== void 0 && object.description !== null ? String(object.description) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.title !== void 0 && (obj.title = message.title);
          message.description !== void 0 && (obj.description = message.description);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseTextProposal);
          message.title = (_a = object.title) !== null && _a !== void 0 ? _a : "";
          message.description = (_b = object.description) !== null && _b !== void 0 ? _b : "";
          return message;
        }
      };
      var baseDeposit = { proposalId: long_1.default.UZERO, depositor: "" };
      exports2.Deposit = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.proposalId.isZero()) {
            writer.uint32(8).uint64(message.proposalId);
          }
          if (message.depositor !== "") {
            writer.uint32(18).string(message.depositor);
          }
          for (const v of message.amount) {
            coin_1.Coin.encode(v, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseDeposit);
          message.amount = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.proposalId = reader.uint64();
                break;
              case 2:
                message.depositor = reader.string();
                break;
              case 3:
                message.amount.push(coin_1.Coin.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseDeposit);
          message.proposalId = object.proposalId !== void 0 && object.proposalId !== null ? long_1.default.fromString(object.proposalId) : long_1.default.UZERO;
          message.depositor = object.depositor !== void 0 && object.depositor !== null ? String(object.depositor) : "";
          message.amount = ((_a = object.amount) !== null && _a !== void 0 ? _a : []).map((e) => coin_1.Coin.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.proposalId !== void 0 && (obj.proposalId = (message.proposalId || long_1.default.UZERO).toString());
          message.depositor !== void 0 && (obj.depositor = message.depositor);
          if (message.amount) {
            obj.amount = message.amount.map((e) => e ? coin_1.Coin.toJSON(e) : void 0);
          } else {
            obj.amount = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseDeposit);
          message.proposalId = object.proposalId !== void 0 && object.proposalId !== null ? long_1.default.fromValue(object.proposalId) : long_1.default.UZERO;
          message.depositor = (_a = object.depositor) !== null && _a !== void 0 ? _a : "";
          message.amount = ((_b = object.amount) === null || _b === void 0 ? void 0 : _b.map((e) => coin_1.Coin.fromPartial(e))) || [];
          return message;
        }
      };
      var baseProposal = { proposalId: long_1.default.UZERO, status: 0 };
      exports2.Proposal = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.proposalId.isZero()) {
            writer.uint32(8).uint64(message.proposalId);
          }
          if (message.content !== void 0) {
            any_1.Any.encode(message.content, writer.uint32(18).fork()).ldelim();
          }
          if (message.status !== 0) {
            writer.uint32(24).int32(message.status);
          }
          if (message.finalTallyResult !== void 0) {
            exports2.TallyResult.encode(message.finalTallyResult, writer.uint32(34).fork()).ldelim();
          }
          if (message.submitTime !== void 0) {
            timestamp_1.Timestamp.encode(message.submitTime, writer.uint32(42).fork()).ldelim();
          }
          if (message.depositEndTime !== void 0) {
            timestamp_1.Timestamp.encode(message.depositEndTime, writer.uint32(50).fork()).ldelim();
          }
          for (const v of message.totalDeposit) {
            coin_1.Coin.encode(v, writer.uint32(58).fork()).ldelim();
          }
          if (message.votingStartTime !== void 0) {
            timestamp_1.Timestamp.encode(message.votingStartTime, writer.uint32(66).fork()).ldelim();
          }
          if (message.votingEndTime !== void 0) {
            timestamp_1.Timestamp.encode(message.votingEndTime, writer.uint32(74).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseProposal);
          message.totalDeposit = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.proposalId = reader.uint64();
                break;
              case 2:
                message.content = any_1.Any.decode(reader, reader.uint32());
                break;
              case 3:
                message.status = reader.int32();
                break;
              case 4:
                message.finalTallyResult = exports2.TallyResult.decode(reader, reader.uint32());
                break;
              case 5:
                message.submitTime = timestamp_1.Timestamp.decode(reader, reader.uint32());
                break;
              case 6:
                message.depositEndTime = timestamp_1.Timestamp.decode(reader, reader.uint32());
                break;
              case 7:
                message.totalDeposit.push(coin_1.Coin.decode(reader, reader.uint32()));
                break;
              case 8:
                message.votingStartTime = timestamp_1.Timestamp.decode(reader, reader.uint32());
                break;
              case 9:
                message.votingEndTime = timestamp_1.Timestamp.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseProposal);
          message.proposalId = object.proposalId !== void 0 && object.proposalId !== null ? long_1.default.fromString(object.proposalId) : long_1.default.UZERO;
          message.content = object.content !== void 0 && object.content !== null ? any_1.Any.fromJSON(object.content) : void 0;
          message.status = object.status !== void 0 && object.status !== null ? proposalStatusFromJSON(object.status) : 0;
          message.finalTallyResult = object.finalTallyResult !== void 0 && object.finalTallyResult !== null ? exports2.TallyResult.fromJSON(object.finalTallyResult) : void 0;
          message.submitTime = object.submitTime !== void 0 && object.submitTime !== null ? fromJsonTimestamp(object.submitTime) : void 0;
          message.depositEndTime = object.depositEndTime !== void 0 && object.depositEndTime !== null ? fromJsonTimestamp(object.depositEndTime) : void 0;
          message.totalDeposit = ((_a = object.totalDeposit) !== null && _a !== void 0 ? _a : []).map((e) => coin_1.Coin.fromJSON(e));
          message.votingStartTime = object.votingStartTime !== void 0 && object.votingStartTime !== null ? fromJsonTimestamp(object.votingStartTime) : void 0;
          message.votingEndTime = object.votingEndTime !== void 0 && object.votingEndTime !== null ? fromJsonTimestamp(object.votingEndTime) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.proposalId !== void 0 && (obj.proposalId = (message.proposalId || long_1.default.UZERO).toString());
          message.content !== void 0 && (obj.content = message.content ? any_1.Any.toJSON(message.content) : void 0);
          message.status !== void 0 && (obj.status = proposalStatusToJSON(message.status));
          message.finalTallyResult !== void 0 && (obj.finalTallyResult = message.finalTallyResult ? exports2.TallyResult.toJSON(message.finalTallyResult) : void 0);
          message.submitTime !== void 0 && (obj.submitTime = fromTimestamp(message.submitTime).toISOString());
          message.depositEndTime !== void 0 && (obj.depositEndTime = fromTimestamp(message.depositEndTime).toISOString());
          if (message.totalDeposit) {
            obj.totalDeposit = message.totalDeposit.map((e) => e ? coin_1.Coin.toJSON(e) : void 0);
          } else {
            obj.totalDeposit = [];
          }
          message.votingStartTime !== void 0 && (obj.votingStartTime = fromTimestamp(message.votingStartTime).toISOString());
          message.votingEndTime !== void 0 && (obj.votingEndTime = fromTimestamp(message.votingEndTime).toISOString());
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseProposal);
          message.proposalId = object.proposalId !== void 0 && object.proposalId !== null ? long_1.default.fromValue(object.proposalId) : long_1.default.UZERO;
          message.content = object.content !== void 0 && object.content !== null ? any_1.Any.fromPartial(object.content) : void 0;
          message.status = (_a = object.status) !== null && _a !== void 0 ? _a : 0;
          message.finalTallyResult = object.finalTallyResult !== void 0 && object.finalTallyResult !== null ? exports2.TallyResult.fromPartial(object.finalTallyResult) : void 0;
          message.submitTime = object.submitTime !== void 0 && object.submitTime !== null ? timestamp_1.Timestamp.fromPartial(object.submitTime) : void 0;
          message.depositEndTime = object.depositEndTime !== void 0 && object.depositEndTime !== null ? timestamp_1.Timestamp.fromPartial(object.depositEndTime) : void 0;
          message.totalDeposit = ((_b = object.totalDeposit) === null || _b === void 0 ? void 0 : _b.map((e) => coin_1.Coin.fromPartial(e))) || [];
          message.votingStartTime = object.votingStartTime !== void 0 && object.votingStartTime !== null ? timestamp_1.Timestamp.fromPartial(object.votingStartTime) : void 0;
          message.votingEndTime = object.votingEndTime !== void 0 && object.votingEndTime !== null ? timestamp_1.Timestamp.fromPartial(object.votingEndTime) : void 0;
          return message;
        }
      };
      var baseTallyResult = { yes: "", abstain: "", no: "", noWithVeto: "" };
      exports2.TallyResult = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.yes !== "") {
            writer.uint32(10).string(message.yes);
          }
          if (message.abstain !== "") {
            writer.uint32(18).string(message.abstain);
          }
          if (message.no !== "") {
            writer.uint32(26).string(message.no);
          }
          if (message.noWithVeto !== "") {
            writer.uint32(34).string(message.noWithVeto);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseTallyResult);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.yes = reader.string();
                break;
              case 2:
                message.abstain = reader.string();
                break;
              case 3:
                message.no = reader.string();
                break;
              case 4:
                message.noWithVeto = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseTallyResult);
          message.yes = object.yes !== void 0 && object.yes !== null ? String(object.yes) : "";
          message.abstain = object.abstain !== void 0 && object.abstain !== null ? String(object.abstain) : "";
          message.no = object.no !== void 0 && object.no !== null ? String(object.no) : "";
          message.noWithVeto = object.noWithVeto !== void 0 && object.noWithVeto !== null ? String(object.noWithVeto) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.yes !== void 0 && (obj.yes = message.yes);
          message.abstain !== void 0 && (obj.abstain = message.abstain);
          message.no !== void 0 && (obj.no = message.no);
          message.noWithVeto !== void 0 && (obj.noWithVeto = message.noWithVeto);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c, _d;
          const message = Object.assign({}, baseTallyResult);
          message.yes = (_a = object.yes) !== null && _a !== void 0 ? _a : "";
          message.abstain = (_b = object.abstain) !== null && _b !== void 0 ? _b : "";
          message.no = (_c = object.no) !== null && _c !== void 0 ? _c : "";
          message.noWithVeto = (_d = object.noWithVeto) !== null && _d !== void 0 ? _d : "";
          return message;
        }
      };
      var baseVote = { proposalId: long_1.default.UZERO, voter: "", option: 0 };
      exports2.Vote = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.proposalId.isZero()) {
            writer.uint32(8).uint64(message.proposalId);
          }
          if (message.voter !== "") {
            writer.uint32(18).string(message.voter);
          }
          if (message.option !== 0) {
            writer.uint32(24).int32(message.option);
          }
          for (const v of message.options) {
            exports2.WeightedVoteOption.encode(v, writer.uint32(34).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseVote);
          message.options = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.proposalId = reader.uint64();
                break;
              case 2:
                message.voter = reader.string();
                break;
              case 3:
                message.option = reader.int32();
                break;
              case 4:
                message.options.push(exports2.WeightedVoteOption.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseVote);
          message.proposalId = object.proposalId !== void 0 && object.proposalId !== null ? long_1.default.fromString(object.proposalId) : long_1.default.UZERO;
          message.voter = object.voter !== void 0 && object.voter !== null ? String(object.voter) : "";
          message.option = object.option !== void 0 && object.option !== null ? voteOptionFromJSON(object.option) : 0;
          message.options = ((_a = object.options) !== null && _a !== void 0 ? _a : []).map((e) => exports2.WeightedVoteOption.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.proposalId !== void 0 && (obj.proposalId = (message.proposalId || long_1.default.UZERO).toString());
          message.voter !== void 0 && (obj.voter = message.voter);
          message.option !== void 0 && (obj.option = voteOptionToJSON(message.option));
          if (message.options) {
            obj.options = message.options.map((e) => e ? exports2.WeightedVoteOption.toJSON(e) : void 0);
          } else {
            obj.options = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseVote);
          message.proposalId = object.proposalId !== void 0 && object.proposalId !== null ? long_1.default.fromValue(object.proposalId) : long_1.default.UZERO;
          message.voter = (_a = object.voter) !== null && _a !== void 0 ? _a : "";
          message.option = (_b = object.option) !== null && _b !== void 0 ? _b : 0;
          message.options = ((_c = object.options) === null || _c === void 0 ? void 0 : _c.map((e) => exports2.WeightedVoteOption.fromPartial(e))) || [];
          return message;
        }
      };
      var baseDepositParams = {};
      exports2.DepositParams = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.minDeposit) {
            coin_1.Coin.encode(v, writer.uint32(10).fork()).ldelim();
          }
          if (message.maxDepositPeriod !== void 0) {
            duration_1.Duration.encode(message.maxDepositPeriod, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseDepositParams);
          message.minDeposit = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.minDeposit.push(coin_1.Coin.decode(reader, reader.uint32()));
                break;
              case 2:
                message.maxDepositPeriod = duration_1.Duration.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseDepositParams);
          message.minDeposit = ((_a = object.minDeposit) !== null && _a !== void 0 ? _a : []).map((e) => coin_1.Coin.fromJSON(e));
          message.maxDepositPeriod = object.maxDepositPeriod !== void 0 && object.maxDepositPeriod !== null ? duration_1.Duration.fromJSON(object.maxDepositPeriod) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.minDeposit) {
            obj.minDeposit = message.minDeposit.map((e) => e ? coin_1.Coin.toJSON(e) : void 0);
          } else {
            obj.minDeposit = [];
          }
          message.maxDepositPeriod !== void 0 && (obj.maxDepositPeriod = message.maxDepositPeriod ? duration_1.Duration.toJSON(message.maxDepositPeriod) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseDepositParams);
          message.minDeposit = ((_a = object.minDeposit) === null || _a === void 0 ? void 0 : _a.map((e) => coin_1.Coin.fromPartial(e))) || [];
          message.maxDepositPeriod = object.maxDepositPeriod !== void 0 && object.maxDepositPeriod !== null ? duration_1.Duration.fromPartial(object.maxDepositPeriod) : void 0;
          return message;
        }
      };
      var baseVotingParams = {};
      exports2.VotingParams = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.votingPeriod !== void 0) {
            duration_1.Duration.encode(message.votingPeriod, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseVotingParams);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.votingPeriod = duration_1.Duration.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseVotingParams);
          message.votingPeriod = object.votingPeriod !== void 0 && object.votingPeriod !== null ? duration_1.Duration.fromJSON(object.votingPeriod) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.votingPeriod !== void 0 && (obj.votingPeriod = message.votingPeriod ? duration_1.Duration.toJSON(message.votingPeriod) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseVotingParams);
          message.votingPeriod = object.votingPeriod !== void 0 && object.votingPeriod !== null ? duration_1.Duration.fromPartial(object.votingPeriod) : void 0;
          return message;
        }
      };
      var baseTallyParams = {};
      exports2.TallyParams = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.quorum.length !== 0) {
            writer.uint32(10).bytes(message.quorum);
          }
          if (message.threshold.length !== 0) {
            writer.uint32(18).bytes(message.threshold);
          }
          if (message.vetoThreshold.length !== 0) {
            writer.uint32(26).bytes(message.vetoThreshold);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseTallyParams);
          message.quorum = new Uint8Array();
          message.threshold = new Uint8Array();
          message.vetoThreshold = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.quorum = reader.bytes();
                break;
              case 2:
                message.threshold = reader.bytes();
                break;
              case 3:
                message.vetoThreshold = reader.bytes();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseTallyParams);
          message.quorum = object.quorum !== void 0 && object.quorum !== null ? bytesFromBase64(object.quorum) : new Uint8Array();
          message.threshold = object.threshold !== void 0 && object.threshold !== null ? bytesFromBase64(object.threshold) : new Uint8Array();
          message.vetoThreshold = object.vetoThreshold !== void 0 && object.vetoThreshold !== null ? bytesFromBase64(object.vetoThreshold) : new Uint8Array();
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.quorum !== void 0 && (obj.quorum = base64FromBytes(message.quorum !== void 0 ? message.quorum : new Uint8Array()));
          message.threshold !== void 0 && (obj.threshold = base64FromBytes(message.threshold !== void 0 ? message.threshold : new Uint8Array()));
          message.vetoThreshold !== void 0 && (obj.vetoThreshold = base64FromBytes(message.vetoThreshold !== void 0 ? message.vetoThreshold : new Uint8Array()));
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseTallyParams);
          message.quorum = (_a = object.quorum) !== null && _a !== void 0 ? _a : new Uint8Array();
          message.threshold = (_b = object.threshold) !== null && _b !== void 0 ? _b : new Uint8Array();
          message.vetoThreshold = (_c = object.vetoThreshold) !== null && _c !== void 0 ? _c : new Uint8Array();
          return message;
        }
      };
      var globalThis2 = (() => {
        if (typeof globalThis2 !== "undefined")
          return globalThis2;
        if (typeof self !== "undefined")
          return self;
        if (typeof window !== "undefined")
          return window;
        if (typeof global !== "undefined")
          return global;
        throw "Unable to locate global object";
      })();
      var atob2 = globalThis2.atob || ((b64) => globalThis2.Buffer.from(b64, "base64").toString("binary"));
      function bytesFromBase64(b64) {
        const bin = atob2(b64);
        const arr = new Uint8Array(bin.length);
        for (let i = 0; i < bin.length; ++i) {
          arr[i] = bin.charCodeAt(i);
        }
        return arr;
      }
      var btoa2 = globalThis2.btoa || ((bin) => globalThis2.Buffer.from(bin, "binary").toString("base64"));
      function base64FromBytes(arr) {
        const bin = [];
        for (const byte of arr) {
          bin.push(String.fromCharCode(byte));
        }
        return btoa2(bin.join(""));
      }
      function toTimestamp(date) {
        const seconds = numberToLong(date.getTime() / 1e3);
        const nanos = date.getTime() % 1e3 * 1e6;
        return { seconds, nanos };
      }
      function fromTimestamp(t) {
        let millis = t.seconds.toNumber() * 1e3;
        millis += t.nanos / 1e6;
        return new Date(millis);
      }
      function fromJsonTimestamp(o) {
        if (o instanceof Date) {
          return toTimestamp(o);
        } else if (typeof o === "string") {
          return toTimestamp(new Date(o));
        } else {
          return timestamp_1.Timestamp.fromJSON(o);
        }
      }
      function numberToLong(number) {
        return long_1.default.fromNumber(number);
      }
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/@cosmjs/stargate/build/modules/gov/aminomessages.js
  var require_aminomessages7 = __commonJS({
    "node_modules/@cosmjs/stargate/build/modules/gov/aminomessages.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.createGovAminoConverters = exports2.isAminoMsgDeposit = exports2.isAminoMsgVote = exports2.isAminoMsgSubmitProposal = void 0;
      var utils_1 = require_build3();
      var gov_1 = require_gov();
      var any_1 = require_any();
      var long_1 = __importDefault(require_long());
      function isAminoMsgSubmitProposal(msg) {
        return msg.type === "cosmos-sdk/MsgSubmitProposal";
      }
      exports2.isAminoMsgSubmitProposal = isAminoMsgSubmitProposal;
      function isAminoMsgVote(msg) {
        return msg.type === "cosmos-sdk/MsgVote";
      }
      exports2.isAminoMsgVote = isAminoMsgVote;
      function isAminoMsgDeposit(msg) {
        return msg.type === "cosmos-sdk/MsgDeposit";
      }
      exports2.isAminoMsgDeposit = isAminoMsgDeposit;
      function createGovAminoConverters() {
        return {
          "/cosmos.gov.v1beta1.MsgDeposit": {
            aminoType: "cosmos-sdk/MsgDeposit",
            toAmino: ({ amount, depositor, proposalId }) => {
              return {
                amount,
                depositor,
                proposal_id: proposalId.toString()
              };
            },
            fromAmino: ({ amount, depositor, proposal_id }) => {
              return {
                amount: Array.from(amount),
                depositor,
                proposalId: long_1.default.fromString(proposal_id)
              };
            }
          },
          "/cosmos.gov.v1beta1.MsgVote": {
            aminoType: "cosmos-sdk/MsgVote",
            toAmino: ({ option, proposalId, voter }) => {
              return {
                option,
                proposal_id: proposalId.toString(),
                voter
              };
            },
            fromAmino: ({ option, proposal_id, voter }) => {
              return {
                option: (0, gov_1.voteOptionFromJSON)(option),
                proposalId: long_1.default.fromString(proposal_id),
                voter
              };
            }
          },
          "/cosmos.gov.v1beta1.MsgSubmitProposal": {
            aminoType: "cosmos-sdk/MsgSubmitProposal",
            toAmino: ({ initialDeposit, proposer, content }) => {
              (0, utils_1.assertDefinedAndNotNull)(content);
              let proposal;
              switch (content.typeUrl) {
                case "/cosmos.gov.v1beta1.TextProposal": {
                  const textProposal = gov_1.TextProposal.decode(content.value);
                  proposal = {
                    type: "cosmos-sdk/TextProposal",
                    value: {
                      description: textProposal.description,
                      title: textProposal.title
                    }
                  };
                  break;
                }
                default:
                  throw new Error(`Unsupported proposal type: '${content.typeUrl}'`);
              }
              return {
                initial_deposit: initialDeposit,
                proposer,
                content: proposal
              };
            },
            fromAmino: ({ initial_deposit, proposer, content }) => {
              let any_content;
              switch (content.type) {
                case "cosmos-sdk/TextProposal": {
                  const { value } = content;
                  (0, utils_1.assert)((0, utils_1.isNonNullObject)(value));
                  const { title, description } = value;
                  (0, utils_1.assert)(typeof title === "string");
                  (0, utils_1.assert)(typeof description === "string");
                  any_content = any_1.Any.fromPartial({
                    typeUrl: "/cosmos.gov.v1beta1.TextProposal",
                    value: gov_1.TextProposal.encode(gov_1.TextProposal.fromPartial({
                      title,
                      description
                    })).finish()
                  });
                  break;
                }
                default:
                  throw new Error(`Unsupported proposal type: '${content.type}'`);
              }
              return {
                initialDeposit: Array.from(initial_deposit),
                proposer,
                content: any_content
              };
            }
          }
        };
      }
      exports2.createGovAminoConverters = createGovAminoConverters;
    }
  });

  // node_modules/cosmjs-types/cosmos/gov/v1beta1/tx.js
  var require_tx6 = __commonJS({
    "node_modules/cosmjs-types/cosmos/gov/v1beta1/tx.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.MsgClientImpl = exports2.MsgDepositResponse = exports2.MsgDeposit = exports2.MsgVoteWeightedResponse = exports2.MsgVoteWeighted = exports2.MsgVoteResponse = exports2.MsgVote = exports2.MsgSubmitProposalResponse = exports2.MsgSubmitProposal = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var any_1 = require_any();
      var gov_1 = require_gov();
      var coin_1 = require_coin();
      exports2.protobufPackage = "cosmos.gov.v1beta1";
      var baseMsgSubmitProposal = { proposer: "" };
      exports2.MsgSubmitProposal = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.content !== void 0) {
            any_1.Any.encode(message.content, writer.uint32(10).fork()).ldelim();
          }
          for (const v of message.initialDeposit) {
            coin_1.Coin.encode(v, writer.uint32(18).fork()).ldelim();
          }
          if (message.proposer !== "") {
            writer.uint32(26).string(message.proposer);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgSubmitProposal);
          message.initialDeposit = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.content = any_1.Any.decode(reader, reader.uint32());
                break;
              case 2:
                message.initialDeposit.push(coin_1.Coin.decode(reader, reader.uint32()));
                break;
              case 3:
                message.proposer = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseMsgSubmitProposal);
          message.content = object.content !== void 0 && object.content !== null ? any_1.Any.fromJSON(object.content) : void 0;
          message.initialDeposit = ((_a = object.initialDeposit) !== null && _a !== void 0 ? _a : []).map((e) => coin_1.Coin.fromJSON(e));
          message.proposer = object.proposer !== void 0 && object.proposer !== null ? String(object.proposer) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.content !== void 0 && (obj.content = message.content ? any_1.Any.toJSON(message.content) : void 0);
          if (message.initialDeposit) {
            obj.initialDeposit = message.initialDeposit.map((e) => e ? coin_1.Coin.toJSON(e) : void 0);
          } else {
            obj.initialDeposit = [];
          }
          message.proposer !== void 0 && (obj.proposer = message.proposer);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseMsgSubmitProposal);
          message.content = object.content !== void 0 && object.content !== null ? any_1.Any.fromPartial(object.content) : void 0;
          message.initialDeposit = ((_a = object.initialDeposit) === null || _a === void 0 ? void 0 : _a.map((e) => coin_1.Coin.fromPartial(e))) || [];
          message.proposer = (_b = object.proposer) !== null && _b !== void 0 ? _b : "";
          return message;
        }
      };
      var baseMsgSubmitProposalResponse = { proposalId: long_1.default.UZERO };
      exports2.MsgSubmitProposalResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.proposalId.isZero()) {
            writer.uint32(8).uint64(message.proposalId);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgSubmitProposalResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.proposalId = reader.uint64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMsgSubmitProposalResponse);
          message.proposalId = object.proposalId !== void 0 && object.proposalId !== null ? long_1.default.fromString(object.proposalId) : long_1.default.UZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.proposalId !== void 0 && (obj.proposalId = (message.proposalId || long_1.default.UZERO).toString());
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseMsgSubmitProposalResponse);
          message.proposalId = object.proposalId !== void 0 && object.proposalId !== null ? long_1.default.fromValue(object.proposalId) : long_1.default.UZERO;
          return message;
        }
      };
      var baseMsgVote = { proposalId: long_1.default.UZERO, voter: "", option: 0 };
      exports2.MsgVote = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.proposalId.isZero()) {
            writer.uint32(8).uint64(message.proposalId);
          }
          if (message.voter !== "") {
            writer.uint32(18).string(message.voter);
          }
          if (message.option !== 0) {
            writer.uint32(24).int32(message.option);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgVote);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.proposalId = reader.uint64();
                break;
              case 2:
                message.voter = reader.string();
                break;
              case 3:
                message.option = reader.int32();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMsgVote);
          message.proposalId = object.proposalId !== void 0 && object.proposalId !== null ? long_1.default.fromString(object.proposalId) : long_1.default.UZERO;
          message.voter = object.voter !== void 0 && object.voter !== null ? String(object.voter) : "";
          message.option = object.option !== void 0 && object.option !== null ? gov_1.voteOptionFromJSON(object.option) : 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.proposalId !== void 0 && (obj.proposalId = (message.proposalId || long_1.default.UZERO).toString());
          message.voter !== void 0 && (obj.voter = message.voter);
          message.option !== void 0 && (obj.option = gov_1.voteOptionToJSON(message.option));
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseMsgVote);
          message.proposalId = object.proposalId !== void 0 && object.proposalId !== null ? long_1.default.fromValue(object.proposalId) : long_1.default.UZERO;
          message.voter = (_a = object.voter) !== null && _a !== void 0 ? _a : "";
          message.option = (_b = object.option) !== null && _b !== void 0 ? _b : 0;
          return message;
        }
      };
      var baseMsgVoteResponse = {};
      exports2.MsgVoteResponse = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgVoteResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseMsgVoteResponse);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseMsgVoteResponse);
          return message;
        }
      };
      var baseMsgVoteWeighted = { proposalId: long_1.default.UZERO, voter: "" };
      exports2.MsgVoteWeighted = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.proposalId.isZero()) {
            writer.uint32(8).uint64(message.proposalId);
          }
          if (message.voter !== "") {
            writer.uint32(18).string(message.voter);
          }
          for (const v of message.options) {
            gov_1.WeightedVoteOption.encode(v, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgVoteWeighted);
          message.options = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.proposalId = reader.uint64();
                break;
              case 2:
                message.voter = reader.string();
                break;
              case 3:
                message.options.push(gov_1.WeightedVoteOption.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseMsgVoteWeighted);
          message.proposalId = object.proposalId !== void 0 && object.proposalId !== null ? long_1.default.fromString(object.proposalId) : long_1.default.UZERO;
          message.voter = object.voter !== void 0 && object.voter !== null ? String(object.voter) : "";
          message.options = ((_a = object.options) !== null && _a !== void 0 ? _a : []).map((e) => gov_1.WeightedVoteOption.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.proposalId !== void 0 && (obj.proposalId = (message.proposalId || long_1.default.UZERO).toString());
          message.voter !== void 0 && (obj.voter = message.voter);
          if (message.options) {
            obj.options = message.options.map((e) => e ? gov_1.WeightedVoteOption.toJSON(e) : void 0);
          } else {
            obj.options = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseMsgVoteWeighted);
          message.proposalId = object.proposalId !== void 0 && object.proposalId !== null ? long_1.default.fromValue(object.proposalId) : long_1.default.UZERO;
          message.voter = (_a = object.voter) !== null && _a !== void 0 ? _a : "";
          message.options = ((_b = object.options) === null || _b === void 0 ? void 0 : _b.map((e) => gov_1.WeightedVoteOption.fromPartial(e))) || [];
          return message;
        }
      };
      var baseMsgVoteWeightedResponse = {};
      exports2.MsgVoteWeightedResponse = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgVoteWeightedResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseMsgVoteWeightedResponse);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseMsgVoteWeightedResponse);
          return message;
        }
      };
      var baseMsgDeposit = { proposalId: long_1.default.UZERO, depositor: "" };
      exports2.MsgDeposit = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.proposalId.isZero()) {
            writer.uint32(8).uint64(message.proposalId);
          }
          if (message.depositor !== "") {
            writer.uint32(18).string(message.depositor);
          }
          for (const v of message.amount) {
            coin_1.Coin.encode(v, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgDeposit);
          message.amount = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.proposalId = reader.uint64();
                break;
              case 2:
                message.depositor = reader.string();
                break;
              case 3:
                message.amount.push(coin_1.Coin.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseMsgDeposit);
          message.proposalId = object.proposalId !== void 0 && object.proposalId !== null ? long_1.default.fromString(object.proposalId) : long_1.default.UZERO;
          message.depositor = object.depositor !== void 0 && object.depositor !== null ? String(object.depositor) : "";
          message.amount = ((_a = object.amount) !== null && _a !== void 0 ? _a : []).map((e) => coin_1.Coin.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.proposalId !== void 0 && (obj.proposalId = (message.proposalId || long_1.default.UZERO).toString());
          message.depositor !== void 0 && (obj.depositor = message.depositor);
          if (message.amount) {
            obj.amount = message.amount.map((e) => e ? coin_1.Coin.toJSON(e) : void 0);
          } else {
            obj.amount = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseMsgDeposit);
          message.proposalId = object.proposalId !== void 0 && object.proposalId !== null ? long_1.default.fromValue(object.proposalId) : long_1.default.UZERO;
          message.depositor = (_a = object.depositor) !== null && _a !== void 0 ? _a : "";
          message.amount = ((_b = object.amount) === null || _b === void 0 ? void 0 : _b.map((e) => coin_1.Coin.fromPartial(e))) || [];
          return message;
        }
      };
      var baseMsgDepositResponse = {};
      exports2.MsgDepositResponse = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgDepositResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseMsgDepositResponse);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseMsgDepositResponse);
          return message;
        }
      };
      var MsgClientImpl = class {
        constructor(rpc) {
          this.rpc = rpc;
          this.SubmitProposal = this.SubmitProposal.bind(this);
          this.Vote = this.Vote.bind(this);
          this.VoteWeighted = this.VoteWeighted.bind(this);
          this.Deposit = this.Deposit.bind(this);
        }
        SubmitProposal(request) {
          const data = exports2.MsgSubmitProposal.encode(request).finish();
          const promise = this.rpc.request("cosmos.gov.v1beta1.Msg", "SubmitProposal", data);
          return promise.then((data2) => exports2.MsgSubmitProposalResponse.decode(new minimal_1.default.Reader(data2)));
        }
        Vote(request) {
          const data = exports2.MsgVote.encode(request).finish();
          const promise = this.rpc.request("cosmos.gov.v1beta1.Msg", "Vote", data);
          return promise.then((data2) => exports2.MsgVoteResponse.decode(new minimal_1.default.Reader(data2)));
        }
        VoteWeighted(request) {
          const data = exports2.MsgVoteWeighted.encode(request).finish();
          const promise = this.rpc.request("cosmos.gov.v1beta1.Msg", "VoteWeighted", data);
          return promise.then((data2) => exports2.MsgVoteWeightedResponse.decode(new minimal_1.default.Reader(data2)));
        }
        Deposit(request) {
          const data = exports2.MsgDeposit.encode(request).finish();
          const promise = this.rpc.request("cosmos.gov.v1beta1.Msg", "Deposit", data);
          return promise.then((data2) => exports2.MsgDepositResponse.decode(new minimal_1.default.Reader(data2)));
        }
      };
      exports2.MsgClientImpl = MsgClientImpl;
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/@cosmjs/stargate/build/modules/gov/messages.js
  var require_messages5 = __commonJS({
    "node_modules/@cosmjs/stargate/build/modules/gov/messages.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.isMsgVoteEncodeObject = exports2.isMsgSubmitProposalEncodeObject = exports2.isMsgDepositEncodeObject = exports2.govTypes = void 0;
      var tx_1 = require_tx6();
      exports2.govTypes = [
        ["/cosmos.gov.v1beta1.MsgDeposit", tx_1.MsgDeposit],
        ["/cosmos.gov.v1beta1.MsgSubmitProposal", tx_1.MsgSubmitProposal],
        ["/cosmos.gov.v1beta1.MsgVote", tx_1.MsgVote]
      ];
      function isMsgDepositEncodeObject(object) {
        return object.typeUrl === "/cosmos.gov.v1beta1.MsgDeposit";
      }
      exports2.isMsgDepositEncodeObject = isMsgDepositEncodeObject;
      function isMsgSubmitProposalEncodeObject(object) {
        return object.typeUrl === "/cosmos.gov.v1beta1.MsgSubmitProposal";
      }
      exports2.isMsgSubmitProposalEncodeObject = isMsgSubmitProposalEncodeObject;
      function isMsgVoteEncodeObject(object) {
        return object.typeUrl === "/cosmos.gov.v1beta1.MsgVote";
      }
      exports2.isMsgVoteEncodeObject = isMsgVoteEncodeObject;
    }
  });

  // node_modules/cosmjs-types/cosmos/gov/v1beta1/query.js
  var require_query4 = __commonJS({
    "node_modules/cosmjs-types/cosmos/gov/v1beta1/query.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.QueryClientImpl = exports2.QueryTallyResultResponse = exports2.QueryTallyResultRequest = exports2.QueryDepositsResponse = exports2.QueryDepositsRequest = exports2.QueryDepositResponse = exports2.QueryDepositRequest = exports2.QueryParamsResponse = exports2.QueryParamsRequest = exports2.QueryVotesResponse = exports2.QueryVotesRequest = exports2.QueryVoteResponse = exports2.QueryVoteRequest = exports2.QueryProposalsResponse = exports2.QueryProposalsRequest = exports2.QueryProposalResponse = exports2.QueryProposalRequest = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var gov_1 = require_gov();
      var pagination_1 = require_pagination();
      exports2.protobufPackage = "cosmos.gov.v1beta1";
      var baseQueryProposalRequest = { proposalId: long_1.default.UZERO };
      exports2.QueryProposalRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.proposalId.isZero()) {
            writer.uint32(8).uint64(message.proposalId);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryProposalRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.proposalId = reader.uint64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryProposalRequest);
          message.proposalId = object.proposalId !== void 0 && object.proposalId !== null ? long_1.default.fromString(object.proposalId) : long_1.default.UZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.proposalId !== void 0 && (obj.proposalId = (message.proposalId || long_1.default.UZERO).toString());
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryProposalRequest);
          message.proposalId = object.proposalId !== void 0 && object.proposalId !== null ? long_1.default.fromValue(object.proposalId) : long_1.default.UZERO;
          return message;
        }
      };
      var baseQueryProposalResponse = {};
      exports2.QueryProposalResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.proposal !== void 0) {
            gov_1.Proposal.encode(message.proposal, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryProposalResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.proposal = gov_1.Proposal.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryProposalResponse);
          message.proposal = object.proposal !== void 0 && object.proposal !== null ? gov_1.Proposal.fromJSON(object.proposal) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.proposal !== void 0 && (obj.proposal = message.proposal ? gov_1.Proposal.toJSON(message.proposal) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryProposalResponse);
          message.proposal = object.proposal !== void 0 && object.proposal !== null ? gov_1.Proposal.fromPartial(object.proposal) : void 0;
          return message;
        }
      };
      var baseQueryProposalsRequest = { proposalStatus: 0, voter: "", depositor: "" };
      exports2.QueryProposalsRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.proposalStatus !== 0) {
            writer.uint32(8).int32(message.proposalStatus);
          }
          if (message.voter !== "") {
            writer.uint32(18).string(message.voter);
          }
          if (message.depositor !== "") {
            writer.uint32(26).string(message.depositor);
          }
          if (message.pagination !== void 0) {
            pagination_1.PageRequest.encode(message.pagination, writer.uint32(34).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryProposalsRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.proposalStatus = reader.int32();
                break;
              case 2:
                message.voter = reader.string();
                break;
              case 3:
                message.depositor = reader.string();
                break;
              case 4:
                message.pagination = pagination_1.PageRequest.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryProposalsRequest);
          message.proposalStatus = object.proposalStatus !== void 0 && object.proposalStatus !== null ? gov_1.proposalStatusFromJSON(object.proposalStatus) : 0;
          message.voter = object.voter !== void 0 && object.voter !== null ? String(object.voter) : "";
          message.depositor = object.depositor !== void 0 && object.depositor !== null ? String(object.depositor) : "";
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.proposalStatus !== void 0 && (obj.proposalStatus = gov_1.proposalStatusToJSON(message.proposalStatus));
          message.voter !== void 0 && (obj.voter = message.voter);
          message.depositor !== void 0 && (obj.depositor = message.depositor);
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageRequest.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseQueryProposalsRequest);
          message.proposalStatus = (_a = object.proposalStatus) !== null && _a !== void 0 ? _a : 0;
          message.voter = (_b = object.voter) !== null && _b !== void 0 ? _b : "";
          message.depositor = (_c = object.depositor) !== null && _c !== void 0 ? _c : "";
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryProposalsResponse = {};
      exports2.QueryProposalsResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.proposals) {
            gov_1.Proposal.encode(v, writer.uint32(10).fork()).ldelim();
          }
          if (message.pagination !== void 0) {
            pagination_1.PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryProposalsResponse);
          message.proposals = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.proposals.push(gov_1.Proposal.decode(reader, reader.uint32()));
                break;
              case 2:
                message.pagination = pagination_1.PageResponse.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseQueryProposalsResponse);
          message.proposals = ((_a = object.proposals) !== null && _a !== void 0 ? _a : []).map((e) => gov_1.Proposal.fromJSON(e));
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.proposals) {
            obj.proposals = message.proposals.map((e) => e ? gov_1.Proposal.toJSON(e) : void 0);
          } else {
            obj.proposals = [];
          }
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageResponse.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryProposalsResponse);
          message.proposals = ((_a = object.proposals) === null || _a === void 0 ? void 0 : _a.map((e) => gov_1.Proposal.fromPartial(e))) || [];
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryVoteRequest = { proposalId: long_1.default.UZERO, voter: "" };
      exports2.QueryVoteRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.proposalId.isZero()) {
            writer.uint32(8).uint64(message.proposalId);
          }
          if (message.voter !== "") {
            writer.uint32(18).string(message.voter);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryVoteRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.proposalId = reader.uint64();
                break;
              case 2:
                message.voter = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryVoteRequest);
          message.proposalId = object.proposalId !== void 0 && object.proposalId !== null ? long_1.default.fromString(object.proposalId) : long_1.default.UZERO;
          message.voter = object.voter !== void 0 && object.voter !== null ? String(object.voter) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.proposalId !== void 0 && (obj.proposalId = (message.proposalId || long_1.default.UZERO).toString());
          message.voter !== void 0 && (obj.voter = message.voter);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryVoteRequest);
          message.proposalId = object.proposalId !== void 0 && object.proposalId !== null ? long_1.default.fromValue(object.proposalId) : long_1.default.UZERO;
          message.voter = (_a = object.voter) !== null && _a !== void 0 ? _a : "";
          return message;
        }
      };
      var baseQueryVoteResponse = {};
      exports2.QueryVoteResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.vote !== void 0) {
            gov_1.Vote.encode(message.vote, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryVoteResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.vote = gov_1.Vote.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryVoteResponse);
          message.vote = object.vote !== void 0 && object.vote !== null ? gov_1.Vote.fromJSON(object.vote) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.vote !== void 0 && (obj.vote = message.vote ? gov_1.Vote.toJSON(message.vote) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryVoteResponse);
          message.vote = object.vote !== void 0 && object.vote !== null ? gov_1.Vote.fromPartial(object.vote) : void 0;
          return message;
        }
      };
      var baseQueryVotesRequest = { proposalId: long_1.default.UZERO };
      exports2.QueryVotesRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.proposalId.isZero()) {
            writer.uint32(8).uint64(message.proposalId);
          }
          if (message.pagination !== void 0) {
            pagination_1.PageRequest.encode(message.pagination, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryVotesRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.proposalId = reader.uint64();
                break;
              case 2:
                message.pagination = pagination_1.PageRequest.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryVotesRequest);
          message.proposalId = object.proposalId !== void 0 && object.proposalId !== null ? long_1.default.fromString(object.proposalId) : long_1.default.UZERO;
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.proposalId !== void 0 && (obj.proposalId = (message.proposalId || long_1.default.UZERO).toString());
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageRequest.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryVotesRequest);
          message.proposalId = object.proposalId !== void 0 && object.proposalId !== null ? long_1.default.fromValue(object.proposalId) : long_1.default.UZERO;
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryVotesResponse = {};
      exports2.QueryVotesResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.votes) {
            gov_1.Vote.encode(v, writer.uint32(10).fork()).ldelim();
          }
          if (message.pagination !== void 0) {
            pagination_1.PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryVotesResponse);
          message.votes = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.votes.push(gov_1.Vote.decode(reader, reader.uint32()));
                break;
              case 2:
                message.pagination = pagination_1.PageResponse.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseQueryVotesResponse);
          message.votes = ((_a = object.votes) !== null && _a !== void 0 ? _a : []).map((e) => gov_1.Vote.fromJSON(e));
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.votes) {
            obj.votes = message.votes.map((e) => e ? gov_1.Vote.toJSON(e) : void 0);
          } else {
            obj.votes = [];
          }
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageResponse.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryVotesResponse);
          message.votes = ((_a = object.votes) === null || _a === void 0 ? void 0 : _a.map((e) => gov_1.Vote.fromPartial(e))) || [];
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryParamsRequest = { paramsType: "" };
      exports2.QueryParamsRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.paramsType !== "") {
            writer.uint32(10).string(message.paramsType);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryParamsRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.paramsType = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryParamsRequest);
          message.paramsType = object.paramsType !== void 0 && object.paramsType !== null ? String(object.paramsType) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.paramsType !== void 0 && (obj.paramsType = message.paramsType);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryParamsRequest);
          message.paramsType = (_a = object.paramsType) !== null && _a !== void 0 ? _a : "";
          return message;
        }
      };
      var baseQueryParamsResponse = {};
      exports2.QueryParamsResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.votingParams !== void 0) {
            gov_1.VotingParams.encode(message.votingParams, writer.uint32(10).fork()).ldelim();
          }
          if (message.depositParams !== void 0) {
            gov_1.DepositParams.encode(message.depositParams, writer.uint32(18).fork()).ldelim();
          }
          if (message.tallyParams !== void 0) {
            gov_1.TallyParams.encode(message.tallyParams, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryParamsResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.votingParams = gov_1.VotingParams.decode(reader, reader.uint32());
                break;
              case 2:
                message.depositParams = gov_1.DepositParams.decode(reader, reader.uint32());
                break;
              case 3:
                message.tallyParams = gov_1.TallyParams.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryParamsResponse);
          message.votingParams = object.votingParams !== void 0 && object.votingParams !== null ? gov_1.VotingParams.fromJSON(object.votingParams) : void 0;
          message.depositParams = object.depositParams !== void 0 && object.depositParams !== null ? gov_1.DepositParams.fromJSON(object.depositParams) : void 0;
          message.tallyParams = object.tallyParams !== void 0 && object.tallyParams !== null ? gov_1.TallyParams.fromJSON(object.tallyParams) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.votingParams !== void 0 && (obj.votingParams = message.votingParams ? gov_1.VotingParams.toJSON(message.votingParams) : void 0);
          message.depositParams !== void 0 && (obj.depositParams = message.depositParams ? gov_1.DepositParams.toJSON(message.depositParams) : void 0);
          message.tallyParams !== void 0 && (obj.tallyParams = message.tallyParams ? gov_1.TallyParams.toJSON(message.tallyParams) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryParamsResponse);
          message.votingParams = object.votingParams !== void 0 && object.votingParams !== null ? gov_1.VotingParams.fromPartial(object.votingParams) : void 0;
          message.depositParams = object.depositParams !== void 0 && object.depositParams !== null ? gov_1.DepositParams.fromPartial(object.depositParams) : void 0;
          message.tallyParams = object.tallyParams !== void 0 && object.tallyParams !== null ? gov_1.TallyParams.fromPartial(object.tallyParams) : void 0;
          return message;
        }
      };
      var baseQueryDepositRequest = { proposalId: long_1.default.UZERO, depositor: "" };
      exports2.QueryDepositRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.proposalId.isZero()) {
            writer.uint32(8).uint64(message.proposalId);
          }
          if (message.depositor !== "") {
            writer.uint32(18).string(message.depositor);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryDepositRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.proposalId = reader.uint64();
                break;
              case 2:
                message.depositor = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryDepositRequest);
          message.proposalId = object.proposalId !== void 0 && object.proposalId !== null ? long_1.default.fromString(object.proposalId) : long_1.default.UZERO;
          message.depositor = object.depositor !== void 0 && object.depositor !== null ? String(object.depositor) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.proposalId !== void 0 && (obj.proposalId = (message.proposalId || long_1.default.UZERO).toString());
          message.depositor !== void 0 && (obj.depositor = message.depositor);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryDepositRequest);
          message.proposalId = object.proposalId !== void 0 && object.proposalId !== null ? long_1.default.fromValue(object.proposalId) : long_1.default.UZERO;
          message.depositor = (_a = object.depositor) !== null && _a !== void 0 ? _a : "";
          return message;
        }
      };
      var baseQueryDepositResponse = {};
      exports2.QueryDepositResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.deposit !== void 0) {
            gov_1.Deposit.encode(message.deposit, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryDepositResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.deposit = gov_1.Deposit.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryDepositResponse);
          message.deposit = object.deposit !== void 0 && object.deposit !== null ? gov_1.Deposit.fromJSON(object.deposit) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.deposit !== void 0 && (obj.deposit = message.deposit ? gov_1.Deposit.toJSON(message.deposit) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryDepositResponse);
          message.deposit = object.deposit !== void 0 && object.deposit !== null ? gov_1.Deposit.fromPartial(object.deposit) : void 0;
          return message;
        }
      };
      var baseQueryDepositsRequest = { proposalId: long_1.default.UZERO };
      exports2.QueryDepositsRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.proposalId.isZero()) {
            writer.uint32(8).uint64(message.proposalId);
          }
          if (message.pagination !== void 0) {
            pagination_1.PageRequest.encode(message.pagination, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryDepositsRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.proposalId = reader.uint64();
                break;
              case 2:
                message.pagination = pagination_1.PageRequest.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryDepositsRequest);
          message.proposalId = object.proposalId !== void 0 && object.proposalId !== null ? long_1.default.fromString(object.proposalId) : long_1.default.UZERO;
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.proposalId !== void 0 && (obj.proposalId = (message.proposalId || long_1.default.UZERO).toString());
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageRequest.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryDepositsRequest);
          message.proposalId = object.proposalId !== void 0 && object.proposalId !== null ? long_1.default.fromValue(object.proposalId) : long_1.default.UZERO;
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryDepositsResponse = {};
      exports2.QueryDepositsResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.deposits) {
            gov_1.Deposit.encode(v, writer.uint32(10).fork()).ldelim();
          }
          if (message.pagination !== void 0) {
            pagination_1.PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryDepositsResponse);
          message.deposits = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.deposits.push(gov_1.Deposit.decode(reader, reader.uint32()));
                break;
              case 2:
                message.pagination = pagination_1.PageResponse.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseQueryDepositsResponse);
          message.deposits = ((_a = object.deposits) !== null && _a !== void 0 ? _a : []).map((e) => gov_1.Deposit.fromJSON(e));
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.deposits) {
            obj.deposits = message.deposits.map((e) => e ? gov_1.Deposit.toJSON(e) : void 0);
          } else {
            obj.deposits = [];
          }
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageResponse.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryDepositsResponse);
          message.deposits = ((_a = object.deposits) === null || _a === void 0 ? void 0 : _a.map((e) => gov_1.Deposit.fromPartial(e))) || [];
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryTallyResultRequest = { proposalId: long_1.default.UZERO };
      exports2.QueryTallyResultRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.proposalId.isZero()) {
            writer.uint32(8).uint64(message.proposalId);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryTallyResultRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.proposalId = reader.uint64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryTallyResultRequest);
          message.proposalId = object.proposalId !== void 0 && object.proposalId !== null ? long_1.default.fromString(object.proposalId) : long_1.default.UZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.proposalId !== void 0 && (obj.proposalId = (message.proposalId || long_1.default.UZERO).toString());
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryTallyResultRequest);
          message.proposalId = object.proposalId !== void 0 && object.proposalId !== null ? long_1.default.fromValue(object.proposalId) : long_1.default.UZERO;
          return message;
        }
      };
      var baseQueryTallyResultResponse = {};
      exports2.QueryTallyResultResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.tally !== void 0) {
            gov_1.TallyResult.encode(message.tally, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryTallyResultResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.tally = gov_1.TallyResult.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryTallyResultResponse);
          message.tally = object.tally !== void 0 && object.tally !== null ? gov_1.TallyResult.fromJSON(object.tally) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.tally !== void 0 && (obj.tally = message.tally ? gov_1.TallyResult.toJSON(message.tally) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryTallyResultResponse);
          message.tally = object.tally !== void 0 && object.tally !== null ? gov_1.TallyResult.fromPartial(object.tally) : void 0;
          return message;
        }
      };
      var QueryClientImpl = class {
        constructor(rpc) {
          this.rpc = rpc;
          this.Proposal = this.Proposal.bind(this);
          this.Proposals = this.Proposals.bind(this);
          this.Vote = this.Vote.bind(this);
          this.Votes = this.Votes.bind(this);
          this.Params = this.Params.bind(this);
          this.Deposit = this.Deposit.bind(this);
          this.Deposits = this.Deposits.bind(this);
          this.TallyResult = this.TallyResult.bind(this);
        }
        Proposal(request) {
          const data = exports2.QueryProposalRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.gov.v1beta1.Query", "Proposal", data);
          return promise.then((data2) => exports2.QueryProposalResponse.decode(new minimal_1.default.Reader(data2)));
        }
        Proposals(request) {
          const data = exports2.QueryProposalsRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.gov.v1beta1.Query", "Proposals", data);
          return promise.then((data2) => exports2.QueryProposalsResponse.decode(new minimal_1.default.Reader(data2)));
        }
        Vote(request) {
          const data = exports2.QueryVoteRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.gov.v1beta1.Query", "Vote", data);
          return promise.then((data2) => exports2.QueryVoteResponse.decode(new minimal_1.default.Reader(data2)));
        }
        Votes(request) {
          const data = exports2.QueryVotesRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.gov.v1beta1.Query", "Votes", data);
          return promise.then((data2) => exports2.QueryVotesResponse.decode(new minimal_1.default.Reader(data2)));
        }
        Params(request) {
          const data = exports2.QueryParamsRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.gov.v1beta1.Query", "Params", data);
          return promise.then((data2) => exports2.QueryParamsResponse.decode(new minimal_1.default.Reader(data2)));
        }
        Deposit(request) {
          const data = exports2.QueryDepositRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.gov.v1beta1.Query", "Deposit", data);
          return promise.then((data2) => exports2.QueryDepositResponse.decode(new minimal_1.default.Reader(data2)));
        }
        Deposits(request) {
          const data = exports2.QueryDepositsRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.gov.v1beta1.Query", "Deposits", data);
          return promise.then((data2) => exports2.QueryDepositsResponse.decode(new minimal_1.default.Reader(data2)));
        }
        TallyResult(request) {
          const data = exports2.QueryTallyResultRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.gov.v1beta1.Query", "TallyResult", data);
          return promise.then((data2) => exports2.QueryTallyResultResponse.decode(new minimal_1.default.Reader(data2)));
        }
      };
      exports2.QueryClientImpl = QueryClientImpl;
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/@cosmjs/stargate/build/modules/gov/queries.js
  var require_queries4 = __commonJS({
    "node_modules/@cosmjs/stargate/build/modules/gov/queries.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.setupGovExtension = void 0;
      var query_1 = require_query4();
      var queryclient_1 = require_queryclient2();
      function setupGovExtension(base) {
        const rpc = (0, queryclient_1.createProtobufRpcClient)(base);
        const queryService = new query_1.QueryClientImpl(rpc);
        return {
          gov: {
            params: async (parametersType) => {
              const response = await queryService.Params({ paramsType: parametersType });
              return response;
            },
            proposals: async (proposalStatus, depositorAddress, voterAddress, paginationKey) => {
              const response = await queryService.Proposals({
                proposalStatus,
                depositor: depositorAddress,
                voter: voterAddress,
                pagination: (0, queryclient_1.createPagination)(paginationKey)
              });
              return response;
            },
            proposal: async (proposalId) => {
              const response = await queryService.Proposal({ proposalId: (0, queryclient_1.longify)(proposalId) });
              return response;
            },
            deposits: async (proposalId, paginationKey) => {
              const response = await queryService.Deposits({
                proposalId: (0, queryclient_1.longify)(proposalId),
                pagination: (0, queryclient_1.createPagination)(paginationKey)
              });
              return response;
            },
            deposit: async (proposalId, depositorAddress) => {
              const response = await queryService.Deposit({
                proposalId: (0, queryclient_1.longify)(proposalId),
                depositor: depositorAddress
              });
              return response;
            },
            tally: async (proposalId) => {
              const response = await queryService.TallyResult({
                proposalId: (0, queryclient_1.longify)(proposalId)
              });
              return response;
            },
            votes: async (proposalId, paginationKey) => {
              const response = await queryService.Votes({
                proposalId: (0, queryclient_1.longify)(proposalId),
                pagination: (0, queryclient_1.createPagination)(paginationKey)
              });
              return response;
            },
            vote: async (proposalId, voterAddress) => {
              const response = await queryService.Vote({
                proposalId: (0, queryclient_1.longify)(proposalId),
                voter: voterAddress
              });
              return response;
            }
          }
        };
      }
      exports2.setupGovExtension = setupGovExtension;
    }
  });

  // node_modules/@cosmjs/stargate/build/modules/ibc/aminomessages.js
  var require_aminomessages8 = __commonJS({
    "node_modules/@cosmjs/stargate/build/modules/ibc/aminomessages.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.createIbcAminoConverters = exports2.isAminoMsgTransfer = void 0;
      var long_1 = __importDefault(require_long());
      function isAminoMsgTransfer(msg) {
        return msg.type === "cosmos-sdk/MsgTransfer";
      }
      exports2.isAminoMsgTransfer = isAminoMsgTransfer;
      function omitDefault(input) {
        if (typeof input === "string") {
          return input === "" ? void 0 : input;
        }
        if (typeof input === "number") {
          return input === 0 ? void 0 : input;
        }
        if (long_1.default.isLong(input)) {
          return input.isZero() ? void 0 : input;
        }
        throw new Error(`Got unsupported type '${typeof input}'`);
      }
      function createIbcAminoConverters() {
        return {
          "/ibc.applications.transfer.v1.MsgTransfer": {
            aminoType: "cosmos-sdk/MsgTransfer",
            toAmino: ({ sourcePort, sourceChannel, token, sender, receiver, timeoutHeight, timeoutTimestamp }) => {
              var _a, _b, _c;
              return {
                source_port: sourcePort,
                source_channel: sourceChannel,
                token,
                sender,
                receiver,
                timeout_height: timeoutHeight ? {
                  revision_height: (_a = omitDefault(timeoutHeight.revisionHeight)) === null || _a === void 0 ? void 0 : _a.toString(),
                  revision_number: (_b = omitDefault(timeoutHeight.revisionNumber)) === null || _b === void 0 ? void 0 : _b.toString()
                } : {},
                timeout_timestamp: (_c = omitDefault(timeoutTimestamp)) === null || _c === void 0 ? void 0 : _c.toString()
              };
            },
            fromAmino: ({ source_port, source_channel, token, sender, receiver, timeout_height, timeout_timestamp }) => ({
              sourcePort: source_port,
              sourceChannel: source_channel,
              token,
              sender,
              receiver,
              timeoutHeight: timeout_height ? {
                revisionHeight: long_1.default.fromString(timeout_height.revision_height || "0", true),
                revisionNumber: long_1.default.fromString(timeout_height.revision_number || "0", true)
              } : void 0,
              timeoutTimestamp: long_1.default.fromString(timeout_timestamp || "0", true)
            })
          }
        };
      }
      exports2.createIbcAminoConverters = createIbcAminoConverters;
    }
  });

  // node_modules/cosmjs-types/ibc/core/client/v1/client.js
  var require_client = __commonJS({
    "node_modules/cosmjs-types/ibc/core/client/v1/client.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.Params = exports2.Height = exports2.ClientUpdateProposal = exports2.ClientConsensusStates = exports2.ConsensusStateWithHeight = exports2.IdentifiedClientState = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var any_1 = require_any();
      exports2.protobufPackage = "ibc.core.client.v1";
      var baseIdentifiedClientState = { clientId: "" };
      exports2.IdentifiedClientState = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.clientId !== "") {
            writer.uint32(10).string(message.clientId);
          }
          if (message.clientState !== void 0) {
            any_1.Any.encode(message.clientState, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseIdentifiedClientState);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.clientId = reader.string();
                break;
              case 2:
                message.clientState = any_1.Any.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseIdentifiedClientState);
          message.clientId = object.clientId !== void 0 && object.clientId !== null ? String(object.clientId) : "";
          message.clientState = object.clientState !== void 0 && object.clientState !== null ? any_1.Any.fromJSON(object.clientState) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.clientId !== void 0 && (obj.clientId = message.clientId);
          message.clientState !== void 0 && (obj.clientState = message.clientState ? any_1.Any.toJSON(message.clientState) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseIdentifiedClientState);
          message.clientId = (_a = object.clientId) !== null && _a !== void 0 ? _a : "";
          message.clientState = object.clientState !== void 0 && object.clientState !== null ? any_1.Any.fromPartial(object.clientState) : void 0;
          return message;
        }
      };
      var baseConsensusStateWithHeight = {};
      exports2.ConsensusStateWithHeight = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.height !== void 0) {
            exports2.Height.encode(message.height, writer.uint32(10).fork()).ldelim();
          }
          if (message.consensusState !== void 0) {
            any_1.Any.encode(message.consensusState, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseConsensusStateWithHeight);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.height = exports2.Height.decode(reader, reader.uint32());
                break;
              case 2:
                message.consensusState = any_1.Any.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseConsensusStateWithHeight);
          message.height = object.height !== void 0 && object.height !== null ? exports2.Height.fromJSON(object.height) : void 0;
          message.consensusState = object.consensusState !== void 0 && object.consensusState !== null ? any_1.Any.fromJSON(object.consensusState) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.height !== void 0 && (obj.height = message.height ? exports2.Height.toJSON(message.height) : void 0);
          message.consensusState !== void 0 && (obj.consensusState = message.consensusState ? any_1.Any.toJSON(message.consensusState) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseConsensusStateWithHeight);
          message.height = object.height !== void 0 && object.height !== null ? exports2.Height.fromPartial(object.height) : void 0;
          message.consensusState = object.consensusState !== void 0 && object.consensusState !== null ? any_1.Any.fromPartial(object.consensusState) : void 0;
          return message;
        }
      };
      var baseClientConsensusStates = { clientId: "" };
      exports2.ClientConsensusStates = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.clientId !== "") {
            writer.uint32(10).string(message.clientId);
          }
          for (const v of message.consensusStates) {
            exports2.ConsensusStateWithHeight.encode(v, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseClientConsensusStates);
          message.consensusStates = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.clientId = reader.string();
                break;
              case 2:
                message.consensusStates.push(exports2.ConsensusStateWithHeight.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseClientConsensusStates);
          message.clientId = object.clientId !== void 0 && object.clientId !== null ? String(object.clientId) : "";
          message.consensusStates = ((_a = object.consensusStates) !== null && _a !== void 0 ? _a : []).map((e) => exports2.ConsensusStateWithHeight.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.clientId !== void 0 && (obj.clientId = message.clientId);
          if (message.consensusStates) {
            obj.consensusStates = message.consensusStates.map((e) => e ? exports2.ConsensusStateWithHeight.toJSON(e) : void 0);
          } else {
            obj.consensusStates = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseClientConsensusStates);
          message.clientId = (_a = object.clientId) !== null && _a !== void 0 ? _a : "";
          message.consensusStates = ((_b = object.consensusStates) === null || _b === void 0 ? void 0 : _b.map((e) => exports2.ConsensusStateWithHeight.fromPartial(e))) || [];
          return message;
        }
      };
      var baseClientUpdateProposal = { title: "", description: "", clientId: "" };
      exports2.ClientUpdateProposal = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.title !== "") {
            writer.uint32(10).string(message.title);
          }
          if (message.description !== "") {
            writer.uint32(18).string(message.description);
          }
          if (message.clientId !== "") {
            writer.uint32(26).string(message.clientId);
          }
          if (message.header !== void 0) {
            any_1.Any.encode(message.header, writer.uint32(34).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseClientUpdateProposal);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.title = reader.string();
                break;
              case 2:
                message.description = reader.string();
                break;
              case 3:
                message.clientId = reader.string();
                break;
              case 4:
                message.header = any_1.Any.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseClientUpdateProposal);
          message.title = object.title !== void 0 && object.title !== null ? String(object.title) : "";
          message.description = object.description !== void 0 && object.description !== null ? String(object.description) : "";
          message.clientId = object.clientId !== void 0 && object.clientId !== null ? String(object.clientId) : "";
          message.header = object.header !== void 0 && object.header !== null ? any_1.Any.fromJSON(object.header) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.title !== void 0 && (obj.title = message.title);
          message.description !== void 0 && (obj.description = message.description);
          message.clientId !== void 0 && (obj.clientId = message.clientId);
          message.header !== void 0 && (obj.header = message.header ? any_1.Any.toJSON(message.header) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseClientUpdateProposal);
          message.title = (_a = object.title) !== null && _a !== void 0 ? _a : "";
          message.description = (_b = object.description) !== null && _b !== void 0 ? _b : "";
          message.clientId = (_c = object.clientId) !== null && _c !== void 0 ? _c : "";
          message.header = object.header !== void 0 && object.header !== null ? any_1.Any.fromPartial(object.header) : void 0;
          return message;
        }
      };
      var baseHeight = { revisionNumber: long_1.default.UZERO, revisionHeight: long_1.default.UZERO };
      exports2.Height = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.revisionNumber.isZero()) {
            writer.uint32(8).uint64(message.revisionNumber);
          }
          if (!message.revisionHeight.isZero()) {
            writer.uint32(16).uint64(message.revisionHeight);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseHeight);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.revisionNumber = reader.uint64();
                break;
              case 2:
                message.revisionHeight = reader.uint64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseHeight);
          message.revisionNumber = object.revisionNumber !== void 0 && object.revisionNumber !== null ? long_1.default.fromString(object.revisionNumber) : long_1.default.UZERO;
          message.revisionHeight = object.revisionHeight !== void 0 && object.revisionHeight !== null ? long_1.default.fromString(object.revisionHeight) : long_1.default.UZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.revisionNumber !== void 0 && (obj.revisionNumber = (message.revisionNumber || long_1.default.UZERO).toString());
          message.revisionHeight !== void 0 && (obj.revisionHeight = (message.revisionHeight || long_1.default.UZERO).toString());
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseHeight);
          message.revisionNumber = object.revisionNumber !== void 0 && object.revisionNumber !== null ? long_1.default.fromValue(object.revisionNumber) : long_1.default.UZERO;
          message.revisionHeight = object.revisionHeight !== void 0 && object.revisionHeight !== null ? long_1.default.fromValue(object.revisionHeight) : long_1.default.UZERO;
          return message;
        }
      };
      var baseParams = { allowedClients: "" };
      exports2.Params = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.allowedClients) {
            writer.uint32(10).string(v);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseParams);
          message.allowedClients = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.allowedClients.push(reader.string());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseParams);
          message.allowedClients = ((_a = object.allowedClients) !== null && _a !== void 0 ? _a : []).map((e) => String(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.allowedClients) {
            obj.allowedClients = message.allowedClients.map((e) => e);
          } else {
            obj.allowedClients = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseParams);
          message.allowedClients = ((_a = object.allowedClients) === null || _a === void 0 ? void 0 : _a.map((e) => e)) || [];
          return message;
        }
      };
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/cosmjs-types/ibc/applications/transfer/v1/tx.js
  var require_tx7 = __commonJS({
    "node_modules/cosmjs-types/ibc/applications/transfer/v1/tx.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.MsgClientImpl = exports2.MsgTransferResponse = exports2.MsgTransfer = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var coin_1 = require_coin();
      var client_1 = require_client();
      exports2.protobufPackage = "ibc.applications.transfer.v1";
      var baseMsgTransfer = {
        sourcePort: "",
        sourceChannel: "",
        sender: "",
        receiver: "",
        timeoutTimestamp: long_1.default.UZERO
      };
      exports2.MsgTransfer = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.sourcePort !== "") {
            writer.uint32(10).string(message.sourcePort);
          }
          if (message.sourceChannel !== "") {
            writer.uint32(18).string(message.sourceChannel);
          }
          if (message.token !== void 0) {
            coin_1.Coin.encode(message.token, writer.uint32(26).fork()).ldelim();
          }
          if (message.sender !== "") {
            writer.uint32(34).string(message.sender);
          }
          if (message.receiver !== "") {
            writer.uint32(42).string(message.receiver);
          }
          if (message.timeoutHeight !== void 0) {
            client_1.Height.encode(message.timeoutHeight, writer.uint32(50).fork()).ldelim();
          }
          if (!message.timeoutTimestamp.isZero()) {
            writer.uint32(56).uint64(message.timeoutTimestamp);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgTransfer);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.sourcePort = reader.string();
                break;
              case 2:
                message.sourceChannel = reader.string();
                break;
              case 3:
                message.token = coin_1.Coin.decode(reader, reader.uint32());
                break;
              case 4:
                message.sender = reader.string();
                break;
              case 5:
                message.receiver = reader.string();
                break;
              case 6:
                message.timeoutHeight = client_1.Height.decode(reader, reader.uint32());
                break;
              case 7:
                message.timeoutTimestamp = reader.uint64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMsgTransfer);
          message.sourcePort = object.sourcePort !== void 0 && object.sourcePort !== null ? String(object.sourcePort) : "";
          message.sourceChannel = object.sourceChannel !== void 0 && object.sourceChannel !== null ? String(object.sourceChannel) : "";
          message.token = object.token !== void 0 && object.token !== null ? coin_1.Coin.fromJSON(object.token) : void 0;
          message.sender = object.sender !== void 0 && object.sender !== null ? String(object.sender) : "";
          message.receiver = object.receiver !== void 0 && object.receiver !== null ? String(object.receiver) : "";
          message.timeoutHeight = object.timeoutHeight !== void 0 && object.timeoutHeight !== null ? client_1.Height.fromJSON(object.timeoutHeight) : void 0;
          message.timeoutTimestamp = object.timeoutTimestamp !== void 0 && object.timeoutTimestamp !== null ? long_1.default.fromString(object.timeoutTimestamp) : long_1.default.UZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.sourcePort !== void 0 && (obj.sourcePort = message.sourcePort);
          message.sourceChannel !== void 0 && (obj.sourceChannel = message.sourceChannel);
          message.token !== void 0 && (obj.token = message.token ? coin_1.Coin.toJSON(message.token) : void 0);
          message.sender !== void 0 && (obj.sender = message.sender);
          message.receiver !== void 0 && (obj.receiver = message.receiver);
          message.timeoutHeight !== void 0 && (obj.timeoutHeight = message.timeoutHeight ? client_1.Height.toJSON(message.timeoutHeight) : void 0);
          message.timeoutTimestamp !== void 0 && (obj.timeoutTimestamp = (message.timeoutTimestamp || long_1.default.UZERO).toString());
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c, _d;
          const message = Object.assign({}, baseMsgTransfer);
          message.sourcePort = (_a = object.sourcePort) !== null && _a !== void 0 ? _a : "";
          message.sourceChannel = (_b = object.sourceChannel) !== null && _b !== void 0 ? _b : "";
          message.token = object.token !== void 0 && object.token !== null ? coin_1.Coin.fromPartial(object.token) : void 0;
          message.sender = (_c = object.sender) !== null && _c !== void 0 ? _c : "";
          message.receiver = (_d = object.receiver) !== null && _d !== void 0 ? _d : "";
          message.timeoutHeight = object.timeoutHeight !== void 0 && object.timeoutHeight !== null ? client_1.Height.fromPartial(object.timeoutHeight) : void 0;
          message.timeoutTimestamp = object.timeoutTimestamp !== void 0 && object.timeoutTimestamp !== null ? long_1.default.fromValue(object.timeoutTimestamp) : long_1.default.UZERO;
          return message;
        }
      };
      var baseMsgTransferResponse = {};
      exports2.MsgTransferResponse = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgTransferResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseMsgTransferResponse);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseMsgTransferResponse);
          return message;
        }
      };
      var MsgClientImpl = class {
        constructor(rpc) {
          this.rpc = rpc;
          this.Transfer = this.Transfer.bind(this);
        }
        Transfer(request) {
          const data = exports2.MsgTransfer.encode(request).finish();
          const promise = this.rpc.request("ibc.applications.transfer.v1.Msg", "Transfer", data);
          return promise.then((data2) => exports2.MsgTransferResponse.decode(new minimal_1.default.Reader(data2)));
        }
      };
      exports2.MsgClientImpl = MsgClientImpl;
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/cosmjs-types/ibc/core/channel/v1/channel.js
  var require_channel = __commonJS({
    "node_modules/cosmjs-types/ibc/core/channel/v1/channel.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.Acknowledgement = exports2.PacketState = exports2.Packet = exports2.Counterparty = exports2.IdentifiedChannel = exports2.Channel = exports2.orderToJSON = exports2.orderFromJSON = exports2.Order = exports2.stateToJSON = exports2.stateFromJSON = exports2.State = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var client_1 = require_client();
      exports2.protobufPackage = "ibc.core.channel.v1";
      var State;
      (function(State2) {
        State2[State2["STATE_UNINITIALIZED_UNSPECIFIED"] = 0] = "STATE_UNINITIALIZED_UNSPECIFIED";
        State2[State2["STATE_INIT"] = 1] = "STATE_INIT";
        State2[State2["STATE_TRYOPEN"] = 2] = "STATE_TRYOPEN";
        State2[State2["STATE_OPEN"] = 3] = "STATE_OPEN";
        State2[State2["STATE_CLOSED"] = 4] = "STATE_CLOSED";
        State2[State2["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
      })(State = exports2.State || (exports2.State = {}));
      function stateFromJSON(object) {
        switch (object) {
          case 0:
          case "STATE_UNINITIALIZED_UNSPECIFIED":
            return State.STATE_UNINITIALIZED_UNSPECIFIED;
          case 1:
          case "STATE_INIT":
            return State.STATE_INIT;
          case 2:
          case "STATE_TRYOPEN":
            return State.STATE_TRYOPEN;
          case 3:
          case "STATE_OPEN":
            return State.STATE_OPEN;
          case 4:
          case "STATE_CLOSED":
            return State.STATE_CLOSED;
          case -1:
          case "UNRECOGNIZED":
          default:
            return State.UNRECOGNIZED;
        }
      }
      exports2.stateFromJSON = stateFromJSON;
      function stateToJSON(object) {
        switch (object) {
          case State.STATE_UNINITIALIZED_UNSPECIFIED:
            return "STATE_UNINITIALIZED_UNSPECIFIED";
          case State.STATE_INIT:
            return "STATE_INIT";
          case State.STATE_TRYOPEN:
            return "STATE_TRYOPEN";
          case State.STATE_OPEN:
            return "STATE_OPEN";
          case State.STATE_CLOSED:
            return "STATE_CLOSED";
          default:
            return "UNKNOWN";
        }
      }
      exports2.stateToJSON = stateToJSON;
      var Order;
      (function(Order2) {
        Order2[Order2["ORDER_NONE_UNSPECIFIED"] = 0] = "ORDER_NONE_UNSPECIFIED";
        Order2[Order2["ORDER_UNORDERED"] = 1] = "ORDER_UNORDERED";
        Order2[Order2["ORDER_ORDERED"] = 2] = "ORDER_ORDERED";
        Order2[Order2["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
      })(Order = exports2.Order || (exports2.Order = {}));
      function orderFromJSON(object) {
        switch (object) {
          case 0:
          case "ORDER_NONE_UNSPECIFIED":
            return Order.ORDER_NONE_UNSPECIFIED;
          case 1:
          case "ORDER_UNORDERED":
            return Order.ORDER_UNORDERED;
          case 2:
          case "ORDER_ORDERED":
            return Order.ORDER_ORDERED;
          case -1:
          case "UNRECOGNIZED":
          default:
            return Order.UNRECOGNIZED;
        }
      }
      exports2.orderFromJSON = orderFromJSON;
      function orderToJSON(object) {
        switch (object) {
          case Order.ORDER_NONE_UNSPECIFIED:
            return "ORDER_NONE_UNSPECIFIED";
          case Order.ORDER_UNORDERED:
            return "ORDER_UNORDERED";
          case Order.ORDER_ORDERED:
            return "ORDER_ORDERED";
          default:
            return "UNKNOWN";
        }
      }
      exports2.orderToJSON = orderToJSON;
      var baseChannel = { state: 0, ordering: 0, connectionHops: "", version: "" };
      exports2.Channel = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.state !== 0) {
            writer.uint32(8).int32(message.state);
          }
          if (message.ordering !== 0) {
            writer.uint32(16).int32(message.ordering);
          }
          if (message.counterparty !== void 0) {
            exports2.Counterparty.encode(message.counterparty, writer.uint32(26).fork()).ldelim();
          }
          for (const v of message.connectionHops) {
            writer.uint32(34).string(v);
          }
          if (message.version !== "") {
            writer.uint32(42).string(message.version);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseChannel);
          message.connectionHops = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.state = reader.int32();
                break;
              case 2:
                message.ordering = reader.int32();
                break;
              case 3:
                message.counterparty = exports2.Counterparty.decode(reader, reader.uint32());
                break;
              case 4:
                message.connectionHops.push(reader.string());
                break;
              case 5:
                message.version = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseChannel);
          message.state = object.state !== void 0 && object.state !== null ? stateFromJSON(object.state) : 0;
          message.ordering = object.ordering !== void 0 && object.ordering !== null ? orderFromJSON(object.ordering) : 0;
          message.counterparty = object.counterparty !== void 0 && object.counterparty !== null ? exports2.Counterparty.fromJSON(object.counterparty) : void 0;
          message.connectionHops = ((_a = object.connectionHops) !== null && _a !== void 0 ? _a : []).map((e) => String(e));
          message.version = object.version !== void 0 && object.version !== null ? String(object.version) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.state !== void 0 && (obj.state = stateToJSON(message.state));
          message.ordering !== void 0 && (obj.ordering = orderToJSON(message.ordering));
          message.counterparty !== void 0 && (obj.counterparty = message.counterparty ? exports2.Counterparty.toJSON(message.counterparty) : void 0);
          if (message.connectionHops) {
            obj.connectionHops = message.connectionHops.map((e) => e);
          } else {
            obj.connectionHops = [];
          }
          message.version !== void 0 && (obj.version = message.version);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c, _d;
          const message = Object.assign({}, baseChannel);
          message.state = (_a = object.state) !== null && _a !== void 0 ? _a : 0;
          message.ordering = (_b = object.ordering) !== null && _b !== void 0 ? _b : 0;
          message.counterparty = object.counterparty !== void 0 && object.counterparty !== null ? exports2.Counterparty.fromPartial(object.counterparty) : void 0;
          message.connectionHops = ((_c = object.connectionHops) === null || _c === void 0 ? void 0 : _c.map((e) => e)) || [];
          message.version = (_d = object.version) !== null && _d !== void 0 ? _d : "";
          return message;
        }
      };
      var baseIdentifiedChannel = {
        state: 0,
        ordering: 0,
        connectionHops: "",
        version: "",
        portId: "",
        channelId: ""
      };
      exports2.IdentifiedChannel = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.state !== 0) {
            writer.uint32(8).int32(message.state);
          }
          if (message.ordering !== 0) {
            writer.uint32(16).int32(message.ordering);
          }
          if (message.counterparty !== void 0) {
            exports2.Counterparty.encode(message.counterparty, writer.uint32(26).fork()).ldelim();
          }
          for (const v of message.connectionHops) {
            writer.uint32(34).string(v);
          }
          if (message.version !== "") {
            writer.uint32(42).string(message.version);
          }
          if (message.portId !== "") {
            writer.uint32(50).string(message.portId);
          }
          if (message.channelId !== "") {
            writer.uint32(58).string(message.channelId);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseIdentifiedChannel);
          message.connectionHops = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.state = reader.int32();
                break;
              case 2:
                message.ordering = reader.int32();
                break;
              case 3:
                message.counterparty = exports2.Counterparty.decode(reader, reader.uint32());
                break;
              case 4:
                message.connectionHops.push(reader.string());
                break;
              case 5:
                message.version = reader.string();
                break;
              case 6:
                message.portId = reader.string();
                break;
              case 7:
                message.channelId = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseIdentifiedChannel);
          message.state = object.state !== void 0 && object.state !== null ? stateFromJSON(object.state) : 0;
          message.ordering = object.ordering !== void 0 && object.ordering !== null ? orderFromJSON(object.ordering) : 0;
          message.counterparty = object.counterparty !== void 0 && object.counterparty !== null ? exports2.Counterparty.fromJSON(object.counterparty) : void 0;
          message.connectionHops = ((_a = object.connectionHops) !== null && _a !== void 0 ? _a : []).map((e) => String(e));
          message.version = object.version !== void 0 && object.version !== null ? String(object.version) : "";
          message.portId = object.portId !== void 0 && object.portId !== null ? String(object.portId) : "";
          message.channelId = object.channelId !== void 0 && object.channelId !== null ? String(object.channelId) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.state !== void 0 && (obj.state = stateToJSON(message.state));
          message.ordering !== void 0 && (obj.ordering = orderToJSON(message.ordering));
          message.counterparty !== void 0 && (obj.counterparty = message.counterparty ? exports2.Counterparty.toJSON(message.counterparty) : void 0);
          if (message.connectionHops) {
            obj.connectionHops = message.connectionHops.map((e) => e);
          } else {
            obj.connectionHops = [];
          }
          message.version !== void 0 && (obj.version = message.version);
          message.portId !== void 0 && (obj.portId = message.portId);
          message.channelId !== void 0 && (obj.channelId = message.channelId);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c, _d, _e, _f;
          const message = Object.assign({}, baseIdentifiedChannel);
          message.state = (_a = object.state) !== null && _a !== void 0 ? _a : 0;
          message.ordering = (_b = object.ordering) !== null && _b !== void 0 ? _b : 0;
          message.counterparty = object.counterparty !== void 0 && object.counterparty !== null ? exports2.Counterparty.fromPartial(object.counterparty) : void 0;
          message.connectionHops = ((_c = object.connectionHops) === null || _c === void 0 ? void 0 : _c.map((e) => e)) || [];
          message.version = (_d = object.version) !== null && _d !== void 0 ? _d : "";
          message.portId = (_e = object.portId) !== null && _e !== void 0 ? _e : "";
          message.channelId = (_f = object.channelId) !== null && _f !== void 0 ? _f : "";
          return message;
        }
      };
      var baseCounterparty = { portId: "", channelId: "" };
      exports2.Counterparty = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.portId !== "") {
            writer.uint32(10).string(message.portId);
          }
          if (message.channelId !== "") {
            writer.uint32(18).string(message.channelId);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseCounterparty);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.portId = reader.string();
                break;
              case 2:
                message.channelId = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseCounterparty);
          message.portId = object.portId !== void 0 && object.portId !== null ? String(object.portId) : "";
          message.channelId = object.channelId !== void 0 && object.channelId !== null ? String(object.channelId) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.portId !== void 0 && (obj.portId = message.portId);
          message.channelId !== void 0 && (obj.channelId = message.channelId);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseCounterparty);
          message.portId = (_a = object.portId) !== null && _a !== void 0 ? _a : "";
          message.channelId = (_b = object.channelId) !== null && _b !== void 0 ? _b : "";
          return message;
        }
      };
      var basePacket = {
        sequence: long_1.default.UZERO,
        sourcePort: "",
        sourceChannel: "",
        destinationPort: "",
        destinationChannel: "",
        timeoutTimestamp: long_1.default.UZERO
      };
      exports2.Packet = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.sequence.isZero()) {
            writer.uint32(8).uint64(message.sequence);
          }
          if (message.sourcePort !== "") {
            writer.uint32(18).string(message.sourcePort);
          }
          if (message.sourceChannel !== "") {
            writer.uint32(26).string(message.sourceChannel);
          }
          if (message.destinationPort !== "") {
            writer.uint32(34).string(message.destinationPort);
          }
          if (message.destinationChannel !== "") {
            writer.uint32(42).string(message.destinationChannel);
          }
          if (message.data.length !== 0) {
            writer.uint32(50).bytes(message.data);
          }
          if (message.timeoutHeight !== void 0) {
            client_1.Height.encode(message.timeoutHeight, writer.uint32(58).fork()).ldelim();
          }
          if (!message.timeoutTimestamp.isZero()) {
            writer.uint32(64).uint64(message.timeoutTimestamp);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, basePacket);
          message.data = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.sequence = reader.uint64();
                break;
              case 2:
                message.sourcePort = reader.string();
                break;
              case 3:
                message.sourceChannel = reader.string();
                break;
              case 4:
                message.destinationPort = reader.string();
                break;
              case 5:
                message.destinationChannel = reader.string();
                break;
              case 6:
                message.data = reader.bytes();
                break;
              case 7:
                message.timeoutHeight = client_1.Height.decode(reader, reader.uint32());
                break;
              case 8:
                message.timeoutTimestamp = reader.uint64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, basePacket);
          message.sequence = object.sequence !== void 0 && object.sequence !== null ? long_1.default.fromString(object.sequence) : long_1.default.UZERO;
          message.sourcePort = object.sourcePort !== void 0 && object.sourcePort !== null ? String(object.sourcePort) : "";
          message.sourceChannel = object.sourceChannel !== void 0 && object.sourceChannel !== null ? String(object.sourceChannel) : "";
          message.destinationPort = object.destinationPort !== void 0 && object.destinationPort !== null ? String(object.destinationPort) : "";
          message.destinationChannel = object.destinationChannel !== void 0 && object.destinationChannel !== null ? String(object.destinationChannel) : "";
          message.data = object.data !== void 0 && object.data !== null ? bytesFromBase64(object.data) : new Uint8Array();
          message.timeoutHeight = object.timeoutHeight !== void 0 && object.timeoutHeight !== null ? client_1.Height.fromJSON(object.timeoutHeight) : void 0;
          message.timeoutTimestamp = object.timeoutTimestamp !== void 0 && object.timeoutTimestamp !== null ? long_1.default.fromString(object.timeoutTimestamp) : long_1.default.UZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.sequence !== void 0 && (obj.sequence = (message.sequence || long_1.default.UZERO).toString());
          message.sourcePort !== void 0 && (obj.sourcePort = message.sourcePort);
          message.sourceChannel !== void 0 && (obj.sourceChannel = message.sourceChannel);
          message.destinationPort !== void 0 && (obj.destinationPort = message.destinationPort);
          message.destinationChannel !== void 0 && (obj.destinationChannel = message.destinationChannel);
          message.data !== void 0 && (obj.data = base64FromBytes(message.data !== void 0 ? message.data : new Uint8Array()));
          message.timeoutHeight !== void 0 && (obj.timeoutHeight = message.timeoutHeight ? client_1.Height.toJSON(message.timeoutHeight) : void 0);
          message.timeoutTimestamp !== void 0 && (obj.timeoutTimestamp = (message.timeoutTimestamp || long_1.default.UZERO).toString());
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c, _d, _e;
          const message = Object.assign({}, basePacket);
          message.sequence = object.sequence !== void 0 && object.sequence !== null ? long_1.default.fromValue(object.sequence) : long_1.default.UZERO;
          message.sourcePort = (_a = object.sourcePort) !== null && _a !== void 0 ? _a : "";
          message.sourceChannel = (_b = object.sourceChannel) !== null && _b !== void 0 ? _b : "";
          message.destinationPort = (_c = object.destinationPort) !== null && _c !== void 0 ? _c : "";
          message.destinationChannel = (_d = object.destinationChannel) !== null && _d !== void 0 ? _d : "";
          message.data = (_e = object.data) !== null && _e !== void 0 ? _e : new Uint8Array();
          message.timeoutHeight = object.timeoutHeight !== void 0 && object.timeoutHeight !== null ? client_1.Height.fromPartial(object.timeoutHeight) : void 0;
          message.timeoutTimestamp = object.timeoutTimestamp !== void 0 && object.timeoutTimestamp !== null ? long_1.default.fromValue(object.timeoutTimestamp) : long_1.default.UZERO;
          return message;
        }
      };
      var basePacketState = { portId: "", channelId: "", sequence: long_1.default.UZERO };
      exports2.PacketState = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.portId !== "") {
            writer.uint32(10).string(message.portId);
          }
          if (message.channelId !== "") {
            writer.uint32(18).string(message.channelId);
          }
          if (!message.sequence.isZero()) {
            writer.uint32(24).uint64(message.sequence);
          }
          if (message.data.length !== 0) {
            writer.uint32(34).bytes(message.data);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, basePacketState);
          message.data = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.portId = reader.string();
                break;
              case 2:
                message.channelId = reader.string();
                break;
              case 3:
                message.sequence = reader.uint64();
                break;
              case 4:
                message.data = reader.bytes();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, basePacketState);
          message.portId = object.portId !== void 0 && object.portId !== null ? String(object.portId) : "";
          message.channelId = object.channelId !== void 0 && object.channelId !== null ? String(object.channelId) : "";
          message.sequence = object.sequence !== void 0 && object.sequence !== null ? long_1.default.fromString(object.sequence) : long_1.default.UZERO;
          message.data = object.data !== void 0 && object.data !== null ? bytesFromBase64(object.data) : new Uint8Array();
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.portId !== void 0 && (obj.portId = message.portId);
          message.channelId !== void 0 && (obj.channelId = message.channelId);
          message.sequence !== void 0 && (obj.sequence = (message.sequence || long_1.default.UZERO).toString());
          message.data !== void 0 && (obj.data = base64FromBytes(message.data !== void 0 ? message.data : new Uint8Array()));
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, basePacketState);
          message.portId = (_a = object.portId) !== null && _a !== void 0 ? _a : "";
          message.channelId = (_b = object.channelId) !== null && _b !== void 0 ? _b : "";
          message.sequence = object.sequence !== void 0 && object.sequence !== null ? long_1.default.fromValue(object.sequence) : long_1.default.UZERO;
          message.data = (_c = object.data) !== null && _c !== void 0 ? _c : new Uint8Array();
          return message;
        }
      };
      var baseAcknowledgement = {};
      exports2.Acknowledgement = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.result !== void 0) {
            writer.uint32(170).bytes(message.result);
          }
          if (message.error !== void 0) {
            writer.uint32(178).string(message.error);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseAcknowledgement);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 21:
                message.result = reader.bytes();
                break;
              case 22:
                message.error = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseAcknowledgement);
          message.result = object.result !== void 0 && object.result !== null ? bytesFromBase64(object.result) : void 0;
          message.error = object.error !== void 0 && object.error !== null ? String(object.error) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.result !== void 0 && (obj.result = message.result !== void 0 ? base64FromBytes(message.result) : void 0);
          message.error !== void 0 && (obj.error = message.error);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseAcknowledgement);
          message.result = (_a = object.result) !== null && _a !== void 0 ? _a : void 0;
          message.error = (_b = object.error) !== null && _b !== void 0 ? _b : void 0;
          return message;
        }
      };
      var globalThis2 = (() => {
        if (typeof globalThis2 !== "undefined")
          return globalThis2;
        if (typeof self !== "undefined")
          return self;
        if (typeof window !== "undefined")
          return window;
        if (typeof global !== "undefined")
          return global;
        throw "Unable to locate global object";
      })();
      var atob2 = globalThis2.atob || ((b64) => globalThis2.Buffer.from(b64, "base64").toString("binary"));
      function bytesFromBase64(b64) {
        const bin = atob2(b64);
        const arr = new Uint8Array(bin.length);
        for (let i = 0; i < bin.length; ++i) {
          arr[i] = bin.charCodeAt(i);
        }
        return arr;
      }
      var btoa2 = globalThis2.btoa || ((bin) => globalThis2.Buffer.from(bin, "binary").toString("base64"));
      function base64FromBytes(arr) {
        const bin = [];
        for (const byte of arr) {
          bin.push(String.fromCharCode(byte));
        }
        return btoa2(bin.join(""));
      }
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/cosmjs-types/ibc/core/channel/v1/tx.js
  var require_tx8 = __commonJS({
    "node_modules/cosmjs-types/ibc/core/channel/v1/tx.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.MsgClientImpl = exports2.MsgAcknowledgementResponse = exports2.MsgAcknowledgement = exports2.MsgTimeoutOnCloseResponse = exports2.MsgTimeoutOnClose = exports2.MsgTimeoutResponse = exports2.MsgTimeout = exports2.MsgRecvPacketResponse = exports2.MsgRecvPacket = exports2.MsgChannelCloseConfirmResponse = exports2.MsgChannelCloseConfirm = exports2.MsgChannelCloseInitResponse = exports2.MsgChannelCloseInit = exports2.MsgChannelOpenConfirmResponse = exports2.MsgChannelOpenConfirm = exports2.MsgChannelOpenAckResponse = exports2.MsgChannelOpenAck = exports2.MsgChannelOpenTryResponse = exports2.MsgChannelOpenTry = exports2.MsgChannelOpenInitResponse = exports2.MsgChannelOpenInit = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var channel_1 = require_channel();
      var client_1 = require_client();
      exports2.protobufPackage = "ibc.core.channel.v1";
      var baseMsgChannelOpenInit = { portId: "", signer: "" };
      exports2.MsgChannelOpenInit = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.portId !== "") {
            writer.uint32(10).string(message.portId);
          }
          if (message.channel !== void 0) {
            channel_1.Channel.encode(message.channel, writer.uint32(18).fork()).ldelim();
          }
          if (message.signer !== "") {
            writer.uint32(26).string(message.signer);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgChannelOpenInit);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.portId = reader.string();
                break;
              case 2:
                message.channel = channel_1.Channel.decode(reader, reader.uint32());
                break;
              case 3:
                message.signer = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMsgChannelOpenInit);
          message.portId = object.portId !== void 0 && object.portId !== null ? String(object.portId) : "";
          message.channel = object.channel !== void 0 && object.channel !== null ? channel_1.Channel.fromJSON(object.channel) : void 0;
          message.signer = object.signer !== void 0 && object.signer !== null ? String(object.signer) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.portId !== void 0 && (obj.portId = message.portId);
          message.channel !== void 0 && (obj.channel = message.channel ? channel_1.Channel.toJSON(message.channel) : void 0);
          message.signer !== void 0 && (obj.signer = message.signer);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseMsgChannelOpenInit);
          message.portId = (_a = object.portId) !== null && _a !== void 0 ? _a : "";
          message.channel = object.channel !== void 0 && object.channel !== null ? channel_1.Channel.fromPartial(object.channel) : void 0;
          message.signer = (_b = object.signer) !== null && _b !== void 0 ? _b : "";
          return message;
        }
      };
      var baseMsgChannelOpenInitResponse = {};
      exports2.MsgChannelOpenInitResponse = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgChannelOpenInitResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseMsgChannelOpenInitResponse);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseMsgChannelOpenInitResponse);
          return message;
        }
      };
      var baseMsgChannelOpenTry = {
        portId: "",
        previousChannelId: "",
        counterpartyVersion: "",
        signer: ""
      };
      exports2.MsgChannelOpenTry = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.portId !== "") {
            writer.uint32(10).string(message.portId);
          }
          if (message.previousChannelId !== "") {
            writer.uint32(18).string(message.previousChannelId);
          }
          if (message.channel !== void 0) {
            channel_1.Channel.encode(message.channel, writer.uint32(26).fork()).ldelim();
          }
          if (message.counterpartyVersion !== "") {
            writer.uint32(34).string(message.counterpartyVersion);
          }
          if (message.proofInit.length !== 0) {
            writer.uint32(42).bytes(message.proofInit);
          }
          if (message.proofHeight !== void 0) {
            client_1.Height.encode(message.proofHeight, writer.uint32(50).fork()).ldelim();
          }
          if (message.signer !== "") {
            writer.uint32(58).string(message.signer);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgChannelOpenTry);
          message.proofInit = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.portId = reader.string();
                break;
              case 2:
                message.previousChannelId = reader.string();
                break;
              case 3:
                message.channel = channel_1.Channel.decode(reader, reader.uint32());
                break;
              case 4:
                message.counterpartyVersion = reader.string();
                break;
              case 5:
                message.proofInit = reader.bytes();
                break;
              case 6:
                message.proofHeight = client_1.Height.decode(reader, reader.uint32());
                break;
              case 7:
                message.signer = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMsgChannelOpenTry);
          message.portId = object.portId !== void 0 && object.portId !== null ? String(object.portId) : "";
          message.previousChannelId = object.previousChannelId !== void 0 && object.previousChannelId !== null ? String(object.previousChannelId) : "";
          message.channel = object.channel !== void 0 && object.channel !== null ? channel_1.Channel.fromJSON(object.channel) : void 0;
          message.counterpartyVersion = object.counterpartyVersion !== void 0 && object.counterpartyVersion !== null ? String(object.counterpartyVersion) : "";
          message.proofInit = object.proofInit !== void 0 && object.proofInit !== null ? bytesFromBase64(object.proofInit) : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromJSON(object.proofHeight) : void 0;
          message.signer = object.signer !== void 0 && object.signer !== null ? String(object.signer) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.portId !== void 0 && (obj.portId = message.portId);
          message.previousChannelId !== void 0 && (obj.previousChannelId = message.previousChannelId);
          message.channel !== void 0 && (obj.channel = message.channel ? channel_1.Channel.toJSON(message.channel) : void 0);
          message.counterpartyVersion !== void 0 && (obj.counterpartyVersion = message.counterpartyVersion);
          message.proofInit !== void 0 && (obj.proofInit = base64FromBytes(message.proofInit !== void 0 ? message.proofInit : new Uint8Array()));
          message.proofHeight !== void 0 && (obj.proofHeight = message.proofHeight ? client_1.Height.toJSON(message.proofHeight) : void 0);
          message.signer !== void 0 && (obj.signer = message.signer);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c, _d, _e;
          const message = Object.assign({}, baseMsgChannelOpenTry);
          message.portId = (_a = object.portId) !== null && _a !== void 0 ? _a : "";
          message.previousChannelId = (_b = object.previousChannelId) !== null && _b !== void 0 ? _b : "";
          message.channel = object.channel !== void 0 && object.channel !== null ? channel_1.Channel.fromPartial(object.channel) : void 0;
          message.counterpartyVersion = (_c = object.counterpartyVersion) !== null && _c !== void 0 ? _c : "";
          message.proofInit = (_d = object.proofInit) !== null && _d !== void 0 ? _d : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromPartial(object.proofHeight) : void 0;
          message.signer = (_e = object.signer) !== null && _e !== void 0 ? _e : "";
          return message;
        }
      };
      var baseMsgChannelOpenTryResponse = {};
      exports2.MsgChannelOpenTryResponse = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgChannelOpenTryResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseMsgChannelOpenTryResponse);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseMsgChannelOpenTryResponse);
          return message;
        }
      };
      var baseMsgChannelOpenAck = {
        portId: "",
        channelId: "",
        counterpartyChannelId: "",
        counterpartyVersion: "",
        signer: ""
      };
      exports2.MsgChannelOpenAck = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.portId !== "") {
            writer.uint32(10).string(message.portId);
          }
          if (message.channelId !== "") {
            writer.uint32(18).string(message.channelId);
          }
          if (message.counterpartyChannelId !== "") {
            writer.uint32(26).string(message.counterpartyChannelId);
          }
          if (message.counterpartyVersion !== "") {
            writer.uint32(34).string(message.counterpartyVersion);
          }
          if (message.proofTry.length !== 0) {
            writer.uint32(42).bytes(message.proofTry);
          }
          if (message.proofHeight !== void 0) {
            client_1.Height.encode(message.proofHeight, writer.uint32(50).fork()).ldelim();
          }
          if (message.signer !== "") {
            writer.uint32(58).string(message.signer);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgChannelOpenAck);
          message.proofTry = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.portId = reader.string();
                break;
              case 2:
                message.channelId = reader.string();
                break;
              case 3:
                message.counterpartyChannelId = reader.string();
                break;
              case 4:
                message.counterpartyVersion = reader.string();
                break;
              case 5:
                message.proofTry = reader.bytes();
                break;
              case 6:
                message.proofHeight = client_1.Height.decode(reader, reader.uint32());
                break;
              case 7:
                message.signer = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMsgChannelOpenAck);
          message.portId = object.portId !== void 0 && object.portId !== null ? String(object.portId) : "";
          message.channelId = object.channelId !== void 0 && object.channelId !== null ? String(object.channelId) : "";
          message.counterpartyChannelId = object.counterpartyChannelId !== void 0 && object.counterpartyChannelId !== null ? String(object.counterpartyChannelId) : "";
          message.counterpartyVersion = object.counterpartyVersion !== void 0 && object.counterpartyVersion !== null ? String(object.counterpartyVersion) : "";
          message.proofTry = object.proofTry !== void 0 && object.proofTry !== null ? bytesFromBase64(object.proofTry) : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromJSON(object.proofHeight) : void 0;
          message.signer = object.signer !== void 0 && object.signer !== null ? String(object.signer) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.portId !== void 0 && (obj.portId = message.portId);
          message.channelId !== void 0 && (obj.channelId = message.channelId);
          message.counterpartyChannelId !== void 0 && (obj.counterpartyChannelId = message.counterpartyChannelId);
          message.counterpartyVersion !== void 0 && (obj.counterpartyVersion = message.counterpartyVersion);
          message.proofTry !== void 0 && (obj.proofTry = base64FromBytes(message.proofTry !== void 0 ? message.proofTry : new Uint8Array()));
          message.proofHeight !== void 0 && (obj.proofHeight = message.proofHeight ? client_1.Height.toJSON(message.proofHeight) : void 0);
          message.signer !== void 0 && (obj.signer = message.signer);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c, _d, _e, _f;
          const message = Object.assign({}, baseMsgChannelOpenAck);
          message.portId = (_a = object.portId) !== null && _a !== void 0 ? _a : "";
          message.channelId = (_b = object.channelId) !== null && _b !== void 0 ? _b : "";
          message.counterpartyChannelId = (_c = object.counterpartyChannelId) !== null && _c !== void 0 ? _c : "";
          message.counterpartyVersion = (_d = object.counterpartyVersion) !== null && _d !== void 0 ? _d : "";
          message.proofTry = (_e = object.proofTry) !== null && _e !== void 0 ? _e : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromPartial(object.proofHeight) : void 0;
          message.signer = (_f = object.signer) !== null && _f !== void 0 ? _f : "";
          return message;
        }
      };
      var baseMsgChannelOpenAckResponse = {};
      exports2.MsgChannelOpenAckResponse = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgChannelOpenAckResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseMsgChannelOpenAckResponse);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseMsgChannelOpenAckResponse);
          return message;
        }
      };
      var baseMsgChannelOpenConfirm = { portId: "", channelId: "", signer: "" };
      exports2.MsgChannelOpenConfirm = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.portId !== "") {
            writer.uint32(10).string(message.portId);
          }
          if (message.channelId !== "") {
            writer.uint32(18).string(message.channelId);
          }
          if (message.proofAck.length !== 0) {
            writer.uint32(26).bytes(message.proofAck);
          }
          if (message.proofHeight !== void 0) {
            client_1.Height.encode(message.proofHeight, writer.uint32(34).fork()).ldelim();
          }
          if (message.signer !== "") {
            writer.uint32(42).string(message.signer);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgChannelOpenConfirm);
          message.proofAck = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.portId = reader.string();
                break;
              case 2:
                message.channelId = reader.string();
                break;
              case 3:
                message.proofAck = reader.bytes();
                break;
              case 4:
                message.proofHeight = client_1.Height.decode(reader, reader.uint32());
                break;
              case 5:
                message.signer = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMsgChannelOpenConfirm);
          message.portId = object.portId !== void 0 && object.portId !== null ? String(object.portId) : "";
          message.channelId = object.channelId !== void 0 && object.channelId !== null ? String(object.channelId) : "";
          message.proofAck = object.proofAck !== void 0 && object.proofAck !== null ? bytesFromBase64(object.proofAck) : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromJSON(object.proofHeight) : void 0;
          message.signer = object.signer !== void 0 && object.signer !== null ? String(object.signer) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.portId !== void 0 && (obj.portId = message.portId);
          message.channelId !== void 0 && (obj.channelId = message.channelId);
          message.proofAck !== void 0 && (obj.proofAck = base64FromBytes(message.proofAck !== void 0 ? message.proofAck : new Uint8Array()));
          message.proofHeight !== void 0 && (obj.proofHeight = message.proofHeight ? client_1.Height.toJSON(message.proofHeight) : void 0);
          message.signer !== void 0 && (obj.signer = message.signer);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c, _d;
          const message = Object.assign({}, baseMsgChannelOpenConfirm);
          message.portId = (_a = object.portId) !== null && _a !== void 0 ? _a : "";
          message.channelId = (_b = object.channelId) !== null && _b !== void 0 ? _b : "";
          message.proofAck = (_c = object.proofAck) !== null && _c !== void 0 ? _c : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromPartial(object.proofHeight) : void 0;
          message.signer = (_d = object.signer) !== null && _d !== void 0 ? _d : "";
          return message;
        }
      };
      var baseMsgChannelOpenConfirmResponse = {};
      exports2.MsgChannelOpenConfirmResponse = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgChannelOpenConfirmResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseMsgChannelOpenConfirmResponse);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseMsgChannelOpenConfirmResponse);
          return message;
        }
      };
      var baseMsgChannelCloseInit = { portId: "", channelId: "", signer: "" };
      exports2.MsgChannelCloseInit = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.portId !== "") {
            writer.uint32(10).string(message.portId);
          }
          if (message.channelId !== "") {
            writer.uint32(18).string(message.channelId);
          }
          if (message.signer !== "") {
            writer.uint32(26).string(message.signer);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgChannelCloseInit);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.portId = reader.string();
                break;
              case 2:
                message.channelId = reader.string();
                break;
              case 3:
                message.signer = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMsgChannelCloseInit);
          message.portId = object.portId !== void 0 && object.portId !== null ? String(object.portId) : "";
          message.channelId = object.channelId !== void 0 && object.channelId !== null ? String(object.channelId) : "";
          message.signer = object.signer !== void 0 && object.signer !== null ? String(object.signer) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.portId !== void 0 && (obj.portId = message.portId);
          message.channelId !== void 0 && (obj.channelId = message.channelId);
          message.signer !== void 0 && (obj.signer = message.signer);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseMsgChannelCloseInit);
          message.portId = (_a = object.portId) !== null && _a !== void 0 ? _a : "";
          message.channelId = (_b = object.channelId) !== null && _b !== void 0 ? _b : "";
          message.signer = (_c = object.signer) !== null && _c !== void 0 ? _c : "";
          return message;
        }
      };
      var baseMsgChannelCloseInitResponse = {};
      exports2.MsgChannelCloseInitResponse = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgChannelCloseInitResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseMsgChannelCloseInitResponse);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseMsgChannelCloseInitResponse);
          return message;
        }
      };
      var baseMsgChannelCloseConfirm = { portId: "", channelId: "", signer: "" };
      exports2.MsgChannelCloseConfirm = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.portId !== "") {
            writer.uint32(10).string(message.portId);
          }
          if (message.channelId !== "") {
            writer.uint32(18).string(message.channelId);
          }
          if (message.proofInit.length !== 0) {
            writer.uint32(26).bytes(message.proofInit);
          }
          if (message.proofHeight !== void 0) {
            client_1.Height.encode(message.proofHeight, writer.uint32(34).fork()).ldelim();
          }
          if (message.signer !== "") {
            writer.uint32(42).string(message.signer);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgChannelCloseConfirm);
          message.proofInit = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.portId = reader.string();
                break;
              case 2:
                message.channelId = reader.string();
                break;
              case 3:
                message.proofInit = reader.bytes();
                break;
              case 4:
                message.proofHeight = client_1.Height.decode(reader, reader.uint32());
                break;
              case 5:
                message.signer = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMsgChannelCloseConfirm);
          message.portId = object.portId !== void 0 && object.portId !== null ? String(object.portId) : "";
          message.channelId = object.channelId !== void 0 && object.channelId !== null ? String(object.channelId) : "";
          message.proofInit = object.proofInit !== void 0 && object.proofInit !== null ? bytesFromBase64(object.proofInit) : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromJSON(object.proofHeight) : void 0;
          message.signer = object.signer !== void 0 && object.signer !== null ? String(object.signer) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.portId !== void 0 && (obj.portId = message.portId);
          message.channelId !== void 0 && (obj.channelId = message.channelId);
          message.proofInit !== void 0 && (obj.proofInit = base64FromBytes(message.proofInit !== void 0 ? message.proofInit : new Uint8Array()));
          message.proofHeight !== void 0 && (obj.proofHeight = message.proofHeight ? client_1.Height.toJSON(message.proofHeight) : void 0);
          message.signer !== void 0 && (obj.signer = message.signer);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c, _d;
          const message = Object.assign({}, baseMsgChannelCloseConfirm);
          message.portId = (_a = object.portId) !== null && _a !== void 0 ? _a : "";
          message.channelId = (_b = object.channelId) !== null && _b !== void 0 ? _b : "";
          message.proofInit = (_c = object.proofInit) !== null && _c !== void 0 ? _c : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromPartial(object.proofHeight) : void 0;
          message.signer = (_d = object.signer) !== null && _d !== void 0 ? _d : "";
          return message;
        }
      };
      var baseMsgChannelCloseConfirmResponse = {};
      exports2.MsgChannelCloseConfirmResponse = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgChannelCloseConfirmResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseMsgChannelCloseConfirmResponse);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseMsgChannelCloseConfirmResponse);
          return message;
        }
      };
      var baseMsgRecvPacket = { signer: "" };
      exports2.MsgRecvPacket = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.packet !== void 0) {
            channel_1.Packet.encode(message.packet, writer.uint32(10).fork()).ldelim();
          }
          if (message.proofCommitment.length !== 0) {
            writer.uint32(18).bytes(message.proofCommitment);
          }
          if (message.proofHeight !== void 0) {
            client_1.Height.encode(message.proofHeight, writer.uint32(26).fork()).ldelim();
          }
          if (message.signer !== "") {
            writer.uint32(34).string(message.signer);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgRecvPacket);
          message.proofCommitment = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.packet = channel_1.Packet.decode(reader, reader.uint32());
                break;
              case 2:
                message.proofCommitment = reader.bytes();
                break;
              case 3:
                message.proofHeight = client_1.Height.decode(reader, reader.uint32());
                break;
              case 4:
                message.signer = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMsgRecvPacket);
          message.packet = object.packet !== void 0 && object.packet !== null ? channel_1.Packet.fromJSON(object.packet) : void 0;
          message.proofCommitment = object.proofCommitment !== void 0 && object.proofCommitment !== null ? bytesFromBase64(object.proofCommitment) : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromJSON(object.proofHeight) : void 0;
          message.signer = object.signer !== void 0 && object.signer !== null ? String(object.signer) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.packet !== void 0 && (obj.packet = message.packet ? channel_1.Packet.toJSON(message.packet) : void 0);
          message.proofCommitment !== void 0 && (obj.proofCommitment = base64FromBytes(message.proofCommitment !== void 0 ? message.proofCommitment : new Uint8Array()));
          message.proofHeight !== void 0 && (obj.proofHeight = message.proofHeight ? client_1.Height.toJSON(message.proofHeight) : void 0);
          message.signer !== void 0 && (obj.signer = message.signer);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseMsgRecvPacket);
          message.packet = object.packet !== void 0 && object.packet !== null ? channel_1.Packet.fromPartial(object.packet) : void 0;
          message.proofCommitment = (_a = object.proofCommitment) !== null && _a !== void 0 ? _a : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromPartial(object.proofHeight) : void 0;
          message.signer = (_b = object.signer) !== null && _b !== void 0 ? _b : "";
          return message;
        }
      };
      var baseMsgRecvPacketResponse = {};
      exports2.MsgRecvPacketResponse = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgRecvPacketResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseMsgRecvPacketResponse);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseMsgRecvPacketResponse);
          return message;
        }
      };
      var baseMsgTimeout = { nextSequenceRecv: long_1.default.UZERO, signer: "" };
      exports2.MsgTimeout = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.packet !== void 0) {
            channel_1.Packet.encode(message.packet, writer.uint32(10).fork()).ldelim();
          }
          if (message.proofUnreceived.length !== 0) {
            writer.uint32(18).bytes(message.proofUnreceived);
          }
          if (message.proofHeight !== void 0) {
            client_1.Height.encode(message.proofHeight, writer.uint32(26).fork()).ldelim();
          }
          if (!message.nextSequenceRecv.isZero()) {
            writer.uint32(32).uint64(message.nextSequenceRecv);
          }
          if (message.signer !== "") {
            writer.uint32(42).string(message.signer);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgTimeout);
          message.proofUnreceived = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.packet = channel_1.Packet.decode(reader, reader.uint32());
                break;
              case 2:
                message.proofUnreceived = reader.bytes();
                break;
              case 3:
                message.proofHeight = client_1.Height.decode(reader, reader.uint32());
                break;
              case 4:
                message.nextSequenceRecv = reader.uint64();
                break;
              case 5:
                message.signer = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMsgTimeout);
          message.packet = object.packet !== void 0 && object.packet !== null ? channel_1.Packet.fromJSON(object.packet) : void 0;
          message.proofUnreceived = object.proofUnreceived !== void 0 && object.proofUnreceived !== null ? bytesFromBase64(object.proofUnreceived) : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromJSON(object.proofHeight) : void 0;
          message.nextSequenceRecv = object.nextSequenceRecv !== void 0 && object.nextSequenceRecv !== null ? long_1.default.fromString(object.nextSequenceRecv) : long_1.default.UZERO;
          message.signer = object.signer !== void 0 && object.signer !== null ? String(object.signer) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.packet !== void 0 && (obj.packet = message.packet ? channel_1.Packet.toJSON(message.packet) : void 0);
          message.proofUnreceived !== void 0 && (obj.proofUnreceived = base64FromBytes(message.proofUnreceived !== void 0 ? message.proofUnreceived : new Uint8Array()));
          message.proofHeight !== void 0 && (obj.proofHeight = message.proofHeight ? client_1.Height.toJSON(message.proofHeight) : void 0);
          message.nextSequenceRecv !== void 0 && (obj.nextSequenceRecv = (message.nextSequenceRecv || long_1.default.UZERO).toString());
          message.signer !== void 0 && (obj.signer = message.signer);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseMsgTimeout);
          message.packet = object.packet !== void 0 && object.packet !== null ? channel_1.Packet.fromPartial(object.packet) : void 0;
          message.proofUnreceived = (_a = object.proofUnreceived) !== null && _a !== void 0 ? _a : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromPartial(object.proofHeight) : void 0;
          message.nextSequenceRecv = object.nextSequenceRecv !== void 0 && object.nextSequenceRecv !== null ? long_1.default.fromValue(object.nextSequenceRecv) : long_1.default.UZERO;
          message.signer = (_b = object.signer) !== null && _b !== void 0 ? _b : "";
          return message;
        }
      };
      var baseMsgTimeoutResponse = {};
      exports2.MsgTimeoutResponse = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgTimeoutResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseMsgTimeoutResponse);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseMsgTimeoutResponse);
          return message;
        }
      };
      var baseMsgTimeoutOnClose = { nextSequenceRecv: long_1.default.UZERO, signer: "" };
      exports2.MsgTimeoutOnClose = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.packet !== void 0) {
            channel_1.Packet.encode(message.packet, writer.uint32(10).fork()).ldelim();
          }
          if (message.proofUnreceived.length !== 0) {
            writer.uint32(18).bytes(message.proofUnreceived);
          }
          if (message.proofClose.length !== 0) {
            writer.uint32(26).bytes(message.proofClose);
          }
          if (message.proofHeight !== void 0) {
            client_1.Height.encode(message.proofHeight, writer.uint32(34).fork()).ldelim();
          }
          if (!message.nextSequenceRecv.isZero()) {
            writer.uint32(40).uint64(message.nextSequenceRecv);
          }
          if (message.signer !== "") {
            writer.uint32(50).string(message.signer);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgTimeoutOnClose);
          message.proofUnreceived = new Uint8Array();
          message.proofClose = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.packet = channel_1.Packet.decode(reader, reader.uint32());
                break;
              case 2:
                message.proofUnreceived = reader.bytes();
                break;
              case 3:
                message.proofClose = reader.bytes();
                break;
              case 4:
                message.proofHeight = client_1.Height.decode(reader, reader.uint32());
                break;
              case 5:
                message.nextSequenceRecv = reader.uint64();
                break;
              case 6:
                message.signer = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMsgTimeoutOnClose);
          message.packet = object.packet !== void 0 && object.packet !== null ? channel_1.Packet.fromJSON(object.packet) : void 0;
          message.proofUnreceived = object.proofUnreceived !== void 0 && object.proofUnreceived !== null ? bytesFromBase64(object.proofUnreceived) : new Uint8Array();
          message.proofClose = object.proofClose !== void 0 && object.proofClose !== null ? bytesFromBase64(object.proofClose) : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromJSON(object.proofHeight) : void 0;
          message.nextSequenceRecv = object.nextSequenceRecv !== void 0 && object.nextSequenceRecv !== null ? long_1.default.fromString(object.nextSequenceRecv) : long_1.default.UZERO;
          message.signer = object.signer !== void 0 && object.signer !== null ? String(object.signer) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.packet !== void 0 && (obj.packet = message.packet ? channel_1.Packet.toJSON(message.packet) : void 0);
          message.proofUnreceived !== void 0 && (obj.proofUnreceived = base64FromBytes(message.proofUnreceived !== void 0 ? message.proofUnreceived : new Uint8Array()));
          message.proofClose !== void 0 && (obj.proofClose = base64FromBytes(message.proofClose !== void 0 ? message.proofClose : new Uint8Array()));
          message.proofHeight !== void 0 && (obj.proofHeight = message.proofHeight ? client_1.Height.toJSON(message.proofHeight) : void 0);
          message.nextSequenceRecv !== void 0 && (obj.nextSequenceRecv = (message.nextSequenceRecv || long_1.default.UZERO).toString());
          message.signer !== void 0 && (obj.signer = message.signer);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseMsgTimeoutOnClose);
          message.packet = object.packet !== void 0 && object.packet !== null ? channel_1.Packet.fromPartial(object.packet) : void 0;
          message.proofUnreceived = (_a = object.proofUnreceived) !== null && _a !== void 0 ? _a : new Uint8Array();
          message.proofClose = (_b = object.proofClose) !== null && _b !== void 0 ? _b : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromPartial(object.proofHeight) : void 0;
          message.nextSequenceRecv = object.nextSequenceRecv !== void 0 && object.nextSequenceRecv !== null ? long_1.default.fromValue(object.nextSequenceRecv) : long_1.default.UZERO;
          message.signer = (_c = object.signer) !== null && _c !== void 0 ? _c : "";
          return message;
        }
      };
      var baseMsgTimeoutOnCloseResponse = {};
      exports2.MsgTimeoutOnCloseResponse = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgTimeoutOnCloseResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseMsgTimeoutOnCloseResponse);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseMsgTimeoutOnCloseResponse);
          return message;
        }
      };
      var baseMsgAcknowledgement = { signer: "" };
      exports2.MsgAcknowledgement = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.packet !== void 0) {
            channel_1.Packet.encode(message.packet, writer.uint32(10).fork()).ldelim();
          }
          if (message.acknowledgement.length !== 0) {
            writer.uint32(18).bytes(message.acknowledgement);
          }
          if (message.proofAcked.length !== 0) {
            writer.uint32(26).bytes(message.proofAcked);
          }
          if (message.proofHeight !== void 0) {
            client_1.Height.encode(message.proofHeight, writer.uint32(34).fork()).ldelim();
          }
          if (message.signer !== "") {
            writer.uint32(42).string(message.signer);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgAcknowledgement);
          message.acknowledgement = new Uint8Array();
          message.proofAcked = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.packet = channel_1.Packet.decode(reader, reader.uint32());
                break;
              case 2:
                message.acknowledgement = reader.bytes();
                break;
              case 3:
                message.proofAcked = reader.bytes();
                break;
              case 4:
                message.proofHeight = client_1.Height.decode(reader, reader.uint32());
                break;
              case 5:
                message.signer = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMsgAcknowledgement);
          message.packet = object.packet !== void 0 && object.packet !== null ? channel_1.Packet.fromJSON(object.packet) : void 0;
          message.acknowledgement = object.acknowledgement !== void 0 && object.acknowledgement !== null ? bytesFromBase64(object.acknowledgement) : new Uint8Array();
          message.proofAcked = object.proofAcked !== void 0 && object.proofAcked !== null ? bytesFromBase64(object.proofAcked) : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromJSON(object.proofHeight) : void 0;
          message.signer = object.signer !== void 0 && object.signer !== null ? String(object.signer) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.packet !== void 0 && (obj.packet = message.packet ? channel_1.Packet.toJSON(message.packet) : void 0);
          message.acknowledgement !== void 0 && (obj.acknowledgement = base64FromBytes(message.acknowledgement !== void 0 ? message.acknowledgement : new Uint8Array()));
          message.proofAcked !== void 0 && (obj.proofAcked = base64FromBytes(message.proofAcked !== void 0 ? message.proofAcked : new Uint8Array()));
          message.proofHeight !== void 0 && (obj.proofHeight = message.proofHeight ? client_1.Height.toJSON(message.proofHeight) : void 0);
          message.signer !== void 0 && (obj.signer = message.signer);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseMsgAcknowledgement);
          message.packet = object.packet !== void 0 && object.packet !== null ? channel_1.Packet.fromPartial(object.packet) : void 0;
          message.acknowledgement = (_a = object.acknowledgement) !== null && _a !== void 0 ? _a : new Uint8Array();
          message.proofAcked = (_b = object.proofAcked) !== null && _b !== void 0 ? _b : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromPartial(object.proofHeight) : void 0;
          message.signer = (_c = object.signer) !== null && _c !== void 0 ? _c : "";
          return message;
        }
      };
      var baseMsgAcknowledgementResponse = {};
      exports2.MsgAcknowledgementResponse = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgAcknowledgementResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseMsgAcknowledgementResponse);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseMsgAcknowledgementResponse);
          return message;
        }
      };
      var MsgClientImpl = class {
        constructor(rpc) {
          this.rpc = rpc;
          this.ChannelOpenInit = this.ChannelOpenInit.bind(this);
          this.ChannelOpenTry = this.ChannelOpenTry.bind(this);
          this.ChannelOpenAck = this.ChannelOpenAck.bind(this);
          this.ChannelOpenConfirm = this.ChannelOpenConfirm.bind(this);
          this.ChannelCloseInit = this.ChannelCloseInit.bind(this);
          this.ChannelCloseConfirm = this.ChannelCloseConfirm.bind(this);
          this.RecvPacket = this.RecvPacket.bind(this);
          this.Timeout = this.Timeout.bind(this);
          this.TimeoutOnClose = this.TimeoutOnClose.bind(this);
          this.Acknowledgement = this.Acknowledgement.bind(this);
        }
        ChannelOpenInit(request) {
          const data = exports2.MsgChannelOpenInit.encode(request).finish();
          const promise = this.rpc.request("ibc.core.channel.v1.Msg", "ChannelOpenInit", data);
          return promise.then((data2) => exports2.MsgChannelOpenInitResponse.decode(new minimal_1.default.Reader(data2)));
        }
        ChannelOpenTry(request) {
          const data = exports2.MsgChannelOpenTry.encode(request).finish();
          const promise = this.rpc.request("ibc.core.channel.v1.Msg", "ChannelOpenTry", data);
          return promise.then((data2) => exports2.MsgChannelOpenTryResponse.decode(new minimal_1.default.Reader(data2)));
        }
        ChannelOpenAck(request) {
          const data = exports2.MsgChannelOpenAck.encode(request).finish();
          const promise = this.rpc.request("ibc.core.channel.v1.Msg", "ChannelOpenAck", data);
          return promise.then((data2) => exports2.MsgChannelOpenAckResponse.decode(new minimal_1.default.Reader(data2)));
        }
        ChannelOpenConfirm(request) {
          const data = exports2.MsgChannelOpenConfirm.encode(request).finish();
          const promise = this.rpc.request("ibc.core.channel.v1.Msg", "ChannelOpenConfirm", data);
          return promise.then((data2) => exports2.MsgChannelOpenConfirmResponse.decode(new minimal_1.default.Reader(data2)));
        }
        ChannelCloseInit(request) {
          const data = exports2.MsgChannelCloseInit.encode(request).finish();
          const promise = this.rpc.request("ibc.core.channel.v1.Msg", "ChannelCloseInit", data);
          return promise.then((data2) => exports2.MsgChannelCloseInitResponse.decode(new minimal_1.default.Reader(data2)));
        }
        ChannelCloseConfirm(request) {
          const data = exports2.MsgChannelCloseConfirm.encode(request).finish();
          const promise = this.rpc.request("ibc.core.channel.v1.Msg", "ChannelCloseConfirm", data);
          return promise.then((data2) => exports2.MsgChannelCloseConfirmResponse.decode(new minimal_1.default.Reader(data2)));
        }
        RecvPacket(request) {
          const data = exports2.MsgRecvPacket.encode(request).finish();
          const promise = this.rpc.request("ibc.core.channel.v1.Msg", "RecvPacket", data);
          return promise.then((data2) => exports2.MsgRecvPacketResponse.decode(new minimal_1.default.Reader(data2)));
        }
        Timeout(request) {
          const data = exports2.MsgTimeout.encode(request).finish();
          const promise = this.rpc.request("ibc.core.channel.v1.Msg", "Timeout", data);
          return promise.then((data2) => exports2.MsgTimeoutResponse.decode(new minimal_1.default.Reader(data2)));
        }
        TimeoutOnClose(request) {
          const data = exports2.MsgTimeoutOnClose.encode(request).finish();
          const promise = this.rpc.request("ibc.core.channel.v1.Msg", "TimeoutOnClose", data);
          return promise.then((data2) => exports2.MsgTimeoutOnCloseResponse.decode(new minimal_1.default.Reader(data2)));
        }
        Acknowledgement(request) {
          const data = exports2.MsgAcknowledgement.encode(request).finish();
          const promise = this.rpc.request("ibc.core.channel.v1.Msg", "Acknowledgement", data);
          return promise.then((data2) => exports2.MsgAcknowledgementResponse.decode(new minimal_1.default.Reader(data2)));
        }
      };
      exports2.MsgClientImpl = MsgClientImpl;
      var globalThis2 = (() => {
        if (typeof globalThis2 !== "undefined")
          return globalThis2;
        if (typeof self !== "undefined")
          return self;
        if (typeof window !== "undefined")
          return window;
        if (typeof global !== "undefined")
          return global;
        throw "Unable to locate global object";
      })();
      var atob2 = globalThis2.atob || ((b64) => globalThis2.Buffer.from(b64, "base64").toString("binary"));
      function bytesFromBase64(b64) {
        const bin = atob2(b64);
        const arr = new Uint8Array(bin.length);
        for (let i = 0; i < bin.length; ++i) {
          arr[i] = bin.charCodeAt(i);
        }
        return arr;
      }
      var btoa2 = globalThis2.btoa || ((bin) => globalThis2.Buffer.from(bin, "binary").toString("base64"));
      function base64FromBytes(arr) {
        const bin = [];
        for (const byte of arr) {
          bin.push(String.fromCharCode(byte));
        }
        return btoa2(bin.join(""));
      }
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/cosmjs-types/ibc/core/client/v1/tx.js
  var require_tx9 = __commonJS({
    "node_modules/cosmjs-types/ibc/core/client/v1/tx.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.MsgClientImpl = exports2.MsgSubmitMisbehaviourResponse = exports2.MsgSubmitMisbehaviour = exports2.MsgUpgradeClientResponse = exports2.MsgUpgradeClient = exports2.MsgUpdateClientResponse = exports2.MsgUpdateClient = exports2.MsgCreateClientResponse = exports2.MsgCreateClient = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var any_1 = require_any();
      exports2.protobufPackage = "ibc.core.client.v1";
      var baseMsgCreateClient = { signer: "" };
      exports2.MsgCreateClient = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.clientState !== void 0) {
            any_1.Any.encode(message.clientState, writer.uint32(10).fork()).ldelim();
          }
          if (message.consensusState !== void 0) {
            any_1.Any.encode(message.consensusState, writer.uint32(18).fork()).ldelim();
          }
          if (message.signer !== "") {
            writer.uint32(26).string(message.signer);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgCreateClient);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.clientState = any_1.Any.decode(reader, reader.uint32());
                break;
              case 2:
                message.consensusState = any_1.Any.decode(reader, reader.uint32());
                break;
              case 3:
                message.signer = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMsgCreateClient);
          message.clientState = object.clientState !== void 0 && object.clientState !== null ? any_1.Any.fromJSON(object.clientState) : void 0;
          message.consensusState = object.consensusState !== void 0 && object.consensusState !== null ? any_1.Any.fromJSON(object.consensusState) : void 0;
          message.signer = object.signer !== void 0 && object.signer !== null ? String(object.signer) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.clientState !== void 0 && (obj.clientState = message.clientState ? any_1.Any.toJSON(message.clientState) : void 0);
          message.consensusState !== void 0 && (obj.consensusState = message.consensusState ? any_1.Any.toJSON(message.consensusState) : void 0);
          message.signer !== void 0 && (obj.signer = message.signer);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseMsgCreateClient);
          message.clientState = object.clientState !== void 0 && object.clientState !== null ? any_1.Any.fromPartial(object.clientState) : void 0;
          message.consensusState = object.consensusState !== void 0 && object.consensusState !== null ? any_1.Any.fromPartial(object.consensusState) : void 0;
          message.signer = (_a = object.signer) !== null && _a !== void 0 ? _a : "";
          return message;
        }
      };
      var baseMsgCreateClientResponse = {};
      exports2.MsgCreateClientResponse = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgCreateClientResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseMsgCreateClientResponse);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseMsgCreateClientResponse);
          return message;
        }
      };
      var baseMsgUpdateClient = { clientId: "", signer: "" };
      exports2.MsgUpdateClient = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.clientId !== "") {
            writer.uint32(10).string(message.clientId);
          }
          if (message.header !== void 0) {
            any_1.Any.encode(message.header, writer.uint32(18).fork()).ldelim();
          }
          if (message.signer !== "") {
            writer.uint32(26).string(message.signer);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgUpdateClient);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.clientId = reader.string();
                break;
              case 2:
                message.header = any_1.Any.decode(reader, reader.uint32());
                break;
              case 3:
                message.signer = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMsgUpdateClient);
          message.clientId = object.clientId !== void 0 && object.clientId !== null ? String(object.clientId) : "";
          message.header = object.header !== void 0 && object.header !== null ? any_1.Any.fromJSON(object.header) : void 0;
          message.signer = object.signer !== void 0 && object.signer !== null ? String(object.signer) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.clientId !== void 0 && (obj.clientId = message.clientId);
          message.header !== void 0 && (obj.header = message.header ? any_1.Any.toJSON(message.header) : void 0);
          message.signer !== void 0 && (obj.signer = message.signer);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseMsgUpdateClient);
          message.clientId = (_a = object.clientId) !== null && _a !== void 0 ? _a : "";
          message.header = object.header !== void 0 && object.header !== null ? any_1.Any.fromPartial(object.header) : void 0;
          message.signer = (_b = object.signer) !== null && _b !== void 0 ? _b : "";
          return message;
        }
      };
      var baseMsgUpdateClientResponse = {};
      exports2.MsgUpdateClientResponse = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgUpdateClientResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseMsgUpdateClientResponse);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseMsgUpdateClientResponse);
          return message;
        }
      };
      var baseMsgUpgradeClient = { clientId: "", signer: "" };
      exports2.MsgUpgradeClient = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.clientId !== "") {
            writer.uint32(10).string(message.clientId);
          }
          if (message.clientState !== void 0) {
            any_1.Any.encode(message.clientState, writer.uint32(18).fork()).ldelim();
          }
          if (message.consensusState !== void 0) {
            any_1.Any.encode(message.consensusState, writer.uint32(26).fork()).ldelim();
          }
          if (message.proofUpgradeClient.length !== 0) {
            writer.uint32(34).bytes(message.proofUpgradeClient);
          }
          if (message.proofUpgradeConsensusState.length !== 0) {
            writer.uint32(42).bytes(message.proofUpgradeConsensusState);
          }
          if (message.signer !== "") {
            writer.uint32(50).string(message.signer);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgUpgradeClient);
          message.proofUpgradeClient = new Uint8Array();
          message.proofUpgradeConsensusState = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.clientId = reader.string();
                break;
              case 2:
                message.clientState = any_1.Any.decode(reader, reader.uint32());
                break;
              case 3:
                message.consensusState = any_1.Any.decode(reader, reader.uint32());
                break;
              case 4:
                message.proofUpgradeClient = reader.bytes();
                break;
              case 5:
                message.proofUpgradeConsensusState = reader.bytes();
                break;
              case 6:
                message.signer = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMsgUpgradeClient);
          message.clientId = object.clientId !== void 0 && object.clientId !== null ? String(object.clientId) : "";
          message.clientState = object.clientState !== void 0 && object.clientState !== null ? any_1.Any.fromJSON(object.clientState) : void 0;
          message.consensusState = object.consensusState !== void 0 && object.consensusState !== null ? any_1.Any.fromJSON(object.consensusState) : void 0;
          message.proofUpgradeClient = object.proofUpgradeClient !== void 0 && object.proofUpgradeClient !== null ? bytesFromBase64(object.proofUpgradeClient) : new Uint8Array();
          message.proofUpgradeConsensusState = object.proofUpgradeConsensusState !== void 0 && object.proofUpgradeConsensusState !== null ? bytesFromBase64(object.proofUpgradeConsensusState) : new Uint8Array();
          message.signer = object.signer !== void 0 && object.signer !== null ? String(object.signer) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.clientId !== void 0 && (obj.clientId = message.clientId);
          message.clientState !== void 0 && (obj.clientState = message.clientState ? any_1.Any.toJSON(message.clientState) : void 0);
          message.consensusState !== void 0 && (obj.consensusState = message.consensusState ? any_1.Any.toJSON(message.consensusState) : void 0);
          message.proofUpgradeClient !== void 0 && (obj.proofUpgradeClient = base64FromBytes(message.proofUpgradeClient !== void 0 ? message.proofUpgradeClient : new Uint8Array()));
          message.proofUpgradeConsensusState !== void 0 && (obj.proofUpgradeConsensusState = base64FromBytes(message.proofUpgradeConsensusState !== void 0 ? message.proofUpgradeConsensusState : new Uint8Array()));
          message.signer !== void 0 && (obj.signer = message.signer);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c, _d;
          const message = Object.assign({}, baseMsgUpgradeClient);
          message.clientId = (_a = object.clientId) !== null && _a !== void 0 ? _a : "";
          message.clientState = object.clientState !== void 0 && object.clientState !== null ? any_1.Any.fromPartial(object.clientState) : void 0;
          message.consensusState = object.consensusState !== void 0 && object.consensusState !== null ? any_1.Any.fromPartial(object.consensusState) : void 0;
          message.proofUpgradeClient = (_b = object.proofUpgradeClient) !== null && _b !== void 0 ? _b : new Uint8Array();
          message.proofUpgradeConsensusState = (_c = object.proofUpgradeConsensusState) !== null && _c !== void 0 ? _c : new Uint8Array();
          message.signer = (_d = object.signer) !== null && _d !== void 0 ? _d : "";
          return message;
        }
      };
      var baseMsgUpgradeClientResponse = {};
      exports2.MsgUpgradeClientResponse = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgUpgradeClientResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseMsgUpgradeClientResponse);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseMsgUpgradeClientResponse);
          return message;
        }
      };
      var baseMsgSubmitMisbehaviour = { clientId: "", signer: "" };
      exports2.MsgSubmitMisbehaviour = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.clientId !== "") {
            writer.uint32(10).string(message.clientId);
          }
          if (message.misbehaviour !== void 0) {
            any_1.Any.encode(message.misbehaviour, writer.uint32(18).fork()).ldelim();
          }
          if (message.signer !== "") {
            writer.uint32(26).string(message.signer);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgSubmitMisbehaviour);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.clientId = reader.string();
                break;
              case 2:
                message.misbehaviour = any_1.Any.decode(reader, reader.uint32());
                break;
              case 3:
                message.signer = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMsgSubmitMisbehaviour);
          message.clientId = object.clientId !== void 0 && object.clientId !== null ? String(object.clientId) : "";
          message.misbehaviour = object.misbehaviour !== void 0 && object.misbehaviour !== null ? any_1.Any.fromJSON(object.misbehaviour) : void 0;
          message.signer = object.signer !== void 0 && object.signer !== null ? String(object.signer) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.clientId !== void 0 && (obj.clientId = message.clientId);
          message.misbehaviour !== void 0 && (obj.misbehaviour = message.misbehaviour ? any_1.Any.toJSON(message.misbehaviour) : void 0);
          message.signer !== void 0 && (obj.signer = message.signer);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseMsgSubmitMisbehaviour);
          message.clientId = (_a = object.clientId) !== null && _a !== void 0 ? _a : "";
          message.misbehaviour = object.misbehaviour !== void 0 && object.misbehaviour !== null ? any_1.Any.fromPartial(object.misbehaviour) : void 0;
          message.signer = (_b = object.signer) !== null && _b !== void 0 ? _b : "";
          return message;
        }
      };
      var baseMsgSubmitMisbehaviourResponse = {};
      exports2.MsgSubmitMisbehaviourResponse = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgSubmitMisbehaviourResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseMsgSubmitMisbehaviourResponse);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseMsgSubmitMisbehaviourResponse);
          return message;
        }
      };
      var MsgClientImpl = class {
        constructor(rpc) {
          this.rpc = rpc;
          this.CreateClient = this.CreateClient.bind(this);
          this.UpdateClient = this.UpdateClient.bind(this);
          this.UpgradeClient = this.UpgradeClient.bind(this);
          this.SubmitMisbehaviour = this.SubmitMisbehaviour.bind(this);
        }
        CreateClient(request) {
          const data = exports2.MsgCreateClient.encode(request).finish();
          const promise = this.rpc.request("ibc.core.client.v1.Msg", "CreateClient", data);
          return promise.then((data2) => exports2.MsgCreateClientResponse.decode(new minimal_1.default.Reader(data2)));
        }
        UpdateClient(request) {
          const data = exports2.MsgUpdateClient.encode(request).finish();
          const promise = this.rpc.request("ibc.core.client.v1.Msg", "UpdateClient", data);
          return promise.then((data2) => exports2.MsgUpdateClientResponse.decode(new minimal_1.default.Reader(data2)));
        }
        UpgradeClient(request) {
          const data = exports2.MsgUpgradeClient.encode(request).finish();
          const promise = this.rpc.request("ibc.core.client.v1.Msg", "UpgradeClient", data);
          return promise.then((data2) => exports2.MsgUpgradeClientResponse.decode(new minimal_1.default.Reader(data2)));
        }
        SubmitMisbehaviour(request) {
          const data = exports2.MsgSubmitMisbehaviour.encode(request).finish();
          const promise = this.rpc.request("ibc.core.client.v1.Msg", "SubmitMisbehaviour", data);
          return promise.then((data2) => exports2.MsgSubmitMisbehaviourResponse.decode(new minimal_1.default.Reader(data2)));
        }
      };
      exports2.MsgClientImpl = MsgClientImpl;
      var globalThis2 = (() => {
        if (typeof globalThis2 !== "undefined")
          return globalThis2;
        if (typeof self !== "undefined")
          return self;
        if (typeof window !== "undefined")
          return window;
        if (typeof global !== "undefined")
          return global;
        throw "Unable to locate global object";
      })();
      var atob2 = globalThis2.atob || ((b64) => globalThis2.Buffer.from(b64, "base64").toString("binary"));
      function bytesFromBase64(b64) {
        const bin = atob2(b64);
        const arr = new Uint8Array(bin.length);
        for (let i = 0; i < bin.length; ++i) {
          arr[i] = bin.charCodeAt(i);
        }
        return arr;
      }
      var btoa2 = globalThis2.btoa || ((bin) => globalThis2.Buffer.from(bin, "binary").toString("base64"));
      function base64FromBytes(arr) {
        const bin = [];
        for (const byte of arr) {
          bin.push(String.fromCharCode(byte));
        }
        return btoa2(bin.join(""));
      }
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/cosmjs-types/confio/proofs.js
  var require_proofs2 = __commonJS({
    "node_modules/cosmjs-types/confio/proofs.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.CompressedNonExistenceProof = exports2.CompressedExistenceProof = exports2.CompressedBatchEntry = exports2.CompressedBatchProof = exports2.BatchEntry = exports2.BatchProof = exports2.InnerSpec = exports2.ProofSpec = exports2.InnerOp = exports2.LeafOp = exports2.CommitmentProof = exports2.NonExistenceProof = exports2.ExistenceProof = exports2.lengthOpToJSON = exports2.lengthOpFromJSON = exports2.LengthOp = exports2.hashOpToJSON = exports2.hashOpFromJSON = exports2.HashOp = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      exports2.protobufPackage = "ics23";
      var HashOp;
      (function(HashOp2) {
        HashOp2[HashOp2["NO_HASH"] = 0] = "NO_HASH";
        HashOp2[HashOp2["SHA256"] = 1] = "SHA256";
        HashOp2[HashOp2["SHA512"] = 2] = "SHA512";
        HashOp2[HashOp2["KECCAK"] = 3] = "KECCAK";
        HashOp2[HashOp2["RIPEMD160"] = 4] = "RIPEMD160";
        HashOp2[HashOp2["BITCOIN"] = 5] = "BITCOIN";
        HashOp2[HashOp2["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
      })(HashOp = exports2.HashOp || (exports2.HashOp = {}));
      function hashOpFromJSON(object) {
        switch (object) {
          case 0:
          case "NO_HASH":
            return HashOp.NO_HASH;
          case 1:
          case "SHA256":
            return HashOp.SHA256;
          case 2:
          case "SHA512":
            return HashOp.SHA512;
          case 3:
          case "KECCAK":
            return HashOp.KECCAK;
          case 4:
          case "RIPEMD160":
            return HashOp.RIPEMD160;
          case 5:
          case "BITCOIN":
            return HashOp.BITCOIN;
          case -1:
          case "UNRECOGNIZED":
          default:
            return HashOp.UNRECOGNIZED;
        }
      }
      exports2.hashOpFromJSON = hashOpFromJSON;
      function hashOpToJSON(object) {
        switch (object) {
          case HashOp.NO_HASH:
            return "NO_HASH";
          case HashOp.SHA256:
            return "SHA256";
          case HashOp.SHA512:
            return "SHA512";
          case HashOp.KECCAK:
            return "KECCAK";
          case HashOp.RIPEMD160:
            return "RIPEMD160";
          case HashOp.BITCOIN:
            return "BITCOIN";
          default:
            return "UNKNOWN";
        }
      }
      exports2.hashOpToJSON = hashOpToJSON;
      var LengthOp;
      (function(LengthOp2) {
        LengthOp2[LengthOp2["NO_PREFIX"] = 0] = "NO_PREFIX";
        LengthOp2[LengthOp2["VAR_PROTO"] = 1] = "VAR_PROTO";
        LengthOp2[LengthOp2["VAR_RLP"] = 2] = "VAR_RLP";
        LengthOp2[LengthOp2["FIXED32_BIG"] = 3] = "FIXED32_BIG";
        LengthOp2[LengthOp2["FIXED32_LITTLE"] = 4] = "FIXED32_LITTLE";
        LengthOp2[LengthOp2["FIXED64_BIG"] = 5] = "FIXED64_BIG";
        LengthOp2[LengthOp2["FIXED64_LITTLE"] = 6] = "FIXED64_LITTLE";
        LengthOp2[LengthOp2["REQUIRE_32_BYTES"] = 7] = "REQUIRE_32_BYTES";
        LengthOp2[LengthOp2["REQUIRE_64_BYTES"] = 8] = "REQUIRE_64_BYTES";
        LengthOp2[LengthOp2["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
      })(LengthOp = exports2.LengthOp || (exports2.LengthOp = {}));
      function lengthOpFromJSON(object) {
        switch (object) {
          case 0:
          case "NO_PREFIX":
            return LengthOp.NO_PREFIX;
          case 1:
          case "VAR_PROTO":
            return LengthOp.VAR_PROTO;
          case 2:
          case "VAR_RLP":
            return LengthOp.VAR_RLP;
          case 3:
          case "FIXED32_BIG":
            return LengthOp.FIXED32_BIG;
          case 4:
          case "FIXED32_LITTLE":
            return LengthOp.FIXED32_LITTLE;
          case 5:
          case "FIXED64_BIG":
            return LengthOp.FIXED64_BIG;
          case 6:
          case "FIXED64_LITTLE":
            return LengthOp.FIXED64_LITTLE;
          case 7:
          case "REQUIRE_32_BYTES":
            return LengthOp.REQUIRE_32_BYTES;
          case 8:
          case "REQUIRE_64_BYTES":
            return LengthOp.REQUIRE_64_BYTES;
          case -1:
          case "UNRECOGNIZED":
          default:
            return LengthOp.UNRECOGNIZED;
        }
      }
      exports2.lengthOpFromJSON = lengthOpFromJSON;
      function lengthOpToJSON(object) {
        switch (object) {
          case LengthOp.NO_PREFIX:
            return "NO_PREFIX";
          case LengthOp.VAR_PROTO:
            return "VAR_PROTO";
          case LengthOp.VAR_RLP:
            return "VAR_RLP";
          case LengthOp.FIXED32_BIG:
            return "FIXED32_BIG";
          case LengthOp.FIXED32_LITTLE:
            return "FIXED32_LITTLE";
          case LengthOp.FIXED64_BIG:
            return "FIXED64_BIG";
          case LengthOp.FIXED64_LITTLE:
            return "FIXED64_LITTLE";
          case LengthOp.REQUIRE_32_BYTES:
            return "REQUIRE_32_BYTES";
          case LengthOp.REQUIRE_64_BYTES:
            return "REQUIRE_64_BYTES";
          default:
            return "UNKNOWN";
        }
      }
      exports2.lengthOpToJSON = lengthOpToJSON;
      var baseExistenceProof = {};
      exports2.ExistenceProof = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.key.length !== 0) {
            writer.uint32(10).bytes(message.key);
          }
          if (message.value.length !== 0) {
            writer.uint32(18).bytes(message.value);
          }
          if (message.leaf !== void 0) {
            exports2.LeafOp.encode(message.leaf, writer.uint32(26).fork()).ldelim();
          }
          for (const v of message.path) {
            exports2.InnerOp.encode(v, writer.uint32(34).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseExistenceProof);
          message.path = [];
          message.key = new Uint8Array();
          message.value = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.key = reader.bytes();
                break;
              case 2:
                message.value = reader.bytes();
                break;
              case 3:
                message.leaf = exports2.LeafOp.decode(reader, reader.uint32());
                break;
              case 4:
                message.path.push(exports2.InnerOp.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseExistenceProof);
          message.key = object.key !== void 0 && object.key !== null ? bytesFromBase64(object.key) : new Uint8Array();
          message.value = object.value !== void 0 && object.value !== null ? bytesFromBase64(object.value) : new Uint8Array();
          message.leaf = object.leaf !== void 0 && object.leaf !== null ? exports2.LeafOp.fromJSON(object.leaf) : void 0;
          message.path = ((_a = object.path) !== null && _a !== void 0 ? _a : []).map((e) => exports2.InnerOp.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.key !== void 0 && (obj.key = base64FromBytes(message.key !== void 0 ? message.key : new Uint8Array()));
          message.value !== void 0 && (obj.value = base64FromBytes(message.value !== void 0 ? message.value : new Uint8Array()));
          message.leaf !== void 0 && (obj.leaf = message.leaf ? exports2.LeafOp.toJSON(message.leaf) : void 0);
          if (message.path) {
            obj.path = message.path.map((e) => e ? exports2.InnerOp.toJSON(e) : void 0);
          } else {
            obj.path = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseExistenceProof);
          message.key = (_a = object.key) !== null && _a !== void 0 ? _a : new Uint8Array();
          message.value = (_b = object.value) !== null && _b !== void 0 ? _b : new Uint8Array();
          message.leaf = object.leaf !== void 0 && object.leaf !== null ? exports2.LeafOp.fromPartial(object.leaf) : void 0;
          message.path = ((_c = object.path) === null || _c === void 0 ? void 0 : _c.map((e) => exports2.InnerOp.fromPartial(e))) || [];
          return message;
        }
      };
      var baseNonExistenceProof = {};
      exports2.NonExistenceProof = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.key.length !== 0) {
            writer.uint32(10).bytes(message.key);
          }
          if (message.left !== void 0) {
            exports2.ExistenceProof.encode(message.left, writer.uint32(18).fork()).ldelim();
          }
          if (message.right !== void 0) {
            exports2.ExistenceProof.encode(message.right, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseNonExistenceProof);
          message.key = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.key = reader.bytes();
                break;
              case 2:
                message.left = exports2.ExistenceProof.decode(reader, reader.uint32());
                break;
              case 3:
                message.right = exports2.ExistenceProof.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseNonExistenceProof);
          message.key = object.key !== void 0 && object.key !== null ? bytesFromBase64(object.key) : new Uint8Array();
          message.left = object.left !== void 0 && object.left !== null ? exports2.ExistenceProof.fromJSON(object.left) : void 0;
          message.right = object.right !== void 0 && object.right !== null ? exports2.ExistenceProof.fromJSON(object.right) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.key !== void 0 && (obj.key = base64FromBytes(message.key !== void 0 ? message.key : new Uint8Array()));
          message.left !== void 0 && (obj.left = message.left ? exports2.ExistenceProof.toJSON(message.left) : void 0);
          message.right !== void 0 && (obj.right = message.right ? exports2.ExistenceProof.toJSON(message.right) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseNonExistenceProof);
          message.key = (_a = object.key) !== null && _a !== void 0 ? _a : new Uint8Array();
          message.left = object.left !== void 0 && object.left !== null ? exports2.ExistenceProof.fromPartial(object.left) : void 0;
          message.right = object.right !== void 0 && object.right !== null ? exports2.ExistenceProof.fromPartial(object.right) : void 0;
          return message;
        }
      };
      var baseCommitmentProof = {};
      exports2.CommitmentProof = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.exist !== void 0) {
            exports2.ExistenceProof.encode(message.exist, writer.uint32(10).fork()).ldelim();
          }
          if (message.nonexist !== void 0) {
            exports2.NonExistenceProof.encode(message.nonexist, writer.uint32(18).fork()).ldelim();
          }
          if (message.batch !== void 0) {
            exports2.BatchProof.encode(message.batch, writer.uint32(26).fork()).ldelim();
          }
          if (message.compressed !== void 0) {
            exports2.CompressedBatchProof.encode(message.compressed, writer.uint32(34).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseCommitmentProof);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.exist = exports2.ExistenceProof.decode(reader, reader.uint32());
                break;
              case 2:
                message.nonexist = exports2.NonExistenceProof.decode(reader, reader.uint32());
                break;
              case 3:
                message.batch = exports2.BatchProof.decode(reader, reader.uint32());
                break;
              case 4:
                message.compressed = exports2.CompressedBatchProof.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseCommitmentProof);
          message.exist = object.exist !== void 0 && object.exist !== null ? exports2.ExistenceProof.fromJSON(object.exist) : void 0;
          message.nonexist = object.nonexist !== void 0 && object.nonexist !== null ? exports2.NonExistenceProof.fromJSON(object.nonexist) : void 0;
          message.batch = object.batch !== void 0 && object.batch !== null ? exports2.BatchProof.fromJSON(object.batch) : void 0;
          message.compressed = object.compressed !== void 0 && object.compressed !== null ? exports2.CompressedBatchProof.fromJSON(object.compressed) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.exist !== void 0 && (obj.exist = message.exist ? exports2.ExistenceProof.toJSON(message.exist) : void 0);
          message.nonexist !== void 0 && (obj.nonexist = message.nonexist ? exports2.NonExistenceProof.toJSON(message.nonexist) : void 0);
          message.batch !== void 0 && (obj.batch = message.batch ? exports2.BatchProof.toJSON(message.batch) : void 0);
          message.compressed !== void 0 && (obj.compressed = message.compressed ? exports2.CompressedBatchProof.toJSON(message.compressed) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseCommitmentProof);
          message.exist = object.exist !== void 0 && object.exist !== null ? exports2.ExistenceProof.fromPartial(object.exist) : void 0;
          message.nonexist = object.nonexist !== void 0 && object.nonexist !== null ? exports2.NonExistenceProof.fromPartial(object.nonexist) : void 0;
          message.batch = object.batch !== void 0 && object.batch !== null ? exports2.BatchProof.fromPartial(object.batch) : void 0;
          message.compressed = object.compressed !== void 0 && object.compressed !== null ? exports2.CompressedBatchProof.fromPartial(object.compressed) : void 0;
          return message;
        }
      };
      var baseLeafOp = { hash: 0, prehashKey: 0, prehashValue: 0, length: 0 };
      exports2.LeafOp = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.hash !== 0) {
            writer.uint32(8).int32(message.hash);
          }
          if (message.prehashKey !== 0) {
            writer.uint32(16).int32(message.prehashKey);
          }
          if (message.prehashValue !== 0) {
            writer.uint32(24).int32(message.prehashValue);
          }
          if (message.length !== 0) {
            writer.uint32(32).int32(message.length);
          }
          if (message.prefix.length !== 0) {
            writer.uint32(42).bytes(message.prefix);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseLeafOp);
          message.prefix = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.hash = reader.int32();
                break;
              case 2:
                message.prehashKey = reader.int32();
                break;
              case 3:
                message.prehashValue = reader.int32();
                break;
              case 4:
                message.length = reader.int32();
                break;
              case 5:
                message.prefix = reader.bytes();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseLeafOp);
          message.hash = object.hash !== void 0 && object.hash !== null ? hashOpFromJSON(object.hash) : 0;
          message.prehashKey = object.prehashKey !== void 0 && object.prehashKey !== null ? hashOpFromJSON(object.prehashKey) : 0;
          message.prehashValue = object.prehashValue !== void 0 && object.prehashValue !== null ? hashOpFromJSON(object.prehashValue) : 0;
          message.length = object.length !== void 0 && object.length !== null ? lengthOpFromJSON(object.length) : 0;
          message.prefix = object.prefix !== void 0 && object.prefix !== null ? bytesFromBase64(object.prefix) : new Uint8Array();
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.hash !== void 0 && (obj.hash = hashOpToJSON(message.hash));
          message.prehashKey !== void 0 && (obj.prehashKey = hashOpToJSON(message.prehashKey));
          message.prehashValue !== void 0 && (obj.prehashValue = hashOpToJSON(message.prehashValue));
          message.length !== void 0 && (obj.length = lengthOpToJSON(message.length));
          message.prefix !== void 0 && (obj.prefix = base64FromBytes(message.prefix !== void 0 ? message.prefix : new Uint8Array()));
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c, _d, _e;
          const message = Object.assign({}, baseLeafOp);
          message.hash = (_a = object.hash) !== null && _a !== void 0 ? _a : 0;
          message.prehashKey = (_b = object.prehashKey) !== null && _b !== void 0 ? _b : 0;
          message.prehashValue = (_c = object.prehashValue) !== null && _c !== void 0 ? _c : 0;
          message.length = (_d = object.length) !== null && _d !== void 0 ? _d : 0;
          message.prefix = (_e = object.prefix) !== null && _e !== void 0 ? _e : new Uint8Array();
          return message;
        }
      };
      var baseInnerOp = { hash: 0 };
      exports2.InnerOp = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.hash !== 0) {
            writer.uint32(8).int32(message.hash);
          }
          if (message.prefix.length !== 0) {
            writer.uint32(18).bytes(message.prefix);
          }
          if (message.suffix.length !== 0) {
            writer.uint32(26).bytes(message.suffix);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseInnerOp);
          message.prefix = new Uint8Array();
          message.suffix = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.hash = reader.int32();
                break;
              case 2:
                message.prefix = reader.bytes();
                break;
              case 3:
                message.suffix = reader.bytes();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseInnerOp);
          message.hash = object.hash !== void 0 && object.hash !== null ? hashOpFromJSON(object.hash) : 0;
          message.prefix = object.prefix !== void 0 && object.prefix !== null ? bytesFromBase64(object.prefix) : new Uint8Array();
          message.suffix = object.suffix !== void 0 && object.suffix !== null ? bytesFromBase64(object.suffix) : new Uint8Array();
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.hash !== void 0 && (obj.hash = hashOpToJSON(message.hash));
          message.prefix !== void 0 && (obj.prefix = base64FromBytes(message.prefix !== void 0 ? message.prefix : new Uint8Array()));
          message.suffix !== void 0 && (obj.suffix = base64FromBytes(message.suffix !== void 0 ? message.suffix : new Uint8Array()));
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseInnerOp);
          message.hash = (_a = object.hash) !== null && _a !== void 0 ? _a : 0;
          message.prefix = (_b = object.prefix) !== null && _b !== void 0 ? _b : new Uint8Array();
          message.suffix = (_c = object.suffix) !== null && _c !== void 0 ? _c : new Uint8Array();
          return message;
        }
      };
      var baseProofSpec = { maxDepth: 0, minDepth: 0 };
      exports2.ProofSpec = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.leafSpec !== void 0) {
            exports2.LeafOp.encode(message.leafSpec, writer.uint32(10).fork()).ldelim();
          }
          if (message.innerSpec !== void 0) {
            exports2.InnerSpec.encode(message.innerSpec, writer.uint32(18).fork()).ldelim();
          }
          if (message.maxDepth !== 0) {
            writer.uint32(24).int32(message.maxDepth);
          }
          if (message.minDepth !== 0) {
            writer.uint32(32).int32(message.minDepth);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseProofSpec);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.leafSpec = exports2.LeafOp.decode(reader, reader.uint32());
                break;
              case 2:
                message.innerSpec = exports2.InnerSpec.decode(reader, reader.uint32());
                break;
              case 3:
                message.maxDepth = reader.int32();
                break;
              case 4:
                message.minDepth = reader.int32();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseProofSpec);
          message.leafSpec = object.leafSpec !== void 0 && object.leafSpec !== null ? exports2.LeafOp.fromJSON(object.leafSpec) : void 0;
          message.innerSpec = object.innerSpec !== void 0 && object.innerSpec !== null ? exports2.InnerSpec.fromJSON(object.innerSpec) : void 0;
          message.maxDepth = object.maxDepth !== void 0 && object.maxDepth !== null ? Number(object.maxDepth) : 0;
          message.minDepth = object.minDepth !== void 0 && object.minDepth !== null ? Number(object.minDepth) : 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.leafSpec !== void 0 && (obj.leafSpec = message.leafSpec ? exports2.LeafOp.toJSON(message.leafSpec) : void 0);
          message.innerSpec !== void 0 && (obj.innerSpec = message.innerSpec ? exports2.InnerSpec.toJSON(message.innerSpec) : void 0);
          message.maxDepth !== void 0 && (obj.maxDepth = message.maxDepth);
          message.minDepth !== void 0 && (obj.minDepth = message.minDepth);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseProofSpec);
          message.leafSpec = object.leafSpec !== void 0 && object.leafSpec !== null ? exports2.LeafOp.fromPartial(object.leafSpec) : void 0;
          message.innerSpec = object.innerSpec !== void 0 && object.innerSpec !== null ? exports2.InnerSpec.fromPartial(object.innerSpec) : void 0;
          message.maxDepth = (_a = object.maxDepth) !== null && _a !== void 0 ? _a : 0;
          message.minDepth = (_b = object.minDepth) !== null && _b !== void 0 ? _b : 0;
          return message;
        }
      };
      var baseInnerSpec = {
        childOrder: 0,
        childSize: 0,
        minPrefixLength: 0,
        maxPrefixLength: 0,
        hash: 0
      };
      exports2.InnerSpec = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          writer.uint32(10).fork();
          for (const v of message.childOrder) {
            writer.int32(v);
          }
          writer.ldelim();
          if (message.childSize !== 0) {
            writer.uint32(16).int32(message.childSize);
          }
          if (message.minPrefixLength !== 0) {
            writer.uint32(24).int32(message.minPrefixLength);
          }
          if (message.maxPrefixLength !== 0) {
            writer.uint32(32).int32(message.maxPrefixLength);
          }
          if (message.emptyChild.length !== 0) {
            writer.uint32(42).bytes(message.emptyChild);
          }
          if (message.hash !== 0) {
            writer.uint32(48).int32(message.hash);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseInnerSpec);
          message.childOrder = [];
          message.emptyChild = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                if ((tag & 7) === 2) {
                  const end2 = reader.uint32() + reader.pos;
                  while (reader.pos < end2) {
                    message.childOrder.push(reader.int32());
                  }
                } else {
                  message.childOrder.push(reader.int32());
                }
                break;
              case 2:
                message.childSize = reader.int32();
                break;
              case 3:
                message.minPrefixLength = reader.int32();
                break;
              case 4:
                message.maxPrefixLength = reader.int32();
                break;
              case 5:
                message.emptyChild = reader.bytes();
                break;
              case 6:
                message.hash = reader.int32();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseInnerSpec);
          message.childOrder = ((_a = object.childOrder) !== null && _a !== void 0 ? _a : []).map((e) => Number(e));
          message.childSize = object.childSize !== void 0 && object.childSize !== null ? Number(object.childSize) : 0;
          message.minPrefixLength = object.minPrefixLength !== void 0 && object.minPrefixLength !== null ? Number(object.minPrefixLength) : 0;
          message.maxPrefixLength = object.maxPrefixLength !== void 0 && object.maxPrefixLength !== null ? Number(object.maxPrefixLength) : 0;
          message.emptyChild = object.emptyChild !== void 0 && object.emptyChild !== null ? bytesFromBase64(object.emptyChild) : new Uint8Array();
          message.hash = object.hash !== void 0 && object.hash !== null ? hashOpFromJSON(object.hash) : 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.childOrder) {
            obj.childOrder = message.childOrder.map((e) => e);
          } else {
            obj.childOrder = [];
          }
          message.childSize !== void 0 && (obj.childSize = message.childSize);
          message.minPrefixLength !== void 0 && (obj.minPrefixLength = message.minPrefixLength);
          message.maxPrefixLength !== void 0 && (obj.maxPrefixLength = message.maxPrefixLength);
          message.emptyChild !== void 0 && (obj.emptyChild = base64FromBytes(message.emptyChild !== void 0 ? message.emptyChild : new Uint8Array()));
          message.hash !== void 0 && (obj.hash = hashOpToJSON(message.hash));
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c, _d, _e, _f;
          const message = Object.assign({}, baseInnerSpec);
          message.childOrder = ((_a = object.childOrder) === null || _a === void 0 ? void 0 : _a.map((e) => e)) || [];
          message.childSize = (_b = object.childSize) !== null && _b !== void 0 ? _b : 0;
          message.minPrefixLength = (_c = object.minPrefixLength) !== null && _c !== void 0 ? _c : 0;
          message.maxPrefixLength = (_d = object.maxPrefixLength) !== null && _d !== void 0 ? _d : 0;
          message.emptyChild = (_e = object.emptyChild) !== null && _e !== void 0 ? _e : new Uint8Array();
          message.hash = (_f = object.hash) !== null && _f !== void 0 ? _f : 0;
          return message;
        }
      };
      var baseBatchProof = {};
      exports2.BatchProof = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.entries) {
            exports2.BatchEntry.encode(v, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseBatchProof);
          message.entries = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.entries.push(exports2.BatchEntry.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseBatchProof);
          message.entries = ((_a = object.entries) !== null && _a !== void 0 ? _a : []).map((e) => exports2.BatchEntry.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.entries) {
            obj.entries = message.entries.map((e) => e ? exports2.BatchEntry.toJSON(e) : void 0);
          } else {
            obj.entries = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseBatchProof);
          message.entries = ((_a = object.entries) === null || _a === void 0 ? void 0 : _a.map((e) => exports2.BatchEntry.fromPartial(e))) || [];
          return message;
        }
      };
      var baseBatchEntry = {};
      exports2.BatchEntry = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.exist !== void 0) {
            exports2.ExistenceProof.encode(message.exist, writer.uint32(10).fork()).ldelim();
          }
          if (message.nonexist !== void 0) {
            exports2.NonExistenceProof.encode(message.nonexist, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseBatchEntry);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.exist = exports2.ExistenceProof.decode(reader, reader.uint32());
                break;
              case 2:
                message.nonexist = exports2.NonExistenceProof.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseBatchEntry);
          message.exist = object.exist !== void 0 && object.exist !== null ? exports2.ExistenceProof.fromJSON(object.exist) : void 0;
          message.nonexist = object.nonexist !== void 0 && object.nonexist !== null ? exports2.NonExistenceProof.fromJSON(object.nonexist) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.exist !== void 0 && (obj.exist = message.exist ? exports2.ExistenceProof.toJSON(message.exist) : void 0);
          message.nonexist !== void 0 && (obj.nonexist = message.nonexist ? exports2.NonExistenceProof.toJSON(message.nonexist) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseBatchEntry);
          message.exist = object.exist !== void 0 && object.exist !== null ? exports2.ExistenceProof.fromPartial(object.exist) : void 0;
          message.nonexist = object.nonexist !== void 0 && object.nonexist !== null ? exports2.NonExistenceProof.fromPartial(object.nonexist) : void 0;
          return message;
        }
      };
      var baseCompressedBatchProof = {};
      exports2.CompressedBatchProof = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.entries) {
            exports2.CompressedBatchEntry.encode(v, writer.uint32(10).fork()).ldelim();
          }
          for (const v of message.lookupInners) {
            exports2.InnerOp.encode(v, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseCompressedBatchProof);
          message.entries = [];
          message.lookupInners = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.entries.push(exports2.CompressedBatchEntry.decode(reader, reader.uint32()));
                break;
              case 2:
                message.lookupInners.push(exports2.InnerOp.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a, _b;
          const message = Object.assign({}, baseCompressedBatchProof);
          message.entries = ((_a = object.entries) !== null && _a !== void 0 ? _a : []).map((e) => exports2.CompressedBatchEntry.fromJSON(e));
          message.lookupInners = ((_b = object.lookupInners) !== null && _b !== void 0 ? _b : []).map((e) => exports2.InnerOp.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.entries) {
            obj.entries = message.entries.map((e) => e ? exports2.CompressedBatchEntry.toJSON(e) : void 0);
          } else {
            obj.entries = [];
          }
          if (message.lookupInners) {
            obj.lookupInners = message.lookupInners.map((e) => e ? exports2.InnerOp.toJSON(e) : void 0);
          } else {
            obj.lookupInners = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseCompressedBatchProof);
          message.entries = ((_a = object.entries) === null || _a === void 0 ? void 0 : _a.map((e) => exports2.CompressedBatchEntry.fromPartial(e))) || [];
          message.lookupInners = ((_b = object.lookupInners) === null || _b === void 0 ? void 0 : _b.map((e) => exports2.InnerOp.fromPartial(e))) || [];
          return message;
        }
      };
      var baseCompressedBatchEntry = {};
      exports2.CompressedBatchEntry = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.exist !== void 0) {
            exports2.CompressedExistenceProof.encode(message.exist, writer.uint32(10).fork()).ldelim();
          }
          if (message.nonexist !== void 0) {
            exports2.CompressedNonExistenceProof.encode(message.nonexist, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseCompressedBatchEntry);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.exist = exports2.CompressedExistenceProof.decode(reader, reader.uint32());
                break;
              case 2:
                message.nonexist = exports2.CompressedNonExistenceProof.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseCompressedBatchEntry);
          message.exist = object.exist !== void 0 && object.exist !== null ? exports2.CompressedExistenceProof.fromJSON(object.exist) : void 0;
          message.nonexist = object.nonexist !== void 0 && object.nonexist !== null ? exports2.CompressedNonExistenceProof.fromJSON(object.nonexist) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.exist !== void 0 && (obj.exist = message.exist ? exports2.CompressedExistenceProof.toJSON(message.exist) : void 0);
          message.nonexist !== void 0 && (obj.nonexist = message.nonexist ? exports2.CompressedNonExistenceProof.toJSON(message.nonexist) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseCompressedBatchEntry);
          message.exist = object.exist !== void 0 && object.exist !== null ? exports2.CompressedExistenceProof.fromPartial(object.exist) : void 0;
          message.nonexist = object.nonexist !== void 0 && object.nonexist !== null ? exports2.CompressedNonExistenceProof.fromPartial(object.nonexist) : void 0;
          return message;
        }
      };
      var baseCompressedExistenceProof = { path: 0 };
      exports2.CompressedExistenceProof = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.key.length !== 0) {
            writer.uint32(10).bytes(message.key);
          }
          if (message.value.length !== 0) {
            writer.uint32(18).bytes(message.value);
          }
          if (message.leaf !== void 0) {
            exports2.LeafOp.encode(message.leaf, writer.uint32(26).fork()).ldelim();
          }
          writer.uint32(34).fork();
          for (const v of message.path) {
            writer.int32(v);
          }
          writer.ldelim();
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseCompressedExistenceProof);
          message.path = [];
          message.key = new Uint8Array();
          message.value = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.key = reader.bytes();
                break;
              case 2:
                message.value = reader.bytes();
                break;
              case 3:
                message.leaf = exports2.LeafOp.decode(reader, reader.uint32());
                break;
              case 4:
                if ((tag & 7) === 2) {
                  const end2 = reader.uint32() + reader.pos;
                  while (reader.pos < end2) {
                    message.path.push(reader.int32());
                  }
                } else {
                  message.path.push(reader.int32());
                }
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseCompressedExistenceProof);
          message.key = object.key !== void 0 && object.key !== null ? bytesFromBase64(object.key) : new Uint8Array();
          message.value = object.value !== void 0 && object.value !== null ? bytesFromBase64(object.value) : new Uint8Array();
          message.leaf = object.leaf !== void 0 && object.leaf !== null ? exports2.LeafOp.fromJSON(object.leaf) : void 0;
          message.path = ((_a = object.path) !== null && _a !== void 0 ? _a : []).map((e) => Number(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.key !== void 0 && (obj.key = base64FromBytes(message.key !== void 0 ? message.key : new Uint8Array()));
          message.value !== void 0 && (obj.value = base64FromBytes(message.value !== void 0 ? message.value : new Uint8Array()));
          message.leaf !== void 0 && (obj.leaf = message.leaf ? exports2.LeafOp.toJSON(message.leaf) : void 0);
          if (message.path) {
            obj.path = message.path.map((e) => e);
          } else {
            obj.path = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseCompressedExistenceProof);
          message.key = (_a = object.key) !== null && _a !== void 0 ? _a : new Uint8Array();
          message.value = (_b = object.value) !== null && _b !== void 0 ? _b : new Uint8Array();
          message.leaf = object.leaf !== void 0 && object.leaf !== null ? exports2.LeafOp.fromPartial(object.leaf) : void 0;
          message.path = ((_c = object.path) === null || _c === void 0 ? void 0 : _c.map((e) => e)) || [];
          return message;
        }
      };
      var baseCompressedNonExistenceProof = {};
      exports2.CompressedNonExistenceProof = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.key.length !== 0) {
            writer.uint32(10).bytes(message.key);
          }
          if (message.left !== void 0) {
            exports2.CompressedExistenceProof.encode(message.left, writer.uint32(18).fork()).ldelim();
          }
          if (message.right !== void 0) {
            exports2.CompressedExistenceProof.encode(message.right, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseCompressedNonExistenceProof);
          message.key = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.key = reader.bytes();
                break;
              case 2:
                message.left = exports2.CompressedExistenceProof.decode(reader, reader.uint32());
                break;
              case 3:
                message.right = exports2.CompressedExistenceProof.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseCompressedNonExistenceProof);
          message.key = object.key !== void 0 && object.key !== null ? bytesFromBase64(object.key) : new Uint8Array();
          message.left = object.left !== void 0 && object.left !== null ? exports2.CompressedExistenceProof.fromJSON(object.left) : void 0;
          message.right = object.right !== void 0 && object.right !== null ? exports2.CompressedExistenceProof.fromJSON(object.right) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.key !== void 0 && (obj.key = base64FromBytes(message.key !== void 0 ? message.key : new Uint8Array()));
          message.left !== void 0 && (obj.left = message.left ? exports2.CompressedExistenceProof.toJSON(message.left) : void 0);
          message.right !== void 0 && (obj.right = message.right ? exports2.CompressedExistenceProof.toJSON(message.right) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseCompressedNonExistenceProof);
          message.key = (_a = object.key) !== null && _a !== void 0 ? _a : new Uint8Array();
          message.left = object.left !== void 0 && object.left !== null ? exports2.CompressedExistenceProof.fromPartial(object.left) : void 0;
          message.right = object.right !== void 0 && object.right !== null ? exports2.CompressedExistenceProof.fromPartial(object.right) : void 0;
          return message;
        }
      };
      var globalThis2 = (() => {
        if (typeof globalThis2 !== "undefined")
          return globalThis2;
        if (typeof self !== "undefined")
          return self;
        if (typeof window !== "undefined")
          return window;
        if (typeof global !== "undefined")
          return global;
        throw "Unable to locate global object";
      })();
      var atob2 = globalThis2.atob || ((b64) => globalThis2.Buffer.from(b64, "base64").toString("binary"));
      function bytesFromBase64(b64) {
        const bin = atob2(b64);
        const arr = new Uint8Array(bin.length);
        for (let i = 0; i < bin.length; ++i) {
          arr[i] = bin.charCodeAt(i);
        }
        return arr;
      }
      var btoa2 = globalThis2.btoa || ((bin) => globalThis2.Buffer.from(bin, "binary").toString("base64"));
      function base64FromBytes(arr) {
        const bin = [];
        for (const byte of arr) {
          bin.push(String.fromCharCode(byte));
        }
        return btoa2(bin.join(""));
      }
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/cosmjs-types/ibc/core/commitment/v1/commitment.js
  var require_commitment = __commonJS({
    "node_modules/cosmjs-types/ibc/core/commitment/v1/commitment.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.MerkleProof = exports2.MerklePath = exports2.MerklePrefix = exports2.MerkleRoot = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var proofs_1 = require_proofs2();
      exports2.protobufPackage = "ibc.core.commitment.v1";
      var baseMerkleRoot = {};
      exports2.MerkleRoot = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.hash.length !== 0) {
            writer.uint32(10).bytes(message.hash);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMerkleRoot);
          message.hash = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.hash = reader.bytes();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMerkleRoot);
          message.hash = object.hash !== void 0 && object.hash !== null ? bytesFromBase64(object.hash) : new Uint8Array();
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.hash !== void 0 && (obj.hash = base64FromBytes(message.hash !== void 0 ? message.hash : new Uint8Array()));
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseMerkleRoot);
          message.hash = (_a = object.hash) !== null && _a !== void 0 ? _a : new Uint8Array();
          return message;
        }
      };
      var baseMerklePrefix = {};
      exports2.MerklePrefix = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.keyPrefix.length !== 0) {
            writer.uint32(10).bytes(message.keyPrefix);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMerklePrefix);
          message.keyPrefix = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.keyPrefix = reader.bytes();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMerklePrefix);
          message.keyPrefix = object.keyPrefix !== void 0 && object.keyPrefix !== null ? bytesFromBase64(object.keyPrefix) : new Uint8Array();
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.keyPrefix !== void 0 && (obj.keyPrefix = base64FromBytes(message.keyPrefix !== void 0 ? message.keyPrefix : new Uint8Array()));
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseMerklePrefix);
          message.keyPrefix = (_a = object.keyPrefix) !== null && _a !== void 0 ? _a : new Uint8Array();
          return message;
        }
      };
      var baseMerklePath = { keyPath: "" };
      exports2.MerklePath = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.keyPath) {
            writer.uint32(10).string(v);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMerklePath);
          message.keyPath = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.keyPath.push(reader.string());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseMerklePath);
          message.keyPath = ((_a = object.keyPath) !== null && _a !== void 0 ? _a : []).map((e) => String(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.keyPath) {
            obj.keyPath = message.keyPath.map((e) => e);
          } else {
            obj.keyPath = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseMerklePath);
          message.keyPath = ((_a = object.keyPath) === null || _a === void 0 ? void 0 : _a.map((e) => e)) || [];
          return message;
        }
      };
      var baseMerkleProof = {};
      exports2.MerkleProof = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.proofs) {
            proofs_1.CommitmentProof.encode(v, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMerkleProof);
          message.proofs = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.proofs.push(proofs_1.CommitmentProof.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseMerkleProof);
          message.proofs = ((_a = object.proofs) !== null && _a !== void 0 ? _a : []).map((e) => proofs_1.CommitmentProof.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.proofs) {
            obj.proofs = message.proofs.map((e) => e ? proofs_1.CommitmentProof.toJSON(e) : void 0);
          } else {
            obj.proofs = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseMerkleProof);
          message.proofs = ((_a = object.proofs) === null || _a === void 0 ? void 0 : _a.map((e) => proofs_1.CommitmentProof.fromPartial(e))) || [];
          return message;
        }
      };
      var globalThis2 = (() => {
        if (typeof globalThis2 !== "undefined")
          return globalThis2;
        if (typeof self !== "undefined")
          return self;
        if (typeof window !== "undefined")
          return window;
        if (typeof global !== "undefined")
          return global;
        throw "Unable to locate global object";
      })();
      var atob2 = globalThis2.atob || ((b64) => globalThis2.Buffer.from(b64, "base64").toString("binary"));
      function bytesFromBase64(b64) {
        const bin = atob2(b64);
        const arr = new Uint8Array(bin.length);
        for (let i = 0; i < bin.length; ++i) {
          arr[i] = bin.charCodeAt(i);
        }
        return arr;
      }
      var btoa2 = globalThis2.btoa || ((bin) => globalThis2.Buffer.from(bin, "binary").toString("base64"));
      function base64FromBytes(arr) {
        const bin = [];
        for (const byte of arr) {
          bin.push(String.fromCharCode(byte));
        }
        return btoa2(bin.join(""));
      }
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/cosmjs-types/ibc/core/connection/v1/connection.js
  var require_connection = __commonJS({
    "node_modules/cosmjs-types/ibc/core/connection/v1/connection.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.Version = exports2.ConnectionPaths = exports2.ClientPaths = exports2.Counterparty = exports2.IdentifiedConnection = exports2.ConnectionEnd = exports2.stateToJSON = exports2.stateFromJSON = exports2.State = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var commitment_1 = require_commitment();
      exports2.protobufPackage = "ibc.core.connection.v1";
      var State;
      (function(State2) {
        State2[State2["STATE_UNINITIALIZED_UNSPECIFIED"] = 0] = "STATE_UNINITIALIZED_UNSPECIFIED";
        State2[State2["STATE_INIT"] = 1] = "STATE_INIT";
        State2[State2["STATE_TRYOPEN"] = 2] = "STATE_TRYOPEN";
        State2[State2["STATE_OPEN"] = 3] = "STATE_OPEN";
        State2[State2["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
      })(State = exports2.State || (exports2.State = {}));
      function stateFromJSON(object) {
        switch (object) {
          case 0:
          case "STATE_UNINITIALIZED_UNSPECIFIED":
            return State.STATE_UNINITIALIZED_UNSPECIFIED;
          case 1:
          case "STATE_INIT":
            return State.STATE_INIT;
          case 2:
          case "STATE_TRYOPEN":
            return State.STATE_TRYOPEN;
          case 3:
          case "STATE_OPEN":
            return State.STATE_OPEN;
          case -1:
          case "UNRECOGNIZED":
          default:
            return State.UNRECOGNIZED;
        }
      }
      exports2.stateFromJSON = stateFromJSON;
      function stateToJSON(object) {
        switch (object) {
          case State.STATE_UNINITIALIZED_UNSPECIFIED:
            return "STATE_UNINITIALIZED_UNSPECIFIED";
          case State.STATE_INIT:
            return "STATE_INIT";
          case State.STATE_TRYOPEN:
            return "STATE_TRYOPEN";
          case State.STATE_OPEN:
            return "STATE_OPEN";
          default:
            return "UNKNOWN";
        }
      }
      exports2.stateToJSON = stateToJSON;
      var baseConnectionEnd = { clientId: "", state: 0, delayPeriod: long_1.default.UZERO };
      exports2.ConnectionEnd = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.clientId !== "") {
            writer.uint32(10).string(message.clientId);
          }
          for (const v of message.versions) {
            exports2.Version.encode(v, writer.uint32(18).fork()).ldelim();
          }
          if (message.state !== 0) {
            writer.uint32(24).int32(message.state);
          }
          if (message.counterparty !== void 0) {
            exports2.Counterparty.encode(message.counterparty, writer.uint32(34).fork()).ldelim();
          }
          if (!message.delayPeriod.isZero()) {
            writer.uint32(40).uint64(message.delayPeriod);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseConnectionEnd);
          message.versions = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.clientId = reader.string();
                break;
              case 2:
                message.versions.push(exports2.Version.decode(reader, reader.uint32()));
                break;
              case 3:
                message.state = reader.int32();
                break;
              case 4:
                message.counterparty = exports2.Counterparty.decode(reader, reader.uint32());
                break;
              case 5:
                message.delayPeriod = reader.uint64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseConnectionEnd);
          message.clientId = object.clientId !== void 0 && object.clientId !== null ? String(object.clientId) : "";
          message.versions = ((_a = object.versions) !== null && _a !== void 0 ? _a : []).map((e) => exports2.Version.fromJSON(e));
          message.state = object.state !== void 0 && object.state !== null ? stateFromJSON(object.state) : 0;
          message.counterparty = object.counterparty !== void 0 && object.counterparty !== null ? exports2.Counterparty.fromJSON(object.counterparty) : void 0;
          message.delayPeriod = object.delayPeriod !== void 0 && object.delayPeriod !== null ? long_1.default.fromString(object.delayPeriod) : long_1.default.UZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.clientId !== void 0 && (obj.clientId = message.clientId);
          if (message.versions) {
            obj.versions = message.versions.map((e) => e ? exports2.Version.toJSON(e) : void 0);
          } else {
            obj.versions = [];
          }
          message.state !== void 0 && (obj.state = stateToJSON(message.state));
          message.counterparty !== void 0 && (obj.counterparty = message.counterparty ? exports2.Counterparty.toJSON(message.counterparty) : void 0);
          message.delayPeriod !== void 0 && (obj.delayPeriod = (message.delayPeriod || long_1.default.UZERO).toString());
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseConnectionEnd);
          message.clientId = (_a = object.clientId) !== null && _a !== void 0 ? _a : "";
          message.versions = ((_b = object.versions) === null || _b === void 0 ? void 0 : _b.map((e) => exports2.Version.fromPartial(e))) || [];
          message.state = (_c = object.state) !== null && _c !== void 0 ? _c : 0;
          message.counterparty = object.counterparty !== void 0 && object.counterparty !== null ? exports2.Counterparty.fromPartial(object.counterparty) : void 0;
          message.delayPeriod = object.delayPeriod !== void 0 && object.delayPeriod !== null ? long_1.default.fromValue(object.delayPeriod) : long_1.default.UZERO;
          return message;
        }
      };
      var baseIdentifiedConnection = { id: "", clientId: "", state: 0, delayPeriod: long_1.default.UZERO };
      exports2.IdentifiedConnection = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.id !== "") {
            writer.uint32(10).string(message.id);
          }
          if (message.clientId !== "") {
            writer.uint32(18).string(message.clientId);
          }
          for (const v of message.versions) {
            exports2.Version.encode(v, writer.uint32(26).fork()).ldelim();
          }
          if (message.state !== 0) {
            writer.uint32(32).int32(message.state);
          }
          if (message.counterparty !== void 0) {
            exports2.Counterparty.encode(message.counterparty, writer.uint32(42).fork()).ldelim();
          }
          if (!message.delayPeriod.isZero()) {
            writer.uint32(48).uint64(message.delayPeriod);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseIdentifiedConnection);
          message.versions = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.id = reader.string();
                break;
              case 2:
                message.clientId = reader.string();
                break;
              case 3:
                message.versions.push(exports2.Version.decode(reader, reader.uint32()));
                break;
              case 4:
                message.state = reader.int32();
                break;
              case 5:
                message.counterparty = exports2.Counterparty.decode(reader, reader.uint32());
                break;
              case 6:
                message.delayPeriod = reader.uint64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseIdentifiedConnection);
          message.id = object.id !== void 0 && object.id !== null ? String(object.id) : "";
          message.clientId = object.clientId !== void 0 && object.clientId !== null ? String(object.clientId) : "";
          message.versions = ((_a = object.versions) !== null && _a !== void 0 ? _a : []).map((e) => exports2.Version.fromJSON(e));
          message.state = object.state !== void 0 && object.state !== null ? stateFromJSON(object.state) : 0;
          message.counterparty = object.counterparty !== void 0 && object.counterparty !== null ? exports2.Counterparty.fromJSON(object.counterparty) : void 0;
          message.delayPeriod = object.delayPeriod !== void 0 && object.delayPeriod !== null ? long_1.default.fromString(object.delayPeriod) : long_1.default.UZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.id !== void 0 && (obj.id = message.id);
          message.clientId !== void 0 && (obj.clientId = message.clientId);
          if (message.versions) {
            obj.versions = message.versions.map((e) => e ? exports2.Version.toJSON(e) : void 0);
          } else {
            obj.versions = [];
          }
          message.state !== void 0 && (obj.state = stateToJSON(message.state));
          message.counterparty !== void 0 && (obj.counterparty = message.counterparty ? exports2.Counterparty.toJSON(message.counterparty) : void 0);
          message.delayPeriod !== void 0 && (obj.delayPeriod = (message.delayPeriod || long_1.default.UZERO).toString());
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c, _d;
          const message = Object.assign({}, baseIdentifiedConnection);
          message.id = (_a = object.id) !== null && _a !== void 0 ? _a : "";
          message.clientId = (_b = object.clientId) !== null && _b !== void 0 ? _b : "";
          message.versions = ((_c = object.versions) === null || _c === void 0 ? void 0 : _c.map((e) => exports2.Version.fromPartial(e))) || [];
          message.state = (_d = object.state) !== null && _d !== void 0 ? _d : 0;
          message.counterparty = object.counterparty !== void 0 && object.counterparty !== null ? exports2.Counterparty.fromPartial(object.counterparty) : void 0;
          message.delayPeriod = object.delayPeriod !== void 0 && object.delayPeriod !== null ? long_1.default.fromValue(object.delayPeriod) : long_1.default.UZERO;
          return message;
        }
      };
      var baseCounterparty = { clientId: "", connectionId: "" };
      exports2.Counterparty = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.clientId !== "") {
            writer.uint32(10).string(message.clientId);
          }
          if (message.connectionId !== "") {
            writer.uint32(18).string(message.connectionId);
          }
          if (message.prefix !== void 0) {
            commitment_1.MerklePrefix.encode(message.prefix, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseCounterparty);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.clientId = reader.string();
                break;
              case 2:
                message.connectionId = reader.string();
                break;
              case 3:
                message.prefix = commitment_1.MerklePrefix.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseCounterparty);
          message.clientId = object.clientId !== void 0 && object.clientId !== null ? String(object.clientId) : "";
          message.connectionId = object.connectionId !== void 0 && object.connectionId !== null ? String(object.connectionId) : "";
          message.prefix = object.prefix !== void 0 && object.prefix !== null ? commitment_1.MerklePrefix.fromJSON(object.prefix) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.clientId !== void 0 && (obj.clientId = message.clientId);
          message.connectionId !== void 0 && (obj.connectionId = message.connectionId);
          message.prefix !== void 0 && (obj.prefix = message.prefix ? commitment_1.MerklePrefix.toJSON(message.prefix) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseCounterparty);
          message.clientId = (_a = object.clientId) !== null && _a !== void 0 ? _a : "";
          message.connectionId = (_b = object.connectionId) !== null && _b !== void 0 ? _b : "";
          message.prefix = object.prefix !== void 0 && object.prefix !== null ? commitment_1.MerklePrefix.fromPartial(object.prefix) : void 0;
          return message;
        }
      };
      var baseClientPaths = { paths: "" };
      exports2.ClientPaths = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.paths) {
            writer.uint32(10).string(v);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseClientPaths);
          message.paths = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.paths.push(reader.string());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseClientPaths);
          message.paths = ((_a = object.paths) !== null && _a !== void 0 ? _a : []).map((e) => String(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.paths) {
            obj.paths = message.paths.map((e) => e);
          } else {
            obj.paths = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseClientPaths);
          message.paths = ((_a = object.paths) === null || _a === void 0 ? void 0 : _a.map((e) => e)) || [];
          return message;
        }
      };
      var baseConnectionPaths = { clientId: "", paths: "" };
      exports2.ConnectionPaths = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.clientId !== "") {
            writer.uint32(10).string(message.clientId);
          }
          for (const v of message.paths) {
            writer.uint32(18).string(v);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseConnectionPaths);
          message.paths = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.clientId = reader.string();
                break;
              case 2:
                message.paths.push(reader.string());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseConnectionPaths);
          message.clientId = object.clientId !== void 0 && object.clientId !== null ? String(object.clientId) : "";
          message.paths = ((_a = object.paths) !== null && _a !== void 0 ? _a : []).map((e) => String(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.clientId !== void 0 && (obj.clientId = message.clientId);
          if (message.paths) {
            obj.paths = message.paths.map((e) => e);
          } else {
            obj.paths = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseConnectionPaths);
          message.clientId = (_a = object.clientId) !== null && _a !== void 0 ? _a : "";
          message.paths = ((_b = object.paths) === null || _b === void 0 ? void 0 : _b.map((e) => e)) || [];
          return message;
        }
      };
      var baseVersion = { identifier: "", features: "" };
      exports2.Version = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.identifier !== "") {
            writer.uint32(10).string(message.identifier);
          }
          for (const v of message.features) {
            writer.uint32(18).string(v);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseVersion);
          message.features = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.identifier = reader.string();
                break;
              case 2:
                message.features.push(reader.string());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseVersion);
          message.identifier = object.identifier !== void 0 && object.identifier !== null ? String(object.identifier) : "";
          message.features = ((_a = object.features) !== null && _a !== void 0 ? _a : []).map((e) => String(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.identifier !== void 0 && (obj.identifier = message.identifier);
          if (message.features) {
            obj.features = message.features.map((e) => e);
          } else {
            obj.features = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseVersion);
          message.identifier = (_a = object.identifier) !== null && _a !== void 0 ? _a : "";
          message.features = ((_b = object.features) === null || _b === void 0 ? void 0 : _b.map((e) => e)) || [];
          return message;
        }
      };
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/cosmjs-types/ibc/core/connection/v1/tx.js
  var require_tx10 = __commonJS({
    "node_modules/cosmjs-types/ibc/core/connection/v1/tx.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.MsgClientImpl = exports2.MsgConnectionOpenConfirmResponse = exports2.MsgConnectionOpenConfirm = exports2.MsgConnectionOpenAckResponse = exports2.MsgConnectionOpenAck = exports2.MsgConnectionOpenTryResponse = exports2.MsgConnectionOpenTry = exports2.MsgConnectionOpenInitResponse = exports2.MsgConnectionOpenInit = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var connection_1 = require_connection();
      var any_1 = require_any();
      var client_1 = require_client();
      exports2.protobufPackage = "ibc.core.connection.v1";
      var baseMsgConnectionOpenInit = { clientId: "", delayPeriod: long_1.default.UZERO, signer: "" };
      exports2.MsgConnectionOpenInit = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.clientId !== "") {
            writer.uint32(10).string(message.clientId);
          }
          if (message.counterparty !== void 0) {
            connection_1.Counterparty.encode(message.counterparty, writer.uint32(18).fork()).ldelim();
          }
          if (message.version !== void 0) {
            connection_1.Version.encode(message.version, writer.uint32(26).fork()).ldelim();
          }
          if (!message.delayPeriod.isZero()) {
            writer.uint32(32).uint64(message.delayPeriod);
          }
          if (message.signer !== "") {
            writer.uint32(42).string(message.signer);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgConnectionOpenInit);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.clientId = reader.string();
                break;
              case 2:
                message.counterparty = connection_1.Counterparty.decode(reader, reader.uint32());
                break;
              case 3:
                message.version = connection_1.Version.decode(reader, reader.uint32());
                break;
              case 4:
                message.delayPeriod = reader.uint64();
                break;
              case 5:
                message.signer = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMsgConnectionOpenInit);
          message.clientId = object.clientId !== void 0 && object.clientId !== null ? String(object.clientId) : "";
          message.counterparty = object.counterparty !== void 0 && object.counterparty !== null ? connection_1.Counterparty.fromJSON(object.counterparty) : void 0;
          message.version = object.version !== void 0 && object.version !== null ? connection_1.Version.fromJSON(object.version) : void 0;
          message.delayPeriod = object.delayPeriod !== void 0 && object.delayPeriod !== null ? long_1.default.fromString(object.delayPeriod) : long_1.default.UZERO;
          message.signer = object.signer !== void 0 && object.signer !== null ? String(object.signer) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.clientId !== void 0 && (obj.clientId = message.clientId);
          message.counterparty !== void 0 && (obj.counterparty = message.counterparty ? connection_1.Counterparty.toJSON(message.counterparty) : void 0);
          message.version !== void 0 && (obj.version = message.version ? connection_1.Version.toJSON(message.version) : void 0);
          message.delayPeriod !== void 0 && (obj.delayPeriod = (message.delayPeriod || long_1.default.UZERO).toString());
          message.signer !== void 0 && (obj.signer = message.signer);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseMsgConnectionOpenInit);
          message.clientId = (_a = object.clientId) !== null && _a !== void 0 ? _a : "";
          message.counterparty = object.counterparty !== void 0 && object.counterparty !== null ? connection_1.Counterparty.fromPartial(object.counterparty) : void 0;
          message.version = object.version !== void 0 && object.version !== null ? connection_1.Version.fromPartial(object.version) : void 0;
          message.delayPeriod = object.delayPeriod !== void 0 && object.delayPeriod !== null ? long_1.default.fromValue(object.delayPeriod) : long_1.default.UZERO;
          message.signer = (_b = object.signer) !== null && _b !== void 0 ? _b : "";
          return message;
        }
      };
      var baseMsgConnectionOpenInitResponse = {};
      exports2.MsgConnectionOpenInitResponse = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgConnectionOpenInitResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseMsgConnectionOpenInitResponse);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseMsgConnectionOpenInitResponse);
          return message;
        }
      };
      var baseMsgConnectionOpenTry = {
        clientId: "",
        previousConnectionId: "",
        delayPeriod: long_1.default.UZERO,
        signer: ""
      };
      exports2.MsgConnectionOpenTry = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.clientId !== "") {
            writer.uint32(10).string(message.clientId);
          }
          if (message.previousConnectionId !== "") {
            writer.uint32(18).string(message.previousConnectionId);
          }
          if (message.clientState !== void 0) {
            any_1.Any.encode(message.clientState, writer.uint32(26).fork()).ldelim();
          }
          if (message.counterparty !== void 0) {
            connection_1.Counterparty.encode(message.counterparty, writer.uint32(34).fork()).ldelim();
          }
          if (!message.delayPeriod.isZero()) {
            writer.uint32(40).uint64(message.delayPeriod);
          }
          for (const v of message.counterpartyVersions) {
            connection_1.Version.encode(v, writer.uint32(50).fork()).ldelim();
          }
          if (message.proofHeight !== void 0) {
            client_1.Height.encode(message.proofHeight, writer.uint32(58).fork()).ldelim();
          }
          if (message.proofInit.length !== 0) {
            writer.uint32(66).bytes(message.proofInit);
          }
          if (message.proofClient.length !== 0) {
            writer.uint32(74).bytes(message.proofClient);
          }
          if (message.proofConsensus.length !== 0) {
            writer.uint32(82).bytes(message.proofConsensus);
          }
          if (message.consensusHeight !== void 0) {
            client_1.Height.encode(message.consensusHeight, writer.uint32(90).fork()).ldelim();
          }
          if (message.signer !== "") {
            writer.uint32(98).string(message.signer);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgConnectionOpenTry);
          message.counterpartyVersions = [];
          message.proofInit = new Uint8Array();
          message.proofClient = new Uint8Array();
          message.proofConsensus = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.clientId = reader.string();
                break;
              case 2:
                message.previousConnectionId = reader.string();
                break;
              case 3:
                message.clientState = any_1.Any.decode(reader, reader.uint32());
                break;
              case 4:
                message.counterparty = connection_1.Counterparty.decode(reader, reader.uint32());
                break;
              case 5:
                message.delayPeriod = reader.uint64();
                break;
              case 6:
                message.counterpartyVersions.push(connection_1.Version.decode(reader, reader.uint32()));
                break;
              case 7:
                message.proofHeight = client_1.Height.decode(reader, reader.uint32());
                break;
              case 8:
                message.proofInit = reader.bytes();
                break;
              case 9:
                message.proofClient = reader.bytes();
                break;
              case 10:
                message.proofConsensus = reader.bytes();
                break;
              case 11:
                message.consensusHeight = client_1.Height.decode(reader, reader.uint32());
                break;
              case 12:
                message.signer = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseMsgConnectionOpenTry);
          message.clientId = object.clientId !== void 0 && object.clientId !== null ? String(object.clientId) : "";
          message.previousConnectionId = object.previousConnectionId !== void 0 && object.previousConnectionId !== null ? String(object.previousConnectionId) : "";
          message.clientState = object.clientState !== void 0 && object.clientState !== null ? any_1.Any.fromJSON(object.clientState) : void 0;
          message.counterparty = object.counterparty !== void 0 && object.counterparty !== null ? connection_1.Counterparty.fromJSON(object.counterparty) : void 0;
          message.delayPeriod = object.delayPeriod !== void 0 && object.delayPeriod !== null ? long_1.default.fromString(object.delayPeriod) : long_1.default.UZERO;
          message.counterpartyVersions = ((_a = object.counterpartyVersions) !== null && _a !== void 0 ? _a : []).map((e) => connection_1.Version.fromJSON(e));
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromJSON(object.proofHeight) : void 0;
          message.proofInit = object.proofInit !== void 0 && object.proofInit !== null ? bytesFromBase64(object.proofInit) : new Uint8Array();
          message.proofClient = object.proofClient !== void 0 && object.proofClient !== null ? bytesFromBase64(object.proofClient) : new Uint8Array();
          message.proofConsensus = object.proofConsensus !== void 0 && object.proofConsensus !== null ? bytesFromBase64(object.proofConsensus) : new Uint8Array();
          message.consensusHeight = object.consensusHeight !== void 0 && object.consensusHeight !== null ? client_1.Height.fromJSON(object.consensusHeight) : void 0;
          message.signer = object.signer !== void 0 && object.signer !== null ? String(object.signer) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.clientId !== void 0 && (obj.clientId = message.clientId);
          message.previousConnectionId !== void 0 && (obj.previousConnectionId = message.previousConnectionId);
          message.clientState !== void 0 && (obj.clientState = message.clientState ? any_1.Any.toJSON(message.clientState) : void 0);
          message.counterparty !== void 0 && (obj.counterparty = message.counterparty ? connection_1.Counterparty.toJSON(message.counterparty) : void 0);
          message.delayPeriod !== void 0 && (obj.delayPeriod = (message.delayPeriod || long_1.default.UZERO).toString());
          if (message.counterpartyVersions) {
            obj.counterpartyVersions = message.counterpartyVersions.map((e) => e ? connection_1.Version.toJSON(e) : void 0);
          } else {
            obj.counterpartyVersions = [];
          }
          message.proofHeight !== void 0 && (obj.proofHeight = message.proofHeight ? client_1.Height.toJSON(message.proofHeight) : void 0);
          message.proofInit !== void 0 && (obj.proofInit = base64FromBytes(message.proofInit !== void 0 ? message.proofInit : new Uint8Array()));
          message.proofClient !== void 0 && (obj.proofClient = base64FromBytes(message.proofClient !== void 0 ? message.proofClient : new Uint8Array()));
          message.proofConsensus !== void 0 && (obj.proofConsensus = base64FromBytes(message.proofConsensus !== void 0 ? message.proofConsensus : new Uint8Array()));
          message.consensusHeight !== void 0 && (obj.consensusHeight = message.consensusHeight ? client_1.Height.toJSON(message.consensusHeight) : void 0);
          message.signer !== void 0 && (obj.signer = message.signer);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c, _d, _e, _f, _g;
          const message = Object.assign({}, baseMsgConnectionOpenTry);
          message.clientId = (_a = object.clientId) !== null && _a !== void 0 ? _a : "";
          message.previousConnectionId = (_b = object.previousConnectionId) !== null && _b !== void 0 ? _b : "";
          message.clientState = object.clientState !== void 0 && object.clientState !== null ? any_1.Any.fromPartial(object.clientState) : void 0;
          message.counterparty = object.counterparty !== void 0 && object.counterparty !== null ? connection_1.Counterparty.fromPartial(object.counterparty) : void 0;
          message.delayPeriod = object.delayPeriod !== void 0 && object.delayPeriod !== null ? long_1.default.fromValue(object.delayPeriod) : long_1.default.UZERO;
          message.counterpartyVersions = ((_c = object.counterpartyVersions) === null || _c === void 0 ? void 0 : _c.map((e) => connection_1.Version.fromPartial(e))) || [];
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromPartial(object.proofHeight) : void 0;
          message.proofInit = (_d = object.proofInit) !== null && _d !== void 0 ? _d : new Uint8Array();
          message.proofClient = (_e = object.proofClient) !== null && _e !== void 0 ? _e : new Uint8Array();
          message.proofConsensus = (_f = object.proofConsensus) !== null && _f !== void 0 ? _f : new Uint8Array();
          message.consensusHeight = object.consensusHeight !== void 0 && object.consensusHeight !== null ? client_1.Height.fromPartial(object.consensusHeight) : void 0;
          message.signer = (_g = object.signer) !== null && _g !== void 0 ? _g : "";
          return message;
        }
      };
      var baseMsgConnectionOpenTryResponse = {};
      exports2.MsgConnectionOpenTryResponse = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgConnectionOpenTryResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseMsgConnectionOpenTryResponse);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseMsgConnectionOpenTryResponse);
          return message;
        }
      };
      var baseMsgConnectionOpenAck = { connectionId: "", counterpartyConnectionId: "", signer: "" };
      exports2.MsgConnectionOpenAck = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.connectionId !== "") {
            writer.uint32(10).string(message.connectionId);
          }
          if (message.counterpartyConnectionId !== "") {
            writer.uint32(18).string(message.counterpartyConnectionId);
          }
          if (message.version !== void 0) {
            connection_1.Version.encode(message.version, writer.uint32(26).fork()).ldelim();
          }
          if (message.clientState !== void 0) {
            any_1.Any.encode(message.clientState, writer.uint32(34).fork()).ldelim();
          }
          if (message.proofHeight !== void 0) {
            client_1.Height.encode(message.proofHeight, writer.uint32(42).fork()).ldelim();
          }
          if (message.proofTry.length !== 0) {
            writer.uint32(50).bytes(message.proofTry);
          }
          if (message.proofClient.length !== 0) {
            writer.uint32(58).bytes(message.proofClient);
          }
          if (message.proofConsensus.length !== 0) {
            writer.uint32(66).bytes(message.proofConsensus);
          }
          if (message.consensusHeight !== void 0) {
            client_1.Height.encode(message.consensusHeight, writer.uint32(74).fork()).ldelim();
          }
          if (message.signer !== "") {
            writer.uint32(82).string(message.signer);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgConnectionOpenAck);
          message.proofTry = new Uint8Array();
          message.proofClient = new Uint8Array();
          message.proofConsensus = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.connectionId = reader.string();
                break;
              case 2:
                message.counterpartyConnectionId = reader.string();
                break;
              case 3:
                message.version = connection_1.Version.decode(reader, reader.uint32());
                break;
              case 4:
                message.clientState = any_1.Any.decode(reader, reader.uint32());
                break;
              case 5:
                message.proofHeight = client_1.Height.decode(reader, reader.uint32());
                break;
              case 6:
                message.proofTry = reader.bytes();
                break;
              case 7:
                message.proofClient = reader.bytes();
                break;
              case 8:
                message.proofConsensus = reader.bytes();
                break;
              case 9:
                message.consensusHeight = client_1.Height.decode(reader, reader.uint32());
                break;
              case 10:
                message.signer = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMsgConnectionOpenAck);
          message.connectionId = object.connectionId !== void 0 && object.connectionId !== null ? String(object.connectionId) : "";
          message.counterpartyConnectionId = object.counterpartyConnectionId !== void 0 && object.counterpartyConnectionId !== null ? String(object.counterpartyConnectionId) : "";
          message.version = object.version !== void 0 && object.version !== null ? connection_1.Version.fromJSON(object.version) : void 0;
          message.clientState = object.clientState !== void 0 && object.clientState !== null ? any_1.Any.fromJSON(object.clientState) : void 0;
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromJSON(object.proofHeight) : void 0;
          message.proofTry = object.proofTry !== void 0 && object.proofTry !== null ? bytesFromBase64(object.proofTry) : new Uint8Array();
          message.proofClient = object.proofClient !== void 0 && object.proofClient !== null ? bytesFromBase64(object.proofClient) : new Uint8Array();
          message.proofConsensus = object.proofConsensus !== void 0 && object.proofConsensus !== null ? bytesFromBase64(object.proofConsensus) : new Uint8Array();
          message.consensusHeight = object.consensusHeight !== void 0 && object.consensusHeight !== null ? client_1.Height.fromJSON(object.consensusHeight) : void 0;
          message.signer = object.signer !== void 0 && object.signer !== null ? String(object.signer) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.connectionId !== void 0 && (obj.connectionId = message.connectionId);
          message.counterpartyConnectionId !== void 0 && (obj.counterpartyConnectionId = message.counterpartyConnectionId);
          message.version !== void 0 && (obj.version = message.version ? connection_1.Version.toJSON(message.version) : void 0);
          message.clientState !== void 0 && (obj.clientState = message.clientState ? any_1.Any.toJSON(message.clientState) : void 0);
          message.proofHeight !== void 0 && (obj.proofHeight = message.proofHeight ? client_1.Height.toJSON(message.proofHeight) : void 0);
          message.proofTry !== void 0 && (obj.proofTry = base64FromBytes(message.proofTry !== void 0 ? message.proofTry : new Uint8Array()));
          message.proofClient !== void 0 && (obj.proofClient = base64FromBytes(message.proofClient !== void 0 ? message.proofClient : new Uint8Array()));
          message.proofConsensus !== void 0 && (obj.proofConsensus = base64FromBytes(message.proofConsensus !== void 0 ? message.proofConsensus : new Uint8Array()));
          message.consensusHeight !== void 0 && (obj.consensusHeight = message.consensusHeight ? client_1.Height.toJSON(message.consensusHeight) : void 0);
          message.signer !== void 0 && (obj.signer = message.signer);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c, _d, _e, _f;
          const message = Object.assign({}, baseMsgConnectionOpenAck);
          message.connectionId = (_a = object.connectionId) !== null && _a !== void 0 ? _a : "";
          message.counterpartyConnectionId = (_b = object.counterpartyConnectionId) !== null && _b !== void 0 ? _b : "";
          message.version = object.version !== void 0 && object.version !== null ? connection_1.Version.fromPartial(object.version) : void 0;
          message.clientState = object.clientState !== void 0 && object.clientState !== null ? any_1.Any.fromPartial(object.clientState) : void 0;
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromPartial(object.proofHeight) : void 0;
          message.proofTry = (_c = object.proofTry) !== null && _c !== void 0 ? _c : new Uint8Array();
          message.proofClient = (_d = object.proofClient) !== null && _d !== void 0 ? _d : new Uint8Array();
          message.proofConsensus = (_e = object.proofConsensus) !== null && _e !== void 0 ? _e : new Uint8Array();
          message.consensusHeight = object.consensusHeight !== void 0 && object.consensusHeight !== null ? client_1.Height.fromPartial(object.consensusHeight) : void 0;
          message.signer = (_f = object.signer) !== null && _f !== void 0 ? _f : "";
          return message;
        }
      };
      var baseMsgConnectionOpenAckResponse = {};
      exports2.MsgConnectionOpenAckResponse = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgConnectionOpenAckResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseMsgConnectionOpenAckResponse);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseMsgConnectionOpenAckResponse);
          return message;
        }
      };
      var baseMsgConnectionOpenConfirm = { connectionId: "", signer: "" };
      exports2.MsgConnectionOpenConfirm = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.connectionId !== "") {
            writer.uint32(10).string(message.connectionId);
          }
          if (message.proofAck.length !== 0) {
            writer.uint32(18).bytes(message.proofAck);
          }
          if (message.proofHeight !== void 0) {
            client_1.Height.encode(message.proofHeight, writer.uint32(26).fork()).ldelim();
          }
          if (message.signer !== "") {
            writer.uint32(34).string(message.signer);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgConnectionOpenConfirm);
          message.proofAck = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.connectionId = reader.string();
                break;
              case 2:
                message.proofAck = reader.bytes();
                break;
              case 3:
                message.proofHeight = client_1.Height.decode(reader, reader.uint32());
                break;
              case 4:
                message.signer = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMsgConnectionOpenConfirm);
          message.connectionId = object.connectionId !== void 0 && object.connectionId !== null ? String(object.connectionId) : "";
          message.proofAck = object.proofAck !== void 0 && object.proofAck !== null ? bytesFromBase64(object.proofAck) : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromJSON(object.proofHeight) : void 0;
          message.signer = object.signer !== void 0 && object.signer !== null ? String(object.signer) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.connectionId !== void 0 && (obj.connectionId = message.connectionId);
          message.proofAck !== void 0 && (obj.proofAck = base64FromBytes(message.proofAck !== void 0 ? message.proofAck : new Uint8Array()));
          message.proofHeight !== void 0 && (obj.proofHeight = message.proofHeight ? client_1.Height.toJSON(message.proofHeight) : void 0);
          message.signer !== void 0 && (obj.signer = message.signer);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseMsgConnectionOpenConfirm);
          message.connectionId = (_a = object.connectionId) !== null && _a !== void 0 ? _a : "";
          message.proofAck = (_b = object.proofAck) !== null && _b !== void 0 ? _b : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromPartial(object.proofHeight) : void 0;
          message.signer = (_c = object.signer) !== null && _c !== void 0 ? _c : "";
          return message;
        }
      };
      var baseMsgConnectionOpenConfirmResponse = {};
      exports2.MsgConnectionOpenConfirmResponse = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgConnectionOpenConfirmResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseMsgConnectionOpenConfirmResponse);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseMsgConnectionOpenConfirmResponse);
          return message;
        }
      };
      var MsgClientImpl = class {
        constructor(rpc) {
          this.rpc = rpc;
          this.ConnectionOpenInit = this.ConnectionOpenInit.bind(this);
          this.ConnectionOpenTry = this.ConnectionOpenTry.bind(this);
          this.ConnectionOpenAck = this.ConnectionOpenAck.bind(this);
          this.ConnectionOpenConfirm = this.ConnectionOpenConfirm.bind(this);
        }
        ConnectionOpenInit(request) {
          const data = exports2.MsgConnectionOpenInit.encode(request).finish();
          const promise = this.rpc.request("ibc.core.connection.v1.Msg", "ConnectionOpenInit", data);
          return promise.then((data2) => exports2.MsgConnectionOpenInitResponse.decode(new minimal_1.default.Reader(data2)));
        }
        ConnectionOpenTry(request) {
          const data = exports2.MsgConnectionOpenTry.encode(request).finish();
          const promise = this.rpc.request("ibc.core.connection.v1.Msg", "ConnectionOpenTry", data);
          return promise.then((data2) => exports2.MsgConnectionOpenTryResponse.decode(new minimal_1.default.Reader(data2)));
        }
        ConnectionOpenAck(request) {
          const data = exports2.MsgConnectionOpenAck.encode(request).finish();
          const promise = this.rpc.request("ibc.core.connection.v1.Msg", "ConnectionOpenAck", data);
          return promise.then((data2) => exports2.MsgConnectionOpenAckResponse.decode(new minimal_1.default.Reader(data2)));
        }
        ConnectionOpenConfirm(request) {
          const data = exports2.MsgConnectionOpenConfirm.encode(request).finish();
          const promise = this.rpc.request("ibc.core.connection.v1.Msg", "ConnectionOpenConfirm", data);
          return promise.then((data2) => exports2.MsgConnectionOpenConfirmResponse.decode(new minimal_1.default.Reader(data2)));
        }
      };
      exports2.MsgClientImpl = MsgClientImpl;
      var globalThis2 = (() => {
        if (typeof globalThis2 !== "undefined")
          return globalThis2;
        if (typeof self !== "undefined")
          return self;
        if (typeof window !== "undefined")
          return window;
        if (typeof global !== "undefined")
          return global;
        throw "Unable to locate global object";
      })();
      var atob2 = globalThis2.atob || ((b64) => globalThis2.Buffer.from(b64, "base64").toString("binary"));
      function bytesFromBase64(b64) {
        const bin = atob2(b64);
        const arr = new Uint8Array(bin.length);
        for (let i = 0; i < bin.length; ++i) {
          arr[i] = bin.charCodeAt(i);
        }
        return arr;
      }
      var btoa2 = globalThis2.btoa || ((bin) => globalThis2.Buffer.from(bin, "binary").toString("base64"));
      function base64FromBytes(arr) {
        const bin = [];
        for (const byte of arr) {
          bin.push(String.fromCharCode(byte));
        }
        return btoa2(bin.join(""));
      }
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/@cosmjs/stargate/build/modules/ibc/messages.js
  var require_messages6 = __commonJS({
    "node_modules/@cosmjs/stargate/build/modules/ibc/messages.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.isMsgTransferEncodeObject = exports2.ibcTypes = void 0;
      var tx_1 = require_tx7();
      var tx_2 = require_tx8();
      var tx_3 = require_tx9();
      var tx_4 = require_tx10();
      exports2.ibcTypes = [
        ["/ibc.applications.transfer.v1.MsgTransfer", tx_1.MsgTransfer],
        ["/ibc.core.channel.v1.MsgAcknowledgement", tx_2.MsgAcknowledgement],
        ["/ibc.core.channel.v1.MsgChannelCloseConfirm", tx_2.MsgChannelCloseConfirm],
        ["/ibc.core.channel.v1.MsgChannelCloseInit", tx_2.MsgChannelCloseInit],
        ["/ibc.core.channel.v1.MsgChannelOpenAck", tx_2.MsgChannelOpenAck],
        ["/ibc.core.channel.v1.MsgChannelOpenConfirm", tx_2.MsgChannelOpenConfirm],
        ["/ibc.core.channel.v1.MsgChannelOpenInit", tx_2.MsgChannelOpenInit],
        ["/ibc.core.channel.v1.MsgChannelOpenTry", tx_2.MsgChannelOpenTry],
        ["/ibc.core.channel.v1.MsgRecvPacket", tx_2.MsgRecvPacket],
        ["/ibc.core.channel.v1.MsgTimeout", tx_2.MsgTimeout],
        ["/ibc.core.channel.v1.MsgTimeoutOnClose", tx_2.MsgTimeoutOnClose],
        ["/ibc.core.client.v1.MsgCreateClient", tx_3.MsgCreateClient],
        ["/ibc.core.client.v1.MsgSubmitMisbehaviour", tx_3.MsgSubmitMisbehaviour],
        ["/ibc.core.client.v1.MsgUpdateClient", tx_3.MsgUpdateClient],
        ["/ibc.core.client.v1.MsgUpgradeClient", tx_3.MsgUpgradeClient],
        ["/ibc.core.connection.v1.MsgConnectionOpenAck", tx_4.MsgConnectionOpenAck],
        ["/ibc.core.connection.v1.MsgConnectionOpenConfirm", tx_4.MsgConnectionOpenConfirm],
        ["/ibc.core.connection.v1.MsgConnectionOpenInit", tx_4.MsgConnectionOpenInit],
        ["/ibc.core.connection.v1.MsgConnectionOpenTry", tx_4.MsgConnectionOpenTry]
      ];
      function isMsgTransferEncodeObject(object) {
        return object.typeUrl === "/ibc.applications.transfer.v1.MsgTransfer";
      }
      exports2.isMsgTransferEncodeObject = isMsgTransferEncodeObject;
    }
  });

  // node_modules/cosmjs-types/ibc/applications/transfer/v1/transfer.js
  var require_transfer = __commonJS({
    "node_modules/cosmjs-types/ibc/applications/transfer/v1/transfer.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.Params = exports2.DenomTrace = exports2.FungibleTokenPacketData = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      exports2.protobufPackage = "ibc.applications.transfer.v1";
      var baseFungibleTokenPacketData = { denom: "", amount: long_1.default.UZERO, sender: "", receiver: "" };
      exports2.FungibleTokenPacketData = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.denom !== "") {
            writer.uint32(10).string(message.denom);
          }
          if (!message.amount.isZero()) {
            writer.uint32(16).uint64(message.amount);
          }
          if (message.sender !== "") {
            writer.uint32(26).string(message.sender);
          }
          if (message.receiver !== "") {
            writer.uint32(34).string(message.receiver);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseFungibleTokenPacketData);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.denom = reader.string();
                break;
              case 2:
                message.amount = reader.uint64();
                break;
              case 3:
                message.sender = reader.string();
                break;
              case 4:
                message.receiver = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseFungibleTokenPacketData);
          message.denom = object.denom !== void 0 && object.denom !== null ? String(object.denom) : "";
          message.amount = object.amount !== void 0 && object.amount !== null ? long_1.default.fromString(object.amount) : long_1.default.UZERO;
          message.sender = object.sender !== void 0 && object.sender !== null ? String(object.sender) : "";
          message.receiver = object.receiver !== void 0 && object.receiver !== null ? String(object.receiver) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.denom !== void 0 && (obj.denom = message.denom);
          message.amount !== void 0 && (obj.amount = (message.amount || long_1.default.UZERO).toString());
          message.sender !== void 0 && (obj.sender = message.sender);
          message.receiver !== void 0 && (obj.receiver = message.receiver);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseFungibleTokenPacketData);
          message.denom = (_a = object.denom) !== null && _a !== void 0 ? _a : "";
          message.amount = object.amount !== void 0 && object.amount !== null ? long_1.default.fromValue(object.amount) : long_1.default.UZERO;
          message.sender = (_b = object.sender) !== null && _b !== void 0 ? _b : "";
          message.receiver = (_c = object.receiver) !== null && _c !== void 0 ? _c : "";
          return message;
        }
      };
      var baseDenomTrace = { path: "", baseDenom: "" };
      exports2.DenomTrace = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.path !== "") {
            writer.uint32(10).string(message.path);
          }
          if (message.baseDenom !== "") {
            writer.uint32(18).string(message.baseDenom);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseDenomTrace);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.path = reader.string();
                break;
              case 2:
                message.baseDenom = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseDenomTrace);
          message.path = object.path !== void 0 && object.path !== null ? String(object.path) : "";
          message.baseDenom = object.baseDenom !== void 0 && object.baseDenom !== null ? String(object.baseDenom) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.path !== void 0 && (obj.path = message.path);
          message.baseDenom !== void 0 && (obj.baseDenom = message.baseDenom);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseDenomTrace);
          message.path = (_a = object.path) !== null && _a !== void 0 ? _a : "";
          message.baseDenom = (_b = object.baseDenom) !== null && _b !== void 0 ? _b : "";
          return message;
        }
      };
      var baseParams = { sendEnabled: false, receiveEnabled: false };
      exports2.Params = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.sendEnabled === true) {
            writer.uint32(8).bool(message.sendEnabled);
          }
          if (message.receiveEnabled === true) {
            writer.uint32(16).bool(message.receiveEnabled);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseParams);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.sendEnabled = reader.bool();
                break;
              case 2:
                message.receiveEnabled = reader.bool();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseParams);
          message.sendEnabled = object.sendEnabled !== void 0 && object.sendEnabled !== null ? Boolean(object.sendEnabled) : false;
          message.receiveEnabled = object.receiveEnabled !== void 0 && object.receiveEnabled !== null ? Boolean(object.receiveEnabled) : false;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.sendEnabled !== void 0 && (obj.sendEnabled = message.sendEnabled);
          message.receiveEnabled !== void 0 && (obj.receiveEnabled = message.receiveEnabled);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseParams);
          message.sendEnabled = (_a = object.sendEnabled) !== null && _a !== void 0 ? _a : false;
          message.receiveEnabled = (_b = object.receiveEnabled) !== null && _b !== void 0 ? _b : false;
          return message;
        }
      };
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/cosmjs-types/ibc/applications/transfer/v1/query.js
  var require_query5 = __commonJS({
    "node_modules/cosmjs-types/ibc/applications/transfer/v1/query.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.QueryClientImpl = exports2.QueryParamsResponse = exports2.QueryParamsRequest = exports2.QueryDenomTracesResponse = exports2.QueryDenomTracesRequest = exports2.QueryDenomTraceResponse = exports2.QueryDenomTraceRequest = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var transfer_1 = require_transfer();
      var pagination_1 = require_pagination();
      exports2.protobufPackage = "ibc.applications.transfer.v1";
      var baseQueryDenomTraceRequest = { hash: "" };
      exports2.QueryDenomTraceRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.hash !== "") {
            writer.uint32(10).string(message.hash);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryDenomTraceRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.hash = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryDenomTraceRequest);
          message.hash = object.hash !== void 0 && object.hash !== null ? String(object.hash) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.hash !== void 0 && (obj.hash = message.hash);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryDenomTraceRequest);
          message.hash = (_a = object.hash) !== null && _a !== void 0 ? _a : "";
          return message;
        }
      };
      var baseQueryDenomTraceResponse = {};
      exports2.QueryDenomTraceResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.denomTrace !== void 0) {
            transfer_1.DenomTrace.encode(message.denomTrace, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryDenomTraceResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.denomTrace = transfer_1.DenomTrace.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryDenomTraceResponse);
          message.denomTrace = object.denomTrace !== void 0 && object.denomTrace !== null ? transfer_1.DenomTrace.fromJSON(object.denomTrace) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.denomTrace !== void 0 && (obj.denomTrace = message.denomTrace ? transfer_1.DenomTrace.toJSON(message.denomTrace) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryDenomTraceResponse);
          message.denomTrace = object.denomTrace !== void 0 && object.denomTrace !== null ? transfer_1.DenomTrace.fromPartial(object.denomTrace) : void 0;
          return message;
        }
      };
      var baseQueryDenomTracesRequest = {};
      exports2.QueryDenomTracesRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.pagination !== void 0) {
            pagination_1.PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryDenomTracesRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.pagination = pagination_1.PageRequest.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryDenomTracesRequest);
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageRequest.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryDenomTracesRequest);
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryDenomTracesResponse = {};
      exports2.QueryDenomTracesResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.denomTraces) {
            transfer_1.DenomTrace.encode(v, writer.uint32(10).fork()).ldelim();
          }
          if (message.pagination !== void 0) {
            pagination_1.PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryDenomTracesResponse);
          message.denomTraces = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.denomTraces.push(transfer_1.DenomTrace.decode(reader, reader.uint32()));
                break;
              case 2:
                message.pagination = pagination_1.PageResponse.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseQueryDenomTracesResponse);
          message.denomTraces = ((_a = object.denomTraces) !== null && _a !== void 0 ? _a : []).map((e) => transfer_1.DenomTrace.fromJSON(e));
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.denomTraces) {
            obj.denomTraces = message.denomTraces.map((e) => e ? transfer_1.DenomTrace.toJSON(e) : void 0);
          } else {
            obj.denomTraces = [];
          }
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageResponse.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryDenomTracesResponse);
          message.denomTraces = ((_a = object.denomTraces) === null || _a === void 0 ? void 0 : _a.map((e) => transfer_1.DenomTrace.fromPartial(e))) || [];
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryParamsRequest = {};
      exports2.QueryParamsRequest = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryParamsRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseQueryParamsRequest);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseQueryParamsRequest);
          return message;
        }
      };
      var baseQueryParamsResponse = {};
      exports2.QueryParamsResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.params !== void 0) {
            transfer_1.Params.encode(message.params, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryParamsResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.params = transfer_1.Params.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryParamsResponse);
          message.params = object.params !== void 0 && object.params !== null ? transfer_1.Params.fromJSON(object.params) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.params !== void 0 && (obj.params = message.params ? transfer_1.Params.toJSON(message.params) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryParamsResponse);
          message.params = object.params !== void 0 && object.params !== null ? transfer_1.Params.fromPartial(object.params) : void 0;
          return message;
        }
      };
      var QueryClientImpl = class {
        constructor(rpc) {
          this.rpc = rpc;
          this.DenomTrace = this.DenomTrace.bind(this);
          this.DenomTraces = this.DenomTraces.bind(this);
          this.Params = this.Params.bind(this);
        }
        DenomTrace(request) {
          const data = exports2.QueryDenomTraceRequest.encode(request).finish();
          const promise = this.rpc.request("ibc.applications.transfer.v1.Query", "DenomTrace", data);
          return promise.then((data2) => exports2.QueryDenomTraceResponse.decode(new minimal_1.default.Reader(data2)));
        }
        DenomTraces(request) {
          const data = exports2.QueryDenomTracesRequest.encode(request).finish();
          const promise = this.rpc.request("ibc.applications.transfer.v1.Query", "DenomTraces", data);
          return promise.then((data2) => exports2.QueryDenomTracesResponse.decode(new minimal_1.default.Reader(data2)));
        }
        Params(request) {
          const data = exports2.QueryParamsRequest.encode(request).finish();
          const promise = this.rpc.request("ibc.applications.transfer.v1.Query", "Params", data);
          return promise.then((data2) => exports2.QueryParamsResponse.decode(new minimal_1.default.Reader(data2)));
        }
      };
      exports2.QueryClientImpl = QueryClientImpl;
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/cosmjs-types/ibc/core/channel/v1/query.js
  var require_query6 = __commonJS({
    "node_modules/cosmjs-types/ibc/core/channel/v1/query.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.QueryClientImpl = exports2.QueryNextSequenceReceiveResponse = exports2.QueryNextSequenceReceiveRequest = exports2.QueryUnreceivedAcksResponse = exports2.QueryUnreceivedAcksRequest = exports2.QueryUnreceivedPacketsResponse = exports2.QueryUnreceivedPacketsRequest = exports2.QueryPacketAcknowledgementsResponse = exports2.QueryPacketAcknowledgementsRequest = exports2.QueryPacketAcknowledgementResponse = exports2.QueryPacketAcknowledgementRequest = exports2.QueryPacketReceiptResponse = exports2.QueryPacketReceiptRequest = exports2.QueryPacketCommitmentsResponse = exports2.QueryPacketCommitmentsRequest = exports2.QueryPacketCommitmentResponse = exports2.QueryPacketCommitmentRequest = exports2.QueryChannelConsensusStateResponse = exports2.QueryChannelConsensusStateRequest = exports2.QueryChannelClientStateResponse = exports2.QueryChannelClientStateRequest = exports2.QueryConnectionChannelsResponse = exports2.QueryConnectionChannelsRequest = exports2.QueryChannelsResponse = exports2.QueryChannelsRequest = exports2.QueryChannelResponse = exports2.QueryChannelRequest = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var channel_1 = require_channel();
      var client_1 = require_client();
      var pagination_1 = require_pagination();
      var any_1 = require_any();
      exports2.protobufPackage = "ibc.core.channel.v1";
      var baseQueryChannelRequest = { portId: "", channelId: "" };
      exports2.QueryChannelRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.portId !== "") {
            writer.uint32(10).string(message.portId);
          }
          if (message.channelId !== "") {
            writer.uint32(18).string(message.channelId);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryChannelRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.portId = reader.string();
                break;
              case 2:
                message.channelId = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryChannelRequest);
          message.portId = object.portId !== void 0 && object.portId !== null ? String(object.portId) : "";
          message.channelId = object.channelId !== void 0 && object.channelId !== null ? String(object.channelId) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.portId !== void 0 && (obj.portId = message.portId);
          message.channelId !== void 0 && (obj.channelId = message.channelId);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseQueryChannelRequest);
          message.portId = (_a = object.portId) !== null && _a !== void 0 ? _a : "";
          message.channelId = (_b = object.channelId) !== null && _b !== void 0 ? _b : "";
          return message;
        }
      };
      var baseQueryChannelResponse = {};
      exports2.QueryChannelResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.channel !== void 0) {
            channel_1.Channel.encode(message.channel, writer.uint32(10).fork()).ldelim();
          }
          if (message.proof.length !== 0) {
            writer.uint32(18).bytes(message.proof);
          }
          if (message.proofHeight !== void 0) {
            client_1.Height.encode(message.proofHeight, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryChannelResponse);
          message.proof = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.channel = channel_1.Channel.decode(reader, reader.uint32());
                break;
              case 2:
                message.proof = reader.bytes();
                break;
              case 3:
                message.proofHeight = client_1.Height.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryChannelResponse);
          message.channel = object.channel !== void 0 && object.channel !== null ? channel_1.Channel.fromJSON(object.channel) : void 0;
          message.proof = object.proof !== void 0 && object.proof !== null ? bytesFromBase64(object.proof) : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromJSON(object.proofHeight) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.channel !== void 0 && (obj.channel = message.channel ? channel_1.Channel.toJSON(message.channel) : void 0);
          message.proof !== void 0 && (obj.proof = base64FromBytes(message.proof !== void 0 ? message.proof : new Uint8Array()));
          message.proofHeight !== void 0 && (obj.proofHeight = message.proofHeight ? client_1.Height.toJSON(message.proofHeight) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryChannelResponse);
          message.channel = object.channel !== void 0 && object.channel !== null ? channel_1.Channel.fromPartial(object.channel) : void 0;
          message.proof = (_a = object.proof) !== null && _a !== void 0 ? _a : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromPartial(object.proofHeight) : void 0;
          return message;
        }
      };
      var baseQueryChannelsRequest = {};
      exports2.QueryChannelsRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.pagination !== void 0) {
            pagination_1.PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryChannelsRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.pagination = pagination_1.PageRequest.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryChannelsRequest);
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageRequest.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryChannelsRequest);
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryChannelsResponse = {};
      exports2.QueryChannelsResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.channels) {
            channel_1.IdentifiedChannel.encode(v, writer.uint32(10).fork()).ldelim();
          }
          if (message.pagination !== void 0) {
            pagination_1.PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
          }
          if (message.height !== void 0) {
            client_1.Height.encode(message.height, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryChannelsResponse);
          message.channels = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.channels.push(channel_1.IdentifiedChannel.decode(reader, reader.uint32()));
                break;
              case 2:
                message.pagination = pagination_1.PageResponse.decode(reader, reader.uint32());
                break;
              case 3:
                message.height = client_1.Height.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseQueryChannelsResponse);
          message.channels = ((_a = object.channels) !== null && _a !== void 0 ? _a : []).map((e) => channel_1.IdentifiedChannel.fromJSON(e));
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromJSON(object.pagination) : void 0;
          message.height = object.height !== void 0 && object.height !== null ? client_1.Height.fromJSON(object.height) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.channels) {
            obj.channels = message.channels.map((e) => e ? channel_1.IdentifiedChannel.toJSON(e) : void 0);
          } else {
            obj.channels = [];
          }
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageResponse.toJSON(message.pagination) : void 0);
          message.height !== void 0 && (obj.height = message.height ? client_1.Height.toJSON(message.height) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryChannelsResponse);
          message.channels = ((_a = object.channels) === null || _a === void 0 ? void 0 : _a.map((e) => channel_1.IdentifiedChannel.fromPartial(e))) || [];
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromPartial(object.pagination) : void 0;
          message.height = object.height !== void 0 && object.height !== null ? client_1.Height.fromPartial(object.height) : void 0;
          return message;
        }
      };
      var baseQueryConnectionChannelsRequest = { connection: "" };
      exports2.QueryConnectionChannelsRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.connection !== "") {
            writer.uint32(10).string(message.connection);
          }
          if (message.pagination !== void 0) {
            pagination_1.PageRequest.encode(message.pagination, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryConnectionChannelsRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.connection = reader.string();
                break;
              case 2:
                message.pagination = pagination_1.PageRequest.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryConnectionChannelsRequest);
          message.connection = object.connection !== void 0 && object.connection !== null ? String(object.connection) : "";
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.connection !== void 0 && (obj.connection = message.connection);
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageRequest.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryConnectionChannelsRequest);
          message.connection = (_a = object.connection) !== null && _a !== void 0 ? _a : "";
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryConnectionChannelsResponse = {};
      exports2.QueryConnectionChannelsResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.channels) {
            channel_1.IdentifiedChannel.encode(v, writer.uint32(10).fork()).ldelim();
          }
          if (message.pagination !== void 0) {
            pagination_1.PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
          }
          if (message.height !== void 0) {
            client_1.Height.encode(message.height, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryConnectionChannelsResponse);
          message.channels = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.channels.push(channel_1.IdentifiedChannel.decode(reader, reader.uint32()));
                break;
              case 2:
                message.pagination = pagination_1.PageResponse.decode(reader, reader.uint32());
                break;
              case 3:
                message.height = client_1.Height.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseQueryConnectionChannelsResponse);
          message.channels = ((_a = object.channels) !== null && _a !== void 0 ? _a : []).map((e) => channel_1.IdentifiedChannel.fromJSON(e));
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromJSON(object.pagination) : void 0;
          message.height = object.height !== void 0 && object.height !== null ? client_1.Height.fromJSON(object.height) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.channels) {
            obj.channels = message.channels.map((e) => e ? channel_1.IdentifiedChannel.toJSON(e) : void 0);
          } else {
            obj.channels = [];
          }
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageResponse.toJSON(message.pagination) : void 0);
          message.height !== void 0 && (obj.height = message.height ? client_1.Height.toJSON(message.height) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryConnectionChannelsResponse);
          message.channels = ((_a = object.channels) === null || _a === void 0 ? void 0 : _a.map((e) => channel_1.IdentifiedChannel.fromPartial(e))) || [];
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromPartial(object.pagination) : void 0;
          message.height = object.height !== void 0 && object.height !== null ? client_1.Height.fromPartial(object.height) : void 0;
          return message;
        }
      };
      var baseQueryChannelClientStateRequest = { portId: "", channelId: "" };
      exports2.QueryChannelClientStateRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.portId !== "") {
            writer.uint32(10).string(message.portId);
          }
          if (message.channelId !== "") {
            writer.uint32(18).string(message.channelId);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryChannelClientStateRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.portId = reader.string();
                break;
              case 2:
                message.channelId = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryChannelClientStateRequest);
          message.portId = object.portId !== void 0 && object.portId !== null ? String(object.portId) : "";
          message.channelId = object.channelId !== void 0 && object.channelId !== null ? String(object.channelId) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.portId !== void 0 && (obj.portId = message.portId);
          message.channelId !== void 0 && (obj.channelId = message.channelId);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseQueryChannelClientStateRequest);
          message.portId = (_a = object.portId) !== null && _a !== void 0 ? _a : "";
          message.channelId = (_b = object.channelId) !== null && _b !== void 0 ? _b : "";
          return message;
        }
      };
      var baseQueryChannelClientStateResponse = {};
      exports2.QueryChannelClientStateResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.identifiedClientState !== void 0) {
            client_1.IdentifiedClientState.encode(message.identifiedClientState, writer.uint32(10).fork()).ldelim();
          }
          if (message.proof.length !== 0) {
            writer.uint32(18).bytes(message.proof);
          }
          if (message.proofHeight !== void 0) {
            client_1.Height.encode(message.proofHeight, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryChannelClientStateResponse);
          message.proof = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.identifiedClientState = client_1.IdentifiedClientState.decode(reader, reader.uint32());
                break;
              case 2:
                message.proof = reader.bytes();
                break;
              case 3:
                message.proofHeight = client_1.Height.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryChannelClientStateResponse);
          message.identifiedClientState = object.identifiedClientState !== void 0 && object.identifiedClientState !== null ? client_1.IdentifiedClientState.fromJSON(object.identifiedClientState) : void 0;
          message.proof = object.proof !== void 0 && object.proof !== null ? bytesFromBase64(object.proof) : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromJSON(object.proofHeight) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.identifiedClientState !== void 0 && (obj.identifiedClientState = message.identifiedClientState ? client_1.IdentifiedClientState.toJSON(message.identifiedClientState) : void 0);
          message.proof !== void 0 && (obj.proof = base64FromBytes(message.proof !== void 0 ? message.proof : new Uint8Array()));
          message.proofHeight !== void 0 && (obj.proofHeight = message.proofHeight ? client_1.Height.toJSON(message.proofHeight) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryChannelClientStateResponse);
          message.identifiedClientState = object.identifiedClientState !== void 0 && object.identifiedClientState !== null ? client_1.IdentifiedClientState.fromPartial(object.identifiedClientState) : void 0;
          message.proof = (_a = object.proof) !== null && _a !== void 0 ? _a : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromPartial(object.proofHeight) : void 0;
          return message;
        }
      };
      var baseQueryChannelConsensusStateRequest = {
        portId: "",
        channelId: "",
        revisionNumber: long_1.default.UZERO,
        revisionHeight: long_1.default.UZERO
      };
      exports2.QueryChannelConsensusStateRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.portId !== "") {
            writer.uint32(10).string(message.portId);
          }
          if (message.channelId !== "") {
            writer.uint32(18).string(message.channelId);
          }
          if (!message.revisionNumber.isZero()) {
            writer.uint32(24).uint64(message.revisionNumber);
          }
          if (!message.revisionHeight.isZero()) {
            writer.uint32(32).uint64(message.revisionHeight);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryChannelConsensusStateRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.portId = reader.string();
                break;
              case 2:
                message.channelId = reader.string();
                break;
              case 3:
                message.revisionNumber = reader.uint64();
                break;
              case 4:
                message.revisionHeight = reader.uint64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryChannelConsensusStateRequest);
          message.portId = object.portId !== void 0 && object.portId !== null ? String(object.portId) : "";
          message.channelId = object.channelId !== void 0 && object.channelId !== null ? String(object.channelId) : "";
          message.revisionNumber = object.revisionNumber !== void 0 && object.revisionNumber !== null ? long_1.default.fromString(object.revisionNumber) : long_1.default.UZERO;
          message.revisionHeight = object.revisionHeight !== void 0 && object.revisionHeight !== null ? long_1.default.fromString(object.revisionHeight) : long_1.default.UZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.portId !== void 0 && (obj.portId = message.portId);
          message.channelId !== void 0 && (obj.channelId = message.channelId);
          message.revisionNumber !== void 0 && (obj.revisionNumber = (message.revisionNumber || long_1.default.UZERO).toString());
          message.revisionHeight !== void 0 && (obj.revisionHeight = (message.revisionHeight || long_1.default.UZERO).toString());
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseQueryChannelConsensusStateRequest);
          message.portId = (_a = object.portId) !== null && _a !== void 0 ? _a : "";
          message.channelId = (_b = object.channelId) !== null && _b !== void 0 ? _b : "";
          message.revisionNumber = object.revisionNumber !== void 0 && object.revisionNumber !== null ? long_1.default.fromValue(object.revisionNumber) : long_1.default.UZERO;
          message.revisionHeight = object.revisionHeight !== void 0 && object.revisionHeight !== null ? long_1.default.fromValue(object.revisionHeight) : long_1.default.UZERO;
          return message;
        }
      };
      var baseQueryChannelConsensusStateResponse = { clientId: "" };
      exports2.QueryChannelConsensusStateResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.consensusState !== void 0) {
            any_1.Any.encode(message.consensusState, writer.uint32(10).fork()).ldelim();
          }
          if (message.clientId !== "") {
            writer.uint32(18).string(message.clientId);
          }
          if (message.proof.length !== 0) {
            writer.uint32(26).bytes(message.proof);
          }
          if (message.proofHeight !== void 0) {
            client_1.Height.encode(message.proofHeight, writer.uint32(34).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryChannelConsensusStateResponse);
          message.proof = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.consensusState = any_1.Any.decode(reader, reader.uint32());
                break;
              case 2:
                message.clientId = reader.string();
                break;
              case 3:
                message.proof = reader.bytes();
                break;
              case 4:
                message.proofHeight = client_1.Height.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryChannelConsensusStateResponse);
          message.consensusState = object.consensusState !== void 0 && object.consensusState !== null ? any_1.Any.fromJSON(object.consensusState) : void 0;
          message.clientId = object.clientId !== void 0 && object.clientId !== null ? String(object.clientId) : "";
          message.proof = object.proof !== void 0 && object.proof !== null ? bytesFromBase64(object.proof) : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromJSON(object.proofHeight) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.consensusState !== void 0 && (obj.consensusState = message.consensusState ? any_1.Any.toJSON(message.consensusState) : void 0);
          message.clientId !== void 0 && (obj.clientId = message.clientId);
          message.proof !== void 0 && (obj.proof = base64FromBytes(message.proof !== void 0 ? message.proof : new Uint8Array()));
          message.proofHeight !== void 0 && (obj.proofHeight = message.proofHeight ? client_1.Height.toJSON(message.proofHeight) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseQueryChannelConsensusStateResponse);
          message.consensusState = object.consensusState !== void 0 && object.consensusState !== null ? any_1.Any.fromPartial(object.consensusState) : void 0;
          message.clientId = (_a = object.clientId) !== null && _a !== void 0 ? _a : "";
          message.proof = (_b = object.proof) !== null && _b !== void 0 ? _b : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromPartial(object.proofHeight) : void 0;
          return message;
        }
      };
      var baseQueryPacketCommitmentRequest = { portId: "", channelId: "", sequence: long_1.default.UZERO };
      exports2.QueryPacketCommitmentRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.portId !== "") {
            writer.uint32(10).string(message.portId);
          }
          if (message.channelId !== "") {
            writer.uint32(18).string(message.channelId);
          }
          if (!message.sequence.isZero()) {
            writer.uint32(24).uint64(message.sequence);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryPacketCommitmentRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.portId = reader.string();
                break;
              case 2:
                message.channelId = reader.string();
                break;
              case 3:
                message.sequence = reader.uint64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryPacketCommitmentRequest);
          message.portId = object.portId !== void 0 && object.portId !== null ? String(object.portId) : "";
          message.channelId = object.channelId !== void 0 && object.channelId !== null ? String(object.channelId) : "";
          message.sequence = object.sequence !== void 0 && object.sequence !== null ? long_1.default.fromString(object.sequence) : long_1.default.UZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.portId !== void 0 && (obj.portId = message.portId);
          message.channelId !== void 0 && (obj.channelId = message.channelId);
          message.sequence !== void 0 && (obj.sequence = (message.sequence || long_1.default.UZERO).toString());
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseQueryPacketCommitmentRequest);
          message.portId = (_a = object.portId) !== null && _a !== void 0 ? _a : "";
          message.channelId = (_b = object.channelId) !== null && _b !== void 0 ? _b : "";
          message.sequence = object.sequence !== void 0 && object.sequence !== null ? long_1.default.fromValue(object.sequence) : long_1.default.UZERO;
          return message;
        }
      };
      var baseQueryPacketCommitmentResponse = {};
      exports2.QueryPacketCommitmentResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.commitment.length !== 0) {
            writer.uint32(10).bytes(message.commitment);
          }
          if (message.proof.length !== 0) {
            writer.uint32(18).bytes(message.proof);
          }
          if (message.proofHeight !== void 0) {
            client_1.Height.encode(message.proofHeight, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryPacketCommitmentResponse);
          message.commitment = new Uint8Array();
          message.proof = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.commitment = reader.bytes();
                break;
              case 2:
                message.proof = reader.bytes();
                break;
              case 3:
                message.proofHeight = client_1.Height.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryPacketCommitmentResponse);
          message.commitment = object.commitment !== void 0 && object.commitment !== null ? bytesFromBase64(object.commitment) : new Uint8Array();
          message.proof = object.proof !== void 0 && object.proof !== null ? bytesFromBase64(object.proof) : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromJSON(object.proofHeight) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.commitment !== void 0 && (obj.commitment = base64FromBytes(message.commitment !== void 0 ? message.commitment : new Uint8Array()));
          message.proof !== void 0 && (obj.proof = base64FromBytes(message.proof !== void 0 ? message.proof : new Uint8Array()));
          message.proofHeight !== void 0 && (obj.proofHeight = message.proofHeight ? client_1.Height.toJSON(message.proofHeight) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseQueryPacketCommitmentResponse);
          message.commitment = (_a = object.commitment) !== null && _a !== void 0 ? _a : new Uint8Array();
          message.proof = (_b = object.proof) !== null && _b !== void 0 ? _b : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromPartial(object.proofHeight) : void 0;
          return message;
        }
      };
      var baseQueryPacketCommitmentsRequest = { portId: "", channelId: "" };
      exports2.QueryPacketCommitmentsRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.portId !== "") {
            writer.uint32(10).string(message.portId);
          }
          if (message.channelId !== "") {
            writer.uint32(18).string(message.channelId);
          }
          if (message.pagination !== void 0) {
            pagination_1.PageRequest.encode(message.pagination, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryPacketCommitmentsRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.portId = reader.string();
                break;
              case 2:
                message.channelId = reader.string();
                break;
              case 3:
                message.pagination = pagination_1.PageRequest.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryPacketCommitmentsRequest);
          message.portId = object.portId !== void 0 && object.portId !== null ? String(object.portId) : "";
          message.channelId = object.channelId !== void 0 && object.channelId !== null ? String(object.channelId) : "";
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.portId !== void 0 && (obj.portId = message.portId);
          message.channelId !== void 0 && (obj.channelId = message.channelId);
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageRequest.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseQueryPacketCommitmentsRequest);
          message.portId = (_a = object.portId) !== null && _a !== void 0 ? _a : "";
          message.channelId = (_b = object.channelId) !== null && _b !== void 0 ? _b : "";
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryPacketCommitmentsResponse = {};
      exports2.QueryPacketCommitmentsResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.commitments) {
            channel_1.PacketState.encode(v, writer.uint32(10).fork()).ldelim();
          }
          if (message.pagination !== void 0) {
            pagination_1.PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
          }
          if (message.height !== void 0) {
            client_1.Height.encode(message.height, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryPacketCommitmentsResponse);
          message.commitments = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.commitments.push(channel_1.PacketState.decode(reader, reader.uint32()));
                break;
              case 2:
                message.pagination = pagination_1.PageResponse.decode(reader, reader.uint32());
                break;
              case 3:
                message.height = client_1.Height.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseQueryPacketCommitmentsResponse);
          message.commitments = ((_a = object.commitments) !== null && _a !== void 0 ? _a : []).map((e) => channel_1.PacketState.fromJSON(e));
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromJSON(object.pagination) : void 0;
          message.height = object.height !== void 0 && object.height !== null ? client_1.Height.fromJSON(object.height) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.commitments) {
            obj.commitments = message.commitments.map((e) => e ? channel_1.PacketState.toJSON(e) : void 0);
          } else {
            obj.commitments = [];
          }
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageResponse.toJSON(message.pagination) : void 0);
          message.height !== void 0 && (obj.height = message.height ? client_1.Height.toJSON(message.height) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryPacketCommitmentsResponse);
          message.commitments = ((_a = object.commitments) === null || _a === void 0 ? void 0 : _a.map((e) => channel_1.PacketState.fromPartial(e))) || [];
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromPartial(object.pagination) : void 0;
          message.height = object.height !== void 0 && object.height !== null ? client_1.Height.fromPartial(object.height) : void 0;
          return message;
        }
      };
      var baseQueryPacketReceiptRequest = { portId: "", channelId: "", sequence: long_1.default.UZERO };
      exports2.QueryPacketReceiptRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.portId !== "") {
            writer.uint32(10).string(message.portId);
          }
          if (message.channelId !== "") {
            writer.uint32(18).string(message.channelId);
          }
          if (!message.sequence.isZero()) {
            writer.uint32(24).uint64(message.sequence);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryPacketReceiptRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.portId = reader.string();
                break;
              case 2:
                message.channelId = reader.string();
                break;
              case 3:
                message.sequence = reader.uint64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryPacketReceiptRequest);
          message.portId = object.portId !== void 0 && object.portId !== null ? String(object.portId) : "";
          message.channelId = object.channelId !== void 0 && object.channelId !== null ? String(object.channelId) : "";
          message.sequence = object.sequence !== void 0 && object.sequence !== null ? long_1.default.fromString(object.sequence) : long_1.default.UZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.portId !== void 0 && (obj.portId = message.portId);
          message.channelId !== void 0 && (obj.channelId = message.channelId);
          message.sequence !== void 0 && (obj.sequence = (message.sequence || long_1.default.UZERO).toString());
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseQueryPacketReceiptRequest);
          message.portId = (_a = object.portId) !== null && _a !== void 0 ? _a : "";
          message.channelId = (_b = object.channelId) !== null && _b !== void 0 ? _b : "";
          message.sequence = object.sequence !== void 0 && object.sequence !== null ? long_1.default.fromValue(object.sequence) : long_1.default.UZERO;
          return message;
        }
      };
      var baseQueryPacketReceiptResponse = { received: false };
      exports2.QueryPacketReceiptResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.received === true) {
            writer.uint32(16).bool(message.received);
          }
          if (message.proof.length !== 0) {
            writer.uint32(26).bytes(message.proof);
          }
          if (message.proofHeight !== void 0) {
            client_1.Height.encode(message.proofHeight, writer.uint32(34).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryPacketReceiptResponse);
          message.proof = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 2:
                message.received = reader.bool();
                break;
              case 3:
                message.proof = reader.bytes();
                break;
              case 4:
                message.proofHeight = client_1.Height.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryPacketReceiptResponse);
          message.received = object.received !== void 0 && object.received !== null ? Boolean(object.received) : false;
          message.proof = object.proof !== void 0 && object.proof !== null ? bytesFromBase64(object.proof) : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromJSON(object.proofHeight) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.received !== void 0 && (obj.received = message.received);
          message.proof !== void 0 && (obj.proof = base64FromBytes(message.proof !== void 0 ? message.proof : new Uint8Array()));
          message.proofHeight !== void 0 && (obj.proofHeight = message.proofHeight ? client_1.Height.toJSON(message.proofHeight) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseQueryPacketReceiptResponse);
          message.received = (_a = object.received) !== null && _a !== void 0 ? _a : false;
          message.proof = (_b = object.proof) !== null && _b !== void 0 ? _b : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromPartial(object.proofHeight) : void 0;
          return message;
        }
      };
      var baseQueryPacketAcknowledgementRequest = { portId: "", channelId: "", sequence: long_1.default.UZERO };
      exports2.QueryPacketAcknowledgementRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.portId !== "") {
            writer.uint32(10).string(message.portId);
          }
          if (message.channelId !== "") {
            writer.uint32(18).string(message.channelId);
          }
          if (!message.sequence.isZero()) {
            writer.uint32(24).uint64(message.sequence);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryPacketAcknowledgementRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.portId = reader.string();
                break;
              case 2:
                message.channelId = reader.string();
                break;
              case 3:
                message.sequence = reader.uint64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryPacketAcknowledgementRequest);
          message.portId = object.portId !== void 0 && object.portId !== null ? String(object.portId) : "";
          message.channelId = object.channelId !== void 0 && object.channelId !== null ? String(object.channelId) : "";
          message.sequence = object.sequence !== void 0 && object.sequence !== null ? long_1.default.fromString(object.sequence) : long_1.default.UZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.portId !== void 0 && (obj.portId = message.portId);
          message.channelId !== void 0 && (obj.channelId = message.channelId);
          message.sequence !== void 0 && (obj.sequence = (message.sequence || long_1.default.UZERO).toString());
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseQueryPacketAcknowledgementRequest);
          message.portId = (_a = object.portId) !== null && _a !== void 0 ? _a : "";
          message.channelId = (_b = object.channelId) !== null && _b !== void 0 ? _b : "";
          message.sequence = object.sequence !== void 0 && object.sequence !== null ? long_1.default.fromValue(object.sequence) : long_1.default.UZERO;
          return message;
        }
      };
      var baseQueryPacketAcknowledgementResponse = {};
      exports2.QueryPacketAcknowledgementResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.acknowledgement.length !== 0) {
            writer.uint32(10).bytes(message.acknowledgement);
          }
          if (message.proof.length !== 0) {
            writer.uint32(18).bytes(message.proof);
          }
          if (message.proofHeight !== void 0) {
            client_1.Height.encode(message.proofHeight, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryPacketAcknowledgementResponse);
          message.acknowledgement = new Uint8Array();
          message.proof = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.acknowledgement = reader.bytes();
                break;
              case 2:
                message.proof = reader.bytes();
                break;
              case 3:
                message.proofHeight = client_1.Height.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryPacketAcknowledgementResponse);
          message.acknowledgement = object.acknowledgement !== void 0 && object.acknowledgement !== null ? bytesFromBase64(object.acknowledgement) : new Uint8Array();
          message.proof = object.proof !== void 0 && object.proof !== null ? bytesFromBase64(object.proof) : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromJSON(object.proofHeight) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.acknowledgement !== void 0 && (obj.acknowledgement = base64FromBytes(message.acknowledgement !== void 0 ? message.acknowledgement : new Uint8Array()));
          message.proof !== void 0 && (obj.proof = base64FromBytes(message.proof !== void 0 ? message.proof : new Uint8Array()));
          message.proofHeight !== void 0 && (obj.proofHeight = message.proofHeight ? client_1.Height.toJSON(message.proofHeight) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseQueryPacketAcknowledgementResponse);
          message.acknowledgement = (_a = object.acknowledgement) !== null && _a !== void 0 ? _a : new Uint8Array();
          message.proof = (_b = object.proof) !== null && _b !== void 0 ? _b : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromPartial(object.proofHeight) : void 0;
          return message;
        }
      };
      var baseQueryPacketAcknowledgementsRequest = { portId: "", channelId: "" };
      exports2.QueryPacketAcknowledgementsRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.portId !== "") {
            writer.uint32(10).string(message.portId);
          }
          if (message.channelId !== "") {
            writer.uint32(18).string(message.channelId);
          }
          if (message.pagination !== void 0) {
            pagination_1.PageRequest.encode(message.pagination, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryPacketAcknowledgementsRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.portId = reader.string();
                break;
              case 2:
                message.channelId = reader.string();
                break;
              case 3:
                message.pagination = pagination_1.PageRequest.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryPacketAcknowledgementsRequest);
          message.portId = object.portId !== void 0 && object.portId !== null ? String(object.portId) : "";
          message.channelId = object.channelId !== void 0 && object.channelId !== null ? String(object.channelId) : "";
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.portId !== void 0 && (obj.portId = message.portId);
          message.channelId !== void 0 && (obj.channelId = message.channelId);
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageRequest.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseQueryPacketAcknowledgementsRequest);
          message.portId = (_a = object.portId) !== null && _a !== void 0 ? _a : "";
          message.channelId = (_b = object.channelId) !== null && _b !== void 0 ? _b : "";
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryPacketAcknowledgementsResponse = {};
      exports2.QueryPacketAcknowledgementsResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.acknowledgements) {
            channel_1.PacketState.encode(v, writer.uint32(10).fork()).ldelim();
          }
          if (message.pagination !== void 0) {
            pagination_1.PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
          }
          if (message.height !== void 0) {
            client_1.Height.encode(message.height, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryPacketAcknowledgementsResponse);
          message.acknowledgements = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.acknowledgements.push(channel_1.PacketState.decode(reader, reader.uint32()));
                break;
              case 2:
                message.pagination = pagination_1.PageResponse.decode(reader, reader.uint32());
                break;
              case 3:
                message.height = client_1.Height.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseQueryPacketAcknowledgementsResponse);
          message.acknowledgements = ((_a = object.acknowledgements) !== null && _a !== void 0 ? _a : []).map((e) => channel_1.PacketState.fromJSON(e));
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromJSON(object.pagination) : void 0;
          message.height = object.height !== void 0 && object.height !== null ? client_1.Height.fromJSON(object.height) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.acknowledgements) {
            obj.acknowledgements = message.acknowledgements.map((e) => e ? channel_1.PacketState.toJSON(e) : void 0);
          } else {
            obj.acknowledgements = [];
          }
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageResponse.toJSON(message.pagination) : void 0);
          message.height !== void 0 && (obj.height = message.height ? client_1.Height.toJSON(message.height) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryPacketAcknowledgementsResponse);
          message.acknowledgements = ((_a = object.acknowledgements) === null || _a === void 0 ? void 0 : _a.map((e) => channel_1.PacketState.fromPartial(e))) || [];
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromPartial(object.pagination) : void 0;
          message.height = object.height !== void 0 && object.height !== null ? client_1.Height.fromPartial(object.height) : void 0;
          return message;
        }
      };
      var baseQueryUnreceivedPacketsRequest = {
        portId: "",
        channelId: "",
        packetCommitmentSequences: long_1.default.UZERO
      };
      exports2.QueryUnreceivedPacketsRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.portId !== "") {
            writer.uint32(10).string(message.portId);
          }
          if (message.channelId !== "") {
            writer.uint32(18).string(message.channelId);
          }
          writer.uint32(26).fork();
          for (const v of message.packetCommitmentSequences) {
            writer.uint64(v);
          }
          writer.ldelim();
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryUnreceivedPacketsRequest);
          message.packetCommitmentSequences = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.portId = reader.string();
                break;
              case 2:
                message.channelId = reader.string();
                break;
              case 3:
                if ((tag & 7) === 2) {
                  const end2 = reader.uint32() + reader.pos;
                  while (reader.pos < end2) {
                    message.packetCommitmentSequences.push(reader.uint64());
                  }
                } else {
                  message.packetCommitmentSequences.push(reader.uint64());
                }
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseQueryUnreceivedPacketsRequest);
          message.portId = object.portId !== void 0 && object.portId !== null ? String(object.portId) : "";
          message.channelId = object.channelId !== void 0 && object.channelId !== null ? String(object.channelId) : "";
          message.packetCommitmentSequences = ((_a = object.packetCommitmentSequences) !== null && _a !== void 0 ? _a : []).map((e) => long_1.default.fromString(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.portId !== void 0 && (obj.portId = message.portId);
          message.channelId !== void 0 && (obj.channelId = message.channelId);
          if (message.packetCommitmentSequences) {
            obj.packetCommitmentSequences = message.packetCommitmentSequences.map((e) => (e || long_1.default.UZERO).toString());
          } else {
            obj.packetCommitmentSequences = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseQueryUnreceivedPacketsRequest);
          message.portId = (_a = object.portId) !== null && _a !== void 0 ? _a : "";
          message.channelId = (_b = object.channelId) !== null && _b !== void 0 ? _b : "";
          message.packetCommitmentSequences = ((_c = object.packetCommitmentSequences) === null || _c === void 0 ? void 0 : _c.map((e) => long_1.default.fromValue(e))) || [];
          return message;
        }
      };
      var baseQueryUnreceivedPacketsResponse = { sequences: long_1.default.UZERO };
      exports2.QueryUnreceivedPacketsResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          writer.uint32(10).fork();
          for (const v of message.sequences) {
            writer.uint64(v);
          }
          writer.ldelim();
          if (message.height !== void 0) {
            client_1.Height.encode(message.height, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryUnreceivedPacketsResponse);
          message.sequences = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                if ((tag & 7) === 2) {
                  const end2 = reader.uint32() + reader.pos;
                  while (reader.pos < end2) {
                    message.sequences.push(reader.uint64());
                  }
                } else {
                  message.sequences.push(reader.uint64());
                }
                break;
              case 2:
                message.height = client_1.Height.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseQueryUnreceivedPacketsResponse);
          message.sequences = ((_a = object.sequences) !== null && _a !== void 0 ? _a : []).map((e) => long_1.default.fromString(e));
          message.height = object.height !== void 0 && object.height !== null ? client_1.Height.fromJSON(object.height) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.sequences) {
            obj.sequences = message.sequences.map((e) => (e || long_1.default.UZERO).toString());
          } else {
            obj.sequences = [];
          }
          message.height !== void 0 && (obj.height = message.height ? client_1.Height.toJSON(message.height) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryUnreceivedPacketsResponse);
          message.sequences = ((_a = object.sequences) === null || _a === void 0 ? void 0 : _a.map((e) => long_1.default.fromValue(e))) || [];
          message.height = object.height !== void 0 && object.height !== null ? client_1.Height.fromPartial(object.height) : void 0;
          return message;
        }
      };
      var baseQueryUnreceivedAcksRequest = { portId: "", channelId: "", packetAckSequences: long_1.default.UZERO };
      exports2.QueryUnreceivedAcksRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.portId !== "") {
            writer.uint32(10).string(message.portId);
          }
          if (message.channelId !== "") {
            writer.uint32(18).string(message.channelId);
          }
          writer.uint32(26).fork();
          for (const v of message.packetAckSequences) {
            writer.uint64(v);
          }
          writer.ldelim();
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryUnreceivedAcksRequest);
          message.packetAckSequences = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.portId = reader.string();
                break;
              case 2:
                message.channelId = reader.string();
                break;
              case 3:
                if ((tag & 7) === 2) {
                  const end2 = reader.uint32() + reader.pos;
                  while (reader.pos < end2) {
                    message.packetAckSequences.push(reader.uint64());
                  }
                } else {
                  message.packetAckSequences.push(reader.uint64());
                }
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseQueryUnreceivedAcksRequest);
          message.portId = object.portId !== void 0 && object.portId !== null ? String(object.portId) : "";
          message.channelId = object.channelId !== void 0 && object.channelId !== null ? String(object.channelId) : "";
          message.packetAckSequences = ((_a = object.packetAckSequences) !== null && _a !== void 0 ? _a : []).map((e) => long_1.default.fromString(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.portId !== void 0 && (obj.portId = message.portId);
          message.channelId !== void 0 && (obj.channelId = message.channelId);
          if (message.packetAckSequences) {
            obj.packetAckSequences = message.packetAckSequences.map((e) => (e || long_1.default.UZERO).toString());
          } else {
            obj.packetAckSequences = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseQueryUnreceivedAcksRequest);
          message.portId = (_a = object.portId) !== null && _a !== void 0 ? _a : "";
          message.channelId = (_b = object.channelId) !== null && _b !== void 0 ? _b : "";
          message.packetAckSequences = ((_c = object.packetAckSequences) === null || _c === void 0 ? void 0 : _c.map((e) => long_1.default.fromValue(e))) || [];
          return message;
        }
      };
      var baseQueryUnreceivedAcksResponse = { sequences: long_1.default.UZERO };
      exports2.QueryUnreceivedAcksResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          writer.uint32(10).fork();
          for (const v of message.sequences) {
            writer.uint64(v);
          }
          writer.ldelim();
          if (message.height !== void 0) {
            client_1.Height.encode(message.height, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryUnreceivedAcksResponse);
          message.sequences = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                if ((tag & 7) === 2) {
                  const end2 = reader.uint32() + reader.pos;
                  while (reader.pos < end2) {
                    message.sequences.push(reader.uint64());
                  }
                } else {
                  message.sequences.push(reader.uint64());
                }
                break;
              case 2:
                message.height = client_1.Height.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseQueryUnreceivedAcksResponse);
          message.sequences = ((_a = object.sequences) !== null && _a !== void 0 ? _a : []).map((e) => long_1.default.fromString(e));
          message.height = object.height !== void 0 && object.height !== null ? client_1.Height.fromJSON(object.height) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.sequences) {
            obj.sequences = message.sequences.map((e) => (e || long_1.default.UZERO).toString());
          } else {
            obj.sequences = [];
          }
          message.height !== void 0 && (obj.height = message.height ? client_1.Height.toJSON(message.height) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryUnreceivedAcksResponse);
          message.sequences = ((_a = object.sequences) === null || _a === void 0 ? void 0 : _a.map((e) => long_1.default.fromValue(e))) || [];
          message.height = object.height !== void 0 && object.height !== null ? client_1.Height.fromPartial(object.height) : void 0;
          return message;
        }
      };
      var baseQueryNextSequenceReceiveRequest = { portId: "", channelId: "" };
      exports2.QueryNextSequenceReceiveRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.portId !== "") {
            writer.uint32(10).string(message.portId);
          }
          if (message.channelId !== "") {
            writer.uint32(18).string(message.channelId);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryNextSequenceReceiveRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.portId = reader.string();
                break;
              case 2:
                message.channelId = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryNextSequenceReceiveRequest);
          message.portId = object.portId !== void 0 && object.portId !== null ? String(object.portId) : "";
          message.channelId = object.channelId !== void 0 && object.channelId !== null ? String(object.channelId) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.portId !== void 0 && (obj.portId = message.portId);
          message.channelId !== void 0 && (obj.channelId = message.channelId);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseQueryNextSequenceReceiveRequest);
          message.portId = (_a = object.portId) !== null && _a !== void 0 ? _a : "";
          message.channelId = (_b = object.channelId) !== null && _b !== void 0 ? _b : "";
          return message;
        }
      };
      var baseQueryNextSequenceReceiveResponse = { nextSequenceReceive: long_1.default.UZERO };
      exports2.QueryNextSequenceReceiveResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.nextSequenceReceive.isZero()) {
            writer.uint32(8).uint64(message.nextSequenceReceive);
          }
          if (message.proof.length !== 0) {
            writer.uint32(18).bytes(message.proof);
          }
          if (message.proofHeight !== void 0) {
            client_1.Height.encode(message.proofHeight, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryNextSequenceReceiveResponse);
          message.proof = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.nextSequenceReceive = reader.uint64();
                break;
              case 2:
                message.proof = reader.bytes();
                break;
              case 3:
                message.proofHeight = client_1.Height.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryNextSequenceReceiveResponse);
          message.nextSequenceReceive = object.nextSequenceReceive !== void 0 && object.nextSequenceReceive !== null ? long_1.default.fromString(object.nextSequenceReceive) : long_1.default.UZERO;
          message.proof = object.proof !== void 0 && object.proof !== null ? bytesFromBase64(object.proof) : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromJSON(object.proofHeight) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.nextSequenceReceive !== void 0 && (obj.nextSequenceReceive = (message.nextSequenceReceive || long_1.default.UZERO).toString());
          message.proof !== void 0 && (obj.proof = base64FromBytes(message.proof !== void 0 ? message.proof : new Uint8Array()));
          message.proofHeight !== void 0 && (obj.proofHeight = message.proofHeight ? client_1.Height.toJSON(message.proofHeight) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryNextSequenceReceiveResponse);
          message.nextSequenceReceive = object.nextSequenceReceive !== void 0 && object.nextSequenceReceive !== null ? long_1.default.fromValue(object.nextSequenceReceive) : long_1.default.UZERO;
          message.proof = (_a = object.proof) !== null && _a !== void 0 ? _a : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromPartial(object.proofHeight) : void 0;
          return message;
        }
      };
      var QueryClientImpl = class {
        constructor(rpc) {
          this.rpc = rpc;
          this.Channel = this.Channel.bind(this);
          this.Channels = this.Channels.bind(this);
          this.ConnectionChannels = this.ConnectionChannels.bind(this);
          this.ChannelClientState = this.ChannelClientState.bind(this);
          this.ChannelConsensusState = this.ChannelConsensusState.bind(this);
          this.PacketCommitment = this.PacketCommitment.bind(this);
          this.PacketCommitments = this.PacketCommitments.bind(this);
          this.PacketReceipt = this.PacketReceipt.bind(this);
          this.PacketAcknowledgement = this.PacketAcknowledgement.bind(this);
          this.PacketAcknowledgements = this.PacketAcknowledgements.bind(this);
          this.UnreceivedPackets = this.UnreceivedPackets.bind(this);
          this.UnreceivedAcks = this.UnreceivedAcks.bind(this);
          this.NextSequenceReceive = this.NextSequenceReceive.bind(this);
        }
        Channel(request) {
          const data = exports2.QueryChannelRequest.encode(request).finish();
          const promise = this.rpc.request("ibc.core.channel.v1.Query", "Channel", data);
          return promise.then((data2) => exports2.QueryChannelResponse.decode(new minimal_1.default.Reader(data2)));
        }
        Channels(request) {
          const data = exports2.QueryChannelsRequest.encode(request).finish();
          const promise = this.rpc.request("ibc.core.channel.v1.Query", "Channels", data);
          return promise.then((data2) => exports2.QueryChannelsResponse.decode(new minimal_1.default.Reader(data2)));
        }
        ConnectionChannels(request) {
          const data = exports2.QueryConnectionChannelsRequest.encode(request).finish();
          const promise = this.rpc.request("ibc.core.channel.v1.Query", "ConnectionChannels", data);
          return promise.then((data2) => exports2.QueryConnectionChannelsResponse.decode(new minimal_1.default.Reader(data2)));
        }
        ChannelClientState(request) {
          const data = exports2.QueryChannelClientStateRequest.encode(request).finish();
          const promise = this.rpc.request("ibc.core.channel.v1.Query", "ChannelClientState", data);
          return promise.then((data2) => exports2.QueryChannelClientStateResponse.decode(new minimal_1.default.Reader(data2)));
        }
        ChannelConsensusState(request) {
          const data = exports2.QueryChannelConsensusStateRequest.encode(request).finish();
          const promise = this.rpc.request("ibc.core.channel.v1.Query", "ChannelConsensusState", data);
          return promise.then((data2) => exports2.QueryChannelConsensusStateResponse.decode(new minimal_1.default.Reader(data2)));
        }
        PacketCommitment(request) {
          const data = exports2.QueryPacketCommitmentRequest.encode(request).finish();
          const promise = this.rpc.request("ibc.core.channel.v1.Query", "PacketCommitment", data);
          return promise.then((data2) => exports2.QueryPacketCommitmentResponse.decode(new minimal_1.default.Reader(data2)));
        }
        PacketCommitments(request) {
          const data = exports2.QueryPacketCommitmentsRequest.encode(request).finish();
          const promise = this.rpc.request("ibc.core.channel.v1.Query", "PacketCommitments", data);
          return promise.then((data2) => exports2.QueryPacketCommitmentsResponse.decode(new minimal_1.default.Reader(data2)));
        }
        PacketReceipt(request) {
          const data = exports2.QueryPacketReceiptRequest.encode(request).finish();
          const promise = this.rpc.request("ibc.core.channel.v1.Query", "PacketReceipt", data);
          return promise.then((data2) => exports2.QueryPacketReceiptResponse.decode(new minimal_1.default.Reader(data2)));
        }
        PacketAcknowledgement(request) {
          const data = exports2.QueryPacketAcknowledgementRequest.encode(request).finish();
          const promise = this.rpc.request("ibc.core.channel.v1.Query", "PacketAcknowledgement", data);
          return promise.then((data2) => exports2.QueryPacketAcknowledgementResponse.decode(new minimal_1.default.Reader(data2)));
        }
        PacketAcknowledgements(request) {
          const data = exports2.QueryPacketAcknowledgementsRequest.encode(request).finish();
          const promise = this.rpc.request("ibc.core.channel.v1.Query", "PacketAcknowledgements", data);
          return promise.then((data2) => exports2.QueryPacketAcknowledgementsResponse.decode(new minimal_1.default.Reader(data2)));
        }
        UnreceivedPackets(request) {
          const data = exports2.QueryUnreceivedPacketsRequest.encode(request).finish();
          const promise = this.rpc.request("ibc.core.channel.v1.Query", "UnreceivedPackets", data);
          return promise.then((data2) => exports2.QueryUnreceivedPacketsResponse.decode(new minimal_1.default.Reader(data2)));
        }
        UnreceivedAcks(request) {
          const data = exports2.QueryUnreceivedAcksRequest.encode(request).finish();
          const promise = this.rpc.request("ibc.core.channel.v1.Query", "UnreceivedAcks", data);
          return promise.then((data2) => exports2.QueryUnreceivedAcksResponse.decode(new minimal_1.default.Reader(data2)));
        }
        NextSequenceReceive(request) {
          const data = exports2.QueryNextSequenceReceiveRequest.encode(request).finish();
          const promise = this.rpc.request("ibc.core.channel.v1.Query", "NextSequenceReceive", data);
          return promise.then((data2) => exports2.QueryNextSequenceReceiveResponse.decode(new minimal_1.default.Reader(data2)));
        }
      };
      exports2.QueryClientImpl = QueryClientImpl;
      var globalThis2 = (() => {
        if (typeof globalThis2 !== "undefined")
          return globalThis2;
        if (typeof self !== "undefined")
          return self;
        if (typeof window !== "undefined")
          return window;
        if (typeof global !== "undefined")
          return global;
        throw "Unable to locate global object";
      })();
      var atob2 = globalThis2.atob || ((b64) => globalThis2.Buffer.from(b64, "base64").toString("binary"));
      function bytesFromBase64(b64) {
        const bin = atob2(b64);
        const arr = new Uint8Array(bin.length);
        for (let i = 0; i < bin.length; ++i) {
          arr[i] = bin.charCodeAt(i);
        }
        return arr;
      }
      var btoa2 = globalThis2.btoa || ((bin) => globalThis2.Buffer.from(bin, "binary").toString("base64"));
      function base64FromBytes(arr) {
        const bin = [];
        for (const byte of arr) {
          bin.push(String.fromCharCode(byte));
        }
        return btoa2(bin.join(""));
      }
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/cosmjs-types/ibc/core/client/v1/query.js
  var require_query7 = __commonJS({
    "node_modules/cosmjs-types/ibc/core/client/v1/query.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.QueryClientImpl = exports2.QueryClientParamsResponse = exports2.QueryClientParamsRequest = exports2.QueryConsensusStatesResponse = exports2.QueryConsensusStatesRequest = exports2.QueryConsensusStateResponse = exports2.QueryConsensusStateRequest = exports2.QueryClientStatesResponse = exports2.QueryClientStatesRequest = exports2.QueryClientStateResponse = exports2.QueryClientStateRequest = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var any_1 = require_any();
      var client_1 = require_client();
      var pagination_1 = require_pagination();
      exports2.protobufPackage = "ibc.core.client.v1";
      var baseQueryClientStateRequest = { clientId: "" };
      exports2.QueryClientStateRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.clientId !== "") {
            writer.uint32(10).string(message.clientId);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryClientStateRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.clientId = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryClientStateRequest);
          message.clientId = object.clientId !== void 0 && object.clientId !== null ? String(object.clientId) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.clientId !== void 0 && (obj.clientId = message.clientId);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryClientStateRequest);
          message.clientId = (_a = object.clientId) !== null && _a !== void 0 ? _a : "";
          return message;
        }
      };
      var baseQueryClientStateResponse = {};
      exports2.QueryClientStateResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.clientState !== void 0) {
            any_1.Any.encode(message.clientState, writer.uint32(10).fork()).ldelim();
          }
          if (message.proof.length !== 0) {
            writer.uint32(18).bytes(message.proof);
          }
          if (message.proofHeight !== void 0) {
            client_1.Height.encode(message.proofHeight, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryClientStateResponse);
          message.proof = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.clientState = any_1.Any.decode(reader, reader.uint32());
                break;
              case 2:
                message.proof = reader.bytes();
                break;
              case 3:
                message.proofHeight = client_1.Height.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryClientStateResponse);
          message.clientState = object.clientState !== void 0 && object.clientState !== null ? any_1.Any.fromJSON(object.clientState) : void 0;
          message.proof = object.proof !== void 0 && object.proof !== null ? bytesFromBase64(object.proof) : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromJSON(object.proofHeight) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.clientState !== void 0 && (obj.clientState = message.clientState ? any_1.Any.toJSON(message.clientState) : void 0);
          message.proof !== void 0 && (obj.proof = base64FromBytes(message.proof !== void 0 ? message.proof : new Uint8Array()));
          message.proofHeight !== void 0 && (obj.proofHeight = message.proofHeight ? client_1.Height.toJSON(message.proofHeight) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryClientStateResponse);
          message.clientState = object.clientState !== void 0 && object.clientState !== null ? any_1.Any.fromPartial(object.clientState) : void 0;
          message.proof = (_a = object.proof) !== null && _a !== void 0 ? _a : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromPartial(object.proofHeight) : void 0;
          return message;
        }
      };
      var baseQueryClientStatesRequest = {};
      exports2.QueryClientStatesRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.pagination !== void 0) {
            pagination_1.PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryClientStatesRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.pagination = pagination_1.PageRequest.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryClientStatesRequest);
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageRequest.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryClientStatesRequest);
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryClientStatesResponse = {};
      exports2.QueryClientStatesResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.clientStates) {
            client_1.IdentifiedClientState.encode(v, writer.uint32(10).fork()).ldelim();
          }
          if (message.pagination !== void 0) {
            pagination_1.PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryClientStatesResponse);
          message.clientStates = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.clientStates.push(client_1.IdentifiedClientState.decode(reader, reader.uint32()));
                break;
              case 2:
                message.pagination = pagination_1.PageResponse.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseQueryClientStatesResponse);
          message.clientStates = ((_a = object.clientStates) !== null && _a !== void 0 ? _a : []).map((e) => client_1.IdentifiedClientState.fromJSON(e));
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.clientStates) {
            obj.clientStates = message.clientStates.map((e) => e ? client_1.IdentifiedClientState.toJSON(e) : void 0);
          } else {
            obj.clientStates = [];
          }
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageResponse.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryClientStatesResponse);
          message.clientStates = ((_a = object.clientStates) === null || _a === void 0 ? void 0 : _a.map((e) => client_1.IdentifiedClientState.fromPartial(e))) || [];
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryConsensusStateRequest = {
        clientId: "",
        revisionNumber: long_1.default.UZERO,
        revisionHeight: long_1.default.UZERO,
        latestHeight: false
      };
      exports2.QueryConsensusStateRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.clientId !== "") {
            writer.uint32(10).string(message.clientId);
          }
          if (!message.revisionNumber.isZero()) {
            writer.uint32(16).uint64(message.revisionNumber);
          }
          if (!message.revisionHeight.isZero()) {
            writer.uint32(24).uint64(message.revisionHeight);
          }
          if (message.latestHeight === true) {
            writer.uint32(32).bool(message.latestHeight);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryConsensusStateRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.clientId = reader.string();
                break;
              case 2:
                message.revisionNumber = reader.uint64();
                break;
              case 3:
                message.revisionHeight = reader.uint64();
                break;
              case 4:
                message.latestHeight = reader.bool();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryConsensusStateRequest);
          message.clientId = object.clientId !== void 0 && object.clientId !== null ? String(object.clientId) : "";
          message.revisionNumber = object.revisionNumber !== void 0 && object.revisionNumber !== null ? long_1.default.fromString(object.revisionNumber) : long_1.default.UZERO;
          message.revisionHeight = object.revisionHeight !== void 0 && object.revisionHeight !== null ? long_1.default.fromString(object.revisionHeight) : long_1.default.UZERO;
          message.latestHeight = object.latestHeight !== void 0 && object.latestHeight !== null ? Boolean(object.latestHeight) : false;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.clientId !== void 0 && (obj.clientId = message.clientId);
          message.revisionNumber !== void 0 && (obj.revisionNumber = (message.revisionNumber || long_1.default.UZERO).toString());
          message.revisionHeight !== void 0 && (obj.revisionHeight = (message.revisionHeight || long_1.default.UZERO).toString());
          message.latestHeight !== void 0 && (obj.latestHeight = message.latestHeight);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseQueryConsensusStateRequest);
          message.clientId = (_a = object.clientId) !== null && _a !== void 0 ? _a : "";
          message.revisionNumber = object.revisionNumber !== void 0 && object.revisionNumber !== null ? long_1.default.fromValue(object.revisionNumber) : long_1.default.UZERO;
          message.revisionHeight = object.revisionHeight !== void 0 && object.revisionHeight !== null ? long_1.default.fromValue(object.revisionHeight) : long_1.default.UZERO;
          message.latestHeight = (_b = object.latestHeight) !== null && _b !== void 0 ? _b : false;
          return message;
        }
      };
      var baseQueryConsensusStateResponse = {};
      exports2.QueryConsensusStateResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.consensusState !== void 0) {
            any_1.Any.encode(message.consensusState, writer.uint32(10).fork()).ldelim();
          }
          if (message.proof.length !== 0) {
            writer.uint32(18).bytes(message.proof);
          }
          if (message.proofHeight !== void 0) {
            client_1.Height.encode(message.proofHeight, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryConsensusStateResponse);
          message.proof = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.consensusState = any_1.Any.decode(reader, reader.uint32());
                break;
              case 2:
                message.proof = reader.bytes();
                break;
              case 3:
                message.proofHeight = client_1.Height.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryConsensusStateResponse);
          message.consensusState = object.consensusState !== void 0 && object.consensusState !== null ? any_1.Any.fromJSON(object.consensusState) : void 0;
          message.proof = object.proof !== void 0 && object.proof !== null ? bytesFromBase64(object.proof) : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromJSON(object.proofHeight) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.consensusState !== void 0 && (obj.consensusState = message.consensusState ? any_1.Any.toJSON(message.consensusState) : void 0);
          message.proof !== void 0 && (obj.proof = base64FromBytes(message.proof !== void 0 ? message.proof : new Uint8Array()));
          message.proofHeight !== void 0 && (obj.proofHeight = message.proofHeight ? client_1.Height.toJSON(message.proofHeight) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryConsensusStateResponse);
          message.consensusState = object.consensusState !== void 0 && object.consensusState !== null ? any_1.Any.fromPartial(object.consensusState) : void 0;
          message.proof = (_a = object.proof) !== null && _a !== void 0 ? _a : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromPartial(object.proofHeight) : void 0;
          return message;
        }
      };
      var baseQueryConsensusStatesRequest = { clientId: "" };
      exports2.QueryConsensusStatesRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.clientId !== "") {
            writer.uint32(10).string(message.clientId);
          }
          if (message.pagination !== void 0) {
            pagination_1.PageRequest.encode(message.pagination, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryConsensusStatesRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.clientId = reader.string();
                break;
              case 2:
                message.pagination = pagination_1.PageRequest.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryConsensusStatesRequest);
          message.clientId = object.clientId !== void 0 && object.clientId !== null ? String(object.clientId) : "";
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.clientId !== void 0 && (obj.clientId = message.clientId);
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageRequest.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryConsensusStatesRequest);
          message.clientId = (_a = object.clientId) !== null && _a !== void 0 ? _a : "";
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryConsensusStatesResponse = {};
      exports2.QueryConsensusStatesResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.consensusStates) {
            client_1.ConsensusStateWithHeight.encode(v, writer.uint32(10).fork()).ldelim();
          }
          if (message.pagination !== void 0) {
            pagination_1.PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryConsensusStatesResponse);
          message.consensusStates = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.consensusStates.push(client_1.ConsensusStateWithHeight.decode(reader, reader.uint32()));
                break;
              case 2:
                message.pagination = pagination_1.PageResponse.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseQueryConsensusStatesResponse);
          message.consensusStates = ((_a = object.consensusStates) !== null && _a !== void 0 ? _a : []).map((e) => client_1.ConsensusStateWithHeight.fromJSON(e));
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.consensusStates) {
            obj.consensusStates = message.consensusStates.map((e) => e ? client_1.ConsensusStateWithHeight.toJSON(e) : void 0);
          } else {
            obj.consensusStates = [];
          }
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageResponse.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryConsensusStatesResponse);
          message.consensusStates = ((_a = object.consensusStates) === null || _a === void 0 ? void 0 : _a.map((e) => client_1.ConsensusStateWithHeight.fromPartial(e))) || [];
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryClientParamsRequest = {};
      exports2.QueryClientParamsRequest = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryClientParamsRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseQueryClientParamsRequest);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseQueryClientParamsRequest);
          return message;
        }
      };
      var baseQueryClientParamsResponse = {};
      exports2.QueryClientParamsResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.params !== void 0) {
            client_1.Params.encode(message.params, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryClientParamsResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.params = client_1.Params.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryClientParamsResponse);
          message.params = object.params !== void 0 && object.params !== null ? client_1.Params.fromJSON(object.params) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.params !== void 0 && (obj.params = message.params ? client_1.Params.toJSON(message.params) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryClientParamsResponse);
          message.params = object.params !== void 0 && object.params !== null ? client_1.Params.fromPartial(object.params) : void 0;
          return message;
        }
      };
      var QueryClientImpl = class {
        constructor(rpc) {
          this.rpc = rpc;
          this.ClientState = this.ClientState.bind(this);
          this.ClientStates = this.ClientStates.bind(this);
          this.ConsensusState = this.ConsensusState.bind(this);
          this.ConsensusStates = this.ConsensusStates.bind(this);
          this.ClientParams = this.ClientParams.bind(this);
        }
        ClientState(request) {
          const data = exports2.QueryClientStateRequest.encode(request).finish();
          const promise = this.rpc.request("ibc.core.client.v1.Query", "ClientState", data);
          return promise.then((data2) => exports2.QueryClientStateResponse.decode(new minimal_1.default.Reader(data2)));
        }
        ClientStates(request) {
          const data = exports2.QueryClientStatesRequest.encode(request).finish();
          const promise = this.rpc.request("ibc.core.client.v1.Query", "ClientStates", data);
          return promise.then((data2) => exports2.QueryClientStatesResponse.decode(new minimal_1.default.Reader(data2)));
        }
        ConsensusState(request) {
          const data = exports2.QueryConsensusStateRequest.encode(request).finish();
          const promise = this.rpc.request("ibc.core.client.v1.Query", "ConsensusState", data);
          return promise.then((data2) => exports2.QueryConsensusStateResponse.decode(new minimal_1.default.Reader(data2)));
        }
        ConsensusStates(request) {
          const data = exports2.QueryConsensusStatesRequest.encode(request).finish();
          const promise = this.rpc.request("ibc.core.client.v1.Query", "ConsensusStates", data);
          return promise.then((data2) => exports2.QueryConsensusStatesResponse.decode(new minimal_1.default.Reader(data2)));
        }
        ClientParams(request) {
          const data = exports2.QueryClientParamsRequest.encode(request).finish();
          const promise = this.rpc.request("ibc.core.client.v1.Query", "ClientParams", data);
          return promise.then((data2) => exports2.QueryClientParamsResponse.decode(new minimal_1.default.Reader(data2)));
        }
      };
      exports2.QueryClientImpl = QueryClientImpl;
      var globalThis2 = (() => {
        if (typeof globalThis2 !== "undefined")
          return globalThis2;
        if (typeof self !== "undefined")
          return self;
        if (typeof window !== "undefined")
          return window;
        if (typeof global !== "undefined")
          return global;
        throw "Unable to locate global object";
      })();
      var atob2 = globalThis2.atob || ((b64) => globalThis2.Buffer.from(b64, "base64").toString("binary"));
      function bytesFromBase64(b64) {
        const bin = atob2(b64);
        const arr = new Uint8Array(bin.length);
        for (let i = 0; i < bin.length; ++i) {
          arr[i] = bin.charCodeAt(i);
        }
        return arr;
      }
      var btoa2 = globalThis2.btoa || ((bin) => globalThis2.Buffer.from(bin, "binary").toString("base64"));
      function base64FromBytes(arr) {
        const bin = [];
        for (const byte of arr) {
          bin.push(String.fromCharCode(byte));
        }
        return btoa2(bin.join(""));
      }
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/cosmjs-types/ibc/core/connection/v1/query.js
  var require_query8 = __commonJS({
    "node_modules/cosmjs-types/ibc/core/connection/v1/query.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.QueryClientImpl = exports2.QueryConnectionConsensusStateResponse = exports2.QueryConnectionConsensusStateRequest = exports2.QueryConnectionClientStateResponse = exports2.QueryConnectionClientStateRequest = exports2.QueryClientConnectionsResponse = exports2.QueryClientConnectionsRequest = exports2.QueryConnectionsResponse = exports2.QueryConnectionsRequest = exports2.QueryConnectionResponse = exports2.QueryConnectionRequest = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var connection_1 = require_connection();
      var client_1 = require_client();
      var pagination_1 = require_pagination();
      var any_1 = require_any();
      exports2.protobufPackage = "ibc.core.connection.v1";
      var baseQueryConnectionRequest = { connectionId: "" };
      exports2.QueryConnectionRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.connectionId !== "") {
            writer.uint32(10).string(message.connectionId);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryConnectionRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.connectionId = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryConnectionRequest);
          message.connectionId = object.connectionId !== void 0 && object.connectionId !== null ? String(object.connectionId) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.connectionId !== void 0 && (obj.connectionId = message.connectionId);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryConnectionRequest);
          message.connectionId = (_a = object.connectionId) !== null && _a !== void 0 ? _a : "";
          return message;
        }
      };
      var baseQueryConnectionResponse = {};
      exports2.QueryConnectionResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.connection !== void 0) {
            connection_1.ConnectionEnd.encode(message.connection, writer.uint32(10).fork()).ldelim();
          }
          if (message.proof.length !== 0) {
            writer.uint32(18).bytes(message.proof);
          }
          if (message.proofHeight !== void 0) {
            client_1.Height.encode(message.proofHeight, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryConnectionResponse);
          message.proof = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.connection = connection_1.ConnectionEnd.decode(reader, reader.uint32());
                break;
              case 2:
                message.proof = reader.bytes();
                break;
              case 3:
                message.proofHeight = client_1.Height.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryConnectionResponse);
          message.connection = object.connection !== void 0 && object.connection !== null ? connection_1.ConnectionEnd.fromJSON(object.connection) : void 0;
          message.proof = object.proof !== void 0 && object.proof !== null ? bytesFromBase64(object.proof) : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromJSON(object.proofHeight) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.connection !== void 0 && (obj.connection = message.connection ? connection_1.ConnectionEnd.toJSON(message.connection) : void 0);
          message.proof !== void 0 && (obj.proof = base64FromBytes(message.proof !== void 0 ? message.proof : new Uint8Array()));
          message.proofHeight !== void 0 && (obj.proofHeight = message.proofHeight ? client_1.Height.toJSON(message.proofHeight) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryConnectionResponse);
          message.connection = object.connection !== void 0 && object.connection !== null ? connection_1.ConnectionEnd.fromPartial(object.connection) : void 0;
          message.proof = (_a = object.proof) !== null && _a !== void 0 ? _a : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromPartial(object.proofHeight) : void 0;
          return message;
        }
      };
      var baseQueryConnectionsRequest = {};
      exports2.QueryConnectionsRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.pagination !== void 0) {
            pagination_1.PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryConnectionsRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.pagination = pagination_1.PageRequest.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryConnectionsRequest);
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageRequest.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryConnectionsRequest);
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryConnectionsResponse = {};
      exports2.QueryConnectionsResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.connections) {
            connection_1.IdentifiedConnection.encode(v, writer.uint32(10).fork()).ldelim();
          }
          if (message.pagination !== void 0) {
            pagination_1.PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
          }
          if (message.height !== void 0) {
            client_1.Height.encode(message.height, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryConnectionsResponse);
          message.connections = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.connections.push(connection_1.IdentifiedConnection.decode(reader, reader.uint32()));
                break;
              case 2:
                message.pagination = pagination_1.PageResponse.decode(reader, reader.uint32());
                break;
              case 3:
                message.height = client_1.Height.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseQueryConnectionsResponse);
          message.connections = ((_a = object.connections) !== null && _a !== void 0 ? _a : []).map((e) => connection_1.IdentifiedConnection.fromJSON(e));
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromJSON(object.pagination) : void 0;
          message.height = object.height !== void 0 && object.height !== null ? client_1.Height.fromJSON(object.height) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.connections) {
            obj.connections = message.connections.map((e) => e ? connection_1.IdentifiedConnection.toJSON(e) : void 0);
          } else {
            obj.connections = [];
          }
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageResponse.toJSON(message.pagination) : void 0);
          message.height !== void 0 && (obj.height = message.height ? client_1.Height.toJSON(message.height) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryConnectionsResponse);
          message.connections = ((_a = object.connections) === null || _a === void 0 ? void 0 : _a.map((e) => connection_1.IdentifiedConnection.fromPartial(e))) || [];
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromPartial(object.pagination) : void 0;
          message.height = object.height !== void 0 && object.height !== null ? client_1.Height.fromPartial(object.height) : void 0;
          return message;
        }
      };
      var baseQueryClientConnectionsRequest = { clientId: "" };
      exports2.QueryClientConnectionsRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.clientId !== "") {
            writer.uint32(10).string(message.clientId);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryClientConnectionsRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.clientId = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryClientConnectionsRequest);
          message.clientId = object.clientId !== void 0 && object.clientId !== null ? String(object.clientId) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.clientId !== void 0 && (obj.clientId = message.clientId);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryClientConnectionsRequest);
          message.clientId = (_a = object.clientId) !== null && _a !== void 0 ? _a : "";
          return message;
        }
      };
      var baseQueryClientConnectionsResponse = { connectionPaths: "" };
      exports2.QueryClientConnectionsResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.connectionPaths) {
            writer.uint32(10).string(v);
          }
          if (message.proof.length !== 0) {
            writer.uint32(18).bytes(message.proof);
          }
          if (message.proofHeight !== void 0) {
            client_1.Height.encode(message.proofHeight, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryClientConnectionsResponse);
          message.connectionPaths = [];
          message.proof = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.connectionPaths.push(reader.string());
                break;
              case 2:
                message.proof = reader.bytes();
                break;
              case 3:
                message.proofHeight = client_1.Height.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseQueryClientConnectionsResponse);
          message.connectionPaths = ((_a = object.connectionPaths) !== null && _a !== void 0 ? _a : []).map((e) => String(e));
          message.proof = object.proof !== void 0 && object.proof !== null ? bytesFromBase64(object.proof) : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromJSON(object.proofHeight) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.connectionPaths) {
            obj.connectionPaths = message.connectionPaths.map((e) => e);
          } else {
            obj.connectionPaths = [];
          }
          message.proof !== void 0 && (obj.proof = base64FromBytes(message.proof !== void 0 ? message.proof : new Uint8Array()));
          message.proofHeight !== void 0 && (obj.proofHeight = message.proofHeight ? client_1.Height.toJSON(message.proofHeight) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseQueryClientConnectionsResponse);
          message.connectionPaths = ((_a = object.connectionPaths) === null || _a === void 0 ? void 0 : _a.map((e) => e)) || [];
          message.proof = (_b = object.proof) !== null && _b !== void 0 ? _b : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromPartial(object.proofHeight) : void 0;
          return message;
        }
      };
      var baseQueryConnectionClientStateRequest = { connectionId: "" };
      exports2.QueryConnectionClientStateRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.connectionId !== "") {
            writer.uint32(10).string(message.connectionId);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryConnectionClientStateRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.connectionId = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryConnectionClientStateRequest);
          message.connectionId = object.connectionId !== void 0 && object.connectionId !== null ? String(object.connectionId) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.connectionId !== void 0 && (obj.connectionId = message.connectionId);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryConnectionClientStateRequest);
          message.connectionId = (_a = object.connectionId) !== null && _a !== void 0 ? _a : "";
          return message;
        }
      };
      var baseQueryConnectionClientStateResponse = {};
      exports2.QueryConnectionClientStateResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.identifiedClientState !== void 0) {
            client_1.IdentifiedClientState.encode(message.identifiedClientState, writer.uint32(10).fork()).ldelim();
          }
          if (message.proof.length !== 0) {
            writer.uint32(18).bytes(message.proof);
          }
          if (message.proofHeight !== void 0) {
            client_1.Height.encode(message.proofHeight, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryConnectionClientStateResponse);
          message.proof = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.identifiedClientState = client_1.IdentifiedClientState.decode(reader, reader.uint32());
                break;
              case 2:
                message.proof = reader.bytes();
                break;
              case 3:
                message.proofHeight = client_1.Height.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryConnectionClientStateResponse);
          message.identifiedClientState = object.identifiedClientState !== void 0 && object.identifiedClientState !== null ? client_1.IdentifiedClientState.fromJSON(object.identifiedClientState) : void 0;
          message.proof = object.proof !== void 0 && object.proof !== null ? bytesFromBase64(object.proof) : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromJSON(object.proofHeight) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.identifiedClientState !== void 0 && (obj.identifiedClientState = message.identifiedClientState ? client_1.IdentifiedClientState.toJSON(message.identifiedClientState) : void 0);
          message.proof !== void 0 && (obj.proof = base64FromBytes(message.proof !== void 0 ? message.proof : new Uint8Array()));
          message.proofHeight !== void 0 && (obj.proofHeight = message.proofHeight ? client_1.Height.toJSON(message.proofHeight) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryConnectionClientStateResponse);
          message.identifiedClientState = object.identifiedClientState !== void 0 && object.identifiedClientState !== null ? client_1.IdentifiedClientState.fromPartial(object.identifiedClientState) : void 0;
          message.proof = (_a = object.proof) !== null && _a !== void 0 ? _a : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromPartial(object.proofHeight) : void 0;
          return message;
        }
      };
      var baseQueryConnectionConsensusStateRequest = {
        connectionId: "",
        revisionNumber: long_1.default.UZERO,
        revisionHeight: long_1.default.UZERO
      };
      exports2.QueryConnectionConsensusStateRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.connectionId !== "") {
            writer.uint32(10).string(message.connectionId);
          }
          if (!message.revisionNumber.isZero()) {
            writer.uint32(16).uint64(message.revisionNumber);
          }
          if (!message.revisionHeight.isZero()) {
            writer.uint32(24).uint64(message.revisionHeight);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryConnectionConsensusStateRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.connectionId = reader.string();
                break;
              case 2:
                message.revisionNumber = reader.uint64();
                break;
              case 3:
                message.revisionHeight = reader.uint64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryConnectionConsensusStateRequest);
          message.connectionId = object.connectionId !== void 0 && object.connectionId !== null ? String(object.connectionId) : "";
          message.revisionNumber = object.revisionNumber !== void 0 && object.revisionNumber !== null ? long_1.default.fromString(object.revisionNumber) : long_1.default.UZERO;
          message.revisionHeight = object.revisionHeight !== void 0 && object.revisionHeight !== null ? long_1.default.fromString(object.revisionHeight) : long_1.default.UZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.connectionId !== void 0 && (obj.connectionId = message.connectionId);
          message.revisionNumber !== void 0 && (obj.revisionNumber = (message.revisionNumber || long_1.default.UZERO).toString());
          message.revisionHeight !== void 0 && (obj.revisionHeight = (message.revisionHeight || long_1.default.UZERO).toString());
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryConnectionConsensusStateRequest);
          message.connectionId = (_a = object.connectionId) !== null && _a !== void 0 ? _a : "";
          message.revisionNumber = object.revisionNumber !== void 0 && object.revisionNumber !== null ? long_1.default.fromValue(object.revisionNumber) : long_1.default.UZERO;
          message.revisionHeight = object.revisionHeight !== void 0 && object.revisionHeight !== null ? long_1.default.fromValue(object.revisionHeight) : long_1.default.UZERO;
          return message;
        }
      };
      var baseQueryConnectionConsensusStateResponse = { clientId: "" };
      exports2.QueryConnectionConsensusStateResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.consensusState !== void 0) {
            any_1.Any.encode(message.consensusState, writer.uint32(10).fork()).ldelim();
          }
          if (message.clientId !== "") {
            writer.uint32(18).string(message.clientId);
          }
          if (message.proof.length !== 0) {
            writer.uint32(26).bytes(message.proof);
          }
          if (message.proofHeight !== void 0) {
            client_1.Height.encode(message.proofHeight, writer.uint32(34).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryConnectionConsensusStateResponse);
          message.proof = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.consensusState = any_1.Any.decode(reader, reader.uint32());
                break;
              case 2:
                message.clientId = reader.string();
                break;
              case 3:
                message.proof = reader.bytes();
                break;
              case 4:
                message.proofHeight = client_1.Height.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryConnectionConsensusStateResponse);
          message.consensusState = object.consensusState !== void 0 && object.consensusState !== null ? any_1.Any.fromJSON(object.consensusState) : void 0;
          message.clientId = object.clientId !== void 0 && object.clientId !== null ? String(object.clientId) : "";
          message.proof = object.proof !== void 0 && object.proof !== null ? bytesFromBase64(object.proof) : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromJSON(object.proofHeight) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.consensusState !== void 0 && (obj.consensusState = message.consensusState ? any_1.Any.toJSON(message.consensusState) : void 0);
          message.clientId !== void 0 && (obj.clientId = message.clientId);
          message.proof !== void 0 && (obj.proof = base64FromBytes(message.proof !== void 0 ? message.proof : new Uint8Array()));
          message.proofHeight !== void 0 && (obj.proofHeight = message.proofHeight ? client_1.Height.toJSON(message.proofHeight) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseQueryConnectionConsensusStateResponse);
          message.consensusState = object.consensusState !== void 0 && object.consensusState !== null ? any_1.Any.fromPartial(object.consensusState) : void 0;
          message.clientId = (_a = object.clientId) !== null && _a !== void 0 ? _a : "";
          message.proof = (_b = object.proof) !== null && _b !== void 0 ? _b : new Uint8Array();
          message.proofHeight = object.proofHeight !== void 0 && object.proofHeight !== null ? client_1.Height.fromPartial(object.proofHeight) : void 0;
          return message;
        }
      };
      var QueryClientImpl = class {
        constructor(rpc) {
          this.rpc = rpc;
          this.Connection = this.Connection.bind(this);
          this.Connections = this.Connections.bind(this);
          this.ClientConnections = this.ClientConnections.bind(this);
          this.ConnectionClientState = this.ConnectionClientState.bind(this);
          this.ConnectionConsensusState = this.ConnectionConsensusState.bind(this);
        }
        Connection(request) {
          const data = exports2.QueryConnectionRequest.encode(request).finish();
          const promise = this.rpc.request("ibc.core.connection.v1.Query", "Connection", data);
          return promise.then((data2) => exports2.QueryConnectionResponse.decode(new minimal_1.default.Reader(data2)));
        }
        Connections(request) {
          const data = exports2.QueryConnectionsRequest.encode(request).finish();
          const promise = this.rpc.request("ibc.core.connection.v1.Query", "Connections", data);
          return promise.then((data2) => exports2.QueryConnectionsResponse.decode(new minimal_1.default.Reader(data2)));
        }
        ClientConnections(request) {
          const data = exports2.QueryClientConnectionsRequest.encode(request).finish();
          const promise = this.rpc.request("ibc.core.connection.v1.Query", "ClientConnections", data);
          return promise.then((data2) => exports2.QueryClientConnectionsResponse.decode(new minimal_1.default.Reader(data2)));
        }
        ConnectionClientState(request) {
          const data = exports2.QueryConnectionClientStateRequest.encode(request).finish();
          const promise = this.rpc.request("ibc.core.connection.v1.Query", "ConnectionClientState", data);
          return promise.then((data2) => exports2.QueryConnectionClientStateResponse.decode(new minimal_1.default.Reader(data2)));
        }
        ConnectionConsensusState(request) {
          const data = exports2.QueryConnectionConsensusStateRequest.encode(request).finish();
          const promise = this.rpc.request("ibc.core.connection.v1.Query", "ConnectionConsensusState", data);
          return promise.then((data2) => exports2.QueryConnectionConsensusStateResponse.decode(new minimal_1.default.Reader(data2)));
        }
      };
      exports2.QueryClientImpl = QueryClientImpl;
      var globalThis2 = (() => {
        if (typeof globalThis2 !== "undefined")
          return globalThis2;
        if (typeof self !== "undefined")
          return self;
        if (typeof window !== "undefined")
          return window;
        if (typeof global !== "undefined")
          return global;
        throw "Unable to locate global object";
      })();
      var atob2 = globalThis2.atob || ((b64) => globalThis2.Buffer.from(b64, "base64").toString("binary"));
      function bytesFromBase64(b64) {
        const bin = atob2(b64);
        const arr = new Uint8Array(bin.length);
        for (let i = 0; i < bin.length; ++i) {
          arr[i] = bin.charCodeAt(i);
        }
        return arr;
      }
      var btoa2 = globalThis2.btoa || ((bin) => globalThis2.Buffer.from(bin, "binary").toString("base64"));
      function base64FromBytes(arr) {
        const bin = [];
        for (const byte of arr) {
          bin.push(String.fromCharCode(byte));
        }
        return btoa2(bin.join(""));
      }
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/cosmjs-types/tendermint/crypto/proof.js
  var require_proof = __commonJS({
    "node_modules/cosmjs-types/tendermint/crypto/proof.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.ProofOps = exports2.ProofOp = exports2.DominoOp = exports2.ValueOp = exports2.Proof = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      exports2.protobufPackage = "tendermint.crypto";
      var baseProof = { total: long_1.default.ZERO, index: long_1.default.ZERO };
      exports2.Proof = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.total.isZero()) {
            writer.uint32(8).int64(message.total);
          }
          if (!message.index.isZero()) {
            writer.uint32(16).int64(message.index);
          }
          if (message.leafHash.length !== 0) {
            writer.uint32(26).bytes(message.leafHash);
          }
          for (const v of message.aunts) {
            writer.uint32(34).bytes(v);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseProof);
          message.aunts = [];
          message.leafHash = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.total = reader.int64();
                break;
              case 2:
                message.index = reader.int64();
                break;
              case 3:
                message.leafHash = reader.bytes();
                break;
              case 4:
                message.aunts.push(reader.bytes());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseProof);
          message.total = object.total !== void 0 && object.total !== null ? long_1.default.fromString(object.total) : long_1.default.ZERO;
          message.index = object.index !== void 0 && object.index !== null ? long_1.default.fromString(object.index) : long_1.default.ZERO;
          message.leafHash = object.leafHash !== void 0 && object.leafHash !== null ? bytesFromBase64(object.leafHash) : new Uint8Array();
          message.aunts = ((_a = object.aunts) !== null && _a !== void 0 ? _a : []).map((e) => bytesFromBase64(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.total !== void 0 && (obj.total = (message.total || long_1.default.ZERO).toString());
          message.index !== void 0 && (obj.index = (message.index || long_1.default.ZERO).toString());
          message.leafHash !== void 0 && (obj.leafHash = base64FromBytes(message.leafHash !== void 0 ? message.leafHash : new Uint8Array()));
          if (message.aunts) {
            obj.aunts = message.aunts.map((e) => base64FromBytes(e !== void 0 ? e : new Uint8Array()));
          } else {
            obj.aunts = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseProof);
          message.total = object.total !== void 0 && object.total !== null ? long_1.default.fromValue(object.total) : long_1.default.ZERO;
          message.index = object.index !== void 0 && object.index !== null ? long_1.default.fromValue(object.index) : long_1.default.ZERO;
          message.leafHash = (_a = object.leafHash) !== null && _a !== void 0 ? _a : new Uint8Array();
          message.aunts = ((_b = object.aunts) === null || _b === void 0 ? void 0 : _b.map((e) => e)) || [];
          return message;
        }
      };
      var baseValueOp = {};
      exports2.ValueOp = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.key.length !== 0) {
            writer.uint32(10).bytes(message.key);
          }
          if (message.proof !== void 0) {
            exports2.Proof.encode(message.proof, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseValueOp);
          message.key = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.key = reader.bytes();
                break;
              case 2:
                message.proof = exports2.Proof.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseValueOp);
          message.key = object.key !== void 0 && object.key !== null ? bytesFromBase64(object.key) : new Uint8Array();
          message.proof = object.proof !== void 0 && object.proof !== null ? exports2.Proof.fromJSON(object.proof) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.key !== void 0 && (obj.key = base64FromBytes(message.key !== void 0 ? message.key : new Uint8Array()));
          message.proof !== void 0 && (obj.proof = message.proof ? exports2.Proof.toJSON(message.proof) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseValueOp);
          message.key = (_a = object.key) !== null && _a !== void 0 ? _a : new Uint8Array();
          message.proof = object.proof !== void 0 && object.proof !== null ? exports2.Proof.fromPartial(object.proof) : void 0;
          return message;
        }
      };
      var baseDominoOp = { key: "", input: "", output: "" };
      exports2.DominoOp = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.key !== "") {
            writer.uint32(10).string(message.key);
          }
          if (message.input !== "") {
            writer.uint32(18).string(message.input);
          }
          if (message.output !== "") {
            writer.uint32(26).string(message.output);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseDominoOp);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.key = reader.string();
                break;
              case 2:
                message.input = reader.string();
                break;
              case 3:
                message.output = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseDominoOp);
          message.key = object.key !== void 0 && object.key !== null ? String(object.key) : "";
          message.input = object.input !== void 0 && object.input !== null ? String(object.input) : "";
          message.output = object.output !== void 0 && object.output !== null ? String(object.output) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.key !== void 0 && (obj.key = message.key);
          message.input !== void 0 && (obj.input = message.input);
          message.output !== void 0 && (obj.output = message.output);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseDominoOp);
          message.key = (_a = object.key) !== null && _a !== void 0 ? _a : "";
          message.input = (_b = object.input) !== null && _b !== void 0 ? _b : "";
          message.output = (_c = object.output) !== null && _c !== void 0 ? _c : "";
          return message;
        }
      };
      var baseProofOp = { type: "" };
      exports2.ProofOp = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.type !== "") {
            writer.uint32(10).string(message.type);
          }
          if (message.key.length !== 0) {
            writer.uint32(18).bytes(message.key);
          }
          if (message.data.length !== 0) {
            writer.uint32(26).bytes(message.data);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseProofOp);
          message.key = new Uint8Array();
          message.data = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.type = reader.string();
                break;
              case 2:
                message.key = reader.bytes();
                break;
              case 3:
                message.data = reader.bytes();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseProofOp);
          message.type = object.type !== void 0 && object.type !== null ? String(object.type) : "";
          message.key = object.key !== void 0 && object.key !== null ? bytesFromBase64(object.key) : new Uint8Array();
          message.data = object.data !== void 0 && object.data !== null ? bytesFromBase64(object.data) : new Uint8Array();
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.type !== void 0 && (obj.type = message.type);
          message.key !== void 0 && (obj.key = base64FromBytes(message.key !== void 0 ? message.key : new Uint8Array()));
          message.data !== void 0 && (obj.data = base64FromBytes(message.data !== void 0 ? message.data : new Uint8Array()));
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseProofOp);
          message.type = (_a = object.type) !== null && _a !== void 0 ? _a : "";
          message.key = (_b = object.key) !== null && _b !== void 0 ? _b : new Uint8Array();
          message.data = (_c = object.data) !== null && _c !== void 0 ? _c : new Uint8Array();
          return message;
        }
      };
      var baseProofOps = {};
      exports2.ProofOps = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.ops) {
            exports2.ProofOp.encode(v, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseProofOps);
          message.ops = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.ops.push(exports2.ProofOp.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseProofOps);
          message.ops = ((_a = object.ops) !== null && _a !== void 0 ? _a : []).map((e) => exports2.ProofOp.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.ops) {
            obj.ops = message.ops.map((e) => e ? exports2.ProofOp.toJSON(e) : void 0);
          } else {
            obj.ops = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseProofOps);
          message.ops = ((_a = object.ops) === null || _a === void 0 ? void 0 : _a.map((e) => exports2.ProofOp.fromPartial(e))) || [];
          return message;
        }
      };
      var globalThis2 = (() => {
        if (typeof globalThis2 !== "undefined")
          return globalThis2;
        if (typeof self !== "undefined")
          return self;
        if (typeof window !== "undefined")
          return window;
        if (typeof global !== "undefined")
          return global;
        throw "Unable to locate global object";
      })();
      var atob2 = globalThis2.atob || ((b64) => globalThis2.Buffer.from(b64, "base64").toString("binary"));
      function bytesFromBase64(b64) {
        const bin = atob2(b64);
        const arr = new Uint8Array(bin.length);
        for (let i = 0; i < bin.length; ++i) {
          arr[i] = bin.charCodeAt(i);
        }
        return arr;
      }
      var btoa2 = globalThis2.btoa || ((bin) => globalThis2.Buffer.from(bin, "binary").toString("base64"));
      function base64FromBytes(arr) {
        const bin = [];
        for (const byte of arr) {
          bin.push(String.fromCharCode(byte));
        }
        return btoa2(bin.join(""));
      }
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/cosmjs-types/tendermint/version/types.js
  var require_types = __commonJS({
    "node_modules/cosmjs-types/tendermint/version/types.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.Consensus = exports2.App = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      exports2.protobufPackage = "tendermint.version";
      var baseApp = { protocol: long_1.default.UZERO, software: "" };
      exports2.App = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.protocol.isZero()) {
            writer.uint32(8).uint64(message.protocol);
          }
          if (message.software !== "") {
            writer.uint32(18).string(message.software);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseApp);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.protocol = reader.uint64();
                break;
              case 2:
                message.software = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseApp);
          message.protocol = object.protocol !== void 0 && object.protocol !== null ? long_1.default.fromString(object.protocol) : long_1.default.UZERO;
          message.software = object.software !== void 0 && object.software !== null ? String(object.software) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.protocol !== void 0 && (obj.protocol = (message.protocol || long_1.default.UZERO).toString());
          message.software !== void 0 && (obj.software = message.software);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseApp);
          message.protocol = object.protocol !== void 0 && object.protocol !== null ? long_1.default.fromValue(object.protocol) : long_1.default.UZERO;
          message.software = (_a = object.software) !== null && _a !== void 0 ? _a : "";
          return message;
        }
      };
      var baseConsensus = { block: long_1.default.UZERO, app: long_1.default.UZERO };
      exports2.Consensus = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.block.isZero()) {
            writer.uint32(8).uint64(message.block);
          }
          if (!message.app.isZero()) {
            writer.uint32(16).uint64(message.app);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseConsensus);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.block = reader.uint64();
                break;
              case 2:
                message.app = reader.uint64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseConsensus);
          message.block = object.block !== void 0 && object.block !== null ? long_1.default.fromString(object.block) : long_1.default.UZERO;
          message.app = object.app !== void 0 && object.app !== null ? long_1.default.fromString(object.app) : long_1.default.UZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.block !== void 0 && (obj.block = (message.block || long_1.default.UZERO).toString());
          message.app !== void 0 && (obj.app = (message.app || long_1.default.UZERO).toString());
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseConsensus);
          message.block = object.block !== void 0 && object.block !== null ? long_1.default.fromValue(object.block) : long_1.default.UZERO;
          message.app = object.app !== void 0 && object.app !== null ? long_1.default.fromValue(object.app) : long_1.default.UZERO;
          return message;
        }
      };
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/cosmjs-types/tendermint/crypto/keys.js
  var require_keys3 = __commonJS({
    "node_modules/cosmjs-types/tendermint/crypto/keys.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.PublicKey = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      exports2.protobufPackage = "tendermint.crypto";
      var basePublicKey = {};
      exports2.PublicKey = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.ed25519 !== void 0) {
            writer.uint32(10).bytes(message.ed25519);
          }
          if (message.secp256k1 !== void 0) {
            writer.uint32(18).bytes(message.secp256k1);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, basePublicKey);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.ed25519 = reader.bytes();
                break;
              case 2:
                message.secp256k1 = reader.bytes();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, basePublicKey);
          message.ed25519 = object.ed25519 !== void 0 && object.ed25519 !== null ? bytesFromBase64(object.ed25519) : void 0;
          message.secp256k1 = object.secp256k1 !== void 0 && object.secp256k1 !== null ? bytesFromBase64(object.secp256k1) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.ed25519 !== void 0 && (obj.ed25519 = message.ed25519 !== void 0 ? base64FromBytes(message.ed25519) : void 0);
          message.secp256k1 !== void 0 && (obj.secp256k1 = message.secp256k1 !== void 0 ? base64FromBytes(message.secp256k1) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, basePublicKey);
          message.ed25519 = (_a = object.ed25519) !== null && _a !== void 0 ? _a : void 0;
          message.secp256k1 = (_b = object.secp256k1) !== null && _b !== void 0 ? _b : void 0;
          return message;
        }
      };
      var globalThis2 = (() => {
        if (typeof globalThis2 !== "undefined")
          return globalThis2;
        if (typeof self !== "undefined")
          return self;
        if (typeof window !== "undefined")
          return window;
        if (typeof global !== "undefined")
          return global;
        throw "Unable to locate global object";
      })();
      var atob2 = globalThis2.atob || ((b64) => globalThis2.Buffer.from(b64, "base64").toString("binary"));
      function bytesFromBase64(b64) {
        const bin = atob2(b64);
        const arr = new Uint8Array(bin.length);
        for (let i = 0; i < bin.length; ++i) {
          arr[i] = bin.charCodeAt(i);
        }
        return arr;
      }
      var btoa2 = globalThis2.btoa || ((bin) => globalThis2.Buffer.from(bin, "binary").toString("base64"));
      function base64FromBytes(arr) {
        const bin = [];
        for (const byte of arr) {
          bin.push(String.fromCharCode(byte));
        }
        return btoa2(bin.join(""));
      }
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/cosmjs-types/tendermint/types/validator.js
  var require_validator = __commonJS({
    "node_modules/cosmjs-types/tendermint/types/validator.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.SimpleValidator = exports2.Validator = exports2.ValidatorSet = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var keys_1 = require_keys3();
      exports2.protobufPackage = "tendermint.types";
      var baseValidatorSet = { totalVotingPower: long_1.default.ZERO };
      exports2.ValidatorSet = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.validators) {
            exports2.Validator.encode(v, writer.uint32(10).fork()).ldelim();
          }
          if (message.proposer !== void 0) {
            exports2.Validator.encode(message.proposer, writer.uint32(18).fork()).ldelim();
          }
          if (!message.totalVotingPower.isZero()) {
            writer.uint32(24).int64(message.totalVotingPower);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseValidatorSet);
          message.validators = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.validators.push(exports2.Validator.decode(reader, reader.uint32()));
                break;
              case 2:
                message.proposer = exports2.Validator.decode(reader, reader.uint32());
                break;
              case 3:
                message.totalVotingPower = reader.int64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseValidatorSet);
          message.validators = ((_a = object.validators) !== null && _a !== void 0 ? _a : []).map((e) => exports2.Validator.fromJSON(e));
          message.proposer = object.proposer !== void 0 && object.proposer !== null ? exports2.Validator.fromJSON(object.proposer) : void 0;
          message.totalVotingPower = object.totalVotingPower !== void 0 && object.totalVotingPower !== null ? long_1.default.fromString(object.totalVotingPower) : long_1.default.ZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.validators) {
            obj.validators = message.validators.map((e) => e ? exports2.Validator.toJSON(e) : void 0);
          } else {
            obj.validators = [];
          }
          message.proposer !== void 0 && (obj.proposer = message.proposer ? exports2.Validator.toJSON(message.proposer) : void 0);
          message.totalVotingPower !== void 0 && (obj.totalVotingPower = (message.totalVotingPower || long_1.default.ZERO).toString());
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseValidatorSet);
          message.validators = ((_a = object.validators) === null || _a === void 0 ? void 0 : _a.map((e) => exports2.Validator.fromPartial(e))) || [];
          message.proposer = object.proposer !== void 0 && object.proposer !== null ? exports2.Validator.fromPartial(object.proposer) : void 0;
          message.totalVotingPower = object.totalVotingPower !== void 0 && object.totalVotingPower !== null ? long_1.default.fromValue(object.totalVotingPower) : long_1.default.ZERO;
          return message;
        }
      };
      var baseValidator = { votingPower: long_1.default.ZERO, proposerPriority: long_1.default.ZERO };
      exports2.Validator = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.address.length !== 0) {
            writer.uint32(10).bytes(message.address);
          }
          if (message.pubKey !== void 0) {
            keys_1.PublicKey.encode(message.pubKey, writer.uint32(18).fork()).ldelim();
          }
          if (!message.votingPower.isZero()) {
            writer.uint32(24).int64(message.votingPower);
          }
          if (!message.proposerPriority.isZero()) {
            writer.uint32(32).int64(message.proposerPriority);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseValidator);
          message.address = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.address = reader.bytes();
                break;
              case 2:
                message.pubKey = keys_1.PublicKey.decode(reader, reader.uint32());
                break;
              case 3:
                message.votingPower = reader.int64();
                break;
              case 4:
                message.proposerPriority = reader.int64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseValidator);
          message.address = object.address !== void 0 && object.address !== null ? bytesFromBase64(object.address) : new Uint8Array();
          message.pubKey = object.pubKey !== void 0 && object.pubKey !== null ? keys_1.PublicKey.fromJSON(object.pubKey) : void 0;
          message.votingPower = object.votingPower !== void 0 && object.votingPower !== null ? long_1.default.fromString(object.votingPower) : long_1.default.ZERO;
          message.proposerPriority = object.proposerPriority !== void 0 && object.proposerPriority !== null ? long_1.default.fromString(object.proposerPriority) : long_1.default.ZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.address !== void 0 && (obj.address = base64FromBytes(message.address !== void 0 ? message.address : new Uint8Array()));
          message.pubKey !== void 0 && (obj.pubKey = message.pubKey ? keys_1.PublicKey.toJSON(message.pubKey) : void 0);
          message.votingPower !== void 0 && (obj.votingPower = (message.votingPower || long_1.default.ZERO).toString());
          message.proposerPriority !== void 0 && (obj.proposerPriority = (message.proposerPriority || long_1.default.ZERO).toString());
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseValidator);
          message.address = (_a = object.address) !== null && _a !== void 0 ? _a : new Uint8Array();
          message.pubKey = object.pubKey !== void 0 && object.pubKey !== null ? keys_1.PublicKey.fromPartial(object.pubKey) : void 0;
          message.votingPower = object.votingPower !== void 0 && object.votingPower !== null ? long_1.default.fromValue(object.votingPower) : long_1.default.ZERO;
          message.proposerPriority = object.proposerPriority !== void 0 && object.proposerPriority !== null ? long_1.default.fromValue(object.proposerPriority) : long_1.default.ZERO;
          return message;
        }
      };
      var baseSimpleValidator = { votingPower: long_1.default.ZERO };
      exports2.SimpleValidator = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.pubKey !== void 0) {
            keys_1.PublicKey.encode(message.pubKey, writer.uint32(10).fork()).ldelim();
          }
          if (!message.votingPower.isZero()) {
            writer.uint32(16).int64(message.votingPower);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseSimpleValidator);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.pubKey = keys_1.PublicKey.decode(reader, reader.uint32());
                break;
              case 2:
                message.votingPower = reader.int64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseSimpleValidator);
          message.pubKey = object.pubKey !== void 0 && object.pubKey !== null ? keys_1.PublicKey.fromJSON(object.pubKey) : void 0;
          message.votingPower = object.votingPower !== void 0 && object.votingPower !== null ? long_1.default.fromString(object.votingPower) : long_1.default.ZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.pubKey !== void 0 && (obj.pubKey = message.pubKey ? keys_1.PublicKey.toJSON(message.pubKey) : void 0);
          message.votingPower !== void 0 && (obj.votingPower = (message.votingPower || long_1.default.ZERO).toString());
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseSimpleValidator);
          message.pubKey = object.pubKey !== void 0 && object.pubKey !== null ? keys_1.PublicKey.fromPartial(object.pubKey) : void 0;
          message.votingPower = object.votingPower !== void 0 && object.votingPower !== null ? long_1.default.fromValue(object.votingPower) : long_1.default.ZERO;
          return message;
        }
      };
      var globalThis2 = (() => {
        if (typeof globalThis2 !== "undefined")
          return globalThis2;
        if (typeof self !== "undefined")
          return self;
        if (typeof window !== "undefined")
          return window;
        if (typeof global !== "undefined")
          return global;
        throw "Unable to locate global object";
      })();
      var atob2 = globalThis2.atob || ((b64) => globalThis2.Buffer.from(b64, "base64").toString("binary"));
      function bytesFromBase64(b64) {
        const bin = atob2(b64);
        const arr = new Uint8Array(bin.length);
        for (let i = 0; i < bin.length; ++i) {
          arr[i] = bin.charCodeAt(i);
        }
        return arr;
      }
      var btoa2 = globalThis2.btoa || ((bin) => globalThis2.Buffer.from(bin, "binary").toString("base64"));
      function base64FromBytes(arr) {
        const bin = [];
        for (const byte of arr) {
          bin.push(String.fromCharCode(byte));
        }
        return btoa2(bin.join(""));
      }
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/cosmjs-types/tendermint/types/types.js
  var require_types2 = __commonJS({
    "node_modules/cosmjs-types/tendermint/types/types.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.TxProof = exports2.BlockMeta = exports2.LightBlock = exports2.SignedHeader = exports2.Proposal = exports2.CommitSig = exports2.Commit = exports2.Vote = exports2.Data = exports2.Header = exports2.BlockID = exports2.Part = exports2.PartSetHeader = exports2.signedMsgTypeToJSON = exports2.signedMsgTypeFromJSON = exports2.SignedMsgType = exports2.blockIDFlagToJSON = exports2.blockIDFlagFromJSON = exports2.BlockIDFlag = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var proof_1 = require_proof();
      var types_1 = require_types();
      var timestamp_1 = require_timestamp();
      var validator_1 = require_validator();
      exports2.protobufPackage = "tendermint.types";
      var BlockIDFlag;
      (function(BlockIDFlag2) {
        BlockIDFlag2[BlockIDFlag2["BLOCK_ID_FLAG_UNKNOWN"] = 0] = "BLOCK_ID_FLAG_UNKNOWN";
        BlockIDFlag2[BlockIDFlag2["BLOCK_ID_FLAG_ABSENT"] = 1] = "BLOCK_ID_FLAG_ABSENT";
        BlockIDFlag2[BlockIDFlag2["BLOCK_ID_FLAG_COMMIT"] = 2] = "BLOCK_ID_FLAG_COMMIT";
        BlockIDFlag2[BlockIDFlag2["BLOCK_ID_FLAG_NIL"] = 3] = "BLOCK_ID_FLAG_NIL";
        BlockIDFlag2[BlockIDFlag2["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
      })(BlockIDFlag = exports2.BlockIDFlag || (exports2.BlockIDFlag = {}));
      function blockIDFlagFromJSON(object) {
        switch (object) {
          case 0:
          case "BLOCK_ID_FLAG_UNKNOWN":
            return BlockIDFlag.BLOCK_ID_FLAG_UNKNOWN;
          case 1:
          case "BLOCK_ID_FLAG_ABSENT":
            return BlockIDFlag.BLOCK_ID_FLAG_ABSENT;
          case 2:
          case "BLOCK_ID_FLAG_COMMIT":
            return BlockIDFlag.BLOCK_ID_FLAG_COMMIT;
          case 3:
          case "BLOCK_ID_FLAG_NIL":
            return BlockIDFlag.BLOCK_ID_FLAG_NIL;
          case -1:
          case "UNRECOGNIZED":
          default:
            return BlockIDFlag.UNRECOGNIZED;
        }
      }
      exports2.blockIDFlagFromJSON = blockIDFlagFromJSON;
      function blockIDFlagToJSON(object) {
        switch (object) {
          case BlockIDFlag.BLOCK_ID_FLAG_UNKNOWN:
            return "BLOCK_ID_FLAG_UNKNOWN";
          case BlockIDFlag.BLOCK_ID_FLAG_ABSENT:
            return "BLOCK_ID_FLAG_ABSENT";
          case BlockIDFlag.BLOCK_ID_FLAG_COMMIT:
            return "BLOCK_ID_FLAG_COMMIT";
          case BlockIDFlag.BLOCK_ID_FLAG_NIL:
            return "BLOCK_ID_FLAG_NIL";
          default:
            return "UNKNOWN";
        }
      }
      exports2.blockIDFlagToJSON = blockIDFlagToJSON;
      var SignedMsgType;
      (function(SignedMsgType2) {
        SignedMsgType2[SignedMsgType2["SIGNED_MSG_TYPE_UNKNOWN"] = 0] = "SIGNED_MSG_TYPE_UNKNOWN";
        SignedMsgType2[SignedMsgType2["SIGNED_MSG_TYPE_PREVOTE"] = 1] = "SIGNED_MSG_TYPE_PREVOTE";
        SignedMsgType2[SignedMsgType2["SIGNED_MSG_TYPE_PRECOMMIT"] = 2] = "SIGNED_MSG_TYPE_PRECOMMIT";
        SignedMsgType2[SignedMsgType2["SIGNED_MSG_TYPE_PROPOSAL"] = 32] = "SIGNED_MSG_TYPE_PROPOSAL";
        SignedMsgType2[SignedMsgType2["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
      })(SignedMsgType = exports2.SignedMsgType || (exports2.SignedMsgType = {}));
      function signedMsgTypeFromJSON(object) {
        switch (object) {
          case 0:
          case "SIGNED_MSG_TYPE_UNKNOWN":
            return SignedMsgType.SIGNED_MSG_TYPE_UNKNOWN;
          case 1:
          case "SIGNED_MSG_TYPE_PREVOTE":
            return SignedMsgType.SIGNED_MSG_TYPE_PREVOTE;
          case 2:
          case "SIGNED_MSG_TYPE_PRECOMMIT":
            return SignedMsgType.SIGNED_MSG_TYPE_PRECOMMIT;
          case 32:
          case "SIGNED_MSG_TYPE_PROPOSAL":
            return SignedMsgType.SIGNED_MSG_TYPE_PROPOSAL;
          case -1:
          case "UNRECOGNIZED":
          default:
            return SignedMsgType.UNRECOGNIZED;
        }
      }
      exports2.signedMsgTypeFromJSON = signedMsgTypeFromJSON;
      function signedMsgTypeToJSON(object) {
        switch (object) {
          case SignedMsgType.SIGNED_MSG_TYPE_UNKNOWN:
            return "SIGNED_MSG_TYPE_UNKNOWN";
          case SignedMsgType.SIGNED_MSG_TYPE_PREVOTE:
            return "SIGNED_MSG_TYPE_PREVOTE";
          case SignedMsgType.SIGNED_MSG_TYPE_PRECOMMIT:
            return "SIGNED_MSG_TYPE_PRECOMMIT";
          case SignedMsgType.SIGNED_MSG_TYPE_PROPOSAL:
            return "SIGNED_MSG_TYPE_PROPOSAL";
          default:
            return "UNKNOWN";
        }
      }
      exports2.signedMsgTypeToJSON = signedMsgTypeToJSON;
      var basePartSetHeader = { total: 0 };
      exports2.PartSetHeader = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.total !== 0) {
            writer.uint32(8).uint32(message.total);
          }
          if (message.hash.length !== 0) {
            writer.uint32(18).bytes(message.hash);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, basePartSetHeader);
          message.hash = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.total = reader.uint32();
                break;
              case 2:
                message.hash = reader.bytes();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, basePartSetHeader);
          message.total = object.total !== void 0 && object.total !== null ? Number(object.total) : 0;
          message.hash = object.hash !== void 0 && object.hash !== null ? bytesFromBase64(object.hash) : new Uint8Array();
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.total !== void 0 && (obj.total = message.total);
          message.hash !== void 0 && (obj.hash = base64FromBytes(message.hash !== void 0 ? message.hash : new Uint8Array()));
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, basePartSetHeader);
          message.total = (_a = object.total) !== null && _a !== void 0 ? _a : 0;
          message.hash = (_b = object.hash) !== null && _b !== void 0 ? _b : new Uint8Array();
          return message;
        }
      };
      var basePart = { index: 0 };
      exports2.Part = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.index !== 0) {
            writer.uint32(8).uint32(message.index);
          }
          if (message.bytes.length !== 0) {
            writer.uint32(18).bytes(message.bytes);
          }
          if (message.proof !== void 0) {
            proof_1.Proof.encode(message.proof, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, basePart);
          message.bytes = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.index = reader.uint32();
                break;
              case 2:
                message.bytes = reader.bytes();
                break;
              case 3:
                message.proof = proof_1.Proof.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, basePart);
          message.index = object.index !== void 0 && object.index !== null ? Number(object.index) : 0;
          message.bytes = object.bytes !== void 0 && object.bytes !== null ? bytesFromBase64(object.bytes) : new Uint8Array();
          message.proof = object.proof !== void 0 && object.proof !== null ? proof_1.Proof.fromJSON(object.proof) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.index !== void 0 && (obj.index = message.index);
          message.bytes !== void 0 && (obj.bytes = base64FromBytes(message.bytes !== void 0 ? message.bytes : new Uint8Array()));
          message.proof !== void 0 && (obj.proof = message.proof ? proof_1.Proof.toJSON(message.proof) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, basePart);
          message.index = (_a = object.index) !== null && _a !== void 0 ? _a : 0;
          message.bytes = (_b = object.bytes) !== null && _b !== void 0 ? _b : new Uint8Array();
          message.proof = object.proof !== void 0 && object.proof !== null ? proof_1.Proof.fromPartial(object.proof) : void 0;
          return message;
        }
      };
      var baseBlockID = {};
      exports2.BlockID = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.hash.length !== 0) {
            writer.uint32(10).bytes(message.hash);
          }
          if (message.partSetHeader !== void 0) {
            exports2.PartSetHeader.encode(message.partSetHeader, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseBlockID);
          message.hash = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.hash = reader.bytes();
                break;
              case 2:
                message.partSetHeader = exports2.PartSetHeader.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseBlockID);
          message.hash = object.hash !== void 0 && object.hash !== null ? bytesFromBase64(object.hash) : new Uint8Array();
          message.partSetHeader = object.partSetHeader !== void 0 && object.partSetHeader !== null ? exports2.PartSetHeader.fromJSON(object.partSetHeader) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.hash !== void 0 && (obj.hash = base64FromBytes(message.hash !== void 0 ? message.hash : new Uint8Array()));
          message.partSetHeader !== void 0 && (obj.partSetHeader = message.partSetHeader ? exports2.PartSetHeader.toJSON(message.partSetHeader) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseBlockID);
          message.hash = (_a = object.hash) !== null && _a !== void 0 ? _a : new Uint8Array();
          message.partSetHeader = object.partSetHeader !== void 0 && object.partSetHeader !== null ? exports2.PartSetHeader.fromPartial(object.partSetHeader) : void 0;
          return message;
        }
      };
      var baseHeader = { chainId: "", height: long_1.default.ZERO };
      exports2.Header = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.version !== void 0) {
            types_1.Consensus.encode(message.version, writer.uint32(10).fork()).ldelim();
          }
          if (message.chainId !== "") {
            writer.uint32(18).string(message.chainId);
          }
          if (!message.height.isZero()) {
            writer.uint32(24).int64(message.height);
          }
          if (message.time !== void 0) {
            timestamp_1.Timestamp.encode(message.time, writer.uint32(34).fork()).ldelim();
          }
          if (message.lastBlockId !== void 0) {
            exports2.BlockID.encode(message.lastBlockId, writer.uint32(42).fork()).ldelim();
          }
          if (message.lastCommitHash.length !== 0) {
            writer.uint32(50).bytes(message.lastCommitHash);
          }
          if (message.dataHash.length !== 0) {
            writer.uint32(58).bytes(message.dataHash);
          }
          if (message.validatorsHash.length !== 0) {
            writer.uint32(66).bytes(message.validatorsHash);
          }
          if (message.nextValidatorsHash.length !== 0) {
            writer.uint32(74).bytes(message.nextValidatorsHash);
          }
          if (message.consensusHash.length !== 0) {
            writer.uint32(82).bytes(message.consensusHash);
          }
          if (message.appHash.length !== 0) {
            writer.uint32(90).bytes(message.appHash);
          }
          if (message.lastResultsHash.length !== 0) {
            writer.uint32(98).bytes(message.lastResultsHash);
          }
          if (message.evidenceHash.length !== 0) {
            writer.uint32(106).bytes(message.evidenceHash);
          }
          if (message.proposerAddress.length !== 0) {
            writer.uint32(114).bytes(message.proposerAddress);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseHeader);
          message.lastCommitHash = new Uint8Array();
          message.dataHash = new Uint8Array();
          message.validatorsHash = new Uint8Array();
          message.nextValidatorsHash = new Uint8Array();
          message.consensusHash = new Uint8Array();
          message.appHash = new Uint8Array();
          message.lastResultsHash = new Uint8Array();
          message.evidenceHash = new Uint8Array();
          message.proposerAddress = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.version = types_1.Consensus.decode(reader, reader.uint32());
                break;
              case 2:
                message.chainId = reader.string();
                break;
              case 3:
                message.height = reader.int64();
                break;
              case 4:
                message.time = timestamp_1.Timestamp.decode(reader, reader.uint32());
                break;
              case 5:
                message.lastBlockId = exports2.BlockID.decode(reader, reader.uint32());
                break;
              case 6:
                message.lastCommitHash = reader.bytes();
                break;
              case 7:
                message.dataHash = reader.bytes();
                break;
              case 8:
                message.validatorsHash = reader.bytes();
                break;
              case 9:
                message.nextValidatorsHash = reader.bytes();
                break;
              case 10:
                message.consensusHash = reader.bytes();
                break;
              case 11:
                message.appHash = reader.bytes();
                break;
              case 12:
                message.lastResultsHash = reader.bytes();
                break;
              case 13:
                message.evidenceHash = reader.bytes();
                break;
              case 14:
                message.proposerAddress = reader.bytes();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseHeader);
          message.version = object.version !== void 0 && object.version !== null ? types_1.Consensus.fromJSON(object.version) : void 0;
          message.chainId = object.chainId !== void 0 && object.chainId !== null ? String(object.chainId) : "";
          message.height = object.height !== void 0 && object.height !== null ? long_1.default.fromString(object.height) : long_1.default.ZERO;
          message.time = object.time !== void 0 && object.time !== null ? fromJsonTimestamp(object.time) : void 0;
          message.lastBlockId = object.lastBlockId !== void 0 && object.lastBlockId !== null ? exports2.BlockID.fromJSON(object.lastBlockId) : void 0;
          message.lastCommitHash = object.lastCommitHash !== void 0 && object.lastCommitHash !== null ? bytesFromBase64(object.lastCommitHash) : new Uint8Array();
          message.dataHash = object.dataHash !== void 0 && object.dataHash !== null ? bytesFromBase64(object.dataHash) : new Uint8Array();
          message.validatorsHash = object.validatorsHash !== void 0 && object.validatorsHash !== null ? bytesFromBase64(object.validatorsHash) : new Uint8Array();
          message.nextValidatorsHash = object.nextValidatorsHash !== void 0 && object.nextValidatorsHash !== null ? bytesFromBase64(object.nextValidatorsHash) : new Uint8Array();
          message.consensusHash = object.consensusHash !== void 0 && object.consensusHash !== null ? bytesFromBase64(object.consensusHash) : new Uint8Array();
          message.appHash = object.appHash !== void 0 && object.appHash !== null ? bytesFromBase64(object.appHash) : new Uint8Array();
          message.lastResultsHash = object.lastResultsHash !== void 0 && object.lastResultsHash !== null ? bytesFromBase64(object.lastResultsHash) : new Uint8Array();
          message.evidenceHash = object.evidenceHash !== void 0 && object.evidenceHash !== null ? bytesFromBase64(object.evidenceHash) : new Uint8Array();
          message.proposerAddress = object.proposerAddress !== void 0 && object.proposerAddress !== null ? bytesFromBase64(object.proposerAddress) : new Uint8Array();
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.version !== void 0 && (obj.version = message.version ? types_1.Consensus.toJSON(message.version) : void 0);
          message.chainId !== void 0 && (obj.chainId = message.chainId);
          message.height !== void 0 && (obj.height = (message.height || long_1.default.ZERO).toString());
          message.time !== void 0 && (obj.time = fromTimestamp(message.time).toISOString());
          message.lastBlockId !== void 0 && (obj.lastBlockId = message.lastBlockId ? exports2.BlockID.toJSON(message.lastBlockId) : void 0);
          message.lastCommitHash !== void 0 && (obj.lastCommitHash = base64FromBytes(message.lastCommitHash !== void 0 ? message.lastCommitHash : new Uint8Array()));
          message.dataHash !== void 0 && (obj.dataHash = base64FromBytes(message.dataHash !== void 0 ? message.dataHash : new Uint8Array()));
          message.validatorsHash !== void 0 && (obj.validatorsHash = base64FromBytes(message.validatorsHash !== void 0 ? message.validatorsHash : new Uint8Array()));
          message.nextValidatorsHash !== void 0 && (obj.nextValidatorsHash = base64FromBytes(message.nextValidatorsHash !== void 0 ? message.nextValidatorsHash : new Uint8Array()));
          message.consensusHash !== void 0 && (obj.consensusHash = base64FromBytes(message.consensusHash !== void 0 ? message.consensusHash : new Uint8Array()));
          message.appHash !== void 0 && (obj.appHash = base64FromBytes(message.appHash !== void 0 ? message.appHash : new Uint8Array()));
          message.lastResultsHash !== void 0 && (obj.lastResultsHash = base64FromBytes(message.lastResultsHash !== void 0 ? message.lastResultsHash : new Uint8Array()));
          message.evidenceHash !== void 0 && (obj.evidenceHash = base64FromBytes(message.evidenceHash !== void 0 ? message.evidenceHash : new Uint8Array()));
          message.proposerAddress !== void 0 && (obj.proposerAddress = base64FromBytes(message.proposerAddress !== void 0 ? message.proposerAddress : new Uint8Array()));
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
          const message = Object.assign({}, baseHeader);
          message.version = object.version !== void 0 && object.version !== null ? types_1.Consensus.fromPartial(object.version) : void 0;
          message.chainId = (_a = object.chainId) !== null && _a !== void 0 ? _a : "";
          message.height = object.height !== void 0 && object.height !== null ? long_1.default.fromValue(object.height) : long_1.default.ZERO;
          message.time = object.time !== void 0 && object.time !== null ? timestamp_1.Timestamp.fromPartial(object.time) : void 0;
          message.lastBlockId = object.lastBlockId !== void 0 && object.lastBlockId !== null ? exports2.BlockID.fromPartial(object.lastBlockId) : void 0;
          message.lastCommitHash = (_b = object.lastCommitHash) !== null && _b !== void 0 ? _b : new Uint8Array();
          message.dataHash = (_c = object.dataHash) !== null && _c !== void 0 ? _c : new Uint8Array();
          message.validatorsHash = (_d = object.validatorsHash) !== null && _d !== void 0 ? _d : new Uint8Array();
          message.nextValidatorsHash = (_e = object.nextValidatorsHash) !== null && _e !== void 0 ? _e : new Uint8Array();
          message.consensusHash = (_f = object.consensusHash) !== null && _f !== void 0 ? _f : new Uint8Array();
          message.appHash = (_g = object.appHash) !== null && _g !== void 0 ? _g : new Uint8Array();
          message.lastResultsHash = (_h = object.lastResultsHash) !== null && _h !== void 0 ? _h : new Uint8Array();
          message.evidenceHash = (_j = object.evidenceHash) !== null && _j !== void 0 ? _j : new Uint8Array();
          message.proposerAddress = (_k = object.proposerAddress) !== null && _k !== void 0 ? _k : new Uint8Array();
          return message;
        }
      };
      var baseData = {};
      exports2.Data = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.txs) {
            writer.uint32(10).bytes(v);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseData);
          message.txs = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.txs.push(reader.bytes());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseData);
          message.txs = ((_a = object.txs) !== null && _a !== void 0 ? _a : []).map((e) => bytesFromBase64(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.txs) {
            obj.txs = message.txs.map((e) => base64FromBytes(e !== void 0 ? e : new Uint8Array()));
          } else {
            obj.txs = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseData);
          message.txs = ((_a = object.txs) === null || _a === void 0 ? void 0 : _a.map((e) => e)) || [];
          return message;
        }
      };
      var baseVote = { type: 0, height: long_1.default.ZERO, round: 0, validatorIndex: 0 };
      exports2.Vote = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.type !== 0) {
            writer.uint32(8).int32(message.type);
          }
          if (!message.height.isZero()) {
            writer.uint32(16).int64(message.height);
          }
          if (message.round !== 0) {
            writer.uint32(24).int32(message.round);
          }
          if (message.blockId !== void 0) {
            exports2.BlockID.encode(message.blockId, writer.uint32(34).fork()).ldelim();
          }
          if (message.timestamp !== void 0) {
            timestamp_1.Timestamp.encode(message.timestamp, writer.uint32(42).fork()).ldelim();
          }
          if (message.validatorAddress.length !== 0) {
            writer.uint32(50).bytes(message.validatorAddress);
          }
          if (message.validatorIndex !== 0) {
            writer.uint32(56).int32(message.validatorIndex);
          }
          if (message.signature.length !== 0) {
            writer.uint32(66).bytes(message.signature);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseVote);
          message.validatorAddress = new Uint8Array();
          message.signature = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.type = reader.int32();
                break;
              case 2:
                message.height = reader.int64();
                break;
              case 3:
                message.round = reader.int32();
                break;
              case 4:
                message.blockId = exports2.BlockID.decode(reader, reader.uint32());
                break;
              case 5:
                message.timestamp = timestamp_1.Timestamp.decode(reader, reader.uint32());
                break;
              case 6:
                message.validatorAddress = reader.bytes();
                break;
              case 7:
                message.validatorIndex = reader.int32();
                break;
              case 8:
                message.signature = reader.bytes();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseVote);
          message.type = object.type !== void 0 && object.type !== null ? signedMsgTypeFromJSON(object.type) : 0;
          message.height = object.height !== void 0 && object.height !== null ? long_1.default.fromString(object.height) : long_1.default.ZERO;
          message.round = object.round !== void 0 && object.round !== null ? Number(object.round) : 0;
          message.blockId = object.blockId !== void 0 && object.blockId !== null ? exports2.BlockID.fromJSON(object.blockId) : void 0;
          message.timestamp = object.timestamp !== void 0 && object.timestamp !== null ? fromJsonTimestamp(object.timestamp) : void 0;
          message.validatorAddress = object.validatorAddress !== void 0 && object.validatorAddress !== null ? bytesFromBase64(object.validatorAddress) : new Uint8Array();
          message.validatorIndex = object.validatorIndex !== void 0 && object.validatorIndex !== null ? Number(object.validatorIndex) : 0;
          message.signature = object.signature !== void 0 && object.signature !== null ? bytesFromBase64(object.signature) : new Uint8Array();
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.type !== void 0 && (obj.type = signedMsgTypeToJSON(message.type));
          message.height !== void 0 && (obj.height = (message.height || long_1.default.ZERO).toString());
          message.round !== void 0 && (obj.round = message.round);
          message.blockId !== void 0 && (obj.blockId = message.blockId ? exports2.BlockID.toJSON(message.blockId) : void 0);
          message.timestamp !== void 0 && (obj.timestamp = fromTimestamp(message.timestamp).toISOString());
          message.validatorAddress !== void 0 && (obj.validatorAddress = base64FromBytes(message.validatorAddress !== void 0 ? message.validatorAddress : new Uint8Array()));
          message.validatorIndex !== void 0 && (obj.validatorIndex = message.validatorIndex);
          message.signature !== void 0 && (obj.signature = base64FromBytes(message.signature !== void 0 ? message.signature : new Uint8Array()));
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c, _d, _e;
          const message = Object.assign({}, baseVote);
          message.type = (_a = object.type) !== null && _a !== void 0 ? _a : 0;
          message.height = object.height !== void 0 && object.height !== null ? long_1.default.fromValue(object.height) : long_1.default.ZERO;
          message.round = (_b = object.round) !== null && _b !== void 0 ? _b : 0;
          message.blockId = object.blockId !== void 0 && object.blockId !== null ? exports2.BlockID.fromPartial(object.blockId) : void 0;
          message.timestamp = object.timestamp !== void 0 && object.timestamp !== null ? timestamp_1.Timestamp.fromPartial(object.timestamp) : void 0;
          message.validatorAddress = (_c = object.validatorAddress) !== null && _c !== void 0 ? _c : new Uint8Array();
          message.validatorIndex = (_d = object.validatorIndex) !== null && _d !== void 0 ? _d : 0;
          message.signature = (_e = object.signature) !== null && _e !== void 0 ? _e : new Uint8Array();
          return message;
        }
      };
      var baseCommit = { height: long_1.default.ZERO, round: 0 };
      exports2.Commit = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.height.isZero()) {
            writer.uint32(8).int64(message.height);
          }
          if (message.round !== 0) {
            writer.uint32(16).int32(message.round);
          }
          if (message.blockId !== void 0) {
            exports2.BlockID.encode(message.blockId, writer.uint32(26).fork()).ldelim();
          }
          for (const v of message.signatures) {
            exports2.CommitSig.encode(v, writer.uint32(34).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseCommit);
          message.signatures = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.height = reader.int64();
                break;
              case 2:
                message.round = reader.int32();
                break;
              case 3:
                message.blockId = exports2.BlockID.decode(reader, reader.uint32());
                break;
              case 4:
                message.signatures.push(exports2.CommitSig.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseCommit);
          message.height = object.height !== void 0 && object.height !== null ? long_1.default.fromString(object.height) : long_1.default.ZERO;
          message.round = object.round !== void 0 && object.round !== null ? Number(object.round) : 0;
          message.blockId = object.blockId !== void 0 && object.blockId !== null ? exports2.BlockID.fromJSON(object.blockId) : void 0;
          message.signatures = ((_a = object.signatures) !== null && _a !== void 0 ? _a : []).map((e) => exports2.CommitSig.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.height !== void 0 && (obj.height = (message.height || long_1.default.ZERO).toString());
          message.round !== void 0 && (obj.round = message.round);
          message.blockId !== void 0 && (obj.blockId = message.blockId ? exports2.BlockID.toJSON(message.blockId) : void 0);
          if (message.signatures) {
            obj.signatures = message.signatures.map((e) => e ? exports2.CommitSig.toJSON(e) : void 0);
          } else {
            obj.signatures = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseCommit);
          message.height = object.height !== void 0 && object.height !== null ? long_1.default.fromValue(object.height) : long_1.default.ZERO;
          message.round = (_a = object.round) !== null && _a !== void 0 ? _a : 0;
          message.blockId = object.blockId !== void 0 && object.blockId !== null ? exports2.BlockID.fromPartial(object.blockId) : void 0;
          message.signatures = ((_b = object.signatures) === null || _b === void 0 ? void 0 : _b.map((e) => exports2.CommitSig.fromPartial(e))) || [];
          return message;
        }
      };
      var baseCommitSig = { blockIdFlag: 0 };
      exports2.CommitSig = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.blockIdFlag !== 0) {
            writer.uint32(8).int32(message.blockIdFlag);
          }
          if (message.validatorAddress.length !== 0) {
            writer.uint32(18).bytes(message.validatorAddress);
          }
          if (message.timestamp !== void 0) {
            timestamp_1.Timestamp.encode(message.timestamp, writer.uint32(26).fork()).ldelim();
          }
          if (message.signature.length !== 0) {
            writer.uint32(34).bytes(message.signature);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseCommitSig);
          message.validatorAddress = new Uint8Array();
          message.signature = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.blockIdFlag = reader.int32();
                break;
              case 2:
                message.validatorAddress = reader.bytes();
                break;
              case 3:
                message.timestamp = timestamp_1.Timestamp.decode(reader, reader.uint32());
                break;
              case 4:
                message.signature = reader.bytes();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseCommitSig);
          message.blockIdFlag = object.blockIdFlag !== void 0 && object.blockIdFlag !== null ? blockIDFlagFromJSON(object.blockIdFlag) : 0;
          message.validatorAddress = object.validatorAddress !== void 0 && object.validatorAddress !== null ? bytesFromBase64(object.validatorAddress) : new Uint8Array();
          message.timestamp = object.timestamp !== void 0 && object.timestamp !== null ? fromJsonTimestamp(object.timestamp) : void 0;
          message.signature = object.signature !== void 0 && object.signature !== null ? bytesFromBase64(object.signature) : new Uint8Array();
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.blockIdFlag !== void 0 && (obj.blockIdFlag = blockIDFlagToJSON(message.blockIdFlag));
          message.validatorAddress !== void 0 && (obj.validatorAddress = base64FromBytes(message.validatorAddress !== void 0 ? message.validatorAddress : new Uint8Array()));
          message.timestamp !== void 0 && (obj.timestamp = fromTimestamp(message.timestamp).toISOString());
          message.signature !== void 0 && (obj.signature = base64FromBytes(message.signature !== void 0 ? message.signature : new Uint8Array()));
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseCommitSig);
          message.blockIdFlag = (_a = object.blockIdFlag) !== null && _a !== void 0 ? _a : 0;
          message.validatorAddress = (_b = object.validatorAddress) !== null && _b !== void 0 ? _b : new Uint8Array();
          message.timestamp = object.timestamp !== void 0 && object.timestamp !== null ? timestamp_1.Timestamp.fromPartial(object.timestamp) : void 0;
          message.signature = (_c = object.signature) !== null && _c !== void 0 ? _c : new Uint8Array();
          return message;
        }
      };
      var baseProposal = { type: 0, height: long_1.default.ZERO, round: 0, polRound: 0 };
      exports2.Proposal = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.type !== 0) {
            writer.uint32(8).int32(message.type);
          }
          if (!message.height.isZero()) {
            writer.uint32(16).int64(message.height);
          }
          if (message.round !== 0) {
            writer.uint32(24).int32(message.round);
          }
          if (message.polRound !== 0) {
            writer.uint32(32).int32(message.polRound);
          }
          if (message.blockId !== void 0) {
            exports2.BlockID.encode(message.blockId, writer.uint32(42).fork()).ldelim();
          }
          if (message.timestamp !== void 0) {
            timestamp_1.Timestamp.encode(message.timestamp, writer.uint32(50).fork()).ldelim();
          }
          if (message.signature.length !== 0) {
            writer.uint32(58).bytes(message.signature);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseProposal);
          message.signature = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.type = reader.int32();
                break;
              case 2:
                message.height = reader.int64();
                break;
              case 3:
                message.round = reader.int32();
                break;
              case 4:
                message.polRound = reader.int32();
                break;
              case 5:
                message.blockId = exports2.BlockID.decode(reader, reader.uint32());
                break;
              case 6:
                message.timestamp = timestamp_1.Timestamp.decode(reader, reader.uint32());
                break;
              case 7:
                message.signature = reader.bytes();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseProposal);
          message.type = object.type !== void 0 && object.type !== null ? signedMsgTypeFromJSON(object.type) : 0;
          message.height = object.height !== void 0 && object.height !== null ? long_1.default.fromString(object.height) : long_1.default.ZERO;
          message.round = object.round !== void 0 && object.round !== null ? Number(object.round) : 0;
          message.polRound = object.polRound !== void 0 && object.polRound !== null ? Number(object.polRound) : 0;
          message.blockId = object.blockId !== void 0 && object.blockId !== null ? exports2.BlockID.fromJSON(object.blockId) : void 0;
          message.timestamp = object.timestamp !== void 0 && object.timestamp !== null ? fromJsonTimestamp(object.timestamp) : void 0;
          message.signature = object.signature !== void 0 && object.signature !== null ? bytesFromBase64(object.signature) : new Uint8Array();
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.type !== void 0 && (obj.type = signedMsgTypeToJSON(message.type));
          message.height !== void 0 && (obj.height = (message.height || long_1.default.ZERO).toString());
          message.round !== void 0 && (obj.round = message.round);
          message.polRound !== void 0 && (obj.polRound = message.polRound);
          message.blockId !== void 0 && (obj.blockId = message.blockId ? exports2.BlockID.toJSON(message.blockId) : void 0);
          message.timestamp !== void 0 && (obj.timestamp = fromTimestamp(message.timestamp).toISOString());
          message.signature !== void 0 && (obj.signature = base64FromBytes(message.signature !== void 0 ? message.signature : new Uint8Array()));
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c, _d;
          const message = Object.assign({}, baseProposal);
          message.type = (_a = object.type) !== null && _a !== void 0 ? _a : 0;
          message.height = object.height !== void 0 && object.height !== null ? long_1.default.fromValue(object.height) : long_1.default.ZERO;
          message.round = (_b = object.round) !== null && _b !== void 0 ? _b : 0;
          message.polRound = (_c = object.polRound) !== null && _c !== void 0 ? _c : 0;
          message.blockId = object.blockId !== void 0 && object.blockId !== null ? exports2.BlockID.fromPartial(object.blockId) : void 0;
          message.timestamp = object.timestamp !== void 0 && object.timestamp !== null ? timestamp_1.Timestamp.fromPartial(object.timestamp) : void 0;
          message.signature = (_d = object.signature) !== null && _d !== void 0 ? _d : new Uint8Array();
          return message;
        }
      };
      var baseSignedHeader = {};
      exports2.SignedHeader = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.header !== void 0) {
            exports2.Header.encode(message.header, writer.uint32(10).fork()).ldelim();
          }
          if (message.commit !== void 0) {
            exports2.Commit.encode(message.commit, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseSignedHeader);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.header = exports2.Header.decode(reader, reader.uint32());
                break;
              case 2:
                message.commit = exports2.Commit.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseSignedHeader);
          message.header = object.header !== void 0 && object.header !== null ? exports2.Header.fromJSON(object.header) : void 0;
          message.commit = object.commit !== void 0 && object.commit !== null ? exports2.Commit.fromJSON(object.commit) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.header !== void 0 && (obj.header = message.header ? exports2.Header.toJSON(message.header) : void 0);
          message.commit !== void 0 && (obj.commit = message.commit ? exports2.Commit.toJSON(message.commit) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseSignedHeader);
          message.header = object.header !== void 0 && object.header !== null ? exports2.Header.fromPartial(object.header) : void 0;
          message.commit = object.commit !== void 0 && object.commit !== null ? exports2.Commit.fromPartial(object.commit) : void 0;
          return message;
        }
      };
      var baseLightBlock = {};
      exports2.LightBlock = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.signedHeader !== void 0) {
            exports2.SignedHeader.encode(message.signedHeader, writer.uint32(10).fork()).ldelim();
          }
          if (message.validatorSet !== void 0) {
            validator_1.ValidatorSet.encode(message.validatorSet, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseLightBlock);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.signedHeader = exports2.SignedHeader.decode(reader, reader.uint32());
                break;
              case 2:
                message.validatorSet = validator_1.ValidatorSet.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseLightBlock);
          message.signedHeader = object.signedHeader !== void 0 && object.signedHeader !== null ? exports2.SignedHeader.fromJSON(object.signedHeader) : void 0;
          message.validatorSet = object.validatorSet !== void 0 && object.validatorSet !== null ? validator_1.ValidatorSet.fromJSON(object.validatorSet) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.signedHeader !== void 0 && (obj.signedHeader = message.signedHeader ? exports2.SignedHeader.toJSON(message.signedHeader) : void 0);
          message.validatorSet !== void 0 && (obj.validatorSet = message.validatorSet ? validator_1.ValidatorSet.toJSON(message.validatorSet) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseLightBlock);
          message.signedHeader = object.signedHeader !== void 0 && object.signedHeader !== null ? exports2.SignedHeader.fromPartial(object.signedHeader) : void 0;
          message.validatorSet = object.validatorSet !== void 0 && object.validatorSet !== null ? validator_1.ValidatorSet.fromPartial(object.validatorSet) : void 0;
          return message;
        }
      };
      var baseBlockMeta = { blockSize: long_1.default.ZERO, numTxs: long_1.default.ZERO };
      exports2.BlockMeta = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.blockId !== void 0) {
            exports2.BlockID.encode(message.blockId, writer.uint32(10).fork()).ldelim();
          }
          if (!message.blockSize.isZero()) {
            writer.uint32(16).int64(message.blockSize);
          }
          if (message.header !== void 0) {
            exports2.Header.encode(message.header, writer.uint32(26).fork()).ldelim();
          }
          if (!message.numTxs.isZero()) {
            writer.uint32(32).int64(message.numTxs);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseBlockMeta);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.blockId = exports2.BlockID.decode(reader, reader.uint32());
                break;
              case 2:
                message.blockSize = reader.int64();
                break;
              case 3:
                message.header = exports2.Header.decode(reader, reader.uint32());
                break;
              case 4:
                message.numTxs = reader.int64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseBlockMeta);
          message.blockId = object.blockId !== void 0 && object.blockId !== null ? exports2.BlockID.fromJSON(object.blockId) : void 0;
          message.blockSize = object.blockSize !== void 0 && object.blockSize !== null ? long_1.default.fromString(object.blockSize) : long_1.default.ZERO;
          message.header = object.header !== void 0 && object.header !== null ? exports2.Header.fromJSON(object.header) : void 0;
          message.numTxs = object.numTxs !== void 0 && object.numTxs !== null ? long_1.default.fromString(object.numTxs) : long_1.default.ZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.blockId !== void 0 && (obj.blockId = message.blockId ? exports2.BlockID.toJSON(message.blockId) : void 0);
          message.blockSize !== void 0 && (obj.blockSize = (message.blockSize || long_1.default.ZERO).toString());
          message.header !== void 0 && (obj.header = message.header ? exports2.Header.toJSON(message.header) : void 0);
          message.numTxs !== void 0 && (obj.numTxs = (message.numTxs || long_1.default.ZERO).toString());
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseBlockMeta);
          message.blockId = object.blockId !== void 0 && object.blockId !== null ? exports2.BlockID.fromPartial(object.blockId) : void 0;
          message.blockSize = object.blockSize !== void 0 && object.blockSize !== null ? long_1.default.fromValue(object.blockSize) : long_1.default.ZERO;
          message.header = object.header !== void 0 && object.header !== null ? exports2.Header.fromPartial(object.header) : void 0;
          message.numTxs = object.numTxs !== void 0 && object.numTxs !== null ? long_1.default.fromValue(object.numTxs) : long_1.default.ZERO;
          return message;
        }
      };
      var baseTxProof = {};
      exports2.TxProof = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.rootHash.length !== 0) {
            writer.uint32(10).bytes(message.rootHash);
          }
          if (message.data.length !== 0) {
            writer.uint32(18).bytes(message.data);
          }
          if (message.proof !== void 0) {
            proof_1.Proof.encode(message.proof, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseTxProof);
          message.rootHash = new Uint8Array();
          message.data = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.rootHash = reader.bytes();
                break;
              case 2:
                message.data = reader.bytes();
                break;
              case 3:
                message.proof = proof_1.Proof.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseTxProof);
          message.rootHash = object.rootHash !== void 0 && object.rootHash !== null ? bytesFromBase64(object.rootHash) : new Uint8Array();
          message.data = object.data !== void 0 && object.data !== null ? bytesFromBase64(object.data) : new Uint8Array();
          message.proof = object.proof !== void 0 && object.proof !== null ? proof_1.Proof.fromJSON(object.proof) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.rootHash !== void 0 && (obj.rootHash = base64FromBytes(message.rootHash !== void 0 ? message.rootHash : new Uint8Array()));
          message.data !== void 0 && (obj.data = base64FromBytes(message.data !== void 0 ? message.data : new Uint8Array()));
          message.proof !== void 0 && (obj.proof = message.proof ? proof_1.Proof.toJSON(message.proof) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseTxProof);
          message.rootHash = (_a = object.rootHash) !== null && _a !== void 0 ? _a : new Uint8Array();
          message.data = (_b = object.data) !== null && _b !== void 0 ? _b : new Uint8Array();
          message.proof = object.proof !== void 0 && object.proof !== null ? proof_1.Proof.fromPartial(object.proof) : void 0;
          return message;
        }
      };
      var globalThis2 = (() => {
        if (typeof globalThis2 !== "undefined")
          return globalThis2;
        if (typeof self !== "undefined")
          return self;
        if (typeof window !== "undefined")
          return window;
        if (typeof global !== "undefined")
          return global;
        throw "Unable to locate global object";
      })();
      var atob2 = globalThis2.atob || ((b64) => globalThis2.Buffer.from(b64, "base64").toString("binary"));
      function bytesFromBase64(b64) {
        const bin = atob2(b64);
        const arr = new Uint8Array(bin.length);
        for (let i = 0; i < bin.length; ++i) {
          arr[i] = bin.charCodeAt(i);
        }
        return arr;
      }
      var btoa2 = globalThis2.btoa || ((bin) => globalThis2.Buffer.from(bin, "binary").toString("base64"));
      function base64FromBytes(arr) {
        const bin = [];
        for (const byte of arr) {
          bin.push(String.fromCharCode(byte));
        }
        return btoa2(bin.join(""));
      }
      function toTimestamp(date) {
        const seconds = numberToLong(date.getTime() / 1e3);
        const nanos = date.getTime() % 1e3 * 1e6;
        return { seconds, nanos };
      }
      function fromTimestamp(t) {
        let millis = t.seconds.toNumber() * 1e3;
        millis += t.nanos / 1e6;
        return new Date(millis);
      }
      function fromJsonTimestamp(o) {
        if (o instanceof Date) {
          return toTimestamp(o);
        } else if (typeof o === "string") {
          return toTimestamp(new Date(o));
        } else {
          return timestamp_1.Timestamp.fromJSON(o);
        }
      }
      function numberToLong(number) {
        return long_1.default.fromNumber(number);
      }
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/cosmjs-types/ibc/lightclients/tendermint/v1/tendermint.js
  var require_tendermint = __commonJS({
    "node_modules/cosmjs-types/ibc/lightclients/tendermint/v1/tendermint.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.Fraction = exports2.Header = exports2.Misbehaviour = exports2.ConsensusState = exports2.ClientState = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var duration_1 = require_duration();
      var client_1 = require_client();
      var timestamp_1 = require_timestamp();
      var commitment_1 = require_commitment();
      var types_1 = require_types2();
      var validator_1 = require_validator();
      var proofs_1 = require_proofs2();
      exports2.protobufPackage = "ibc.lightclients.tendermint.v1";
      var baseClientState = {
        chainId: "",
        upgradePath: "",
        allowUpdateAfterExpiry: false,
        allowUpdateAfterMisbehaviour: false
      };
      exports2.ClientState = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.chainId !== "") {
            writer.uint32(10).string(message.chainId);
          }
          if (message.trustLevel !== void 0) {
            exports2.Fraction.encode(message.trustLevel, writer.uint32(18).fork()).ldelim();
          }
          if (message.trustingPeriod !== void 0) {
            duration_1.Duration.encode(message.trustingPeriod, writer.uint32(26).fork()).ldelim();
          }
          if (message.unbondingPeriod !== void 0) {
            duration_1.Duration.encode(message.unbondingPeriod, writer.uint32(34).fork()).ldelim();
          }
          if (message.maxClockDrift !== void 0) {
            duration_1.Duration.encode(message.maxClockDrift, writer.uint32(42).fork()).ldelim();
          }
          if (message.frozenHeight !== void 0) {
            client_1.Height.encode(message.frozenHeight, writer.uint32(50).fork()).ldelim();
          }
          if (message.latestHeight !== void 0) {
            client_1.Height.encode(message.latestHeight, writer.uint32(58).fork()).ldelim();
          }
          for (const v of message.proofSpecs) {
            proofs_1.ProofSpec.encode(v, writer.uint32(66).fork()).ldelim();
          }
          for (const v of message.upgradePath) {
            writer.uint32(74).string(v);
          }
          if (message.allowUpdateAfterExpiry === true) {
            writer.uint32(80).bool(message.allowUpdateAfterExpiry);
          }
          if (message.allowUpdateAfterMisbehaviour === true) {
            writer.uint32(88).bool(message.allowUpdateAfterMisbehaviour);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseClientState);
          message.proofSpecs = [];
          message.upgradePath = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.chainId = reader.string();
                break;
              case 2:
                message.trustLevel = exports2.Fraction.decode(reader, reader.uint32());
                break;
              case 3:
                message.trustingPeriod = duration_1.Duration.decode(reader, reader.uint32());
                break;
              case 4:
                message.unbondingPeriod = duration_1.Duration.decode(reader, reader.uint32());
                break;
              case 5:
                message.maxClockDrift = duration_1.Duration.decode(reader, reader.uint32());
                break;
              case 6:
                message.frozenHeight = client_1.Height.decode(reader, reader.uint32());
                break;
              case 7:
                message.latestHeight = client_1.Height.decode(reader, reader.uint32());
                break;
              case 8:
                message.proofSpecs.push(proofs_1.ProofSpec.decode(reader, reader.uint32()));
                break;
              case 9:
                message.upgradePath.push(reader.string());
                break;
              case 10:
                message.allowUpdateAfterExpiry = reader.bool();
                break;
              case 11:
                message.allowUpdateAfterMisbehaviour = reader.bool();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a, _b;
          const message = Object.assign({}, baseClientState);
          message.chainId = object.chainId !== void 0 && object.chainId !== null ? String(object.chainId) : "";
          message.trustLevel = object.trustLevel !== void 0 && object.trustLevel !== null ? exports2.Fraction.fromJSON(object.trustLevel) : void 0;
          message.trustingPeriod = object.trustingPeriod !== void 0 && object.trustingPeriod !== null ? duration_1.Duration.fromJSON(object.trustingPeriod) : void 0;
          message.unbondingPeriod = object.unbondingPeriod !== void 0 && object.unbondingPeriod !== null ? duration_1.Duration.fromJSON(object.unbondingPeriod) : void 0;
          message.maxClockDrift = object.maxClockDrift !== void 0 && object.maxClockDrift !== null ? duration_1.Duration.fromJSON(object.maxClockDrift) : void 0;
          message.frozenHeight = object.frozenHeight !== void 0 && object.frozenHeight !== null ? client_1.Height.fromJSON(object.frozenHeight) : void 0;
          message.latestHeight = object.latestHeight !== void 0 && object.latestHeight !== null ? client_1.Height.fromJSON(object.latestHeight) : void 0;
          message.proofSpecs = ((_a = object.proofSpecs) !== null && _a !== void 0 ? _a : []).map((e) => proofs_1.ProofSpec.fromJSON(e));
          message.upgradePath = ((_b = object.upgradePath) !== null && _b !== void 0 ? _b : []).map((e) => String(e));
          message.allowUpdateAfterExpiry = object.allowUpdateAfterExpiry !== void 0 && object.allowUpdateAfterExpiry !== null ? Boolean(object.allowUpdateAfterExpiry) : false;
          message.allowUpdateAfterMisbehaviour = object.allowUpdateAfterMisbehaviour !== void 0 && object.allowUpdateAfterMisbehaviour !== null ? Boolean(object.allowUpdateAfterMisbehaviour) : false;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.chainId !== void 0 && (obj.chainId = message.chainId);
          message.trustLevel !== void 0 && (obj.trustLevel = message.trustLevel ? exports2.Fraction.toJSON(message.trustLevel) : void 0);
          message.trustingPeriod !== void 0 && (obj.trustingPeriod = message.trustingPeriod ? duration_1.Duration.toJSON(message.trustingPeriod) : void 0);
          message.unbondingPeriod !== void 0 && (obj.unbondingPeriod = message.unbondingPeriod ? duration_1.Duration.toJSON(message.unbondingPeriod) : void 0);
          message.maxClockDrift !== void 0 && (obj.maxClockDrift = message.maxClockDrift ? duration_1.Duration.toJSON(message.maxClockDrift) : void 0);
          message.frozenHeight !== void 0 && (obj.frozenHeight = message.frozenHeight ? client_1.Height.toJSON(message.frozenHeight) : void 0);
          message.latestHeight !== void 0 && (obj.latestHeight = message.latestHeight ? client_1.Height.toJSON(message.latestHeight) : void 0);
          if (message.proofSpecs) {
            obj.proofSpecs = message.proofSpecs.map((e) => e ? proofs_1.ProofSpec.toJSON(e) : void 0);
          } else {
            obj.proofSpecs = [];
          }
          if (message.upgradePath) {
            obj.upgradePath = message.upgradePath.map((e) => e);
          } else {
            obj.upgradePath = [];
          }
          message.allowUpdateAfterExpiry !== void 0 && (obj.allowUpdateAfterExpiry = message.allowUpdateAfterExpiry);
          message.allowUpdateAfterMisbehaviour !== void 0 && (obj.allowUpdateAfterMisbehaviour = message.allowUpdateAfterMisbehaviour);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c, _d, _e;
          const message = Object.assign({}, baseClientState);
          message.chainId = (_a = object.chainId) !== null && _a !== void 0 ? _a : "";
          message.trustLevel = object.trustLevel !== void 0 && object.trustLevel !== null ? exports2.Fraction.fromPartial(object.trustLevel) : void 0;
          message.trustingPeriod = object.trustingPeriod !== void 0 && object.trustingPeriod !== null ? duration_1.Duration.fromPartial(object.trustingPeriod) : void 0;
          message.unbondingPeriod = object.unbondingPeriod !== void 0 && object.unbondingPeriod !== null ? duration_1.Duration.fromPartial(object.unbondingPeriod) : void 0;
          message.maxClockDrift = object.maxClockDrift !== void 0 && object.maxClockDrift !== null ? duration_1.Duration.fromPartial(object.maxClockDrift) : void 0;
          message.frozenHeight = object.frozenHeight !== void 0 && object.frozenHeight !== null ? client_1.Height.fromPartial(object.frozenHeight) : void 0;
          message.latestHeight = object.latestHeight !== void 0 && object.latestHeight !== null ? client_1.Height.fromPartial(object.latestHeight) : void 0;
          message.proofSpecs = ((_b = object.proofSpecs) === null || _b === void 0 ? void 0 : _b.map((e) => proofs_1.ProofSpec.fromPartial(e))) || [];
          message.upgradePath = ((_c = object.upgradePath) === null || _c === void 0 ? void 0 : _c.map((e) => e)) || [];
          message.allowUpdateAfterExpiry = (_d = object.allowUpdateAfterExpiry) !== null && _d !== void 0 ? _d : false;
          message.allowUpdateAfterMisbehaviour = (_e = object.allowUpdateAfterMisbehaviour) !== null && _e !== void 0 ? _e : false;
          return message;
        }
      };
      var baseConsensusState = {};
      exports2.ConsensusState = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.timestamp !== void 0) {
            timestamp_1.Timestamp.encode(message.timestamp, writer.uint32(10).fork()).ldelim();
          }
          if (message.root !== void 0) {
            commitment_1.MerkleRoot.encode(message.root, writer.uint32(18).fork()).ldelim();
          }
          if (message.nextValidatorsHash.length !== 0) {
            writer.uint32(26).bytes(message.nextValidatorsHash);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseConsensusState);
          message.nextValidatorsHash = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.timestamp = timestamp_1.Timestamp.decode(reader, reader.uint32());
                break;
              case 2:
                message.root = commitment_1.MerkleRoot.decode(reader, reader.uint32());
                break;
              case 3:
                message.nextValidatorsHash = reader.bytes();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseConsensusState);
          message.timestamp = object.timestamp !== void 0 && object.timestamp !== null ? fromJsonTimestamp(object.timestamp) : void 0;
          message.root = object.root !== void 0 && object.root !== null ? commitment_1.MerkleRoot.fromJSON(object.root) : void 0;
          message.nextValidatorsHash = object.nextValidatorsHash !== void 0 && object.nextValidatorsHash !== null ? bytesFromBase64(object.nextValidatorsHash) : new Uint8Array();
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.timestamp !== void 0 && (obj.timestamp = fromTimestamp(message.timestamp).toISOString());
          message.root !== void 0 && (obj.root = message.root ? commitment_1.MerkleRoot.toJSON(message.root) : void 0);
          message.nextValidatorsHash !== void 0 && (obj.nextValidatorsHash = base64FromBytes(message.nextValidatorsHash !== void 0 ? message.nextValidatorsHash : new Uint8Array()));
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseConsensusState);
          message.timestamp = object.timestamp !== void 0 && object.timestamp !== null ? timestamp_1.Timestamp.fromPartial(object.timestamp) : void 0;
          message.root = object.root !== void 0 && object.root !== null ? commitment_1.MerkleRoot.fromPartial(object.root) : void 0;
          message.nextValidatorsHash = (_a = object.nextValidatorsHash) !== null && _a !== void 0 ? _a : new Uint8Array();
          return message;
        }
      };
      var baseMisbehaviour = { clientId: "" };
      exports2.Misbehaviour = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.clientId !== "") {
            writer.uint32(10).string(message.clientId);
          }
          if (message.header1 !== void 0) {
            exports2.Header.encode(message.header1, writer.uint32(18).fork()).ldelim();
          }
          if (message.header2 !== void 0) {
            exports2.Header.encode(message.header2, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMisbehaviour);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.clientId = reader.string();
                break;
              case 2:
                message.header1 = exports2.Header.decode(reader, reader.uint32());
                break;
              case 3:
                message.header2 = exports2.Header.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMisbehaviour);
          message.clientId = object.clientId !== void 0 && object.clientId !== null ? String(object.clientId) : "";
          message.header1 = object.header1 !== void 0 && object.header1 !== null ? exports2.Header.fromJSON(object.header1) : void 0;
          message.header2 = object.header2 !== void 0 && object.header2 !== null ? exports2.Header.fromJSON(object.header2) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.clientId !== void 0 && (obj.clientId = message.clientId);
          message.header1 !== void 0 && (obj.header1 = message.header1 ? exports2.Header.toJSON(message.header1) : void 0);
          message.header2 !== void 0 && (obj.header2 = message.header2 ? exports2.Header.toJSON(message.header2) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseMisbehaviour);
          message.clientId = (_a = object.clientId) !== null && _a !== void 0 ? _a : "";
          message.header1 = object.header1 !== void 0 && object.header1 !== null ? exports2.Header.fromPartial(object.header1) : void 0;
          message.header2 = object.header2 !== void 0 && object.header2 !== null ? exports2.Header.fromPartial(object.header2) : void 0;
          return message;
        }
      };
      var baseHeader = {};
      exports2.Header = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.signedHeader !== void 0) {
            types_1.SignedHeader.encode(message.signedHeader, writer.uint32(10).fork()).ldelim();
          }
          if (message.validatorSet !== void 0) {
            validator_1.ValidatorSet.encode(message.validatorSet, writer.uint32(18).fork()).ldelim();
          }
          if (message.trustedHeight !== void 0) {
            client_1.Height.encode(message.trustedHeight, writer.uint32(26).fork()).ldelim();
          }
          if (message.trustedValidators !== void 0) {
            validator_1.ValidatorSet.encode(message.trustedValidators, writer.uint32(34).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseHeader);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.signedHeader = types_1.SignedHeader.decode(reader, reader.uint32());
                break;
              case 2:
                message.validatorSet = validator_1.ValidatorSet.decode(reader, reader.uint32());
                break;
              case 3:
                message.trustedHeight = client_1.Height.decode(reader, reader.uint32());
                break;
              case 4:
                message.trustedValidators = validator_1.ValidatorSet.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseHeader);
          message.signedHeader = object.signedHeader !== void 0 && object.signedHeader !== null ? types_1.SignedHeader.fromJSON(object.signedHeader) : void 0;
          message.validatorSet = object.validatorSet !== void 0 && object.validatorSet !== null ? validator_1.ValidatorSet.fromJSON(object.validatorSet) : void 0;
          message.trustedHeight = object.trustedHeight !== void 0 && object.trustedHeight !== null ? client_1.Height.fromJSON(object.trustedHeight) : void 0;
          message.trustedValidators = object.trustedValidators !== void 0 && object.trustedValidators !== null ? validator_1.ValidatorSet.fromJSON(object.trustedValidators) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.signedHeader !== void 0 && (obj.signedHeader = message.signedHeader ? types_1.SignedHeader.toJSON(message.signedHeader) : void 0);
          message.validatorSet !== void 0 && (obj.validatorSet = message.validatorSet ? validator_1.ValidatorSet.toJSON(message.validatorSet) : void 0);
          message.trustedHeight !== void 0 && (obj.trustedHeight = message.trustedHeight ? client_1.Height.toJSON(message.trustedHeight) : void 0);
          message.trustedValidators !== void 0 && (obj.trustedValidators = message.trustedValidators ? validator_1.ValidatorSet.toJSON(message.trustedValidators) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseHeader);
          message.signedHeader = object.signedHeader !== void 0 && object.signedHeader !== null ? types_1.SignedHeader.fromPartial(object.signedHeader) : void 0;
          message.validatorSet = object.validatorSet !== void 0 && object.validatorSet !== null ? validator_1.ValidatorSet.fromPartial(object.validatorSet) : void 0;
          message.trustedHeight = object.trustedHeight !== void 0 && object.trustedHeight !== null ? client_1.Height.fromPartial(object.trustedHeight) : void 0;
          message.trustedValidators = object.trustedValidators !== void 0 && object.trustedValidators !== null ? validator_1.ValidatorSet.fromPartial(object.trustedValidators) : void 0;
          return message;
        }
      };
      var baseFraction = { numerator: long_1.default.UZERO, denominator: long_1.default.UZERO };
      exports2.Fraction = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.numerator.isZero()) {
            writer.uint32(8).uint64(message.numerator);
          }
          if (!message.denominator.isZero()) {
            writer.uint32(16).uint64(message.denominator);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseFraction);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.numerator = reader.uint64();
                break;
              case 2:
                message.denominator = reader.uint64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseFraction);
          message.numerator = object.numerator !== void 0 && object.numerator !== null ? long_1.default.fromString(object.numerator) : long_1.default.UZERO;
          message.denominator = object.denominator !== void 0 && object.denominator !== null ? long_1.default.fromString(object.denominator) : long_1.default.UZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.numerator !== void 0 && (obj.numerator = (message.numerator || long_1.default.UZERO).toString());
          message.denominator !== void 0 && (obj.denominator = (message.denominator || long_1.default.UZERO).toString());
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseFraction);
          message.numerator = object.numerator !== void 0 && object.numerator !== null ? long_1.default.fromValue(object.numerator) : long_1.default.UZERO;
          message.denominator = object.denominator !== void 0 && object.denominator !== null ? long_1.default.fromValue(object.denominator) : long_1.default.UZERO;
          return message;
        }
      };
      var globalThis2 = (() => {
        if (typeof globalThis2 !== "undefined")
          return globalThis2;
        if (typeof self !== "undefined")
          return self;
        if (typeof window !== "undefined")
          return window;
        if (typeof global !== "undefined")
          return global;
        throw "Unable to locate global object";
      })();
      var atob2 = globalThis2.atob || ((b64) => globalThis2.Buffer.from(b64, "base64").toString("binary"));
      function bytesFromBase64(b64) {
        const bin = atob2(b64);
        const arr = new Uint8Array(bin.length);
        for (let i = 0; i < bin.length; ++i) {
          arr[i] = bin.charCodeAt(i);
        }
        return arr;
      }
      var btoa2 = globalThis2.btoa || ((bin) => globalThis2.Buffer.from(bin, "binary").toString("base64"));
      function base64FromBytes(arr) {
        const bin = [];
        for (const byte of arr) {
          bin.push(String.fromCharCode(byte));
        }
        return btoa2(bin.join(""));
      }
      function toTimestamp(date) {
        const seconds = numberToLong(date.getTime() / 1e3);
        const nanos = date.getTime() % 1e3 * 1e6;
        return { seconds, nanos };
      }
      function fromTimestamp(t) {
        let millis = t.seconds.toNumber() * 1e3;
        millis += t.nanos / 1e6;
        return new Date(millis);
      }
      function fromJsonTimestamp(o) {
        if (o instanceof Date) {
          return toTimestamp(o);
        } else if (typeof o === "string") {
          return toTimestamp(new Date(o));
        } else {
          return timestamp_1.Timestamp.fromJSON(o);
        }
      }
      function numberToLong(number) {
        return long_1.default.fromNumber(number);
      }
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/@cosmjs/stargate/build/modules/ibc/queries.js
  var require_queries5 = __commonJS({
    "node_modules/@cosmjs/stargate/build/modules/ibc/queries.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.setupIbcExtension = void 0;
      var encoding_1 = require_build2();
      var math_1 = require_build();
      var query_1 = require_query5();
      var channel_1 = require_channel();
      var query_2 = require_query6();
      var query_3 = require_query7();
      var query_4 = require_query8();
      var tendermint_1 = require_tendermint();
      var long_1 = __importDefault(require_long());
      var queryclient_1 = require_queryclient2();
      function decodeTendermintClientStateAny(clientState) {
        if ((clientState === null || clientState === void 0 ? void 0 : clientState.typeUrl) !== "/ibc.lightclients.tendermint.v1.ClientState") {
          throw new Error(`Unexpected client state type: ${clientState === null || clientState === void 0 ? void 0 : clientState.typeUrl}`);
        }
        return tendermint_1.ClientState.decode(clientState.value);
      }
      function decodeTendermintConsensusStateAny(clientState) {
        if ((clientState === null || clientState === void 0 ? void 0 : clientState.typeUrl) !== "/ibc.lightclients.tendermint.v1.ConsensusState") {
          throw new Error(`Unexpected client state type: ${clientState === null || clientState === void 0 ? void 0 : clientState.typeUrl}`);
        }
        return tendermint_1.ConsensusState.decode(clientState.value);
      }
      function setupIbcExtension(base) {
        const rpc = (0, queryclient_1.createProtobufRpcClient)(base);
        const channelQueryService = new query_2.QueryClientImpl(rpc);
        const clientQueryService = new query_3.QueryClientImpl(rpc);
        const connectionQueryService = new query_4.QueryClientImpl(rpc);
        const transferQueryService = new query_1.QueryClientImpl(rpc);
        return {
          ibc: {
            channel: {
              channel: async (portId, channelId) => channelQueryService.Channel({
                portId,
                channelId
              }),
              channels: async (paginationKey) => channelQueryService.Channels({
                pagination: (0, queryclient_1.createPagination)(paginationKey)
              }),
              allChannels: async () => {
                var _a;
                const channels = [];
                let response;
                let key;
                do {
                  response = await channelQueryService.Channels({
                    pagination: (0, queryclient_1.createPagination)(key)
                  });
                  channels.push(...response.channels);
                  key = (_a = response.pagination) === null || _a === void 0 ? void 0 : _a.nextKey;
                } while (key && key.length);
                return {
                  channels,
                  height: response.height
                };
              },
              connectionChannels: async (connection, paginationKey) => channelQueryService.ConnectionChannels({
                connection,
                pagination: (0, queryclient_1.createPagination)(paginationKey)
              }),
              allConnectionChannels: async (connection) => {
                var _a;
                const channels = [];
                let response;
                let key;
                do {
                  response = await channelQueryService.ConnectionChannels({
                    connection,
                    pagination: (0, queryclient_1.createPagination)(key)
                  });
                  channels.push(...response.channels);
                  key = (_a = response.pagination) === null || _a === void 0 ? void 0 : _a.nextKey;
                } while (key && key.length);
                return {
                  channels,
                  height: response.height
                };
              },
              clientState: async (portId, channelId) => channelQueryService.ChannelClientState({
                portId,
                channelId
              }),
              consensusState: async (portId, channelId, revisionNumber, revisionHeight) => channelQueryService.ChannelConsensusState({
                portId,
                channelId,
                revisionNumber: long_1.default.fromNumber(revisionNumber, true),
                revisionHeight: long_1.default.fromNumber(revisionHeight, true)
              }),
              packetCommitment: async (portId, channelId, sequence) => channelQueryService.PacketCommitment({
                portId,
                channelId,
                sequence
              }),
              packetCommitments: async (portId, channelId, paginationKey) => channelQueryService.PacketCommitments({
                channelId,
                portId,
                pagination: (0, queryclient_1.createPagination)(paginationKey)
              }),
              allPacketCommitments: async (portId, channelId) => {
                var _a;
                const commitments = [];
                let response;
                let key;
                do {
                  response = await channelQueryService.PacketCommitments({
                    channelId,
                    portId,
                    pagination: (0, queryclient_1.createPagination)(key)
                  });
                  commitments.push(...response.commitments);
                  key = (_a = response.pagination) === null || _a === void 0 ? void 0 : _a.nextKey;
                } while (key && key.length);
                return {
                  commitments,
                  height: response.height
                };
              },
              packetReceipt: async (portId, channelId, sequence) => channelQueryService.PacketReceipt({
                portId,
                channelId,
                sequence: long_1.default.fromNumber(sequence, true)
              }),
              packetAcknowledgement: async (portId, channelId, sequence) => channelQueryService.PacketAcknowledgement({
                portId,
                channelId,
                sequence: long_1.default.fromNumber(sequence, true)
              }),
              packetAcknowledgements: async (portId, channelId, paginationKey) => channelQueryService.PacketAcknowledgements({
                portId,
                channelId,
                pagination: (0, queryclient_1.createPagination)(paginationKey)
              }),
              allPacketAcknowledgements: async (portId, channelId) => {
                var _a;
                const acknowledgements = [];
                let response;
                let key;
                do {
                  response = await channelQueryService.PacketAcknowledgements({
                    channelId,
                    portId,
                    pagination: (0, queryclient_1.createPagination)(key)
                  });
                  acknowledgements.push(...response.acknowledgements);
                  key = (_a = response.pagination) === null || _a === void 0 ? void 0 : _a.nextKey;
                } while (key && key.length);
                return {
                  acknowledgements,
                  height: response.height
                };
              },
              unreceivedPackets: async (portId, channelId, packetCommitmentSequences) => channelQueryService.UnreceivedPackets({
                portId,
                channelId,
                packetCommitmentSequences: packetCommitmentSequences.map((s) => long_1.default.fromNumber(s, true))
              }),
              unreceivedAcks: async (portId, channelId, packetAckSequences) => channelQueryService.UnreceivedAcks({
                portId,
                channelId,
                packetAckSequences: packetAckSequences.map((s) => long_1.default.fromNumber(s, true))
              }),
              nextSequenceReceive: async (portId, channelId) => channelQueryService.NextSequenceReceive({
                portId,
                channelId
              })
            },
            client: {
              state: async (clientId) => clientQueryService.ClientState({ clientId }),
              states: async (paginationKey) => clientQueryService.ClientStates({
                pagination: (0, queryclient_1.createPagination)(paginationKey)
              }),
              allStates: async () => {
                var _a;
                const clientStates = [];
                let response;
                let key;
                do {
                  response = await clientQueryService.ClientStates({
                    pagination: (0, queryclient_1.createPagination)(key)
                  });
                  clientStates.push(...response.clientStates);
                  key = (_a = response.pagination) === null || _a === void 0 ? void 0 : _a.nextKey;
                } while (key && key.length);
                return {
                  clientStates
                };
              },
              consensusState: async (clientId, consensusHeight) => clientQueryService.ConsensusState(query_3.QueryConsensusStateRequest.fromPartial({
                clientId,
                revisionHeight: consensusHeight !== void 0 ? long_1.default.fromNumber(consensusHeight, true) : void 0,
                latestHeight: consensusHeight === void 0
              })),
              consensusStates: async (clientId, paginationKey) => clientQueryService.ConsensusStates({
                clientId,
                pagination: (0, queryclient_1.createPagination)(paginationKey)
              }),
              allConsensusStates: async (clientId) => {
                var _a;
                const consensusStates = [];
                let response;
                let key;
                do {
                  response = await clientQueryService.ConsensusStates({
                    clientId,
                    pagination: (0, queryclient_1.createPagination)(key)
                  });
                  consensusStates.push(...response.consensusStates);
                  key = (_a = response.pagination) === null || _a === void 0 ? void 0 : _a.nextKey;
                } while (key && key.length);
                return {
                  consensusStates
                };
              },
              params: async () => clientQueryService.ClientParams({}),
              stateTm: async (clientId) => {
                const response = await clientQueryService.ClientState({ clientId });
                return decodeTendermintClientStateAny(response.clientState);
              },
              statesTm: async (paginationKey) => {
                const { clientStates } = await clientQueryService.ClientStates({
                  pagination: (0, queryclient_1.createPagination)(paginationKey)
                });
                return clientStates.map(({ clientState }) => decodeTendermintClientStateAny(clientState));
              },
              allStatesTm: async () => {
                var _a;
                const clientStates = [];
                let response;
                let key;
                do {
                  response = await clientQueryService.ClientStates({
                    pagination: (0, queryclient_1.createPagination)(key)
                  });
                  clientStates.push(...response.clientStates);
                  key = (_a = response.pagination) === null || _a === void 0 ? void 0 : _a.nextKey;
                } while (key && key.length);
                return clientStates.map(({ clientState }) => decodeTendermintClientStateAny(clientState));
              },
              consensusStateTm: async (clientId, consensusHeight) => {
                const response = await clientQueryService.ConsensusState(query_3.QueryConsensusStateRequest.fromPartial({
                  clientId,
                  revisionHeight: consensusHeight === null || consensusHeight === void 0 ? void 0 : consensusHeight.revisionHeight,
                  revisionNumber: consensusHeight === null || consensusHeight === void 0 ? void 0 : consensusHeight.revisionNumber,
                  latestHeight: consensusHeight === void 0
                }));
                return decodeTendermintConsensusStateAny(response.consensusState);
              }
            },
            connection: {
              connection: async (connectionId) => connectionQueryService.Connection({
                connectionId
              }),
              connections: async (paginationKey) => connectionQueryService.Connections({
                pagination: (0, queryclient_1.createPagination)(paginationKey)
              }),
              allConnections: async () => {
                var _a;
                const connections = [];
                let response;
                let key;
                do {
                  response = await connectionQueryService.Connections({
                    pagination: (0, queryclient_1.createPagination)(key)
                  });
                  connections.push(...response.connections);
                  key = (_a = response.pagination) === null || _a === void 0 ? void 0 : _a.nextKey;
                } while (key && key.length);
                return {
                  connections,
                  height: response.height
                };
              },
              clientConnections: async (clientId) => connectionQueryService.ClientConnections({
                clientId
              }),
              clientState: async (connectionId) => connectionQueryService.ConnectionClientState({
                connectionId
              }),
              consensusState: async (connectionId, revisionHeight) => connectionQueryService.ConnectionConsensusState(query_4.QueryConnectionConsensusStateRequest.fromPartial({
                connectionId,
                revisionHeight: long_1.default.fromNumber(revisionHeight, true)
              }))
            },
            transfer: {
              denomTrace: async (hash) => transferQueryService.DenomTrace({ hash }),
              denomTraces: async (paginationKey) => transferQueryService.DenomTraces({
                pagination: (0, queryclient_1.createPagination)(paginationKey)
              }),
              allDenomTraces: async () => {
                var _a;
                const denomTraces = [];
                let response;
                let key;
                do {
                  response = await transferQueryService.DenomTraces({
                    pagination: (0, queryclient_1.createPagination)(key)
                  });
                  denomTraces.push(...response.denomTraces);
                  key = (_a = response.pagination) === null || _a === void 0 ? void 0 : _a.nextKey;
                } while (key && key.length);
                return {
                  denomTraces
                };
              },
              params: async () => transferQueryService.Params({})
            },
            verified: {
              channel: {
                channel: async (portId, channelId) => {
                  const key = (0, encoding_1.toAscii)(`channelEnds/ports/${portId}/channels/${channelId}`);
                  const responseData = await base.queryVerified("ibc", key);
                  return responseData.length ? channel_1.Channel.decode(responseData) : null;
                },
                packetCommitment: async (portId, channelId, sequence) => {
                  const key = (0, encoding_1.toAscii)(`commitments/ports/${portId}/channels/${channelId}/packets/${sequence}`);
                  const responseData = await base.queryVerified("ibc", key);
                  return responseData;
                },
                packetAcknowledgement: async (portId, channelId, sequence) => {
                  const key = (0, encoding_1.toAscii)(`acks/ports/${portId}/channels/${channelId}/acknowledgements/${sequence}`);
                  const responseData = await base.queryVerified("ibc", key);
                  return responseData;
                },
                nextSequenceReceive: async (portId, channelId) => {
                  const key = (0, encoding_1.toAscii)(`seqAcks/ports/${portId}/channels/${channelId}/nextSequenceAck`);
                  const responseData = await base.queryVerified("ibc", key);
                  return responseData.length ? math_1.Uint64.fromBytes(responseData).toNumber() : null;
                }
              }
            }
          }
        };
      }
      exports2.setupIbcExtension = setupIbcExtension;
    }
  });

  // node_modules/cosmjs-types/cosmos/mint/v1beta1/mint.js
  var require_mint = __commonJS({
    "node_modules/cosmjs-types/cosmos/mint/v1beta1/mint.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.Params = exports2.Minter = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      exports2.protobufPackage = "cosmos.mint.v1beta1";
      var baseMinter = { inflation: "", annualProvisions: "" };
      exports2.Minter = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.inflation !== "") {
            writer.uint32(10).string(message.inflation);
          }
          if (message.annualProvisions !== "") {
            writer.uint32(18).string(message.annualProvisions);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMinter);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.inflation = reader.string();
                break;
              case 2:
                message.annualProvisions = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMinter);
          message.inflation = object.inflation !== void 0 && object.inflation !== null ? String(object.inflation) : "";
          message.annualProvisions = object.annualProvisions !== void 0 && object.annualProvisions !== null ? String(object.annualProvisions) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.inflation !== void 0 && (obj.inflation = message.inflation);
          message.annualProvisions !== void 0 && (obj.annualProvisions = message.annualProvisions);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseMinter);
          message.inflation = (_a = object.inflation) !== null && _a !== void 0 ? _a : "";
          message.annualProvisions = (_b = object.annualProvisions) !== null && _b !== void 0 ? _b : "";
          return message;
        }
      };
      var baseParams = {
        mintDenom: "",
        inflationRateChange: "",
        inflationMax: "",
        inflationMin: "",
        goalBonded: "",
        blocksPerYear: long_1.default.UZERO
      };
      exports2.Params = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.mintDenom !== "") {
            writer.uint32(10).string(message.mintDenom);
          }
          if (message.inflationRateChange !== "") {
            writer.uint32(18).string(message.inflationRateChange);
          }
          if (message.inflationMax !== "") {
            writer.uint32(26).string(message.inflationMax);
          }
          if (message.inflationMin !== "") {
            writer.uint32(34).string(message.inflationMin);
          }
          if (message.goalBonded !== "") {
            writer.uint32(42).string(message.goalBonded);
          }
          if (!message.blocksPerYear.isZero()) {
            writer.uint32(48).uint64(message.blocksPerYear);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseParams);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.mintDenom = reader.string();
                break;
              case 2:
                message.inflationRateChange = reader.string();
                break;
              case 3:
                message.inflationMax = reader.string();
                break;
              case 4:
                message.inflationMin = reader.string();
                break;
              case 5:
                message.goalBonded = reader.string();
                break;
              case 6:
                message.blocksPerYear = reader.uint64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseParams);
          message.mintDenom = object.mintDenom !== void 0 && object.mintDenom !== null ? String(object.mintDenom) : "";
          message.inflationRateChange = object.inflationRateChange !== void 0 && object.inflationRateChange !== null ? String(object.inflationRateChange) : "";
          message.inflationMax = object.inflationMax !== void 0 && object.inflationMax !== null ? String(object.inflationMax) : "";
          message.inflationMin = object.inflationMin !== void 0 && object.inflationMin !== null ? String(object.inflationMin) : "";
          message.goalBonded = object.goalBonded !== void 0 && object.goalBonded !== null ? String(object.goalBonded) : "";
          message.blocksPerYear = object.blocksPerYear !== void 0 && object.blocksPerYear !== null ? long_1.default.fromString(object.blocksPerYear) : long_1.default.UZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.mintDenom !== void 0 && (obj.mintDenom = message.mintDenom);
          message.inflationRateChange !== void 0 && (obj.inflationRateChange = message.inflationRateChange);
          message.inflationMax !== void 0 && (obj.inflationMax = message.inflationMax);
          message.inflationMin !== void 0 && (obj.inflationMin = message.inflationMin);
          message.goalBonded !== void 0 && (obj.goalBonded = message.goalBonded);
          message.blocksPerYear !== void 0 && (obj.blocksPerYear = (message.blocksPerYear || long_1.default.UZERO).toString());
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c, _d, _e;
          const message = Object.assign({}, baseParams);
          message.mintDenom = (_a = object.mintDenom) !== null && _a !== void 0 ? _a : "";
          message.inflationRateChange = (_b = object.inflationRateChange) !== null && _b !== void 0 ? _b : "";
          message.inflationMax = (_c = object.inflationMax) !== null && _c !== void 0 ? _c : "";
          message.inflationMin = (_d = object.inflationMin) !== null && _d !== void 0 ? _d : "";
          message.goalBonded = (_e = object.goalBonded) !== null && _e !== void 0 ? _e : "";
          message.blocksPerYear = object.blocksPerYear !== void 0 && object.blocksPerYear !== null ? long_1.default.fromValue(object.blocksPerYear) : long_1.default.UZERO;
          return message;
        }
      };
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/cosmjs-types/cosmos/mint/v1beta1/query.js
  var require_query9 = __commonJS({
    "node_modules/cosmjs-types/cosmos/mint/v1beta1/query.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.QueryClientImpl = exports2.QueryAnnualProvisionsResponse = exports2.QueryAnnualProvisionsRequest = exports2.QueryInflationResponse = exports2.QueryInflationRequest = exports2.QueryParamsResponse = exports2.QueryParamsRequest = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var mint_1 = require_mint();
      exports2.protobufPackage = "cosmos.mint.v1beta1";
      var baseQueryParamsRequest = {};
      exports2.QueryParamsRequest = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryParamsRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseQueryParamsRequest);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseQueryParamsRequest);
          return message;
        }
      };
      var baseQueryParamsResponse = {};
      exports2.QueryParamsResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.params !== void 0) {
            mint_1.Params.encode(message.params, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryParamsResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.params = mint_1.Params.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryParamsResponse);
          message.params = object.params !== void 0 && object.params !== null ? mint_1.Params.fromJSON(object.params) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.params !== void 0 && (obj.params = message.params ? mint_1.Params.toJSON(message.params) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryParamsResponse);
          message.params = object.params !== void 0 && object.params !== null ? mint_1.Params.fromPartial(object.params) : void 0;
          return message;
        }
      };
      var baseQueryInflationRequest = {};
      exports2.QueryInflationRequest = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryInflationRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseQueryInflationRequest);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseQueryInflationRequest);
          return message;
        }
      };
      var baseQueryInflationResponse = {};
      exports2.QueryInflationResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.inflation.length !== 0) {
            writer.uint32(10).bytes(message.inflation);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryInflationResponse);
          message.inflation = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.inflation = reader.bytes();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryInflationResponse);
          message.inflation = object.inflation !== void 0 && object.inflation !== null ? bytesFromBase64(object.inflation) : new Uint8Array();
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.inflation !== void 0 && (obj.inflation = base64FromBytes(message.inflation !== void 0 ? message.inflation : new Uint8Array()));
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryInflationResponse);
          message.inflation = (_a = object.inflation) !== null && _a !== void 0 ? _a : new Uint8Array();
          return message;
        }
      };
      var baseQueryAnnualProvisionsRequest = {};
      exports2.QueryAnnualProvisionsRequest = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryAnnualProvisionsRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseQueryAnnualProvisionsRequest);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseQueryAnnualProvisionsRequest);
          return message;
        }
      };
      var baseQueryAnnualProvisionsResponse = {};
      exports2.QueryAnnualProvisionsResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.annualProvisions.length !== 0) {
            writer.uint32(10).bytes(message.annualProvisions);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryAnnualProvisionsResponse);
          message.annualProvisions = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.annualProvisions = reader.bytes();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryAnnualProvisionsResponse);
          message.annualProvisions = object.annualProvisions !== void 0 && object.annualProvisions !== null ? bytesFromBase64(object.annualProvisions) : new Uint8Array();
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.annualProvisions !== void 0 && (obj.annualProvisions = base64FromBytes(message.annualProvisions !== void 0 ? message.annualProvisions : new Uint8Array()));
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryAnnualProvisionsResponse);
          message.annualProvisions = (_a = object.annualProvisions) !== null && _a !== void 0 ? _a : new Uint8Array();
          return message;
        }
      };
      var QueryClientImpl = class {
        constructor(rpc) {
          this.rpc = rpc;
          this.Params = this.Params.bind(this);
          this.Inflation = this.Inflation.bind(this);
          this.AnnualProvisions = this.AnnualProvisions.bind(this);
        }
        Params(request) {
          const data = exports2.QueryParamsRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.mint.v1beta1.Query", "Params", data);
          return promise.then((data2) => exports2.QueryParamsResponse.decode(new minimal_1.default.Reader(data2)));
        }
        Inflation(request) {
          const data = exports2.QueryInflationRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.mint.v1beta1.Query", "Inflation", data);
          return promise.then((data2) => exports2.QueryInflationResponse.decode(new minimal_1.default.Reader(data2)));
        }
        AnnualProvisions(request) {
          const data = exports2.QueryAnnualProvisionsRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.mint.v1beta1.Query", "AnnualProvisions", data);
          return promise.then((data2) => exports2.QueryAnnualProvisionsResponse.decode(new minimal_1.default.Reader(data2)));
        }
      };
      exports2.QueryClientImpl = QueryClientImpl;
      var globalThis2 = (() => {
        if (typeof globalThis2 !== "undefined")
          return globalThis2;
        if (typeof self !== "undefined")
          return self;
        if (typeof window !== "undefined")
          return window;
        if (typeof global !== "undefined")
          return global;
        throw "Unable to locate global object";
      })();
      var atob2 = globalThis2.atob || ((b64) => globalThis2.Buffer.from(b64, "base64").toString("binary"));
      function bytesFromBase64(b64) {
        const bin = atob2(b64);
        const arr = new Uint8Array(bin.length);
        for (let i = 0; i < bin.length; ++i) {
          arr[i] = bin.charCodeAt(i);
        }
        return arr;
      }
      var btoa2 = globalThis2.btoa || ((bin) => globalThis2.Buffer.from(bin, "binary").toString("base64"));
      function base64FromBytes(arr) {
        const bin = [];
        for (const byte of arr) {
          bin.push(String.fromCharCode(byte));
        }
        return btoa2(bin.join(""));
      }
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/@cosmjs/stargate/build/modules/mint/queries.js
  var require_queries6 = __commonJS({
    "node_modules/@cosmjs/stargate/build/modules/mint/queries.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.setupMintExtension = void 0;
      var utils_1 = require_build3();
      var query_1 = require_query9();
      var queryclient_1 = require_queryclient2();
      function setupMintExtension(base) {
        const rpc = (0, queryclient_1.createProtobufRpcClient)(base);
        const queryService = new query_1.QueryClientImpl(rpc);
        return {
          mint: {
            params: async () => {
              const { params } = await queryService.Params({});
              (0, utils_1.assert)(params);
              return {
                blocksPerYear: params.blocksPerYear,
                goalBonded: (0, queryclient_1.decodeCosmosSdkDecFromProto)(params.goalBonded),
                inflationMin: (0, queryclient_1.decodeCosmosSdkDecFromProto)(params.inflationMin),
                inflationMax: (0, queryclient_1.decodeCosmosSdkDecFromProto)(params.inflationMax),
                inflationRateChange: (0, queryclient_1.decodeCosmosSdkDecFromProto)(params.inflationRateChange),
                mintDenom: params.mintDenom
              };
            },
            inflation: async () => {
              const { inflation } = await queryService.Inflation({});
              return (0, queryclient_1.decodeCosmosSdkDecFromProto)(inflation);
            },
            annualProvisions: async () => {
              const { annualProvisions } = await queryService.AnnualProvisions({});
              return (0, queryclient_1.decodeCosmosSdkDecFromProto)(annualProvisions);
            }
          }
        };
      }
      exports2.setupMintExtension = setupMintExtension;
    }
  });

  // node_modules/@cosmjs/stargate/build/modules/slashing/aminomessages.js
  var require_aminomessages9 = __commonJS({
    "node_modules/@cosmjs/stargate/build/modules/slashing/aminomessages.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.createSlashingAminoConverters = exports2.isAminoMsgUnjail = void 0;
      function isAminoMsgUnjail(msg) {
        return msg.type === "cosmos-sdk/MsgUnjail";
      }
      exports2.isAminoMsgUnjail = isAminoMsgUnjail;
      function createSlashingAminoConverters() {
        throw new Error("Not implemented");
      }
      exports2.createSlashingAminoConverters = createSlashingAminoConverters;
    }
  });

  // node_modules/cosmjs-types/cosmos/slashing/v1beta1/slashing.js
  var require_slashing = __commonJS({
    "node_modules/cosmjs-types/cosmos/slashing/v1beta1/slashing.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.Params = exports2.ValidatorSigningInfo = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var timestamp_1 = require_timestamp();
      var duration_1 = require_duration();
      exports2.protobufPackage = "cosmos.slashing.v1beta1";
      var baseValidatorSigningInfo = {
        address: "",
        startHeight: long_1.default.ZERO,
        indexOffset: long_1.default.ZERO,
        tombstoned: false,
        missedBlocksCounter: long_1.default.ZERO
      };
      exports2.ValidatorSigningInfo = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.address !== "") {
            writer.uint32(10).string(message.address);
          }
          if (!message.startHeight.isZero()) {
            writer.uint32(16).int64(message.startHeight);
          }
          if (!message.indexOffset.isZero()) {
            writer.uint32(24).int64(message.indexOffset);
          }
          if (message.jailedUntil !== void 0) {
            timestamp_1.Timestamp.encode(message.jailedUntil, writer.uint32(34).fork()).ldelim();
          }
          if (message.tombstoned === true) {
            writer.uint32(40).bool(message.tombstoned);
          }
          if (!message.missedBlocksCounter.isZero()) {
            writer.uint32(48).int64(message.missedBlocksCounter);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseValidatorSigningInfo);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.address = reader.string();
                break;
              case 2:
                message.startHeight = reader.int64();
                break;
              case 3:
                message.indexOffset = reader.int64();
                break;
              case 4:
                message.jailedUntil = timestamp_1.Timestamp.decode(reader, reader.uint32());
                break;
              case 5:
                message.tombstoned = reader.bool();
                break;
              case 6:
                message.missedBlocksCounter = reader.int64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseValidatorSigningInfo);
          message.address = object.address !== void 0 && object.address !== null ? String(object.address) : "";
          message.startHeight = object.startHeight !== void 0 && object.startHeight !== null ? long_1.default.fromString(object.startHeight) : long_1.default.ZERO;
          message.indexOffset = object.indexOffset !== void 0 && object.indexOffset !== null ? long_1.default.fromString(object.indexOffset) : long_1.default.ZERO;
          message.jailedUntil = object.jailedUntil !== void 0 && object.jailedUntil !== null ? fromJsonTimestamp(object.jailedUntil) : void 0;
          message.tombstoned = object.tombstoned !== void 0 && object.tombstoned !== null ? Boolean(object.tombstoned) : false;
          message.missedBlocksCounter = object.missedBlocksCounter !== void 0 && object.missedBlocksCounter !== null ? long_1.default.fromString(object.missedBlocksCounter) : long_1.default.ZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.address !== void 0 && (obj.address = message.address);
          message.startHeight !== void 0 && (obj.startHeight = (message.startHeight || long_1.default.ZERO).toString());
          message.indexOffset !== void 0 && (obj.indexOffset = (message.indexOffset || long_1.default.ZERO).toString());
          message.jailedUntil !== void 0 && (obj.jailedUntil = fromTimestamp(message.jailedUntil).toISOString());
          message.tombstoned !== void 0 && (obj.tombstoned = message.tombstoned);
          message.missedBlocksCounter !== void 0 && (obj.missedBlocksCounter = (message.missedBlocksCounter || long_1.default.ZERO).toString());
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseValidatorSigningInfo);
          message.address = (_a = object.address) !== null && _a !== void 0 ? _a : "";
          message.startHeight = object.startHeight !== void 0 && object.startHeight !== null ? long_1.default.fromValue(object.startHeight) : long_1.default.ZERO;
          message.indexOffset = object.indexOffset !== void 0 && object.indexOffset !== null ? long_1.default.fromValue(object.indexOffset) : long_1.default.ZERO;
          message.jailedUntil = object.jailedUntil !== void 0 && object.jailedUntil !== null ? timestamp_1.Timestamp.fromPartial(object.jailedUntil) : void 0;
          message.tombstoned = (_b = object.tombstoned) !== null && _b !== void 0 ? _b : false;
          message.missedBlocksCounter = object.missedBlocksCounter !== void 0 && object.missedBlocksCounter !== null ? long_1.default.fromValue(object.missedBlocksCounter) : long_1.default.ZERO;
          return message;
        }
      };
      var baseParams = { signedBlocksWindow: long_1.default.ZERO };
      exports2.Params = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.signedBlocksWindow.isZero()) {
            writer.uint32(8).int64(message.signedBlocksWindow);
          }
          if (message.minSignedPerWindow.length !== 0) {
            writer.uint32(18).bytes(message.minSignedPerWindow);
          }
          if (message.downtimeJailDuration !== void 0) {
            duration_1.Duration.encode(message.downtimeJailDuration, writer.uint32(26).fork()).ldelim();
          }
          if (message.slashFractionDoubleSign.length !== 0) {
            writer.uint32(34).bytes(message.slashFractionDoubleSign);
          }
          if (message.slashFractionDowntime.length !== 0) {
            writer.uint32(42).bytes(message.slashFractionDowntime);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseParams);
          message.minSignedPerWindow = new Uint8Array();
          message.slashFractionDoubleSign = new Uint8Array();
          message.slashFractionDowntime = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.signedBlocksWindow = reader.int64();
                break;
              case 2:
                message.minSignedPerWindow = reader.bytes();
                break;
              case 3:
                message.downtimeJailDuration = duration_1.Duration.decode(reader, reader.uint32());
                break;
              case 4:
                message.slashFractionDoubleSign = reader.bytes();
                break;
              case 5:
                message.slashFractionDowntime = reader.bytes();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseParams);
          message.signedBlocksWindow = object.signedBlocksWindow !== void 0 && object.signedBlocksWindow !== null ? long_1.default.fromString(object.signedBlocksWindow) : long_1.default.ZERO;
          message.minSignedPerWindow = object.minSignedPerWindow !== void 0 && object.minSignedPerWindow !== null ? bytesFromBase64(object.minSignedPerWindow) : new Uint8Array();
          message.downtimeJailDuration = object.downtimeJailDuration !== void 0 && object.downtimeJailDuration !== null ? duration_1.Duration.fromJSON(object.downtimeJailDuration) : void 0;
          message.slashFractionDoubleSign = object.slashFractionDoubleSign !== void 0 && object.slashFractionDoubleSign !== null ? bytesFromBase64(object.slashFractionDoubleSign) : new Uint8Array();
          message.slashFractionDowntime = object.slashFractionDowntime !== void 0 && object.slashFractionDowntime !== null ? bytesFromBase64(object.slashFractionDowntime) : new Uint8Array();
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.signedBlocksWindow !== void 0 && (obj.signedBlocksWindow = (message.signedBlocksWindow || long_1.default.ZERO).toString());
          message.minSignedPerWindow !== void 0 && (obj.minSignedPerWindow = base64FromBytes(message.minSignedPerWindow !== void 0 ? message.minSignedPerWindow : new Uint8Array()));
          message.downtimeJailDuration !== void 0 && (obj.downtimeJailDuration = message.downtimeJailDuration ? duration_1.Duration.toJSON(message.downtimeJailDuration) : void 0);
          message.slashFractionDoubleSign !== void 0 && (obj.slashFractionDoubleSign = base64FromBytes(message.slashFractionDoubleSign !== void 0 ? message.slashFractionDoubleSign : new Uint8Array()));
          message.slashFractionDowntime !== void 0 && (obj.slashFractionDowntime = base64FromBytes(message.slashFractionDowntime !== void 0 ? message.slashFractionDowntime : new Uint8Array()));
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseParams);
          message.signedBlocksWindow = object.signedBlocksWindow !== void 0 && object.signedBlocksWindow !== null ? long_1.default.fromValue(object.signedBlocksWindow) : long_1.default.ZERO;
          message.minSignedPerWindow = (_a = object.minSignedPerWindow) !== null && _a !== void 0 ? _a : new Uint8Array();
          message.downtimeJailDuration = object.downtimeJailDuration !== void 0 && object.downtimeJailDuration !== null ? duration_1.Duration.fromPartial(object.downtimeJailDuration) : void 0;
          message.slashFractionDoubleSign = (_b = object.slashFractionDoubleSign) !== null && _b !== void 0 ? _b : new Uint8Array();
          message.slashFractionDowntime = (_c = object.slashFractionDowntime) !== null && _c !== void 0 ? _c : new Uint8Array();
          return message;
        }
      };
      var globalThis2 = (() => {
        if (typeof globalThis2 !== "undefined")
          return globalThis2;
        if (typeof self !== "undefined")
          return self;
        if (typeof window !== "undefined")
          return window;
        if (typeof global !== "undefined")
          return global;
        throw "Unable to locate global object";
      })();
      var atob2 = globalThis2.atob || ((b64) => globalThis2.Buffer.from(b64, "base64").toString("binary"));
      function bytesFromBase64(b64) {
        const bin = atob2(b64);
        const arr = new Uint8Array(bin.length);
        for (let i = 0; i < bin.length; ++i) {
          arr[i] = bin.charCodeAt(i);
        }
        return arr;
      }
      var btoa2 = globalThis2.btoa || ((bin) => globalThis2.Buffer.from(bin, "binary").toString("base64"));
      function base64FromBytes(arr) {
        const bin = [];
        for (const byte of arr) {
          bin.push(String.fromCharCode(byte));
        }
        return btoa2(bin.join(""));
      }
      function toTimestamp(date) {
        const seconds = numberToLong(date.getTime() / 1e3);
        const nanos = date.getTime() % 1e3 * 1e6;
        return { seconds, nanos };
      }
      function fromTimestamp(t) {
        let millis = t.seconds.toNumber() * 1e3;
        millis += t.nanos / 1e6;
        return new Date(millis);
      }
      function fromJsonTimestamp(o) {
        if (o instanceof Date) {
          return toTimestamp(o);
        } else if (typeof o === "string") {
          return toTimestamp(new Date(o));
        } else {
          return timestamp_1.Timestamp.fromJSON(o);
        }
      }
      function numberToLong(number) {
        return long_1.default.fromNumber(number);
      }
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/cosmjs-types/cosmos/slashing/v1beta1/query.js
  var require_query10 = __commonJS({
    "node_modules/cosmjs-types/cosmos/slashing/v1beta1/query.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.QueryClientImpl = exports2.QuerySigningInfosResponse = exports2.QuerySigningInfosRequest = exports2.QuerySigningInfoResponse = exports2.QuerySigningInfoRequest = exports2.QueryParamsResponse = exports2.QueryParamsRequest = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var slashing_1 = require_slashing();
      var pagination_1 = require_pagination();
      exports2.protobufPackage = "cosmos.slashing.v1beta1";
      var baseQueryParamsRequest = {};
      exports2.QueryParamsRequest = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryParamsRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseQueryParamsRequest);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseQueryParamsRequest);
          return message;
        }
      };
      var baseQueryParamsResponse = {};
      exports2.QueryParamsResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.params !== void 0) {
            slashing_1.Params.encode(message.params, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryParamsResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.params = slashing_1.Params.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryParamsResponse);
          message.params = object.params !== void 0 && object.params !== null ? slashing_1.Params.fromJSON(object.params) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.params !== void 0 && (obj.params = message.params ? slashing_1.Params.toJSON(message.params) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryParamsResponse);
          message.params = object.params !== void 0 && object.params !== null ? slashing_1.Params.fromPartial(object.params) : void 0;
          return message;
        }
      };
      var baseQuerySigningInfoRequest = { consAddress: "" };
      exports2.QuerySigningInfoRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.consAddress !== "") {
            writer.uint32(10).string(message.consAddress);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQuerySigningInfoRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.consAddress = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQuerySigningInfoRequest);
          message.consAddress = object.consAddress !== void 0 && object.consAddress !== null ? String(object.consAddress) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.consAddress !== void 0 && (obj.consAddress = message.consAddress);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQuerySigningInfoRequest);
          message.consAddress = (_a = object.consAddress) !== null && _a !== void 0 ? _a : "";
          return message;
        }
      };
      var baseQuerySigningInfoResponse = {};
      exports2.QuerySigningInfoResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.valSigningInfo !== void 0) {
            slashing_1.ValidatorSigningInfo.encode(message.valSigningInfo, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQuerySigningInfoResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.valSigningInfo = slashing_1.ValidatorSigningInfo.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQuerySigningInfoResponse);
          message.valSigningInfo = object.valSigningInfo !== void 0 && object.valSigningInfo !== null ? slashing_1.ValidatorSigningInfo.fromJSON(object.valSigningInfo) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.valSigningInfo !== void 0 && (obj.valSigningInfo = message.valSigningInfo ? slashing_1.ValidatorSigningInfo.toJSON(message.valSigningInfo) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQuerySigningInfoResponse);
          message.valSigningInfo = object.valSigningInfo !== void 0 && object.valSigningInfo !== null ? slashing_1.ValidatorSigningInfo.fromPartial(object.valSigningInfo) : void 0;
          return message;
        }
      };
      var baseQuerySigningInfosRequest = {};
      exports2.QuerySigningInfosRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.pagination !== void 0) {
            pagination_1.PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQuerySigningInfosRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.pagination = pagination_1.PageRequest.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQuerySigningInfosRequest);
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageRequest.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQuerySigningInfosRequest);
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQuerySigningInfosResponse = {};
      exports2.QuerySigningInfosResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.info) {
            slashing_1.ValidatorSigningInfo.encode(v, writer.uint32(10).fork()).ldelim();
          }
          if (message.pagination !== void 0) {
            pagination_1.PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQuerySigningInfosResponse);
          message.info = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.info.push(slashing_1.ValidatorSigningInfo.decode(reader, reader.uint32()));
                break;
              case 2:
                message.pagination = pagination_1.PageResponse.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseQuerySigningInfosResponse);
          message.info = ((_a = object.info) !== null && _a !== void 0 ? _a : []).map((e) => slashing_1.ValidatorSigningInfo.fromJSON(e));
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.info) {
            obj.info = message.info.map((e) => e ? slashing_1.ValidatorSigningInfo.toJSON(e) : void 0);
          } else {
            obj.info = [];
          }
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageResponse.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQuerySigningInfosResponse);
          message.info = ((_a = object.info) === null || _a === void 0 ? void 0 : _a.map((e) => slashing_1.ValidatorSigningInfo.fromPartial(e))) || [];
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var QueryClientImpl = class {
        constructor(rpc) {
          this.rpc = rpc;
          this.Params = this.Params.bind(this);
          this.SigningInfo = this.SigningInfo.bind(this);
          this.SigningInfos = this.SigningInfos.bind(this);
        }
        Params(request) {
          const data = exports2.QueryParamsRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.slashing.v1beta1.Query", "Params", data);
          return promise.then((data2) => exports2.QueryParamsResponse.decode(new minimal_1.default.Reader(data2)));
        }
        SigningInfo(request) {
          const data = exports2.QuerySigningInfoRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.slashing.v1beta1.Query", "SigningInfo", data);
          return promise.then((data2) => exports2.QuerySigningInfoResponse.decode(new minimal_1.default.Reader(data2)));
        }
        SigningInfos(request) {
          const data = exports2.QuerySigningInfosRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.slashing.v1beta1.Query", "SigningInfos", data);
          return promise.then((data2) => exports2.QuerySigningInfosResponse.decode(new minimal_1.default.Reader(data2)));
        }
      };
      exports2.QueryClientImpl = QueryClientImpl;
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/@cosmjs/stargate/build/modules/slashing/queries.js
  var require_queries7 = __commonJS({
    "node_modules/@cosmjs/stargate/build/modules/slashing/queries.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.setupSlashingExtension = void 0;
      var query_1 = require_query10();
      var queryclient_1 = require_queryclient2();
      function setupSlashingExtension(base) {
        const rpc = (0, queryclient_1.createProtobufRpcClient)(base);
        const queryService = new query_1.QueryClientImpl(rpc);
        return {
          slashing: {
            signingInfo: async (consAddress) => {
              const response = await queryService.SigningInfo({
                consAddress
              });
              return response;
            },
            signingInfos: async (paginationKey) => {
              const response = await queryService.SigningInfos({
                pagination: (0, queryclient_1.createPagination)(paginationKey)
              });
              return response;
            },
            params: async () => {
              const response = await queryService.Params({});
              return response;
            }
          }
        };
      }
      exports2.setupSlashingExtension = setupSlashingExtension;
    }
  });

  // node_modules/@cosmjs/stargate/build/modules/staking/aminomessages.js
  var require_aminomessages10 = __commonJS({
    "node_modules/@cosmjs/stargate/build/modules/staking/aminomessages.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.createStakingAminoConverters = exports2.isAminoMsgUndelegate = exports2.isAminoMsgBeginRedelegate = exports2.isAminoMsgDelegate = exports2.isAminoMsgEditValidator = exports2.isAminoMsgCreateValidator = void 0;
      var amino_1 = require_build5();
      var encoding_1 = require_build2();
      var utils_1 = require_build3();
      function isAminoMsgCreateValidator(msg) {
        return msg.type === "cosmos-sdk/MsgCreateValidator";
      }
      exports2.isAminoMsgCreateValidator = isAminoMsgCreateValidator;
      function isAminoMsgEditValidator(msg) {
        return msg.type === "cosmos-sdk/MsgEditValidator";
      }
      exports2.isAminoMsgEditValidator = isAminoMsgEditValidator;
      function isAminoMsgDelegate(msg) {
        return msg.type === "cosmos-sdk/MsgDelegate";
      }
      exports2.isAminoMsgDelegate = isAminoMsgDelegate;
      function isAminoMsgBeginRedelegate(msg) {
        return msg.type === "cosmos-sdk/MsgBeginRedelegate";
      }
      exports2.isAminoMsgBeginRedelegate = isAminoMsgBeginRedelegate;
      function isAminoMsgUndelegate(msg) {
        return msg.type === "cosmos-sdk/MsgUndelegate";
      }
      exports2.isAminoMsgUndelegate = isAminoMsgUndelegate;
      function createStakingAminoConverters(prefix) {
        return {
          "/cosmos.staking.v1beta1.MsgBeginRedelegate": {
            aminoType: "cosmos-sdk/MsgBeginRedelegate",
            toAmino: ({ delegatorAddress, validatorSrcAddress, validatorDstAddress, amount }) => {
              (0, utils_1.assertDefinedAndNotNull)(amount, "missing amount");
              return {
                delegator_address: delegatorAddress,
                validator_src_address: validatorSrcAddress,
                validator_dst_address: validatorDstAddress,
                amount
              };
            },
            fromAmino: ({ delegator_address, validator_src_address, validator_dst_address, amount }) => ({
              delegatorAddress: delegator_address,
              validatorSrcAddress: validator_src_address,
              validatorDstAddress: validator_dst_address,
              amount
            })
          },
          "/cosmos.staking.v1beta1.MsgCreateValidator": {
            aminoType: "cosmos-sdk/MsgCreateValidator",
            toAmino: ({ description, commission, minSelfDelegation, delegatorAddress, validatorAddress, pubkey, value }) => {
              (0, utils_1.assertDefinedAndNotNull)(description, "missing description");
              (0, utils_1.assertDefinedAndNotNull)(commission, "missing commission");
              (0, utils_1.assertDefinedAndNotNull)(pubkey, "missing pubkey");
              (0, utils_1.assertDefinedAndNotNull)(value, "missing value");
              return {
                description: {
                  moniker: description.moniker,
                  identity: description.identity,
                  website: description.website,
                  security_contact: description.securityContact,
                  details: description.details
                },
                commission: {
                  rate: commission.rate,
                  max_rate: commission.maxRate,
                  max_change_rate: commission.maxChangeRate
                },
                min_self_delegation: minSelfDelegation,
                delegator_address: delegatorAddress,
                validator_address: validatorAddress,
                pubkey: (0, amino_1.encodeBech32Pubkey)({
                  type: "tendermint/PubKeySecp256k1",
                  value: (0, encoding_1.toBase64)(pubkey.value)
                }, prefix),
                value
              };
            },
            fromAmino: ({ description, commission, min_self_delegation, delegator_address, validator_address, pubkey, value }) => {
              const decodedPubkey = (0, amino_1.decodeBech32Pubkey)(pubkey);
              if (decodedPubkey.type !== "tendermint/PubKeySecp256k1") {
                throw new Error("Only Secp256k1 public keys are supported");
              }
              return {
                description: {
                  moniker: description.moniker,
                  identity: description.identity,
                  website: description.website,
                  securityContact: description.security_contact,
                  details: description.details
                },
                commission: {
                  rate: commission.rate,
                  maxRate: commission.max_rate,
                  maxChangeRate: commission.max_change_rate
                },
                minSelfDelegation: min_self_delegation,
                delegatorAddress: delegator_address,
                validatorAddress: validator_address,
                pubkey: {
                  typeUrl: "/cosmos.crypto.secp256k1.PubKey",
                  value: (0, encoding_1.fromBase64)(decodedPubkey.value)
                },
                value
              };
            }
          },
          "/cosmos.staking.v1beta1.MsgDelegate": {
            aminoType: "cosmos-sdk/MsgDelegate",
            toAmino: ({ delegatorAddress, validatorAddress, amount }) => {
              (0, utils_1.assertDefinedAndNotNull)(amount, "missing amount");
              return {
                delegator_address: delegatorAddress,
                validator_address: validatorAddress,
                amount
              };
            },
            fromAmino: ({ delegator_address, validator_address, amount }) => ({
              delegatorAddress: delegator_address,
              validatorAddress: validator_address,
              amount
            })
          },
          "/cosmos.staking.v1beta1.MsgEditValidator": {
            aminoType: "cosmos-sdk/MsgEditValidator",
            toAmino: ({ description, commissionRate, minSelfDelegation, validatorAddress }) => {
              (0, utils_1.assertDefinedAndNotNull)(description, "missing description");
              return {
                description: {
                  moniker: description.moniker,
                  identity: description.identity,
                  website: description.website,
                  security_contact: description.securityContact,
                  details: description.details
                },
                commission_rate: commissionRate,
                min_self_delegation: minSelfDelegation,
                validator_address: validatorAddress
              };
            },
            fromAmino: ({ description, commission_rate, min_self_delegation, validator_address }) => ({
              description: {
                moniker: description.moniker,
                identity: description.identity,
                website: description.website,
                securityContact: description.security_contact,
                details: description.details
              },
              commissionRate: commission_rate,
              minSelfDelegation: min_self_delegation,
              validatorAddress: validator_address
            })
          },
          "/cosmos.staking.v1beta1.MsgUndelegate": {
            aminoType: "cosmos-sdk/MsgUndelegate",
            toAmino: ({ delegatorAddress, validatorAddress, amount }) => {
              (0, utils_1.assertDefinedAndNotNull)(amount, "missing amount");
              return {
                delegator_address: delegatorAddress,
                validator_address: validatorAddress,
                amount
              };
            },
            fromAmino: ({ delegator_address, validator_address, amount }) => ({
              delegatorAddress: delegator_address,
              validatorAddress: validator_address,
              amount
            })
          }
        };
      }
      exports2.createStakingAminoConverters = createStakingAminoConverters;
    }
  });

  // node_modules/cosmjs-types/cosmos/staking/v1beta1/staking.js
  var require_staking = __commonJS({
    "node_modules/cosmjs-types/cosmos/staking/v1beta1/staking.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.Pool = exports2.RedelegationResponse = exports2.RedelegationEntryResponse = exports2.DelegationResponse = exports2.Params = exports2.Redelegation = exports2.RedelegationEntry = exports2.UnbondingDelegationEntry = exports2.UnbondingDelegation = exports2.Delegation = exports2.DVVTriplets = exports2.DVVTriplet = exports2.DVPairs = exports2.DVPair = exports2.ValAddresses = exports2.Validator = exports2.Description = exports2.Commission = exports2.CommissionRates = exports2.HistoricalInfo = exports2.bondStatusToJSON = exports2.bondStatusFromJSON = exports2.BondStatus = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var types_1 = require_types2();
      var timestamp_1 = require_timestamp();
      var any_1 = require_any();
      var duration_1 = require_duration();
      var coin_1 = require_coin();
      exports2.protobufPackage = "cosmos.staking.v1beta1";
      var BondStatus;
      (function(BondStatus2) {
        BondStatus2[BondStatus2["BOND_STATUS_UNSPECIFIED"] = 0] = "BOND_STATUS_UNSPECIFIED";
        BondStatus2[BondStatus2["BOND_STATUS_UNBONDED"] = 1] = "BOND_STATUS_UNBONDED";
        BondStatus2[BondStatus2["BOND_STATUS_UNBONDING"] = 2] = "BOND_STATUS_UNBONDING";
        BondStatus2[BondStatus2["BOND_STATUS_BONDED"] = 3] = "BOND_STATUS_BONDED";
        BondStatus2[BondStatus2["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
      })(BondStatus = exports2.BondStatus || (exports2.BondStatus = {}));
      function bondStatusFromJSON(object) {
        switch (object) {
          case 0:
          case "BOND_STATUS_UNSPECIFIED":
            return BondStatus.BOND_STATUS_UNSPECIFIED;
          case 1:
          case "BOND_STATUS_UNBONDED":
            return BondStatus.BOND_STATUS_UNBONDED;
          case 2:
          case "BOND_STATUS_UNBONDING":
            return BondStatus.BOND_STATUS_UNBONDING;
          case 3:
          case "BOND_STATUS_BONDED":
            return BondStatus.BOND_STATUS_BONDED;
          case -1:
          case "UNRECOGNIZED":
          default:
            return BondStatus.UNRECOGNIZED;
        }
      }
      exports2.bondStatusFromJSON = bondStatusFromJSON;
      function bondStatusToJSON(object) {
        switch (object) {
          case BondStatus.BOND_STATUS_UNSPECIFIED:
            return "BOND_STATUS_UNSPECIFIED";
          case BondStatus.BOND_STATUS_UNBONDED:
            return "BOND_STATUS_UNBONDED";
          case BondStatus.BOND_STATUS_UNBONDING:
            return "BOND_STATUS_UNBONDING";
          case BondStatus.BOND_STATUS_BONDED:
            return "BOND_STATUS_BONDED";
          default:
            return "UNKNOWN";
        }
      }
      exports2.bondStatusToJSON = bondStatusToJSON;
      var baseHistoricalInfo = {};
      exports2.HistoricalInfo = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.header !== void 0) {
            types_1.Header.encode(message.header, writer.uint32(10).fork()).ldelim();
          }
          for (const v of message.valset) {
            exports2.Validator.encode(v, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseHistoricalInfo);
          message.valset = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.header = types_1.Header.decode(reader, reader.uint32());
                break;
              case 2:
                message.valset.push(exports2.Validator.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseHistoricalInfo);
          message.header = object.header !== void 0 && object.header !== null ? types_1.Header.fromJSON(object.header) : void 0;
          message.valset = ((_a = object.valset) !== null && _a !== void 0 ? _a : []).map((e) => exports2.Validator.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.header !== void 0 && (obj.header = message.header ? types_1.Header.toJSON(message.header) : void 0);
          if (message.valset) {
            obj.valset = message.valset.map((e) => e ? exports2.Validator.toJSON(e) : void 0);
          } else {
            obj.valset = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseHistoricalInfo);
          message.header = object.header !== void 0 && object.header !== null ? types_1.Header.fromPartial(object.header) : void 0;
          message.valset = ((_a = object.valset) === null || _a === void 0 ? void 0 : _a.map((e) => exports2.Validator.fromPartial(e))) || [];
          return message;
        }
      };
      var baseCommissionRates = { rate: "", maxRate: "", maxChangeRate: "" };
      exports2.CommissionRates = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.rate !== "") {
            writer.uint32(10).string(message.rate);
          }
          if (message.maxRate !== "") {
            writer.uint32(18).string(message.maxRate);
          }
          if (message.maxChangeRate !== "") {
            writer.uint32(26).string(message.maxChangeRate);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseCommissionRates);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.rate = reader.string();
                break;
              case 2:
                message.maxRate = reader.string();
                break;
              case 3:
                message.maxChangeRate = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseCommissionRates);
          message.rate = object.rate !== void 0 && object.rate !== null ? String(object.rate) : "";
          message.maxRate = object.maxRate !== void 0 && object.maxRate !== null ? String(object.maxRate) : "";
          message.maxChangeRate = object.maxChangeRate !== void 0 && object.maxChangeRate !== null ? String(object.maxChangeRate) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.rate !== void 0 && (obj.rate = message.rate);
          message.maxRate !== void 0 && (obj.maxRate = message.maxRate);
          message.maxChangeRate !== void 0 && (obj.maxChangeRate = message.maxChangeRate);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseCommissionRates);
          message.rate = (_a = object.rate) !== null && _a !== void 0 ? _a : "";
          message.maxRate = (_b = object.maxRate) !== null && _b !== void 0 ? _b : "";
          message.maxChangeRate = (_c = object.maxChangeRate) !== null && _c !== void 0 ? _c : "";
          return message;
        }
      };
      var baseCommission = {};
      exports2.Commission = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.commissionRates !== void 0) {
            exports2.CommissionRates.encode(message.commissionRates, writer.uint32(10).fork()).ldelim();
          }
          if (message.updateTime !== void 0) {
            timestamp_1.Timestamp.encode(message.updateTime, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseCommission);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.commissionRates = exports2.CommissionRates.decode(reader, reader.uint32());
                break;
              case 2:
                message.updateTime = timestamp_1.Timestamp.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseCommission);
          message.commissionRates = object.commissionRates !== void 0 && object.commissionRates !== null ? exports2.CommissionRates.fromJSON(object.commissionRates) : void 0;
          message.updateTime = object.updateTime !== void 0 && object.updateTime !== null ? fromJsonTimestamp(object.updateTime) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.commissionRates !== void 0 && (obj.commissionRates = message.commissionRates ? exports2.CommissionRates.toJSON(message.commissionRates) : void 0);
          message.updateTime !== void 0 && (obj.updateTime = fromTimestamp(message.updateTime).toISOString());
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseCommission);
          message.commissionRates = object.commissionRates !== void 0 && object.commissionRates !== null ? exports2.CommissionRates.fromPartial(object.commissionRates) : void 0;
          message.updateTime = object.updateTime !== void 0 && object.updateTime !== null ? timestamp_1.Timestamp.fromPartial(object.updateTime) : void 0;
          return message;
        }
      };
      var baseDescription = { moniker: "", identity: "", website: "", securityContact: "", details: "" };
      exports2.Description = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.moniker !== "") {
            writer.uint32(10).string(message.moniker);
          }
          if (message.identity !== "") {
            writer.uint32(18).string(message.identity);
          }
          if (message.website !== "") {
            writer.uint32(26).string(message.website);
          }
          if (message.securityContact !== "") {
            writer.uint32(34).string(message.securityContact);
          }
          if (message.details !== "") {
            writer.uint32(42).string(message.details);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseDescription);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.moniker = reader.string();
                break;
              case 2:
                message.identity = reader.string();
                break;
              case 3:
                message.website = reader.string();
                break;
              case 4:
                message.securityContact = reader.string();
                break;
              case 5:
                message.details = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseDescription);
          message.moniker = object.moniker !== void 0 && object.moniker !== null ? String(object.moniker) : "";
          message.identity = object.identity !== void 0 && object.identity !== null ? String(object.identity) : "";
          message.website = object.website !== void 0 && object.website !== null ? String(object.website) : "";
          message.securityContact = object.securityContact !== void 0 && object.securityContact !== null ? String(object.securityContact) : "";
          message.details = object.details !== void 0 && object.details !== null ? String(object.details) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.moniker !== void 0 && (obj.moniker = message.moniker);
          message.identity !== void 0 && (obj.identity = message.identity);
          message.website !== void 0 && (obj.website = message.website);
          message.securityContact !== void 0 && (obj.securityContact = message.securityContact);
          message.details !== void 0 && (obj.details = message.details);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c, _d, _e;
          const message = Object.assign({}, baseDescription);
          message.moniker = (_a = object.moniker) !== null && _a !== void 0 ? _a : "";
          message.identity = (_b = object.identity) !== null && _b !== void 0 ? _b : "";
          message.website = (_c = object.website) !== null && _c !== void 0 ? _c : "";
          message.securityContact = (_d = object.securityContact) !== null && _d !== void 0 ? _d : "";
          message.details = (_e = object.details) !== null && _e !== void 0 ? _e : "";
          return message;
        }
      };
      var baseValidator = {
        operatorAddress: "",
        jailed: false,
        status: 0,
        tokens: "",
        delegatorShares: "",
        unbondingHeight: long_1.default.ZERO,
        minSelfDelegation: ""
      };
      exports2.Validator = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.operatorAddress !== "") {
            writer.uint32(10).string(message.operatorAddress);
          }
          if (message.consensusPubkey !== void 0) {
            any_1.Any.encode(message.consensusPubkey, writer.uint32(18).fork()).ldelim();
          }
          if (message.jailed === true) {
            writer.uint32(24).bool(message.jailed);
          }
          if (message.status !== 0) {
            writer.uint32(32).int32(message.status);
          }
          if (message.tokens !== "") {
            writer.uint32(42).string(message.tokens);
          }
          if (message.delegatorShares !== "") {
            writer.uint32(50).string(message.delegatorShares);
          }
          if (message.description !== void 0) {
            exports2.Description.encode(message.description, writer.uint32(58).fork()).ldelim();
          }
          if (!message.unbondingHeight.isZero()) {
            writer.uint32(64).int64(message.unbondingHeight);
          }
          if (message.unbondingTime !== void 0) {
            timestamp_1.Timestamp.encode(message.unbondingTime, writer.uint32(74).fork()).ldelim();
          }
          if (message.commission !== void 0) {
            exports2.Commission.encode(message.commission, writer.uint32(82).fork()).ldelim();
          }
          if (message.minSelfDelegation !== "") {
            writer.uint32(90).string(message.minSelfDelegation);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseValidator);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.operatorAddress = reader.string();
                break;
              case 2:
                message.consensusPubkey = any_1.Any.decode(reader, reader.uint32());
                break;
              case 3:
                message.jailed = reader.bool();
                break;
              case 4:
                message.status = reader.int32();
                break;
              case 5:
                message.tokens = reader.string();
                break;
              case 6:
                message.delegatorShares = reader.string();
                break;
              case 7:
                message.description = exports2.Description.decode(reader, reader.uint32());
                break;
              case 8:
                message.unbondingHeight = reader.int64();
                break;
              case 9:
                message.unbondingTime = timestamp_1.Timestamp.decode(reader, reader.uint32());
                break;
              case 10:
                message.commission = exports2.Commission.decode(reader, reader.uint32());
                break;
              case 11:
                message.minSelfDelegation = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseValidator);
          message.operatorAddress = object.operatorAddress !== void 0 && object.operatorAddress !== null ? String(object.operatorAddress) : "";
          message.consensusPubkey = object.consensusPubkey !== void 0 && object.consensusPubkey !== null ? any_1.Any.fromJSON(object.consensusPubkey) : void 0;
          message.jailed = object.jailed !== void 0 && object.jailed !== null ? Boolean(object.jailed) : false;
          message.status = object.status !== void 0 && object.status !== null ? bondStatusFromJSON(object.status) : 0;
          message.tokens = object.tokens !== void 0 && object.tokens !== null ? String(object.tokens) : "";
          message.delegatorShares = object.delegatorShares !== void 0 && object.delegatorShares !== null ? String(object.delegatorShares) : "";
          message.description = object.description !== void 0 && object.description !== null ? exports2.Description.fromJSON(object.description) : void 0;
          message.unbondingHeight = object.unbondingHeight !== void 0 && object.unbondingHeight !== null ? long_1.default.fromString(object.unbondingHeight) : long_1.default.ZERO;
          message.unbondingTime = object.unbondingTime !== void 0 && object.unbondingTime !== null ? fromJsonTimestamp(object.unbondingTime) : void 0;
          message.commission = object.commission !== void 0 && object.commission !== null ? exports2.Commission.fromJSON(object.commission) : void 0;
          message.minSelfDelegation = object.minSelfDelegation !== void 0 && object.minSelfDelegation !== null ? String(object.minSelfDelegation) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.operatorAddress !== void 0 && (obj.operatorAddress = message.operatorAddress);
          message.consensusPubkey !== void 0 && (obj.consensusPubkey = message.consensusPubkey ? any_1.Any.toJSON(message.consensusPubkey) : void 0);
          message.jailed !== void 0 && (obj.jailed = message.jailed);
          message.status !== void 0 && (obj.status = bondStatusToJSON(message.status));
          message.tokens !== void 0 && (obj.tokens = message.tokens);
          message.delegatorShares !== void 0 && (obj.delegatorShares = message.delegatorShares);
          message.description !== void 0 && (obj.description = message.description ? exports2.Description.toJSON(message.description) : void 0);
          message.unbondingHeight !== void 0 && (obj.unbondingHeight = (message.unbondingHeight || long_1.default.ZERO).toString());
          message.unbondingTime !== void 0 && (obj.unbondingTime = fromTimestamp(message.unbondingTime).toISOString());
          message.commission !== void 0 && (obj.commission = message.commission ? exports2.Commission.toJSON(message.commission) : void 0);
          message.minSelfDelegation !== void 0 && (obj.minSelfDelegation = message.minSelfDelegation);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c, _d, _e, _f;
          const message = Object.assign({}, baseValidator);
          message.operatorAddress = (_a = object.operatorAddress) !== null && _a !== void 0 ? _a : "";
          message.consensusPubkey = object.consensusPubkey !== void 0 && object.consensusPubkey !== null ? any_1.Any.fromPartial(object.consensusPubkey) : void 0;
          message.jailed = (_b = object.jailed) !== null && _b !== void 0 ? _b : false;
          message.status = (_c = object.status) !== null && _c !== void 0 ? _c : 0;
          message.tokens = (_d = object.tokens) !== null && _d !== void 0 ? _d : "";
          message.delegatorShares = (_e = object.delegatorShares) !== null && _e !== void 0 ? _e : "";
          message.description = object.description !== void 0 && object.description !== null ? exports2.Description.fromPartial(object.description) : void 0;
          message.unbondingHeight = object.unbondingHeight !== void 0 && object.unbondingHeight !== null ? long_1.default.fromValue(object.unbondingHeight) : long_1.default.ZERO;
          message.unbondingTime = object.unbondingTime !== void 0 && object.unbondingTime !== null ? timestamp_1.Timestamp.fromPartial(object.unbondingTime) : void 0;
          message.commission = object.commission !== void 0 && object.commission !== null ? exports2.Commission.fromPartial(object.commission) : void 0;
          message.minSelfDelegation = (_f = object.minSelfDelegation) !== null && _f !== void 0 ? _f : "";
          return message;
        }
      };
      var baseValAddresses = { addresses: "" };
      exports2.ValAddresses = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.addresses) {
            writer.uint32(10).string(v);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseValAddresses);
          message.addresses = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.addresses.push(reader.string());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseValAddresses);
          message.addresses = ((_a = object.addresses) !== null && _a !== void 0 ? _a : []).map((e) => String(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.addresses) {
            obj.addresses = message.addresses.map((e) => e);
          } else {
            obj.addresses = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseValAddresses);
          message.addresses = ((_a = object.addresses) === null || _a === void 0 ? void 0 : _a.map((e) => e)) || [];
          return message;
        }
      };
      var baseDVPair = { delegatorAddress: "", validatorAddress: "" };
      exports2.DVPair = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.delegatorAddress !== "") {
            writer.uint32(10).string(message.delegatorAddress);
          }
          if (message.validatorAddress !== "") {
            writer.uint32(18).string(message.validatorAddress);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseDVPair);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.delegatorAddress = reader.string();
                break;
              case 2:
                message.validatorAddress = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseDVPair);
          message.delegatorAddress = object.delegatorAddress !== void 0 && object.delegatorAddress !== null ? String(object.delegatorAddress) : "";
          message.validatorAddress = object.validatorAddress !== void 0 && object.validatorAddress !== null ? String(object.validatorAddress) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.delegatorAddress !== void 0 && (obj.delegatorAddress = message.delegatorAddress);
          message.validatorAddress !== void 0 && (obj.validatorAddress = message.validatorAddress);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseDVPair);
          message.delegatorAddress = (_a = object.delegatorAddress) !== null && _a !== void 0 ? _a : "";
          message.validatorAddress = (_b = object.validatorAddress) !== null && _b !== void 0 ? _b : "";
          return message;
        }
      };
      var baseDVPairs = {};
      exports2.DVPairs = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.pairs) {
            exports2.DVPair.encode(v, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseDVPairs);
          message.pairs = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.pairs.push(exports2.DVPair.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseDVPairs);
          message.pairs = ((_a = object.pairs) !== null && _a !== void 0 ? _a : []).map((e) => exports2.DVPair.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.pairs) {
            obj.pairs = message.pairs.map((e) => e ? exports2.DVPair.toJSON(e) : void 0);
          } else {
            obj.pairs = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseDVPairs);
          message.pairs = ((_a = object.pairs) === null || _a === void 0 ? void 0 : _a.map((e) => exports2.DVPair.fromPartial(e))) || [];
          return message;
        }
      };
      var baseDVVTriplet = { delegatorAddress: "", validatorSrcAddress: "", validatorDstAddress: "" };
      exports2.DVVTriplet = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.delegatorAddress !== "") {
            writer.uint32(10).string(message.delegatorAddress);
          }
          if (message.validatorSrcAddress !== "") {
            writer.uint32(18).string(message.validatorSrcAddress);
          }
          if (message.validatorDstAddress !== "") {
            writer.uint32(26).string(message.validatorDstAddress);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseDVVTriplet);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.delegatorAddress = reader.string();
                break;
              case 2:
                message.validatorSrcAddress = reader.string();
                break;
              case 3:
                message.validatorDstAddress = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseDVVTriplet);
          message.delegatorAddress = object.delegatorAddress !== void 0 && object.delegatorAddress !== null ? String(object.delegatorAddress) : "";
          message.validatorSrcAddress = object.validatorSrcAddress !== void 0 && object.validatorSrcAddress !== null ? String(object.validatorSrcAddress) : "";
          message.validatorDstAddress = object.validatorDstAddress !== void 0 && object.validatorDstAddress !== null ? String(object.validatorDstAddress) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.delegatorAddress !== void 0 && (obj.delegatorAddress = message.delegatorAddress);
          message.validatorSrcAddress !== void 0 && (obj.validatorSrcAddress = message.validatorSrcAddress);
          message.validatorDstAddress !== void 0 && (obj.validatorDstAddress = message.validatorDstAddress);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseDVVTriplet);
          message.delegatorAddress = (_a = object.delegatorAddress) !== null && _a !== void 0 ? _a : "";
          message.validatorSrcAddress = (_b = object.validatorSrcAddress) !== null && _b !== void 0 ? _b : "";
          message.validatorDstAddress = (_c = object.validatorDstAddress) !== null && _c !== void 0 ? _c : "";
          return message;
        }
      };
      var baseDVVTriplets = {};
      exports2.DVVTriplets = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.triplets) {
            exports2.DVVTriplet.encode(v, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseDVVTriplets);
          message.triplets = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.triplets.push(exports2.DVVTriplet.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseDVVTriplets);
          message.triplets = ((_a = object.triplets) !== null && _a !== void 0 ? _a : []).map((e) => exports2.DVVTriplet.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.triplets) {
            obj.triplets = message.triplets.map((e) => e ? exports2.DVVTriplet.toJSON(e) : void 0);
          } else {
            obj.triplets = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseDVVTriplets);
          message.triplets = ((_a = object.triplets) === null || _a === void 0 ? void 0 : _a.map((e) => exports2.DVVTriplet.fromPartial(e))) || [];
          return message;
        }
      };
      var baseDelegation = { delegatorAddress: "", validatorAddress: "", shares: "" };
      exports2.Delegation = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.delegatorAddress !== "") {
            writer.uint32(10).string(message.delegatorAddress);
          }
          if (message.validatorAddress !== "") {
            writer.uint32(18).string(message.validatorAddress);
          }
          if (message.shares !== "") {
            writer.uint32(26).string(message.shares);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseDelegation);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.delegatorAddress = reader.string();
                break;
              case 2:
                message.validatorAddress = reader.string();
                break;
              case 3:
                message.shares = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseDelegation);
          message.delegatorAddress = object.delegatorAddress !== void 0 && object.delegatorAddress !== null ? String(object.delegatorAddress) : "";
          message.validatorAddress = object.validatorAddress !== void 0 && object.validatorAddress !== null ? String(object.validatorAddress) : "";
          message.shares = object.shares !== void 0 && object.shares !== null ? String(object.shares) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.delegatorAddress !== void 0 && (obj.delegatorAddress = message.delegatorAddress);
          message.validatorAddress !== void 0 && (obj.validatorAddress = message.validatorAddress);
          message.shares !== void 0 && (obj.shares = message.shares);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseDelegation);
          message.delegatorAddress = (_a = object.delegatorAddress) !== null && _a !== void 0 ? _a : "";
          message.validatorAddress = (_b = object.validatorAddress) !== null && _b !== void 0 ? _b : "";
          message.shares = (_c = object.shares) !== null && _c !== void 0 ? _c : "";
          return message;
        }
      };
      var baseUnbondingDelegation = { delegatorAddress: "", validatorAddress: "" };
      exports2.UnbondingDelegation = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.delegatorAddress !== "") {
            writer.uint32(10).string(message.delegatorAddress);
          }
          if (message.validatorAddress !== "") {
            writer.uint32(18).string(message.validatorAddress);
          }
          for (const v of message.entries) {
            exports2.UnbondingDelegationEntry.encode(v, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseUnbondingDelegation);
          message.entries = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.delegatorAddress = reader.string();
                break;
              case 2:
                message.validatorAddress = reader.string();
                break;
              case 3:
                message.entries.push(exports2.UnbondingDelegationEntry.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseUnbondingDelegation);
          message.delegatorAddress = object.delegatorAddress !== void 0 && object.delegatorAddress !== null ? String(object.delegatorAddress) : "";
          message.validatorAddress = object.validatorAddress !== void 0 && object.validatorAddress !== null ? String(object.validatorAddress) : "";
          message.entries = ((_a = object.entries) !== null && _a !== void 0 ? _a : []).map((e) => exports2.UnbondingDelegationEntry.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.delegatorAddress !== void 0 && (obj.delegatorAddress = message.delegatorAddress);
          message.validatorAddress !== void 0 && (obj.validatorAddress = message.validatorAddress);
          if (message.entries) {
            obj.entries = message.entries.map((e) => e ? exports2.UnbondingDelegationEntry.toJSON(e) : void 0);
          } else {
            obj.entries = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseUnbondingDelegation);
          message.delegatorAddress = (_a = object.delegatorAddress) !== null && _a !== void 0 ? _a : "";
          message.validatorAddress = (_b = object.validatorAddress) !== null && _b !== void 0 ? _b : "";
          message.entries = ((_c = object.entries) === null || _c === void 0 ? void 0 : _c.map((e) => exports2.UnbondingDelegationEntry.fromPartial(e))) || [];
          return message;
        }
      };
      var baseUnbondingDelegationEntry = { creationHeight: long_1.default.ZERO, initialBalance: "", balance: "" };
      exports2.UnbondingDelegationEntry = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.creationHeight.isZero()) {
            writer.uint32(8).int64(message.creationHeight);
          }
          if (message.completionTime !== void 0) {
            timestamp_1.Timestamp.encode(message.completionTime, writer.uint32(18).fork()).ldelim();
          }
          if (message.initialBalance !== "") {
            writer.uint32(26).string(message.initialBalance);
          }
          if (message.balance !== "") {
            writer.uint32(34).string(message.balance);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseUnbondingDelegationEntry);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.creationHeight = reader.int64();
                break;
              case 2:
                message.completionTime = timestamp_1.Timestamp.decode(reader, reader.uint32());
                break;
              case 3:
                message.initialBalance = reader.string();
                break;
              case 4:
                message.balance = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseUnbondingDelegationEntry);
          message.creationHeight = object.creationHeight !== void 0 && object.creationHeight !== null ? long_1.default.fromString(object.creationHeight) : long_1.default.ZERO;
          message.completionTime = object.completionTime !== void 0 && object.completionTime !== null ? fromJsonTimestamp(object.completionTime) : void 0;
          message.initialBalance = object.initialBalance !== void 0 && object.initialBalance !== null ? String(object.initialBalance) : "";
          message.balance = object.balance !== void 0 && object.balance !== null ? String(object.balance) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.creationHeight !== void 0 && (obj.creationHeight = (message.creationHeight || long_1.default.ZERO).toString());
          message.completionTime !== void 0 && (obj.completionTime = fromTimestamp(message.completionTime).toISOString());
          message.initialBalance !== void 0 && (obj.initialBalance = message.initialBalance);
          message.balance !== void 0 && (obj.balance = message.balance);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseUnbondingDelegationEntry);
          message.creationHeight = object.creationHeight !== void 0 && object.creationHeight !== null ? long_1.default.fromValue(object.creationHeight) : long_1.default.ZERO;
          message.completionTime = object.completionTime !== void 0 && object.completionTime !== null ? timestamp_1.Timestamp.fromPartial(object.completionTime) : void 0;
          message.initialBalance = (_a = object.initialBalance) !== null && _a !== void 0 ? _a : "";
          message.balance = (_b = object.balance) !== null && _b !== void 0 ? _b : "";
          return message;
        }
      };
      var baseRedelegationEntry = { creationHeight: long_1.default.ZERO, initialBalance: "", sharesDst: "" };
      exports2.RedelegationEntry = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.creationHeight.isZero()) {
            writer.uint32(8).int64(message.creationHeight);
          }
          if (message.completionTime !== void 0) {
            timestamp_1.Timestamp.encode(message.completionTime, writer.uint32(18).fork()).ldelim();
          }
          if (message.initialBalance !== "") {
            writer.uint32(26).string(message.initialBalance);
          }
          if (message.sharesDst !== "") {
            writer.uint32(34).string(message.sharesDst);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseRedelegationEntry);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.creationHeight = reader.int64();
                break;
              case 2:
                message.completionTime = timestamp_1.Timestamp.decode(reader, reader.uint32());
                break;
              case 3:
                message.initialBalance = reader.string();
                break;
              case 4:
                message.sharesDst = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseRedelegationEntry);
          message.creationHeight = object.creationHeight !== void 0 && object.creationHeight !== null ? long_1.default.fromString(object.creationHeight) : long_1.default.ZERO;
          message.completionTime = object.completionTime !== void 0 && object.completionTime !== null ? fromJsonTimestamp(object.completionTime) : void 0;
          message.initialBalance = object.initialBalance !== void 0 && object.initialBalance !== null ? String(object.initialBalance) : "";
          message.sharesDst = object.sharesDst !== void 0 && object.sharesDst !== null ? String(object.sharesDst) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.creationHeight !== void 0 && (obj.creationHeight = (message.creationHeight || long_1.default.ZERO).toString());
          message.completionTime !== void 0 && (obj.completionTime = fromTimestamp(message.completionTime).toISOString());
          message.initialBalance !== void 0 && (obj.initialBalance = message.initialBalance);
          message.sharesDst !== void 0 && (obj.sharesDst = message.sharesDst);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseRedelegationEntry);
          message.creationHeight = object.creationHeight !== void 0 && object.creationHeight !== null ? long_1.default.fromValue(object.creationHeight) : long_1.default.ZERO;
          message.completionTime = object.completionTime !== void 0 && object.completionTime !== null ? timestamp_1.Timestamp.fromPartial(object.completionTime) : void 0;
          message.initialBalance = (_a = object.initialBalance) !== null && _a !== void 0 ? _a : "";
          message.sharesDst = (_b = object.sharesDst) !== null && _b !== void 0 ? _b : "";
          return message;
        }
      };
      var baseRedelegation = { delegatorAddress: "", validatorSrcAddress: "", validatorDstAddress: "" };
      exports2.Redelegation = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.delegatorAddress !== "") {
            writer.uint32(10).string(message.delegatorAddress);
          }
          if (message.validatorSrcAddress !== "") {
            writer.uint32(18).string(message.validatorSrcAddress);
          }
          if (message.validatorDstAddress !== "") {
            writer.uint32(26).string(message.validatorDstAddress);
          }
          for (const v of message.entries) {
            exports2.RedelegationEntry.encode(v, writer.uint32(34).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseRedelegation);
          message.entries = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.delegatorAddress = reader.string();
                break;
              case 2:
                message.validatorSrcAddress = reader.string();
                break;
              case 3:
                message.validatorDstAddress = reader.string();
                break;
              case 4:
                message.entries.push(exports2.RedelegationEntry.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseRedelegation);
          message.delegatorAddress = object.delegatorAddress !== void 0 && object.delegatorAddress !== null ? String(object.delegatorAddress) : "";
          message.validatorSrcAddress = object.validatorSrcAddress !== void 0 && object.validatorSrcAddress !== null ? String(object.validatorSrcAddress) : "";
          message.validatorDstAddress = object.validatorDstAddress !== void 0 && object.validatorDstAddress !== null ? String(object.validatorDstAddress) : "";
          message.entries = ((_a = object.entries) !== null && _a !== void 0 ? _a : []).map((e) => exports2.RedelegationEntry.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.delegatorAddress !== void 0 && (obj.delegatorAddress = message.delegatorAddress);
          message.validatorSrcAddress !== void 0 && (obj.validatorSrcAddress = message.validatorSrcAddress);
          message.validatorDstAddress !== void 0 && (obj.validatorDstAddress = message.validatorDstAddress);
          if (message.entries) {
            obj.entries = message.entries.map((e) => e ? exports2.RedelegationEntry.toJSON(e) : void 0);
          } else {
            obj.entries = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c, _d;
          const message = Object.assign({}, baseRedelegation);
          message.delegatorAddress = (_a = object.delegatorAddress) !== null && _a !== void 0 ? _a : "";
          message.validatorSrcAddress = (_b = object.validatorSrcAddress) !== null && _b !== void 0 ? _b : "";
          message.validatorDstAddress = (_c = object.validatorDstAddress) !== null && _c !== void 0 ? _c : "";
          message.entries = ((_d = object.entries) === null || _d === void 0 ? void 0 : _d.map((e) => exports2.RedelegationEntry.fromPartial(e))) || [];
          return message;
        }
      };
      var baseParams = { maxValidators: 0, maxEntries: 0, historicalEntries: 0, bondDenom: "" };
      exports2.Params = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.unbondingTime !== void 0) {
            duration_1.Duration.encode(message.unbondingTime, writer.uint32(10).fork()).ldelim();
          }
          if (message.maxValidators !== 0) {
            writer.uint32(16).uint32(message.maxValidators);
          }
          if (message.maxEntries !== 0) {
            writer.uint32(24).uint32(message.maxEntries);
          }
          if (message.historicalEntries !== 0) {
            writer.uint32(32).uint32(message.historicalEntries);
          }
          if (message.bondDenom !== "") {
            writer.uint32(42).string(message.bondDenom);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseParams);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.unbondingTime = duration_1.Duration.decode(reader, reader.uint32());
                break;
              case 2:
                message.maxValidators = reader.uint32();
                break;
              case 3:
                message.maxEntries = reader.uint32();
                break;
              case 4:
                message.historicalEntries = reader.uint32();
                break;
              case 5:
                message.bondDenom = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseParams);
          message.unbondingTime = object.unbondingTime !== void 0 && object.unbondingTime !== null ? duration_1.Duration.fromJSON(object.unbondingTime) : void 0;
          message.maxValidators = object.maxValidators !== void 0 && object.maxValidators !== null ? Number(object.maxValidators) : 0;
          message.maxEntries = object.maxEntries !== void 0 && object.maxEntries !== null ? Number(object.maxEntries) : 0;
          message.historicalEntries = object.historicalEntries !== void 0 && object.historicalEntries !== null ? Number(object.historicalEntries) : 0;
          message.bondDenom = object.bondDenom !== void 0 && object.bondDenom !== null ? String(object.bondDenom) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.unbondingTime !== void 0 && (obj.unbondingTime = message.unbondingTime ? duration_1.Duration.toJSON(message.unbondingTime) : void 0);
          message.maxValidators !== void 0 && (obj.maxValidators = message.maxValidators);
          message.maxEntries !== void 0 && (obj.maxEntries = message.maxEntries);
          message.historicalEntries !== void 0 && (obj.historicalEntries = message.historicalEntries);
          message.bondDenom !== void 0 && (obj.bondDenom = message.bondDenom);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c, _d;
          const message = Object.assign({}, baseParams);
          message.unbondingTime = object.unbondingTime !== void 0 && object.unbondingTime !== null ? duration_1.Duration.fromPartial(object.unbondingTime) : void 0;
          message.maxValidators = (_a = object.maxValidators) !== null && _a !== void 0 ? _a : 0;
          message.maxEntries = (_b = object.maxEntries) !== null && _b !== void 0 ? _b : 0;
          message.historicalEntries = (_c = object.historicalEntries) !== null && _c !== void 0 ? _c : 0;
          message.bondDenom = (_d = object.bondDenom) !== null && _d !== void 0 ? _d : "";
          return message;
        }
      };
      var baseDelegationResponse = {};
      exports2.DelegationResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.delegation !== void 0) {
            exports2.Delegation.encode(message.delegation, writer.uint32(10).fork()).ldelim();
          }
          if (message.balance !== void 0) {
            coin_1.Coin.encode(message.balance, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseDelegationResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.delegation = exports2.Delegation.decode(reader, reader.uint32());
                break;
              case 2:
                message.balance = coin_1.Coin.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseDelegationResponse);
          message.delegation = object.delegation !== void 0 && object.delegation !== null ? exports2.Delegation.fromJSON(object.delegation) : void 0;
          message.balance = object.balance !== void 0 && object.balance !== null ? coin_1.Coin.fromJSON(object.balance) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.delegation !== void 0 && (obj.delegation = message.delegation ? exports2.Delegation.toJSON(message.delegation) : void 0);
          message.balance !== void 0 && (obj.balance = message.balance ? coin_1.Coin.toJSON(message.balance) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseDelegationResponse);
          message.delegation = object.delegation !== void 0 && object.delegation !== null ? exports2.Delegation.fromPartial(object.delegation) : void 0;
          message.balance = object.balance !== void 0 && object.balance !== null ? coin_1.Coin.fromPartial(object.balance) : void 0;
          return message;
        }
      };
      var baseRedelegationEntryResponse = { balance: "" };
      exports2.RedelegationEntryResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.redelegationEntry !== void 0) {
            exports2.RedelegationEntry.encode(message.redelegationEntry, writer.uint32(10).fork()).ldelim();
          }
          if (message.balance !== "") {
            writer.uint32(34).string(message.balance);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseRedelegationEntryResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.redelegationEntry = exports2.RedelegationEntry.decode(reader, reader.uint32());
                break;
              case 4:
                message.balance = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseRedelegationEntryResponse);
          message.redelegationEntry = object.redelegationEntry !== void 0 && object.redelegationEntry !== null ? exports2.RedelegationEntry.fromJSON(object.redelegationEntry) : void 0;
          message.balance = object.balance !== void 0 && object.balance !== null ? String(object.balance) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.redelegationEntry !== void 0 && (obj.redelegationEntry = message.redelegationEntry ? exports2.RedelegationEntry.toJSON(message.redelegationEntry) : void 0);
          message.balance !== void 0 && (obj.balance = message.balance);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseRedelegationEntryResponse);
          message.redelegationEntry = object.redelegationEntry !== void 0 && object.redelegationEntry !== null ? exports2.RedelegationEntry.fromPartial(object.redelegationEntry) : void 0;
          message.balance = (_a = object.balance) !== null && _a !== void 0 ? _a : "";
          return message;
        }
      };
      var baseRedelegationResponse = {};
      exports2.RedelegationResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.redelegation !== void 0) {
            exports2.Redelegation.encode(message.redelegation, writer.uint32(10).fork()).ldelim();
          }
          for (const v of message.entries) {
            exports2.RedelegationEntryResponse.encode(v, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseRedelegationResponse);
          message.entries = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.redelegation = exports2.Redelegation.decode(reader, reader.uint32());
                break;
              case 2:
                message.entries.push(exports2.RedelegationEntryResponse.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseRedelegationResponse);
          message.redelegation = object.redelegation !== void 0 && object.redelegation !== null ? exports2.Redelegation.fromJSON(object.redelegation) : void 0;
          message.entries = ((_a = object.entries) !== null && _a !== void 0 ? _a : []).map((e) => exports2.RedelegationEntryResponse.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.redelegation !== void 0 && (obj.redelegation = message.redelegation ? exports2.Redelegation.toJSON(message.redelegation) : void 0);
          if (message.entries) {
            obj.entries = message.entries.map((e) => e ? exports2.RedelegationEntryResponse.toJSON(e) : void 0);
          } else {
            obj.entries = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseRedelegationResponse);
          message.redelegation = object.redelegation !== void 0 && object.redelegation !== null ? exports2.Redelegation.fromPartial(object.redelegation) : void 0;
          message.entries = ((_a = object.entries) === null || _a === void 0 ? void 0 : _a.map((e) => exports2.RedelegationEntryResponse.fromPartial(e))) || [];
          return message;
        }
      };
      var basePool = { notBondedTokens: "", bondedTokens: "" };
      exports2.Pool = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.notBondedTokens !== "") {
            writer.uint32(10).string(message.notBondedTokens);
          }
          if (message.bondedTokens !== "") {
            writer.uint32(18).string(message.bondedTokens);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, basePool);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.notBondedTokens = reader.string();
                break;
              case 2:
                message.bondedTokens = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, basePool);
          message.notBondedTokens = object.notBondedTokens !== void 0 && object.notBondedTokens !== null ? String(object.notBondedTokens) : "";
          message.bondedTokens = object.bondedTokens !== void 0 && object.bondedTokens !== null ? String(object.bondedTokens) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.notBondedTokens !== void 0 && (obj.notBondedTokens = message.notBondedTokens);
          message.bondedTokens !== void 0 && (obj.bondedTokens = message.bondedTokens);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, basePool);
          message.notBondedTokens = (_a = object.notBondedTokens) !== null && _a !== void 0 ? _a : "";
          message.bondedTokens = (_b = object.bondedTokens) !== null && _b !== void 0 ? _b : "";
          return message;
        }
      };
      function toTimestamp(date) {
        const seconds = numberToLong(date.getTime() / 1e3);
        const nanos = date.getTime() % 1e3 * 1e6;
        return { seconds, nanos };
      }
      function fromTimestamp(t) {
        let millis = t.seconds.toNumber() * 1e3;
        millis += t.nanos / 1e6;
        return new Date(millis);
      }
      function fromJsonTimestamp(o) {
        if (o instanceof Date) {
          return toTimestamp(o);
        } else if (typeof o === "string") {
          return toTimestamp(new Date(o));
        } else {
          return timestamp_1.Timestamp.fromJSON(o);
        }
      }
      function numberToLong(number) {
        return long_1.default.fromNumber(number);
      }
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/cosmjs-types/cosmos/staking/v1beta1/tx.js
  var require_tx11 = __commonJS({
    "node_modules/cosmjs-types/cosmos/staking/v1beta1/tx.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.MsgClientImpl = exports2.MsgUndelegateResponse = exports2.MsgUndelegate = exports2.MsgBeginRedelegateResponse = exports2.MsgBeginRedelegate = exports2.MsgDelegateResponse = exports2.MsgDelegate = exports2.MsgEditValidatorResponse = exports2.MsgEditValidator = exports2.MsgCreateValidatorResponse = exports2.MsgCreateValidator = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var staking_1 = require_staking();
      var any_1 = require_any();
      var coin_1 = require_coin();
      var timestamp_1 = require_timestamp();
      exports2.protobufPackage = "cosmos.staking.v1beta1";
      var baseMsgCreateValidator = { minSelfDelegation: "", delegatorAddress: "", validatorAddress: "" };
      exports2.MsgCreateValidator = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.description !== void 0) {
            staking_1.Description.encode(message.description, writer.uint32(10).fork()).ldelim();
          }
          if (message.commission !== void 0) {
            staking_1.CommissionRates.encode(message.commission, writer.uint32(18).fork()).ldelim();
          }
          if (message.minSelfDelegation !== "") {
            writer.uint32(26).string(message.minSelfDelegation);
          }
          if (message.delegatorAddress !== "") {
            writer.uint32(34).string(message.delegatorAddress);
          }
          if (message.validatorAddress !== "") {
            writer.uint32(42).string(message.validatorAddress);
          }
          if (message.pubkey !== void 0) {
            any_1.Any.encode(message.pubkey, writer.uint32(50).fork()).ldelim();
          }
          if (message.value !== void 0) {
            coin_1.Coin.encode(message.value, writer.uint32(58).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgCreateValidator);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.description = staking_1.Description.decode(reader, reader.uint32());
                break;
              case 2:
                message.commission = staking_1.CommissionRates.decode(reader, reader.uint32());
                break;
              case 3:
                message.minSelfDelegation = reader.string();
                break;
              case 4:
                message.delegatorAddress = reader.string();
                break;
              case 5:
                message.validatorAddress = reader.string();
                break;
              case 6:
                message.pubkey = any_1.Any.decode(reader, reader.uint32());
                break;
              case 7:
                message.value = coin_1.Coin.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMsgCreateValidator);
          message.description = object.description !== void 0 && object.description !== null ? staking_1.Description.fromJSON(object.description) : void 0;
          message.commission = object.commission !== void 0 && object.commission !== null ? staking_1.CommissionRates.fromJSON(object.commission) : void 0;
          message.minSelfDelegation = object.minSelfDelegation !== void 0 && object.minSelfDelegation !== null ? String(object.minSelfDelegation) : "";
          message.delegatorAddress = object.delegatorAddress !== void 0 && object.delegatorAddress !== null ? String(object.delegatorAddress) : "";
          message.validatorAddress = object.validatorAddress !== void 0 && object.validatorAddress !== null ? String(object.validatorAddress) : "";
          message.pubkey = object.pubkey !== void 0 && object.pubkey !== null ? any_1.Any.fromJSON(object.pubkey) : void 0;
          message.value = object.value !== void 0 && object.value !== null ? coin_1.Coin.fromJSON(object.value) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.description !== void 0 && (obj.description = message.description ? staking_1.Description.toJSON(message.description) : void 0);
          message.commission !== void 0 && (obj.commission = message.commission ? staking_1.CommissionRates.toJSON(message.commission) : void 0);
          message.minSelfDelegation !== void 0 && (obj.minSelfDelegation = message.minSelfDelegation);
          message.delegatorAddress !== void 0 && (obj.delegatorAddress = message.delegatorAddress);
          message.validatorAddress !== void 0 && (obj.validatorAddress = message.validatorAddress);
          message.pubkey !== void 0 && (obj.pubkey = message.pubkey ? any_1.Any.toJSON(message.pubkey) : void 0);
          message.value !== void 0 && (obj.value = message.value ? coin_1.Coin.toJSON(message.value) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseMsgCreateValidator);
          message.description = object.description !== void 0 && object.description !== null ? staking_1.Description.fromPartial(object.description) : void 0;
          message.commission = object.commission !== void 0 && object.commission !== null ? staking_1.CommissionRates.fromPartial(object.commission) : void 0;
          message.minSelfDelegation = (_a = object.minSelfDelegation) !== null && _a !== void 0 ? _a : "";
          message.delegatorAddress = (_b = object.delegatorAddress) !== null && _b !== void 0 ? _b : "";
          message.validatorAddress = (_c = object.validatorAddress) !== null && _c !== void 0 ? _c : "";
          message.pubkey = object.pubkey !== void 0 && object.pubkey !== null ? any_1.Any.fromPartial(object.pubkey) : void 0;
          message.value = object.value !== void 0 && object.value !== null ? coin_1.Coin.fromPartial(object.value) : void 0;
          return message;
        }
      };
      var baseMsgCreateValidatorResponse = {};
      exports2.MsgCreateValidatorResponse = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgCreateValidatorResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseMsgCreateValidatorResponse);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseMsgCreateValidatorResponse);
          return message;
        }
      };
      var baseMsgEditValidator = { validatorAddress: "", commissionRate: "", minSelfDelegation: "" };
      exports2.MsgEditValidator = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.description !== void 0) {
            staking_1.Description.encode(message.description, writer.uint32(10).fork()).ldelim();
          }
          if (message.validatorAddress !== "") {
            writer.uint32(18).string(message.validatorAddress);
          }
          if (message.commissionRate !== "") {
            writer.uint32(26).string(message.commissionRate);
          }
          if (message.minSelfDelegation !== "") {
            writer.uint32(34).string(message.minSelfDelegation);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgEditValidator);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.description = staking_1.Description.decode(reader, reader.uint32());
                break;
              case 2:
                message.validatorAddress = reader.string();
                break;
              case 3:
                message.commissionRate = reader.string();
                break;
              case 4:
                message.minSelfDelegation = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMsgEditValidator);
          message.description = object.description !== void 0 && object.description !== null ? staking_1.Description.fromJSON(object.description) : void 0;
          message.validatorAddress = object.validatorAddress !== void 0 && object.validatorAddress !== null ? String(object.validatorAddress) : "";
          message.commissionRate = object.commissionRate !== void 0 && object.commissionRate !== null ? String(object.commissionRate) : "";
          message.minSelfDelegation = object.minSelfDelegation !== void 0 && object.minSelfDelegation !== null ? String(object.minSelfDelegation) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.description !== void 0 && (obj.description = message.description ? staking_1.Description.toJSON(message.description) : void 0);
          message.validatorAddress !== void 0 && (obj.validatorAddress = message.validatorAddress);
          message.commissionRate !== void 0 && (obj.commissionRate = message.commissionRate);
          message.minSelfDelegation !== void 0 && (obj.minSelfDelegation = message.minSelfDelegation);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseMsgEditValidator);
          message.description = object.description !== void 0 && object.description !== null ? staking_1.Description.fromPartial(object.description) : void 0;
          message.validatorAddress = (_a = object.validatorAddress) !== null && _a !== void 0 ? _a : "";
          message.commissionRate = (_b = object.commissionRate) !== null && _b !== void 0 ? _b : "";
          message.minSelfDelegation = (_c = object.minSelfDelegation) !== null && _c !== void 0 ? _c : "";
          return message;
        }
      };
      var baseMsgEditValidatorResponse = {};
      exports2.MsgEditValidatorResponse = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgEditValidatorResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseMsgEditValidatorResponse);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseMsgEditValidatorResponse);
          return message;
        }
      };
      var baseMsgDelegate = { delegatorAddress: "", validatorAddress: "" };
      exports2.MsgDelegate = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.delegatorAddress !== "") {
            writer.uint32(10).string(message.delegatorAddress);
          }
          if (message.validatorAddress !== "") {
            writer.uint32(18).string(message.validatorAddress);
          }
          if (message.amount !== void 0) {
            coin_1.Coin.encode(message.amount, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgDelegate);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.delegatorAddress = reader.string();
                break;
              case 2:
                message.validatorAddress = reader.string();
                break;
              case 3:
                message.amount = coin_1.Coin.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMsgDelegate);
          message.delegatorAddress = object.delegatorAddress !== void 0 && object.delegatorAddress !== null ? String(object.delegatorAddress) : "";
          message.validatorAddress = object.validatorAddress !== void 0 && object.validatorAddress !== null ? String(object.validatorAddress) : "";
          message.amount = object.amount !== void 0 && object.amount !== null ? coin_1.Coin.fromJSON(object.amount) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.delegatorAddress !== void 0 && (obj.delegatorAddress = message.delegatorAddress);
          message.validatorAddress !== void 0 && (obj.validatorAddress = message.validatorAddress);
          message.amount !== void 0 && (obj.amount = message.amount ? coin_1.Coin.toJSON(message.amount) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseMsgDelegate);
          message.delegatorAddress = (_a = object.delegatorAddress) !== null && _a !== void 0 ? _a : "";
          message.validatorAddress = (_b = object.validatorAddress) !== null && _b !== void 0 ? _b : "";
          message.amount = object.amount !== void 0 && object.amount !== null ? coin_1.Coin.fromPartial(object.amount) : void 0;
          return message;
        }
      };
      var baseMsgDelegateResponse = {};
      exports2.MsgDelegateResponse = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgDelegateResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseMsgDelegateResponse);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseMsgDelegateResponse);
          return message;
        }
      };
      var baseMsgBeginRedelegate = {
        delegatorAddress: "",
        validatorSrcAddress: "",
        validatorDstAddress: ""
      };
      exports2.MsgBeginRedelegate = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.delegatorAddress !== "") {
            writer.uint32(10).string(message.delegatorAddress);
          }
          if (message.validatorSrcAddress !== "") {
            writer.uint32(18).string(message.validatorSrcAddress);
          }
          if (message.validatorDstAddress !== "") {
            writer.uint32(26).string(message.validatorDstAddress);
          }
          if (message.amount !== void 0) {
            coin_1.Coin.encode(message.amount, writer.uint32(34).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgBeginRedelegate);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.delegatorAddress = reader.string();
                break;
              case 2:
                message.validatorSrcAddress = reader.string();
                break;
              case 3:
                message.validatorDstAddress = reader.string();
                break;
              case 4:
                message.amount = coin_1.Coin.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMsgBeginRedelegate);
          message.delegatorAddress = object.delegatorAddress !== void 0 && object.delegatorAddress !== null ? String(object.delegatorAddress) : "";
          message.validatorSrcAddress = object.validatorSrcAddress !== void 0 && object.validatorSrcAddress !== null ? String(object.validatorSrcAddress) : "";
          message.validatorDstAddress = object.validatorDstAddress !== void 0 && object.validatorDstAddress !== null ? String(object.validatorDstAddress) : "";
          message.amount = object.amount !== void 0 && object.amount !== null ? coin_1.Coin.fromJSON(object.amount) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.delegatorAddress !== void 0 && (obj.delegatorAddress = message.delegatorAddress);
          message.validatorSrcAddress !== void 0 && (obj.validatorSrcAddress = message.validatorSrcAddress);
          message.validatorDstAddress !== void 0 && (obj.validatorDstAddress = message.validatorDstAddress);
          message.amount !== void 0 && (obj.amount = message.amount ? coin_1.Coin.toJSON(message.amount) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseMsgBeginRedelegate);
          message.delegatorAddress = (_a = object.delegatorAddress) !== null && _a !== void 0 ? _a : "";
          message.validatorSrcAddress = (_b = object.validatorSrcAddress) !== null && _b !== void 0 ? _b : "";
          message.validatorDstAddress = (_c = object.validatorDstAddress) !== null && _c !== void 0 ? _c : "";
          message.amount = object.amount !== void 0 && object.amount !== null ? coin_1.Coin.fromPartial(object.amount) : void 0;
          return message;
        }
      };
      var baseMsgBeginRedelegateResponse = {};
      exports2.MsgBeginRedelegateResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.completionTime !== void 0) {
            timestamp_1.Timestamp.encode(message.completionTime, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgBeginRedelegateResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.completionTime = timestamp_1.Timestamp.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMsgBeginRedelegateResponse);
          message.completionTime = object.completionTime !== void 0 && object.completionTime !== null ? fromJsonTimestamp(object.completionTime) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.completionTime !== void 0 && (obj.completionTime = fromTimestamp(message.completionTime).toISOString());
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseMsgBeginRedelegateResponse);
          message.completionTime = object.completionTime !== void 0 && object.completionTime !== null ? timestamp_1.Timestamp.fromPartial(object.completionTime) : void 0;
          return message;
        }
      };
      var baseMsgUndelegate = { delegatorAddress: "", validatorAddress: "" };
      exports2.MsgUndelegate = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.delegatorAddress !== "") {
            writer.uint32(10).string(message.delegatorAddress);
          }
          if (message.validatorAddress !== "") {
            writer.uint32(18).string(message.validatorAddress);
          }
          if (message.amount !== void 0) {
            coin_1.Coin.encode(message.amount, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgUndelegate);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.delegatorAddress = reader.string();
                break;
              case 2:
                message.validatorAddress = reader.string();
                break;
              case 3:
                message.amount = coin_1.Coin.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMsgUndelegate);
          message.delegatorAddress = object.delegatorAddress !== void 0 && object.delegatorAddress !== null ? String(object.delegatorAddress) : "";
          message.validatorAddress = object.validatorAddress !== void 0 && object.validatorAddress !== null ? String(object.validatorAddress) : "";
          message.amount = object.amount !== void 0 && object.amount !== null ? coin_1.Coin.fromJSON(object.amount) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.delegatorAddress !== void 0 && (obj.delegatorAddress = message.delegatorAddress);
          message.validatorAddress !== void 0 && (obj.validatorAddress = message.validatorAddress);
          message.amount !== void 0 && (obj.amount = message.amount ? coin_1.Coin.toJSON(message.amount) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseMsgUndelegate);
          message.delegatorAddress = (_a = object.delegatorAddress) !== null && _a !== void 0 ? _a : "";
          message.validatorAddress = (_b = object.validatorAddress) !== null && _b !== void 0 ? _b : "";
          message.amount = object.amount !== void 0 && object.amount !== null ? coin_1.Coin.fromPartial(object.amount) : void 0;
          return message;
        }
      };
      var baseMsgUndelegateResponse = {};
      exports2.MsgUndelegateResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.completionTime !== void 0) {
            timestamp_1.Timestamp.encode(message.completionTime, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgUndelegateResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.completionTime = timestamp_1.Timestamp.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMsgUndelegateResponse);
          message.completionTime = object.completionTime !== void 0 && object.completionTime !== null ? fromJsonTimestamp(object.completionTime) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.completionTime !== void 0 && (obj.completionTime = fromTimestamp(message.completionTime).toISOString());
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseMsgUndelegateResponse);
          message.completionTime = object.completionTime !== void 0 && object.completionTime !== null ? timestamp_1.Timestamp.fromPartial(object.completionTime) : void 0;
          return message;
        }
      };
      var MsgClientImpl = class {
        constructor(rpc) {
          this.rpc = rpc;
          this.CreateValidator = this.CreateValidator.bind(this);
          this.EditValidator = this.EditValidator.bind(this);
          this.Delegate = this.Delegate.bind(this);
          this.BeginRedelegate = this.BeginRedelegate.bind(this);
          this.Undelegate = this.Undelegate.bind(this);
        }
        CreateValidator(request) {
          const data = exports2.MsgCreateValidator.encode(request).finish();
          const promise = this.rpc.request("cosmos.staking.v1beta1.Msg", "CreateValidator", data);
          return promise.then((data2) => exports2.MsgCreateValidatorResponse.decode(new minimal_1.default.Reader(data2)));
        }
        EditValidator(request) {
          const data = exports2.MsgEditValidator.encode(request).finish();
          const promise = this.rpc.request("cosmos.staking.v1beta1.Msg", "EditValidator", data);
          return promise.then((data2) => exports2.MsgEditValidatorResponse.decode(new minimal_1.default.Reader(data2)));
        }
        Delegate(request) {
          const data = exports2.MsgDelegate.encode(request).finish();
          const promise = this.rpc.request("cosmos.staking.v1beta1.Msg", "Delegate", data);
          return promise.then((data2) => exports2.MsgDelegateResponse.decode(new minimal_1.default.Reader(data2)));
        }
        BeginRedelegate(request) {
          const data = exports2.MsgBeginRedelegate.encode(request).finish();
          const promise = this.rpc.request("cosmos.staking.v1beta1.Msg", "BeginRedelegate", data);
          return promise.then((data2) => exports2.MsgBeginRedelegateResponse.decode(new minimal_1.default.Reader(data2)));
        }
        Undelegate(request) {
          const data = exports2.MsgUndelegate.encode(request).finish();
          const promise = this.rpc.request("cosmos.staking.v1beta1.Msg", "Undelegate", data);
          return promise.then((data2) => exports2.MsgUndelegateResponse.decode(new minimal_1.default.Reader(data2)));
        }
      };
      exports2.MsgClientImpl = MsgClientImpl;
      function toTimestamp(date) {
        const seconds = numberToLong(date.getTime() / 1e3);
        const nanos = date.getTime() % 1e3 * 1e6;
        return { seconds, nanos };
      }
      function fromTimestamp(t) {
        let millis = t.seconds.toNumber() * 1e3;
        millis += t.nanos / 1e6;
        return new Date(millis);
      }
      function fromJsonTimestamp(o) {
        if (o instanceof Date) {
          return toTimestamp(o);
        } else if (typeof o === "string") {
          return toTimestamp(new Date(o));
        } else {
          return timestamp_1.Timestamp.fromJSON(o);
        }
      }
      function numberToLong(number) {
        return long_1.default.fromNumber(number);
      }
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/@cosmjs/stargate/build/modules/staking/messages.js
  var require_messages7 = __commonJS({
    "node_modules/@cosmjs/stargate/build/modules/staking/messages.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.isMsgUndelegateEncodeObject = exports2.isMsgDelegateEncodeObject = exports2.stakingTypes = void 0;
      var tx_1 = require_tx11();
      exports2.stakingTypes = [
        ["/cosmos.staking.v1beta1.MsgBeginRedelegate", tx_1.MsgBeginRedelegate],
        ["/cosmos.staking.v1beta1.MsgCreateValidator", tx_1.MsgCreateValidator],
        ["/cosmos.staking.v1beta1.MsgDelegate", tx_1.MsgDelegate],
        ["/cosmos.staking.v1beta1.MsgEditValidator", tx_1.MsgEditValidator],
        ["/cosmos.staking.v1beta1.MsgUndelegate", tx_1.MsgUndelegate]
      ];
      function isMsgDelegateEncodeObject(object) {
        return object.typeUrl === "/cosmos.staking.v1beta1.MsgDelegate";
      }
      exports2.isMsgDelegateEncodeObject = isMsgDelegateEncodeObject;
      function isMsgUndelegateEncodeObject(object) {
        return object.typeUrl === "/cosmos.staking.v1beta1.MsgUndelegate";
      }
      exports2.isMsgUndelegateEncodeObject = isMsgUndelegateEncodeObject;
    }
  });

  // node_modules/cosmjs-types/cosmos/staking/v1beta1/query.js
  var require_query11 = __commonJS({
    "node_modules/cosmjs-types/cosmos/staking/v1beta1/query.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.QueryClientImpl = exports2.QueryParamsResponse = exports2.QueryParamsRequest = exports2.QueryPoolResponse = exports2.QueryPoolRequest = exports2.QueryHistoricalInfoResponse = exports2.QueryHistoricalInfoRequest = exports2.QueryDelegatorValidatorResponse = exports2.QueryDelegatorValidatorRequest = exports2.QueryDelegatorValidatorsResponse = exports2.QueryDelegatorValidatorsRequest = exports2.QueryRedelegationsResponse = exports2.QueryRedelegationsRequest = exports2.QueryDelegatorUnbondingDelegationsResponse = exports2.QueryDelegatorUnbondingDelegationsRequest = exports2.QueryDelegatorDelegationsResponse = exports2.QueryDelegatorDelegationsRequest = exports2.QueryUnbondingDelegationResponse = exports2.QueryUnbondingDelegationRequest = exports2.QueryDelegationResponse = exports2.QueryDelegationRequest = exports2.QueryValidatorUnbondingDelegationsResponse = exports2.QueryValidatorUnbondingDelegationsRequest = exports2.QueryValidatorDelegationsResponse = exports2.QueryValidatorDelegationsRequest = exports2.QueryValidatorResponse = exports2.QueryValidatorRequest = exports2.QueryValidatorsResponse = exports2.QueryValidatorsRequest = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var pagination_1 = require_pagination();
      var staking_1 = require_staking();
      exports2.protobufPackage = "cosmos.staking.v1beta1";
      var baseQueryValidatorsRequest = { status: "" };
      exports2.QueryValidatorsRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.status !== "") {
            writer.uint32(10).string(message.status);
          }
          if (message.pagination !== void 0) {
            pagination_1.PageRequest.encode(message.pagination, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryValidatorsRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.status = reader.string();
                break;
              case 2:
                message.pagination = pagination_1.PageRequest.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryValidatorsRequest);
          message.status = object.status !== void 0 && object.status !== null ? String(object.status) : "";
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.status !== void 0 && (obj.status = message.status);
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageRequest.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryValidatorsRequest);
          message.status = (_a = object.status) !== null && _a !== void 0 ? _a : "";
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryValidatorsResponse = {};
      exports2.QueryValidatorsResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.validators) {
            staking_1.Validator.encode(v, writer.uint32(10).fork()).ldelim();
          }
          if (message.pagination !== void 0) {
            pagination_1.PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryValidatorsResponse);
          message.validators = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.validators.push(staking_1.Validator.decode(reader, reader.uint32()));
                break;
              case 2:
                message.pagination = pagination_1.PageResponse.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseQueryValidatorsResponse);
          message.validators = ((_a = object.validators) !== null && _a !== void 0 ? _a : []).map((e) => staking_1.Validator.fromJSON(e));
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.validators) {
            obj.validators = message.validators.map((e) => e ? staking_1.Validator.toJSON(e) : void 0);
          } else {
            obj.validators = [];
          }
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageResponse.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryValidatorsResponse);
          message.validators = ((_a = object.validators) === null || _a === void 0 ? void 0 : _a.map((e) => staking_1.Validator.fromPartial(e))) || [];
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryValidatorRequest = { validatorAddr: "" };
      exports2.QueryValidatorRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.validatorAddr !== "") {
            writer.uint32(10).string(message.validatorAddr);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryValidatorRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.validatorAddr = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryValidatorRequest);
          message.validatorAddr = object.validatorAddr !== void 0 && object.validatorAddr !== null ? String(object.validatorAddr) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.validatorAddr !== void 0 && (obj.validatorAddr = message.validatorAddr);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryValidatorRequest);
          message.validatorAddr = (_a = object.validatorAddr) !== null && _a !== void 0 ? _a : "";
          return message;
        }
      };
      var baseQueryValidatorResponse = {};
      exports2.QueryValidatorResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.validator !== void 0) {
            staking_1.Validator.encode(message.validator, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryValidatorResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.validator = staking_1.Validator.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryValidatorResponse);
          message.validator = object.validator !== void 0 && object.validator !== null ? staking_1.Validator.fromJSON(object.validator) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.validator !== void 0 && (obj.validator = message.validator ? staking_1.Validator.toJSON(message.validator) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryValidatorResponse);
          message.validator = object.validator !== void 0 && object.validator !== null ? staking_1.Validator.fromPartial(object.validator) : void 0;
          return message;
        }
      };
      var baseQueryValidatorDelegationsRequest = { validatorAddr: "" };
      exports2.QueryValidatorDelegationsRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.validatorAddr !== "") {
            writer.uint32(10).string(message.validatorAddr);
          }
          if (message.pagination !== void 0) {
            pagination_1.PageRequest.encode(message.pagination, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryValidatorDelegationsRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.validatorAddr = reader.string();
                break;
              case 2:
                message.pagination = pagination_1.PageRequest.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryValidatorDelegationsRequest);
          message.validatorAddr = object.validatorAddr !== void 0 && object.validatorAddr !== null ? String(object.validatorAddr) : "";
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.validatorAddr !== void 0 && (obj.validatorAddr = message.validatorAddr);
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageRequest.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryValidatorDelegationsRequest);
          message.validatorAddr = (_a = object.validatorAddr) !== null && _a !== void 0 ? _a : "";
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryValidatorDelegationsResponse = {};
      exports2.QueryValidatorDelegationsResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.delegationResponses) {
            staking_1.DelegationResponse.encode(v, writer.uint32(10).fork()).ldelim();
          }
          if (message.pagination !== void 0) {
            pagination_1.PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryValidatorDelegationsResponse);
          message.delegationResponses = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.delegationResponses.push(staking_1.DelegationResponse.decode(reader, reader.uint32()));
                break;
              case 2:
                message.pagination = pagination_1.PageResponse.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseQueryValidatorDelegationsResponse);
          message.delegationResponses = ((_a = object.delegationResponses) !== null && _a !== void 0 ? _a : []).map((e) => staking_1.DelegationResponse.fromJSON(e));
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.delegationResponses) {
            obj.delegationResponses = message.delegationResponses.map((e) => e ? staking_1.DelegationResponse.toJSON(e) : void 0);
          } else {
            obj.delegationResponses = [];
          }
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageResponse.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryValidatorDelegationsResponse);
          message.delegationResponses = ((_a = object.delegationResponses) === null || _a === void 0 ? void 0 : _a.map((e) => staking_1.DelegationResponse.fromPartial(e))) || [];
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryValidatorUnbondingDelegationsRequest = { validatorAddr: "" };
      exports2.QueryValidatorUnbondingDelegationsRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.validatorAddr !== "") {
            writer.uint32(10).string(message.validatorAddr);
          }
          if (message.pagination !== void 0) {
            pagination_1.PageRequest.encode(message.pagination, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryValidatorUnbondingDelegationsRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.validatorAddr = reader.string();
                break;
              case 2:
                message.pagination = pagination_1.PageRequest.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryValidatorUnbondingDelegationsRequest);
          message.validatorAddr = object.validatorAddr !== void 0 && object.validatorAddr !== null ? String(object.validatorAddr) : "";
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.validatorAddr !== void 0 && (obj.validatorAddr = message.validatorAddr);
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageRequest.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryValidatorUnbondingDelegationsRequest);
          message.validatorAddr = (_a = object.validatorAddr) !== null && _a !== void 0 ? _a : "";
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryValidatorUnbondingDelegationsResponse = {};
      exports2.QueryValidatorUnbondingDelegationsResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.unbondingResponses) {
            staking_1.UnbondingDelegation.encode(v, writer.uint32(10).fork()).ldelim();
          }
          if (message.pagination !== void 0) {
            pagination_1.PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryValidatorUnbondingDelegationsResponse);
          message.unbondingResponses = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.unbondingResponses.push(staking_1.UnbondingDelegation.decode(reader, reader.uint32()));
                break;
              case 2:
                message.pagination = pagination_1.PageResponse.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseQueryValidatorUnbondingDelegationsResponse);
          message.unbondingResponses = ((_a = object.unbondingResponses) !== null && _a !== void 0 ? _a : []).map((e) => staking_1.UnbondingDelegation.fromJSON(e));
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.unbondingResponses) {
            obj.unbondingResponses = message.unbondingResponses.map((e) => e ? staking_1.UnbondingDelegation.toJSON(e) : void 0);
          } else {
            obj.unbondingResponses = [];
          }
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageResponse.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryValidatorUnbondingDelegationsResponse);
          message.unbondingResponses = ((_a = object.unbondingResponses) === null || _a === void 0 ? void 0 : _a.map((e) => staking_1.UnbondingDelegation.fromPartial(e))) || [];
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryDelegationRequest = { delegatorAddr: "", validatorAddr: "" };
      exports2.QueryDelegationRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.delegatorAddr !== "") {
            writer.uint32(10).string(message.delegatorAddr);
          }
          if (message.validatorAddr !== "") {
            writer.uint32(18).string(message.validatorAddr);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryDelegationRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.delegatorAddr = reader.string();
                break;
              case 2:
                message.validatorAddr = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryDelegationRequest);
          message.delegatorAddr = object.delegatorAddr !== void 0 && object.delegatorAddr !== null ? String(object.delegatorAddr) : "";
          message.validatorAddr = object.validatorAddr !== void 0 && object.validatorAddr !== null ? String(object.validatorAddr) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.delegatorAddr !== void 0 && (obj.delegatorAddr = message.delegatorAddr);
          message.validatorAddr !== void 0 && (obj.validatorAddr = message.validatorAddr);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseQueryDelegationRequest);
          message.delegatorAddr = (_a = object.delegatorAddr) !== null && _a !== void 0 ? _a : "";
          message.validatorAddr = (_b = object.validatorAddr) !== null && _b !== void 0 ? _b : "";
          return message;
        }
      };
      var baseQueryDelegationResponse = {};
      exports2.QueryDelegationResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.delegationResponse !== void 0) {
            staking_1.DelegationResponse.encode(message.delegationResponse, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryDelegationResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.delegationResponse = staking_1.DelegationResponse.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryDelegationResponse);
          message.delegationResponse = object.delegationResponse !== void 0 && object.delegationResponse !== null ? staking_1.DelegationResponse.fromJSON(object.delegationResponse) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.delegationResponse !== void 0 && (obj.delegationResponse = message.delegationResponse ? staking_1.DelegationResponse.toJSON(message.delegationResponse) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryDelegationResponse);
          message.delegationResponse = object.delegationResponse !== void 0 && object.delegationResponse !== null ? staking_1.DelegationResponse.fromPartial(object.delegationResponse) : void 0;
          return message;
        }
      };
      var baseQueryUnbondingDelegationRequest = { delegatorAddr: "", validatorAddr: "" };
      exports2.QueryUnbondingDelegationRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.delegatorAddr !== "") {
            writer.uint32(10).string(message.delegatorAddr);
          }
          if (message.validatorAddr !== "") {
            writer.uint32(18).string(message.validatorAddr);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryUnbondingDelegationRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.delegatorAddr = reader.string();
                break;
              case 2:
                message.validatorAddr = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryUnbondingDelegationRequest);
          message.delegatorAddr = object.delegatorAddr !== void 0 && object.delegatorAddr !== null ? String(object.delegatorAddr) : "";
          message.validatorAddr = object.validatorAddr !== void 0 && object.validatorAddr !== null ? String(object.validatorAddr) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.delegatorAddr !== void 0 && (obj.delegatorAddr = message.delegatorAddr);
          message.validatorAddr !== void 0 && (obj.validatorAddr = message.validatorAddr);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseQueryUnbondingDelegationRequest);
          message.delegatorAddr = (_a = object.delegatorAddr) !== null && _a !== void 0 ? _a : "";
          message.validatorAddr = (_b = object.validatorAddr) !== null && _b !== void 0 ? _b : "";
          return message;
        }
      };
      var baseQueryUnbondingDelegationResponse = {};
      exports2.QueryUnbondingDelegationResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.unbond !== void 0) {
            staking_1.UnbondingDelegation.encode(message.unbond, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryUnbondingDelegationResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.unbond = staking_1.UnbondingDelegation.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryUnbondingDelegationResponse);
          message.unbond = object.unbond !== void 0 && object.unbond !== null ? staking_1.UnbondingDelegation.fromJSON(object.unbond) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.unbond !== void 0 && (obj.unbond = message.unbond ? staking_1.UnbondingDelegation.toJSON(message.unbond) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryUnbondingDelegationResponse);
          message.unbond = object.unbond !== void 0 && object.unbond !== null ? staking_1.UnbondingDelegation.fromPartial(object.unbond) : void 0;
          return message;
        }
      };
      var baseQueryDelegatorDelegationsRequest = { delegatorAddr: "" };
      exports2.QueryDelegatorDelegationsRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.delegatorAddr !== "") {
            writer.uint32(10).string(message.delegatorAddr);
          }
          if (message.pagination !== void 0) {
            pagination_1.PageRequest.encode(message.pagination, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryDelegatorDelegationsRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.delegatorAddr = reader.string();
                break;
              case 2:
                message.pagination = pagination_1.PageRequest.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryDelegatorDelegationsRequest);
          message.delegatorAddr = object.delegatorAddr !== void 0 && object.delegatorAddr !== null ? String(object.delegatorAddr) : "";
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.delegatorAddr !== void 0 && (obj.delegatorAddr = message.delegatorAddr);
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageRequest.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryDelegatorDelegationsRequest);
          message.delegatorAddr = (_a = object.delegatorAddr) !== null && _a !== void 0 ? _a : "";
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryDelegatorDelegationsResponse = {};
      exports2.QueryDelegatorDelegationsResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.delegationResponses) {
            staking_1.DelegationResponse.encode(v, writer.uint32(10).fork()).ldelim();
          }
          if (message.pagination !== void 0) {
            pagination_1.PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryDelegatorDelegationsResponse);
          message.delegationResponses = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.delegationResponses.push(staking_1.DelegationResponse.decode(reader, reader.uint32()));
                break;
              case 2:
                message.pagination = pagination_1.PageResponse.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseQueryDelegatorDelegationsResponse);
          message.delegationResponses = ((_a = object.delegationResponses) !== null && _a !== void 0 ? _a : []).map((e) => staking_1.DelegationResponse.fromJSON(e));
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.delegationResponses) {
            obj.delegationResponses = message.delegationResponses.map((e) => e ? staking_1.DelegationResponse.toJSON(e) : void 0);
          } else {
            obj.delegationResponses = [];
          }
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageResponse.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryDelegatorDelegationsResponse);
          message.delegationResponses = ((_a = object.delegationResponses) === null || _a === void 0 ? void 0 : _a.map((e) => staking_1.DelegationResponse.fromPartial(e))) || [];
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryDelegatorUnbondingDelegationsRequest = { delegatorAddr: "" };
      exports2.QueryDelegatorUnbondingDelegationsRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.delegatorAddr !== "") {
            writer.uint32(10).string(message.delegatorAddr);
          }
          if (message.pagination !== void 0) {
            pagination_1.PageRequest.encode(message.pagination, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryDelegatorUnbondingDelegationsRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.delegatorAddr = reader.string();
                break;
              case 2:
                message.pagination = pagination_1.PageRequest.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryDelegatorUnbondingDelegationsRequest);
          message.delegatorAddr = object.delegatorAddr !== void 0 && object.delegatorAddr !== null ? String(object.delegatorAddr) : "";
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.delegatorAddr !== void 0 && (obj.delegatorAddr = message.delegatorAddr);
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageRequest.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryDelegatorUnbondingDelegationsRequest);
          message.delegatorAddr = (_a = object.delegatorAddr) !== null && _a !== void 0 ? _a : "";
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryDelegatorUnbondingDelegationsResponse = {};
      exports2.QueryDelegatorUnbondingDelegationsResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.unbondingResponses) {
            staking_1.UnbondingDelegation.encode(v, writer.uint32(10).fork()).ldelim();
          }
          if (message.pagination !== void 0) {
            pagination_1.PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryDelegatorUnbondingDelegationsResponse);
          message.unbondingResponses = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.unbondingResponses.push(staking_1.UnbondingDelegation.decode(reader, reader.uint32()));
                break;
              case 2:
                message.pagination = pagination_1.PageResponse.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseQueryDelegatorUnbondingDelegationsResponse);
          message.unbondingResponses = ((_a = object.unbondingResponses) !== null && _a !== void 0 ? _a : []).map((e) => staking_1.UnbondingDelegation.fromJSON(e));
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.unbondingResponses) {
            obj.unbondingResponses = message.unbondingResponses.map((e) => e ? staking_1.UnbondingDelegation.toJSON(e) : void 0);
          } else {
            obj.unbondingResponses = [];
          }
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageResponse.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryDelegatorUnbondingDelegationsResponse);
          message.unbondingResponses = ((_a = object.unbondingResponses) === null || _a === void 0 ? void 0 : _a.map((e) => staking_1.UnbondingDelegation.fromPartial(e))) || [];
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryRedelegationsRequest = {
        delegatorAddr: "",
        srcValidatorAddr: "",
        dstValidatorAddr: ""
      };
      exports2.QueryRedelegationsRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.delegatorAddr !== "") {
            writer.uint32(10).string(message.delegatorAddr);
          }
          if (message.srcValidatorAddr !== "") {
            writer.uint32(18).string(message.srcValidatorAddr);
          }
          if (message.dstValidatorAddr !== "") {
            writer.uint32(26).string(message.dstValidatorAddr);
          }
          if (message.pagination !== void 0) {
            pagination_1.PageRequest.encode(message.pagination, writer.uint32(34).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryRedelegationsRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.delegatorAddr = reader.string();
                break;
              case 2:
                message.srcValidatorAddr = reader.string();
                break;
              case 3:
                message.dstValidatorAddr = reader.string();
                break;
              case 4:
                message.pagination = pagination_1.PageRequest.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryRedelegationsRequest);
          message.delegatorAddr = object.delegatorAddr !== void 0 && object.delegatorAddr !== null ? String(object.delegatorAddr) : "";
          message.srcValidatorAddr = object.srcValidatorAddr !== void 0 && object.srcValidatorAddr !== null ? String(object.srcValidatorAddr) : "";
          message.dstValidatorAddr = object.dstValidatorAddr !== void 0 && object.dstValidatorAddr !== null ? String(object.dstValidatorAddr) : "";
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.delegatorAddr !== void 0 && (obj.delegatorAddr = message.delegatorAddr);
          message.srcValidatorAddr !== void 0 && (obj.srcValidatorAddr = message.srcValidatorAddr);
          message.dstValidatorAddr !== void 0 && (obj.dstValidatorAddr = message.dstValidatorAddr);
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageRequest.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseQueryRedelegationsRequest);
          message.delegatorAddr = (_a = object.delegatorAddr) !== null && _a !== void 0 ? _a : "";
          message.srcValidatorAddr = (_b = object.srcValidatorAddr) !== null && _b !== void 0 ? _b : "";
          message.dstValidatorAddr = (_c = object.dstValidatorAddr) !== null && _c !== void 0 ? _c : "";
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryRedelegationsResponse = {};
      exports2.QueryRedelegationsResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.redelegationResponses) {
            staking_1.RedelegationResponse.encode(v, writer.uint32(10).fork()).ldelim();
          }
          if (message.pagination !== void 0) {
            pagination_1.PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryRedelegationsResponse);
          message.redelegationResponses = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.redelegationResponses.push(staking_1.RedelegationResponse.decode(reader, reader.uint32()));
                break;
              case 2:
                message.pagination = pagination_1.PageResponse.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseQueryRedelegationsResponse);
          message.redelegationResponses = ((_a = object.redelegationResponses) !== null && _a !== void 0 ? _a : []).map((e) => staking_1.RedelegationResponse.fromJSON(e));
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.redelegationResponses) {
            obj.redelegationResponses = message.redelegationResponses.map((e) => e ? staking_1.RedelegationResponse.toJSON(e) : void 0);
          } else {
            obj.redelegationResponses = [];
          }
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageResponse.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryRedelegationsResponse);
          message.redelegationResponses = ((_a = object.redelegationResponses) === null || _a === void 0 ? void 0 : _a.map((e) => staking_1.RedelegationResponse.fromPartial(e))) || [];
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryDelegatorValidatorsRequest = { delegatorAddr: "" };
      exports2.QueryDelegatorValidatorsRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.delegatorAddr !== "") {
            writer.uint32(10).string(message.delegatorAddr);
          }
          if (message.pagination !== void 0) {
            pagination_1.PageRequest.encode(message.pagination, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryDelegatorValidatorsRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.delegatorAddr = reader.string();
                break;
              case 2:
                message.pagination = pagination_1.PageRequest.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryDelegatorValidatorsRequest);
          message.delegatorAddr = object.delegatorAddr !== void 0 && object.delegatorAddr !== null ? String(object.delegatorAddr) : "";
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.delegatorAddr !== void 0 && (obj.delegatorAddr = message.delegatorAddr);
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageRequest.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryDelegatorValidatorsRequest);
          message.delegatorAddr = (_a = object.delegatorAddr) !== null && _a !== void 0 ? _a : "";
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryDelegatorValidatorsResponse = {};
      exports2.QueryDelegatorValidatorsResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.validators) {
            staking_1.Validator.encode(v, writer.uint32(10).fork()).ldelim();
          }
          if (message.pagination !== void 0) {
            pagination_1.PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryDelegatorValidatorsResponse);
          message.validators = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.validators.push(staking_1.Validator.decode(reader, reader.uint32()));
                break;
              case 2:
                message.pagination = pagination_1.PageResponse.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseQueryDelegatorValidatorsResponse);
          message.validators = ((_a = object.validators) !== null && _a !== void 0 ? _a : []).map((e) => staking_1.Validator.fromJSON(e));
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.validators) {
            obj.validators = message.validators.map((e) => e ? staking_1.Validator.toJSON(e) : void 0);
          } else {
            obj.validators = [];
          }
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageResponse.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseQueryDelegatorValidatorsResponse);
          message.validators = ((_a = object.validators) === null || _a === void 0 ? void 0 : _a.map((e) => staking_1.Validator.fromPartial(e))) || [];
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseQueryDelegatorValidatorRequest = { delegatorAddr: "", validatorAddr: "" };
      exports2.QueryDelegatorValidatorRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.delegatorAddr !== "") {
            writer.uint32(10).string(message.delegatorAddr);
          }
          if (message.validatorAddr !== "") {
            writer.uint32(18).string(message.validatorAddr);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryDelegatorValidatorRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.delegatorAddr = reader.string();
                break;
              case 2:
                message.validatorAddr = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryDelegatorValidatorRequest);
          message.delegatorAddr = object.delegatorAddr !== void 0 && object.delegatorAddr !== null ? String(object.delegatorAddr) : "";
          message.validatorAddr = object.validatorAddr !== void 0 && object.validatorAddr !== null ? String(object.validatorAddr) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.delegatorAddr !== void 0 && (obj.delegatorAddr = message.delegatorAddr);
          message.validatorAddr !== void 0 && (obj.validatorAddr = message.validatorAddr);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseQueryDelegatorValidatorRequest);
          message.delegatorAddr = (_a = object.delegatorAddr) !== null && _a !== void 0 ? _a : "";
          message.validatorAddr = (_b = object.validatorAddr) !== null && _b !== void 0 ? _b : "";
          return message;
        }
      };
      var baseQueryDelegatorValidatorResponse = {};
      exports2.QueryDelegatorValidatorResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.validator !== void 0) {
            staking_1.Validator.encode(message.validator, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryDelegatorValidatorResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.validator = staking_1.Validator.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryDelegatorValidatorResponse);
          message.validator = object.validator !== void 0 && object.validator !== null ? staking_1.Validator.fromJSON(object.validator) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.validator !== void 0 && (obj.validator = message.validator ? staking_1.Validator.toJSON(message.validator) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryDelegatorValidatorResponse);
          message.validator = object.validator !== void 0 && object.validator !== null ? staking_1.Validator.fromPartial(object.validator) : void 0;
          return message;
        }
      };
      var baseQueryHistoricalInfoRequest = { height: long_1.default.ZERO };
      exports2.QueryHistoricalInfoRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.height.isZero()) {
            writer.uint32(8).int64(message.height);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryHistoricalInfoRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.height = reader.int64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryHistoricalInfoRequest);
          message.height = object.height !== void 0 && object.height !== null ? long_1.default.fromString(object.height) : long_1.default.ZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.height !== void 0 && (obj.height = (message.height || long_1.default.ZERO).toString());
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryHistoricalInfoRequest);
          message.height = object.height !== void 0 && object.height !== null ? long_1.default.fromValue(object.height) : long_1.default.ZERO;
          return message;
        }
      };
      var baseQueryHistoricalInfoResponse = {};
      exports2.QueryHistoricalInfoResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.hist !== void 0) {
            staking_1.HistoricalInfo.encode(message.hist, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryHistoricalInfoResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.hist = staking_1.HistoricalInfo.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryHistoricalInfoResponse);
          message.hist = object.hist !== void 0 && object.hist !== null ? staking_1.HistoricalInfo.fromJSON(object.hist) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.hist !== void 0 && (obj.hist = message.hist ? staking_1.HistoricalInfo.toJSON(message.hist) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryHistoricalInfoResponse);
          message.hist = object.hist !== void 0 && object.hist !== null ? staking_1.HistoricalInfo.fromPartial(object.hist) : void 0;
          return message;
        }
      };
      var baseQueryPoolRequest = {};
      exports2.QueryPoolRequest = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryPoolRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseQueryPoolRequest);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseQueryPoolRequest);
          return message;
        }
      };
      var baseQueryPoolResponse = {};
      exports2.QueryPoolResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.pool !== void 0) {
            staking_1.Pool.encode(message.pool, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryPoolResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.pool = staking_1.Pool.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryPoolResponse);
          message.pool = object.pool !== void 0 && object.pool !== null ? staking_1.Pool.fromJSON(object.pool) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.pool !== void 0 && (obj.pool = message.pool ? staking_1.Pool.toJSON(message.pool) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryPoolResponse);
          message.pool = object.pool !== void 0 && object.pool !== null ? staking_1.Pool.fromPartial(object.pool) : void 0;
          return message;
        }
      };
      var baseQueryParamsRequest = {};
      exports2.QueryParamsRequest = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryParamsRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseQueryParamsRequest);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseQueryParamsRequest);
          return message;
        }
      };
      var baseQueryParamsResponse = {};
      exports2.QueryParamsResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.params !== void 0) {
            staking_1.Params.encode(message.params, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseQueryParamsResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.params = staking_1.Params.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseQueryParamsResponse);
          message.params = object.params !== void 0 && object.params !== null ? staking_1.Params.fromJSON(object.params) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.params !== void 0 && (obj.params = message.params ? staking_1.Params.toJSON(message.params) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseQueryParamsResponse);
          message.params = object.params !== void 0 && object.params !== null ? staking_1.Params.fromPartial(object.params) : void 0;
          return message;
        }
      };
      var QueryClientImpl = class {
        constructor(rpc) {
          this.rpc = rpc;
          this.Validators = this.Validators.bind(this);
          this.Validator = this.Validator.bind(this);
          this.ValidatorDelegations = this.ValidatorDelegations.bind(this);
          this.ValidatorUnbondingDelegations = this.ValidatorUnbondingDelegations.bind(this);
          this.Delegation = this.Delegation.bind(this);
          this.UnbondingDelegation = this.UnbondingDelegation.bind(this);
          this.DelegatorDelegations = this.DelegatorDelegations.bind(this);
          this.DelegatorUnbondingDelegations = this.DelegatorUnbondingDelegations.bind(this);
          this.Redelegations = this.Redelegations.bind(this);
          this.DelegatorValidators = this.DelegatorValidators.bind(this);
          this.DelegatorValidator = this.DelegatorValidator.bind(this);
          this.HistoricalInfo = this.HistoricalInfo.bind(this);
          this.Pool = this.Pool.bind(this);
          this.Params = this.Params.bind(this);
        }
        Validators(request) {
          const data = exports2.QueryValidatorsRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.staking.v1beta1.Query", "Validators", data);
          return promise.then((data2) => exports2.QueryValidatorsResponse.decode(new minimal_1.default.Reader(data2)));
        }
        Validator(request) {
          const data = exports2.QueryValidatorRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.staking.v1beta1.Query", "Validator", data);
          return promise.then((data2) => exports2.QueryValidatorResponse.decode(new minimal_1.default.Reader(data2)));
        }
        ValidatorDelegations(request) {
          const data = exports2.QueryValidatorDelegationsRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.staking.v1beta1.Query", "ValidatorDelegations", data);
          return promise.then((data2) => exports2.QueryValidatorDelegationsResponse.decode(new minimal_1.default.Reader(data2)));
        }
        ValidatorUnbondingDelegations(request) {
          const data = exports2.QueryValidatorUnbondingDelegationsRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.staking.v1beta1.Query", "ValidatorUnbondingDelegations", data);
          return promise.then((data2) => exports2.QueryValidatorUnbondingDelegationsResponse.decode(new minimal_1.default.Reader(data2)));
        }
        Delegation(request) {
          const data = exports2.QueryDelegationRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.staking.v1beta1.Query", "Delegation", data);
          return promise.then((data2) => exports2.QueryDelegationResponse.decode(new minimal_1.default.Reader(data2)));
        }
        UnbondingDelegation(request) {
          const data = exports2.QueryUnbondingDelegationRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.staking.v1beta1.Query", "UnbondingDelegation", data);
          return promise.then((data2) => exports2.QueryUnbondingDelegationResponse.decode(new minimal_1.default.Reader(data2)));
        }
        DelegatorDelegations(request) {
          const data = exports2.QueryDelegatorDelegationsRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.staking.v1beta1.Query", "DelegatorDelegations", data);
          return promise.then((data2) => exports2.QueryDelegatorDelegationsResponse.decode(new minimal_1.default.Reader(data2)));
        }
        DelegatorUnbondingDelegations(request) {
          const data = exports2.QueryDelegatorUnbondingDelegationsRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.staking.v1beta1.Query", "DelegatorUnbondingDelegations", data);
          return promise.then((data2) => exports2.QueryDelegatorUnbondingDelegationsResponse.decode(new minimal_1.default.Reader(data2)));
        }
        Redelegations(request) {
          const data = exports2.QueryRedelegationsRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.staking.v1beta1.Query", "Redelegations", data);
          return promise.then((data2) => exports2.QueryRedelegationsResponse.decode(new minimal_1.default.Reader(data2)));
        }
        DelegatorValidators(request) {
          const data = exports2.QueryDelegatorValidatorsRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.staking.v1beta1.Query", "DelegatorValidators", data);
          return promise.then((data2) => exports2.QueryDelegatorValidatorsResponse.decode(new minimal_1.default.Reader(data2)));
        }
        DelegatorValidator(request) {
          const data = exports2.QueryDelegatorValidatorRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.staking.v1beta1.Query", "DelegatorValidator", data);
          return promise.then((data2) => exports2.QueryDelegatorValidatorResponse.decode(new minimal_1.default.Reader(data2)));
        }
        HistoricalInfo(request) {
          const data = exports2.QueryHistoricalInfoRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.staking.v1beta1.Query", "HistoricalInfo", data);
          return promise.then((data2) => exports2.QueryHistoricalInfoResponse.decode(new minimal_1.default.Reader(data2)));
        }
        Pool(request) {
          const data = exports2.QueryPoolRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.staking.v1beta1.Query", "Pool", data);
          return promise.then((data2) => exports2.QueryPoolResponse.decode(new minimal_1.default.Reader(data2)));
        }
        Params(request) {
          const data = exports2.QueryParamsRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.staking.v1beta1.Query", "Params", data);
          return promise.then((data2) => exports2.QueryParamsResponse.decode(new minimal_1.default.Reader(data2)));
        }
      };
      exports2.QueryClientImpl = QueryClientImpl;
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/@cosmjs/stargate/build/modules/staking/queries.js
  var require_queries8 = __commonJS({
    "node_modules/@cosmjs/stargate/build/modules/staking/queries.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.setupStakingExtension = void 0;
      var query_1 = require_query11();
      var long_1 = __importDefault(require_long());
      var queryclient_1 = require_queryclient2();
      function setupStakingExtension(base) {
        const rpc = (0, queryclient_1.createProtobufRpcClient)(base);
        const queryService = new query_1.QueryClientImpl(rpc);
        return {
          staking: {
            delegation: async (delegatorAddress, validatorAddress) => {
              const response = await queryService.Delegation({
                delegatorAddr: delegatorAddress,
                validatorAddr: validatorAddress
              });
              return response;
            },
            delegatorDelegations: async (delegatorAddress, paginationKey) => {
              const response = await queryService.DelegatorDelegations({
                delegatorAddr: delegatorAddress,
                pagination: (0, queryclient_1.createPagination)(paginationKey)
              });
              return response;
            },
            delegatorUnbondingDelegations: async (delegatorAddress, paginationKey) => {
              const response = await queryService.DelegatorUnbondingDelegations({
                delegatorAddr: delegatorAddress,
                pagination: (0, queryclient_1.createPagination)(paginationKey)
              });
              return response;
            },
            delegatorValidator: async (delegatorAddress, validatorAddress) => {
              const response = await queryService.DelegatorValidator({
                delegatorAddr: delegatorAddress,
                validatorAddr: validatorAddress
              });
              return response;
            },
            delegatorValidators: async (delegatorAddress, paginationKey) => {
              const response = await queryService.DelegatorValidators({
                delegatorAddr: delegatorAddress,
                pagination: (0, queryclient_1.createPagination)(paginationKey)
              });
              return response;
            },
            historicalInfo: async (height) => {
              const response = await queryService.HistoricalInfo({
                height: long_1.default.fromNumber(height, true)
              });
              return response;
            },
            params: async () => {
              const response = await queryService.Params({});
              return response;
            },
            pool: async () => {
              const response = await queryService.Pool({});
              return response;
            },
            redelegations: async (delegatorAddress, sourceValidatorAddress, destinationValidatorAddress, paginationKey) => {
              const response = await queryService.Redelegations({
                delegatorAddr: delegatorAddress,
                srcValidatorAddr: sourceValidatorAddress,
                dstValidatorAddr: destinationValidatorAddress,
                pagination: (0, queryclient_1.createPagination)(paginationKey)
              });
              return response;
            },
            unbondingDelegation: async (delegatorAddress, validatorAddress) => {
              const response = await queryService.UnbondingDelegation({
                delegatorAddr: delegatorAddress,
                validatorAddr: validatorAddress
              });
              return response;
            },
            validator: async (validatorAddress) => {
              const response = await queryService.Validator({ validatorAddr: validatorAddress });
              return response;
            },
            validatorDelegations: async (validatorAddress, paginationKey) => {
              const response = await queryService.ValidatorDelegations({
                validatorAddr: validatorAddress,
                pagination: (0, queryclient_1.createPagination)(paginationKey)
              });
              return response;
            },
            validators: async (status, paginationKey) => {
              const response = await queryService.Validators({
                status,
                pagination: (0, queryclient_1.createPagination)(paginationKey)
              });
              return response;
            },
            validatorUnbondingDelegations: async (validatorAddress, paginationKey) => {
              const response = await queryService.ValidatorUnbondingDelegations({
                validatorAddr: validatorAddress,
                pagination: (0, queryclient_1.createPagination)(paginationKey)
              });
              return response;
            }
          }
        };
      }
      exports2.setupStakingExtension = setupStakingExtension;
    }
  });

  // node_modules/cosmjs-types/tendermint/types/params.js
  var require_params = __commonJS({
    "node_modules/cosmjs-types/tendermint/types/params.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.HashedParams = exports2.VersionParams = exports2.ValidatorParams = exports2.EvidenceParams = exports2.BlockParams = exports2.ConsensusParams = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var duration_1 = require_duration();
      exports2.protobufPackage = "tendermint.types";
      var baseConsensusParams = {};
      exports2.ConsensusParams = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.block !== void 0) {
            exports2.BlockParams.encode(message.block, writer.uint32(10).fork()).ldelim();
          }
          if (message.evidence !== void 0) {
            exports2.EvidenceParams.encode(message.evidence, writer.uint32(18).fork()).ldelim();
          }
          if (message.validator !== void 0) {
            exports2.ValidatorParams.encode(message.validator, writer.uint32(26).fork()).ldelim();
          }
          if (message.version !== void 0) {
            exports2.VersionParams.encode(message.version, writer.uint32(34).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseConsensusParams);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.block = exports2.BlockParams.decode(reader, reader.uint32());
                break;
              case 2:
                message.evidence = exports2.EvidenceParams.decode(reader, reader.uint32());
                break;
              case 3:
                message.validator = exports2.ValidatorParams.decode(reader, reader.uint32());
                break;
              case 4:
                message.version = exports2.VersionParams.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseConsensusParams);
          message.block = object.block !== void 0 && object.block !== null ? exports2.BlockParams.fromJSON(object.block) : void 0;
          message.evidence = object.evidence !== void 0 && object.evidence !== null ? exports2.EvidenceParams.fromJSON(object.evidence) : void 0;
          message.validator = object.validator !== void 0 && object.validator !== null ? exports2.ValidatorParams.fromJSON(object.validator) : void 0;
          message.version = object.version !== void 0 && object.version !== null ? exports2.VersionParams.fromJSON(object.version) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.block !== void 0 && (obj.block = message.block ? exports2.BlockParams.toJSON(message.block) : void 0);
          message.evidence !== void 0 && (obj.evidence = message.evidence ? exports2.EvidenceParams.toJSON(message.evidence) : void 0);
          message.validator !== void 0 && (obj.validator = message.validator ? exports2.ValidatorParams.toJSON(message.validator) : void 0);
          message.version !== void 0 && (obj.version = message.version ? exports2.VersionParams.toJSON(message.version) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseConsensusParams);
          message.block = object.block !== void 0 && object.block !== null ? exports2.BlockParams.fromPartial(object.block) : void 0;
          message.evidence = object.evidence !== void 0 && object.evidence !== null ? exports2.EvidenceParams.fromPartial(object.evidence) : void 0;
          message.validator = object.validator !== void 0 && object.validator !== null ? exports2.ValidatorParams.fromPartial(object.validator) : void 0;
          message.version = object.version !== void 0 && object.version !== null ? exports2.VersionParams.fromPartial(object.version) : void 0;
          return message;
        }
      };
      var baseBlockParams = { maxBytes: long_1.default.ZERO, maxGas: long_1.default.ZERO, timeIotaMs: long_1.default.ZERO };
      exports2.BlockParams = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.maxBytes.isZero()) {
            writer.uint32(8).int64(message.maxBytes);
          }
          if (!message.maxGas.isZero()) {
            writer.uint32(16).int64(message.maxGas);
          }
          if (!message.timeIotaMs.isZero()) {
            writer.uint32(24).int64(message.timeIotaMs);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseBlockParams);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.maxBytes = reader.int64();
                break;
              case 2:
                message.maxGas = reader.int64();
                break;
              case 3:
                message.timeIotaMs = reader.int64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseBlockParams);
          message.maxBytes = object.maxBytes !== void 0 && object.maxBytes !== null ? long_1.default.fromString(object.maxBytes) : long_1.default.ZERO;
          message.maxGas = object.maxGas !== void 0 && object.maxGas !== null ? long_1.default.fromString(object.maxGas) : long_1.default.ZERO;
          message.timeIotaMs = object.timeIotaMs !== void 0 && object.timeIotaMs !== null ? long_1.default.fromString(object.timeIotaMs) : long_1.default.ZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.maxBytes !== void 0 && (obj.maxBytes = (message.maxBytes || long_1.default.ZERO).toString());
          message.maxGas !== void 0 && (obj.maxGas = (message.maxGas || long_1.default.ZERO).toString());
          message.timeIotaMs !== void 0 && (obj.timeIotaMs = (message.timeIotaMs || long_1.default.ZERO).toString());
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseBlockParams);
          message.maxBytes = object.maxBytes !== void 0 && object.maxBytes !== null ? long_1.default.fromValue(object.maxBytes) : long_1.default.ZERO;
          message.maxGas = object.maxGas !== void 0 && object.maxGas !== null ? long_1.default.fromValue(object.maxGas) : long_1.default.ZERO;
          message.timeIotaMs = object.timeIotaMs !== void 0 && object.timeIotaMs !== null ? long_1.default.fromValue(object.timeIotaMs) : long_1.default.ZERO;
          return message;
        }
      };
      var baseEvidenceParams = { maxAgeNumBlocks: long_1.default.ZERO, maxBytes: long_1.default.ZERO };
      exports2.EvidenceParams = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.maxAgeNumBlocks.isZero()) {
            writer.uint32(8).int64(message.maxAgeNumBlocks);
          }
          if (message.maxAgeDuration !== void 0) {
            duration_1.Duration.encode(message.maxAgeDuration, writer.uint32(18).fork()).ldelim();
          }
          if (!message.maxBytes.isZero()) {
            writer.uint32(24).int64(message.maxBytes);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseEvidenceParams);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.maxAgeNumBlocks = reader.int64();
                break;
              case 2:
                message.maxAgeDuration = duration_1.Duration.decode(reader, reader.uint32());
                break;
              case 3:
                message.maxBytes = reader.int64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseEvidenceParams);
          message.maxAgeNumBlocks = object.maxAgeNumBlocks !== void 0 && object.maxAgeNumBlocks !== null ? long_1.default.fromString(object.maxAgeNumBlocks) : long_1.default.ZERO;
          message.maxAgeDuration = object.maxAgeDuration !== void 0 && object.maxAgeDuration !== null ? duration_1.Duration.fromJSON(object.maxAgeDuration) : void 0;
          message.maxBytes = object.maxBytes !== void 0 && object.maxBytes !== null ? long_1.default.fromString(object.maxBytes) : long_1.default.ZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.maxAgeNumBlocks !== void 0 && (obj.maxAgeNumBlocks = (message.maxAgeNumBlocks || long_1.default.ZERO).toString());
          message.maxAgeDuration !== void 0 && (obj.maxAgeDuration = message.maxAgeDuration ? duration_1.Duration.toJSON(message.maxAgeDuration) : void 0);
          message.maxBytes !== void 0 && (obj.maxBytes = (message.maxBytes || long_1.default.ZERO).toString());
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseEvidenceParams);
          message.maxAgeNumBlocks = object.maxAgeNumBlocks !== void 0 && object.maxAgeNumBlocks !== null ? long_1.default.fromValue(object.maxAgeNumBlocks) : long_1.default.ZERO;
          message.maxAgeDuration = object.maxAgeDuration !== void 0 && object.maxAgeDuration !== null ? duration_1.Duration.fromPartial(object.maxAgeDuration) : void 0;
          message.maxBytes = object.maxBytes !== void 0 && object.maxBytes !== null ? long_1.default.fromValue(object.maxBytes) : long_1.default.ZERO;
          return message;
        }
      };
      var baseValidatorParams = { pubKeyTypes: "" };
      exports2.ValidatorParams = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.pubKeyTypes) {
            writer.uint32(10).string(v);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseValidatorParams);
          message.pubKeyTypes = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.pubKeyTypes.push(reader.string());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseValidatorParams);
          message.pubKeyTypes = ((_a = object.pubKeyTypes) !== null && _a !== void 0 ? _a : []).map((e) => String(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.pubKeyTypes) {
            obj.pubKeyTypes = message.pubKeyTypes.map((e) => e);
          } else {
            obj.pubKeyTypes = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseValidatorParams);
          message.pubKeyTypes = ((_a = object.pubKeyTypes) === null || _a === void 0 ? void 0 : _a.map((e) => e)) || [];
          return message;
        }
      };
      var baseVersionParams = { appVersion: long_1.default.UZERO };
      exports2.VersionParams = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.appVersion.isZero()) {
            writer.uint32(8).uint64(message.appVersion);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseVersionParams);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.appVersion = reader.uint64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseVersionParams);
          message.appVersion = object.appVersion !== void 0 && object.appVersion !== null ? long_1.default.fromString(object.appVersion) : long_1.default.UZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.appVersion !== void 0 && (obj.appVersion = (message.appVersion || long_1.default.UZERO).toString());
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseVersionParams);
          message.appVersion = object.appVersion !== void 0 && object.appVersion !== null ? long_1.default.fromValue(object.appVersion) : long_1.default.UZERO;
          return message;
        }
      };
      var baseHashedParams = { blockMaxBytes: long_1.default.ZERO, blockMaxGas: long_1.default.ZERO };
      exports2.HashedParams = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.blockMaxBytes.isZero()) {
            writer.uint32(8).int64(message.blockMaxBytes);
          }
          if (!message.blockMaxGas.isZero()) {
            writer.uint32(16).int64(message.blockMaxGas);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseHashedParams);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.blockMaxBytes = reader.int64();
                break;
              case 2:
                message.blockMaxGas = reader.int64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseHashedParams);
          message.blockMaxBytes = object.blockMaxBytes !== void 0 && object.blockMaxBytes !== null ? long_1.default.fromString(object.blockMaxBytes) : long_1.default.ZERO;
          message.blockMaxGas = object.blockMaxGas !== void 0 && object.blockMaxGas !== null ? long_1.default.fromString(object.blockMaxGas) : long_1.default.ZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.blockMaxBytes !== void 0 && (obj.blockMaxBytes = (message.blockMaxBytes || long_1.default.ZERO).toString());
          message.blockMaxGas !== void 0 && (obj.blockMaxGas = (message.blockMaxGas || long_1.default.ZERO).toString());
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseHashedParams);
          message.blockMaxBytes = object.blockMaxBytes !== void 0 && object.blockMaxBytes !== null ? long_1.default.fromValue(object.blockMaxBytes) : long_1.default.ZERO;
          message.blockMaxGas = object.blockMaxGas !== void 0 && object.blockMaxGas !== null ? long_1.default.fromValue(object.blockMaxGas) : long_1.default.ZERO;
          return message;
        }
      };
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/cosmjs-types/tendermint/abci/types.js
  var require_types3 = __commonJS({
    "node_modules/cosmjs-types/tendermint/abci/types.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.Event = exports2.LastCommitInfo = exports2.BlockParams = exports2.ConsensusParams = exports2.ResponseApplySnapshotChunk = exports2.ResponseLoadSnapshotChunk = exports2.ResponseOfferSnapshot = exports2.ResponseListSnapshots = exports2.ResponseCommit = exports2.ResponseEndBlock = exports2.ResponseDeliverTx = exports2.ResponseCheckTx = exports2.ResponseBeginBlock = exports2.ResponseQuery = exports2.ResponseInitChain = exports2.ResponseSetOption = exports2.ResponseInfo = exports2.ResponseFlush = exports2.ResponseEcho = exports2.ResponseException = exports2.Response = exports2.RequestApplySnapshotChunk = exports2.RequestLoadSnapshotChunk = exports2.RequestOfferSnapshot = exports2.RequestListSnapshots = exports2.RequestCommit = exports2.RequestEndBlock = exports2.RequestDeliverTx = exports2.RequestCheckTx = exports2.RequestBeginBlock = exports2.RequestQuery = exports2.RequestInitChain = exports2.RequestSetOption = exports2.RequestInfo = exports2.RequestFlush = exports2.RequestEcho = exports2.Request = exports2.responseApplySnapshotChunk_ResultToJSON = exports2.responseApplySnapshotChunk_ResultFromJSON = exports2.ResponseApplySnapshotChunk_Result = exports2.responseOfferSnapshot_ResultToJSON = exports2.responseOfferSnapshot_ResultFromJSON = exports2.ResponseOfferSnapshot_Result = exports2.evidenceTypeToJSON = exports2.evidenceTypeFromJSON = exports2.EvidenceType = exports2.checkTxTypeToJSON = exports2.checkTxTypeFromJSON = exports2.CheckTxType = exports2.protobufPackage = void 0;
      exports2.ABCIApplicationClientImpl = exports2.Snapshot = exports2.Evidence = exports2.VoteInfo = exports2.ValidatorUpdate = exports2.Validator = exports2.TxResult = exports2.EventAttribute = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var timestamp_1 = require_timestamp();
      var types_1 = require_types2();
      var proof_1 = require_proof();
      var params_1 = require_params();
      var keys_1 = require_keys3();
      exports2.protobufPackage = "tendermint.abci";
      var CheckTxType;
      (function(CheckTxType2) {
        CheckTxType2[CheckTxType2["NEW"] = 0] = "NEW";
        CheckTxType2[CheckTxType2["RECHECK"] = 1] = "RECHECK";
        CheckTxType2[CheckTxType2["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
      })(CheckTxType = exports2.CheckTxType || (exports2.CheckTxType = {}));
      function checkTxTypeFromJSON(object) {
        switch (object) {
          case 0:
          case "NEW":
            return CheckTxType.NEW;
          case 1:
          case "RECHECK":
            return CheckTxType.RECHECK;
          case -1:
          case "UNRECOGNIZED":
          default:
            return CheckTxType.UNRECOGNIZED;
        }
      }
      exports2.checkTxTypeFromJSON = checkTxTypeFromJSON;
      function checkTxTypeToJSON(object) {
        switch (object) {
          case CheckTxType.NEW:
            return "NEW";
          case CheckTxType.RECHECK:
            return "RECHECK";
          default:
            return "UNKNOWN";
        }
      }
      exports2.checkTxTypeToJSON = checkTxTypeToJSON;
      var EvidenceType;
      (function(EvidenceType2) {
        EvidenceType2[EvidenceType2["UNKNOWN"] = 0] = "UNKNOWN";
        EvidenceType2[EvidenceType2["DUPLICATE_VOTE"] = 1] = "DUPLICATE_VOTE";
        EvidenceType2[EvidenceType2["LIGHT_CLIENT_ATTACK"] = 2] = "LIGHT_CLIENT_ATTACK";
        EvidenceType2[EvidenceType2["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
      })(EvidenceType = exports2.EvidenceType || (exports2.EvidenceType = {}));
      function evidenceTypeFromJSON(object) {
        switch (object) {
          case 0:
          case "UNKNOWN":
            return EvidenceType.UNKNOWN;
          case 1:
          case "DUPLICATE_VOTE":
            return EvidenceType.DUPLICATE_VOTE;
          case 2:
          case "LIGHT_CLIENT_ATTACK":
            return EvidenceType.LIGHT_CLIENT_ATTACK;
          case -1:
          case "UNRECOGNIZED":
          default:
            return EvidenceType.UNRECOGNIZED;
        }
      }
      exports2.evidenceTypeFromJSON = evidenceTypeFromJSON;
      function evidenceTypeToJSON(object) {
        switch (object) {
          case EvidenceType.UNKNOWN:
            return "UNKNOWN";
          case EvidenceType.DUPLICATE_VOTE:
            return "DUPLICATE_VOTE";
          case EvidenceType.LIGHT_CLIENT_ATTACK:
            return "LIGHT_CLIENT_ATTACK";
          default:
            return "UNKNOWN";
        }
      }
      exports2.evidenceTypeToJSON = evidenceTypeToJSON;
      var ResponseOfferSnapshot_Result;
      (function(ResponseOfferSnapshot_Result2) {
        ResponseOfferSnapshot_Result2[ResponseOfferSnapshot_Result2["UNKNOWN"] = 0] = "UNKNOWN";
        ResponseOfferSnapshot_Result2[ResponseOfferSnapshot_Result2["ACCEPT"] = 1] = "ACCEPT";
        ResponseOfferSnapshot_Result2[ResponseOfferSnapshot_Result2["ABORT"] = 2] = "ABORT";
        ResponseOfferSnapshot_Result2[ResponseOfferSnapshot_Result2["REJECT"] = 3] = "REJECT";
        ResponseOfferSnapshot_Result2[ResponseOfferSnapshot_Result2["REJECT_FORMAT"] = 4] = "REJECT_FORMAT";
        ResponseOfferSnapshot_Result2[ResponseOfferSnapshot_Result2["REJECT_SENDER"] = 5] = "REJECT_SENDER";
        ResponseOfferSnapshot_Result2[ResponseOfferSnapshot_Result2["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
      })(ResponseOfferSnapshot_Result = exports2.ResponseOfferSnapshot_Result || (exports2.ResponseOfferSnapshot_Result = {}));
      function responseOfferSnapshot_ResultFromJSON(object) {
        switch (object) {
          case 0:
          case "UNKNOWN":
            return ResponseOfferSnapshot_Result.UNKNOWN;
          case 1:
          case "ACCEPT":
            return ResponseOfferSnapshot_Result.ACCEPT;
          case 2:
          case "ABORT":
            return ResponseOfferSnapshot_Result.ABORT;
          case 3:
          case "REJECT":
            return ResponseOfferSnapshot_Result.REJECT;
          case 4:
          case "REJECT_FORMAT":
            return ResponseOfferSnapshot_Result.REJECT_FORMAT;
          case 5:
          case "REJECT_SENDER":
            return ResponseOfferSnapshot_Result.REJECT_SENDER;
          case -1:
          case "UNRECOGNIZED":
          default:
            return ResponseOfferSnapshot_Result.UNRECOGNIZED;
        }
      }
      exports2.responseOfferSnapshot_ResultFromJSON = responseOfferSnapshot_ResultFromJSON;
      function responseOfferSnapshot_ResultToJSON(object) {
        switch (object) {
          case ResponseOfferSnapshot_Result.UNKNOWN:
            return "UNKNOWN";
          case ResponseOfferSnapshot_Result.ACCEPT:
            return "ACCEPT";
          case ResponseOfferSnapshot_Result.ABORT:
            return "ABORT";
          case ResponseOfferSnapshot_Result.REJECT:
            return "REJECT";
          case ResponseOfferSnapshot_Result.REJECT_FORMAT:
            return "REJECT_FORMAT";
          case ResponseOfferSnapshot_Result.REJECT_SENDER:
            return "REJECT_SENDER";
          default:
            return "UNKNOWN";
        }
      }
      exports2.responseOfferSnapshot_ResultToJSON = responseOfferSnapshot_ResultToJSON;
      var ResponseApplySnapshotChunk_Result;
      (function(ResponseApplySnapshotChunk_Result2) {
        ResponseApplySnapshotChunk_Result2[ResponseApplySnapshotChunk_Result2["UNKNOWN"] = 0] = "UNKNOWN";
        ResponseApplySnapshotChunk_Result2[ResponseApplySnapshotChunk_Result2["ACCEPT"] = 1] = "ACCEPT";
        ResponseApplySnapshotChunk_Result2[ResponseApplySnapshotChunk_Result2["ABORT"] = 2] = "ABORT";
        ResponseApplySnapshotChunk_Result2[ResponseApplySnapshotChunk_Result2["RETRY"] = 3] = "RETRY";
        ResponseApplySnapshotChunk_Result2[ResponseApplySnapshotChunk_Result2["RETRY_SNAPSHOT"] = 4] = "RETRY_SNAPSHOT";
        ResponseApplySnapshotChunk_Result2[ResponseApplySnapshotChunk_Result2["REJECT_SNAPSHOT"] = 5] = "REJECT_SNAPSHOT";
        ResponseApplySnapshotChunk_Result2[ResponseApplySnapshotChunk_Result2["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
      })(ResponseApplySnapshotChunk_Result = exports2.ResponseApplySnapshotChunk_Result || (exports2.ResponseApplySnapshotChunk_Result = {}));
      function responseApplySnapshotChunk_ResultFromJSON(object) {
        switch (object) {
          case 0:
          case "UNKNOWN":
            return ResponseApplySnapshotChunk_Result.UNKNOWN;
          case 1:
          case "ACCEPT":
            return ResponseApplySnapshotChunk_Result.ACCEPT;
          case 2:
          case "ABORT":
            return ResponseApplySnapshotChunk_Result.ABORT;
          case 3:
          case "RETRY":
            return ResponseApplySnapshotChunk_Result.RETRY;
          case 4:
          case "RETRY_SNAPSHOT":
            return ResponseApplySnapshotChunk_Result.RETRY_SNAPSHOT;
          case 5:
          case "REJECT_SNAPSHOT":
            return ResponseApplySnapshotChunk_Result.REJECT_SNAPSHOT;
          case -1:
          case "UNRECOGNIZED":
          default:
            return ResponseApplySnapshotChunk_Result.UNRECOGNIZED;
        }
      }
      exports2.responseApplySnapshotChunk_ResultFromJSON = responseApplySnapshotChunk_ResultFromJSON;
      function responseApplySnapshotChunk_ResultToJSON(object) {
        switch (object) {
          case ResponseApplySnapshotChunk_Result.UNKNOWN:
            return "UNKNOWN";
          case ResponseApplySnapshotChunk_Result.ACCEPT:
            return "ACCEPT";
          case ResponseApplySnapshotChunk_Result.ABORT:
            return "ABORT";
          case ResponseApplySnapshotChunk_Result.RETRY:
            return "RETRY";
          case ResponseApplySnapshotChunk_Result.RETRY_SNAPSHOT:
            return "RETRY_SNAPSHOT";
          case ResponseApplySnapshotChunk_Result.REJECT_SNAPSHOT:
            return "REJECT_SNAPSHOT";
          default:
            return "UNKNOWN";
        }
      }
      exports2.responseApplySnapshotChunk_ResultToJSON = responseApplySnapshotChunk_ResultToJSON;
      var baseRequest = {};
      exports2.Request = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.echo !== void 0) {
            exports2.RequestEcho.encode(message.echo, writer.uint32(10).fork()).ldelim();
          }
          if (message.flush !== void 0) {
            exports2.RequestFlush.encode(message.flush, writer.uint32(18).fork()).ldelim();
          }
          if (message.info !== void 0) {
            exports2.RequestInfo.encode(message.info, writer.uint32(26).fork()).ldelim();
          }
          if (message.setOption !== void 0) {
            exports2.RequestSetOption.encode(message.setOption, writer.uint32(34).fork()).ldelim();
          }
          if (message.initChain !== void 0) {
            exports2.RequestInitChain.encode(message.initChain, writer.uint32(42).fork()).ldelim();
          }
          if (message.query !== void 0) {
            exports2.RequestQuery.encode(message.query, writer.uint32(50).fork()).ldelim();
          }
          if (message.beginBlock !== void 0) {
            exports2.RequestBeginBlock.encode(message.beginBlock, writer.uint32(58).fork()).ldelim();
          }
          if (message.checkTx !== void 0) {
            exports2.RequestCheckTx.encode(message.checkTx, writer.uint32(66).fork()).ldelim();
          }
          if (message.deliverTx !== void 0) {
            exports2.RequestDeliverTx.encode(message.deliverTx, writer.uint32(74).fork()).ldelim();
          }
          if (message.endBlock !== void 0) {
            exports2.RequestEndBlock.encode(message.endBlock, writer.uint32(82).fork()).ldelim();
          }
          if (message.commit !== void 0) {
            exports2.RequestCommit.encode(message.commit, writer.uint32(90).fork()).ldelim();
          }
          if (message.listSnapshots !== void 0) {
            exports2.RequestListSnapshots.encode(message.listSnapshots, writer.uint32(98).fork()).ldelim();
          }
          if (message.offerSnapshot !== void 0) {
            exports2.RequestOfferSnapshot.encode(message.offerSnapshot, writer.uint32(106).fork()).ldelim();
          }
          if (message.loadSnapshotChunk !== void 0) {
            exports2.RequestLoadSnapshotChunk.encode(message.loadSnapshotChunk, writer.uint32(114).fork()).ldelim();
          }
          if (message.applySnapshotChunk !== void 0) {
            exports2.RequestApplySnapshotChunk.encode(message.applySnapshotChunk, writer.uint32(122).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.echo = exports2.RequestEcho.decode(reader, reader.uint32());
                break;
              case 2:
                message.flush = exports2.RequestFlush.decode(reader, reader.uint32());
                break;
              case 3:
                message.info = exports2.RequestInfo.decode(reader, reader.uint32());
                break;
              case 4:
                message.setOption = exports2.RequestSetOption.decode(reader, reader.uint32());
                break;
              case 5:
                message.initChain = exports2.RequestInitChain.decode(reader, reader.uint32());
                break;
              case 6:
                message.query = exports2.RequestQuery.decode(reader, reader.uint32());
                break;
              case 7:
                message.beginBlock = exports2.RequestBeginBlock.decode(reader, reader.uint32());
                break;
              case 8:
                message.checkTx = exports2.RequestCheckTx.decode(reader, reader.uint32());
                break;
              case 9:
                message.deliverTx = exports2.RequestDeliverTx.decode(reader, reader.uint32());
                break;
              case 10:
                message.endBlock = exports2.RequestEndBlock.decode(reader, reader.uint32());
                break;
              case 11:
                message.commit = exports2.RequestCommit.decode(reader, reader.uint32());
                break;
              case 12:
                message.listSnapshots = exports2.RequestListSnapshots.decode(reader, reader.uint32());
                break;
              case 13:
                message.offerSnapshot = exports2.RequestOfferSnapshot.decode(reader, reader.uint32());
                break;
              case 14:
                message.loadSnapshotChunk = exports2.RequestLoadSnapshotChunk.decode(reader, reader.uint32());
                break;
              case 15:
                message.applySnapshotChunk = exports2.RequestApplySnapshotChunk.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseRequest);
          message.echo = object.echo !== void 0 && object.echo !== null ? exports2.RequestEcho.fromJSON(object.echo) : void 0;
          message.flush = object.flush !== void 0 && object.flush !== null ? exports2.RequestFlush.fromJSON(object.flush) : void 0;
          message.info = object.info !== void 0 && object.info !== null ? exports2.RequestInfo.fromJSON(object.info) : void 0;
          message.setOption = object.setOption !== void 0 && object.setOption !== null ? exports2.RequestSetOption.fromJSON(object.setOption) : void 0;
          message.initChain = object.initChain !== void 0 && object.initChain !== null ? exports2.RequestInitChain.fromJSON(object.initChain) : void 0;
          message.query = object.query !== void 0 && object.query !== null ? exports2.RequestQuery.fromJSON(object.query) : void 0;
          message.beginBlock = object.beginBlock !== void 0 && object.beginBlock !== null ? exports2.RequestBeginBlock.fromJSON(object.beginBlock) : void 0;
          message.checkTx = object.checkTx !== void 0 && object.checkTx !== null ? exports2.RequestCheckTx.fromJSON(object.checkTx) : void 0;
          message.deliverTx = object.deliverTx !== void 0 && object.deliverTx !== null ? exports2.RequestDeliverTx.fromJSON(object.deliverTx) : void 0;
          message.endBlock = object.endBlock !== void 0 && object.endBlock !== null ? exports2.RequestEndBlock.fromJSON(object.endBlock) : void 0;
          message.commit = object.commit !== void 0 && object.commit !== null ? exports2.RequestCommit.fromJSON(object.commit) : void 0;
          message.listSnapshots = object.listSnapshots !== void 0 && object.listSnapshots !== null ? exports2.RequestListSnapshots.fromJSON(object.listSnapshots) : void 0;
          message.offerSnapshot = object.offerSnapshot !== void 0 && object.offerSnapshot !== null ? exports2.RequestOfferSnapshot.fromJSON(object.offerSnapshot) : void 0;
          message.loadSnapshotChunk = object.loadSnapshotChunk !== void 0 && object.loadSnapshotChunk !== null ? exports2.RequestLoadSnapshotChunk.fromJSON(object.loadSnapshotChunk) : void 0;
          message.applySnapshotChunk = object.applySnapshotChunk !== void 0 && object.applySnapshotChunk !== null ? exports2.RequestApplySnapshotChunk.fromJSON(object.applySnapshotChunk) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.echo !== void 0 && (obj.echo = message.echo ? exports2.RequestEcho.toJSON(message.echo) : void 0);
          message.flush !== void 0 && (obj.flush = message.flush ? exports2.RequestFlush.toJSON(message.flush) : void 0);
          message.info !== void 0 && (obj.info = message.info ? exports2.RequestInfo.toJSON(message.info) : void 0);
          message.setOption !== void 0 && (obj.setOption = message.setOption ? exports2.RequestSetOption.toJSON(message.setOption) : void 0);
          message.initChain !== void 0 && (obj.initChain = message.initChain ? exports2.RequestInitChain.toJSON(message.initChain) : void 0);
          message.query !== void 0 && (obj.query = message.query ? exports2.RequestQuery.toJSON(message.query) : void 0);
          message.beginBlock !== void 0 && (obj.beginBlock = message.beginBlock ? exports2.RequestBeginBlock.toJSON(message.beginBlock) : void 0);
          message.checkTx !== void 0 && (obj.checkTx = message.checkTx ? exports2.RequestCheckTx.toJSON(message.checkTx) : void 0);
          message.deliverTx !== void 0 && (obj.deliverTx = message.deliverTx ? exports2.RequestDeliverTx.toJSON(message.deliverTx) : void 0);
          message.endBlock !== void 0 && (obj.endBlock = message.endBlock ? exports2.RequestEndBlock.toJSON(message.endBlock) : void 0);
          message.commit !== void 0 && (obj.commit = message.commit ? exports2.RequestCommit.toJSON(message.commit) : void 0);
          message.listSnapshots !== void 0 && (obj.listSnapshots = message.listSnapshots ? exports2.RequestListSnapshots.toJSON(message.listSnapshots) : void 0);
          message.offerSnapshot !== void 0 && (obj.offerSnapshot = message.offerSnapshot ? exports2.RequestOfferSnapshot.toJSON(message.offerSnapshot) : void 0);
          message.loadSnapshotChunk !== void 0 && (obj.loadSnapshotChunk = message.loadSnapshotChunk ? exports2.RequestLoadSnapshotChunk.toJSON(message.loadSnapshotChunk) : void 0);
          message.applySnapshotChunk !== void 0 && (obj.applySnapshotChunk = message.applySnapshotChunk ? exports2.RequestApplySnapshotChunk.toJSON(message.applySnapshotChunk) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseRequest);
          message.echo = object.echo !== void 0 && object.echo !== null ? exports2.RequestEcho.fromPartial(object.echo) : void 0;
          message.flush = object.flush !== void 0 && object.flush !== null ? exports2.RequestFlush.fromPartial(object.flush) : void 0;
          message.info = object.info !== void 0 && object.info !== null ? exports2.RequestInfo.fromPartial(object.info) : void 0;
          message.setOption = object.setOption !== void 0 && object.setOption !== null ? exports2.RequestSetOption.fromPartial(object.setOption) : void 0;
          message.initChain = object.initChain !== void 0 && object.initChain !== null ? exports2.RequestInitChain.fromPartial(object.initChain) : void 0;
          message.query = object.query !== void 0 && object.query !== null ? exports2.RequestQuery.fromPartial(object.query) : void 0;
          message.beginBlock = object.beginBlock !== void 0 && object.beginBlock !== null ? exports2.RequestBeginBlock.fromPartial(object.beginBlock) : void 0;
          message.checkTx = object.checkTx !== void 0 && object.checkTx !== null ? exports2.RequestCheckTx.fromPartial(object.checkTx) : void 0;
          message.deliverTx = object.deliverTx !== void 0 && object.deliverTx !== null ? exports2.RequestDeliverTx.fromPartial(object.deliverTx) : void 0;
          message.endBlock = object.endBlock !== void 0 && object.endBlock !== null ? exports2.RequestEndBlock.fromPartial(object.endBlock) : void 0;
          message.commit = object.commit !== void 0 && object.commit !== null ? exports2.RequestCommit.fromPartial(object.commit) : void 0;
          message.listSnapshots = object.listSnapshots !== void 0 && object.listSnapshots !== null ? exports2.RequestListSnapshots.fromPartial(object.listSnapshots) : void 0;
          message.offerSnapshot = object.offerSnapshot !== void 0 && object.offerSnapshot !== null ? exports2.RequestOfferSnapshot.fromPartial(object.offerSnapshot) : void 0;
          message.loadSnapshotChunk = object.loadSnapshotChunk !== void 0 && object.loadSnapshotChunk !== null ? exports2.RequestLoadSnapshotChunk.fromPartial(object.loadSnapshotChunk) : void 0;
          message.applySnapshotChunk = object.applySnapshotChunk !== void 0 && object.applySnapshotChunk !== null ? exports2.RequestApplySnapshotChunk.fromPartial(object.applySnapshotChunk) : void 0;
          return message;
        }
      };
      var baseRequestEcho = { message: "" };
      exports2.RequestEcho = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.message !== "") {
            writer.uint32(10).string(message.message);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseRequestEcho);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.message = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseRequestEcho);
          message.message = object.message !== void 0 && object.message !== null ? String(object.message) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.message !== void 0 && (obj.message = message.message);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseRequestEcho);
          message.message = (_a = object.message) !== null && _a !== void 0 ? _a : "";
          return message;
        }
      };
      var baseRequestFlush = {};
      exports2.RequestFlush = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseRequestFlush);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseRequestFlush);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseRequestFlush);
          return message;
        }
      };
      var baseRequestInfo = { version: "", blockVersion: long_1.default.UZERO, p2pVersion: long_1.default.UZERO };
      exports2.RequestInfo = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.version !== "") {
            writer.uint32(10).string(message.version);
          }
          if (!message.blockVersion.isZero()) {
            writer.uint32(16).uint64(message.blockVersion);
          }
          if (!message.p2pVersion.isZero()) {
            writer.uint32(24).uint64(message.p2pVersion);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseRequestInfo);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.version = reader.string();
                break;
              case 2:
                message.blockVersion = reader.uint64();
                break;
              case 3:
                message.p2pVersion = reader.uint64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseRequestInfo);
          message.version = object.version !== void 0 && object.version !== null ? String(object.version) : "";
          message.blockVersion = object.blockVersion !== void 0 && object.blockVersion !== null ? long_1.default.fromString(object.blockVersion) : long_1.default.UZERO;
          message.p2pVersion = object.p2pVersion !== void 0 && object.p2pVersion !== null ? long_1.default.fromString(object.p2pVersion) : long_1.default.UZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.version !== void 0 && (obj.version = message.version);
          message.blockVersion !== void 0 && (obj.blockVersion = (message.blockVersion || long_1.default.UZERO).toString());
          message.p2pVersion !== void 0 && (obj.p2pVersion = (message.p2pVersion || long_1.default.UZERO).toString());
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseRequestInfo);
          message.version = (_a = object.version) !== null && _a !== void 0 ? _a : "";
          message.blockVersion = object.blockVersion !== void 0 && object.blockVersion !== null ? long_1.default.fromValue(object.blockVersion) : long_1.default.UZERO;
          message.p2pVersion = object.p2pVersion !== void 0 && object.p2pVersion !== null ? long_1.default.fromValue(object.p2pVersion) : long_1.default.UZERO;
          return message;
        }
      };
      var baseRequestSetOption = { key: "", value: "" };
      exports2.RequestSetOption = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.key !== "") {
            writer.uint32(10).string(message.key);
          }
          if (message.value !== "") {
            writer.uint32(18).string(message.value);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseRequestSetOption);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.key = reader.string();
                break;
              case 2:
                message.value = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseRequestSetOption);
          message.key = object.key !== void 0 && object.key !== null ? String(object.key) : "";
          message.value = object.value !== void 0 && object.value !== null ? String(object.value) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.key !== void 0 && (obj.key = message.key);
          message.value !== void 0 && (obj.value = message.value);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseRequestSetOption);
          message.key = (_a = object.key) !== null && _a !== void 0 ? _a : "";
          message.value = (_b = object.value) !== null && _b !== void 0 ? _b : "";
          return message;
        }
      };
      var baseRequestInitChain = { chainId: "", initialHeight: long_1.default.ZERO };
      exports2.RequestInitChain = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.time !== void 0) {
            timestamp_1.Timestamp.encode(message.time, writer.uint32(10).fork()).ldelim();
          }
          if (message.chainId !== "") {
            writer.uint32(18).string(message.chainId);
          }
          if (message.consensusParams !== void 0) {
            exports2.ConsensusParams.encode(message.consensusParams, writer.uint32(26).fork()).ldelim();
          }
          for (const v of message.validators) {
            exports2.ValidatorUpdate.encode(v, writer.uint32(34).fork()).ldelim();
          }
          if (message.appStateBytes.length !== 0) {
            writer.uint32(42).bytes(message.appStateBytes);
          }
          if (!message.initialHeight.isZero()) {
            writer.uint32(48).int64(message.initialHeight);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseRequestInitChain);
          message.validators = [];
          message.appStateBytes = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.time = timestamp_1.Timestamp.decode(reader, reader.uint32());
                break;
              case 2:
                message.chainId = reader.string();
                break;
              case 3:
                message.consensusParams = exports2.ConsensusParams.decode(reader, reader.uint32());
                break;
              case 4:
                message.validators.push(exports2.ValidatorUpdate.decode(reader, reader.uint32()));
                break;
              case 5:
                message.appStateBytes = reader.bytes();
                break;
              case 6:
                message.initialHeight = reader.int64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseRequestInitChain);
          message.time = object.time !== void 0 && object.time !== null ? fromJsonTimestamp(object.time) : void 0;
          message.chainId = object.chainId !== void 0 && object.chainId !== null ? String(object.chainId) : "";
          message.consensusParams = object.consensusParams !== void 0 && object.consensusParams !== null ? exports2.ConsensusParams.fromJSON(object.consensusParams) : void 0;
          message.validators = ((_a = object.validators) !== null && _a !== void 0 ? _a : []).map((e) => exports2.ValidatorUpdate.fromJSON(e));
          message.appStateBytes = object.appStateBytes !== void 0 && object.appStateBytes !== null ? bytesFromBase64(object.appStateBytes) : new Uint8Array();
          message.initialHeight = object.initialHeight !== void 0 && object.initialHeight !== null ? long_1.default.fromString(object.initialHeight) : long_1.default.ZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.time !== void 0 && (obj.time = fromTimestamp(message.time).toISOString());
          message.chainId !== void 0 && (obj.chainId = message.chainId);
          message.consensusParams !== void 0 && (obj.consensusParams = message.consensusParams ? exports2.ConsensusParams.toJSON(message.consensusParams) : void 0);
          if (message.validators) {
            obj.validators = message.validators.map((e) => e ? exports2.ValidatorUpdate.toJSON(e) : void 0);
          } else {
            obj.validators = [];
          }
          message.appStateBytes !== void 0 && (obj.appStateBytes = base64FromBytes(message.appStateBytes !== void 0 ? message.appStateBytes : new Uint8Array()));
          message.initialHeight !== void 0 && (obj.initialHeight = (message.initialHeight || long_1.default.ZERO).toString());
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseRequestInitChain);
          message.time = object.time !== void 0 && object.time !== null ? timestamp_1.Timestamp.fromPartial(object.time) : void 0;
          message.chainId = (_a = object.chainId) !== null && _a !== void 0 ? _a : "";
          message.consensusParams = object.consensusParams !== void 0 && object.consensusParams !== null ? exports2.ConsensusParams.fromPartial(object.consensusParams) : void 0;
          message.validators = ((_b = object.validators) === null || _b === void 0 ? void 0 : _b.map((e) => exports2.ValidatorUpdate.fromPartial(e))) || [];
          message.appStateBytes = (_c = object.appStateBytes) !== null && _c !== void 0 ? _c : new Uint8Array();
          message.initialHeight = object.initialHeight !== void 0 && object.initialHeight !== null ? long_1.default.fromValue(object.initialHeight) : long_1.default.ZERO;
          return message;
        }
      };
      var baseRequestQuery = { path: "", height: long_1.default.ZERO, prove: false };
      exports2.RequestQuery = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.data.length !== 0) {
            writer.uint32(10).bytes(message.data);
          }
          if (message.path !== "") {
            writer.uint32(18).string(message.path);
          }
          if (!message.height.isZero()) {
            writer.uint32(24).int64(message.height);
          }
          if (message.prove === true) {
            writer.uint32(32).bool(message.prove);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseRequestQuery);
          message.data = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.data = reader.bytes();
                break;
              case 2:
                message.path = reader.string();
                break;
              case 3:
                message.height = reader.int64();
                break;
              case 4:
                message.prove = reader.bool();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseRequestQuery);
          message.data = object.data !== void 0 && object.data !== null ? bytesFromBase64(object.data) : new Uint8Array();
          message.path = object.path !== void 0 && object.path !== null ? String(object.path) : "";
          message.height = object.height !== void 0 && object.height !== null ? long_1.default.fromString(object.height) : long_1.default.ZERO;
          message.prove = object.prove !== void 0 && object.prove !== null ? Boolean(object.prove) : false;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.data !== void 0 && (obj.data = base64FromBytes(message.data !== void 0 ? message.data : new Uint8Array()));
          message.path !== void 0 && (obj.path = message.path);
          message.height !== void 0 && (obj.height = (message.height || long_1.default.ZERO).toString());
          message.prove !== void 0 && (obj.prove = message.prove);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseRequestQuery);
          message.data = (_a = object.data) !== null && _a !== void 0 ? _a : new Uint8Array();
          message.path = (_b = object.path) !== null && _b !== void 0 ? _b : "";
          message.height = object.height !== void 0 && object.height !== null ? long_1.default.fromValue(object.height) : long_1.default.ZERO;
          message.prove = (_c = object.prove) !== null && _c !== void 0 ? _c : false;
          return message;
        }
      };
      var baseRequestBeginBlock = {};
      exports2.RequestBeginBlock = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.hash.length !== 0) {
            writer.uint32(10).bytes(message.hash);
          }
          if (message.header !== void 0) {
            types_1.Header.encode(message.header, writer.uint32(18).fork()).ldelim();
          }
          if (message.lastCommitInfo !== void 0) {
            exports2.LastCommitInfo.encode(message.lastCommitInfo, writer.uint32(26).fork()).ldelim();
          }
          for (const v of message.byzantineValidators) {
            exports2.Evidence.encode(v, writer.uint32(34).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseRequestBeginBlock);
          message.byzantineValidators = [];
          message.hash = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.hash = reader.bytes();
                break;
              case 2:
                message.header = types_1.Header.decode(reader, reader.uint32());
                break;
              case 3:
                message.lastCommitInfo = exports2.LastCommitInfo.decode(reader, reader.uint32());
                break;
              case 4:
                message.byzantineValidators.push(exports2.Evidence.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseRequestBeginBlock);
          message.hash = object.hash !== void 0 && object.hash !== null ? bytesFromBase64(object.hash) : new Uint8Array();
          message.header = object.header !== void 0 && object.header !== null ? types_1.Header.fromJSON(object.header) : void 0;
          message.lastCommitInfo = object.lastCommitInfo !== void 0 && object.lastCommitInfo !== null ? exports2.LastCommitInfo.fromJSON(object.lastCommitInfo) : void 0;
          message.byzantineValidators = ((_a = object.byzantineValidators) !== null && _a !== void 0 ? _a : []).map((e) => exports2.Evidence.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.hash !== void 0 && (obj.hash = base64FromBytes(message.hash !== void 0 ? message.hash : new Uint8Array()));
          message.header !== void 0 && (obj.header = message.header ? types_1.Header.toJSON(message.header) : void 0);
          message.lastCommitInfo !== void 0 && (obj.lastCommitInfo = message.lastCommitInfo ? exports2.LastCommitInfo.toJSON(message.lastCommitInfo) : void 0);
          if (message.byzantineValidators) {
            obj.byzantineValidators = message.byzantineValidators.map((e) => e ? exports2.Evidence.toJSON(e) : void 0);
          } else {
            obj.byzantineValidators = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseRequestBeginBlock);
          message.hash = (_a = object.hash) !== null && _a !== void 0 ? _a : new Uint8Array();
          message.header = object.header !== void 0 && object.header !== null ? types_1.Header.fromPartial(object.header) : void 0;
          message.lastCommitInfo = object.lastCommitInfo !== void 0 && object.lastCommitInfo !== null ? exports2.LastCommitInfo.fromPartial(object.lastCommitInfo) : void 0;
          message.byzantineValidators = ((_b = object.byzantineValidators) === null || _b === void 0 ? void 0 : _b.map((e) => exports2.Evidence.fromPartial(e))) || [];
          return message;
        }
      };
      var baseRequestCheckTx = { type: 0 };
      exports2.RequestCheckTx = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.tx.length !== 0) {
            writer.uint32(10).bytes(message.tx);
          }
          if (message.type !== 0) {
            writer.uint32(16).int32(message.type);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseRequestCheckTx);
          message.tx = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.tx = reader.bytes();
                break;
              case 2:
                message.type = reader.int32();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseRequestCheckTx);
          message.tx = object.tx !== void 0 && object.tx !== null ? bytesFromBase64(object.tx) : new Uint8Array();
          message.type = object.type !== void 0 && object.type !== null ? checkTxTypeFromJSON(object.type) : 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.tx !== void 0 && (obj.tx = base64FromBytes(message.tx !== void 0 ? message.tx : new Uint8Array()));
          message.type !== void 0 && (obj.type = checkTxTypeToJSON(message.type));
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseRequestCheckTx);
          message.tx = (_a = object.tx) !== null && _a !== void 0 ? _a : new Uint8Array();
          message.type = (_b = object.type) !== null && _b !== void 0 ? _b : 0;
          return message;
        }
      };
      var baseRequestDeliverTx = {};
      exports2.RequestDeliverTx = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.tx.length !== 0) {
            writer.uint32(10).bytes(message.tx);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseRequestDeliverTx);
          message.tx = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.tx = reader.bytes();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseRequestDeliverTx);
          message.tx = object.tx !== void 0 && object.tx !== null ? bytesFromBase64(object.tx) : new Uint8Array();
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.tx !== void 0 && (obj.tx = base64FromBytes(message.tx !== void 0 ? message.tx : new Uint8Array()));
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseRequestDeliverTx);
          message.tx = (_a = object.tx) !== null && _a !== void 0 ? _a : new Uint8Array();
          return message;
        }
      };
      var baseRequestEndBlock = { height: long_1.default.ZERO };
      exports2.RequestEndBlock = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.height.isZero()) {
            writer.uint32(8).int64(message.height);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseRequestEndBlock);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.height = reader.int64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseRequestEndBlock);
          message.height = object.height !== void 0 && object.height !== null ? long_1.default.fromString(object.height) : long_1.default.ZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.height !== void 0 && (obj.height = (message.height || long_1.default.ZERO).toString());
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseRequestEndBlock);
          message.height = object.height !== void 0 && object.height !== null ? long_1.default.fromValue(object.height) : long_1.default.ZERO;
          return message;
        }
      };
      var baseRequestCommit = {};
      exports2.RequestCommit = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseRequestCommit);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseRequestCommit);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseRequestCommit);
          return message;
        }
      };
      var baseRequestListSnapshots = {};
      exports2.RequestListSnapshots = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseRequestListSnapshots);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseRequestListSnapshots);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseRequestListSnapshots);
          return message;
        }
      };
      var baseRequestOfferSnapshot = {};
      exports2.RequestOfferSnapshot = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.snapshot !== void 0) {
            exports2.Snapshot.encode(message.snapshot, writer.uint32(10).fork()).ldelim();
          }
          if (message.appHash.length !== 0) {
            writer.uint32(18).bytes(message.appHash);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseRequestOfferSnapshot);
          message.appHash = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.snapshot = exports2.Snapshot.decode(reader, reader.uint32());
                break;
              case 2:
                message.appHash = reader.bytes();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseRequestOfferSnapshot);
          message.snapshot = object.snapshot !== void 0 && object.snapshot !== null ? exports2.Snapshot.fromJSON(object.snapshot) : void 0;
          message.appHash = object.appHash !== void 0 && object.appHash !== null ? bytesFromBase64(object.appHash) : new Uint8Array();
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.snapshot !== void 0 && (obj.snapshot = message.snapshot ? exports2.Snapshot.toJSON(message.snapshot) : void 0);
          message.appHash !== void 0 && (obj.appHash = base64FromBytes(message.appHash !== void 0 ? message.appHash : new Uint8Array()));
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseRequestOfferSnapshot);
          message.snapshot = object.snapshot !== void 0 && object.snapshot !== null ? exports2.Snapshot.fromPartial(object.snapshot) : void 0;
          message.appHash = (_a = object.appHash) !== null && _a !== void 0 ? _a : new Uint8Array();
          return message;
        }
      };
      var baseRequestLoadSnapshotChunk = { height: long_1.default.UZERO, format: 0, chunk: 0 };
      exports2.RequestLoadSnapshotChunk = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.height.isZero()) {
            writer.uint32(8).uint64(message.height);
          }
          if (message.format !== 0) {
            writer.uint32(16).uint32(message.format);
          }
          if (message.chunk !== 0) {
            writer.uint32(24).uint32(message.chunk);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseRequestLoadSnapshotChunk);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.height = reader.uint64();
                break;
              case 2:
                message.format = reader.uint32();
                break;
              case 3:
                message.chunk = reader.uint32();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseRequestLoadSnapshotChunk);
          message.height = object.height !== void 0 && object.height !== null ? long_1.default.fromString(object.height) : long_1.default.UZERO;
          message.format = object.format !== void 0 && object.format !== null ? Number(object.format) : 0;
          message.chunk = object.chunk !== void 0 && object.chunk !== null ? Number(object.chunk) : 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.height !== void 0 && (obj.height = (message.height || long_1.default.UZERO).toString());
          message.format !== void 0 && (obj.format = message.format);
          message.chunk !== void 0 && (obj.chunk = message.chunk);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseRequestLoadSnapshotChunk);
          message.height = object.height !== void 0 && object.height !== null ? long_1.default.fromValue(object.height) : long_1.default.UZERO;
          message.format = (_a = object.format) !== null && _a !== void 0 ? _a : 0;
          message.chunk = (_b = object.chunk) !== null && _b !== void 0 ? _b : 0;
          return message;
        }
      };
      var baseRequestApplySnapshotChunk = { index: 0, sender: "" };
      exports2.RequestApplySnapshotChunk = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.index !== 0) {
            writer.uint32(8).uint32(message.index);
          }
          if (message.chunk.length !== 0) {
            writer.uint32(18).bytes(message.chunk);
          }
          if (message.sender !== "") {
            writer.uint32(26).string(message.sender);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseRequestApplySnapshotChunk);
          message.chunk = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.index = reader.uint32();
                break;
              case 2:
                message.chunk = reader.bytes();
                break;
              case 3:
                message.sender = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseRequestApplySnapshotChunk);
          message.index = object.index !== void 0 && object.index !== null ? Number(object.index) : 0;
          message.chunk = object.chunk !== void 0 && object.chunk !== null ? bytesFromBase64(object.chunk) : new Uint8Array();
          message.sender = object.sender !== void 0 && object.sender !== null ? String(object.sender) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.index !== void 0 && (obj.index = message.index);
          message.chunk !== void 0 && (obj.chunk = base64FromBytes(message.chunk !== void 0 ? message.chunk : new Uint8Array()));
          message.sender !== void 0 && (obj.sender = message.sender);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseRequestApplySnapshotChunk);
          message.index = (_a = object.index) !== null && _a !== void 0 ? _a : 0;
          message.chunk = (_b = object.chunk) !== null && _b !== void 0 ? _b : new Uint8Array();
          message.sender = (_c = object.sender) !== null && _c !== void 0 ? _c : "";
          return message;
        }
      };
      var baseResponse = {};
      exports2.Response = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.exception !== void 0) {
            exports2.ResponseException.encode(message.exception, writer.uint32(10).fork()).ldelim();
          }
          if (message.echo !== void 0) {
            exports2.ResponseEcho.encode(message.echo, writer.uint32(18).fork()).ldelim();
          }
          if (message.flush !== void 0) {
            exports2.ResponseFlush.encode(message.flush, writer.uint32(26).fork()).ldelim();
          }
          if (message.info !== void 0) {
            exports2.ResponseInfo.encode(message.info, writer.uint32(34).fork()).ldelim();
          }
          if (message.setOption !== void 0) {
            exports2.ResponseSetOption.encode(message.setOption, writer.uint32(42).fork()).ldelim();
          }
          if (message.initChain !== void 0) {
            exports2.ResponseInitChain.encode(message.initChain, writer.uint32(50).fork()).ldelim();
          }
          if (message.query !== void 0) {
            exports2.ResponseQuery.encode(message.query, writer.uint32(58).fork()).ldelim();
          }
          if (message.beginBlock !== void 0) {
            exports2.ResponseBeginBlock.encode(message.beginBlock, writer.uint32(66).fork()).ldelim();
          }
          if (message.checkTx !== void 0) {
            exports2.ResponseCheckTx.encode(message.checkTx, writer.uint32(74).fork()).ldelim();
          }
          if (message.deliverTx !== void 0) {
            exports2.ResponseDeliverTx.encode(message.deliverTx, writer.uint32(82).fork()).ldelim();
          }
          if (message.endBlock !== void 0) {
            exports2.ResponseEndBlock.encode(message.endBlock, writer.uint32(90).fork()).ldelim();
          }
          if (message.commit !== void 0) {
            exports2.ResponseCommit.encode(message.commit, writer.uint32(98).fork()).ldelim();
          }
          if (message.listSnapshots !== void 0) {
            exports2.ResponseListSnapshots.encode(message.listSnapshots, writer.uint32(106).fork()).ldelim();
          }
          if (message.offerSnapshot !== void 0) {
            exports2.ResponseOfferSnapshot.encode(message.offerSnapshot, writer.uint32(114).fork()).ldelim();
          }
          if (message.loadSnapshotChunk !== void 0) {
            exports2.ResponseLoadSnapshotChunk.encode(message.loadSnapshotChunk, writer.uint32(122).fork()).ldelim();
          }
          if (message.applySnapshotChunk !== void 0) {
            exports2.ResponseApplySnapshotChunk.encode(message.applySnapshotChunk, writer.uint32(130).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.exception = exports2.ResponseException.decode(reader, reader.uint32());
                break;
              case 2:
                message.echo = exports2.ResponseEcho.decode(reader, reader.uint32());
                break;
              case 3:
                message.flush = exports2.ResponseFlush.decode(reader, reader.uint32());
                break;
              case 4:
                message.info = exports2.ResponseInfo.decode(reader, reader.uint32());
                break;
              case 5:
                message.setOption = exports2.ResponseSetOption.decode(reader, reader.uint32());
                break;
              case 6:
                message.initChain = exports2.ResponseInitChain.decode(reader, reader.uint32());
                break;
              case 7:
                message.query = exports2.ResponseQuery.decode(reader, reader.uint32());
                break;
              case 8:
                message.beginBlock = exports2.ResponseBeginBlock.decode(reader, reader.uint32());
                break;
              case 9:
                message.checkTx = exports2.ResponseCheckTx.decode(reader, reader.uint32());
                break;
              case 10:
                message.deliverTx = exports2.ResponseDeliverTx.decode(reader, reader.uint32());
                break;
              case 11:
                message.endBlock = exports2.ResponseEndBlock.decode(reader, reader.uint32());
                break;
              case 12:
                message.commit = exports2.ResponseCommit.decode(reader, reader.uint32());
                break;
              case 13:
                message.listSnapshots = exports2.ResponseListSnapshots.decode(reader, reader.uint32());
                break;
              case 14:
                message.offerSnapshot = exports2.ResponseOfferSnapshot.decode(reader, reader.uint32());
                break;
              case 15:
                message.loadSnapshotChunk = exports2.ResponseLoadSnapshotChunk.decode(reader, reader.uint32());
                break;
              case 16:
                message.applySnapshotChunk = exports2.ResponseApplySnapshotChunk.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseResponse);
          message.exception = object.exception !== void 0 && object.exception !== null ? exports2.ResponseException.fromJSON(object.exception) : void 0;
          message.echo = object.echo !== void 0 && object.echo !== null ? exports2.ResponseEcho.fromJSON(object.echo) : void 0;
          message.flush = object.flush !== void 0 && object.flush !== null ? exports2.ResponseFlush.fromJSON(object.flush) : void 0;
          message.info = object.info !== void 0 && object.info !== null ? exports2.ResponseInfo.fromJSON(object.info) : void 0;
          message.setOption = object.setOption !== void 0 && object.setOption !== null ? exports2.ResponseSetOption.fromJSON(object.setOption) : void 0;
          message.initChain = object.initChain !== void 0 && object.initChain !== null ? exports2.ResponseInitChain.fromJSON(object.initChain) : void 0;
          message.query = object.query !== void 0 && object.query !== null ? exports2.ResponseQuery.fromJSON(object.query) : void 0;
          message.beginBlock = object.beginBlock !== void 0 && object.beginBlock !== null ? exports2.ResponseBeginBlock.fromJSON(object.beginBlock) : void 0;
          message.checkTx = object.checkTx !== void 0 && object.checkTx !== null ? exports2.ResponseCheckTx.fromJSON(object.checkTx) : void 0;
          message.deliverTx = object.deliverTx !== void 0 && object.deliverTx !== null ? exports2.ResponseDeliverTx.fromJSON(object.deliverTx) : void 0;
          message.endBlock = object.endBlock !== void 0 && object.endBlock !== null ? exports2.ResponseEndBlock.fromJSON(object.endBlock) : void 0;
          message.commit = object.commit !== void 0 && object.commit !== null ? exports2.ResponseCommit.fromJSON(object.commit) : void 0;
          message.listSnapshots = object.listSnapshots !== void 0 && object.listSnapshots !== null ? exports2.ResponseListSnapshots.fromJSON(object.listSnapshots) : void 0;
          message.offerSnapshot = object.offerSnapshot !== void 0 && object.offerSnapshot !== null ? exports2.ResponseOfferSnapshot.fromJSON(object.offerSnapshot) : void 0;
          message.loadSnapshotChunk = object.loadSnapshotChunk !== void 0 && object.loadSnapshotChunk !== null ? exports2.ResponseLoadSnapshotChunk.fromJSON(object.loadSnapshotChunk) : void 0;
          message.applySnapshotChunk = object.applySnapshotChunk !== void 0 && object.applySnapshotChunk !== null ? exports2.ResponseApplySnapshotChunk.fromJSON(object.applySnapshotChunk) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.exception !== void 0 && (obj.exception = message.exception ? exports2.ResponseException.toJSON(message.exception) : void 0);
          message.echo !== void 0 && (obj.echo = message.echo ? exports2.ResponseEcho.toJSON(message.echo) : void 0);
          message.flush !== void 0 && (obj.flush = message.flush ? exports2.ResponseFlush.toJSON(message.flush) : void 0);
          message.info !== void 0 && (obj.info = message.info ? exports2.ResponseInfo.toJSON(message.info) : void 0);
          message.setOption !== void 0 && (obj.setOption = message.setOption ? exports2.ResponseSetOption.toJSON(message.setOption) : void 0);
          message.initChain !== void 0 && (obj.initChain = message.initChain ? exports2.ResponseInitChain.toJSON(message.initChain) : void 0);
          message.query !== void 0 && (obj.query = message.query ? exports2.ResponseQuery.toJSON(message.query) : void 0);
          message.beginBlock !== void 0 && (obj.beginBlock = message.beginBlock ? exports2.ResponseBeginBlock.toJSON(message.beginBlock) : void 0);
          message.checkTx !== void 0 && (obj.checkTx = message.checkTx ? exports2.ResponseCheckTx.toJSON(message.checkTx) : void 0);
          message.deliverTx !== void 0 && (obj.deliverTx = message.deliverTx ? exports2.ResponseDeliverTx.toJSON(message.deliverTx) : void 0);
          message.endBlock !== void 0 && (obj.endBlock = message.endBlock ? exports2.ResponseEndBlock.toJSON(message.endBlock) : void 0);
          message.commit !== void 0 && (obj.commit = message.commit ? exports2.ResponseCommit.toJSON(message.commit) : void 0);
          message.listSnapshots !== void 0 && (obj.listSnapshots = message.listSnapshots ? exports2.ResponseListSnapshots.toJSON(message.listSnapshots) : void 0);
          message.offerSnapshot !== void 0 && (obj.offerSnapshot = message.offerSnapshot ? exports2.ResponseOfferSnapshot.toJSON(message.offerSnapshot) : void 0);
          message.loadSnapshotChunk !== void 0 && (obj.loadSnapshotChunk = message.loadSnapshotChunk ? exports2.ResponseLoadSnapshotChunk.toJSON(message.loadSnapshotChunk) : void 0);
          message.applySnapshotChunk !== void 0 && (obj.applySnapshotChunk = message.applySnapshotChunk ? exports2.ResponseApplySnapshotChunk.toJSON(message.applySnapshotChunk) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseResponse);
          message.exception = object.exception !== void 0 && object.exception !== null ? exports2.ResponseException.fromPartial(object.exception) : void 0;
          message.echo = object.echo !== void 0 && object.echo !== null ? exports2.ResponseEcho.fromPartial(object.echo) : void 0;
          message.flush = object.flush !== void 0 && object.flush !== null ? exports2.ResponseFlush.fromPartial(object.flush) : void 0;
          message.info = object.info !== void 0 && object.info !== null ? exports2.ResponseInfo.fromPartial(object.info) : void 0;
          message.setOption = object.setOption !== void 0 && object.setOption !== null ? exports2.ResponseSetOption.fromPartial(object.setOption) : void 0;
          message.initChain = object.initChain !== void 0 && object.initChain !== null ? exports2.ResponseInitChain.fromPartial(object.initChain) : void 0;
          message.query = object.query !== void 0 && object.query !== null ? exports2.ResponseQuery.fromPartial(object.query) : void 0;
          message.beginBlock = object.beginBlock !== void 0 && object.beginBlock !== null ? exports2.ResponseBeginBlock.fromPartial(object.beginBlock) : void 0;
          message.checkTx = object.checkTx !== void 0 && object.checkTx !== null ? exports2.ResponseCheckTx.fromPartial(object.checkTx) : void 0;
          message.deliverTx = object.deliverTx !== void 0 && object.deliverTx !== null ? exports2.ResponseDeliverTx.fromPartial(object.deliverTx) : void 0;
          message.endBlock = object.endBlock !== void 0 && object.endBlock !== null ? exports2.ResponseEndBlock.fromPartial(object.endBlock) : void 0;
          message.commit = object.commit !== void 0 && object.commit !== null ? exports2.ResponseCommit.fromPartial(object.commit) : void 0;
          message.listSnapshots = object.listSnapshots !== void 0 && object.listSnapshots !== null ? exports2.ResponseListSnapshots.fromPartial(object.listSnapshots) : void 0;
          message.offerSnapshot = object.offerSnapshot !== void 0 && object.offerSnapshot !== null ? exports2.ResponseOfferSnapshot.fromPartial(object.offerSnapshot) : void 0;
          message.loadSnapshotChunk = object.loadSnapshotChunk !== void 0 && object.loadSnapshotChunk !== null ? exports2.ResponseLoadSnapshotChunk.fromPartial(object.loadSnapshotChunk) : void 0;
          message.applySnapshotChunk = object.applySnapshotChunk !== void 0 && object.applySnapshotChunk !== null ? exports2.ResponseApplySnapshotChunk.fromPartial(object.applySnapshotChunk) : void 0;
          return message;
        }
      };
      var baseResponseException = { error: "" };
      exports2.ResponseException = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.error !== "") {
            writer.uint32(10).string(message.error);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseResponseException);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.error = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseResponseException);
          message.error = object.error !== void 0 && object.error !== null ? String(object.error) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.error !== void 0 && (obj.error = message.error);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseResponseException);
          message.error = (_a = object.error) !== null && _a !== void 0 ? _a : "";
          return message;
        }
      };
      var baseResponseEcho = { message: "" };
      exports2.ResponseEcho = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.message !== "") {
            writer.uint32(10).string(message.message);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseResponseEcho);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.message = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseResponseEcho);
          message.message = object.message !== void 0 && object.message !== null ? String(object.message) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.message !== void 0 && (obj.message = message.message);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseResponseEcho);
          message.message = (_a = object.message) !== null && _a !== void 0 ? _a : "";
          return message;
        }
      };
      var baseResponseFlush = {};
      exports2.ResponseFlush = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseResponseFlush);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseResponseFlush);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseResponseFlush);
          return message;
        }
      };
      var baseResponseInfo = {
        data: "",
        version: "",
        appVersion: long_1.default.UZERO,
        lastBlockHeight: long_1.default.ZERO
      };
      exports2.ResponseInfo = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.data !== "") {
            writer.uint32(10).string(message.data);
          }
          if (message.version !== "") {
            writer.uint32(18).string(message.version);
          }
          if (!message.appVersion.isZero()) {
            writer.uint32(24).uint64(message.appVersion);
          }
          if (!message.lastBlockHeight.isZero()) {
            writer.uint32(32).int64(message.lastBlockHeight);
          }
          if (message.lastBlockAppHash.length !== 0) {
            writer.uint32(42).bytes(message.lastBlockAppHash);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseResponseInfo);
          message.lastBlockAppHash = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.data = reader.string();
                break;
              case 2:
                message.version = reader.string();
                break;
              case 3:
                message.appVersion = reader.uint64();
                break;
              case 4:
                message.lastBlockHeight = reader.int64();
                break;
              case 5:
                message.lastBlockAppHash = reader.bytes();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseResponseInfo);
          message.data = object.data !== void 0 && object.data !== null ? String(object.data) : "";
          message.version = object.version !== void 0 && object.version !== null ? String(object.version) : "";
          message.appVersion = object.appVersion !== void 0 && object.appVersion !== null ? long_1.default.fromString(object.appVersion) : long_1.default.UZERO;
          message.lastBlockHeight = object.lastBlockHeight !== void 0 && object.lastBlockHeight !== null ? long_1.default.fromString(object.lastBlockHeight) : long_1.default.ZERO;
          message.lastBlockAppHash = object.lastBlockAppHash !== void 0 && object.lastBlockAppHash !== null ? bytesFromBase64(object.lastBlockAppHash) : new Uint8Array();
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.data !== void 0 && (obj.data = message.data);
          message.version !== void 0 && (obj.version = message.version);
          message.appVersion !== void 0 && (obj.appVersion = (message.appVersion || long_1.default.UZERO).toString());
          message.lastBlockHeight !== void 0 && (obj.lastBlockHeight = (message.lastBlockHeight || long_1.default.ZERO).toString());
          message.lastBlockAppHash !== void 0 && (obj.lastBlockAppHash = base64FromBytes(message.lastBlockAppHash !== void 0 ? message.lastBlockAppHash : new Uint8Array()));
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseResponseInfo);
          message.data = (_a = object.data) !== null && _a !== void 0 ? _a : "";
          message.version = (_b = object.version) !== null && _b !== void 0 ? _b : "";
          message.appVersion = object.appVersion !== void 0 && object.appVersion !== null ? long_1.default.fromValue(object.appVersion) : long_1.default.UZERO;
          message.lastBlockHeight = object.lastBlockHeight !== void 0 && object.lastBlockHeight !== null ? long_1.default.fromValue(object.lastBlockHeight) : long_1.default.ZERO;
          message.lastBlockAppHash = (_c = object.lastBlockAppHash) !== null && _c !== void 0 ? _c : new Uint8Array();
          return message;
        }
      };
      var baseResponseSetOption = { code: 0, log: "", info: "" };
      exports2.ResponseSetOption = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.code !== 0) {
            writer.uint32(8).uint32(message.code);
          }
          if (message.log !== "") {
            writer.uint32(26).string(message.log);
          }
          if (message.info !== "") {
            writer.uint32(34).string(message.info);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseResponseSetOption);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.code = reader.uint32();
                break;
              case 3:
                message.log = reader.string();
                break;
              case 4:
                message.info = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseResponseSetOption);
          message.code = object.code !== void 0 && object.code !== null ? Number(object.code) : 0;
          message.log = object.log !== void 0 && object.log !== null ? String(object.log) : "";
          message.info = object.info !== void 0 && object.info !== null ? String(object.info) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.code !== void 0 && (obj.code = message.code);
          message.log !== void 0 && (obj.log = message.log);
          message.info !== void 0 && (obj.info = message.info);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseResponseSetOption);
          message.code = (_a = object.code) !== null && _a !== void 0 ? _a : 0;
          message.log = (_b = object.log) !== null && _b !== void 0 ? _b : "";
          message.info = (_c = object.info) !== null && _c !== void 0 ? _c : "";
          return message;
        }
      };
      var baseResponseInitChain = {};
      exports2.ResponseInitChain = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.consensusParams !== void 0) {
            exports2.ConsensusParams.encode(message.consensusParams, writer.uint32(10).fork()).ldelim();
          }
          for (const v of message.validators) {
            exports2.ValidatorUpdate.encode(v, writer.uint32(18).fork()).ldelim();
          }
          if (message.appHash.length !== 0) {
            writer.uint32(26).bytes(message.appHash);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseResponseInitChain);
          message.validators = [];
          message.appHash = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.consensusParams = exports2.ConsensusParams.decode(reader, reader.uint32());
                break;
              case 2:
                message.validators.push(exports2.ValidatorUpdate.decode(reader, reader.uint32()));
                break;
              case 3:
                message.appHash = reader.bytes();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseResponseInitChain);
          message.consensusParams = object.consensusParams !== void 0 && object.consensusParams !== null ? exports2.ConsensusParams.fromJSON(object.consensusParams) : void 0;
          message.validators = ((_a = object.validators) !== null && _a !== void 0 ? _a : []).map((e) => exports2.ValidatorUpdate.fromJSON(e));
          message.appHash = object.appHash !== void 0 && object.appHash !== null ? bytesFromBase64(object.appHash) : new Uint8Array();
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.consensusParams !== void 0 && (obj.consensusParams = message.consensusParams ? exports2.ConsensusParams.toJSON(message.consensusParams) : void 0);
          if (message.validators) {
            obj.validators = message.validators.map((e) => e ? exports2.ValidatorUpdate.toJSON(e) : void 0);
          } else {
            obj.validators = [];
          }
          message.appHash !== void 0 && (obj.appHash = base64FromBytes(message.appHash !== void 0 ? message.appHash : new Uint8Array()));
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseResponseInitChain);
          message.consensusParams = object.consensusParams !== void 0 && object.consensusParams !== null ? exports2.ConsensusParams.fromPartial(object.consensusParams) : void 0;
          message.validators = ((_a = object.validators) === null || _a === void 0 ? void 0 : _a.map((e) => exports2.ValidatorUpdate.fromPartial(e))) || [];
          message.appHash = (_b = object.appHash) !== null && _b !== void 0 ? _b : new Uint8Array();
          return message;
        }
      };
      var baseResponseQuery = {
        code: 0,
        log: "",
        info: "",
        index: long_1.default.ZERO,
        height: long_1.default.ZERO,
        codespace: ""
      };
      exports2.ResponseQuery = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.code !== 0) {
            writer.uint32(8).uint32(message.code);
          }
          if (message.log !== "") {
            writer.uint32(26).string(message.log);
          }
          if (message.info !== "") {
            writer.uint32(34).string(message.info);
          }
          if (!message.index.isZero()) {
            writer.uint32(40).int64(message.index);
          }
          if (message.key.length !== 0) {
            writer.uint32(50).bytes(message.key);
          }
          if (message.value.length !== 0) {
            writer.uint32(58).bytes(message.value);
          }
          if (message.proofOps !== void 0) {
            proof_1.ProofOps.encode(message.proofOps, writer.uint32(66).fork()).ldelim();
          }
          if (!message.height.isZero()) {
            writer.uint32(72).int64(message.height);
          }
          if (message.codespace !== "") {
            writer.uint32(82).string(message.codespace);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseResponseQuery);
          message.key = new Uint8Array();
          message.value = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.code = reader.uint32();
                break;
              case 3:
                message.log = reader.string();
                break;
              case 4:
                message.info = reader.string();
                break;
              case 5:
                message.index = reader.int64();
                break;
              case 6:
                message.key = reader.bytes();
                break;
              case 7:
                message.value = reader.bytes();
                break;
              case 8:
                message.proofOps = proof_1.ProofOps.decode(reader, reader.uint32());
                break;
              case 9:
                message.height = reader.int64();
                break;
              case 10:
                message.codespace = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseResponseQuery);
          message.code = object.code !== void 0 && object.code !== null ? Number(object.code) : 0;
          message.log = object.log !== void 0 && object.log !== null ? String(object.log) : "";
          message.info = object.info !== void 0 && object.info !== null ? String(object.info) : "";
          message.index = object.index !== void 0 && object.index !== null ? long_1.default.fromString(object.index) : long_1.default.ZERO;
          message.key = object.key !== void 0 && object.key !== null ? bytesFromBase64(object.key) : new Uint8Array();
          message.value = object.value !== void 0 && object.value !== null ? bytesFromBase64(object.value) : new Uint8Array();
          message.proofOps = object.proofOps !== void 0 && object.proofOps !== null ? proof_1.ProofOps.fromJSON(object.proofOps) : void 0;
          message.height = object.height !== void 0 && object.height !== null ? long_1.default.fromString(object.height) : long_1.default.ZERO;
          message.codespace = object.codespace !== void 0 && object.codespace !== null ? String(object.codespace) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.code !== void 0 && (obj.code = message.code);
          message.log !== void 0 && (obj.log = message.log);
          message.info !== void 0 && (obj.info = message.info);
          message.index !== void 0 && (obj.index = (message.index || long_1.default.ZERO).toString());
          message.key !== void 0 && (obj.key = base64FromBytes(message.key !== void 0 ? message.key : new Uint8Array()));
          message.value !== void 0 && (obj.value = base64FromBytes(message.value !== void 0 ? message.value : new Uint8Array()));
          message.proofOps !== void 0 && (obj.proofOps = message.proofOps ? proof_1.ProofOps.toJSON(message.proofOps) : void 0);
          message.height !== void 0 && (obj.height = (message.height || long_1.default.ZERO).toString());
          message.codespace !== void 0 && (obj.codespace = message.codespace);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c, _d, _e, _f;
          const message = Object.assign({}, baseResponseQuery);
          message.code = (_a = object.code) !== null && _a !== void 0 ? _a : 0;
          message.log = (_b = object.log) !== null && _b !== void 0 ? _b : "";
          message.info = (_c = object.info) !== null && _c !== void 0 ? _c : "";
          message.index = object.index !== void 0 && object.index !== null ? long_1.default.fromValue(object.index) : long_1.default.ZERO;
          message.key = (_d = object.key) !== null && _d !== void 0 ? _d : new Uint8Array();
          message.value = (_e = object.value) !== null && _e !== void 0 ? _e : new Uint8Array();
          message.proofOps = object.proofOps !== void 0 && object.proofOps !== null ? proof_1.ProofOps.fromPartial(object.proofOps) : void 0;
          message.height = object.height !== void 0 && object.height !== null ? long_1.default.fromValue(object.height) : long_1.default.ZERO;
          message.codespace = (_f = object.codespace) !== null && _f !== void 0 ? _f : "";
          return message;
        }
      };
      var baseResponseBeginBlock = {};
      exports2.ResponseBeginBlock = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.events) {
            exports2.Event.encode(v, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseResponseBeginBlock);
          message.events = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.events.push(exports2.Event.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseResponseBeginBlock);
          message.events = ((_a = object.events) !== null && _a !== void 0 ? _a : []).map((e) => exports2.Event.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.events) {
            obj.events = message.events.map((e) => e ? exports2.Event.toJSON(e) : void 0);
          } else {
            obj.events = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseResponseBeginBlock);
          message.events = ((_a = object.events) === null || _a === void 0 ? void 0 : _a.map((e) => exports2.Event.fromPartial(e))) || [];
          return message;
        }
      };
      var baseResponseCheckTx = {
        code: 0,
        log: "",
        info: "",
        gasWanted: long_1.default.ZERO,
        gasUsed: long_1.default.ZERO,
        codespace: ""
      };
      exports2.ResponseCheckTx = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.code !== 0) {
            writer.uint32(8).uint32(message.code);
          }
          if (message.data.length !== 0) {
            writer.uint32(18).bytes(message.data);
          }
          if (message.log !== "") {
            writer.uint32(26).string(message.log);
          }
          if (message.info !== "") {
            writer.uint32(34).string(message.info);
          }
          if (!message.gasWanted.isZero()) {
            writer.uint32(40).int64(message.gasWanted);
          }
          if (!message.gasUsed.isZero()) {
            writer.uint32(48).int64(message.gasUsed);
          }
          for (const v of message.events) {
            exports2.Event.encode(v, writer.uint32(58).fork()).ldelim();
          }
          if (message.codespace !== "") {
            writer.uint32(66).string(message.codespace);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseResponseCheckTx);
          message.events = [];
          message.data = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.code = reader.uint32();
                break;
              case 2:
                message.data = reader.bytes();
                break;
              case 3:
                message.log = reader.string();
                break;
              case 4:
                message.info = reader.string();
                break;
              case 5:
                message.gasWanted = reader.int64();
                break;
              case 6:
                message.gasUsed = reader.int64();
                break;
              case 7:
                message.events.push(exports2.Event.decode(reader, reader.uint32()));
                break;
              case 8:
                message.codespace = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseResponseCheckTx);
          message.code = object.code !== void 0 && object.code !== null ? Number(object.code) : 0;
          message.data = object.data !== void 0 && object.data !== null ? bytesFromBase64(object.data) : new Uint8Array();
          message.log = object.log !== void 0 && object.log !== null ? String(object.log) : "";
          message.info = object.info !== void 0 && object.info !== null ? String(object.info) : "";
          message.gasWanted = object.gas_wanted !== void 0 && object.gas_wanted !== null ? long_1.default.fromString(object.gas_wanted) : long_1.default.ZERO;
          message.gasUsed = object.gas_used !== void 0 && object.gas_used !== null ? long_1.default.fromString(object.gas_used) : long_1.default.ZERO;
          message.events = ((_a = object.events) !== null && _a !== void 0 ? _a : []).map((e) => exports2.Event.fromJSON(e));
          message.codespace = object.codespace !== void 0 && object.codespace !== null ? String(object.codespace) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.code !== void 0 && (obj.code = message.code);
          message.data !== void 0 && (obj.data = base64FromBytes(message.data !== void 0 ? message.data : new Uint8Array()));
          message.log !== void 0 && (obj.log = message.log);
          message.info !== void 0 && (obj.info = message.info);
          message.gasWanted !== void 0 && (obj.gas_wanted = (message.gasWanted || long_1.default.ZERO).toString());
          message.gasUsed !== void 0 && (obj.gas_used = (message.gasUsed || long_1.default.ZERO).toString());
          if (message.events) {
            obj.events = message.events.map((e) => e ? exports2.Event.toJSON(e) : void 0);
          } else {
            obj.events = [];
          }
          message.codespace !== void 0 && (obj.codespace = message.codespace);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c, _d, _e, _f;
          const message = Object.assign({}, baseResponseCheckTx);
          message.code = (_a = object.code) !== null && _a !== void 0 ? _a : 0;
          message.data = (_b = object.data) !== null && _b !== void 0 ? _b : new Uint8Array();
          message.log = (_c = object.log) !== null && _c !== void 0 ? _c : "";
          message.info = (_d = object.info) !== null && _d !== void 0 ? _d : "";
          message.gasWanted = object.gasWanted !== void 0 && object.gasWanted !== null ? long_1.default.fromValue(object.gasWanted) : long_1.default.ZERO;
          message.gasUsed = object.gasUsed !== void 0 && object.gasUsed !== null ? long_1.default.fromValue(object.gasUsed) : long_1.default.ZERO;
          message.events = ((_e = object.events) === null || _e === void 0 ? void 0 : _e.map((e) => exports2.Event.fromPartial(e))) || [];
          message.codespace = (_f = object.codespace) !== null && _f !== void 0 ? _f : "";
          return message;
        }
      };
      var baseResponseDeliverTx = {
        code: 0,
        log: "",
        info: "",
        gasWanted: long_1.default.ZERO,
        gasUsed: long_1.default.ZERO,
        codespace: ""
      };
      exports2.ResponseDeliverTx = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.code !== 0) {
            writer.uint32(8).uint32(message.code);
          }
          if (message.data.length !== 0) {
            writer.uint32(18).bytes(message.data);
          }
          if (message.log !== "") {
            writer.uint32(26).string(message.log);
          }
          if (message.info !== "") {
            writer.uint32(34).string(message.info);
          }
          if (!message.gasWanted.isZero()) {
            writer.uint32(40).int64(message.gasWanted);
          }
          if (!message.gasUsed.isZero()) {
            writer.uint32(48).int64(message.gasUsed);
          }
          for (const v of message.events) {
            exports2.Event.encode(v, writer.uint32(58).fork()).ldelim();
          }
          if (message.codespace !== "") {
            writer.uint32(66).string(message.codespace);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseResponseDeliverTx);
          message.events = [];
          message.data = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.code = reader.uint32();
                break;
              case 2:
                message.data = reader.bytes();
                break;
              case 3:
                message.log = reader.string();
                break;
              case 4:
                message.info = reader.string();
                break;
              case 5:
                message.gasWanted = reader.int64();
                break;
              case 6:
                message.gasUsed = reader.int64();
                break;
              case 7:
                message.events.push(exports2.Event.decode(reader, reader.uint32()));
                break;
              case 8:
                message.codespace = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseResponseDeliverTx);
          message.code = object.code !== void 0 && object.code !== null ? Number(object.code) : 0;
          message.data = object.data !== void 0 && object.data !== null ? bytesFromBase64(object.data) : new Uint8Array();
          message.log = object.log !== void 0 && object.log !== null ? String(object.log) : "";
          message.info = object.info !== void 0 && object.info !== null ? String(object.info) : "";
          message.gasWanted = object.gas_wanted !== void 0 && object.gas_wanted !== null ? long_1.default.fromString(object.gas_wanted) : long_1.default.ZERO;
          message.gasUsed = object.gas_used !== void 0 && object.gas_used !== null ? long_1.default.fromString(object.gas_used) : long_1.default.ZERO;
          message.events = ((_a = object.events) !== null && _a !== void 0 ? _a : []).map((e) => exports2.Event.fromJSON(e));
          message.codespace = object.codespace !== void 0 && object.codespace !== null ? String(object.codespace) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.code !== void 0 && (obj.code = message.code);
          message.data !== void 0 && (obj.data = base64FromBytes(message.data !== void 0 ? message.data : new Uint8Array()));
          message.log !== void 0 && (obj.log = message.log);
          message.info !== void 0 && (obj.info = message.info);
          message.gasWanted !== void 0 && (obj.gas_wanted = (message.gasWanted || long_1.default.ZERO).toString());
          message.gasUsed !== void 0 && (obj.gas_used = (message.gasUsed || long_1.default.ZERO).toString());
          if (message.events) {
            obj.events = message.events.map((e) => e ? exports2.Event.toJSON(e) : void 0);
          } else {
            obj.events = [];
          }
          message.codespace !== void 0 && (obj.codespace = message.codespace);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c, _d, _e, _f;
          const message = Object.assign({}, baseResponseDeliverTx);
          message.code = (_a = object.code) !== null && _a !== void 0 ? _a : 0;
          message.data = (_b = object.data) !== null && _b !== void 0 ? _b : new Uint8Array();
          message.log = (_c = object.log) !== null && _c !== void 0 ? _c : "";
          message.info = (_d = object.info) !== null && _d !== void 0 ? _d : "";
          message.gasWanted = object.gasWanted !== void 0 && object.gasWanted !== null ? long_1.default.fromValue(object.gasWanted) : long_1.default.ZERO;
          message.gasUsed = object.gasUsed !== void 0 && object.gasUsed !== null ? long_1.default.fromValue(object.gasUsed) : long_1.default.ZERO;
          message.events = ((_e = object.events) === null || _e === void 0 ? void 0 : _e.map((e) => exports2.Event.fromPartial(e))) || [];
          message.codespace = (_f = object.codespace) !== null && _f !== void 0 ? _f : "";
          return message;
        }
      };
      var baseResponseEndBlock = {};
      exports2.ResponseEndBlock = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.validatorUpdates) {
            exports2.ValidatorUpdate.encode(v, writer.uint32(10).fork()).ldelim();
          }
          if (message.consensusParamUpdates !== void 0) {
            exports2.ConsensusParams.encode(message.consensusParamUpdates, writer.uint32(18).fork()).ldelim();
          }
          for (const v of message.events) {
            exports2.Event.encode(v, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseResponseEndBlock);
          message.validatorUpdates = [];
          message.events = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.validatorUpdates.push(exports2.ValidatorUpdate.decode(reader, reader.uint32()));
                break;
              case 2:
                message.consensusParamUpdates = exports2.ConsensusParams.decode(reader, reader.uint32());
                break;
              case 3:
                message.events.push(exports2.Event.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a, _b;
          const message = Object.assign({}, baseResponseEndBlock);
          message.validatorUpdates = ((_a = object.validatorUpdates) !== null && _a !== void 0 ? _a : []).map((e) => exports2.ValidatorUpdate.fromJSON(e));
          message.consensusParamUpdates = object.consensusParamUpdates !== void 0 && object.consensusParamUpdates !== null ? exports2.ConsensusParams.fromJSON(object.consensusParamUpdates) : void 0;
          message.events = ((_b = object.events) !== null && _b !== void 0 ? _b : []).map((e) => exports2.Event.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.validatorUpdates) {
            obj.validatorUpdates = message.validatorUpdates.map((e) => e ? exports2.ValidatorUpdate.toJSON(e) : void 0);
          } else {
            obj.validatorUpdates = [];
          }
          message.consensusParamUpdates !== void 0 && (obj.consensusParamUpdates = message.consensusParamUpdates ? exports2.ConsensusParams.toJSON(message.consensusParamUpdates) : void 0);
          if (message.events) {
            obj.events = message.events.map((e) => e ? exports2.Event.toJSON(e) : void 0);
          } else {
            obj.events = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseResponseEndBlock);
          message.validatorUpdates = ((_a = object.validatorUpdates) === null || _a === void 0 ? void 0 : _a.map((e) => exports2.ValidatorUpdate.fromPartial(e))) || [];
          message.consensusParamUpdates = object.consensusParamUpdates !== void 0 && object.consensusParamUpdates !== null ? exports2.ConsensusParams.fromPartial(object.consensusParamUpdates) : void 0;
          message.events = ((_b = object.events) === null || _b === void 0 ? void 0 : _b.map((e) => exports2.Event.fromPartial(e))) || [];
          return message;
        }
      };
      var baseResponseCommit = { retainHeight: long_1.default.ZERO };
      exports2.ResponseCommit = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.data.length !== 0) {
            writer.uint32(18).bytes(message.data);
          }
          if (!message.retainHeight.isZero()) {
            writer.uint32(24).int64(message.retainHeight);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseResponseCommit);
          message.data = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 2:
                message.data = reader.bytes();
                break;
              case 3:
                message.retainHeight = reader.int64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseResponseCommit);
          message.data = object.data !== void 0 && object.data !== null ? bytesFromBase64(object.data) : new Uint8Array();
          message.retainHeight = object.retainHeight !== void 0 && object.retainHeight !== null ? long_1.default.fromString(object.retainHeight) : long_1.default.ZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.data !== void 0 && (obj.data = base64FromBytes(message.data !== void 0 ? message.data : new Uint8Array()));
          message.retainHeight !== void 0 && (obj.retainHeight = (message.retainHeight || long_1.default.ZERO).toString());
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseResponseCommit);
          message.data = (_a = object.data) !== null && _a !== void 0 ? _a : new Uint8Array();
          message.retainHeight = object.retainHeight !== void 0 && object.retainHeight !== null ? long_1.default.fromValue(object.retainHeight) : long_1.default.ZERO;
          return message;
        }
      };
      var baseResponseListSnapshots = {};
      exports2.ResponseListSnapshots = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.snapshots) {
            exports2.Snapshot.encode(v, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseResponseListSnapshots);
          message.snapshots = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.snapshots.push(exports2.Snapshot.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseResponseListSnapshots);
          message.snapshots = ((_a = object.snapshots) !== null && _a !== void 0 ? _a : []).map((e) => exports2.Snapshot.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.snapshots) {
            obj.snapshots = message.snapshots.map((e) => e ? exports2.Snapshot.toJSON(e) : void 0);
          } else {
            obj.snapshots = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseResponseListSnapshots);
          message.snapshots = ((_a = object.snapshots) === null || _a === void 0 ? void 0 : _a.map((e) => exports2.Snapshot.fromPartial(e))) || [];
          return message;
        }
      };
      var baseResponseOfferSnapshot = { result: 0 };
      exports2.ResponseOfferSnapshot = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.result !== 0) {
            writer.uint32(8).int32(message.result);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseResponseOfferSnapshot);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.result = reader.int32();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseResponseOfferSnapshot);
          message.result = object.result !== void 0 && object.result !== null ? responseOfferSnapshot_ResultFromJSON(object.result) : 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.result !== void 0 && (obj.result = responseOfferSnapshot_ResultToJSON(message.result));
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseResponseOfferSnapshot);
          message.result = (_a = object.result) !== null && _a !== void 0 ? _a : 0;
          return message;
        }
      };
      var baseResponseLoadSnapshotChunk = {};
      exports2.ResponseLoadSnapshotChunk = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.chunk.length !== 0) {
            writer.uint32(10).bytes(message.chunk);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseResponseLoadSnapshotChunk);
          message.chunk = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.chunk = reader.bytes();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseResponseLoadSnapshotChunk);
          message.chunk = object.chunk !== void 0 && object.chunk !== null ? bytesFromBase64(object.chunk) : new Uint8Array();
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.chunk !== void 0 && (obj.chunk = base64FromBytes(message.chunk !== void 0 ? message.chunk : new Uint8Array()));
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseResponseLoadSnapshotChunk);
          message.chunk = (_a = object.chunk) !== null && _a !== void 0 ? _a : new Uint8Array();
          return message;
        }
      };
      var baseResponseApplySnapshotChunk = { result: 0, refetchChunks: 0, rejectSenders: "" };
      exports2.ResponseApplySnapshotChunk = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.result !== 0) {
            writer.uint32(8).int32(message.result);
          }
          writer.uint32(18).fork();
          for (const v of message.refetchChunks) {
            writer.uint32(v);
          }
          writer.ldelim();
          for (const v of message.rejectSenders) {
            writer.uint32(26).string(v);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseResponseApplySnapshotChunk);
          message.refetchChunks = [];
          message.rejectSenders = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.result = reader.int32();
                break;
              case 2:
                if ((tag & 7) === 2) {
                  const end2 = reader.uint32() + reader.pos;
                  while (reader.pos < end2) {
                    message.refetchChunks.push(reader.uint32());
                  }
                } else {
                  message.refetchChunks.push(reader.uint32());
                }
                break;
              case 3:
                message.rejectSenders.push(reader.string());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a, _b;
          const message = Object.assign({}, baseResponseApplySnapshotChunk);
          message.result = object.result !== void 0 && object.result !== null ? responseApplySnapshotChunk_ResultFromJSON(object.result) : 0;
          message.refetchChunks = ((_a = object.refetchChunks) !== null && _a !== void 0 ? _a : []).map((e) => Number(e));
          message.rejectSenders = ((_b = object.rejectSenders) !== null && _b !== void 0 ? _b : []).map((e) => String(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.result !== void 0 && (obj.result = responseApplySnapshotChunk_ResultToJSON(message.result));
          if (message.refetchChunks) {
            obj.refetchChunks = message.refetchChunks.map((e) => e);
          } else {
            obj.refetchChunks = [];
          }
          if (message.rejectSenders) {
            obj.rejectSenders = message.rejectSenders.map((e) => e);
          } else {
            obj.rejectSenders = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseResponseApplySnapshotChunk);
          message.result = (_a = object.result) !== null && _a !== void 0 ? _a : 0;
          message.refetchChunks = ((_b = object.refetchChunks) === null || _b === void 0 ? void 0 : _b.map((e) => e)) || [];
          message.rejectSenders = ((_c = object.rejectSenders) === null || _c === void 0 ? void 0 : _c.map((e) => e)) || [];
          return message;
        }
      };
      var baseConsensusParams = {};
      exports2.ConsensusParams = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.block !== void 0) {
            exports2.BlockParams.encode(message.block, writer.uint32(10).fork()).ldelim();
          }
          if (message.evidence !== void 0) {
            params_1.EvidenceParams.encode(message.evidence, writer.uint32(18).fork()).ldelim();
          }
          if (message.validator !== void 0) {
            params_1.ValidatorParams.encode(message.validator, writer.uint32(26).fork()).ldelim();
          }
          if (message.version !== void 0) {
            params_1.VersionParams.encode(message.version, writer.uint32(34).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseConsensusParams);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.block = exports2.BlockParams.decode(reader, reader.uint32());
                break;
              case 2:
                message.evidence = params_1.EvidenceParams.decode(reader, reader.uint32());
                break;
              case 3:
                message.validator = params_1.ValidatorParams.decode(reader, reader.uint32());
                break;
              case 4:
                message.version = params_1.VersionParams.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseConsensusParams);
          message.block = object.block !== void 0 && object.block !== null ? exports2.BlockParams.fromJSON(object.block) : void 0;
          message.evidence = object.evidence !== void 0 && object.evidence !== null ? params_1.EvidenceParams.fromJSON(object.evidence) : void 0;
          message.validator = object.validator !== void 0 && object.validator !== null ? params_1.ValidatorParams.fromJSON(object.validator) : void 0;
          message.version = object.version !== void 0 && object.version !== null ? params_1.VersionParams.fromJSON(object.version) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.block !== void 0 && (obj.block = message.block ? exports2.BlockParams.toJSON(message.block) : void 0);
          message.evidence !== void 0 && (obj.evidence = message.evidence ? params_1.EvidenceParams.toJSON(message.evidence) : void 0);
          message.validator !== void 0 && (obj.validator = message.validator ? params_1.ValidatorParams.toJSON(message.validator) : void 0);
          message.version !== void 0 && (obj.version = message.version ? params_1.VersionParams.toJSON(message.version) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseConsensusParams);
          message.block = object.block !== void 0 && object.block !== null ? exports2.BlockParams.fromPartial(object.block) : void 0;
          message.evidence = object.evidence !== void 0 && object.evidence !== null ? params_1.EvidenceParams.fromPartial(object.evidence) : void 0;
          message.validator = object.validator !== void 0 && object.validator !== null ? params_1.ValidatorParams.fromPartial(object.validator) : void 0;
          message.version = object.version !== void 0 && object.version !== null ? params_1.VersionParams.fromPartial(object.version) : void 0;
          return message;
        }
      };
      var baseBlockParams = { maxBytes: long_1.default.ZERO, maxGas: long_1.default.ZERO };
      exports2.BlockParams = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.maxBytes.isZero()) {
            writer.uint32(8).int64(message.maxBytes);
          }
          if (!message.maxGas.isZero()) {
            writer.uint32(16).int64(message.maxGas);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseBlockParams);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.maxBytes = reader.int64();
                break;
              case 2:
                message.maxGas = reader.int64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseBlockParams);
          message.maxBytes = object.maxBytes !== void 0 && object.maxBytes !== null ? long_1.default.fromString(object.maxBytes) : long_1.default.ZERO;
          message.maxGas = object.maxGas !== void 0 && object.maxGas !== null ? long_1.default.fromString(object.maxGas) : long_1.default.ZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.maxBytes !== void 0 && (obj.maxBytes = (message.maxBytes || long_1.default.ZERO).toString());
          message.maxGas !== void 0 && (obj.maxGas = (message.maxGas || long_1.default.ZERO).toString());
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseBlockParams);
          message.maxBytes = object.maxBytes !== void 0 && object.maxBytes !== null ? long_1.default.fromValue(object.maxBytes) : long_1.default.ZERO;
          message.maxGas = object.maxGas !== void 0 && object.maxGas !== null ? long_1.default.fromValue(object.maxGas) : long_1.default.ZERO;
          return message;
        }
      };
      var baseLastCommitInfo = { round: 0 };
      exports2.LastCommitInfo = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.round !== 0) {
            writer.uint32(8).int32(message.round);
          }
          for (const v of message.votes) {
            exports2.VoteInfo.encode(v, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseLastCommitInfo);
          message.votes = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.round = reader.int32();
                break;
              case 2:
                message.votes.push(exports2.VoteInfo.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseLastCommitInfo);
          message.round = object.round !== void 0 && object.round !== null ? Number(object.round) : 0;
          message.votes = ((_a = object.votes) !== null && _a !== void 0 ? _a : []).map((e) => exports2.VoteInfo.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.round !== void 0 && (obj.round = message.round);
          if (message.votes) {
            obj.votes = message.votes.map((e) => e ? exports2.VoteInfo.toJSON(e) : void 0);
          } else {
            obj.votes = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseLastCommitInfo);
          message.round = (_a = object.round) !== null && _a !== void 0 ? _a : 0;
          message.votes = ((_b = object.votes) === null || _b === void 0 ? void 0 : _b.map((e) => exports2.VoteInfo.fromPartial(e))) || [];
          return message;
        }
      };
      var baseEvent = { type: "" };
      exports2.Event = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.type !== "") {
            writer.uint32(10).string(message.type);
          }
          for (const v of message.attributes) {
            exports2.EventAttribute.encode(v, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseEvent);
          message.attributes = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.type = reader.string();
                break;
              case 2:
                message.attributes.push(exports2.EventAttribute.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseEvent);
          message.type = object.type !== void 0 && object.type !== null ? String(object.type) : "";
          message.attributes = ((_a = object.attributes) !== null && _a !== void 0 ? _a : []).map((e) => exports2.EventAttribute.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.type !== void 0 && (obj.type = message.type);
          if (message.attributes) {
            obj.attributes = message.attributes.map((e) => e ? exports2.EventAttribute.toJSON(e) : void 0);
          } else {
            obj.attributes = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseEvent);
          message.type = (_a = object.type) !== null && _a !== void 0 ? _a : "";
          message.attributes = ((_b = object.attributes) === null || _b === void 0 ? void 0 : _b.map((e) => exports2.EventAttribute.fromPartial(e))) || [];
          return message;
        }
      };
      var baseEventAttribute = { index: false };
      exports2.EventAttribute = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.key.length !== 0) {
            writer.uint32(10).bytes(message.key);
          }
          if (message.value.length !== 0) {
            writer.uint32(18).bytes(message.value);
          }
          if (message.index === true) {
            writer.uint32(24).bool(message.index);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseEventAttribute);
          message.key = new Uint8Array();
          message.value = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.key = reader.bytes();
                break;
              case 2:
                message.value = reader.bytes();
                break;
              case 3:
                message.index = reader.bool();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseEventAttribute);
          message.key = object.key !== void 0 && object.key !== null ? bytesFromBase64(object.key) : new Uint8Array();
          message.value = object.value !== void 0 && object.value !== null ? bytesFromBase64(object.value) : new Uint8Array();
          message.index = object.index !== void 0 && object.index !== null ? Boolean(object.index) : false;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.key !== void 0 && (obj.key = base64FromBytes(message.key !== void 0 ? message.key : new Uint8Array()));
          message.value !== void 0 && (obj.value = base64FromBytes(message.value !== void 0 ? message.value : new Uint8Array()));
          message.index !== void 0 && (obj.index = message.index);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseEventAttribute);
          message.key = (_a = object.key) !== null && _a !== void 0 ? _a : new Uint8Array();
          message.value = (_b = object.value) !== null && _b !== void 0 ? _b : new Uint8Array();
          message.index = (_c = object.index) !== null && _c !== void 0 ? _c : false;
          return message;
        }
      };
      var baseTxResult = { height: long_1.default.ZERO, index: 0 };
      exports2.TxResult = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.height.isZero()) {
            writer.uint32(8).int64(message.height);
          }
          if (message.index !== 0) {
            writer.uint32(16).uint32(message.index);
          }
          if (message.tx.length !== 0) {
            writer.uint32(26).bytes(message.tx);
          }
          if (message.result !== void 0) {
            exports2.ResponseDeliverTx.encode(message.result, writer.uint32(34).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseTxResult);
          message.tx = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.height = reader.int64();
                break;
              case 2:
                message.index = reader.uint32();
                break;
              case 3:
                message.tx = reader.bytes();
                break;
              case 4:
                message.result = exports2.ResponseDeliverTx.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseTxResult);
          message.height = object.height !== void 0 && object.height !== null ? long_1.default.fromString(object.height) : long_1.default.ZERO;
          message.index = object.index !== void 0 && object.index !== null ? Number(object.index) : 0;
          message.tx = object.tx !== void 0 && object.tx !== null ? bytesFromBase64(object.tx) : new Uint8Array();
          message.result = object.result !== void 0 && object.result !== null ? exports2.ResponseDeliverTx.fromJSON(object.result) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.height !== void 0 && (obj.height = (message.height || long_1.default.ZERO).toString());
          message.index !== void 0 && (obj.index = message.index);
          message.tx !== void 0 && (obj.tx = base64FromBytes(message.tx !== void 0 ? message.tx : new Uint8Array()));
          message.result !== void 0 && (obj.result = message.result ? exports2.ResponseDeliverTx.toJSON(message.result) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseTxResult);
          message.height = object.height !== void 0 && object.height !== null ? long_1.default.fromValue(object.height) : long_1.default.ZERO;
          message.index = (_a = object.index) !== null && _a !== void 0 ? _a : 0;
          message.tx = (_b = object.tx) !== null && _b !== void 0 ? _b : new Uint8Array();
          message.result = object.result !== void 0 && object.result !== null ? exports2.ResponseDeliverTx.fromPartial(object.result) : void 0;
          return message;
        }
      };
      var baseValidator = { power: long_1.default.ZERO };
      exports2.Validator = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.address.length !== 0) {
            writer.uint32(10).bytes(message.address);
          }
          if (!message.power.isZero()) {
            writer.uint32(24).int64(message.power);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseValidator);
          message.address = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.address = reader.bytes();
                break;
              case 3:
                message.power = reader.int64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseValidator);
          message.address = object.address !== void 0 && object.address !== null ? bytesFromBase64(object.address) : new Uint8Array();
          message.power = object.power !== void 0 && object.power !== null ? long_1.default.fromString(object.power) : long_1.default.ZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.address !== void 0 && (obj.address = base64FromBytes(message.address !== void 0 ? message.address : new Uint8Array()));
          message.power !== void 0 && (obj.power = (message.power || long_1.default.ZERO).toString());
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseValidator);
          message.address = (_a = object.address) !== null && _a !== void 0 ? _a : new Uint8Array();
          message.power = object.power !== void 0 && object.power !== null ? long_1.default.fromValue(object.power) : long_1.default.ZERO;
          return message;
        }
      };
      var baseValidatorUpdate = { power: long_1.default.ZERO };
      exports2.ValidatorUpdate = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.pubKey !== void 0) {
            keys_1.PublicKey.encode(message.pubKey, writer.uint32(10).fork()).ldelim();
          }
          if (!message.power.isZero()) {
            writer.uint32(16).int64(message.power);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseValidatorUpdate);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.pubKey = keys_1.PublicKey.decode(reader, reader.uint32());
                break;
              case 2:
                message.power = reader.int64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseValidatorUpdate);
          message.pubKey = object.pubKey !== void 0 && object.pubKey !== null ? keys_1.PublicKey.fromJSON(object.pubKey) : void 0;
          message.power = object.power !== void 0 && object.power !== null ? long_1.default.fromString(object.power) : long_1.default.ZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.pubKey !== void 0 && (obj.pubKey = message.pubKey ? keys_1.PublicKey.toJSON(message.pubKey) : void 0);
          message.power !== void 0 && (obj.power = (message.power || long_1.default.ZERO).toString());
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseValidatorUpdate);
          message.pubKey = object.pubKey !== void 0 && object.pubKey !== null ? keys_1.PublicKey.fromPartial(object.pubKey) : void 0;
          message.power = object.power !== void 0 && object.power !== null ? long_1.default.fromValue(object.power) : long_1.default.ZERO;
          return message;
        }
      };
      var baseVoteInfo = { signedLastBlock: false };
      exports2.VoteInfo = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.validator !== void 0) {
            exports2.Validator.encode(message.validator, writer.uint32(10).fork()).ldelim();
          }
          if (message.signedLastBlock === true) {
            writer.uint32(16).bool(message.signedLastBlock);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseVoteInfo);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.validator = exports2.Validator.decode(reader, reader.uint32());
                break;
              case 2:
                message.signedLastBlock = reader.bool();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseVoteInfo);
          message.validator = object.validator !== void 0 && object.validator !== null ? exports2.Validator.fromJSON(object.validator) : void 0;
          message.signedLastBlock = object.signedLastBlock !== void 0 && object.signedLastBlock !== null ? Boolean(object.signedLastBlock) : false;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.validator !== void 0 && (obj.validator = message.validator ? exports2.Validator.toJSON(message.validator) : void 0);
          message.signedLastBlock !== void 0 && (obj.signedLastBlock = message.signedLastBlock);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseVoteInfo);
          message.validator = object.validator !== void 0 && object.validator !== null ? exports2.Validator.fromPartial(object.validator) : void 0;
          message.signedLastBlock = (_a = object.signedLastBlock) !== null && _a !== void 0 ? _a : false;
          return message;
        }
      };
      var baseEvidence = { type: 0, height: long_1.default.ZERO, totalVotingPower: long_1.default.ZERO };
      exports2.Evidence = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.type !== 0) {
            writer.uint32(8).int32(message.type);
          }
          if (message.validator !== void 0) {
            exports2.Validator.encode(message.validator, writer.uint32(18).fork()).ldelim();
          }
          if (!message.height.isZero()) {
            writer.uint32(24).int64(message.height);
          }
          if (message.time !== void 0) {
            timestamp_1.Timestamp.encode(message.time, writer.uint32(34).fork()).ldelim();
          }
          if (!message.totalVotingPower.isZero()) {
            writer.uint32(40).int64(message.totalVotingPower);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseEvidence);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.type = reader.int32();
                break;
              case 2:
                message.validator = exports2.Validator.decode(reader, reader.uint32());
                break;
              case 3:
                message.height = reader.int64();
                break;
              case 4:
                message.time = timestamp_1.Timestamp.decode(reader, reader.uint32());
                break;
              case 5:
                message.totalVotingPower = reader.int64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseEvidence);
          message.type = object.type !== void 0 && object.type !== null ? evidenceTypeFromJSON(object.type) : 0;
          message.validator = object.validator !== void 0 && object.validator !== null ? exports2.Validator.fromJSON(object.validator) : void 0;
          message.height = object.height !== void 0 && object.height !== null ? long_1.default.fromString(object.height) : long_1.default.ZERO;
          message.time = object.time !== void 0 && object.time !== null ? fromJsonTimestamp(object.time) : void 0;
          message.totalVotingPower = object.totalVotingPower !== void 0 && object.totalVotingPower !== null ? long_1.default.fromString(object.totalVotingPower) : long_1.default.ZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.type !== void 0 && (obj.type = evidenceTypeToJSON(message.type));
          message.validator !== void 0 && (obj.validator = message.validator ? exports2.Validator.toJSON(message.validator) : void 0);
          message.height !== void 0 && (obj.height = (message.height || long_1.default.ZERO).toString());
          message.time !== void 0 && (obj.time = fromTimestamp(message.time).toISOString());
          message.totalVotingPower !== void 0 && (obj.totalVotingPower = (message.totalVotingPower || long_1.default.ZERO).toString());
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseEvidence);
          message.type = (_a = object.type) !== null && _a !== void 0 ? _a : 0;
          message.validator = object.validator !== void 0 && object.validator !== null ? exports2.Validator.fromPartial(object.validator) : void 0;
          message.height = object.height !== void 0 && object.height !== null ? long_1.default.fromValue(object.height) : long_1.default.ZERO;
          message.time = object.time !== void 0 && object.time !== null ? timestamp_1.Timestamp.fromPartial(object.time) : void 0;
          message.totalVotingPower = object.totalVotingPower !== void 0 && object.totalVotingPower !== null ? long_1.default.fromValue(object.totalVotingPower) : long_1.default.ZERO;
          return message;
        }
      };
      var baseSnapshot = { height: long_1.default.UZERO, format: 0, chunks: 0 };
      exports2.Snapshot = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.height.isZero()) {
            writer.uint32(8).uint64(message.height);
          }
          if (message.format !== 0) {
            writer.uint32(16).uint32(message.format);
          }
          if (message.chunks !== 0) {
            writer.uint32(24).uint32(message.chunks);
          }
          if (message.hash.length !== 0) {
            writer.uint32(34).bytes(message.hash);
          }
          if (message.metadata.length !== 0) {
            writer.uint32(42).bytes(message.metadata);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseSnapshot);
          message.hash = new Uint8Array();
          message.metadata = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.height = reader.uint64();
                break;
              case 2:
                message.format = reader.uint32();
                break;
              case 3:
                message.chunks = reader.uint32();
                break;
              case 4:
                message.hash = reader.bytes();
                break;
              case 5:
                message.metadata = reader.bytes();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseSnapshot);
          message.height = object.height !== void 0 && object.height !== null ? long_1.default.fromString(object.height) : long_1.default.UZERO;
          message.format = object.format !== void 0 && object.format !== null ? Number(object.format) : 0;
          message.chunks = object.chunks !== void 0 && object.chunks !== null ? Number(object.chunks) : 0;
          message.hash = object.hash !== void 0 && object.hash !== null ? bytesFromBase64(object.hash) : new Uint8Array();
          message.metadata = object.metadata !== void 0 && object.metadata !== null ? bytesFromBase64(object.metadata) : new Uint8Array();
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.height !== void 0 && (obj.height = (message.height || long_1.default.UZERO).toString());
          message.format !== void 0 && (obj.format = message.format);
          message.chunks !== void 0 && (obj.chunks = message.chunks);
          message.hash !== void 0 && (obj.hash = base64FromBytes(message.hash !== void 0 ? message.hash : new Uint8Array()));
          message.metadata !== void 0 && (obj.metadata = base64FromBytes(message.metadata !== void 0 ? message.metadata : new Uint8Array()));
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c, _d;
          const message = Object.assign({}, baseSnapshot);
          message.height = object.height !== void 0 && object.height !== null ? long_1.default.fromValue(object.height) : long_1.default.UZERO;
          message.format = (_a = object.format) !== null && _a !== void 0 ? _a : 0;
          message.chunks = (_b = object.chunks) !== null && _b !== void 0 ? _b : 0;
          message.hash = (_c = object.hash) !== null && _c !== void 0 ? _c : new Uint8Array();
          message.metadata = (_d = object.metadata) !== null && _d !== void 0 ? _d : new Uint8Array();
          return message;
        }
      };
      var ABCIApplicationClientImpl = class {
        constructor(rpc) {
          this.rpc = rpc;
          this.Echo = this.Echo.bind(this);
          this.Flush = this.Flush.bind(this);
          this.Info = this.Info.bind(this);
          this.SetOption = this.SetOption.bind(this);
          this.DeliverTx = this.DeliverTx.bind(this);
          this.CheckTx = this.CheckTx.bind(this);
          this.Query = this.Query.bind(this);
          this.Commit = this.Commit.bind(this);
          this.InitChain = this.InitChain.bind(this);
          this.BeginBlock = this.BeginBlock.bind(this);
          this.EndBlock = this.EndBlock.bind(this);
          this.ListSnapshots = this.ListSnapshots.bind(this);
          this.OfferSnapshot = this.OfferSnapshot.bind(this);
          this.LoadSnapshotChunk = this.LoadSnapshotChunk.bind(this);
          this.ApplySnapshotChunk = this.ApplySnapshotChunk.bind(this);
        }
        Echo(request) {
          const data = exports2.RequestEcho.encode(request).finish();
          const promise = this.rpc.request("tendermint.abci.ABCIApplication", "Echo", data);
          return promise.then((data2) => exports2.ResponseEcho.decode(new minimal_1.default.Reader(data2)));
        }
        Flush(request) {
          const data = exports2.RequestFlush.encode(request).finish();
          const promise = this.rpc.request("tendermint.abci.ABCIApplication", "Flush", data);
          return promise.then((data2) => exports2.ResponseFlush.decode(new minimal_1.default.Reader(data2)));
        }
        Info(request) {
          const data = exports2.RequestInfo.encode(request).finish();
          const promise = this.rpc.request("tendermint.abci.ABCIApplication", "Info", data);
          return promise.then((data2) => exports2.ResponseInfo.decode(new minimal_1.default.Reader(data2)));
        }
        SetOption(request) {
          const data = exports2.RequestSetOption.encode(request).finish();
          const promise = this.rpc.request("tendermint.abci.ABCIApplication", "SetOption", data);
          return promise.then((data2) => exports2.ResponseSetOption.decode(new minimal_1.default.Reader(data2)));
        }
        DeliverTx(request) {
          const data = exports2.RequestDeliverTx.encode(request).finish();
          const promise = this.rpc.request("tendermint.abci.ABCIApplication", "DeliverTx", data);
          return promise.then((data2) => exports2.ResponseDeliverTx.decode(new minimal_1.default.Reader(data2)));
        }
        CheckTx(request) {
          const data = exports2.RequestCheckTx.encode(request).finish();
          const promise = this.rpc.request("tendermint.abci.ABCIApplication", "CheckTx", data);
          return promise.then((data2) => exports2.ResponseCheckTx.decode(new minimal_1.default.Reader(data2)));
        }
        Query(request) {
          const data = exports2.RequestQuery.encode(request).finish();
          const promise = this.rpc.request("tendermint.abci.ABCIApplication", "Query", data);
          return promise.then((data2) => exports2.ResponseQuery.decode(new minimal_1.default.Reader(data2)));
        }
        Commit(request) {
          const data = exports2.RequestCommit.encode(request).finish();
          const promise = this.rpc.request("tendermint.abci.ABCIApplication", "Commit", data);
          return promise.then((data2) => exports2.ResponseCommit.decode(new minimal_1.default.Reader(data2)));
        }
        InitChain(request) {
          const data = exports2.RequestInitChain.encode(request).finish();
          const promise = this.rpc.request("tendermint.abci.ABCIApplication", "InitChain", data);
          return promise.then((data2) => exports2.ResponseInitChain.decode(new minimal_1.default.Reader(data2)));
        }
        BeginBlock(request) {
          const data = exports2.RequestBeginBlock.encode(request).finish();
          const promise = this.rpc.request("tendermint.abci.ABCIApplication", "BeginBlock", data);
          return promise.then((data2) => exports2.ResponseBeginBlock.decode(new minimal_1.default.Reader(data2)));
        }
        EndBlock(request) {
          const data = exports2.RequestEndBlock.encode(request).finish();
          const promise = this.rpc.request("tendermint.abci.ABCIApplication", "EndBlock", data);
          return promise.then((data2) => exports2.ResponseEndBlock.decode(new minimal_1.default.Reader(data2)));
        }
        ListSnapshots(request) {
          const data = exports2.RequestListSnapshots.encode(request).finish();
          const promise = this.rpc.request("tendermint.abci.ABCIApplication", "ListSnapshots", data);
          return promise.then((data2) => exports2.ResponseListSnapshots.decode(new minimal_1.default.Reader(data2)));
        }
        OfferSnapshot(request) {
          const data = exports2.RequestOfferSnapshot.encode(request).finish();
          const promise = this.rpc.request("tendermint.abci.ABCIApplication", "OfferSnapshot", data);
          return promise.then((data2) => exports2.ResponseOfferSnapshot.decode(new minimal_1.default.Reader(data2)));
        }
        LoadSnapshotChunk(request) {
          const data = exports2.RequestLoadSnapshotChunk.encode(request).finish();
          const promise = this.rpc.request("tendermint.abci.ABCIApplication", "LoadSnapshotChunk", data);
          return promise.then((data2) => exports2.ResponseLoadSnapshotChunk.decode(new minimal_1.default.Reader(data2)));
        }
        ApplySnapshotChunk(request) {
          const data = exports2.RequestApplySnapshotChunk.encode(request).finish();
          const promise = this.rpc.request("tendermint.abci.ABCIApplication", "ApplySnapshotChunk", data);
          return promise.then((data2) => exports2.ResponseApplySnapshotChunk.decode(new minimal_1.default.Reader(data2)));
        }
      };
      exports2.ABCIApplicationClientImpl = ABCIApplicationClientImpl;
      var globalThis2 = (() => {
        if (typeof globalThis2 !== "undefined")
          return globalThis2;
        if (typeof self !== "undefined")
          return self;
        if (typeof window !== "undefined")
          return window;
        if (typeof global !== "undefined")
          return global;
        throw "Unable to locate global object";
      })();
      var atob2 = globalThis2.atob || ((b64) => globalThis2.Buffer.from(b64, "base64").toString("binary"));
      function bytesFromBase64(b64) {
        const bin = atob2(b64);
        const arr = new Uint8Array(bin.length);
        for (let i = 0; i < bin.length; ++i) {
          arr[i] = bin.charCodeAt(i);
        }
        return arr;
      }
      var btoa2 = globalThis2.btoa || ((bin) => globalThis2.Buffer.from(bin, "binary").toString("base64"));
      function base64FromBytes(arr) {
        const bin = [];
        for (const byte of arr) {
          bin.push(String.fromCharCode(byte));
        }
        return btoa2(bin.join(""));
      }
      function toTimestamp(date) {
        const seconds = numberToLong(date.getTime() / 1e3);
        const nanos = date.getTime() % 1e3 * 1e6;
        return { seconds, nanos };
      }
      function fromTimestamp(t) {
        let millis = t.seconds.toNumber() * 1e3;
        millis += t.nanos / 1e6;
        return new Date(millis);
      }
      function fromJsonTimestamp(o) {
        if (o instanceof Date) {
          return toTimestamp(o);
        } else if (typeof o === "string") {
          return toTimestamp(new Date(o));
        } else {
          return timestamp_1.Timestamp.fromJSON(o);
        }
      }
      function numberToLong(number) {
        return long_1.default.fromNumber(number);
      }
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/cosmjs-types/cosmos/base/abci/v1beta1/abci.js
  var require_abci = __commonJS({
    "node_modules/cosmjs-types/cosmos/base/abci/v1beta1/abci.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.SearchTxsResult = exports2.TxMsgData = exports2.MsgData = exports2.SimulationResponse = exports2.Result = exports2.GasInfo = exports2.Attribute = exports2.StringEvent = exports2.ABCIMessageLog = exports2.TxResponse = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var any_1 = require_any();
      var types_1 = require_types3();
      exports2.protobufPackage = "cosmos.base.abci.v1beta1";
      var baseTxResponse = {
        height: long_1.default.ZERO,
        txhash: "",
        codespace: "",
        code: 0,
        data: "",
        rawLog: "",
        info: "",
        gasWanted: long_1.default.ZERO,
        gasUsed: long_1.default.ZERO,
        timestamp: ""
      };
      exports2.TxResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.height.isZero()) {
            writer.uint32(8).int64(message.height);
          }
          if (message.txhash !== "") {
            writer.uint32(18).string(message.txhash);
          }
          if (message.codespace !== "") {
            writer.uint32(26).string(message.codespace);
          }
          if (message.code !== 0) {
            writer.uint32(32).uint32(message.code);
          }
          if (message.data !== "") {
            writer.uint32(42).string(message.data);
          }
          if (message.rawLog !== "") {
            writer.uint32(50).string(message.rawLog);
          }
          for (const v of message.logs) {
            exports2.ABCIMessageLog.encode(v, writer.uint32(58).fork()).ldelim();
          }
          if (message.info !== "") {
            writer.uint32(66).string(message.info);
          }
          if (!message.gasWanted.isZero()) {
            writer.uint32(72).int64(message.gasWanted);
          }
          if (!message.gasUsed.isZero()) {
            writer.uint32(80).int64(message.gasUsed);
          }
          if (message.tx !== void 0) {
            any_1.Any.encode(message.tx, writer.uint32(90).fork()).ldelim();
          }
          if (message.timestamp !== "") {
            writer.uint32(98).string(message.timestamp);
          }
          for (const v of message.events) {
            types_1.Event.encode(v, writer.uint32(106).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseTxResponse);
          message.logs = [];
          message.events = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.height = reader.int64();
                break;
              case 2:
                message.txhash = reader.string();
                break;
              case 3:
                message.codespace = reader.string();
                break;
              case 4:
                message.code = reader.uint32();
                break;
              case 5:
                message.data = reader.string();
                break;
              case 6:
                message.rawLog = reader.string();
                break;
              case 7:
                message.logs.push(exports2.ABCIMessageLog.decode(reader, reader.uint32()));
                break;
              case 8:
                message.info = reader.string();
                break;
              case 9:
                message.gasWanted = reader.int64();
                break;
              case 10:
                message.gasUsed = reader.int64();
                break;
              case 11:
                message.tx = any_1.Any.decode(reader, reader.uint32());
                break;
              case 12:
                message.timestamp = reader.string();
                break;
              case 13:
                message.events.push(types_1.Event.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a, _b;
          const message = Object.assign({}, baseTxResponse);
          message.height = object.height !== void 0 && object.height !== null ? long_1.default.fromString(object.height) : long_1.default.ZERO;
          message.txhash = object.txhash !== void 0 && object.txhash !== null ? String(object.txhash) : "";
          message.codespace = object.codespace !== void 0 && object.codespace !== null ? String(object.codespace) : "";
          message.code = object.code !== void 0 && object.code !== null ? Number(object.code) : 0;
          message.data = object.data !== void 0 && object.data !== null ? String(object.data) : "";
          message.rawLog = object.rawLog !== void 0 && object.rawLog !== null ? String(object.rawLog) : "";
          message.logs = ((_a = object.logs) !== null && _a !== void 0 ? _a : []).map((e) => exports2.ABCIMessageLog.fromJSON(e));
          message.info = object.info !== void 0 && object.info !== null ? String(object.info) : "";
          message.gasWanted = object.gasWanted !== void 0 && object.gasWanted !== null ? long_1.default.fromString(object.gasWanted) : long_1.default.ZERO;
          message.gasUsed = object.gasUsed !== void 0 && object.gasUsed !== null ? long_1.default.fromString(object.gasUsed) : long_1.default.ZERO;
          message.tx = object.tx !== void 0 && object.tx !== null ? any_1.Any.fromJSON(object.tx) : void 0;
          message.timestamp = object.timestamp !== void 0 && object.timestamp !== null ? String(object.timestamp) : "";
          message.events = ((_b = object.events) !== null && _b !== void 0 ? _b : []).map((e) => types_1.Event.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.height !== void 0 && (obj.height = (message.height || long_1.default.ZERO).toString());
          message.txhash !== void 0 && (obj.txhash = message.txhash);
          message.codespace !== void 0 && (obj.codespace = message.codespace);
          message.code !== void 0 && (obj.code = message.code);
          message.data !== void 0 && (obj.data = message.data);
          message.rawLog !== void 0 && (obj.rawLog = message.rawLog);
          if (message.logs) {
            obj.logs = message.logs.map((e) => e ? exports2.ABCIMessageLog.toJSON(e) : void 0);
          } else {
            obj.logs = [];
          }
          message.info !== void 0 && (obj.info = message.info);
          message.gasWanted !== void 0 && (obj.gasWanted = (message.gasWanted || long_1.default.ZERO).toString());
          message.gasUsed !== void 0 && (obj.gasUsed = (message.gasUsed || long_1.default.ZERO).toString());
          message.tx !== void 0 && (obj.tx = message.tx ? any_1.Any.toJSON(message.tx) : void 0);
          message.timestamp !== void 0 && (obj.timestamp = message.timestamp);
          if (message.events) {
            obj.events = message.events.map((e) => e ? types_1.Event.toJSON(e) : void 0);
          } else {
            obj.events = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c, _d, _e, _f, _g, _h, _j;
          const message = Object.assign({}, baseTxResponse);
          message.height = object.height !== void 0 && object.height !== null ? long_1.default.fromValue(object.height) : long_1.default.ZERO;
          message.txhash = (_a = object.txhash) !== null && _a !== void 0 ? _a : "";
          message.codespace = (_b = object.codespace) !== null && _b !== void 0 ? _b : "";
          message.code = (_c = object.code) !== null && _c !== void 0 ? _c : 0;
          message.data = (_d = object.data) !== null && _d !== void 0 ? _d : "";
          message.rawLog = (_e = object.rawLog) !== null && _e !== void 0 ? _e : "";
          message.logs = ((_f = object.logs) === null || _f === void 0 ? void 0 : _f.map((e) => exports2.ABCIMessageLog.fromPartial(e))) || [];
          message.info = (_g = object.info) !== null && _g !== void 0 ? _g : "";
          message.gasWanted = object.gasWanted !== void 0 && object.gasWanted !== null ? long_1.default.fromValue(object.gasWanted) : long_1.default.ZERO;
          message.gasUsed = object.gasUsed !== void 0 && object.gasUsed !== null ? long_1.default.fromValue(object.gasUsed) : long_1.default.ZERO;
          message.tx = object.tx !== void 0 && object.tx !== null ? any_1.Any.fromPartial(object.tx) : void 0;
          message.timestamp = (_h = object.timestamp) !== null && _h !== void 0 ? _h : "";
          message.events = ((_j = object.events) === null || _j === void 0 ? void 0 : _j.map((e) => types_1.Event.fromPartial(e))) || [];
          return message;
        }
      };
      var baseABCIMessageLog = { msgIndex: 0, log: "" };
      exports2.ABCIMessageLog = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.msgIndex !== 0) {
            writer.uint32(8).uint32(message.msgIndex);
          }
          if (message.log !== "") {
            writer.uint32(18).string(message.log);
          }
          for (const v of message.events) {
            exports2.StringEvent.encode(v, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseABCIMessageLog);
          message.events = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.msgIndex = reader.uint32();
                break;
              case 2:
                message.log = reader.string();
                break;
              case 3:
                message.events.push(exports2.StringEvent.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseABCIMessageLog);
          message.msgIndex = object.msgIndex !== void 0 && object.msgIndex !== null ? Number(object.msgIndex) : 0;
          message.log = object.log !== void 0 && object.log !== null ? String(object.log) : "";
          message.events = ((_a = object.events) !== null && _a !== void 0 ? _a : []).map((e) => exports2.StringEvent.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.msgIndex !== void 0 && (obj.msgIndex = message.msgIndex);
          message.log !== void 0 && (obj.log = message.log);
          if (message.events) {
            obj.events = message.events.map((e) => e ? exports2.StringEvent.toJSON(e) : void 0);
          } else {
            obj.events = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseABCIMessageLog);
          message.msgIndex = (_a = object.msgIndex) !== null && _a !== void 0 ? _a : 0;
          message.log = (_b = object.log) !== null && _b !== void 0 ? _b : "";
          message.events = ((_c = object.events) === null || _c === void 0 ? void 0 : _c.map((e) => exports2.StringEvent.fromPartial(e))) || [];
          return message;
        }
      };
      var baseStringEvent = { type: "" };
      exports2.StringEvent = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.type !== "") {
            writer.uint32(10).string(message.type);
          }
          for (const v of message.attributes) {
            exports2.Attribute.encode(v, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseStringEvent);
          message.attributes = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.type = reader.string();
                break;
              case 2:
                message.attributes.push(exports2.Attribute.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseStringEvent);
          message.type = object.type !== void 0 && object.type !== null ? String(object.type) : "";
          message.attributes = ((_a = object.attributes) !== null && _a !== void 0 ? _a : []).map((e) => exports2.Attribute.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.type !== void 0 && (obj.type = message.type);
          if (message.attributes) {
            obj.attributes = message.attributes.map((e) => e ? exports2.Attribute.toJSON(e) : void 0);
          } else {
            obj.attributes = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseStringEvent);
          message.type = (_a = object.type) !== null && _a !== void 0 ? _a : "";
          message.attributes = ((_b = object.attributes) === null || _b === void 0 ? void 0 : _b.map((e) => exports2.Attribute.fromPartial(e))) || [];
          return message;
        }
      };
      var baseAttribute = { key: "", value: "" };
      exports2.Attribute = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.key !== "") {
            writer.uint32(10).string(message.key);
          }
          if (message.value !== "") {
            writer.uint32(18).string(message.value);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseAttribute);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.key = reader.string();
                break;
              case 2:
                message.value = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseAttribute);
          message.key = object.key !== void 0 && object.key !== null ? String(object.key) : "";
          message.value = object.value !== void 0 && object.value !== null ? String(object.value) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.key !== void 0 && (obj.key = message.key);
          message.value !== void 0 && (obj.value = message.value);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseAttribute);
          message.key = (_a = object.key) !== null && _a !== void 0 ? _a : "";
          message.value = (_b = object.value) !== null && _b !== void 0 ? _b : "";
          return message;
        }
      };
      var baseGasInfo = { gasWanted: long_1.default.UZERO, gasUsed: long_1.default.UZERO };
      exports2.GasInfo = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.gasWanted.isZero()) {
            writer.uint32(8).uint64(message.gasWanted);
          }
          if (!message.gasUsed.isZero()) {
            writer.uint32(16).uint64(message.gasUsed);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseGasInfo);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.gasWanted = reader.uint64();
                break;
              case 2:
                message.gasUsed = reader.uint64();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseGasInfo);
          message.gasWanted = object.gasWanted !== void 0 && object.gasWanted !== null ? long_1.default.fromString(object.gasWanted) : long_1.default.UZERO;
          message.gasUsed = object.gasUsed !== void 0 && object.gasUsed !== null ? long_1.default.fromString(object.gasUsed) : long_1.default.UZERO;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.gasWanted !== void 0 && (obj.gasWanted = (message.gasWanted || long_1.default.UZERO).toString());
          message.gasUsed !== void 0 && (obj.gasUsed = (message.gasUsed || long_1.default.UZERO).toString());
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseGasInfo);
          message.gasWanted = object.gasWanted !== void 0 && object.gasWanted !== null ? long_1.default.fromValue(object.gasWanted) : long_1.default.UZERO;
          message.gasUsed = object.gasUsed !== void 0 && object.gasUsed !== null ? long_1.default.fromValue(object.gasUsed) : long_1.default.UZERO;
          return message;
        }
      };
      var baseResult = { log: "" };
      exports2.Result = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.data.length !== 0) {
            writer.uint32(10).bytes(message.data);
          }
          if (message.log !== "") {
            writer.uint32(18).string(message.log);
          }
          for (const v of message.events) {
            types_1.Event.encode(v, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseResult);
          message.events = [];
          message.data = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.data = reader.bytes();
                break;
              case 2:
                message.log = reader.string();
                break;
              case 3:
                message.events.push(types_1.Event.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseResult);
          message.data = object.data !== void 0 && object.data !== null ? bytesFromBase64(object.data) : new Uint8Array();
          message.log = object.log !== void 0 && object.log !== null ? String(object.log) : "";
          message.events = ((_a = object.events) !== null && _a !== void 0 ? _a : []).map((e) => types_1.Event.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.data !== void 0 && (obj.data = base64FromBytes(message.data !== void 0 ? message.data : new Uint8Array()));
          message.log !== void 0 && (obj.log = message.log);
          if (message.events) {
            obj.events = message.events.map((e) => e ? types_1.Event.toJSON(e) : void 0);
          } else {
            obj.events = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c;
          const message = Object.assign({}, baseResult);
          message.data = (_a = object.data) !== null && _a !== void 0 ? _a : new Uint8Array();
          message.log = (_b = object.log) !== null && _b !== void 0 ? _b : "";
          message.events = ((_c = object.events) === null || _c === void 0 ? void 0 : _c.map((e) => types_1.Event.fromPartial(e))) || [];
          return message;
        }
      };
      var baseSimulationResponse = {};
      exports2.SimulationResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.gasInfo !== void 0) {
            exports2.GasInfo.encode(message.gasInfo, writer.uint32(10).fork()).ldelim();
          }
          if (message.result !== void 0) {
            exports2.Result.encode(message.result, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseSimulationResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.gasInfo = exports2.GasInfo.decode(reader, reader.uint32());
                break;
              case 2:
                message.result = exports2.Result.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseSimulationResponse);
          message.gasInfo = object.gasInfo !== void 0 && object.gasInfo !== null ? exports2.GasInfo.fromJSON(object.gasInfo) : void 0;
          message.result = object.result !== void 0 && object.result !== null ? exports2.Result.fromJSON(object.result) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.gasInfo !== void 0 && (obj.gasInfo = message.gasInfo ? exports2.GasInfo.toJSON(message.gasInfo) : void 0);
          message.result !== void 0 && (obj.result = message.result ? exports2.Result.toJSON(message.result) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseSimulationResponse);
          message.gasInfo = object.gasInfo !== void 0 && object.gasInfo !== null ? exports2.GasInfo.fromPartial(object.gasInfo) : void 0;
          message.result = object.result !== void 0 && object.result !== null ? exports2.Result.fromPartial(object.result) : void 0;
          return message;
        }
      };
      var baseMsgData = { msgType: "" };
      exports2.MsgData = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.msgType !== "") {
            writer.uint32(10).string(message.msgType);
          }
          if (message.data.length !== 0) {
            writer.uint32(18).bytes(message.data);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgData);
          message.data = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.msgType = reader.string();
                break;
              case 2:
                message.data = reader.bytes();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseMsgData);
          message.msgType = object.msgType !== void 0 && object.msgType !== null ? String(object.msgType) : "";
          message.data = object.data !== void 0 && object.data !== null ? bytesFromBase64(object.data) : new Uint8Array();
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.msgType !== void 0 && (obj.msgType = message.msgType);
          message.data !== void 0 && (obj.data = base64FromBytes(message.data !== void 0 ? message.data : new Uint8Array()));
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseMsgData);
          message.msgType = (_a = object.msgType) !== null && _a !== void 0 ? _a : "";
          message.data = (_b = object.data) !== null && _b !== void 0 ? _b : new Uint8Array();
          return message;
        }
      };
      var baseTxMsgData = {};
      exports2.TxMsgData = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.data) {
            exports2.MsgData.encode(v, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseTxMsgData);
          message.data = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.data.push(exports2.MsgData.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseTxMsgData);
          message.data = ((_a = object.data) !== null && _a !== void 0 ? _a : []).map((e) => exports2.MsgData.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.data) {
            obj.data = message.data.map((e) => e ? exports2.MsgData.toJSON(e) : void 0);
          } else {
            obj.data = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseTxMsgData);
          message.data = ((_a = object.data) === null || _a === void 0 ? void 0 : _a.map((e) => exports2.MsgData.fromPartial(e))) || [];
          return message;
        }
      };
      var baseSearchTxsResult = {
        totalCount: long_1.default.UZERO,
        count: long_1.default.UZERO,
        pageNumber: long_1.default.UZERO,
        pageTotal: long_1.default.UZERO,
        limit: long_1.default.UZERO
      };
      exports2.SearchTxsResult = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (!message.totalCount.isZero()) {
            writer.uint32(8).uint64(message.totalCount);
          }
          if (!message.count.isZero()) {
            writer.uint32(16).uint64(message.count);
          }
          if (!message.pageNumber.isZero()) {
            writer.uint32(24).uint64(message.pageNumber);
          }
          if (!message.pageTotal.isZero()) {
            writer.uint32(32).uint64(message.pageTotal);
          }
          if (!message.limit.isZero()) {
            writer.uint32(40).uint64(message.limit);
          }
          for (const v of message.txs) {
            exports2.TxResponse.encode(v, writer.uint32(50).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseSearchTxsResult);
          message.txs = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.totalCount = reader.uint64();
                break;
              case 2:
                message.count = reader.uint64();
                break;
              case 3:
                message.pageNumber = reader.uint64();
                break;
              case 4:
                message.pageTotal = reader.uint64();
                break;
              case 5:
                message.limit = reader.uint64();
                break;
              case 6:
                message.txs.push(exports2.TxResponse.decode(reader, reader.uint32()));
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseSearchTxsResult);
          message.totalCount = object.totalCount !== void 0 && object.totalCount !== null ? long_1.default.fromString(object.totalCount) : long_1.default.UZERO;
          message.count = object.count !== void 0 && object.count !== null ? long_1.default.fromString(object.count) : long_1.default.UZERO;
          message.pageNumber = object.pageNumber !== void 0 && object.pageNumber !== null ? long_1.default.fromString(object.pageNumber) : long_1.default.UZERO;
          message.pageTotal = object.pageTotal !== void 0 && object.pageTotal !== null ? long_1.default.fromString(object.pageTotal) : long_1.default.UZERO;
          message.limit = object.limit !== void 0 && object.limit !== null ? long_1.default.fromString(object.limit) : long_1.default.UZERO;
          message.txs = ((_a = object.txs) !== null && _a !== void 0 ? _a : []).map((e) => exports2.TxResponse.fromJSON(e));
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.totalCount !== void 0 && (obj.totalCount = (message.totalCount || long_1.default.UZERO).toString());
          message.count !== void 0 && (obj.count = (message.count || long_1.default.UZERO).toString());
          message.pageNumber !== void 0 && (obj.pageNumber = (message.pageNumber || long_1.default.UZERO).toString());
          message.pageTotal !== void 0 && (obj.pageTotal = (message.pageTotal || long_1.default.UZERO).toString());
          message.limit !== void 0 && (obj.limit = (message.limit || long_1.default.UZERO).toString());
          if (message.txs) {
            obj.txs = message.txs.map((e) => e ? exports2.TxResponse.toJSON(e) : void 0);
          } else {
            obj.txs = [];
          }
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseSearchTxsResult);
          message.totalCount = object.totalCount !== void 0 && object.totalCount !== null ? long_1.default.fromValue(object.totalCount) : long_1.default.UZERO;
          message.count = object.count !== void 0 && object.count !== null ? long_1.default.fromValue(object.count) : long_1.default.UZERO;
          message.pageNumber = object.pageNumber !== void 0 && object.pageNumber !== null ? long_1.default.fromValue(object.pageNumber) : long_1.default.UZERO;
          message.pageTotal = object.pageTotal !== void 0 && object.pageTotal !== null ? long_1.default.fromValue(object.pageTotal) : long_1.default.UZERO;
          message.limit = object.limit !== void 0 && object.limit !== null ? long_1.default.fromValue(object.limit) : long_1.default.UZERO;
          message.txs = ((_a = object.txs) === null || _a === void 0 ? void 0 : _a.map((e) => exports2.TxResponse.fromPartial(e))) || [];
          return message;
        }
      };
      var globalThis2 = (() => {
        if (typeof globalThis2 !== "undefined")
          return globalThis2;
        if (typeof self !== "undefined")
          return self;
        if (typeof window !== "undefined")
          return window;
        if (typeof global !== "undefined")
          return global;
        throw "Unable to locate global object";
      })();
      var atob2 = globalThis2.atob || ((b64) => globalThis2.Buffer.from(b64, "base64").toString("binary"));
      function bytesFromBase64(b64) {
        const bin = atob2(b64);
        const arr = new Uint8Array(bin.length);
        for (let i = 0; i < bin.length; ++i) {
          arr[i] = bin.charCodeAt(i);
        }
        return arr;
      }
      var btoa2 = globalThis2.btoa || ((bin) => globalThis2.Buffer.from(bin, "binary").toString("base64"));
      function base64FromBytes(arr) {
        const bin = [];
        for (const byte of arr) {
          bin.push(String.fromCharCode(byte));
        }
        return btoa2(bin.join(""));
      }
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/cosmjs-types/cosmos/tx/v1beta1/service.js
  var require_service3 = __commonJS({
    "node_modules/cosmjs-types/cosmos/tx/v1beta1/service.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.ServiceClientImpl = exports2.GetTxResponse = exports2.GetTxRequest = exports2.SimulateResponse = exports2.SimulateRequest = exports2.BroadcastTxResponse = exports2.BroadcastTxRequest = exports2.GetTxsEventResponse = exports2.GetTxsEventRequest = exports2.broadcastModeToJSON = exports2.broadcastModeFromJSON = exports2.BroadcastMode = exports2.orderByToJSON = exports2.orderByFromJSON = exports2.OrderBy = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var pagination_1 = require_pagination();
      var abci_1 = require_abci();
      var tx_1 = require_tx();
      exports2.protobufPackage = "cosmos.tx.v1beta1";
      var OrderBy;
      (function(OrderBy2) {
        OrderBy2[OrderBy2["ORDER_BY_UNSPECIFIED"] = 0] = "ORDER_BY_UNSPECIFIED";
        OrderBy2[OrderBy2["ORDER_BY_ASC"] = 1] = "ORDER_BY_ASC";
        OrderBy2[OrderBy2["ORDER_BY_DESC"] = 2] = "ORDER_BY_DESC";
        OrderBy2[OrderBy2["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
      })(OrderBy = exports2.OrderBy || (exports2.OrderBy = {}));
      function orderByFromJSON(object) {
        switch (object) {
          case 0:
          case "ORDER_BY_UNSPECIFIED":
            return OrderBy.ORDER_BY_UNSPECIFIED;
          case 1:
          case "ORDER_BY_ASC":
            return OrderBy.ORDER_BY_ASC;
          case 2:
          case "ORDER_BY_DESC":
            return OrderBy.ORDER_BY_DESC;
          case -1:
          case "UNRECOGNIZED":
          default:
            return OrderBy.UNRECOGNIZED;
        }
      }
      exports2.orderByFromJSON = orderByFromJSON;
      function orderByToJSON(object) {
        switch (object) {
          case OrderBy.ORDER_BY_UNSPECIFIED:
            return "ORDER_BY_UNSPECIFIED";
          case OrderBy.ORDER_BY_ASC:
            return "ORDER_BY_ASC";
          case OrderBy.ORDER_BY_DESC:
            return "ORDER_BY_DESC";
          default:
            return "UNKNOWN";
        }
      }
      exports2.orderByToJSON = orderByToJSON;
      var BroadcastMode;
      (function(BroadcastMode2) {
        BroadcastMode2[BroadcastMode2["BROADCAST_MODE_UNSPECIFIED"] = 0] = "BROADCAST_MODE_UNSPECIFIED";
        BroadcastMode2[BroadcastMode2["BROADCAST_MODE_BLOCK"] = 1] = "BROADCAST_MODE_BLOCK";
        BroadcastMode2[BroadcastMode2["BROADCAST_MODE_SYNC"] = 2] = "BROADCAST_MODE_SYNC";
        BroadcastMode2[BroadcastMode2["BROADCAST_MODE_ASYNC"] = 3] = "BROADCAST_MODE_ASYNC";
        BroadcastMode2[BroadcastMode2["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
      })(BroadcastMode = exports2.BroadcastMode || (exports2.BroadcastMode = {}));
      function broadcastModeFromJSON(object) {
        switch (object) {
          case 0:
          case "BROADCAST_MODE_UNSPECIFIED":
            return BroadcastMode.BROADCAST_MODE_UNSPECIFIED;
          case 1:
          case "BROADCAST_MODE_BLOCK":
            return BroadcastMode.BROADCAST_MODE_BLOCK;
          case 2:
          case "BROADCAST_MODE_SYNC":
            return BroadcastMode.BROADCAST_MODE_SYNC;
          case 3:
          case "BROADCAST_MODE_ASYNC":
            return BroadcastMode.BROADCAST_MODE_ASYNC;
          case -1:
          case "UNRECOGNIZED":
          default:
            return BroadcastMode.UNRECOGNIZED;
        }
      }
      exports2.broadcastModeFromJSON = broadcastModeFromJSON;
      function broadcastModeToJSON(object) {
        switch (object) {
          case BroadcastMode.BROADCAST_MODE_UNSPECIFIED:
            return "BROADCAST_MODE_UNSPECIFIED";
          case BroadcastMode.BROADCAST_MODE_BLOCK:
            return "BROADCAST_MODE_BLOCK";
          case BroadcastMode.BROADCAST_MODE_SYNC:
            return "BROADCAST_MODE_SYNC";
          case BroadcastMode.BROADCAST_MODE_ASYNC:
            return "BROADCAST_MODE_ASYNC";
          default:
            return "UNKNOWN";
        }
      }
      exports2.broadcastModeToJSON = broadcastModeToJSON;
      var baseGetTxsEventRequest = { events: "", orderBy: 0 };
      exports2.GetTxsEventRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.events) {
            writer.uint32(10).string(v);
          }
          if (message.pagination !== void 0) {
            pagination_1.PageRequest.encode(message.pagination, writer.uint32(18).fork()).ldelim();
          }
          if (message.orderBy !== 0) {
            writer.uint32(24).int32(message.orderBy);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseGetTxsEventRequest);
          message.events = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.events.push(reader.string());
                break;
              case 2:
                message.pagination = pagination_1.PageRequest.decode(reader, reader.uint32());
                break;
              case 3:
                message.orderBy = reader.int32();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseGetTxsEventRequest);
          message.events = ((_a = object.events) !== null && _a !== void 0 ? _a : []).map((e) => String(e));
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromJSON(object.pagination) : void 0;
          message.orderBy = object.orderBy !== void 0 && object.orderBy !== null ? orderByFromJSON(object.orderBy) : 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.events) {
            obj.events = message.events.map((e) => e);
          } else {
            obj.events = [];
          }
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageRequest.toJSON(message.pagination) : void 0);
          message.orderBy !== void 0 && (obj.orderBy = orderByToJSON(message.orderBy));
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseGetTxsEventRequest);
          message.events = ((_a = object.events) === null || _a === void 0 ? void 0 : _a.map((e) => e)) || [];
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageRequest.fromPartial(object.pagination) : void 0;
          message.orderBy = (_b = object.orderBy) !== null && _b !== void 0 ? _b : 0;
          return message;
        }
      };
      var baseGetTxsEventResponse = {};
      exports2.GetTxsEventResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          for (const v of message.txs) {
            tx_1.Tx.encode(v, writer.uint32(10).fork()).ldelim();
          }
          for (const v of message.txResponses) {
            abci_1.TxResponse.encode(v, writer.uint32(18).fork()).ldelim();
          }
          if (message.pagination !== void 0) {
            pagination_1.PageResponse.encode(message.pagination, writer.uint32(26).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseGetTxsEventResponse);
          message.txs = [];
          message.txResponses = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.txs.push(tx_1.Tx.decode(reader, reader.uint32()));
                break;
              case 2:
                message.txResponses.push(abci_1.TxResponse.decode(reader, reader.uint32()));
                break;
              case 3:
                message.pagination = pagination_1.PageResponse.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a, _b;
          const message = Object.assign({}, baseGetTxsEventResponse);
          message.txs = ((_a = object.txs) !== null && _a !== void 0 ? _a : []).map((e) => tx_1.Tx.fromJSON(e));
          message.txResponses = ((_b = object.txResponses) !== null && _b !== void 0 ? _b : []).map((e) => abci_1.TxResponse.fromJSON(e));
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromJSON(object.pagination) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          if (message.txs) {
            obj.txs = message.txs.map((e) => e ? tx_1.Tx.toJSON(e) : void 0);
          } else {
            obj.txs = [];
          }
          if (message.txResponses) {
            obj.txResponses = message.txResponses.map((e) => e ? abci_1.TxResponse.toJSON(e) : void 0);
          } else {
            obj.txResponses = [];
          }
          message.pagination !== void 0 && (obj.pagination = message.pagination ? pagination_1.PageResponse.toJSON(message.pagination) : void 0);
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseGetTxsEventResponse);
          message.txs = ((_a = object.txs) === null || _a === void 0 ? void 0 : _a.map((e) => tx_1.Tx.fromPartial(e))) || [];
          message.txResponses = ((_b = object.txResponses) === null || _b === void 0 ? void 0 : _b.map((e) => abci_1.TxResponse.fromPartial(e))) || [];
          message.pagination = object.pagination !== void 0 && object.pagination !== null ? pagination_1.PageResponse.fromPartial(object.pagination) : void 0;
          return message;
        }
      };
      var baseBroadcastTxRequest = { mode: 0 };
      exports2.BroadcastTxRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.txBytes.length !== 0) {
            writer.uint32(10).bytes(message.txBytes);
          }
          if (message.mode !== 0) {
            writer.uint32(16).int32(message.mode);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseBroadcastTxRequest);
          message.txBytes = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.txBytes = reader.bytes();
                break;
              case 2:
                message.mode = reader.int32();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseBroadcastTxRequest);
          message.txBytes = object.txBytes !== void 0 && object.txBytes !== null ? bytesFromBase64(object.txBytes) : new Uint8Array();
          message.mode = object.mode !== void 0 && object.mode !== null ? broadcastModeFromJSON(object.mode) : 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.txBytes !== void 0 && (obj.txBytes = base64FromBytes(message.txBytes !== void 0 ? message.txBytes : new Uint8Array()));
          message.mode !== void 0 && (obj.mode = broadcastModeToJSON(message.mode));
          return obj;
        },
        fromPartial(object) {
          var _a, _b;
          const message = Object.assign({}, baseBroadcastTxRequest);
          message.txBytes = (_a = object.txBytes) !== null && _a !== void 0 ? _a : new Uint8Array();
          message.mode = (_b = object.mode) !== null && _b !== void 0 ? _b : 0;
          return message;
        }
      };
      var baseBroadcastTxResponse = {};
      exports2.BroadcastTxResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.txResponse !== void 0) {
            abci_1.TxResponse.encode(message.txResponse, writer.uint32(10).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseBroadcastTxResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.txResponse = abci_1.TxResponse.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseBroadcastTxResponse);
          message.txResponse = object.txResponse !== void 0 && object.txResponse !== null ? abci_1.TxResponse.fromJSON(object.txResponse) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.txResponse !== void 0 && (obj.txResponse = message.txResponse ? abci_1.TxResponse.toJSON(message.txResponse) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseBroadcastTxResponse);
          message.txResponse = object.txResponse !== void 0 && object.txResponse !== null ? abci_1.TxResponse.fromPartial(object.txResponse) : void 0;
          return message;
        }
      };
      var baseSimulateRequest = {};
      exports2.SimulateRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.tx !== void 0) {
            tx_1.Tx.encode(message.tx, writer.uint32(10).fork()).ldelim();
          }
          if (message.txBytes.length !== 0) {
            writer.uint32(18).bytes(message.txBytes);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseSimulateRequest);
          message.txBytes = new Uint8Array();
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.tx = tx_1.Tx.decode(reader, reader.uint32());
                break;
              case 2:
                message.txBytes = reader.bytes();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseSimulateRequest);
          message.tx = object.tx !== void 0 && object.tx !== null ? tx_1.Tx.fromJSON(object.tx) : void 0;
          message.txBytes = object.txBytes !== void 0 && object.txBytes !== null ? bytesFromBase64(object.txBytes) : new Uint8Array();
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.tx !== void 0 && (obj.tx = message.tx ? tx_1.Tx.toJSON(message.tx) : void 0);
          message.txBytes !== void 0 && (obj.txBytes = base64FromBytes(message.txBytes !== void 0 ? message.txBytes : new Uint8Array()));
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseSimulateRequest);
          message.tx = object.tx !== void 0 && object.tx !== null ? tx_1.Tx.fromPartial(object.tx) : void 0;
          message.txBytes = (_a = object.txBytes) !== null && _a !== void 0 ? _a : new Uint8Array();
          return message;
        }
      };
      var baseSimulateResponse = {};
      exports2.SimulateResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.gasInfo !== void 0) {
            abci_1.GasInfo.encode(message.gasInfo, writer.uint32(10).fork()).ldelim();
          }
          if (message.result !== void 0) {
            abci_1.Result.encode(message.result, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseSimulateResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.gasInfo = abci_1.GasInfo.decode(reader, reader.uint32());
                break;
              case 2:
                message.result = abci_1.Result.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseSimulateResponse);
          message.gasInfo = object.gasInfo !== void 0 && object.gasInfo !== null ? abci_1.GasInfo.fromJSON(object.gasInfo) : void 0;
          message.result = object.result !== void 0 && object.result !== null ? abci_1.Result.fromJSON(object.result) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.gasInfo !== void 0 && (obj.gasInfo = message.gasInfo ? abci_1.GasInfo.toJSON(message.gasInfo) : void 0);
          message.result !== void 0 && (obj.result = message.result ? abci_1.Result.toJSON(message.result) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseSimulateResponse);
          message.gasInfo = object.gasInfo !== void 0 && object.gasInfo !== null ? abci_1.GasInfo.fromPartial(object.gasInfo) : void 0;
          message.result = object.result !== void 0 && object.result !== null ? abci_1.Result.fromPartial(object.result) : void 0;
          return message;
        }
      };
      var baseGetTxRequest = { hash: "" };
      exports2.GetTxRequest = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.hash !== "") {
            writer.uint32(10).string(message.hash);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseGetTxRequest);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.hash = reader.string();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseGetTxRequest);
          message.hash = object.hash !== void 0 && object.hash !== null ? String(object.hash) : "";
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.hash !== void 0 && (obj.hash = message.hash);
          return obj;
        },
        fromPartial(object) {
          var _a;
          const message = Object.assign({}, baseGetTxRequest);
          message.hash = (_a = object.hash) !== null && _a !== void 0 ? _a : "";
          return message;
        }
      };
      var baseGetTxResponse = {};
      exports2.GetTxResponse = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.tx !== void 0) {
            tx_1.Tx.encode(message.tx, writer.uint32(10).fork()).ldelim();
          }
          if (message.txResponse !== void 0) {
            abci_1.TxResponse.encode(message.txResponse, writer.uint32(18).fork()).ldelim();
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseGetTxResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.tx = tx_1.Tx.decode(reader, reader.uint32());
                break;
              case 2:
                message.txResponse = abci_1.TxResponse.decode(reader, reader.uint32());
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          const message = Object.assign({}, baseGetTxResponse);
          message.tx = object.tx !== void 0 && object.tx !== null ? tx_1.Tx.fromJSON(object.tx) : void 0;
          message.txResponse = object.txResponse !== void 0 && object.txResponse !== null ? abci_1.TxResponse.fromJSON(object.txResponse) : void 0;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.tx !== void 0 && (obj.tx = message.tx ? tx_1.Tx.toJSON(message.tx) : void 0);
          message.txResponse !== void 0 && (obj.txResponse = message.txResponse ? abci_1.TxResponse.toJSON(message.txResponse) : void 0);
          return obj;
        },
        fromPartial(object) {
          const message = Object.assign({}, baseGetTxResponse);
          message.tx = object.tx !== void 0 && object.tx !== null ? tx_1.Tx.fromPartial(object.tx) : void 0;
          message.txResponse = object.txResponse !== void 0 && object.txResponse !== null ? abci_1.TxResponse.fromPartial(object.txResponse) : void 0;
          return message;
        }
      };
      var ServiceClientImpl = class {
        constructor(rpc) {
          this.rpc = rpc;
          this.Simulate = this.Simulate.bind(this);
          this.GetTx = this.GetTx.bind(this);
          this.BroadcastTx = this.BroadcastTx.bind(this);
          this.GetTxsEvent = this.GetTxsEvent.bind(this);
        }
        Simulate(request) {
          const data = exports2.SimulateRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.tx.v1beta1.Service", "Simulate", data);
          return promise.then((data2) => exports2.SimulateResponse.decode(new minimal_1.default.Reader(data2)));
        }
        GetTx(request) {
          const data = exports2.GetTxRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.tx.v1beta1.Service", "GetTx", data);
          return promise.then((data2) => exports2.GetTxResponse.decode(new minimal_1.default.Reader(data2)));
        }
        BroadcastTx(request) {
          const data = exports2.BroadcastTxRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.tx.v1beta1.Service", "BroadcastTx", data);
          return promise.then((data2) => exports2.BroadcastTxResponse.decode(new minimal_1.default.Reader(data2)));
        }
        GetTxsEvent(request) {
          const data = exports2.GetTxsEventRequest.encode(request).finish();
          const promise = this.rpc.request("cosmos.tx.v1beta1.Service", "GetTxsEvent", data);
          return promise.then((data2) => exports2.GetTxsEventResponse.decode(new minimal_1.default.Reader(data2)));
        }
      };
      exports2.ServiceClientImpl = ServiceClientImpl;
      var globalThis2 = (() => {
        if (typeof globalThis2 !== "undefined")
          return globalThis2;
        if (typeof self !== "undefined")
          return self;
        if (typeof window !== "undefined")
          return window;
        if (typeof global !== "undefined")
          return global;
        throw "Unable to locate global object";
      })();
      var atob2 = globalThis2.atob || ((b64) => globalThis2.Buffer.from(b64, "base64").toString("binary"));
      function bytesFromBase64(b64) {
        const bin = atob2(b64);
        const arr = new Uint8Array(bin.length);
        for (let i = 0; i < bin.length; ++i) {
          arr[i] = bin.charCodeAt(i);
        }
        return arr;
      }
      var btoa2 = globalThis2.btoa || ((bin) => globalThis2.Buffer.from(bin, "binary").toString("base64"));
      function base64FromBytes(arr) {
        const bin = [];
        for (const byte of arr) {
          bin.push(String.fromCharCode(byte));
        }
        return btoa2(bin.join(""));
      }
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/@cosmjs/stargate/build/modules/tx/queries.js
  var require_queries9 = __commonJS({
    "node_modules/@cosmjs/stargate/build/modules/tx/queries.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.setupTxExtension = void 0;
      var proto_signing_1 = require_build6();
      var signing_1 = require_signing();
      var service_1 = require_service3();
      var tx_1 = require_tx();
      var long_1 = __importDefault(require_long());
      var queryclient_1 = require_queryclient2();
      function setupTxExtension(base) {
        const rpc = (0, queryclient_1.createProtobufRpcClient)(base);
        const queryService = new service_1.ServiceClientImpl(rpc);
        return {
          tx: {
            getTx: async (txId) => {
              const request = {
                hash: txId
              };
              const response = await queryService.GetTx(request);
              return response;
            },
            simulate: async (messages, memo, signer, sequence) => {
              const request = service_1.SimulateRequest.fromPartial({
                tx: tx_1.Tx.fromPartial({
                  authInfo: tx_1.AuthInfo.fromPartial({
                    fee: tx_1.Fee.fromPartial({}),
                    signerInfos: [
                      {
                        publicKey: (0, proto_signing_1.encodePubkey)(signer),
                        sequence: long_1.default.fromNumber(sequence, true),
                        modeInfo: { single: { mode: signing_1.SignMode.SIGN_MODE_UNSPECIFIED } }
                      }
                    ]
                  }),
                  body: tx_1.TxBody.fromPartial({
                    messages: Array.from(messages),
                    memo
                  }),
                  signatures: [new Uint8Array()]
                }),
                txBytes: void 0
              });
              const response = await queryService.Simulate(request);
              return response;
            }
          }
        };
      }
      exports2.setupTxExtension = setupTxExtension;
    }
  });

  // node_modules/@cosmjs/stargate/build/modules/vesting/aminomessages.js
  var require_aminomessages11 = __commonJS({
    "node_modules/@cosmjs/stargate/build/modules/vesting/aminomessages.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.createVestingAminoConverters = void 0;
      function createVestingAminoConverters() {
        return {
          "/cosmos.vesting.v1beta1.MsgCreateVestingAccount": "not_supported_by_chain"
        };
      }
      exports2.createVestingAminoConverters = createVestingAminoConverters;
    }
  });

  // node_modules/cosmjs-types/cosmos/vesting/v1beta1/tx.js
  var require_tx12 = __commonJS({
    "node_modules/cosmjs-types/cosmos/vesting/v1beta1/tx.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.MsgClientImpl = exports2.MsgCreateVestingAccountResponse = exports2.MsgCreateVestingAccount = exports2.protobufPackage = void 0;
      var long_1 = __importDefault(require_long());
      var minimal_1 = __importDefault(require_minimal2());
      var coin_1 = require_coin();
      exports2.protobufPackage = "cosmos.vesting.v1beta1";
      var baseMsgCreateVestingAccount = {
        fromAddress: "",
        toAddress: "",
        endTime: long_1.default.ZERO,
        delayed: false
      };
      exports2.MsgCreateVestingAccount = {
        encode(message, writer = minimal_1.default.Writer.create()) {
          if (message.fromAddress !== "") {
            writer.uint32(10).string(message.fromAddress);
          }
          if (message.toAddress !== "") {
            writer.uint32(18).string(message.toAddress);
          }
          for (const v of message.amount) {
            coin_1.Coin.encode(v, writer.uint32(26).fork()).ldelim();
          }
          if (!message.endTime.isZero()) {
            writer.uint32(32).int64(message.endTime);
          }
          if (message.delayed === true) {
            writer.uint32(40).bool(message.delayed);
          }
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgCreateVestingAccount);
          message.amount = [];
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              case 1:
                message.fromAddress = reader.string();
                break;
              case 2:
                message.toAddress = reader.string();
                break;
              case 3:
                message.amount.push(coin_1.Coin.decode(reader, reader.uint32()));
                break;
              case 4:
                message.endTime = reader.int64();
                break;
              case 5:
                message.delayed = reader.bool();
                break;
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(object) {
          var _a;
          const message = Object.assign({}, baseMsgCreateVestingAccount);
          message.fromAddress = object.fromAddress !== void 0 && object.fromAddress !== null ? String(object.fromAddress) : "";
          message.toAddress = object.toAddress !== void 0 && object.toAddress !== null ? String(object.toAddress) : "";
          message.amount = ((_a = object.amount) !== null && _a !== void 0 ? _a : []).map((e) => coin_1.Coin.fromJSON(e));
          message.endTime = object.endTime !== void 0 && object.endTime !== null ? long_1.default.fromString(object.endTime) : long_1.default.ZERO;
          message.delayed = object.delayed !== void 0 && object.delayed !== null ? Boolean(object.delayed) : false;
          return message;
        },
        toJSON(message) {
          const obj = {};
          message.fromAddress !== void 0 && (obj.fromAddress = message.fromAddress);
          message.toAddress !== void 0 && (obj.toAddress = message.toAddress);
          if (message.amount) {
            obj.amount = message.amount.map((e) => e ? coin_1.Coin.toJSON(e) : void 0);
          } else {
            obj.amount = [];
          }
          message.endTime !== void 0 && (obj.endTime = (message.endTime || long_1.default.ZERO).toString());
          message.delayed !== void 0 && (obj.delayed = message.delayed);
          return obj;
        },
        fromPartial(object) {
          var _a, _b, _c, _d;
          const message = Object.assign({}, baseMsgCreateVestingAccount);
          message.fromAddress = (_a = object.fromAddress) !== null && _a !== void 0 ? _a : "";
          message.toAddress = (_b = object.toAddress) !== null && _b !== void 0 ? _b : "";
          message.amount = ((_c = object.amount) === null || _c === void 0 ? void 0 : _c.map((e) => coin_1.Coin.fromPartial(e))) || [];
          message.endTime = object.endTime !== void 0 && object.endTime !== null ? long_1.default.fromValue(object.endTime) : long_1.default.ZERO;
          message.delayed = (_d = object.delayed) !== null && _d !== void 0 ? _d : false;
          return message;
        }
      };
      var baseMsgCreateVestingAccountResponse = {};
      exports2.MsgCreateVestingAccountResponse = {
        encode(_, writer = minimal_1.default.Writer.create()) {
          return writer;
        },
        decode(input, length) {
          const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
          let end = length === void 0 ? reader.len : reader.pos + length;
          const message = Object.assign({}, baseMsgCreateVestingAccountResponse);
          while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
              default:
                reader.skipType(tag & 7);
                break;
            }
          }
          return message;
        },
        fromJSON(_) {
          const message = Object.assign({}, baseMsgCreateVestingAccountResponse);
          return message;
        },
        toJSON(_) {
          const obj = {};
          return obj;
        },
        fromPartial(_) {
          const message = Object.assign({}, baseMsgCreateVestingAccountResponse);
          return message;
        }
      };
      var MsgClientImpl = class {
        constructor(rpc) {
          this.rpc = rpc;
          this.CreateVestingAccount = this.CreateVestingAccount.bind(this);
        }
        CreateVestingAccount(request) {
          const data = exports2.MsgCreateVestingAccount.encode(request).finish();
          const promise = this.rpc.request("cosmos.vesting.v1beta1.Msg", "CreateVestingAccount", data);
          return promise.then((data2) => exports2.MsgCreateVestingAccountResponse.decode(new minimal_1.default.Reader(data2)));
        }
      };
      exports2.MsgClientImpl = MsgClientImpl;
      if (minimal_1.default.util.Long !== long_1.default) {
        minimal_1.default.util.Long = long_1.default;
        minimal_1.default.configure();
      }
    }
  });

  // node_modules/@cosmjs/stargate/build/modules/vesting/messages.js
  var require_messages8 = __commonJS({
    "node_modules/@cosmjs/stargate/build/modules/vesting/messages.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.vestingTypes = void 0;
      var tx_1 = require_tx12();
      exports2.vestingTypes = [
        ["/cosmos.vesting.v1beta1.MsgCreateVestingAccount", tx_1.MsgCreateVestingAccount]
      ];
    }
  });

  // node_modules/@cosmjs/stargate/build/modules/index.js
  var require_modules = __commonJS({
    "node_modules/@cosmjs/stargate/build/modules/index.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.stakingTypes = exports2.isMsgUndelegateEncodeObject = exports2.isMsgDelegateEncodeObject = exports2.isAminoMsgUndelegate = exports2.isAminoMsgEditValidator = exports2.isAminoMsgDelegate = exports2.isAminoMsgCreateValidator = exports2.isAminoMsgBeginRedelegate = exports2.createStakingAminoConverters = exports2.setupSlashingExtension = exports2.isAminoMsgUnjail = exports2.createSlashingAminoConverters = exports2.setupMintExtension = exports2.setupIbcExtension = exports2.isMsgTransferEncodeObject = exports2.ibcTypes = exports2.isAminoMsgTransfer = exports2.createIbcAminoConverters = exports2.setupGovExtension = exports2.isMsgVoteEncodeObject = exports2.isMsgSubmitProposalEncodeObject = exports2.isMsgDepositEncodeObject = exports2.govTypes = exports2.isAminoMsgVote = exports2.isAminoMsgSubmitProposal = exports2.isAminoMsgDeposit = exports2.createGovAminoConverters = exports2.feegrantTypes = exports2.createFreegrantAminoConverters = exports2.isAminoMsgSubmitEvidence = exports2.createEvidenceAminoConverters = exports2.setupDistributionExtension = exports2.isMsgWithdrawDelegatorRewardEncodeObject = exports2.distributionTypes = exports2.isAminoMsgWithdrawValidatorCommission = exports2.isAminoMsgWithdrawDelegatorReward = exports2.isAminoMsgSetWithdrawAddress = exports2.isAminoMsgFundCommunityPool = exports2.createDistributionAminoConverters = exports2.isAminoMsgVerifyInvariant = exports2.createCrysisAminoConverters = exports2.setupBankExtension = exports2.isMsgSendEncodeObject = exports2.bankTypes = exports2.isAminoMsgSend = exports2.isAminoMsgMultiSend = exports2.createBankAminoConverters = exports2.authzTypes = exports2.createAuthzAminoConverters = exports2.setupAuthExtension = void 0;
      exports2.vestingTypes = exports2.createVestingAminoConverters = exports2.setupTxExtension = exports2.setupStakingExtension = void 0;
      var queries_1 = require_queries();
      Object.defineProperty(exports2, "setupAuthExtension", { enumerable: true, get: function() {
        return queries_1.setupAuthExtension;
      } });
      var aminomessages_1 = require_aminomessages();
      Object.defineProperty(exports2, "createAuthzAminoConverters", { enumerable: true, get: function() {
        return aminomessages_1.createAuthzAminoConverters;
      } });
      var messages_1 = require_messages();
      Object.defineProperty(exports2, "authzTypes", { enumerable: true, get: function() {
        return messages_1.authzTypes;
      } });
      var aminomessages_2 = require_aminomessages2();
      Object.defineProperty(exports2, "createBankAminoConverters", { enumerable: true, get: function() {
        return aminomessages_2.createBankAminoConverters;
      } });
      Object.defineProperty(exports2, "isAminoMsgMultiSend", { enumerable: true, get: function() {
        return aminomessages_2.isAminoMsgMultiSend;
      } });
      Object.defineProperty(exports2, "isAminoMsgSend", { enumerable: true, get: function() {
        return aminomessages_2.isAminoMsgSend;
      } });
      var messages_2 = require_messages2();
      Object.defineProperty(exports2, "bankTypes", { enumerable: true, get: function() {
        return messages_2.bankTypes;
      } });
      Object.defineProperty(exports2, "isMsgSendEncodeObject", { enumerable: true, get: function() {
        return messages_2.isMsgSendEncodeObject;
      } });
      var queries_2 = require_queries2();
      Object.defineProperty(exports2, "setupBankExtension", { enumerable: true, get: function() {
        return queries_2.setupBankExtension;
      } });
      var aminomessages_3 = require_aminomessages3();
      Object.defineProperty(exports2, "createCrysisAminoConverters", { enumerable: true, get: function() {
        return aminomessages_3.createCrysisAminoConverters;
      } });
      Object.defineProperty(exports2, "isAminoMsgVerifyInvariant", { enumerable: true, get: function() {
        return aminomessages_3.isAminoMsgVerifyInvariant;
      } });
      var aminomessages_4 = require_aminomessages4();
      Object.defineProperty(exports2, "createDistributionAminoConverters", { enumerable: true, get: function() {
        return aminomessages_4.createDistributionAminoConverters;
      } });
      Object.defineProperty(exports2, "isAminoMsgFundCommunityPool", { enumerable: true, get: function() {
        return aminomessages_4.isAminoMsgFundCommunityPool;
      } });
      Object.defineProperty(exports2, "isAminoMsgSetWithdrawAddress", { enumerable: true, get: function() {
        return aminomessages_4.isAminoMsgSetWithdrawAddress;
      } });
      Object.defineProperty(exports2, "isAminoMsgWithdrawDelegatorReward", { enumerable: true, get: function() {
        return aminomessages_4.isAminoMsgWithdrawDelegatorReward;
      } });
      Object.defineProperty(exports2, "isAminoMsgWithdrawValidatorCommission", { enumerable: true, get: function() {
        return aminomessages_4.isAminoMsgWithdrawValidatorCommission;
      } });
      var messages_3 = require_messages3();
      Object.defineProperty(exports2, "distributionTypes", { enumerable: true, get: function() {
        return messages_3.distributionTypes;
      } });
      Object.defineProperty(exports2, "isMsgWithdrawDelegatorRewardEncodeObject", { enumerable: true, get: function() {
        return messages_3.isMsgWithdrawDelegatorRewardEncodeObject;
      } });
      var queries_3 = require_queries3();
      Object.defineProperty(exports2, "setupDistributionExtension", { enumerable: true, get: function() {
        return queries_3.setupDistributionExtension;
      } });
      var aminomessages_5 = require_aminomessages5();
      Object.defineProperty(exports2, "createEvidenceAminoConverters", { enumerable: true, get: function() {
        return aminomessages_5.createEvidenceAminoConverters;
      } });
      Object.defineProperty(exports2, "isAminoMsgSubmitEvidence", { enumerable: true, get: function() {
        return aminomessages_5.isAminoMsgSubmitEvidence;
      } });
      var aminomessages_6 = require_aminomessages6();
      Object.defineProperty(exports2, "createFreegrantAminoConverters", { enumerable: true, get: function() {
        return aminomessages_6.createFreegrantAminoConverters;
      } });
      var messages_4 = require_messages4();
      Object.defineProperty(exports2, "feegrantTypes", { enumerable: true, get: function() {
        return messages_4.feegrantTypes;
      } });
      var aminomessages_7 = require_aminomessages7();
      Object.defineProperty(exports2, "createGovAminoConverters", { enumerable: true, get: function() {
        return aminomessages_7.createGovAminoConverters;
      } });
      Object.defineProperty(exports2, "isAminoMsgDeposit", { enumerable: true, get: function() {
        return aminomessages_7.isAminoMsgDeposit;
      } });
      Object.defineProperty(exports2, "isAminoMsgSubmitProposal", { enumerable: true, get: function() {
        return aminomessages_7.isAminoMsgSubmitProposal;
      } });
      Object.defineProperty(exports2, "isAminoMsgVote", { enumerable: true, get: function() {
        return aminomessages_7.isAminoMsgVote;
      } });
      var messages_5 = require_messages5();
      Object.defineProperty(exports2, "govTypes", { enumerable: true, get: function() {
        return messages_5.govTypes;
      } });
      Object.defineProperty(exports2, "isMsgDepositEncodeObject", { enumerable: true, get: function() {
        return messages_5.isMsgDepositEncodeObject;
      } });
      Object.defineProperty(exports2, "isMsgSubmitProposalEncodeObject", { enumerable: true, get: function() {
        return messages_5.isMsgSubmitProposalEncodeObject;
      } });
      Object.defineProperty(exports2, "isMsgVoteEncodeObject", { enumerable: true, get: function() {
        return messages_5.isMsgVoteEncodeObject;
      } });
      var queries_4 = require_queries4();
      Object.defineProperty(exports2, "setupGovExtension", { enumerable: true, get: function() {
        return queries_4.setupGovExtension;
      } });
      var aminomessages_8 = require_aminomessages8();
      Object.defineProperty(exports2, "createIbcAminoConverters", { enumerable: true, get: function() {
        return aminomessages_8.createIbcAminoConverters;
      } });
      Object.defineProperty(exports2, "isAminoMsgTransfer", { enumerable: true, get: function() {
        return aminomessages_8.isAminoMsgTransfer;
      } });
      var messages_6 = require_messages6();
      Object.defineProperty(exports2, "ibcTypes", { enumerable: true, get: function() {
        return messages_6.ibcTypes;
      } });
      Object.defineProperty(exports2, "isMsgTransferEncodeObject", { enumerable: true, get: function() {
        return messages_6.isMsgTransferEncodeObject;
      } });
      var queries_5 = require_queries5();
      Object.defineProperty(exports2, "setupIbcExtension", { enumerable: true, get: function() {
        return queries_5.setupIbcExtension;
      } });
      var queries_6 = require_queries6();
      Object.defineProperty(exports2, "setupMintExtension", { enumerable: true, get: function() {
        return queries_6.setupMintExtension;
      } });
      var aminomessages_9 = require_aminomessages9();
      Object.defineProperty(exports2, "createSlashingAminoConverters", { enumerable: true, get: function() {
        return aminomessages_9.createSlashingAminoConverters;
      } });
      Object.defineProperty(exports2, "isAminoMsgUnjail", { enumerable: true, get: function() {
        return aminomessages_9.isAminoMsgUnjail;
      } });
      var queries_7 = require_queries7();
      Object.defineProperty(exports2, "setupSlashingExtension", { enumerable: true, get: function() {
        return queries_7.setupSlashingExtension;
      } });
      var aminomessages_10 = require_aminomessages10();
      Object.defineProperty(exports2, "createStakingAminoConverters", { enumerable: true, get: function() {
        return aminomessages_10.createStakingAminoConverters;
      } });
      Object.defineProperty(exports2, "isAminoMsgBeginRedelegate", { enumerable: true, get: function() {
        return aminomessages_10.isAminoMsgBeginRedelegate;
      } });
      Object.defineProperty(exports2, "isAminoMsgCreateValidator", { enumerable: true, get: function() {
        return aminomessages_10.isAminoMsgCreateValidator;
      } });
      Object.defineProperty(exports2, "isAminoMsgDelegate", { enumerable: true, get: function() {
        return aminomessages_10.isAminoMsgDelegate;
      } });
      Object.defineProperty(exports2, "isAminoMsgEditValidator", { enumerable: true, get: function() {
        return aminomessages_10.isAminoMsgEditValidator;
      } });
      Object.defineProperty(exports2, "isAminoMsgUndelegate", { enumerable: true, get: function() {
        return aminomessages_10.isAminoMsgUndelegate;
      } });
      var messages_7 = require_messages7();
      Object.defineProperty(exports2, "isMsgDelegateEncodeObject", { enumerable: true, get: function() {
        return messages_7.isMsgDelegateEncodeObject;
      } });
      Object.defineProperty(exports2, "isMsgUndelegateEncodeObject", { enumerable: true, get: function() {
        return messages_7.isMsgUndelegateEncodeObject;
      } });
      Object.defineProperty(exports2, "stakingTypes", { enumerable: true, get: function() {
        return messages_7.stakingTypes;
      } });
      var queries_8 = require_queries8();
      Object.defineProperty(exports2, "setupStakingExtension", { enumerable: true, get: function() {
        return queries_8.setupStakingExtension;
      } });
      var queries_9 = require_queries9();
      Object.defineProperty(exports2, "setupTxExtension", { enumerable: true, get: function() {
        return queries_9.setupTxExtension;
      } });
      var aminomessages_11 = require_aminomessages11();
      Object.defineProperty(exports2, "createVestingAminoConverters", { enumerable: true, get: function() {
        return aminomessages_11.createVestingAminoConverters;
      } });
      var messages_8 = require_messages8();
      Object.defineProperty(exports2, "vestingTypes", { enumerable: true, get: function() {
        return messages_8.vestingTypes;
      } });
    }
  });

  // node_modules/@cosmjs/stargate/build/multisignature.js
  var require_multisignature = __commonJS({
    "node_modules/@cosmjs/stargate/build/multisignature.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.makeMultisignedTx = exports2.makeCompactBitArray = void 0;
      var amino_1 = require_build5();
      var encoding_1 = require_build2();
      var proto_signing_1 = require_build6();
      var multisig_1 = require_multisig();
      var signing_1 = require_signing();
      var tx_1 = require_tx();
      var tx_2 = require_tx();
      var long_1 = __importDefault(require_long());
      function makeCompactBitArray(bits) {
        const byteCount = Math.ceil(bits.length / 8);
        const extraBits = bits.length - Math.floor(bits.length / 8) * 8;
        const bytes = new Uint8Array(byteCount);
        bits.forEach((value, index) => {
          const bytePos = Math.floor(index / 8);
          const bitPos = index % 8;
          if (value)
            bytes[bytePos] |= 1 << 8 - 1 - bitPos;
        });
        return multisig_1.CompactBitArray.fromPartial({ elems: bytes, extraBitsStored: extraBits });
      }
      exports2.makeCompactBitArray = makeCompactBitArray;
      function makeMultisignedTx(multisigPubkey, sequence, fee, bodyBytes, signatures) {
        const addresses = Array.from(signatures.keys());
        const prefix = (0, encoding_1.fromBech32)(addresses[0]).prefix;
        const signers = Array(multisigPubkey.value.pubkeys.length).fill(false);
        const signaturesList = new Array();
        for (let i = 0; i < multisigPubkey.value.pubkeys.length; i++) {
          const signerAddress = (0, amino_1.pubkeyToAddress)(multisigPubkey.value.pubkeys[i], prefix);
          const signature = signatures.get(signerAddress);
          if (signature) {
            signers[i] = true;
            signaturesList.push(signature);
          }
        }
        const signerInfo = {
          publicKey: (0, proto_signing_1.encodePubkey)(multisigPubkey),
          modeInfo: {
            multi: {
              bitarray: makeCompactBitArray(signers),
              modeInfos: signaturesList.map((_) => ({ single: { mode: signing_1.SignMode.SIGN_MODE_LEGACY_AMINO_JSON } }))
            }
          },
          sequence: long_1.default.fromNumber(sequence)
        };
        const authInfo = tx_1.AuthInfo.fromPartial({
          signerInfos: [signerInfo],
          fee: {
            amount: [...fee.amount],
            gasLimit: long_1.default.fromString(fee.gas)
          }
        });
        const authInfoBytes = tx_1.AuthInfo.encode(authInfo).finish();
        const signedTx = tx_2.TxRaw.fromPartial({
          bodyBytes,
          authInfoBytes,
          signatures: [multisig_1.MultiSignature.encode(multisig_1.MultiSignature.fromPartial({ signatures: signaturesList })).finish()]
        });
        return signedTx;
      }
      exports2.makeMultisignedTx = makeMultisignedTx;
    }
  });

  // node_modules/@cosmjs/stargate/build/search.js
  var require_search = __commonJS({
    "node_modules/@cosmjs/stargate/build/search.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.isSearchByTagsQuery = exports2.isSearchBySentFromOrToQuery = exports2.isSearchByHeightQuery = void 0;
      function isSearchByHeightQuery(query) {
        return query.height !== void 0;
      }
      exports2.isSearchByHeightQuery = isSearchByHeightQuery;
      function isSearchBySentFromOrToQuery(query) {
        return query.sentFromOrTo !== void 0;
      }
      exports2.isSearchBySentFromOrToQuery = isSearchBySentFromOrToQuery;
      function isSearchByTagsQuery(query) {
        return query.tags !== void 0;
      }
      exports2.isSearchByTagsQuery = isSearchByTagsQuery;
    }
  });

  // node_modules/@cosmjs/tendermint-rpc/build/addresses.js
  var require_addresses2 = __commonJS({
    "node_modules/@cosmjs/tendermint-rpc/build/addresses.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.pubkeyToAddress = exports2.pubkeyToRawAddress = exports2.rawSecp256k1PubkeyToRawAddress = exports2.rawEd25519PubkeyToRawAddress = void 0;
      var crypto_1 = require_build4();
      var encoding_1 = require_build2();
      function rawEd25519PubkeyToRawAddress(pubkeyData) {
        if (pubkeyData.length !== 32) {
          throw new Error(`Invalid Ed25519 pubkey length: ${pubkeyData.length}`);
        }
        return (0, crypto_1.sha256)(pubkeyData).slice(0, 20);
      }
      exports2.rawEd25519PubkeyToRawAddress = rawEd25519PubkeyToRawAddress;
      function rawSecp256k1PubkeyToRawAddress(pubkeyData) {
        if (pubkeyData.length !== 33) {
          throw new Error(`Invalid Secp256k1 pubkey length (compressed): ${pubkeyData.length}`);
        }
        return (0, crypto_1.ripemd160)((0, crypto_1.sha256)(pubkeyData));
      }
      exports2.rawSecp256k1PubkeyToRawAddress = rawSecp256k1PubkeyToRawAddress;
      function pubkeyToRawAddress(type, data) {
        switch (type) {
          case "ed25519":
            return rawEd25519PubkeyToRawAddress(data);
          case "secp256k1":
            return rawSecp256k1PubkeyToRawAddress(data);
          default:
            throw new Error(`Pubkey type ${type} not supported`);
        }
      }
      exports2.pubkeyToRawAddress = pubkeyToRawAddress;
      function pubkeyToAddress(type, data) {
        return (0, encoding_1.toHex)(pubkeyToRawAddress(type, data)).toUpperCase();
      }
      exports2.pubkeyToAddress = pubkeyToAddress;
    }
  });

  // node_modules/@cosmjs/tendermint-rpc/build/dates.js
  var require_dates = __commonJS({
    "node_modules/@cosmjs/tendermint-rpc/build/dates.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.DateTime = exports2.toSeconds = exports2.fromSeconds = exports2.toRfc3339WithNanoseconds = exports2.fromRfc3339WithNanoseconds = void 0;
      var encoding_1 = require_build2();
      var math_1 = require_build();
      function fromRfc3339WithNanoseconds(dateTimeString) {
        const out = (0, encoding_1.fromRfc3339)(dateTimeString);
        const nanosecondsMatch = dateTimeString.match(/\.(\d+)Z$/);
        const nanoseconds = nanosecondsMatch ? nanosecondsMatch[1].slice(3) : "";
        out.nanoseconds = parseInt(nanoseconds.padEnd(6, "0"), 10);
        return out;
      }
      exports2.fromRfc3339WithNanoseconds = fromRfc3339WithNanoseconds;
      function toRfc3339WithNanoseconds(dateTime) {
        var _a, _b;
        const millisecondIso = dateTime.toISOString();
        const nanoseconds = (_b = (_a = dateTime.nanoseconds) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : "";
        return `${millisecondIso.slice(0, -1)}${nanoseconds.padStart(6, "0")}Z`;
      }
      exports2.toRfc3339WithNanoseconds = toRfc3339WithNanoseconds;
      function fromSeconds(seconds, nanos = 0) {
        const checkedNanos = new math_1.Uint32(nanos).toNumber();
        if (checkedNanos > 999999999) {
          throw new Error("Nano seconds must not exceed 999999999");
        }
        const out = new Date(seconds * 1e3 + Math.floor(checkedNanos / 1e6));
        out.nanoseconds = checkedNanos % 1e6;
        return out;
      }
      exports2.fromSeconds = fromSeconds;
      function toSeconds(date) {
        var _a;
        return {
          seconds: Math.floor(date.getTime() / 1e3),
          nanos: date.getTime() % 1e3 * 1e6 + ((_a = date.nanoseconds) !== null && _a !== void 0 ? _a : 0)
        };
      }
      exports2.toSeconds = toSeconds;
      var DateTime = class {
        static decode(dateTimeString) {
          return fromRfc3339WithNanoseconds(dateTimeString);
        }
        static encode(dateTime) {
          return toRfc3339WithNanoseconds(dateTime);
        }
      };
      exports2.DateTime = DateTime;
    }
  });

  // node_modules/@cosmjs/json-rpc/build/id.js
  var require_id = __commonJS({
    "node_modules/@cosmjs/json-rpc/build/id.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.makeJsonRpcId = void 0;
      var counter = 1e4;
      function makeJsonRpcId() {
        return counter += 1;
      }
      exports2.makeJsonRpcId = makeJsonRpcId;
    }
  });

  // node_modules/@cosmjs/json-rpc/build/types.js
  var require_types4 = __commonJS({
    "node_modules/@cosmjs/json-rpc/build/types.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.jsonRpcCode = exports2.isJsonRpcSuccessResponse = exports2.isJsonRpcErrorResponse = void 0;
      function isJsonRpcErrorResponse(response) {
        return typeof response.error === "object";
      }
      exports2.isJsonRpcErrorResponse = isJsonRpcErrorResponse;
      function isJsonRpcSuccessResponse(response) {
        return !isJsonRpcErrorResponse(response);
      }
      exports2.isJsonRpcSuccessResponse = isJsonRpcSuccessResponse;
      exports2.jsonRpcCode = {
        parseError: -32700,
        invalidRequest: -32600,
        methodNotFound: -32601,
        invalidParams: -32602,
        internalError: -32603,
        serverError: {
          default: -32e3
        }
      };
    }
  });

  // node_modules/@cosmjs/json-rpc/build/jsonrpcclient.js
  var require_jsonrpcclient = __commonJS({
    "node_modules/@cosmjs/json-rpc/build/jsonrpcclient.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.JsonRpcClient = void 0;
      var stream_1 = require_build8();
      var types_1 = require_types4();
      var JsonRpcClient = class {
        constructor(connection) {
          this.connection = connection;
        }
        async run(request) {
          const filteredStream = this.connection.responseStream.filter((r) => r.id === request.id);
          const pendingResponses = (0, stream_1.firstEvent)(filteredStream);
          this.connection.sendRequest(request);
          const response = await pendingResponses;
          if ((0, types_1.isJsonRpcErrorResponse)(response)) {
            const error = response.error;
            throw new Error(`JSON RPC error: code=${error.code}; message='${error.message}'`);
          }
          return response;
        }
      };
      exports2.JsonRpcClient = JsonRpcClient;
    }
  });

  // node_modules/@cosmjs/json-rpc/build/compatibility.js
  var require_compatibility = __commonJS({
    "node_modules/@cosmjs/json-rpc/build/compatibility.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.isJsonCompatibleDictionary = exports2.isJsonCompatibleArray = exports2.isJsonCompatibleValue = void 0;
      function isJsonCompatibleValue(value) {
        if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null || isJsonCompatibleArray(value) || isJsonCompatibleDictionary(value)) {
          return true;
        } else {
          return false;
        }
      }
      exports2.isJsonCompatibleValue = isJsonCompatibleValue;
      function isJsonCompatibleArray(value) {
        if (!Array.isArray(value)) {
          return false;
        }
        for (const item of value) {
          if (!isJsonCompatibleValue(item)) {
            return false;
          }
        }
        return true;
      }
      exports2.isJsonCompatibleArray = isJsonCompatibleArray;
      function isJsonCompatibleDictionary(data) {
        if (typeof data !== "object" || data === null) {
          return false;
        }
        if (Object.prototype.toString.call(data) !== "[object Object]") {
          return false;
        }
        return Object.values(data).every(isJsonCompatibleValue);
      }
      exports2.isJsonCompatibleDictionary = isJsonCompatibleDictionary;
    }
  });

  // node_modules/@cosmjs/json-rpc/build/parse.js
  var require_parse = __commonJS({
    "node_modules/@cosmjs/json-rpc/build/parse.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.parseJsonRpcResponse = exports2.parseJsonRpcSuccessResponse = exports2.parseJsonRpcErrorResponse = exports2.parseJsonRpcRequest = exports2.parseJsonRpcId = void 0;
      var compatibility_1 = require_compatibility();
      function parseJsonRpcId(data) {
        if (!(0, compatibility_1.isJsonCompatibleDictionary)(data)) {
          throw new Error("Data must be JSON compatible dictionary");
        }
        const id = data.id;
        if (typeof id !== "number" && typeof id !== "string") {
          return null;
        }
        return id;
      }
      exports2.parseJsonRpcId = parseJsonRpcId;
      function parseJsonRpcRequest(data) {
        if (!(0, compatibility_1.isJsonCompatibleDictionary)(data)) {
          throw new Error("Data must be JSON compatible dictionary");
        }
        if (data.jsonrpc !== "2.0") {
          throw new Error(`Got unexpected jsonrpc version: ${data.jsonrpc}`);
        }
        const id = parseJsonRpcId(data);
        if (id === null) {
          throw new Error("Invalid id field");
        }
        const method = data.method;
        if (typeof method !== "string") {
          throw new Error("Invalid method field");
        }
        if (!(0, compatibility_1.isJsonCompatibleArray)(data.params) && !(0, compatibility_1.isJsonCompatibleDictionary)(data.params)) {
          throw new Error("Invalid params field");
        }
        return {
          jsonrpc: "2.0",
          id,
          method,
          params: data.params
        };
      }
      exports2.parseJsonRpcRequest = parseJsonRpcRequest;
      function parseError(error) {
        if (typeof error.code !== "number") {
          throw new Error("Error property 'code' is not a number");
        }
        if (typeof error.message !== "string") {
          throw new Error("Error property 'message' is not a string");
        }
        let maybeUndefinedData;
        if (error.data === void 0) {
          maybeUndefinedData = void 0;
        } else if ((0, compatibility_1.isJsonCompatibleValue)(error.data)) {
          maybeUndefinedData = error.data;
        } else {
          throw new Error("Error property 'data' is defined but not a JSON compatible value.");
        }
        return {
          code: error.code,
          message: error.message,
          ...maybeUndefinedData !== void 0 ? { data: maybeUndefinedData } : {}
        };
      }
      function parseJsonRpcErrorResponse(data) {
        if (!(0, compatibility_1.isJsonCompatibleDictionary)(data)) {
          throw new Error("Data must be JSON compatible dictionary");
        }
        if (data.jsonrpc !== "2.0") {
          throw new Error(`Got unexpected jsonrpc version: ${JSON.stringify(data)}`);
        }
        const id = data.id;
        if (typeof id !== "number" && typeof id !== "string" && id !== null) {
          throw new Error("Invalid id field");
        }
        if (typeof data.error === "undefined" || !(0, compatibility_1.isJsonCompatibleDictionary)(data.error)) {
          throw new Error("Invalid error field");
        }
        return {
          jsonrpc: "2.0",
          id,
          error: parseError(data.error)
        };
      }
      exports2.parseJsonRpcErrorResponse = parseJsonRpcErrorResponse;
      function parseJsonRpcSuccessResponse(data) {
        if (!(0, compatibility_1.isJsonCompatibleDictionary)(data)) {
          throw new Error("Data must be JSON compatible dictionary");
        }
        if (data.jsonrpc !== "2.0") {
          throw new Error(`Got unexpected jsonrpc version: ${JSON.stringify(data)}`);
        }
        const id = data.id;
        if (typeof id !== "number" && typeof id !== "string") {
          throw new Error("Invalid id field");
        }
        if (typeof data.result === "undefined") {
          throw new Error("Invalid result field");
        }
        const result = data.result;
        return {
          jsonrpc: "2.0",
          id,
          result
        };
      }
      exports2.parseJsonRpcSuccessResponse = parseJsonRpcSuccessResponse;
      function parseJsonRpcResponse(data) {
        let response;
        try {
          response = parseJsonRpcErrorResponse(data);
        } catch (_) {
          response = parseJsonRpcSuccessResponse(data);
        }
        return response;
      }
      exports2.parseJsonRpcResponse = parseJsonRpcResponse;
    }
  });

  // node_modules/@cosmjs/json-rpc/build/index.js
  var require_build9 = __commonJS({
    "node_modules/@cosmjs/json-rpc/build/index.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.jsonRpcCode = exports2.isJsonRpcSuccessResponse = exports2.isJsonRpcErrorResponse = exports2.parseJsonRpcSuccessResponse = exports2.parseJsonRpcResponse = exports2.parseJsonRpcRequest = exports2.parseJsonRpcId = exports2.parseJsonRpcErrorResponse = exports2.JsonRpcClient = exports2.makeJsonRpcId = void 0;
      var id_1 = require_id();
      Object.defineProperty(exports2, "makeJsonRpcId", { enumerable: true, get: function() {
        return id_1.makeJsonRpcId;
      } });
      var jsonrpcclient_1 = require_jsonrpcclient();
      Object.defineProperty(exports2, "JsonRpcClient", { enumerable: true, get: function() {
        return jsonrpcclient_1.JsonRpcClient;
      } });
      var parse_1 = require_parse();
      Object.defineProperty(exports2, "parseJsonRpcErrorResponse", { enumerable: true, get: function() {
        return parse_1.parseJsonRpcErrorResponse;
      } });
      Object.defineProperty(exports2, "parseJsonRpcId", { enumerable: true, get: function() {
        return parse_1.parseJsonRpcId;
      } });
      Object.defineProperty(exports2, "parseJsonRpcRequest", { enumerable: true, get: function() {
        return parse_1.parseJsonRpcRequest;
      } });
      Object.defineProperty(exports2, "parseJsonRpcResponse", { enumerable: true, get: function() {
        return parse_1.parseJsonRpcResponse;
      } });
      Object.defineProperty(exports2, "parseJsonRpcSuccessResponse", { enumerable: true, get: function() {
        return parse_1.parseJsonRpcSuccessResponse;
      } });
      var types_1 = require_types4();
      Object.defineProperty(exports2, "isJsonRpcErrorResponse", { enumerable: true, get: function() {
        return types_1.isJsonRpcErrorResponse;
      } });
      Object.defineProperty(exports2, "isJsonRpcSuccessResponse", { enumerable: true, get: function() {
        return types_1.isJsonRpcSuccessResponse;
      } });
      Object.defineProperty(exports2, "jsonRpcCode", { enumerable: true, get: function() {
        return types_1.jsonRpcCode;
      } });
    }
  });

  // node_modules/axios/lib/helpers/bind.js
  var require_bind = __commonJS({
    "node_modules/axios/lib/helpers/bind.js"(exports2, module2) {
      "use strict";
      module2.exports = function bind(fn, thisArg) {
        return function wrap() {
          var args = new Array(arguments.length);
          for (var i = 0; i < args.length; i++) {
            args[i] = arguments[i];
          }
          return fn.apply(thisArg, args);
        };
      };
    }
  });

  // node_modules/axios/lib/utils.js
  var require_utils8 = __commonJS({
    "node_modules/axios/lib/utils.js"(exports2, module2) {
      "use strict";
      var bind = require_bind();
      var toString = Object.prototype.toString;
      function isArray(val) {
        return toString.call(val) === "[object Array]";
      }
      function isUndefined(val) {
        return typeof val === "undefined";
      }
      function isBuffer(val) {
        return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor) && typeof val.constructor.isBuffer === "function" && val.constructor.isBuffer(val);
      }
      function isArrayBuffer(val) {
        return toString.call(val) === "[object ArrayBuffer]";
      }
      function isFormData(val) {
        return typeof FormData !== "undefined" && val instanceof FormData;
      }
      function isArrayBufferView(val) {
        var result;
        if (typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView) {
          result = ArrayBuffer.isView(val);
        } else {
          result = val && val.buffer && val.buffer instanceof ArrayBuffer;
        }
        return result;
      }
      function isString(val) {
        return typeof val === "string";
      }
      function isNumber(val) {
        return typeof val === "number";
      }
      function isObject(val) {
        return val !== null && typeof val === "object";
      }
      function isPlainObject(val) {
        if (toString.call(val) !== "[object Object]") {
          return false;
        }
        var prototype = Object.getPrototypeOf(val);
        return prototype === null || prototype === Object.prototype;
      }
      function isDate(val) {
        return toString.call(val) === "[object Date]";
      }
      function isFile(val) {
        return toString.call(val) === "[object File]";
      }
      function isBlob(val) {
        return toString.call(val) === "[object Blob]";
      }
      function isFunction(val) {
        return toString.call(val) === "[object Function]";
      }
      function isStream(val) {
        return isObject(val) && isFunction(val.pipe);
      }
      function isURLSearchParams(val) {
        return typeof URLSearchParams !== "undefined" && val instanceof URLSearchParams;
      }
      function trim(str) {
        return str.trim ? str.trim() : str.replace(/^\s+|\s+$/g, "");
      }
      function isStandardBrowserEnv() {
        if (typeof navigator !== "undefined" && (navigator.product === "ReactNative" || navigator.product === "NativeScript" || navigator.product === "NS")) {
          return false;
        }
        return typeof window !== "undefined" && typeof document !== "undefined";
      }
      function forEach(obj, fn) {
        if (obj === null || typeof obj === "undefined") {
          return;
        }
        if (typeof obj !== "object") {
          obj = [obj];
        }
        if (isArray(obj)) {
          for (var i = 0, l = obj.length; i < l; i++) {
            fn.call(null, obj[i], i, obj);
          }
        } else {
          for (var key in obj) {
            if (Object.prototype.hasOwnProperty.call(obj, key)) {
              fn.call(null, obj[key], key, obj);
            }
          }
        }
      }
      function merge() {
        var result = {};
        function assignValue(val, key) {
          if (isPlainObject(result[key]) && isPlainObject(val)) {
            result[key] = merge(result[key], val);
          } else if (isPlainObject(val)) {
            result[key] = merge({}, val);
          } else if (isArray(val)) {
            result[key] = val.slice();
          } else {
            result[key] = val;
          }
        }
        for (var i = 0, l = arguments.length; i < l; i++) {
          forEach(arguments[i], assignValue);
        }
        return result;
      }
      function extend2(a, b, thisArg) {
        forEach(b, function assignValue(val, key) {
          if (thisArg && typeof val === "function") {
            a[key] = bind(val, thisArg);
          } else {
            a[key] = val;
          }
        });
        return a;
      }
      function stripBOM(content) {
        if (content.charCodeAt(0) === 65279) {
          content = content.slice(1);
        }
        return content;
      }
      module2.exports = {
        isArray,
        isArrayBuffer,
        isBuffer,
        isFormData,
        isArrayBufferView,
        isString,
        isNumber,
        isObject,
        isPlainObject,
        isUndefined,
        isDate,
        isFile,
        isBlob,
        isFunction,
        isStream,
        isURLSearchParams,
        isStandardBrowserEnv,
        forEach,
        merge,
        extend: extend2,
        trim,
        stripBOM
      };
    }
  });

  // node_modules/axios/lib/helpers/buildURL.js
  var require_buildURL = __commonJS({
    "node_modules/axios/lib/helpers/buildURL.js"(exports2, module2) {
      "use strict";
      var utils = require_utils8();
      function encode(val) {
        return encodeURIComponent(val).replace(/%3A/gi, ":").replace(/%24/g, "$").replace(/%2C/gi, ",").replace(/%20/g, "+").replace(/%5B/gi, "[").replace(/%5D/gi, "]");
      }
      module2.exports = function buildURL(url, params, paramsSerializer) {
        if (!params) {
          return url;
        }
        var serializedParams;
        if (paramsSerializer) {
          serializedParams = paramsSerializer(params);
        } else if (utils.isURLSearchParams(params)) {
          serializedParams = params.toString();
        } else {
          var parts = [];
          utils.forEach(params, function serialize(val, key) {
            if (val === null || typeof val === "undefined") {
              return;
            }
            if (utils.isArray(val)) {
              key = key + "[]";
            } else {
              val = [val];
            }
            utils.forEach(val, function parseValue(v) {
              if (utils.isDate(v)) {
                v = v.toISOString();
              } else if (utils.isObject(v)) {
                v = JSON.stringify(v);
              }
              parts.push(encode(key) + "=" + encode(v));
            });
          });
          serializedParams = parts.join("&");
        }
        if (serializedParams) {
          var hashmarkIndex = url.indexOf("#");
          if (hashmarkIndex !== -1) {
            url = url.slice(0, hashmarkIndex);
          }
          url += (url.indexOf("?") === -1 ? "?" : "&") + serializedParams;
        }
        return url;
      };
    }
  });

  // node_modules/axios/lib/core/InterceptorManager.js
  var require_InterceptorManager = __commonJS({
    "node_modules/axios/lib/core/InterceptorManager.js"(exports2, module2) {
      "use strict";
      var utils = require_utils8();
      function InterceptorManager() {
        this.handlers = [];
      }
      InterceptorManager.prototype.use = function use(fulfilled, rejected, options) {
        this.handlers.push({
          fulfilled,
          rejected,
          synchronous: options ? options.synchronous : false,
          runWhen: options ? options.runWhen : null
        });
        return this.handlers.length - 1;
      };
      InterceptorManager.prototype.eject = function eject(id) {
        if (this.handlers[id]) {
          this.handlers[id] = null;
        }
      };
      InterceptorManager.prototype.forEach = function forEach(fn) {
        utils.forEach(this.handlers, function forEachHandler(h) {
          if (h !== null) {
            fn(h);
          }
        });
      };
      module2.exports = InterceptorManager;
    }
  });

  // node_modules/axios/lib/helpers/normalizeHeaderName.js
  var require_normalizeHeaderName = __commonJS({
    "node_modules/axios/lib/helpers/normalizeHeaderName.js"(exports2, module2) {
      "use strict";
      var utils = require_utils8();
      module2.exports = function normalizeHeaderName(headers, normalizedName) {
        utils.forEach(headers, function processHeader(value, name) {
          if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {
            headers[normalizedName] = value;
            delete headers[name];
          }
        });
      };
    }
  });

  // node_modules/axios/lib/core/enhanceError.js
  var require_enhanceError = __commonJS({
    "node_modules/axios/lib/core/enhanceError.js"(exports2, module2) {
      "use strict";
      module2.exports = function enhanceError(error, config, code, request, response) {
        error.config = config;
        if (code) {
          error.code = code;
        }
        error.request = request;
        error.response = response;
        error.isAxiosError = true;
        error.toJSON = function toJSON() {
          return {
            message: this.message,
            name: this.name,
            description: this.description,
            number: this.number,
            fileName: this.fileName,
            lineNumber: this.lineNumber,
            columnNumber: this.columnNumber,
            stack: this.stack,
            config: this.config,
            code: this.code
          };
        };
        return error;
      };
    }
  });

  // node_modules/axios/lib/core/createError.js
  var require_createError = __commonJS({
    "node_modules/axios/lib/core/createError.js"(exports2, module2) {
      "use strict";
      var enhanceError = require_enhanceError();
      module2.exports = function createError(message, config, code, request, response) {
        var error = new Error(message);
        return enhanceError(error, config, code, request, response);
      };
    }
  });

  // node_modules/axios/lib/core/settle.js
  var require_settle = __commonJS({
    "node_modules/axios/lib/core/settle.js"(exports2, module2) {
      "use strict";
      var createError = require_createError();
      module2.exports = function settle(resolve, reject, response) {
        var validateStatus = response.config.validateStatus;
        if (!response.status || !validateStatus || validateStatus(response.status)) {
          resolve(response);
        } else {
          reject(createError("Request failed with status code " + response.status, response.config, null, response.request, response));
        }
      };
    }
  });

  // node_modules/axios/lib/helpers/cookies.js
  var require_cookies = __commonJS({
    "node_modules/axios/lib/helpers/cookies.js"(exports2, module2) {
      "use strict";
      var utils = require_utils8();
      module2.exports = utils.isStandardBrowserEnv() ? function standardBrowserEnv() {
        return {
          write: function write(name, value, expires, path, domain, secure) {
            var cookie = [];
            cookie.push(name + "=" + encodeURIComponent(value));
            if (utils.isNumber(expires)) {
              cookie.push("expires=" + new Date(expires).toGMTString());
            }
            if (utils.isString(path)) {
              cookie.push("path=" + path);
            }
            if (utils.isString(domain)) {
              cookie.push("domain=" + domain);
            }
            if (secure === true) {
              cookie.push("secure");
            }
            document.cookie = cookie.join("; ");
          },
          read: function read(name) {
            var match = document.cookie.match(new RegExp("(^|;\\s*)(" + name + ")=([^;]*)"));
            return match ? decodeURIComponent(match[3]) : null;
          },
          remove: function remove(name) {
            this.write(name, "", Date.now() - 864e5);
          }
        };
      }() : function nonStandardBrowserEnv() {
        return {
          write: function write() {
          },
          read: function read() {
            return null;
          },
          remove: function remove() {
          }
        };
      }();
    }
  });

  // node_modules/axios/lib/helpers/isAbsoluteURL.js
  var require_isAbsoluteURL = __commonJS({
    "node_modules/axios/lib/helpers/isAbsoluteURL.js"(exports2, module2) {
      "use strict";
      module2.exports = function isAbsoluteURL(url) {
        return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url);
      };
    }
  });

  // node_modules/axios/lib/helpers/combineURLs.js
  var require_combineURLs = __commonJS({
    "node_modules/axios/lib/helpers/combineURLs.js"(exports2, module2) {
      "use strict";
      module2.exports = function combineURLs(baseURL, relativeURL) {
        return relativeURL ? baseURL.replace(/\/+$/, "") + "/" + relativeURL.replace(/^\/+/, "") : baseURL;
      };
    }
  });

  // node_modules/axios/lib/core/buildFullPath.js
  var require_buildFullPath = __commonJS({
    "node_modules/axios/lib/core/buildFullPath.js"(exports2, module2) {
      "use strict";
      var isAbsoluteURL = require_isAbsoluteURL();
      var combineURLs = require_combineURLs();
      module2.exports = function buildFullPath(baseURL, requestedURL) {
        if (baseURL && !isAbsoluteURL(requestedURL)) {
          return combineURLs(baseURL, requestedURL);
        }
        return requestedURL;
      };
    }
  });

  // node_modules/axios/lib/helpers/parseHeaders.js
  var require_parseHeaders = __commonJS({
    "node_modules/axios/lib/helpers/parseHeaders.js"(exports2, module2) {
      "use strict";
      var utils = require_utils8();
      var ignoreDuplicateOf = [
        "age",
        "authorization",
        "content-length",
        "content-type",
        "etag",
        "expires",
        "from",
        "host",
        "if-modified-since",
        "if-unmodified-since",
        "last-modified",
        "location",
        "max-forwards",
        "proxy-authorization",
        "referer",
        "retry-after",
        "user-agent"
      ];
      module2.exports = function parseHeaders(headers) {
        var parsed = {};
        var key;
        var val;
        var i;
        if (!headers) {
          return parsed;
        }
        utils.forEach(headers.split("\n"), function parser(line) {
          i = line.indexOf(":");
          key = utils.trim(line.substr(0, i)).toLowerCase();
          val = utils.trim(line.substr(i + 1));
          if (key) {
            if (parsed[key] && ignoreDuplicateOf.indexOf(key) >= 0) {
              return;
            }
            if (key === "set-cookie") {
              parsed[key] = (parsed[key] ? parsed[key] : []).concat([val]);
            } else {
              parsed[key] = parsed[key] ? parsed[key] + ", " + val : val;
            }
          }
        });
        return parsed;
      };
    }
  });

  // node_modules/axios/lib/helpers/isURLSameOrigin.js
  var require_isURLSameOrigin = __commonJS({
    "node_modules/axios/lib/helpers/isURLSameOrigin.js"(exports2, module2) {
      "use strict";
      var utils = require_utils8();
      module2.exports = utils.isStandardBrowserEnv() ? function standardBrowserEnv() {
        var msie = /(msie|trident)/i.test(navigator.userAgent);
        var urlParsingNode = document.createElement("a");
        var originURL;
        function resolveURL(url) {
          var href = url;
          if (msie) {
            urlParsingNode.setAttribute("href", href);
            href = urlParsingNode.href;
          }
          urlParsingNode.setAttribute("href", href);
          return {
            href: urlParsingNode.href,
            protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, "") : "",
            host: urlParsingNode.host,
            search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, "") : "",
            hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, "") : "",
            hostname: urlParsingNode.hostname,
            port: urlParsingNode.port,
            pathname: urlParsingNode.pathname.charAt(0) === "/" ? urlParsingNode.pathname : "/" + urlParsingNode.pathname
          };
        }
        originURL = resolveURL(window.location.href);
        return function isURLSameOrigin(requestURL) {
          var parsed = utils.isString(requestURL) ? resolveURL(requestURL) : requestURL;
          return parsed.protocol === originURL.protocol && parsed.host === originURL.host;
        };
      }() : function nonStandardBrowserEnv() {
        return function isURLSameOrigin() {
          return true;
        };
      }();
    }
  });

  // node_modules/axios/lib/adapters/xhr.js
  var require_xhr = __commonJS({
    "node_modules/axios/lib/adapters/xhr.js"(exports2, module2) {
      "use strict";
      var utils = require_utils8();
      var settle = require_settle();
      var cookies = require_cookies();
      var buildURL = require_buildURL();
      var buildFullPath = require_buildFullPath();
      var parseHeaders = require_parseHeaders();
      var isURLSameOrigin = require_isURLSameOrigin();
      var createError = require_createError();
      module2.exports = function xhrAdapter(config) {
        return new Promise(function dispatchXhrRequest(resolve, reject) {
          var requestData = config.data;
          var requestHeaders = config.headers;
          var responseType = config.responseType;
          if (utils.isFormData(requestData)) {
            delete requestHeaders["Content-Type"];
          }
          var request = new XMLHttpRequest();
          if (config.auth) {
            var username = config.auth.username || "";
            var password = config.auth.password ? unescape(encodeURIComponent(config.auth.password)) : "";
            requestHeaders.Authorization = "Basic " + btoa(username + ":" + password);
          }
          var fullPath = buildFullPath(config.baseURL, config.url);
          request.open(config.method.toUpperCase(), buildURL(fullPath, config.params, config.paramsSerializer), true);
          request.timeout = config.timeout;
          function onloadend() {
            if (!request) {
              return;
            }
            var responseHeaders = "getAllResponseHeaders" in request ? parseHeaders(request.getAllResponseHeaders()) : null;
            var responseData = !responseType || responseType === "text" || responseType === "json" ? request.responseText : request.response;
            var response = {
              data: responseData,
              status: request.status,
              statusText: request.statusText,
              headers: responseHeaders,
              config,
              request
            };
            settle(resolve, reject, response);
            request = null;
          }
          if ("onloadend" in request) {
            request.onloadend = onloadend;
          } else {
            request.onreadystatechange = function handleLoad() {
              if (!request || request.readyState !== 4) {
                return;
              }
              if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf("file:") === 0)) {
                return;
              }
              setTimeout(onloadend);
            };
          }
          request.onabort = function handleAbort() {
            if (!request) {
              return;
            }
            reject(createError("Request aborted", config, "ECONNABORTED", request));
            request = null;
          };
          request.onerror = function handleError() {
            reject(createError("Network Error", config, null, request));
            request = null;
          };
          request.ontimeout = function handleTimeout() {
            var timeoutErrorMessage = "timeout of " + config.timeout + "ms exceeded";
            if (config.timeoutErrorMessage) {
              timeoutErrorMessage = config.timeoutErrorMessage;
            }
            reject(createError(timeoutErrorMessage, config, config.transitional && config.transitional.clarifyTimeoutError ? "ETIMEDOUT" : "ECONNABORTED", request));
            request = null;
          };
          if (utils.isStandardBrowserEnv()) {
            var xsrfValue = (config.withCredentials || isURLSameOrigin(fullPath)) && config.xsrfCookieName ? cookies.read(config.xsrfCookieName) : void 0;
            if (xsrfValue) {
              requestHeaders[config.xsrfHeaderName] = xsrfValue;
            }
          }
          if ("setRequestHeader" in request) {
            utils.forEach(requestHeaders, function setRequestHeader(val, key) {
              if (typeof requestData === "undefined" && key.toLowerCase() === "content-type") {
                delete requestHeaders[key];
              } else {
                request.setRequestHeader(key, val);
              }
            });
          }
          if (!utils.isUndefined(config.withCredentials)) {
            request.withCredentials = !!config.withCredentials;
          }
          if (responseType && responseType !== "json") {
            request.responseType = config.responseType;
          }
          if (typeof config.onDownloadProgress === "function") {
            request.addEventListener("progress", config.onDownloadProgress);
          }
          if (typeof config.onUploadProgress === "function" && request.upload) {
            request.upload.addEventListener("progress", config.onUploadProgress);
          }
          if (config.cancelToken) {
            config.cancelToken.promise.then(function onCanceled(cancel) {
              if (!request) {
                return;
              }
              request.abort();
              reject(cancel);
              request = null;
            });
          }
          if (!requestData) {
            requestData = null;
          }
          request.send(requestData);
        });
      };
    }
  });

  // node_modules/axios/lib/defaults.js
  var require_defaults = __commonJS({
    "node_modules/axios/lib/defaults.js"(exports2, module2) {
      "use strict";
      var utils = require_utils8();
      var normalizeHeaderName = require_normalizeHeaderName();
      var enhanceError = require_enhanceError();
      var DEFAULT_CONTENT_TYPE = {
        "Content-Type": "application/x-www-form-urlencoded"
      };
      function setContentTypeIfUnset(headers, value) {
        if (!utils.isUndefined(headers) && utils.isUndefined(headers["Content-Type"])) {
          headers["Content-Type"] = value;
        }
      }
      function getDefaultAdapter() {
        var adapter;
        if (typeof XMLHttpRequest !== "undefined") {
          adapter = require_xhr();
        } else if (typeof process !== "undefined" && Object.prototype.toString.call(process) === "[object process]") {
          adapter = require_xhr();
        }
        return adapter;
      }
      function stringifySafely(rawValue, parser, encoder) {
        if (utils.isString(rawValue)) {
          try {
            (parser || JSON.parse)(rawValue);
            return utils.trim(rawValue);
          } catch (e) {
            if (e.name !== "SyntaxError") {
              throw e;
            }
          }
        }
        return (encoder || JSON.stringify)(rawValue);
      }
      var defaults = {
        transitional: {
          silentJSONParsing: true,
          forcedJSONParsing: true,
          clarifyTimeoutError: false
        },
        adapter: getDefaultAdapter(),
        transformRequest: [function transformRequest(data, headers) {
          normalizeHeaderName(headers, "Accept");
          normalizeHeaderName(headers, "Content-Type");
          if (utils.isFormData(data) || utils.isArrayBuffer(data) || utils.isBuffer(data) || utils.isStream(data) || utils.isFile(data) || utils.isBlob(data)) {
            return data;
          }
          if (utils.isArrayBufferView(data)) {
            return data.buffer;
          }
          if (utils.isURLSearchParams(data)) {
            setContentTypeIfUnset(headers, "application/x-www-form-urlencoded;charset=utf-8");
            return data.toString();
          }
          if (utils.isObject(data) || headers && headers["Content-Type"] === "application/json") {
            setContentTypeIfUnset(headers, "application/json");
            return stringifySafely(data);
          }
          return data;
        }],
        transformResponse: [function transformResponse(data) {
          var transitional = this.transitional;
          var silentJSONParsing = transitional && transitional.silentJSONParsing;
          var forcedJSONParsing = transitional && transitional.forcedJSONParsing;
          var strictJSONParsing = !silentJSONParsing && this.responseType === "json";
          if (strictJSONParsing || forcedJSONParsing && utils.isString(data) && data.length) {
            try {
              return JSON.parse(data);
            } catch (e) {
              if (strictJSONParsing) {
                if (e.name === "SyntaxError") {
                  throw enhanceError(e, this, "E_JSON_PARSE");
                }
                throw e;
              }
            }
          }
          return data;
        }],
        timeout: 0,
        xsrfCookieName: "XSRF-TOKEN",
        xsrfHeaderName: "X-XSRF-TOKEN",
        maxContentLength: -1,
        maxBodyLength: -1,
        validateStatus: function validateStatus(status) {
          return status >= 200 && status < 300;
        }
      };
      defaults.headers = {
        common: {
          "Accept": "application/json, text/plain, */*"
        }
      };
      utils.forEach(["delete", "get", "head"], function forEachMethodNoData(method) {
        defaults.headers[method] = {};
      });
      utils.forEach(["post", "put", "patch"], function forEachMethodWithData(method) {
        defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);
      });
      module2.exports = defaults;
    }
  });

  // node_modules/axios/lib/core/transformData.js
  var require_transformData = __commonJS({
    "node_modules/axios/lib/core/transformData.js"(exports2, module2) {
      "use strict";
      var utils = require_utils8();
      var defaults = require_defaults();
      module2.exports = function transformData(data, headers, fns) {
        var context = this || defaults;
        utils.forEach(fns, function transform(fn) {
          data = fn.call(context, data, headers);
        });
        return data;
      };
    }
  });

  // node_modules/axios/lib/cancel/isCancel.js
  var require_isCancel = __commonJS({
    "node_modules/axios/lib/cancel/isCancel.js"(exports2, module2) {
      "use strict";
      module2.exports = function isCancel(value) {
        return !!(value && value.__CANCEL__);
      };
    }
  });

  // node_modules/axios/lib/core/dispatchRequest.js
  var require_dispatchRequest = __commonJS({
    "node_modules/axios/lib/core/dispatchRequest.js"(exports2, module2) {
      "use strict";
      var utils = require_utils8();
      var transformData = require_transformData();
      var isCancel = require_isCancel();
      var defaults = require_defaults();
      function throwIfCancellationRequested(config) {
        if (config.cancelToken) {
          config.cancelToken.throwIfRequested();
        }
      }
      module2.exports = function dispatchRequest(config) {
        throwIfCancellationRequested(config);
        config.headers = config.headers || {};
        config.data = transformData.call(config, config.data, config.headers, config.transformRequest);
        config.headers = utils.merge(config.headers.common || {}, config.headers[config.method] || {}, config.headers);
        utils.forEach(["delete", "get", "head", "post", "put", "patch", "common"], function cleanHeaderConfig(method) {
          delete config.headers[method];
        });
        var adapter = config.adapter || defaults.adapter;
        return adapter(config).then(function onAdapterResolution(response) {
          throwIfCancellationRequested(config);
          response.data = transformData.call(config, response.data, response.headers, config.transformResponse);
          return response;
        }, function onAdapterRejection(reason) {
          if (!isCancel(reason)) {
            throwIfCancellationRequested(config);
            if (reason && reason.response) {
              reason.response.data = transformData.call(config, reason.response.data, reason.response.headers, config.transformResponse);
            }
          }
          return Promise.reject(reason);
        });
      };
    }
  });

  // node_modules/axios/lib/core/mergeConfig.js
  var require_mergeConfig = __commonJS({
    "node_modules/axios/lib/core/mergeConfig.js"(exports2, module2) {
      "use strict";
      var utils = require_utils8();
      module2.exports = function mergeConfig(config1, config2) {
        config2 = config2 || {};
        var config = {};
        var valueFromConfig2Keys = ["url", "method", "data"];
        var mergeDeepPropertiesKeys = ["headers", "auth", "proxy", "params"];
        var defaultToConfig2Keys = [
          "baseURL",
          "transformRequest",
          "transformResponse",
          "paramsSerializer",
          "timeout",
          "timeoutMessage",
          "withCredentials",
          "adapter",
          "responseType",
          "xsrfCookieName",
          "xsrfHeaderName",
          "onUploadProgress",
          "onDownloadProgress",
          "decompress",
          "maxContentLength",
          "maxBodyLength",
          "maxRedirects",
          "transport",
          "httpAgent",
          "httpsAgent",
          "cancelToken",
          "socketPath",
          "responseEncoding"
        ];
        var directMergeKeys = ["validateStatus"];
        function getMergedValue(target, source) {
          if (utils.isPlainObject(target) && utils.isPlainObject(source)) {
            return utils.merge(target, source);
          } else if (utils.isPlainObject(source)) {
            return utils.merge({}, source);
          } else if (utils.isArray(source)) {
            return source.slice();
          }
          return source;
        }
        function mergeDeepProperties(prop) {
          if (!utils.isUndefined(config2[prop])) {
            config[prop] = getMergedValue(config1[prop], config2[prop]);
          } else if (!utils.isUndefined(config1[prop])) {
            config[prop] = getMergedValue(void 0, config1[prop]);
          }
        }
        utils.forEach(valueFromConfig2Keys, function valueFromConfig2(prop) {
          if (!utils.isUndefined(config2[prop])) {
            config[prop] = getMergedValue(void 0, config2[prop]);
          }
        });
        utils.forEach(mergeDeepPropertiesKeys, mergeDeepProperties);
        utils.forEach(defaultToConfig2Keys, function defaultToConfig2(prop) {
          if (!utils.isUndefined(config2[prop])) {
            config[prop] = getMergedValue(void 0, config2[prop]);
          } else if (!utils.isUndefined(config1[prop])) {
            config[prop] = getMergedValue(void 0, config1[prop]);
          }
        });
        utils.forEach(directMergeKeys, function merge(prop) {
          if (prop in config2) {
            config[prop] = getMergedValue(config1[prop], config2[prop]);
          } else if (prop in config1) {
            config[prop] = getMergedValue(void 0, config1[prop]);
          }
        });
        var axiosKeys = valueFromConfig2Keys.concat(mergeDeepPropertiesKeys).concat(defaultToConfig2Keys).concat(directMergeKeys);
        var otherKeys = Object.keys(config1).concat(Object.keys(config2)).filter(function filterAxiosKeys(key) {
          return axiosKeys.indexOf(key) === -1;
        });
        utils.forEach(otherKeys, mergeDeepProperties);
        return config;
      };
    }
  });

  // node_modules/axios/package.json
  var require_package2 = __commonJS({
    "node_modules/axios/package.json"(exports2, module2) {
      module2.exports = {
        name: "axios",
        version: "0.21.4",
        description: "Promise based HTTP client for the browser and node.js",
        main: "index.js",
        scripts: {
          test: "grunt test",
          start: "node ./sandbox/server.js",
          build: "NODE_ENV=production grunt build",
          preversion: "npm test",
          version: "npm run build && grunt version && git add -A dist && git add CHANGELOG.md bower.json package.json",
          postversion: "git push && git push --tags",
          examples: "node ./examples/server.js",
          coveralls: "cat coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js",
          fix: "eslint --fix lib/**/*.js"
        },
        repository: {
          type: "git",
          url: "https://github.com/axios/axios.git"
        },
        keywords: [
          "xhr",
          "http",
          "ajax",
          "promise",
          "node"
        ],
        author: "Matt Zabriskie",
        license: "MIT",
        bugs: {
          url: "https://github.com/axios/axios/issues"
        },
        homepage: "https://axios-http.com",
        devDependencies: {
          coveralls: "^3.0.0",
          "es6-promise": "^4.2.4",
          grunt: "^1.3.0",
          "grunt-banner": "^0.6.0",
          "grunt-cli": "^1.2.0",
          "grunt-contrib-clean": "^1.1.0",
          "grunt-contrib-watch": "^1.0.0",
          "grunt-eslint": "^23.0.0",
          "grunt-karma": "^4.0.0",
          "grunt-mocha-test": "^0.13.3",
          "grunt-ts": "^6.0.0-beta.19",
          "grunt-webpack": "^4.0.2",
          "istanbul-instrumenter-loader": "^1.0.0",
          "jasmine-core": "^2.4.1",
          karma: "^6.3.2",
          "karma-chrome-launcher": "^3.1.0",
          "karma-firefox-launcher": "^2.1.0",
          "karma-jasmine": "^1.1.1",
          "karma-jasmine-ajax": "^0.1.13",
          "karma-safari-launcher": "^1.0.0",
          "karma-sauce-launcher": "^4.3.6",
          "karma-sinon": "^1.0.5",
          "karma-sourcemap-loader": "^0.3.8",
          "karma-webpack": "^4.0.2",
          "load-grunt-tasks": "^3.5.2",
          minimist: "^1.2.0",
          mocha: "^8.2.1",
          sinon: "^4.5.0",
          "terser-webpack-plugin": "^4.2.3",
          typescript: "^4.0.5",
          "url-search-params": "^0.10.0",
          webpack: "^4.44.2",
          "webpack-dev-server": "^3.11.0"
        },
        browser: {
          "./lib/adapters/http.js": "./lib/adapters/xhr.js"
        },
        jsdelivr: "dist/axios.min.js",
        unpkg: "dist/axios.min.js",
        typings: "./index.d.ts",
        dependencies: {
          "follow-redirects": "^1.14.0"
        },
        bundlesize: [
          {
            path: "./dist/axios.min.js",
            threshold: "5kB"
          }
        ]
      };
    }
  });

  // node_modules/axios/lib/helpers/validator.js
  var require_validator2 = __commonJS({
    "node_modules/axios/lib/helpers/validator.js"(exports2, module2) {
      "use strict";
      var pkg = require_package2();
      var validators = {};
      ["object", "boolean", "number", "function", "string", "symbol"].forEach(function(type, i) {
        validators[type] = function validator(thing) {
          return typeof thing === type || "a" + (i < 1 ? "n " : " ") + type;
        };
      });
      var deprecatedWarnings = {};
      var currentVerArr = pkg.version.split(".");
      function isOlderVersion(version, thanVersion) {
        var pkgVersionArr = thanVersion ? thanVersion.split(".") : currentVerArr;
        var destVer = version.split(".");
        for (var i = 0; i < 3; i++) {
          if (pkgVersionArr[i] > destVer[i]) {
            return true;
          } else if (pkgVersionArr[i] < destVer[i]) {
            return false;
          }
        }
        return false;
      }
      validators.transitional = function transitional(validator, version, message) {
        var isDeprecated = version && isOlderVersion(version);
        function formatMessage(opt, desc) {
          return "[Axios v" + pkg.version + "] Transitional option '" + opt + "'" + desc + (message ? ". " + message : "");
        }
        return function(value, opt, opts) {
          if (validator === false) {
            throw new Error(formatMessage(opt, " has been removed in " + version));
          }
          if (isDeprecated && !deprecatedWarnings[opt]) {
            deprecatedWarnings[opt] = true;
            console.warn(formatMessage(opt, " has been deprecated since v" + version + " and will be removed in the near future"));
          }
          return validator ? validator(value, opt, opts) : true;
        };
      };
      function assertOptions(options, schema, allowUnknown) {
        if (typeof options !== "object") {
          throw new TypeError("options must be an object");
        }
        var keys = Object.keys(options);
        var i = keys.length;
        while (i-- > 0) {
          var opt = keys[i];
          var validator = schema[opt];
          if (validator) {
            var value = options[opt];
            var result = value === void 0 || validator(value, opt, options);
            if (result !== true) {
              throw new TypeError("option " + opt + " must be " + result);
            }
            continue;
          }
          if (allowUnknown !== true) {
            throw Error("Unknown option " + opt);
          }
        }
      }
      module2.exports = {
        isOlderVersion,
        assertOptions,
        validators
      };
    }
  });

  // node_modules/axios/lib/core/Axios.js
  var require_Axios = __commonJS({
    "node_modules/axios/lib/core/Axios.js"(exports2, module2) {
      "use strict";
      var utils = require_utils8();
      var buildURL = require_buildURL();
      var InterceptorManager = require_InterceptorManager();
      var dispatchRequest = require_dispatchRequest();
      var mergeConfig = require_mergeConfig();
      var validator = require_validator2();
      var validators = validator.validators;
      function Axios(instanceConfig) {
        this.defaults = instanceConfig;
        this.interceptors = {
          request: new InterceptorManager(),
          response: new InterceptorManager()
        };
      }
      Axios.prototype.request = function request(config) {
        if (typeof config === "string") {
          config = arguments[1] || {};
          config.url = arguments[0];
        } else {
          config = config || {};
        }
        config = mergeConfig(this.defaults, config);
        if (config.method) {
          config.method = config.method.toLowerCase();
        } else if (this.defaults.method) {
          config.method = this.defaults.method.toLowerCase();
        } else {
          config.method = "get";
        }
        var transitional = config.transitional;
        if (transitional !== void 0) {
          validator.assertOptions(transitional, {
            silentJSONParsing: validators.transitional(validators.boolean, "1.0.0"),
            forcedJSONParsing: validators.transitional(validators.boolean, "1.0.0"),
            clarifyTimeoutError: validators.transitional(validators.boolean, "1.0.0")
          }, false);
        }
        var requestInterceptorChain = [];
        var synchronousRequestInterceptors = true;
        this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
          if (typeof interceptor.runWhen === "function" && interceptor.runWhen(config) === false) {
            return;
          }
          synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;
          requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
        });
        var responseInterceptorChain = [];
        this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
          responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
        });
        var promise;
        if (!synchronousRequestInterceptors) {
          var chain = [dispatchRequest, void 0];
          Array.prototype.unshift.apply(chain, requestInterceptorChain);
          chain = chain.concat(responseInterceptorChain);
          promise = Promise.resolve(config);
          while (chain.length) {
            promise = promise.then(chain.shift(), chain.shift());
          }
          return promise;
        }
        var newConfig = config;
        while (requestInterceptorChain.length) {
          var onFulfilled = requestInterceptorChain.shift();
          var onRejected = requestInterceptorChain.shift();
          try {
            newConfig = onFulfilled(newConfig);
          } catch (error) {
            onRejected(error);
            break;
          }
        }
        try {
          promise = dispatchRequest(newConfig);
        } catch (error) {
          return Promise.reject(error);
        }
        while (responseInterceptorChain.length) {
          promise = promise.then(responseInterceptorChain.shift(), responseInterceptorChain.shift());
        }
        return promise;
      };
      Axios.prototype.getUri = function getUri(config) {
        config = mergeConfig(this.defaults, config);
        return buildURL(config.url, config.params, config.paramsSerializer).replace(/^\?/, "");
      };
      utils.forEach(["delete", "get", "head", "options"], function forEachMethodNoData(method) {
        Axios.prototype[method] = function(url, config) {
          return this.request(mergeConfig(config || {}, {
            method,
            url,
            data: (config || {}).data
          }));
        };
      });
      utils.forEach(["post", "put", "patch"], function forEachMethodWithData(method) {
        Axios.prototype[method] = function(url, data, config) {
          return this.request(mergeConfig(config || {}, {
            method,
            url,
            data
          }));
        };
      });
      module2.exports = Axios;
    }
  });

  // node_modules/axios/lib/cancel/Cancel.js
  var require_Cancel = __commonJS({
    "node_modules/axios/lib/cancel/Cancel.js"(exports2, module2) {
      "use strict";
      function Cancel(message) {
        this.message = message;
      }
      Cancel.prototype.toString = function toString() {
        return "Cancel" + (this.message ? ": " + this.message : "");
      };
      Cancel.prototype.__CANCEL__ = true;
      module2.exports = Cancel;
    }
  });

  // node_modules/axios/lib/cancel/CancelToken.js
  var require_CancelToken = __commonJS({
    "node_modules/axios/lib/cancel/CancelToken.js"(exports2, module2) {
      "use strict";
      var Cancel = require_Cancel();
      function CancelToken(executor) {
        if (typeof executor !== "function") {
          throw new TypeError("executor must be a function.");
        }
        var resolvePromise;
        this.promise = new Promise(function promiseExecutor(resolve) {
          resolvePromise = resolve;
        });
        var token = this;
        executor(function cancel(message) {
          if (token.reason) {
            return;
          }
          token.reason = new Cancel(message);
          resolvePromise(token.reason);
        });
      }
      CancelToken.prototype.throwIfRequested = function throwIfRequested() {
        if (this.reason) {
          throw this.reason;
        }
      };
      CancelToken.source = function source() {
        var cancel;
        var token = new CancelToken(function executor(c) {
          cancel = c;
        });
        return {
          token,
          cancel
        };
      };
      module2.exports = CancelToken;
    }
  });

  // node_modules/axios/lib/helpers/spread.js
  var require_spread = __commonJS({
    "node_modules/axios/lib/helpers/spread.js"(exports2, module2) {
      "use strict";
      module2.exports = function spread(callback) {
        return function wrap(arr) {
          return callback.apply(null, arr);
        };
      };
    }
  });

  // node_modules/axios/lib/helpers/isAxiosError.js
  var require_isAxiosError = __commonJS({
    "node_modules/axios/lib/helpers/isAxiosError.js"(exports2, module2) {
      "use strict";
      module2.exports = function isAxiosError(payload) {
        return typeof payload === "object" && payload.isAxiosError === true;
      };
    }
  });

  // node_modules/axios/lib/axios.js
  var require_axios = __commonJS({
    "node_modules/axios/lib/axios.js"(exports2, module2) {
      "use strict";
      var utils = require_utils8();
      var bind = require_bind();
      var Axios = require_Axios();
      var mergeConfig = require_mergeConfig();
      var defaults = require_defaults();
      function createInstance(defaultConfig) {
        var context = new Axios(defaultConfig);
        var instance = bind(Axios.prototype.request, context);
        utils.extend(instance, Axios.prototype, context);
        utils.extend(instance, context);
        return instance;
      }
      var axios = createInstance(defaults);
      axios.Axios = Axios;
      axios.create = function create(instanceConfig) {
        return createInstance(mergeConfig(axios.defaults, instanceConfig));
      };
      axios.Cancel = require_Cancel();
      axios.CancelToken = require_CancelToken();
      axios.isCancel = require_isCancel();
      axios.all = function all(promises) {
        return Promise.all(promises);
      };
      axios.spread = require_spread();
      axios.isAxiosError = require_isAxiosError();
      module2.exports = axios;
      module2.exports.default = axios;
    }
  });

  // node_modules/axios/index.js
  var require_axios2 = __commonJS({
    "node_modules/axios/index.js"(exports2, module2) {
      module2.exports = require_axios();
    }
  });

  // node_modules/@cosmjs/tendermint-rpc/build/rpcclients/rpcclient.js
  var require_rpcclient = __commonJS({
    "node_modules/@cosmjs/tendermint-rpc/build/rpcclients/rpcclient.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.hasProtocol = exports2.instanceOfRpcStreamingClient = void 0;
      function instanceOfRpcStreamingClient(client) {
        return typeof client.listen === "function";
      }
      exports2.instanceOfRpcStreamingClient = instanceOfRpcStreamingClient;
      function hasProtocol(url) {
        return url.search("://") !== -1;
      }
      exports2.hasProtocol = hasProtocol;
    }
  });

  // node_modules/@cosmjs/tendermint-rpc/build/rpcclients/httpclient.js
  var require_httpclient = __commonJS({
    "node_modules/@cosmjs/tendermint-rpc/build/rpcclients/httpclient.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.HttpClient = exports2.http = void 0;
      var json_rpc_1 = require_build9();
      var axios_1 = __importDefault(require_axios2());
      var rpcclient_1 = require_rpcclient();
      function filterBadStatus(res) {
        if (res.status >= 400) {
          throw new Error(`Bad status on response: ${res.status}`);
        }
        return res;
      }
      async function http(method, url, headers, request) {
        if (typeof fetch !== "undefined") {
          const settings = {
            method,
            body: request ? JSON.stringify(request) : void 0,
            headers: {
              "Content-Type": "application/json",
              ...headers
            }
          };
          return fetch(url, settings).then(filterBadStatus).then((res) => res.json());
        } else {
          return axios_1.default.request({ url, method, data: request, headers }).then((res) => res.data);
        }
      }
      exports2.http = http;
      var HttpClient = class {
        constructor(endpoint) {
          if (typeof endpoint === "string") {
            this.url = (0, rpcclient_1.hasProtocol)(endpoint) ? endpoint : "http://" + endpoint;
          } else {
            this.url = endpoint.url;
            this.headers = endpoint.headers;
          }
        }
        disconnect() {
        }
        async execute(request) {
          const response = (0, json_rpc_1.parseJsonRpcResponse)(await http("POST", this.url, this.headers, request));
          if ((0, json_rpc_1.isJsonRpcErrorResponse)(response)) {
            throw new Error(JSON.stringify(response.error));
          }
          return response;
        }
      };
      exports2.HttpClient = HttpClient;
    }
  });

  // node_modules/isomorphic-ws/browser.js
  var require_browser13 = __commonJS({
    "node_modules/isomorphic-ws/browser.js"(exports2, module2) {
      var ws = null;
      if (typeof WebSocket !== "undefined") {
        ws = WebSocket;
      } else if (typeof MozWebSocket !== "undefined") {
        ws = MozWebSocket;
      } else if (typeof global !== "undefined") {
        ws = global.WebSocket || global.MozWebSocket;
      } else if (typeof window !== "undefined") {
        ws = window.WebSocket || window.MozWebSocket;
      } else if (typeof self !== "undefined") {
        ws = self.WebSocket || self.MozWebSocket;
      }
      module2.exports = ws;
    }
  });

  // node_modules/@cosmjs/socket/build/socketwrapper.js
  var require_socketwrapper = __commonJS({
    "node_modules/@cosmjs/socket/build/socketwrapper.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.SocketWrapper = void 0;
      var isomorphic_ws_1 = __importDefault(require_browser13());
      function environmentIsNodeJs() {
        return typeof process !== "undefined" && typeof process.versions !== "undefined" && typeof process.versions.node !== "undefined";
      }
      var SocketWrapper = class {
        constructor(url, messageHandler, errorHandler, openHandler, closeHandler, timeout = 1e4) {
          this.closed = false;
          this.connected = new Promise((resolve, reject) => {
            this.connectedResolver = resolve;
            this.connectedRejecter = reject;
          });
          this.url = url;
          this.messageHandler = messageHandler;
          this.errorHandler = errorHandler;
          this.openHandler = openHandler;
          this.closeHandler = closeHandler;
          this.timeout = timeout;
        }
        connect() {
          const socket = new isomorphic_ws_1.default(this.url);
          socket.onerror = (error) => {
            this.clearTimeout();
            if (this.errorHandler) {
              this.errorHandler(error);
            }
          };
          socket.onmessage = (messageEvent) => {
            this.messageHandler({
              type: messageEvent.type,
              data: messageEvent.data
            });
          };
          socket.onopen = (_) => {
            this.clearTimeout();
            this.connectedResolver();
            if (this.openHandler) {
              this.openHandler();
            }
          };
          socket.onclose = (closeEvent) => {
            this.closed = true;
            if (this.closeHandler) {
              this.closeHandler(closeEvent);
            }
          };
          const started = Date.now();
          this.timeoutId = setTimeout(() => {
            socket.onmessage = () => 0;
            socket.onerror = () => 0;
            socket.onopen = () => 0;
            socket.onclose = () => 0;
            socket.close();
            this.socket = void 0;
            const elapsed = Math.floor(Date.now() - started);
            this.connectedRejecter(`Connection attempt timed out after ${elapsed} ms`);
          }, this.timeout);
          this.socket = socket;
        }
        disconnect() {
          if (!this.socket) {
            throw new Error("Socket undefined. This must be called after connecting.");
          }
          this.clearTimeout();
          switch (this.socket.readyState) {
            case isomorphic_ws_1.default.OPEN:
              this.socket.close(1e3);
              break;
            case isomorphic_ws_1.default.CLOSED:
              break;
            case isomorphic_ws_1.default.CONNECTING:
              this.socket.onopen = () => 0;
              this.socket.onclose = () => 0;
              this.socket.onerror = () => 0;
              this.socket.onmessage = () => 0;
              this.socket = void 0;
              if (this.closeHandler) {
                this.closeHandler({ wasClean: false, code: 4001 });
              }
              break;
            case isomorphic_ws_1.default.CLOSING:
              break;
            default:
              throw new Error(`Unknown readyState: ${this.socket.readyState}`);
          }
        }
        async send(data) {
          return new Promise((resolve, reject) => {
            if (!this.socket) {
              throw new Error("Socket undefined. This must be called after connecting.");
            }
            if (this.closed) {
              throw new Error("Socket was closed, so no data can be sent anymore.");
            }
            if (this.socket.readyState !== isomorphic_ws_1.default.OPEN) {
              throw new Error("Websocket is not open");
            }
            if (environmentIsNodeJs()) {
              this.socket.send(data, (err) => err ? reject(err) : resolve());
            } else {
              this.socket.send(data);
              resolve();
            }
          });
        }
        clearTimeout() {
          if (!this.timeoutId) {
            throw new Error("Timeout ID not set. This should not happen and usually means connect() was not called.");
          }
          clearTimeout(this.timeoutId);
        }
      };
      exports2.SocketWrapper = SocketWrapper;
    }
  });

  // node_modules/@cosmjs/socket/build/streamingsocket.js
  var require_streamingsocket = __commonJS({
    "node_modules/@cosmjs/socket/build/streamingsocket.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.StreamingSocket = void 0;
      var xstream_1 = require_xstream();
      var socketwrapper_1 = require_socketwrapper();
      var StreamingSocket = class {
        constructor(url, timeout = 1e4) {
          this.socket = new socketwrapper_1.SocketWrapper(url, (event) => {
            if (this.eventProducerListener) {
              this.eventProducerListener.next(event);
            }
          }, (errorEvent) => {
            if (this.eventProducerListener) {
              this.eventProducerListener.error(errorEvent);
            }
          }, () => {
          }, (closeEvent) => {
            if (this.eventProducerListener) {
              if (closeEvent.wasClean) {
                this.eventProducerListener.complete();
              } else {
                this.eventProducerListener.error("Socket was closed unclean");
              }
            }
          }, timeout);
          this.connected = this.socket.connected;
          const eventProducer = {
            start: (listener) => this.eventProducerListener = listener,
            stop: () => this.eventProducerListener = void 0
          };
          this.events = xstream_1.Stream.create(eventProducer);
        }
        connect() {
          this.socket.connect();
        }
        disconnect() {
          this.socket.disconnect();
        }
        async send(data) {
          return this.socket.send(data);
        }
      };
      exports2.StreamingSocket = StreamingSocket;
    }
  });

  // node_modules/@cosmjs/socket/build/queueingstreamingsocket.js
  var require_queueingstreamingsocket = __commonJS({
    "node_modules/@cosmjs/socket/build/queueingstreamingsocket.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.QueueingStreamingSocket = exports2.ConnectionStatus = void 0;
      var stream_1 = require_build8();
      var xstream_1 = require_xstream();
      var streamingsocket_1 = require_streamingsocket();
      var ConnectionStatus;
      (function(ConnectionStatus2) {
        ConnectionStatus2[ConnectionStatus2["Unconnected"] = 0] = "Unconnected";
        ConnectionStatus2[ConnectionStatus2["Connecting"] = 1] = "Connecting";
        ConnectionStatus2[ConnectionStatus2["Connected"] = 2] = "Connected";
        ConnectionStatus2[ConnectionStatus2["Disconnected"] = 3] = "Disconnected";
      })(ConnectionStatus = exports2.ConnectionStatus || (exports2.ConnectionStatus = {}));
      var QueueingStreamingSocket = class {
        constructor(url, timeout = 1e4, reconnectedHandler) {
          this.queue = [];
          this.isProcessingQueue = false;
          this.url = url;
          this.timeout = timeout;
          this.reconnectedHandler = reconnectedHandler;
          const eventProducer = {
            start: (listener) => this.eventProducerListener = listener,
            stop: () => this.eventProducerListener = void 0
          };
          this.events = xstream_1.Stream.create(eventProducer);
          this.connectionStatusProducer = new stream_1.DefaultValueProducer(ConnectionStatus.Unconnected);
          this.connectionStatus = new stream_1.ValueAndUpdates(this.connectionStatusProducer);
          this.socket = new streamingsocket_1.StreamingSocket(this.url, this.timeout);
          this.socket.events.subscribe({
            next: (event) => {
              if (!this.eventProducerListener)
                throw new Error("No event producer listener set");
              this.eventProducerListener.next(event);
            },
            error: () => this.connectionStatusProducer.update(ConnectionStatus.Disconnected)
          });
        }
        connect() {
          this.connectionStatusProducer.update(ConnectionStatus.Connecting);
          this.socket.connected.then(async () => {
            this.connectionStatusProducer.update(ConnectionStatus.Connected);
            return this.processQueue();
          }, () => this.connectionStatusProducer.update(ConnectionStatus.Disconnected));
          this.socket.connect();
        }
        disconnect() {
          this.connectionStatusProducer.update(ConnectionStatus.Disconnected);
          this.socket.disconnect();
        }
        reconnect() {
          this.socket = new streamingsocket_1.StreamingSocket(this.url, this.timeout);
          this.socket.events.subscribe({
            next: (event) => {
              if (!this.eventProducerListener)
                throw new Error("No event producer listener set");
              this.eventProducerListener.next(event);
            },
            error: () => this.connectionStatusProducer.update(ConnectionStatus.Disconnected)
          });
          this.socket.connected.then(() => {
            if (this.reconnectedHandler) {
              this.reconnectedHandler();
            }
          });
          this.connect();
        }
        getQueueLength() {
          return this.queue.length;
        }
        queueRequest(request) {
          this.queue.push(request);
          this.processQueue();
        }
        async processQueue() {
          if (this.isProcessingQueue || this.connectionStatus.value !== ConnectionStatus.Connected) {
            return;
          }
          this.isProcessingQueue = true;
          let request;
          while (request = this.queue.shift()) {
            try {
              await this.socket.send(request);
              this.isProcessingQueue = false;
            } catch (error) {
              this.queue.unshift(request);
              this.isProcessingQueue = false;
              return;
            }
          }
        }
      };
      exports2.QueueingStreamingSocket = QueueingStreamingSocket;
    }
  });

  // node_modules/@cosmjs/socket/build/reconnectingsocket.js
  var require_reconnectingsocket = __commonJS({
    "node_modules/@cosmjs/socket/build/reconnectingsocket.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.ReconnectingSocket = void 0;
      var xstream_1 = require_xstream();
      var queueingstreamingsocket_1 = require_queueingstreamingsocket();
      var ReconnectingSocket = class {
        constructor(url, timeout = 1e4, reconnectedHandler) {
          this.unconnected = true;
          this.disconnected = false;
          this.timeoutIndex = 0;
          this.reconnectTimeout = null;
          const eventProducer = {
            start: (listener) => this.eventProducerListener = listener,
            stop: () => this.eventProducerListener = void 0
          };
          this.events = xstream_1.Stream.create(eventProducer);
          this.socket = new queueingstreamingsocket_1.QueueingStreamingSocket(url, timeout, reconnectedHandler);
          this.socket.events.subscribe({
            next: (event) => {
              if (this.eventProducerListener) {
                this.eventProducerListener.next(event);
              }
            },
            error: (error) => {
              if (this.eventProducerListener) {
                this.eventProducerListener.error(error);
              }
            }
          });
          this.connectionStatus = this.socket.connectionStatus;
          this.connectionStatus.updates.subscribe({
            next: (status) => {
              if (status === queueingstreamingsocket_1.ConnectionStatus.Connected) {
                this.timeoutIndex = 0;
              }
              if (status === queueingstreamingsocket_1.ConnectionStatus.Disconnected) {
                if (this.reconnectTimeout) {
                  clearTimeout(this.reconnectTimeout);
                  this.reconnectTimeout = null;
                }
                this.reconnectTimeout = setTimeout(() => this.socket.reconnect(), ReconnectingSocket.calculateTimeout(this.timeoutIndex++));
              }
            }
          });
        }
        static calculateTimeout(index) {
          return Math.min(2 ** index * 100, 5e3);
        }
        connect() {
          if (!this.unconnected) {
            throw new Error("Cannot connect: socket has already connected");
          }
          this.socket.connect();
          this.unconnected = false;
        }
        disconnect() {
          if (this.unconnected) {
            throw new Error("Cannot disconnect: socket has not yet connected");
          }
          this.socket.disconnect();
          if (this.eventProducerListener) {
            this.eventProducerListener.complete();
          }
          this.disconnected = true;
        }
        queueRequest(request) {
          if (this.disconnected) {
            throw new Error("Cannot queue request: socket has disconnected");
          }
          this.socket.queueRequest(request);
        }
      };
      exports2.ReconnectingSocket = ReconnectingSocket;
    }
  });

  // node_modules/@cosmjs/socket/build/index.js
  var require_build10 = __commonJS({
    "node_modules/@cosmjs/socket/build/index.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.StreamingSocket = exports2.SocketWrapper = exports2.ReconnectingSocket = exports2.QueueingStreamingSocket = exports2.ConnectionStatus = void 0;
      var queueingstreamingsocket_1 = require_queueingstreamingsocket();
      Object.defineProperty(exports2, "ConnectionStatus", { enumerable: true, get: function() {
        return queueingstreamingsocket_1.ConnectionStatus;
      } });
      Object.defineProperty(exports2, "QueueingStreamingSocket", { enumerable: true, get: function() {
        return queueingstreamingsocket_1.QueueingStreamingSocket;
      } });
      var reconnectingsocket_1 = require_reconnectingsocket();
      Object.defineProperty(exports2, "ReconnectingSocket", { enumerable: true, get: function() {
        return reconnectingsocket_1.ReconnectingSocket;
      } });
      var socketwrapper_1 = require_socketwrapper();
      Object.defineProperty(exports2, "SocketWrapper", { enumerable: true, get: function() {
        return socketwrapper_1.SocketWrapper;
      } });
      var streamingsocket_1 = require_streamingsocket();
      Object.defineProperty(exports2, "StreamingSocket", { enumerable: true, get: function() {
        return streamingsocket_1.StreamingSocket;
      } });
    }
  });

  // node_modules/@cosmjs/tendermint-rpc/build/rpcclients/websocketclient.js
  var require_websocketclient = __commonJS({
    "node_modules/@cosmjs/tendermint-rpc/build/rpcclients/websocketclient.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.WebsocketClient = void 0;
      var json_rpc_1 = require_build9();
      var socket_1 = require_build10();
      var stream_1 = require_build8();
      var xstream_1 = require_xstream();
      var rpcclient_1 = require_rpcclient();
      function defaultErrorHandler(error) {
        throw error;
      }
      function toJsonRpcResponse(message) {
        if (message.type !== "message") {
          throw new Error(`Unexcepted message type on websocket: ${message.type}`);
        }
        const jsonRpcEvent = (0, json_rpc_1.parseJsonRpcResponse)(JSON.parse(message.data));
        return jsonRpcEvent;
      }
      var RpcEventProducer = class {
        constructor(request, socket) {
          this.running = false;
          this.subscriptions = [];
          this.request = request;
          this.socket = socket;
        }
        start(listener) {
          if (this.running) {
            throw Error("Already started. Please stop first before restarting.");
          }
          this.running = true;
          this.connectToClient(listener);
          this.socket.queueRequest(JSON.stringify(this.request));
        }
        stop() {
          this.running = false;
          const endRequest = { ...this.request, method: "unsubscribe" };
          try {
            this.socket.queueRequest(JSON.stringify(endRequest));
          } catch (error) {
            if (error instanceof Error && error.message.match(/socket has disconnected/i)) {
            } else {
              throw error;
            }
          }
        }
        connectToClient(listener) {
          const responseStream = this.socket.events.map(toJsonRpcResponse);
          const idSubscription = responseStream.filter((response) => response.id === this.request.id).subscribe({
            next: (response) => {
              if ((0, json_rpc_1.isJsonRpcErrorResponse)(response)) {
                this.closeSubscriptions();
                listener.error(JSON.stringify(response.error));
              }
              idSubscription.unsubscribe();
            }
          });
          const idEventSubscription = responseStream.filter((response) => response.id === this.request.id).subscribe({
            next: (response) => {
              if ((0, json_rpc_1.isJsonRpcErrorResponse)(response)) {
                this.closeSubscriptions();
                listener.error(JSON.stringify(response.error));
              } else {
                listener.next(response.result);
              }
            }
          });
          const nonResponseSubscription = responseStream.subscribe({
            error: (error) => {
              this.closeSubscriptions();
              listener.error(error);
            },
            complete: () => {
              this.closeSubscriptions();
              listener.complete();
            }
          });
          this.subscriptions.push(idSubscription, idEventSubscription, nonResponseSubscription);
        }
        closeSubscriptions() {
          for (const subscription of this.subscriptions) {
            subscription.unsubscribe();
          }
          this.subscriptions = [];
        }
      };
      var WebsocketClient = class {
        constructor(baseUrl, onError = defaultErrorHandler) {
          this.subscriptionStreams = /* @__PURE__ */ new Map();
          const path = baseUrl.endsWith("/") ? "websocket" : "/websocket";
          const cleanBaseUrl = (0, rpcclient_1.hasProtocol)(baseUrl) ? baseUrl : "ws://" + baseUrl;
          this.url = cleanBaseUrl + path;
          this.socket = new socket_1.ReconnectingSocket(this.url);
          const errorSubscription = this.socket.events.subscribe({
            error: (error) => {
              onError(error);
              errorSubscription.unsubscribe();
            }
          });
          this.jsonRpcResponseStream = this.socket.events.map(toJsonRpcResponse);
          this.socket.connect();
        }
        async execute(request) {
          const pendingResponse = this.responseForRequestId(request.id);
          this.socket.queueRequest(JSON.stringify(request));
          const response = await pendingResponse;
          if ((0, json_rpc_1.isJsonRpcErrorResponse)(response)) {
            throw new Error(JSON.stringify(response.error));
          }
          return response;
        }
        listen(request) {
          if (request.method !== "subscribe") {
            throw new Error(`Request method must be "subscribe" to start event listening`);
          }
          const query = request.params.query;
          if (typeof query !== "string") {
            throw new Error("request.params.query must be a string");
          }
          if (!this.subscriptionStreams.has(query)) {
            const producer = new RpcEventProducer(request, this.socket);
            const stream = xstream_1.Stream.create(producer);
            this.subscriptionStreams.set(query, stream);
          }
          return this.subscriptionStreams.get(query).filter((response) => response.query !== void 0);
        }
        async connected() {
          await this.socket.connectionStatus.waitFor(socket_1.ConnectionStatus.Connected);
        }
        disconnect() {
          this.socket.disconnect();
        }
        async responseForRequestId(id) {
          return (0, stream_1.firstEvent)(this.jsonRpcResponseStream.filter((r) => r.id === id));
        }
      };
      exports2.WebsocketClient = WebsocketClient;
    }
  });

  // node_modules/@cosmjs/tendermint-rpc/build/rpcclients/index.js
  var require_rpcclients = __commonJS({
    "node_modules/@cosmjs/tendermint-rpc/build/rpcclients/index.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.WebsocketClient = exports2.instanceOfRpcStreamingClient = exports2.HttpClient = void 0;
      var httpclient_1 = require_httpclient();
      Object.defineProperty(exports2, "HttpClient", { enumerable: true, get: function() {
        return httpclient_1.HttpClient;
      } });
      var rpcclient_1 = require_rpcclient();
      Object.defineProperty(exports2, "instanceOfRpcStreamingClient", { enumerable: true, get: function() {
        return rpcclient_1.instanceOfRpcStreamingClient;
      } });
      var websocketclient_1 = require_websocketclient();
      Object.defineProperty(exports2, "WebsocketClient", { enumerable: true, get: function() {
        return websocketclient_1.WebsocketClient;
      } });
    }
  });

  // node_modules/@cosmjs/tendermint-rpc/build/tendermint34/requests.js
  var require_requests = __commonJS({
    "node_modules/@cosmjs/tendermint-rpc/build/tendermint34/requests.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.buildQuery = exports2.SubscriptionEventType = exports2.Method = void 0;
      var Method;
      (function(Method2) {
        Method2["AbciInfo"] = "abci_info";
        Method2["AbciQuery"] = "abci_query";
        Method2["Block"] = "block";
        Method2["Blockchain"] = "blockchain";
        Method2["BlockResults"] = "block_results";
        Method2["BlockSearch"] = "block_search";
        Method2["BroadcastTxAsync"] = "broadcast_tx_async";
        Method2["BroadcastTxSync"] = "broadcast_tx_sync";
        Method2["BroadcastTxCommit"] = "broadcast_tx_commit";
        Method2["Commit"] = "commit";
        Method2["Genesis"] = "genesis";
        Method2["Health"] = "health";
        Method2["Status"] = "status";
        Method2["Subscribe"] = "subscribe";
        Method2["Tx"] = "tx";
        Method2["TxSearch"] = "tx_search";
        Method2["Validators"] = "validators";
        Method2["Unsubscribe"] = "unsubscribe";
      })(Method = exports2.Method || (exports2.Method = {}));
      var SubscriptionEventType;
      (function(SubscriptionEventType2) {
        SubscriptionEventType2["NewBlock"] = "NewBlock";
        SubscriptionEventType2["NewBlockHeader"] = "NewBlockHeader";
        SubscriptionEventType2["Tx"] = "Tx";
      })(SubscriptionEventType = exports2.SubscriptionEventType || (exports2.SubscriptionEventType = {}));
      function buildQuery(components) {
        const tags = components.tags ? components.tags : [];
        const tagComponents = tags.map((tag) => `${tag.key}='${tag.value}'`);
        const rawComponents = components.raw ? [components.raw] : [];
        return [...tagComponents, ...rawComponents].join(" AND ");
      }
      exports2.buildQuery = buildQuery;
    }
  });

  // node_modules/@cosmjs/tendermint-rpc/build/tendermint34/responses.js
  var require_responses = __commonJS({
    "node_modules/@cosmjs/tendermint-rpc/build/tendermint34/responses.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.VoteType = exports2.broadcastTxCommitSuccess = exports2.broadcastTxSyncSuccess = void 0;
      function broadcastTxSyncSuccess(res) {
        return res.code === 0;
      }
      exports2.broadcastTxSyncSuccess = broadcastTxSyncSuccess;
      function broadcastTxCommitSuccess(response) {
        return response.checkTx.code === 0 && !!response.deliverTx && response.deliverTx.code === 0;
      }
      exports2.broadcastTxCommitSuccess = broadcastTxCommitSuccess;
      var VoteType;
      (function(VoteType2) {
        VoteType2[VoteType2["PreVote"] = 1] = "PreVote";
        VoteType2[VoteType2["PreCommit"] = 2] = "PreCommit";
      })(VoteType = exports2.VoteType || (exports2.VoteType = {}));
    }
  });

  // node_modules/@cosmjs/tendermint-rpc/build/jsonrpc.js
  var require_jsonrpc = __commonJS({
    "node_modules/@cosmjs/tendermint-rpc/build/jsonrpc.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.createJsonRpcRequest = void 0;
      var numbersWithoutZero = "123456789";
      function randomNumericChar() {
        return numbersWithoutZero[Math.floor(Math.random() * numbersWithoutZero.length)];
      }
      function randomId() {
        return parseInt(Array.from({ length: 12 }).map(() => randomNumericChar()).join(""), 10);
      }
      function createJsonRpcRequest(method, params) {
        const paramsCopy = params ? { ...params } : {};
        return {
          jsonrpc: "2.0",
          id: randomId(),
          method,
          params: paramsCopy
        };
      }
      exports2.createJsonRpcRequest = createJsonRpcRequest;
    }
  });

  // node_modules/@cosmjs/tendermint-rpc/build/tendermint34/encodings.js
  var require_encodings = __commonJS({
    "node_modules/@cosmjs/tendermint-rpc/build/tendermint34/encodings.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.encodeBlockId = exports2.encodeVersion = exports2.encodeBytes = exports2.encodeTime = exports2.encodeInt = exports2.encodeString = exports2.Integer = exports2.dictionaryToStringMap = exports2.may = exports2.optional = exports2.assertNotEmpty = exports2.assertObject = exports2.assertArray = exports2.assertNumber = exports2.assertString = exports2.assertBoolean = exports2.assertSet = void 0;
      var encoding_1 = require_build2();
      var math_1 = require_build();
      function assertSet(value) {
        if (value === void 0) {
          throw new Error("Value must not be undefined");
        }
        if (value === null) {
          throw new Error("Value must not be null");
        }
        return value;
      }
      exports2.assertSet = assertSet;
      function assertBoolean(value) {
        assertSet(value);
        if (typeof value !== "boolean") {
          throw new Error("Value must be a boolean");
        }
        return value;
      }
      exports2.assertBoolean = assertBoolean;
      function assertString(value) {
        assertSet(value);
        if (typeof value !== "string") {
          throw new Error("Value must be a string");
        }
        return value;
      }
      exports2.assertString = assertString;
      function assertNumber(value) {
        assertSet(value);
        if (typeof value !== "number") {
          throw new Error("Value must be a number");
        }
        return value;
      }
      exports2.assertNumber = assertNumber;
      function assertArray(value) {
        assertSet(value);
        if (!Array.isArray(value)) {
          throw new Error("Value must be a an array");
        }
        return value;
      }
      exports2.assertArray = assertArray;
      function assertObject(value) {
        assertSet(value);
        if (typeof value !== "object") {
          throw new Error("Value must be an object");
        }
        if (Object.prototype.toString.call(value) !== "[object Object]") {
          throw new Error("Value must be a simple object");
        }
        return value;
      }
      exports2.assertObject = assertObject;
      function assertNotEmpty(value) {
        assertSet(value);
        if (typeof value === "number" && value === 0) {
          throw new Error("must provide a non-zero value");
        } else if (value.length === 0) {
          throw new Error("must provide a non-empty value");
        }
        return value;
      }
      exports2.assertNotEmpty = assertNotEmpty;
      function optional(value, fallback) {
        return value === void 0 || value === null ? fallback : value;
      }
      exports2.optional = optional;
      function may(transform, value) {
        return value === void 0 || value === null ? void 0 : transform(value);
      }
      exports2.may = may;
      function dictionaryToStringMap(obj) {
        const out = /* @__PURE__ */ new Map();
        for (const key of Object.keys(obj)) {
          const value = obj[key];
          if (typeof value !== "string") {
            throw new Error("Found dictionary value of type other than string");
          }
          out.set(key, value);
        }
        return out;
      }
      exports2.dictionaryToStringMap = dictionaryToStringMap;
      var Integer = class {
        static parse(input) {
          const asInt = typeof input === "number" ? new math_1.Int53(input) : math_1.Int53.fromString(input);
          return asInt.toNumber();
        }
        static encode(num) {
          return new math_1.Int53(num).toString();
        }
      };
      exports2.Integer = Integer;
      function encodeString(s) {
        const utf8 = (0, encoding_1.toUtf8)(s);
        return Uint8Array.from([utf8.length, ...utf8]);
      }
      exports2.encodeString = encodeString;
      function encodeInt(n) {
        return n >= 128 ? Uint8Array.from([n & 255 | 128, ...encodeInt(n >> 7)]) : Uint8Array.from([n & 255]);
      }
      exports2.encodeInt = encodeInt;
      function encodeTime(time) {
        const milliseconds = time.getTime();
        const seconds = Math.floor(milliseconds / 1e3);
        const secondsArray = seconds ? [8, ...encodeInt(seconds)] : new Uint8Array();
        const nanoseconds = (time.nanoseconds || 0) + milliseconds % 1e3 * 1e6;
        const nanosecondsArray = nanoseconds ? [16, ...encodeInt(nanoseconds)] : new Uint8Array();
        return Uint8Array.from([...secondsArray, ...nanosecondsArray]);
      }
      exports2.encodeTime = encodeTime;
      function encodeBytes(bytes) {
        if (bytes.length >= 128)
          throw new Error("Not implemented for byte arrays of length 128 or more");
        return bytes.length ? Uint8Array.from([bytes.length, ...bytes]) : new Uint8Array();
      }
      exports2.encodeBytes = encodeBytes;
      function encodeVersion(version) {
        const blockArray = version.block ? Uint8Array.from([8, ...encodeInt(version.block)]) : new Uint8Array();
        const appArray = version.app ? Uint8Array.from([16, ...encodeInt(version.app)]) : new Uint8Array();
        return Uint8Array.from([...blockArray, ...appArray]);
      }
      exports2.encodeVersion = encodeVersion;
      function encodeBlockId(blockId) {
        return Uint8Array.from([
          10,
          blockId.hash.length,
          ...blockId.hash,
          18,
          blockId.parts.hash.length + 4,
          8,
          blockId.parts.total,
          18,
          blockId.parts.hash.length,
          ...blockId.parts.hash
        ]);
      }
      exports2.encodeBlockId = encodeBlockId;
    }
  });

  // node_modules/@cosmjs/tendermint-rpc/build/tendermint34/hasher.js
  var require_hasher = __commonJS({
    "node_modules/@cosmjs/tendermint-rpc/build/tendermint34/hasher.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.hashBlock = exports2.hashTx = void 0;
      var crypto_1 = require_build4();
      var encodings_1 = require_encodings();
      function hashTx(tx) {
        return (0, crypto_1.sha256)(tx);
      }
      exports2.hashTx = hashTx;
      function getSplitPoint(n) {
        if (n < 1)
          throw new Error("Cannot split an empty tree");
        const largestPowerOf2 = 2 ** Math.floor(Math.log2(n));
        return largestPowerOf2 < n ? largestPowerOf2 : largestPowerOf2 / 2;
      }
      function hashLeaf(leaf) {
        const hash = new crypto_1.Sha256(Uint8Array.from([0]));
        hash.update(leaf);
        return hash.digest();
      }
      function hashInner(left, right) {
        const hash = new crypto_1.Sha256(Uint8Array.from([1]));
        hash.update(left);
        hash.update(right);
        return hash.digest();
      }
      function hashTree(hashes) {
        switch (hashes.length) {
          case 0:
            throw new Error("Cannot hash empty tree");
          case 1:
            return hashLeaf(hashes[0]);
          default: {
            const slicePoint = getSplitPoint(hashes.length);
            const left = hashTree(hashes.slice(0, slicePoint));
            const right = hashTree(hashes.slice(slicePoint));
            return hashInner(left, right);
          }
        }
      }
      function hashBlock(header) {
        if (!header.lastBlockId) {
          throw new Error("Hashing a block header with no last block ID (i.e. header at height 1) is not supported. If you need this, contributions are welcome. Please add documentation and test vectors for this case.");
        }
        const encodedFields = [
          (0, encodings_1.encodeVersion)(header.version),
          (0, encodings_1.encodeString)(header.chainId),
          (0, encodings_1.encodeInt)(header.height),
          (0, encodings_1.encodeTime)(header.time),
          (0, encodings_1.encodeBlockId)(header.lastBlockId),
          (0, encodings_1.encodeBytes)(header.lastCommitHash),
          (0, encodings_1.encodeBytes)(header.dataHash),
          (0, encodings_1.encodeBytes)(header.validatorsHash),
          (0, encodings_1.encodeBytes)(header.nextValidatorsHash),
          (0, encodings_1.encodeBytes)(header.consensusHash),
          (0, encodings_1.encodeBytes)(header.appHash),
          (0, encodings_1.encodeBytes)(header.lastResultsHash),
          (0, encodings_1.encodeBytes)(header.evidenceHash),
          (0, encodings_1.encodeBytes)(header.proposerAddress)
        ];
        return hashTree(encodedFields);
      }
      exports2.hashBlock = hashBlock;
    }
  });

  // node_modules/@cosmjs/tendermint-rpc/build/tendermint34/adaptor/requests.js
  var require_requests2 = __commonJS({
    "node_modules/@cosmjs/tendermint-rpc/build/tendermint34/adaptor/requests.js"(exports2) {
      "use strict";
      var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
        if (k2 === void 0)
          k2 = k;
        Object.defineProperty(o, k2, { enumerable: true, get: function() {
          return m[k];
        } });
      } : function(o, m, k, k2) {
        if (k2 === void 0)
          k2 = k;
        o[k2] = m[k];
      });
      var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
        Object.defineProperty(o, "default", { enumerable: true, value: v });
      } : function(o, v) {
        o["default"] = v;
      });
      var __importStar = exports2 && exports2.__importStar || function(mod2) {
        if (mod2 && mod2.__esModule)
          return mod2;
        var result = {};
        if (mod2 != null) {
          for (var k in mod2)
            if (k !== "default" && Object.prototype.hasOwnProperty.call(mod2, k))
              __createBinding(result, mod2, k);
        }
        __setModuleDefault(result, mod2);
        return result;
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.Params = void 0;
      var encoding_1 = require_build2();
      var jsonrpc_1 = require_jsonrpc();
      var encodings_1 = require_encodings();
      var requests = __importStar(require_requests());
      function encodeHeightParam(param) {
        return {
          height: (0, encodings_1.may)(encodings_1.Integer.encode, param.height)
        };
      }
      function encodeBlockchainRequestParams(param) {
        return {
          minHeight: (0, encodings_1.may)(encodings_1.Integer.encode, param.minHeight),
          maxHeight: (0, encodings_1.may)(encodings_1.Integer.encode, param.maxHeight)
        };
      }
      function encodeBlockSearchParams(params) {
        return {
          query: params.query,
          page: (0, encodings_1.may)(encodings_1.Integer.encode, params.page),
          per_page: (0, encodings_1.may)(encodings_1.Integer.encode, params.per_page),
          order_by: params.order_by
        };
      }
      function encodeAbciQueryParams(params) {
        return {
          path: (0, encodings_1.assertNotEmpty)(params.path),
          data: (0, encoding_1.toHex)(params.data),
          height: (0, encodings_1.may)(encodings_1.Integer.encode, params.height),
          prove: params.prove
        };
      }
      function encodeBroadcastTxParams(params) {
        return {
          tx: (0, encoding_1.toBase64)((0, encodings_1.assertNotEmpty)(params.tx))
        };
      }
      function encodeTxParams(params) {
        return {
          hash: (0, encoding_1.toBase64)((0, encodings_1.assertNotEmpty)(params.hash)),
          prove: params.prove
        };
      }
      function encodeTxSearchParams(params) {
        return {
          query: params.query,
          prove: params.prove,
          page: (0, encodings_1.may)(encodings_1.Integer.encode, params.page),
          per_page: (0, encodings_1.may)(encodings_1.Integer.encode, params.per_page),
          order_by: params.order_by
        };
      }
      function encodeValidatorsParams(params) {
        return {
          height: (0, encodings_1.may)(encodings_1.Integer.encode, params.height),
          page: (0, encodings_1.may)(encodings_1.Integer.encode, params.page),
          per_page: (0, encodings_1.may)(encodings_1.Integer.encode, params.per_page)
        };
      }
      var Params = class {
        static encodeAbciInfo(req) {
          return (0, jsonrpc_1.createJsonRpcRequest)(req.method);
        }
        static encodeAbciQuery(req) {
          return (0, jsonrpc_1.createJsonRpcRequest)(req.method, encodeAbciQueryParams(req.params));
        }
        static encodeBlock(req) {
          return (0, jsonrpc_1.createJsonRpcRequest)(req.method, encodeHeightParam(req.params));
        }
        static encodeBlockchain(req) {
          return (0, jsonrpc_1.createJsonRpcRequest)(req.method, encodeBlockchainRequestParams(req.params));
        }
        static encodeBlockResults(req) {
          return (0, jsonrpc_1.createJsonRpcRequest)(req.method, encodeHeightParam(req.params));
        }
        static encodeBlockSearch(req) {
          return (0, jsonrpc_1.createJsonRpcRequest)(req.method, encodeBlockSearchParams(req.params));
        }
        static encodeBroadcastTx(req) {
          return (0, jsonrpc_1.createJsonRpcRequest)(req.method, encodeBroadcastTxParams(req.params));
        }
        static encodeCommit(req) {
          return (0, jsonrpc_1.createJsonRpcRequest)(req.method, encodeHeightParam(req.params));
        }
        static encodeGenesis(req) {
          return (0, jsonrpc_1.createJsonRpcRequest)(req.method);
        }
        static encodeHealth(req) {
          return (0, jsonrpc_1.createJsonRpcRequest)(req.method);
        }
        static encodeStatus(req) {
          return (0, jsonrpc_1.createJsonRpcRequest)(req.method);
        }
        static encodeSubscribe(req) {
          const eventTag = { key: "tm.event", value: req.query.type };
          const query = requests.buildQuery({ tags: [eventTag], raw: req.query.raw });
          return (0, jsonrpc_1.createJsonRpcRequest)("subscribe", { query });
        }
        static encodeTx(req) {
          return (0, jsonrpc_1.createJsonRpcRequest)(req.method, encodeTxParams(req.params));
        }
        static encodeTxSearch(req) {
          return (0, jsonrpc_1.createJsonRpcRequest)(req.method, encodeTxSearchParams(req.params));
        }
        static encodeValidators(req) {
          return (0, jsonrpc_1.createJsonRpcRequest)(req.method, encodeValidatorsParams(req.params));
        }
      };
      exports2.Params = Params;
    }
  });

  // node_modules/@cosmjs/tendermint-rpc/build/types.js
  var require_types5 = __commonJS({
    "node_modules/@cosmjs/tendermint-rpc/build/types.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.BlockIdFlag = void 0;
      var BlockIdFlag;
      (function(BlockIdFlag2) {
        BlockIdFlag2[BlockIdFlag2["Unknown"] = 0] = "Unknown";
        BlockIdFlag2[BlockIdFlag2["Absent"] = 1] = "Absent";
        BlockIdFlag2[BlockIdFlag2["Commit"] = 2] = "Commit";
        BlockIdFlag2[BlockIdFlag2["Nil"] = 3] = "Nil";
        BlockIdFlag2[BlockIdFlag2["Unrecognized"] = -1] = "Unrecognized";
      })(BlockIdFlag = exports2.BlockIdFlag || (exports2.BlockIdFlag = {}));
    }
  });

  // node_modules/@cosmjs/tendermint-rpc/build/tendermint34/adaptor/responses.js
  var require_responses2 = __commonJS({
    "node_modules/@cosmjs/tendermint-rpc/build/tendermint34/adaptor/responses.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.Responses = void 0;
      var encoding_1 = require_build2();
      var utils_1 = require_build3();
      var dates_1 = require_dates();
      var types_1 = require_types5();
      var encodings_1 = require_encodings();
      var hasher_1 = require_hasher();
      function decodeAbciInfo(data) {
        return {
          data: data.data,
          lastBlockHeight: (0, encodings_1.may)(encodings_1.Integer.parse, data.last_block_height),
          lastBlockAppHash: (0, encodings_1.may)(encoding_1.fromBase64, data.last_block_app_hash)
        };
      }
      function decodeQueryProof(data) {
        return {
          ops: data.ops.map((op) => ({
            type: op.type,
            key: (0, encoding_1.fromBase64)(op.key),
            data: (0, encoding_1.fromBase64)(op.data)
          }))
        };
      }
      function decodeAbciQuery(data) {
        return {
          key: (0, encoding_1.fromBase64)((0, encodings_1.optional)(data.key, "")),
          value: (0, encoding_1.fromBase64)((0, encodings_1.optional)(data.value, "")),
          proof: (0, encodings_1.may)(decodeQueryProof, data.proofOps),
          height: (0, encodings_1.may)(encodings_1.Integer.parse, data.height),
          code: (0, encodings_1.may)(encodings_1.Integer.parse, data.code),
          index: (0, encodings_1.may)(encodings_1.Integer.parse, data.index),
          log: data.log
        };
      }
      function decodeAttribute(attribute) {
        return {
          key: (0, encoding_1.fromBase64)((0, encodings_1.assertNotEmpty)(attribute.key)),
          value: (0, encoding_1.fromBase64)((0, encodings_1.optional)(attribute.value, ""))
        };
      }
      function decodeAttributes(attributes) {
        return (0, encodings_1.assertArray)(attributes).map(decodeAttribute);
      }
      function decodeEvent(event) {
        return {
          type: event.type,
          attributes: decodeAttributes(event.attributes)
        };
      }
      function decodeEvents(events) {
        return (0, encodings_1.assertArray)(events).map(decodeEvent);
      }
      function decodeTxData(data) {
        return {
          code: encodings_1.Integer.parse((0, encodings_1.assertNumber)((0, encodings_1.optional)(data.code, 0))),
          codeSpace: data.codespace,
          log: data.log,
          data: (0, encodings_1.may)(encoding_1.fromBase64, data.data),
          events: data.events ? decodeEvents(data.events) : [],
          gasWanted: encodings_1.Integer.parse((0, encodings_1.optional)(data.gas_wanted, "0")),
          gasUsed: encodings_1.Integer.parse((0, encodings_1.optional)(data.gas_used, "0"))
        };
      }
      function decodePubkey(data) {
        switch (data.type) {
          case "tendermint/PubKeyEd25519":
            return {
              algorithm: "ed25519",
              data: (0, encoding_1.fromBase64)((0, encodings_1.assertNotEmpty)(data.value))
            };
          case "tendermint/PubKeySecp256k1":
            return {
              algorithm: "secp256k1",
              data: (0, encoding_1.fromBase64)((0, encodings_1.assertNotEmpty)(data.value))
            };
          default:
            throw new Error(`unknown pubkey type: ${data.type}`);
        }
      }
      function decodeValidatorUpdate(data) {
        return {
          pubkey: decodePubkey((0, encodings_1.assertObject)(data.pub_key)),
          votingPower: encodings_1.Integer.parse((0, encodings_1.assertNotEmpty)(data.voting_power)),
          address: (0, encoding_1.fromHex)((0, encodings_1.assertNotEmpty)(data.address)),
          proposerPriority: encodings_1.Integer.parse(data.proposer_priority)
        };
      }
      function decodeBlockParams(data) {
        return {
          maxBytes: encodings_1.Integer.parse((0, encodings_1.assertNotEmpty)(data.max_bytes)),
          maxGas: encodings_1.Integer.parse((0, encodings_1.assertNotEmpty)(data.max_gas))
        };
      }
      function decodeEvidenceParams(data) {
        return {
          maxAgeNumBlocks: encodings_1.Integer.parse((0, encodings_1.assertNotEmpty)(data.max_age_num_blocks)),
          maxAgeDuration: encodings_1.Integer.parse((0, encodings_1.assertNotEmpty)(data.max_age_duration))
        };
      }
      function decodeConsensusParams(data) {
        return {
          block: decodeBlockParams((0, encodings_1.assertObject)(data.block)),
          evidence: decodeEvidenceParams((0, encodings_1.assertObject)(data.evidence))
        };
      }
      function decodeBlockResults(data) {
        return {
          height: encodings_1.Integer.parse((0, encodings_1.assertNotEmpty)(data.height)),
          results: (data.txs_results || []).map(decodeTxData),
          validatorUpdates: (data.validator_updates || []).map(decodeValidatorUpdate),
          consensusUpdates: (0, encodings_1.may)(decodeConsensusParams, data.consensus_param_updates),
          beginBlockEvents: decodeEvents(data.begin_block_events || []),
          endBlockEvents: decodeEvents(data.end_block_events || [])
        };
      }
      function decodeBlockId(data) {
        return {
          hash: (0, encoding_1.fromHex)((0, encodings_1.assertNotEmpty)(data.hash)),
          parts: {
            total: (0, encodings_1.assertNotEmpty)(data.parts.total),
            hash: (0, encoding_1.fromHex)((0, encodings_1.assertNotEmpty)(data.parts.hash))
          }
        };
      }
      function decodeBlockVersion(data) {
        var _a;
        return {
          block: encodings_1.Integer.parse(data.block),
          app: encodings_1.Integer.parse((_a = data.app) !== null && _a !== void 0 ? _a : 0)
        };
      }
      function decodeHeader(data) {
        return {
          version: decodeBlockVersion(data.version),
          chainId: (0, encodings_1.assertNotEmpty)(data.chain_id),
          height: encodings_1.Integer.parse((0, encodings_1.assertNotEmpty)(data.height)),
          time: (0, dates_1.fromRfc3339WithNanoseconds)((0, encodings_1.assertNotEmpty)(data.time)),
          lastBlockId: data.last_block_id.hash ? decodeBlockId(data.last_block_id) : null,
          lastCommitHash: (0, encoding_1.fromHex)((0, encodings_1.assertSet)(data.last_commit_hash)),
          dataHash: (0, encoding_1.fromHex)((0, encodings_1.assertSet)(data.data_hash)),
          validatorsHash: (0, encoding_1.fromHex)((0, encodings_1.assertSet)(data.validators_hash)),
          nextValidatorsHash: (0, encoding_1.fromHex)((0, encodings_1.assertSet)(data.next_validators_hash)),
          consensusHash: (0, encoding_1.fromHex)((0, encodings_1.assertSet)(data.consensus_hash)),
          appHash: (0, encoding_1.fromHex)((0, encodings_1.assertSet)(data.app_hash)),
          lastResultsHash: (0, encoding_1.fromHex)((0, encodings_1.assertSet)(data.last_results_hash)),
          evidenceHash: (0, encoding_1.fromHex)((0, encodings_1.assertSet)(data.evidence_hash)),
          proposerAddress: (0, encoding_1.fromHex)((0, encodings_1.assertNotEmpty)(data.proposer_address))
        };
      }
      function decodeBlockMeta(data) {
        return {
          blockId: decodeBlockId(data.block_id),
          blockSize: encodings_1.Integer.parse((0, encodings_1.assertNotEmpty)(data.block_size)),
          header: decodeHeader(data.header),
          numTxs: encodings_1.Integer.parse((0, encodings_1.assertNotEmpty)(data.num_txs))
        };
      }
      function decodeBlockchain(data) {
        return {
          lastHeight: encodings_1.Integer.parse((0, encodings_1.assertNotEmpty)(data.last_height)),
          blockMetas: (0, encodings_1.assertArray)(data.block_metas).map(decodeBlockMeta)
        };
      }
      function decodeBroadcastTxSync(data) {
        return {
          ...decodeTxData(data),
          hash: (0, encoding_1.fromHex)((0, encodings_1.assertNotEmpty)(data.hash))
        };
      }
      function decodeBroadcastTxCommit(data) {
        return {
          height: encodings_1.Integer.parse(data.height),
          hash: (0, encoding_1.fromHex)((0, encodings_1.assertNotEmpty)(data.hash)),
          checkTx: decodeTxData((0, encodings_1.assertObject)(data.check_tx)),
          deliverTx: (0, encodings_1.may)(decodeTxData, data.deliver_tx)
        };
      }
      function decodeBlockIdFlag(blockIdFlag) {
        (0, utils_1.assert)(blockIdFlag in types_1.BlockIdFlag);
        return blockIdFlag;
      }
      function decodeOptionalTime(timestamp) {
        const nonZeroTime = timestamp && !timestamp.startsWith("0001-01-01");
        return nonZeroTime ? (0, dates_1.fromRfc3339WithNanoseconds)(timestamp) : void 0;
      }
      function decodeCommitSignature(data) {
        return {
          blockIdFlag: decodeBlockIdFlag(data.block_id_flag),
          validatorAddress: data.validator_address ? (0, encoding_1.fromHex)(data.validator_address) : void 0,
          timestamp: decodeOptionalTime(data.timestamp),
          signature: data.signature ? (0, encoding_1.fromBase64)(data.signature) : void 0
        };
      }
      function decodeCommit(data) {
        return {
          blockId: decodeBlockId((0, encodings_1.assertObject)(data.block_id)),
          height: encodings_1.Integer.parse((0, encodings_1.assertNotEmpty)(data.height)),
          round: encodings_1.Integer.parse(data.round),
          signatures: (0, encodings_1.assertArray)(data.signatures).map(decodeCommitSignature)
        };
      }
      function decodeCommitResponse(data) {
        return {
          canonical: (0, encodings_1.assertBoolean)(data.canonical),
          header: decodeHeader(data.signed_header.header),
          commit: decodeCommit(data.signed_header.commit)
        };
      }
      function decodeValidatorGenesis(data) {
        return {
          address: (0, encoding_1.fromHex)((0, encodings_1.assertNotEmpty)(data.address)),
          pubkey: decodePubkey((0, encodings_1.assertObject)(data.pub_key)),
          votingPower: encodings_1.Integer.parse((0, encodings_1.assertNotEmpty)(data.power))
        };
      }
      function decodeGenesis(data) {
        return {
          genesisTime: (0, dates_1.fromRfc3339WithNanoseconds)((0, encodings_1.assertNotEmpty)(data.genesis_time)),
          chainId: (0, encodings_1.assertNotEmpty)(data.chain_id),
          consensusParams: decodeConsensusParams(data.consensus_params),
          validators: data.validators ? (0, encodings_1.assertArray)(data.validators).map(decodeValidatorGenesis) : [],
          appHash: (0, encoding_1.fromHex)((0, encodings_1.assertSet)(data.app_hash)),
          appState: data.app_state
        };
      }
      function decodeValidatorInfo(data) {
        return {
          pubkey: decodePubkey((0, encodings_1.assertObject)(data.pub_key)),
          votingPower: encodings_1.Integer.parse((0, encodings_1.assertNotEmpty)(data.voting_power)),
          address: (0, encoding_1.fromHex)((0, encodings_1.assertNotEmpty)(data.address))
        };
      }
      function decodeNodeInfo(data) {
        return {
          id: (0, encoding_1.fromHex)((0, encodings_1.assertNotEmpty)(data.id)),
          listenAddr: (0, encodings_1.assertNotEmpty)(data.listen_addr),
          network: (0, encodings_1.assertNotEmpty)(data.network),
          version: (0, encodings_1.assertString)(data.version),
          channels: (0, encodings_1.assertNotEmpty)(data.channels),
          moniker: (0, encodings_1.assertNotEmpty)(data.moniker),
          other: (0, encodings_1.dictionaryToStringMap)(data.other),
          protocolVersion: {
            app: encodings_1.Integer.parse((0, encodings_1.assertNotEmpty)(data.protocol_version.app)),
            block: encodings_1.Integer.parse((0, encodings_1.assertNotEmpty)(data.protocol_version.block)),
            p2p: encodings_1.Integer.parse((0, encodings_1.assertNotEmpty)(data.protocol_version.p2p))
          }
        };
      }
      function decodeSyncInfo(data) {
        return {
          latestBlockHash: (0, encoding_1.fromHex)((0, encodings_1.assertNotEmpty)(data.latest_block_hash)),
          latestAppHash: (0, encoding_1.fromHex)((0, encodings_1.assertNotEmpty)(data.latest_app_hash)),
          latestBlockTime: (0, dates_1.fromRfc3339WithNanoseconds)((0, encodings_1.assertNotEmpty)(data.latest_block_time)),
          latestBlockHeight: encodings_1.Integer.parse((0, encodings_1.assertNotEmpty)(data.latest_block_height)),
          catchingUp: (0, encodings_1.assertBoolean)(data.catching_up)
        };
      }
      function decodeStatus(data) {
        return {
          nodeInfo: decodeNodeInfo(data.node_info),
          syncInfo: decodeSyncInfo(data.sync_info),
          validatorInfo: decodeValidatorInfo(data.validator_info)
        };
      }
      function decodeTxProof(data) {
        return {
          data: (0, encoding_1.fromBase64)((0, encodings_1.assertNotEmpty)(data.data)),
          rootHash: (0, encoding_1.fromHex)((0, encodings_1.assertNotEmpty)(data.root_hash)),
          proof: {
            total: encodings_1.Integer.parse((0, encodings_1.assertNotEmpty)(data.proof.total)),
            index: encodings_1.Integer.parse((0, encodings_1.assertNotEmpty)(data.proof.index)),
            leafHash: (0, encoding_1.fromBase64)((0, encodings_1.assertNotEmpty)(data.proof.leaf_hash)),
            aunts: (0, encodings_1.assertArray)(data.proof.aunts).map(encoding_1.fromBase64)
          }
        };
      }
      function decodeTxResponse(data) {
        return {
          tx: (0, encoding_1.fromBase64)((0, encodings_1.assertNotEmpty)(data.tx)),
          result: decodeTxData((0, encodings_1.assertObject)(data.tx_result)),
          height: encodings_1.Integer.parse((0, encodings_1.assertNotEmpty)(data.height)),
          index: encodings_1.Integer.parse((0, encodings_1.assertNumber)(data.index)),
          hash: (0, encoding_1.fromHex)((0, encodings_1.assertNotEmpty)(data.hash)),
          proof: (0, encodings_1.may)(decodeTxProof, data.proof)
        };
      }
      function decodeTxSearch(data) {
        return {
          totalCount: encodings_1.Integer.parse((0, encodings_1.assertNotEmpty)(data.total_count)),
          txs: (0, encodings_1.assertArray)(data.txs).map(decodeTxResponse)
        };
      }
      function decodeTxEvent(data) {
        const tx = (0, encoding_1.fromBase64)((0, encodings_1.assertNotEmpty)(data.tx));
        return {
          tx,
          hash: (0, hasher_1.hashTx)(tx),
          result: decodeTxData(data.result),
          height: encodings_1.Integer.parse((0, encodings_1.assertNotEmpty)(data.height)),
          index: (0, encodings_1.may)(encodings_1.Integer.parse, data.index)
        };
      }
      function decodeValidators(data) {
        return {
          blockHeight: encodings_1.Integer.parse((0, encodings_1.assertNotEmpty)(data.block_height)),
          validators: (0, encodings_1.assertArray)(data.validators).map(decodeValidatorUpdate),
          count: encodings_1.Integer.parse((0, encodings_1.assertNotEmpty)(data.count)),
          total: encodings_1.Integer.parse((0, encodings_1.assertNotEmpty)(data.total))
        };
      }
      function decodeBlock(data) {
        var _a, _b;
        return {
          header: decodeHeader((0, encodings_1.assertObject)(data.header)),
          lastCommit: data.last_commit.block_id.hash ? decodeCommit((0, encodings_1.assertObject)(data.last_commit)) : null,
          txs: data.data.txs ? (0, encodings_1.assertArray)(data.data.txs).map(encoding_1.fromBase64) : [],
          evidence: (_b = (_a = data.evidence) === null || _a === void 0 ? void 0 : _a.evidence) !== null && _b !== void 0 ? _b : []
        };
      }
      function decodeBlockResponse(data) {
        return {
          blockId: decodeBlockId(data.block_id),
          block: decodeBlock(data.block)
        };
      }
      function decodeBlockSearch(data) {
        return {
          totalCount: encodings_1.Integer.parse((0, encodings_1.assertNotEmpty)(data.total_count)),
          blocks: (0, encodings_1.assertArray)(data.blocks).map(decodeBlockResponse)
        };
      }
      var Responses = class {
        static decodeAbciInfo(response) {
          return decodeAbciInfo((0, encodings_1.assertObject)(response.result.response));
        }
        static decodeAbciQuery(response) {
          return decodeAbciQuery((0, encodings_1.assertObject)(response.result.response));
        }
        static decodeBlock(response) {
          return decodeBlockResponse(response.result);
        }
        static decodeBlockResults(response) {
          return decodeBlockResults(response.result);
        }
        static decodeBlockSearch(response) {
          return decodeBlockSearch(response.result);
        }
        static decodeBlockchain(response) {
          return decodeBlockchain(response.result);
        }
        static decodeBroadcastTxSync(response) {
          return decodeBroadcastTxSync(response.result);
        }
        static decodeBroadcastTxAsync(response) {
          return Responses.decodeBroadcastTxSync(response);
        }
        static decodeBroadcastTxCommit(response) {
          return decodeBroadcastTxCommit(response.result);
        }
        static decodeCommit(response) {
          return decodeCommitResponse(response.result);
        }
        static decodeGenesis(response) {
          return decodeGenesis((0, encodings_1.assertObject)(response.result.genesis));
        }
        static decodeHealth() {
          return null;
        }
        static decodeStatus(response) {
          return decodeStatus(response.result);
        }
        static decodeNewBlockEvent(event) {
          return decodeBlock(event.data.value.block);
        }
        static decodeNewBlockHeaderEvent(event) {
          return decodeHeader(event.data.value.header);
        }
        static decodeTxEvent(event) {
          return decodeTxEvent(event.data.value.TxResult);
        }
        static decodeTx(response) {
          return decodeTxResponse(response.result);
        }
        static decodeTxSearch(response) {
          return decodeTxSearch(response.result);
        }
        static decodeValidators(response) {
          return decodeValidators(response.result);
        }
      };
      exports2.Responses = Responses;
    }
  });

  // node_modules/@cosmjs/tendermint-rpc/build/tendermint34/adaptor/index.js
  var require_adaptor = __commonJS({
    "node_modules/@cosmjs/tendermint-rpc/build/tendermint34/adaptor/index.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.adaptor34 = void 0;
      var hasher_1 = require_hasher();
      var requests_1 = require_requests2();
      var responses_1 = require_responses2();
      exports2.adaptor34 = {
        params: requests_1.Params,
        responses: responses_1.Responses,
        hashTx: hasher_1.hashTx,
        hashBlock: hasher_1.hashBlock
      };
    }
  });

  // node_modules/@cosmjs/tendermint-rpc/build/tendermint34/tendermint34client.js
  var require_tendermint34client = __commonJS({
    "node_modules/@cosmjs/tendermint-rpc/build/tendermint34/tendermint34client.js"(exports2) {
      "use strict";
      var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
        if (k2 === void 0)
          k2 = k;
        Object.defineProperty(o, k2, { enumerable: true, get: function() {
          return m[k];
        } });
      } : function(o, m, k, k2) {
        if (k2 === void 0)
          k2 = k;
        o[k2] = m[k];
      });
      var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
        Object.defineProperty(o, "default", { enumerable: true, value: v });
      } : function(o, v) {
        o["default"] = v;
      });
      var __importStar = exports2 && exports2.__importStar || function(mod2) {
        if (mod2 && mod2.__esModule)
          return mod2;
        var result = {};
        if (mod2 != null) {
          for (var k in mod2)
            if (k !== "default" && Object.prototype.hasOwnProperty.call(mod2, k))
              __createBinding(result, mod2, k);
        }
        __setModuleDefault(result, mod2);
        return result;
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.Tendermint34Client = void 0;
      var jsonrpc_1 = require_jsonrpc();
      var rpcclients_1 = require_rpcclients();
      var adaptor_1 = require_adaptor();
      var requests = __importStar(require_requests());
      var Tendermint34Client = class {
        constructor(client) {
          this.client = client;
          this.p = adaptor_1.adaptor34.params;
          this.r = adaptor_1.adaptor34.responses;
        }
        static async connect(endpoint) {
          if (typeof endpoint === "object") {
            return Tendermint34Client.create(new rpcclients_1.HttpClient(endpoint));
          } else {
            const useHttp = endpoint.startsWith("http://") || endpoint.startsWith("https://");
            const rpcClient = useHttp ? new rpcclients_1.HttpClient(endpoint) : new rpcclients_1.WebsocketClient(endpoint);
            return Tendermint34Client.create(rpcClient);
          }
        }
        static async create(rpcClient) {
          const _version = await this.detectVersion(rpcClient);
          return new Tendermint34Client(rpcClient);
        }
        static async detectVersion(client) {
          const req = (0, jsonrpc_1.createJsonRpcRequest)(requests.Method.Status);
          const response = await client.execute(req);
          const result = response.result;
          if (!result || !result.node_info) {
            throw new Error("Unrecognized format for status response");
          }
          const version = result.node_info.version;
          if (typeof version !== "string") {
            throw new Error("Unrecognized version format: must be string");
          }
          return version;
        }
        disconnect() {
          this.client.disconnect();
        }
        async abciInfo() {
          const query = { method: requests.Method.AbciInfo };
          return this.doCall(query, this.p.encodeAbciInfo, this.r.decodeAbciInfo);
        }
        async abciQuery(params) {
          const query = { params, method: requests.Method.AbciQuery };
          return this.doCall(query, this.p.encodeAbciQuery, this.r.decodeAbciQuery);
        }
        async block(height) {
          const query = { method: requests.Method.Block, params: { height } };
          return this.doCall(query, this.p.encodeBlock, this.r.decodeBlock);
        }
        async blockResults(height) {
          const query = {
            method: requests.Method.BlockResults,
            params: { height }
          };
          return this.doCall(query, this.p.encodeBlockResults, this.r.decodeBlockResults);
        }
        async blockSearch(params) {
          const query = { params, method: requests.Method.BlockSearch };
          const resp = await this.doCall(query, this.p.encodeBlockSearch, this.r.decodeBlockSearch);
          return {
            ...resp,
            blocks: [...resp.blocks].sort((a, b) => a.block.header.height - b.block.header.height)
          };
        }
        async blockSearchAll(params) {
          let page = params.page || 1;
          const blocks = [];
          let done = false;
          while (!done) {
            const resp = await this.blockSearch({ ...params, page });
            blocks.push(...resp.blocks);
            if (blocks.length < resp.totalCount) {
              page++;
            } else {
              done = true;
            }
          }
          blocks.sort((a, b) => a.block.header.height - b.block.header.height);
          return {
            totalCount: blocks.length,
            blocks
          };
        }
        async blockchain(minHeight, maxHeight) {
          const query = {
            method: requests.Method.Blockchain,
            params: {
              minHeight,
              maxHeight
            }
          };
          return this.doCall(query, this.p.encodeBlockchain, this.r.decodeBlockchain);
        }
        async broadcastTxSync(params) {
          const query = { params, method: requests.Method.BroadcastTxSync };
          return this.doCall(query, this.p.encodeBroadcastTx, this.r.decodeBroadcastTxSync);
        }
        async broadcastTxAsync(params) {
          const query = { params, method: requests.Method.BroadcastTxAsync };
          return this.doCall(query, this.p.encodeBroadcastTx, this.r.decodeBroadcastTxAsync);
        }
        async broadcastTxCommit(params) {
          const query = { params, method: requests.Method.BroadcastTxCommit };
          return this.doCall(query, this.p.encodeBroadcastTx, this.r.decodeBroadcastTxCommit);
        }
        async commit(height) {
          const query = { method: requests.Method.Commit, params: { height } };
          return this.doCall(query, this.p.encodeCommit, this.r.decodeCommit);
        }
        async genesis() {
          const query = { method: requests.Method.Genesis };
          return this.doCall(query, this.p.encodeGenesis, this.r.decodeGenesis);
        }
        async health() {
          const query = { method: requests.Method.Health };
          return this.doCall(query, this.p.encodeHealth, this.r.decodeHealth);
        }
        async status() {
          const query = { method: requests.Method.Status };
          return this.doCall(query, this.p.encodeStatus, this.r.decodeStatus);
        }
        subscribeNewBlock() {
          const request = {
            method: requests.Method.Subscribe,
            query: { type: requests.SubscriptionEventType.NewBlock }
          };
          return this.subscribe(request, this.r.decodeNewBlockEvent);
        }
        subscribeNewBlockHeader() {
          const request = {
            method: requests.Method.Subscribe,
            query: { type: requests.SubscriptionEventType.NewBlockHeader }
          };
          return this.subscribe(request, this.r.decodeNewBlockHeaderEvent);
        }
        subscribeTx(query) {
          const request = {
            method: requests.Method.Subscribe,
            query: {
              type: requests.SubscriptionEventType.Tx,
              raw: query
            }
          };
          return this.subscribe(request, this.r.decodeTxEvent);
        }
        async tx(params) {
          const query = { params, method: requests.Method.Tx };
          return this.doCall(query, this.p.encodeTx, this.r.decodeTx);
        }
        async txSearch(params) {
          const query = { params, method: requests.Method.TxSearch };
          return this.doCall(query, this.p.encodeTxSearch, this.r.decodeTxSearch);
        }
        async txSearchAll(params) {
          let page = params.page || 1;
          const txs = [];
          let done = false;
          while (!done) {
            const resp = await this.txSearch({ ...params, page });
            txs.push(...resp.txs);
            if (txs.length < resp.totalCount) {
              page++;
            } else {
              done = true;
            }
          }
          return {
            totalCount: txs.length,
            txs
          };
        }
        async validators(params) {
          const query = {
            method: requests.Method.Validators,
            params
          };
          return this.doCall(query, this.p.encodeValidators, this.r.decodeValidators);
        }
        async validatorsAll(height) {
          const validators = [];
          let page = 1;
          let done = false;
          let blockHeight = height;
          while (!done) {
            const response = await this.validators({
              per_page: 50,
              height: blockHeight,
              page
            });
            validators.push(...response.validators);
            blockHeight = blockHeight || response.blockHeight;
            if (validators.length < response.total) {
              page++;
            } else {
              done = true;
            }
          }
          return {
            blockHeight: blockHeight !== null && blockHeight !== void 0 ? blockHeight : 0,
            count: validators.length,
            total: validators.length,
            validators
          };
        }
        async doCall(request, encode, decode) {
          const req = encode(request);
          const result = await this.client.execute(req);
          return decode(result);
        }
        subscribe(request, decode) {
          if (!(0, rpcclients_1.instanceOfRpcStreamingClient)(this.client)) {
            throw new Error("This RPC client type cannot subscribe to events");
          }
          const req = this.p.encodeSubscribe(request);
          const eventStream = this.client.listen(req);
          return eventStream.map((event) => {
            return decode(event);
          });
        }
      };
      exports2.Tendermint34Client = Tendermint34Client;
    }
  });

  // node_modules/@cosmjs/tendermint-rpc/build/tendermint34/index.js
  var require_tendermint34 = __commonJS({
    "node_modules/@cosmjs/tendermint-rpc/build/tendermint34/index.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.Tendermint34Client = exports2.VoteType = exports2.broadcastTxSyncSuccess = exports2.broadcastTxCommitSuccess = exports2.SubscriptionEventType = exports2.Method = void 0;
      var requests_1 = require_requests();
      Object.defineProperty(exports2, "Method", { enumerable: true, get: function() {
        return requests_1.Method;
      } });
      Object.defineProperty(exports2, "SubscriptionEventType", { enumerable: true, get: function() {
        return requests_1.SubscriptionEventType;
      } });
      var responses_1 = require_responses();
      Object.defineProperty(exports2, "broadcastTxCommitSuccess", { enumerable: true, get: function() {
        return responses_1.broadcastTxCommitSuccess;
      } });
      Object.defineProperty(exports2, "broadcastTxSyncSuccess", { enumerable: true, get: function() {
        return responses_1.broadcastTxSyncSuccess;
      } });
      Object.defineProperty(exports2, "VoteType", { enumerable: true, get: function() {
        return responses_1.VoteType;
      } });
      var tendermint34client_1 = require_tendermint34client();
      Object.defineProperty(exports2, "Tendermint34Client", { enumerable: true, get: function() {
        return tendermint34client_1.Tendermint34Client;
      } });
    }
  });

  // node_modules/@cosmjs/tendermint-rpc/build/index.js
  var require_build11 = __commonJS({
    "node_modules/@cosmjs/tendermint-rpc/build/index.js"(exports2) {
      "use strict";
      var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
        if (k2 === void 0)
          k2 = k;
        Object.defineProperty(o, k2, { enumerable: true, get: function() {
          return m[k];
        } });
      } : function(o, m, k, k2) {
        if (k2 === void 0)
          k2 = k;
        o[k2] = m[k];
      });
      var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
        Object.defineProperty(o, "default", { enumerable: true, value: v });
      } : function(o, v) {
        o["default"] = v;
      });
      var __importStar = exports2 && exports2.__importStar || function(mod2) {
        if (mod2 && mod2.__esModule)
          return mod2;
        var result = {};
        if (mod2 != null) {
          for (var k in mod2)
            if (k !== "default" && Object.prototype.hasOwnProperty.call(mod2, k))
              __createBinding(result, mod2, k);
        }
        __setModuleDefault(result, mod2);
        return result;
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.BlockIdFlag = exports2.Tendermint34Client = exports2.tendermint34 = exports2.VoteType = exports2.SubscriptionEventType = exports2.Method = exports2.broadcastTxSyncSuccess = exports2.broadcastTxCommitSuccess = exports2.WebsocketClient = exports2.HttpClient = exports2.toSeconds = exports2.toRfc3339WithNanoseconds = exports2.fromSeconds = exports2.fromRfc3339WithNanoseconds = exports2.DateTime = exports2.rawSecp256k1PubkeyToRawAddress = exports2.rawEd25519PubkeyToRawAddress = exports2.pubkeyToRawAddress = exports2.pubkeyToAddress = void 0;
      var addresses_1 = require_addresses2();
      Object.defineProperty(exports2, "pubkeyToAddress", { enumerable: true, get: function() {
        return addresses_1.pubkeyToAddress;
      } });
      Object.defineProperty(exports2, "pubkeyToRawAddress", { enumerable: true, get: function() {
        return addresses_1.pubkeyToRawAddress;
      } });
      Object.defineProperty(exports2, "rawEd25519PubkeyToRawAddress", { enumerable: true, get: function() {
        return addresses_1.rawEd25519PubkeyToRawAddress;
      } });
      Object.defineProperty(exports2, "rawSecp256k1PubkeyToRawAddress", { enumerable: true, get: function() {
        return addresses_1.rawSecp256k1PubkeyToRawAddress;
      } });
      var dates_1 = require_dates();
      Object.defineProperty(exports2, "DateTime", { enumerable: true, get: function() {
        return dates_1.DateTime;
      } });
      Object.defineProperty(exports2, "fromRfc3339WithNanoseconds", { enumerable: true, get: function() {
        return dates_1.fromRfc3339WithNanoseconds;
      } });
      Object.defineProperty(exports2, "fromSeconds", { enumerable: true, get: function() {
        return dates_1.fromSeconds;
      } });
      Object.defineProperty(exports2, "toRfc3339WithNanoseconds", { enumerable: true, get: function() {
        return dates_1.toRfc3339WithNanoseconds;
      } });
      Object.defineProperty(exports2, "toSeconds", { enumerable: true, get: function() {
        return dates_1.toSeconds;
      } });
      var rpcclients_1 = require_rpcclients();
      Object.defineProperty(exports2, "HttpClient", { enumerable: true, get: function() {
        return rpcclients_1.HttpClient;
      } });
      Object.defineProperty(exports2, "WebsocketClient", { enumerable: true, get: function() {
        return rpcclients_1.WebsocketClient;
      } });
      var tendermint34_1 = require_tendermint34();
      Object.defineProperty(exports2, "broadcastTxCommitSuccess", { enumerable: true, get: function() {
        return tendermint34_1.broadcastTxCommitSuccess;
      } });
      Object.defineProperty(exports2, "broadcastTxSyncSuccess", { enumerable: true, get: function() {
        return tendermint34_1.broadcastTxSyncSuccess;
      } });
      Object.defineProperty(exports2, "Method", { enumerable: true, get: function() {
        return tendermint34_1.Method;
      } });
      Object.defineProperty(exports2, "SubscriptionEventType", { enumerable: true, get: function() {
        return tendermint34_1.SubscriptionEventType;
      } });
      Object.defineProperty(exports2, "VoteType", { enumerable: true, get: function() {
        return tendermint34_1.VoteType;
      } });
      exports2.tendermint34 = __importStar(require_tendermint34());
      var tendermint34_2 = require_tendermint34();
      Object.defineProperty(exports2, "Tendermint34Client", { enumerable: true, get: function() {
        return tendermint34_2.Tendermint34Client;
      } });
      var types_1 = require_types5();
      Object.defineProperty(exports2, "BlockIdFlag", { enumerable: true, get: function() {
        return types_1.BlockIdFlag;
      } });
    }
  });

  // node_modules/@cosmjs/stargate/build/stargateclient.js
  var require_stargateclient = __commonJS({
    "node_modules/@cosmjs/stargate/build/stargateclient.js"(exports2) {
      "use strict";
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.StargateClient = exports2.assertIsDeliverTxFailure = exports2.assertIsDeliverTxSuccess = exports2.isDeliverTxSuccess = exports2.isDeliverTxFailure = exports2.TimeoutError = void 0;
      var amino_1 = require_build5();
      var encoding_1 = require_build2();
      var math_1 = require_build();
      var tendermint_rpc_1 = require_build11();
      var utils_1 = require_build3();
      var accounts_1 = require_accounts();
      var modules_1 = require_modules();
      var queryclient_1 = require_queryclient2();
      var search_1 = require_search();
      var TimeoutError = class extends Error {
        constructor(message, txId) {
          super(message);
          this.txId = txId;
        }
      };
      exports2.TimeoutError = TimeoutError;
      function isDeliverTxFailure(result) {
        return !!result.code;
      }
      exports2.isDeliverTxFailure = isDeliverTxFailure;
      function isDeliverTxSuccess(result) {
        return !isDeliverTxFailure(result);
      }
      exports2.isDeliverTxSuccess = isDeliverTxSuccess;
      function assertIsDeliverTxSuccess(result) {
        if (isDeliverTxFailure(result)) {
          throw new Error(`Error when broadcasting tx ${result.transactionHash} at height ${result.height}. Code: ${result.code}; Raw log: ${result.rawLog}`);
        }
      }
      exports2.assertIsDeliverTxSuccess = assertIsDeliverTxSuccess;
      function assertIsDeliverTxFailure(result) {
        if (isDeliverTxSuccess(result)) {
          throw new Error(`Transaction ${result.transactionHash} did not fail at height ${result.height}. Code: ${result.code}; Raw log: ${result.rawLog}`);
        }
      }
      exports2.assertIsDeliverTxFailure = assertIsDeliverTxFailure;
      var StargateClient = class {
        constructor(tmClient, options) {
          if (tmClient) {
            this.tmClient = tmClient;
            this.queryClient = queryclient_1.QueryClient.withExtensions(tmClient, modules_1.setupAuthExtension, modules_1.setupBankExtension, modules_1.setupStakingExtension, modules_1.setupTxExtension);
          }
          const { accountParser = accounts_1.accountFromAny } = options;
          this.accountParser = accountParser;
        }
        static async connect(endpoint, options = {}) {
          const tmClient = await tendermint_rpc_1.Tendermint34Client.connect(endpoint);
          return new StargateClient(tmClient, options);
        }
        getTmClient() {
          return this.tmClient;
        }
        forceGetTmClient() {
          if (!this.tmClient) {
            throw new Error("Tendermint client not available. You cannot use online functionality in offline mode.");
          }
          return this.tmClient;
        }
        getQueryClient() {
          return this.queryClient;
        }
        forceGetQueryClient() {
          if (!this.queryClient) {
            throw new Error("Query client not available. You cannot use online functionality in offline mode.");
          }
          return this.queryClient;
        }
        async getChainId() {
          if (!this.chainId) {
            const response = await this.forceGetTmClient().status();
            const chainId = response.nodeInfo.network;
            if (!chainId)
              throw new Error("Chain ID must not be empty");
            this.chainId = chainId;
          }
          return this.chainId;
        }
        async getHeight() {
          const status = await this.forceGetTmClient().status();
          return status.syncInfo.latestBlockHeight;
        }
        async getAccount(searchAddress) {
          try {
            const account = await this.forceGetQueryClient().auth.account(searchAddress);
            return account ? this.accountParser(account) : null;
          } catch (error) {
            if (/rpc error: code = NotFound/i.test(error.toString())) {
              return null;
            }
            throw error;
          }
        }
        async getSequence(address) {
          const account = await this.getAccount(address);
          if (!account) {
            throw new Error("Account does not exist on chain. Send some tokens there before trying to query sequence.");
          }
          return {
            accountNumber: account.accountNumber,
            sequence: account.sequence
          };
        }
        async getBlock(height) {
          const response = await this.forceGetTmClient().block(height);
          return {
            id: (0, encoding_1.toHex)(response.blockId.hash).toUpperCase(),
            header: {
              version: {
                block: new math_1.Uint53(response.block.header.version.block).toString(),
                app: new math_1.Uint53(response.block.header.version.app).toString()
              },
              height: response.block.header.height,
              chainId: response.block.header.chainId,
              time: (0, tendermint_rpc_1.toRfc3339WithNanoseconds)(response.block.header.time)
            },
            txs: response.block.txs
          };
        }
        async getBalance(address, searchDenom) {
          return this.forceGetQueryClient().bank.balance(address, searchDenom);
        }
        async getAllBalances(address) {
          return this.forceGetQueryClient().bank.allBalances(address);
        }
        async getBalanceStaked(address) {
          const allDelegations = [];
          let startAtKey = void 0;
          do {
            const { delegationResponses, pagination } = await this.forceGetQueryClient().staking.delegatorDelegations(address, startAtKey);
            const loadedDelegations = delegationResponses || [];
            allDelegations.push(...loadedDelegations);
            startAtKey = pagination === null || pagination === void 0 ? void 0 : pagination.nextKey;
          } while (startAtKey !== void 0 && startAtKey.length !== 0);
          const sumValues = allDelegations.reduce((previousValue, currentValue) => {
            (0, utils_1.assert)(currentValue.balance);
            return previousValue !== null ? (0, amino_1.addCoins)(previousValue, currentValue.balance) : currentValue.balance;
          }, null);
          return sumValues;
        }
        async getDelegation(delegatorAddress, validatorAddress) {
          var _a;
          let delegatedAmount;
          try {
            delegatedAmount = (_a = (await this.forceGetQueryClient().staking.delegation(delegatorAddress, validatorAddress)).delegationResponse) === null || _a === void 0 ? void 0 : _a.balance;
          } catch (e) {
            if (e.toString().includes("key not found")) {
            } else {
              throw e;
            }
          }
          return delegatedAmount || null;
        }
        async getTx(id) {
          var _a;
          const results = await this.txsQuery(`tx.hash='${id}'`);
          return (_a = results[0]) !== null && _a !== void 0 ? _a : null;
        }
        async searchTx(query, filter = {}) {
          const minHeight = filter.minHeight || 0;
          const maxHeight = filter.maxHeight || Number.MAX_SAFE_INTEGER;
          if (maxHeight < minHeight)
            return [];
          function withFilters(originalQuery) {
            return `${originalQuery} AND tx.height>=${minHeight} AND tx.height<=${maxHeight}`;
          }
          let txs;
          if ((0, search_1.isSearchByHeightQuery)(query)) {
            txs = query.height >= minHeight && query.height <= maxHeight ? await this.txsQuery(`tx.height=${query.height}`) : [];
          } else if ((0, search_1.isSearchBySentFromOrToQuery)(query)) {
            const sentQuery = withFilters(`message.module='bank' AND transfer.sender='${query.sentFromOrTo}'`);
            const receivedQuery = withFilters(`message.module='bank' AND transfer.recipient='${query.sentFromOrTo}'`);
            const [sent, received] = await Promise.all([sentQuery, receivedQuery].map((rawQuery) => this.txsQuery(rawQuery)));
            const sentHashes = sent.map((t) => t.hash);
            txs = [...sent, ...received.filter((t) => !sentHashes.includes(t.hash))];
          } else if ((0, search_1.isSearchByTagsQuery)(query)) {
            const rawQuery = withFilters(query.tags.map((t) => `${t.key}='${t.value}'`).join(" AND "));
            txs = await this.txsQuery(rawQuery);
          } else {
            throw new Error("Unknown query type");
          }
          const filtered = txs.filter((tx) => tx.height >= minHeight && tx.height <= maxHeight);
          return filtered;
        }
        disconnect() {
          if (this.tmClient)
            this.tmClient.disconnect();
        }
        async broadcastTx(tx, timeoutMs = 6e4, pollIntervalMs = 3e3) {
          let timedOut = false;
          const txPollTimeout = setTimeout(() => {
            timedOut = true;
          }, timeoutMs);
          const pollForTx = async (txId) => {
            if (timedOut) {
              throw new TimeoutError(`Transaction with ID ${txId} was submitted but was not yet found on the chain. You might want to check later. There was a wait of ${timeoutMs / 1e4} seconds.`, txId);
            }
            await (0, utils_1.sleep)(pollIntervalMs);
            const result = await this.getTx(txId);
            return result ? {
              code: result.code,
              height: result.height,
              rawLog: result.rawLog,
              transactionHash: txId,
              gasUsed: result.gasUsed,
              gasWanted: result.gasWanted
            } : pollForTx(txId);
          };
          const broadcasted = await this.forceGetTmClient().broadcastTxSync({ tx });
          if (broadcasted.code) {
            return Promise.reject(new Error(`Broadcasting transaction failed with code ${broadcasted.code} (codespace: ${broadcasted.codeSpace}). Log: ${broadcasted.log}`));
          }
          const transactionId = (0, encoding_1.toHex)(broadcasted.hash).toUpperCase();
          return new Promise((resolve, reject) => pollForTx(transactionId).then((value) => {
            clearTimeout(txPollTimeout);
            resolve(value);
          }, (error) => {
            clearTimeout(txPollTimeout);
            reject(error);
          }));
        }
        async txsQuery(query) {
          const results = await this.forceGetTmClient().txSearchAll({ query });
          return results.txs.map((tx) => {
            return {
              height: tx.height,
              hash: (0, encoding_1.toHex)(tx.hash).toUpperCase(),
              code: tx.result.code,
              rawLog: tx.result.log || "",
              tx: tx.tx,
              gasUsed: tx.result.gasUsed,
              gasWanted: tx.result.gasWanted
            };
          });
        }
      };
      exports2.StargateClient = StargateClient;
    }
  });

  // node_modules/@cosmjs/stargate/build/signingstargateclient.js
  var require_signingstargateclient = __commonJS({
    "node_modules/@cosmjs/stargate/build/signingstargateclient.js"(exports2) {
      "use strict";
      var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.SigningStargateClient = exports2.defaultRegistryTypes = void 0;
      var amino_1 = require_build5();
      var encoding_1 = require_build2();
      var math_1 = require_build();
      var proto_signing_1 = require_build6();
      var tendermint_rpc_1 = require_build11();
      var utils_1 = require_build3();
      var coin_1 = require_coin();
      var tx_1 = require_tx4();
      var tx_2 = require_tx11();
      var signing_1 = require_signing();
      var tx_3 = require_tx();
      var tx_4 = require_tx7();
      var long_1 = __importDefault(require_long());
      var aminotypes_1 = require_aminotypes();
      var fee_1 = require_fee();
      var modules_1 = require_modules();
      var modules_2 = require_modules();
      var stargateclient_1 = require_stargateclient();
      exports2.defaultRegistryTypes = [
        ["/cosmos.base.v1beta1.Coin", coin_1.Coin],
        ...modules_1.authzTypes,
        ...modules_1.bankTypes,
        ...modules_1.distributionTypes,
        ...modules_1.feegrantTypes,
        ...modules_1.govTypes,
        ...modules_1.stakingTypes,
        ...modules_1.ibcTypes,
        ...modules_1.vestingTypes
      ];
      function createDefaultRegistry() {
        return new proto_signing_1.Registry(exports2.defaultRegistryTypes);
      }
      function createDefaultTypes(prefix) {
        return {
          ...(0, modules_2.createAuthzAminoConverters)(),
          ...(0, modules_2.createBankAminoConverters)(),
          ...(0, modules_2.createDistributionAminoConverters)(),
          ...(0, modules_2.createGovAminoConverters)(),
          ...(0, modules_2.createStakingAminoConverters)(prefix),
          ...(0, modules_2.createIbcAminoConverters)(),
          ...(0, modules_2.createFreegrantAminoConverters)(),
          ...(0, modules_2.createVestingAminoConverters)()
        };
      }
      var SigningStargateClient2 = class extends stargateclient_1.StargateClient {
        constructor(tmClient, signer, options) {
          var _a;
          super(tmClient, options);
          const prefix = (_a = options.prefix) !== null && _a !== void 0 ? _a : "cosmos";
          const { registry = createDefaultRegistry(), aminoTypes = new aminotypes_1.AminoTypes(createDefaultTypes(prefix)) } = options;
          this.registry = registry;
          this.aminoTypes = aminoTypes;
          this.signer = signer;
          this.broadcastTimeoutMs = options.broadcastTimeoutMs;
          this.broadcastPollIntervalMs = options.broadcastPollIntervalMs;
          this.gasPrice = options.gasPrice;
        }
        static async connectWithSigner(endpoint, signer, options = {}) {
          const tmClient = await tendermint_rpc_1.Tendermint34Client.connect(endpoint);
          return new SigningStargateClient2(tmClient, signer, options);
        }
        static async offline(signer, options = {}) {
          return new SigningStargateClient2(void 0, signer, options);
        }
        async simulate(signerAddress, messages, memo) {
          const anyMsgs = messages.map((m) => this.registry.encodeAsAny(m));
          const accountFromSigner = (await this.signer.getAccounts()).find((account) => account.address === signerAddress);
          if (!accountFromSigner) {
            throw new Error("Failed to retrieve account from signer");
          }
          const pubkey = (0, amino_1.encodeSecp256k1Pubkey)(accountFromSigner.pubkey);
          const { sequence } = await this.getSequence(signerAddress);
          const { gasInfo } = await this.forceGetQueryClient().tx.simulate(anyMsgs, memo, pubkey, sequence);
          (0, utils_1.assertDefined)(gasInfo);
          return math_1.Uint53.fromString(gasInfo.gasUsed.toString()).toNumber();
        }
        async sendTokens(senderAddress, recipientAddress, amount, fee, memo = "") {
          const sendMsg = {
            typeUrl: "/cosmos.bank.v1beta1.MsgSend",
            value: {
              fromAddress: senderAddress,
              toAddress: recipientAddress,
              amount: [...amount]
            }
          };
          return this.signAndBroadcast(senderAddress, [sendMsg], fee, memo);
        }
        async delegateTokens(delegatorAddress, validatorAddress, amount, fee, memo = "") {
          const delegateMsg = {
            typeUrl: "/cosmos.staking.v1beta1.MsgDelegate",
            value: tx_2.MsgDelegate.fromPartial({
              delegatorAddress,
              validatorAddress,
              amount
            })
          };
          return this.signAndBroadcast(delegatorAddress, [delegateMsg], fee, memo);
        }
        async undelegateTokens(delegatorAddress, validatorAddress, amount, fee, memo = "") {
          const undelegateMsg = {
            typeUrl: "/cosmos.staking.v1beta1.MsgUndelegate",
            value: tx_2.MsgUndelegate.fromPartial({
              delegatorAddress,
              validatorAddress,
              amount
            })
          };
          return this.signAndBroadcast(delegatorAddress, [undelegateMsg], fee, memo);
        }
        async withdrawRewards(delegatorAddress, validatorAddress, fee, memo = "") {
          const withdrawMsg = {
            typeUrl: "/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward",
            value: tx_1.MsgWithdrawDelegatorReward.fromPartial({
              delegatorAddress,
              validatorAddress
            })
          };
          return this.signAndBroadcast(delegatorAddress, [withdrawMsg], fee, memo);
        }
        async sendIbcTokens(senderAddress, recipientAddress, transferAmount, sourcePort, sourceChannel, timeoutHeight, timeoutTimestamp, fee, memo = "") {
          const timeoutTimestampNanoseconds = timeoutTimestamp ? long_1.default.fromNumber(timeoutTimestamp).multiply(1e9) : void 0;
          const transferMsg = {
            typeUrl: "/ibc.applications.transfer.v1.MsgTransfer",
            value: tx_4.MsgTransfer.fromPartial({
              sourcePort,
              sourceChannel,
              sender: senderAddress,
              receiver: recipientAddress,
              token: transferAmount,
              timeoutHeight,
              timeoutTimestamp: timeoutTimestampNanoseconds
            })
          };
          return this.signAndBroadcast(senderAddress, [transferMsg], fee, memo);
        }
        async signAndBroadcast(signerAddress, messages, fee, memo = "") {
          let usedFee;
          if (fee == "auto" || typeof fee === "number") {
            (0, utils_1.assertDefined)(this.gasPrice, "Gas price must be set in the client options when auto gas is used.");
            const gasEstimation = await this.simulate(signerAddress, messages, memo);
            const multiplier = typeof fee === "number" ? fee : 1.3;
            usedFee = (0, fee_1.calculateFee)(Math.round(gasEstimation * multiplier), this.gasPrice);
          } else {
            usedFee = fee;
          }
          const txRaw = await this.sign(signerAddress, messages, usedFee, memo);
          const txBytes = tx_3.TxRaw.encode(txRaw).finish();
          return this.broadcastTx(txBytes, this.broadcastTimeoutMs, this.broadcastPollIntervalMs);
        }
        async sign(signerAddress, messages, fee, memo, explicitSignerData) {
          let signerData;
          if (explicitSignerData) {
            signerData = explicitSignerData;
          } else {
            const { accountNumber, sequence } = await this.getSequence(signerAddress);
            const chainId = await this.getChainId();
            signerData = {
              accountNumber,
              sequence,
              chainId
            };
          }
          return (0, proto_signing_1.isOfflineDirectSigner)(this.signer) ? this.signDirect(signerAddress, messages, fee, memo, signerData) : this.signAmino(signerAddress, messages, fee, memo, signerData);
        }
        async signAmino(signerAddress, messages, fee, memo, { accountNumber, sequence, chainId }) {
          (0, utils_1.assert)(!(0, proto_signing_1.isOfflineDirectSigner)(this.signer));
          const accountFromSigner = (await this.signer.getAccounts()).find((account) => account.address === signerAddress);
          if (!accountFromSigner) {
            throw new Error("Failed to retrieve account from signer");
          }
          const pubkey = (0, proto_signing_1.encodePubkey)((0, amino_1.encodeSecp256k1Pubkey)(accountFromSigner.pubkey));
          const signMode = signing_1.SignMode.SIGN_MODE_LEGACY_AMINO_JSON;
          const msgs = messages.map((msg) => this.aminoTypes.toAmino(msg));
          const signDoc = (0, amino_1.makeSignDoc)(msgs, fee, chainId, memo, accountNumber, sequence);
          const { signature, signed } = await this.signer.signAmino(signerAddress, signDoc);
          const signedTxBody = {
            messages: signed.msgs.map((msg) => this.aminoTypes.fromAmino(msg)),
            memo: signed.memo
          };
          const signedTxBodyEncodeObject = {
            typeUrl: "/cosmos.tx.v1beta1.TxBody",
            value: signedTxBody
          };
          const signedTxBodyBytes = this.registry.encode(signedTxBodyEncodeObject);
          const signedGasLimit = math_1.Int53.fromString(signed.fee.gas).toNumber();
          const signedSequence = math_1.Int53.fromString(signed.sequence).toNumber();
          const signedAuthInfoBytes = (0, proto_signing_1.makeAuthInfoBytes)([{ pubkey, sequence: signedSequence }], signed.fee.amount, signedGasLimit, signMode);
          return tx_3.TxRaw.fromPartial({
            bodyBytes: signedTxBodyBytes,
            authInfoBytes: signedAuthInfoBytes,
            signatures: [(0, encoding_1.fromBase64)(signature.signature)]
          });
        }
        async signDirect(signerAddress, messages, fee, memo, { accountNumber, sequence, chainId }) {
          (0, utils_1.assert)((0, proto_signing_1.isOfflineDirectSigner)(this.signer));
          const accountFromSigner = (await this.signer.getAccounts()).find((account) => account.address === signerAddress);
          if (!accountFromSigner) {
            throw new Error("Failed to retrieve account from signer");
          }
          const pubkey = (0, proto_signing_1.encodePubkey)((0, amino_1.encodeSecp256k1Pubkey)(accountFromSigner.pubkey));
          const txBodyEncodeObject = {
            typeUrl: "/cosmos.tx.v1beta1.TxBody",
            value: {
              messages,
              memo
            }
          };
          const txBodyBytes = this.registry.encode(txBodyEncodeObject);
          const gasLimit = math_1.Int53.fromString(fee.gas).toNumber();
          const authInfoBytes = (0, proto_signing_1.makeAuthInfoBytes)([{ pubkey, sequence }], fee.amount, gasLimit);
          const signDoc = (0, proto_signing_1.makeSignDoc)(txBodyBytes, authInfoBytes, chainId, accountNumber);
          const { signature, signed } = await this.signer.signDirect(signerAddress, signDoc);
          return tx_3.TxRaw.fromPartial({
            bodyBytes: signed.bodyBytes,
            authInfoBytes: signed.authInfoBytes,
            signatures: [(0, encoding_1.fromBase64)(signature.signature)]
          });
        }
      };
      exports2.SigningStargateClient = SigningStargateClient2;
    }
  });

  // node_modules/@cosmjs/stargate/build/index.js
  var require_build12 = __commonJS({
    "node_modules/@cosmjs/stargate/build/index.js"(exports2) {
      "use strict";
      var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
        if (k2 === void 0)
          k2 = k;
        Object.defineProperty(o, k2, { enumerable: true, get: function() {
          return m[k];
        } });
      } : function(o, m, k, k2) {
        if (k2 === void 0)
          k2 = k;
        o[k2] = m[k];
      });
      var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
        Object.defineProperty(o, "default", { enumerable: true, value: v });
      } : function(o, v) {
        o["default"] = v;
      });
      var __importStar = exports2 && exports2.__importStar || function(mod2) {
        if (mod2 && mod2.__esModule)
          return mod2;
        var result = {};
        if (mod2 != null) {
          for (var k in mod2)
            if (k !== "default" && Object.prototype.hasOwnProperty.call(mod2, k))
              __createBinding(result, mod2, k);
        }
        __setModuleDefault(result, mod2);
        return result;
      };
      Object.defineProperty(exports2, "__esModule", { value: true });
      exports2.QueryClient = exports2.decodeCosmosSdkDecFromProto = exports2.createProtobufRpcClient = exports2.createPagination = exports2.makeMultisignedTx = exports2.createStakingAminoConverters = exports2.createIbcAminoConverters = exports2.createGovAminoConverters = exports2.createFreegrantAminoConverters = exports2.createDistributionAminoConverters = exports2.createBankAminoConverters = exports2.createAuthzAminoConverters = exports2.setupTxExtension = exports2.setupStakingExtension = exports2.setupMintExtension = exports2.setupIbcExtension = exports2.setupGovExtension = exports2.setupDistributionExtension = exports2.setupBankExtension = exports2.setupAuthExtension = exports2.isMsgWithdrawDelegatorRewardEncodeObject = exports2.isMsgVoteEncodeObject = exports2.isMsgUndelegateEncodeObject = exports2.isMsgTransferEncodeObject = exports2.isMsgSubmitProposalEncodeObject = exports2.isMsgSendEncodeObject = exports2.isMsgDepositEncodeObject = exports2.isMsgDelegateEncodeObject = exports2.isAminoMsgWithdrawValidatorCommission = exports2.isAminoMsgWithdrawDelegatorReward = exports2.isAminoMsgVote = exports2.isAminoMsgVerifyInvariant = exports2.isAminoMsgUnjail = exports2.isAminoMsgUndelegate = exports2.isAminoMsgSubmitProposal = exports2.isAminoMsgSubmitEvidence = exports2.isAminoMsgSetWithdrawAddress = exports2.isAminoMsgSend = exports2.isAminoMsgMultiSend = exports2.isAminoMsgFundCommunityPool = exports2.isAminoMsgEditValidator = exports2.isAminoMsgDeposit = exports2.isAminoMsgDelegate = exports2.isAminoMsgCreateValidator = exports2.isAminoMsgBeginRedelegate = exports2.logs = exports2.GasPrice = exports2.calculateFee = exports2.AminoTypes = exports2.accountFromAny = void 0;
      exports2.parseCoins = exports2.makeCosmoshubPath = exports2.coins = exports2.coin = exports2.TimeoutError = exports2.StargateClient = exports2.isDeliverTxSuccess = exports2.isDeliverTxFailure = exports2.assertIsDeliverTxSuccess = exports2.assertIsDeliverTxFailure = exports2.SigningStargateClient = exports2.defaultRegistryTypes = exports2.isSearchByTagsQuery = exports2.isSearchBySentFromOrToQuery = exports2.isSearchByHeightQuery = void 0;
      var accounts_1 = require_accounts();
      Object.defineProperty(exports2, "accountFromAny", { enumerable: true, get: function() {
        return accounts_1.accountFromAny;
      } });
      var aminotypes_1 = require_aminotypes();
      Object.defineProperty(exports2, "AminoTypes", { enumerable: true, get: function() {
        return aminotypes_1.AminoTypes;
      } });
      var fee_1 = require_fee();
      Object.defineProperty(exports2, "calculateFee", { enumerable: true, get: function() {
        return fee_1.calculateFee;
      } });
      Object.defineProperty(exports2, "GasPrice", { enumerable: true, get: function() {
        return fee_1.GasPrice;
      } });
      exports2.logs = __importStar(require_logs());
      var modules_1 = require_modules();
      Object.defineProperty(exports2, "isAminoMsgBeginRedelegate", { enumerable: true, get: function() {
        return modules_1.isAminoMsgBeginRedelegate;
      } });
      Object.defineProperty(exports2, "isAminoMsgCreateValidator", { enumerable: true, get: function() {
        return modules_1.isAminoMsgCreateValidator;
      } });
      Object.defineProperty(exports2, "isAminoMsgDelegate", { enumerable: true, get: function() {
        return modules_1.isAminoMsgDelegate;
      } });
      Object.defineProperty(exports2, "isAminoMsgDeposit", { enumerable: true, get: function() {
        return modules_1.isAminoMsgDeposit;
      } });
      Object.defineProperty(exports2, "isAminoMsgEditValidator", { enumerable: true, get: function() {
        return modules_1.isAminoMsgEditValidator;
      } });
      Object.defineProperty(exports2, "isAminoMsgFundCommunityPool", { enumerable: true, get: function() {
        return modules_1.isAminoMsgFundCommunityPool;
      } });
      Object.defineProperty(exports2, "isAminoMsgMultiSend", { enumerable: true, get: function() {
        return modules_1.isAminoMsgMultiSend;
      } });
      Object.defineProperty(exports2, "isAminoMsgSend", { enumerable: true, get: function() {
        return modules_1.isAminoMsgSend;
      } });
      Object.defineProperty(exports2, "isAminoMsgSetWithdrawAddress", { enumerable: true, get: function() {
        return modules_1.isAminoMsgSetWithdrawAddress;
      } });
      Object.defineProperty(exports2, "isAminoMsgSubmitEvidence", { enumerable: true, get: function() {
        return modules_1.isAminoMsgSubmitEvidence;
      } });
      Object.defineProperty(exports2, "isAminoMsgSubmitProposal", { enumerable: true, get: function() {
        return modules_1.isAminoMsgSubmitProposal;
      } });
      Object.defineProperty(exports2, "isAminoMsgUndelegate", { enumerable: true, get: function() {
        return modules_1.isAminoMsgUndelegate;
      } });
      Object.defineProperty(exports2, "isAminoMsgUnjail", { enumerable: true, get: function() {
        return modules_1.isAminoMsgUnjail;
      } });
      Object.defineProperty(exports2, "isAminoMsgVerifyInvariant", { enumerable: true, get: function() {
        return modules_1.isAminoMsgVerifyInvariant;
      } });
      Object.defineProperty(exports2, "isAminoMsgVote", { enumerable: true, get: function() {
        return modules_1.isAminoMsgVote;
      } });
      Object.defineProperty(exports2, "isAminoMsgWithdrawDelegatorReward", { enumerable: true, get: function() {
        return modules_1.isAminoMsgWithdrawDelegatorReward;
      } });
      Object.defineProperty(exports2, "isAminoMsgWithdrawValidatorCommission", { enumerable: true, get: function() {
        return modules_1.isAminoMsgWithdrawValidatorCommission;
      } });
      Object.defineProperty(exports2, "isMsgDelegateEncodeObject", { enumerable: true, get: function() {
        return modules_1.isMsgDelegateEncodeObject;
      } });
      Object.defineProperty(exports2, "isMsgDepositEncodeObject", { enumerable: true, get: function() {
        return modules_1.isMsgDepositEncodeObject;
      } });
      Object.defineProperty(exports2, "isMsgSendEncodeObject", { enumerable: true, get: function() {
        return modules_1.isMsgSendEncodeObject;
      } });
      Object.defineProperty(exports2, "isMsgSubmitProposalEncodeObject", { enumerable: true, get: function() {
        return modules_1.isMsgSubmitProposalEncodeObject;
      } });
      Object.defineProperty(exports2, "isMsgTransferEncodeObject", { enumerable: true, get: function() {
        return modules_1.isMsgTransferEncodeObject;
      } });
      Object.defineProperty(exports2, "isMsgUndelegateEncodeObject", { enumerable: true, get: function() {
        return modules_1.isMsgUndelegateEncodeObject;
      } });
      Object.defineProperty(exports2, "isMsgVoteEncodeObject", { enumerable: true, get: function() {
        return modules_1.isMsgVoteEncodeObject;
      } });
      Object.defineProperty(exports2, "isMsgWithdrawDelegatorRewardEncodeObject", { enumerable: true, get: function() {
        return modules_1.isMsgWithdrawDelegatorRewardEncodeObject;
      } });
      Object.defineProperty(exports2, "setupAuthExtension", { enumerable: true, get: function() {
        return modules_1.setupAuthExtension;
      } });
      Object.defineProperty(exports2, "setupBankExtension", { enumerable: true, get: function() {
        return modules_1.setupBankExtension;
      } });
      Object.defineProperty(exports2, "setupDistributionExtension", { enumerable: true, get: function() {
        return modules_1.setupDistributionExtension;
      } });
      Object.defineProperty(exports2, "setupGovExtension", { enumerable: true, get: function() {
        return modules_1.setupGovExtension;
      } });
      Object.defineProperty(exports2, "setupIbcExtension", { enumerable: true, get: function() {
        return modules_1.setupIbcExtension;
      } });
      Object.defineProperty(exports2, "setupMintExtension", { enumerable: true, get: function() {
        return modules_1.setupMintExtension;
      } });
      Object.defineProperty(exports2, "setupStakingExtension", { enumerable: true, get: function() {
        return modules_1.setupStakingExtension;
      } });
      Object.defineProperty(exports2, "setupTxExtension", { enumerable: true, get: function() {
        return modules_1.setupTxExtension;
      } });
      var modules_2 = require_modules();
      Object.defineProperty(exports2, "createAuthzAminoConverters", { enumerable: true, get: function() {
        return modules_2.createAuthzAminoConverters;
      } });
      Object.defineProperty(exports2, "createBankAminoConverters", { enumerable: true, get: function() {
        return modules_2.createBankAminoConverters;
      } });
      Object.defineProperty(exports2, "createDistributionAminoConverters", { enumerable: true, get: function() {
        return modules_2.createDistributionAminoConverters;
      } });
      Object.defineProperty(exports2, "createFreegrantAminoConverters", { enumerable: true, get: function() {
        return modules_2.createFreegrantAminoConverters;
      } });
      Object.defineProperty(exports2, "createGovAminoConverters", { enumerable: true, get: function() {
        return modules_2.createGovAminoConverters;
      } });
      Object.defineProperty(exports2, "createIbcAminoConverters", { enumerable: true, get: function() {
        return modules_2.createIbcAminoConverters;
      } });
      Object.defineProperty(exports2, "createStakingAminoConverters", { enumerable: true, get: function() {
        return modules_2.createStakingAminoConverters;
      } });
      var multisignature_1 = require_multisignature();
      Object.defineProperty(exports2, "makeMultisignedTx", { enumerable: true, get: function() {
        return multisignature_1.makeMultisignedTx;
      } });
      var queryclient_1 = require_queryclient2();
      Object.defineProperty(exports2, "createPagination", { enumerable: true, get: function() {
        return queryclient_1.createPagination;
      } });
      Object.defineProperty(exports2, "createProtobufRpcClient", { enumerable: true, get: function() {
        return queryclient_1.createProtobufRpcClient;
      } });
      Object.defineProperty(exports2, "decodeCosmosSdkDecFromProto", { enumerable: true, get: function() {
        return queryclient_1.decodeCosmosSdkDecFromProto;
      } });
      Object.defineProperty(exports2, "QueryClient", { enumerable: true, get: function() {
        return queryclient_1.QueryClient;
      } });
      var search_1 = require_search();
      Object.defineProperty(exports2, "isSearchByHeightQuery", { enumerable: true, get: function() {
        return search_1.isSearchByHeightQuery;
      } });
      Object.defineProperty(exports2, "isSearchBySentFromOrToQuery", { enumerable: true, get: function() {
        return search_1.isSearchBySentFromOrToQuery;
      } });
      Object.defineProperty(exports2, "isSearchByTagsQuery", { enumerable: true, get: function() {
        return search_1.isSearchByTagsQuery;
      } });
      var signingstargateclient_1 = require_signingstargateclient();
      Object.defineProperty(exports2, "defaultRegistryTypes", { enumerable: true, get: function() {
        return signingstargateclient_1.defaultRegistryTypes;
      } });
      Object.defineProperty(exports2, "SigningStargateClient", { enumerable: true, get: function() {
        return signingstargateclient_1.SigningStargateClient;
      } });
      var stargateclient_1 = require_stargateclient();
      Object.defineProperty(exports2, "assertIsDeliverTxFailure", { enumerable: true, get: function() {
        return stargateclient_1.assertIsDeliverTxFailure;
      } });
      Object.defineProperty(exports2, "assertIsDeliverTxSuccess", { enumerable: true, get: function() {
        return stargateclient_1.assertIsDeliverTxSuccess;
      } });
      Object.defineProperty(exports2, "isDeliverTxFailure", { enumerable: true, get: function() {
        return stargateclient_1.isDeliverTxFailure;
      } });
      Object.defineProperty(exports2, "isDeliverTxSuccess", { enumerable: true, get: function() {
        return stargateclient_1.isDeliverTxSuccess;
      } });
      Object.defineProperty(exports2, "StargateClient", { enumerable: true, get: function() {
        return stargateclient_1.StargateClient;
      } });
      Object.defineProperty(exports2, "TimeoutError", { enumerable: true, get: function() {
        return stargateclient_1.TimeoutError;
      } });
      var proto_signing_1 = require_build6();
      Object.defineProperty(exports2, "coin", { enumerable: true, get: function() {
        return proto_signing_1.coin;
      } });
      Object.defineProperty(exports2, "coins", { enumerable: true, get: function() {
        return proto_signing_1.coins;
      } });
      Object.defineProperty(exports2, "makeCosmoshubPath", { enumerable: true, get: function() {
        return proto_signing_1.makeCosmoshubPath;
      } });
      Object.defineProperty(exports2, "parseCoins", { enumerable: true, get: function() {
        return proto_signing_1.parseCoins;
      } });
    }
  });

  // node_modules/@hotwired/turbo/dist/turbo.es2017-esm.js
  (function() {
    if (window.Reflect === void 0 || window.customElements === void 0 || window.customElements.polyfillWrapFlushCallback) {
      return;
    }
    const BuiltInHTMLElement = HTMLElement;
    const wrapperForTheName = {
      "HTMLElement": function HTMLElement2() {
        return Reflect.construct(BuiltInHTMLElement, [], this.constructor);
      }
    };
    window.HTMLElement = wrapperForTheName["HTMLElement"];
    HTMLElement.prototype = BuiltInHTMLElement.prototype;
    HTMLElement.prototype.constructor = HTMLElement;
    Object.setPrototypeOf(HTMLElement, BuiltInHTMLElement);
  })();
  (function(prototype) {
    if (typeof prototype.requestSubmit == "function")
      return;
    prototype.requestSubmit = function(submitter) {
      if (submitter) {
        validateSubmitter(submitter, this);
        submitter.click();
      } else {
        submitter = document.createElement("input");
        submitter.type = "submit";
        submitter.hidden = true;
        this.appendChild(submitter);
        submitter.click();
        this.removeChild(submitter);
      }
    };
    function validateSubmitter(submitter, form) {
      submitter instanceof HTMLElement || raise(TypeError, "parameter 1 is not of type 'HTMLElement'");
      submitter.type == "submit" || raise(TypeError, "The specified element is not a submit button");
      submitter.form == form || raise(DOMException, "The specified element is not owned by this form element", "NotFoundError");
    }
    function raise(errorConstructor, message, name) {
      throw new errorConstructor("Failed to execute 'requestSubmit' on 'HTMLFormElement': " + message + ".", name);
    }
  })(HTMLFormElement.prototype);
  var submittersByForm = /* @__PURE__ */ new WeakMap();
  function findSubmitterFromClickTarget(target) {
    const element = target instanceof Element ? target : target instanceof Node ? target.parentElement : null;
    const candidate = element ? element.closest("input, button") : null;
    return (candidate === null || candidate === void 0 ? void 0 : candidate.type) == "submit" ? candidate : null;
  }
  function clickCaptured(event) {
    const submitter = findSubmitterFromClickTarget(event.target);
    if (submitter && submitter.form) {
      submittersByForm.set(submitter.form, submitter);
    }
  }
  (function() {
    if ("submitter" in Event.prototype)
      return;
    let prototype;
    if ("SubmitEvent" in window && /Apple Computer/.test(navigator.vendor)) {
      prototype = window.SubmitEvent.prototype;
    } else if ("SubmitEvent" in window) {
      return;
    } else {
      prototype = window.Event.prototype;
    }
    addEventListener("click", clickCaptured, true);
    Object.defineProperty(prototype, "submitter", {
      get() {
        if (this.type == "submit" && this.target instanceof HTMLFormElement) {
          return submittersByForm.get(this.target);
        }
      }
    });
  })();
  var FrameLoadingStyle;
  (function(FrameLoadingStyle2) {
    FrameLoadingStyle2["eager"] = "eager";
    FrameLoadingStyle2["lazy"] = "lazy";
  })(FrameLoadingStyle || (FrameLoadingStyle = {}));
  var FrameElement = class extends HTMLElement {
    constructor() {
      super();
      this.loaded = Promise.resolve();
      this.delegate = new FrameElement.delegateConstructor(this);
    }
    static get observedAttributes() {
      return ["disabled", "loading", "src"];
    }
    connectedCallback() {
      this.delegate.connect();
    }
    disconnectedCallback() {
      this.delegate.disconnect();
    }
    reload() {
      const { src } = this;
      this.src = null;
      this.src = src;
    }
    attributeChangedCallback(name) {
      if (name == "loading") {
        this.delegate.loadingStyleChanged();
      } else if (name == "src") {
        this.delegate.sourceURLChanged();
      } else {
        this.delegate.disabledChanged();
      }
    }
    get src() {
      return this.getAttribute("src");
    }
    set src(value) {
      if (value) {
        this.setAttribute("src", value);
      } else {
        this.removeAttribute("src");
      }
    }
    get loading() {
      return frameLoadingStyleFromString(this.getAttribute("loading") || "");
    }
    set loading(value) {
      if (value) {
        this.setAttribute("loading", value);
      } else {
        this.removeAttribute("loading");
      }
    }
    get disabled() {
      return this.hasAttribute("disabled");
    }
    set disabled(value) {
      if (value) {
        this.setAttribute("disabled", "");
      } else {
        this.removeAttribute("disabled");
      }
    }
    get autoscroll() {
      return this.hasAttribute("autoscroll");
    }
    set autoscroll(value) {
      if (value) {
        this.setAttribute("autoscroll", "");
      } else {
        this.removeAttribute("autoscroll");
      }
    }
    get complete() {
      return !this.delegate.isLoading;
    }
    get isActive() {
      return this.ownerDocument === document && !this.isPreview;
    }
    get isPreview() {
      var _a, _b;
      return (_b = (_a = this.ownerDocument) === null || _a === void 0 ? void 0 : _a.documentElement) === null || _b === void 0 ? void 0 : _b.hasAttribute("data-turbo-preview");
    }
  };
  function frameLoadingStyleFromString(style) {
    switch (style.toLowerCase()) {
      case "lazy":
        return FrameLoadingStyle.lazy;
      default:
        return FrameLoadingStyle.eager;
    }
  }
  function expandURL(locatable) {
    return new URL(locatable.toString(), document.baseURI);
  }
  function getAnchor(url) {
    let anchorMatch;
    if (url.hash) {
      return url.hash.slice(1);
    } else if (anchorMatch = url.href.match(/#(.*)$/)) {
      return anchorMatch[1];
    }
  }
  function getAction(form, submitter) {
    const action = (submitter === null || submitter === void 0 ? void 0 : submitter.getAttribute("formaction")) || form.getAttribute("action") || form.action;
    return expandURL(action);
  }
  function getExtension(url) {
    return (getLastPathComponent(url).match(/\.[^.]*$/) || [])[0] || "";
  }
  function isHTML(url) {
    return !!getExtension(url).match(/^(?:|\.(?:htm|html|xhtml))$/);
  }
  function isPrefixedBy(baseURL, url) {
    const prefix = getPrefix(url);
    return baseURL.href === expandURL(prefix).href || baseURL.href.startsWith(prefix);
  }
  function locationIsVisitable(location2, rootLocation) {
    return isPrefixedBy(location2, rootLocation) && isHTML(location2);
  }
  function getRequestURL(url) {
    const anchor = getAnchor(url);
    return anchor != null ? url.href.slice(0, -(anchor.length + 1)) : url.href;
  }
  function toCacheKey(url) {
    return getRequestURL(url);
  }
  function urlsAreEqual(left, right) {
    return expandURL(left).href == expandURL(right).href;
  }
  function getPathComponents(url) {
    return url.pathname.split("/").slice(1);
  }
  function getLastPathComponent(url) {
    return getPathComponents(url).slice(-1)[0];
  }
  function getPrefix(url) {
    return addTrailingSlash(url.origin + url.pathname);
  }
  function addTrailingSlash(value) {
    return value.endsWith("/") ? value : value + "/";
  }
  var FetchResponse = class {
    constructor(response) {
      this.response = response;
    }
    get succeeded() {
      return this.response.ok;
    }
    get failed() {
      return !this.succeeded;
    }
    get clientError() {
      return this.statusCode >= 400 && this.statusCode <= 499;
    }
    get serverError() {
      return this.statusCode >= 500 && this.statusCode <= 599;
    }
    get redirected() {
      return this.response.redirected;
    }
    get location() {
      return expandURL(this.response.url);
    }
    get isHTML() {
      return this.contentType && this.contentType.match(/^(?:text\/([^\s;,]+\b)?html|application\/xhtml\+xml)\b/);
    }
    get statusCode() {
      return this.response.status;
    }
    get contentType() {
      return this.header("Content-Type");
    }
    get responseText() {
      return this.response.clone().text();
    }
    get responseHTML() {
      if (this.isHTML) {
        return this.response.clone().text();
      } else {
        return Promise.resolve(void 0);
      }
    }
    header(name) {
      return this.response.headers.get(name);
    }
  };
  function dispatch(eventName, { target, cancelable, detail } = {}) {
    const event = new CustomEvent(eventName, { cancelable, bubbles: true, detail });
    if (target && target.isConnected) {
      target.dispatchEvent(event);
    } else {
      document.documentElement.dispatchEvent(event);
    }
    return event;
  }
  function nextAnimationFrame() {
    return new Promise((resolve) => requestAnimationFrame(() => resolve()));
  }
  function nextEventLoopTick() {
    return new Promise((resolve) => setTimeout(() => resolve(), 0));
  }
  function nextMicrotask() {
    return Promise.resolve();
  }
  function parseHTMLDocument(html = "") {
    return new DOMParser().parseFromString(html, "text/html");
  }
  function unindent(strings, ...values) {
    const lines = interpolate(strings, values).replace(/^\n/, "").split("\n");
    const match = lines[0].match(/^\s+/);
    const indent = match ? match[0].length : 0;
    return lines.map((line) => line.slice(indent)).join("\n");
  }
  function interpolate(strings, values) {
    return strings.reduce((result, string, i) => {
      const value = values[i] == void 0 ? "" : values[i];
      return result + string + value;
    }, "");
  }
  function uuid() {
    return Array.apply(null, { length: 36 }).map((_, i) => {
      if (i == 8 || i == 13 || i == 18 || i == 23) {
        return "-";
      } else if (i == 14) {
        return "4";
      } else if (i == 19) {
        return (Math.floor(Math.random() * 4) + 8).toString(16);
      } else {
        return Math.floor(Math.random() * 15).toString(16);
      }
    }).join("");
  }
  function getAttribute(attributeName, ...elements) {
    for (const value of elements.map((element) => element === null || element === void 0 ? void 0 : element.getAttribute(attributeName))) {
      if (typeof value == "string")
        return value;
    }
    return null;
  }
  function markAsBusy(...elements) {
    for (const element of elements) {
      if (element.localName == "turbo-frame") {
        element.setAttribute("busy", "");
      }
      element.setAttribute("aria-busy", "true");
    }
  }
  function clearBusyState(...elements) {
    for (const element of elements) {
      if (element.localName == "turbo-frame") {
        element.removeAttribute("busy");
      }
      element.removeAttribute("aria-busy");
    }
  }
  var FetchMethod;
  (function(FetchMethod2) {
    FetchMethod2[FetchMethod2["get"] = 0] = "get";
    FetchMethod2[FetchMethod2["post"] = 1] = "post";
    FetchMethod2[FetchMethod2["put"] = 2] = "put";
    FetchMethod2[FetchMethod2["patch"] = 3] = "patch";
    FetchMethod2[FetchMethod2["delete"] = 4] = "delete";
  })(FetchMethod || (FetchMethod = {}));
  function fetchMethodFromString(method) {
    switch (method.toLowerCase()) {
      case "get":
        return FetchMethod.get;
      case "post":
        return FetchMethod.post;
      case "put":
        return FetchMethod.put;
      case "patch":
        return FetchMethod.patch;
      case "delete":
        return FetchMethod.delete;
    }
  }
  var FetchRequest = class {
    constructor(delegate, method, location2, body = new URLSearchParams(), target = null) {
      this.abortController = new AbortController();
      this.resolveRequestPromise = (value) => {
      };
      this.delegate = delegate;
      this.method = method;
      this.headers = this.defaultHeaders;
      this.body = body;
      this.url = location2;
      this.target = target;
    }
    get location() {
      return this.url;
    }
    get params() {
      return this.url.searchParams;
    }
    get entries() {
      return this.body ? Array.from(this.body.entries()) : [];
    }
    cancel() {
      this.abortController.abort();
    }
    async perform() {
      var _a, _b;
      const { fetchOptions } = this;
      (_b = (_a = this.delegate).prepareHeadersForRequest) === null || _b === void 0 ? void 0 : _b.call(_a, this.headers, this);
      await this.allowRequestToBeIntercepted(fetchOptions);
      try {
        this.delegate.requestStarted(this);
        const response = await fetch(this.url.href, fetchOptions);
        return await this.receive(response);
      } catch (error) {
        if (error.name !== "AbortError") {
          this.delegate.requestErrored(this, error);
          throw error;
        }
      } finally {
        this.delegate.requestFinished(this);
      }
    }
    async receive(response) {
      const fetchResponse = new FetchResponse(response);
      const event = dispatch("turbo:before-fetch-response", { cancelable: true, detail: { fetchResponse }, target: this.target });
      if (event.defaultPrevented) {
        this.delegate.requestPreventedHandlingResponse(this, fetchResponse);
      } else if (fetchResponse.succeeded) {
        this.delegate.requestSucceededWithResponse(this, fetchResponse);
      } else {
        this.delegate.requestFailedWithResponse(this, fetchResponse);
      }
      return fetchResponse;
    }
    get fetchOptions() {
      var _a;
      return {
        method: FetchMethod[this.method].toUpperCase(),
        credentials: "same-origin",
        headers: this.headers,
        redirect: "follow",
        body: this.isIdempotent ? null : this.body,
        signal: this.abortSignal,
        referrer: (_a = this.delegate.referrer) === null || _a === void 0 ? void 0 : _a.href
      };
    }
    get defaultHeaders() {
      return {
        "Accept": "text/html, application/xhtml+xml"
      };
    }
    get isIdempotent() {
      return this.method == FetchMethod.get;
    }
    get abortSignal() {
      return this.abortController.signal;
    }
    async allowRequestToBeIntercepted(fetchOptions) {
      const requestInterception = new Promise((resolve) => this.resolveRequestPromise = resolve);
      const event = dispatch("turbo:before-fetch-request", {
        cancelable: true,
        detail: {
          fetchOptions,
          url: this.url,
          resume: this.resolveRequestPromise
        },
        target: this.target
      });
      if (event.defaultPrevented)
        await requestInterception;
    }
  };
  var AppearanceObserver = class {
    constructor(delegate, element) {
      this.started = false;
      this.intersect = (entries) => {
        const lastEntry = entries.slice(-1)[0];
        if (lastEntry === null || lastEntry === void 0 ? void 0 : lastEntry.isIntersecting) {
          this.delegate.elementAppearedInViewport(this.element);
        }
      };
      this.delegate = delegate;
      this.element = element;
      this.intersectionObserver = new IntersectionObserver(this.intersect);
    }
    start() {
      if (!this.started) {
        this.started = true;
        this.intersectionObserver.observe(this.element);
      }
    }
    stop() {
      if (this.started) {
        this.started = false;
        this.intersectionObserver.unobserve(this.element);
      }
    }
  };
  var StreamMessage = class {
    constructor(html) {
      this.templateElement = document.createElement("template");
      this.templateElement.innerHTML = html;
    }
    static wrap(message) {
      if (typeof message == "string") {
        return new this(message);
      } else {
        return message;
      }
    }
    get fragment() {
      const fragment = document.createDocumentFragment();
      for (const element of this.foreignElements) {
        fragment.appendChild(document.importNode(element, true));
      }
      return fragment;
    }
    get foreignElements() {
      return this.templateChildren.reduce((streamElements, child) => {
        if (child.tagName.toLowerCase() == "turbo-stream") {
          return [...streamElements, child];
        } else {
          return streamElements;
        }
      }, []);
    }
    get templateChildren() {
      return Array.from(this.templateElement.content.children);
    }
  };
  StreamMessage.contentType = "text/vnd.turbo-stream.html";
  var FormSubmissionState;
  (function(FormSubmissionState2) {
    FormSubmissionState2[FormSubmissionState2["initialized"] = 0] = "initialized";
    FormSubmissionState2[FormSubmissionState2["requesting"] = 1] = "requesting";
    FormSubmissionState2[FormSubmissionState2["waiting"] = 2] = "waiting";
    FormSubmissionState2[FormSubmissionState2["receiving"] = 3] = "receiving";
    FormSubmissionState2[FormSubmissionState2["stopping"] = 4] = "stopping";
    FormSubmissionState2[FormSubmissionState2["stopped"] = 5] = "stopped";
  })(FormSubmissionState || (FormSubmissionState = {}));
  var FormEnctype;
  (function(FormEnctype2) {
    FormEnctype2["urlEncoded"] = "application/x-www-form-urlencoded";
    FormEnctype2["multipart"] = "multipart/form-data";
    FormEnctype2["plain"] = "text/plain";
  })(FormEnctype || (FormEnctype = {}));
  function formEnctypeFromString(encoding) {
    switch (encoding.toLowerCase()) {
      case FormEnctype.multipart:
        return FormEnctype.multipart;
      case FormEnctype.plain:
        return FormEnctype.plain;
      default:
        return FormEnctype.urlEncoded;
    }
  }
  var FormSubmission = class {
    constructor(delegate, formElement, submitter, mustRedirect = false) {
      this.state = FormSubmissionState.initialized;
      this.delegate = delegate;
      this.formElement = formElement;
      this.submitter = submitter;
      this.formData = buildFormData(formElement, submitter);
      this.location = expandURL(this.action);
      if (this.method == FetchMethod.get) {
        mergeFormDataEntries(this.location, [...this.body.entries()]);
      }
      this.fetchRequest = new FetchRequest(this, this.method, this.location, this.body, this.formElement);
      this.mustRedirect = mustRedirect;
    }
    static confirmMethod(message, element) {
      return confirm(message);
    }
    get method() {
      var _a;
      const method = ((_a = this.submitter) === null || _a === void 0 ? void 0 : _a.getAttribute("formmethod")) || this.formElement.getAttribute("method") || "";
      return fetchMethodFromString(method.toLowerCase()) || FetchMethod.get;
    }
    get action() {
      var _a;
      const formElementAction = typeof this.formElement.action === "string" ? this.formElement.action : null;
      return ((_a = this.submitter) === null || _a === void 0 ? void 0 : _a.getAttribute("formaction")) || this.formElement.getAttribute("action") || formElementAction || "";
    }
    get body() {
      if (this.enctype == FormEnctype.urlEncoded || this.method == FetchMethod.get) {
        return new URLSearchParams(this.stringFormData);
      } else {
        return this.formData;
      }
    }
    get enctype() {
      var _a;
      return formEnctypeFromString(((_a = this.submitter) === null || _a === void 0 ? void 0 : _a.getAttribute("formenctype")) || this.formElement.enctype);
    }
    get isIdempotent() {
      return this.fetchRequest.isIdempotent;
    }
    get stringFormData() {
      return [...this.formData].reduce((entries, [name, value]) => {
        return entries.concat(typeof value == "string" ? [[name, value]] : []);
      }, []);
    }
    get confirmationMessage() {
      return this.formElement.getAttribute("data-turbo-confirm");
    }
    get needsConfirmation() {
      return this.confirmationMessage !== null;
    }
    async start() {
      const { initialized, requesting } = FormSubmissionState;
      if (this.needsConfirmation) {
        const answer = FormSubmission.confirmMethod(this.confirmationMessage, this.formElement);
        if (!answer) {
          return;
        }
      }
      if (this.state == initialized) {
        this.state = requesting;
        return this.fetchRequest.perform();
      }
    }
    stop() {
      const { stopping, stopped } = FormSubmissionState;
      if (this.state != stopping && this.state != stopped) {
        this.state = stopping;
        this.fetchRequest.cancel();
        return true;
      }
    }
    prepareHeadersForRequest(headers, request) {
      if (!request.isIdempotent) {
        const token = getCookieValue(getMetaContent("csrf-param")) || getMetaContent("csrf-token");
        if (token) {
          headers["X-CSRF-Token"] = token;
        }
        headers["Accept"] = [StreamMessage.contentType, headers["Accept"]].join(", ");
      }
    }
    requestStarted(request) {
      var _a;
      this.state = FormSubmissionState.waiting;
      (_a = this.submitter) === null || _a === void 0 ? void 0 : _a.setAttribute("disabled", "");
      dispatch("turbo:submit-start", { target: this.formElement, detail: { formSubmission: this } });
      this.delegate.formSubmissionStarted(this);
    }
    requestPreventedHandlingResponse(request, response) {
      this.result = { success: response.succeeded, fetchResponse: response };
    }
    requestSucceededWithResponse(request, response) {
      if (response.clientError || response.serverError) {
        this.delegate.formSubmissionFailedWithResponse(this, response);
      } else if (this.requestMustRedirect(request) && responseSucceededWithoutRedirect(response)) {
        const error = new Error("Form responses must redirect to another location");
        this.delegate.formSubmissionErrored(this, error);
      } else {
        this.state = FormSubmissionState.receiving;
        this.result = { success: true, fetchResponse: response };
        this.delegate.formSubmissionSucceededWithResponse(this, response);
      }
    }
    requestFailedWithResponse(request, response) {
      this.result = { success: false, fetchResponse: response };
      this.delegate.formSubmissionFailedWithResponse(this, response);
    }
    requestErrored(request, error) {
      this.result = { success: false, error };
      this.delegate.formSubmissionErrored(this, error);
    }
    requestFinished(request) {
      var _a;
      this.state = FormSubmissionState.stopped;
      (_a = this.submitter) === null || _a === void 0 ? void 0 : _a.removeAttribute("disabled");
      dispatch("turbo:submit-end", { target: this.formElement, detail: Object.assign({ formSubmission: this }, this.result) });
      this.delegate.formSubmissionFinished(this);
    }
    requestMustRedirect(request) {
      return !request.isIdempotent && this.mustRedirect;
    }
  };
  function buildFormData(formElement, submitter) {
    const formData = new FormData(formElement);
    const name = submitter === null || submitter === void 0 ? void 0 : submitter.getAttribute("name");
    const value = submitter === null || submitter === void 0 ? void 0 : submitter.getAttribute("value");
    if (name && value != null && formData.get(name) != value) {
      formData.append(name, value);
    }
    return formData;
  }
  function getCookieValue(cookieName) {
    if (cookieName != null) {
      const cookies = document.cookie ? document.cookie.split("; ") : [];
      const cookie = cookies.find((cookie2) => cookie2.startsWith(cookieName));
      if (cookie) {
        const value = cookie.split("=").slice(1).join("=");
        return value ? decodeURIComponent(value) : void 0;
      }
    }
  }
  function getMetaContent(name) {
    const element = document.querySelector(`meta[name="${name}"]`);
    return element && element.content;
  }
  function responseSucceededWithoutRedirect(response) {
    return response.statusCode == 200 && !response.redirected;
  }
  function mergeFormDataEntries(url, entries) {
    const searchParams = new URLSearchParams();
    for (const [name, value] of entries) {
      if (value instanceof File)
        continue;
      searchParams.append(name, value);
    }
    url.search = searchParams.toString();
    return url;
  }
  var Snapshot = class {
    constructor(element) {
      this.element = element;
    }
    get children() {
      return [...this.element.children];
    }
    hasAnchor(anchor) {
      return this.getElementForAnchor(anchor) != null;
    }
    getElementForAnchor(anchor) {
      return anchor ? this.element.querySelector(`[id='${anchor}'], a[name='${anchor}']`) : null;
    }
    get isConnected() {
      return this.element.isConnected;
    }
    get firstAutofocusableElement() {
      return this.element.querySelector("[autofocus]");
    }
    get permanentElements() {
      return [...this.element.querySelectorAll("[id][data-turbo-permanent]")];
    }
    getPermanentElementById(id) {
      return this.element.querySelector(`#${id}[data-turbo-permanent]`);
    }
    getPermanentElementMapForSnapshot(snapshot) {
      const permanentElementMap = {};
      for (const currentPermanentElement of this.permanentElements) {
        const { id } = currentPermanentElement;
        const newPermanentElement = snapshot.getPermanentElementById(id);
        if (newPermanentElement) {
          permanentElementMap[id] = [currentPermanentElement, newPermanentElement];
        }
      }
      return permanentElementMap;
    }
  };
  var FormInterceptor = class {
    constructor(delegate, element) {
      this.submitBubbled = (event) => {
        const form = event.target;
        if (!event.defaultPrevented && form instanceof HTMLFormElement && form.closest("turbo-frame, html") == this.element) {
          const submitter = event.submitter || void 0;
          const method = (submitter === null || submitter === void 0 ? void 0 : submitter.getAttribute("formmethod")) || form.method;
          if (method != "dialog" && this.delegate.shouldInterceptFormSubmission(form, submitter)) {
            event.preventDefault();
            event.stopImmediatePropagation();
            this.delegate.formSubmissionIntercepted(form, submitter);
          }
        }
      };
      this.delegate = delegate;
      this.element = element;
    }
    start() {
      this.element.addEventListener("submit", this.submitBubbled);
    }
    stop() {
      this.element.removeEventListener("submit", this.submitBubbled);
    }
  };
  var View = class {
    constructor(delegate, element) {
      this.resolveRenderPromise = (value) => {
      };
      this.resolveInterceptionPromise = (value) => {
      };
      this.delegate = delegate;
      this.element = element;
    }
    scrollToAnchor(anchor) {
      const element = this.snapshot.getElementForAnchor(anchor);
      if (element) {
        this.scrollToElement(element);
        this.focusElement(element);
      } else {
        this.scrollToPosition({ x: 0, y: 0 });
      }
    }
    scrollToAnchorFromLocation(location2) {
      this.scrollToAnchor(getAnchor(location2));
    }
    scrollToElement(element) {
      element.scrollIntoView();
    }
    focusElement(element) {
      if (element instanceof HTMLElement) {
        if (element.hasAttribute("tabindex")) {
          element.focus();
        } else {
          element.setAttribute("tabindex", "-1");
          element.focus();
          element.removeAttribute("tabindex");
        }
      }
    }
    scrollToPosition({ x, y }) {
      this.scrollRoot.scrollTo(x, y);
    }
    scrollToTop() {
      this.scrollToPosition({ x: 0, y: 0 });
    }
    get scrollRoot() {
      return window;
    }
    async render(renderer) {
      const { isPreview, shouldRender, newSnapshot: snapshot } = renderer;
      if (shouldRender) {
        try {
          this.renderPromise = new Promise((resolve) => this.resolveRenderPromise = resolve);
          this.renderer = renderer;
          this.prepareToRenderSnapshot(renderer);
          const renderInterception = new Promise((resolve) => this.resolveInterceptionPromise = resolve);
          const immediateRender = this.delegate.allowsImmediateRender(snapshot, this.resolveInterceptionPromise);
          if (!immediateRender)
            await renderInterception;
          await this.renderSnapshot(renderer);
          this.delegate.viewRenderedSnapshot(snapshot, isPreview);
          this.finishRenderingSnapshot(renderer);
        } finally {
          delete this.renderer;
          this.resolveRenderPromise(void 0);
          delete this.renderPromise;
        }
      } else {
        this.invalidate();
      }
    }
    invalidate() {
      this.delegate.viewInvalidated();
    }
    prepareToRenderSnapshot(renderer) {
      this.markAsPreview(renderer.isPreview);
      renderer.prepareToRender();
    }
    markAsPreview(isPreview) {
      if (isPreview) {
        this.element.setAttribute("data-turbo-preview", "");
      } else {
        this.element.removeAttribute("data-turbo-preview");
      }
    }
    async renderSnapshot(renderer) {
      await renderer.render();
    }
    finishRenderingSnapshot(renderer) {
      renderer.finishRendering();
    }
  };
  var FrameView = class extends View {
    invalidate() {
      this.element.innerHTML = "";
    }
    get snapshot() {
      return new Snapshot(this.element);
    }
  };
  var LinkInterceptor = class {
    constructor(delegate, element) {
      this.clickBubbled = (event) => {
        if (this.respondsToEventTarget(event.target)) {
          this.clickEvent = event;
        } else {
          delete this.clickEvent;
        }
      };
      this.linkClicked = (event) => {
        if (this.clickEvent && this.respondsToEventTarget(event.target) && event.target instanceof Element) {
          if (this.delegate.shouldInterceptLinkClick(event.target, event.detail.url)) {
            this.clickEvent.preventDefault();
            event.preventDefault();
            this.delegate.linkClickIntercepted(event.target, event.detail.url);
          }
        }
        delete this.clickEvent;
      };
      this.willVisit = () => {
        delete this.clickEvent;
      };
      this.delegate = delegate;
      this.element = element;
    }
    start() {
      this.element.addEventListener("click", this.clickBubbled);
      document.addEventListener("turbo:click", this.linkClicked);
      document.addEventListener("turbo:before-visit", this.willVisit);
    }
    stop() {
      this.element.removeEventListener("click", this.clickBubbled);
      document.removeEventListener("turbo:click", this.linkClicked);
      document.removeEventListener("turbo:before-visit", this.willVisit);
    }
    respondsToEventTarget(target) {
      const element = target instanceof Element ? target : target instanceof Node ? target.parentElement : null;
      return element && element.closest("turbo-frame, html") == this.element;
    }
  };
  var Bardo = class {
    constructor(permanentElementMap) {
      this.permanentElementMap = permanentElementMap;
    }
    static preservingPermanentElements(permanentElementMap, callback) {
      const bardo = new this(permanentElementMap);
      bardo.enter();
      callback();
      bardo.leave();
    }
    enter() {
      for (const id in this.permanentElementMap) {
        const [, newPermanentElement] = this.permanentElementMap[id];
        this.replaceNewPermanentElementWithPlaceholder(newPermanentElement);
      }
    }
    leave() {
      for (const id in this.permanentElementMap) {
        const [currentPermanentElement] = this.permanentElementMap[id];
        this.replaceCurrentPermanentElementWithClone(currentPermanentElement);
        this.replacePlaceholderWithPermanentElement(currentPermanentElement);
      }
    }
    replaceNewPermanentElementWithPlaceholder(permanentElement) {
      const placeholder = createPlaceholderForPermanentElement(permanentElement);
      permanentElement.replaceWith(placeholder);
    }
    replaceCurrentPermanentElementWithClone(permanentElement) {
      const clone = permanentElement.cloneNode(true);
      permanentElement.replaceWith(clone);
    }
    replacePlaceholderWithPermanentElement(permanentElement) {
      const placeholder = this.getPlaceholderById(permanentElement.id);
      placeholder === null || placeholder === void 0 ? void 0 : placeholder.replaceWith(permanentElement);
    }
    getPlaceholderById(id) {
      return this.placeholders.find((element) => element.content == id);
    }
    get placeholders() {
      return [...document.querySelectorAll("meta[name=turbo-permanent-placeholder][content]")];
    }
  };
  function createPlaceholderForPermanentElement(permanentElement) {
    const element = document.createElement("meta");
    element.setAttribute("name", "turbo-permanent-placeholder");
    element.setAttribute("content", permanentElement.id);
    return element;
  }
  var Renderer = class {
    constructor(currentSnapshot, newSnapshot, isPreview, willRender = true) {
      this.currentSnapshot = currentSnapshot;
      this.newSnapshot = newSnapshot;
      this.isPreview = isPreview;
      this.willRender = willRender;
      this.promise = new Promise((resolve, reject) => this.resolvingFunctions = { resolve, reject });
    }
    get shouldRender() {
      return true;
    }
    prepareToRender() {
      return;
    }
    finishRendering() {
      if (this.resolvingFunctions) {
        this.resolvingFunctions.resolve();
        delete this.resolvingFunctions;
      }
    }
    createScriptElement(element) {
      if (element.getAttribute("data-turbo-eval") == "false") {
        return element;
      } else {
        const createdScriptElement = document.createElement("script");
        if (this.cspNonce) {
          createdScriptElement.nonce = this.cspNonce;
        }
        createdScriptElement.textContent = element.textContent;
        createdScriptElement.async = false;
        copyElementAttributes(createdScriptElement, element);
        return createdScriptElement;
      }
    }
    preservingPermanentElements(callback) {
      Bardo.preservingPermanentElements(this.permanentElementMap, callback);
    }
    focusFirstAutofocusableElement() {
      const element = this.connectedSnapshot.firstAutofocusableElement;
      if (elementIsFocusable(element)) {
        element.focus();
      }
    }
    get connectedSnapshot() {
      return this.newSnapshot.isConnected ? this.newSnapshot : this.currentSnapshot;
    }
    get currentElement() {
      return this.currentSnapshot.element;
    }
    get newElement() {
      return this.newSnapshot.element;
    }
    get permanentElementMap() {
      return this.currentSnapshot.getPermanentElementMapForSnapshot(this.newSnapshot);
    }
    get cspNonce() {
      var _a;
      return (_a = document.head.querySelector('meta[name="csp-nonce"]')) === null || _a === void 0 ? void 0 : _a.getAttribute("content");
    }
  };
  function copyElementAttributes(destinationElement, sourceElement) {
    for (const { name, value } of [...sourceElement.attributes]) {
      destinationElement.setAttribute(name, value);
    }
  }
  function elementIsFocusable(element) {
    return element && typeof element.focus == "function";
  }
  var FrameRenderer = class extends Renderer {
    get shouldRender() {
      return true;
    }
    async render() {
      await nextAnimationFrame();
      this.preservingPermanentElements(() => {
        this.loadFrameElement();
      });
      this.scrollFrameIntoView();
      await nextAnimationFrame();
      this.focusFirstAutofocusableElement();
      await nextAnimationFrame();
      this.activateScriptElements();
    }
    loadFrameElement() {
      var _a;
      const destinationRange = document.createRange();
      destinationRange.selectNodeContents(this.currentElement);
      destinationRange.deleteContents();
      const frameElement = this.newElement;
      const sourceRange = (_a = frameElement.ownerDocument) === null || _a === void 0 ? void 0 : _a.createRange();
      if (sourceRange) {
        sourceRange.selectNodeContents(frameElement);
        this.currentElement.appendChild(sourceRange.extractContents());
      }
    }
    scrollFrameIntoView() {
      if (this.currentElement.autoscroll || this.newElement.autoscroll) {
        const element = this.currentElement.firstElementChild;
        const block = readScrollLogicalPosition(this.currentElement.getAttribute("data-autoscroll-block"), "end");
        if (element) {
          element.scrollIntoView({ block });
          return true;
        }
      }
      return false;
    }
    activateScriptElements() {
      for (const inertScriptElement of this.newScriptElements) {
        const activatedScriptElement = this.createScriptElement(inertScriptElement);
        inertScriptElement.replaceWith(activatedScriptElement);
      }
    }
    get newScriptElements() {
      return this.currentElement.querySelectorAll("script");
    }
  };
  function readScrollLogicalPosition(value, defaultValue) {
    if (value == "end" || value == "start" || value == "center" || value == "nearest") {
      return value;
    } else {
      return defaultValue;
    }
  }
  var ProgressBar = class {
    constructor() {
      this.hiding = false;
      this.value = 0;
      this.visible = false;
      this.trickle = () => {
        this.setValue(this.value + Math.random() / 100);
      };
      this.stylesheetElement = this.createStylesheetElement();
      this.progressElement = this.createProgressElement();
      this.installStylesheetElement();
      this.setValue(0);
    }
    static get defaultCSS() {
      return unindent`
      .turbo-progress-bar {
        position: fixed;
        display: block;
        top: 0;
        left: 0;
        height: 3px;
        background: #0076ff;
        z-index: 9999;
        transition:
          width ${ProgressBar.animationDuration}ms ease-out,
          opacity ${ProgressBar.animationDuration / 2}ms ${ProgressBar.animationDuration / 2}ms ease-in;
        transform: translate3d(0, 0, 0);
      }
    `;
    }
    show() {
      if (!this.visible) {
        this.visible = true;
        this.installProgressElement();
        this.startTrickling();
      }
    }
    hide() {
      if (this.visible && !this.hiding) {
        this.hiding = true;
        this.fadeProgressElement(() => {
          this.uninstallProgressElement();
          this.stopTrickling();
          this.visible = false;
          this.hiding = false;
        });
      }
    }
    setValue(value) {
      this.value = value;
      this.refresh();
    }
    installStylesheetElement() {
      document.head.insertBefore(this.stylesheetElement, document.head.firstChild);
    }
    installProgressElement() {
      this.progressElement.style.width = "0";
      this.progressElement.style.opacity = "1";
      document.documentElement.insertBefore(this.progressElement, document.body);
      this.refresh();
    }
    fadeProgressElement(callback) {
      this.progressElement.style.opacity = "0";
      setTimeout(callback, ProgressBar.animationDuration * 1.5);
    }
    uninstallProgressElement() {
      if (this.progressElement.parentNode) {
        document.documentElement.removeChild(this.progressElement);
      }
    }
    startTrickling() {
      if (!this.trickleInterval) {
        this.trickleInterval = window.setInterval(this.trickle, ProgressBar.animationDuration);
      }
    }
    stopTrickling() {
      window.clearInterval(this.trickleInterval);
      delete this.trickleInterval;
    }
    refresh() {
      requestAnimationFrame(() => {
        this.progressElement.style.width = `${10 + this.value * 90}%`;
      });
    }
    createStylesheetElement() {
      const element = document.createElement("style");
      element.type = "text/css";
      element.textContent = ProgressBar.defaultCSS;
      return element;
    }
    createProgressElement() {
      const element = document.createElement("div");
      element.className = "turbo-progress-bar";
      return element;
    }
  };
  ProgressBar.animationDuration = 300;
  var HeadSnapshot = class extends Snapshot {
    constructor() {
      super(...arguments);
      this.detailsByOuterHTML = this.children.filter((element) => !elementIsNoscript(element)).map((element) => elementWithoutNonce(element)).reduce((result, element) => {
        const { outerHTML } = element;
        const details = outerHTML in result ? result[outerHTML] : {
          type: elementType(element),
          tracked: elementIsTracked(element),
          elements: []
        };
        return Object.assign(Object.assign({}, result), { [outerHTML]: Object.assign(Object.assign({}, details), { elements: [...details.elements, element] }) });
      }, {});
    }
    get trackedElementSignature() {
      return Object.keys(this.detailsByOuterHTML).filter((outerHTML) => this.detailsByOuterHTML[outerHTML].tracked).join("");
    }
    getScriptElementsNotInSnapshot(snapshot) {
      return this.getElementsMatchingTypeNotInSnapshot("script", snapshot);
    }
    getStylesheetElementsNotInSnapshot(snapshot) {
      return this.getElementsMatchingTypeNotInSnapshot("stylesheet", snapshot);
    }
    getElementsMatchingTypeNotInSnapshot(matchedType, snapshot) {
      return Object.keys(this.detailsByOuterHTML).filter((outerHTML) => !(outerHTML in snapshot.detailsByOuterHTML)).map((outerHTML) => this.detailsByOuterHTML[outerHTML]).filter(({ type }) => type == matchedType).map(({ elements: [element] }) => element);
    }
    get provisionalElements() {
      return Object.keys(this.detailsByOuterHTML).reduce((result, outerHTML) => {
        const { type, tracked, elements } = this.detailsByOuterHTML[outerHTML];
        if (type == null && !tracked) {
          return [...result, ...elements];
        } else if (elements.length > 1) {
          return [...result, ...elements.slice(1)];
        } else {
          return result;
        }
      }, []);
    }
    getMetaValue(name) {
      const element = this.findMetaElementByName(name);
      return element ? element.getAttribute("content") : null;
    }
    findMetaElementByName(name) {
      return Object.keys(this.detailsByOuterHTML).reduce((result, outerHTML) => {
        const { elements: [element] } = this.detailsByOuterHTML[outerHTML];
        return elementIsMetaElementWithName(element, name) ? element : result;
      }, void 0);
    }
  };
  function elementType(element) {
    if (elementIsScript(element)) {
      return "script";
    } else if (elementIsStylesheet(element)) {
      return "stylesheet";
    }
  }
  function elementIsTracked(element) {
    return element.getAttribute("data-turbo-track") == "reload";
  }
  function elementIsScript(element) {
    const tagName = element.tagName.toLowerCase();
    return tagName == "script";
  }
  function elementIsNoscript(element) {
    const tagName = element.tagName.toLowerCase();
    return tagName == "noscript";
  }
  function elementIsStylesheet(element) {
    const tagName = element.tagName.toLowerCase();
    return tagName == "style" || tagName == "link" && element.getAttribute("rel") == "stylesheet";
  }
  function elementIsMetaElementWithName(element, name) {
    const tagName = element.tagName.toLowerCase();
    return tagName == "meta" && element.getAttribute("name") == name;
  }
  function elementWithoutNonce(element) {
    if (element.hasAttribute("nonce")) {
      element.setAttribute("nonce", "");
    }
    return element;
  }
  var PageSnapshot = class extends Snapshot {
    constructor(element, headSnapshot) {
      super(element);
      this.headSnapshot = headSnapshot;
    }
    static fromHTMLString(html = "") {
      return this.fromDocument(parseHTMLDocument(html));
    }
    static fromElement(element) {
      return this.fromDocument(element.ownerDocument);
    }
    static fromDocument({ head, body }) {
      return new this(body, new HeadSnapshot(head));
    }
    clone() {
      return new PageSnapshot(this.element.cloneNode(true), this.headSnapshot);
    }
    get headElement() {
      return this.headSnapshot.element;
    }
    get rootLocation() {
      var _a;
      const root = (_a = this.getSetting("root")) !== null && _a !== void 0 ? _a : "/";
      return expandURL(root);
    }
    get cacheControlValue() {
      return this.getSetting("cache-control");
    }
    get isPreviewable() {
      return this.cacheControlValue != "no-preview";
    }
    get isCacheable() {
      return this.cacheControlValue != "no-cache";
    }
    get isVisitable() {
      return this.getSetting("visit-control") != "reload";
    }
    getSetting(name) {
      return this.headSnapshot.getMetaValue(`turbo-${name}`);
    }
  };
  var TimingMetric;
  (function(TimingMetric2) {
    TimingMetric2["visitStart"] = "visitStart";
    TimingMetric2["requestStart"] = "requestStart";
    TimingMetric2["requestEnd"] = "requestEnd";
    TimingMetric2["visitEnd"] = "visitEnd";
  })(TimingMetric || (TimingMetric = {}));
  var VisitState;
  (function(VisitState2) {
    VisitState2["initialized"] = "initialized";
    VisitState2["started"] = "started";
    VisitState2["canceled"] = "canceled";
    VisitState2["failed"] = "failed";
    VisitState2["completed"] = "completed";
  })(VisitState || (VisitState = {}));
  var defaultOptions = {
    action: "advance",
    historyChanged: false,
    visitCachedSnapshot: () => {
    },
    willRender: true
  };
  var SystemStatusCode;
  (function(SystemStatusCode2) {
    SystemStatusCode2[SystemStatusCode2["networkFailure"] = 0] = "networkFailure";
    SystemStatusCode2[SystemStatusCode2["timeoutFailure"] = -1] = "timeoutFailure";
    SystemStatusCode2[SystemStatusCode2["contentTypeMismatch"] = -2] = "contentTypeMismatch";
  })(SystemStatusCode || (SystemStatusCode = {}));
  var Visit = class {
    constructor(delegate, location2, restorationIdentifier, options = {}) {
      this.identifier = uuid();
      this.timingMetrics = {};
      this.followedRedirect = false;
      this.historyChanged = false;
      this.scrolled = false;
      this.snapshotCached = false;
      this.state = VisitState.initialized;
      this.delegate = delegate;
      this.location = location2;
      this.restorationIdentifier = restorationIdentifier || uuid();
      const { action, historyChanged, referrer, snapshotHTML, response, visitCachedSnapshot, willRender } = Object.assign(Object.assign({}, defaultOptions), options);
      this.action = action;
      this.historyChanged = historyChanged;
      this.referrer = referrer;
      this.snapshotHTML = snapshotHTML;
      this.response = response;
      this.isSamePage = this.delegate.locationWithActionIsSamePage(this.location, this.action);
      this.visitCachedSnapshot = visitCachedSnapshot;
      this.willRender = willRender;
      this.scrolled = !willRender;
    }
    get adapter() {
      return this.delegate.adapter;
    }
    get view() {
      return this.delegate.view;
    }
    get history() {
      return this.delegate.history;
    }
    get restorationData() {
      return this.history.getRestorationDataForIdentifier(this.restorationIdentifier);
    }
    get silent() {
      return this.isSamePage;
    }
    start() {
      if (this.state == VisitState.initialized) {
        this.recordTimingMetric(TimingMetric.visitStart);
        this.state = VisitState.started;
        this.adapter.visitStarted(this);
        this.delegate.visitStarted(this);
      }
    }
    cancel() {
      if (this.state == VisitState.started) {
        if (this.request) {
          this.request.cancel();
        }
        this.cancelRender();
        this.state = VisitState.canceled;
      }
    }
    complete() {
      if (this.state == VisitState.started) {
        this.recordTimingMetric(TimingMetric.visitEnd);
        this.state = VisitState.completed;
        this.adapter.visitCompleted(this);
        this.delegate.visitCompleted(this);
        this.followRedirect();
      }
    }
    fail() {
      if (this.state == VisitState.started) {
        this.state = VisitState.failed;
        this.adapter.visitFailed(this);
      }
    }
    changeHistory() {
      var _a;
      if (!this.historyChanged) {
        const actionForHistory = this.location.href === ((_a = this.referrer) === null || _a === void 0 ? void 0 : _a.href) ? "replace" : this.action;
        const method = this.getHistoryMethodForAction(actionForHistory);
        this.history.update(method, this.location, this.restorationIdentifier);
        this.historyChanged = true;
      }
    }
    issueRequest() {
      if (this.hasPreloadedResponse()) {
        this.simulateRequest();
      } else if (this.shouldIssueRequest() && !this.request) {
        this.request = new FetchRequest(this, FetchMethod.get, this.location);
        this.request.perform();
      }
    }
    simulateRequest() {
      if (this.response) {
        this.startRequest();
        this.recordResponse();
        this.finishRequest();
      }
    }
    startRequest() {
      this.recordTimingMetric(TimingMetric.requestStart);
      this.adapter.visitRequestStarted(this);
    }
    recordResponse(response = this.response) {
      this.response = response;
      if (response) {
        const { statusCode } = response;
        if (isSuccessful(statusCode)) {
          this.adapter.visitRequestCompleted(this);
        } else {
          this.adapter.visitRequestFailedWithStatusCode(this, statusCode);
        }
      }
    }
    finishRequest() {
      this.recordTimingMetric(TimingMetric.requestEnd);
      this.adapter.visitRequestFinished(this);
    }
    loadResponse() {
      if (this.response) {
        const { statusCode, responseHTML } = this.response;
        this.render(async () => {
          this.cacheSnapshot();
          if (this.view.renderPromise)
            await this.view.renderPromise;
          if (isSuccessful(statusCode) && responseHTML != null) {
            await this.view.renderPage(PageSnapshot.fromHTMLString(responseHTML), false, this.willRender);
            this.adapter.visitRendered(this);
            this.complete();
          } else {
            await this.view.renderError(PageSnapshot.fromHTMLString(responseHTML));
            this.adapter.visitRendered(this);
            this.fail();
          }
        });
      }
    }
    getCachedSnapshot() {
      const snapshot = this.view.getCachedSnapshotForLocation(this.location) || this.getPreloadedSnapshot();
      if (snapshot && (!getAnchor(this.location) || snapshot.hasAnchor(getAnchor(this.location)))) {
        if (this.action == "restore" || snapshot.isPreviewable) {
          return snapshot;
        }
      }
    }
    getPreloadedSnapshot() {
      if (this.snapshotHTML) {
        return PageSnapshot.fromHTMLString(this.snapshotHTML);
      }
    }
    hasCachedSnapshot() {
      return this.getCachedSnapshot() != null;
    }
    loadCachedSnapshot() {
      const snapshot = this.getCachedSnapshot();
      if (snapshot) {
        const isPreview = this.shouldIssueRequest();
        this.render(async () => {
          this.cacheSnapshot();
          if (this.isSamePage) {
            this.adapter.visitRendered(this);
          } else {
            if (this.view.renderPromise)
              await this.view.renderPromise;
            await this.view.renderPage(snapshot, isPreview, this.willRender);
            this.adapter.visitRendered(this);
            if (!isPreview) {
              this.complete();
            }
          }
        });
      }
    }
    followRedirect() {
      var _a;
      if (this.redirectedToLocation && !this.followedRedirect && ((_a = this.response) === null || _a === void 0 ? void 0 : _a.redirected)) {
        this.adapter.visitProposedToLocation(this.redirectedToLocation, {
          action: "replace",
          response: this.response
        });
        this.followedRedirect = true;
      }
    }
    goToSamePageAnchor() {
      if (this.isSamePage) {
        this.render(async () => {
          this.cacheSnapshot();
          this.adapter.visitRendered(this);
        });
      }
    }
    requestStarted() {
      this.startRequest();
    }
    requestPreventedHandlingResponse(request, response) {
    }
    async requestSucceededWithResponse(request, response) {
      const responseHTML = await response.responseHTML;
      const { redirected, statusCode } = response;
      if (responseHTML == void 0) {
        this.recordResponse({ statusCode: SystemStatusCode.contentTypeMismatch, redirected });
      } else {
        this.redirectedToLocation = response.redirected ? response.location : void 0;
        this.recordResponse({ statusCode, responseHTML, redirected });
      }
    }
    async requestFailedWithResponse(request, response) {
      const responseHTML = await response.responseHTML;
      const { redirected, statusCode } = response;
      if (responseHTML == void 0) {
        this.recordResponse({ statusCode: SystemStatusCode.contentTypeMismatch, redirected });
      } else {
        this.recordResponse({ statusCode, responseHTML, redirected });
      }
    }
    requestErrored(request, error) {
      this.recordResponse({ statusCode: SystemStatusCode.networkFailure, redirected: false });
    }
    requestFinished() {
      this.finishRequest();
    }
    performScroll() {
      if (!this.scrolled) {
        if (this.action == "restore") {
          this.scrollToRestoredPosition() || this.scrollToAnchor() || this.view.scrollToTop();
        } else {
          this.scrollToAnchor() || this.view.scrollToTop();
        }
        if (this.isSamePage) {
          this.delegate.visitScrolledToSamePageLocation(this.view.lastRenderedLocation, this.location);
        }
        this.scrolled = true;
      }
    }
    scrollToRestoredPosition() {
      const { scrollPosition } = this.restorationData;
      if (scrollPosition) {
        this.view.scrollToPosition(scrollPosition);
        return true;
      }
    }
    scrollToAnchor() {
      const anchor = getAnchor(this.location);
      if (anchor != null) {
        this.view.scrollToAnchor(anchor);
        return true;
      }
    }
    recordTimingMetric(metric) {
      this.timingMetrics[metric] = new Date().getTime();
    }
    getTimingMetrics() {
      return Object.assign({}, this.timingMetrics);
    }
    getHistoryMethodForAction(action) {
      switch (action) {
        case "replace":
          return history.replaceState;
        case "advance":
        case "restore":
          return history.pushState;
      }
    }
    hasPreloadedResponse() {
      return typeof this.response == "object";
    }
    shouldIssueRequest() {
      if (this.isSamePage) {
        return false;
      } else if (this.action == "restore") {
        return !this.hasCachedSnapshot();
      } else {
        return this.willRender;
      }
    }
    cacheSnapshot() {
      if (!this.snapshotCached) {
        this.view.cacheSnapshot().then((snapshot) => snapshot && this.visitCachedSnapshot(snapshot));
        this.snapshotCached = true;
      }
    }
    async render(callback) {
      this.cancelRender();
      await new Promise((resolve) => {
        this.frame = requestAnimationFrame(() => resolve());
      });
      await callback();
      delete this.frame;
      this.performScroll();
    }
    cancelRender() {
      if (this.frame) {
        cancelAnimationFrame(this.frame);
        delete this.frame;
      }
    }
  };
  function isSuccessful(statusCode) {
    return statusCode >= 200 && statusCode < 300;
  }
  var BrowserAdapter = class {
    constructor(session2) {
      this.progressBar = new ProgressBar();
      this.showProgressBar = () => {
        this.progressBar.show();
      };
      this.session = session2;
    }
    visitProposedToLocation(location2, options) {
      this.navigator.startVisit(location2, uuid(), options);
    }
    visitStarted(visit2) {
      visit2.loadCachedSnapshot();
      visit2.issueRequest();
      visit2.changeHistory();
      visit2.goToSamePageAnchor();
    }
    visitRequestStarted(visit2) {
      this.progressBar.setValue(0);
      if (visit2.hasCachedSnapshot() || visit2.action != "restore") {
        this.showVisitProgressBarAfterDelay();
      } else {
        this.showProgressBar();
      }
    }
    visitRequestCompleted(visit2) {
      visit2.loadResponse();
    }
    visitRequestFailedWithStatusCode(visit2, statusCode) {
      switch (statusCode) {
        case SystemStatusCode.networkFailure:
        case SystemStatusCode.timeoutFailure:
        case SystemStatusCode.contentTypeMismatch:
          return this.reload();
        default:
          return visit2.loadResponse();
      }
    }
    visitRequestFinished(visit2) {
      this.progressBar.setValue(1);
      this.hideVisitProgressBar();
    }
    visitCompleted(visit2) {
    }
    pageInvalidated() {
      this.reload();
    }
    visitFailed(visit2) {
    }
    visitRendered(visit2) {
    }
    formSubmissionStarted(formSubmission) {
      this.progressBar.setValue(0);
      this.showFormProgressBarAfterDelay();
    }
    formSubmissionFinished(formSubmission) {
      this.progressBar.setValue(1);
      this.hideFormProgressBar();
    }
    showVisitProgressBarAfterDelay() {
      this.visitProgressBarTimeout = window.setTimeout(this.showProgressBar, this.session.progressBarDelay);
    }
    hideVisitProgressBar() {
      this.progressBar.hide();
      if (this.visitProgressBarTimeout != null) {
        window.clearTimeout(this.visitProgressBarTimeout);
        delete this.visitProgressBarTimeout;
      }
    }
    showFormProgressBarAfterDelay() {
      if (this.formProgressBarTimeout == null) {
        this.formProgressBarTimeout = window.setTimeout(this.showProgressBar, this.session.progressBarDelay);
      }
    }
    hideFormProgressBar() {
      this.progressBar.hide();
      if (this.formProgressBarTimeout != null) {
        window.clearTimeout(this.formProgressBarTimeout);
        delete this.formProgressBarTimeout;
      }
    }
    reload() {
      window.location.reload();
    }
    get navigator() {
      return this.session.navigator;
    }
  };
  var CacheObserver = class {
    constructor() {
      this.started = false;
    }
    start() {
      if (!this.started) {
        this.started = true;
        addEventListener("turbo:before-cache", this.removeStaleElements, false);
      }
    }
    stop() {
      if (this.started) {
        this.started = false;
        removeEventListener("turbo:before-cache", this.removeStaleElements, false);
      }
    }
    removeStaleElements() {
      const staleElements = [...document.querySelectorAll('[data-turbo-cache="false"]')];
      for (const element of staleElements) {
        element.remove();
      }
    }
  };
  var FormSubmitObserver = class {
    constructor(delegate) {
      this.started = false;
      this.submitCaptured = () => {
        removeEventListener("submit", this.submitBubbled, false);
        addEventListener("submit", this.submitBubbled, false);
      };
      this.submitBubbled = (event) => {
        if (!event.defaultPrevented) {
          const form = event.target instanceof HTMLFormElement ? event.target : void 0;
          const submitter = event.submitter || void 0;
          if (form) {
            const method = (submitter === null || submitter === void 0 ? void 0 : submitter.getAttribute("formmethod")) || form.getAttribute("method");
            if (method != "dialog" && this.delegate.willSubmitForm(form, submitter)) {
              event.preventDefault();
              this.delegate.formSubmitted(form, submitter);
            }
          }
        }
      };
      this.delegate = delegate;
    }
    start() {
      if (!this.started) {
        addEventListener("submit", this.submitCaptured, true);
        this.started = true;
      }
    }
    stop() {
      if (this.started) {
        removeEventListener("submit", this.submitCaptured, true);
        this.started = false;
      }
    }
  };
  var FrameRedirector = class {
    constructor(element) {
      this.element = element;
      this.linkInterceptor = new LinkInterceptor(this, element);
      this.formInterceptor = new FormInterceptor(this, element);
    }
    start() {
      this.linkInterceptor.start();
      this.formInterceptor.start();
    }
    stop() {
      this.linkInterceptor.stop();
      this.formInterceptor.stop();
    }
    shouldInterceptLinkClick(element, url) {
      return this.shouldRedirect(element);
    }
    linkClickIntercepted(element, url) {
      const frame = this.findFrameElement(element);
      if (frame) {
        frame.delegate.linkClickIntercepted(element, url);
      }
    }
    shouldInterceptFormSubmission(element, submitter) {
      return this.shouldSubmit(element, submitter);
    }
    formSubmissionIntercepted(element, submitter) {
      const frame = this.findFrameElement(element, submitter);
      if (frame) {
        frame.removeAttribute("reloadable");
        frame.delegate.formSubmissionIntercepted(element, submitter);
      }
    }
    shouldSubmit(form, submitter) {
      var _a;
      const action = getAction(form, submitter);
      const meta = this.element.ownerDocument.querySelector(`meta[name="turbo-root"]`);
      const rootLocation = expandURL((_a = meta === null || meta === void 0 ? void 0 : meta.content) !== null && _a !== void 0 ? _a : "/");
      return this.shouldRedirect(form, submitter) && locationIsVisitable(action, rootLocation);
    }
    shouldRedirect(element, submitter) {
      const frame = this.findFrameElement(element, submitter);
      return frame ? frame != element.closest("turbo-frame") : false;
    }
    findFrameElement(element, submitter) {
      const id = (submitter === null || submitter === void 0 ? void 0 : submitter.getAttribute("data-turbo-frame")) || element.getAttribute("data-turbo-frame");
      if (id && id != "_top") {
        const frame = this.element.querySelector(`#${id}:not([disabled])`);
        if (frame instanceof FrameElement) {
          return frame;
        }
      }
    }
  };
  var History = class {
    constructor(delegate) {
      this.restorationIdentifier = uuid();
      this.restorationData = {};
      this.started = false;
      this.pageLoaded = false;
      this.onPopState = (event) => {
        if (this.shouldHandlePopState()) {
          const { turbo } = event.state || {};
          if (turbo) {
            this.location = new URL(window.location.href);
            const { restorationIdentifier } = turbo;
            this.restorationIdentifier = restorationIdentifier;
            this.delegate.historyPoppedToLocationWithRestorationIdentifier(this.location, restorationIdentifier);
          }
        }
      };
      this.onPageLoad = async (event) => {
        await nextMicrotask();
        this.pageLoaded = true;
      };
      this.delegate = delegate;
    }
    start() {
      if (!this.started) {
        addEventListener("popstate", this.onPopState, false);
        addEventListener("load", this.onPageLoad, false);
        this.started = true;
        this.replace(new URL(window.location.href));
      }
    }
    stop() {
      if (this.started) {
        removeEventListener("popstate", this.onPopState, false);
        removeEventListener("load", this.onPageLoad, false);
        this.started = false;
      }
    }
    push(location2, restorationIdentifier) {
      this.update(history.pushState, location2, restorationIdentifier);
    }
    replace(location2, restorationIdentifier) {
      this.update(history.replaceState, location2, restorationIdentifier);
    }
    update(method, location2, restorationIdentifier = uuid()) {
      const state = { turbo: { restorationIdentifier } };
      method.call(history, state, "", location2.href);
      this.location = location2;
      this.restorationIdentifier = restorationIdentifier;
    }
    getRestorationDataForIdentifier(restorationIdentifier) {
      return this.restorationData[restorationIdentifier] || {};
    }
    updateRestorationData(additionalData) {
      const { restorationIdentifier } = this;
      const restorationData = this.restorationData[restorationIdentifier];
      this.restorationData[restorationIdentifier] = Object.assign(Object.assign({}, restorationData), additionalData);
    }
    assumeControlOfScrollRestoration() {
      var _a;
      if (!this.previousScrollRestoration) {
        this.previousScrollRestoration = (_a = history.scrollRestoration) !== null && _a !== void 0 ? _a : "auto";
        history.scrollRestoration = "manual";
      }
    }
    relinquishControlOfScrollRestoration() {
      if (this.previousScrollRestoration) {
        history.scrollRestoration = this.previousScrollRestoration;
        delete this.previousScrollRestoration;
      }
    }
    shouldHandlePopState() {
      return this.pageIsLoaded();
    }
    pageIsLoaded() {
      return this.pageLoaded || document.readyState == "complete";
    }
  };
  var LinkClickObserver = class {
    constructor(delegate) {
      this.started = false;
      this.clickCaptured = () => {
        removeEventListener("click", this.clickBubbled, false);
        addEventListener("click", this.clickBubbled, false);
      };
      this.clickBubbled = (event) => {
        if (this.clickEventIsSignificant(event)) {
          const target = event.composedPath && event.composedPath()[0] || event.target;
          const link = this.findLinkFromClickTarget(target);
          if (link) {
            const location2 = this.getLocationForLink(link);
            if (this.delegate.willFollowLinkToLocation(link, location2)) {
              event.preventDefault();
              this.delegate.followedLinkToLocation(link, location2);
            }
          }
        }
      };
      this.delegate = delegate;
    }
    start() {
      if (!this.started) {
        addEventListener("click", this.clickCaptured, true);
        this.started = true;
      }
    }
    stop() {
      if (this.started) {
        removeEventListener("click", this.clickCaptured, true);
        this.started = false;
      }
    }
    clickEventIsSignificant(event) {
      return !(event.target && event.target.isContentEditable || event.defaultPrevented || event.which > 1 || event.altKey || event.ctrlKey || event.metaKey || event.shiftKey);
    }
    findLinkFromClickTarget(target) {
      if (target instanceof Element) {
        return target.closest("a[href]:not([target^=_]):not([download])");
      }
    }
    getLocationForLink(link) {
      return expandURL(link.getAttribute("href") || "");
    }
  };
  function isAction(action) {
    return action == "advance" || action == "replace" || action == "restore";
  }
  var Navigator = class {
    constructor(delegate) {
      this.delegate = delegate;
    }
    proposeVisit(location2, options = {}) {
      if (this.delegate.allowsVisitingLocationWithAction(location2, options.action)) {
        if (locationIsVisitable(location2, this.view.snapshot.rootLocation)) {
          this.delegate.visitProposedToLocation(location2, options);
        } else {
          window.location.href = location2.toString();
        }
      }
    }
    startVisit(locatable, restorationIdentifier, options = {}) {
      this.stop();
      this.currentVisit = new Visit(this, expandURL(locatable), restorationIdentifier, Object.assign({ referrer: this.location }, options));
      this.currentVisit.start();
    }
    submitForm(form, submitter) {
      this.stop();
      this.formSubmission = new FormSubmission(this, form, submitter, true);
      this.formSubmission.start();
    }
    stop() {
      if (this.formSubmission) {
        this.formSubmission.stop();
        delete this.formSubmission;
      }
      if (this.currentVisit) {
        this.currentVisit.cancel();
        delete this.currentVisit;
      }
    }
    get adapter() {
      return this.delegate.adapter;
    }
    get view() {
      return this.delegate.view;
    }
    get history() {
      return this.delegate.history;
    }
    formSubmissionStarted(formSubmission) {
      if (typeof this.adapter.formSubmissionStarted === "function") {
        this.adapter.formSubmissionStarted(formSubmission);
      }
    }
    async formSubmissionSucceededWithResponse(formSubmission, fetchResponse) {
      if (formSubmission == this.formSubmission) {
        const responseHTML = await fetchResponse.responseHTML;
        if (responseHTML) {
          if (formSubmission.method != FetchMethod.get) {
            this.view.clearSnapshotCache();
          }
          const { statusCode, redirected } = fetchResponse;
          const action = this.getActionForFormSubmission(formSubmission);
          const visitOptions = { action, response: { statusCode, responseHTML, redirected } };
          this.proposeVisit(fetchResponse.location, visitOptions);
        }
      }
    }
    async formSubmissionFailedWithResponse(formSubmission, fetchResponse) {
      const responseHTML = await fetchResponse.responseHTML;
      if (responseHTML) {
        const snapshot = PageSnapshot.fromHTMLString(responseHTML);
        if (fetchResponse.serverError) {
          await this.view.renderError(snapshot);
        } else {
          await this.view.renderPage(snapshot);
        }
        this.view.scrollToTop();
        this.view.clearSnapshotCache();
      }
    }
    formSubmissionErrored(formSubmission, error) {
      console.error(error);
    }
    formSubmissionFinished(formSubmission) {
      if (typeof this.adapter.formSubmissionFinished === "function") {
        this.adapter.formSubmissionFinished(formSubmission);
      }
    }
    visitStarted(visit2) {
      this.delegate.visitStarted(visit2);
    }
    visitCompleted(visit2) {
      this.delegate.visitCompleted(visit2);
    }
    locationWithActionIsSamePage(location2, action) {
      const anchor = getAnchor(location2);
      const currentAnchor = getAnchor(this.view.lastRenderedLocation);
      const isRestorationToTop = action === "restore" && typeof anchor === "undefined";
      return action !== "replace" && getRequestURL(location2) === getRequestURL(this.view.lastRenderedLocation) && (isRestorationToTop || anchor != null && anchor !== currentAnchor);
    }
    visitScrolledToSamePageLocation(oldURL, newURL) {
      this.delegate.visitScrolledToSamePageLocation(oldURL, newURL);
    }
    get location() {
      return this.history.location;
    }
    get restorationIdentifier() {
      return this.history.restorationIdentifier;
    }
    getActionForFormSubmission(formSubmission) {
      const { formElement, submitter } = formSubmission;
      const action = getAttribute("data-turbo-action", submitter, formElement);
      return isAction(action) ? action : "advance";
    }
  };
  var PageStage;
  (function(PageStage2) {
    PageStage2[PageStage2["initial"] = 0] = "initial";
    PageStage2[PageStage2["loading"] = 1] = "loading";
    PageStage2[PageStage2["interactive"] = 2] = "interactive";
    PageStage2[PageStage2["complete"] = 3] = "complete";
  })(PageStage || (PageStage = {}));
  var PageObserver = class {
    constructor(delegate) {
      this.stage = PageStage.initial;
      this.started = false;
      this.interpretReadyState = () => {
        const { readyState } = this;
        if (readyState == "interactive") {
          this.pageIsInteractive();
        } else if (readyState == "complete") {
          this.pageIsComplete();
        }
      };
      this.pageWillUnload = () => {
        this.delegate.pageWillUnload();
      };
      this.delegate = delegate;
    }
    start() {
      if (!this.started) {
        if (this.stage == PageStage.initial) {
          this.stage = PageStage.loading;
        }
        document.addEventListener("readystatechange", this.interpretReadyState, false);
        addEventListener("pagehide", this.pageWillUnload, false);
        this.started = true;
      }
    }
    stop() {
      if (this.started) {
        document.removeEventListener("readystatechange", this.interpretReadyState, false);
        removeEventListener("pagehide", this.pageWillUnload, false);
        this.started = false;
      }
    }
    pageIsInteractive() {
      if (this.stage == PageStage.loading) {
        this.stage = PageStage.interactive;
        this.delegate.pageBecameInteractive();
      }
    }
    pageIsComplete() {
      this.pageIsInteractive();
      if (this.stage == PageStage.interactive) {
        this.stage = PageStage.complete;
        this.delegate.pageLoaded();
      }
    }
    get readyState() {
      return document.readyState;
    }
  };
  var ScrollObserver = class {
    constructor(delegate) {
      this.started = false;
      this.onScroll = () => {
        this.updatePosition({ x: window.pageXOffset, y: window.pageYOffset });
      };
      this.delegate = delegate;
    }
    start() {
      if (!this.started) {
        addEventListener("scroll", this.onScroll, false);
        this.onScroll();
        this.started = true;
      }
    }
    stop() {
      if (this.started) {
        removeEventListener("scroll", this.onScroll, false);
        this.started = false;
      }
    }
    updatePosition(position) {
      this.delegate.scrollPositionChanged(position);
    }
  };
  var StreamObserver = class {
    constructor(delegate) {
      this.sources = /* @__PURE__ */ new Set();
      this.started = false;
      this.inspectFetchResponse = (event) => {
        const response = fetchResponseFromEvent(event);
        if (response && fetchResponseIsStream(response)) {
          event.preventDefault();
          this.receiveMessageResponse(response);
        }
      };
      this.receiveMessageEvent = (event) => {
        if (this.started && typeof event.data == "string") {
          this.receiveMessageHTML(event.data);
        }
      };
      this.delegate = delegate;
    }
    start() {
      if (!this.started) {
        this.started = true;
        addEventListener("turbo:before-fetch-response", this.inspectFetchResponse, false);
      }
    }
    stop() {
      if (this.started) {
        this.started = false;
        removeEventListener("turbo:before-fetch-response", this.inspectFetchResponse, false);
      }
    }
    connectStreamSource(source) {
      if (!this.streamSourceIsConnected(source)) {
        this.sources.add(source);
        source.addEventListener("message", this.receiveMessageEvent, false);
      }
    }
    disconnectStreamSource(source) {
      if (this.streamSourceIsConnected(source)) {
        this.sources.delete(source);
        source.removeEventListener("message", this.receiveMessageEvent, false);
      }
    }
    streamSourceIsConnected(source) {
      return this.sources.has(source);
    }
    async receiveMessageResponse(response) {
      const html = await response.responseHTML;
      if (html) {
        this.receiveMessageHTML(html);
      }
    }
    receiveMessageHTML(html) {
      this.delegate.receivedMessageFromStream(new StreamMessage(html));
    }
  };
  function fetchResponseFromEvent(event) {
    var _a;
    const fetchResponse = (_a = event.detail) === null || _a === void 0 ? void 0 : _a.fetchResponse;
    if (fetchResponse instanceof FetchResponse) {
      return fetchResponse;
    }
  }
  function fetchResponseIsStream(response) {
    var _a;
    const contentType = (_a = response.contentType) !== null && _a !== void 0 ? _a : "";
    return contentType.startsWith(StreamMessage.contentType);
  }
  var ErrorRenderer = class extends Renderer {
    async render() {
      this.replaceHeadAndBody();
      this.activateScriptElements();
    }
    replaceHeadAndBody() {
      const { documentElement, head, body } = document;
      documentElement.replaceChild(this.newHead, head);
      documentElement.replaceChild(this.newElement, body);
    }
    activateScriptElements() {
      for (const replaceableElement of this.scriptElements) {
        const parentNode = replaceableElement.parentNode;
        if (parentNode) {
          const element = this.createScriptElement(replaceableElement);
          parentNode.replaceChild(element, replaceableElement);
        }
      }
    }
    get newHead() {
      return this.newSnapshot.headSnapshot.element;
    }
    get scriptElements() {
      return [...document.documentElement.querySelectorAll("script")];
    }
  };
  var PageRenderer = class extends Renderer {
    get shouldRender() {
      return this.newSnapshot.isVisitable && this.trackedElementsAreIdentical;
    }
    prepareToRender() {
      this.mergeHead();
    }
    async render() {
      if (this.willRender) {
        this.replaceBody();
      }
    }
    finishRendering() {
      super.finishRendering();
      if (!this.isPreview) {
        this.focusFirstAutofocusableElement();
      }
    }
    get currentHeadSnapshot() {
      return this.currentSnapshot.headSnapshot;
    }
    get newHeadSnapshot() {
      return this.newSnapshot.headSnapshot;
    }
    get newElement() {
      return this.newSnapshot.element;
    }
    mergeHead() {
      this.copyNewHeadStylesheetElements();
      this.copyNewHeadScriptElements();
      this.removeCurrentHeadProvisionalElements();
      this.copyNewHeadProvisionalElements();
    }
    replaceBody() {
      this.preservingPermanentElements(() => {
        this.activateNewBody();
        this.assignNewBody();
      });
    }
    get trackedElementsAreIdentical() {
      return this.currentHeadSnapshot.trackedElementSignature == this.newHeadSnapshot.trackedElementSignature;
    }
    copyNewHeadStylesheetElements() {
      for (const element of this.newHeadStylesheetElements) {
        document.head.appendChild(element);
      }
    }
    copyNewHeadScriptElements() {
      for (const element of this.newHeadScriptElements) {
        document.head.appendChild(this.createScriptElement(element));
      }
    }
    removeCurrentHeadProvisionalElements() {
      for (const element of this.currentHeadProvisionalElements) {
        document.head.removeChild(element);
      }
    }
    copyNewHeadProvisionalElements() {
      for (const element of this.newHeadProvisionalElements) {
        document.head.appendChild(element);
      }
    }
    activateNewBody() {
      document.adoptNode(this.newElement);
      this.activateNewBodyScriptElements();
    }
    activateNewBodyScriptElements() {
      for (const inertScriptElement of this.newBodyScriptElements) {
        const activatedScriptElement = this.createScriptElement(inertScriptElement);
        inertScriptElement.replaceWith(activatedScriptElement);
      }
    }
    assignNewBody() {
      if (document.body && this.newElement instanceof HTMLBodyElement) {
        document.body.replaceWith(this.newElement);
      } else {
        document.documentElement.appendChild(this.newElement);
      }
    }
    get newHeadStylesheetElements() {
      return this.newHeadSnapshot.getStylesheetElementsNotInSnapshot(this.currentHeadSnapshot);
    }
    get newHeadScriptElements() {
      return this.newHeadSnapshot.getScriptElementsNotInSnapshot(this.currentHeadSnapshot);
    }
    get currentHeadProvisionalElements() {
      return this.currentHeadSnapshot.provisionalElements;
    }
    get newHeadProvisionalElements() {
      return this.newHeadSnapshot.provisionalElements;
    }
    get newBodyScriptElements() {
      return this.newElement.querySelectorAll("script");
    }
  };
  var SnapshotCache = class {
    constructor(size) {
      this.keys = [];
      this.snapshots = {};
      this.size = size;
    }
    has(location2) {
      return toCacheKey(location2) in this.snapshots;
    }
    get(location2) {
      if (this.has(location2)) {
        const snapshot = this.read(location2);
        this.touch(location2);
        return snapshot;
      }
    }
    put(location2, snapshot) {
      this.write(location2, snapshot);
      this.touch(location2);
      return snapshot;
    }
    clear() {
      this.snapshots = {};
    }
    read(location2) {
      return this.snapshots[toCacheKey(location2)];
    }
    write(location2, snapshot) {
      this.snapshots[toCacheKey(location2)] = snapshot;
    }
    touch(location2) {
      const key = toCacheKey(location2);
      const index = this.keys.indexOf(key);
      if (index > -1)
        this.keys.splice(index, 1);
      this.keys.unshift(key);
      this.trim();
    }
    trim() {
      for (const key of this.keys.splice(this.size)) {
        delete this.snapshots[key];
      }
    }
  };
  var PageView = class extends View {
    constructor() {
      super(...arguments);
      this.snapshotCache = new SnapshotCache(10);
      this.lastRenderedLocation = new URL(location.href);
    }
    renderPage(snapshot, isPreview = false, willRender = true) {
      const renderer = new PageRenderer(this.snapshot, snapshot, isPreview, willRender);
      return this.render(renderer);
    }
    renderError(snapshot) {
      const renderer = new ErrorRenderer(this.snapshot, snapshot, false);
      return this.render(renderer);
    }
    clearSnapshotCache() {
      this.snapshotCache.clear();
    }
    async cacheSnapshot() {
      if (this.shouldCacheSnapshot) {
        this.delegate.viewWillCacheSnapshot();
        const { snapshot, lastRenderedLocation: location2 } = this;
        await nextEventLoopTick();
        const cachedSnapshot = snapshot.clone();
        this.snapshotCache.put(location2, cachedSnapshot);
        return cachedSnapshot;
      }
    }
    getCachedSnapshotForLocation(location2) {
      return this.snapshotCache.get(location2);
    }
    get snapshot() {
      return PageSnapshot.fromElement(this.element);
    }
    get shouldCacheSnapshot() {
      return this.snapshot.isCacheable;
    }
  };
  var Session = class {
    constructor() {
      this.navigator = new Navigator(this);
      this.history = new History(this);
      this.view = new PageView(this, document.documentElement);
      this.adapter = new BrowserAdapter(this);
      this.pageObserver = new PageObserver(this);
      this.cacheObserver = new CacheObserver();
      this.linkClickObserver = new LinkClickObserver(this);
      this.formSubmitObserver = new FormSubmitObserver(this);
      this.scrollObserver = new ScrollObserver(this);
      this.streamObserver = new StreamObserver(this);
      this.frameRedirector = new FrameRedirector(document.documentElement);
      this.drive = true;
      this.enabled = true;
      this.progressBarDelay = 500;
      this.started = false;
    }
    start() {
      if (!this.started) {
        this.pageObserver.start();
        this.cacheObserver.start();
        this.linkClickObserver.start();
        this.formSubmitObserver.start();
        this.scrollObserver.start();
        this.streamObserver.start();
        this.frameRedirector.start();
        this.history.start();
        this.started = true;
        this.enabled = true;
      }
    }
    disable() {
      this.enabled = false;
    }
    stop() {
      if (this.started) {
        this.pageObserver.stop();
        this.cacheObserver.stop();
        this.linkClickObserver.stop();
        this.formSubmitObserver.stop();
        this.scrollObserver.stop();
        this.streamObserver.stop();
        this.frameRedirector.stop();
        this.history.stop();
        this.started = false;
      }
    }
    registerAdapter(adapter) {
      this.adapter = adapter;
    }
    visit(location2, options = {}) {
      this.navigator.proposeVisit(expandURL(location2), options);
    }
    connectStreamSource(source) {
      this.streamObserver.connectStreamSource(source);
    }
    disconnectStreamSource(source) {
      this.streamObserver.disconnectStreamSource(source);
    }
    renderStreamMessage(message) {
      document.documentElement.appendChild(StreamMessage.wrap(message).fragment);
    }
    clearCache() {
      this.view.clearSnapshotCache();
    }
    setProgressBarDelay(delay) {
      this.progressBarDelay = delay;
    }
    get location() {
      return this.history.location;
    }
    get restorationIdentifier() {
      return this.history.restorationIdentifier;
    }
    historyPoppedToLocationWithRestorationIdentifier(location2, restorationIdentifier) {
      if (this.enabled) {
        this.navigator.startVisit(location2, restorationIdentifier, { action: "restore", historyChanged: true });
      } else {
        this.adapter.pageInvalidated();
      }
    }
    scrollPositionChanged(position) {
      this.history.updateRestorationData({ scrollPosition: position });
    }
    willFollowLinkToLocation(link, location2) {
      return this.elementDriveEnabled(link) && locationIsVisitable(location2, this.snapshot.rootLocation) && this.applicationAllowsFollowingLinkToLocation(link, location2);
    }
    followedLinkToLocation(link, location2) {
      const action = this.getActionForLink(link);
      this.convertLinkWithMethodClickToFormSubmission(link) || this.visit(location2.href, { action });
    }
    convertLinkWithMethodClickToFormSubmission(link) {
      const linkMethod = link.getAttribute("data-turbo-method");
      if (linkMethod) {
        const form = document.createElement("form");
        form.method = linkMethod;
        form.action = link.getAttribute("href") || "undefined";
        form.hidden = true;
        if (link.hasAttribute("data-turbo-confirm")) {
          form.setAttribute("data-turbo-confirm", link.getAttribute("data-turbo-confirm"));
        }
        const frame = this.getTargetFrameForLink(link);
        if (frame) {
          form.setAttribute("data-turbo-frame", frame);
          form.addEventListener("turbo:submit-start", () => form.remove());
        } else {
          form.addEventListener("submit", () => form.remove());
        }
        document.body.appendChild(form);
        return dispatch("submit", { cancelable: true, target: form });
      } else {
        return false;
      }
    }
    allowsVisitingLocationWithAction(location2, action) {
      return this.locationWithActionIsSamePage(location2, action) || this.applicationAllowsVisitingLocation(location2);
    }
    visitProposedToLocation(location2, options) {
      extendURLWithDeprecatedProperties(location2);
      this.adapter.visitProposedToLocation(location2, options);
    }
    visitStarted(visit2) {
      extendURLWithDeprecatedProperties(visit2.location);
      if (!visit2.silent) {
        this.notifyApplicationAfterVisitingLocation(visit2.location, visit2.action);
      }
    }
    visitCompleted(visit2) {
      this.notifyApplicationAfterPageLoad(visit2.getTimingMetrics());
    }
    locationWithActionIsSamePage(location2, action) {
      return this.navigator.locationWithActionIsSamePage(location2, action);
    }
    visitScrolledToSamePageLocation(oldURL, newURL) {
      this.notifyApplicationAfterVisitingSamePageLocation(oldURL, newURL);
    }
    willSubmitForm(form, submitter) {
      const action = getAction(form, submitter);
      return this.elementDriveEnabled(form) && (!submitter || this.elementDriveEnabled(submitter)) && locationIsVisitable(expandURL(action), this.snapshot.rootLocation);
    }
    formSubmitted(form, submitter) {
      this.navigator.submitForm(form, submitter);
    }
    pageBecameInteractive() {
      this.view.lastRenderedLocation = this.location;
      this.notifyApplicationAfterPageLoad();
    }
    pageLoaded() {
      this.history.assumeControlOfScrollRestoration();
    }
    pageWillUnload() {
      this.history.relinquishControlOfScrollRestoration();
    }
    receivedMessageFromStream(message) {
      this.renderStreamMessage(message);
    }
    viewWillCacheSnapshot() {
      var _a;
      if (!((_a = this.navigator.currentVisit) === null || _a === void 0 ? void 0 : _a.silent)) {
        this.notifyApplicationBeforeCachingSnapshot();
      }
    }
    allowsImmediateRender({ element }, resume) {
      const event = this.notifyApplicationBeforeRender(element, resume);
      return !event.defaultPrevented;
    }
    viewRenderedSnapshot(snapshot, isPreview) {
      this.view.lastRenderedLocation = this.history.location;
      this.notifyApplicationAfterRender();
    }
    viewInvalidated() {
      this.adapter.pageInvalidated();
    }
    frameLoaded(frame) {
      this.notifyApplicationAfterFrameLoad(frame);
    }
    frameRendered(fetchResponse, frame) {
      this.notifyApplicationAfterFrameRender(fetchResponse, frame);
    }
    applicationAllowsFollowingLinkToLocation(link, location2) {
      const event = this.notifyApplicationAfterClickingLinkToLocation(link, location2);
      return !event.defaultPrevented;
    }
    applicationAllowsVisitingLocation(location2) {
      const event = this.notifyApplicationBeforeVisitingLocation(location2);
      return !event.defaultPrevented;
    }
    notifyApplicationAfterClickingLinkToLocation(link, location2) {
      return dispatch("turbo:click", { target: link, detail: { url: location2.href }, cancelable: true });
    }
    notifyApplicationBeforeVisitingLocation(location2) {
      return dispatch("turbo:before-visit", { detail: { url: location2.href }, cancelable: true });
    }
    notifyApplicationAfterVisitingLocation(location2, action) {
      markAsBusy(document.documentElement);
      return dispatch("turbo:visit", { detail: { url: location2.href, action } });
    }
    notifyApplicationBeforeCachingSnapshot() {
      return dispatch("turbo:before-cache");
    }
    notifyApplicationBeforeRender(newBody, resume) {
      return dispatch("turbo:before-render", { detail: { newBody, resume }, cancelable: true });
    }
    notifyApplicationAfterRender() {
      return dispatch("turbo:render");
    }
    notifyApplicationAfterPageLoad(timing = {}) {
      clearBusyState(document.documentElement);
      return dispatch("turbo:load", { detail: { url: this.location.href, timing } });
    }
    notifyApplicationAfterVisitingSamePageLocation(oldURL, newURL) {
      dispatchEvent(new HashChangeEvent("hashchange", { oldURL: oldURL.toString(), newURL: newURL.toString() }));
    }
    notifyApplicationAfterFrameLoad(frame) {
      return dispatch("turbo:frame-load", { target: frame });
    }
    notifyApplicationAfterFrameRender(fetchResponse, frame) {
      return dispatch("turbo:frame-render", { detail: { fetchResponse }, target: frame, cancelable: true });
    }
    elementDriveEnabled(element) {
      const container = element === null || element === void 0 ? void 0 : element.closest("[data-turbo]");
      if (this.drive) {
        if (container) {
          return container.getAttribute("data-turbo") != "false";
        } else {
          return true;
        }
      } else {
        if (container) {
          return container.getAttribute("data-turbo") == "true";
        } else {
          return false;
        }
      }
    }
    getActionForLink(link) {
      const action = link.getAttribute("data-turbo-action");
      return isAction(action) ? action : "advance";
    }
    getTargetFrameForLink(link) {
      const frame = link.getAttribute("data-turbo-frame");
      if (frame) {
        return frame;
      } else {
        const container = link.closest("turbo-frame");
        if (container) {
          return container.id;
        }
      }
    }
    get snapshot() {
      return this.view.snapshot;
    }
  };
  function extendURLWithDeprecatedProperties(url) {
    Object.defineProperties(url, deprecatedLocationPropertyDescriptors);
  }
  var deprecatedLocationPropertyDescriptors = {
    absoluteURL: {
      get() {
        return this.toString();
      }
    }
  };
  var session = new Session();
  var { navigator: navigator$1 } = session;
  function start() {
    session.start();
  }
  function registerAdapter(adapter) {
    session.registerAdapter(adapter);
  }
  function visit(location2, options) {
    session.visit(location2, options);
  }
  function connectStreamSource(source) {
    session.connectStreamSource(source);
  }
  function disconnectStreamSource(source) {
    session.disconnectStreamSource(source);
  }
  function renderStreamMessage(message) {
    session.renderStreamMessage(message);
  }
  function clearCache() {
    session.clearCache();
  }
  function setProgressBarDelay(delay) {
    session.setProgressBarDelay(delay);
  }
  function setConfirmMethod(confirmMethod) {
    FormSubmission.confirmMethod = confirmMethod;
  }
  var Turbo = /* @__PURE__ */ Object.freeze({
    __proto__: null,
    navigator: navigator$1,
    session,
    PageRenderer,
    PageSnapshot,
    start,
    registerAdapter,
    visit,
    connectStreamSource,
    disconnectStreamSource,
    renderStreamMessage,
    clearCache,
    setProgressBarDelay,
    setConfirmMethod
  });
  var FrameController = class {
    constructor(element) {
      this.fetchResponseLoaded = (fetchResponse) => {
      };
      this.currentFetchRequest = null;
      this.resolveVisitPromise = () => {
      };
      this.connected = false;
      this.hasBeenLoaded = false;
      this.settingSourceURL = false;
      this.element = element;
      this.view = new FrameView(this, this.element);
      this.appearanceObserver = new AppearanceObserver(this, this.element);
      this.linkInterceptor = new LinkInterceptor(this, this.element);
      this.formInterceptor = new FormInterceptor(this, this.element);
    }
    connect() {
      if (!this.connected) {
        this.connected = true;
        this.reloadable = false;
        if (this.loadingStyle == FrameLoadingStyle.lazy) {
          this.appearanceObserver.start();
        }
        this.linkInterceptor.start();
        this.formInterceptor.start();
        this.sourceURLChanged();
      }
    }
    disconnect() {
      if (this.connected) {
        this.connected = false;
        this.appearanceObserver.stop();
        this.linkInterceptor.stop();
        this.formInterceptor.stop();
      }
    }
    disabledChanged() {
      if (this.loadingStyle == FrameLoadingStyle.eager) {
        this.loadSourceURL();
      }
    }
    sourceURLChanged() {
      if (this.loadingStyle == FrameLoadingStyle.eager || this.hasBeenLoaded) {
        this.loadSourceURL();
      }
    }
    loadingStyleChanged() {
      if (this.loadingStyle == FrameLoadingStyle.lazy) {
        this.appearanceObserver.start();
      } else {
        this.appearanceObserver.stop();
        this.loadSourceURL();
      }
    }
    async loadSourceURL() {
      if (!this.settingSourceURL && this.enabled && this.isActive && (this.reloadable || this.sourceURL != this.currentURL)) {
        const previousURL = this.currentURL;
        this.currentURL = this.sourceURL;
        if (this.sourceURL) {
          try {
            this.element.loaded = this.visit(expandURL(this.sourceURL));
            this.appearanceObserver.stop();
            await this.element.loaded;
            this.hasBeenLoaded = true;
          } catch (error) {
            this.currentURL = previousURL;
            throw error;
          }
        }
      }
    }
    async loadResponse(fetchResponse) {
      if (fetchResponse.redirected || fetchResponse.succeeded && fetchResponse.isHTML) {
        this.sourceURL = fetchResponse.response.url;
      }
      try {
        const html = await fetchResponse.responseHTML;
        if (html) {
          const { body } = parseHTMLDocument(html);
          const snapshot = new Snapshot(await this.extractForeignFrameElement(body));
          const renderer = new FrameRenderer(this.view.snapshot, snapshot, false, false);
          if (this.view.renderPromise)
            await this.view.renderPromise;
          await this.view.render(renderer);
          session.frameRendered(fetchResponse, this.element);
          session.frameLoaded(this.element);
          this.fetchResponseLoaded(fetchResponse);
        }
      } catch (error) {
        console.error(error);
        this.view.invalidate();
      } finally {
        this.fetchResponseLoaded = () => {
        };
      }
    }
    elementAppearedInViewport(element) {
      this.loadSourceURL();
    }
    shouldInterceptLinkClick(element, url) {
      if (element.hasAttribute("data-turbo-method")) {
        return false;
      } else {
        return this.shouldInterceptNavigation(element);
      }
    }
    linkClickIntercepted(element, url) {
      this.reloadable = true;
      this.navigateFrame(element, url);
    }
    shouldInterceptFormSubmission(element, submitter) {
      return this.shouldInterceptNavigation(element, submitter);
    }
    formSubmissionIntercepted(element, submitter) {
      if (this.formSubmission) {
        this.formSubmission.stop();
      }
      this.reloadable = false;
      this.formSubmission = new FormSubmission(this, element, submitter);
      const { fetchRequest } = this.formSubmission;
      this.prepareHeadersForRequest(fetchRequest.headers, fetchRequest);
      this.formSubmission.start();
    }
    prepareHeadersForRequest(headers, request) {
      headers["Turbo-Frame"] = this.id;
    }
    requestStarted(request) {
      markAsBusy(this.element);
    }
    requestPreventedHandlingResponse(request, response) {
      this.resolveVisitPromise();
    }
    async requestSucceededWithResponse(request, response) {
      await this.loadResponse(response);
      this.resolveVisitPromise();
    }
    requestFailedWithResponse(request, response) {
      console.error(response);
      this.resolveVisitPromise();
    }
    requestErrored(request, error) {
      console.error(error);
      this.resolveVisitPromise();
    }
    requestFinished(request) {
      clearBusyState(this.element);
    }
    formSubmissionStarted({ formElement }) {
      markAsBusy(formElement, this.findFrameElement(formElement));
    }
    formSubmissionSucceededWithResponse(formSubmission, response) {
      const frame = this.findFrameElement(formSubmission.formElement, formSubmission.submitter);
      this.proposeVisitIfNavigatedWithAction(frame, formSubmission.formElement, formSubmission.submitter);
      frame.delegate.loadResponse(response);
    }
    formSubmissionFailedWithResponse(formSubmission, fetchResponse) {
      this.element.delegate.loadResponse(fetchResponse);
    }
    formSubmissionErrored(formSubmission, error) {
      console.error(error);
    }
    formSubmissionFinished({ formElement }) {
      clearBusyState(formElement, this.findFrameElement(formElement));
    }
    allowsImmediateRender(snapshot, resume) {
      return true;
    }
    viewRenderedSnapshot(snapshot, isPreview) {
    }
    viewInvalidated() {
    }
    async visit(url) {
      var _a;
      const request = new FetchRequest(this, FetchMethod.get, url, new URLSearchParams(), this.element);
      (_a = this.currentFetchRequest) === null || _a === void 0 ? void 0 : _a.cancel();
      this.currentFetchRequest = request;
      return new Promise((resolve) => {
        this.resolveVisitPromise = () => {
          this.resolveVisitPromise = () => {
          };
          this.currentFetchRequest = null;
          resolve();
        };
        request.perform();
      });
    }
    navigateFrame(element, url, submitter) {
      const frame = this.findFrameElement(element, submitter);
      this.proposeVisitIfNavigatedWithAction(frame, element, submitter);
      frame.setAttribute("reloadable", "");
      frame.src = url;
    }
    proposeVisitIfNavigatedWithAction(frame, element, submitter) {
      const action = getAttribute("data-turbo-action", submitter, element, frame);
      if (isAction(action)) {
        const { visitCachedSnapshot } = new SnapshotSubstitution(frame);
        frame.delegate.fetchResponseLoaded = (fetchResponse) => {
          if (frame.src) {
            const { statusCode, redirected } = fetchResponse;
            const responseHTML = frame.ownerDocument.documentElement.outerHTML;
            const response = { statusCode, redirected, responseHTML };
            session.visit(frame.src, { action, response, visitCachedSnapshot, willRender: false });
          }
        };
      }
    }
    findFrameElement(element, submitter) {
      var _a;
      const id = getAttribute("data-turbo-frame", submitter, element) || this.element.getAttribute("target");
      return (_a = getFrameElementById(id)) !== null && _a !== void 0 ? _a : this.element;
    }
    async extractForeignFrameElement(container) {
      let element;
      const id = CSS.escape(this.id);
      try {
        if (element = activateElement(container.querySelector(`turbo-frame#${id}`), this.currentURL)) {
          return element;
        }
        if (element = activateElement(container.querySelector(`turbo-frame[src][recurse~=${id}]`), this.currentURL)) {
          await element.loaded;
          return await this.extractForeignFrameElement(element);
        }
        console.error(`Response has no matching <turbo-frame id="${id}"> element`);
      } catch (error) {
        console.error(error);
      }
      return new FrameElement();
    }
    formActionIsVisitable(form, submitter) {
      const action = getAction(form, submitter);
      return locationIsVisitable(expandURL(action), this.rootLocation);
    }
    shouldInterceptNavigation(element, submitter) {
      const id = getAttribute("data-turbo-frame", submitter, element) || this.element.getAttribute("target");
      if (element instanceof HTMLFormElement && !this.formActionIsVisitable(element, submitter)) {
        return false;
      }
      if (!this.enabled || id == "_top") {
        return false;
      }
      if (id) {
        const frameElement = getFrameElementById(id);
        if (frameElement) {
          return !frameElement.disabled;
        }
      }
      if (!session.elementDriveEnabled(element)) {
        return false;
      }
      if (submitter && !session.elementDriveEnabled(submitter)) {
        return false;
      }
      return true;
    }
    get id() {
      return this.element.id;
    }
    get enabled() {
      return !this.element.disabled;
    }
    get sourceURL() {
      if (this.element.src) {
        return this.element.src;
      }
    }
    get reloadable() {
      const frame = this.findFrameElement(this.element);
      return frame.hasAttribute("reloadable");
    }
    set reloadable(value) {
      const frame = this.findFrameElement(this.element);
      if (value) {
        frame.setAttribute("reloadable", "");
      } else {
        frame.removeAttribute("reloadable");
      }
    }
    set sourceURL(sourceURL) {
      this.settingSourceURL = true;
      this.element.src = sourceURL !== null && sourceURL !== void 0 ? sourceURL : null;
      this.currentURL = this.element.src;
      this.settingSourceURL = false;
    }
    get loadingStyle() {
      return this.element.loading;
    }
    get isLoading() {
      return this.formSubmission !== void 0 || this.resolveVisitPromise() !== void 0;
    }
    get isActive() {
      return this.element.isActive && this.connected;
    }
    get rootLocation() {
      var _a;
      const meta = this.element.ownerDocument.querySelector(`meta[name="turbo-root"]`);
      const root = (_a = meta === null || meta === void 0 ? void 0 : meta.content) !== null && _a !== void 0 ? _a : "/";
      return expandURL(root);
    }
  };
  var SnapshotSubstitution = class {
    constructor(element) {
      this.visitCachedSnapshot = ({ element: element2 }) => {
        var _a;
        const { id, clone } = this;
        (_a = element2.querySelector("#" + id)) === null || _a === void 0 ? void 0 : _a.replaceWith(clone);
      };
      this.clone = element.cloneNode(true);
      this.id = element.id;
    }
  };
  function getFrameElementById(id) {
    if (id != null) {
      const element = document.getElementById(id);
      if (element instanceof FrameElement) {
        return element;
      }
    }
  }
  function activateElement(element, currentURL) {
    if (element) {
      const src = element.getAttribute("src");
      if (src != null && currentURL != null && urlsAreEqual(src, currentURL)) {
        throw new Error(`Matching <turbo-frame id="${element.id}"> element has a source URL which references itself`);
      }
      if (element.ownerDocument !== document) {
        element = document.importNode(element, true);
      }
      if (element instanceof FrameElement) {
        element.connectedCallback();
        element.disconnectedCallback();
        return element;
      }
    }
  }
  var StreamActions = {
    after() {
      this.targetElements.forEach((e) => {
        var _a;
        return (_a = e.parentElement) === null || _a === void 0 ? void 0 : _a.insertBefore(this.templateContent, e.nextSibling);
      });
    },
    append() {
      this.removeDuplicateTargetChildren();
      this.targetElements.forEach((e) => e.append(this.templateContent));
    },
    before() {
      this.targetElements.forEach((e) => {
        var _a;
        return (_a = e.parentElement) === null || _a === void 0 ? void 0 : _a.insertBefore(this.templateContent, e);
      });
    },
    prepend() {
      this.removeDuplicateTargetChildren();
      this.targetElements.forEach((e) => e.prepend(this.templateContent));
    },
    remove() {
      this.targetElements.forEach((e) => e.remove());
    },
    replace() {
      this.targetElements.forEach((e) => e.replaceWith(this.templateContent));
    },
    update() {
      this.targetElements.forEach((e) => {
        e.innerHTML = "";
        e.append(this.templateContent);
      });
    }
  };
  var StreamElement = class extends HTMLElement {
    async connectedCallback() {
      try {
        await this.render();
      } catch (error) {
        console.error(error);
      } finally {
        this.disconnect();
      }
    }
    async render() {
      var _a;
      return (_a = this.renderPromise) !== null && _a !== void 0 ? _a : this.renderPromise = (async () => {
        if (this.dispatchEvent(this.beforeRenderEvent)) {
          await nextAnimationFrame();
          this.performAction();
        }
      })();
    }
    disconnect() {
      try {
        this.remove();
      } catch (_a) {
      }
    }
    removeDuplicateTargetChildren() {
      this.duplicateChildren.forEach((c) => c.remove());
    }
    get duplicateChildren() {
      var _a;
      const existingChildren = this.targetElements.flatMap((e) => [...e.children]).filter((c) => !!c.id);
      const newChildrenIds = [...(_a = this.templateContent) === null || _a === void 0 ? void 0 : _a.children].filter((c) => !!c.id).map((c) => c.id);
      return existingChildren.filter((c) => newChildrenIds.includes(c.id));
    }
    get performAction() {
      if (this.action) {
        const actionFunction = StreamActions[this.action];
        if (actionFunction) {
          return actionFunction;
        }
        this.raise("unknown action");
      }
      this.raise("action attribute is missing");
    }
    get targetElements() {
      if (this.target) {
        return this.targetElementsById;
      } else if (this.targets) {
        return this.targetElementsByQuery;
      } else {
        this.raise("target or targets attribute is missing");
      }
    }
    get templateContent() {
      return this.templateElement.content.cloneNode(true);
    }
    get templateElement() {
      if (this.firstElementChild instanceof HTMLTemplateElement) {
        return this.firstElementChild;
      }
      this.raise("first child element must be a <template> element");
    }
    get action() {
      return this.getAttribute("action");
    }
    get target() {
      return this.getAttribute("target");
    }
    get targets() {
      return this.getAttribute("targets");
    }
    raise(message) {
      throw new Error(`${this.description}: ${message}`);
    }
    get description() {
      var _a, _b;
      return (_b = ((_a = this.outerHTML.match(/<[^>]+>/)) !== null && _a !== void 0 ? _a : [])[0]) !== null && _b !== void 0 ? _b : "<turbo-stream>";
    }
    get beforeRenderEvent() {
      return new CustomEvent("turbo:before-stream-render", { bubbles: true, cancelable: true });
    }
    get targetElementsById() {
      var _a;
      const element = (_a = this.ownerDocument) === null || _a === void 0 ? void 0 : _a.getElementById(this.target);
      if (element !== null) {
        return [element];
      } else {
        return [];
      }
    }
    get targetElementsByQuery() {
      var _a;
      const elements = (_a = this.ownerDocument) === null || _a === void 0 ? void 0 : _a.querySelectorAll(this.targets);
      if (elements.length !== 0) {
        return Array.prototype.slice.call(elements);
      } else {
        return [];
      }
    }
  };
  FrameElement.delegateConstructor = FrameController;
  //customElements.define("turbo-frame", FrameElement);
  //customElements.define("turbo-stream", StreamElement);
  (() => {
    let element = document.currentScript;
    if (!element)
      return;
    if (element.hasAttribute("data-turbo-suppress-warning"))
      return;
    while (element = element.parentElement) {
      if (element == document.body) {
        return console.warn(unindent`
        You are loading Turbo from a <script> element inside the <body> element. This is probably not what you meant to do!

        Load your application’s JavaScript bundle inside the <head> element instead. <script> elements in <body> are evaluated with each page change.

        For more information, see: https://turbo.hotwired.dev/handbook/building#working-with-script-elements

        ——
        Suppress this warning by adding a "data-turbo-suppress-warning" attribute to: %s
      `, element.outerHTML);
      }
    }
  })();
  window.Turbo = Turbo;
  start();

  // node_modules/@hotwired/turbo-rails/app/javascript/turbo/cable.js
  var consumer;
  async function getConsumer() {
    return consumer || setConsumer(createConsumer2().then(setConsumer));
  }
  function setConsumer(newConsumer) {
    return consumer = newConsumer;
  }
  async function createConsumer2() {
    const { createConsumer: createConsumer3 } = await Promise.resolve().then(() => (init_src(), src_exports));
    return createConsumer3();
  }
  async function subscribeTo(channel, mixin) {
    const { subscriptions } = await getConsumer();
    return subscriptions.create(channel, mixin);
  }

  // node_modules/@hotwired/turbo-rails/app/javascript/turbo/cable_stream_source_element.js
  var TurboCableStreamSourceElement = class extends HTMLElement {
    async connectedCallback() {
      connectStreamSource(this);
      this.subscription = await subscribeTo(this.channel, { received: this.dispatchMessageEvent.bind(this) });
    }
    disconnectedCallback() {
      disconnectStreamSource(this);
      if (this.subscription)
        this.subscription.unsubscribe();
    }
    dispatchMessageEvent(data) {
      const event = new MessageEvent("message", { data });
      return this.dispatchEvent(event);
    }
    get channel() {
      const channel = this.getAttribute("channel");
      const signed_stream_name = this.getAttribute("signed-stream-name");
      return { channel, signed_stream_name };
    }
  };
  //customElements.define("turbo-cable-stream-source", TurboCableStreamSourceElement);

  // app/javascript/controllers/wallet.js
  var import_stargate = __toESM(require_build12());
  window.onload = async () => {
    const chainId = "stargaze-1"; // **** chain-id CHANGE HERE
    const connectBtn = document.getElementById("connect-btn");
    const disconnectBtn = document.getElementById("disconnect-btn");
    const nfts = document.getElementById("nfts");
    //const balanceDisplay = document.getElementById("balance-display");
    const addressDisplay = document.getElementById("address-display");

    const myaddr = document.getElementById("myaddr");

    connectBtn.addEventListener("click", async function() {
      if (!window.getOfflineSigner || !window.keplr) {
        alert("Please use Chrome and install the Keplr Extension.");
      } else {
        await window.keplr.enable(chainId);
        await connectWallet();
        connectBtn.style.display = "none";
        disconnectBtn.style.display = "block";
      }
    });
    disconnectBtn.addEventListener("click", function() {
      if (isWalletConnected()) {
        sessionStorage.removeItem("address");
      }
      connectBtn.style.display = "block";
      disconnectBtn.style.display = "none";
      //nfts.innerHTML = "";
      //balanceDisplay.innerText = "";
      addressDisplay.innerText = "";

      //myaddr.value = "";

    });
    async function connectWallet() {
      if (!isWalletConnected()) {
        const offlineSigner = window.getOfflineSigner(chainId);
        const accounts = await offlineSigner.getAccounts();
        await sessionStorage.setItem("address", accounts[0].address);
      }
      const address = sessionStorage.getItem("address");
      //await nfts.setAttribute("src", "/wallet/nfts?owner_address=" + address);
      //await nfts.removeAttribute("disabled");
      const rawBalance = await getWalletBalance();
      const balance = Math.round(rawBalance.amount / 1e6 * 100) / 100;
      //balanceDisplay.innerText = balance.toString() + " STARS"; // CHANGE HERE
      addressDisplay.innerText = "Address: " + address;

      //myaddr.value = address;

      qq(address); // pass addrfess to script

    }
    function isWalletConnected() {
      return sessionStorage.getItem("address") !== null;
    }
    async function getWalletBalance() {
      const offlineSigner = window.getOfflineSigner(chainId);
      const cosmJS = await import_stargate.SigningStargateClient.connectWithSigner("https://rpc.stargaze-apis.com:443", offlineSigner); // CHANGE HERE
      const accounts = await offlineSigner.getAccounts();
      if (Array.isArray(accounts) && accounts[0]) {
        return await cosmJS.getBalance(accounts[0].address, "ustars"); // CHANGE HERE
      } else {
        return 0;
      }
    }
    if (isWalletConnected()) {
      connectBtn.style.display = "none";
      disconnectBtn.style.display = "block";
      await connectWallet();
    } else {
      connectBtn.style.display = "block";
      disconnectBtn.style.display = "none";
    }
    window.addEventListener("keplr_keystorechange", async function() {
      if (isWalletConnected()) {
        sessionStorage.removeItem("address");
      }
      await connectWallet();
    });
  };
})();
/*!
 * The buffer module from node.js, for the browser.
 *
 * @author   Feross Aboukhadijeh <https://feross.org>
 * @license  MIT
 */
/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
//# sourceMappingURL=/assets/wallet-application.js-5509243ac101210df951c911b3ecc3a39cb82c9238e5d0979d7883d58f0c25be.map
//!
;