@scout9/app 1.0.0-alpha.0.4.6 → 1.0.0-alpha.0.4.8

package/dist/{dev-1638ac94.cjs → dev-332ccb5a.cjs}

@@ -25458,7 +25458,7 @@ common.createRequestFunction = createRequestFunction;
   Object.defineProperty(exports, "__esModule", {
     value: true
   });
-  exports.Scout9Api = exports.Scout9ApiGenerated = exports.Scout9ApiFactory = exports.Scout9ApiFp = exports.Scout9ApiAxiosParamCreator = exports.WorkflowResponseSlotForwardOneOfModeEnum = exports.PurposeEnum = exports.PmtConfigModelEnum = exports.PmtConfigEngineEnum = exports.MessageGetResponseInnerRoleEnum = exports.MessageCreateRequestRoleEnum = exports.MessageBaseRoleEnum = exports.MessageRoleEnum = exports.MacroResultTypeEnum = exports.MacroDidResultTypeEnum = exports.MacroContextResultTypeEnum = exports.LlmConfigOneOf2EngineEnum = exports.LlmConfigOneOf1EngineEnum = exports.LlmConfigOneOfModelEnum = exports.LlmConfigOneOfEngineEnum = exports.ListApiOperationsResponseInnerMethodEnum = exports.GetApiOperationResponseMethodEnum = exports.ForwardRequestLatestMessageRoleEnum = exports.ForwardRequestForwardOneOfModeEnum = exports.ExistenceOperator = exports.EqualityOperator = exports.ConversationEnvironment = exports.ConversationContextFieldConditionOperatorEnum = exports.ApiOperationMethodEnum = void 0;
+  exports.Scout9Api = exports.Scout9ApiGenerated = exports.Scout9ApiFactory = exports.Scout9ApiFp = exports.Scout9ApiAxiosParamCreator = exports.NoopApi = exports.NoopApiFactory = exports.NoopApiFp = exports.NoopApiAxiosParamCreator = exports.WorkflowResponseSlotForwardOneOfModeEnum = exports.PurposeEnum = exports.PmtConfigModelEnum = exports.PmtConfigEngineEnum = exports.MessageGetResponseInnerRoleEnum = exports.MessageCreateRequestRoleEnum = exports.MessageBaseRoleEnum = exports.MessageRoleEnum = exports.MacroResultTypeEnum = exports.MacroDoesResultTypeEnum = exports.MacroDoesInputRoleEnum = exports.MacroDidResultTypeEnum = exports.MacroContextResultTypeEnum = exports.LlmConfigOneOf2EngineEnum = exports.LlmConfigOneOf1EngineEnum = exports.LlmConfigOneOfModelEnum = exports.LlmConfigOneOfEngineEnum = exports.ListApiOperationsResponseInnerMethodEnum = exports.GetApiOperationResponseMethodEnum = exports.ForwardRequestLatestMessageRoleEnum = exports.ForwardRequestForwardOneOfModeEnum = exports.ExistenceOperator = exports.EqualityOperator = exports.ConversationEnvironment = exports.ConversationContextFieldConditionOperatorEnum = exports.ApiOperationMethodEnum = void 0;
   const axios_1$1 = __importDefault(axios_1);
   // Some imports not used depending on template conditions
   // @ts-ignore
@@ -25589,6 +25589,13 @@ common.createRequestFunction = createRequestFunction;
   exports.MacroDidResultTypeEnum = {
     Did: 'did'
   };
+  exports.MacroDoesInputRoleEnum = {
+    Customer: 'customer',
+    Agent: 'agent'
+  };
+  exports.MacroDoesResultTypeEnum = {
+    Does: 'does'
+  };
   exports.MacroResultTypeEnum = {
     Did: 'did',
     Context: 'context'
@@ -25634,6 +25641,114 @@ common.createRequestFunction = createRequestFunction;
     AfterReply: 'after-reply',
     Immediately: 'immediately'
   };
+  /**
+   * NoopApi - axios parameter creator
+   * @export
+   */
+  const NoopApiAxiosParamCreator = function (configuration) {
+    return {
+      /**
+       *
+       * @summary This is used for the generator to include PurposeEnum, because for whatever reason, query params are not included in the generator.
+       * @param {PingRequest} pingRequest
+       * @param {*} [options] Override http request option.
+       * @throws {RequiredError}
+       */
+      ping: async (pingRequest, options = {}) => {
+        // verify required parameter 'pingRequest' is not null or undefined
+        (0, common_1.assertParamExists)('ping', 'pingRequest', pingRequest);
+        const localVarPath = `/v1-utils-ping`;
+        // use dummy base URL string because the URL constructor only accepts absolute URLs.
+        const localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
+        let baseOptions;
+        if (configuration) {
+          baseOptions = configuration.baseOptions;
+        }
+        const localVarRequestOptions = {
+          method: 'POST',
+          ...baseOptions,
+          ...options
+        };
+        const localVarHeaderParameter = {};
+        const localVarQueryParameter = {};
+        localVarHeaderParameter['Content-Type'] = 'application/json';
+        (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
+        let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+        localVarRequestOptions.headers = {
+          ...localVarHeaderParameter,
+          ...headersFromBaseOptions,
+          ...options.headers
+        };
+        localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(pingRequest, localVarRequestOptions, configuration);
+        return {
+          url: (0, common_1.toPathString)(localVarUrlObj),
+          options: localVarRequestOptions
+        };
+      }
+    };
+  };
+  exports.NoopApiAxiosParamCreator = NoopApiAxiosParamCreator;
+  /**
+   * NoopApi - functional programming interface
+   * @export
+   */
+  const NoopApiFp = function (configuration) {
+    const localVarAxiosParamCreator = (0, exports.NoopApiAxiosParamCreator)(configuration);
+    return {
+      /**
+       *
+       * @summary This is used for the generator to include PurposeEnum, because for whatever reason, query params are not included in the generator.
+       * @param {PingRequest} pingRequest
+       * @param {*} [options] Override http request option.
+       * @throws {RequiredError}
+       */
+      async ping(pingRequest, options) {
+        const localVarAxiosArgs = await localVarAxiosParamCreator.ping(pingRequest, options);
+        return (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1$1.default, base_1.BASE_PATH, configuration);
+      }
+    };
+  };
+  exports.NoopApiFp = NoopApiFp;
+  /**
+   * NoopApi - factory interface
+   * @export
+   */
+  const NoopApiFactory = function (configuration, basePath, axios) {
+    const localVarFp = (0, exports.NoopApiFp)(configuration);
+    return {
+      /**
+       *
+       * @summary This is used for the generator to include PurposeEnum, because for whatever reason, query params are not included in the generator.
+       * @param {PingRequest} pingRequest
+       * @param {*} [options] Override http request option.
+       * @throws {RequiredError}
+       */
+      ping(pingRequest, options) {
+        return localVarFp.ping(pingRequest, options).then(request => request(axios, basePath));
+      }
+    };
+  };
+  exports.NoopApiFactory = NoopApiFactory;
+  /**
+   * NoopApi - object-oriented interface
+   * @export
+   * @class NoopApi
+   * @extends {BaseAPI}
+   */
+  class NoopApi extends base_1.BaseAPI {
+    /**
+     *
+     * @summary This is used for the generator to include PurposeEnum, because for whatever reason, query params are not included in the generator.
+     * @param {PingRequest} pingRequest
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof NoopApi
+     */
+    ping(pingRequest, options) {
+      return (0, exports.NoopApiFp)(this.configuration).ping(pingRequest, options).then(request => request(this.axios, this.basePath));
+    }
+  }
+  exports.NoopApi = NoopApi;
   /**
    * Scout9Api - axios parameter creator
    * @export
@@ -27028,6 +27143,44 @@ common.createRequestFunction = createRequestFunction;
           options: localVarRequestOptions
         };
       },
+      /**
+       *
+       * @summary Natural language prompt to resolve to a boolean value in relation to the given immediate message.
+       * @param {MacroDoesInput} macroDoesInput
+       * @param {*} [options] Override http request option.
+       * @throws {RequiredError}
+       */
+      does: async (macroDoesInput, options = {}) => {
+        // verify required parameter 'macroDoesInput' is not null or undefined
+        (0, common_1.assertParamExists)('does', 'macroDoesInput', macroDoesInput);
+        const localVarPath = `/v1-utils-macros-does`;
+        // use dummy base URL string because the URL constructor only accepts absolute URLs.
+        const localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
+        let baseOptions;
+        if (configuration) {
+          baseOptions = configuration.baseOptions;
+        }
+        const localVarRequestOptions = {
+          method: 'POST',
+          ...baseOptions,
+          ...options
+        };
+        const localVarHeaderParameter = {};
+        const localVarQueryParameter = {};
+        localVarHeaderParameter['Content-Type'] = 'application/json';
+        (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
+        let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+        localVarRequestOptions.headers = {
+          ...localVarHeaderParameter,
+          ...headersFromBaseOptions,
+          ...options.headers
+        };
+        localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(macroDoesInput, localVarRequestOptions, configuration);
+        return {
+          url: (0, common_1.toPathString)(localVarUrlObj),
+          options: localVarRequestOptions
+        };
+      },
       /**
        *
        * @summary Get an entity by type and ID
@@ -27582,44 +27735,6 @@ common.createRequestFunction = createRequestFunction;
           options: localVarRequestOptions
         };
       },
-      /**
-       *
-       * @summary This is used for the generator to include PurposeEnum, because for whatever reason, query params are not included in the generator.
-       * @param {PingRequest} pingRequest
-       * @param {*} [options] Override http request option.
-       * @throws {RequiredError}
-       */
-      ping: async (pingRequest, options = {}) => {
-        // verify required parameter 'pingRequest' is not null or undefined
-        (0, common_1.assertParamExists)('ping', 'pingRequest', pingRequest);
-        const localVarPath = `/v1-utils-ping`;
-        // use dummy base URL string because the URL constructor only accepts absolute URLs.
-        const localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
-        let baseOptions;
-        if (configuration) {
-          baseOptions = configuration.baseOptions;
-        }
-        const localVarRequestOptions = {
-          method: 'POST',
-          ...baseOptions,
-          ...options
-        };
-        const localVarHeaderParameter = {};
-        const localVarQueryParameter = {};
-        localVarHeaderParameter['Content-Type'] = 'application/json';
-        (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
-        let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-        localVarRequestOptions.headers = {
-          ...localVarHeaderParameter,
-          ...headersFromBaseOptions,
-          ...options.headers
-        };
-        localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(pingRequest, localVarRequestOptions, configuration);
-        return {
-          url: (0, common_1.toPathString)(localVarUrlObj),
-          options: localVarRequestOptions
-        };
-      },
       /**
        *
        * @summary Purchase phone for a given agent.
@@ -28227,6 +28342,17 @@ common.createRequestFunction = createRequestFunction;
         const localVarAxiosArgs = await localVarAxiosParamCreator.did(macroDidInput, options);
         return (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1$1.default, base_1.BASE_PATH, configuration);
       },
+      /**
+       *
+       * @summary Natural language prompt to resolve to a boolean value in relation to the given immediate message.
+       * @param {MacroDoesInput} macroDoesInput
+       * @param {*} [options] Override http request option.
+       * @throws {RequiredError}
+       */
+      async does(macroDoesInput, options) {
+        const localVarAxiosArgs = await localVarAxiosParamCreator.does(macroDoesInput, options);
+        return (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1$1.default, base_1.BASE_PATH, configuration);
+      },
       /**
        *
        * @summary Get an entity by type and ID
@@ -28383,17 +28509,6 @@ common.createRequestFunction = createRequestFunction;
         const localVarAxiosArgs = await localVarAxiosParamCreator.parse(parseRequest, options);
         return (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1$1.default, base_1.BASE_PATH, configuration);
       },
-      /**
-       *
-       * @summary This is used for the generator to include PurposeEnum, because for whatever reason, query params are not included in the generator.
-       * @param {PingRequest} pingRequest
-       * @param {*} [options] Override http request option.
-       * @throws {RequiredError}
-       */
-      async ping(pingRequest, options) {
-        const localVarAxiosArgs = await localVarAxiosParamCreator.ping(pingRequest, options);
-        return (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1$1.default, base_1.BASE_PATH, configuration);
-      },
       /**
        *
        * @summary Purchase phone for a given agent.
@@ -28828,6 +28943,16 @@ common.createRequestFunction = createRequestFunction;
       did(macroDidInput, options) {
         return localVarFp.did(macroDidInput, options).then(request => request(axios, basePath));
       },
+      /**
+       *
+       * @summary Natural language prompt to resolve to a boolean value in relation to the given immediate message.
+       * @param {MacroDoesInput} macroDoesInput
+       * @param {*} [options] Override http request option.
+       * @throws {RequiredError}
+       */
+      does(macroDoesInput, options) {
+        return localVarFp.does(macroDoesInput, options).then(request => request(axios, basePath));
+      },
       /**
        *
        * @summary Get an entity by type and ID
@@ -28971,16 +29096,6 @@ common.createRequestFunction = createRequestFunction;
       parse(parseRequest, options) {
         return localVarFp.parse(parseRequest, options).then(request => request(axios, basePath));
       },
-      /**
-       *
-       * @summary This is used for the generator to include PurposeEnum, because for whatever reason, query params are not included in the generator.
-       * @param {PingRequest} pingRequest
-       * @param {*} [options] Override http request option.
-       * @throws {RequiredError}
-       */
-      ping(pingRequest, options) {
-        return localVarFp.ping(pingRequest, options).then(request => request(axios, basePath));
-      },
       /**
        *
        * @summary Purchase phone for a given agent.
@@ -29446,6 +29561,17 @@ common.createRequestFunction = createRequestFunction;
     did(macroDidInput, options) {
       return (0, exports.Scout9ApiFp)(this.configuration).did(macroDidInput, options).then(request => request(this.axios, this.basePath));
     }
+    /**
+     *
+     * @summary Natural language prompt to resolve to a boolean value in relation to the given immediate message.
+     * @param {MacroDoesInput} macroDoesInput
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof Scout9Api
+     */
+    does(macroDoesInput, options) {
+      return (0, exports.Scout9ApiFp)(this.configuration).does(macroDoesInput, options).then(request => request(this.axios, this.basePath));
+    }
     /**
      *
      * @summary Get an entity by type and ID
@@ -29602,17 +29728,6 @@ common.createRequestFunction = createRequestFunction;
     parse(parseRequest, options) {
       return (0, exports.Scout9ApiFp)(this.configuration).parse(parseRequest, options).then(request => request(this.axios, this.basePath));
     }
-    /**
-     *
-     * @summary This is used for the generator to include PurposeEnum, because for whatever reason, query params are not included in the generator.
-     * @param {PingRequest} pingRequest
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof Scout9Api
-     */
-    ping(pingRequest, options) {
-      return (0, exports.Scout9ApiFp)(this.configuration).ping(pingRequest, options).then(request => request(this.axios, this.basePath));
-    }
     /**
      *
      * @summary Purchase phone for a given agent.
@@ -35049,7 +35164,7 @@ function _loadUserPackageJson() {
           targetPkgUrl = isTest ? packageTestJsonUrl : packageJsonUrl;
           _context2.t0 = JSON;
           _context2.next = 10;
-          return fs__default["default"].readFile(new URL(targetPkgUrl, (typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('dev-1638ac94.js', document.baseURI).href))), 'utf-8');
+          return fs__default["default"].readFile(new URL(targetPkgUrl, (typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('dev-332ccb5a.js', document.baseURI).href))), 'utf-8');
         case 10:
           _context2.t1 = _context2.sent;
           pkg = _context2.t0.parse.call(_context2.t0, _context2.t1);
@@ -35909,7 +36024,7 @@ var _excluded$1 = ["success"];
  * @property {function(): EventMacros} resetIntent
  * @property {function(string | string[], boolean?): EventMacros} instructRemove
  * @property {function(string, (OptionsInstruct & OptionsForward & {stagnationLimit?: number})?): EventMacros} instructSafe
- * @property {function(string, OptionsInstruct?): EventMacros} instruct
+ * @property {function(string | Array<string | (OptionsInstruct & {content: string})>, OptionsInstruct?): EventMacros} instruct
  * @property {function(string, OptionsReply?): EventMacros} reply
  * @property {function(string?, OptionsForward?): EventMacros} forward
  * @property {function(boolean?): Array<WorkflowResponseSlot>} toJSON
@@ -36130,32 +36245,70 @@ function EventMacrosFactory() {
       }
     },
     /**
-     * Return instructions to guide next auto reply response
+     * Return instructions to guide next response
+     *
+     * @overload
      * @param {string} instruction
      * @param {OptionsInstruct} [options]
+     *
+     * @overload
+     * @param {Array<string | (OptionsInstruct & {content: string})>} instruction
      * @return {EventMacros}
      */
     instruct: function instruct(instruction) {
       var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-      var slot = {};
-      if (Object.keys(options).length > 0) {
-        var instructionObj = {
-          content: instruction
-        };
-        if (options.id) {
-          instructionObj.id = options.id;
+      if (Array.isArray(instruction)) {
+        instruction.forEach(function (_instruction) {
+          /** @type {WorkflowResponseSlot} */
+          var slot = {};
+          if (spirits._typeof(_instruction) === 'object' && 'content' in _instruction) {
+            /** @type {Instruction} */
+            var instructionObj = {
+              content: instruction
+            };
+            if (options.id) {
+              instructionObj.id = options.id;
+            }
+            if (typeof options.persist === 'boolean') {
+              instructionObj.persist = options.persist;
+            }
+            slot.instructions = instructionObj;
+          } else if (typeof _instruction === 'string') {
+            slot.instructions = instruction;
+          } else {
+            console.warn("Invalid instruction type ".concat(JSON.stringify(_instruction), ", omitted from slot"));
+          }
+          try {
+            slots.push(macros.WorkflowResponseSlotSchema.parse(slot));
+          } catch (e) {
+            throw simplifyError(e, 'Invalid instruct() input');
+          }
+        });
+      } else if (typeof instruction === 'string') {
+        /** @type {WorkflowResponseSlot} */
+        var slot = {};
+        if (Object.keys(options).length > 0) {
+          /** @type {Instruction} */
+          var instructionObj = {
+            content: instruction
+          };
+          if (options.id) {
+            instructionObj.id = options.id;
+          }
+          if (typeof options.persist === 'boolean') {
+            instructionObj.persist = options.persist;
+          }
+          slot.instructions = instructionObj;
+        } else {
+          slot.instructions = instruction;
         }
-        if (typeof options.persist === 'boolean') {
-          instructionObj.persist = options.persist;
+        try {
+          slots.push(macros.WorkflowResponseSlotSchema.parse(slot));
+        } catch (e) {
+          throw simplifyError(e, 'Invalid instruct() input');
         }
-        slot.instructions = instructionObj;
       } else {
-        slot.instructions = instruction;
-      }
-      try {
-        slots.push(macros.WorkflowResponseSlotSchema.parse(slot));
-      } catch (e) {
-        throw simplifyError(e, 'Invalid instruct() input');
+        throw new Error("Invalid instruction param ".concat(JSON.stringify(instruction), ", expected a string or array"));
       }
       return this;
     },
@@ -36246,13 +36399,19 @@ var eventMacros = EventMacrosFactory();
 
 /**
  * Return instructions to guide next response
- * @param {string} instruction - the instruction to send to the
+ *
+ * @example instruct("Ask user if they are looking to order a pizza");
+ *
+ * @overload
+ * @param {string} instruction
  * @param {OptionsInstruct} [options]
+ *
+ * @overload
+ * @param {Array<string | (OptionsInstruct & {content: string})>} instruction
  * @return {EventMacros}
  *
- * @example instruct("Ask user if they are looking to order a pizza");
  *
- * @type {(message: string, options?: OptionsInstruct) => EventMacros}
+ * @type {(instruction: string | Array<string | (OptionsInstruct & {content: string})>, options?: OptionsInstruct) => EventMacros}
  */
 var instruct = eventMacros.instruct.bind(eventMacros);
 

package/dist/{index-f4c10ec2.cjs → index-2d62ac36.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
 var spirits = require("./spirits-5c9243a1.cjs");
-var dev = require("./dev-1638ac94.cjs");
+var dev = require("./dev-332ccb5a.cjs");
 var macros = require("./macros-e4105c56.cjs");
 var require$$0 = require('fs');
 var require$$2$1 = require('events');
@@ -29483,7 +29483,7 @@ class Body {
     }
     const {
       toFormData
-    } = await Promise.resolve().then(function () { return require("./multipart-parser-57fbd838.cjs"); });
+    } = await Promise.resolve().then(function () { return require("./multipart-parser-948d98ce.cjs"); });
     return toFormData(this.body, ct);
   }
 
@@ -41884,7 +41884,7 @@ function _loadUserPackageJson() {
           targetPkgUrl = isTest ? packageTestJsonUrl : packageJsonUrl;
           _context.t0 = JSON;
           _context.next = 10;
-          return fs__default["default"].readFile(new URL(targetPkgUrl, (typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('index-f4c10ec2.js', document.baseURI).href))), 'utf-8');
+          return fs__default["default"].readFile(new URL(targetPkgUrl, (typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('index-2d62ac36.js', document.baseURI).href))), 'utf-8');
         case 10:
           _context.t1 = _context.sent;
           pkg = _context.t0.parse.call(_context.t0, _context.t1);
@@ -41902,7 +41902,8 @@ function _loadUserPackageJson() {
 }
 
 /**
- * Utility runtime class used to guide event output
+ * Utility runtime class for entity APIs methods
+ * @deprecated this is only valid for entity APIs, not workflow templates
  * @template T
  */
 var EventResponse = /*#__PURE__*/function () {
@@ -43157,7 +43158,7 @@ var ProjectFiles = /*#__PURE__*/function () {
   return ProjectFiles;
 }();
 
-var __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('index-f4c10ec2.js', document.baseURI).href)));
+var __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('index-2d62ac36.js', document.baseURI).href)));
 var __dirname$1 = path__default["default"].dirname(__filename$1);
 function zipDirectory(source, out) {
   var archive = archiver$1('tar', {
@@ -43372,7 +43373,7 @@ function _buildApp() {
         case 11:
           _context4.t0 = JSON;
           _context4.next = 14;
-          return fs__default["default"].readFile(new URL(templatePackagePath, (typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('index-f4c10ec2.js', document.baseURI).href))), 'utf-8');
+          return fs__default["default"].readFile(new URL(templatePackagePath, (typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('index-2d62ac36.js', document.baseURI).href))), 'utf-8');
         case 14:
           _context4.t1 = _context4.sent;
           packageTemplate = _context4.t0.parse.call(_context4.t0, _context4.t1);
@@ -43919,25 +43920,19 @@ function _test() {
             var _e$definitions, _e$training;
             return (e === null || e === void 0 || (_e$definitions = e.definitions) === null || _e$definitions === void 0 ? void 0 : _e$definitions.length) > 0 || (e === null || e === void 0 || (_e$training = e.training) === null || _e$training === void 0 ? void 0 : _e$training.length) > 0;
           });
-          if (!(testableEntities.length === 0)) {
-            _context12.next = 4;
-            break;
-          }
-          throw new Error('No testable entities found - make sure you have at least one entity with definitions or training data - learn more at https://scout9.com/docs');
-        case 4:
           tests = testableEntities.reduce(function (accumulator, entity) {
             return accumulator += ((entity === null || entity === void 0 ? void 0 : entity.tests) || []).length;
           }, 0);
           if (!(tests === 0)) {
-            _context12.next = 8;
+            _context12.next = 6;
             break;
           }
           logger.warn('No tests found for any entities, skipping test run');
           return _context12.abrupt("return");
-        case 8:
+        case 6:
           // @TODO format errors
           logger.log("Running ".concat(tests, " entity test points..."));
-          _context12.next = 11;
+          _context12.next = 9;
           return new dev.build.Scout9Api(new dev.build.Configuration({
             apiKey: process.env.SCOUT9_API_KEY || ''
           })).parse({
@@ -43945,7 +43940,7 @@ function _test() {
             language: 'en',
             entities: testableEntities
           });
-        case 11:
+        case 9:
         case "end":
           return _context12.stop();
       }

package/dist/index.cjs

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var index = require("./index-f4c10ec2.cjs");
-var dev = require("./dev-1638ac94.cjs");
+var index = require("./index-2d62ac36.cjs");
+var dev = require("./dev-332ccb5a.cjs");
 require("./spirits-5c9243a1.cjs");
 require("./macros-e4105c56.cjs");
 require('fs');

package/dist/{multipart-parser-57fbd838.cjs → multipart-parser-948d98ce.cjs}

@@ -2,9 +2,9 @@
 
 require('node:fs');
 require('node:path');
-var index = require("./index-f4c10ec2.cjs");
+var index = require("./index-2d62ac36.cjs");
 require("./spirits-5c9243a1.cjs");
-require("./dev-1638ac94.cjs");
+require("./dev-332ccb5a.cjs");
 require('util');
 require('stream');
 require('path');

package/dist/testing-tools.cjs

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var dev = require("./dev-1638ac94.cjs");
+var dev = require("./dev-332ccb5a.cjs");
 require("./spirits-5c9243a1.cjs");
 require('util');
 require('stream');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scout9/app",
-  "version": "1.0.0-alpha.0.4.6",
+  "version": "1.0.0-alpha.0.4.8",
   "description": "Build and deploy your Scout9 app for SMS auto replies",
   "publishConfig": {
     "access": "public"

package/src/core/index.js

@@ -443,10 +443,6 @@ export async function test(
 ) {
 
   const testableEntities = config.entities.filter(e => e?.definitions?.length > 0 || e?.training?.length > 0);
-  if (testableEntities.length === 0) {
-    throw new Error(
-      'No testable entities found - make sure you have at least one entity with definitions or training data - learn more at https://scout9.com/docs');
-  }
 
   const tests = testableEntities.reduce((accumulator, entity) => accumulator += (entity?.tests || []).length, 0);
 

package/src/public.d.ts

@@ -92,11 +92,28 @@ export class EventResponse<T = any> {
  * @param {OptionsInstruct} [options]
  * @return {EventMacros}
  *
+ * @overload
+ * @param {Array<string | (OptionsInstruct & {content: string})>} instruction
+ *
  * @example instruct("Ask user if they are looking to order a pizza");
  *
  * @type {(message: string, options?: OptionsInstruct) => EventMacros}
  */
-export const instruct: (message: string, options?: OptionsInstruct) => EventMacros;
+export const instruct: ((instruction: string, options?: OptionsInstruct) => EventMacros) | ((instruction: Array<string | (OptionsInstruct & {content: string})>) => EventMacros);
+
+/**
+ * If conversation is not stagnant, return instructions to guide next auto reply response, otherwise it will forward the conversation
+ * @param {string} instruction - the instruction to send to the
+ * @param {OptionsInstruct} [options]
+ * @return {EventMacros}
+ *
+ * @example instructSafe("Ask user if they are looking to order a pizza");
+ * @example instructSafe("Ask user if they are looking to order a pizza", {stagnationLimit: 3}); // Allows for 3 stagnate messages before forwarding
+ *
+ * @type {(message: string, options?: OptionsInstruct) => EventMacros}
+ */
+export const instructSafe: (instruction: string, options?: (OptionsInstruct & OptionsForward & {stagnationLimit?: number})) => EventMacros;
+
 /**
  * Forwards conversation back to you or owner of workflow.
  *
@@ -221,13 +238,18 @@ export type EventMacros = {
      * If conversation is not stagnant, return instructions to guide next auto reply response, otherwise it will forward the conversation
      * stagnationLimit defaults to 2
      */
-    instructSafe(instruction: string, options?: (OptionsInstruct & OptionsFollowup & {stagnationLimit?: number})): EventMacros;
+    instructSafe(instruction: string, options?: (OptionsInstruct & OptionsForward & {stagnationLimit?: number})): EventMacros;
 
     /**
      * Return instructions to guide next auto reply response
      */
     instruct(instruction: string, options?: OptionsInstruct): EventMacros;
 
+    /**
+     * Return instructions to guide next auto reply response
+     */
+    instruct(instruction: Array<string | (OptionsInstruct & {content: string})>): EventMacros;
+
     /**
      * If a manual message must be sent, you can use the `reply` macro
      * @param {string} message - the message to manually send to the user

package/src/runtime/client/api.js

@@ -1,5 +1,6 @@
 /**
- * Utility runtime class used to guide event output
+ * Utility runtime class for entity APIs methods
+ * @deprecated this is only valid for entity APIs, not workflow templates
  * @template T
  */
 export class EventResponse {
@@ -56,3 +57,4 @@ export class EventResponse {
 
 }
 
+

package/src/runtime/macros/event.js

@@ -89,7 +89,7 @@ import MacroGlobals from './globals.js';
  * @property {function(): EventMacros} resetIntent
  * @property {function(string | string[], boolean?): EventMacros} instructRemove
  * @property {function(string, (OptionsInstruct & OptionsForward & {stagnationLimit?: number})?): EventMacros} instructSafe
- * @property {function(string, OptionsInstruct?): EventMacros} instruct
+ * @property {function(string | Array<string | (OptionsInstruct & {content: string})>, OptionsInstruct?): EventMacros} instruct
  * @property {function(string, OptionsReply?): EventMacros} reply
  * @property {function(string?, OptionsForward?): EventMacros} forward
  * @property {function(boolean?): Array<WorkflowResponseSlot>} toJSON
@@ -305,35 +305,77 @@ function EventMacrosFactory() {
 
 
     /**
-     * Return instructions to guide next auto reply response
+     * Return instructions to guide next response
+     *
+     * @overload
      * @param {string} instruction
      * @param {OptionsInstruct} [options]
+     *
+     * @overload
+     * @param {Array<string | (OptionsInstruct & {content: string})>} instruction
      * @return {EventMacros}
      */
     instruct(instruction, options = {}) {
-      const slot = {};
-      if (Object.keys(options).length > 0) {
-        const instructionObj = {
-          content: instruction
-        };
-        if (options.id) {
-          instructionObj.id = options.id;
-        }
-        if (typeof options.persist === 'boolean') {
-          instructionObj.persist = options.persist;
-        }
-        slot.instructions = instructionObj;
+
+      if (Array.isArray(instruction)) {
+
+        instruction.forEach((_instruction) => {
+            /** @type {WorkflowResponseSlot} */
+            const slot = {};
+            if (typeof _instruction === 'object' && 'content' in _instruction) {
+                /** @type {Instruction} */
+                const instructionObj = {
+                    content: instruction
+                };
+                if (options.id) {
+                    instructionObj.id = options.id;
+                }
+                if (typeof options.persist === 'boolean') {
+                    instructionObj.persist = options.persist;
+                }
+                slot.instructions = instructionObj;
+            } else if (typeof _instruction === 'string') {
+                slot.instructions = instruction;
+            } else {
+              console.warn(`Invalid instruction type ${JSON.stringify(_instruction)}, omitted from slot`);
+            }
+            try {
+                slots.push(WorkflowResponseSlotSchema.parse(slot));
+            } catch (e) {
+                throw simplifyError(e, 'Invalid instruct() input');
+            }
+        });
+      } else if (typeof instruction === 'string') {
+          /** @type {WorkflowResponseSlot} */
+          const slot = {};
+          if (Object.keys(options).length > 0) {
+              /** @type {Instruction} */
+              const instructionObj = {
+                  content: instruction
+              };
+              if (options.id) {
+                  instructionObj.id = options.id;
+              }
+              if (typeof options.persist === 'boolean') {
+                  instructionObj.persist = options.persist;
+              }
+              slot.instructions = instructionObj;
+          } else {
+              slot.instructions = instruction;
+          }
+          try {
+              slots.push(WorkflowResponseSlotSchema.parse(slot));
+          } catch (e) {
+              throw simplifyError(e, 'Invalid instruct() input');
+          }
       } else {
-        slot.instructions = instruction;
-      }
-      try {
-        slots.push(WorkflowResponseSlotSchema.parse(slot));
-      } catch (e) {
-        throw simplifyError(e, 'Invalid instruct() input');
+        throw new Error(`Invalid instruction param ${JSON.stringify(instruction)}, expected a string or array`);
       }
+
       return this;
     },
 
+
     /**
      * If a manual message must be sent, you can use the `reply` macro
      * @param {string} message - the message to manually send to the user
@@ -421,13 +463,19 @@ const eventMacros = EventMacrosFactory();
 
 /**
  * Return instructions to guide next response
- * @param {string} instruction - the instruction to send to the
+ *
+ * @example instruct("Ask user if they are looking to order a pizza");
+ *
+ * @overload
+ * @param {string} instruction
  * @param {OptionsInstruct} [options]
+ *
+ * @overload
+ * @param {Array<string | (OptionsInstruct & {content: string})>} instruction
  * @return {EventMacros}
  *
- * @example instruct("Ask user if they are looking to order a pizza");
  *
- * @type {(message: string, options?: OptionsInstruct) => EventMacros}
+ * @type {(instruction: string | Array<string | (OptionsInstruct & {content: string})>, options?: OptionsInstruct) => EventMacros}
  */
 export const instruct = eventMacros.instruct.bind(eventMacros);
 

package/types/index.d.ts

@@ -67,7 +67,17 @@ declare module '@scout9/app' {
    * @example instruct("Ask user if they are looking to order a pizza");
    *
    * */
-  export const instruct: (message: string, options?: OptionsInstruct) => EventMacros;
+  export const instruct: ((instruction: string, options?: OptionsInstruct) => EventMacros) | ((instruction: Array<string | (OptionsInstruct & {content: string})>) => EventMacros);
+
+  /**
+   * If conversation is not stagnant, return instructions to guide next auto reply response, otherwise it will forward the conversation
+   * @param instruction - the instruction to send to the
+   * @example instructSafe("Ask user if they are looking to order a pizza");
+   * @example instructSafe("Ask user if they are looking to order a pizza", {stagnationLimit: 3}); // Allows for 3 stagnate messages before forwarding
+   *
+   * */
+  export const instructSafe: (instruction: string, options?: (OptionsInstruct & OptionsForward & {stagnationLimit?: number})) => EventMacros;
+
   /**
    * Forwards conversation back to you or owner of workflow.
    *
@@ -190,13 +200,18 @@ declare module '@scout9/app' {
 	   * If conversation is not stagnant, return instructions to guide next auto reply response, otherwise it will forward the conversation
 	   * stagnationLimit defaults to 2
 	   */
-	  instructSafe(instruction: string, options?: (OptionsInstruct & OptionsFollowup & {stagnationLimit?: number})): EventMacros;
+	  instructSafe(instruction: string, options?: (OptionsInstruct & OptionsForward & {stagnationLimit?: number})): EventMacros;
 
 	  /**
 	   * Return instructions to guide next auto reply response
 	   */
 	  instruct(instruction: string, options?: OptionsInstruct): EventMacros;
 
+	  /**
+	   * Return instructions to guide next auto reply response
+	   */
+	  instruct(instruction: Array<string | (OptionsInstruct & {content: string})>): EventMacros;
+
 	  /**
 	   * If a manual message must be sent, you can use the `reply` macro
 	   * @param message - the message to manually send to the user

package/types/index.d.ts.map

@@ -7,6 +7,7 @@
 		"sendEvent",
 		"EventResponse",
 		"instruct",
+		"instructSafe",
 		"forward",
 		"reply",
 		"OptionsFollowup",
@@ -149,5 +150,5 @@
 		null,
 		null
 	],
-	"mappings": ";;;;;;;;;kBAegBA,GAAGA;;;;;;;kBAYHC,IAAIA;;;;kBAUJC,SAASA;;;;;;;;;;;eAYZC,aAAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAiDbC,QAAQA;;;;;;;;;;;;;;;;;;;;;;;eAwBRC,OAAOA;;;;;;;;;;;;;;;;;eAkBPC,KAAKA;;;;cAINC,eAAeA;;;;;;;;;cASfC,eAAeA;;;;;;;;;;;;;cAafC,YAAYA;;;;;;;cAOZC,cAAcA;;;;;;;;;;;;;;;;cAgBdC,WAAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAsEPC,GAAGA;;;;;;;kBAUHC,IAAIA;;cAERC,8BAA8BA;;;;;cAK9BC,mBAAmBA;;cAEnBC,eAAeA;cACfC,aAAaA;;;;;;;;;;;;;;;;;;;kBAuBTC,OAAOA;;cAEXC,KAAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqCLC,kBAAkBA;;cAElBC,mBAAmBA;;cAEnBC,MAAMA;;cAENC,cAAcA;;cAEdC,sBAAsBA;;;;;;;;;;;;;;;;cAgBtBC,YAAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkCZC,aAAaA;;cAEbC,QAAQA;;;;;;;;;;;;;;;;;;;;cAoBRC,gBAAgBA;;;;;;;;;cAShBC,sBAAsBA;;;;;;;cAOtBC,UAAUA;;;;;;;;;;cAUVC,mBAAmBA;;;;;;;;cAQnBC,sBAAsBA;;;;;;;;;cAStBC,8BAA8BA;;;;;;;cAO9BC,yBAAyBA;;cAEzBC,gCAAgCA;;;cAGhCC,iBAAiBA;;;;;;;;cAQjBC,WAAWA;;cAEXC,YAAYA;;;;;;;;;cASZC,mBAAmBA;;;;;cAKnBC,wBAAwBA;;cAExBC,QAAQA;;cAERC,OAAOA;;;;;;;cAOPC,mBAAmBA;;;;;;cAMnBC,OAAOA;;;;;;;;;;;;;;;;;;;;cAoBPC,oBAAoBA;;cAEpBC,OAAOA;;cAEPC,qBAAqBA;;cAErBC,QAAQA;;cAERC,qBAAqBA;;;;;;;cAOrBC,mBAAmBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkCnBC,wBAAwBA;;;;;;;;;;;;;;cAcxBC,aAAaA;;;;;;;;;;;;;cAabC,aAAaA;;;;;;cAMbC,kBAAkBA;;;;cAIlBC,UAAUA;;cAEVC,wBAAwBA;;;;;;;;;;;;;;;;;cAiBxBC,oBAAoBA;;;;cAIpBC,gBAAgBA;;cAEhBC,gBAAgBA;;cAEhBC,iCAAiCA;;;;;;;cAOjCC,uBAAuBA;;cAEvBC,kCAAkCA;;;;;;;;;;;;;;;cAelCC,sBAAsBA;;;;;;cAMtBC,WAAWA;;;;;;;;;;;;cAYXC,iBAAiBA;;cAEjBC,aAAaA;;;;;;;;;cASbC,cAAcA;;cAEdC,gBAAgBA;;;;iBC5rBfC,eAAeA;iBAWfC,kBAAkBA;iBAgBlBC,iBAAiBA;iBAkBjBC,sBAAsBA;iBAmBtBC,uBAAuBA;;;;cCzDvBC,UAAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCRVC,mBAAmBA;cAEnBC,cAAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAoBdC,WAAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwBXC,aAAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAEbC,wBAAwBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAIxBC,0BAA0BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAI1BC,yBAAyBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAEzBC,2BAA2BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAE3BC,YAAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAEZC,cAAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCzDdC,mBAAmBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cC+CnBC,yBAAyBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsCzBC,8BAA8BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cC1F9BC,4BAA4BA;;;;;;;;;;;;;;;;;;;;;;cAmC5BC,yBAAyBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAYzBC,+BAA+BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiB/BC,oCAAoCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAYpCC,sCAAsCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cC7EtCC,aAAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCMbC,aAAaA;;;;;;;;;;;;;cAWbC,uBAAuBA;;;;;;;;;;;;;cAYvBnC,iCAAiCA;;;;;;;;;;;;;;;;;;;;cAWjCC,uBAAuBA;;;;;;;;;;;;;;;;;;;cAavBC,kCAAkCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAuBlCkC,iBAAiBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;cASjBC,kBAAkBA;;;;;;;;;;;;;;;;cASlBC,cAAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAUdC,2BAA2BA;;;;;;;;;;cAU3BC,4BAA4BA;;;;;;;;;;cAE5BC,yBAAyBA;;;;;;;;;;;;;cAMzBC,mBAAmBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsBnBC,8BAA8BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiB9BC,0BAA0BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAgB1BC,sBAAsBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAKtBC,sBAAsBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cC5KtBC,iBAAiBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAIjBC,sBAAsBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAEtBC,oBAAoBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAEpBC,qBAAqBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAOrBC,oBAAoBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAOpBC,sBAAsBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAMtBC,uBAAuBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCtCvBlG,mBAAmBA;cAYnBmG,4BAA4BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAU5BC,kBAAkBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCvBlBC,oCAAoCA;;;;;;;;;;cAKpCC,oBAAoBA"
+	"mappings": ";;;;;;;;;kBAegBA,GAAGA;;;;;;;kBAYHC,IAAIA;;;;kBAUJC,SAASA;;;;;;;;;;;eAYZC,aAAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAoDbC,QAAQA;;;;;;;;;eAaRC,YAAYA;;;;;;;;;;;;;;;;;;;;;;;;eAyBZC,OAAOA;;;;;;;;;;;;;;;;;eAkBPC,KAAKA;;;;cAINC,eAAeA;;;;;;;;;cASfC,eAAeA;;;;;;;;;;;;;cAafC,YAAYA;;;;;;;cAOZC,cAAcA;;;;;;;;;;;;;;;;cAgBdC,WAAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA2EPC,GAAGA;;;;;;;kBAUHC,IAAIA;;cAERC,8BAA8BA;;;;;cAK9BC,mBAAmBA;;cAEnBC,eAAeA;cACfC,aAAaA;;;;;;;;;;;;;;;;;;;kBAuBTC,OAAOA;;cAEXC,KAAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqCLC,kBAAkBA;;cAElBC,mBAAmBA;;cAEnBC,MAAMA;;cAENC,cAAcA;;cAEdC,sBAAsBA;;;;;;;;;;;;;;;;cAgBtBC,YAAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkCZC,aAAaA;;cAEbC,QAAQA;;;;;;;;;;;;;;;;;;;;cAoBRC,gBAAgBA;;;;;;;;;cAShBC,sBAAsBA;;;;;;;cAOtBC,UAAUA;;;;;;;;;;cAUVC,mBAAmBA;;;;;;;;cAQnBC,sBAAsBA;;;;;;;;;cAStBC,8BAA8BA;;;;;;;cAO9BC,yBAAyBA;;cAEzBC,gCAAgCA;;;cAGhCC,iBAAiBA;;;;;;;;cAQjBC,WAAWA;;cAEXC,YAAYA;;;;;;;;;cASZC,mBAAmBA;;;;;cAKnBC,wBAAwBA;;cAExBC,QAAQA;;cAERC,OAAOA;;;;;;;cAOPC,mBAAmBA;;;;;;cAMnBC,OAAOA;;;;;;;;;;;;;;;;;;;;cAoBPC,oBAAoBA;;cAEpBC,OAAOA;;cAEPC,qBAAqBA;;cAErBC,QAAQA;;cAERC,qBAAqBA;;;;;;;cAOrBC,mBAAmBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkCnBC,wBAAwBA;;;;;;;;;;;;;;cAcxBC,aAAaA;;;;;;;;;;;;;cAabC,aAAaA;;;;;;cAMbC,kBAAkBA;;;;cAIlBC,UAAUA;;cAEVC,wBAAwBA;;;;;;;;;;;;;;;;;cAiBxBC,oBAAoBA;;;;cAIpBC,gBAAgBA;;cAEhBC,gBAAgBA;;cAEhBC,iCAAiCA;;;;;;;cAOjCC,uBAAuBA;;cAEvBC,kCAAkCA;;;;;;;;;;;;;;;cAelCC,sBAAsBA;;;;;;cAMtBC,WAAWA;;;;;;;;;;;;cAYXC,iBAAiBA;;cAEjBC,aAAaA;;;;;;;;;cASbC,cAAcA;;cAEdC,gBAAgBA;;;;iBCltBfC,eAAeA;iBAWfC,kBAAkBA;iBAgBlBC,iBAAiBA;iBAkBjBC,sBAAsBA;iBAmBtBC,uBAAuBA;;;;cCzDvBC,UAAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCRVC,mBAAmBA;cAEnBC,cAAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAoBdC,WAAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwBXC,aAAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAEbC,wBAAwBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAIxBC,0BAA0BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAI1BC,yBAAyBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAEzBC,2BAA2BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAE3BC,YAAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAEZC,cAAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCzDdC,mBAAmBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cC+CnBC,yBAAyBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsCzBC,8BAA8BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cC1F9BC,4BAA4BA;;;;;;;;;;;;;;;;;;;;;;cAmC5BC,yBAAyBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAYzBC,+BAA+BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiB/BC,oCAAoCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAYpCC,sCAAsCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cC7EtCC,aAAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCMbC,aAAaA;;;;;;;;;;;;;cAWbC,uBAAuBA;;;;;;;;;;;;;cAYvBnC,iCAAiCA;;;;;;;;;;;;;;;;;;;;cAWjCC,uBAAuBA;;;;;;;;;;;;;;;;;;;cAavBC,kCAAkCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAuBlCkC,iBAAiBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;cASjBC,kBAAkBA;;;;;;;;;;;;;;;;cASlBC,cAAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAUdC,2BAA2BA;;;;;;;;;;cAU3BC,4BAA4BA;;;;;;;;;;cAE5BC,yBAAyBA;;;;;;;;;;;;;cAMzBC,mBAAmBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsBnBC,8BAA8BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiB9BC,0BAA0BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAgB1BC,sBAAsBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAKtBC,sBAAsBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cC5KtBC,iBAAiBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAIjBC,sBAAsBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAEtBC,oBAAoBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAEpBC,qBAAqBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAOrBC,oBAAoBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAOpBC,sBAAsBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAMtBC,uBAAuBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCtCvBlG,mBAAmBA;cAYnBmG,4BAA4BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAU5BC,kBAAkBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCvBlBC,oCAAoCA;;;;;;;;;;cAKpCC,oBAAoBA"
 }