C语言转WebAssembly

• 官网：https://webassembly.org/
• EMScripten：https://developer.mozilla.org/en-US/docs/WebAssembly/C_to_wasm (注：这里允许C++语言，但必须以C编译，小心掉坑)

C代码

#include 
#include 


const char *str = "hello ";
char *show(char *name){
    int m = strlen(str);
    int n = strlen(name);
    char result[m+n];
    for (int i = 0; i < m; i++) {
        result[i] = str[i];
    }
    for (int j = 0; j < n; j++) {
        result[m+j] = name[j];
    }
    printf("result printf===>%s\n", result);
    char * tmp = result;
    return tmp;
}

C to wasm

emcc helloworld.c -s "EXPORTED_FUNCTIONS=['_show']" -s "EXPORTED_RUNTIME_METHODS=['cwrap','ccall']" -o hello.html

运行一：在浏览器中运行

Module.ccall("show","string",["string"],["zhangsan"]);

注：JS中加载WASM默认开启同源验证，所以需要同服务访问加载。

运行二：在微信小程序/小游戏中运行

编译出来的JS与微信生态语法存在一定不兼容，需要做一定改造适配。

将hello.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 = typeof Module != 'undefined' ? Module : {};

var isWechat = typeof wx == 'object';
WebAssembly = isWechat ? WXWebAssembly : WebAssembly;

// See https://caniuse.com/mdn-javascript_builtins_object_assign

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

// 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' || isWechat;
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, -s ENVIRONMENT=web or -s ENVIRONMENT=node)');
}

// `/` should be present at the end if `scriptDirectory` is not empty
var scriptDirectory = '';

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

// Normally we don't log exceptions but instead let them bubble out the top
// level where the embedding environment (e.g. the browser) can handle
// them.
// However under v8 and node we sometimes exit the process direcly in which case
// its up to use us to log the exception before exiting.
// If we fix https://github.com/emscripten-core/emscripten/issues/15080
// this may no longer be needed under node.
function logExceptionOnExit(e) {
  if (e instanceof ExitStatus) return;
  let toLog = e;
  if (e && typeof e == 'object' && e.stack) {
    toLog = [e, e.stack];
  }
  err('exiting due to exception: ' + toLog);
}

var fs;
var nodePath;
var requireNodeFS;
if (ENVIRONMENT_IS_NODE) {
  if (!(typeof process == 'object' && typeof require == '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 (ENVIRONMENT_IS_WORKER) {
    scriptDirectory = require('path').dirname(scriptDirectory) + '/';
  } else {
    scriptDirectory = __dirname + '/';
  }

// include: node_shell_read.js


requireNodeFS = () => {
  // Use nodePath as the indicator for these not being initialized,
  // since in some environments a global fs may have already been
  // created.
  if (!nodePath) {
    fs = require('fs');
    nodePath = require('path');
  }
};

read_ = function shell_read(filename, binary) {
  requireNodeFS();
  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) => {
  requireNodeFS();
  filename = nodePath['normalize'](filename);
  fs.readFile(filename, function(err, data) {
    if (err) onerror(err);
    else onload(data.buffer);
  });
};

// end include: node_shell_read.js
  if (process['argv'].length > 1) {
    thisProgram = process['argv'][1].replace(/\/g, '/');
  }

  arguments_ = process['argv'].slice(2);

  if (typeof module != 'undefined') {
    module['exports'] = Module;
  }

  process['on']('uncaughtException', function(ex) {
    // suppress ExitStatus exceptions from showing an error
    if (!(ex instanceof ExitStatus)) {
      throw ex;
    }
  });

  // Without this older versions of node (< v15) will log unhandled rejections
  // but return 0, which is not normally the desired behaviour.  This is
  // not be needed with node v15 and about because it is now the default
  // behaviour:
  // See https://nodejs.org/api/cli.html#cli_unhandled_rejections_mode
  process['on']('unhandledRejection', function(reason) { throw reason; });

  quit_ = (status, toThrow) => {
    if (keepRuntimeAlive()) {
      process['exitCode'] = status;
      throw toThrow;
    }
    logExceptionOnExit(toThrow);
    process['exit'](status);
  };

  Module['inspect'] = function () { return '[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_ = function shell_read(f) {
      return read(f);
    };
  }

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

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

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

  if (typeof quit == 'function') {
    quit_ = (status, toThrow) => {
      logExceptionOnExit(toThrow);
      quit(status);
    };
  }

  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;
  }
  // 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' || isWechat)) 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) => {
      var xhr = new XMLHttpRequest();
      xhr.open('GET', url, false);
      xhr.send(null);
      return xhr.responseText;
  }

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

  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;
      }
      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.warn.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';
function alignMemory() { abort('`alignMemory` is now a library function and not included by default; add it to your library.js __deps or to DEFAULT_LIBRARY_FUNCS_TO_INCLUDE on the command line'); }

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




var STACK_ALIGN = 16;
var POINTER_SIZE = 4;

function getNativeTypeSize(type) {
  switch (type) {
    case 'i1': case 'i8': return 1;
    case 'i16': return 2;
    case 'i32': return 4;
    case 'i64': return 8;
    case 'float': return 4;
    case 'double': return 8;
    default: {
      if (type[type.length - 1] === '*') {
        return POINTER_SIZE;
      } else if (type[0] === 'i') {
        const bits = Number(type.substr(1));
        assert(bits % 8 === 0, 'getNativeTypeSize invalid bits ' + bits + ', type ' + type);
        return bits / 8;
      } else {
        return 0;
      }
    }
  }
}

function warnOnce(text) {
  if (!warnOnce.shown) warnOnce.shown = {};
  if (!warnOnce.shown[text]) {
    warnOnce.shown[text] = 1;
    err(text);
  }
}

// include: runtime_functions.js


// Wraps a JS function as a wasm function with a given signature.
function convertJsFunctionToWasm(func, sig) {

  // If the type reflection proposal is available, use the new
  // "WebAssembly.Function" constructor.
  // Otherwise, construct a minimal wasm module importing the JS function and
  // re-exporting it.
  if (typeof WebAssembly.Function == "function") {
    var typeNames = {
      'i': 'i32',
      'j': 'i64',
      'f': 'f32',
      'd': 'f64'
    };
    var type = {
      parameters: [],
      results: sig[0] == 'v' ? [] : [typeNames[sig[0]]]
    };
    for (var i = 1; i < sig.length; ++i) {
      type.parameters.push(typeNames[sig[i]]);
    }
    return new WebAssembly.Function(type, func);
  }

  // The module is static, with the exception of the type section, which is
  // generated based on the signature passed in.
  var typeSection = [
    0x01, // id: section,
    0x00, // length: 0 (placeholder)
    0x01, // count: 1
    0x60, // form: func
  ];
  var sigRet = sig.slice(0, 1);
  var sigParam = sig.slice(1);
  var typeCodes = {
    'i': 0x7f, // i32
    'j': 0x7e, // i64
    'f': 0x7d, // f32
    'd': 0x7c, // f64
  };

  // Parameters, length + signatures
  typeSection.push(sigParam.length);
  for (var i = 0; i < sigParam.length; ++i) {
    typeSection.push(typeCodes[sigParam[i]]);
  }

  // Return values, length + signatures
  // With no multi-return in MVP, either 0 (void) or 1 (anything else)
  if (sigRet == 'v') {
    typeSection.push(0x00);
  } else {
    typeSection = typeSection.concat([0x01, typeCodes[sigRet]]);
  }

  // Write the overall length of the type section back into the section header
  // (excepting the 2 bytes for the section id and length)
  typeSection[1] = typeSection.length - 2;

  // Rest of the module is static
  var bytes = new Uint8Array([
    0x00, 0x61, 0x73, 0x6d, // magic ("0x01asm")
    ,0x00 ,0x00 ,0x00 ,// version: 1 ]
  .concat(,typeSection[ 0x02
    ,0x07 ,// import section // (import "e" "f" (func 0 (type 0)))
      0x01
      ,0x01 ,0x65 ,0x01 ,0x66 ,0x00 ,0x00 ,0x07
    ,0x05 ,// export section // (export "f" (func 0 (type 0)))
      0x01
      ,0x01 ,0x66 ,0x00 ,0x00 ,]
  ));// We can compile this wasm module synchronously because it is very small.

   // This accepts an import (at "e.f"), that it reroutes to an export (at "f")
  var
  = module new . WebAssembly(Module)bytes;var
  = instance new . WebAssembly(Instance,module'e' {
    :'f' {
      :} func
    }
  );var
  = wrappedFunc . instance[exports'f'];return
  ; wrappedFunc}
var

= freeTableIndexes [ ];// Weak map of functions in the table to their indexes, created on first use.

var
; functionsInTableMapfunction

getEmptyTableSlot ()// Reuse a free index if there is one, otherwise grow. {
  if
  ( .freeTableIndexes)lengthreturn {
    . freeTableIndexespop();}
  // Grow the table
  try
  . {
    wasmTablegrow(1);}
  catch ( )errif {
    ( !(instanceoferr RangeError ))throw {
      ; err}
    throw
    'Unable to grow wasm table. Set ALLOW_TABLE_GROWTH.' ;}
  return
  . wasmTable-length 1 ;}
function

updateTableMap (,offset) countfor {
  ( var= i ; offset< i + offset ; count++ i)var {
    = item getWasmTableEntry ()i;// Ignore null values.
    if
    ( )item. {
      functionsInTableMapset(,item) i;}
    }
  }
/**
 * Add a function to the table.
 * 'sig' parameter is required if the function being added is a JS function.
 * @param {string=} sig
 */

function
addFunction (,func) sigassert {
  (typeof!= func 'undefined' );// Check if the function is already in the table, to ensure each function

  // gets a unique index. First, create the map if this is the first use.
  if
  ( !)functionsInTableMap= {
    functionsInTableMap new WeakMap ();updateTableMap
    (0,. wasmTable)length;}
  if
  ( .functionsInTableMaphas()func)return {
    . functionsInTableMapget()func;}
  // It's not in the table, add it now.

  var

  = ret getEmptyTableSlot ();// Set the new value.

  try
  // Attempting to call this with JS function will cause of table.set() to fail {
    setWasmTableEntry
    (,ret) func;}
  catch ( )errif {
    ( !(instanceoferr TypeError ))throw {
      ; err}
    assert
    (typeof!= sig 'undefined' ,'Missing signature argument to addFunction: ' + ) func;var
    = wrapped convertJsFunctionToWasm (,func) sig;setWasmTableEntry
    (,ret) wrapped;}
  .

  functionsInTableMapset(,func) ret;return

  ; ret}
function

removeFunction (index). {
  functionsInTableMapdelete(getWasmTableEntry()index);.
  freeTableIndexespush()index;}
// end include: runtime_functions.js

// include: runtime_debug.js
function


legacyModuleProp (,prop) newNameif {
  ( !.ObjectgetOwnPropertyDescriptor(,Module) prop). {
    ObjectdefineProperty(,Module, propconfigurable {
      :true ,get
      :function ()abort {
        ('Module.'+ + prop ' has been replaced with plain ' + + newName ' (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)' );}
      }
    );}
  }
function

ignoredModuleProp (prop)if {
  ( .ObjectgetOwnPropertyDescriptor(,Module) prop)abort {
    ('`Module.'+ + prop '` was supplied but `' + + prop '` not included in INCOMING_MODULE_JS_API' );}
  }
function

unexportedMessage (,sym) isFSSybolvar {
  = msg "'" + + sym "' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)" ;if
  ( )isFSSybol+= {
    msg '. Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you' ;}
  return
  ; msg}
function

unexportedRuntimeSymbol (,sym) isFSSybolif {
  ( !.ObjectgetOwnPropertyDescriptor(,Module) sym). {
    ObjectdefineProperty(,Module, symconfigurable {
      :true ,get
      :function ()abort {
        (unexportedMessage(,sym) isFSSybol);}
      }
    );}
  }
function

unexportedRuntimeFunction (,sym) isFSSybolif {
  ( !.ObjectgetOwnPropertyDescriptor(,Module) sym)[ {
    Module]sym= ( )abort => (unexportedMessage(,sym) isFSSybol);}
  }
// end include: runtime_debug.js

var
= tempRet0 0 ;var
setTempRet0 = ( value)= => { tempRet0 ; value} ;var
getTempRet0 = ( ); => tempRet0// === 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

; wasmBinaryif
( [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');}
// include: runtime_safe_heap.js

// In MINIMAL_RUNTIME, setValue() and getValue() are only available when building with safe heap enabled, for heap safety checking.


// In traditional runtime, setValue() and getValue() are always available (although their use is highly discouraged due to perf penalties)
/** @param {number} ptr
    @param {number} value
    @param {string} type
    @param {number|boolean=} noSafe */

function
setValue (,ptr, value= type 'i8' ,) noSafeif {
  ( .typecharAt(.type-length1)=== '*' )= type 'i32' ;switch
    ( )typecase {
      'i1' :HEAP8 [(()ptr0>>)]= ; valuebreak ;case
      'i8' :HEAP8 [(()ptr0>>)]= ; valuebreak ;case
      'i16' :HEAP16 [(()ptr1>>)]= ; valuebreak ;case
      'i32' :HEAP32 [(()ptr2>>)]= ; valuebreak ;case
      'i64' :( =tempI64 [ 0value>>>,(=tempDouble,value(+(.Mathabs()tempDouble))1.0 >= ? ( 0.0tempDouble > ? ( (.Mathmin((+(.Mathfloor(()tempDouble/4294967296.0))),4294967295.0 ))|0)0>>>: ( ~~((+(.Mathceil((-tempDouble + (((~~()tempDouble))0>>>))/4294967296.0)))))0>>>): 0 )],HEAP32[(()ptr2>>)]= [ tempI640],HEAP32[((()ptr+(4))2>>)]= [ tempI641]);break ;case
      'float' :HEAPF32 [(()ptr2>>)]= ; valuebreak ;case
      'double' :HEAPF64 [(()ptr3>>)]= ; valuebreak ;default
      :abort ('invalid type for setValue: '+ ) type;}
    }
/** @param {number} ptr
    @param {string} type
    @param {number|boolean=} noSafe */

function
getValue (,ptr= type 'i8' ,) noSafeif {
  ( .typecharAt(.type-length1)=== '*' )= type 'i32' ;switch
    ( )typecase {
      'i1' :return HEAP8 [(()ptr0>>)];case
      'i8' :return HEAP8 [(()ptr0>>)];case
      'i16' :return HEAP16 [(()ptr1>>)];case
      'i32' :return HEAP32 [(()ptr2>>)];case
      'i64' :return HEAP32 [(()ptr2>>)];case
      'float' :return HEAPF32 [(()ptr2>>)];case
      'double' :return Number (HEAPF64[(()ptr3>>)]);default
      :abort ('invalid type for getValue: '+ ) type;}
    return
  null ;}
// end include: runtime_safe_heap.js

// 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) textif {
  ( !)conditionabort {
    ('Assertion failed'+ ( ?text ': ' + : text '' ));}
  }
// Returns the C function with a specified identifier (for C++, you need to do manual name mangling)

function
getCFunc (ident)var {
  = func [ Module'_'+ ] ident;// closure exported function assert
  (,func'Cannot call unknown function ' + + ident ', make sure it is exported' );return
  ; func}
// C calling interface.

/** @param {string|null=} returnType
    @param {Array=} argTypes
    @param {Arguments|Array=} args
    @param {Object=} opts */
function
ccall (,ident, returnType, argTypes, args) opts// For fast lookup of conversion functions {
  var
  = toC 'string' {
    :function (str)var {
      = ret 0 ;if
      ( !==str null && !== str undefined && !== str 0 )// null string { // at most 4 bytes per UTF-8 code point, +1 for the trailing 'var'
        =
        ( len . <<str2length ) +1 ; =stackAlloc
        ret ( );lenstringToUTF8(
        ,,str) ret; len}return
      ;
      } ret,
    'array':
    function( arr)var= {
      stackAlloc ret ( .)arr;lengthwriteArrayToMemory(
      ,)arr; retreturn;
      } ret}
    ;
  functionconvertReturnValue

  ( ret)if( {
    === 'string'returnType ) returnUTF8ToString ( );retif(
    === 'boolean'returnType ) returnBoolean ( );retreturn;
    } retvar
  =

  getCFunc func ( );identvar=
  [ cArgs ] ;var=
  0 stack ; assert(
  !=='array'returnType , 'Return type should not be "array".') ;if(
  ) forargs( {
    var =0 i ; <. i ; args++length) ivar= {
      [ converter [ toC]argTypes]i;if(
      ) ifconverter( {
        === 0stack ) =stackSave stack ( );[]
        cArgs=iconverter ( []args)i;}else
      [ ] {
        cArgs=i[ ] args;i}}
      }
    var
  =
  func ret . apply(null,); cArgsfunctiononDone
  ( ret)if( {
    !== 0stack ) stackRestore( );stackreturnconvertReturnValue
    ( );ret}=
  onDone

  ret ( );retreturn;
  } ret/** @param {string=} returnType
    @param {Array=} argTypes
    @param {Object=} opts */
function

cwrap
( ,,ident, returnType) argTypesreturn optsfunction {
  ( )returnccall {
    ( ,,ident, returnType, argTypes) arguments; opts}}
  // We used to include malloc/free by default in the past. Show a helpful error in
// builds with assertions.

function
_malloc
( )abort( {
  "malloc() called but not included in the build - add '_malloc' to EXPORTED_FUNCTIONS");}function
_free
( )// Show a helpful error since we used to include free by default in the past.abort {
  (
  "free() called but not included in the build - add '_free' to EXPORTED_FUNCTIONS");}// include: runtime_legacy.js
var

ALLOC_NORMAL


= 0 ; // Tries to use _malloc()var ALLOC_STACK
= 1 ; // Lives for the duration of the current function callfunction allocate

/**
 * allocate(): This function is no longer used by emscripten but is kept around to avoid
 *             breaking external users.
 *             You should normally not use allocate(), and instead allocate
 *             memory using _malloc()/stackAlloc(), initialize it with
 *             setValue(), and so forth.
 * @param {(Uint8Array|Array)} slab: An array of data.
 * @param {number=} allocator : How to allocate memory, see ALLOC_*
 */
( ,)slabvar allocator; {
  assert ret(
  typeof=='number' allocator , 'allocate no longer takes a type argument') assert(
  typeof!='number' slab , 'allocate no longer takes a number as arg0') if(

  == ALLOC_STACKallocator ) =stackAlloc {
    ret ( .)slab;length}else
  = abort {
    ret ( 'malloc was not included, but is needed in allocate. Adding "_malloc" to EXPORTED_FUNCTIONS should fix that. This may be a bug in the compiler, please file an issue.');;}if
  (

  ! .&&slab!subarray . )slab=slicenew {
    slab Uint8Array ( );slab}HEAPU8
  .
  set(,)slab; retreturn;
  } ret// end include: runtime_legacy.js
// include: runtime_strings.js

// runtime_strings.js: Strings related runtime functions that are part of both MINIMAL_RUNTIME and regular runtime.
var


=

typeof UTF8Decoder != 'undefined' TextDecoder ? new TextDecoder ( 'utf8'):undefined ; // Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the given array that contains uint8 values, returns// a copy of that string as a Javascript String object.

/**
 * heapOrArray is either a regular array, or a JavaScript typed array view.
 * @param {number} idx
 * @param {number=} maxBytesToRead
 * @return {string}
 */
function
UTF8ArrayToString
( ,,heapOrArray) idxvar maxBytesToRead= {
  + endIdx ; idx var maxBytesToRead=
  ; endPtr // TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself. idx// Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage.
  // (As a tiny code save trick, compare endPtr against endIdx using a negation, so that undefined means Infinity)
  while
  (
  [ ]heapOrArray&&endPtr! ( ))endPtr >= endIdx++; ifendPtr(

  - 16endPtr && idx > . && heapOrArray)buffer return UTF8Decoder. {
    decode UTF8Decoder(.subarrayheapOrArray(,)idx) endPtr;}else
  var = {
    '' str ; // If building with TextDecoder, we have already computed the string length above, so test loop end condition against thatwhile
    (
    < )idx // For UTF8 byte structure, see: endPtr// http://en.wikipedia.org/wiki/UTF-8#Description {
      // https://www.ietf.org/rfc/rfc2279.txt
      // https://tools.ietf.org/html/rfc3629
      var
      =
      [ u0 ++ heapOrArray]idx;if(
      ! (&0x80u0 ) )+=. { str fromCharCode String();u0continue; }var =
      [ u1 ++ heapOrArray]idx&63 ; if(
      ( &0xE0u0 ) ==0xC0 ) +=. { str fromCharCode String(((&31u0 ) <<6 ) |) ; u1continue; }var =
      [ u2 ++ heapOrArray]idx&63 ; if(
      ( &0xF0u0 ) ==0xE0 ) =( {
        u0 ( &15u0 ) <<12 ) |( << 6u1 ) |; } u2else
      if ( {
        ( &0xF8u0 ) !=0xF0 ) warnOnce( 'Invalid UTF-8 leading byte 0x'+. toString u0(16)+' encountered when deserializing a UTF-8 string in wasm memory to a JS string!' ) ;=(
        u0 ( &7u0 ) <<18 ) |( << 12u1 ) |( << 6u2 ) |( [ ++heapOrArray]idx&63 ) ;}if
      (

      < 0x10000u0 ) +=. {
        str fromCharCode String();u0}else
      var = {
        - ch 0x10000 u0 ; +=.
        str fromCharCode String(0xD800|( 10 )ch >> ,0xDC00| ( & 0x3FFch ) );}}
      }
    return
  ;
  } str// Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the emscripten HEAP, returns a
// copy of that string as a Javascript String object.

// maxBytesToRead: an optional length that specifies the maximum number of bytes to read. You can omit
//                 this parameter to scan the string until the first //                 passed, and the string at [ptr, ptr+maxBytesToReadr[ contains a null byte in the byte. If maxBytesToRead is
//                 middle, then the string will cut short at that byte index (i.e. maxBytesToRead will
//                 not produce a string of exact length [ptr, ptr+maxBytesToRead[)
//                 N.B. mixing frequent uses of UTF8ToString() with and without maxBytesToRead may
//                 throw JS JIT optimizations off, so it is worth to consider consistently using one
//                 style or the other.
/**
 * @param {number} ptr
 * @param {number=} maxBytesToRead
 * @return {string}
 */
function
UTF8ToString
(
, );ptrreturn maxBytesToRead? {
  UTF8ArrayToString
  ( ptr HEAPU8 ,,): ptr'' maxBytesToRead; } // Copies the given Javascript String object 'str' to the given byte array at address 'outIdx',// encoded in UTF8 form and null-terminated. The copy will require at most str.length*4+1 bytes of space in the HEAP.
// Use the function lengthBytesUTF8 to compute the exact number of bytes (excluding null terminator) that this function will write.

// Parameters:
//   str: the Javascript string to copy.
//   heap: the array to copy to. Each index in this array is assumed to be one 8-byte element.
//   outIdx: The starting offset in the array to begin the copying.
//   maxBytesToWrite: The maximum number of bytes this function can write to the array.
//                    This count should include the null terminator,
//                    i.e. if maxBytesToWrite=1, only the null terminator will be written and nothing else.
//                    maxBytesToWrite=0 does not write any bytes to the output, not even the null terminator.
// Returns the number of bytes written, EXCLUDING the null terminator.
function
stringToUTF8Array
(

, ,,str) heapif outIdx( maxBytesToWrite! {
  ( 0))maxBytesToWrite > // Parameter maxBytesToWrite is not optional. Negative values, 0, null, undefined and false each don't write out any bytes.return0 ;
    var =;

  var startIdx = outIdx+
  - endIdx 1 outIdx ; maxBytesToWrite // -1 for string null terminator. for( var
  = 0; i < .; i ++ str)length// See http://unicode.org/faq/utf_bom.html#utf16-3 // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description and https://www.ietf.org/rfc/rfc2279.txt and https://tools.ietf.org/html/rfc3629ivar {
    // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! So decode UTF16->UTF32->UTF8.
    =
    .
    charCodeAt u ( str);// possibly a lead surrogateiif( 0xD800
    && <=u >= 0xDFFF ) u var =. {
      charCodeAt u1 ( str++);=i0x10000+
      u ( ( & 0x3FF)u << 10) | (& 0x3FF )u1 ; }if(
    <=
    0x7F )u if () {
      break ;outIdx >= endIdx[ ++]
      heap=outIdx;} else uif
    ( <= 0x7FF )u if (+ {
      1 )outIdx break ; >= endIdx[ ++]
      heap=outIdx0xC0| ( 6 ) ;u >> [++]
      heap=outIdx0x80| ( & 63 )u ; }elseif
    ( <= 0xFFFF )u if (+ {
      2 )outIdx break ; >= endIdx[ ++]
      heap=outIdx0xE0| ( 12 ) ;u >> [++]
      heap=outIdx0x80| ( ( 6 )&u >> 63) ; [++]
      heap=outIdx0x80| ( & 63 )u ; }elseif
    ( + {
      3 )outIdx break ; >= endIdxif (0x10FFFF
      ) warnOnceu > ('Invalid Unicode code point 0x' +.toString ( u16)+' encountered when serializing a JS string to a UTF-8 string in wasm memory! (Valid unicode code points should be in range 0-0x10FFFF).') ; [++]
      heap=outIdx0xF0| ( 18 ) ;u >> [++]
      heap=outIdx0x80| ( ( 12 )&u >> 63) ; [++]
      heap=outIdx0x80| ( ( 6 )&u >> 63) ; [++]
      heap=outIdx0x80| ( & 63 )u ; }}// Null-terminate the pointer to the buffer.
    [
  ]
  =
  heap0outIdx; return -;
  } outIdx // Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', startIdx// null-terminated and encoded in UTF8 form. The copy will require at most str.length*4+1 bytes of space in the HEAP.
// Use the function lengthBytesUTF8 to compute the exact number of bytes (excluding null terminator) that this function will write.

// Returns the number of bytes written, EXCLUDING the null terminator.
function
stringToUTF8
(

, ,)strassert outPtr( maxBytesToWritetypeof {
  =='number', maxBytesToWrite 'stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!' ); returnstringToUTF8Array(
  , HEAPU8,str, );outPtr} maxBytesToWrite// Returns the number of bytes the given Javascript string takes if encoded as a UTF8 byte array, EXCLUDING the null terminator byte.function
lengthBytesUTF8

(
str )var=0 {
  ; len for (var
  = 0; i < .; i ++ str)length// See http://unicode.org/faq/utf_bom.html#utf16-3 vari= {
    // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! So decode UTF16->UTF32->UTF8.
    .
    charCodeAt u ( str);// possibly a lead surrogateiif( 0xD800
    && <=u >= 0xDFFF ) u = 0x10000+ u ( ( & 0x3FF)u << 10) | (. charCodeAt (str++)&0x3FFi) ; if(<=
    0x7F )u ++ ;else iflen(
    <= 0x7FF )u += 2; len else if(
    <= 0xFFFF )u += 3; len else +=4
    ; len } return;
  }
  // end include: runtime_strings.js len// include: runtime_strings_extra.js
// runtime_strings_extra.js: Strings related runtime functions that are available only in regular runtime.

// Given a pointer 'ptr' to a null-terminated ASCII-encoded string in the emscripten HEAP, returns
// a copy of that string as a Javascript String object.


function

AsciiToString
(

ptr )var='' {
  ; str while (1
  ) var=HEAPU8 {
    [ ch ( (++)0ptr)]>>;if(!
    ) return;ch+= . strfromCharCode
    str ( String);}ch}// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
  // null-terminated and encoded in ASCII form. The copy will require at most str.length+1 bytes of space in the HEAP.
function

stringToAscii
(

, )returnstrwriteAsciiToMemory outPtr( {
  , ,falsestr) outPtr; }// Given a pointer 'ptr' to a null-terminated UTF16LE-encoded string in the emscripten HEAP, returns// a copy of that string as a Javascript String object.
var

=
typeof

!= UTF16Decoder 'undefined' ? TextDecoder new TextDecoder ( 'utf-16le' ):undefined; function UTF16ToString(

, )assertptr( maxBytesToRead% {
  2==ptr 0 , 'Pointer passed to UTF16ToString must be aligned to two bytes!' ); var=;
  // TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself. endPtr // Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage. ptrvar
  =
  1
  ; idx var endPtr >> =+
  / maxIdx 2 idx ; maxBytesToRead // If maxBytesToRead is not passed explicitly, it will be undefined, and this // will always evaluate to true. This saves on code size.while
  (
  !
  ( )&&HEAPU16idx >= maxIdx[ ] )++idx;= <<idx1
  endPtr ; idx if (-

  32 &&endPtr ) ptr > return . UTF16Decoderdecode {
    ( UTF16DecoderHEAPU8.subarray(,))ptr; endPtr}elsevar
  = '' {
    ; str // If maxBytesToRead is not passed explicitly, it will be undefined, and the for-loop's condition // will always evaluate to true. The loop is then terminated on the first null char.for

    (
    var
    = 0; i ! (/ 2)i >= maxBytesToRead ; ++)var =iHEAP16 {
      [ codeUnit ( (()+(ptr*2)i)1)]>>;if(==
      0 )codeUnit break ;// fromCharCode constructs a character from a UTF-16 code unit, so we can pass the UTF16 string right through. +=.
      fromCharCode
      str ( String);}codeUnitreturn;
    }

    } str// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
  // null-terminated and encoded in UTF16 form. The copy will require at most str.length*4+2 bytes of space in the HEAP.
// Use the function lengthBytesUTF16() to compute the exact number of bytes (excluding null terminator) that this function will write.

// Parameters:
//   str: the Javascript string to copy.
//   outPtr: Byte address in Emscripten HEAP where to write the string to.
//   maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null
//                    terminator, i.e. if maxBytesToWrite=2, only the null terminator will be written and nothing else.
//                    maxBytesToWrite<2 does not write any bytes to the output, not even the null terminator.
// Returns the number of bytes written, EXCLUDING the null terminator.
function
stringToUTF16
(

, ,)strassert outPtr( maxBytesToWrite% {
  2==outPtr 0 , 'Pointer passed to stringToUTF16 must be aligned to two bytes!' ); assert(typeof
  =='number', maxBytesToWrite 'stringToUTF16(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!' ); // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed.if(
  ===
  undefined )maxBytesToWrite = 0x7FFFFFFF; {
    maxBytesToWrite } if(
  <
  2 )maxBytesToWrite return 0; -= 2;
  maxBytesToWrite // Null terminator. var= ;
  var startPtr = outPtr(
  < numCharsToWrite . *maxBytesToWrite 2 str)length?(/ 2 )maxBytesToWrite : .; for str(lengthvar
  = 0; i < ;++ i ) numCharsToWrite// charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP. vari= {
    .
    charCodeAt codeUnit ( str);// possibly a lead surrogateiHEAP16[ (
    ()1)outPtr]>>=;+= 2 codeUnit;
    outPtr } // Null-terminate the pointer to the HEAP.HEAP16
  [
  (
  ()1)outPtr]>>=0; return -;
  } outPtr // Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte. startPtrfunction
lengthBytesUTF16

(

str )return.* {
  2 str;length}functionUTF32ToString
(

, )assertptr( maxBytesToRead% {
  4==ptr 0 , 'Pointer passed to UTF32ToString must be aligned to four bytes!' ); var=0
  ; i var =''

  ; str // If maxBytesToRead is not passed explicitly, it will be undefined, and this // will always evaluate to true. This saves on code size.while
  (
  !
  ( /4)i >= maxBytesToRead ) var=HEAP32 {
    [ utf32 ( (()+(ptr*4)i)2)]>>;if(==
    0 )utf32 break ;++ ;// Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing.
    // See http://unicode.org/faq/utf_bom.html#utf16-3iif
    (
    0x10000
    ) varutf32 >= =- {
      0x10000 ch ; utf32 += .fromCharCode
      str ( String0xD800|(10 ) ,ch >> 0xDC00|( & 0x3FF )ch ) ;}else+=
    . fromCharCode {
      str ( String);}utf32}return
    ;
  }
  // Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', str// null-terminated and encoded in UTF32 form. The copy will require at most str.length*4+4 bytes of space in the HEAP.
// Use the function lengthBytesUTF32() to compute the exact number of bytes (excluding null terminator) that this function will write.

// Parameters:
//   str: the Javascript string to copy.
//   outPtr: Byte address in Emscripten HEAP where to write the string to.
//   maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null
//                    terminator, i.e. if maxBytesToWrite=4, only the null terminator will be written and nothing else.
//                    maxBytesToWrite<4 does not write any bytes to the output, not even the null terminator.
// Returns the number of bytes written, EXCLUDING the null terminator.
function
stringToUTF32
(

, ,)strassert outPtr( maxBytesToWrite% {
  4==outPtr 0 , 'Pointer passed to stringToUTF32 must be aligned to four bytes!' ); assert(typeof
  =='number', maxBytesToWrite 'stringToUTF32(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!' ); // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed.if(
  ===
  undefined )maxBytesToWrite = 0x7FFFFFFF; {
    maxBytesToWrite } if(
  <
  4 )maxBytesToWrite return 0; var =;
  var startPtr = outPtr+
  - endPtr 4 startPtr ; maxBytesToWrite for (var
  = 0; i < .; i ++ str)length// Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap. // See http://unicode.org/faq/utf_bom.html#utf16-3ivar {
    =
    .
    charCodeAt codeUnit ( str);// possibly a lead surrogateiif( 0xD800
    && <=codeUnit >= 0xDFFF ) codeUnit var =. {
      charCodeAt trailSurrogate ( str++);=i0x10000+
      codeUnit ( ( & 0x3FF)codeUnit << 10) | (& 0x3FF )trailSurrogate ; }HEAP32[
    (
    ()2)outPtr]>>=;+= 4 codeUnit;
    outPtr if (+
    4 )outPtr break ; > endPtr} // Null-terminate the pointer to the HEAP.HEAP32
  [
  (
  ()2)outPtr]>>=0; return -;
  } outPtr // Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte. startPtrfunction
lengthBytesUTF32

(

str )var=0 {
  ; len for (var
  = 0; i < .; i ++ str)length// Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap. // See http://unicode.org/faq/utf_bom.html#utf16-3ivar {
    =
    .
    charCodeAt codeUnit ( str);ifi(0xD800
    && <=codeUnit >= 0xDFFF ) codeUnit ++ ;// possibly a lead surrogate, so skip over the tail surrogate. +=i4 ;
    len } return;
  }

  // Allocate heap space for a JS string, and write it there. len// It is the responsibility of the caller to free() that memory.
function

allocateUTF8
(
str )var=lengthBytesUTF8 {
  ( size ) +1str; var =abort
  ( ret 'malloc was not included, but is needed in allocateUTF8. Adding "_malloc" to EXPORTED_FUNCTIONS should fix that. This may be a bug in the compiler, please file an issue.' );;if()
  stringToUTF8Array (ret, HEAP8,str, ); retreturn size;}
  // Allocate stack space for a JS string, and write it there. retfunction
allocateUTF8OnStack

(
str )var=lengthBytesUTF8 {
  ( size ) +1str; var =stackAlloc
  ( ret ) ;stringToUTF8Arraysize(,
  HEAP8,str, ); retreturn size;}
  // Deprecated: This function should not be called because it is unsafe and does not provide ret// a maximum length limit of how many bytes it is allowed to write. Prefer calling the
// function stringToUTF8Array() instead, which takes in a maximum length that can be used

// to be secure from out of bounds writes.
/** @deprecated
    @param {boolean=} dontAddNull */
function
writeStringToMemory
(
, ,)stringwarnOnce buffer( dontAddNull'writeStringToMemory is deprecated and should not be called! Use stringToUTF8() instead!' {
  );var/** @type {number} */,

  /** @type {number} */ ; lastCharif ( end)
  // stringToUTF8Array always appends null. If we don't want to do that, remember the // character that existed at the location where the null will be placed, and restoredontAddNull// that after the write (below). {
    =
    +
    lengthBytesUTF8
    end ( buffer ) ;=stringHEAP8[
    lastChar ] ;}endstringToUTF8(
  ,
  ,Infinitystring) buffer; if()
  HEAP8 [dontAddNull] =;end// Restore the value under the null character. } lastCharfunction writeArrayToMemory
(

, )assertarray( buffer. {
  0,array'writeArrayToMemory array must have a length (should be an array or typed array)'length >= )HEAP8 .set
  (,);array} buffer/** @param {boolean=} dontAddNull */function
writeAsciiToMemory

(
, ,)strfor buffer( dontAddNullvar {
  = 0; i < .; i ++ str)lengthassert (i. {
    charCodeAt(str)===(i. charCodeAt (str)&0xffi) ) ;HEAP8[(
    (++)0buffer)]>>=.charCodeAt ( str);}i// Null-terminate the pointer to the HEAP.if
  (
  !
  ) HEAP8[dontAddNull( ()0)buffer]>>=0; } // end include: runtime_strings_extra.js// Memory management
var

HEAP
,

/** @type {!ArrayBuffer} */ ,/** @type {!Int8Array} */
HEAP8
  buffer,
/** @type {!Uint8Array} */
  HEAPU8,
/** @type {!Int16Array} */
  HEAP16,
/** @type {!Uint16Array} */
  HEAPU16,
/** @type {!Int32Array} */
  HEAP32,
/** @type {!Uint32Array} */
  HEAPU32,
/** @type {!Float32Array} */
  HEAPF32,
/** @type {!Float64Array} */
  HEAPF64;
function
  updateGlobalBufferAndViews(

buf )=;[ {
  buffer 'HEAP8' buf]
  Module=HEAP8= new Int8Array ( ) ;[buf'HEAP16']
  Module=HEAP16= new Int16Array ( ) ;[buf'HEAP32']
  Module=HEAP32= new Int32Array ( ) ;[buf'HEAPU8']
  Module=HEAPU8= new Uint8Array ( ) ;[buf'HEAPU16']
  Module=HEAPU16= new Uint16Array ( ) ;[buf'HEAPU32']
  Module=HEAPU32= new Uint32Array ( ) ;[buf'HEAPF32']
  Module=HEAPF32= new Float32Array ( ) ;[buf'HEAPF64']
  Module=HEAPF64= new Float64Array ( ) ;}bufvarTOTAL_STACK
=

5242880 ; if ([
'TOTAL_STACK' ]Module)assert(TOTAL_STACK ===['TOTAL_STACK' ] Module,'the stack size can no longer be determined at runtime')var INITIAL_MEMORY=

[ 'INITIAL_MEMORY' ] Module||16777216; legacyModuleProp ('INITIAL_MEMORY','INITIAL_MEMORY'); assert(INITIAL_MEMORY

TOTAL_STACK,'INITIAL_MEMORY should be larger than TOTAL_STACK, was ' >= +INITIAL_MEMORY + '! (TOTAL_STACK=' + TOTAL_STACK + ')' ) ; // check for full engine support (use string 'subarray' to avoid closure compiler confusion)assert(

typeof
!='undefined'&& Int32Array typeof !== 'undefined' && Float64Array Int32Array . . !=undefinedprototype&&subarray Int32Array . . !=undefinedprototype,set 'JS engine does not provide full typed array support' );
       // If memory is defined in wasm, the user can't provide it.assert(

!
['wasmMemory']Module,'Use of `wasmMemory` detected.  Use -s IMPORTED_MEMORY to define wasmMemory externally'); assert(INITIAL_MEMORY
==16777216, 'Detected runtime INITIAL_MEMORY setting.  Use -s IMPORTED_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
;
// end include: runtime_init_table.js
// include: runtime_stack_check.js wasmTable// Initializes the stack cookie. Called at the startup of main and at the startup of each thread in pthreads mode.

function
writeStackCookie


(
) var=_emscripten_stack_get_end {
  ( max ) ;assert((
  &3)max == 0) ; // 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.
  HEAP32
  [
  (
  ()2)max]>>=0x2135467; HEAP32 [(
  (()+(max4))2)]>>=0x89BACDFE; // Also test the global address 0 for integrity. HEAP32[
  0
  ]=0x63736d65; /* 'emsc' */ }function checkStackCookie
(

) if(ABORT {
  ) return;var =_emscripten_stack_get_end
  ( max ) ;var=HEAPU32
  [ cookie1 ( ()2)max]>>;var=HEAPU32
  [ cookie2 ( (()+(max4))2)]>>;if(!=
  0x2135467 ||cookie1 != 0x89BACDFE ) cookie2 abort ('Stack overflow! Stack cookie has been overwritten, expected hex dwords 0x89BACDFE and 0x2135467, but received 0x' {
    +.toString ( cookie216)+' 0x'+ . toString ( cookie116));}// Also test the global address 0 for integrity.if
  (
  HEAP32
  [ 0]!==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=new {
  Int16Array h16 ( 1 );var=new
  Int8Array h8 ( . );h16[buffer0]
  h16=0x6373; if ([
  0 ]h8!==0x73|| [ 1 ] h8!==0x63) throw 'Runtime error: expected the system to be little-endian! (Run with -s SUPPORT_BIG_ENDIAN=1 to bypass)'; } )(
);// end include: runtime_assertions.jsvar=

[
] __ATPRERUN__  ; // functions called before the runtime is initializedvar= [
] __ATINIT__    ; // functions called during startupvar= [
] __ATEXIT__    ; // functions called during shutdownvar= [
] __ATPOSTRUN__ ; // functions called after the main() is calledvar= false

; runtimeInitialized function keepRuntimeAlive(

) return;} {
  function noExitRuntimepreRun
(

) if([ {

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

  ;}__ATPRERUN__functioninitRuntime
(

) checkStackCookie() {
  ;assert(!
  );=runtimeInitializedtrue;
  runtimeInitialized callRuntimeCallbacks ()

  
  ;}__ATINIT__functionpostRun
(

) checkStackCookie() {
  ;if([

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

  ;}__ATPOSTRUN__functionaddOnPreRun
(

cb ).unshift( {
  __ATPRERUN__);}cbfunctionaddOnInit
(

cb ).unshift( {
  __ATINIT__);}cbfunctionaddOnExit
(

cb )}functionaddOnPostRun {
(

cb ).unshift( {
  __ATPOSTRUN__);}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

(

.

,'This browser does not support Math.imul(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill'Math)imul; assert(.
,'This browser does not support Math.fround(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill'Math)fround; assert(.
,'This browser does not support Math.clz32(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill'Math)clz32; assert(.
,'This browser does not support Math.trunc(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill'Math)trunc; // 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
=
0
; runDependencies var =null
; runDependencyWatcher var =null
; dependenciesFulfilled // overridden to take different actions when all run dependencies are fulfilled var= }
; runDependencyTracking function {getUniqueRunDependency(

id )var=; {
  while orig ( id1
  ) if(! {
    [ ])runDependencyTrackingreturnid;= + id.
    id random orig ( Math);}}function
  addRunDependency
(

id )++;if {
  runDependencies([

  'monitorRunDependencies' ]Module)['monitorRunDependencies'] {
    Module();}runDependenciesif(
  )

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

id )--;if {
  runDependencies([

  'monitorRunDependencies' ]Module)['monitorRunDependencies'] {
    Module();}runDependenciesif(
  )

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

Module=}; // maps url to image data {["preloadedAudios" ]
Module=}; // maps url to audio data {/** @param {string|number=} what */function abort

(
what )if([ {
  {
    'onAbort' ]Module)['onAbort'] {
      Module();}what}=
    'Aborted('
  +

  what + ')' ; what // TODO(sbc): Should we remove printing and leave it up to whoever // catches the exception?err
  (
  )
  ;ABORTwhat=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.

  // 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 : isWechat new {. ( ) WebAssembly;RuntimeError// Throw the error whether or not MODULARIZE is set because abort is usedwhat// in code paths apart from instantiation where an exception is expected// to be thrown when abort is called.

  throw
  ;
  }
  // include: memoryprofiler.js e// end include: memoryprofiler.js
// show errors on likely calls to FS when it was not included

// {{MEM_INITIALIZER}}

var


FS
=
error : function {
  () abort('Filesystem support (FS) was not included. The problem is that you are using files from JS, but files were not used from C/C++, so filesystem support was not auto-included. You can force-include filesystem support with  -s FORCE_FILESYSTEM=1' {
    );},init
  :function
  () FS.error { ()},createDataFile :function
  () FS.error { ()},createPreloadedFile :function
  () FS.error { ()},createLazyFile :function
  () FS.error { ()},open :function
  () FS.error { ()},mkdev :function
  () FS.error { ()},registerDevice :function
  () FS.error { ()},analyzePath :function
  () FS.error { ()},loadFilesFromDB :function
  () FS.error { ()},ErrnoError :function

  ErrnoError( ) FS.error { ()},} ;[
'FS_createDataFile']
Module=FS. ; ['FS_createPreloadedFile'createDataFile]
Module=FS. ; // include: URIUtils.js// Prefix of data URIs emitted by SINGLE_FILE and related options.createPreloadedFilevar

=


'data:application/octet-stream;base64,'
; dataURIPrefix // Indicates whether filename is a base64 data URI. functionisDataURI

(
filename )// Prefix of data URIs emitted by SINGLE_FILE and related options.return. {
  startsWith
  ( filename);}dataURIPrefix// Indicates whether filename is delivered via file protocol (as opposed to http/https)function
isFileURI

(
filename )return.startsWith {
  ( filename'file://');}// end include: URIUtils.js/** @param {boolean=} fixedasm */
function

createExportWrapper
(
, )returnnamefunction fixedasm( {
  ) var=; {
    var displayName = name;
    if asm ( fixedasm!
    ) =[fixedasm'asm' {
      asm ] Module;}assert(
    ,
    'native function `'+runtimeInitialized+ '` called before runtime initialization' ) displayName ; if(!
    [ ])asmassertname([ {
      ],asm'exported native function `'name++ '` not found' ) displayName ; }return[
    ]
    . asmapplyname(null,);} arguments;}
  var=
'hello.wasm'

; wasmBinaryFile //这里作为demo，可以上面直接指定即可 if(
)
= "/package_lesson1/assets/hello.wasm"isWechat; {
    wasmBinaryFile } if(
!

) +}isWechatfunction {
	scriptDirectory getBinary wasmBinaryFile
(

file )tryif( {
  == {
    && )file return wasmBinaryFile new wasmBinaryUint8Array {
      ( ) ;}wasmBinaryif(
    )
    return readBinaryreadBinary( {
      ) ;}fileelsethrow
    "both async and sync fetching of the wasm failed" ; {
      } }catch
    (
  )
  abort (err) {
    ;}err}function
  getBinaryPromise
(

) // If we don't have the binary yet, try to to load it asynchronously.// Fetch has some additional restrictions over XHR, like it can't be used on a file:// url.// See https://github.com/github/fetch/pull/92#issuecomment-140665932 {
  // Cordova or Electron apps are typically loaded from a file:// url.
  // So use fetch if it is available and the url is not a file, otherwise fall back to XHR.
  if
  (
  !
  && (ENVIRONMENT_IS_WEBwasmBinary || ENVIRONMENT_IS_WORKER) ) if(typeof {
    == 'function'&& fetch ! isFileURI
      ( ))returnwasmBinaryFilefetch
    ( {
      , credentials:wasmBinaryFile'same-origin' { }) . then(function(response)if(! {
        [ 'ok']response)throw"failed to load wasm binary file at '"+ {
          + "'" ; wasmBinaryFile } return[
        'arrayBuffer'
        ] response();}).
      catch(function()return getBinary( {
          ) ;}wasmBinaryFile);
      }elseif
    (
    ) {
      return newreadAsyncPromise {
        // fetch is not available or url is file => try XHR (readAsync uses XHR internally)
        ( function (,)readAsyncresolve( reject, {
          function(wasmBinaryFileresponse )resolve(new { Uint8Array(/** @type{!ArrayBuffer} */ ()))response},) }) reject;
        }}}
      // Otherwise, getBinary should be able to get it synchronously
    return
  .

  resolve
  ( Promise).then(function()returngetBinary( { ) ;}wasmBinaryFile); }// Create the wasm instance.// Receives the wasm imports, returns the exports.
function

createWasm
(
) // prepare importsvar= {
  'env'
  : info , {
    'wasi_snapshot_preview1': asmLibraryArg,
    }; asmLibraryArg// Load the wasm module and create an instance of using native support in the JS engine.
  // handle a generated wasm instance, receiving its exports and// performing other necessary setup
  /** @param {WebAssembly.Module=} module*/
  function
  receiveInstance
  (
  , )varinstance= module. {
    ; exports [ instance'asm'exports]

    Module=;= [ exports'asm'

    wasmMemory ] Module['memory'];assert(,
    "memory not found in wasm exports")wasmMemory; // This assertion doesn't hold when emscripten is run in --post-link// mode.// TODO(sbc): Read INITIAL_MEMORY out of the wasm file in post-link mode.
    //assert(wasmMemory.buffer.byteLength === 16777216);
    updateGlobalBufferAndViews
    (
    .
    );wasmMemory=buffer['asm'

    wasmTable ] Module['__indirect_function_table'];assert(,
    "table not found in wasm exports")wasmTable; addOnInit([

    'asm']Module['__wasm_call_ctors']);removeRunDependency('wasm-instantiate'

    );}// we can't run yet (except in a pthread, where we have a custom sync instantiator)addRunDependency

  (
  'wasm-instantiate'
  );// Prefer streaming instantiation if available.// Async compilation can be confusing when an error on the page overwrites Module// (for example, if the order of elements is wrong, and the one defining Module is

  // later), so we save Module and check it later.
  var
  =
  ;
  function trueModule receiveInstantiationResult Module(
  result )// 'result' is a ResultObject object which has both the module and instance.// receiveInstance() will swap in the exports (to Module.asm) so they can be calledassert {
    (
    ===
    ,'the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?'Module ) trueModule; =null;
    trueModule // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line. // When the regression is fixed, can restore the above USE_PTHREADS-enabled path.receiveInstance
    (
    [
    'instance']result);}functioninstantiateArrayBuffer
  (

  receiver )var;if {
    ( r)
    = .isWechatinstantiate {
        r ( WebAssembly,);wasmBinaryFile} infoelse=
    getBinaryPromise ( {
        r ) .then(function(binary)return.instantiate {
            ( WebAssembly,);binary} info).
          then(function(instance) return;} {
            ) instance;
          }return.
    then
    ( r,function(receiverreason )err('failed to asynchronously prepare wasm: ' {
      +); // Warn on some common problems. reasonif(

      isFileURI
      ( ))errwasmBinaryFile('warning: Loading from a file URI (' {
        ++') is not supported in most browsers. See https://emscripten.org/docs/getting_started/FAQ.html#how-do-i-run-a-local-webserver-for-testing-why-does-my-program-stall-in-downloading-or-preparing' ) wasmBinaryFile ; }abort(
      )
      ;}reason);
    }functioninstantiateAsync
  (

  ) returninstantiateArrayBuffer( {
      ) ;}receiveInstantiationResult// User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback// to manually instantiate the Wasm module themselves. This allows pages to run the instantiation parallel
  // to any other async startup actions they are performing.

  // Also pthreads and wasm workers initialize the wasm instance through this path.
  if
  (
  [
  'instantiateWasm' ]Module)tryvar= {
    [ {
      'instantiateWasm' exports ] Module(,);inforeturn receiveInstance;}
      catch exports(
    ) err(e'Module.instantiateWasm callback failed with error: ' {
      +); return efalse;
      } }instantiateAsync
    (
  )

  ;return};
  // no exports yet; we'll fill them in later {}// Globals used by JS i64 conversions (see makeSetValue) var
;

var
; tempDouble// === Body ===
var tempI64ASM_CONSTS

=

} ; function {
  
callRuntimeCallbacks(






  callbacks )while(. {
      0 )callbacksvarlength > =. {
        shift callback ( callbacks);if(typeof
        == 'function') callback callback () {
          ;// Pass the module as the first argument.Modulecontinue; }
          var=
        .
        ; func if callback(functypeof
        == 'number') func if (. {
          === undefinedcallback)arg // Run the wasm function ptr with signature 'v'. If no function // with such signature was exported, this call does not need// to be emitted (and would confuse Closure) {
            getWasmTableEntry
            (
            )
            ()func;}else// If any function with signature 'vi' was exported, run
          // the callback with that signature. getWasmTableEntry {
            (
            )
            (.func);callback}arg}else
          func
        ( . {
          ===undefinedcallback?arg null : . ) ; callback}arg}}
        function
      withStackSave
    (

  f )var=stackSave {
      ( stack ) ;var=f
      ( ret ) ;stackRestore()
      ;returnstack;}
      function retdemangle
    (
  func )warnOnce('warning: build with  -s DEMANGLE_SUPPORT=1  to link in libcxxabi demangling' {
      );return;}
      function funcdemangleAll
    (

  text )var=/ {
      \b_Z[\w\d_]+ regex /
        g;return.replace
      ( text,function(regexx
        )var=demangle {
          ( y ) ;returnx===?
          : x ( y + x ' [' +y + ']' ) x ; });
        }var=
    [

  ] wasmTableMirror ; functiongetWasmTableEntry(
  funcPtr )var=[ {
      ] func ; wasmTableMirroriffuncPtr(!
      ) if(func. {
        ) .funcPtr >= wasmTableMirror=length+ wasmTableMirror1length ; funcPtr [ ]=
        wasmTableMirror=funcPtr. get func ( wasmTable);}funcPtrassert(
      .
      get(wasmTable)==,funcPtr"JavaScript-side Wasm function table mirror is out of date!" ) func; return;}
      function funchandleException
    (

  e )// Certain exception types we do not treat as errors since they are used for// internal control flow.// 1. ExitStatus, which is thrown by exit() {
      // 2. "unwind", which is thrown by emscripten_unwind_to_js_event_loop() and others
      //    that wish to return to JS event loop.
      if
      (
      instanceof
      ExitStatus ||e == 'unwind' ) e return EXITSTATUS; {
        } quit_(
      1
      ,);} efunctionjsStackTrace
    (

  ) var=new {
      Error error ( ) ;if(!
      . )// IE10+ special cases: It does have callstack info, but it is only populated if an Error object is thrown,error// so try that as a special-case.stacktry {
        throw
        new
        Error {
          ( ) ;}catch(
        ) =;e} {
          error if e(
        !
        . )returnerror'(no stack trace available)'stack; {
          } }return
        .
      .
      toString error(stack);}functionsetWasmTableEntry
    (

  , ).idxset func( {
      wasmTable,);idx[ func]=
      wasmTableMirror;idx} function funcstackTrace
    (

  ) var=jsStackTrace {
      ( js ) ;if([
      'extraStackTrace' ]Module)+='\n'+ js [ 'extraStackTrace' ] Module();returndemangleAll(
      ) ;}jsfunction_emscripten_memcpy_big
    (

  , ,)destHEAPU8 src. numcopyWithin {
      (,,+dest) src; src } numfunctionflush_NO_FILESYSTEM
    (

  ) // flush anything remaining in the buffers during shutdown___stdio_exit( {
      )
      ;var=SYSCALLS
      . buffers ; if(buffers[
      1 ]buffers.)SYSCALLS.lengthprintChar (1,10); if([
      2 ]buffers.)SYSCALLS.lengthprintChar (2,10); }varSYSCALLS
    =
  
  buffers : [ {null,[],[]],printChar:function(,)varstream= currSYSCALLS {
        . buffer [ ];buffersassertstream()
        ;ifbuffer(===
        0 ||curr === 10 ) curr ( ===1 {
          ?stream : ) ( out UTF8ArrayToString err(,0)buffer) ;.=0
          buffer;length } else.
        push ( {
          buffer);}curr},
        varargs
      :undefined,get:function()assert(SYSCALLS {
        .!=undefined)varargs ; SYSCALLS.+=
        4;varargs var =HEAP32
        [ ret ( ((SYSCALLS.)-(varargs4))2)]>>;return;}
        , retgetStr
      :function(ptr)var=UTF8ToString {
        ( ret ) ;returnptr;}
        , retget64
      :function(,)iflow( high0 {
        ) assertlow >= (=== 0)high ; elseassert(
        === -1high ) ;return;}
        } low;
      function_fd_write(
  , ,,fd) iov; iovcnt// hack to support printf in SYSCALLS_REQUIRE_FILESYSTEM=0 pnumvar {
      =
      0
      ; num for (var
      = 0; i < ;++ i ) iovcntvar i=HEAP32 {
        [ ptr ( ()2)iov]>>;var=HEAP32
        [ len ( (()+(iov4))2)]>>;+=8;
        iov for (var
        = 0; j < ;++ j ) lenSYSCALLS j.printChar {
          (,HEAPU8[fd+ ])ptr;j}+=;
        }
        num HEAP32 len[
      (
      ()2)pnum]>>=;return 0 num;
      } function_setTempRet0
    (

  val )setTempRet0() {
      ;}valvarASSERTIONS
    =
true ; /** @type {function(string, boolean=, number=)} */ functionintArrayFromString



(
, ,)stringyvar dontAddNull= length0 {
  ? len : length > lengthBytesUTF8 ( length ) +1stringy;var=new
  Array u8array ( ) ;varlen=stringToUTF8Array
  ( numBytesWritten , ,0stringy, u8array. ); u8arrayiflength()
  . =dontAddNull; u8arrayreturnlength ; numBytesWritten}
  function u8arrayintArrayToString
(

array )var=[ {
  ] ret ; for(var
  = 0; i < .; i ++ array)lengthvar i=[ {
    ] chr ; arrayifi(0xFF
    ) ifchr > (ASSERTIONS {
      ) assert(false {
        ,'Character code '++ ' (' + chr . fromCharCode ( String)+')  at offset 'chr+ + ' not in 0x00-0xFF.' ) i ; }&=0xFF
      ;
      chr } .push
    (
    ret.fromCharCode(String));chr}return.
  join
  ( ret'');}functioncheckIncomingModuleAPI
(


) ignoredModuleProp('fetchSettings' {
  );}var=
"emscripten_memcpy_big"
: asmLibraryArg , {
  "fd_write": _emscripten_memcpy_big,
  "setTempRet0": _fd_write}
  ;var _setTempRet0
=createWasm
( asm ) ;/** @type {function(...*):?} */var=
[
"___wasm_call_ctors" ___wasm_call_ctors ] Module=createExportWrapper( "__wasm_call_ctors" );/** @type {function(...*):?} */var=

[
"_show" _show ] Module=createExportWrapper( "show" );/** @type {function(...*):?} */var=

[
"___errno_location" ___errno_location ] Module=createExportWrapper( "__errno_location" );/** @type {function(...*):?} */var=

[
"___stdio_exit" ___stdio_exit ] Module=createExportWrapper( "__stdio_exit" );/** @type {function(...*):?} */var=

[
"_emscripten_stack_init" _emscripten_stack_init ] Module=function( ) return(= {
  [ "_emscripten_stack_init"_emscripten_stack_init ] Module=["asm" ] Module["emscripten_stack_init"]).apply(null,);} arguments;/** @type {function(...*):?} */
var=

[
"_emscripten_stack_get_free" _emscripten_stack_get_free ] Module=function( ) return(= {
  [ "_emscripten_stack_get_free"_emscripten_stack_get_free ] Module=["asm" ] Module["emscripten_stack_get_free"]).apply(null,);} arguments;/** @type {function(...*):?} */
var=

[
"_emscripten_stack_get_base" _emscripten_stack_get_base ] Module=function( ) return(= {
  [ "_emscripten_stack_get_base"_emscripten_stack_get_base ] Module=["asm" ] Module["emscripten_stack_get_base"]).apply(null,);} arguments;/** @type {function(...*):?} */
var=

[
"_emscripten_stack_get_end" _emscripten_stack_get_end ] Module=function( ) return(= {
  [ "_emscripten_stack_get_end"_emscripten_stack_get_end ] Module=["asm" ] Module["emscripten_stack_get_end"]).apply(null,);} arguments;/** @type {function(...*):?} */
var=

[
"stackSave" stackSave ] Module=createExportWrapper( "stackSave" );/** @type {function(...*):?} */var=

[
"stackRestore" stackRestore ] Module=createExportWrapper( "stackRestore" );/** @type {function(...*):?} */var=

[
"stackAlloc" stackAlloc ] Module=createExportWrapper( "stackAlloc" );/** @type {function(...*):?} */var=

[
"dynCall_jiji" dynCall_jiji ] Module=createExportWrapper( "dynCall_jiji" );// === Auto-generated postamble setup entry stuff ===unexportedRuntimeFunction(





'intArrayFromString'

,false); unexportedRuntimeFunction('intArrayToString'
,false); ["ccall"]
Module=;[ "cwrap" ccall]
Module=;unexportedRuntimeFunction ( cwrap'setValue'
,false); unexportedRuntimeFunction('getValue'
,false); unexportedRuntimeFunction('allocate'
,false); unexportedRuntimeFunction('UTF8ArrayToString'
,false); unexportedRuntimeFunction('UTF8ToString'
,false); unexportedRuntimeFunction('stringToUTF8Array'
,false); unexportedRuntimeFunction('stringToUTF8'
,false); unexportedRuntimeFunction('lengthBytesUTF8'
,false); unexportedRuntimeFunction('stackTrace'
,false); unexportedRuntimeFunction('addOnPreRun'
,false); unexportedRuntimeFunction('addOnInit'
,false); unexportedRuntimeFunction('addOnPreMain'
,false); unexportedRuntimeFunction('addOnExit'
,false); unexportedRuntimeFunction('addOnPostRun'
,false); unexportedRuntimeFunction('writeStringToMemory'
,false); unexportedRuntimeFunction('writeArrayToMemory'
,false); unexportedRuntimeFunction('writeAsciiToMemory'
,false); unexportedRuntimeFunction('addRunDependency'
,true); unexportedRuntimeFunction('removeRunDependency'
,true); unexportedRuntimeFunction('FS_createFolder'
,false); unexportedRuntimeFunction('FS_createPath'
,true); unexportedRuntimeFunction('FS_createDataFile'
,true); unexportedRuntimeFunction('FS_createPreloadedFile'
,true); unexportedRuntimeFunction('FS_createLazyFile'
,true); unexportedRuntimeFunction('FS_createLink'
,false); unexportedRuntimeFunction('FS_createDevice'
,true); unexportedRuntimeFunction('FS_unlink'
,true); unexportedRuntimeFunction('getLEB'
,false); unexportedRuntimeFunction('getFunctionTables'
,false); unexportedRuntimeFunction('alignFunctionTables'
,false); unexportedRuntimeFunction('registerFunctions'
,false); unexportedRuntimeFunction('addFunction'
,false); unexportedRuntimeFunction('removeFunction'
,false); unexportedRuntimeFunction('getFuncWrapper'
,false); unexportedRuntimeFunction('prettyPrint'
,false); unexportedRuntimeFunction('dynCall'
,false); unexportedRuntimeFunction('getCompilerSetting'
,false); unexportedRuntimeFunction('print'
,false); unexportedRuntimeFunction('printErr'
,false); unexportedRuntimeFunction('getTempRet0'
,false); unexportedRuntimeFunction('setTempRet0'
,false); unexportedRuntimeFunction('callMain'
,false); unexportedRuntimeFunction('abort'
,false); unexportedRuntimeFunction('keepRuntimeAlive'
,false); unexportedRuntimeFunction('zeroMemory'
,false); unexportedRuntimeFunction('stringToNewUTF8'
,false); unexportedRuntimeFunction('abortOnCannotGrowMemory'
,false); unexportedRuntimeFunction('emscripten_realloc_buffer'
,false); unexportedRuntimeFunction('ENV'
,false); unexportedRuntimeFunction('ERRNO_CODES'
,false); unexportedRuntimeFunction('ERRNO_MESSAGES'
,false); unexportedRuntimeFunction('setErrNo'
,false); unexportedRuntimeFunction('inetPton4'
,false); unexportedRuntimeFunction('inetNtop4'
,false); unexportedRuntimeFunction('inetPton6'
,false); unexportedRuntimeFunction('inetNtop6'
,false); unexportedRuntimeFunction('readSockaddr'
,false); unexportedRuntimeFunction('writeSockaddr'
,false); unexportedRuntimeFunction('DNS'
,false); unexportedRuntimeFunction('getHostByName'
,false); unexportedRuntimeFunction('Protocols'
,false); unexportedRuntimeFunction('Sockets'
,false); unexportedRuntimeFunction('getRandomDevice'
,false); unexportedRuntimeFunction('traverseStack'
,false); unexportedRuntimeFunction('UNWIND_CACHE'
,false); unexportedRuntimeFunction('convertPCtoSourceLocation'
,false); unexportedRuntimeFunction('readAsmConstArgsArray'
,false); unexportedRuntimeFunction('readAsmConstArgs'
,false); unexportedRuntimeFunction('mainThreadEM_ASM'
,false); unexportedRuntimeFunction('jstoi_q'
,false); unexportedRuntimeFunction('jstoi_s'
,false); unexportedRuntimeFunction('getExecutableName'
,false); unexportedRuntimeFunction('listenOnce'
,false); unexportedRuntimeFunction('autoResumeAudioContext'
,false); unexportedRuntimeFunction('dynCallLegacy'
,false); unexportedRuntimeFunction('getDynCaller'
,false); unexportedRuntimeFunction('dynCall'
,false); unexportedRuntimeFunction('handleException'
,false); unexportedRuntimeFunction('runtimeKeepalivePush'
,false); unexportedRuntimeFunction('runtimeKeepalivePop'
,false); unexportedRuntimeFunction('callUserCallback'
,false); unexportedRuntimeFunction('maybeExit'
,false); unexportedRuntimeFunction('safeSetTimeout'
,false); unexportedRuntimeFunction('asmjsMangle'
,false); unexportedRuntimeFunction('asyncLoad'
,false); unexportedRuntimeFunction('alignMemory'
,false); unexportedRuntimeFunction('mmapAlloc'
,false); unexportedRuntimeFunction('reallyNegative'
,false); unexportedRuntimeFunction('unSign'
,false); unexportedRuntimeFunction('reSign'
,false); unexportedRuntimeFunction('formatString'
,false); unexportedRuntimeFunction('PATH'
,false); unexportedRuntimeFunction('PATH_FS'
,false); unexportedRuntimeFunction('SYSCALLS'
,false); unexportedRuntimeFunction('getSocketFromFD'
,false); unexportedRuntimeFunction('getSocketAddress'
,false); unexportedRuntimeFunction('JSEvents'
,false); unexportedRuntimeFunction('registerKeyEventCallback'
,false); unexportedRuntimeFunction('specialHTMLTargets'
,false); unexportedRuntimeFunction('maybeCStringToJsString'
,false); unexportedRuntimeFunction('findEventTarget'
,false); unexportedRuntimeFunction('findCanvasEventTarget'
,false); unexportedRuntimeFunction('getBoundingClientRect'
,false); unexportedRuntimeFunction('fillMouseEventData'
,false); unexportedRuntimeFunction('registerMouseEventCallback'
,false); unexportedRuntimeFunction('registerWheelEventCallback'
,false); unexportedRuntimeFunction('registerUiEventCallback'
,false); unexportedRuntimeFunction('registerFocusEventCallback'
,false); unexportedRuntimeFunction('fillDeviceOrientationEventData'
,false); unexportedRuntimeFunction('registerDeviceOrientationEventCallback'
,false); unexportedRuntimeFunction('fillDeviceMotionEventData'
,false); unexportedRuntimeFunction('registerDeviceMotionEventCallback'
,false); unexportedRuntimeFunction('screenOrientation'
,false); unexportedRuntimeFunction('fillOrientationChangeEventData'
,false); unexportedRuntimeFunction('registerOrientationChangeEventCallback'
,false); unexportedRuntimeFunction('fillFullscreenChangeEventData'
,false); unexportedRuntimeFunction('registerFullscreenChangeEventCallback'
,false); unexportedRuntimeFunction('registerRestoreOldStyle'
,false); unexportedRuntimeFunction('hideEverythingExceptGivenElement'
,false); unexportedRuntimeFunction('restoreHiddenElements'
,false); unexportedRuntimeFunction('setLetterbox'
,false); unexportedRuntimeFunction('currentFullscreenStrategy'
,false); unexportedRuntimeFunction('restoreOldWindowedStyle'
,false); unexportedRuntimeFunction('softFullscreenResizeWebGLRenderTarget'
,false); unexportedRuntimeFunction('doRequestFullscreen'
,false); unexportedRuntimeFunction('fillPointerlockChangeEventData'
,false); unexportedRuntimeFunction('registerPointerlockChangeEventCallback'
,false); unexportedRuntimeFunction('registerPointerlockErrorEventCallback'
,false); unexportedRuntimeFunction('requestPointerLock'
,false); unexportedRuntimeFunction('fillVisibilityChangeEventData'
,false); unexportedRuntimeFunction('registerVisibilityChangeEventCallback'
,false); unexportedRuntimeFunction('registerTouchEventCallback'
,false); unexportedRuntimeFunction('fillGamepadEventData'
,false); unexportedRuntimeFunction('registerGamepadEventCallback'
,false); unexportedRuntimeFunction('registerBeforeUnloadEventCallback'
,false); unexportedRuntimeFunction('fillBatteryEventData'
,false); unexportedRuntimeFunction('battery'
,false); unexportedRuntimeFunction('registerBatteryEventCallback'
,false); unexportedRuntimeFunction('setCanvasElementSize'
,false); unexportedRuntimeFunction('getCanvasElementSize'
,false); unexportedRuntimeFunction('demangle'
,false); unexportedRuntimeFunction('demangleAll'
,false); unexportedRuntimeFunction('jsStackTrace'
,false); unexportedRuntimeFunction('stackTrace'
,false); unexportedRuntimeFunction('getEnvStrings'
,false); unexportedRuntimeFunction('checkWasiClock'
,false); unexportedRuntimeFunction('flush_NO_FILESYSTEM'
,false); unexportedRuntimeFunction('writeI53ToI64'
,false); unexportedRuntimeFunction('writeI53ToI64Clamped'
,false); unexportedRuntimeFunction('writeI53ToI64Signaling'
,false); unexportedRuntimeFunction('writeI53ToU64Clamped'
,false); unexportedRuntimeFunction('writeI53ToU64Signaling'
,false); unexportedRuntimeFunction('readI53FromI64'
,false); unexportedRuntimeFunction('readI53FromU64'
,false); unexportedRuntimeFunction('convertI32PairToI53'
,false); unexportedRuntimeFunction('convertU32PairToI53'
,false); unexportedRuntimeFunction('setImmediateWrapped'
,false); unexportedRuntimeFunction('clearImmediateWrapped'
,false); unexportedRuntimeFunction('polyfillSetImmediate'
,false); unexportedRuntimeFunction('uncaughtExceptionCount'
,false); unexportedRuntimeFunction('exceptionLast'
,false); unexportedRuntimeFunction('exceptionCaught'
,false); unexportedRuntimeFunction('ExceptionInfo'
,false); unexportedRuntimeFunction('CatchInfo'
,false); unexportedRuntimeFunction('exception_addRef'
,false); unexportedRuntimeFunction('exception_decRef'
,false); unexportedRuntimeFunction('Browser'
,false); unexportedRuntimeFunction('funcWrappers'
,false); unexportedRuntimeFunction('getFuncWrapper'
,false); unexportedRuntimeFunction('setMainLoop'
,false); unexportedRuntimeFunction('wget'
,false); unexportedRuntimeFunction('FS'
,false); unexportedRuntimeFunction('MEMFS'
,false); unexportedRuntimeFunction('TTY'
,false); unexportedRuntimeFunction('PIPEFS'
,false); unexportedRuntimeFunction('SOCKFS'
,false); unexportedRuntimeFunction('_setNetworkCallback'
,false); unexportedRuntimeFunction('tempFixedLengthArray'
,false); unexportedRuntimeFunction('miniTempWebGLFloatBuffers'
,false); unexportedRuntimeFunction('heapObjectForWebGLType'
,false); unexportedRuntimeFunction('heapAccessShiftForWebGLHeap'
,false); unexportedRuntimeFunction('GL'
,false); unexportedRuntimeFunction('emscriptenWebGLGet'
,false); unexportedRuntimeFunction('computeUnpackAlignedImageSize'
,false); unexportedRuntimeFunction('emscriptenWebGLGetTexPixelData'
,false); unexportedRuntimeFunction('emscriptenWebGLGetUniform'
,false); unexportedRuntimeFunction('webglGetUniformLocation'
,false); unexportedRuntimeFunction('webglPrepareUniformLocationsBeforeFirstUse'
,false); unexportedRuntimeFunction('webglGetLeftBracePos'
,false); unexportedRuntimeFunction('emscriptenWebGLGetVertexAttrib'
,false); unexportedRuntimeFunction('writeGLArray'
,false); unexportedRuntimeFunction('AL'
,false); unexportedRuntimeFunction('SDL_unicode'
,false); unexportedRuntimeFunction('SDL_ttfContext'
,false); unexportedRuntimeFunction('SDL_audio'
,false); unexportedRuntimeFunction('SDL'
,false); unexportedRuntimeFunction('SDL_gfx'
,false); unexportedRuntimeFunction('GLUT'
,false); unexportedRuntimeFunction('EGL'
,false); unexportedRuntimeFunction('GLFW_Window'
,false); unexportedRuntimeFunction('GLFW'
,false); unexportedRuntimeFunction('GLEW'
,false); unexportedRuntimeFunction('IDBStore'
,false); unexportedRuntimeFunction('runAndAbortIfError'
,false); unexportedRuntimeFunction('warnOnce'
,false); unexportedRuntimeFunction('stackSave'
,false); unexportedRuntimeFunction('stackRestore'
,false); unexportedRuntimeFunction('stackAlloc'
,false); unexportedRuntimeFunction('AsciiToString'
,false); unexportedRuntimeFunction('stringToAscii'
,false); unexportedRuntimeFunction('UTF16ToString'
,false); unexportedRuntimeFunction('stringToUTF16'
,false); unexportedRuntimeFunction('lengthBytesUTF16'
,false); unexportedRuntimeFunction('UTF32ToString'
,false); unexportedRuntimeFunction('stringToUTF32'
,false); unexportedRuntimeFunction('lengthBytesUTF32'
,false); unexportedRuntimeFunction('allocateUTF8'
,false); unexportedRuntimeFunction('allocateUTF8OnStack'
,false); ["writeStackCookie"]
Module=;[ "checkStackCookie" writeStackCookie]
Module=;unexportedRuntimeSymbol ( checkStackCookie'ALLOC_NORMAL'
,false); unexportedRuntimeSymbol('ALLOC_STACK'
,false); var;/**
 * @constructor
 * @this {ExitStatus}
 */

function calledRunExitStatus

(
status )this.= {
  "ExitStatus";name this .=
  "Program terminated with exit("+message + ")" ; status this .=
  ;}status var status=
false

; calledMain dependenciesFulfilled =function

runCaller ( ) // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false)if( {
  !
  ) run(calledRun) ;if(!
  ) =;calledRun// try this again later, after new deps are fulfilled dependenciesFulfilled } runCaller; function
stackCheckInit(

) // This is normally called automatically during __wasm_call_ctors but need to// get these values before even running any of the ctors so we call it redundantly// here. {
  // TODO(sbc): Move writeStackCookie to native to to avoid this.
  _emscripten_stack_init
  (
  )
  ;writeStackCookie()
  ;}/** @type {function(Array=)} */function
run

(
args )=||; {
  args if args ( arguments_0

  ) returnrunDependencies > ;} {
    stackCheckInit(
  )

  ;preRun()

  ;// a preRun added a dependency, run will be called laterif(

  0
  ) returnrunDependencies > ;} {
    functiondoRun
  (

  ) // run may have just been called through dependencies being fulfilled just in this very frame,// or while the async setStatus time below was happeningif {
    (
    )
    return ;calledRun= true;
    calledRun [ 'calledRun']
    Module=true; if (ABORT

    ) return;initRuntime ()

    ;if([

    'onRuntimeInitialized' ]Module)['onRuntimeInitialized'] Module();assert(!

    ['_main']Module,'compiled without a main, but one is present. if you added it from JS, use Module["onRuntimeInitialized"]'); postRun()

    ;}if(
  [

  'setStatus' ]Module)['setStatus'] {
    Module('Running...');setTimeout(function
    ()setTimeout(function {
      ()['setStatus'] {
        Module('');},1
      ); doRun()
      ;},1
    ); }elsedoRun
  ( )
  {
    ;}checkStackCookie(
  )
  ;}['run'
]
Module=;function checkUnflushedContent run(

) // Compiler settings do not allow exiting the runtime, so flushing// the streams is not possible. but in ASSERTIONS mode we check// if there was something to flush, and if so tell the user they {
  // should request that the runtime be exitable.
  // Normally we would not even include flush() at all, but in ASSERTIONS
  // builds we do so just for this check, and here we see if there is any
  // content to flush, that is, we check if there would have been
  // something a non-ASSERTIONS build would have not seen.
  // How we flush the streams depends on whether we are in SYSCALLS_REQUIRE_FILESYSTEM=0
  // mode (which has its own special function for this; otherwise, all
  // the code is inside libc)
  var
  =
  ;
  var oldOut = out;
  var oldErr = errfalse
  ; has = err=
  out ( x ) =true; => {
    has } try// it doesn't matter if it fails
  var
  = { ;
    if flush ( flush_NO_FILESYSTEM)
    flush (flush) ;}catch(
  ) }=e; {=
  out ; oldOutif
  err ( oldErr)
  warnOnce (has'stdio streams had content in them that was not flushed. you should set EXIT_RUNTIME to 1 (see the FAQ), or make sure to emit a newline when you printf etc.' {
    );warnOnce('(this may also be due to not including full filesystem support - try building with -s FORCE_FILESYSTEM=1)'
    );}}/** @param {boolean|number=} implicit */
  function
exit

(
, )EXITSTATUSstatus= implicit; {
  checkUnflushedContent ( status)

  ;// if exit() was called explicitly, warn the user if the runtime isn't actually being shut downif(

  keepRuntimeAlive
  ( )&&!) var =implicit'program exited (with status: ' {
    + msg + '), but EXIT_RUNTIME is not set, so halting execution but not exiting the runtime or preventing further async execution (build with EXIT_RUNTIME=1, if you want a true shutdown)' ; status err ()
    ;}msgprocExit(
  )

  ;}statusfunctionprocExit
(

code )EXITSTATUS=; {
  if ( code!
  keepRuntimeAlive ())if([ {
    'onExit' ]Module)['onExit'] Module();ABORTcode=true
    ; } quit_(
  ,
  newExitStatuscode( ) );code}if(
[

'preInit' ]Module)if(typeof {
  [ 'preInit'] Module=='function') [ 'preInit'] Module=[[ 'preInit' ]Module];while([
  'preInit' ]Module.0)[length > 'preInit'] {
    Module.pop()();}}run
  (
)
;//demo运行延演示setTimeout(

(
).log(=>{
    console.ccall(Module"show","string",["string"],["zhangsan"]))},3000
)

运行结果如下：