starcoder.js/dist/main.js

Web browser version of StarCoder.cpp

var Module = (() => {
  var _scriptDir = import.meta.url;
  
  return (
async function(moduleArg = {}) {

// include: shell.js
// The Module object: Our interface to the outside world. We import
// and export values on it. There are various ways Module can be used:
// 1. Not defined. We create it here
// 2. A function parameter, function(Module) { ..generated code.. }
// 3. pre-run appended it, var Module = {}; ..generated code..
// 4. External script tag defines var Module.
// We need to check if Module already exists (e.g. case 3 above).
// Substitution will be replaced with actual code on later stage of the build,
// this way Closure Compiler will not mangle it (e.g. case 4. above).
// Note that if you want to run closure, and also to use Module
// after the generated code, you will need to define   var Module = {};
// before the code. Then that object will be used in the code, and you
// can continue to use Module afterwards as well.
var Module = moduleArg;

// Set up the promise that indicates the Module is initialized
var readyPromiseResolve, readyPromiseReject;
Module['ready'] = new Promise((resolve, reject) => {
  readyPromiseResolve = resolve;
  readyPromiseReject = reject;
});
["_main","_fflush","onRuntimeInitialized"].forEach((prop) => {
  if (!Object.getOwnPropertyDescriptor(Module['ready'], prop)) {
    Object.defineProperty(Module['ready'], prop, {
      get: () => abort('You are getting ' + prop + ' on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js'),
      set: () => abort('You are setting ' + prop + ' on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js'),
    });
  }
});

// --pre-jses are emitted after the Module integration code, so that they can
// refer to Module (if they choose; they can also define Module)


// Sometimes an existing Module object exists with properties
// meant to overwrite the default module functionality. Here
// we collect those properties and reapply _after_ we configure
// the current environment's defaults to avoid having to be so
// defensive during initialization.
var moduleOverrides = Object.assign({}, Module);

var arguments_ = [];
var thisProgram = './this.program';
var quit_ = (status, toThrow) => {
  throw toThrow;
};

// Determine the runtime environment we are in. You can customize this by
// setting the ENVIRONMENT setting at compile time (see settings.js).

// Attempt to auto-detect the environment
var ENVIRONMENT_IS_WEB = typeof window == 'object';
var ENVIRONMENT_IS_WORKER = typeof importScripts == 'function';
// N.b. Electron.js environment is simultaneously a NODE-environment, but
// also a web environment.
var ENVIRONMENT_IS_NODE = typeof process == 'object' && typeof process.versions == 'object' && typeof process.versions.node == 'string';
var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;

if (Module['ENVIRONMENT']) {
  throw new Error('Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -sENVIRONMENT=web or -sENVIRONMENT=node)');
}

// `/` should be present at the end if `scriptDirectory` is not empty
var scriptDirectory = '';
function locateFile(path) {
  if (Module['locateFile']) {
    return Module['locateFile'](path, scriptDirectory);
  }
  return scriptDirectory + path;
}

// Hooks that are implemented differently in different runtime environments.
var read_,
    readAsync,
    readBinary,
    setWindowTitle;

if (ENVIRONMENT_IS_NODE) {
  if (typeof process == 'undefined' || !process.release || process.release.name !== 'node') throw new Error('not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)');

  var nodeVersion = process.versions.node;
  var numericVersion = nodeVersion.split('.').slice(0, 3);
  numericVersion = (numericVersion[0] * 10000) + (numericVersion[1] * 100) + (numericVersion[2].split('-')[0] * 1);
  var minVersion = 160000;
  if (numericVersion < 160000) {
    throw new Error('This emscripten-generated code requires node v16.0.0 (detected v' + nodeVersion + ')');
  }

  // `require()` is no-op in an ESM module, use `createRequire()` to construct
  // the require()` function.  This is only necessary for multi-environment
  // builds, `-sENVIRONMENT=node` emits a static import declaration instead.
  // TODO: Swap all `require()`'s with `import()`'s?
  const { createRequire } = await import('module');
  /** @suppress{duplicate} */
  var require = createRequire(import.meta.url);
  // These modules will usually be used on Node.js. Load them eagerly to avoid
  // the complexity of lazy-loading.
  var fs = require('fs');
  var nodePath = require('path');

  if (ENVIRONMENT_IS_WORKER) {
    scriptDirectory = nodePath.dirname(scriptDirectory) + '/';
  } else {
    // EXPORT_ES6 + ENVIRONMENT_IS_NODE always requires use of import.meta.url,
    // since there's no way getting the current absolute path of the module when
    // support for that is not available.
    scriptDirectory = require('url').fileURLToPath(new URL('./', import.meta.url)); // includes trailing slash
  }

// include: node_shell_read.js
read_ = (filename, binary) => {
  var ret = tryParseAsDataURI(filename);
  if (ret) {
    return binary ? ret : ret.toString();
  }
  // We need to re-wrap `file://` strings to URLs. Normalizing isn't
  // necessary in that case, the path should already be absolute.
  filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
  return fs.readFileSync(filename, binary ? undefined : 'utf8');
};

readBinary = (filename) => {
  var ret = read_(filename, true);
  if (!ret.buffer) {
    ret = new Uint8Array(ret);
  }
  assert(ret.buffer);
  return ret;
};

readAsync = (filename, onload, onerror, binary = true) => {
  var ret = tryParseAsDataURI(filename);
  if (ret) {
    onload(ret);
  }
  // See the comment in the `read_` function.
  filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
  fs.readFile(filename, binary ? undefined : 'utf8', (err, data) => {
    if (err) onerror(err);
    else onload(binary ? data.buffer : data);
  });
};
// end include: node_shell_read.js
  if (!Module['thisProgram'] && process.argv.length > 1) {
    thisProgram = process.argv[1].replace(/\\/g, '/');
  }

  arguments_ = process.argv.slice(2);

  // MODULARIZE will export the module in the proper place outside, we don't need to export here

  quit_ = (status, toThrow) => {
    process.exitCode = status;
    throw toThrow;
  };

  Module['inspect'] = () => '[Emscripten Module object]';

} else
if (ENVIRONMENT_IS_SHELL) {

  if ((typeof process == 'object' && typeof require === 'function') || typeof window == 'object' || typeof importScripts == 'function') throw new Error('not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)');

  if (typeof read != 'undefined') {
    read_ = (f) => {
      const data = tryParseAsDataURI(f);
      if (data) {
        return intArrayToString(data);
      }
      return read(f);
    };
  }

  readBinary = (f) => {
    let data;
    data = tryParseAsDataURI(f);
    if (data) {
      return data;
    }
    if (typeof readbuffer == 'function') {
      return new Uint8Array(readbuffer(f));
    }
    data = read(f, 'binary');
    assert(typeof data == 'object');
    return data;
  };

  readAsync = (f, onload, onerror) => {
    setTimeout(() => onload(readBinary(f)));
  };

  if (typeof clearTimeout == 'undefined') {
    globalThis.clearTimeout = (id) => {};
  }

  if (typeof setTimeout == 'undefined') {
    // spidermonkey lacks setTimeout but we use it above in readAsync.
    globalThis.setTimeout = (f) => (typeof f == 'function') ? f() : abort();
  }

  if (typeof scriptArgs != 'undefined') {
    arguments_ = scriptArgs;
  } else if (typeof arguments != 'undefined') {
    arguments_ = arguments;
  }

  if (typeof quit == 'function') {
    quit_ = (status, toThrow) => {
      // Unlike node which has process.exitCode, d8 has no such mechanism. So we
      // have no way to set the exit code and then let the program exit with
      // that code when it naturally stops running (say, when all setTimeouts
      // have completed). For that reason, we must call `quit` - the only way to
      // set the exit code - but quit also halts immediately.  To increase
      // consistency with node (and the web) we schedule the actual quit call
      // using a setTimeout to give the current stack and any exception handlers
      // a chance to run.  This enables features such as addOnPostRun (which
      // expected to be able to run code after main returns).
      setTimeout(() => {
        if (!(toThrow instanceof ExitStatus)) {
          let toLog = toThrow;
          if (toThrow && typeof toThrow == 'object' && toThrow.stack) {
            toLog = [toThrow, toThrow.stack];
          }
          err(`exiting due to exception: ${toLog}`);
        }
        quit(status);
      });
      throw toThrow;
    };
  }

  if (typeof print != 'undefined') {
    // Prefer to use print/printErr where they exist, as they usually work better.
    if (typeof console == 'undefined') console = /** @type{!Console} */({});
    console.log = /** @type{!function(this:Console, ...*): undefined} */ (print);
    console.warn = console.error = /** @type{!function(this:Console, ...*): undefined} */ (typeof printErr != 'undefined' ? printErr : print);
  }

} else

// Note that this includes Node.js workers when relevant (pthreads is enabled).
// Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and
// ENVIRONMENT_IS_NODE.
if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
  if (ENVIRONMENT_IS_WORKER) { // Check worker, not web, since window could be polyfilled
    scriptDirectory = self.location.href;
  } else if (typeof document != 'undefined' && document.currentScript) { // web
    scriptDirectory = document.currentScript.src;
  }
  // When MODULARIZE, this JS may be executed later, after document.currentScript
  // is gone, so we saved it, and we use it here instead of any other info.
  if (_scriptDir) {
    scriptDirectory = _scriptDir;
  }
  // blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them.
  // otherwise, slice off the final part of the url to find the script directory.
  // if scriptDirectory does not contain a slash, lastIndexOf will return -1,
  // and scriptDirectory will correctly be replaced with an empty string.
  // If scriptDirectory contains a query (starting with ?) or a fragment (starting with #),
  // they are removed because they could contain a slash.
  if (scriptDirectory.indexOf('blob:') !== 0) {
    scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf('/')+1);
  } else {
    scriptDirectory = '';
  }

  if (!(typeof window == 'object' || typeof importScripts == 'function')) throw new Error('not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)');

  // Differentiate the Web Worker from the Node Worker case, as reading must
  // be done differently.
  {
// include: web_or_worker_shell_read.js
read_ = (url) => {
    try {
      var xhr = new XMLHttpRequest();
      xhr.open('GET', url, false);
      xhr.send(null);
      return xhr.responseText;
    } catch (err) {
      var data = tryParseAsDataURI(url);
      if (data) {
        return intArrayToString(data);
      }
      throw err;
    }
  }

  if (ENVIRONMENT_IS_WORKER) {
    readBinary = (url) => {
      try {
        var xhr = new XMLHttpRequest();
        xhr.open('GET', url, false);
        xhr.responseType = 'arraybuffer';
        xhr.send(null);
        return new Uint8Array(/** @type{!ArrayBuffer} */(xhr.response));
      } catch (err) {
        var data = tryParseAsDataURI(url);
        if (data) {
          return data;
        }
        throw err;
      }
    };
  }

  readAsync = (url, onload, onerror) => {
    var xhr = new XMLHttpRequest();
    xhr.open('GET', url, true);
    xhr.responseType = 'arraybuffer';
    xhr.onload = () => {
      if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0
        onload(xhr.response);
        return;
      }
      var data = tryParseAsDataURI(url);
      if (data) {
        onload(data.buffer);
        return;
      }
      onerror();
    };
    xhr.onerror = onerror;
    xhr.send(null);
  }

// end include: web_or_worker_shell_read.js
  }

  setWindowTitle = (title) => document.title = title;
} else
{
  throw new Error('environment detection error');
}

var out = Module['print'] || console.log.bind(console);
var err = Module['printErr'] || console.error.bind(console);

// Merge back in the overrides
Object.assign(Module, moduleOverrides);
// Free the object hierarchy contained in the overrides, this lets the GC
// reclaim data used e.g. in memoryInitializerRequest, which is a large typed array.
moduleOverrides = null;
checkIncomingModuleAPI();

// Emit code to handle expected values on the Module object. This applies Module.x
// to the proper local x. This has two benefits: first, we only emit it if it is
// expected to arrive, and second, by using a local everywhere else that can be
// minified.

if (Module['arguments']) arguments_ = Module['arguments'];legacyModuleProp('arguments', 'arguments_');

if (Module['thisProgram']) thisProgram = Module['thisProgram'];legacyModuleProp('thisProgram', 'thisProgram');

if (Module['quit']) quit_ = Module['quit'];legacyModuleProp('quit', 'quit_');

// perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message
// Assertions on removed incoming Module JS APIs.
assert(typeof Module['memoryInitializerPrefixURL'] == 'undefined', 'Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead');
assert(typeof Module['pthreadMainPrefixURL'] == 'undefined', 'Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead');
assert(typeof Module['cdInitializerPrefixURL'] == 'undefined', 'Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead');
assert(typeof Module['filePackagePrefixURL'] == 'undefined', 'Module.filePackagePrefixURL option was removed, use Module.locateFile instead');
assert(typeof Module['read'] == 'undefined', 'Module.read option was removed (modify read_ in JS)');
assert(typeof Module['readAsync'] == 'undefined', 'Module.readAsync option was removed (modify readAsync in JS)');
assert(typeof Module['readBinary'] == 'undefined', 'Module.readBinary option was removed (modify readBinary in JS)');
assert(typeof Module['setWindowTitle'] == 'undefined', 'Module.setWindowTitle option was removed (modify setWindowTitle in JS)');
assert(typeof Module['TOTAL_MEMORY'] == 'undefined', 'Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY');
legacyModuleProp('read', 'read_');
legacyModuleProp('readAsync', 'readAsync');
legacyModuleProp('readBinary', 'readBinary');
legacyModuleProp('setWindowTitle', 'setWindowTitle');
var IDBFS = 'IDBFS is no longer included by default; build with -lidbfs.js';
var PROXYFS = 'PROXYFS is no longer included by default; build with -lproxyfs.js';
var WORKERFS = 'WORKERFS is no longer included by default; build with -lworkerfs.js';
var NODEFS = 'NODEFS is no longer included by default; build with -lnodefs.js';

assert(!ENVIRONMENT_IS_SHELL, "shell environment detected but not enabled at build time.  Add 'shell' to `-sENVIRONMENT` to enable.");


// end include: shell.js
// include: preamble.js
// === Preamble library stuff ===

// Documentation for the public APIs defined in this file must be updated in:
//    site/source/docs/api_reference/preamble.js.rst
// A prebuilt local version of the documentation is available at:
//    site/build/text/docs/api_reference/preamble.js.txt
// You can also build docs locally as HTML or other formats in site/
// An online HTML version (which may be of a different version of Emscripten)
//    is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html

var wasmBinary;
if (Module['wasmBinary']) wasmBinary = Module['wasmBinary'];legacyModuleProp('wasmBinary', 'wasmBinary');
var noExitRuntime = Module['noExitRuntime'] || true;legacyModuleProp('noExitRuntime', 'noExitRuntime');

if (typeof WebAssembly != 'object') {
  abort('no native wasm support detected');
}

// Wasm globals

var wasmMemory;

//========================================
// Runtime essentials
//========================================

// whether we are quitting the application. no code should run after this.
// set in exit() and abort()
var ABORT = false;

// set by exit() and abort().  Passed to 'onExit' handler.
// NOTE: This is also used as the process return code code in shell environments
// but only when noExitRuntime is false.
var EXITSTATUS;

/** @type {function(*, string=)} */
function assert(condition, text) {
  if (!condition) {
    abort('Assertion failed' + (text ? ': ' + text : ''));
  }
}

// We used to include malloc/free by default in the past. Show a helpful error in
// builds with assertions.

// Memory management

var HEAP,
/** @type {!Int8Array} */
  HEAP8,
/** @type {!Uint8Array} */
  HEAPU8,
/** @type {!Int16Array} */
  HEAP16,
/** @type {!Uint16Array} */
  HEAPU16,
/** @type {!Int32Array} */
  HEAP32,
/** @type {!Uint32Array} */
  HEAPU32,
/** @type {!Float32Array} */
  HEAPF32,
/* BigInt64Array type is not correctly defined in closure
/** not-@type {!BigInt64Array} */
  HEAP64,
/* BigUInt64Array type is not correctly defined in closure
/** not-t@type {!BigUint64Array} */
  HEAPU64,
/** @type {!Float64Array} */
  HEAPF64;

function updateMemoryViews() {
  var b = wasmMemory.buffer;
  Module['HEAP8'] = HEAP8 = new Int8Array(b);
  Module['HEAP16'] = HEAP16 = new Int16Array(b);
  Module['HEAP32'] = HEAP32 = new Int32Array(b);
  Module['HEAPU8'] = HEAPU8 = new Uint8Array(b);
  Module['HEAPU16'] = HEAPU16 = new Uint16Array(b);
  Module['HEAPU32'] = HEAPU32 = new Uint32Array(b);
  Module['HEAPF32'] = HEAPF32 = new Float32Array(b);
  Module['HEAPF64'] = HEAPF64 = new Float64Array(b);
  Module['HEAP64'] = HEAP64 = new BigInt64Array(b);
  Module['HEAPU64'] = HEAPU64 = new BigUint64Array(b);
}

assert(!Module['STACK_SIZE'], 'STACK_SIZE can no longer be set at runtime.  Use -sSTACK_SIZE at link time')

assert(typeof Int32Array != 'undefined' && typeof Float64Array !== 'undefined' && Int32Array.prototype.subarray != undefined && Int32Array.prototype.set != undefined,
       'JS engine does not provide full typed array support');

// If memory is defined in wasm, the user can't provide it, or set INITIAL_MEMORY
assert(!Module['wasmMemory'], 'Use of `wasmMemory` detected.  Use -sIMPORTED_MEMORY to define wasmMemory externally');
assert(!Module['INITIAL_MEMORY'], 'Detected runtime INITIAL_MEMORY setting.  Use -sIMPORTED_MEMORY to define wasmMemory dynamically');

// include: runtime_init_table.js
// In regular non-RELOCATABLE mode the table is exported
// from the wasm module and this will be assigned once
// the exports are available.
var wasmTable;
// end include: runtime_init_table.js
// include: runtime_stack_check.js
// Initializes the stack cookie. Called at the startup of main and at the startup of each thread in pthreads mode.
function writeStackCookie() {
  var max = _emscripten_stack_get_end();
  assert((max & 3) == 0);
  // If the stack ends at address zero we write our cookies 4 bytes into the
  // stack.  This prevents interference with SAFE_HEAP and ASAN which also
  // monitor writes to address zero.
  if (max == 0) {
    max += 4;
  }
  // The stack grow downwards towards _emscripten_stack_get_end.
  // We write cookies to the final two words in the stack and detect if they are
  // ever overwritten.
  HEAPU32[((max)/2**2)] = 0x02135467;
  HEAPU32[(((max)+(4))/2**2)] = 0x89BACDFE;
  // Also test the global address 0 for integrity.
  HEAPU32[((0)/2**2)] = 1668509029;
}

function checkStackCookie() {
  if (ABORT) return;
  var max = _emscripten_stack_get_end();
  // See writeStackCookie().
  if (max == 0) {
    max += 4;
  }
  var cookie1 = HEAPU32[((max)/2**2)];
  var cookie2 = HEAPU32[(((max)+(4))/2**2)];
  if (cookie1 != 0x02135467 || cookie2 != 0x89BACDFE) {
    abort(`Stack overflow! Stack cookie has been overwritten at ${ptrToString(max)}, expected hex dwords 0x89BACDFE and 0x2135467, but received ${ptrToString(cookie2)} ${ptrToString(cookie1)}`);
  }
  // Also test the global address 0 for integrity.
  if (HEAPU32[((0)/2**2)] != 0x63736d65 /* 'emsc' */) {
    abort('Runtime error: The application has corrupted its heap memory area (address zero)!');
  }
}
// end include: runtime_stack_check.js
// include: runtime_assertions.js
// Endianness check
(function() {
  var h16 = new Int16Array(1);
  var h8 = new Int8Array(h16.buffer);
  h16[0] = 0x6373;
  if (h8[0] !== 0x73 || h8[1] !== 0x63) throw 'Runtime error: expected the system to be little-endian! (Run with -sSUPPORT_BIG_ENDIAN to bypass)';
})();

// end include: runtime_assertions.js
var __ATPRERUN__  = []; // functions called before the runtime is initialized
var __ATINIT__    = []; // functions called during startup
var __ATMAIN__    = []; // functions called when main() is to be run
var __ATEXIT__    = []; // functions called during shutdown
var __ATPOSTRUN__ = []; // functions called after the main() is called

var runtimeInitialized = false;

var runtimeKeepaliveCounter = 0;

function keepRuntimeAlive() {
  return noExitRuntime || runtimeKeepaliveCounter > 0;
}

function preRun() {
  if (Module['preRun']) {
    if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];
    while (Module['preRun'].length) {
      addOnPreRun(Module['preRun'].shift());
    }
  }
  callRuntimeCallbacks(__ATPRERUN__);
}

function initRuntime() {
  assert(!runtimeInitialized);
  runtimeInitialized = true;

  checkStackCookie();

  
if (!Module["noFSInit"] && !FS.init.initialized)
  FS.init();
FS.ignorePermissions = false;

TTY.init();
  callRuntimeCallbacks(__ATINIT__);
}

function preMain() {
  checkStackCookie();
  
  callRuntimeCallbacks(__ATMAIN__);
}

function postRun() {
  checkStackCookie();

  if (Module['postRun']) {
    if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']];
    while (Module['postRun'].length) {
      addOnPostRun(Module['postRun'].shift());
    }
  }

  callRuntimeCallbacks(__ATPOSTRUN__);
}

function addOnPreRun(cb) {
  __ATPRERUN__.unshift(cb);
}

function addOnInit(cb) {
  __ATINIT__.unshift(cb);
}

function addOnPreMain(cb) {
  __ATMAIN__.unshift(cb);
}

function addOnExit(cb) {
}

function addOnPostRun(cb) {
  __ATPOSTRUN__.unshift(cb);
}

// include: runtime_math.js
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul

// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/fround

// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32

// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc

assert(Math.imul, 'This browser does not support Math.imul(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill');
assert(Math.fround, 'This browser does not support Math.fround(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill');
assert(Math.clz32, 'This browser does not support Math.clz32(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill');
assert(Math.trunc, 'This browser does not support Math.trunc(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill');
// end include: runtime_math.js
// A counter of dependencies for calling run(). If we need to
// do asynchronous work before running, increment this and
// decrement it. Incrementing must happen in a place like
// Module.preRun (used by emcc to add file preloading).
// Note that you can add dependencies in preRun, even though
// it happens right before run - run will be postponed until
// the dependencies are met.
var runDependencies = 0;
var runDependencyWatcher = null;
var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled
var runDependencyTracking = {};

function getUniqueRunDependency(id) {
  var orig = id;
  while (1) {
    if (!runDependencyTracking[id]) return id;
    id = orig + Math.random();
  }
}

function addRunDependency(id) {
  runDependencies++;

  if (Module['monitorRunDependencies']) {
    Module['monitorRunDependencies'](runDependencies);
  }

  if (id) {
    assert(!runDependencyTracking[id]);
    runDependencyTracking[id] = 1;
    if (runDependencyWatcher === null && typeof setInterval != 'undefined') {
      // Check for missing dependencies every few seconds
      runDependencyWatcher = setInterval(() => {
        if (ABORT) {
          clearInterval(runDependencyWatcher);
          runDependencyWatcher = null;
          return;
        }
        var shown = false;
        for (var dep in runDependencyTracking) {
          if (!shown) {
            shown = true;
            err('still waiting on run dependencies:');
          }
          err('dependency: ' + dep);
        }
        if (shown) {
          err('(end of list)');
        }
      }, 10000);
    }
  } else {
    err('warning: run dependency added without ID');
  }
}

function removeRunDependency(id) {
  runDependencies--;

  if (Module['monitorRunDependencies']) {
    Module['monitorRunDependencies'](runDependencies);
  }

  if (id) {
    assert(runDependencyTracking[id]);
    delete runDependencyTracking[id];
  } else {
    err('warning: run dependency removed without ID');
  }
  if (runDependencies == 0) {
    if (runDependencyWatcher !== null) {
      clearInterval(runDependencyWatcher);
      runDependencyWatcher = null;
    }
    if (dependenciesFulfilled) {
      var callback = dependenciesFulfilled;
      dependenciesFulfilled = null;
      callback(); // can add another dependenciesFulfilled
    }
  }
}

/** @param {string|number=} what */
function abort(what) {
  if (Module['onAbort']) {
    Module['onAbort'](what);
  }

  what = 'Aborted(' + what + ')';
  // TODO(sbc): Should we remove printing and leave it up to whoever
  // catches the exception?
  err(what);

  ABORT = true;
  EXITSTATUS = 1;

  // Use a wasm runtime error, because a JS error might be seen as a foreign
  // exception, which means we'd run destructors on it. We need the error to
  // simply make the program stop.
  // FIXME This approach does not work in Wasm EH because it currently does not assume
  // all RuntimeErrors are from traps; it decides whether a RuntimeError is from
  // a trap or not based on a hidden field within the object. So at the moment
  // we don't have a way of throwing a wasm trap from JS. TODO Make a JS API that
  // allows this in the wasm spec.

  // Suppress closure compiler warning here. Closure compiler's builtin extern
  // defintion for WebAssembly.RuntimeError claims it takes no arguments even
  // though it can.
  // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure gets fixed.
  /** @suppress {checkTypes} */
  var e = new WebAssembly.RuntimeError(what);

  readyPromiseReject(e);
  // Throw the error whether or not MODULARIZE is set because abort is used
  // in code paths apart from instantiation where an exception is expected
  // to be thrown when abort is called.
  throw e;
}

// include: memoryprofiler.js
// end include: memoryprofiler.js
// include: URIUtils.js
// Prefix of data URIs emitted by SINGLE_FILE and related options.
var dataURIPrefix = 'data:application/octet-stream;base64,';

// Indicates whether filename is a base64 data URI.
function isDataURI(filename) {
  // Prefix of data URIs emitted by SINGLE_FILE and related options.
  return filename.startsWith(dataURIPrefix);
}

// Indicates whether filename is delivered via file protocol (as opposed to http/https)
function isFileURI(filename) {
  return filename.startsWith('file://');
}
// end include: URIUtils.js
/** @param {boolean=} fixedasm */
function createExportWrapper(name, fixedasm) {
  return function() {
    var displayName = name;
    var asm = fixedasm;
    if (!fixedasm) {
      asm = Module['asm'];
    }
    assert(runtimeInitialized, 'native function `' + displayName + '` called before runtime initialization');
    if (!asm[name]) {
      assert(asm[name], 'exported native function `' + displayName + '` not found');
    }
    return asm[name].apply(null, arguments);
  };
}

// include: runtime_exceptions.js
// end include: runtime_exceptions.js
var wasmBinaryFile;
  wasmBinaryFile = 'data:application/octet-stream;base64,AGFzbQEAAAABtoiAgACIAWABfgF/YAJ+fwF/YAF+AGACfn4AYAN+f34AYAR+fn5+AGADfn5+AX5gA35+fwBgBH9+fn4AYAN/fn4AYAN+fn8BfmAGfnx/f39/AX9gA35+fwF/YAh+fn5+fn5+fgF/YAV+fn5+fgF/YAN/fn8AYAZ+fn5+fn4BfmAEfn5+fgF+YAV+fn5/fgF+YAh+fn5+fn5/fwF+YAN+f38Bf2ABfgF+YAAAYAR+fn5/AGAGfn5+fn9/AGAFfn5+f38AYAN+fn4AYAF/AGAAAXxgAAF/YAR/fn9+AX9gA39/fgF/YAR/fn5+AX9gAX8Bf2ACf34Bf2ACfn4Bf2AFfn5+fn4BfmAAAX5gA35+fgF/YAJ+fgF+YAJ+fwBgBn5+fn5+fgBgBn5/f35+fgF/YAF9AX1gAn5/AX5gBX5+fn5+AGACf38Bf2ADf35+AX9gBH5+fn8Bf2AFfn5+fn8Bf2AFfn5+fn8AYAp+fn5+f3x8f31+AX9gBn5+fn5/fwF+YAR+fn9/AGAHfn5+fn5+fwBgA35/fgF+YAR+fn9+AX5gBX5+f35/AX5gA35/fgF/YAV+f35+fwBgBn5+fn5/fwF/YAZ+fn5/f38BfmADfn9/AGAEfn5+fwF+YAl+fn5+fn5+fn4AYAp+fn5+fn5+fn5+AGAFfn5+f38BfmAJfn9+fn9/f35+AX5gA35+fAF8YAJ+fgF8YAN+fHwBfmADfn5+AXxgAX4BfGABfwF9YAF9AX9gAX8BfmAFfn9/fn4BfmAEfn9/fgF+YAR+f35+AX5gBX5/fn5+AX5gA39+fQBgAn59AX5gBn5+f39/fwF+YAR+fn9/AX5gBn5+fn5/fgBgB35+fn5+fn4AYAV+fn5+fQBgBH9+fn0AYAJ9fQF9YAV/f35+fgBgAXwBfWAFfn5/f38Bf2ACfX4Bf2ACf3wBfGABfAF8YAF/AXxgAXwBf2ADfH5+AXxgAXwAYAJ/fQF9YAJ/fgF+YAR+fn5+AX9gA39+fwF+YAJ8fwF9YAJ8fwF8YAJ8fgF8YAd+fn5+fn5+AX9gBH5/fn4AYAV+f39/fwBgAXwBfmACfn0AYAJ+fABgBn5+f39/fwBgB35+f39/f38AYAJ+fgF9YAN/fn4BfmADfn5+AX1gB35+fn5+fn8BfmAKf39+fn5/fn5+fgF/YAx/fn5+fn9/fn5+fn4Bf2AGfn5+f35+AX5gBn5+fn5+fwF+YAV+fn5/fAF+YAZ+fn5/fH4BfmAHfn5+f35+fgF+YAh+fn5+fn5+fgF+YAd+fn5/fn9/AX5gC35+f35/fn5+fn5+AX9gCn9+fn5+fn5+fn4AYAd+fn9+f35+AX5gCn9/fn5+fn5+fn4AYA9+fn5/fn5+f35/f35+fn8AYAZ+fn9+f34BfmAGfn5+f39+AGAIfn5+fn5+fn8Bf2AIfn5+fn5+fn4AAq6EgIAAFANlbnYLX19jeGFfdGhyb3cAGgNlbnYEZXhpdAAbA2VudhVlbXNjcmlwdGVuX21lbWNweV9iaWcAGgNlbnYTZW1zY3JpcHRlbl9kYXRlX25vdwAcA2VudiBfZW1zY3JpcHRlbl9nZXRfbm93X2lzX21vbm90b25pYwAdA2VudhJlbXNjcmlwdGVuX2dldF9ub3cAHANlbnYQX19zeXNjYWxsX29wZW5hdAAeA2VudhFfX3N5c2NhbGxfZmNudGw2NAAfA2Vudg9fX3N5c2NhbGxfaW9jdGwAHxZ3YXNpX3NuYXBzaG90X3ByZXZpZXcxCGZkX3dyaXRlACAWd2FzaV9zbmFwc2hvdF9wcmV2aWV3MQdmZF9yZWFkACAWd2FzaV9zbmFwc2hvdF9wcmV2aWV3MQhmZF9jbG9zZQAhFndhc2lfc25hcHNob3RfcHJldmlldzENZmRfZmRzdGF0X2dldAAiFndhc2lfc25hcHNob3RfcHJldmlldzEHZmRfc2VlawAeA2VudhZlbXNjcmlwdGVuX3Jlc2l6ZV9oZWFwAAADZW52BWFib3J0ABYWd2FzaV9zbmFwc2hvdF9wcmV2aWV3MRFlbnZpcm9uX3NpemVzX2dldAAjFndhc2lfc25hcHNob3RfcHJldmlldzELZW52aXJvbl9nZXQAIwNlbnYKc3RyZnRpbWVfbAAkA2VudhdlbXNjcmlwdGVuX2dldF9oZWFwX21heAAlA92lgIAAySUWJgoAFRUnAxUGJycnFQMnJycaGgAKJxUnFSMjAhUVBgooABUGAgIGJwMCAwMCFRUDAxUVFikVFRUpFRUDABUVFQIVAwMVKRUVFScAFSMnJxUnKhUVJysDFRUVAwMVIhUnLAAnABoaJxUVFScVFRonFScVAhUDBicnIxUVFRUVFRUnKAEKJwICBgYKAxUVFRUVFQYCBicDAgMDAhUaJycVFRUFAgIDAhUDAxUnBgMDFSMnAhUVFRUVFRUnFScGAhUGFRUVFScnFRUVFRUVFQYVFRUnFRUVJxUVFQYCFScnFRUVFQYVFRUnFRUVJhUnAhUDFRUDGhUVFRoVFRUaABoDAwIVFQICAhUVGhUtAxoVFRUDAxUVFScCFRUCAgIVFRoVFS0DGhUVFQMDFRUVFQMVFQMaFRUVGhUVFRUVAxUVAxoVFRUaFRUVFRUVFRUVFQMVFRUVFRUVFRUVFRoDAxUDGhUDFRUVAygdACcnFQIVGhUDBgMVFRUlJwInFRUVFS0nFRUlJhUnFicnFRUVFRUDAgICAwMDJxEDAxUDAycGFRUGFScRFQMCAhUnJxUVFQYFBQUaFS0nJxojFRUVFQYnFgMVAxUAAwYGBi0VBRUVJwYnFRUVFSYmJwoGFS0VAxUVFQMVFSYVIxUjAyMVFSYGJhUnBi0VFRUnJycGFScVFQYVJxUVFQACAhUDFRUDJycGLRUFFRUnBicVFRUVJiYnCgYVLRUVFRUDFRUmFRUVJwYtFRUVJycnBhUVFRUVFQMnJxUDJxEDAxUDAxUGAxUVAgYVGhUGFScRFQMDAgIVFQMVFRUVFScnFRUVBgUFBRoVLScnGiMVFRUVBicWAxUDFQYtFQUVFScGJxUVFRUmJicKBhUtFRUVFQMVFRUVFScGLRUVFScnJwYVFQMVFRUVAycnESMVJxUDFScRAwMVAwMDFQYDFRUVAhUGFRoVBhUCJxEVAwMCAhUaFQMVFRUVFRUVFRUnJycVFRUVLQYFBQUaFS0nJxojFRUVFQYnFgMaFQMDAxUhAAIVAC4hLhUVAQIVISUlBgIVJwMDAwYGJxUGBQUFGhUtJycaFRoFFQYnJwYVGgYnFQYVFRUCAicVJxUCFRoDBgMVFRUVFScVFRUtFRUVFRUVFRUDAgIaAxoDAwYnBhUGEQYFBQUaFS0nJxoVGgUVBicnBhUVGgYnGicRAxUaBhUVJxEVAwIVJxUVFQYFBQUaFS0nJxojFRUVFQYnFgMVAxUVFQUnBgUFGi0nGgUGGgYWBgYVAhUnFRUaFRUVJxUVIxUVIxUKFRUnIxUVFRUaFRUvCQonFRUGFQIFJwMDACEhISEhAxUDAxoAJycVMBUVIxUDAxUVFRUVIxUFJxUjFScVFScVMS4yFQAVFSMDAwMVJyMnJyMVFRUGAjMVBhUDFScGIxonAxUnFRoDIxUnFRUVAwMVFSMVFScDFQYjJxUVFRUnBgIVFQIVEQMVIxUVJxUDAwYRJycDAyMnBgIVFQIVEQMVFQMDJyMDAwYmFScCJwIVAgAVFScCAgICFRUaFRUtAxoVFRUDAxUVFRUnFSYVFQYVFRUGFScVFRUGJxUtJBoVBRUVJwYVJxUVJhUVJgYnFRUnCgYVFRoVFRUVAycVFRUVAxUVFRUVFQMVFRUVJwYaFRUVFRUnJycVFRUVFRUDAxoaAycGAiEsBiMWJxUuFScVJwMVFRUGBgYGBhYjFQYnAxUnFQMGAhUVGgIGJwIWBgYVFQIDBAIDJxUnFScVAxUDAwYVJwYGFQMnFScnJycVAgIVFRUDJxUVAhUnFRoVFRUVFRUVFRUVJxUVAgMVFRUCAhUVAxUGFQYnBgY0KBU1FgIGBgIoFgYZGTYRFhYANzcDODkuFQIDJyEDAxUCAwMnJxUCAzoMJycVAgMAOy4hPBUnJwICFRUnGhUVFQMVFRoAAxYCJxUnFgAVJxUVJwYCFScnFQYaAwInAwIVBgYVFRoVAwMDAhoVFQIaAxUVGhUVAxUtAwIaFRUVFScVFRUGAhUDAxUVFRoVAwMDJycnAicVFRUVBhUVGhUVJxEDFRUaFScnJwYDFQYCAxUnFScnFRUVFRUCFQYVGhUCJxEVAwMCAhUaFRUVFRUVFRUnJxUVFRUtEQMjFRUVAhUnFQIVJxojFQMVFQMVFRUVAxoVAxUGBhUVFRUnAicCAgICFRoVLQMaFRUDAxUVAgIRGgMVBhUVBhUnERUDAhUnFRUVEQMjFRUaFQIVJxoVAhUnGiMVFRUVFRUVAxUDFQMnEQMDFQMDBgMVFQIGFRoVBhUnERUDAwICFQMVFRUVFRUnJxUVFREDIxUVGhUCFScaFQIVJxojFRUVFRUVFQMVAxUDAwMCAwUCFQIDAwUCFScREQMaAhUnGgIaJxERAxoCFScaAhoCAicWBgYRFiwoETc3KBUCHRYoAxUUADg4Nx04ODcBAQEVAgMVAgMVAgMVAgMVAgMVAgMmJiY9AwMVFRUDIwYCBgIVFRUCAwYFFScjAAUVJyMFJyMnABUVJxUVFScVFRUnAicCAgICFRUaFS0DGhUVFQMDFRUVAgICFRUaFS0DGhUVFQMDFRUVFTIGMicaJycGAwMDAxoaGhoCFC4hISERERERJBEaPhEFFhUVBQM/FgMoLAUaAxYaAxoRMjInQBonQQYnJwMnJyYaJycGBhonJwYaJyMVFScjJxUGQgYVAwMGFQYaFScRAxUVGicVAgYVGhUnERUDAwICFRUVFRUVJycVFRURAyMVFRUCFScVAhUnGiMVFRUVFRUVAxUDFRUDAwYGFQYaFScRAxUVGhUCBhUaFScRFQMDAgIVFRUVFRUnJxUVFREDIxUVFQIVJxUCFScaIxUVFRUVFRUDFQMVFQIDFQIDFUMnFScVFRUVHRUGBhUVAxUVFQIDJwMVBAInFRUVAgMVFQMVHRUCAwQVAgMGBjQGBgYGBgYGBgIBJxUCAwYGBgYDAiw8JywVAycnFQA8PCcVAxUCAgMAFScCFQYnFRUCAxUVFRUBAyMVFRUCFQIVFRUGJxUVFRUVAxUVJwMDFREGBhUDFQMDFRUVFQAGFRUVFQMGJxoVGhUaBhUGFRoGFRUVFQMCFRoDBScGFRUVGgUFGhUtJycaBRUGJxoGJxoVJxUVFRUFBQUtBRoGFScnFRUnJxUVAxUDGhUDAwMVFRUCAwMjAxUDAicnAxoDGgMnAwYnAwUFBRoVLScnGhUGJwMnAwYCJwMFAgUFGhUtJycaJxUGJwMDFQMnEQMDFQMVBgMVFQIGFRoVBhUnERUDAwIVFQMVFRUVFRUVJycnFRUVEQMjFRUaFQIVJxoVAhUnGiMVFRUVFRUVAxUDFRUFBRoVLScnGhUaIwAVJxUVFQYnJwYVIwAAJwYDAwYGGhUVJxUVFRUnFQYaFScRAxUVGhUCBhUaFScRFQMDAgIVFRUVFRUnJxUVFREDIxUVGhUCFScaFQIVJxojFRUVFRUVFQMVAxUVJwYCJycGBhEVFScjFRUVFScVJycVFRUCAgIaFS0DGhUVFQMDFRUVFRUGFRoVJxEVAwMCAhUVFRUnJxUVFRURAyMVFRoVAhUVJxoVAhUnGiMVFRUVFRUVAxUDFQYVJwYnAxEaJyYDBRoDFScFFQMDAwMWBgUDAwMDAwYVAxUnFRUVAgICGhUtAxoVFRUDAxUVFRUVBhUaFScRFQMDAgIVFRUVJycVFRUVBhUFBQUaFS0nJxojFRUVFQYnFgMVAxUGGhUnGgYDAwMDAwYVAwYCAycDBQIVAEQjJycGAwICJycRJxEDGgIVJxoCGhUVFScDJwMDFRUVRQYnRhUGJ0dGJCcVJxUnJhUnJycnAwMnBkhISB0dFklKSkkWJRUAFSFLSRUhIRUWSSsrFhUCFScCAkxNN05PDw8PD1BRUScBFSc/IwYAAAA/BgYjCicKJwYjAD8GPwYkERBSBgAAUwoKJwMHAwMVIS4DGgUFLQUFBRoaGhoaGhoaGhoaGhoaBRoaBQUFLRoaGgMDAwUtGgUFGgUFBQUFVFUFLVAJCQlQCAgJCAcHBwcHBwcHCAcHBwcIBwcIBwcIBwgaGhoFBQUFBQUFBS0FBQUaGhoaGhoaGhoaGhoaGgUaGgUFBQUFLQUFBS0tGlYaBQUFBQUFBQUFBVRUVQUtCAlXCAkJCQkJCQkJCQhYCAlZCSZaWltcKwYGNyUVIl1eX19eYGEcYmMrSUkrSgACAgAAXgAKBgYhAGQnJiYhISEiIR0BYmIAAGUjIwACAl9eXl5gSSsrK2Y3JiUWFVghIStfZyMraB0rZQAKLCwVFSsrACdpBhEOahoAawonJ2wmCwNtJmUGIR0dJRY3ASUVFQInJycmAy0XF0UdHQwMDAARFRUVAhUCFQMGGScXABUGJygnAAABBgEnFRUCAgoAFRUAIwAAAAEdBgYVJxUVAgInFRUsFQYVAhUCFQMGGRcAFQYGKCEGAB0AIQEGAScVFQICABUVFSMADBUoFQAAIwAALgEnFRUCAicVFSwVBhUVFRUVFQUaAwMDERUDKCEKSxUAFQAVFQYVFQIGFQMAAA0WAQECDQYnJxkAAxcDAA4OAwICJgYFBQUaFS0nJxoaBRUGJycVBhUVGgYVJycdAAEnJxUVFSgDKBUCAgMnFSIAAAAAAAACFgIVBicGJycVBicGJycBAxUDFQAVFQIVAgMAAQABJycCAwAGAQIDAAABAAENDQIDAA4GASEWAwBuKC0dHS1vZWUtKC0XLSMtGjVwcSxNchEAJiwEJgYjFiYVZABzcyEhISEhIiYmAhUlJSQRJCYlBhUKOAoKchdFGnRHBRUVAg4FBhUCDgUGBhoCBhAVAwN1JycGAwEnFRAQAAYadj8FEBA/EBAwEBAwEBA/EBA/EBAtd3QQEEcQEAUQESVlJxUQFQMDdScBFScAEBAGGnYQEBAQEBAQEBAQEBAtdxAQEBAQEQYAAAMGBgAAAwYGQhJ4NQ4GVXkSeBJ4Enh6ewwVBmUDVRV4fBIVJ0IVFSMVFRUnIxJ4VXkSeBJ4Enh6ewYDVRV4fBIKFQMDAwN9FAAQEBApECkQKTETKSkpKSkpLSkpKSktfRQAEBAVFQAVFRApECkQKTETKSkpKSkpLSkpKSktfhgGAycFfhgGJyQCBQAdHQADAwMDAAMDAAADAwMDAAMDAB0dAAMDFQIDAwADAwAAAwMDAwADAycVAgYVFRV8An8VFQYGFYABBwAGIycnJhoaFRUVFXwGIwYVFQMDAwAAAwMAFQMDAwAAAwMANyMmJxUVJxUVJwMDfH8VFQaAAQcAJwYjFRUnJyYaFXwCBgIVAwMVAxUnIwMVERUDAycDAAADAwAVAwMDAAADAwA3FSMVJicVFScDgQEjggGDAQADAwaEAYEBI4IBgwEVFQADAxUnFQaEAQUFJycGhQEDBoUBAxUnJycCFgMWAxYDFgMWAxYDFgMWAxYDFgMWAxYDFgMWAxYDFgMWAxYDFgMWAxYDFgMWAxYDFgMWAxYDFgMWAxYDBicDAgMDAhUCAwIVGicnJycnJycnJycnJycnJycnJycnJycnJycnJSclJycVJwMVAhUVAgIDAxUjJxYlJRUnFQMVIwIGAwICFScnAh0CDBEREQElBgElBgERFBI4FRUCAQYBBgERFBICDQ0OAAAOACcVAg0QTg0QJA4AZRUADhEAAg2GAQ2GAQ4AAA4xAAINDQ4AAA4AAg2GAQ2GAQ4AAA4xAAINDQ4AAA4AJycVAhUCAAAAAAMDAwMnFQMDAxUWAhUWAicVFgIVFgIVFgIVFgIVAhUCFQIVAhUCFQIVAhUCAxUnAgICAhUVAhUVAhUCAhUCAgICAgICAgICFRUnFQAVGgMDAwIVFScVFScVFRUVFRUaGhUVBgMDAwMDAwMVFQUFGhUtJycaGhUGJycGBQUaFS0nJxoaFQYnJwYnJycGGicmJwMDBQUaJxoaBicFBRonGhoGJxUVFRUVJycGJxUnFQIVGhUDBhUVAxUVFQYVFRUVLRUVFRUnFRUVFRUVFRUDAwICJwMaGhoCAhEDAxUGFRUGFScRFQMCFScVFRUGBQUFGhUtJycaGiMVFRUVBicnFgMVAxUCFQMDAwYVFRUVFRUVFRUnAhUnAicCFQICFQYVFScnOCUlJSUlJTgdHSUlckUaJycnFRUVFScVFRUCAgIsJwAAGiMCAgAnFhUVAgInJwMCLEsVAgMVFSwVFQMDIwMjAwMjAyMDFScVJwAnAYcBFQJVLBoaEQYnBiQHBgYGKAoOJwcGhwEGFQJVCgYaGgYnBgcoDDA/AnJ0dCgoFwYCAgIXISEXISwhLCwsLCwsLCwsLCw3Sx0iIiIAAAIDFSUdFRYVAgICAgIMFSYRFxcXFycXMhcZGBkZGRgYGAAVAhUVAhUVAhUVFRUAAhUVFQIVAgIVFiUlJSUCFSUEh4CAgAABcAHzA/MDBYiAgIAAAQWAgAKAgAIGkoCAgAADfgFCgIAgC34BQgALfgFCAAsH0IKAgAARBm1lbW9yeQIAEV9fd2FzbV9jYWxsX2N0b3JzABQGbWFsbG9jANIZEF9fbWFpbl9hcmdjX2FyZ3YAcgZmZmx1c2gA9BgZX19pbmRpcmVjdF9mdW5jdGlvbl90YWJsZQEABGZyZWUA0xkQX19lcnJub19sb2NhdGlvbgDeGBVlbXNjcmlwdGVuX3N0YWNrX2luaXQA1SUZZW1zY3JpcHRlbl9zdGFja19nZXRfZnJlZQDWJRllbXNjcmlwdGVuX3N0YWNrX2dldF9iYXNlANclGGVtc2NyaXB0ZW5fc3RhY2tfZ2V0X2VuZADYJQlzdGFja1NhdmUA2SUMc3RhY2tSZXN0b3JlANolCnN0YWNrQWxsb2MA2yUcZW1zY3JpcHRlbl9zdGFja19nZXRfY3VycmVudADcJRVfX2N4YV9pc19wb2ludGVyX3R5cGUAviUJ6oeAgAABAEEBC/IDyCW/Jc8HtySwCrIKswq0CrEKtQq2Cs4KzwrQCtUK2AroCuoK6wrpCu8K7grwCpQLlQuWC5sLnAudC6ELogujC6gLqQuqC7AOsQ6/JMMOxA7FDsYOxw7IDskOyg7LDswOzQ7ODs8O0A7RDtIO0w7UDuQO5w7oDoIRgxGEEYURhhGHEZkRmxGcEaARmhGhEaURphGnEa0RrhGvEbARsRGyEbMRwhHDEcQRsRf0F/UX7xf2F/cX+Bf5F/AX+hf8F/0X/hfxF/8XgBiBGPIXghiDGPMXhBj7F/cY+Bj5GPsYrBmtGcMZxBnIGfMY6BnpGesZ7BntGe8Z8BnxGfIZ9hn3GfgZ+Rn6GfwZ/hn9Gf8ZjxqRGpAakhqbGpwanhqfGqAaoRqiGqMapBqpGqsarRquGq8asRqzGrIatBrHGskayBrKGuca7BqDG/ga+xr+GoAb8Br0GvUa5hnnGZkamhoxhBvMAYUbqxusG7obzxvRG9Ib0xvVG9Yb2RvaG9sb3BvdG94b3xvhG+Mb5BvnG+gb6RvrG+wbjhzTGdoe9SD9IO4h8SH1Ifgh+yH+IYAigiKEIoYiiCKKIowijiLjIOYg+SCQIZEhkiGTIZQhlSGWIZchmCGZIfEfpCGlIaghqyGsIa8hsCGyIdsh3CHfIeEh4yHlIekh3SHeIeAh4iHkIeYh6iG2HPgg/yCAIYEhgiGDIYQhhiGHIYkhiiGLIYwhjSGaIZshnCGdIZ4hnyGgIaEhsyG0IbYhuCG5IbohuyG9Ib4hvyHAIcEhwiHDIcQhxSHGIcchySHLIcwhzSHOIdAh0SHSIdMh1CHVIdYh1yHYIbUctxy4HLkcuhy7HLwcvRy+HMMckiLEHNAc2BzbHN4c4RzkHOcc7BzvHPIckyL4HIIdhx2JHYsdjR2PHZEdlR2XHZkdlCKmHacdrh2wHbIdtB29Hb8dlSLCHcsdzx3RHdMd1R3bHd0dliKYIuYd5x3oHekd6x3tHfAd7CHzIfkhhyKLIv8hgyKZIpsi/x2AHoEehx6JHosejh7vIfYh/CGJIo0igSKFIpwinSKbHp8iniKhHqAiqB6rHqwerR6uHq8esB6xHrIeoSKzHrQetR62HrceuB65Hroeux6iIrwevx7AHsEexB7FHsYexx7IHqMiyR7KHssezB7NHs4ezx7QHtEepCLZHu8epSKSH6QfpiLQH9gfpyLZH+YfqCLrH+wf7R+pIu4f7x/wH54knySjJaAkoyS4JNElpCWnJaUlpiWsJb0luiWvJaglvCW5JbAlqSW7JbYlsyXDJcQlxiXHJcAlwSXMJc0lzyXQJdIl0yUKyKe4gADJJREAENUlEO4bEJAcEOEWEM0ZC/uWAbsDB34Bfwh+A38GfgR/B34Hfwh+BH8qfgN/AX4Efwd+AX8BfgZ/BH4BfwF+AX8IfgR/B34Ifwd+An8IfgJ/CH4CfwR+AX8PfgN/B34JfwV+AX8GfgR/Bn4BfwF+AX8BfgF/AX4CfwF+An8BfgV/AX0BfwF9AX4EfQF/AX0DfwR+AX8CfQF+BH0BfwF9A38EfgN/AX0BfwF9AX4EfQF/AX0DfwR+A38CfQF+BH0BfwF9A38EfgN/AX0BfwF9AX4EfQF/AX0DfwR+AX8BfQF/A30BfgR9AX8BfQN/BH4BfwF9AX8DfQF+BH0BfwF9A38EfgF/AX0BfwN9AX4EfQF/AX0DfwR+AX8BfQF/A30BfgR9AX8BfQN/BH4BfwF9Bn8BfQF/An0BfgR9AX8BfQN/BH4BfwF9BH8DfQF+BH0BfwF9A38EfgF/AX0CfwF9AX8CfQF+BH0BfwF9A38EfgF/AX0BfwN9AX4EfQF/AX0DfwR+AX8BfQR/AX0BfwJ9AX4EfQF/AX0DfwR+AX8BfQJ/A30BfgR9AX8BfQN/BH4BfwF9A38BfQF/An0BfgR9AX8BfQN/BH4BfwF9AX8DfQF+BH0BfwF9A38EfgV/An0BfgR9AX8BfQN/BH4FfwJ9AX4EfQF/AX0DfwR+CH8FfgF/K34DfwZ+BH8CfgF/AX4BfwF+AX8BfgJ/AX4CfwF+BH8DfgJ/A34CfwF+AX8EfgJ/AX4BfwR+A38BfgJ/BX4CfwF+An8BfgF/BH4DfwF+An9Tfgh/A34CfwR+An8BfgF/BH4CfwF+AX8EfgJ/AX4BfwR+An8BfgF/BH4DfwF+Bn8FfgZ/AX4BfwR+A38BfgJ/BX4CfwF+AX8EfgN/AX4EfwV+BH8BfgF/BH4FfwF+An8FfgJ/AX4Bfwd+AX8jfgF/I34BfyN+AX8jfgF/I34BfyN+AX8jfgF/I34BfyN+AX8jfgF/I34Bfx5+A38CfgF/AX4BfwF+B38CfgJ/AX4BfwR+An8BfgF/Cn4Bfx1+BH8Cfgp/C34Cfwd+CH8EfgR/BX4Cfxx+AX8DfgJ/Cn4EfxR+An8DfgN/An4CfwN+A38IfgF/An4Dfwx+BH8CfgJ/A34Dfwh+An8IfgV/AX4CfwR+A38GfgN/CH4Cfwt+BH8LfgZ/C34EfwR+AX8CfgF/A34EfwN+A38CfiOAgICAACEDQvAPIQQgAyAEfSEFIAUkgICAgAAgBSAANwPgDyAFIAE3A9gPIAUgAjcD0A8gBSkD4A8hBkKADSEHIAUgB3whCCAIIQlBBCEKIAkgBiAKEJaAgIAAGiAFKQOADSELQmghDCALIAx8IQ0gDSkDACEOQoANIQ8gBSAPfCEQIBAhESARIA58IRIgEhCXgICAACETQQEhFCATIBRxIRUCQAJAIBVFDQBCACEWIBYpA8C0oYCAgICAgAAhFyAFKQPgDyEYIBgQmICAgAAhGSAFIBk3AwhCh4yggICAgICAACEaIAUgGjcDAELepKCAgICAgIAAIRsgFyAbIAUQ/piAgAAaQQAhHEEBIR0gHCAdcSEeIAUgHjoA7w9BASEfIAUgHzYC/AwMAQtCgA0hICAFICB8ISEgISEiQvgMISMgBSAjfCEkICQhJUIEISYgIiAlICYQi5qAgAAaIAUoAvgMISdB7NqduwYhKCAnISkgKCEqICkgKkchK0EBISwgKyAscSEtAkAgLUUNAEIAIS4gLikDwLShgICAgICAACEvIAUpA+APITAgMBCYgICAACExIAUgMTcDGEKHjKCAgICAgIAAITIgBSAyNwMQQoWkoICAgICAgAAhM0IQITQgBSA0fCE1IC8gMyA1EP6YgIAAGkEAITZBASE3IDYgN3EhOCAFIDg6AO8PQQEhOSAFIDk2AvwMDAELIAUpA9gPITogBSA6NwPwDCAFKQPwDCE7QoANITwgBSA8fCE9ID0hPkIEIT8gPiA7ID8Qi5qAgAAaIAUpA/AMIUBCBCFBIEAgQXwhQkKADSFDIAUgQ3whRCBEIUVCBCFGIEUgQiBGEIuagIAAGiAFKQPwDCFHQgghSCBHIEh8IUlCgA0hSiAFIEp8IUsgSyFMQgQhTSBMIEkgTRCLmoCAABogBSkD8AwhTkIMIU8gTiBPfCFQQoANIVEgBSBRfCFSIFIhU0IEIVQgUyBQIFQQi5qAgAAaIAUpA/AMIVVCECFWIFUgVnwhV0KADSFYIAUgWHwhWSBZIVpCBCFbIFogVyBbEIuagIAAGiAFKQPwDCFcQhQhXSBcIF18IV5CgA0hXyAFIF98IWAgYCFhQgQhYiBhIF4gYhCLmoCAABogBSkD8AwhYyBjKAIUIWRB6AchZSBkIGVtIWYgBSBmNgLsDCAFKQPwDCFnIGcoAhQhaEHoByFpIGggaW8haiBnIGo2AhRBACFrIAUgazYC6AxCgA0hbCAFIGx8IW0gbSFuQugMIW8gBSBvfCFwIHAhcUIEIXIgbiBxIHIQi5qAgAAaIAUoAugMIXMgBSkD2A8hdCB0KAIAIXUgcyF2IHUhdyB2IHdHIXhBASF5IHggeXEhegJAIHpFDQBCACF7IHspA8C0oYCAgICAgAAhfCAFKQPgDyF9IH0QmICAgAAhfiAFKALoDCF/IAUpA9gPIYABIIABKAIAIYEBQjQhggEgBSCCAXwhgwEggwEggQE2AgBCMCGEASAFIIQBfCGFASCFASB/NgIAIAUgfjcDKEKHjKCAgICAgIAAIYYBIAUghgE3AyBCuqGggICAgICAACGHAUIgIYgBIAUgiAF8IYkBIHwghwEgiQEQ/piAgAAaQQAhigFBASGLASCKASCLAXEhjAEgBSCMAToA7w9BASGNASAFII0BNgL8DAwBC0LQDCGOASAFII4BfCGPASCPASGQASCQARCZgICAABpCuAwhkQEgBSCRAXwhkgEgkgEhkwFCgAEhlAEgkwEglAEQmoCAgAAaQQAhlQEgBSCVATYCtAwCQANAIAUoArQMIZYBIAUoAugMIZcBIJYBIZgBIJcBIZkBIJgBIJkBSCGaAUEBIZsBIJoBIJsBcSGcASCcAUUNAUKADSGdASAFIJ0BfCGeASCeASGfAUKwDCGgASAFIKABfCGhASChASGiAUIEIaMBIJ8BIKIBIKMBEIuagIAAGiAFKAKwDCGkASCkASGlASClAa0hpgFCuAwhpwEgBSCnAXwhqAEgqAEhqQEgqQEgpgEQm4CAgABCuAwhqgEgBSCqAXwhqwEgqwEhrAEgrAEQnICAgAAhrQEgBSgCsAwhrgEgrgEhrwEgrwGtIbABQoANIbEBIAUgsQF8IbIBILIBIbMBILMBIK0BILABEIuagIAAGkK4DCG0ASAFILQBfCG1ASC1ASG2ASC2ARCcgICAACG3ASAFKAKwDCG4ASC4ASG5ASC5Aa0hugFC0AwhuwEgBSC7AXwhvAEgvAEhvQEgvQEgtwEgugEQnYCAgAAaIAUoArQMIb4BIAUpA9APIb8BQtAMIcABIAUgwAF8IcEBIMEBIcIBIL8BIMIBEJ6AgIAAIcMBIMMBIL4BNgIAIAUpA9APIcQBQhghxQEgxAEgxQF8IcYBQrQMIccBIAUgxwF8IcgBIMgBIckBIMYBIMkBEJ+AgIAAIcoBQtAMIcsBIAUgywF8IcwBIMwBIc0BIMoBIM0BEKCAgIAAGiAFKAK0DCHOAUEBIc8BIM4BIM8BaiHQASAFINABNgK0DAwACwtCuAwh0QEgBSDRAXwh0gEg0gEh0wEg0wEQoYCAgAAaQtAMIdQBIAUg1AF8IdUBINUBIdYBINYBENKkgIAAGiAFKQPYDyHXASDXASgCFCHYASDYARDwloCAACHZASAFINkBNgKsDCAFKAKsDCHaAUENIdsBINoBIdwBINsBId0BINwBIN0BRiHeAUEBId8BIN4BIN8BcSHgAQJAIOABRQ0AQgAh4QEg4QEpA8C0oYCAgICAgAAh4gEgBSkD4A8h4wEg4wEQmICAgAAh5AEgBSkD2A8h5QEg5QEoAhQh5gFC0AAh5wEgBSDnAXwh6AEg6AEg5gE2AgAgBSDkATcDSEKHjKCAgICAgIAAIekBIAUg6QE3A0BCiKGggICAgICAACHqAULAACHrASAFIOsBfCHsASDiASDqASDsARD+mICAABpBACHtAUEBIe4BIO0BIO4BcSHvASAFIO8BOgDvD0EBIfABIAUg8AE2AvwMDAELIAUpA9gPIfEBQugAIfIBIPEBIPIBfCHzASAFIPMBNwOgDEIAIfQBIAUg9AE3A5gMIAUpA9gPIfUBIAUg9QE3A5AMIAUpA5AMIfYBIPYBKAIIIfcBIAUg9wE2AowMIAUpA5AMIfgBIPgBKAIQIfkBIAUg+QE2AogMIAUpA5AMIfoBIPoBKAIEIfsBIAUg+wE2AoQMIAUpA5AMIfwBIPwBKAIAIf0BIAUg/QE2AoAMIAUoAowMIf4BIAUpA5AMIf8BIP8BKAIMIYACIP4BIIACbSGBAiAFIIECNgL8CyAFKQOQDCGCAiCCAigCDCGDAiAFIIMCNgL4CyAFKAL4CyGEAiAFKAL8CyGFAiCEAiCFAmwhhgIgBSCGAjYC9AsgBSgCjAwhhwIghwKyIYgCQQAhiQIgiQIQ7ZaAgAAhigIgBSkDmAwhiwIgiwK1IYwCIIgCIIoClCGNAiCNAiCMApIhjgJDAACAXyGPAiCOAiCPAl0hkAJDAAAAACGRAiCOAiCRAmAhkgIgkAIgkgJxIZMCIJMCRSGUAgJAAkAglAINACCOAq8hlQIglQIhlgIMAQtCACGXAiCXAiGWAgsglgIhmAIgBSCYAjcDmAwgBSgCjAwhmQIgmQKyIZoCIIkCEO2WgIAAIZsCIAUpA5gMIZwCIJwCtSGdAiCaAiCbApQhngIgngIgnQKSIZ8CQwAAgF8hoAIgnwIgoAJdIaECQwAAAAAhogIgnwIgogJgIaMCIKECIKMCcSGkAiCkAkUhpQICQAJAIKUCDQAgnwKvIaYCIKYCIacCDAELQgAhqAIgqAIhpwILIKcCIakCIAUgqQI3A5gMIAUoAoAMIaoCIAUoAowMIasCIKoCIKsCbCGsAiCsArIhrQIgBSgCrAwhrgIgrgIQ7ZaAgAAhrwIgBSkDmAwhsAIgsAK1IbECIK0CIK8ClCGyAiCyAiCxApIhswJDAACAXyG0AiCzAiC0Al0htQJDAAAAACG2AiCzAiC2AmAhtwIgtQIgtwJxIbgCILgCRSG5AgJAAkAguQINACCzAq8hugIgugIhuwIMAQtCACG8AiC8AiG7AgsguwIhvQIgBSC9AjcDmAwgBSgChAwhvgIgBSgCjAwhvwIgvgIgvwJsIcACIMACsiHBAiCJAhDtloCAACHCAiAFKQOYDCHDAiDDArUhxAIgwQIgwgKUIcUCIMUCIMQCkiHGAkMAAIBfIccCIMYCIMcCXSHIAkMAAAAAIckCIMYCIMkCYCHKAiDIAiDKAnEhywIgywJFIcwCAkACQCDMAg0AIMYCryHNAiDNAiHOAgwBC0IAIc8CIM8CIc4CCyDOAiHQAiAFINACNwOYDCAFKAKADCHRAiAFKAKMDCHSAiDRAiDSAmwh0wIg0wKyIdQCIAUoAqwMIdUCINUCEO2WgIAAIdYCIAUpA5gMIdcCINcCtSHYAiDUAiDWApQh2QIg2QIg2AKSIdoCQwAAgF8h2wIg2gIg2wJdIdwCQwAAAAAh3QIg2gIg3QJgId4CINwCIN4CcSHfAiDfAkUh4AICQAJAIOACDQAg2gKvIeECIOECIeICDAELQgAh4wIg4wIh4gILIOICIeQCIAUg5AI3A5gMIAUoAogMIeUCIOUCsiHmAiAFKAKMDCHnAiDnArIh6AIgiQIQ7ZaAgAAh6QIg6AIg6QKUIeoCIAUpA5gMIesCIOsCtSHsAiDmAiDqApQh7QIg7QIg7AKSIe4CQwAAgF8h7wIg7gIg7wJdIfACQwAAAAAh8QIg7gIg8QJgIfICIPACIPICcSHzAiDzAkUh9AICQAJAIPQCDQAg7gKvIfUCIPUCIfYCDAELQgAh9wIg9wIh9gILIPYCIfgCIAUg+AI3A5gMIAUoAogMIfkCIPkCsiH6AiAFKAKMDCH7AiD7ArIh/AIgiQIQ7ZaAgAAh/QIg/AIg/QKUIf4CIAUpA5gMIf8CIP8CtSGAAyD6AiD+ApQhgQMggQMggAOSIYIDQwAAgF8hgwMgggMggwNdIYQDQwAAAAAhhQMgggMghQNgIYYDIIQDIIYDcSGHAyCHA0UhiAMCQAJAIIgDDQAgggOvIYkDIIkDIYoDDAELQgAhiwMgiwMhigMLIIoDIYwDIAUgjAM3A5gMIAUoAogMIY0DII0DsiGOAyAFKAKMDCGPAyCPA7IhkAMgiQIQ7ZaAgAAhkQMgkAMgkQOUIZIDIAUpA5gMIZMDIJMDtSGUAyCOAyCSA5QhlQMglQMglAOSIZYDQwAAgF8hlwMglgMglwNdIZgDQwAAAAAhmQMglgMgmQNgIZoDIJgDIJoDcSGbAyCbA0UhnAMCQAJAIJwDDQAglgOvIZ0DIJ0DIZ4DDAELQgAhnwMgnwMhngMLIJ4DIaADIAUgoAM3A5gMIAUoAogMIaEDIKEDsiGiAyAFKAKMDCGjAyCjA7IhpAMgiQIQ7ZaAgAAhpQMgpAMgpQOUIaYDIAUpA5gMIacDIKcDtSGoAyCiAyCmA5QhqQMgqQMgqAOSIaoDQwAAgF8hqwMgqgMgqwNdIawDQwAAAAAhrQMgqgMgrQNgIa4DIKwDIK4DcSGvAyCvA0UhsAMCQAJAILADDQAgqgOvIbEDILEDIbIDDAELQgAhswMgswMhsgMLILIDIbQDIAUgtAM3A5gMIAUoAogMIbUDILUDsiG2AyAFKAKMDCG3AyAFKAL0CyG4A0EBIbkDILgDILkDdCG6AyC3AyC6A2ohuwMguwMgtwNsIbwDILwDsiG9AyAFKAKsDCG+AyC+AxDtloCAACG/AyC9AyC/A5QhwAMgBSkDmAwhwQMgwQO1IcIDILYDIMADlCHDAyDDAyDCA5IhxANDAACAXyHFAyDEAyDFA10hxgNDAAAAACHHAyDEAyDHA2AhyAMgxgMgyANxIckDIMkDRSHKAwJAAkAgygMNACDEA68hywMgywMhzAMMAQtCACHNAyDNAyHMAwsgzAMhzgMgBSDOAzcDmAwgBSgCiAwhzwMgzwOyIdADIAUoAowMIdEDIAUoAvQLIdIDINIDILkDdCHTAyDRAyDTA2oh1AMg1AOyIdUDIIkCEO2WgIAAIdYDINUDINYDlCHXAyAFKQOYDCHYAyDYA7Uh2QMg0AMg1wOUIdoDINoDINkDkiHbA0MAAIBfIdwDINsDINwDXSHdA0MAAAAAId4DINsDIN4DYCHfAyDdAyDfA3Eh4AMg4ANFIeEDAkACQCDhAw0AINsDryHiAyDiAyHjAwwBC0IAIeQDIOQDIeMDCyDjAyHlAyAFIOUDNwOYDCAFKAKIDCHmAyDmA7Ih5wMgBSgCjAwh6AMg6AMg6ANsIekDIOkDsiHqAyAFKAKsDCHrAyDrAxDtloCAACHsAyDqAyDsA5Qh7QMgBSkDmAwh7gMg7gO1Ie8DIOcDIO0DlCHwAyDwAyDvA5Ih8QNDAACAXyHyAyDxAyDyA10h8wNDAAAAACH0AyDxAyD0A2Ah9QMg8wMg9QNxIfYDIPYDRSH3AwJAAkAg9wMNACDxA68h+AMg+AMh+QMMAQtCACH6AyD6AyH5Awsg+QMh+wMgBSD7AzcDmAwgBSgCiAwh/AMg/AOyIf0DIAUoAowMIf4DIP4DsiH/AyCJAhDtloCAACGABCD/AyCABJQhgQQgBSkDmAwhggQgggS1IYMEIP0DIIEElCGEBCCEBCCDBJIhhQRDAACAXyGGBCCFBCCGBF0hhwRDAAAAACGIBCCFBCCIBGAhiQQghwQgiQRxIYoEIIoERSGLBAJAAkAgiwQNACCFBK8hjAQgjAQhjQQMAQtCACGOBCCOBCGNBAsgjQQhjwQgBSCPBDcDmAwgBSgCiAwhkAQgkASyIZEEIAUoAowMIZIEIJIEIJIEbCGTBEECIZQEIJMEIJQEdCGVBCCVBLIhlgQgBSgCrAwhlwQglwQQ7ZaAgAAhmAQglgQgmASUIZkEIAUpA5gMIZoEIJoEtSGbBCCRBCCZBJQhnAQgnAQgmwSSIZ0EQwAAgF8hngQgnQQgngRdIZ8EQwAAAAAhoAQgnQQgoARgIaEEIJ8EIKEEcSGiBCCiBEUhowQCQAJAIKMEDQAgnQSvIaQEIKQEIaUEDAELQgAhpgQgpgQhpQQLIKUEIacEIAUgpwQ3A5gMIAUoAogMIagEIKgEsiGpBCAFKAKMDCGqBCCqBCCUBHQhqwQgqwSyIawEIIkCEO2WgIAAIa0EIKwEIK0ElCGuBCAFKQOYDCGvBCCvBLUhsAQgqQQgrgSUIbEEILEEILAEkiGyBEMAAIBfIbMEILIEILMEXSG0BEMAAAAAIbUEILIEILUEYCG2BCC0BCC2BHEhtwQgtwRFIbgEAkACQCC4BA0AILIEryG5BCC5BCG6BAwBC0IAIbsEILsEIboECyC6BCG8BCAFILwENwOYDCAFKAKIDCG9BCC9BLIhvgQgBSgCjAwhvwQgvwQgvwRsIcAEIMAEIJQEdCHBBCDBBLIhwgQgBSgCrAwhwwQgwwQQ7ZaAgAAhxAQgwgQgxASUIcUEIAUpA5gMIcYEIMYEtSHHBCC+BCDFBJQhyAQgyAQgxwSSIckEQwAAgF8hygQgyQQgygRdIcsEQwAAAAAhzAQgyQQgzARgIc0EIMsEIM0EcSHOBCDOBEUhzwQCQAJAIM8EDQAgyQSvIdAEINAEIdEEDAELQgAh0gQg0gQh0QQLINEEIdMEIAUg0wQ3A5gMIAUoAogMIdQEINQEsiHVBCAFKAKMDCHWBCDWBLIh1wQgiQIQ7ZaAgAAh2AQg1wQg2ASUIdkEIAUpA5gMIdoEINoEtSHbBCDVBCDZBJQh3AQg3AQg2wSSId0EQwAAgF8h3gQg3QQg3gRdId8EQwAAAAAh4AQg3QQg4ARgIeEEIN8EIOEEcSHiBCDiBEUh4wQCQAJAIOMEDQAg3QSvIeQEIOQEIeUEDAELQgAh5gQg5gQh5QQLIOUEIecEIAUg5wQ3A5gMIAUoAoQMIegEIAUoAogMIekEIOgEIOkEbCHqBCAFKAKMDCHrBCDqBCDrBGwh7AQg7ASyIe0EIIkCEO2WgIAAIe4EIAUpA5gMIe8EIO8EtSHwBCDtBCDuBJQh8QQg8QQg8ASSIfIEQwAAgF8h8wQg8gQg8wRdIfQEQwAAAAAh9QQg8gQg9QRgIfYEIPQEIPYEcSH3BCD3BEUh+AQCQAJAIPgEDQAg8gSvIfkEIPkEIfoEDAELQgAh+wQg+wQh+gQLIPoEIfwEIAUg/AQ3A5gMIAUoAoQMIf0EIAUoAogMIf4EIP0EIP4EbCH/BCAFKAKMDCGABSD/BCCABWwhgQUggQWyIYIFIIkCEO2WgIAAIYMFIAUpA5gMIYQFIIQFtSGFBSCCBSCDBZQhhgUghgUghQWSIYcFQwAAgF8hiAUghwUgiAVdIYkFQwAAAAAhigUghwUgigVgIYsFIIkFIIsFcSGMBSCMBUUhjQUCQAJAII0FDQAghwWvIY4FII4FIY8FDAELQgAhkAUgkAUhjwULII8FIZEFIAUgkQU3A5gMIAUoAogMIZIFQQwhkwUgkgUgkwVsIZQFQQYhlQUglAUglQVqIZYFQQkhlwUglgUglwV0IZgFIJgFIZkFIJkFrCGaBSAFKQOYDCGbBSCbBSCaBXwhnAUgBSCcBTcDmAwgBSkDmAwhnQUgBSCdBTcD2AtCACGeBSAFIJ4FNwPgC0EAIZ8FIAUgnwU6AOgLQhAhoAVCwAshoQUgBSChBXwhogUgogUgoAV8IaMFQtgLIaQFIAUgpAV8IaUFIKUFIKAFfCGmBSCmBSkDACGnBSCjBSCnBTcDAEIIIagFQsALIakFIAUgqQV8IaoFIKoFIKgFfCGrBULYCyGsBSAFIKwFfCGtBSCtBSCoBXwhrgUgrgUpAwAhrwUgqwUgrwU3AwAgBSkD2AshsAUgBSCwBTcDwAtCECGxBULYASGyBSAFI