rhino3dm.js

                  throw new TypeError('Passing a number "' + _embind_repr(value) + '" from JS side to C/C++ side to an argument of type "' + name + '", which is outside the valid range [' + minRange + ', ' + maxRange + ']!');
              }
              return isUnsignedType ? (value >>> 0) : (value | 0);
          },
          'argPackAdvance': 8,
          'readValueFromPointer': integerReadValueFromPointer(name, shift, minRange !== 0),
          destructorFunction: null, // This type does not need a destructor
      });
    }

  function __embind_register_memory_view(rawType, dataTypeIndex, name) {
      var typeMapping = [
          Int8Array,
          Uint8Array,
          Int16Array,
          Uint16Array,
          Int32Array,
          Uint32Array,
          Float32Array,
          Float64Array,
      ];
  
      var TA = typeMapping[dataTypeIndex];
  
      function decodeMemoryView(handle) {
          handle = handle >> 2;
          var heap = HEAPU32;
          var size = heap[handle]; // in elements
          var data = heap[handle + 1]; // byte offset into emscripten heap
          return new TA(heap['buffer'], data, size);
      }
  
      name = readLatin1String(name);
      registerType(rawType, {
          name: name,
          'fromWireType': decodeMemoryView,
          'argPackAdvance': 8,
          'readValueFromPointer': decodeMemoryView,
      }, {
          ignoreDuplicateRegistrations: true,
      });
    }

  function __embind_register_std_string(rawType, name) {
      name = readLatin1String(name);
      var stdStringIsUTF8
      //process only std::string bindings with UTF8 support, in contrast to e.g. std::basic_string<unsigned char>
      = (name === "std::string");
  
      registerType(rawType, {
          name: name,
          'fromWireType': function(value) {
              var length = HEAPU32[value >> 2];
  
              var str;
              if(stdStringIsUTF8) {
                  //ensure null termination at one-past-end byte if not present yet
                  var endChar = HEAPU8[value + 4 + length];
                  var endCharSwap = 0;
                  if(endChar != 0)
                  {
                    endCharSwap = endChar;
                    HEAPU8[value + 4 + length] = 0;
                  }
  
                  var decodeStartPtr = value + 4;
                  //looping here to support possible embedded '0' bytes
                  for (var i = 0; i <= length; ++i) {
                    var currentBytePtr = value + 4 + i;
                    if(HEAPU8[currentBytePtr] == 0)
                    {
                      var stringSegment = UTF8ToString(decodeStartPtr);
                      if(str === undefined)
                        str = stringSegment;
                      else
                      {
                        str += String.fromCharCode(0);
                        str += stringSegment;
                      }
                      decodeStartPtr = currentBytePtr + 1;
                    }
                  }
  
                  if(endCharSwap != 0)
                    HEAPU8[value + 4 + length] = endCharSwap;
              } else {
                  var a = new Array(length);
                  for (var i = 0; i < length; ++i) {
                      a[i] = String.fromCharCode(HEAPU8[value + 4 + i]);
                  }
                  str = a.join('');
              }
  
              _free(value);
              
              return str;
          },
          'toWireType': function(destructors, value) {
              if (value instanceof ArrayBuffer) {
                  value = new Uint8Array(value);
              }
              
              var getLength;
              var valueIsOfTypeString = (typeof value === 'string');
  
              if (!(valueIsOfTypeString || value instanceof Uint8Array || value instanceof Uint8ClampedArray || value instanceof Int8Array)) {
                  throwBindingError('Cannot pass non-string to std::string');
              }
              if (stdStringIsUTF8 && valueIsOfTypeString) {
                  getLength = function() {return lengthBytesUTF8(value);};
              } else {
                  getLength = function() {return value.length;};
              }
              
              // assumes 4-byte alignment
              var length = getLength();
              var ptr = _malloc(4 + length + 1);
              HEAPU32[ptr >> 2] = length;
  
              if (stdStringIsUTF8 && valueIsOfTypeString) {
                  stringToUTF8(value, ptr + 4, length + 1);
              } else {
                  if(valueIsOfTypeString) {
                      for (var i = 0; i < length; ++i) {
                          var charCode = value.charCodeAt(i);
                          if (charCode > 255) {
                              _free(ptr);
                              throwBindingError('String has UTF-16 code units that do not fit in 8 bits');
                          }
                          HEAPU8[ptr + 4 + i] = charCode;
                      }
                  } else {
                      for (var i = 0; i < length; ++i) {
                          HEAPU8[ptr + 4 + i] = value[i];
                      }
                  }
              }
  
              if (destructors !== null) {
                  destructors.push(_free, ptr);
              }
              return ptr;
          },
          'argPackAdvance': 8,
          'readValueFromPointer': simpleReadValueFromPointer,
          destructorFunction: function(ptr) { _free(ptr); },
      });
    }

  function __embind_register_std_wstring(rawType, charSize, name) {
      // nb. do not cache HEAPU16 and HEAPU32, they may be destroyed by emscripten_resize_heap().
      name = readLatin1String(name);
      var getHeap, shift;
      if (charSize === 2) {
          getHeap = function() { return HEAPU16; };
          shift = 1;
      } else if (charSize === 4) {
          getHeap = function() { return HEAPU32; };
          shift = 2;
      }
      registerType(rawType, {
          name: name,
          'fromWireType': function(value) {
              var HEAP = getHeap();
              var length = HEAPU32[value >> 2];
              var a = new Array(length);
              var start = (value + 4) >> shift;
              for (var i = 0; i < length; ++i) {
                  a[i] = String.fromCharCode(HEAP[start + i]);
              }
              _free(value);
              return a.join('');
          },
          'toWireType': function(destructors, value) {
              // assumes 4-byte alignment
              var HEAP = getHeap();
              var length = value.length;
              var ptr = _malloc(4 + length * charSize);
              HEAPU32[ptr >> 2] = length;
              var start = (ptr + 4) >> shift;
              for (var i = 0; i < length; ++i) {
                  HEAP[start + i] = value.charCodeAt(i);
              }
              if (destructors !== null) {
                  destructors.push(_free, ptr);
              }
              return ptr;
          },
          'argPackAdvance': 8,
          'readValueFromPointer': simpleReadValueFromPointer,
          destructorFunction: function(ptr) { _free(ptr); },
      });
    }

  function __embind_register_value_array(
      rawType,
      name,
      constructorSignature,
      rawConstructor,
      destructorSignature,
      rawDestructor
    ) {
      tupleRegistrations[rawType] = {
          name: readLatin1String(name),
          rawConstructor: embind__requireFunction(constructorSignature, rawConstructor),
          rawDestructor: embind__requireFunction(destructorSignature, rawDestructor),
          elements: [],
      };
    }

  function __embind_register_value_array_element(
      rawTupleType,
      getterReturnType,
      getterSignature,
      getter,
      getterContext,
      setterArgumentType,
      setterSignature,
      setter,
      setterContext
    ) {
      tupleRegistrations[rawTupleType].elements.push({
          getterReturnType: getterReturnType,
          getter: embind__requireFunction(getterSignature, getter),
          getterContext: getterContext,
          setterArgumentType: setterArgumentType,
          setter: embind__requireFunction(setterSignature, setter),
          setterContext: setterContext,
      });
    }

  function __embind_register_value_object(
      rawType,
      name,
      constructorSignature,
      rawConstructor,
      destructorSignature,
      rawDestructor
    ) {
      structRegistrations[rawType] = {
          name: readLatin1String(name),
          rawConstructor: embind__requireFunction(constructorSignature, rawConstructor),
          rawDestructor: embind__requireFunction(destructorSignature, rawDestructor),
          fields: [],
      };
    }

  function __embind_register_value_object_field(
      structType,
      fieldName,
      getterReturnType,
      getterSignature,
      getter,
      getterContext,
      setterArgumentType,
      setterSignature,
      setter,
      setterContext
    ) {
      structRegistrations[structType].fields.push({
          fieldName: readLatin1String(fieldName),
          getterReturnType: getterReturnType,
          getter: embind__requireFunction(getterSignature, getter),
          getterContext: getterContext,
          setterArgumentType: setterArgumentType,
          setter: embind__requireFunction(setterSignature, setter),
          setterContext: setterContext,
      });
    }

  function __embind_register_void(rawType, name) {
      name = readLatin1String(name);
      registerType(rawType, {
          isVoid: true, // void return values can be optimized out sometimes
          name: name,
          'argPackAdvance': 0,
          'fromWireType': function() {
              return undefined;
          },
          'toWireType': function(destructors, o) {
              // TODO: assert if anything else is given?
              return undefined;
          },
      });
    }

  
  function requireHandle(handle) {
      if (!handle) {
          throwBindingError('Cannot use deleted val. handle = ' + handle);
      }
      return emval_handle_array[handle].value;
    }function __emval_as(handle, returnType, destructorsRef) {
      handle = requireHandle(handle);
      returnType = requireRegisteredType(returnType, 'emval::as');
      var destructors = [];
      var rd = __emval_register(destructors);
      HEAP32[destructorsRef >> 2] = rd;
      return returnType['toWireType'](destructors, handle);
    }

  
  function __emval_allocateDestructors(destructorsRef) {
      var destructors = [];
      HEAP32[destructorsRef >> 2] = __emval_register(destructors);
      return destructors;
    }
  
  
  var emval_symbols={};function getStringOrSymbol(address) {
      var symbol = emval_symbols[address];
      if (symbol === undefined) {
          return readLatin1String(address);
      } else {
          return symbol;
      }
    }
  
  var emval_methodCallers=[];function __emval_call_method(caller, handle, methodName, destructorsRef, args) {
      caller = emval_methodCallers[caller];
      handle = requireHandle(handle);
      methodName = getStringOrSymbol(methodName);
      return caller(handle, methodName, __emval_allocateDestructors(destructorsRef), args);
    }

  function __emval_call_void_method(caller, handle, methodName, args) {
      caller = emval_methodCallers[caller];
      handle = requireHandle(handle);
      methodName = getStringOrSymbol(methodName);
      caller(handle, methodName, null, args);
    }


  function __emval_equals(first, second) {
      first = requireHandle(first);
      second = requireHandle(second);
      return first == second;
    }

  
  function emval_get_global() {
      if (typeof globalThis === 'object') {
        return globalThis;
      }
      return (function(){
        return Function;
      })()('return this')();
    }function __emval_get_global(name) {
      if(name===0){
        return __emval_register(emval_get_global());
      } else {
        name = getStringOrSymbol(name);
        return __emval_register(emval_get_global()[name]);
      }
    }

  
  function __emval_addMethodCaller(caller) {
      var id = emval_methodCallers.length;
      emval_methodCallers.push(caller);
      return id;
    }
  
  function __emval_lookupTypes(argCount, argTypes, argWireTypes) {
      var a = new Array(argCount);
      for (var i = 0; i < argCount; ++i) {
          a[i] = requireRegisteredType(
              HEAP32[(argTypes >> 2) + i],
              "parameter " + i);
      }
      return a;
    }function __emval_get_method_caller(argCount, argTypes) {
      var types = __emval_lookupTypes(argCount, argTypes);
  
      var retType = types[0];
      var signatureName = retType.name + "_$" + types.slice(1).map(function (t) { return t.name; }).join("_") + "$";
  
      var params = ["retType"];
      var args = [retType];
  
      var argsList = ""; // 'arg0, arg1, arg2, ... , argN'
      for (var i = 0; i < argCount - 1; ++i) {
          argsList += (i !== 0 ? ", " : "") + "arg" + i;
          params.push("argType" + i);
          args.push(types[1 + i]);
      }
  
      var functionName = makeLegalFunctionName("methodCaller_" + signatureName);
      var functionBody =
          "return function " + functionName + "(handle, name, destructors, args) {\n";
  
      var offset = 0;
      for (var i = 0; i < argCount - 1; ++i) {
          functionBody +=
          "    var arg" + i + " = argType" + i + ".readValueFromPointer(args" + (offset ? ("+"+offset) : "") + ");\n";
          offset += types[i + 1]['argPackAdvance'];
      }
      functionBody +=
          "    var rv = handle[name](" + argsList + ");\n";
      for (var i = 0; i < argCount - 1; ++i) {
          if (types[i + 1]['deleteObject']) {
              functionBody +=
              "    argType" + i + ".deleteObject(arg" + i + ");\n";
          }
      }
      if (!retType.isVoid) {
          functionBody +=
          "    return retType.toWireType(destructors, rv);\n";
      }
      functionBody +=
          "};\n";
  
      params.push(functionBody);
      var invokerFunction = new_(Function, params).apply(null, args);
      return __emval_addMethodCaller(invokerFunction);
    }

  function __emval_get_module_property(name) {
      name = getStringOrSymbol(name);
      return __emval_register(Module[name]);
    }

  function __emval_get_property(handle, key) {
      handle = requireHandle(handle);
      key = requireHandle(key);
      return __emval_register(handle[key]);
    }

  function __emval_incref(handle) {
      if (handle > 4) {
          emval_handle_array[handle].refcount += 1;
      }
    }

  function __emval_instanceof(object, constructor) {
      object = requireHandle(object);
      constructor = requireHandle(constructor);
      return object instanceof constructor;
    }

  function __emval_is_number(handle) {
      handle = requireHandle(handle);
      return typeof handle === 'number';
    }

  function __emval_is_string(handle) {
      handle = requireHandle(handle);
      return typeof handle === 'string';
    }

  
  function craftEmvalAllocator(argCount) {
      /*This function returns a new function that looks like this:
      function emval_allocator_3(constructor, argTypes, args) {
          var argType0 = requireRegisteredType(HEAP32[(argTypes >> 2)], "parameter 0");
          var arg0 = argType0.readValueFromPointer(args);
          var argType1 = requireRegisteredType(HEAP32[(argTypes >> 2) + 1], "parameter 1");
          var arg1 = argType1.readValueFromPointer(args + 8);
          var argType2 = requireRegisteredType(HEAP32[(argTypes >> 2) + 2], "parameter 2");
          var arg2 = argType2.readValueFromPointer(args + 16);
          var obj = new constructor(arg0, arg1, arg2);
          return __emval_register(obj);
      } */
      var argsList = "";
      for(var i = 0; i < argCount; ++i) {
          argsList += (i!==0?", ":"")+"arg"+i; // 'arg0, arg1, ..., argn'
      }
  
      var functionBody =
          "return function emval_allocator_"+argCount+"(constructor, argTypes, args) {\n";
  
      for(var i = 0; i < argCount; ++i) {
          functionBody +=
              "var argType"+i+" = requireRegisteredType(Module['HEAP32'][(argTypes >> 2) + "+i+"], \"parameter "+i+"\");\n" +
              "var arg"+i+" = argType"+i+".readValueFromPointer(args);\n" +
              "args += argType"+i+"['argPackAdvance'];\n";
      }
      functionBody +=
          "var obj = new constructor("+argsList+");\n" +
          "return __emval_register(obj);\n" +
          "}\n";
  
      /*jshint evil:true*/
      return (new Function("requireRegisteredType", "Module", "__emval_register", functionBody))(
          requireRegisteredType, Module, __emval_register);
    }
  
  var emval_newers={};function __emval_new(handle, argCount, argTypes, args) {
      handle = requireHandle(handle);
  
      var newer = emval_newers[argCount];
      if (!newer) {
          newer = craftEmvalAllocator(argCount);
          emval_newers[argCount] = newer;
      }
  
      return newer(handle, argTypes, args);
    }

  function __emval_new_array() {
      return __emval_register([]);
    }

  function __emval_new_cstring(v) {
      return __emval_register(getStringOrSymbol(v));
    }

  function __emval_new_object() {
      return __emval_register({});
    }

  function __emval_run_destructors(handle) {
      var destructors = emval_handle_array[handle].value;
      runDestructors(destructors);
      __emval_decref(handle);
    }

  function __emval_set_property(handle, key, value) {
      handle = requireHandle(handle);
      key = requireHandle(key);
      value = requireHandle(value);
      handle[key] = value;
    }

  function __emval_take_value(type, argv) {
      type = requireRegisteredType(type, '_emval_take_value');
      var v = type['readValueFromPointer'](argv);
      return __emval_register(v);
    }

  function _abort() {
      Module['abort']();
    }

  function _emscripten_get_heap_size() {
      return HEAP8.length;
    }

  function _getenv(name) {
      // char *getenv(const char *name);
      // http://pubs.opengroup.org/onlinepubs/009695399/functions/getenv.html
      if (name === 0) return 0;
      name = UTF8ToString(name);
      if (!ENV.hasOwnProperty(name)) return 0;
  
      if (_getenv.ret) _free(_getenv.ret);
      _getenv.ret = allocateUTF8(ENV[name]);
      return _getenv.ret;
    }

  
  var ___tm_current=315952;
  
  
  var ___tm_timezone=(stringToUTF8("GMT", 316000, 4), 316000);function _gmtime_r(time, tmPtr) {
      var date = new Date(HEAP32[((time)>>2)]*1000);
      HEAP32[((tmPtr)>>2)]=date.getUTCSeconds();
      HEAP32[(((tmPtr)+(4))>>2)]=date.getUTCMinutes();
      HEAP32[(((tmPtr)+(8))>>2)]=date.getUTCHours();
      HEAP32[(((tmPtr)+(12))>>2)]=date.getUTCDate();
      HEAP32[(((tmPtr)+(16))>>2)]=date.getUTCMonth();
      HEAP32[(((tmPtr)+(20))>>2)]=date.getUTCFullYear()-1900;
      HEAP32[(((tmPtr)+(24))>>2)]=date.getUTCDay();
      HEAP32[(((tmPtr)+(36))>>2)]=0;
      HEAP32[(((tmPtr)+(32))>>2)]=0;
      var start = Date.UTC(date.getUTCFullYear(), 0, 1, 0, 0, 0, 0);
      var yday = ((date.getTime() - start) / (1000 * 60 * 60 * 24))|0;
      HEAP32[(((tmPtr)+(28))>>2)]=yday;
      HEAP32[(((tmPtr)+(40))>>2)]=___tm_timezone;
  
      return tmPtr;
    }function _gmtime(time) {
      return _gmtime_r(time, ___tm_current);
    }

   

  var _llvm_cos_f64=Math_cos;

  
  function _llvm_log2_f32(x) {
      return Math.log(x) / Math.LN2; // TODO: Math.log2, when browser support is there
    }function _llvm_log2_f64(a0
  /*``*/) {
  return _llvm_log2_f32(a0);
  }

  var _llvm_sin_f64=Math_sin;

  function _llvm_trap() {
      abort('trap!');
    }

  
  function _emscripten_memcpy_big(dest, src, num) {
      HEAPU8.set(HEAPU8.subarray(src, src+num), dest);
    }
  
   

   

   

  
  function _usleep(useconds) {
      // int usleep(useconds_t useconds);
      // http://pubs.opengroup.org/onlinepubs/000095399/functions/usleep.html
      // We're single-threaded, so use a busy loop. Super-ugly.
      var msec = useconds / 1000;
      if ((ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) && self['performance'] && self['performance']['now']) {
        var start = self['performance']['now']();
        while (self['performance']['now']() - start < msec) {
          // Do nothing.
        }
      } else {
        var start = Date.now();
        while (Date.now() - start < msec) {
          // Do nothing.
        }
      }
      return 0;
    }function _nanosleep(rqtp, rmtp) {
      // int nanosleep(const struct timespec  *rqtp, struct timespec *rmtp);
      if (rqtp === 0) {
        ___setErrNo(22);
        return -1;
      }
      var seconds = HEAP32[((rqtp)>>2)];
      var nanoseconds = HEAP32[(((rqtp)+(4))>>2)];
      if (nanoseconds < 0 || nanoseconds > 999999999 || seconds < 0) {
        ___setErrNo(22);
        return -1;
      }
      if (rmtp !== 0) {
        HEAP32[((rmtp)>>2)]=0;
        HEAP32[(((rmtp)+(4))>>2)]=0;
      }
      return _usleep((seconds * 1e6) + (nanoseconds / 1000));
    }

  
  
  function abortOnCannotGrowMemory(requestedSize) {
      abort('Cannot enlarge memory arrays to size ' + requestedSize + ' bytes (OOM). Either (1) compile with  -s TOTAL_MEMORY=X  with X higher than the current value ' + HEAP8.length + ', (2) compile with  -s ALLOW_MEMORY_GROWTH=1  which allows increasing the size at runtime, or (3) if you want malloc to return NULL (0) instead of this abort, compile with  -s ABORTING_MALLOC=0 ');
    }
  
  function emscripten_realloc_buffer(size) {
      try {
        // round size grow request up to wasm page size (fixed 64KB per spec)
        wasmMemory.grow((size - buffer.byteLength + 65535) >> 16); // .grow() takes a delta compared to the previous size
        updateGlobalBufferAndViews(wasmMemory.buffer);
        return 1 /*success*/;
      } catch(e) {
        console.error('emscripten_realloc_buffer: Attempted to grow heap from ' + buffer.byteLength  + ' bytes to ' + size + ' bytes, but got error: ' + e);
      }
    }function _emscripten_resize_heap(requestedSize) {
      var oldSize = _emscripten_get_heap_size();
      // With pthreads, races can happen (another thread might increase the size in between), so return a failure, and let the caller retry.
      assert(requestedSize > oldSize);
  
  
      var PAGE_MULTIPLE = 65536;
      var LIMIT = 2147483648 - PAGE_MULTIPLE; // We can do one page short of 2GB as theoretical maximum.
  
      if (requestedSize > LIMIT) {
        err('Cannot enlarge memory, asked to go up to ' + requestedSize + ' bytes, but the limit is ' + LIMIT + ' bytes!');
        return false;
      }
  
      var MIN_TOTAL_MEMORY = 16777216;
      var newSize = Math.max(oldSize, MIN_TOTAL_MEMORY); // So the loop below will not be infinite, and minimum asm.js memory size is 16MB.
  
      // TODO: see realloc_buffer - for PTHREADS we may want to decrease these jumps
      while (newSize < requestedSize) { // Keep incrementing the heap size as long as it's less than what is requested.
        if (newSize <= 536870912) {
          newSize = alignUp(2 * newSize, PAGE_MULTIPLE); // Simple heuristic: double until 1GB...
        } else {
          // ..., but after that, add smaller increments towards 2GB, which we cannot reach
          newSize = Math.min(alignUp((3 * newSize + 2147483648) / 4, PAGE_MULTIPLE), LIMIT);
        }
  
        if (newSize === oldSize) {
          warnOnce('Cannot ask for more memory since we reached the practical limit in browsers (which is just below 2GB), so the request would have failed. Requesting only ' + HEAP8.length);
        }
      }
  
  
  
      var replacement = emscripten_realloc_buffer(newSize);
      if (!replacement) {
        err('Failed to grow the heap from ' + oldSize + ' bytes to ' + newSize + ' bytes, not enough memory!');
        return false;
      }
  
  
  
      return true;
    } 

  function _time(ptr) {
      var ret = (Date.now()/1000)|0;
      if (ptr) {
        HEAP32[((ptr)>>2)]=ret;
      }
      return ret;
    }

  function _uuid_generate(out) {
      // void uuid_generate(uuid_t out);
      var uuid = null;
  
      if (ENVIRONMENT_IS_NODE) {
        // If Node.js try to use crypto.randomBytes
        try {
          var rb = require('crypto')['randomBytes'];
          uuid = rb(16);
        } catch(e) {}
      } else if (ENVIRONMENT_IS_WEB &&
                 typeof(window.crypto) !== 'undefined' &&
                 typeof(window.crypto.getRandomValues) !== 'undefined') {
        // If crypto.getRandomValues is available try to use it.
        uuid = new Uint8Array(16);
        window.crypto.getRandomValues(uuid);
      }
  
      // Fall back to Math.random if a higher quality random number generator is not available.
      if (!uuid) {
        uuid = new Array(16);
        var d = new Date().getTime();
        for (var i = 0; i < 16; i++) {
          var r = ((d + Math.random() * 256) % 256)|0;
          d = (d / 256)|0;
          uuid[i] = r;
        }
      }
  
      uuid[6] = (uuid[6] & 0x0F) | 0x40;
      uuid[8] = (uuid[8] & 0x7F) | 0x80;
      writeArrayToMemory(uuid, out);
    }
FS.staticInit();;
if (ENVIRONMENT_HAS_NODE) { var fs = require("fs"); var NODEJS_PATH = require("path"); NODEFS.staticInit(); };
InternalError = Module['InternalError'] = extendError(Error, 'InternalError');;
embind_init_charCodes();
BindingError = Module['BindingError'] = extendError(Error, 'BindingError');;
init_ClassHandle();
init_RegisteredPointer();
init_embind();;
UnboundTypeError = Module['UnboundTypeError'] = extendError(Error, 'UnboundTypeError');;
init_emval();;
var ASSERTIONS = true;

// Copyright 2017 The Emscripten Authors.  All rights reserved.
// Emscripten is available under two separate licenses, the MIT license and the
// University of Illinois/NCSA Open Source License.  Both these licenses can be
// found in the LICENSE file.

/** @type {function(string, boolean=, number=)} */
function intArrayFromString(stringy, dontAddNull, length) {
  var len = length > 0 ? length : lengthBytesUTF8(stringy)+1;
  var u8array = new Array(len);
  var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length);
  if (dontAddNull) u8array.length = numBytesWritten;
  return u8array;
}

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


// ASM_LIBRARY EXTERN PRIMITIVES: Int8Array,Int32Array

function nullFunc_di(x) { abortFnPtrError(x, 'di'); }
function nullFunc_did(x) { abortFnPtrError(x, 'did'); }
function nullFunc_dii(x) { abortFnPtrError(x, 'dii'); }
function nullFunc_diid(x) { abortFnPtrError(x, 'diid'); }
function nullFunc_diii(x) { abortFnPtrError(x, 'diii'); }
function nullFunc_diiid(x) { abortFnPtrError(x, 'diiid'); }
function nullFunc_fii(x) { abortFnPtrError(x, 'fii'); }
function nullFunc_i(x) { abortFnPtrError(x, 'i'); }
function nullFunc_ii(x) { abortFnPtrError(x, 'ii'); }
function nullFunc_iid(x) { abortFnPtrError(x, 'iid'); }
function nullFunc_iidd(x) { abortFnPtrError(x, 'iidd'); }
function nullFunc_iiddd(x) { abortFnPtrError(x, 'iiddd'); }
function nullFunc_iidddddd(x) { abortFnPtrError(x, 'iidddddd'); }
function nullFunc_iiddi(x) { abortFnPtrError(x, 'iiddi'); }
function nullFunc_iiddii(x) { abortFnPtrError(x, 'iiddii'); }
function nullFunc_iiddiiiii(x) { abortFnPtrError(x, 'iiddiiiii'); }
function nullFunc_iidi(x) { abortFnPtrError(x, 'iidi'); }
function nullFunc_iidid(x) { abortFnPtrError(x, 'iidid'); }
function nullFunc_iididii(x) { abortFnPtrError(x, 'iididii'); }
function nullFunc_iidii(x) { abortFnPtrError(x, 'iidii'); }
function nullFunc_iidiii(x) { abortFnPtrError(x, 'iidiii'); }
function nullFunc_iidiiii(x) { abortFnPtrError(x, 'iidiiii'); }
function nullFunc_iidiiiii(x) { abortFnPtrError(x, 'iidiiiii'); }
function nullFunc_iifff(x) { abortFnPtrError(x, 'iifff'); }
function nullFunc_iii(x) { abortFnPtrError(x, 'iii'); }
function nullFunc_iiid(x) { abortFnPtrError(x, 'iiid'); }
function nullFunc_iiidd(x) { abortFnPtrError(x, 'iiidd'); }
function nullFunc_iiiddd(x) { abortFnPtrError(x, 'iiiddd'); }
function nullFunc_iiidddddd(x) { abortFnPtrError(x, 'iiidddddd'); }
function nullFunc_iiiddi(x) { abortFnPtrError(x, 'iiiddi'); }
function nullFunc_iiiddiddddd(x) { abortFnPtrError(x, 'iiiddiddddd'); }
function nullFunc_iiiddiiidd(x) { abortFnPtrError(x, 'iiiddiiidd'); }
function nullFunc_iiidi(x) { abortFnPtrError(x, 'iiidi'); }
function nullFunc_iiidid(x) { abortFnPtrError(x, 'iiidid'); }
function nullFunc_iiididdddd(x) { abortFnPtrError(x, 'iiididdddd'); }
function nullFunc_iiidii(x) { abortFnPtrError(x, 'iiidii'); }
function nullFunc_iiidiii(x) { abortFnPtrError(x, 'iiidiii'); }
function nullFunc_iiifff(x) { abortFnPtrError(x, 'iiifff'); }
function nullFunc_iiii(x) { abortFnPtrError(x, 'iiii'); }
function nullFunc_iiiid(x) { abortFnPtrError(x, 'iiiid'); }
function nullFunc_iiiidd(x) { abortFnPtrError(x, 'iiiidd'); }
function nullFunc_iiiiddiiidd(x) { abortFnPtrError(x, 'iiiiddiiidd'); }
function nullFunc_iiiidi(x) { abortFnPtrError(x, 'iiiidi'); }
function nullFunc_iiiidiii(x) { abortFnPtrError(x, 'iiiidiii'); }
function nullFunc_iiiii(x) { abortFnPtrError(x, 'iiiii'); }
function nullFunc_iiiiii(x) { abortFnPtrError(x, 'iiiiii'); }
function nullFunc_iiiiiii(x) { abortFnPtrError(x, 'iiiiiii'); }
function nullFunc_iiiiiiii(x) { abortFnPtrError(x, 'iiiiiiii'); }
function nullFunc_ji(x) { abortFnPtrError(x, 'ji'); }
function nullFunc_jiji(x) { abortFnPtrError(x, 'jiji'); }
function nullFunc_v(x) { abortFnPtrError(x, 'v'); }
function nullFunc_vi(x) { abortFnPtrError(x, 'vi'); }
function nullFunc_vid(x) { abortFnPtrError(x, 'vid'); }
function nullFunc_viddd(x) { abortFnPtrError(x, 'viddd'); }
function nullFunc_vidii(x) { abortFnPtrError(x, 'vidii'); }
function nullFunc_vii(x) { abortFnPtrError(x, 'vii'); }
function nullFunc_viid(x) { abortFnPtrError(x, 'viid'); }
function nullFunc_viidd(x) { abortFnPtrError(x, 'viidd'); }
function nullFunc_viiddd(x) { abortFnPtrError(x, 'viiddd'); }
function nullFunc_viif(x) { abortFnPtrError(x, 'viif'); }
function nullFunc_viii(x) { abortFnPtrError(x, 'viii'); }
function nullFunc_viiid(x) { abortFnPtrError(x, 'viiid'); }
function nullFunc_viiidi(x) { abortFnPtrError(x, 'viiidi'); }
function nullFunc_viiii(x) { abortFnPtrError(x, 'viiii'); }
function nullFunc_viiiii(x) { abortFnPtrError(x, 'viiiii'); }
function nullFunc_viiiiii(x) { abortFnPtrError(x, 'viiiiii'); }

var asmGlobalArg = {};

var asmLibraryArg = {
  "abort": abort,
  "setTempRet0": setTempRet0,
  "getTempRet0": getTempRet0,
  "abortStackOverflow": abortStackOverflow,
  "nullFunc_di": nullFunc_di,
  "nullFunc_did": nullFunc_did,
  "nullFunc_dii": nullFunc_dii,
  "nullFunc_diid": nullFunc_diid,
  "nullFunc_diii": nullFunc_diii,
  "nullFunc_diiid": nullFunc_diiid,
  "nullFunc_fii": nullFunc_fii,
  "nullFunc_i": nullFunc_i,
  "nullFunc_ii": nullFunc_ii,
  "nullFunc_iid": nullFunc_iid,
  "nullFunc_iidd": nullFunc_iidd,
  "nullFunc_iiddd": nullFunc_iiddd,
  "nullFunc_iidddddd": nullFunc_iidddddd,
  "nullFunc_iiddi": nullFunc_iiddi,
  "nullFunc_iiddii": nullFunc_iiddii,
  "nullFunc_iiddiiiii": nullFunc_iiddiiiii,
  "nullFunc_iidi": nullFunc_iidi,
  "nullFunc_iidid": nullFunc_iidid,
  "nullFunc_iididii": nullFunc_iididii,
  "nullFunc_iidii": nullFunc_iidii,
  "nullFunc_iidiii": nullFunc_iidiii,
  "nullFunc_iidiiii": nullFunc_iidiiii,
  "nullFunc_iidiiiii": nullFunc_iidiiiii,
  "nullFunc_iifff": nullFunc_iifff,
  "nullFunc_iii": nullFunc_iii,
  "nullFunc_iiid": nullFunc_iiid,
  "nullFunc_iiidd": nullFunc_iiidd,
  "nullFunc_iiiddd": nullFunc_iiiddd,
  "nullFunc_iiidddddd": nullFunc_iiidddddd,
  "nullFunc_iiiddi": nullFunc_iiiddi,
  "nullFunc_iiiddiddddd": nullFunc_iiiddiddddd,
  "nullFunc_iiiddiiidd": nullFunc_iiiddiiidd,
  "nullFunc_iiidi": nullFunc_iiidi,
  "nullFunc_iiidid": nullFunc_iiidid,
  "nullFunc_iiididdddd": nullFunc_iiididdddd,
  "nullFunc_iiidii": nullFunc_iiidii,
  "nullFunc_iiidiii": nullFunc_iiidiii,
  "nullFunc_iiifff": nullFunc_iiifff,
  "nullFunc_iiii": nullFunc_iiii,
  "nullFunc_iiiid": nullFunc_iiiid,
  "nullFunc_iiiidd": nullFunc_iiiidd,
  "nullFunc_iiiiddiiidd": nullFunc_iiiiddiiidd,
  "nullFunc_iiiidi": nullFunc_iiiidi,
  "nullFunc_iiiidiii": nullFunc_iiiidiii,
  "nullFunc_iiiii": nullFunc_iiiii,
  "nullFunc_iiiiii": nullFunc_iiiiii,
  "nullFunc_iiiiiii": nullFunc_iiiiiii,
  "nullFunc_iiiiiiii": nullFunc_iiiiiiii,
  "nullFunc_ji": nullFunc_ji,
  "nullFunc_jiji": nullFunc_jiji,
  "nullFunc_v": nullFunc_v,
  "nullFunc_vi": nullFunc_vi,
  "nullFunc_vid": nullFunc_vid,
  "nullFunc_viddd": nullFunc_viddd,
  "nullFunc_vidii": nullFunc_vidii,
  "nullFunc_vii": nullFunc_vii,
  "nullFunc_viid": nullFunc_viid,
  "nullFunc_viidd": nullFunc_viidd,
  "nullFunc_viiddd": nullFunc_viiddd,
  "nullFunc_viif": nullFunc_viif,
  "nullFunc_viii": nullFunc_viii,
  "nullFunc_viiid": nullFunc_viiid,
  "nullFunc_viiidi": nullFunc_viiidi,
  "nullFunc_viiii": nullFunc_viiii,
  "nullFunc_viiiii": nullFunc_viiiii,
  "nullFunc_viiiiii": nullFunc_viiiiii,
  "ClassHandle": ClassHandle,
  "ClassHandle_clone": ClassHandle_clone,
  "ClassHandle_delete": ClassHandle_delete,
  "ClassHandle_deleteLater": ClassHandle_deleteLater,
  "ClassHandle_isAliasOf": ClassHandle_isAliasOf,
  "ClassHandle_isDeleted": ClassHandle_isDeleted,
  "RegisteredClass": RegisteredClass,
  "RegisteredPointer": RegisteredPointer,
  "RegisteredPointer_deleteObject": RegisteredPointer_deleteObject,
  "RegisteredPointer_destructor": RegisteredPointer_destructor,
  "RegisteredPointer_fromWireType": RegisteredPointer_fromWireType,
  "RegisteredPointer_getPointee": RegisteredPointer_getPointee,
  "___atomic_fetch_add_8": ___atomic_fetch_add_8,
  "___buildEnvironment": ___buildEnvironment,
  "___cxa_allocate_exception": ___cxa_allocate_exception,
  "___cxa_begin_catch": ___cxa_begin_catch,
  "___cxa_pure_virtual": ___cxa_pure_virtual,
  "___cxa_throw": ___cxa_throw,
  "___cxa_uncaught_exceptions": ___cxa_uncaught_exceptions,
  "___exception_addRef": ___exception_addRef,
  "___exception_deAdjust": ___exception_deAdjust,
  "___gxx_personality_v0": ___gxx_personality_v0,
  "___lock": ___lock,
  "___setErrNo": ___setErrNo,
  "___syscall140": ___syscall140,
  "___syscall145": ___syscall145,
  "___syscall146": ___syscall146,
  "___syscall195": ___syscall195,
  "___syscall197": ___syscall197,
  "___syscall221": ___syscall221,
  "___syscall5": ___syscall5,
  "___syscall54": ___syscall54,
  "___syscall6": ___syscall6,
  "___unlock": ___unlock,
  "__embind_finalize_value_array": __embind_finalize_value_array,
  "__embind_finalize_value_object": __embind_finalize_value_object,
  "__embind_register_bool": __embind_register_bool,
  "__embind_register_class": __embind_register_class,
  "__embind_register_class_class_function": __embind_register_class_class_function,
  "__embind_register_class_constructor": __embind_register_class_constructor,
  "__embind_register_class_function": __embind_register_class_function,
  "__embind_register_class_property": __embind_register_class_property,
  "__embind_register_emval": __embind_register_emval,
  "__embind_register_enum": __embind_register_enum,
  "__embind_register_enum_value": __embind_register_enum_value,
  "__embind_register_float": __embind_register_float,
  "__embind_register_integer": __embind_register_integer,
  "__embind_register_memory_view": __embind_register_memory_view,
  "__embind_register_std_string": __embind_register_std_string,
  "__embind_register_std_wstring": __embind_register_std_wstring,
  "__embind_register_value_array": __embind_register_value_array,
  "__embind_register_value_array_element": __embind_register_value_array_element,
  "__embind_register_value_object": __embind_register_value_object,
  "__embind_register_value_object_field": __embind_register_value_object_field,
  "__embind_register_void": __embind_register_void,
  "__emval_addMethodCaller": __emval_addMethodCaller,
  "__emval_allocateDestructors": __emval_allocateDestructors,
  "__emval_as": __emval_as,
  "__emval_call_method": __emval_call_method,
  "__emval_call_void_method": __emval_call_void_method,
  "__emval_decref": __emval_decref,
  "__emval_equals": __emval_equals,
  "__emval_get_global": __emval_get_global,
  "__emval_get_method_caller": __emval_get_method_caller,
  "__emval_get_module_property": __emval_get_module_property,
  "__emval_get_property": __emval_get_property,
  "__emval_incref": __emval_incref,
  "__emval_instanceof": __emval_instanceof,
  "__emval_is_number": __emval_is_number,
  "__emval_is_string": __emval_is_string,
  "__emval_lookupTypes": __emval_lookupTypes,
  "__emval_new": __emval_new,
  "__emval_new_array": __emval_new_array,
  "__emval_new_cstring": __emval_new_cstring,
  "__emval_new_object": __emval_new_object,