From cef187b5b2a91dd988298c3bf2764bb2f3e42e7a Mon Sep 17 00:00:00 2001 From: lalalune Date: Mon, 7 Oct 2024 04:54:44 +0000 Subject: [PATCH] deploy: 17397084c636126c16fb267ad79d308c76511769 --- index.html | 2 +- ktx2/libktx.js | 10272 +++++++++++++++++++++++++++++++++++++++++++++ ktx2/libktx.wasm | Bin 0 -> 1999219 bytes 3 files changed, 10273 insertions(+), 1 deletion(-) create mode 100644 ktx2/libktx.js create mode 100644 ktx2/libktx.wasm diff --git a/index.html b/index.html index 48640e2b..3043fcbc 100644 --- a/index.html +++ b/index.html @@ -16,7 +16,7 @@ - + diff --git a/ktx2/libktx.js b/ktx2/libktx.js new file mode 100644 index 00000000..1526faa3 --- /dev/null +++ b/ktx2/libktx.js @@ -0,0 +1,10272 @@ + +var LIBKTX = (function() { + var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined; + if (typeof __filename !== 'undefined') _scriptDir = _scriptDir || __filename; + return ( +function(LIBKTX) { + LIBKTX = LIBKTX || {}; + + + +// 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 LIBKTX !== 'undefined' ? LIBKTX : {}; + +// Set up the promise that indicates the Module is initialized +var readyPromiseResolve, readyPromiseReject; +Module['ready'] = new Promise(function(resolve, reject) { + readyPromiseResolve = resolve; + readyPromiseReject = reject; +}); + +// --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 = {}; +var key; +for (key in Module) { + if (Module.hasOwnProperty(key)) { + moduleOverrides[key] = Module[key]; + } +} + +var arguments_ = []; +var thisProgram = './this.program'; +var quit_ = function(status, toThrow) { + throw toThrow; +}; + +// Determine the runtime environment we are in. You can customize this by +// setting the ENVIRONMENT setting at compile time (see settings.js). + +// Attempt to auto-detect the environment +var ENVIRONMENT_IS_WEB = typeof window === 'object'; +var ENVIRONMENT_IS_WORKER = typeof importScripts === 'function'; +// N.b. Electron.js environment is simultaneously a NODE-environment, but +// also a web environment. +var ENVIRONMENT_IS_NODE = typeof process === 'object' && typeof process.versions === 'object' && typeof process.versions.node === 'string'; +var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER; + +// `/` should be present at the end if `scriptDirectory` is not empty +var scriptDirectory = ''; +function locateFile(path) { + if (Module['locateFile']) { + return Module['locateFile'](path, scriptDirectory); + } + return scriptDirectory + path; +} + +// Hooks that are implemented differently in different runtime environments. +var read_, + readAsync, + readBinary, + setWindowTitle; + +// 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; + var toLog = e; + err('exiting due to exception: ' + toLog); +} + +var nodeFS; +var nodePath; + +if (ENVIRONMENT_IS_NODE) { + if (ENVIRONMENT_IS_WORKER) { + scriptDirectory = require('path').dirname(scriptDirectory) + '/'; + } else { + scriptDirectory = __dirname + '/'; + } + +// include: node_shell_read.js + + +read_ = function shell_read(filename, binary) { + if (!nodeFS) nodeFS = require('fs'); + if (!nodePath) nodePath = require('path'); + filename = nodePath['normalize'](filename); + return nodeFS['readFileSync'](filename, binary ? null : 'utf8'); +}; + +readBinary = function readBinary(filename) { + var ret = read_(filename, true); + if (!ret.buffer) { + ret = new Uint8Array(ret); + } + assert(ret.buffer); + return ret; +}; + +readAsync = function readAsync(filename, onload, onerror) { + if (!nodeFS) nodeFS = require('fs'); + if (!nodePath) nodePath = require('path'); + filename = nodePath['normalize'](filename); + nodeFS['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); + + // MODULARIZE will export the module in the proper place outside, we don't need to export here + + 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_ = function(status, toThrow) { + if (keepRuntimeAlive()) { + process['exitCode'] = status; + throw toThrow; + } + logExceptionOnExit(toThrow); + process['exit'](status); + }; + + Module['inspect'] = function () { return '[Emscripten Module object]'; }; + +} else + +// Note that this includes Node.js workers when relevant (pthreads is enabled). +// Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and +// ENVIRONMENT_IS_NODE. +if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) { + if (ENVIRONMENT_IS_WORKER) { // Check worker, not web, since window could be polyfilled + scriptDirectory = self.location.href; + } else if (typeof document !== 'undefined' && document.currentScript) { // web + scriptDirectory = document.currentScript.src; + } + // When MODULARIZE, this JS may be executed later, after document.currentScript + // is gone, so we saved it, and we use it here instead of any other info. + if (_scriptDir) { + scriptDirectory = _scriptDir; + } + // blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them. + // otherwise, slice off the final part of the url to find the script directory. + // if scriptDirectory does not contain a slash, lastIndexOf will return -1, + // and scriptDirectory will correctly be replaced with an empty string. + // If scriptDirectory contains a query (starting with ?) or a fragment (starting with #), + // they are removed because they could contain a slash. + if (scriptDirectory.indexOf('blob:') !== 0) { + scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf('/')+1); + } else { + scriptDirectory = ''; + } + + // Differentiate the Web Worker from the Node Worker case, as reading must + // be done differently. + { + +// include: web_or_worker_shell_read.js + + + read_ = function(url) { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + xhr.send(null); + return xhr.responseText; + }; + + if (ENVIRONMENT_IS_WORKER) { + readBinary = function(url) { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + xhr.responseType = 'arraybuffer'; + xhr.send(null); + return new Uint8Array(/** @type{!ArrayBuffer} */(xhr.response)); + }; + } + + readAsync = function(url, onload, onerror) { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, true); + xhr.responseType = 'arraybuffer'; + xhr.onload = function() { + 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 = function(title) { document.title = title }; +} else +{ +} + +var out = Module['print'] || console.log.bind(console); +var err = Module['printErr'] || console.warn.bind(console); + +// Merge back in the overrides +for (key in moduleOverrides) { + if (moduleOverrides.hasOwnProperty(key)) { + Module[key] = moduleOverrides[key]; + } +} +// 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; + +// 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']; + +if (Module['thisProgram']) thisProgram = Module['thisProgram']; + +if (Module['quit']) quit_ = Module['quit']; + +// perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message + + + + +var STACK_ALIGN = 16; + +function getPointerSize() { + return 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 getPointerSize(); + } else if (type[0] === 'i') { + var 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 ("\0asm") + 0x01, 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 functionsInTableMap; + +function getEmptyTableSlot() { + // Reuse a free index if there is one, otherwise grow. + if (freeTableIndexes.length) { + return freeTableIndexes.pop(); + } + // Grow the table + try { + wasmTable.grow(1); + } catch (err) { + if (!(err instanceof RangeError)) { + throw err; + } + throw 'Unable to grow wasm table. Set ALLOW_TABLE_GROWTH.'; + } + return wasmTable.length - 1; +} + +function updateTableMap(offset, count) { + for (var i = offset; i < offset + count; i++) { + var item = getWasmTableEntry(i); + // Ignore null values. + if (item) { + functionsInTableMap.set(item, i); + } + } +} + +// Add a function to the table. +// 'sig' parameter is required if the function being added is a JS function. +function addFunction(func, sig) { + + // 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 (functionsInTableMap.has(func)) { + return functionsInTableMap.get(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 (err) { + if (!(err instanceof TypeError)) { + throw err; + } + var wrapped = convertJsFunctionToWasm(func, sig); + setWasmTableEntry(ret, wrapped); + } + + functionsInTableMap.set(func, ret); + + return ret; +} + +function removeFunction(index) { + functionsInTableMap.delete(getWasmTableEntry(index)); + freeTableIndexes.push(index); +} + +// end include: runtime_functions.js +// include: runtime_debug.js + + +// end include: runtime_debug.js +var tempRet0 = 0; + +var setTempRet0 = function(value) { + tempRet0 = value; +}; + +var getTempRet0 = function() { + return 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 wasmBinary; +if (Module['wasmBinary']) wasmBinary = Module['wasmBinary']; +var noExitRuntime = Module['noExitRuntime'] || true; + +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, noSafe) { + type = type || 'i8'; + if (type.charAt(type.length-1) === '*') type = 'i32'; + switch (type) { + case 'i1': HEAP8[((ptr)>>0)] = value; break; + case 'i8': HEAP8[((ptr)>>0)] = value; break; + case 'i16': HEAP16[((ptr)>>1)] = value; break; + case 'i32': HEAP32[((ptr)>>2)] = value; break; + case 'i64': (tempI64 = [value>>>0,(tempDouble=value,(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? ((Math.min((+(Math.floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)],HEAP32[((ptr)>>2)] = tempI64[0],HEAP32[(((ptr)+(4))>>2)] = tempI64[1]); break; + case 'float': HEAPF32[((ptr)>>2)] = value; break; + case 'double': HEAPF64[((ptr)>>3)] = value; break; + default: abort('invalid type for setValue: ' + type); + } +} + +/** @param {number} ptr + @param {string} type + @param {number|boolean=} noSafe */ +function getValue(ptr, type, noSafe) { + type = type || 'i8'; + if (type.charAt(type.length-1) === '*') type = 'i32'; + switch (type) { + case 'i1': return HEAP8[((ptr)>>0)]; + case 'i8': return HEAP8[((ptr)>>0)]; + case 'i16': return HEAP16[((ptr)>>1)]; + case 'i32': return HEAP32[((ptr)>>2)]; + case 'i64': return HEAP32[((ptr)>>2)]; + case 'float': return HEAPF32[((ptr)>>2)]; + case 'double': return Number(HEAPF64[((ptr)>>3)]); + 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, text) { + if (!condition) { + abort('Assertion failed: ' + 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 '\0' + var len = (str.length << 2) + 1; + ret = stackAlloc(len); + stringToUTF8(str, ret, len); + } + return ret; + }, + 'array': function(arr) { + var ret = stackAlloc(arr.length); + writeArrayToMemory(arr, ret); + return ret; + } + }; + + function convertReturnValue(ret) { + if (returnType === 'string') return UTF8ToString(ret); + if (returnType === 'boolean') return Boolean(ret); + return ret; + } + + var func = getCFunc(ident); + var cArgs = []; + var stack = 0; + if (args) { + for (var i = 0; i < args.length; i++) { + var converter = toC[argTypes[i]]; + if (converter) { + if (stack === 0) stack = stackSave(); + cArgs[i] = converter(args[i]); + } else { + cArgs[i] = args[i]; + } + } + } + var ret = func.apply(null, cArgs); + function onDone(ret) { + if (stack !== 0) stackRestore(stack); + return convertReturnValue(ret); + } + + ret = onDone(ret); + return ret; +} + +/** @param {string=} returnType + @param {Array=} argTypes + @param {Object=} opts */ +function cwrap(ident, returnType, argTypes, opts) { + argTypes = argTypes || []; + // When the function takes numbers and returns a number, we can just return + // the original function + var numericArgs = argTypes.every(function(type){ return type === 'number'}); + var numericRet = returnType !== 'string'; + if (numericRet && numericArgs && !opts) { + return getCFunc(ident); + } + return function() { + return ccall(ident, returnType, argTypes, arguments, opts); + } +} + +var ALLOC_NORMAL = 0; // Tries to use _malloc() +var ALLOC_STACK = 1; // Lives for the duration of the current function call + +// allocate(): This is for internal use. You can use it yourself as well, but the interface +// is a little tricky (see docs right below). The reason is that it is optimized +// for multiple syntaxes to save space in generated code. So you should +// normally not use allocate(), and instead allocate memory using _malloc(), +// initialize it with setValue(), and so forth. +// @slab: An array of data. +// @allocator: How to allocate memory, see ALLOC_* +/** @type {function((Uint8Array|Array), number)} */ +function allocate(slab, allocator) { + var ret; + + if (allocator == ALLOC_STACK) { + ret = stackAlloc(slab.length); + } else { + ret = _malloc(slab.length); + } + + if (slab.subarray || slab.slice) { + HEAPU8.set(/** @type {!Uint8Array} */(slab), ret); + } else { + HEAPU8.set(new Uint8Array(slab), ret); + } + return ret; +} + +// include: runtime_strings.js + + +// runtime_strings.js: Strings related runtime functions that are part of both MINIMAL_RUNTIME and regular runtime. + +// 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. + +var UTF8Decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf8') : undefined; + +/** + * @param {number} idx + * @param {number=} maxBytesToRead + * @return {string} + */ +function UTF8ArrayToString(heap, idx, maxBytesToRead) { + var endIdx = idx + maxBytesToRead; + var endPtr = idx; + // TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself. + // 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 (heap[endPtr] && !(endPtr >= endIdx)) ++endPtr; + + if (endPtr - idx > 16 && heap.subarray && UTF8Decoder) { + return UTF8Decoder.decode(heap.subarray(idx, endPtr)); + } else { + var str = ''; + // If building with TextDecoder, we have already computed the string length above, so test loop end condition against that + while (idx < endPtr) { + // For UTF8 byte structure, see: + // http://en.wikipedia.org/wiki/UTF-8#Description + // https://www.ietf.org/rfc/rfc2279.txt + // https://tools.ietf.org/html/rfc3629 + var u0 = heap[idx++]; + if (!(u0 & 0x80)) { str += String.fromCharCode(u0); continue; } + var u1 = heap[idx++] & 63; + if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; } + var u2 = heap[idx++] & 63; + if ((u0 & 0xF0) == 0xE0) { + u0 = ((u0 & 15) << 12) | (u1 << 6) | u2; + } else { + u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heap[idx++] & 63); + } + + if (u0 < 0x10000) { + str += String.fromCharCode(u0); + } else { + var ch = u0 - 0x10000; + str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF)); + } + } + } + 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 \0 byte. If maxBytesToRead is +// passed, and the string at [ptr, ptr+maxBytesToReadr[ contains a null byte in the +// 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(ptr, maxBytesToRead) { + ; + return ptr ? UTF8ArrayToString(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, heap, outIdx, maxBytesToWrite) { + if (!(maxBytesToWrite > 0)) // Parameter maxBytesToWrite is not optional. Negative values, 0, null, undefined and false each don't write out any bytes. + return 0; + + var startIdx = outIdx; + var endIdx = outIdx + maxBytesToWrite - 1; // -1 for string null terminator. + for (var i = 0; i < str.length; ++i) { + // 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. + // 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/rfc3629 + var u = str.charCodeAt(i); // possibly a lead surrogate + if (u >= 0xD800 && u <= 0xDFFF) { + var u1 = str.charCodeAt(++i); + u = 0x10000 + ((u & 0x3FF) << 10) | (u1 & 0x3FF); + } + if (u <= 0x7F) { + if (outIdx >= endIdx) break; + heap[outIdx++] = u; + } else if (u <= 0x7FF) { + if (outIdx + 1 >= endIdx) break; + heap[outIdx++] = 0xC0 | (u >> 6); + heap[outIdx++] = 0x80 | (u & 63); + } else if (u <= 0xFFFF) { + if (outIdx + 2 >= endIdx) break; + heap[outIdx++] = 0xE0 | (u >> 12); + heap[outIdx++] = 0x80 | ((u >> 6) & 63); + heap[outIdx++] = 0x80 | (u & 63); + } else { + if (outIdx + 3 >= endIdx) break; + heap[outIdx++] = 0xF0 | (u >> 18); + heap[outIdx++] = 0x80 | ((u >> 12) & 63); + heap[outIdx++] = 0x80 | ((u >> 6) & 63); + heap[outIdx++] = 0x80 | (u & 63); + } + } + // Null-terminate the pointer to the buffer. + heap[outIdx] = 0; + return outIdx - startIdx; +} + +// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', +// 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(str, outPtr, maxBytesToWrite) { + return stringToUTF8Array(str, HEAPU8,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 len = 0; + for (var i = 0; i < str.length; ++i) { + // 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. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var u = str.charCodeAt(i); // possibly a lead surrogate + if (u >= 0xD800 && u <= 0xDFFF) u = 0x10000 + ((u & 0x3FF) << 10) | (str.charCodeAt(++i) & 0x3FF); + if (u <= 0x7F) ++len; + else if (u <= 0x7FF) len += 2; + else if (u <= 0xFFFF) len += 3; + else len += 4; + } + return len; +} + +// end include: runtime_strings.js +// 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 ch = HEAPU8[((ptr++)>>0)]; + if (!ch) return str; + str += String.fromCharCode(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(str, outPtr) { + return writeAsciiToMemory(str, outPtr, false); +} + +// 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 UTF16Decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-16le') : undefined; + +function UTF16ToString(ptr, maxBytesToRead) { + var endPtr = ptr; + // TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself. + // Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage. + var idx = endPtr >> 1; + var maxIdx = idx + maxBytesToRead / 2; + // If maxBytesToRead is not passed explicitly, it will be undefined, and this + // will always evaluate to true. This saves on code size. + while (!(idx >= maxIdx) && HEAPU16[idx]) ++idx; + endPtr = idx << 1; + + if (endPtr - ptr > 32 && UTF16Decoder) { + return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr)); + } else { + var 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 i = 0; !(i >= maxBytesToRead / 2); ++i) { + var codeUnit = HEAP16[(((ptr)+(i*2))>>1)]; + if (codeUnit == 0) break; + // fromCharCode constructs a character from a UTF-16 code unit, so we can pass the UTF16 string right through. + str += String.fromCharCode(codeUnit); + } + + return 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(str, outPtr, maxBytesToWrite) { + // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. + if (maxBytesToWrite === undefined) { + maxBytesToWrite = 0x7FFFFFFF; + } + if (maxBytesToWrite < 2) return 0; + maxBytesToWrite -= 2; // Null terminator. + var startPtr = outPtr; + var numCharsToWrite = (maxBytesToWrite < str.length*2) ? (maxBytesToWrite / 2) : str.length; + for (var i = 0; i < numCharsToWrite; ++i) { + // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP. + var codeUnit = str.charCodeAt(i); // possibly a lead surrogate + HEAP16[((outPtr)>>1)] = codeUnit; + outPtr += 2; + } + // Null-terminate the pointer to the HEAP. + HEAP16[((outPtr)>>1)] = 0; + return outPtr - startPtr; +} + +// Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte. + +function lengthBytesUTF16(str) { + return str.length*2; +} + +function UTF32ToString(ptr, maxBytesToRead) { + var i = 0; + + 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 (!(i >= maxBytesToRead / 4)) { + var utf32 = HEAP32[(((ptr)+(i*4))>>2)]; + if (utf32 == 0) break; + ++i; + // 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-3 + if (utf32 >= 0x10000) { + var ch = utf32 - 0x10000; + str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF)); + } else { + str += String.fromCharCode(utf32); + } + } + return str; +} + +// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', +// 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(str, outPtr, maxBytesToWrite) { + // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. + if (maxBytesToWrite === undefined) { + maxBytesToWrite = 0x7FFFFFFF; + } + if (maxBytesToWrite < 4) return 0; + var startPtr = outPtr; + var endPtr = startPtr + maxBytesToWrite - 4; + for (var i = 0; i < str.length; ++i) { + // 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-3 + var codeUnit = str.charCodeAt(i); // possibly a lead surrogate + if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) { + var trailSurrogate = str.charCodeAt(++i); + codeUnit = 0x10000 + ((codeUnit & 0x3FF) << 10) | (trailSurrogate & 0x3FF); + } + HEAP32[((outPtr)>>2)] = codeUnit; + outPtr += 4; + if (outPtr + 4 > endPtr) break; + } + // Null-terminate the pointer to the HEAP. + HEAP32[((outPtr)>>2)] = 0; + return outPtr - startPtr; +} + +// Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte. + +function lengthBytesUTF32(str) { + var len = 0; + for (var i = 0; i < str.length; ++i) { + // 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-3 + var codeUnit = str.charCodeAt(i); + if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) ++i; // possibly a lead surrogate, so skip over the tail surrogate. + len += 4; + } + + return len; +} + +// Allocate heap space for a JS string, and write it there. +// It is the responsibility of the caller to free() that memory. +function allocateUTF8(str) { + var size = lengthBytesUTF8(str) + 1; + var ret = _malloc(size); + if (ret) stringToUTF8Array(str, HEAP8, ret, size); + return ret; +} + +// Allocate stack space for a JS string, and write it there. +function allocateUTF8OnStack(str) { + var size = lengthBytesUTF8(str) + 1; + var ret = stackAlloc(size); + stringToUTF8Array(str, HEAP8, ret, size); + return ret; +} + +// Deprecated: This function should not be called because it is unsafe and does not provide +// 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(string, buffer, dontAddNull) { + warnOnce('writeStringToMemory is deprecated and should not be called! Use stringToUTF8() instead!'); + + var /** @type {number} */ lastChar, /** @type {number} */ end; + if (dontAddNull) { + // 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 restore + // that after the write (below). + end = buffer + lengthBytesUTF8(string); + lastChar = HEAP8[end]; + } + stringToUTF8(string, buffer, Infinity); + if (dontAddNull) HEAP8[end] = lastChar; // Restore the value under the null character. +} + +function writeArrayToMemory(array, buffer) { + HEAP8.set(array, buffer); +} + +/** @param {boolean=} dontAddNull */ +function writeAsciiToMemory(str, buffer, dontAddNull) { + for (var i = 0; i < str.length; ++i) { + HEAP8[((buffer++)>>0)] = str.charCodeAt(i); + } + // Null-terminate the pointer to the HEAP. + if (!dontAddNull) HEAP8[((buffer)>>0)] = 0; +} + +// end include: runtime_strings_extra.js +// Memory management + +function alignUp(x, multiple) { + if (x % multiple > 0) { + x += multiple - (x % multiple); + } + return x; +} + +var HEAP, +/** @type {ArrayBuffer} */ + buffer, +/** @type {Int8Array} */ + HEAP8, +/** @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 = buf; + Module['HEAP8'] = HEAP8 = new Int8Array(buf); + Module['HEAP16'] = HEAP16 = new Int16Array(buf); + Module['HEAP32'] = HEAP32 = new Int32Array(buf); + Module['HEAPU8'] = HEAPU8 = new Uint8Array(buf); + Module['HEAPU16'] = HEAPU16 = new Uint16Array(buf); + Module['HEAPU32'] = HEAPU32 = new Uint32Array(buf); + Module['HEAPF32'] = HEAPF32 = new Float32Array(buf); + Module['HEAPF64'] = HEAPF64 = new Float64Array(buf); +} + +var TOTAL_STACK = 5242880; + +var INITIAL_MEMORY = Module['INITIAL_MEMORY'] || 16777216; + +// include: runtime_init_table.js +// In regular non-RELOCATABLE mode the table is exported +// from the wasm module and this will be assigned once +// the exports are available. +var wasmTable; + +// end include: runtime_init_table.js +// include: runtime_stack_check.js + + +// end include: runtime_stack_check.js +// include: runtime_assertions.js + + +// end include: runtime_assertions.js +var __ATPRERUN__ = []; // functions called before the runtime is initialized +var __ATINIT__ = []; // functions called during startup +var __ATEXIT__ = []; // functions called during shutdown +var __ATPOSTRUN__ = []; // functions called after the main() is called + +var runtimeInitialized = false; +var runtimeExited = false; +var runtimeKeepaliveCounter = 0; + +function keepRuntimeAlive() { + return noExitRuntime || runtimeKeepaliveCounter > 0; +} + +function preRun() { + + if (Module['preRun']) { + if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']]; + while (Module['preRun'].length) { + addOnPreRun(Module['preRun'].shift()); + } + } + + callRuntimeCallbacks(__ATPRERUN__); +} + +function initRuntime() { + runtimeInitialized = true; + + +if (!Module["noFSInit"] && !FS.init.initialized) + FS.init(); +FS.ignorePermissions = false; + +TTY.init(); + callRuntimeCallbacks(__ATINIT__); +} + +function exitRuntime() { + runtimeExited = true; +} + +function postRun() { + + if (Module['postRun']) { + if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']]; + while (Module['postRun'].length) { + addOnPostRun(Module['postRun'].shift()); + } + } + + callRuntimeCallbacks(__ATPOSTRUN__); +} + +function addOnPreRun(cb) { + __ATPRERUN__.unshift(cb); +} + +function addOnInit(cb) { + __ATINIT__.unshift(cb); +} + +function addOnExit(cb) { +} + +function addOnPostRun(cb) { + __ATPOSTRUN__.unshift(cb); +} + +// include: runtime_math.js + + +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul + +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/fround + +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32 + +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc + +// end include: runtime_math.js +// A counter of dependencies for calling run(). If we need to +// do asynchronous work before running, increment this and +// decrement it. Incrementing must happen in a place like +// Module.preRun (used by emcc to add file preloading). +// Note that you can add dependencies in preRun, even though +// it happens right before run - run will be postponed until +// the dependencies are met. +var runDependencies = 0; +var runDependencyWatcher = null; +var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled + +function getUniqueRunDependency(id) { + return id; +} + +function addRunDependency(id) { + runDependencies++; + + if (Module['monitorRunDependencies']) { + Module['monitorRunDependencies'](runDependencies); + } + +} + +function removeRunDependency(id) { + runDependencies--; + + if (Module['monitorRunDependencies']) { + Module['monitorRunDependencies'](runDependencies); + } + + if (runDependencies == 0) { + if (runDependencyWatcher !== null) { + clearInterval(runDependencyWatcher); + runDependencyWatcher = null; + } + if (dependenciesFulfilled) { + var callback = dependenciesFulfilled; + dependenciesFulfilled = null; + callback(); // can add another dependenciesFulfilled + } + } +} + +Module["preloadedImages"] = {}; // maps url to image data +Module["preloadedAudios"] = {}; // maps url to audio data + +/** @param {string|number=} what */ +function abort(what) { + { + if (Module['onAbort']) { + Module['onAbort'](what); + } + } + + what = 'Aborted(' + what + ')'; + // TODO(sbc): Should we remove printing and leave it up to whoever + // catches the exception? + err(what); + + ABORT = true; + EXITSTATUS = 1; + + what += '. Build with -s ASSERTIONS=1 for more info.'; + + // 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. + var e = new WebAssembly.RuntimeError(what); + + readyPromiseReject(e); + // Throw the error whether or not MODULARIZE is set because abort is used + // in code paths apart from instantiation where an exception is expected + // to be thrown when abort is called. + throw e; +} + +// {{MEM_INITIALIZER}} + +// include: memoryprofiler.js + + +// end include: memoryprofiler.js +// include: URIUtils.js + + +// Prefix of data URIs emitted by SINGLE_FILE and related options. +var dataURIPrefix = 'data:application/octet-stream;base64,'; + +// Indicates whether filename is a base64 data URI. +function isDataURI(filename) { + // Prefix of data URIs emitted by SINGLE_FILE and related options. + return filename.startsWith(dataURIPrefix); +} + +// Indicates whether filename is delivered via file protocol (as opposed to http/https) +function isFileURI(filename) { + return filename.startsWith('file://'); +} + +// end include: URIUtils.js +var wasmBinaryFile; + wasmBinaryFile = 'libktx.wasm'; + if (!isDataURI(wasmBinaryFile)) { + wasmBinaryFile = locateFile(wasmBinaryFile); + } + +function getBinary(file) { + try { + if (file == wasmBinaryFile && wasmBinary) { + return new Uint8Array(wasmBinary); + } + if (readBinary) { + return readBinary(file); + } else { + throw "both async and sync fetching of the wasm failed"; + } + } + catch (err) { + abort(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 (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) { + if (typeof fetch === 'function' + && !isFileURI(wasmBinaryFile) + ) { + return fetch(wasmBinaryFile, { credentials: 'same-origin' }).then(function(response) { + if (!response['ok']) { + throw "failed to load wasm binary file at '" + wasmBinaryFile + "'"; + } + return response['arrayBuffer'](); + }).catch(function () { + return getBinary(wasmBinaryFile); + }); + } + else { + if (readAsync) { + // fetch is not available or url is file => try XHR (readAsync uses XHR internally) + return new Promise(function(resolve, reject) { + readAsync(wasmBinaryFile, function(response) { resolve(new Uint8Array(/** @type{!ArrayBuffer} */(response))) }, reject) + }); + } + } + } + + // Otherwise, getBinary should be able to get it synchronously + return Promise.resolve().then(function() { return getBinary(wasmBinaryFile); }); +} + +// Create the wasm instance. +// Receives the wasm imports, returns the exports. +function createWasm() { + // prepare imports + var info = { + 'env': asmLibraryArg, + 'wasi_snapshot_preview1': 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(instance, module) { + var exports = instance.exports; + + Module['asm'] = exports; + + wasmMemory = Module['asm']['memory']; + updateGlobalBufferAndViews(wasmMemory.buffer); + + wasmTable = Module['asm']['__indirect_function_table']; + + addOnInit(Module['asm']['__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. + function receiveInstantiationResult(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 called + // 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(result['instance']); + } + + function instantiateArrayBuffer(receiver) { + return getBinaryPromise().then(function(binary) { + return WebAssembly.instantiate(binary, info); + }).then(function (instance) { + return instance; + }).then(receiver, function(reason) { + err('failed to asynchronously prepare wasm: ' + reason); + + abort(reason); + }); + } + + function instantiateAsync() { + if (!wasmBinary && + typeof WebAssembly.instantiateStreaming === 'function' && + !isDataURI(wasmBinaryFile) && + // Don't use streaming for file:// delivered objects in a webview, fetch them synchronously. + !isFileURI(wasmBinaryFile) && + typeof fetch === 'function') { + return fetch(wasmBinaryFile, { credentials: 'same-origin' }).then(function (response) { + var result = WebAssembly.instantiateStreaming(response, info); + + return result.then( + receiveInstantiationResult, + function(reason) { + // We expect the most common failure cause to be a bad MIME type for the binary, + // in which case falling back to ArrayBuffer instantiation should work. + err('wasm streaming compile failed: ' + reason); + err('falling back to ArrayBuffer instantiation'); + return instantiateArrayBuffer(receiveInstantiationResult); + }); + }); + } else { + return instantiateArrayBuffer(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. + if (Module['instantiateWasm']) { + try { + var exports = Module['instantiateWasm'](info, receiveInstance); + return exports; + } catch(e) { + err('Module.instantiateWasm callback failed with error: ' + e); + return false; + } + } + + // If instantiation fails, reject the module ready promise. + instantiateAsync().catch(readyPromiseReject); + return {}; // no exports yet; we'll fill them in later +} + +// Globals used by JS i64 conversions (see makeSetValue) +var tempDouble; +var tempI64; + +// === Body === + +var ASM_CONSTS = { + +}; + + + + + + + function callRuntimeCallbacks(callbacks) { + while (callbacks.length > 0) { + var callback = callbacks.shift(); + if (typeof callback == 'function') { + callback(Module); // Pass the module as the first argument. + continue; + } + var func = callback.func; + if (typeof func === 'number') { + if (callback.arg === undefined) { + getWasmTableEntry(func)(); + } else { + getWasmTableEntry(func)(callback.arg); + } + } else { + func(callback.arg === undefined ? null : callback.arg); + } + } + } + + function withStackSave(f) { + var stack = stackSave(); + var ret = f(); + stackRestore(stack); + return ret; + } + function demangle(func) { + return func; + } + + function demangleAll(text) { + var regex = + /\b_Z[\w\d_]+/g; + return text.replace(regex, + function(x) { + var y = demangle(x); + return x === y ? x : (y + ' [' + x + ']'); + }); + } + + var wasmTableMirror = []; + function getWasmTableEntry(funcPtr) { + var func = wasmTableMirror[funcPtr]; + if (!func) { + if (funcPtr >= wasmTableMirror.length) wasmTableMirror.length = funcPtr + 1; + wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr); + } + return func; + } + + function handleException(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 (e instanceof ExitStatus || e == 'unwind') { + return EXITSTATUS; + } + quit_(1, e); + } + + function jsStackTrace() { + var error = new Error(); + if (!error.stack) { + // IE10+ special cases: It does have callstack info, but it is only populated if an Error object is thrown, + // so try that as a special-case. + try { + throw new Error(); + } catch(e) { + error = e; + } + if (!error.stack) { + return '(no stack trace available)'; + } + } + return error.stack.toString(); + } + + function setWasmTableEntry(idx, func) { + wasmTable.set(idx, func); + wasmTableMirror[idx] = func; + } + + function stackTrace() { + var js = jsStackTrace(); + if (Module['extraStackTrace']) js += '\n' + Module['extraStackTrace'](); + return demangleAll(js); + } + + function ___assert_fail(condition, filename, line, func) { + abort('Assertion failed: ' + UTF8ToString(condition) + ', at: ' + [filename ? UTF8ToString(filename) : 'unknown filename', line, func ? UTF8ToString(func) : 'unknown function']); + } + + function ___cxa_allocate_exception(size) { + // Thrown object is prepended by exception metadata block + return _malloc(size + 16) + 16; + } + + function _atexit(func, arg) { + } + function ___cxa_atexit(a0,a1 + ) { + return _atexit(a0,a1); + } + + function ExceptionInfo(excPtr) { + this.excPtr = excPtr; + this.ptr = excPtr - 16; + + this.set_type = function(type) { + HEAP32[(((this.ptr)+(4))>>2)] = type; + }; + + this.get_type = function() { + return HEAP32[(((this.ptr)+(4))>>2)]; + }; + + this.set_destructor = function(destructor) { + HEAP32[(((this.ptr)+(8))>>2)] = destructor; + }; + + this.get_destructor = function() { + return HEAP32[(((this.ptr)+(8))>>2)]; + }; + + this.set_refcount = function(refcount) { + HEAP32[((this.ptr)>>2)] = refcount; + }; + + this.set_caught = function (caught) { + caught = caught ? 1 : 0; + HEAP8[(((this.ptr)+(12))>>0)] = caught; + }; + + this.get_caught = function () { + return HEAP8[(((this.ptr)+(12))>>0)] != 0; + }; + + this.set_rethrown = function (rethrown) { + rethrown = rethrown ? 1 : 0; + HEAP8[(((this.ptr)+(13))>>0)] = rethrown; + }; + + this.get_rethrown = function () { + return HEAP8[(((this.ptr)+(13))>>0)] != 0; + }; + + // Initialize native structure fields. Should be called once after allocated. + this.init = function(type, destructor) { + this.set_type(type); + this.set_destructor(destructor); + this.set_refcount(0); + this.set_caught(false); + this.set_rethrown(false); + } + + this.add_ref = function() { + var value = HEAP32[((this.ptr)>>2)]; + HEAP32[((this.ptr)>>2)] = value + 1; + }; + + // Returns true if last reference released. + this.release_ref = function() { + var prev = HEAP32[((this.ptr)>>2)]; + HEAP32[((this.ptr)>>2)] = prev - 1; + return prev === 1; + }; + } + + var exceptionLast = 0; + + var uncaughtExceptionCount = 0; + function ___cxa_throw(ptr, type, destructor) { + var info = new ExceptionInfo(ptr); + // Initialize ExceptionInfo content after it was allocated in __cxa_allocate_exception. + info.init(type, destructor); + exceptionLast = ptr; + uncaughtExceptionCount++; + throw ptr; + } + + function setErrNo(value) { + HEAP32[((___errno_location())>>2)] = value; + return value; + } + + var PATH = {splitPath:function(filename) { + var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/; + return splitPathRe.exec(filename).slice(1); + },normalizeArray:function(parts, allowAboveRoot) { + // if the path tries to go above the root, `up` ends up > 0 + var up = 0; + for (var i = parts.length - 1; i >= 0; i--) { + var last = parts[i]; + if (last === '.') { + parts.splice(i, 1); + } else if (last === '..') { + parts.splice(i, 1); + up++; + } else if (up) { + parts.splice(i, 1); + up--; + } + } + // if the path is allowed to go above the root, restore leading ..s + if (allowAboveRoot) { + for (; up; up--) { + parts.unshift('..'); + } + } + return parts; + },normalize:function(path) { + var isAbsolute = path.charAt(0) === '/', + trailingSlash = path.substr(-1) === '/'; + // Normalize the path + path = PATH.normalizeArray(path.split('/').filter(function(p) { + return !!p; + }), !isAbsolute).join('/'); + if (!path && !isAbsolute) { + path = '.'; + } + if (path && trailingSlash) { + path += '/'; + } + return (isAbsolute ? '/' : '') + path; + },dirname:function(path) { + var result = PATH.splitPath(path), + root = result[0], + dir = result[1]; + if (!root && !dir) { + // No dirname whatsoever + return '.'; + } + if (dir) { + // It has a dirname, strip trailing slash + dir = dir.substr(0, dir.length - 1); + } + return root + dir; + },basename:function(path) { + // EMSCRIPTEN return '/'' for '/', not an empty string + if (path === '/') return '/'; + path = PATH.normalize(path); + path = path.replace(/\/$/, ""); + var lastSlash = path.lastIndexOf('/'); + if (lastSlash === -1) return path; + return path.substr(lastSlash+1); + },extname:function(path) { + return PATH.splitPath(path)[3]; + },join:function() { + var paths = Array.prototype.slice.call(arguments, 0); + return PATH.normalize(paths.join('/')); + },join2:function(l, r) { + return PATH.normalize(l + '/' + r); + }}; + + function getRandomDevice() { + if (typeof crypto === 'object' && typeof crypto['getRandomValues'] === 'function') { + // for modern web browsers + var randomBuffer = new Uint8Array(1); + return function() { crypto.getRandomValues(randomBuffer); return randomBuffer[0]; }; + } else + if (ENVIRONMENT_IS_NODE) { + // for nodejs with or without crypto support included + try { + var crypto_module = require('crypto'); + // nodejs has crypto support + return function() { return crypto_module['randomBytes'](1)[0]; }; + } catch (e) { + // nodejs doesn't have crypto support + } + } + // we couldn't find a proper implementation, as Math.random() is not suitable for /dev/random, see emscripten-core/emscripten/pull/7096 + return function() { abort("randomDevice"); }; + } + + var PATH_FS = {resolve:function() { + var resolvedPath = '', + resolvedAbsolute = false; + for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) { + var path = (i >= 0) ? arguments[i] : FS.cwd(); + // Skip empty and invalid entries + if (typeof path !== 'string') { + throw new TypeError('Arguments to path.resolve must be strings'); + } else if (!path) { + return ''; // an invalid portion invalidates the whole thing + } + resolvedPath = path + '/' + resolvedPath; + resolvedAbsolute = path.charAt(0) === '/'; + } + // At this point the path should be resolved to a full absolute path, but + // handle relative paths to be safe (might happen when process.cwd() fails) + resolvedPath = PATH.normalizeArray(resolvedPath.split('/').filter(function(p) { + return !!p; + }), !resolvedAbsolute).join('/'); + return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.'; + },relative:function(from, to) { + from = PATH_FS.resolve(from).substr(1); + to = PATH_FS.resolve(to).substr(1); + function trim(arr) { + var start = 0; + for (; start < arr.length; start++) { + if (arr[start] !== '') break; + } + var end = arr.length - 1; + for (; end >= 0; end--) { + if (arr[end] !== '') break; + } + if (start > end) return []; + return arr.slice(start, end - start + 1); + } + var fromParts = trim(from.split('/')); + var toParts = trim(to.split('/')); + var length = Math.min(fromParts.length, toParts.length); + var samePartsLength = length; + for (var i = 0; i < length; i++) { + if (fromParts[i] !== toParts[i]) { + samePartsLength = i; + break; + } + } + var outputParts = []; + for (var i = samePartsLength; i < fromParts.length; i++) { + outputParts.push('..'); + } + outputParts = outputParts.concat(toParts.slice(samePartsLength)); + return outputParts.join('/'); + }}; + + var TTY = {ttys:[],init:function () { + // https://github.com/emscripten-core/emscripten/pull/1555 + // if (ENVIRONMENT_IS_NODE) { + // // currently, FS.init does not distinguish if process.stdin is a file or TTY + // // device, it always assumes it's a TTY device. because of this, we're forcing + // // process.stdin to UTF8 encoding to at least make stdin reading compatible + // // with text files until FS.init can be refactored. + // process['stdin']['setEncoding']('utf8'); + // } + },shutdown:function() { + // https://github.com/emscripten-core/emscripten/pull/1555 + // if (ENVIRONMENT_IS_NODE) { + // // inolen: any idea as to why node -e 'process.stdin.read()' wouldn't exit immediately (with process.stdin being a tty)? + // // isaacs: because now it's reading from the stream, you've expressed interest in it, so that read() kicks off a _read() which creates a ReadReq operation + // // inolen: I thought read() in that case was a synchronous operation that just grabbed some amount of buffered data if it exists? + // // isaacs: it is. but it also triggers a _read() call, which calls readStart() on the handle + // // isaacs: do process.stdin.pause() and i'd think it'd probably close the pending call + // process['stdin']['pause'](); + // } + },register:function(dev, ops) { + TTY.ttys[dev] = { input: [], output: [], ops: ops }; + FS.registerDevice(dev, TTY.stream_ops); + },stream_ops:{open:function(stream) { + var tty = TTY.ttys[stream.node.rdev]; + if (!tty) { + throw new FS.ErrnoError(43); + } + stream.tty = tty; + stream.seekable = false; + },close:function(stream) { + // flush any pending line data + stream.tty.ops.flush(stream.tty); + },flush:function(stream) { + stream.tty.ops.flush(stream.tty); + },read:function(stream, buffer, offset, length, pos /* ignored */) { + if (!stream.tty || !stream.tty.ops.get_char) { + throw new FS.ErrnoError(60); + } + var bytesRead = 0; + for (var i = 0; i < length; i++) { + var result; + try { + result = stream.tty.ops.get_char(stream.tty); + } catch (e) { + throw new FS.ErrnoError(29); + } + if (result === undefined && bytesRead === 0) { + throw new FS.ErrnoError(6); + } + if (result === null || result === undefined) break; + bytesRead++; + buffer[offset+i] = result; + } + if (bytesRead) { + stream.node.timestamp = Date.now(); + } + return bytesRead; + },write:function(stream, buffer, offset, length, pos) { + if (!stream.tty || !stream.tty.ops.put_char) { + throw new FS.ErrnoError(60); + } + try { + for (var i = 0; i < length; i++) { + stream.tty.ops.put_char(stream.tty, buffer[offset+i]); + } + } catch (e) { + throw new FS.ErrnoError(29); + } + if (length) { + stream.node.timestamp = Date.now(); + } + return i; + }},default_tty_ops:{get_char:function(tty) { + if (!tty.input.length) { + var result = null; + if (ENVIRONMENT_IS_NODE) { + // we will read data by chunks of BUFSIZE + var BUFSIZE = 256; + var buf = Buffer.alloc(BUFSIZE); + var bytesRead = 0; + + try { + bytesRead = nodeFS.readSync(process.stdin.fd, buf, 0, BUFSIZE, null); + } catch(e) { + // Cross-platform differences: on Windows, reading EOF throws an exception, but on other OSes, + // reading EOF returns 0. Uniformize behavior by treating the EOF exception to return 0. + if (e.toString().includes('EOF')) bytesRead = 0; + else throw e; + } + + if (bytesRead > 0) { + result = buf.slice(0, bytesRead).toString('utf-8'); + } else { + result = null; + } + } else + if (typeof window != 'undefined' && + typeof window.prompt == 'function') { + // Browser. + result = window.prompt('Input: '); // returns null on cancel + if (result !== null) { + result += '\n'; + } + } else if (typeof readline == 'function') { + // Command line. + result = readline(); + if (result !== null) { + result += '\n'; + } + } + if (!result) { + return null; + } + tty.input = intArrayFromString(result, true); + } + return tty.input.shift(); + },put_char:function(tty, val) { + if (val === null || val === 10) { + out(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } else { + if (val != 0) tty.output.push(val); // val == 0 would cut text output off in the middle. + } + },flush:function(tty) { + if (tty.output && tty.output.length > 0) { + out(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } + }},default_tty1_ops:{put_char:function(tty, val) { + if (val === null || val === 10) { + err(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } else { + if (val != 0) tty.output.push(val); + } + },flush:function(tty) { + if (tty.output && tty.output.length > 0) { + err(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } + }}}; + + function zeroMemory(address, size) { + HEAPU8.fill(0, address, address + size); + } + + function alignMemory(size, alignment) { + return Math.ceil(size / alignment) * alignment; + } + function mmapAlloc(size) { + abort(); + } + var MEMFS = {ops_table:null,mount:function(mount) { + return MEMFS.createNode(null, '/', 16384 | 511 /* 0777 */, 0); + },createNode:function(parent, name, mode, dev) { + if (FS.isBlkdev(mode) || FS.isFIFO(mode)) { + // no supported + throw new FS.ErrnoError(63); + } + if (!MEMFS.ops_table) { + MEMFS.ops_table = { + dir: { + node: { + getattr: MEMFS.node_ops.getattr, + setattr: MEMFS.node_ops.setattr, + lookup: MEMFS.node_ops.lookup, + mknod: MEMFS.node_ops.mknod, + rename: MEMFS.node_ops.rename, + unlink: MEMFS.node_ops.unlink, + rmdir: MEMFS.node_ops.rmdir, + readdir: MEMFS.node_ops.readdir, + symlink: MEMFS.node_ops.symlink + }, + stream: { + llseek: MEMFS.stream_ops.llseek + } + }, + file: { + node: { + getattr: MEMFS.node_ops.getattr, + setattr: MEMFS.node_ops.setattr + }, + stream: { + llseek: MEMFS.stream_ops.llseek, + read: MEMFS.stream_ops.read, + write: MEMFS.stream_ops.write, + allocate: MEMFS.stream_ops.allocate, + mmap: MEMFS.stream_ops.mmap, + msync: MEMFS.stream_ops.msync + } + }, + link: { + node: { + getattr: MEMFS.node_ops.getattr, + setattr: MEMFS.node_ops.setattr, + readlink: MEMFS.node_ops.readlink + }, + stream: {} + }, + chrdev: { + node: { + getattr: MEMFS.node_ops.getattr, + setattr: MEMFS.node_ops.setattr + }, + stream: FS.chrdev_stream_ops + } + }; + } + var node = FS.createNode(parent, name, mode, dev); + if (FS.isDir(node.mode)) { + node.node_ops = MEMFS.ops_table.dir.node; + node.stream_ops = MEMFS.ops_table.dir.stream; + node.contents = {}; + } else if (FS.isFile(node.mode)) { + node.node_ops = MEMFS.ops_table.file.node; + node.stream_ops = MEMFS.ops_table.file.stream; + node.usedBytes = 0; // The actual number of bytes used in the typed array, as opposed to contents.length which gives the whole capacity. + // When the byte data of the file is populated, this will point to either a typed array, or a normal JS array. Typed arrays are preferred + // for performance, and used by default. However, typed arrays are not resizable like normal JS arrays are, so there is a small disk size + // penalty involved for appending file writes that continuously grow a file similar to std::vector capacity vs used -scheme. + node.contents = null; + } else if (FS.isLink(node.mode)) { + node.node_ops = MEMFS.ops_table.link.node; + node.stream_ops = MEMFS.ops_table.link.stream; + } else if (FS.isChrdev(node.mode)) { + node.node_ops = MEMFS.ops_table.chrdev.node; + node.stream_ops = MEMFS.ops_table.chrdev.stream; + } + node.timestamp = Date.now(); + // add the new node to the parent + if (parent) { + parent.contents[name] = node; + parent.timestamp = node.timestamp; + } + return node; + },getFileDataAsTypedArray:function(node) { + if (!node.contents) return new Uint8Array(0); + if (node.contents.subarray) return node.contents.subarray(0, node.usedBytes); // Make sure to not return excess unused bytes. + return new Uint8Array(node.contents); + },expandFileStorage:function(node, newCapacity) { + var prevCapacity = node.contents ? node.contents.length : 0; + if (prevCapacity >= newCapacity) return; // No need to expand, the storage was already large enough. + // Don't expand strictly to the given requested limit if it's only a very small increase, but instead geometrically grow capacity. + // For small filesizes (<1MB), perform size*2 geometric increase, but for large sizes, do a much more conservative size*1.125 increase to + // avoid overshooting the allocation cap by a very large margin. + var CAPACITY_DOUBLING_MAX = 1024 * 1024; + newCapacity = Math.max(newCapacity, (prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2.0 : 1.125)) >>> 0); + if (prevCapacity != 0) newCapacity = Math.max(newCapacity, 256); // At minimum allocate 256b for each file when expanding. + var oldContents = node.contents; + node.contents = new Uint8Array(newCapacity); // Allocate new storage. + if (node.usedBytes > 0) node.contents.set(oldContents.subarray(0, node.usedBytes), 0); // Copy old data over to the new storage. + },resizeFileStorage:function(node, newSize) { + if (node.usedBytes == newSize) return; + if (newSize == 0) { + node.contents = null; // Fully decommit when requesting a resize to zero. + node.usedBytes = 0; + } else { + var oldContents = node.contents; + node.contents = new Uint8Array(newSize); // Allocate new storage. + if (oldContents) { + node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes))); // Copy old data over to the new storage. + } + node.usedBytes = newSize; + } + },node_ops:{getattr:function(node) { + var attr = {}; + // device numbers reuse inode numbers. + attr.dev = FS.isChrdev(node.mode) ? node.id : 1; + attr.ino = node.id; + attr.mode = node.mode; + attr.nlink = 1; + attr.uid = 0; + attr.gid = 0; + attr.rdev = node.rdev; + if (FS.isDir(node.mode)) { + attr.size = 4096; + } else if (FS.isFile(node.mode)) { + attr.size = node.usedBytes; + } else if (FS.isLink(node.mode)) { + attr.size = node.link.length; + } else { + attr.size = 0; + } + attr.atime = new Date(node.timestamp); + attr.mtime = new Date(node.timestamp); + attr.ctime = new Date(node.timestamp); + // NOTE: In our implementation, st_blocks = Math.ceil(st_size/st_blksize), + // but this is not required by the standard. + attr.blksize = 4096; + attr.blocks = Math.ceil(attr.size / attr.blksize); + return attr; + },setattr:function(node, attr) { + if (attr.mode !== undefined) { + node.mode = attr.mode; + } + if (attr.timestamp !== undefined) { + node.timestamp = attr.timestamp; + } + if (attr.size !== undefined) { + MEMFS.resizeFileStorage(node, attr.size); + } + },lookup:function(parent, name) { + throw FS.genericErrors[44]; + },mknod:function(parent, name, mode, dev) { + return MEMFS.createNode(parent, name, mode, dev); + },rename:function(old_node, new_dir, new_name) { + // if we're overwriting a directory at new_name, make sure it's empty. + if (FS.isDir(old_node.mode)) { + var new_node; + try { + new_node = FS.lookupNode(new_dir, new_name); + } catch (e) { + } + if (new_node) { + for (var i in new_node.contents) { + throw new FS.ErrnoError(55); + } + } + } + // do the internal rewiring + delete old_node.parent.contents[old_node.name]; + old_node.parent.timestamp = Date.now() + old_node.name = new_name; + new_dir.contents[new_name] = old_node; + new_dir.timestamp = old_node.parent.timestamp; + old_node.parent = new_dir; + },unlink:function(parent, name) { + delete parent.contents[name]; + parent.timestamp = Date.now(); + },rmdir:function(parent, name) { + var node = FS.lookupNode(parent, name); + for (var i in node.contents) { + throw new FS.ErrnoError(55); + } + delete parent.contents[name]; + parent.timestamp = Date.now(); + },readdir:function(node) { + var entries = ['.', '..']; + for (var key in node.contents) { + if (!node.contents.hasOwnProperty(key)) { + continue; + } + entries.push(key); + } + return entries; + },symlink:function(parent, newname, oldpath) { + var node = MEMFS.createNode(parent, newname, 511 /* 0777 */ | 40960, 0); + node.link = oldpath; + return node; + },readlink:function(node) { + if (!FS.isLink(node.mode)) { + throw new FS.ErrnoError(28); + } + return node.link; + }},stream_ops:{read:function(stream, buffer, offset, length, position) { + var contents = stream.node.contents; + if (position >= stream.node.usedBytes) return 0; + var size = Math.min(stream.node.usedBytes - position, length); + if (size > 8 && contents.subarray) { // non-trivial, and typed array + buffer.set(contents.subarray(position, position + size), offset); + } else { + for (var i = 0; i < size; i++) buffer[offset + i] = contents[position + i]; + } + return size; + },write:function(stream, buffer, offset, length, position, canOwn) { + // If the buffer is located in main memory (HEAP), and if + // memory can grow, we can't hold on to references of the + // memory buffer, as they may get invalidated. That means we + // need to do copy its contents. + if (buffer.buffer === HEAP8.buffer) { + canOwn = false; + } + + if (!length) return 0; + var node = stream.node; + node.timestamp = Date.now(); + + if (buffer.subarray && (!node.contents || node.contents.subarray)) { // This write is from a typed array to a typed array? + if (canOwn) { + node.contents = buffer.subarray(offset, offset + length); + node.usedBytes = length; + return length; + } else if (node.usedBytes === 0 && position === 0) { // If this is a simple first write to an empty file, do a fast set since we don't need to care about old data. + node.contents = buffer.slice(offset, offset + length); + node.usedBytes = length; + return length; + } else if (position + length <= node.usedBytes) { // Writing to an already allocated and used subrange of the file? + node.contents.set(buffer.subarray(offset, offset + length), position); + return length; + } + } + + // Appending to an existing file and we need to reallocate, or source data did not come as a typed array. + MEMFS.expandFileStorage(node, position+length); + if (node.contents.subarray && buffer.subarray) { + // Use typed array write which is available. + node.contents.set(buffer.subarray(offset, offset + length), position); + } else { + for (var i = 0; i < length; i++) { + node.contents[position + i] = buffer[offset + i]; // Or fall back to manual write if not. + } + } + node.usedBytes = Math.max(node.usedBytes, position + length); + return length; + },llseek:function(stream, offset, whence) { + var position = offset; + if (whence === 1) { + position += stream.position; + } else if (whence === 2) { + if (FS.isFile(stream.node.mode)) { + position += stream.node.usedBytes; + } + } + if (position < 0) { + throw new FS.ErrnoError(28); + } + return position; + },allocate:function(stream, offset, length) { + MEMFS.expandFileStorage(stream.node, offset + length); + stream.node.usedBytes = Math.max(stream.node.usedBytes, offset + length); + },mmap:function(stream, address, length, position, prot, flags) { + if (address !== 0) { + // We don't currently support location hints for the address of the mapping + throw new FS.ErrnoError(28); + } + if (!FS.isFile(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + var ptr; + var allocated; + var contents = stream.node.contents; + // Only make a new copy when MAP_PRIVATE is specified. + if (!(flags & 2) && contents.buffer === buffer) { + // We can't emulate MAP_SHARED when the file is not backed by the buffer + // we're mapping to (e.g. the HEAP buffer). + allocated = false; + ptr = contents.byteOffset; + } else { + // Try to avoid unnecessary slices. + if (position > 0 || position + length < contents.length) { + if (contents.subarray) { + contents = contents.subarray(position, position + length); + } else { + contents = Array.prototype.slice.call(contents, position, position + length); + } + } + allocated = true; + ptr = mmapAlloc(length); + if (!ptr) { + throw new FS.ErrnoError(48); + } + HEAP8.set(contents, ptr); + } + return { ptr: ptr, allocated: allocated }; + },msync:function(stream, buffer, offset, length, mmapFlags) { + if (!FS.isFile(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + if (mmapFlags & 2) { + // MAP_PRIVATE calls need not to be synced back to underlying fs + return 0; + } + + var bytesWritten = MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false); + // should we check if bytesWritten and length are the same? + return 0; + }}}; + + function asyncLoad(url, onload, onerror, noRunDep) { + var dep = !noRunDep ? getUniqueRunDependency('al ' + url) : ''; + readAsync(url, function(arrayBuffer) { + assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).'); + onload(new Uint8Array(arrayBuffer)); + if (dep) removeRunDependency(dep); + }, function(event) { + if (onerror) { + onerror(); + } else { + throw 'Loading data file "' + url + '" failed.'; + } + }); + if (dep) addRunDependency(dep); + } + var FS = {root:null,mounts:[],devices:{},streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,ErrnoError:null,genericErrors:{},filesystems:null,syncFSRequests:0,lookupPath:function(path, opts) { + path = PATH_FS.resolve(FS.cwd(), path); + opts = opts || {}; + + if (!path) return { path: '', node: null }; + + var defaults = { + follow_mount: true, + recurse_count: 0 + }; + for (var key in defaults) { + if (opts[key] === undefined) { + opts[key] = defaults[key]; + } + } + + if (opts.recurse_count > 8) { // max recursive lookup of 8 + throw new FS.ErrnoError(32); + } + + // split the path + var parts = PATH.normalizeArray(path.split('/').filter(function(p) { + return !!p; + }), false); + + // start at the root + var current = FS.root; + var current_path = '/'; + + for (var i = 0; i < parts.length; i++) { + var islast = (i === parts.length-1); + if (islast && opts.parent) { + // stop resolving + break; + } + + current = FS.lookupNode(current, parts[i]); + current_path = PATH.join2(current_path, parts[i]); + + // jump to the mount's root node if this is a mountpoint + if (FS.isMountpoint(current)) { + if (!islast || (islast && opts.follow_mount)) { + current = current.mounted.root; + } + } + + // by default, lookupPath will not follow a symlink if it is the final path component. + // setting opts.follow = true will override this behavior. + if (!islast || opts.follow) { + var count = 0; + while (FS.isLink(current.mode)) { + var link = FS.readlink(current_path); + current_path = PATH_FS.resolve(PATH.dirname(current_path), link); + + var lookup = FS.lookupPath(current_path, { recurse_count: opts.recurse_count }); + current = lookup.node; + + if (count++ > 40) { // limit max consecutive symlinks to 40 (SYMLOOP_MAX). + throw new FS.ErrnoError(32); + } + } + } + } + + return { path: current_path, node: current }; + },getPath:function(node) { + var path; + while (true) { + if (FS.isRoot(node)) { + var mount = node.mount.mountpoint; + if (!path) return mount; + return mount[mount.length-1] !== '/' ? mount + '/' + path : mount + path; + } + path = path ? node.name + '/' + path : node.name; + node = node.parent; + } + },hashName:function(parentid, name) { + var hash = 0; + + for (var i = 0; i < name.length; i++) { + hash = ((hash << 5) - hash + name.charCodeAt(i)) | 0; + } + return ((parentid + hash) >>> 0) % FS.nameTable.length; + },hashAddNode:function(node) { + var hash = FS.hashName(node.parent.id, node.name); + node.name_next = FS.nameTable[hash]; + FS.nameTable[hash] = node; + },hashRemoveNode:function(node) { + var hash = FS.hashName(node.parent.id, node.name); + if (FS.nameTable[hash] === node) { + FS.nameTable[hash] = node.name_next; + } else { + var current = FS.nameTable[hash]; + while (current) { + if (current.name_next === node) { + current.name_next = node.name_next; + break; + } + current = current.name_next; + } + } + },lookupNode:function(parent, name) { + var errCode = FS.mayLookup(parent); + if (errCode) { + throw new FS.ErrnoError(errCode, parent); + } + var hash = FS.hashName(parent.id, name); + for (var node = FS.nameTable[hash]; node; node = node.name_next) { + var nodeName = node.name; + if (node.parent.id === parent.id && nodeName === name) { + return node; + } + } + // if we failed to find it in the cache, call into the VFS + return FS.lookup(parent, name); + },createNode:function(parent, name, mode, rdev) { + var node = new FS.FSNode(parent, name, mode, rdev); + + FS.hashAddNode(node); + + return node; + },destroyNode:function(node) { + FS.hashRemoveNode(node); + },isRoot:function(node) { + return node === node.parent; + },isMountpoint:function(node) { + return !!node.mounted; + },isFile:function(mode) { + return (mode & 61440) === 32768; + },isDir:function(mode) { + return (mode & 61440) === 16384; + },isLink:function(mode) { + return (mode & 61440) === 40960; + },isChrdev:function(mode) { + return (mode & 61440) === 8192; + },isBlkdev:function(mode) { + return (mode & 61440) === 24576; + },isFIFO:function(mode) { + return (mode & 61440) === 4096; + },isSocket:function(mode) { + return (mode & 49152) === 49152; + },flagModes:{"r":0,"r+":2,"w":577,"w+":578,"a":1089,"a+":1090},modeStringToFlags:function(str) { + var flags = FS.flagModes[str]; + if (typeof flags === 'undefined') { + throw new Error('Unknown file open mode: ' + str); + } + return flags; + },flagsToPermissionString:function(flag) { + var perms = ['r', 'w', 'rw'][flag & 3]; + if ((flag & 512)) { + perms += 'w'; + } + return perms; + },nodePermissions:function(node, perms) { + if (FS.ignorePermissions) { + return 0; + } + // return 0 if any user, group or owner bits are set. + if (perms.includes('r') && !(node.mode & 292)) { + return 2; + } else if (perms.includes('w') && !(node.mode & 146)) { + return 2; + } else if (perms.includes('x') && !(node.mode & 73)) { + return 2; + } + return 0; + },mayLookup:function(dir) { + var errCode = FS.nodePermissions(dir, 'x'); + if (errCode) return errCode; + if (!dir.node_ops.lookup) return 2; + return 0; + },mayCreate:function(dir, name) { + try { + var node = FS.lookupNode(dir, name); + return 20; + } catch (e) { + } + return FS.nodePermissions(dir, 'wx'); + },mayDelete:function(dir, name, isdir) { + var node; + try { + node = FS.lookupNode(dir, name); + } catch (e) { + return e.errno; + } + var errCode = FS.nodePermissions(dir, 'wx'); + if (errCode) { + return errCode; + } + if (isdir) { + if (!FS.isDir(node.mode)) { + return 54; + } + if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) { + return 10; + } + } else { + if (FS.isDir(node.mode)) { + return 31; + } + } + return 0; + },mayOpen:function(node, flags) { + if (!node) { + return 44; + } + if (FS.isLink(node.mode)) { + return 32; + } else if (FS.isDir(node.mode)) { + if (FS.flagsToPermissionString(flags) !== 'r' || // opening for write + (flags & 512)) { // TODO: check for O_SEARCH? (== search for dir only) + return 31; + } + } + return FS.nodePermissions(node, FS.flagsToPermissionString(flags)); + },MAX_OPEN_FDS:4096,nextfd:function(fd_start, fd_end) { + fd_start = fd_start || 0; + fd_end = fd_end || FS.MAX_OPEN_FDS; + for (var fd = fd_start; fd <= fd_end; fd++) { + if (!FS.streams[fd]) { + return fd; + } + } + throw new FS.ErrnoError(33); + },getStream:function(fd) { + return FS.streams[fd]; + },createStream:function(stream, fd_start, fd_end) { + if (!FS.FSStream) { + FS.FSStream = /** @constructor */ function(){}; + FS.FSStream.prototype = { + object: { + get: function() { return this.node; }, + set: function(val) { this.node = val; } + }, + isRead: { + get: function() { return (this.flags & 2097155) !== 1; } + }, + isWrite: { + get: function() { return (this.flags & 2097155) !== 0; } + }, + isAppend: { + get: function() { return (this.flags & 1024); } + } + }; + } + // clone it, so we can return an instance of FSStream + var newStream = new FS.FSStream(); + for (var p in stream) { + newStream[p] = stream[p]; + } + stream = newStream; + var fd = FS.nextfd(fd_start, fd_end); + stream.fd = fd; + FS.streams[fd] = stream; + return stream; + },closeStream:function(fd) { + FS.streams[fd] = null; + },chrdev_stream_ops:{open:function(stream) { + var device = FS.getDevice(stream.node.rdev); + // override node's stream ops with the device's + stream.stream_ops = device.stream_ops; + // forward the open call + if (stream.stream_ops.open) { + stream.stream_ops.open(stream); + } + },llseek:function() { + throw new FS.ErrnoError(70); + }},major:function(dev) { + return ((dev) >> 8); + },minor:function(dev) { + return ((dev) & 0xff); + },makedev:function(ma, mi) { + return ((ma) << 8 | (mi)); + },registerDevice:function(dev, ops) { + FS.devices[dev] = { stream_ops: ops }; + },getDevice:function(dev) { + return FS.devices[dev]; + },getMounts:function(mount) { + var mounts = []; + var check = [mount]; + + while (check.length) { + var m = check.pop(); + + mounts.push(m); + + check.push.apply(check, m.mounts); + } + + return mounts; + },syncfs:function(populate, callback) { + if (typeof(populate) === 'function') { + callback = populate; + populate = false; + } + + FS.syncFSRequests++; + + if (FS.syncFSRequests > 1) { + err('warning: ' + FS.syncFSRequests + ' FS.syncfs operations in flight at once, probably just doing extra work'); + } + + var mounts = FS.getMounts(FS.root.mount); + var completed = 0; + + function doCallback(errCode) { + FS.syncFSRequests--; + return callback(errCode); + } + + function done(errCode) { + if (errCode) { + if (!done.errored) { + done.errored = true; + return doCallback(errCode); + } + return; + } + if (++completed >= mounts.length) { + doCallback(null); + } + }; + + // sync all mounts + mounts.forEach(function (mount) { + if (!mount.type.syncfs) { + return done(null); + } + mount.type.syncfs(mount, populate, done); + }); + },mount:function(type, opts, mountpoint) { + var root = mountpoint === '/'; + var pseudo = !mountpoint; + var node; + + if (root && FS.root) { + throw new FS.ErrnoError(10); + } else if (!root && !pseudo) { + var lookup = FS.lookupPath(mountpoint, { follow_mount: false }); + + mountpoint = lookup.path; // use the absolute path + node = lookup.node; + + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10); + } + + if (!FS.isDir(node.mode)) { + throw new FS.ErrnoError(54); + } + } + + var mount = { + type: type, + opts: opts, + mountpoint: mountpoint, + mounts: [] + }; + + // create a root node for the fs + var mountRoot = type.mount(mount); + mountRoot.mount = mount; + mount.root = mountRoot; + + if (root) { + FS.root = mountRoot; + } else if (node) { + // set as a mountpoint + node.mounted = mount; + + // add the new mount to the current mount's children + if (node.mount) { + node.mount.mounts.push(mount); + } + } + + return mountRoot; + },unmount:function (mountpoint) { + var lookup = FS.lookupPath(mountpoint, { follow_mount: false }); + + if (!FS.isMountpoint(lookup.node)) { + throw new FS.ErrnoError(28); + } + + // destroy the nodes for this mount, and all its child mounts + var node = lookup.node; + var mount = node.mounted; + var mounts = FS.getMounts(mount); + + Object.keys(FS.nameTable).forEach(function (hash) { + var current = FS.nameTable[hash]; + + while (current) { + var next = current.name_next; + + if (mounts.includes(current.mount)) { + FS.destroyNode(current); + } + + current = next; + } + }); + + // no longer a mountpoint + node.mounted = null; + + // remove this mount from the child mounts + var idx = node.mount.mounts.indexOf(mount); + node.mount.mounts.splice(idx, 1); + },lookup:function(parent, name) { + return parent.node_ops.lookup(parent, name); + },mknod:function(path, mode, dev) { + var lookup = FS.lookupPath(path, { parent: true }); + var parent = lookup.node; + var name = PATH.basename(path); + if (!name || name === '.' || name === '..') { + throw new FS.ErrnoError(28); + } + var errCode = FS.mayCreate(parent, name); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.mknod) { + throw new FS.ErrnoError(63); + } + return parent.node_ops.mknod(parent, name, mode, dev); + },create:function(path, mode) { + mode = mode !== undefined ? mode : 438 /* 0666 */; + mode &= 4095; + mode |= 32768; + return FS.mknod(path, mode, 0); + },mkdir:function(path, mode) { + mode = mode !== undefined ? mode : 511 /* 0777 */; + mode &= 511 | 512; + mode |= 16384; + return FS.mknod(path, mode, 0); + },mkdirTree:function(path, mode) { + var dirs = path.split('/'); + var d = ''; + for (var i = 0; i < dirs.length; ++i) { + if (!dirs[i]) continue; + d += '/' + dirs[i]; + try { + FS.mkdir(d, mode); + } catch(e) { + if (e.errno != 20) throw e; + } + } + },mkdev:function(path, mode, dev) { + if (typeof(dev) === 'undefined') { + dev = mode; + mode = 438 /* 0666 */; + } + mode |= 8192; + return FS.mknod(path, mode, dev); + },symlink:function(oldpath, newpath) { + if (!PATH_FS.resolve(oldpath)) { + throw new FS.ErrnoError(44); + } + var lookup = FS.lookupPath(newpath, { parent: true }); + var parent = lookup.node; + if (!parent) { + throw new FS.ErrnoError(44); + } + var newname = PATH.basename(newpath); + var errCode = FS.mayCreate(parent, newname); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.symlink) { + throw new FS.ErrnoError(63); + } + return parent.node_ops.symlink(parent, newname, oldpath); + },rename:function(old_path, new_path) { + var old_dirname = PATH.dirname(old_path); + var new_dirname = PATH.dirname(new_path); + var old_name = PATH.basename(old_path); + var new_name = PATH.basename(new_path); + // parents must exist + var lookup, old_dir, new_dir; + + // let the errors from non existant directories percolate up + lookup = FS.lookupPath(old_path, { parent: true }); + old_dir = lookup.node; + lookup = FS.lookupPath(new_path, { parent: true }); + new_dir = lookup.node; + + if (!old_dir || !new_dir) throw new FS.ErrnoError(44); + // need to be part of the same mount + if (old_dir.mount !== new_dir.mount) { + throw new FS.ErrnoError(75); + } + // source must exist + var old_node = FS.lookupNode(old_dir, old_name); + // old path should not be an ancestor of the new path + var relative = PATH_FS.relative(old_path, new_dirname); + if (relative.charAt(0) !== '.') { + throw new FS.ErrnoError(28); + } + // new path should not be an ancestor of the old path + relative = PATH_FS.relative(new_path, old_dirname); + if (relative.charAt(0) !== '.') { + throw new FS.ErrnoError(55); + } + // see if the new path already exists + var new_node; + try { + new_node = FS.lookupNode(new_dir, new_name); + } catch (e) { + // not fatal + } + // early out if nothing needs to change + if (old_node === new_node) { + return; + } + // we'll need to delete the old entry + var isdir = FS.isDir(old_node.mode); + var errCode = FS.mayDelete(old_dir, old_name, isdir); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + // need delete permissions if we'll be overwriting. + // need create permissions if new doesn't already exist. + errCode = new_node ? + FS.mayDelete(new_dir, new_name, isdir) : + FS.mayCreate(new_dir, new_name); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!old_dir.node_ops.rename) { + throw new FS.ErrnoError(63); + } + if (FS.isMountpoint(old_node) || (new_node && FS.isMountpoint(new_node))) { + throw new FS.ErrnoError(10); + } + // if we are going to change the parent, check write permissions + if (new_dir !== old_dir) { + errCode = FS.nodePermissions(old_dir, 'w'); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + } + // remove the node from the lookup hash + FS.hashRemoveNode(old_node); + // do the underlying fs rename + try { + old_dir.node_ops.rename(old_node, new_dir, new_name); + } catch (e) { + throw e; + } finally { + // add the node back to the hash (in case node_ops.rename + // changed its name) + FS.hashAddNode(old_node); + } + },rmdir:function(path) { + var lookup = FS.lookupPath(path, { parent: true }); + var parent = lookup.node; + var name = PATH.basename(path); + var node = FS.lookupNode(parent, name); + var errCode = FS.mayDelete(parent, name, true); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.rmdir) { + throw new FS.ErrnoError(63); + } + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10); + } + parent.node_ops.rmdir(parent, name); + FS.destroyNode(node); + },readdir:function(path) { + var lookup = FS.lookupPath(path, { follow: true }); + var node = lookup.node; + if (!node.node_ops.readdir) { + throw new FS.ErrnoError(54); + } + return node.node_ops.readdir(node); + },unlink:function(path) { + var lookup = FS.lookupPath(path, { parent: true }); + var parent = lookup.node; + var name = PATH.basename(path); + var node = FS.lookupNode(parent, name); + var errCode = FS.mayDelete(parent, name, false); + if (errCode) { + // According to POSIX, we should map EISDIR to EPERM, but + // we instead do what Linux does (and we must, as we use + // the musl linux libc). + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.unlink) { + throw new FS.ErrnoError(63); + } + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10); + } + parent.node_ops.unlink(parent, name); + FS.destroyNode(node); + },readlink:function(path) { + var lookup = FS.lookupPath(path); + var link = lookup.node; + if (!link) { + throw new FS.ErrnoError(44); + } + if (!link.node_ops.readlink) { + throw new FS.ErrnoError(28); + } + return PATH_FS.resolve(FS.getPath(link.parent), link.node_ops.readlink(link)); + },stat:function(path, dontFollow) { + var lookup = FS.lookupPath(path, { follow: !dontFollow }); + var node = lookup.node; + if (!node) { + throw new FS.ErrnoError(44); + } + if (!node.node_ops.getattr) { + throw new FS.ErrnoError(63); + } + return node.node_ops.getattr(node); + },lstat:function(path) { + return FS.stat(path, true); + },chmod:function(path, mode, dontFollow) { + var node; + if (typeof path === 'string') { + var lookup = FS.lookupPath(path, { follow: !dontFollow }); + node = lookup.node; + } else { + node = path; + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63); + } + node.node_ops.setattr(node, { + mode: (mode & 4095) | (node.mode & ~4095), + timestamp: Date.now() + }); + },lchmod:function(path, mode) { + FS.chmod(path, mode, true); + },fchmod:function(fd, mode) { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8); + } + FS.chmod(stream.node, mode); + },chown:function(path, uid, gid, dontFollow) { + var node; + if (typeof path === 'string') { + var lookup = FS.lookupPath(path, { follow: !dontFollow }); + node = lookup.node; + } else { + node = path; + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63); + } + node.node_ops.setattr(node, { + timestamp: Date.now() + // we ignore the uid / gid for now + }); + },lchown:function(path, uid, gid) { + FS.chown(path, uid, gid, true); + },fchown:function(fd, uid, gid) { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8); + } + FS.chown(stream.node, uid, gid); + },truncate:function(path, len) { + if (len < 0) { + throw new FS.ErrnoError(28); + } + var node; + if (typeof path === 'string') { + var lookup = FS.lookupPath(path, { follow: true }); + node = lookup.node; + } else { + node = path; + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63); + } + if (FS.isDir(node.mode)) { + throw new FS.ErrnoError(31); + } + if (!FS.isFile(node.mode)) { + throw new FS.ErrnoError(28); + } + var errCode = FS.nodePermissions(node, 'w'); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + node.node_ops.setattr(node, { + size: len, + timestamp: Date.now() + }); + },ftruncate:function(fd, len) { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(28); + } + FS.truncate(stream.node, len); + },utime:function(path, atime, mtime) { + var lookup = FS.lookupPath(path, { follow: true }); + var node = lookup.node; + node.node_ops.setattr(node, { + timestamp: Math.max(atime, mtime) + }); + },open:function(path, flags, mode, fd_start, fd_end) { + if (path === "") { + throw new FS.ErrnoError(44); + } + flags = typeof flags === 'string' ? FS.modeStringToFlags(flags) : flags; + mode = typeof mode === 'undefined' ? 438 /* 0666 */ : mode; + if ((flags & 64)) { + mode = (mode & 4095) | 32768; + } else { + mode = 0; + } + var node; + if (typeof path === 'object') { + node = path; + } else { + path = PATH.normalize(path); + try { + var lookup = FS.lookupPath(path, { + follow: !(flags & 131072) + }); + node = lookup.node; + } catch (e) { + // ignore + } + } + // perhaps we need to create the node + var created = false; + if ((flags & 64)) { + if (node) { + // if O_CREAT and O_EXCL are set, error out if the node already exists + if ((flags & 128)) { + throw new FS.ErrnoError(20); + } + } else { + // node doesn't exist, try to create it + node = FS.mknod(path, mode, 0); + created = true; + } + } + if (!node) { + throw new FS.ErrnoError(44); + } + // can't truncate a device + if (FS.isChrdev(node.mode)) { + flags &= ~512; + } + // if asked only for a directory, then this must be one + if ((flags & 65536) && !FS.isDir(node.mode)) { + throw new FS.ErrnoError(54); + } + // check permissions, if this is not a file we just created now (it is ok to + // create and write to a file with read-only permissions; it is read-only + // for later use) + if (!created) { + var errCode = FS.mayOpen(node, flags); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + } + // do truncation if necessary + if ((flags & 512)) { + FS.truncate(node, 0); + } + // we've already handled these, don't pass down to the underlying vfs + flags &= ~(128 | 512 | 131072); + + // register the stream with the filesystem + var stream = FS.createStream({ + node: node, + path: FS.getPath(node), // we want the absolute path to the node + id: node.id, + flags: flags, + mode: node.mode, + seekable: true, + position: 0, + stream_ops: node.stream_ops, + node_ops: node.node_ops, + // used by the file family libc calls (fopen, fwrite, ferror, etc.) + ungotten: [], + error: false + }, fd_start, fd_end); + // call the new stream's open function + if (stream.stream_ops.open) { + stream.stream_ops.open(stream); + } + if (Module['logReadFiles'] && !(flags & 1)) { + if (!FS.readFiles) FS.readFiles = {}; + if (!(path in FS.readFiles)) { + FS.readFiles[path] = 1; + } + } + return stream; + },close:function(stream) { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if (stream.getdents) stream.getdents = null; // free readdir state + try { + if (stream.stream_ops.close) { + stream.stream_ops.close(stream); + } + } catch (e) { + throw e; + } finally { + FS.closeStream(stream.fd); + } + stream.fd = null; + },isClosed:function(stream) { + return stream.fd === null; + },llseek:function(stream, offset, whence) { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if (!stream.seekable || !stream.stream_ops.llseek) { + throw new FS.ErrnoError(70); + } + if (whence != 0 && whence != 1 && whence != 2) { + throw new FS.ErrnoError(28); + } + stream.position = stream.stream_ops.llseek(stream, offset, whence); + stream.ungotten = []; + return stream.position; + },read:function(stream, buffer, offset, length, position) { + if (length < 0 || position < 0) { + throw new FS.ErrnoError(28); + } + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 1) { + throw new FS.ErrnoError(8); + } + if (FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(31); + } + if (!stream.stream_ops.read) { + throw new FS.ErrnoError(28); + } + var seeking = typeof position !== 'undefined'; + if (!seeking) { + position = stream.position; + } else if (!stream.seekable) { + throw new FS.ErrnoError(70); + } + var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position); + if (!seeking) stream.position += bytesRead; + return bytesRead; + },write:function(stream, buffer, offset, length, position, canOwn) { + if (length < 0 || position < 0) { + throw new FS.ErrnoError(28); + } + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(8); + } + if (FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(31); + } + if (!stream.stream_ops.write) { + throw new FS.ErrnoError(28); + } + if (stream.seekable && stream.flags & 1024) { + // seek to the end before writing in append mode + FS.llseek(stream, 0, 2); + } + var seeking = typeof position !== 'undefined'; + if (!seeking) { + position = stream.position; + } else if (!stream.seekable) { + throw new FS.ErrnoError(70); + } + var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn); + if (!seeking) stream.position += bytesWritten; + return bytesWritten; + },allocate:function(stream, offset, length) { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if (offset < 0 || length <= 0) { + throw new FS.ErrnoError(28); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(8); + } + if (!FS.isFile(stream.node.mode) && !FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + if (!stream.stream_ops.allocate) { + throw new FS.ErrnoError(138); + } + stream.stream_ops.allocate(stream, offset, length); + },mmap:function(stream, address, length, position, prot, flags) { + // User requests writing to file (prot & PROT_WRITE != 0). + // Checking if we have permissions to write to the file unless + // MAP_PRIVATE flag is set. According to POSIX spec it is possible + // to write to file opened in read-only mode with MAP_PRIVATE flag, + // as all modifications will be visible only in the memory of + // the current process. + if ((prot & 2) !== 0 + && (flags & 2) === 0 + && (stream.flags & 2097155) !== 2) { + throw new FS.ErrnoError(2); + } + if ((stream.flags & 2097155) === 1) { + throw new FS.ErrnoError(2); + } + if (!stream.stream_ops.mmap) { + throw new FS.ErrnoError(43); + } + return stream.stream_ops.mmap(stream, address, length, position, prot, flags); + },msync:function(stream, buffer, offset, length, mmapFlags) { + if (!stream || !stream.stream_ops.msync) { + return 0; + } + return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags); + },munmap:function(stream) { + return 0; + },ioctl:function(stream, cmd, arg) { + if (!stream.stream_ops.ioctl) { + throw new FS.ErrnoError(59); + } + return stream.stream_ops.ioctl(stream, cmd, arg); + },readFile:function(path, opts) { + opts = opts || {}; + opts.flags = opts.flags || 0; + opts.encoding = opts.encoding || 'binary'; + if (opts.encoding !== 'utf8' && opts.encoding !== 'binary') { + throw new Error('Invalid encoding type "' + opts.encoding + '"'); + } + var ret; + var stream = FS.open(path, opts.flags); + var stat = FS.stat(path); + var length = stat.size; + var buf = new Uint8Array(length); + FS.read(stream, buf, 0, length, 0); + if (opts.encoding === 'utf8') { + ret = UTF8ArrayToString(buf, 0); + } else if (opts.encoding === 'binary') { + ret = buf; + } + FS.close(stream); + return ret; + },writeFile:function(path, data, opts) { + opts = opts || {}; + opts.flags = opts.flags || 577; + var stream = FS.open(path, opts.flags, opts.mode); + if (typeof data === 'string') { + var buf = new Uint8Array(lengthBytesUTF8(data)+1); + var actualNumBytes = stringToUTF8Array(data, buf, 0, buf.length); + FS.write(stream, buf, 0, actualNumBytes, undefined, opts.canOwn); + } else if (ArrayBuffer.isView(data)) { + FS.write(stream, data, 0, data.byteLength, undefined, opts.canOwn); + } else { + throw new Error('Unsupported data type'); + } + FS.close(stream); + },cwd:function() { + return FS.currentPath; + },chdir:function(path) { + var lookup = FS.lookupPath(path, { follow: true }); + if (lookup.node === null) { + throw new FS.ErrnoError(44); + } + if (!FS.isDir(lookup.node.mode)) { + throw new FS.ErrnoError(54); + } + var errCode = FS.nodePermissions(lookup.node, 'x'); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + FS.currentPath = lookup.path; + },createDefaultDirectories:function() { + FS.mkdir('/tmp'); + FS.mkdir('/home'); + FS.mkdir('/home/web_user'); + },createDefaultDevices:function() { + // create /dev + FS.mkdir('/dev'); + // setup /dev/null + FS.registerDevice(FS.makedev(1, 3), { + read: function() { return 0; }, + write: function(stream, buffer, offset, length, pos) { return length; } + }); + FS.mkdev('/dev/null', FS.makedev(1, 3)); + // setup /dev/tty and /dev/tty1 + // stderr needs to print output using err() rather than out() + // so we register a second tty just for it. + TTY.register(FS.makedev(5, 0), TTY.default_tty_ops); + TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops); + FS.mkdev('/dev/tty', FS.makedev(5, 0)); + FS.mkdev('/dev/tty1', FS.makedev(6, 0)); + // setup /dev/[u]random + var random_device = getRandomDevice(); + FS.createDevice('/dev', 'random', random_device); + FS.createDevice('/dev', 'urandom', random_device); + // we're not going to emulate the actual shm device, + // just create the tmp dirs that reside in it commonly + FS.mkdir('/dev/shm'); + FS.mkdir('/dev/shm/tmp'); + },createSpecialDirectories:function() { + // create /proc/self/fd which allows /proc/self/fd/6 => readlink gives the + // name of the stream for fd 6 (see test_unistd_ttyname) + FS.mkdir('/proc'); + var proc_self = FS.mkdir('/proc/self'); + FS.mkdir('/proc/self/fd'); + FS.mount({ + mount: function() { + var node = FS.createNode(proc_self, 'fd', 16384 | 511 /* 0777 */, 73); + node.node_ops = { + lookup: function(parent, name) { + var fd = +name; + var stream = FS.getStream(fd); + if (!stream) throw new FS.ErrnoError(8); + var ret = { + parent: null, + mount: { mountpoint: 'fake' }, + node_ops: { readlink: function() { return stream.path } } + }; + ret.parent = ret; // make it look like a simple root node + return ret; + } + }; + return node; + } + }, {}, '/proc/self/fd'); + },createStandardStreams:function() { + // TODO deprecate the old functionality of a single + // input / output callback and that utilizes FS.createDevice + // and instead require a unique set of stream ops + + // by default, we symlink the standard streams to the + // default tty devices. however, if the standard streams + // have been overwritten we create a unique device for + // them instead. + if (Module['stdin']) { + FS.createDevice('/dev', 'stdin', Module['stdin']); + } else { + FS.symlink('/dev/tty', '/dev/stdin'); + } + if (Module['stdout']) { + FS.createDevice('/dev', 'stdout', null, Module['stdout']); + } else { + FS.symlink('/dev/tty', '/dev/stdout'); + } + if (Module['stderr']) { + FS.createDevice('/dev', 'stderr', null, Module['stderr']); + } else { + FS.symlink('/dev/tty1', '/dev/stderr'); + } + + // open default streams for the stdin, stdout and stderr devices + var stdin = FS.open('/dev/stdin', 0); + var stdout = FS.open('/dev/stdout', 1); + var stderr = FS.open('/dev/stderr', 1); + },ensureErrnoError:function() { + if (FS.ErrnoError) return; + FS.ErrnoError = /** @this{Object} */ function ErrnoError(errno, node) { + this.node = node; + this.setErrno = /** @this{Object} */ function(errno) { + this.errno = errno; + }; + this.setErrno(errno); + this.message = 'FS error'; + + }; + FS.ErrnoError.prototype = new Error(); + FS.ErrnoError.prototype.constructor = FS.ErrnoError; + // Some errors may happen quite a bit, to avoid overhead we reuse them (and suffer a lack of stack info) + [44].forEach(function(code) { + FS.genericErrors[code] = new FS.ErrnoError(code); + FS.genericErrors[code].stack = ''; + }); + },staticInit:function() { + FS.ensureErrnoError(); + + FS.nameTable = new Array(4096); + + FS.mount(MEMFS, {}, '/'); + + FS.createDefaultDirectories(); + FS.createDefaultDevices(); + FS.createSpecialDirectories(); + + FS.filesystems = { + 'MEMFS': MEMFS, + }; + },init:function(input, output, error) { + FS.init.initialized = true; + + FS.ensureErrnoError(); + + // Allow Module.stdin etc. to provide defaults, if none explicitly passed to us here + Module['stdin'] = input || Module['stdin']; + Module['stdout'] = output || Module['stdout']; + Module['stderr'] = error || Module['stderr']; + + FS.createStandardStreams(); + },quit:function() { + FS.init.initialized = false; + // force-flush all streams, so we get musl std streams printed out + var fflush = Module['_fflush']; + if (fflush) fflush(0); + // close all of our streams + for (var i = 0; i < FS.streams.length; i++) { + var stream = FS.streams[i]; + if (!stream) { + continue; + } + FS.close(stream); + } + },getMode:function(canRead, canWrite) { + var mode = 0; + if (canRead) mode |= 292 | 73; + if (canWrite) mode |= 146; + return mode; + },findObject:function(path, dontResolveLastLink) { + var ret = FS.analyzePath(path, dontResolveLastLink); + if (ret.exists) { + return ret.object; + } else { + return null; + } + },analyzePath:function(path, dontResolveLastLink) { + // operate from within the context of the symlink's target + try { + var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink }); + path = lookup.path; + } catch (e) { + } + var ret = { + isRoot: false, exists: false, error: 0, name: null, path: null, object: null, + parentExists: false, parentPath: null, parentObject: null + }; + try { + var lookup = FS.lookupPath(path, { parent: true }); + ret.parentExists = true; + ret.parentPath = lookup.path; + ret.parentObject = lookup.node; + ret.name = PATH.basename(path); + lookup = FS.lookupPath(path, { follow: !dontResolveLastLink }); + ret.exists = true; + ret.path = lookup.path; + ret.object = lookup.node; + ret.name = lookup.node.name; + ret.isRoot = lookup.path === '/'; + } catch (e) { + ret.error = e.errno; + }; + return ret; + },createPath:function(parent, path, canRead, canWrite) { + parent = typeof parent === 'string' ? parent : FS.getPath(parent); + var parts = path.split('/').reverse(); + while (parts.length) { + var part = parts.pop(); + if (!part) continue; + var current = PATH.join2(parent, part); + try { + FS.mkdir(current); + } catch (e) { + // ignore EEXIST + } + parent = current; + } + return current; + },createFile:function(parent, name, properties, canRead, canWrite) { + var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name); + var mode = FS.getMode(canRead, canWrite); + return FS.create(path, mode); + },createDataFile:function(parent, name, data, canRead, canWrite, canOwn) { + var path = name ? PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name) : parent; + var mode = FS.getMode(canRead, canWrite); + var node = FS.create(path, mode); + if (data) { + if (typeof data === 'string') { + var arr = new Array(data.length); + for (var i = 0, len = data.length; i < len; ++i) arr[i] = data.charCodeAt(i); + data = arr; + } + // make sure we can write to the file + FS.chmod(node, mode | 146); + var stream = FS.open(node, 577); + FS.write(stream, data, 0, data.length, 0, canOwn); + FS.close(stream); + FS.chmod(node, mode); + } + return node; + },createDevice:function(parent, name, input, output) { + var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name); + var mode = FS.getMode(!!input, !!output); + if (!FS.createDevice.major) FS.createDevice.major = 64; + var dev = FS.makedev(FS.createDevice.major++, 0); + // Create a fake device that a set of stream ops to emulate + // the old behavior. + FS.registerDevice(dev, { + open: function(stream) { + stream.seekable = false; + }, + close: function(stream) { + // flush any pending line data + if (output && output.buffer && output.buffer.length) { + output(10); + } + }, + read: function(stream, buffer, offset, length, pos /* ignored */) { + var bytesRead = 0; + for (var i = 0; i < length; i++) { + var result; + try { + result = input(); + } catch (e) { + throw new FS.ErrnoError(29); + } + if (result === undefined && bytesRead === 0) { + throw new FS.ErrnoError(6); + } + if (result === null || result === undefined) break; + bytesRead++; + buffer[offset+i] = result; + } + if (bytesRead) { + stream.node.timestamp = Date.now(); + } + return bytesRead; + }, + write: function(stream, buffer, offset, length, pos) { + for (var i = 0; i < length; i++) { + try { + output(buffer[offset+i]); + } catch (e) { + throw new FS.ErrnoError(29); + } + } + if (length) { + stream.node.timestamp = Date.now(); + } + return i; + } + }); + return FS.mkdev(path, mode, dev); + },forceLoadFile:function(obj) { + if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true; + if (typeof XMLHttpRequest !== 'undefined') { + throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread."); + } else if (read_) { + // Command-line. + try { + // WARNING: Can't read binary files in V8's d8 or tracemonkey's js, as + // read() will try to parse UTF8. + obj.contents = intArrayFromString(read_(obj.url), true); + obj.usedBytes = obj.contents.length; + } catch (e) { + throw new FS.ErrnoError(29); + } + } else { + throw new Error('Cannot load without read() or XMLHttpRequest.'); + } + },createLazyFile:function(parent, name, url, canRead, canWrite) { + // Lazy chunked Uint8Array (implements get and length from Uint8Array). Actual getting is abstracted away for eventual reuse. + /** @constructor */ + function LazyUint8Array() { + this.lengthKnown = false; + this.chunks = []; // Loaded chunks. Index is the chunk number + } + LazyUint8Array.prototype.get = /** @this{Object} */ function LazyUint8Array_get(idx) { + if (idx > this.length-1 || idx < 0) { + return undefined; + } + var chunkOffset = idx % this.chunkSize; + var chunkNum = (idx / this.chunkSize)|0; + return this.getter(chunkNum)[chunkOffset]; + }; + LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) { + this.getter = getter; + }; + LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() { + // Find length + var xhr = new XMLHttpRequest(); + xhr.open('HEAD', url, false); + xhr.send(null); + if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status); + var datalength = Number(xhr.getResponseHeader("Content-length")); + var header; + var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes"; + var usesGzip = (header = xhr.getResponseHeader("Content-Encoding")) && header === "gzip"; + + var chunkSize = 1024*1024; // Chunk size in bytes + + if (!hasByteServing) chunkSize = datalength; + + // Function to get a range from the remote URL. + var doXHR = (function(from, to) { + if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!"); + if (to > datalength-1) throw new Error("only " + datalength + " bytes available! programmer error!"); + + // TODO: Use mozResponseArrayBuffer, responseStream, etc. if available. + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to); + + // Some hints to the browser that we want binary data. + if (typeof Uint8Array != 'undefined') xhr.responseType = 'arraybuffer'; + if (xhr.overrideMimeType) { + xhr.overrideMimeType('text/plain; charset=x-user-defined'); + } + + xhr.send(null); + if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status); + if (xhr.response !== undefined) { + return new Uint8Array(/** @type{Array} */(xhr.response || [])); + } else { + return intArrayFromString(xhr.responseText || '', true); + } + }); + var lazyArray = this; + lazyArray.setDataGetter(function(chunkNum) { + var start = chunkNum * chunkSize; + var end = (chunkNum+1) * chunkSize - 1; // including this byte + end = Math.min(end, datalength-1); // if datalength-1 is selected, this is the last block + if (typeof(lazyArray.chunks[chunkNum]) === "undefined") { + lazyArray.chunks[chunkNum] = doXHR(start, end); + } + if (typeof(lazyArray.chunks[chunkNum]) === "undefined") throw new Error("doXHR failed!"); + return lazyArray.chunks[chunkNum]; + }); + + if (usesGzip || !datalength) { + // if the server uses gzip or doesn't supply the length, we have to download the whole file to get the (uncompressed) length + chunkSize = datalength = 1; // this will force getter(0)/doXHR do download the whole file + datalength = this.getter(0).length; + chunkSize = datalength; + out("LazyFiles on gzip forces download of the whole file when length is accessed"); + } + + this._length = datalength; + this._chunkSize = chunkSize; + this.lengthKnown = true; + }; + if (typeof XMLHttpRequest !== 'undefined') { + if (!ENVIRONMENT_IS_WORKER) throw 'Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc'; + var lazyArray = new LazyUint8Array(); + Object.defineProperties(lazyArray, { + length: { + get: /** @this{Object} */ function() { + if (!this.lengthKnown) { + this.cacheLength(); + } + return this._length; + } + }, + chunkSize: { + get: /** @this{Object} */ function() { + if (!this.lengthKnown) { + this.cacheLength(); + } + return this._chunkSize; + } + } + }); + + var properties = { isDevice: false, contents: lazyArray }; + } else { + var properties = { isDevice: false, url: url }; + } + + var node = FS.createFile(parent, name, properties, canRead, canWrite); + // This is a total hack, but I want to get this lazy file code out of the + // core of MEMFS. If we want to keep this lazy file concept I feel it should + // be its own thin LAZYFS proxying calls to MEMFS. + if (properties.contents) { + node.contents = properties.contents; + } else if (properties.url) { + node.contents = null; + node.url = properties.url; + } + // Add a function that defers querying the file size until it is asked the first time. + Object.defineProperties(node, { + usedBytes: { + get: /** @this {FSNode} */ function() { return this.contents.length; } + } + }); + // override each stream op with one that tries to force load the lazy file first + var stream_ops = {}; + var keys = Object.keys(node.stream_ops); + keys.forEach(function(key) { + var fn = node.stream_ops[key]; + stream_ops[key] = function forceLoadLazyFile() { + FS.forceLoadFile(node); + return fn.apply(null, arguments); + }; + }); + // use a custom read function + stream_ops.read = function stream_ops_read(stream, buffer, offset, length, position) { + FS.forceLoadFile(node); + var contents = stream.node.contents; + if (position >= contents.length) + return 0; + var size = Math.min(contents.length - position, length); + if (contents.slice) { // normal array + for (var i = 0; i < size; i++) { + buffer[offset + i] = contents[position + i]; + } + } else { + for (var i = 0; i < size; i++) { // LazyUint8Array from sync binary XHR + buffer[offset + i] = contents.get(position + i); + } + } + return size; + }; + node.stream_ops = stream_ops; + return node; + },createPreloadedFile:function(parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) { + Browser.init(); // XXX perhaps this method should move onto Browser? + // TODO we should allow people to just pass in a complete filename instead + // of parent and name being that we just join them anyways + var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent; + var dep = getUniqueRunDependency('cp ' + fullname); // might have several active requests for the same fullname + function processData(byteArray) { + function finish(byteArray) { + if (preFinish) preFinish(); + if (!dontCreateFile) { + FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn); + } + if (onload) onload(); + removeRunDependency(dep); + } + var handled = false; + Module['preloadPlugins'].forEach(function(plugin) { + if (handled) return; + if (plugin['canHandle'](fullname)) { + plugin['handle'](byteArray, fullname, finish, function() { + if (onerror) onerror(); + removeRunDependency(dep); + }); + handled = true; + } + }); + if (!handled) finish(byteArray); + } + addRunDependency(dep); + if (typeof url == 'string') { + asyncLoad(url, function(byteArray) { + processData(byteArray); + }, onerror); + } else { + processData(url); + } + },indexedDB:function() { + return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB; + },DB_NAME:function() { + return 'EM_FS_' + window.location.pathname; + },DB_VERSION:20,DB_STORE_NAME:"FILE_DATA",saveFilesToDB:function(paths, onload, onerror) { + onload = onload || function(){}; + onerror = onerror || function(){}; + var indexedDB = FS.indexedDB(); + try { + var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION); + } catch (e) { + return onerror(e); + } + openRequest.onupgradeneeded = function openRequest_onupgradeneeded() { + out('creating db'); + var db = openRequest.result; + db.createObjectStore(FS.DB_STORE_NAME); + }; + openRequest.onsuccess = function openRequest_onsuccess() { + var db = openRequest.result; + var transaction = db.transaction([FS.DB_STORE_NAME], 'readwrite'); + var files = transaction.objectStore(FS.DB_STORE_NAME); + var ok = 0, fail = 0, total = paths.length; + function finish() { + if (fail == 0) onload(); else onerror(); + } + paths.forEach(function(path) { + var putRequest = files.put(FS.analyzePath(path).object.contents, path); + putRequest.onsuccess = function putRequest_onsuccess() { ok++; if (ok + fail == total) finish() }; + putRequest.onerror = function putRequest_onerror() { fail++; if (ok + fail == total) finish() }; + }); + transaction.onerror = onerror; + }; + openRequest.onerror = onerror; + },loadFilesFromDB:function(paths, onload, onerror) { + onload = onload || function(){}; + onerror = onerror || function(){}; + var indexedDB = FS.indexedDB(); + try { + var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION); + } catch (e) { + return onerror(e); + } + openRequest.onupgradeneeded = onerror; // no database to load from + openRequest.onsuccess = function openRequest_onsuccess() { + var db = openRequest.result; + try { + var transaction = db.transaction([FS.DB_STORE_NAME], 'readonly'); + } catch(e) { + onerror(e); + return; + } + var files = transaction.objectStore(FS.DB_STORE_NAME); + var ok = 0, fail = 0, total = paths.length; + function finish() { + if (fail == 0) onload(); else onerror(); + } + paths.forEach(function(path) { + var getRequest = files.get(path); + getRequest.onsuccess = function getRequest_onsuccess() { + if (FS.analyzePath(path).exists) { + FS.unlink(path); + } + FS.createDataFile(PATH.dirname(path), PATH.basename(path), getRequest.result, true, true, true); + ok++; + if (ok + fail == total) finish(); + }; + getRequest.onerror = function getRequest_onerror() { fail++; if (ok + fail == total) finish() }; + }); + transaction.onerror = onerror; + }; + openRequest.onerror = onerror; + }}; + var SYSCALLS = {mappings:{},DEFAULT_POLLMASK:5,calculateAt:function(dirfd, path, allowEmpty) { + if (path[0] === '/') { + return path; + } + // relative path + var dir; + if (dirfd === -100) { + dir = FS.cwd(); + } else { + var dirstream = FS.getStream(dirfd); + if (!dirstream) throw new FS.ErrnoError(8); + dir = dirstream.path; + } + if (path.length == 0) { + if (!allowEmpty) { + throw new FS.ErrnoError(44);; + } + return dir; + } + return PATH.join2(dir, path); + },doStat:function(func, path, buf) { + try { + var stat = func(path); + } catch (e) { + if (e && e.node && PATH.normalize(path) !== PATH.normalize(FS.getPath(e.node))) { + // an error occurred while trying to look up the path; we should just report ENOTDIR + return -54; + } + throw e; + } + HEAP32[((buf)>>2)] = stat.dev; + HEAP32[(((buf)+(4))>>2)] = 0; + HEAP32[(((buf)+(8))>>2)] = stat.ino; + HEAP32[(((buf)+(12))>>2)] = stat.mode; + HEAP32[(((buf)+(16))>>2)] = stat.nlink; + HEAP32[(((buf)+(20))>>2)] = stat.uid; + HEAP32[(((buf)+(24))>>2)] = stat.gid; + HEAP32[(((buf)+(28))>>2)] = stat.rdev; + HEAP32[(((buf)+(32))>>2)] = 0; + (tempI64 = [stat.size>>>0,(tempDouble=stat.size,(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? ((Math.min((+(Math.floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)],HEAP32[(((buf)+(40))>>2)] = tempI64[0],HEAP32[(((buf)+(44))>>2)] = tempI64[1]); + HEAP32[(((buf)+(48))>>2)] = 4096; + HEAP32[(((buf)+(52))>>2)] = stat.blocks; + HEAP32[(((buf)+(56))>>2)] = (stat.atime.getTime() / 1000)|0; + HEAP32[(((buf)+(60))>>2)] = 0; + HEAP32[(((buf)+(64))>>2)] = (stat.mtime.getTime() / 1000)|0; + HEAP32[(((buf)+(68))>>2)] = 0; + HEAP32[(((buf)+(72))>>2)] = (stat.ctime.getTime() / 1000)|0; + HEAP32[(((buf)+(76))>>2)] = 0; + (tempI64 = [stat.ino>>>0,(tempDouble=stat.ino,(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? ((Math.min((+(Math.floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)],HEAP32[(((buf)+(80))>>2)] = tempI64[0],HEAP32[(((buf)+(84))>>2)] = tempI64[1]); + return 0; + },doMsync:function(addr, stream, len, flags, offset) { + var buffer = HEAPU8.slice(addr, addr + len); + FS.msync(stream, buffer, offset, len, flags); + },doMkdir:function(path, mode) { + // remove a trailing slash, if one - /a/b/ has basename of '', but + // we want to create b in the context of this function + path = PATH.normalize(path); + if (path[path.length-1] === '/') path = path.substr(0, path.length-1); + FS.mkdir(path, mode, 0); + return 0; + },doMknod:function(path, mode, dev) { + // we don't want this in the JS API as it uses mknod to create all nodes. + switch (mode & 61440) { + case 32768: + case 8192: + case 24576: + case 4096: + case 49152: + break; + default: return -28; + } + FS.mknod(path, mode, dev); + return 0; + },doReadlink:function(path, buf, bufsize) { + if (bufsize <= 0) return -28; + var ret = FS.readlink(path); + + var len = Math.min(bufsize, lengthBytesUTF8(ret)); + var endChar = HEAP8[buf+len]; + stringToUTF8(ret, buf, bufsize+1); + // readlink is one of the rare functions that write out a C string, but does never append a null to the output buffer(!) + // stringToUTF8() always appends a null byte, so restore the character under the null byte after the write. + HEAP8[buf+len] = endChar; + + return len; + },doAccess:function(path, amode) { + if (amode & ~7) { + // need a valid mode + return -28; + } + var node; + var lookup = FS.lookupPath(path, { follow: true }); + node = lookup.node; + if (!node) { + return -44; + } + var perms = ''; + if (amode & 4) perms += 'r'; + if (amode & 2) perms += 'w'; + if (amode & 1) perms += 'x'; + if (perms /* otherwise, they've just passed F_OK */ && FS.nodePermissions(node, perms)) { + return -2; + } + return 0; + },doDup:function(path, flags, suggestFD) { + var suggest = FS.getStream(suggestFD); + if (suggest) FS.close(suggest); + return FS.open(path, flags, 0, suggestFD, suggestFD).fd; + },doReadv:function(stream, iov, iovcnt, offset) { + var ret = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = HEAP32[(((iov)+(i*8))>>2)]; + var len = HEAP32[(((iov)+(i*8 + 4))>>2)]; + var curr = FS.read(stream, HEAP8,ptr, len, offset); + if (curr < 0) return -1; + ret += curr; + if (curr < len) break; // nothing more to read + } + return ret; + },doWritev:function(stream, iov, iovcnt, offset) { + var ret = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = HEAP32[(((iov)+(i*8))>>2)]; + var len = HEAP32[(((iov)+(i*8 + 4))>>2)]; + var curr = FS.write(stream, HEAP8,ptr, len, offset); + if (curr < 0) return -1; + ret += curr; + } + return ret; + },varargs:undefined,get:function() { + SYSCALLS.varargs += 4; + var ret = HEAP32[(((SYSCALLS.varargs)-(4))>>2)]; + return ret; + },getStr:function(ptr) { + var ret = UTF8ToString(ptr); + return ret; + },getStreamFromFD:function(fd) { + var stream = FS.getStream(fd); + if (!stream) throw new FS.ErrnoError(8); + return stream; + },get64:function(low, high) { + return low; + }}; + function ___syscall_fcntl64(fd, cmd, varargs) {SYSCALLS.varargs = varargs; + try { + + var stream = SYSCALLS.getStreamFromFD(fd); + switch (cmd) { + case 0: { + var arg = SYSCALLS.get(); + if (arg < 0) { + return -28; + } + var newStream; + newStream = FS.open(stream.path, stream.flags, 0, arg); + return newStream.fd; + } + case 1: + case 2: + return 0; // FD_CLOEXEC makes no sense for a single process. + case 3: + return stream.flags; + case 4: { + var arg = SYSCALLS.get(); + stream.flags |= arg; + return 0; + } + case 12: + /* case 12: Currently in musl F_GETLK64 has same value as F_GETLK, so omitted to avoid duplicate case blocks. If that changes, uncomment this */ { + + var arg = SYSCALLS.get(); + var offset = 0; + // We're always unlocked. + HEAP16[(((arg)+(offset))>>1)] = 2; + return 0; + } + case 13: + case 14: + /* case 13: Currently in musl F_SETLK64 has same value as F_SETLK, so omitted to avoid duplicate case blocks. If that changes, uncomment this */ + /* case 14: Currently in musl F_SETLKW64 has same value as F_SETLKW, so omitted to avoid duplicate case blocks. If that changes, uncomment this */ + + + return 0; // Pretend that the locking is successful. + case 16: + case 8: + return -28; // These are for sockets. We don't have them fully implemented yet. + case 9: + // musl trusts getown return values, due to a bug where they must be, as they overlap with errors. just return -1 here, so fnctl() returns that, and we set errno ourselves. + setErrNo(28); + return -1; + default: { + return -28; + } + } + } catch (e) { + if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } + } + + function ___syscall_fstat64(fd, buf) {try { + + var stream = SYSCALLS.getStreamFromFD(fd); + return SYSCALLS.doStat(FS.stat, stream.path, buf); + } catch (e) { + if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } + } + + function ___syscall_ioctl(fd, op, varargs) {SYSCALLS.varargs = varargs; + try { + + var stream = SYSCALLS.getStreamFromFD(fd); + switch (op) { + case 21509: + case 21505: { + if (!stream.tty) return -59; + return 0; + } + case 21510: + case 21511: + case 21512: + case 21506: + case 21507: + case 21508: { + if (!stream.tty) return -59; + return 0; // no-op, not actually adjusting terminal settings + } + case 21519: { + if (!stream.tty) return -59; + var argp = SYSCALLS.get(); + HEAP32[((argp)>>2)] = 0; + return 0; + } + case 21520: { + if (!stream.tty) return -59; + return -28; // not supported + } + case 21531: { + var argp = SYSCALLS.get(); + return FS.ioctl(stream, op, argp); + } + case 21523: { + // TODO: in theory we should write to the winsize struct that gets + // passed in, but for now musl doesn't read anything on it + if (!stream.tty) return -59; + return 0; + } + case 21524: { + // TODO: technically, this ioctl call should change the window size. + // but, since emscripten doesn't have any concept of a terminal window + // yet, we'll just silently throw it away as we do TIOCGWINSZ + if (!stream.tty) return -59; + return 0; + } + default: abort('bad ioctl syscall ' + op); + } + } catch (e) { + if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } + } + + function ___syscall_open(path, flags, varargs) {SYSCALLS.varargs = varargs; + try { + + var pathname = SYSCALLS.getStr(path); + var mode = varargs ? SYSCALLS.get() : 0; + var stream = FS.open(pathname, flags, mode); + return stream.fd; + } catch (e) { + if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } + } + + var structRegistrations = {}; + + function runDestructors(destructors) { + while (destructors.length) { + var ptr = destructors.pop(); + var del = destructors.pop(); + del(ptr); + } + } + + function simpleReadValueFromPointer(pointer) { + return this['fromWireType'](HEAPU32[pointer >> 2]); + } + + var awaitingDependencies = {}; + + var registeredTypes = {}; + + var typeDependencies = {}; + + var char_0 = 48; + + var char_9 = 57; + function makeLegalFunctionName(name) { + if (undefined === name) { + return '_unknown'; + } + name = name.replace(/[^a-zA-Z0-9_]/g, '$'); + var f = name.charCodeAt(0); + if (f >= char_0 && f <= char_9) { + return '_' + name; + } else { + return name; + } + } + function createNamedFunction(name, body) { + name = makeLegalFunctionName(name); + /*jshint evil:true*/ + return new Function( + "body", + "return function " + name + "() {\n" + + " \"use strict\";" + + " return body.apply(this, arguments);\n" + + "};\n" + )(body); + } + function extendError(baseErrorType, errorName) { + var errorClass = createNamedFunction(errorName, function(message) { + this.name = errorName; + this.message = message; + + var stack = (new Error(message)).stack; + if (stack !== undefined) { + this.stack = this.toString() + '\n' + + stack.replace(/^Error(:[^\n]*)?\n/, ''); + } + }); + errorClass.prototype = Object.create(baseErrorType.prototype); + errorClass.prototype.constructor = errorClass; + errorClass.prototype.toString = function() { + if (this.message === undefined) { + return this.name; + } else { + return this.name + ': ' + this.message; + } + }; + + return errorClass; + } + var InternalError = undefined; + function throwInternalError(message) { + throw new InternalError(message); + } + function whenDependentTypesAreResolved(myTypes, dependentTypes, getTypeConverters) { + myTypes.forEach(function(type) { + typeDependencies[type] = dependentTypes; + }); + + function onComplete(typeConverters) { + var myTypeConverters = getTypeConverters(typeConverters); + if (myTypeConverters.length !== myTypes.length) { + throwInternalError('Mismatched type converter count'); + } + for (var i = 0; i < myTypes.length; ++i) { + registerType(myTypes[i], myTypeConverters[i]); + } + } + + var typeConverters = new Array(dependentTypes.length); + var unregisteredTypes = []; + var registered = 0; + dependentTypes.forEach(function(dt, i) { + if (registeredTypes.hasOwnProperty(dt)) { + typeConverters[i] = registeredTypes[dt]; + } else { + unregisteredTypes.push(dt); + if (!awaitingDependencies.hasOwnProperty(dt)) { + awaitingDependencies[dt] = []; + } + awaitingDependencies[dt].push(function() { + typeConverters[i] = registeredTypes[dt]; + ++registered; + if (registered === unregisteredTypes.length) { + onComplete(typeConverters); + } + }); + } + }); + if (0 === unregisteredTypes.length) { + onComplete(typeConverters); + } + } + function __embind_finalize_value_object(structType) { + var reg = structRegistrations[structType]; + delete structRegistrations[structType]; + + var rawConstructor = reg.rawConstructor; + var rawDestructor = reg.rawDestructor; + var fieldRecords = reg.fields; + var fieldTypes = fieldRecords.map(function(field) { return field.getterReturnType; }). + concat(fieldRecords.map(function(field) { return field.setterArgumentType; })); + whenDependentTypesAreResolved([structType], fieldTypes, function(fieldTypes) { + var fields = {}; + fieldRecords.forEach(function(field, i) { + var fieldName = field.fieldName; + var getterReturnType = fieldTypes[i]; + var getter = field.getter; + var getterContext = field.getterContext; + var setterArgumentType = fieldTypes[i + fieldRecords.length]; + var setter = field.setter; + var setterContext = field.setterContext; + fields[fieldName] = { + read: function(ptr) { + return getterReturnType['fromWireType']( + getter(getterContext, ptr)); + }, + write: function(ptr, o) { + var destructors = []; + setter(setterContext, ptr, setterArgumentType['toWireType'](destructors, o)); + runDestructors(destructors); + } + }; + }); + + return [{ + name: reg.name, + 'fromWireType': function(ptr) { + var rv = {}; + for (var i in fields) { + rv[i] = fields[i].read(ptr); + } + rawDestructor(ptr); + return rv; + }, + 'toWireType': function(destructors, o) { + // todo: Here we have an opportunity for -O3 level "unsafe" optimizations: + // assume all fields are present without checking. + for (var fieldName in fields) { + if (!(fieldName in o)) { + throw new TypeError('Missing field: "' + fieldName + '"'); + } + } + var ptr = rawConstructor(); + for (fieldName in fields) { + fields[fieldName].write(ptr, o[fieldName]); + } + if (destructors !== null) { + destructors.push(rawDestructor, ptr); + } + return ptr; + }, + 'argPackAdvance': 8, + 'readValueFromPointer': simpleReadValueFromPointer, + destructorFunction: rawDestructor, + }]; + }); + } + + function __embind_register_bigint(primitiveType, name, size, minRange, maxRange) {} + + function getShiftFromSize(size) { + + switch (size) { + case 1: return 0; + case 2: return 1; + case 4: return 2; + case 8: return 3; + default: + throw new TypeError('Unknown type size: ' + size); + } + } + + function embind_init_charCodes() { + var codes = new Array(256); + for (var i = 0; i < 256; ++i) { + codes[i] = String.fromCharCode(i); + } + embind_charCodes = codes; + } + var embind_charCodes = undefined; + function readLatin1String(ptr) { + var ret = ""; + var c = ptr; + while (HEAPU8[c]) { + ret += embind_charCodes[HEAPU8[c++]]; + } + return ret; + } + + var BindingError = undefined; + function throwBindingError(message) { + throw new BindingError(message); + } + /** @param {Object=} options */ + function registerType(rawType, registeredInstance, options) { + options = options || {}; + + if (!('argPackAdvance' in registeredInstance)) { + throw new TypeError('registerType registeredInstance requires argPackAdvance'); + } + + var name = registeredInstance.name; + if (!rawType) { + throwBindingError('type "' + name + '" must have a positive integer typeid pointer'); + } + if (registeredTypes.hasOwnProperty(rawType)) { + if (options.ignoreDuplicateRegistrations) { + return; + } else { + throwBindingError("Cannot register type '" + name + "' twice"); + } + } + + registeredTypes[rawType] = registeredInstance; + delete typeDependencies[rawType]; + + if (awaitingDependencies.hasOwnProperty(rawType)) { + var callbacks = awaitingDependencies[rawType]; + delete awaitingDependencies[rawType]; + callbacks.forEach(function(cb) { + cb(); + }); + } + } + function __embind_register_bool(rawType, name, size, trueValue, falseValue) { + var shift = getShiftFromSize(size); + + name = readLatin1String(name); + registerType(rawType, { + name: name, + 'fromWireType': function(wt) { + // ambiguous emscripten ABI: sometimes return values are + // true or false, and sometimes integers (0 or 1) + return !!wt; + }, + 'toWireType': function(destructors, o) { + return o ? trueValue : falseValue; + }, + 'argPackAdvance': 8, + 'readValueFromPointer': function(pointer) { + // TODO: if heap is fixed (like in asm.js) this could be executed outside + var heap; + if (size === 1) { + heap = HEAP8; + } else if (size === 2) { + heap = HEAP16; + } else if (size === 4) { + heap = HEAP32; + } else { + throw new TypeError("Unknown boolean type size: " + name); + } + return this['fromWireType'](heap[pointer >> shift]); + }, + destructorFunction: null, // This type does not need a destructor + }); + } + + function ClassHandle_isAliasOf(other) { + if (!(this instanceof ClassHandle)) { + return false; + } + if (!(other instanceof ClassHandle)) { + return false; + } + + var leftClass = this.$$.ptrType.registeredClass; + var left = this.$$.ptr; + var rightClass = other.$$.ptrType.registeredClass; + var right = other.$$.ptr; + + while (leftClass.baseClass) { + left = leftClass.upcast(left); + leftClass = leftClass.baseClass; + } + + while (rightClass.baseClass) { + right = rightClass.upcast(right); + rightClass = rightClass.baseClass; + } + + return leftClass === rightClass && left === right; + } + + function shallowCopyInternalPointer(o) { + return { + count: o.count, + deleteScheduled: o.deleteScheduled, + preservePointerOnDelete: o.preservePointerOnDelete, + ptr: o.ptr, + ptrType: o.ptrType, + smartPtr: o.smartPtr, + smartPtrType: o.smartPtrType, + }; + } + + function throwInstanceAlreadyDeleted(obj) { + function getInstanceTypeName(handle) { + return handle.$$.ptrType.registeredClass.name; + } + throwBindingError(getInstanceTypeName(obj) + ' instance already deleted'); + } + + var finalizationRegistry = false; + + function detachFinalizer(handle) {} + + function runDestructor($$) { + if ($$.smartPtr) { + $$.smartPtrType.rawDestructor($$.smartPtr); + } else { + $$.ptrType.registeredClass.rawDestructor($$.ptr); + } + } + function releaseClassHandle($$) { + $$.count.value -= 1; + var toDelete = 0 === $$.count.value; + if (toDelete) { + runDestructor($$); + } + } + function attachFinalizer(handle) { + if ('undefined' === typeof FinalizationRegistry) { + attachFinalizer = function (handle) { return handle; }; + return handle; + } + // If the running environment has a FinalizationRegistry (see + // https://github.com/tc39/proposal-weakrefs), then attach finalizers + // for class handles. We check for the presence of FinalizationRegistry + // at run-time, not build-time. + finalizationRegistry = new FinalizationRegistry(function (info) { + releaseClassHandle(info.$$); + }); + attachFinalizer = function(handle) { + var $$ = handle.$$; + var info = { $$: $$ }; + finalizationRegistry.register(handle, info, handle); + return handle; + }; + detachFinalizer = function(handle) { + finalizationRegistry.unregister(handle); + }; + return attachFinalizer(handle); + } + function ClassHandle_clone() { + if (!this.$$.ptr) { + throwInstanceAlreadyDeleted(this); + } + + if (this.$$.preservePointerOnDelete) { + this.$$.count.value += 1; + return this; + } else { + var clone = attachFinalizer(Object.create(Object.getPrototypeOf(this), { + $$: { + value: shallowCopyInternalPointer(this.$$), + } + })); + + clone.$$.count.value += 1; + clone.$$.deleteScheduled = false; + return clone; + } + } + + function ClassHandle_delete() { + if (!this.$$.ptr) { + throwInstanceAlreadyDeleted(this); + } + + if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) { + throwBindingError('Object already scheduled for deletion'); + } + + detachFinalizer(this); + releaseClassHandle(this.$$); + + if (!this.$$.preservePointerOnDelete) { + this.$$.smartPtr = undefined; + this.$$.ptr = undefined; + } + } + + function ClassHandle_isDeleted() { + return !this.$$.ptr; + } + + var delayFunction = undefined; + + var deletionQueue = []; + + function flushPendingDeletes() { + while (deletionQueue.length) { + var obj = deletionQueue.pop(); + obj.$$.deleteScheduled = false; + obj['delete'](); + } + } + function ClassHandle_deleteLater() { + if (!this.$$.ptr) { + throwInstanceAlreadyDeleted(this); + } + if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) { + throwBindingError('Object already scheduled for deletion'); + } + deletionQueue.push(this); + if (deletionQueue.length === 1 && delayFunction) { + delayFunction(flushPendingDeletes); + } + this.$$.deleteScheduled = true; + return this; + } + function init_ClassHandle() { + ClassHandle.prototype['isAliasOf'] = ClassHandle_isAliasOf; + ClassHandle.prototype['clone'] = ClassHandle_clone; + ClassHandle.prototype['delete'] = ClassHandle_delete; + ClassHandle.prototype['isDeleted'] = ClassHandle_isDeleted; + ClassHandle.prototype['deleteLater'] = ClassHandle_deleteLater; + } + function ClassHandle() { + } + + var registeredPointers = {}; + + function ensureOverloadTable(proto, methodName, humanName) { + if (undefined === proto[methodName].overloadTable) { + var prevFunc = proto[methodName]; + // Inject an overload resolver function that routes to the appropriate overload based on the number of arguments. + proto[methodName] = function() { + // TODO This check can be removed in -O3 level "unsafe" optimizations. + if (!proto[methodName].overloadTable.hasOwnProperty(arguments.length)) { + throwBindingError("Function '" + humanName + "' called with an invalid number of arguments (" + arguments.length + ") - expects one of (" + proto[methodName].overloadTable + ")!"); + } + return proto[methodName].overloadTable[arguments.length].apply(this, arguments); + }; + // Move the previous function into the overload table. + proto[methodName].overloadTable = []; + proto[methodName].overloadTable[prevFunc.argCount] = prevFunc; + } + } + /** @param {number=} numArguments */ + function exposePublicSymbol(name, value, numArguments) { + if (Module.hasOwnProperty(name)) { + if (undefined === numArguments || (undefined !== Module[name].overloadTable && undefined !== Module[name].overloadTable[numArguments])) { + throwBindingError("Cannot register public name '" + name + "' twice"); + } + + // We are exposing a function with the same name as an existing function. Create an overload table and a function selector + // that routes between the two. + ensureOverloadTable(Module, name, name); + if (Module.hasOwnProperty(numArguments)) { + throwBindingError("Cannot register multiple overloads of a function with the same number of arguments (" + numArguments + ")!"); + } + // Add the new function into the overload table. + Module[name].overloadTable[numArguments] = value; + } + else { + Module[name] = value; + if (undefined !== numArguments) { + Module[name].numArguments = numArguments; + } + } + } + + /** @constructor */ + function RegisteredClass( + name, + constructor, + instancePrototype, + rawDestructor, + baseClass, + getActualType, + upcast, + downcast + ) { + this.name = name; + this.constructor = constructor; + this.instancePrototype = instancePrototype; + this.rawDestructor = rawDestructor; + this.baseClass = baseClass; + this.getActualType = getActualType; + this.upcast = upcast; + this.downcast = downcast; + this.pureVirtualFunctions = []; + } + + function upcastPointer(ptr, ptrClass, desiredClass) { + while (ptrClass !== desiredClass) { + if (!ptrClass.upcast) { + throwBindingError("Expected null or instance of " + desiredClass.name + ", got an instance of " + ptrClass.name); + } + ptr = ptrClass.upcast(ptr); + ptrClass = ptrClass.baseClass; + } + return ptr; + } + function constNoSmartPtrRawPointerToWireType(destructors, handle) { + if (handle === null) { + if (this.isReference) { + throwBindingError('null is not a valid ' + this.name); + } + return 0; + } + + if (!handle.$$) { + throwBindingError('Cannot pass "' + _embind_repr(handle) + '" as a ' + this.name); + } + if (!handle.$$.ptr) { + throwBindingError('Cannot pass deleted object as a pointer of type ' + this.name); + } + var handleClass = handle.$$.ptrType.registeredClass; + var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass); + return ptr; + } + + function genericPointerToWireType(destructors, handle) { + var ptr; + if (handle === null) { + if (this.isReference) { + throwBindingError('null is not a valid ' + this.name); + } + + if (this.isSmartPointer) { + ptr = this.rawConstructor(); + if (destructors !== null) { + destructors.push(this.rawDestructor, ptr); + } + return ptr; + } else { + return 0; + } + } + + if (!handle.$$) { + throwBindingError('Cannot pass "' + _embind_repr(handle) + '" as a ' + this.name); + } + if (!handle.$$.ptr) { + throwBindingError('Cannot pass deleted object as a pointer of type ' + this.name); + } + if (!this.isConst && handle.$$.ptrType.isConst) { + throwBindingError('Cannot convert argument of type ' + (handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name) + ' to parameter type ' + this.name); + } + var handleClass = handle.$$.ptrType.registeredClass; + ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass); + + if (this.isSmartPointer) { + // TODO: this is not strictly true + // We could support BY_EMVAL conversions from raw pointers to smart pointers + // because the smart pointer can hold a reference to the handle + if (undefined === handle.$$.smartPtr) { + throwBindingError('Passing raw pointer to smart pointer is illegal'); + } + + switch (this.sharingPolicy) { + case 0: // NONE + // no upcasting + if (handle.$$.smartPtrType === this) { + ptr = handle.$$.smartPtr; + } else { + throwBindingError('Cannot convert argument of type ' + (handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name) + ' to parameter type ' + this.name); + } + break; + + case 1: // INTRUSIVE + ptr = handle.$$.smartPtr; + break; + + case 2: // BY_EMVAL + if (handle.$$.smartPtrType === this) { + ptr = handle.$$.smartPtr; + } else { + var clonedHandle = handle['clone'](); + ptr = this.rawShare( + ptr, + Emval.toHandle(function() { + clonedHandle['delete'](); + }) + ); + if (destructors !== null) { + destructors.push(this.rawDestructor, ptr); + } + } + break; + + default: + throwBindingError('Unsupporting sharing policy'); + } + } + return ptr; + } + + function nonConstNoSmartPtrRawPointerToWireType(destructors, handle) { + if (handle === null) { + if (this.isReference) { + throwBindingError('null is not a valid ' + this.name); + } + return 0; + } + + if (!handle.$$) { + throwBindingError('Cannot pass "' + _embind_repr(handle) + '" as a ' + this.name); + } + if (!handle.$$.ptr) { + throwBindingError('Cannot pass deleted object as a pointer of type ' + this.name); + } + if (handle.$$.ptrType.isConst) { + throwBindingError('Cannot convert argument of type ' + handle.$$.ptrType.name + ' to parameter type ' + this.name); + } + var handleClass = handle.$$.ptrType.registeredClass; + var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass); + return ptr; + } + + function RegisteredPointer_getPointee(ptr) { + if (this.rawGetPointee) { + ptr = this.rawGetPointee(ptr); + } + return ptr; + } + + function RegisteredPointer_destructor(ptr) { + if (this.rawDestructor) { + this.rawDestructor(ptr); + } + } + + function RegisteredPointer_deleteObject(handle) { + if (handle !== null) { + handle['delete'](); + } + } + + function downcastPointer(ptr, ptrClass, desiredClass) { + if (ptrClass === desiredClass) { + return ptr; + } + if (undefined === desiredClass.baseClass) { + return null; // no conversion + } + + var rv = downcastPointer(ptr, ptrClass, desiredClass.baseClass); + if (rv === null) { + return null; + } + return desiredClass.downcast(rv); + } + + function getInheritedInstanceCount() { + return Object.keys(registeredInstances).length; + } + + function getLiveInheritedInstances() { + var rv = []; + for (var k in registeredInstances) { + if (registeredInstances.hasOwnProperty(k)) { + rv.push(registeredInstances[k]); + } + } + return rv; + } + + function setDelayFunction(fn) { + delayFunction = fn; + if (deletionQueue.length && delayFunction) { + delayFunction(flushPendingDeletes); + } + } + function init_embind() { + Module['getInheritedInstanceCount'] = getInheritedInstanceCount; + Module['getLiveInheritedInstances'] = getLiveInheritedInstances; + Module['flushPendingDeletes'] = flushPendingDeletes; + Module['setDelayFunction'] = setDelayFunction; + } + var registeredInstances = {}; + + function getBasestPointer(class_, ptr) { + if (ptr === undefined) { + throwBindingError('ptr should not be undefined'); + } + while (class_.baseClass) { + ptr = class_.upcast(ptr); + class_ = class_.baseClass; + } + return ptr; + } + function getInheritedInstance(class_, ptr) { + ptr = getBasestPointer(class_, ptr); + return registeredInstances[ptr]; + } + + function makeClassHandle(prototype, record) { + if (!record.ptrType || !record.ptr) { + throwInternalError('makeClassHandle requires ptr and ptrType'); + } + var hasSmartPtrType = !!record.smartPtrType; + var hasSmartPtr = !!record.smartPtr; + if (hasSmartPtrType !== hasSmartPtr) { + throwInternalError('Both smartPtrType and smartPtr must be specified'); + } + record.count = { value: 1 }; + return attachFinalizer(Object.create(prototype, { + $$: { + value: record, + }, + })); + } + function RegisteredPointer_fromWireType(ptr) { + // ptr is a raw pointer (or a raw smartpointer) + + // rawPointer is a maybe-null raw pointer + var rawPointer = this.getPointee(ptr); + if (!rawPointer) { + this.destructor(ptr); + return null; + } + + var registeredInstance = getInheritedInstance(this.registeredClass, rawPointer); + if (undefined !== registeredInstance) { + // JS object has been neutered, time to repopulate it + if (0 === registeredInstance.$$.count.value) { + registeredInstance.$$.ptr = rawPointer; + registeredInstance.$$.smartPtr = ptr; + return registeredInstance['clone'](); + } else { + // else, just increment reference count on existing object + // it already has a reference to the smart pointer + var rv = registeredInstance['clone'](); + this.destructor(ptr); + return rv; + } + } + + function makeDefaultHandle() { + if (this.isSmartPointer) { + return makeClassHandle(this.registeredClass.instancePrototype, { + ptrType: this.pointeeType, + ptr: rawPointer, + smartPtrType: this, + smartPtr: ptr, + }); + } else { + return makeClassHandle(this.registeredClass.instancePrototype, { + ptrType: this, + ptr: ptr, + }); + } + } + + var actualType = this.registeredClass.getActualType(rawPointer); + var registeredPointerRecord = registeredPointers[actualType]; + if (!registeredPointerRecord) { + return makeDefaultHandle.call(this); + } + + var toType; + if (this.isConst) { + toType = registeredPointerRecord.constPointerType; + } else { + toType = registeredPointerRecord.pointerType; + } + var dp = downcastPointer( + rawPointer, + this.registeredClass, + toType.registeredClass); + if (dp === null) { + return makeDefaultHandle.call(this); + } + if (this.isSmartPointer) { + return makeClassHandle(toType.registeredClass.instancePrototype, { + ptrType: toType, + ptr: dp, + smartPtrType: this, + smartPtr: ptr, + }); + } else { + return makeClassHandle(toType.registeredClass.instancePrototype, { + ptrType: toType, + ptr: dp, + }); + } + } + function init_RegisteredPointer() { + RegisteredPointer.prototype.getPointee = RegisteredPointer_getPointee; + RegisteredPointer.prototype.destructor = RegisteredPointer_destructor; + RegisteredPointer.prototype['argPackAdvance'] = 8; + RegisteredPointer.prototype['readValueFromPointer'] = simpleReadValueFromPointer; + RegisteredPointer.prototype['deleteObject'] = RegisteredPointer_deleteObject; + RegisteredPointer.prototype['fromWireType'] = RegisteredPointer_fromWireType; + } + /** @constructor + @param {*=} pointeeType, + @param {*=} sharingPolicy, + @param {*=} rawGetPointee, + @param {*=} rawConstructor, + @param {*=} rawShare, + @param {*=} rawDestructor, + */ + function RegisteredPointer( + name, + registeredClass, + isReference, + isConst, + + // smart pointer properties + isSmartPointer, + pointeeType, + sharingPolicy, + rawGetPointee, + rawConstructor, + rawShare, + rawDestructor + ) { + this.name = name; + this.registeredClass = registeredClass; + this.isReference = isReference; + this.isConst = isConst; + + // smart pointer properties + this.isSmartPointer = isSmartPointer; + this.pointeeType = pointeeType; + this.sharingPolicy = sharingPolicy; + this.rawGetPointee = rawGetPointee; + this.rawConstructor = rawConstructor; + this.rawShare = rawShare; + this.rawDestructor = rawDestructor; + + if (!isSmartPointer && registeredClass.baseClass === undefined) { + if (isConst) { + this['toWireType'] = constNoSmartPtrRawPointerToWireType; + this.destructorFunction = null; + } else { + this['toWireType'] = nonConstNoSmartPtrRawPointerToWireType; + this.destructorFunction = null; + } + } else { + this['toWireType'] = genericPointerToWireType; + // Here we must leave this.destructorFunction undefined, since whether genericPointerToWireType returns + // a pointer that needs to be freed up is runtime-dependent, and cannot be evaluated at registration time. + // TODO: Create an alternative mechanism that allows removing the use of var destructors = []; array in + // craftInvokerFunction altogether. + } + } + + /** @param {number=} numArguments */ + function replacePublicSymbol(name, value, numArguments) { + if (!Module.hasOwnProperty(name)) { + throwInternalError('Replacing nonexistant public symbol'); + } + // If there's an overload table for this symbol, replace the symbol in the overload table instead. + if (undefined !== Module[name].overloadTable && undefined !== numArguments) { + Module[name].overloadTable[numArguments] = value; + } + else { + Module[name] = value; + Module[name].argCount = numArguments; + } + } + + function dynCallLegacy(sig, ptr, args) { + var f = Module["dynCall_" + sig]; + return args && args.length ? f.apply(null, [ptr].concat(args)) : f.call(null, ptr); + } + function dynCall(sig, ptr, args) { + // Without WASM_BIGINT support we cannot directly call function with i64 as + // part of thier signature, so we rely the dynCall functions generated by + // wasm-emscripten-finalize + if (sig.includes('j')) { + return dynCallLegacy(sig, ptr, args); + } + return getWasmTableEntry(ptr).apply(null, args) + } + function getDynCaller(sig, ptr) { + var argCache = []; + return function() { + argCache.length = arguments.length; + for (var i = 0; i < arguments.length; i++) { + argCache[i] = arguments[i]; + } + return dynCall(sig, ptr, argCache); + }; + } + function embind__requireFunction(signature, rawFunction) { + signature = readLatin1String(signature); + + function makeDynCaller() { + if (signature.includes('j')) { + return getDynCaller(signature, rawFunction); + } + return getWasmTableEntry(rawFunction); + } + + var fp = makeDynCaller(); + if (typeof fp !== "function") { + throwBindingError("unknown function pointer with signature " + signature + ": " + rawFunction); + } + return fp; + } + + var UnboundTypeError = undefined; + + function getTypeName(type) { + var ptr = ___getTypeName(type); + var rv = readLatin1String(ptr); + _free(ptr); + return rv; + } + function throwUnboundTypeError(message, types) { + var unboundTypes = []; + var seen = {}; + function visit(type) { + if (seen[type]) { + return; + } + if (registeredTypes[type]) { + return; + } + if (typeDependencies[type]) { + typeDependencies[type].forEach(visit); + return; + } + unboundTypes.push(type); + seen[type] = true; + } + types.forEach(visit); + + throw new UnboundTypeError(message + ': ' + unboundTypes.map(getTypeName).join([', '])); + } + function __embind_register_class( + rawType, + rawPointerType, + rawConstPointerType, + baseClassRawType, + getActualTypeSignature, + getActualType, + upcastSignature, + upcast, + downcastSignature, + downcast, + name, + destructorSignature, + rawDestructor + ) { + name = readLatin1String(name); + getActualType = embind__requireFunction(getActualTypeSignature, getActualType); + if (upcast) { + upcast = embind__requireFunction(upcastSignature, upcast); + } + if (downcast) { + downcast = embind__requireFunction(downcastSignature, downcast); + } + rawDestructor = embind__requireFunction(destructorSignature, rawDestructor); + var legalFunctionName = makeLegalFunctionName(name); + + exposePublicSymbol(legalFunctionName, function() { + // this code cannot run if baseClassRawType is zero + throwUnboundTypeError('Cannot construct ' + name + ' due to unbound types', [baseClassRawType]); + }); + + whenDependentTypesAreResolved( + [rawType, rawPointerType, rawConstPointerType], + baseClassRawType ? [baseClassRawType] : [], + function(base) { + base = base[0]; + + var baseClass; + var basePrototype; + if (baseClassRawType) { + baseClass = base.registeredClass; + basePrototype = baseClass.instancePrototype; + } else { + basePrototype = ClassHandle.prototype; + } + + var constructor = createNamedFunction(legalFunctionName, function() { + if (Object.getPrototypeOf(this) !== instancePrototype) { + throw new BindingError("Use 'new' to construct " + name); + } + if (undefined === registeredClass.constructor_body) { + throw new BindingError(name + " has no accessible constructor"); + } + var body = registeredClass.constructor_body[arguments.length]; + if (undefined === body) { + throw new BindingError("Tried to invoke ctor of " + name + " with invalid number of parameters (" + arguments.length + ") - expected (" + Object.keys(registeredClass.constructor_body).toString() + ") parameters instead!"); + } + return body.apply(this, arguments); + }); + + var instancePrototype = Object.create(basePrototype, { + constructor: { value: constructor }, + }); + + constructor.prototype = instancePrototype; + + var registeredClass = new RegisteredClass( + name, + constructor, + instancePrototype, + rawDestructor, + baseClass, + getActualType, + upcast, + downcast); + + var referenceConverter = new RegisteredPointer( + name, + registeredClass, + true, + false, + false); + + var pointerConverter = new RegisteredPointer( + name + '*', + registeredClass, + false, + false, + false); + + var constPointerConverter = new RegisteredPointer( + name + ' const*', + registeredClass, + false, + true, + false); + + registeredPointers[rawType] = { + pointerType: pointerConverter, + constPointerType: constPointerConverter + }; + + replacePublicSymbol(legalFunctionName, constructor); + + return [referenceConverter, pointerConverter, constPointerConverter]; + } + ); + } + + function heap32VectorToArray(count, firstElement) { + + var array = []; + for (var i = 0; i < count; i++) { + array.push(HEAP32[(firstElement >> 2) + i]); + } + return array; + } + function __embind_register_class_constructor( + rawClassType, + argCount, + rawArgTypesAddr, + invokerSignature, + invoker, + rawConstructor + ) { + assert(argCount > 0); + var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr); + invoker = embind__requireFunction(invokerSignature, invoker); + var args = [rawConstructor]; + var destructors = []; + + whenDependentTypesAreResolved([], [rawClassType], function(classType) { + classType = classType[0]; + var humanName = 'constructor ' + classType.name; + + if (undefined === classType.registeredClass.constructor_body) { + classType.registeredClass.constructor_body = []; + } + if (undefined !== classType.registeredClass.constructor_body[argCount - 1]) { + throw new BindingError("Cannot register multiple constructors with identical number of parameters (" + (argCount-1) + ") for class '" + classType.name + "'! Overload resolution is currently only performed using the parameter count, not actual type info!"); + } + classType.registeredClass.constructor_body[argCount - 1] = function unboundTypeHandler() { + throwUnboundTypeError('Cannot construct ' + classType.name + ' due to unbound types', rawArgTypes); + }; + + whenDependentTypesAreResolved([], rawArgTypes, function(argTypes) { + // Insert empty slot for context type (argTypes[1]). + argTypes.splice(1, 0, null); + classType.registeredClass.constructor_body[argCount - 1] = craftInvokerFunction(humanName, argTypes, null, invoker, rawConstructor); + return []; + }); + return []; + }); + } + + function new_(constructor, argumentList) { + if (!(constructor instanceof Function)) { + throw new TypeError('new_ called with constructor type ' + typeof(constructor) + " which is not a function"); + } + + /* + * Previously, the following line was just: + + function dummy() {}; + + * Unfortunately, Chrome was preserving 'dummy' as the object's name, even though at creation, the 'dummy' has the + * correct constructor name. Thus, objects created with IMVU.new would show up in the debugger as 'dummy', which + * isn't very helpful. Using IMVU.createNamedFunction addresses the issue. Doublely-unfortunately, there's no way + * to write a test for this behavior. -NRD 2013.02.22 + */ + var dummy = createNamedFunction(constructor.name || 'unknownFunctionName', function(){}); + dummy.prototype = constructor.prototype; + var obj = new dummy; + + var r = constructor.apply(obj, argumentList); + return (r instanceof Object) ? r : obj; + } + function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc) { + // humanName: a human-readable string name for the function to be generated. + // argTypes: An array that contains the embind type objects for all types in the function signature. + // argTypes[0] is the type object for the function return value. + // argTypes[1] is the type object for function this object/class type, or null if not crafting an invoker for a class method. + // argTypes[2...] are the actual function parameters. + // classType: The embind type object for the class to be bound, or null if this is not a method of a class. + // cppInvokerFunc: JS Function object to the C++-side function that interops into C++ code. + // cppTargetFunc: Function pointer (an integer to FUNCTION_TABLE) to the target C++ function the cppInvokerFunc will end up calling. + var argCount = argTypes.length; + + if (argCount < 2) { + throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!"); + } + + var isClassMethodFunc = (argTypes[1] !== null && classType !== null); + + // Free functions with signature "void function()" do not need an invoker that marshalls between wire types. + // TODO: This omits argument count check - enable only at -O3 or similar. + // if (ENABLE_UNSAFE_OPTS && argCount == 2 && argTypes[0].name == "void" && !isClassMethodFunc) { + // return FUNCTION_TABLE[fn]; + // } + + // Determine if we need to use a dynamic stack to store the destructors for the function parameters. + // TODO: Remove this completely once all function invokers are being dynamically generated. + var needsDestructorStack = false; + + for (var i = 1; i < argTypes.length; ++i) { // Skip return value at index 0 - it's not deleted here. + if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) { // The type does not define a destructor function - must use dynamic stack + needsDestructorStack = true; + break; + } + } + + var returns = (argTypes[0].name !== "void"); + + var argsList = ""; + var argsListWired = ""; + for (var i = 0; i < argCount - 2; ++i) { + argsList += (i!==0?", ":"")+"arg"+i; + argsListWired += (i!==0?", ":"")+"arg"+i+"Wired"; + } + + var invokerFnBody = + "return function "+makeLegalFunctionName(humanName)+"("+argsList+") {\n" + + "if (arguments.length !== "+(argCount - 2)+") {\n" + + "throwBindingError('function "+humanName+" called with ' + arguments.length + ' arguments, expected "+(argCount - 2)+" args!');\n" + + "}\n"; + + if (needsDestructorStack) { + invokerFnBody += + "var destructors = [];\n"; + } + + var dtorStack = needsDestructorStack ? "destructors" : "null"; + var args1 = ["throwBindingError", "invoker", "fn", "runDestructors", "retType", "classParam"]; + var args2 = [throwBindingError, cppInvokerFunc, cppTargetFunc, runDestructors, argTypes[0], argTypes[1]]; + + if (isClassMethodFunc) { + invokerFnBody += "var thisWired = classParam.toWireType("+dtorStack+", this);\n"; + } + + for (var i = 0; i < argCount - 2; ++i) { + invokerFnBody += "var arg"+i+"Wired = argType"+i+".toWireType("+dtorStack+", arg"+i+"); // "+argTypes[i+2].name+"\n"; + args1.push("argType"+i); + args2.push(argTypes[i+2]); + } + + if (isClassMethodFunc) { + argsListWired = "thisWired" + (argsListWired.length > 0 ? ", " : "") + argsListWired; + } + + invokerFnBody += + (returns?"var rv = ":"") + "invoker(fn"+(argsListWired.length>0?", ":"")+argsListWired+");\n"; + + if (needsDestructorStack) { + invokerFnBody += "runDestructors(destructors);\n"; + } else { + for (var i = isClassMethodFunc?1:2; i < argTypes.length; ++i) { // Skip return value at index 0 - it's not deleted here. Also skip class type if not a method. + var paramName = (i === 1 ? "thisWired" : ("arg"+(i - 2)+"Wired")); + if (argTypes[i].destructorFunction !== null) { + invokerFnBody += paramName+"_dtor("+paramName+"); // "+argTypes[i].name+"\n"; + args1.push(paramName+"_dtor"); + args2.push(argTypes[i].destructorFunction); + } + } + } + + if (returns) { + invokerFnBody += "var ret = retType.fromWireType(rv);\n" + + "return ret;\n"; + } else { + } + + invokerFnBody += "}\n"; + + args1.push(invokerFnBody); + + var invokerFunction = new_(Function, args1).apply(null, args2); + return invokerFunction; + } + function __embind_register_class_function( + rawClassType, + methodName, + argCount, + rawArgTypesAddr, // [ReturnType, ThisType, Args...] + invokerSignature, + rawInvoker, + context, + isPureVirtual + ) { + var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr); + methodName = readLatin1String(methodName); + rawInvoker = embind__requireFunction(invokerSignature, rawInvoker); + + whenDependentTypesAreResolved([], [rawClassType], function(classType) { + classType = classType[0]; + var humanName = classType.name + '.' + methodName; + + if (methodName.startsWith("@@")) { + methodName = Symbol[methodName.substring(2)]; + } + + if (isPureVirtual) { + classType.registeredClass.pureVirtualFunctions.push(methodName); + } + + function unboundTypesHandler() { + throwUnboundTypeError('Cannot call ' + humanName + ' due to unbound types', rawArgTypes); + } + + var proto = classType.registeredClass.instancePrototype; + var method = proto[methodName]; + if (undefined === method || (undefined === method.overloadTable && method.className !== classType.name && method.argCount === argCount - 2)) { + // This is the first overload to be registered, OR we are replacing a function in the base class with a function in the derived class. + unboundTypesHandler.argCount = argCount - 2; + unboundTypesHandler.className = classType.name; + proto[methodName] = unboundTypesHandler; + } else { + // There was an existing function with the same name registered. Set up a function overload routing table. + ensureOverloadTable(proto, methodName, humanName); + proto[methodName].overloadTable[argCount - 2] = unboundTypesHandler; + } + + whenDependentTypesAreResolved([], rawArgTypes, function(argTypes) { + + var memberFunction = craftInvokerFunction(humanName, argTypes, classType, rawInvoker, context); + + // Replace the initial unbound-handler-stub function with the appropriate member function, now that all types + // are resolved. If multiple overloads are registered for this function, the function goes into an overload table. + if (undefined === proto[methodName].overloadTable) { + // Set argCount in case an overload is registered later + memberFunction.argCount = argCount - 2; + proto[methodName] = memberFunction; + } else { + proto[methodName].overloadTable[argCount - 2] = memberFunction; + } + + return []; + }); + return []; + }); + } + + function validateThis(this_, classType, humanName) { + if (!(this_ instanceof Object)) { + throwBindingError(humanName + ' with invalid "this": ' + this_); + } + if (!(this_ instanceof classType.registeredClass.constructor)) { + throwBindingError(humanName + ' incompatible with "this" of type ' + this_.constructor.name); + } + if (!this_.$$.ptr) { + throwBindingError('cannot call emscripten binding method ' + humanName + ' on deleted object'); + } + + // todo: kill this + return upcastPointer( + this_.$$.ptr, + this_.$$.ptrType.registeredClass, + classType.registeredClass); + } + function __embind_register_class_property( + classType, + fieldName, + getterReturnType, + getterSignature, + getter, + getterContext, + setterArgumentType, + setterSignature, + setter, + setterContext + ) { + fieldName = readLatin1String(fieldName); + getter = embind__requireFunction(getterSignature, getter); + + whenDependentTypesAreResolved([], [classType], function(classType) { + classType = classType[0]; + var humanName = classType.name + '.' + fieldName; + var desc = { + get: function() { + throwUnboundTypeError('Cannot access ' + humanName + ' due to unbound types', [getterReturnType, setterArgumentType]); + }, + enumerable: true, + configurable: true + }; + if (setter) { + desc.set = function() { + throwUnboundTypeError('Cannot access ' + humanName + ' due to unbound types', [getterReturnType, setterArgumentType]); + }; + } else { + desc.set = function(v) { + throwBindingError(humanName + ' is a read-only property'); + }; + } + + Object.defineProperty(classType.registeredClass.instancePrototype, fieldName, desc); + + whenDependentTypesAreResolved( + [], + (setter ? [getterReturnType, setterArgumentType] : [getterReturnType]), + function(types) { + var getterReturnType = types[0]; + var desc = { + get: function() { + var ptr = validateThis(this, classType, humanName + ' getter'); + return getterReturnType['fromWireType'](getter(getterContext, ptr)); + }, + enumerable: true + }; + + if (setter) { + setter = embind__requireFunction(setterSignature, setter); + var setterArgumentType = types[1]; + desc.set = function(v) { + var ptr = validateThis(this, classType, humanName + ' setter'); + var destructors = []; + setter(setterContext, ptr, setterArgumentType['toWireType'](destructors, v)); + runDestructors(destructors); + }; + } + + Object.defineProperty(classType.registeredClass.instancePrototype, fieldName, desc); + return []; + }); + + return []; + }); + } + + var emval_free_list = []; + + var emval_handle_array = [{},{value:undefined},{value:null},{value:true},{value:false}]; + function __emval_decref(handle) { + if (handle > 4 && 0 === --emval_handle_array[handle].refcount) { + emval_handle_array[handle] = undefined; + emval_free_list.push(handle); + } + } + + function count_emval_handles() { + var count = 0; + for (var i = 5; i < emval_handle_array.length; ++i) { + if (emval_handle_array[i] !== undefined) { + ++count; + } + } + return count; + } + + function get_first_emval() { + for (var i = 5; i < emval_handle_array.length; ++i) { + if (emval_handle_array[i] !== undefined) { + return emval_handle_array[i]; + } + } + return null; + } + function init_emval() { + Module['count_emval_handles'] = count_emval_handles; + Module['get_first_emval'] = get_first_emval; + } + var Emval = {toValue:function(handle) { + if (!handle) { + throwBindingError('Cannot use deleted val. handle = ' + handle); + } + return emval_handle_array[handle].value; + },toHandle:function(value) { + switch (value) { + case undefined :{ return 1; } + case null :{ return 2; } + case true :{ return 3; } + case false :{ return 4; } + default:{ + var handle = emval_free_list.length ? + emval_free_list.pop() : + emval_handle_array.length; + + emval_handle_array[handle] = {refcount: 1, value: value}; + return handle; + } + } + }}; + function __embind_register_emval(rawType, name) { + name = readLatin1String(name); + registerType(rawType, { + name: name, + 'fromWireType': function(handle) { + var rv = Emval.toValue(handle); + __emval_decref(handle); + return rv; + }, + 'toWireType': function(destructors, value) { + return Emval.toHandle(value); + }, + 'argPackAdvance': 8, + 'readValueFromPointer': simpleReadValueFromPointer, + destructorFunction: null, // This type does not need a destructor + + // TODO: do we need a deleteObject here? write a test where + // emval is passed into JS via an interface + }); + } + + function enumReadValueFromPointer(name, shift, signed) { + switch (shift) { + case 0: return function(pointer) { + var heap = signed ? HEAP8 : HEAPU8; + return this['fromWireType'](heap[pointer]); + }; + case 1: return function(pointer) { + var heap = signed ? HEAP16 : HEAPU16; + return this['fromWireType'](heap[pointer >> 1]); + }; + case 2: return function(pointer) { + var heap = signed ? HEAP32 : HEAPU32; + return this['fromWireType'](heap[pointer >> 2]); + }; + default: + throw new TypeError("Unknown integer type: " + name); + } + } + function __embind_register_enum( + rawType, + name, + size, + isSigned + ) { + var shift = getShiftFromSize(size); + name = readLatin1String(name); + + function ctor() { + } + ctor.values = {}; + + registerType(rawType, { + name: name, + constructor: ctor, + 'fromWireType': function(c) { + return this.constructor.values[c]; + }, + 'toWireType': function(destructors, c) { + return c.value; + }, + 'argPackAdvance': 8, + 'readValueFromPointer': enumReadValueFromPointer(name, shift, isSigned), + destructorFunction: null, + }); + exposePublicSymbol(name, ctor); + } + + function requireRegisteredType(rawType, humanName) { + var impl = registeredTypes[rawType]; + if (undefined === impl) { + throwBindingError(humanName + " has unknown type " + getTypeName(rawType)); + } + return impl; + } + function __embind_register_enum_value( + rawEnumType, + name, + enumValue + ) { + var enumType = requireRegisteredType(rawEnumType, 'enum'); + name = readLatin1String(name); + + var Enum = enumType.constructor; + + var Value = Object.create(enumType.constructor.prototype, { + value: {value: enumValue}, + constructor: {value: createNamedFunction(enumType.name + '_' + name, function() {})}, + }); + Enum.values[enumValue] = Value; + Enum[name] = Value; + } + + function _embind_repr(v) { + if (v === null) { + return 'null'; + } + var t = typeof v; + if (t === 'object' || t === 'array' || t === 'function') { + return v.toString(); + } else { + return '' + v; + } + } + + function floatReadValueFromPointer(name, shift) { + switch (shift) { + case 2: return function(pointer) { + return this['fromWireType'](HEAPF32[pointer >> 2]); + }; + case 3: return function(pointer) { + return this['fromWireType'](HEAPF64[pointer >> 3]); + }; + default: + throw new TypeError("Unknown float type: " + name); + } + } + function __embind_register_float(rawType, name, size) { + var shift = getShiftFromSize(size); + name = readLatin1String(name); + registerType(rawType, { + name: name, + 'fromWireType': function(value) { + return value; + }, + 'toWireType': function(destructors, value) { + // todo: Here we have an opportunity for -O3 level "unsafe" optimizations: we could + // avoid the following if() and assume value is of proper type. + if (typeof value !== "number" && typeof value !== "boolean") { + throw new TypeError('Cannot convert "' + _embind_repr(value) + '" to ' + this.name); + } + return value; + }, + 'argPackAdvance': 8, + 'readValueFromPointer': floatReadValueFromPointer(name, shift), + destructorFunction: null, // This type does not need a destructor + }); + } + + function integerReadValueFromPointer(name, shift, signed) { + // integers are quite common, so generate very specialized functions + switch (shift) { + case 0: return signed ? + function readS8FromPointer(pointer) { return HEAP8[pointer]; } : + function readU8FromPointer(pointer) { return HEAPU8[pointer]; }; + case 1: return signed ? + function readS16FromPointer(pointer) { return HEAP16[pointer >> 1]; } : + function readU16FromPointer(pointer) { return HEAPU16[pointer >> 1]; }; + case 2: return signed ? + function readS32FromPointer(pointer) { return HEAP32[pointer >> 2]; } : + function readU32FromPointer(pointer) { return HEAPU32[pointer >> 2]; }; + default: + throw new TypeError("Unknown integer type: " + name); + } + } + function __embind_register_integer(primitiveType, name, size, minRange, maxRange) { + name = readLatin1String(name); + if (maxRange === -1) { // LLVM doesn't have signed and unsigned 32-bit types, so u32 literals come out as 'i32 -1'. Always treat those as max u32. + maxRange = 4294967295; + } + + var shift = getShiftFromSize(size); + + var fromWireType = function(value) { + return value; + }; + + if (minRange === 0) { + var bitshift = 32 - 8*size; + fromWireType = function(value) { + return (value << bitshift) >>> bitshift; + }; + } + + var isUnsignedType = (name.includes('unsigned')); + + registerType(primitiveType, { + name: name, + 'fromWireType': fromWireType, + 'toWireType': function(destructors, value) { + // todo: Here we have an opportunity for -O3 level "unsafe" optimizations: we could + // avoid the following two if()s and assume value is of proper type. + if (typeof value !== "number" && typeof value !== "boolean") { + throw new TypeError('Cannot convert "' + _embind_repr(value) + '" to ' + this.name); + } + if (value < minRange || value > maxRange) { + 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(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 + = (name === "std::string"); + + registerType(rawType, { + name: name, + 'fromWireType': function(value) { + var length = HEAPU32[value >> 2]; + + var str; + if (stdStringIsUTF8) { + 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 (i == length || HEAPU8[currentBytePtr] == 0) { + var maxRead = currentBytePtr - decodeStartPtr; + var stringSegment = UTF8ToString(decodeStartPtr, maxRead); + if (str === undefined) { + str = stringSegment; + } else { + str += String.fromCharCode(0); + str += stringSegment; + } + decodeStartPtr = currentBytePtr + 1; + } + } + } 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) { + name = readLatin1String(name); + var decodeString, encodeString, getHeap, lengthBytesUTF, shift; + if (charSize === 2) { + decodeString = UTF16ToString; + encodeString = stringToUTF16; + lengthBytesUTF = lengthBytesUTF16; + getHeap = function() { return HEAPU16; }; + shift = 1; + } else if (charSize === 4) { + decodeString = UTF32ToString; + encodeString = stringToUTF32; + lengthBytesUTF = lengthBytesUTF32; + getHeap = function() { return HEAPU32; }; + shift = 2; + } + registerType(rawType, { + name: name, + 'fromWireType': function(value) { + // Code mostly taken from _embind_register_std_string fromWireType + var length = HEAPU32[value >> 2]; + var HEAP = getHeap(); + var str; + + var decodeStartPtr = value + 4; + // Looping here to support possible embedded '0' bytes + for (var i = 0; i <= length; ++i) { + var currentBytePtr = value + 4 + i * charSize; + if (i == length || HEAP[currentBytePtr >> shift] == 0) { + var maxReadBytes = currentBytePtr - decodeStartPtr; + var stringSegment = decodeString(decodeStartPtr, maxReadBytes); + if (str === undefined) { + str = stringSegment; + } else { + str += String.fromCharCode(0); + str += stringSegment; + } + decodeStartPtr = currentBytePtr + charSize; + } + } + + _free(value); + + return str; + }, + 'toWireType': function(destructors, value) { + if (!(typeof value === 'string')) { + throwBindingError('Cannot pass non-string to C++ string type ' + name); + } + + // assumes 4-byte alignment + var length = lengthBytesUTF(value); + var ptr = _malloc(4 + length + charSize); + HEAPU32[ptr >> 2] = length >> shift; + + encodeString(value, ptr + 4, length + charSize); + + if (destructors !== null) { + destructors.push(_free, ptr); + } + return ptr; + }, + 'argPackAdvance': 8, + 'readValueFromPointer': simpleReadValueFromPointer, + destructorFunction: function(ptr) { _free(ptr); }, + }); + } + + 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 __emval_as(handle, returnType, destructorsRef) { + handle = Emval.toValue(handle); + returnType = requireRegisteredType(returnType, 'emval::as'); + var destructors = []; + var rd = Emval.toHandle(destructors); + HEAP32[destructorsRef >> 2] = rd; + return returnType['toWireType'](destructors, handle); + } + + function __emval_allocateDestructors(destructorsRef) { + var destructors = []; + HEAP32[destructorsRef >> 2] = Emval.toHandle(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_void_method(caller, handle, methodName, args) { + caller = emval_methodCallers[caller]; + handle = Emval.toValue(handle); + methodName = getStringOrSymbol(methodName); + caller(handle, methodName, null, args); + } + + + function __emval_addMethodCaller(caller) { + var id = emval_methodCallers.length; + emval_methodCallers.push(caller); + return id; + } + + function __emval_lookupTypes(argCount, argTypes) { + 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.toHandle(Module[name]); + } + + function __emval_get_property(handle, key) { + handle = Emval.toValue(handle); + key = Emval.toValue(key); + return Emval.toHandle(handle[key]); + } + + function __emval_incref(handle) { + if (handle > 4) { + emval_handle_array[handle].refcount += 1; + } + } + + 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.toHandle(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 valueToHandle(obj);\n" + + "}\n"; + + /*jshint evil:true*/ + return (new Function("requireRegisteredType", "Module", "valueToHandle", functionBody))( + requireRegisteredType, Module, Emval.toHandle); + } + + var emval_newers = {}; + function __emval_new(handle, argCount, argTypes, args) { + handle = Emval.toValue(handle); + + var newer = emval_newers[argCount]; + if (!newer) { + newer = craftEmvalAllocator(argCount); + emval_newers[argCount] = newer; + } + + return newer(handle, argTypes, args); + } + + function __emval_new_cstring(v) { + return Emval.toHandle(getStringOrSymbol(v)); + } + + function __emval_new_object() { + return Emval.toHandle({}); + } + + function __emval_run_destructors(handle) { + var destructors = Emval.toValue(handle); + runDestructors(destructors); + __emval_decref(handle); + } + + function __emval_set_property(handle, key, value) { + handle = Emval.toValue(handle); + key = Emval.toValue(key); + value = Emval.toValue(value); + handle[key] = value; + } + + function __emval_take_value(type, argv) { + type = requireRegisteredType(type, '_emval_take_value'); + var v = type['readValueFromPointer'](argv); + return Emval.toHandle(v); + } + + function _abort() { + abort(''); + } + + function _emscripten_get_heap_max() { + // Handle the case of 4GB (which would wrap to 0 in the return value) by + // returning up to 4GB - one wasm page. + return 2147483648; + } + + function __webgl_enable_ANGLE_instanced_arrays(ctx) { + // Extension available in WebGL 1 from Firefox 26 and Google Chrome 30 onwards. Core feature in WebGL 2. + var ext = ctx.getExtension('ANGLE_instanced_arrays'); + if (ext) { + ctx['vertexAttribDivisor'] = function(index, divisor) { ext['vertexAttribDivisorANGLE'](index, divisor); }; + ctx['drawArraysInstanced'] = function(mode, first, count, primcount) { ext['drawArraysInstancedANGLE'](mode, first, count, primcount); }; + ctx['drawElementsInstanced'] = function(mode, count, type, indices, primcount) { ext['drawElementsInstancedANGLE'](mode, count, type, indices, primcount); }; + return 1; + } + } + + function __webgl_enable_OES_vertex_array_object(ctx) { + // Extension available in WebGL 1 from Firefox 25 and WebKit 536.28/desktop Safari 6.0.3 onwards. Core feature in WebGL 2. + var ext = ctx.getExtension('OES_vertex_array_object'); + if (ext) { + ctx['createVertexArray'] = function() { return ext['createVertexArrayOES'](); }; + ctx['deleteVertexArray'] = function(vao) { ext['deleteVertexArrayOES'](vao); }; + ctx['bindVertexArray'] = function(vao) { ext['bindVertexArrayOES'](vao); }; + ctx['isVertexArray'] = function(vao) { return ext['isVertexArrayOES'](vao); }; + return 1; + } + } + + function __webgl_enable_WEBGL_draw_buffers(ctx) { + // Extension available in WebGL 1 from Firefox 28 onwards. Core feature in WebGL 2. + var ext = ctx.getExtension('WEBGL_draw_buffers'); + if (ext) { + ctx['drawBuffers'] = function(n, bufs) { ext['drawBuffersWEBGL'](n, bufs); }; + return 1; + } + } + + function __webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance(ctx) { + // Closure is expected to be allowed to minify the '.dibvbi' property, so not accessing it quoted. + return !!(ctx.dibvbi = ctx.getExtension('WEBGL_draw_instanced_base_vertex_base_instance')); + } + + function __webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance(ctx) { + // Closure is expected to be allowed to minify the '.mdibvbi' property, so not accessing it quoted. + return !!(ctx.mdibvbi = ctx.getExtension('WEBGL_multi_draw_instanced_base_vertex_base_instance')); + } + + function __webgl_enable_WEBGL_multi_draw(ctx) { + // Closure is expected to be allowed to minify the '.multiDrawWebgl' property, so not accessing it quoted. + return !!(ctx.multiDrawWebgl = ctx.getExtension('WEBGL_multi_draw')); + } + var GL = {counter:1,buffers:[],mappedBuffers:{},programs:[],framebuffers:[],renderbuffers:[],textures:[],shaders:[],vaos:[],contexts:[],offscreenCanvases:{},queries:[],samplers:[],transformFeedbacks:[],syncs:[],byteSizeByTypeRoot:5120,byteSizeByType:[1,1,2,2,4,4,4,2,3,4,8],stringCache:{},stringiCache:{},unpackAlignment:4,recordError:function recordError(errorCode) { + if (!GL.lastError) { + GL.lastError = errorCode; + } + },getNewId:function(table) { + var ret = GL.counter++; + for (var i = table.length; i < ret; i++) { + table[i] = null; + } + return ret; + },MAX_TEMP_BUFFER_SIZE:2097152,numTempVertexBuffersPerSize:64,log2ceilLookup:function(i) { + return 32 - Math.clz32(i === 0 ? 0 : i - 1); + },generateTempBuffers:function(quads, context) { + var largestIndex = GL.log2ceilLookup(GL.MAX_TEMP_BUFFER_SIZE); + context.tempVertexBufferCounters1 = []; + context.tempVertexBufferCounters2 = []; + context.tempVertexBufferCounters1.length = context.tempVertexBufferCounters2.length = largestIndex+1; + context.tempVertexBuffers1 = []; + context.tempVertexBuffers2 = []; + context.tempVertexBuffers1.length = context.tempVertexBuffers2.length = largestIndex+1; + context.tempIndexBuffers = []; + context.tempIndexBuffers.length = largestIndex+1; + for (var i = 0; i <= largestIndex; ++i) { + context.tempIndexBuffers[i] = null; // Created on-demand + context.tempVertexBufferCounters1[i] = context.tempVertexBufferCounters2[i] = 0; + var ringbufferLength = GL.numTempVertexBuffersPerSize; + context.tempVertexBuffers1[i] = []; + context.tempVertexBuffers2[i] = []; + var ringbuffer1 = context.tempVertexBuffers1[i]; + var ringbuffer2 = context.tempVertexBuffers2[i]; + ringbuffer1.length = ringbuffer2.length = ringbufferLength; + for (var j = 0; j < ringbufferLength; ++j) { + ringbuffer1[j] = ringbuffer2[j] = null; // Created on-demand + } + } + + if (quads) { + // GL_QUAD indexes can be precalculated + context.tempQuadIndexBuffer = GLctx.createBuffer(); + context.GLctx.bindBuffer(0x8893 /*GL_ELEMENT_ARRAY_BUFFER*/, context.tempQuadIndexBuffer); + var numIndexes = GL.MAX_TEMP_BUFFER_SIZE >> 1; + var quadIndexes = new Uint16Array(numIndexes); + var i = 0, v = 0; + while (1) { + quadIndexes[i++] = v; + if (i >= numIndexes) break; + quadIndexes[i++] = v+1; + if (i >= numIndexes) break; + quadIndexes[i++] = v+2; + if (i >= numIndexes) break; + quadIndexes[i++] = v; + if (i >= numIndexes) break; + quadIndexes[i++] = v+2; + if (i >= numIndexes) break; + quadIndexes[i++] = v+3; + if (i >= numIndexes) break; + v += 4; + } + context.GLctx.bufferData(0x8893 /*GL_ELEMENT_ARRAY_BUFFER*/, quadIndexes, 0x88E4 /*GL_STATIC_DRAW*/); + context.GLctx.bindBuffer(0x8893 /*GL_ELEMENT_ARRAY_BUFFER*/, null); + } + },getTempVertexBuffer:function getTempVertexBuffer(sizeBytes) { + var idx = GL.log2ceilLookup(sizeBytes); + var ringbuffer = GL.currentContext.tempVertexBuffers1[idx]; + var nextFreeBufferIndex = GL.currentContext.tempVertexBufferCounters1[idx]; + GL.currentContext.tempVertexBufferCounters1[idx] = (GL.currentContext.tempVertexBufferCounters1[idx]+1) & (GL.numTempVertexBuffersPerSize-1); + var vbo = ringbuffer[nextFreeBufferIndex]; + if (vbo) { + return vbo; + } + var prevVBO = GLctx.getParameter(0x8894 /*GL_ARRAY_BUFFER_BINDING*/); + ringbuffer[nextFreeBufferIndex] = GLctx.createBuffer(); + GLctx.bindBuffer(0x8892 /*GL_ARRAY_BUFFER*/, ringbuffer[nextFreeBufferIndex]); + GLctx.bufferData(0x8892 /*GL_ARRAY_BUFFER*/, 1 << idx, 0x88E8 /*GL_DYNAMIC_DRAW*/); + GLctx.bindBuffer(0x8892 /*GL_ARRAY_BUFFER*/, prevVBO); + return ringbuffer[nextFreeBufferIndex]; + },getTempIndexBuffer:function getTempIndexBuffer(sizeBytes) { + var idx = GL.log2ceilLookup(sizeBytes); + var ibo = GL.currentContext.tempIndexBuffers[idx]; + if (ibo) { + return ibo; + } + var prevIBO = GLctx.getParameter(0x8895 /*ELEMENT_ARRAY_BUFFER_BINDING*/); + GL.currentContext.tempIndexBuffers[idx] = GLctx.createBuffer(); + GLctx.bindBuffer(0x8893 /*GL_ELEMENT_ARRAY_BUFFER*/, GL.currentContext.tempIndexBuffers[idx]); + GLctx.bufferData(0x8893 /*GL_ELEMENT_ARRAY_BUFFER*/, 1 << idx, 0x88E8 /*GL_DYNAMIC_DRAW*/); + GLctx.bindBuffer(0x8893 /*GL_ELEMENT_ARRAY_BUFFER*/, prevIBO); + return GL.currentContext.tempIndexBuffers[idx]; + },newRenderingFrameStarted:function newRenderingFrameStarted() { + if (!GL.currentContext) { + return; + } + var vb = GL.currentContext.tempVertexBuffers1; + GL.currentContext.tempVertexBuffers1 = GL.currentContext.tempVertexBuffers2; + GL.currentContext.tempVertexBuffers2 = vb; + vb = GL.currentContext.tempVertexBufferCounters1; + GL.currentContext.tempVertexBufferCounters1 = GL.currentContext.tempVertexBufferCounters2; + GL.currentContext.tempVertexBufferCounters2 = vb; + var largestIndex = GL.log2ceilLookup(GL.MAX_TEMP_BUFFER_SIZE); + for (var i = 0; i <= largestIndex; ++i) { + GL.currentContext.tempVertexBufferCounters1[i] = 0; + } + },getSource:function(shader, count, string, length) { + var source = ''; + for (var i = 0; i < count; ++i) { + var len = length ? HEAP32[(((length)+(i*4))>>2)] : -1; + source += UTF8ToString(HEAP32[(((string)+(i*4))>>2)], len < 0 ? undefined : len); + } + return source; + },calcBufLength:function calcBufLength(size, type, stride, count) { + if (stride > 0) { + return count * stride; // XXXvlad this is not exactly correct I don't think + } + var typeSize = GL.byteSizeByType[type - GL.byteSizeByTypeRoot]; + return size * typeSize * count; + },usedTempBuffers:[],preDrawHandleClientVertexAttribBindings:function preDrawHandleClientVertexAttribBindings(count) { + GL.resetBufferBinding = false; + + // TODO: initial pass to detect ranges we need to upload, might not need an upload per attrib + for (var i = 0; i < GL.currentContext.maxVertexAttribs; ++i) { + var cb = GL.currentContext.clientBuffers[i]; + if (!cb.clientside || !cb.enabled) continue; + + GL.resetBufferBinding = true; + + var size = GL.calcBufLength(cb.size, cb.type, cb.stride, count); + var buf = GL.getTempVertexBuffer(size); + GLctx.bindBuffer(0x8892 /*GL_ARRAY_BUFFER*/, buf); + GLctx.bufferSubData(0x8892 /*GL_ARRAY_BUFFER*/, + 0, + HEAPU8.subarray(cb.ptr, cb.ptr + size)); + cb.vertexAttribPointerAdaptor.call(GLctx, i, cb.size, cb.type, cb.normalized, cb.stride, 0); + } + },postDrawHandleClientVertexAttribBindings:function postDrawHandleClientVertexAttribBindings() { + if (GL.resetBufferBinding) { + GLctx.bindBuffer(0x8892 /*GL_ARRAY_BUFFER*/, GL.buffers[GLctx.currentArrayBufferBinding]); + } + },createContext:function(canvas, webGLContextAttributes) { + + // If WebGL context has already been preinitialized for the page on the JS side, reuse that context instead. This is useful for example when + // the main page precompiles shaders for the application, in which case the WebGL context is created already before any Emscripten compiled + // code has been downloaded. + if (Module['preinitializedWebGLContext']) { + var ctx = Module['preinitializedWebGLContext']; + webGLContextAttributes.majorVersion = (typeof WebGL2RenderingContext !== 'undefined' && ctx instanceof WebGL2RenderingContext) ? 2 : 1; + } else { + + // BUG: Workaround Safari WebGL issue: After successfully acquiring WebGL context on a canvas, + // calling .getContext() will always return that context independent of which 'webgl' or 'webgl2' + // context version was passed. See https://bugs.webkit.org/show_bug.cgi?id=222758 and + // https://github.com/emscripten-core/emscripten/issues/13295. + // TODO: Once the bug is fixed and shipped in Safari, adjust the Safari version field in above check. + if (!canvas.getContextSafariWebGL2Fixed) { + canvas.getContextSafariWebGL2Fixed = canvas.getContext; + canvas.getContext = function(ver, attrs) { + var gl = canvas.getContextSafariWebGL2Fixed(ver, attrs); + return ((ver == 'webgl') == (gl instanceof WebGLRenderingContext)) ? gl : null; + } + } + + var ctx = + (webGLContextAttributes.majorVersion > 1) + ? + canvas.getContext("webgl2", webGLContextAttributes) + : + (canvas.getContext("webgl", webGLContextAttributes) + // https://caniuse.com/#feat=webgl + ); + + } + + if (!ctx) return 0; + + var handle = GL.registerContext(ctx, webGLContextAttributes); + + return handle; + },registerContext:function(ctx, webGLContextAttributes) { + // without pthreads a context is just an integer ID + var handle = GL.getNewId(GL.contexts); + + var context = { + handle: handle, + attributes: webGLContextAttributes, + version: webGLContextAttributes.majorVersion, + GLctx: ctx + }; + + // Store the created context object so that we can access the context given a canvas without having to pass the parameters again. + if (ctx.canvas) ctx.canvas.GLctxObject = context; + GL.contexts[handle] = context; + if (typeof webGLContextAttributes.enableExtensionsByDefault === 'undefined' || webGLContextAttributes.enableExtensionsByDefault) { + GL.initExtensions(context); + } + + context.maxVertexAttribs = context.GLctx.getParameter(0x8869 /*GL_MAX_VERTEX_ATTRIBS*/); + context.clientBuffers = []; + for (var i = 0; i < context.maxVertexAttribs; i++) { + context.clientBuffers[i] = { enabled: false, clientside: false, size: 0, type: 0, normalized: 0, stride: 0, ptr: 0, vertexAttribPointerAdaptor: null }; + } + + GL.generateTempBuffers(false, context); + + return handle; + },makeContextCurrent:function(contextHandle) { + + GL.currentContext = GL.contexts[contextHandle]; // Active Emscripten GL layer context object. + Module.ctx = GLctx = GL.currentContext && GL.currentContext.GLctx; // Active WebGL context object. + return !(contextHandle && !GLctx); + },getContext:function(contextHandle) { + return GL.contexts[contextHandle]; + },deleteContext:function(contextHandle) { + if (GL.currentContext === GL.contexts[contextHandle]) GL.currentContext = null; + if (typeof JSEvents === 'object') JSEvents.removeAllHandlersOnTarget(GL.contexts[contextHandle].GLctx.canvas); // Release all JS event handlers on the DOM element that the GL context is associated with since the context is now deleted. + if (GL.contexts[contextHandle] && GL.contexts[contextHandle].GLctx.canvas) GL.contexts[contextHandle].GLctx.canvas.GLctxObject = undefined; // Make sure the canvas object no longer refers to the context object so there are no GC surprises. + GL.contexts[contextHandle] = null; + },initExtensions:function(context) { + // If this function is called without a specific context object, init the extensions of the currently active context. + if (!context) context = GL.currentContext; + + if (context.initExtensionsDone) return; + context.initExtensionsDone = true; + + var GLctx = context.GLctx; + + // Detect the presence of a few extensions manually, this GL interop layer itself will need to know if they exist. + + // Extensions that are only available in WebGL 1 (the calls will be no-ops if called on a WebGL 2 context active) + __webgl_enable_ANGLE_instanced_arrays(GLctx); + __webgl_enable_OES_vertex_array_object(GLctx); + __webgl_enable_WEBGL_draw_buffers(GLctx); + // Extensions that are available from WebGL >= 2 (no-op if called on a WebGL 1 context active) + __webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance(GLctx); + __webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance(GLctx); + + // On WebGL 2, EXT_disjoint_timer_query is replaced with an alternative + // that's based on core APIs, and exposes only the queryCounterEXT() + // entrypoint. + if (context.version >= 2) { + GLctx.disjointTimerQueryExt = GLctx.getExtension("EXT_disjoint_timer_query_webgl2"); + } + + // However, Firefox exposes the WebGL 1 version on WebGL 2 as well and + // thus we look for the WebGL 1 version again if the WebGL 2 version + // isn't present. https://bugzilla.mozilla.org/show_bug.cgi?id=1328882 + if (context.version < 2 || !GLctx.disjointTimerQueryExt) + { + GLctx.disjointTimerQueryExt = GLctx.getExtension("EXT_disjoint_timer_query"); + } + + __webgl_enable_WEBGL_multi_draw(GLctx); + + // .getSupportedExtensions() can return null if context is lost, so coerce to empty array. + var exts = GLctx.getSupportedExtensions() || []; + exts.forEach(function(ext) { + // WEBGL_lose_context, WEBGL_debug_renderer_info and WEBGL_debug_shaders are not enabled by default. + if (!ext.includes('lose_context') && !ext.includes('debug')) { + // Call .getExtension() to enable that extension permanently. + GLctx.getExtension(ext); + } + }); + }}; + function _emscripten_glActiveTexture(x0) { GLctx['activeTexture'](x0) } + + function _emscripten_glAttachShader(program, shader) { + GLctx.attachShader(GL.programs[program], GL.shaders[shader]); + } + + function _emscripten_glBeginQuery(target, id) { + GLctx['beginQuery'](target, GL.queries[id]); + } + + function _emscripten_glBeginQueryEXT(target, id) { + GLctx.disjointTimerQueryExt['beginQueryEXT'](target, GL.queries[id]); + } + + function _emscripten_glBeginTransformFeedback(x0) { GLctx['beginTransformFeedback'](x0) } + + function _emscripten_glBindAttribLocation(program, index, name) { + GLctx.bindAttribLocation(GL.programs[program], index, UTF8ToString(name)); + } + + function _emscripten_glBindBuffer(target, buffer) { + if (target == 0x8892 /*GL_ARRAY_BUFFER*/) { + GLctx.currentArrayBufferBinding = buffer; + } else if (target == 0x8893 /*GL_ELEMENT_ARRAY_BUFFER*/) { + GLctx.currentElementArrayBufferBinding = buffer; + } + + if (target == 0x88EB /*GL_PIXEL_PACK_BUFFER*/) { + // In WebGL 2 glReadPixels entry point, we need to use a different WebGL 2 API function call when a buffer is bound to + // GL_PIXEL_PACK_BUFFER_BINDING point, so must keep track whether that binding point is non-null to know what is + // the proper API function to call. + GLctx.currentPixelPackBufferBinding = buffer; + } else if (target == 0x88EC /*GL_PIXEL_UNPACK_BUFFER*/) { + // In WebGL 2 gl(Compressed)Tex(Sub)Image[23]D entry points, we need to + // use a different WebGL 2 API function call when a buffer is bound to + // GL_PIXEL_UNPACK_BUFFER_BINDING point, so must keep track whether that + // binding point is non-null to know what is the proper API function to + // call. + GLctx.currentPixelUnpackBufferBinding = buffer; + } + GLctx.bindBuffer(target, GL.buffers[buffer]); + } + + function _emscripten_glBindBufferBase(target, index, buffer) { + GLctx['bindBufferBase'](target, index, GL.buffers[buffer]); + } + + function _emscripten_glBindBufferRange(target, index, buffer, offset, ptrsize) { + GLctx['bindBufferRange'](target, index, GL.buffers[buffer], offset, ptrsize); + } + + function _emscripten_glBindFramebuffer(target, framebuffer) { + + GLctx.bindFramebuffer(target, GL.framebuffers[framebuffer]); + + } + + function _emscripten_glBindRenderbuffer(target, renderbuffer) { + GLctx.bindRenderbuffer(target, GL.renderbuffers[renderbuffer]); + } + + function _emscripten_glBindSampler(unit, sampler) { + GLctx['bindSampler'](unit, GL.samplers[sampler]); + } + + function _emscripten_glBindTexture(target, texture) { + GLctx.bindTexture(target, GL.textures[texture]); + } + + function _emscripten_glBindTransformFeedback(target, id) { + GLctx['bindTransformFeedback'](target, GL.transformFeedbacks[id]); + } + + function _emscripten_glBindVertexArray(vao) { + GLctx['bindVertexArray'](GL.vaos[vao]); + var ibo = GLctx.getParameter(0x8895 /*ELEMENT_ARRAY_BUFFER_BINDING*/); + GLctx.currentElementArrayBufferBinding = ibo ? (ibo.name | 0) : 0; + } + + function _emscripten_glBindVertexArrayOES(vao) { + GLctx['bindVertexArray'](GL.vaos[vao]); + var ibo = GLctx.getParameter(0x8895 /*ELEMENT_ARRAY_BUFFER_BINDING*/); + GLctx.currentElementArrayBufferBinding = ibo ? (ibo.name | 0) : 0; + } + + function _emscripten_glBlendColor(x0, x1, x2, x3) { GLctx['blendColor'](x0, x1, x2, x3) } + + function _emscripten_glBlendEquation(x0) { GLctx['blendEquation'](x0) } + + function _emscripten_glBlendEquationSeparate(x0, x1) { GLctx['blendEquationSeparate'](x0, x1) } + + function _emscripten_glBlendFunc(x0, x1) { GLctx['blendFunc'](x0, x1) } + + function _emscripten_glBlendFuncSeparate(x0, x1, x2, x3) { GLctx['blendFuncSeparate'](x0, x1, x2, x3) } + + function _emscripten_glBlitFramebuffer(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) { GLctx['blitFramebuffer'](x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) } + + function _emscripten_glBufferData(target, size, data, usage) { + + if (GL.currentContext.version >= 2) { // WebGL 2 provides new garbage-free entry points to call to WebGL. Use those always when possible. + if (data) { + GLctx.bufferData(target, HEAPU8, usage, data, size); + } else { + GLctx.bufferData(target, size, usage); + } + } else { + // N.b. here first form specifies a heap subarray, second form an integer size, so the ?: code here is polymorphic. It is advised to avoid + // randomly mixing both uses in calling code, to avoid any potential JS engine JIT issues. + GLctx.bufferData(target, data ? HEAPU8.subarray(data, data+size) : size, usage); + } + } + + function _emscripten_glBufferSubData(target, offset, size, data) { + if (GL.currentContext.version >= 2) { // WebGL 2 provides new garbage-free entry points to call to WebGL. Use those always when possible. + GLctx.bufferSubData(target, offset, HEAPU8, data, size); + return; + } + GLctx.bufferSubData(target, offset, HEAPU8.subarray(data, data+size)); + } + + function _emscripten_glCheckFramebufferStatus(x0) { return GLctx['checkFramebufferStatus'](x0) } + + function _emscripten_glClear(x0) { GLctx['clear'](x0) } + + function _emscripten_glClearBufferfi(x0, x1, x2, x3) { GLctx['clearBufferfi'](x0, x1, x2, x3) } + + function _emscripten_glClearBufferfv(buffer, drawbuffer, value) { + + GLctx['clearBufferfv'](buffer, drawbuffer, HEAPF32, value>>2); + } + + function _emscripten_glClearBufferiv(buffer, drawbuffer, value) { + + GLctx['clearBufferiv'](buffer, drawbuffer, HEAP32, value>>2); + } + + function _emscripten_glClearBufferuiv(buffer, drawbuffer, value) { + + GLctx['clearBufferuiv'](buffer, drawbuffer, HEAPU32, value>>2); + } + + function _emscripten_glClearColor(x0, x1, x2, x3) { GLctx['clearColor'](x0, x1, x2, x3) } + + function _emscripten_glClearDepthf(x0) { GLctx['clearDepth'](x0) } + + function _emscripten_glClearStencil(x0) { GLctx['clearStencil'](x0) } + + function convertI32PairToI53(lo, hi) { + return (lo >>> 0) + hi * 4294967296; + } + function _emscripten_glClientWaitSync(sync, flags, timeoutLo, timeoutHi) { + // WebGL2 vs GLES3 differences: in GLES3, the timeout parameter is a uint64, where 0xFFFFFFFFFFFFFFFFULL means GL_TIMEOUT_IGNORED. + // In JS, there's no 64-bit value types, so instead timeout is taken to be signed, and GL_TIMEOUT_IGNORED is given value -1. + // Inherently the value accepted in the timeout is lossy, and can't take in arbitrary u64 bit pattern (but most likely doesn't matter) + // See https://www.khronos.org/registry/webgl/specs/latest/2.0/#5.15 + return GLctx.clientWaitSync(GL.syncs[sync], flags, convertI32PairToI53(timeoutLo, timeoutHi)); + } + + function _emscripten_glColorMask(red, green, blue, alpha) { + GLctx.colorMask(!!red, !!green, !!blue, !!alpha); + } + + function _emscripten_glCompileShader(shader) { + GLctx.compileShader(GL.shaders[shader]); + } + + function _emscripten_glCompressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, data) { + if (GL.currentContext.version >= 2) { // WebGL 2 provides new garbage-free entry points to call to WebGL. Use those always when possible. + if (GLctx.currentPixelUnpackBufferBinding) { + GLctx['compressedTexImage2D'](target, level, internalFormat, width, height, border, imageSize, data); + } else { + GLctx['compressedTexImage2D'](target, level, internalFormat, width, height, border, HEAPU8, data, imageSize); + } + return; + } + GLctx['compressedTexImage2D'](target, level, internalFormat, width, height, border, data ? HEAPU8.subarray((data), (data+imageSize)) : null); + } + + function _emscripten_glCompressedTexImage3D(target, level, internalFormat, width, height, depth, border, imageSize, data) { + if (GLctx.currentPixelUnpackBufferBinding) { + GLctx['compressedTexImage3D'](target, level, internalFormat, width, height, depth, border, imageSize, data); + } else { + GLctx['compressedTexImage3D'](target, level, internalFormat, width, height, depth, border, HEAPU8, data, imageSize); + } + } + + function _emscripten_glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data) { + if (GL.currentContext.version >= 2) { // WebGL 2 provides new garbage-free entry points to call to WebGL. Use those always when possible. + if (GLctx.currentPixelUnpackBufferBinding) { + GLctx['compressedTexSubImage2D'](target, level, xoffset, yoffset, width, height, format, imageSize, data); + } else { + GLctx['compressedTexSubImage2D'](target, level, xoffset, yoffset, width, height, format, HEAPU8, data, imageSize); + } + return; + } + GLctx['compressedTexSubImage2D'](target, level, xoffset, yoffset, width, height, format, data ? HEAPU8.subarray((data), (data+imageSize)) : null); + } + + function _emscripten_glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data) { + if (GLctx.currentPixelUnpackBufferBinding) { + GLctx['compressedTexSubImage3D'](target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); + } else { + GLctx['compressedTexSubImage3D'](target, level, xoffset, yoffset, zoffset, width, height, depth, format, HEAPU8, data, imageSize); + } + } + + function _emscripten_glCopyBufferSubData(x0, x1, x2, x3, x4) { GLctx['copyBufferSubData'](x0, x1, x2, x3, x4) } + + function _emscripten_glCopyTexImage2D(x0, x1, x2, x3, x4, x5, x6, x7) { GLctx['copyTexImage2D'](x0, x1, x2, x3, x4, x5, x6, x7) } + + function _emscripten_glCopyTexSubImage2D(x0, x1, x2, x3, x4, x5, x6, x7) { GLctx['copyTexSubImage2D'](x0, x1, x2, x3, x4, x5, x6, x7) } + + function _emscripten_glCopyTexSubImage3D(x0, x1, x2, x3, x4, x5, x6, x7, x8) { GLctx['copyTexSubImage3D'](x0, x1, x2, x3, x4, x5, x6, x7, x8) } + + function _emscripten_glCreateProgram() { + var id = GL.getNewId(GL.programs); + var program = GLctx.createProgram(); + // Store additional information needed for each shader program: + program.name = id; + // Lazy cache results of glGetProgramiv(GL_ACTIVE_UNIFORM_MAX_LENGTH/GL_ACTIVE_ATTRIBUTE_MAX_LENGTH/GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH) + program.maxUniformLength = program.maxAttributeLength = program.maxUniformBlockNameLength = 0; + program.uniformIdCounter = 1; + GL.programs[id] = program; + return id; + } + + function _emscripten_glCreateShader(shaderType) { + var id = GL.getNewId(GL.shaders); + GL.shaders[id] = GLctx.createShader(shaderType); + + return id; + } + + function _emscripten_glCullFace(x0) { GLctx['cullFace'](x0) } + + function _emscripten_glDeleteBuffers(n, buffers) { + for (var i = 0; i < n; i++) { + var id = HEAP32[(((buffers)+(i*4))>>2)]; + var buffer = GL.buffers[id]; + + // From spec: "glDeleteBuffers silently ignores 0's and names that do not + // correspond to existing buffer objects." + if (!buffer) continue; + + GLctx.deleteBuffer(buffer); + buffer.name = 0; + GL.buffers[id] = null; + + if (id == GLctx.currentArrayBufferBinding) GLctx.currentArrayBufferBinding = 0; + if (id == GLctx.currentElementArrayBufferBinding) GLctx.currentElementArrayBufferBinding = 0; + if (id == GLctx.currentPixelPackBufferBinding) GLctx.currentPixelPackBufferBinding = 0; + if (id == GLctx.currentPixelUnpackBufferBinding) GLctx.currentPixelUnpackBufferBinding = 0; + } + } + + function _emscripten_glDeleteFramebuffers(n, framebuffers) { + for (var i = 0; i < n; ++i) { + var id = HEAP32[(((framebuffers)+(i*4))>>2)]; + var framebuffer = GL.framebuffers[id]; + if (!framebuffer) continue; // GL spec: "glDeleteFramebuffers silently ignores 0s and names that do not correspond to existing framebuffer objects". + GLctx.deleteFramebuffer(framebuffer); + framebuffer.name = 0; + GL.framebuffers[id] = null; + } + } + + function _emscripten_glDeleteProgram(id) { + if (!id) return; + var program = GL.programs[id]; + if (!program) { // glDeleteProgram actually signals an error when deleting a nonexisting object, unlike some other GL delete functions. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + GLctx.deleteProgram(program); + program.name = 0; + GL.programs[id] = null; + } + + function _emscripten_glDeleteQueries(n, ids) { + for (var i = 0; i < n; i++) { + var id = HEAP32[(((ids)+(i*4))>>2)]; + var query = GL.queries[id]; + if (!query) continue; // GL spec: "unused names in ids are ignored, as is the name zero." + GLctx['deleteQuery'](query); + GL.queries[id] = null; + } + } + + function _emscripten_glDeleteQueriesEXT(n, ids) { + for (var i = 0; i < n; i++) { + var id = HEAP32[(((ids)+(i*4))>>2)]; + var query = GL.queries[id]; + if (!query) continue; // GL spec: "unused names in ids are ignored, as is the name zero." + GLctx.disjointTimerQueryExt['deleteQueryEXT'](query); + GL.queries[id] = null; + } + } + + function _emscripten_glDeleteRenderbuffers(n, renderbuffers) { + for (var i = 0; i < n; i++) { + var id = HEAP32[(((renderbuffers)+(i*4))>>2)]; + var renderbuffer = GL.renderbuffers[id]; + if (!renderbuffer) continue; // GL spec: "glDeleteRenderbuffers silently ignores 0s and names that do not correspond to existing renderbuffer objects". + GLctx.deleteRenderbuffer(renderbuffer); + renderbuffer.name = 0; + GL.renderbuffers[id] = null; + } + } + + function _emscripten_glDeleteSamplers(n, samplers) { + for (var i = 0; i < n; i++) { + var id = HEAP32[(((samplers)+(i*4))>>2)]; + var sampler = GL.samplers[id]; + if (!sampler) continue; + GLctx['deleteSampler'](sampler); + sampler.name = 0; + GL.samplers[id] = null; + } + } + + function _emscripten_glDeleteShader(id) { + if (!id) return; + var shader = GL.shaders[id]; + if (!shader) { // glDeleteShader actually signals an error when deleting a nonexisting object, unlike some other GL delete functions. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + GLctx.deleteShader(shader); + GL.shaders[id] = null; + } + + function _emscripten_glDeleteSync(id) { + if (!id) return; + var sync = GL.syncs[id]; + if (!sync) { // glDeleteSync signals an error when deleting a nonexisting object, unlike some other GL delete functions. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + GLctx.deleteSync(sync); + sync.name = 0; + GL.syncs[id] = null; + } + + function _emscripten_glDeleteTextures(n, textures) { + for (var i = 0; i < n; i++) { + var id = HEAP32[(((textures)+(i*4))>>2)]; + var texture = GL.textures[id]; + if (!texture) continue; // GL spec: "glDeleteTextures silently ignores 0s and names that do not correspond to existing textures". + GLctx.deleteTexture(texture); + texture.name = 0; + GL.textures[id] = null; + } + } + + function _emscripten_glDeleteTransformFeedbacks(n, ids) { + for (var i = 0; i < n; i++) { + var id = HEAP32[(((ids)+(i*4))>>2)]; + var transformFeedback = GL.transformFeedbacks[id]; + if (!transformFeedback) continue; // GL spec: "unused names in ids are ignored, as is the name zero." + GLctx['deleteTransformFeedback'](transformFeedback); + transformFeedback.name = 0; + GL.transformFeedbacks[id] = null; + } + } + + function _emscripten_glDeleteVertexArrays(n, vaos) { + for (var i = 0; i < n; i++) { + var id = HEAP32[(((vaos)+(i*4))>>2)]; + GLctx['deleteVertexArray'](GL.vaos[id]); + GL.vaos[id] = null; + } + } + + function _emscripten_glDeleteVertexArraysOES(n, vaos) { + for (var i = 0; i < n; i++) { + var id = HEAP32[(((vaos)+(i*4))>>2)]; + GLctx['deleteVertexArray'](GL.vaos[id]); + GL.vaos[id] = null; + } + } + + function _emscripten_glDepthFunc(x0) { GLctx['depthFunc'](x0) } + + function _emscripten_glDepthMask(flag) { + GLctx.depthMask(!!flag); + } + + function _emscripten_glDepthRangef(x0, x1) { GLctx['depthRange'](x0, x1) } + + function _emscripten_glDetachShader(program, shader) { + GLctx.detachShader(GL.programs[program], GL.shaders[shader]); + } + + function _emscripten_glDisable(x0) { GLctx['disable'](x0) } + + function _emscripten_glDisableVertexAttribArray(index) { + var cb = GL.currentContext.clientBuffers[index]; + cb.enabled = false; + GLctx.disableVertexAttribArray(index); + } + + function _emscripten_glDrawArrays(mode, first, count) { + // bind any client-side buffers + GL.preDrawHandleClientVertexAttribBindings(first + count); + + GLctx.drawArrays(mode, first, count); + + GL.postDrawHandleClientVertexAttribBindings(); + } + + function _emscripten_glDrawArraysInstanced(mode, first, count, primcount) { + GLctx['drawArraysInstanced'](mode, first, count, primcount); + } + + function _emscripten_glDrawArraysInstancedANGLE(mode, first, count, primcount) { + GLctx['drawArraysInstanced'](mode, first, count, primcount); + } + + function _emscripten_glDrawArraysInstancedARB(mode, first, count, primcount) { + GLctx['drawArraysInstanced'](mode, first, count, primcount); + } + + function _emscripten_glDrawArraysInstancedEXT(mode, first, count, primcount) { + GLctx['drawArraysInstanced'](mode, first, count, primcount); + } + + function _emscripten_glDrawArraysInstancedNV(mode, first, count, primcount) { + GLctx['drawArraysInstanced'](mode, first, count, primcount); + } + + var tempFixedLengthArray = []; + function _emscripten_glDrawBuffers(n, bufs) { + + var bufArray = tempFixedLengthArray[n]; + for (var i = 0; i < n; i++) { + bufArray[i] = HEAP32[(((bufs)+(i*4))>>2)]; + } + + GLctx['drawBuffers'](bufArray); + } + + function _emscripten_glDrawBuffersEXT(n, bufs) { + + var bufArray = tempFixedLengthArray[n]; + for (var i = 0; i < n; i++) { + bufArray[i] = HEAP32[(((bufs)+(i*4))>>2)]; + } + + GLctx['drawBuffers'](bufArray); + } + + function _emscripten_glDrawBuffersWEBGL(n, bufs) { + + var bufArray = tempFixedLengthArray[n]; + for (var i = 0; i < n; i++) { + bufArray[i] = HEAP32[(((bufs)+(i*4))>>2)]; + } + + GLctx['drawBuffers'](bufArray); + } + + function _emscripten_glDrawElements(mode, count, type, indices) { + var buf; + if (!GLctx.currentElementArrayBufferBinding) { + var size = GL.calcBufLength(1, type, 0, count); + buf = GL.getTempIndexBuffer(size); + GLctx.bindBuffer(0x8893 /*GL_ELEMENT_ARRAY_BUFFER*/, buf); + GLctx.bufferSubData(0x8893 /*GL_ELEMENT_ARRAY_BUFFER*/, + 0, + HEAPU8.subarray(indices, indices + size)); + // the index is now 0 + indices = 0; + } + + // bind any client-side buffers + GL.preDrawHandleClientVertexAttribBindings(count); + + GLctx.drawElements(mode, count, type, indices); + + GL.postDrawHandleClientVertexAttribBindings(count); + + if (!GLctx.currentElementArrayBufferBinding) { + GLctx.bindBuffer(0x8893 /*GL_ELEMENT_ARRAY_BUFFER*/, null); + } + } + + function _emscripten_glDrawElementsInstanced(mode, count, type, indices, primcount) { + GLctx['drawElementsInstanced'](mode, count, type, indices, primcount); + } + + function _emscripten_glDrawElementsInstancedANGLE(mode, count, type, indices, primcount) { + GLctx['drawElementsInstanced'](mode, count, type, indices, primcount); + } + + function _emscripten_glDrawElementsInstancedARB(mode, count, type, indices, primcount) { + GLctx['drawElementsInstanced'](mode, count, type, indices, primcount); + } + + function _emscripten_glDrawElementsInstancedEXT(mode, count, type, indices, primcount) { + GLctx['drawElementsInstanced'](mode, count, type, indices, primcount); + } + + function _emscripten_glDrawElementsInstancedNV(mode, count, type, indices, primcount) { + GLctx['drawElementsInstanced'](mode, count, type, indices, primcount); + } + + function _glDrawElements(mode, count, type, indices) { + var buf; + if (!GLctx.currentElementArrayBufferBinding) { + var size = GL.calcBufLength(1, type, 0, count); + buf = GL.getTempIndexBuffer(size); + GLctx.bindBuffer(0x8893 /*GL_ELEMENT_ARRAY_BUFFER*/, buf); + GLctx.bufferSubData(0x8893 /*GL_ELEMENT_ARRAY_BUFFER*/, + 0, + HEAPU8.subarray(indices, indices + size)); + // the index is now 0 + indices = 0; + } + + // bind any client-side buffers + GL.preDrawHandleClientVertexAttribBindings(count); + + GLctx.drawElements(mode, count, type, indices); + + GL.postDrawHandleClientVertexAttribBindings(count); + + if (!GLctx.currentElementArrayBufferBinding) { + GLctx.bindBuffer(0x8893 /*GL_ELEMENT_ARRAY_BUFFER*/, null); + } + } + function _emscripten_glDrawRangeElements(mode, start, end, count, type, indices) { + // TODO: This should be a trivial pass-though function registered at the bottom of this page as + // glFuncs[6][1] += ' drawRangeElements'; + // but due to https://bugzilla.mozilla.org/show_bug.cgi?id=1202427, + // we work around by ignoring the range. + _glDrawElements(mode, count, type, indices); + } + + function _emscripten_glEnable(x0) { GLctx['enable'](x0) } + + function _emscripten_glEnableVertexAttribArray(index) { + var cb = GL.currentContext.clientBuffers[index]; + cb.enabled = true; + GLctx.enableVertexAttribArray(index); + } + + function _emscripten_glEndQuery(x0) { GLctx['endQuery'](x0) } + + function _emscripten_glEndQueryEXT(target) { + GLctx.disjointTimerQueryExt['endQueryEXT'](target); + } + + function _emscripten_glEndTransformFeedback() { GLctx['endTransformFeedback']() } + + function _emscripten_glFenceSync(condition, flags) { + var sync = GLctx.fenceSync(condition, flags); + if (sync) { + var id = GL.getNewId(GL.syncs); + sync.name = id; + GL.syncs[id] = sync; + return id; + } else { + return 0; // Failed to create a sync object + } + } + + function _emscripten_glFinish() { GLctx['finish']() } + + function _emscripten_glFlush() { GLctx['flush']() } + + function emscriptenWebGLGetBufferBinding(target) { + switch (target) { + case 0x8892 /*GL_ARRAY_BUFFER*/: target = 0x8894 /*GL_ARRAY_BUFFER_BINDING*/; break; + case 0x8893 /*GL_ELEMENT_ARRAY_BUFFER*/: target = 0x8895 /*GL_ELEMENT_ARRAY_BUFFER_BINDING*/; break; + case 0x88EB /*GL_PIXEL_PACK_BUFFER*/: target = 0x88ED /*GL_PIXEL_PACK_BUFFER_BINDING*/; break; + case 0x88EC /*GL_PIXEL_UNPACK_BUFFER*/: target = 0x88EF /*GL_PIXEL_UNPACK_BUFFER_BINDING*/; break; + case 0x8C8E /*GL_TRANSFORM_FEEDBACK_BUFFER*/: target = 0x8C8F /*GL_TRANSFORM_FEEDBACK_BUFFER_BINDING*/; break; + case 0x8F36 /*GL_COPY_READ_BUFFER*/: target = 0x8F36 /*GL_COPY_READ_BUFFER_BINDING*/; break; + case 0x8F37 /*GL_COPY_WRITE_BUFFER*/: target = 0x8F37 /*GL_COPY_WRITE_BUFFER_BINDING*/; break; + case 0x8A11 /*GL_UNIFORM_BUFFER*/: target = 0x8A28 /*GL_UNIFORM_BUFFER_BINDING*/; break; + // In default case, fall through and assume passed one of the _BINDING enums directly. + } + var buffer = GLctx.getParameter(target); + if (buffer) return buffer.name|0; + else return 0; + } + + function emscriptenWebGLValidateMapBufferTarget(target) { + switch (target) { + case 0x8892: // GL_ARRAY_BUFFER + case 0x8893: // GL_ELEMENT_ARRAY_BUFFER + case 0x8F36: // GL_COPY_READ_BUFFER + case 0x8F37: // GL_COPY_WRITE_BUFFER + case 0x88EB: // GL_PIXEL_PACK_BUFFER + case 0x88EC: // GL_PIXEL_UNPACK_BUFFER + case 0x8C2A: // GL_TEXTURE_BUFFER + case 0x8C8E: // GL_TRANSFORM_FEEDBACK_BUFFER + case 0x8A11: // GL_UNIFORM_BUFFER + return true; + default: + return false; + } + } + function _emscripten_glFlushMappedBufferRange(target, offset, length) { + if (!emscriptenWebGLValidateMapBufferTarget(target)) { + GL.recordError(0x500/*GL_INVALID_ENUM*/); + err('GL_INVALID_ENUM in glFlushMappedBufferRange'); + return; + } + + var mapping = GL.mappedBuffers[emscriptenWebGLGetBufferBinding(target)]; + if (!mapping) { + GL.recordError(0x502 /* GL_INVALID_OPERATION */); + err('buffer was never mapped in glFlushMappedBufferRange'); + return; + } + + if (!(mapping.access & 0x10)) { + GL.recordError(0x502 /* GL_INVALID_OPERATION */); + err('buffer was not mapped with GL_MAP_FLUSH_EXPLICIT_BIT in glFlushMappedBufferRange'); + return; + } + if (offset < 0 || length < 0 || offset + length > mapping.length) { + GL.recordError(0x501 /* GL_INVALID_VALUE */); + err('invalid range in glFlushMappedBufferRange'); + return; + } + + GLctx.bufferSubData( + target, + mapping.offset, + HEAPU8.subarray(mapping.mem + offset, mapping.mem + offset + length)); + } + + function _emscripten_glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer) { + GLctx.framebufferRenderbuffer(target, attachment, renderbuffertarget, + GL.renderbuffers[renderbuffer]); + } + + function _emscripten_glFramebufferTexture2D(target, attachment, textarget, texture, level) { + GLctx.framebufferTexture2D(target, attachment, textarget, + GL.textures[texture], level); + } + + function _emscripten_glFramebufferTextureLayer(target, attachment, texture, level, layer) { + GLctx.framebufferTextureLayer(target, attachment, GL.textures[texture], level, layer); + } + + function _emscripten_glFrontFace(x0) { GLctx['frontFace'](x0) } + + function __glGenObject(n, buffers, createFunction, objectTable + ) { + for (var i = 0; i < n; i++) { + var buffer = GLctx[createFunction](); + var id = buffer && GL.getNewId(objectTable); + if (buffer) { + buffer.name = id; + objectTable[id] = buffer; + } else { + GL.recordError(0x502 /* GL_INVALID_OPERATION */); + } + HEAP32[(((buffers)+(i*4))>>2)] = id; + } + } + function _emscripten_glGenBuffers(n, buffers) { + __glGenObject(n, buffers, 'createBuffer', GL.buffers + ); + } + + function _emscripten_glGenFramebuffers(n, ids) { + __glGenObject(n, ids, 'createFramebuffer', GL.framebuffers + ); + } + + function _emscripten_glGenQueries(n, ids) { + __glGenObject(n, ids, 'createQuery', GL.queries + ); + } + + function _emscripten_glGenQueriesEXT(n, ids) { + for (var i = 0; i < n; i++) { + var query = GLctx.disjointTimerQueryExt['createQueryEXT'](); + if (!query) { + GL.recordError(0x502 /* GL_INVALID_OPERATION */); + while (i < n) HEAP32[(((ids)+(i++*4))>>2)] = 0; + return; + } + var id = GL.getNewId(GL.queries); + query.name = id; + GL.queries[id] = query; + HEAP32[(((ids)+(i*4))>>2)] = id; + } + } + + function _emscripten_glGenRenderbuffers(n, renderbuffers) { + __glGenObject(n, renderbuffers, 'createRenderbuffer', GL.renderbuffers + ); + } + + function _emscripten_glGenSamplers(n, samplers) { + __glGenObject(n, samplers, 'createSampler', GL.samplers + ); + } + + function _emscripten_glGenTextures(n, textures) { + __glGenObject(n, textures, 'createTexture', GL.textures + ); + } + + function _emscripten_glGenTransformFeedbacks(n, ids) { + __glGenObject(n, ids, 'createTransformFeedback', GL.transformFeedbacks + ); + } + + function _emscripten_glGenVertexArrays(n, arrays) { + __glGenObject(n, arrays, 'createVertexArray', GL.vaos + ); + } + + function _emscripten_glGenVertexArraysOES(n, arrays) { + __glGenObject(n, arrays, 'createVertexArray', GL.vaos + ); + } + + function _emscripten_glGenerateMipmap(x0) { GLctx['generateMipmap'](x0) } + + function __glGetActiveAttribOrUniform(funcName, program, index, bufSize, length, size, type, name) { + program = GL.programs[program]; + var info = GLctx[funcName](program, index); + if (info) { // If an error occurs, nothing will be written to length, size and type and name. + var numBytesWrittenExclNull = name && stringToUTF8(info.name, name, bufSize); + if (length) HEAP32[((length)>>2)] = numBytesWrittenExclNull; + if (size) HEAP32[((size)>>2)] = info.size; + if (type) HEAP32[((type)>>2)] = info.type; + } + } + function _emscripten_glGetActiveAttrib(program, index, bufSize, length, size, type, name) { + __glGetActiveAttribOrUniform('getActiveAttrib', program, index, bufSize, length, size, type, name); + } + + function _emscripten_glGetActiveUniform(program, index, bufSize, length, size, type, name) { + __glGetActiveAttribOrUniform('getActiveUniform', program, index, bufSize, length, size, type, name); + } + + function _emscripten_glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName) { + program = GL.programs[program]; + + var result = GLctx['getActiveUniformBlockName'](program, uniformBlockIndex); + if (!result) return; // If an error occurs, nothing will be written to uniformBlockName or length. + if (uniformBlockName && bufSize > 0) { + var numBytesWrittenExclNull = stringToUTF8(result, uniformBlockName, bufSize); + if (length) HEAP32[((length)>>2)] = numBytesWrittenExclNull; + } else { + if (length) HEAP32[((length)>>2)] = 0; + } + } + + function _emscripten_glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, params) { + if (!params) { + // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense + // if params == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + program = GL.programs[program]; + + if (pname == 0x8A41 /* GL_UNIFORM_BLOCK_NAME_LENGTH */) { + var name = GLctx['getActiveUniformBlockName'](program, uniformBlockIndex); + HEAP32[((params)>>2)] = name.length+1; + return; + } + + var result = GLctx['getActiveUniformBlockParameter'](program, uniformBlockIndex, pname); + if (result === null) return; // If an error occurs, nothing should be written to params. + if (pname == 0x8A43 /*GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES*/) { + for (var i = 0; i < result.length; i++) { + HEAP32[(((params)+(i*4))>>2)] = result[i]; + } + } else { + HEAP32[((params)>>2)] = result; + } + } + + function _emscripten_glGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params) { + if (!params) { + // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense + // if params == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + if (uniformCount > 0 && uniformIndices == 0) { + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + program = GL.programs[program]; + var ids = []; + for (var i = 0; i < uniformCount; i++) { + ids.push(HEAP32[(((uniformIndices)+(i*4))>>2)]); + } + + var result = GLctx['getActiveUniforms'](program, ids, pname); + if (!result) return; // GL spec: If an error is generated, nothing is written out to params. + + var len = result.length; + for (var i = 0; i < len; i++) { + HEAP32[(((params)+(i*4))>>2)] = result[i]; + } + } + + function _emscripten_glGetAttachedShaders(program, maxCount, count, shaders) { + var result = GLctx.getAttachedShaders(GL.programs[program]); + var len = result.length; + if (len > maxCount) { + len = maxCount; + } + HEAP32[((count)>>2)] = len; + for (var i = 0; i < len; ++i) { + var id = GL.shaders.indexOf(result[i]); + HEAP32[(((shaders)+(i*4))>>2)] = id; + } + } + + function _emscripten_glGetAttribLocation(program, name) { + return GLctx.getAttribLocation(GL.programs[program], UTF8ToString(name)); + } + + function writeI53ToI64(ptr, num) { + HEAPU32[ptr>>2] = num; + HEAPU32[ptr+4>>2] = (num - HEAPU32[ptr>>2])/4294967296; + } + function emscriptenWebGLGet(name_, p, type) { + // Guard against user passing a null pointer. + // Note that GLES2 spec does not say anything about how passing a null pointer should be treated. + // Testing on desktop core GL 3, the application crashes on glGetIntegerv to a null pointer, but + // better to report an error instead of doing anything random. + if (!p) { + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + var ret = undefined; + switch (name_) { // Handle a few trivial GLES values + case 0x8DFA: // GL_SHADER_COMPILER + ret = 1; + break; + case 0x8DF8: // GL_SHADER_BINARY_FORMATS + if (type != 0 && type != 1) { + GL.recordError(0x500); // GL_INVALID_ENUM + } + return; // Do not write anything to the out pointer, since no binary formats are supported. + case 0x87FE: // GL_NUM_PROGRAM_BINARY_FORMATS + case 0x8DF9: // GL_NUM_SHADER_BINARY_FORMATS + ret = 0; + break; + case 0x86A2: // GL_NUM_COMPRESSED_TEXTURE_FORMATS + // WebGL doesn't have GL_NUM_COMPRESSED_TEXTURE_FORMATS (it's obsolete since GL_COMPRESSED_TEXTURE_FORMATS returns a JS array that can be queried for length), + // so implement it ourselves to allow C++ GLES2 code get the length. + var formats = GLctx.getParameter(0x86A3 /*GL_COMPRESSED_TEXTURE_FORMATS*/); + ret = formats ? formats.length : 0; + break; + + case 0x821D: // GL_NUM_EXTENSIONS + if (GL.currentContext.version < 2) { + GL.recordError(0x502 /* GL_INVALID_OPERATION */); // Calling GLES3/WebGL2 function with a GLES2/WebGL1 context + return; + } + // .getSupportedExtensions() can return null if context is lost, so coerce to empty array. + var exts = GLctx.getSupportedExtensions() || []; + ret = 2 * exts.length; // each extension is duplicated, first in unprefixed WebGL form, and then a second time with "GL_" prefix. + break; + case 0x821B: // GL_MAJOR_VERSION + case 0x821C: // GL_MINOR_VERSION + if (GL.currentContext.version < 2) { + GL.recordError(0x500); // GL_INVALID_ENUM + return; + } + ret = name_ == 0x821B ? 3 : 0; // return version 3.0 + break; + } + + if (ret === undefined) { + var result = GLctx.getParameter(name_); + switch (typeof(result)) { + case "number": + ret = result; + break; + case "boolean": + ret = result ? 1 : 0; + break; + case "string": + GL.recordError(0x500); // GL_INVALID_ENUM + return; + case "object": + if (result === null) { + // null is a valid result for some (e.g., which buffer is bound - perhaps nothing is bound), but otherwise + // can mean an invalid name_, which we need to report as an error + switch (name_) { + case 0x8894: // ARRAY_BUFFER_BINDING + case 0x8B8D: // CURRENT_PROGRAM + case 0x8895: // ELEMENT_ARRAY_BUFFER_BINDING + case 0x8CA6: // FRAMEBUFFER_BINDING or DRAW_FRAMEBUFFER_BINDING + case 0x8CA7: // RENDERBUFFER_BINDING + case 0x8069: // TEXTURE_BINDING_2D + case 0x85B5: // WebGL 2 GL_VERTEX_ARRAY_BINDING, or WebGL 1 extension OES_vertex_array_object GL_VERTEX_ARRAY_BINDING_OES + case 0x8F36: // COPY_READ_BUFFER_BINDING or COPY_READ_BUFFER + case 0x8F37: // COPY_WRITE_BUFFER_BINDING or COPY_WRITE_BUFFER + case 0x88ED: // PIXEL_PACK_BUFFER_BINDING + case 0x88EF: // PIXEL_UNPACK_BUFFER_BINDING + case 0x8CAA: // READ_FRAMEBUFFER_BINDING + case 0x8919: // SAMPLER_BINDING + case 0x8C1D: // TEXTURE_BINDING_2D_ARRAY + case 0x806A: // TEXTURE_BINDING_3D + case 0x8E25: // TRANSFORM_FEEDBACK_BINDING + case 0x8C8F: // TRANSFORM_FEEDBACK_BUFFER_BINDING + case 0x8A28: // UNIFORM_BUFFER_BINDING + case 0x8514: { // TEXTURE_BINDING_CUBE_MAP + ret = 0; + break; + } + default: { + GL.recordError(0x500); // GL_INVALID_ENUM + return; + } + } + } else if (result instanceof Float32Array || + result instanceof Uint32Array || + result instanceof Int32Array || + result instanceof Array) { + for (var i = 0; i < result.length; ++i) { + switch (type) { + case 0: HEAP32[(((p)+(i*4))>>2)] = result[i]; break; + case 2: HEAPF32[(((p)+(i*4))>>2)] = result[i]; break; + case 4: HEAP8[(((p)+(i))>>0)] = result[i] ? 1 : 0; break; + } + } + return; + } else { + try { + ret = result.name | 0; + } catch(e) { + GL.recordError(0x500); // GL_INVALID_ENUM + err('GL_INVALID_ENUM in glGet' + type + 'v: Unknown object returned from WebGL getParameter(' + name_ + ')! (error: ' + e + ')'); + return; + } + } + break; + default: + GL.recordError(0x500); // GL_INVALID_ENUM + err('GL_INVALID_ENUM in glGet' + type + 'v: Native code calling glGet' + type + 'v(' + name_ + ') and it returns ' + result + ' of type ' + typeof(result) + '!'); + return; + } + } + + switch (type) { + case 1: writeI53ToI64(p, ret); break; + case 0: HEAP32[((p)>>2)] = ret; break; + case 2: HEAPF32[((p)>>2)] = ret; break; + case 4: HEAP8[((p)>>0)] = ret ? 1 : 0; break; + } + } + function _emscripten_glGetBooleanv(name_, p) { + emscriptenWebGLGet(name_, p, 4); + } + + function _emscripten_glGetBufferParameteri64v(target, value, data) { + if (!data) { + // GLES2 specification does not specify how to behave if data is a null pointer. Since calling this function does not make sense + // if data == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + writeI53ToI64(data, GLctx.getBufferParameter(target, value)); + } + + function _emscripten_glGetBufferParameteriv(target, value, data) { + if (!data) { + // GLES2 specification does not specify how to behave if data is a null pointer. Since calling this function does not make sense + // if data == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + HEAP32[((data)>>2)] = GLctx.getBufferParameter(target, value); + } + + function _emscripten_glGetBufferPointerv(target, pname, params) { + if (pname == 0x88BD/*GL_BUFFER_MAP_POINTER*/) { + var ptr = 0; + var mappedBuffer = GL.mappedBuffers[emscriptenWebGLGetBufferBinding(target)]; + if (mappedBuffer) { + ptr = mappedBuffer.mem; + } + HEAP32[((params)>>2)] = ptr; + } else { + GL.recordError(0x500/*GL_INVALID_ENUM*/); + err('GL_INVALID_ENUM in glGetBufferPointerv'); + } + } + + function _emscripten_glGetError() { + var error = GLctx.getError() || GL.lastError; + GL.lastError = 0/*GL_NO_ERROR*/; + return error; + } + + function _emscripten_glGetFloatv(name_, p) { + emscriptenWebGLGet(name_, p, 2); + } + + function _emscripten_glGetFragDataLocation(program, name) { + return GLctx['getFragDataLocation'](GL.programs[program], UTF8ToString(name)); + } + + function _emscripten_glGetFramebufferAttachmentParameteriv(target, attachment, pname, params) { + var result = GLctx.getFramebufferAttachmentParameter(target, attachment, pname); + if (result instanceof WebGLRenderbuffer || + result instanceof WebGLTexture) { + result = result.name | 0; + } + HEAP32[((params)>>2)] = result; + } + + function emscriptenWebGLGetIndexed(target, index, data, type) { + if (!data) { + // GLES2 specification does not specify how to behave if data is a null pointer. Since calling this function does not make sense + // if data == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + var result = GLctx['getIndexedParameter'](target, index); + var ret; + switch (typeof result) { + case 'boolean': + ret = result ? 1 : 0; + break; + case 'number': + ret = result; + break; + case 'object': + if (result === null) { + switch (target) { + case 0x8C8F: // TRANSFORM_FEEDBACK_BUFFER_BINDING + case 0x8A28: // UNIFORM_BUFFER_BINDING + ret = 0; + break; + default: { + GL.recordError(0x500); // GL_INVALID_ENUM + return; + } + } + } else if (result instanceof WebGLBuffer) { + ret = result.name | 0; + } else { + GL.recordError(0x500); // GL_INVALID_ENUM + return; + } + break; + default: + GL.recordError(0x500); // GL_INVALID_ENUM + return; + } + + switch (type) { + case 1: writeI53ToI64(data, ret); break; + case 0: HEAP32[((data)>>2)] = ret; break; + case 2: HEAPF32[((data)>>2)] = ret; break; + case 4: HEAP8[((data)>>0)] = ret ? 1 : 0; break; + default: throw 'internal emscriptenWebGLGetIndexed() error, bad type: ' + type; + } + } + function _emscripten_glGetInteger64i_v(target, index, data) { + emscriptenWebGLGetIndexed(target, index, data, 1); + } + + function _emscripten_glGetInteger64v(name_, p) { + emscriptenWebGLGet(name_, p, 1); + } + + function _emscripten_glGetIntegeri_v(target, index, data) { + emscriptenWebGLGetIndexed(target, index, data, 0); + } + + function _emscripten_glGetIntegerv(name_, p) { + emscriptenWebGLGet(name_, p, 0); + } + + function _emscripten_glGetInternalformativ(target, internalformat, pname, bufSize, params) { + if (bufSize < 0) { + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + if (!params) { + // GLES3 specification does not specify how to behave if values is a null pointer. Since calling this function does not make sense + // if values == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + var ret = GLctx['getInternalformatParameter'](target, internalformat, pname); + if (ret === null) return; + for (var i = 0; i < ret.length && i < bufSize; ++i) { + HEAP32[(((params)+(i))>>2)] = ret[i]; + } + } + + function _emscripten_glGetProgramBinary(program, bufSize, length, binaryFormat, binary) { + GL.recordError(0x502/*GL_INVALID_OPERATION*/); + } + + function _emscripten_glGetProgramInfoLog(program, maxLength, length, infoLog) { + var log = GLctx.getProgramInfoLog(GL.programs[program]); + if (log === null) log = '(unknown error)'; + var numBytesWrittenExclNull = (maxLength > 0 && infoLog) ? stringToUTF8(log, infoLog, maxLength) : 0; + if (length) HEAP32[((length)>>2)] = numBytesWrittenExclNull; + } + + function _emscripten_glGetProgramiv(program, pname, p) { + if (!p) { + // GLES2 specification does not specify how to behave if p is a null pointer. Since calling this function does not make sense + // if p == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + + if (program >= GL.counter) { + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + + program = GL.programs[program]; + + if (pname == 0x8B84) { // GL_INFO_LOG_LENGTH + var log = GLctx.getProgramInfoLog(program); + if (log === null) log = '(unknown error)'; + HEAP32[((p)>>2)] = log.length + 1; + } else if (pname == 0x8B87 /* GL_ACTIVE_UNIFORM_MAX_LENGTH */) { + if (!program.maxUniformLength) { + for (var i = 0; i < GLctx.getProgramParameter(program, 0x8B86/*GL_ACTIVE_UNIFORMS*/); ++i) { + program.maxUniformLength = Math.max(program.maxUniformLength, GLctx.getActiveUniform(program, i).name.length+1); + } + } + HEAP32[((p)>>2)] = program.maxUniformLength; + } else if (pname == 0x8B8A /* GL_ACTIVE_ATTRIBUTE_MAX_LENGTH */) { + if (!program.maxAttributeLength) { + for (var i = 0; i < GLctx.getProgramParameter(program, 0x8B89/*GL_ACTIVE_ATTRIBUTES*/); ++i) { + program.maxAttributeLength = Math.max(program.maxAttributeLength, GLctx.getActiveAttrib(program, i).name.length+1); + } + } + HEAP32[((p)>>2)] = program.maxAttributeLength; + } else if (pname == 0x8A35 /* GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH */) { + if (!program.maxUniformBlockNameLength) { + for (var i = 0; i < GLctx.getProgramParameter(program, 0x8A36/*GL_ACTIVE_UNIFORM_BLOCKS*/); ++i) { + program.maxUniformBlockNameLength = Math.max(program.maxUniformBlockNameLength, GLctx.getActiveUniformBlockName(program, i).length+1); + } + } + HEAP32[((p)>>2)] = program.maxUniformBlockNameLength; + } else { + HEAP32[((p)>>2)] = GLctx.getProgramParameter(program, pname); + } + } + + function _emscripten_glGetQueryObjecti64vEXT(id, pname, params) { + if (!params) { + // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense + // if p == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + var query = GL.queries[id]; + var param; + if (GL.currentContext.version < 2) + { + param = GLctx.disjointTimerQueryExt['getQueryObjectEXT'](query, pname); + } + else { + param = GLctx['getQueryParameter'](query, pname); + } + var ret; + if (typeof param == 'boolean') { + ret = param ? 1 : 0; + } else { + ret = param; + } + writeI53ToI64(params, ret); + } + + function _emscripten_glGetQueryObjectivEXT(id, pname, params) { + if (!params) { + // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense + // if p == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + var query = GL.queries[id]; + var param = GLctx.disjointTimerQueryExt['getQueryObjectEXT'](query, pname); + var ret; + if (typeof param == 'boolean') { + ret = param ? 1 : 0; + } else { + ret = param; + } + HEAP32[((params)>>2)] = ret; + } + + function _emscripten_glGetQueryObjectui64vEXT(id, pname, params) { + if (!params) { + // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense + // if p == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + var query = GL.queries[id]; + var param; + if (GL.currentContext.version < 2) + { + param = GLctx.disjointTimerQueryExt['getQueryObjectEXT'](query, pname); + } + else { + param = GLctx['getQueryParameter'](query, pname); + } + var ret; + if (typeof param == 'boolean') { + ret = param ? 1 : 0; + } else { + ret = param; + } + writeI53ToI64(params, ret); + } + + function _emscripten_glGetQueryObjectuiv(id, pname, params) { + if (!params) { + // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense + // if p == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + var query = GL.queries[id]; + var param = GLctx['getQueryParameter'](query, pname); + var ret; + if (typeof param == 'boolean') { + ret = param ? 1 : 0; + } else { + ret = param; + } + HEAP32[((params)>>2)] = ret; + } + + function _emscripten_glGetQueryObjectuivEXT(id, pname, params) { + if (!params) { + // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense + // if p == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + var query = GL.queries[id]; + var param = GLctx.disjointTimerQueryExt['getQueryObjectEXT'](query, pname); + var ret; + if (typeof param == 'boolean') { + ret = param ? 1 : 0; + } else { + ret = param; + } + HEAP32[((params)>>2)] = ret; + } + + function _emscripten_glGetQueryiv(target, pname, params) { + if (!params) { + // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense + // if p == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + HEAP32[((params)>>2)] = GLctx['getQuery'](target, pname); + } + + function _emscripten_glGetQueryivEXT(target, pname, params) { + if (!params) { + // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense + // if p == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + HEAP32[((params)>>2)] = GLctx.disjointTimerQueryExt['getQueryEXT'](target, pname); + } + + function _emscripten_glGetRenderbufferParameteriv(target, pname, params) { + if (!params) { + // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense + // if params == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + HEAP32[((params)>>2)] = GLctx.getRenderbufferParameter(target, pname); + } + + function _emscripten_glGetSamplerParameterfv(sampler, pname, params) { + if (!params) { + // GLES3 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense + // if p == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + HEAPF32[((params)>>2)] = GLctx['getSamplerParameter'](GL.samplers[sampler], pname); + } + + function _emscripten_glGetSamplerParameteriv(sampler, pname, params) { + if (!params) { + // GLES3 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense + // if p == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + HEAP32[((params)>>2)] = GLctx['getSamplerParameter'](GL.samplers[sampler], pname); + } + + function _emscripten_glGetShaderInfoLog(shader, maxLength, length, infoLog) { + var log = GLctx.getShaderInfoLog(GL.shaders[shader]); + if (log === null) log = '(unknown error)'; + var numBytesWrittenExclNull = (maxLength > 0 && infoLog) ? stringToUTF8(log, infoLog, maxLength) : 0; + if (length) HEAP32[((length)>>2)] = numBytesWrittenExclNull; + } + + function _emscripten_glGetShaderPrecisionFormat(shaderType, precisionType, range, precision) { + var result = GLctx.getShaderPrecisionFormat(shaderType, precisionType); + HEAP32[((range)>>2)] = result.rangeMin; + HEAP32[(((range)+(4))>>2)] = result.rangeMax; + HEAP32[((precision)>>2)] = result.precision; + } + + function _emscripten_glGetShaderSource(shader, bufSize, length, source) { + var result = GLctx.getShaderSource(GL.shaders[shader]); + if (!result) return; // If an error occurs, nothing will be written to length or source. + var numBytesWrittenExclNull = (bufSize > 0 && source) ? stringToUTF8(result, source, bufSize) : 0; + if (length) HEAP32[((length)>>2)] = numBytesWrittenExclNull; + } + + function _emscripten_glGetShaderiv(shader, pname, p) { + if (!p) { + // GLES2 specification does not specify how to behave if p is a null pointer. Since calling this function does not make sense + // if p == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + if (pname == 0x8B84) { // GL_INFO_LOG_LENGTH + var log = GLctx.getShaderInfoLog(GL.shaders[shader]); + if (log === null) log = '(unknown error)'; + // The GLES2 specification says that if the shader has an empty info log, + // a value of 0 is returned. Otherwise the log has a null char appended. + // (An empty string is falsey, so we can just check that instead of + // looking at log.length.) + var logLength = log ? log.length + 1 : 0; + HEAP32[((p)>>2)] = logLength; + } else if (pname == 0x8B88) { // GL_SHADER_SOURCE_LENGTH + var source = GLctx.getShaderSource(GL.shaders[shader]); + // source may be a null, or the empty string, both of which are falsey + // values that we report a 0 length for. + var sourceLength = source ? source.length + 1 : 0; + HEAP32[((p)>>2)] = sourceLength; + } else { + HEAP32[((p)>>2)] = GLctx.getShaderParameter(GL.shaders[shader], pname); + } + } + + function stringToNewUTF8(jsString) { + var length = lengthBytesUTF8(jsString)+1; + var cString = _malloc(length); + stringToUTF8(jsString, cString, length); + return cString; + } + function _emscripten_glGetString(name_) { + var ret = GL.stringCache[name_]; + if (!ret) { + switch (name_) { + case 0x1F03 /* GL_EXTENSIONS */: + var exts = GLctx.getSupportedExtensions() || []; // .getSupportedExtensions() can return null if context is lost, so coerce to empty array. + exts = exts.concat(exts.map(function(e) { return "GL_" + e; })); + ret = stringToNewUTF8(exts.join(' ')); + break; + case 0x1F00 /* GL_VENDOR */: + case 0x1F01 /* GL_RENDERER */: + case 0x9245 /* UNMASKED_VENDOR_WEBGL */: + case 0x9246 /* UNMASKED_RENDERER_WEBGL */: + var s = GLctx.getParameter(name_); + if (!s) { + GL.recordError(0x500/*GL_INVALID_ENUM*/); + } + ret = s && stringToNewUTF8(s); + break; + + case 0x1F02 /* GL_VERSION */: + var glVersion = GLctx.getParameter(0x1F02 /*GL_VERSION*/); + // return GLES version string corresponding to the version of the WebGL context + if (GL.currentContext.version >= 2) glVersion = 'OpenGL ES 3.0 (' + glVersion + ')'; + else + { + glVersion = 'OpenGL ES 2.0 (' + glVersion + ')'; + } + ret = stringToNewUTF8(glVersion); + break; + case 0x8B8C /* GL_SHADING_LANGUAGE_VERSION */: + var glslVersion = GLctx.getParameter(0x8B8C /*GL_SHADING_LANGUAGE_VERSION*/); + // extract the version number 'N.M' from the string 'WebGL GLSL ES N.M ...' + var ver_re = /^WebGL GLSL ES ([0-9]\.[0-9][0-9]?)(?:$| .*)/; + var ver_num = glslVersion.match(ver_re); + if (ver_num !== null) { + if (ver_num[1].length == 3) ver_num[1] = ver_num[1] + '0'; // ensure minor version has 2 digits + glslVersion = 'OpenGL ES GLSL ES ' + ver_num[1] + ' (' + glslVersion + ')'; + } + ret = stringToNewUTF8(glslVersion); + break; + default: + GL.recordError(0x500/*GL_INVALID_ENUM*/); + // fall through + } + GL.stringCache[name_] = ret; + } + return ret; + } + + function _emscripten_glGetStringi(name, index) { + if (GL.currentContext.version < 2) { + GL.recordError(0x502 /* GL_INVALID_OPERATION */); // Calling GLES3/WebGL2 function with a GLES2/WebGL1 context + return 0; + } + var stringiCache = GL.stringiCache[name]; + if (stringiCache) { + if (index < 0 || index >= stringiCache.length) { + GL.recordError(0x501/*GL_INVALID_VALUE*/); + return 0; + } + return stringiCache[index]; + } + switch (name) { + case 0x1F03 /* GL_EXTENSIONS */: + var exts = GLctx.getSupportedExtensions() || []; // .getSupportedExtensions() can return null if context is lost, so coerce to empty array. + exts = exts.concat(exts.map(function(e) { return "GL_" + e; })); + exts = exts.map(function(e) { return stringToNewUTF8(e); }); + + stringiCache = GL.stringiCache[name] = exts; + if (index < 0 || index >= stringiCache.length) { + GL.recordError(0x501/*GL_INVALID_VALUE*/); + return 0; + } + return stringiCache[index]; + default: + GL.recordError(0x500/*GL_INVALID_ENUM*/); + return 0; + } + } + + function _emscripten_glGetSynciv(sync, pname, bufSize, length, values) { + if (bufSize < 0) { + // GLES3 specification does not specify how to behave if bufSize < 0, however in the spec wording for glGetInternalformativ, it does say that GL_INVALID_VALUE should be raised, + // so raise GL_INVALID_VALUE here as well. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + if (!values) { + // GLES3 specification does not specify how to behave if values is a null pointer. Since calling this function does not make sense + // if values == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + var ret = GLctx.getSyncParameter(GL.syncs[sync], pname); + if (ret !== null) { + HEAP32[((values)>>2)] = ret; + if (length) HEAP32[((length)>>2)] = 1; // Report a single value outputted. + } + } + + function _emscripten_glGetTexParameterfv(target, pname, params) { + if (!params) { + // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense + // if p == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + HEAPF32[((params)>>2)] = GLctx.getTexParameter(target, pname); + } + + function _emscripten_glGetTexParameteriv(target, pname, params) { + if (!params) { + // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense + // if p == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + HEAP32[((params)>>2)] = GLctx.getTexParameter(target, pname); + } + + function _emscripten_glGetTransformFeedbackVarying(program, index, bufSize, length, size, type, name) { + program = GL.programs[program]; + var info = GLctx['getTransformFeedbackVarying'](program, index); + if (!info) return; // If an error occurred, the return parameters length, size, type and name will be unmodified. + + if (name && bufSize > 0) { + var numBytesWrittenExclNull = stringToUTF8(info.name, name, bufSize); + if (length) HEAP32[((length)>>2)] = numBytesWrittenExclNull; + } else { + if (length) HEAP32[((length)>>2)] = 0; + } + + if (size) HEAP32[((size)>>2)] = info.size; + if (type) HEAP32[((type)>>2)] = info.type; + } + + function _emscripten_glGetUniformBlockIndex(program, uniformBlockName) { + return GLctx['getUniformBlockIndex'](GL.programs[program], UTF8ToString(uniformBlockName)); + } + + function _emscripten_glGetUniformIndices(program, uniformCount, uniformNames, uniformIndices) { + if (!uniformIndices) { + // GLES2 specification does not specify how to behave if uniformIndices is a null pointer. Since calling this function does not make sense + // if uniformIndices == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + if (uniformCount > 0 && (uniformNames == 0 || uniformIndices == 0)) { + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + program = GL.programs[program]; + var names = []; + for (var i = 0; i < uniformCount; i++) + names.push(UTF8ToString(HEAP32[(((uniformNames)+(i*4))>>2)])); + + var result = GLctx['getUniformIndices'](program, names); + if (!result) return; // GL spec: If an error is generated, nothing is written out to uniformIndices. + + var len = result.length; + for (var i = 0; i < len; i++) { + HEAP32[(((uniformIndices)+(i*4))>>2)] = result[i]; + } + } + + /** @suppress {checkTypes} */ + function jstoi_q(str) { + return parseInt(str); + } + + /** @noinline */ + function webglGetLeftBracePos(name) { + return name.slice(-1) == ']' && name.lastIndexOf('['); + } + function webglPrepareUniformLocationsBeforeFirstUse(program) { + var uniformLocsById = program.uniformLocsById, // Maps GLuint -> WebGLUniformLocation + uniformSizeAndIdsByName = program.uniformSizeAndIdsByName, // Maps name -> [uniform array length, GLuint] + i, j; + + // On the first time invocation of glGetUniformLocation on this shader program: + // initialize cache data structures and discover which uniforms are arrays. + if (!uniformLocsById) { + // maps GLint integer locations to WebGLUniformLocations + program.uniformLocsById = uniformLocsById = {}; + // maps integer locations back to uniform name strings, so that we can lazily fetch uniform array locations + program.uniformArrayNamesById = {}; + + for (i = 0; i < GLctx.getProgramParameter(program, 0x8B86/*GL_ACTIVE_UNIFORMS*/); ++i) { + var u = GLctx.getActiveUniform(program, i); + var nm = u.name; + var sz = u.size; + var lb = webglGetLeftBracePos(nm); + var arrayName = lb > 0 ? nm.slice(0, lb) : nm; + + // Assign a new location. + var id = program.uniformIdCounter; + program.uniformIdCounter += sz; + // Eagerly get the location of the uniformArray[0] base element. + // The remaining indices >0 will be left for lazy evaluation to + // improve performance. Those may never be needed to fetch, if the + // application fills arrays always in full starting from the first + // element of the array. + uniformSizeAndIdsByName[arrayName] = [sz, id]; + + // Store placeholder integers in place that highlight that these + // >0 index locations are array indices pending population. + for(j = 0; j < sz; ++j) { + uniformLocsById[id] = j; + program.uniformArrayNamesById[id++] = arrayName; + } + } + } + } + function _emscripten_glGetUniformLocation(program, name) { + + name = UTF8ToString(name); + + if (program = GL.programs[program]) { + webglPrepareUniformLocationsBeforeFirstUse(program); + var uniformLocsById = program.uniformLocsById; // Maps GLuint -> WebGLUniformLocation + var arrayIndex = 0; + var uniformBaseName = name; + + // Invariant: when populating integer IDs for uniform locations, we must maintain the precondition that + // arrays reside in contiguous addresses, i.e. for a 'vec4 colors[10];', colors[4] must be at location colors[0]+4. + // However, user might call glGetUniformLocation(program, "colors") for an array, so we cannot discover based on the user + // input arguments whether the uniform we are dealing with is an array. The only way to discover which uniforms are arrays + // is to enumerate over all the active uniforms in the program. + var leftBrace = webglGetLeftBracePos(name); + + // If user passed an array accessor "[index]", parse the array index off the accessor. + if (leftBrace > 0) { + arrayIndex = jstoi_q(name.slice(leftBrace + 1)) >>> 0; // "index]", coerce parseInt(']') with >>>0 to treat "foo[]" as "foo[0]" and foo[-1] as unsigned out-of-bounds. + uniformBaseName = name.slice(0, leftBrace); + } + + // Have we cached the location of this uniform before? + var sizeAndId = program.uniformSizeAndIdsByName[uniformBaseName]; // A pair [array length, GLint of the uniform location] + + // If an uniform with this name exists, and if its index is within the array limits (if it's even an array), + // query the WebGLlocation, or return an existing cached location. + if (sizeAndId && arrayIndex < sizeAndId[0]) { + arrayIndex += sizeAndId[1]; // Add the base location of the uniform to the array index offset. + if ((uniformLocsById[arrayIndex] = uniformLocsById[arrayIndex] || GLctx.getUniformLocation(program, name))) { + return arrayIndex; + } + } + } + else { + // N.b. we are currently unable to distinguish between GL program IDs that never existed vs GL program IDs that have been deleted, + // so report GL_INVALID_VALUE in both cases. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + } + return -1; + } + + function webglGetUniformLocation(location) { + var p = GLctx.currentProgram; + + if (p) { + var webglLoc = p.uniformLocsById[location]; + // p.uniformLocsById[location] stores either an integer, or a WebGLUniformLocation. + + // If an integer, we have not yet bound the location, so do it now. The integer value specifies the array index + // we should bind to. + if (typeof webglLoc === 'number') { + p.uniformLocsById[location] = webglLoc = GLctx.getUniformLocation(p, p.uniformArrayNamesById[location] + (webglLoc > 0 ? '[' + webglLoc + ']' : '')); + } + // Else an already cached WebGLUniformLocation, return it. + return webglLoc; + } else { + GL.recordError(0x502/*GL_INVALID_OPERATION*/); + } + } + /** @suppress{checkTypes} */ + function emscriptenWebGLGetUniform(program, location, params, type) { + if (!params) { + // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense + // if params == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + program = GL.programs[program]; + webglPrepareUniformLocationsBeforeFirstUse(program); + var data = GLctx.getUniform(program, webglGetUniformLocation(location)); + if (typeof data == 'number' || typeof data == 'boolean') { + switch (type) { + case 0: HEAP32[((params)>>2)] = data; break; + case 2: HEAPF32[((params)>>2)] = data; break; + } + } else { + for (var i = 0; i < data.length; i++) { + switch (type) { + case 0: HEAP32[(((params)+(i*4))>>2)] = data[i]; break; + case 2: HEAPF32[(((params)+(i*4))>>2)] = data[i]; break; + } + } + } + } + function _emscripten_glGetUniformfv(program, location, params) { + emscriptenWebGLGetUniform(program, location, params, 2); + } + + function _emscripten_glGetUniformiv(program, location, params) { + emscriptenWebGLGetUniform(program, location, params, 0); + } + + function _emscripten_glGetUniformuiv(program, location, params) { + emscriptenWebGLGetUniform(program, location, params, 0); + } + + /** @suppress{checkTypes} */ + function emscriptenWebGLGetVertexAttrib(index, pname, params, type) { + if (!params) { + // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense + // if params == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + if (GL.currentContext.clientBuffers[index].enabled) { + err("glGetVertexAttrib*v on client-side array: not supported, bad data returned"); + } + var data = GLctx.getVertexAttrib(index, pname); + if (pname == 0x889F/*VERTEX_ATTRIB_ARRAY_BUFFER_BINDING*/) { + HEAP32[((params)>>2)] = data && data["name"]; + } else if (typeof data == 'number' || typeof data == 'boolean') { + switch (type) { + case 0: HEAP32[((params)>>2)] = data; break; + case 2: HEAPF32[((params)>>2)] = data; break; + case 5: HEAP32[((params)>>2)] = Math.fround(data); break; + } + } else { + for (var i = 0; i < data.length; i++) { + switch (type) { + case 0: HEAP32[(((params)+(i*4))>>2)] = data[i]; break; + case 2: HEAPF32[(((params)+(i*4))>>2)] = data[i]; break; + case 5: HEAP32[(((params)+(i*4))>>2)] = Math.fround(data[i]); break; + } + } + } + } + function _emscripten_glGetVertexAttribIiv(index, pname, params) { + // N.B. This function may only be called if the vertex attribute was specified using the function glVertexAttribI4iv(), + // otherwise the results are undefined. (GLES3 spec 6.1.12) + emscriptenWebGLGetVertexAttrib(index, pname, params, 0); + } + + function _emscripten_glGetVertexAttribIuiv(index, pname, params) { + // N.B. This function may only be called if the vertex attribute was specified using the function glVertexAttribI4iv(), + // otherwise the results are undefined. (GLES3 spec 6.1.12) + emscriptenWebGLGetVertexAttrib(index, pname, params, 0); + } + + function _emscripten_glGetVertexAttribPointerv(index, pname, pointer) { + if (!pointer) { + // GLES2 specification does not specify how to behave if pointer is a null pointer. Since calling this function does not make sense + // if pointer == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + if (GL.currentContext.clientBuffers[index].enabled) { + err("glGetVertexAttribPointer on client-side array: not supported, bad data returned"); + } + HEAP32[((pointer)>>2)] = GLctx.getVertexAttribOffset(index, pname); + } + + function _emscripten_glGetVertexAttribfv(index, pname, params) { + // N.B. This function may only be called if the vertex attribute was specified using the function glVertexAttrib*f(), + // otherwise the results are undefined. (GLES3 spec 6.1.12) + emscriptenWebGLGetVertexAttrib(index, pname, params, 2); + } + + function _emscripten_glGetVertexAttribiv(index, pname, params) { + // N.B. This function may only be called if the vertex attribute was specified using the function glVertexAttrib*f(), + // otherwise the results are undefined. (GLES3 spec 6.1.12) + emscriptenWebGLGetVertexAttrib(index, pname, params, 5); + } + + function _emscripten_glHint(x0, x1) { GLctx['hint'](x0, x1) } + + function _emscripten_glInvalidateFramebuffer(target, numAttachments, attachments) { + var list = tempFixedLengthArray[numAttachments]; + for (var i = 0; i < numAttachments; i++) { + list[i] = HEAP32[(((attachments)+(i*4))>>2)]; + } + + GLctx['invalidateFramebuffer'](target, list); + } + + function _emscripten_glInvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height) { + var list = tempFixedLengthArray[numAttachments]; + for (var i = 0; i < numAttachments; i++) { + list[i] = HEAP32[(((attachments)+(i*4))>>2)]; + } + + GLctx['invalidateSubFramebuffer'](target, list, x, y, width, height); + } + + function _emscripten_glIsBuffer(buffer) { + var b = GL.buffers[buffer]; + if (!b) return 0; + return GLctx.isBuffer(b); + } + + function _emscripten_glIsEnabled(x0) { return GLctx['isEnabled'](x0) } + + function _emscripten_glIsFramebuffer(framebuffer) { + var fb = GL.framebuffers[framebuffer]; + if (!fb) return 0; + return GLctx.isFramebuffer(fb); + } + + function _emscripten_glIsProgram(program) { + program = GL.programs[program]; + if (!program) return 0; + return GLctx.isProgram(program); + } + + function _emscripten_glIsQuery(id) { + var query = GL.queries[id]; + if (!query) return 0; + return GLctx['isQuery'](query); + } + + function _emscripten_glIsQueryEXT(id) { + var query = GL.queries[id]; + if (!query) return 0; + return GLctx.disjointTimerQueryExt['isQueryEXT'](query); + } + + function _emscripten_glIsRenderbuffer(renderbuffer) { + var rb = GL.renderbuffers[renderbuffer]; + if (!rb) return 0; + return GLctx.isRenderbuffer(rb); + } + + function _emscripten_glIsSampler(id) { + var sampler = GL.samplers[id]; + if (!sampler) return 0; + return GLctx['isSampler'](sampler); + } + + function _emscripten_glIsShader(shader) { + var s = GL.shaders[shader]; + if (!s) return 0; + return GLctx.isShader(s); + } + + function _emscripten_glIsSync(sync) { + return GLctx.isSync(GL.syncs[sync]); + } + + function _emscripten_glIsTexture(id) { + var texture = GL.textures[id]; + if (!texture) return 0; + return GLctx.isTexture(texture); + } + + function _emscripten_glIsTransformFeedback(id) { + return GLctx['isTransformFeedback'](GL.transformFeedbacks[id]); + } + + function _emscripten_glIsVertexArray(array) { + + var vao = GL.vaos[array]; + if (!vao) return 0; + return GLctx['isVertexArray'](vao); + } + + function _emscripten_glIsVertexArrayOES(array) { + + var vao = GL.vaos[array]; + if (!vao) return 0; + return GLctx['isVertexArray'](vao); + } + + function _emscripten_glLineWidth(x0) { GLctx['lineWidth'](x0) } + + function _emscripten_glLinkProgram(program) { + program = GL.programs[program]; + GLctx.linkProgram(program); + // Invalidate earlier computed uniform->ID mappings, those have now become stale + program.uniformLocsById = 0; // Mark as null-like so that glGetUniformLocation() knows to populate this again. + program.uniformSizeAndIdsByName = {}; + + } + + function _emscripten_glMapBufferRange(target, offset, length, access) { + if (access != 0x1A && access != 0xA) { + err("glMapBufferRange is only supported when access is MAP_WRITE|INVALIDATE_BUFFER"); + return 0; + } + + if (!emscriptenWebGLValidateMapBufferTarget(target)) { + GL.recordError(0x500/*GL_INVALID_ENUM*/); + err('GL_INVALID_ENUM in glMapBufferRange'); + return 0; + } + + var mem = _malloc(length); + if (!mem) return 0; + + GL.mappedBuffers[emscriptenWebGLGetBufferBinding(target)] = { + offset: offset, + length: length, + mem: mem, + access: access, + }; + return mem; + } + + function _emscripten_glPauseTransformFeedback() { GLctx['pauseTransformFeedback']() } + + function _emscripten_glPixelStorei(pname, param) { + if (pname == 0xCF5 /* GL_UNPACK_ALIGNMENT */) { + GL.unpackAlignment = param; + } + GLctx.pixelStorei(pname, param); + } + + function _emscripten_glPolygonOffset(x0, x1) { GLctx['polygonOffset'](x0, x1) } + + function _emscripten_glProgramBinary(program, binaryFormat, binary, length) { + GL.recordError(0x500/*GL_INVALID_ENUM*/); + } + + function _emscripten_glProgramParameteri(program, pname, value) { + GL.recordError(0x500/*GL_INVALID_ENUM*/); + } + + function _emscripten_glQueryCounterEXT(id, target) { + GLctx.disjointTimerQueryExt['queryCounterEXT'](GL.queries[id], target); + } + + function _emscripten_glReadBuffer(x0) { GLctx['readBuffer'](x0) } + + function computeUnpackAlignedImageSize(width, height, sizePerPixel, alignment) { + function roundedToNextMultipleOf(x, y) { + return (x + y - 1) & -y; + } + var plainRowSize = width * sizePerPixel; + var alignedRowSize = roundedToNextMultipleOf(plainRowSize, alignment); + return height * alignedRowSize; + } + + function __colorChannelsInGlTextureFormat(format) { + // Micro-optimizations for size: map format to size by subtracting smallest enum value (0x1902) from all values first. + // Also omit the most common size value (1) from the list, which is assumed by formats not on the list. + var colorChannels = { + // 0x1902 /* GL_DEPTH_COMPONENT */ - 0x1902: 1, + // 0x1906 /* GL_ALPHA */ - 0x1902: 1, + 5: 3, + 6: 4, + // 0x1909 /* GL_LUMINANCE */ - 0x1902: 1, + 8: 2, + 29502: 3, + 29504: 4, + // 0x1903 /* GL_RED */ - 0x1902: 1, + 26917: 2, + 26918: 2, + // 0x8D94 /* GL_RED_INTEGER */ - 0x1902: 1, + 29846: 3, + 29847: 4 + }; + return colorChannels[format - 0x1902]||1; + } + + function heapObjectForWebGLType(type) { + // Micro-optimization for size: Subtract lowest GL enum number (0x1400/* GL_BYTE */) from type to compare + // smaller values for the heap, for shorter generated code size. + // Also the type HEAPU16 is not tested for explicitly, but any unrecognized type will return out HEAPU16. + // (since most types are HEAPU16) + type -= 0x1400; + if (type == 0) return HEAP8; + + if (type == 1) return HEAPU8; + + if (type == 2) return HEAP16; + + if (type == 4) return HEAP32; + + if (type == 6) return HEAPF32; + + if (type == 5 + || type == 28922 + || type == 28520 + || type == 30779 + || type == 30782 + ) + return HEAPU32; + + return HEAPU16; + } + + function heapAccessShiftForWebGLHeap(heap) { + return 31 - Math.clz32(heap.BYTES_PER_ELEMENT); + } + function emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, internalFormat) { + var heap = heapObjectForWebGLType(type); + var shift = heapAccessShiftForWebGLHeap(heap); + var byteSize = 1<> shift, pixels + bytes >> shift); + } + function _emscripten_glReadPixels(x, y, width, height, format, type, pixels) { + if (GL.currentContext.version >= 2) { // WebGL 2 provides new garbage-free entry points to call to WebGL. Use those always when possible. + if (GLctx.currentPixelPackBufferBinding) { + GLctx.readPixels(x, y, width, height, format, type, pixels); + } else { + var heap = heapObjectForWebGLType(type); + GLctx.readPixels(x, y, width, height, format, type, heap, pixels >> heapAccessShiftForWebGLHeap(heap)); + } + return; + } + var pixelData = emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, format); + if (!pixelData) { + GL.recordError(0x500/*GL_INVALID_ENUM*/); + return; + } + GLctx.readPixels(x, y, width, height, format, type, pixelData); + } + + function _emscripten_glReleaseShaderCompiler() { + // NOP (as allowed by GLES 2.0 spec) + } + + function _emscripten_glRenderbufferStorage(x0, x1, x2, x3) { GLctx['renderbufferStorage'](x0, x1, x2, x3) } + + function _emscripten_glRenderbufferStorageMultisample(x0, x1, x2, x3, x4) { GLctx['renderbufferStorageMultisample'](x0, x1, x2, x3, x4) } + + function _emscripten_glResumeTransformFeedback() { GLctx['resumeTransformFeedback']() } + + function _emscripten_glSampleCoverage(value, invert) { + GLctx.sampleCoverage(value, !!invert); + } + + function _emscripten_glSamplerParameterf(sampler, pname, param) { + GLctx['samplerParameterf'](GL.samplers[sampler], pname, param); + } + + function _emscripten_glSamplerParameterfv(sampler, pname, params) { + var param = HEAPF32[((params)>>2)]; + GLctx['samplerParameterf'](GL.samplers[sampler], pname, param); + } + + function _emscripten_glSamplerParameteri(sampler, pname, param) { + GLctx['samplerParameteri'](GL.samplers[sampler], pname, param); + } + + function _emscripten_glSamplerParameteriv(sampler, pname, params) { + var param = HEAP32[((params)>>2)]; + GLctx['samplerParameteri'](GL.samplers[sampler], pname, param); + } + + function _emscripten_glScissor(x0, x1, x2, x3) { GLctx['scissor'](x0, x1, x2, x3) } + + function _emscripten_glShaderBinary() { + GL.recordError(0x500/*GL_INVALID_ENUM*/); + } + + function _emscripten_glShaderSource(shader, count, string, length) { + var source = GL.getSource(shader, count, string, length); + + GLctx.shaderSource(GL.shaders[shader], source); + } + + function _emscripten_glStencilFunc(x0, x1, x2) { GLctx['stencilFunc'](x0, x1, x2) } + + function _emscripten_glStencilFuncSeparate(x0, x1, x2, x3) { GLctx['stencilFuncSeparate'](x0, x1, x2, x3) } + + function _emscripten_glStencilMask(x0) { GLctx['stencilMask'](x0) } + + function _emscripten_glStencilMaskSeparate(x0, x1) { GLctx['stencilMaskSeparate'](x0, x1) } + + function _emscripten_glStencilOp(x0, x1, x2) { GLctx['stencilOp'](x0, x1, x2) } + + function _emscripten_glStencilOpSeparate(x0, x1, x2, x3) { GLctx['stencilOpSeparate'](x0, x1, x2, x3) } + + function _emscripten_glTexImage2D(target, level, internalFormat, width, height, border, format, type, pixels) { + if (GL.currentContext.version >= 2) { + // WebGL 2 provides new garbage-free entry points to call to WebGL. Use those always when possible. + if (GLctx.currentPixelUnpackBufferBinding) { + GLctx.texImage2D(target, level, internalFormat, width, height, border, format, type, pixels); + } else if (pixels) { + var heap = heapObjectForWebGLType(type); + GLctx.texImage2D(target, level, internalFormat, width, height, border, format, type, heap, pixels >> heapAccessShiftForWebGLHeap(heap)); + } else { + GLctx.texImage2D(target, level, internalFormat, width, height, border, format, type, null); + } + return; + } + GLctx.texImage2D(target, level, internalFormat, width, height, border, format, type, pixels ? emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, internalFormat) : null); + } + + function _emscripten_glTexImage3D(target, level, internalFormat, width, height, depth, border, format, type, pixels) { + if (GLctx.currentPixelUnpackBufferBinding) { + GLctx['texImage3D'](target, level, internalFormat, width, height, depth, border, format, type, pixels); + } else if (pixels) { + var heap = heapObjectForWebGLType(type); + GLctx['texImage3D'](target, level, internalFormat, width, height, depth, border, format, type, heap, pixels >> heapAccessShiftForWebGLHeap(heap)); + } else { + GLctx['texImage3D'](target, level, internalFormat, width, height, depth, border, format, type, null); + } + } + + function _emscripten_glTexParameterf(x0, x1, x2) { GLctx['texParameterf'](x0, x1, x2) } + + function _emscripten_glTexParameterfv(target, pname, params) { + var param = HEAPF32[((params)>>2)]; + GLctx.texParameterf(target, pname, param); + } + + function _emscripten_glTexParameteri(x0, x1, x2) { GLctx['texParameteri'](x0, x1, x2) } + + function _emscripten_glTexParameteriv(target, pname, params) { + var param = HEAP32[((params)>>2)]; + GLctx.texParameteri(target, pname, param); + } + + function _emscripten_glTexStorage2D(x0, x1, x2, x3, x4) { GLctx['texStorage2D'](x0, x1, x2, x3, x4) } + + function _emscripten_glTexStorage3D(x0, x1, x2, x3, x4, x5) { GLctx['texStorage3D'](x0, x1, x2, x3, x4, x5) } + + function _emscripten_glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels) { + if (GL.currentContext.version >= 2) { + // WebGL 2 provides new garbage-free entry points to call to WebGL. Use those always when possible. + if (GLctx.currentPixelUnpackBufferBinding) { + GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); + } else if (pixels) { + var heap = heapObjectForWebGLType(type); + GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, heap, pixels >> heapAccessShiftForWebGLHeap(heap)); + } else { + GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, null); + } + return; + } + var pixelData = null; + if (pixels) pixelData = emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, 0); + GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixelData); + } + + function _emscripten_glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels) { + if (GLctx.currentPixelUnpackBufferBinding) { + GLctx['texSubImage3D'](target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); + } else if (pixels) { + var heap = heapObjectForWebGLType(type); + GLctx['texSubImage3D'](target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, heap, pixels >> heapAccessShiftForWebGLHeap(heap)); + } else { + GLctx['texSubImage3D'](target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, null); + } + } + + function _emscripten_glTransformFeedbackVaryings(program, count, varyings, bufferMode) { + program = GL.programs[program]; + var vars = []; + for (var i = 0; i < count; i++) + vars.push(UTF8ToString(HEAP32[(((varyings)+(i*4))>>2)])); + + GLctx['transformFeedbackVaryings'](program, vars, bufferMode); + } + + function _emscripten_glUniform1f(location, v0) { + GLctx.uniform1f(webglGetUniformLocation(location), v0); + } + + var miniTempWebGLFloatBuffers = []; + function _emscripten_glUniform1fv(location, count, value) { + + if (GL.currentContext.version >= 2) { // WebGL 2 provides new garbage-free entry points to call to WebGL. Use those always when possible. + GLctx.uniform1fv(webglGetUniformLocation(location), HEAPF32, value>>2, count); + return; + } + + if (count <= 288) { + // avoid allocation when uploading few enough uniforms + var view = miniTempWebGLFloatBuffers[count-1]; + for (var i = 0; i < count; ++i) { + view[i] = HEAPF32[(((value)+(4*i))>>2)]; + } + } else + { + var view = HEAPF32.subarray((value)>>2, (value+count*4)>>2); + } + GLctx.uniform1fv(webglGetUniformLocation(location), view); + } + + function _emscripten_glUniform1i(location, v0) { + GLctx.uniform1i(webglGetUniformLocation(location), v0); + } + + var __miniTempWebGLIntBuffers = []; + function _emscripten_glUniform1iv(location, count, value) { + + if (GL.currentContext.version >= 2) { // WebGL 2 provides new garbage-free entry points to call to WebGL. Use those always when possible. + GLctx.uniform1iv(webglGetUniformLocation(location), HEAP32, value>>2, count); + return; + } + + if (count <= 288) { + // avoid allocation when uploading few enough uniforms + var view = __miniTempWebGLIntBuffers[count-1]; + for (var i = 0; i < count; ++i) { + view[i] = HEAP32[(((value)+(4*i))>>2)]; + } + } else + { + var view = HEAP32.subarray((value)>>2, (value+count*4)>>2); + } + GLctx.uniform1iv(webglGetUniformLocation(location), view); + } + + function _emscripten_glUniform1ui(location, v0) { + GLctx.uniform1ui(webglGetUniformLocation(location), v0); + } + + function _emscripten_glUniform1uiv(location, count, value) { + GLctx.uniform1uiv(webglGetUniformLocation(location), HEAPU32, value>>2, count); + } + + function _emscripten_glUniform2f(location, v0, v1) { + GLctx.uniform2f(webglGetUniformLocation(location), v0, v1); + } + + function _emscripten_glUniform2fv(location, count, value) { + + if (GL.currentContext.version >= 2) { // WebGL 2 provides new garbage-free entry points to call to WebGL. Use those always when possible. + GLctx.uniform2fv(webglGetUniformLocation(location), HEAPF32, value>>2, count*2); + return; + } + + if (count <= 144) { + // avoid allocation when uploading few enough uniforms + var view = miniTempWebGLFloatBuffers[2*count-1]; + for (var i = 0; i < 2*count; i += 2) { + view[i] = HEAPF32[(((value)+(4*i))>>2)]; + view[i+1] = HEAPF32[(((value)+(4*i+4))>>2)]; + } + } else + { + var view = HEAPF32.subarray((value)>>2, (value+count*8)>>2); + } + GLctx.uniform2fv(webglGetUniformLocation(location), view); + } + + function _emscripten_glUniform2i(location, v0, v1) { + GLctx.uniform2i(webglGetUniformLocation(location), v0, v1); + } + + function _emscripten_glUniform2iv(location, count, value) { + + if (GL.currentContext.version >= 2) { // WebGL 2 provides new garbage-free entry points to call to WebGL. Use those always when possible. + GLctx.uniform2iv(webglGetUniformLocation(location), HEAP32, value>>2, count*2); + return; + } + + if (count <= 144) { + // avoid allocation when uploading few enough uniforms + var view = __miniTempWebGLIntBuffers[2*count-1]; + for (var i = 0; i < 2*count; i += 2) { + view[i] = HEAP32[(((value)+(4*i))>>2)]; + view[i+1] = HEAP32[(((value)+(4*i+4))>>2)]; + } + } else + { + var view = HEAP32.subarray((value)>>2, (value+count*8)>>2); + } + GLctx.uniform2iv(webglGetUniformLocation(location), view); + } + + function _emscripten_glUniform2ui(location, v0, v1) { + GLctx.uniform2ui(webglGetUniformLocation(location), v0, v1); + } + + function _emscripten_glUniform2uiv(location, count, value) { + GLctx.uniform2uiv(webglGetUniformLocation(location), HEAPU32, value>>2, count*2); + } + + function _emscripten_glUniform3f(location, v0, v1, v2) { + GLctx.uniform3f(webglGetUniformLocation(location), v0, v1, v2); + } + + function _emscripten_glUniform3fv(location, count, value) { + + if (GL.currentContext.version >= 2) { // WebGL 2 provides new garbage-free entry points to call to WebGL. Use those always when possible. + GLctx.uniform3fv(webglGetUniformLocation(location), HEAPF32, value>>2, count*3); + return; + } + + if (count <= 96) { + // avoid allocation when uploading few enough uniforms + var view = miniTempWebGLFloatBuffers[3*count-1]; + for (var i = 0; i < 3*count; i += 3) { + view[i] = HEAPF32[(((value)+(4*i))>>2)]; + view[i+1] = HEAPF32[(((value)+(4*i+4))>>2)]; + view[i+2] = HEAPF32[(((value)+(4*i+8))>>2)]; + } + } else + { + var view = HEAPF32.subarray((value)>>2, (value+count*12)>>2); + } + GLctx.uniform3fv(webglGetUniformLocation(location), view); + } + + function _emscripten_glUniform3i(location, v0, v1, v2) { + GLctx.uniform3i(webglGetUniformLocation(location), v0, v1, v2); + } + + function _emscripten_glUniform3iv(location, count, value) { + + if (GL.currentContext.version >= 2) { // WebGL 2 provides new garbage-free entry points to call to WebGL. Use those always when possible. + GLctx.uniform3iv(webglGetUniformLocation(location), HEAP32, value>>2, count*3); + return; + } + + if (count <= 96) { + // avoid allocation when uploading few enough uniforms + var view = __miniTempWebGLIntBuffers[3*count-1]; + for (var i = 0; i < 3*count; i += 3) { + view[i] = HEAP32[(((value)+(4*i))>>2)]; + view[i+1] = HEAP32[(((value)+(4*i+4))>>2)]; + view[i+2] = HEAP32[(((value)+(4*i+8))>>2)]; + } + } else + { + var view = HEAP32.subarray((value)>>2, (value+count*12)>>2); + } + GLctx.uniform3iv(webglGetUniformLocation(location), view); + } + + function _emscripten_glUniform3ui(location, v0, v1, v2) { + GLctx.uniform3ui(webglGetUniformLocation(location), v0, v1, v2); + } + + function _emscripten_glUniform3uiv(location, count, value) { + GLctx.uniform3uiv(webglGetUniformLocation(location), HEAPU32, value>>2, count*3); + } + + function _emscripten_glUniform4f(location, v0, v1, v2, v3) { + GLctx.uniform4f(webglGetUniformLocation(location), v0, v1, v2, v3); + } + + function _emscripten_glUniform4fv(location, count, value) { + + if (GL.currentContext.version >= 2) { // WebGL 2 provides new garbage-free entry points to call to WebGL. Use those always when possible. + GLctx.uniform4fv(webglGetUniformLocation(location), HEAPF32, value>>2, count*4); + return; + } + + if (count <= 72) { + // avoid allocation when uploading few enough uniforms + var view = miniTempWebGLFloatBuffers[4*count-1]; + // hoist the heap out of the loop for size and for pthreads+growth. + var heap = HEAPF32; + value >>= 2; + for (var i = 0; i < 4 * count; i += 4) { + var dst = value + i; + view[i] = heap[dst]; + view[i + 1] = heap[dst + 1]; + view[i + 2] = heap[dst + 2]; + view[i + 3] = heap[dst + 3]; + } + } else + { + var view = HEAPF32.subarray((value)>>2, (value+count*16)>>2); + } + GLctx.uniform4fv(webglGetUniformLocation(location), view); + } + + function _emscripten_glUniform4i(location, v0, v1, v2, v3) { + GLctx.uniform4i(webglGetUniformLocation(location), v0, v1, v2, v3); + } + + function _emscripten_glUniform4iv(location, count, value) { + + if (GL.currentContext.version >= 2) { // WebGL 2 provides new garbage-free entry points to call to WebGL. Use those always when possible. + GLctx.uniform4iv(webglGetUniformLocation(location), HEAP32, value>>2, count*4); + return; + } + + if (count <= 72) { + // avoid allocation when uploading few enough uniforms + var view = __miniTempWebGLIntBuffers[4*count-1]; + for (var i = 0; i < 4*count; i += 4) { + view[i] = HEAP32[(((value)+(4*i))>>2)]; + view[i+1] = HEAP32[(((value)+(4*i+4))>>2)]; + view[i+2] = HEAP32[(((value)+(4*i+8))>>2)]; + view[i+3] = HEAP32[(((value)+(4*i+12))>>2)]; + } + } else + { + var view = HEAP32.subarray((value)>>2, (value+count*16)>>2); + } + GLctx.uniform4iv(webglGetUniformLocation(location), view); + } + + function _emscripten_glUniform4ui(location, v0, v1, v2, v3) { + GLctx.uniform4ui(webglGetUniformLocation(location), v0, v1, v2, v3); + } + + function _emscripten_glUniform4uiv(location, count, value) { + GLctx.uniform4uiv(webglGetUniformLocation(location), HEAPU32, value>>2, count*4); + } + + function _emscripten_glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding) { + program = GL.programs[program]; + + GLctx['uniformBlockBinding'](program, uniformBlockIndex, uniformBlockBinding); + } + + function _emscripten_glUniformMatrix2fv(location, count, transpose, value) { + + if (GL.currentContext.version >= 2) { // WebGL 2 provides new garbage-free entry points to call to WebGL. Use those always when possible. + GLctx.uniformMatrix2fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value>>2, count*4); + return; + } + + if (count <= 72) { + // avoid allocation when uploading few enough uniforms + var view = miniTempWebGLFloatBuffers[4*count-1]; + for (var i = 0; i < 4*count; i += 4) { + view[i] = HEAPF32[(((value)+(4*i))>>2)]; + view[i+1] = HEAPF32[(((value)+(4*i+4))>>2)]; + view[i+2] = HEAPF32[(((value)+(4*i+8))>>2)]; + view[i+3] = HEAPF32[(((value)+(4*i+12))>>2)]; + } + } else + { + var view = HEAPF32.subarray((value)>>2, (value+count*16)>>2); + } + GLctx.uniformMatrix2fv(webglGetUniformLocation(location), !!transpose, view); + } + + function _emscripten_glUniformMatrix2x3fv(location, count, transpose, value) { + GLctx.uniformMatrix2x3fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value>>2, count*6); + } + + function _emscripten_glUniformMatrix2x4fv(location, count, transpose, value) { + GLctx.uniformMatrix2x4fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value>>2, count*8); + } + + function _emscripten_glUniformMatrix3fv(location, count, transpose, value) { + + if (GL.currentContext.version >= 2) { // WebGL 2 provides new garbage-free entry points to call to WebGL. Use those always when possible. + GLctx.uniformMatrix3fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value>>2, count*9); + return; + } + + if (count <= 32) { + // avoid allocation when uploading few enough uniforms + var view = miniTempWebGLFloatBuffers[9*count-1]; + for (var i = 0; i < 9*count; i += 9) { + view[i] = HEAPF32[(((value)+(4*i))>>2)]; + view[i+1] = HEAPF32[(((value)+(4*i+4))>>2)]; + view[i+2] = HEAPF32[(((value)+(4*i+8))>>2)]; + view[i+3] = HEAPF32[(((value)+(4*i+12))>>2)]; + view[i+4] = HEAPF32[(((value)+(4*i+16))>>2)]; + view[i+5] = HEAPF32[(((value)+(4*i+20))>>2)]; + view[i+6] = HEAPF32[(((value)+(4*i+24))>>2)]; + view[i+7] = HEAPF32[(((value)+(4*i+28))>>2)]; + view[i+8] = HEAPF32[(((value)+(4*i+32))>>2)]; + } + } else + { + var view = HEAPF32.subarray((value)>>2, (value+count*36)>>2); + } + GLctx.uniformMatrix3fv(webglGetUniformLocation(location), !!transpose, view); + } + + function _emscripten_glUniformMatrix3x2fv(location, count, transpose, value) { + GLctx.uniformMatrix3x2fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value>>2, count*6); + } + + function _emscripten_glUniformMatrix3x4fv(location, count, transpose, value) { + GLctx.uniformMatrix3x4fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value>>2, count*12); + } + + function _emscripten_glUniformMatrix4fv(location, count, transpose, value) { + + if (GL.currentContext.version >= 2) { // WebGL 2 provides new garbage-free entry points to call to WebGL. Use those always when possible. + GLctx.uniformMatrix4fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value>>2, count*16); + return; + } + + if (count <= 18) { + // avoid allocation when uploading few enough uniforms + var view = miniTempWebGLFloatBuffers[16*count-1]; + // hoist the heap out of the loop for size and for pthreads+growth. + var heap = HEAPF32; + value >>= 2; + for (var i = 0; i < 16 * count; i += 16) { + var dst = value + i; + view[i] = heap[dst]; + view[i + 1] = heap[dst + 1]; + view[i + 2] = heap[dst + 2]; + view[i + 3] = heap[dst + 3]; + view[i + 4] = heap[dst + 4]; + view[i + 5] = heap[dst + 5]; + view[i + 6] = heap[dst + 6]; + view[i + 7] = heap[dst + 7]; + view[i + 8] = heap[dst + 8]; + view[i + 9] = heap[dst + 9]; + view[i + 10] = heap[dst + 10]; + view[i + 11] = heap[dst + 11]; + view[i + 12] = heap[dst + 12]; + view[i + 13] = heap[dst + 13]; + view[i + 14] = heap[dst + 14]; + view[i + 15] = heap[dst + 15]; + } + } else + { + var view = HEAPF32.subarray((value)>>2, (value+count*64)>>2); + } + GLctx.uniformMatrix4fv(webglGetUniformLocation(location), !!transpose, view); + } + + function _emscripten_glUniformMatrix4x2fv(location, count, transpose, value) { + GLctx.uniformMatrix4x2fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value>>2, count*8); + } + + function _emscripten_glUniformMatrix4x3fv(location, count, transpose, value) { + GLctx.uniformMatrix4x3fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value>>2, count*12); + } + + function _emscripten_glUnmapBuffer(target) { + if (!emscriptenWebGLValidateMapBufferTarget(target)) { + GL.recordError(0x500/*GL_INVALID_ENUM*/); + err('GL_INVALID_ENUM in glUnmapBuffer'); + return 0; + } + + var buffer = emscriptenWebGLGetBufferBinding(target); + var mapping = GL.mappedBuffers[buffer]; + if (!mapping) { + GL.recordError(0x502 /* GL_INVALID_OPERATION */); + err('buffer was never mapped in glUnmapBuffer'); + return 0; + } + GL.mappedBuffers[buffer] = null; + + if (!(mapping.access & 0x10)) /* GL_MAP_FLUSH_EXPLICIT_BIT */ + if (GL.currentContext.version >= 2) { // WebGL 2 provides new garbage-free entry points to call to WebGL. Use those always when possible. + GLctx.bufferSubData(target, mapping.offset, HEAPU8, mapping.mem, mapping.length); + } else { + GLctx.bufferSubData(target, mapping.offset, HEAPU8.subarray(mapping.mem, mapping.mem+mapping.length)); + } + _free(mapping.mem); + return 1; + } + + function _emscripten_glUseProgram(program) { + program = GL.programs[program]; + GLctx.useProgram(program); + // Record the currently active program so that we can access the uniform + // mapping table of that program. + GLctx.currentProgram = program; + } + + function _emscripten_glValidateProgram(program) { + GLctx.validateProgram(GL.programs[program]); + } + + function _emscripten_glVertexAttrib1f(x0, x1) { GLctx['vertexAttrib1f'](x0, x1) } + + function _emscripten_glVertexAttrib1fv(index, v) { + + GLctx.vertexAttrib1f(index, HEAPF32[v>>2]); + } + + function _emscripten_glVertexAttrib2f(x0, x1, x2) { GLctx['vertexAttrib2f'](x0, x1, x2) } + + function _emscripten_glVertexAttrib2fv(index, v) { + + GLctx.vertexAttrib2f(index, HEAPF32[v>>2], HEAPF32[v+4>>2]); + } + + function _emscripten_glVertexAttrib3f(x0, x1, x2, x3) { GLctx['vertexAttrib3f'](x0, x1, x2, x3) } + + function _emscripten_glVertexAttrib3fv(index, v) { + + GLctx.vertexAttrib3f(index, HEAPF32[v>>2], HEAPF32[v+4>>2], HEAPF32[v+8>>2]); + } + + function _emscripten_glVertexAttrib4f(x0, x1, x2, x3, x4) { GLctx['vertexAttrib4f'](x0, x1, x2, x3, x4) } + + function _emscripten_glVertexAttrib4fv(index, v) { + + GLctx.vertexAttrib4f(index, HEAPF32[v>>2], HEAPF32[v+4>>2], HEAPF32[v+8>>2], HEAPF32[v+12>>2]); + } + + function _emscripten_glVertexAttribDivisor(index, divisor) { + GLctx['vertexAttribDivisor'](index, divisor); + } + + function _emscripten_glVertexAttribDivisorANGLE(index, divisor) { + GLctx['vertexAttribDivisor'](index, divisor); + } + + function _emscripten_glVertexAttribDivisorARB(index, divisor) { + GLctx['vertexAttribDivisor'](index, divisor); + } + + function _emscripten_glVertexAttribDivisorEXT(index, divisor) { + GLctx['vertexAttribDivisor'](index, divisor); + } + + function _emscripten_glVertexAttribDivisorNV(index, divisor) { + GLctx['vertexAttribDivisor'](index, divisor); + } + + function _emscripten_glVertexAttribI4i(x0, x1, x2, x3, x4) { GLctx['vertexAttribI4i'](x0, x1, x2, x3, x4) } + + function _emscripten_glVertexAttribI4iv(index, v) { + GLctx.vertexAttribI4i(index, HEAP32[v>>2], HEAP32[v+4>>2], HEAP32[v+8>>2], HEAP32[v+12>>2]); + } + + function _emscripten_glVertexAttribI4ui(x0, x1, x2, x3, x4) { GLctx['vertexAttribI4ui'](x0, x1, x2, x3, x4) } + + function _emscripten_glVertexAttribI4uiv(index, v) { + GLctx.vertexAttribI4ui(index, HEAPU32[v>>2], HEAPU32[v+4>>2], HEAPU32[v+8>>2], HEAPU32[v+12>>2]); + } + + function _emscripten_glVertexAttribIPointer(index, size, type, stride, ptr) { + var cb = GL.currentContext.clientBuffers[index]; + if (!GLctx.currentArrayBufferBinding) { + cb.size = size; + cb.type = type; + cb.normalized = false; + cb.stride = stride; + cb.ptr = ptr; + cb.clientside = true; + cb.vertexAttribPointerAdaptor = function(index, size, type, normalized, stride, ptr) { + this.vertexAttribIPointer(index, size, type, stride, ptr); + }; + return; + } + cb.clientside = false; + GLctx['vertexAttribIPointer'](index, size, type, stride, ptr); + } + + function _emscripten_glVertexAttribPointer(index, size, type, normalized, stride, ptr) { + var cb = GL.currentContext.clientBuffers[index]; + if (!GLctx.currentArrayBufferBinding) { + cb.size = size; + cb.type = type; + cb.normalized = normalized; + cb.stride = stride; + cb.ptr = ptr; + cb.clientside = true; + cb.vertexAttribPointerAdaptor = function(index, size, type, normalized, stride, ptr) { + this.vertexAttribPointer(index, size, type, normalized, stride, ptr); + }; + return; + } + cb.clientside = false; + GLctx.vertexAttribPointer(index, size, type, !!normalized, stride, ptr); + } + + function _emscripten_glViewport(x0, x1, x2, x3) { GLctx['viewport'](x0, x1, x2, x3) } + + function _emscripten_glWaitSync(sync, flags, timeoutLo, timeoutHi) { + // See WebGL2 vs GLES3 difference on GL_TIMEOUT_IGNORED above (https://www.khronos.org/registry/webgl/specs/latest/2.0/#5.15) + GLctx.waitSync(GL.syncs[sync], flags, convertI32PairToI53(timeoutLo, timeoutHi)); + } + + function _emscripten_memcpy_big(dest, src, num) { + HEAPU8.copyWithin(dest, src, src + num); + } + + 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) { + } + // implicit 0 return to save code size (caller will cast "undefined" into 0 + // anyhow) + } + function _emscripten_resize_heap(requestedSize) { + var oldSize = HEAPU8.length; + requestedSize = requestedSize >>> 0; + // With pthreads, races can happen (another thread might increase the size in between), so return a failure, and let the caller retry. + + // Memory resize rules: + // 1. Always increase heap size to at least the requested size, rounded up to next page multiple. + // 2a. If MEMORY_GROWTH_LINEAR_STEP == -1, excessively resize the heap geometrically: increase the heap size according to + // MEMORY_GROWTH_GEOMETRIC_STEP factor (default +20%), + // At most overreserve by MEMORY_GROWTH_GEOMETRIC_CAP bytes (default 96MB). + // 2b. If MEMORY_GROWTH_LINEAR_STEP != -1, excessively resize the heap linearly: increase the heap size by at least MEMORY_GROWTH_LINEAR_STEP bytes. + // 3. Max size for the heap is capped at 2048MB-WASM_PAGE_SIZE, or by MAXIMUM_MEMORY, or by ASAN limit, depending on which is smallest + // 4. If we were unable to allocate as much memory, it may be due to over-eager decision to excessively reserve due to (3) above. + // Hence if an allocation fails, cut down on the amount of excess growth, in an attempt to succeed to perform a smaller allocation. + + // A limit is set for how much we can grow. We should not exceed that + // (the wasm binary specifies it, so if we tried, we'd fail anyhow). + // In CAN_ADDRESS_2GB mode, stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate full 4GB Wasm memories, the size will wrap + // back to 0 bytes in Wasm side for any code that deals with heap sizes, which would require special casing all heap size related code to treat + // 0 specially. + var maxHeapSize = 2147483648; + if (requestedSize > maxHeapSize) { + return false; + } + + // Loop through potential heap size increases. If we attempt a too eager reservation that fails, cut down on the + // attempted size and reserve a smaller bump instead. (max 3 times, chosen somewhat arbitrarily) + for (var cutDown = 1; cutDown <= 4; cutDown *= 2) { + var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown); // ensure geometric growth + // but limit overreserving (default to capping at +96MB overgrowth at most) + overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296 ); + + var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536)); + + var replacement = emscripten_realloc_buffer(newSize); + if (replacement) { + + return true; + } + } + return false; + } + + var ENV = {}; + + function getExecutableName() { + return thisProgram || './this.program'; + } + function getEnvStrings() { + if (!getEnvStrings.strings) { + // Default values. + // Browser language detection #8751 + var lang = ((typeof navigator === 'object' && navigator.languages && navigator.languages[0]) || 'C').replace('-', '_') + '.UTF-8'; + var env = { + 'USER': 'web_user', + 'LOGNAME': 'web_user', + 'PATH': '/', + 'PWD': '/', + 'HOME': '/home/web_user', + 'LANG': lang, + '_': getExecutableName() + }; + // Apply the user-provided values, if any. + for (var x in ENV) { + // x is a key in ENV; if ENV[x] is undefined, that means it was + // explicitly set to be so. We allow user code to do that to + // force variables with default values to remain unset. + if (ENV[x] === undefined) delete env[x]; + else env[x] = ENV[x]; + } + var strings = []; + for (var x in env) { + strings.push(x + '=' + env[x]); + } + getEnvStrings.strings = strings; + } + return getEnvStrings.strings; + } + function _environ_get(__environ, environ_buf) { + var bufSize = 0; + getEnvStrings().forEach(function(string, i) { + var ptr = environ_buf + bufSize; + HEAP32[(((__environ)+(i * 4))>>2)] = ptr; + writeAsciiToMemory(string, ptr); + bufSize += string.length + 1; + }); + return 0; + } + + function _environ_sizes_get(penviron_count, penviron_buf_size) { + var strings = getEnvStrings(); + HEAP32[((penviron_count)>>2)] = strings.length; + var bufSize = 0; + strings.forEach(function(string) { + bufSize += string.length + 1; + }); + HEAP32[((penviron_buf_size)>>2)] = bufSize; + return 0; + } + + function _exit(status) { + // void _exit(int status); + // http://pubs.opengroup.org/onlinepubs/000095399/functions/exit.html + exit(status); + } + + function _fd_close(fd) {try { + + var stream = SYSCALLS.getStreamFromFD(fd); + FS.close(stream); + return 0; + } catch (e) { + if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e); + return e.errno; + } + } + + function _fd_read(fd, iov, iovcnt, pnum) {try { + + var stream = SYSCALLS.getStreamFromFD(fd); + var num = SYSCALLS.doReadv(stream, iov, iovcnt); + HEAP32[((pnum)>>2)] = num + return 0; + } catch (e) { + if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e); + return e.errno; + } + } + + function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {try { + + + var stream = SYSCALLS.getStreamFromFD(fd); + var HIGH_OFFSET = 0x100000000; // 2^32 + // use an unsigned operator on low and shift high by 32-bits + var offset = offset_high * HIGH_OFFSET + (offset_low >>> 0); + + var DOUBLE_LIMIT = 0x20000000000000; // 2^53 + // we also check for equality since DOUBLE_LIMIT + 1 == DOUBLE_LIMIT + if (offset <= -DOUBLE_LIMIT || offset >= DOUBLE_LIMIT) { + return -61; + } + + FS.llseek(stream, offset, whence); + (tempI64 = [stream.position>>>0,(tempDouble=stream.position,(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? ((Math.min((+(Math.floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)],HEAP32[((newOffset)>>2)] = tempI64[0],HEAP32[(((newOffset)+(4))>>2)] = tempI64[1]); + if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null; // reset readdir state + return 0; + } catch (e) { + if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e); + return e.errno; + } + } + + function _fd_write(fd, iov, iovcnt, pnum) {try { + + ; + var stream = SYSCALLS.getStreamFromFD(fd); + var num = SYSCALLS.doWritev(stream, iov, iovcnt); + HEAP32[((pnum)>>2)] = num + return 0; + } catch (e) { + if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e); + return e.errno; + } + } + + function _gettimeofday(ptr) { + var now = Date.now(); + HEAP32[((ptr)>>2)] = (now/1000)|0; // seconds + HEAP32[(((ptr)+(4))>>2)] = ((now % 1000)*1000)|0; // microseconds + return 0; + } + + function _setTempRet0(val) { + setTempRet0(val); + } + + function __isLeapYear(year) { + return year%4 === 0 && (year%100 !== 0 || year%400 === 0); + } + + function __arraySum(array, index) { + var sum = 0; + for (var i = 0; i <= index; sum += array[i++]) { + // no-op + } + return sum; + } + + var __MONTH_DAYS_LEAP = [31,29,31,30,31,30,31,31,30,31,30,31]; + + var __MONTH_DAYS_REGULAR = [31,28,31,30,31,30,31,31,30,31,30,31]; + function __addDays(date, days) { + var newDate = new Date(date.getTime()); + while (days > 0) { + var leap = __isLeapYear(newDate.getFullYear()); + var currentMonth = newDate.getMonth(); + var daysInCurrentMonth = (leap ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR)[currentMonth]; + + if (days > daysInCurrentMonth-newDate.getDate()) { + // we spill over to next month + days -= (daysInCurrentMonth-newDate.getDate()+1); + newDate.setDate(1); + if (currentMonth < 11) { + newDate.setMonth(currentMonth+1) + } else { + newDate.setMonth(0); + newDate.setFullYear(newDate.getFullYear()+1); + } + } else { + // we stay in current month + newDate.setDate(newDate.getDate()+days); + return newDate; + } + } + + return newDate; + } + function _strftime(s, maxsize, format, tm) { + // size_t strftime(char *restrict s, size_t maxsize, const char *restrict format, const struct tm *restrict timeptr); + // http://pubs.opengroup.org/onlinepubs/009695399/functions/strftime.html + + var tm_zone = HEAP32[(((tm)+(40))>>2)]; + + var date = { + tm_sec: HEAP32[((tm)>>2)], + tm_min: HEAP32[(((tm)+(4))>>2)], + tm_hour: HEAP32[(((tm)+(8))>>2)], + tm_mday: HEAP32[(((tm)+(12))>>2)], + tm_mon: HEAP32[(((tm)+(16))>>2)], + tm_year: HEAP32[(((tm)+(20))>>2)], + tm_wday: HEAP32[(((tm)+(24))>>2)], + tm_yday: HEAP32[(((tm)+(28))>>2)], + tm_isdst: HEAP32[(((tm)+(32))>>2)], + tm_gmtoff: HEAP32[(((tm)+(36))>>2)], + tm_zone: tm_zone ? UTF8ToString(tm_zone) : '' + }; + + var pattern = UTF8ToString(format); + + // expand format + var EXPANSION_RULES_1 = { + '%c': '%a %b %d %H:%M:%S %Y', // Replaced by the locale's appropriate date and time representation - e.g., Mon Aug 3 14:02:01 2013 + '%D': '%m/%d/%y', // Equivalent to %m / %d / %y + '%F': '%Y-%m-%d', // Equivalent to %Y - %m - %d + '%h': '%b', // Equivalent to %b + '%r': '%I:%M:%S %p', // Replaced by the time in a.m. and p.m. notation + '%R': '%H:%M', // Replaced by the time in 24-hour notation + '%T': '%H:%M:%S', // Replaced by the time + '%x': '%m/%d/%y', // Replaced by the locale's appropriate date representation + '%X': '%H:%M:%S', // Replaced by the locale's appropriate time representation + // Modified Conversion Specifiers + '%Ec': '%c', // Replaced by the locale's alternative appropriate date and time representation. + '%EC': '%C', // Replaced by the name of the base year (period) in the locale's alternative representation. + '%Ex': '%m/%d/%y', // Replaced by the locale's alternative date representation. + '%EX': '%H:%M:%S', // Replaced by the locale's alternative time representation. + '%Ey': '%y', // Replaced by the offset from %EC (year only) in the locale's alternative representation. + '%EY': '%Y', // Replaced by the full alternative year representation. + '%Od': '%d', // Replaced by the day of the month, using the locale's alternative numeric symbols, filled as needed with leading zeros if there is any alternative symbol for zero; otherwise, with leading characters. + '%Oe': '%e', // Replaced by the day of the month, using the locale's alternative numeric symbols, filled as needed with leading characters. + '%OH': '%H', // Replaced by the hour (24-hour clock) using the locale's alternative numeric symbols. + '%OI': '%I', // Replaced by the hour (12-hour clock) using the locale's alternative numeric symbols. + '%Om': '%m', // Replaced by the month using the locale's alternative numeric symbols. + '%OM': '%M', // Replaced by the minutes using the locale's alternative numeric symbols. + '%OS': '%S', // Replaced by the seconds using the locale's alternative numeric symbols. + '%Ou': '%u', // Replaced by the weekday as a number in the locale's alternative representation (Monday=1). + '%OU': '%U', // Replaced by the week number of the year (Sunday as the first day of the week, rules corresponding to %U ) using the locale's alternative numeric symbols. + '%OV': '%V', // Replaced by the week number of the year (Monday as the first day of the week, rules corresponding to %V ) using the locale's alternative numeric symbols. + '%Ow': '%w', // Replaced by the number of the weekday (Sunday=0) using the locale's alternative numeric symbols. + '%OW': '%W', // Replaced by the week number of the year (Monday as the first day of the week) using the locale's alternative numeric symbols. + '%Oy': '%y', // Replaced by the year (offset from %C ) using the locale's alternative numeric symbols. + }; + for (var rule in EXPANSION_RULES_1) { + pattern = pattern.replace(new RegExp(rule, 'g'), EXPANSION_RULES_1[rule]); + } + + var WEEKDAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']; + var MONTHS = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']; + + function leadingSomething(value, digits, character) { + var str = typeof value === 'number' ? value.toString() : (value || ''); + while (str.length < digits) { + str = character[0]+str; + } + return str; + } + + function leadingNulls(value, digits) { + return leadingSomething(value, digits, '0'); + } + + function compareByDay(date1, date2) { + function sgn(value) { + return value < 0 ? -1 : (value > 0 ? 1 : 0); + } + + var compare; + if ((compare = sgn(date1.getFullYear()-date2.getFullYear())) === 0) { + if ((compare = sgn(date1.getMonth()-date2.getMonth())) === 0) { + compare = sgn(date1.getDate()-date2.getDate()); + } + } + return compare; + } + + function getFirstWeekStartDate(janFourth) { + switch (janFourth.getDay()) { + case 0: // Sunday + return new Date(janFourth.getFullYear()-1, 11, 29); + case 1: // Monday + return janFourth; + case 2: // Tuesday + return new Date(janFourth.getFullYear(), 0, 3); + case 3: // Wednesday + return new Date(janFourth.getFullYear(), 0, 2); + case 4: // Thursday + return new Date(janFourth.getFullYear(), 0, 1); + case 5: // Friday + return new Date(janFourth.getFullYear()-1, 11, 31); + case 6: // Saturday + return new Date(janFourth.getFullYear()-1, 11, 30); + } + } + + function getWeekBasedYear(date) { + var thisDate = __addDays(new Date(date.tm_year+1900, 0, 1), date.tm_yday); + + var janFourthThisYear = new Date(thisDate.getFullYear(), 0, 4); + var janFourthNextYear = new Date(thisDate.getFullYear()+1, 0, 4); + + var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear); + var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear); + + if (compareByDay(firstWeekStartThisYear, thisDate) <= 0) { + // this date is after the start of the first week of this year + if (compareByDay(firstWeekStartNextYear, thisDate) <= 0) { + return thisDate.getFullYear()+1; + } else { + return thisDate.getFullYear(); + } + } else { + return thisDate.getFullYear()-1; + } + } + + var EXPANSION_RULES_2 = { + '%a': function(date) { + return WEEKDAYS[date.tm_wday].substring(0,3); + }, + '%A': function(date) { + return WEEKDAYS[date.tm_wday]; + }, + '%b': function(date) { + return MONTHS[date.tm_mon].substring(0,3); + }, + '%B': function(date) { + return MONTHS[date.tm_mon]; + }, + '%C': function(date) { + var year = date.tm_year+1900; + return leadingNulls((year/100)|0,2); + }, + '%d': function(date) { + return leadingNulls(date.tm_mday, 2); + }, + '%e': function(date) { + return leadingSomething(date.tm_mday, 2, ' '); + }, + '%g': function(date) { + // %g, %G, and %V give values according to the ISO 8601:2000 standard week-based year. + // In this system, weeks begin on a Monday and week 1 of the year is the week that includes + // January 4th, which is also the week that includes the first Thursday of the year, and + // is also the first week that contains at least four days in the year. + // If the first Monday of January is the 2nd, 3rd, or 4th, the preceding days are part of + // the last week of the preceding year; thus, for Saturday 2nd January 1999, + // %G is replaced by 1998 and %V is replaced by 53. If December 29th, 30th, + // or 31st is a Monday, it and any following days are part of week 1 of the following year. + // Thus, for Tuesday 30th December 1997, %G is replaced by 1998 and %V is replaced by 01. + + return getWeekBasedYear(date).toString().substring(2); + }, + '%G': function(date) { + return getWeekBasedYear(date); + }, + '%H': function(date) { + return leadingNulls(date.tm_hour, 2); + }, + '%I': function(date) { + var twelveHour = date.tm_hour; + if (twelveHour == 0) twelveHour = 12; + else if (twelveHour > 12) twelveHour -= 12; + return leadingNulls(twelveHour, 2); + }, + '%j': function(date) { + // Day of the year (001-366) + return leadingNulls(date.tm_mday+__arraySum(__isLeapYear(date.tm_year+1900) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, date.tm_mon-1), 3); + }, + '%m': function(date) { + return leadingNulls(date.tm_mon+1, 2); + }, + '%M': function(date) { + return leadingNulls(date.tm_min, 2); + }, + '%n': function() { + return '\n'; + }, + '%p': function(date) { + if (date.tm_hour >= 0 && date.tm_hour < 12) { + return 'AM'; + } else { + return 'PM'; + } + }, + '%S': function(date) { + return leadingNulls(date.tm_sec, 2); + }, + '%t': function() { + return '\t'; + }, + '%u': function(date) { + return date.tm_wday || 7; + }, + '%U': function(date) { + // Replaced by the week number of the year as a decimal number [00,53]. + // The first Sunday of January is the first day of week 1; + // days in the new year before this are in week 0. [ tm_year, tm_wday, tm_yday] + var janFirst = new Date(date.tm_year+1900, 0, 1); + var firstSunday = janFirst.getDay() === 0 ? janFirst : __addDays(janFirst, 7-janFirst.getDay()); + var endDate = new Date(date.tm_year+1900, date.tm_mon, date.tm_mday); + + // is target date after the first Sunday? + if (compareByDay(firstSunday, endDate) < 0) { + // calculate difference in days between first Sunday and endDate + var februaryFirstUntilEndMonth = __arraySum(__isLeapYear(endDate.getFullYear()) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, endDate.getMonth()-1)-31; + var firstSundayUntilEndJanuary = 31-firstSunday.getDate(); + var days = firstSundayUntilEndJanuary+februaryFirstUntilEndMonth+endDate.getDate(); + return leadingNulls(Math.ceil(days/7), 2); + } + + return compareByDay(firstSunday, janFirst) === 0 ? '01': '00'; + }, + '%V': function(date) { + // Replaced by the week number of the year (Monday as the first day of the week) + // as a decimal number [01,53]. If the week containing 1 January has four + // or more days in the new year, then it is considered week 1. + // Otherwise, it is the last week of the previous year, and the next week is week 1. + // Both January 4th and the first Thursday of January are always in week 1. [ tm_year, tm_wday, tm_yday] + var janFourthThisYear = new Date(date.tm_year+1900, 0, 4); + var janFourthNextYear = new Date(date.tm_year+1901, 0, 4); + + var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear); + var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear); + + var endDate = __addDays(new Date(date.tm_year+1900, 0, 1), date.tm_yday); + + if (compareByDay(endDate, firstWeekStartThisYear) < 0) { + // if given date is before this years first week, then it belongs to the 53rd week of last year + return '53'; + } + + if (compareByDay(firstWeekStartNextYear, endDate) <= 0) { + // if given date is after next years first week, then it belongs to the 01th week of next year + return '01'; + } + + // given date is in between CW 01..53 of this calendar year + var daysDifference; + if (firstWeekStartThisYear.getFullYear() < date.tm_year+1900) { + // first CW of this year starts last year + daysDifference = date.tm_yday+32-firstWeekStartThisYear.getDate() + } else { + // first CW of this year starts this year + daysDifference = date.tm_yday+1-firstWeekStartThisYear.getDate(); + } + return leadingNulls(Math.ceil(daysDifference/7), 2); + }, + '%w': function(date) { + return date.tm_wday; + }, + '%W': function(date) { + // Replaced by the week number of the year as a decimal number [00,53]. + // The first Monday of January is the first day of week 1; + // days in the new year before this are in week 0. [ tm_year, tm_wday, tm_yday] + var janFirst = new Date(date.tm_year, 0, 1); + var firstMonday = janFirst.getDay() === 1 ? janFirst : __addDays(janFirst, janFirst.getDay() === 0 ? 1 : 7-janFirst.getDay()+1); + var endDate = new Date(date.tm_year+1900, date.tm_mon, date.tm_mday); + + // is target date after the first Monday? + if (compareByDay(firstMonday, endDate) < 0) { + var februaryFirstUntilEndMonth = __arraySum(__isLeapYear(endDate.getFullYear()) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, endDate.getMonth()-1)-31; + var firstMondayUntilEndJanuary = 31-firstMonday.getDate(); + var days = firstMondayUntilEndJanuary+februaryFirstUntilEndMonth+endDate.getDate(); + return leadingNulls(Math.ceil(days/7), 2); + } + return compareByDay(firstMonday, janFirst) === 0 ? '01': '00'; + }, + '%y': function(date) { + // Replaced by the last two digits of the year as a decimal number [00,99]. [ tm_year] + return (date.tm_year+1900).toString().substring(2); + }, + '%Y': function(date) { + // Replaced by the year as a decimal number (for example, 1997). [ tm_year] + return date.tm_year+1900; + }, + '%z': function(date) { + // Replaced by the offset from UTC in the ISO 8601:2000 standard format ( +hhmm or -hhmm ). + // For example, "-0430" means 4 hours 30 minutes behind UTC (west of Greenwich). + var off = date.tm_gmtoff; + var ahead = off >= 0; + off = Math.abs(off) / 60; + // convert from minutes into hhmm format (which means 60 minutes = 100 units) + off = (off / 60)*100 + (off % 60); + return (ahead ? '+' : '-') + String("0000" + off).slice(-4); + }, + '%Z': function(date) { + return date.tm_zone; + }, + '%%': function() { + return '%'; + } + }; + for (var rule in EXPANSION_RULES_2) { + if (pattern.includes(rule)) { + pattern = pattern.replace(new RegExp(rule, 'g'), EXPANSION_RULES_2[rule](date)); + } + } + + var bytes = intArrayFromString(pattern, false); + if (bytes.length > maxsize) { + return 0; + } + + writeArrayToMemory(bytes, s); + return bytes.length-1; + } + function _strftime_l(s, maxsize, format, tm) { + return _strftime(s, maxsize, format, tm); // no locale support yet + } + + var FSNode = /** @constructor */ function(parent, name, mode, rdev) { + if (!parent) { + parent = this; // root node sets parent to itself + } + this.parent = parent; + this.mount = parent.mount; + this.mounted = null; + this.id = FS.nextInode++; + this.name = name; + this.mode = mode; + this.node_ops = {}; + this.stream_ops = {}; + this.rdev = rdev; + }; + var readMode = 292/*292*/ | 73/*73*/; + var writeMode = 146/*146*/; + Object.defineProperties(FSNode.prototype, { + read: { + get: /** @this{FSNode} */function() { + return (this.mode & readMode) === readMode; + }, + set: /** @this{FSNode} */function(val) { + val ? this.mode |= readMode : this.mode &= ~readMode; + } + }, + write: { + get: /** @this{FSNode} */function() { + return (this.mode & writeMode) === writeMode; + }, + set: /** @this{FSNode} */function(val) { + val ? this.mode |= writeMode : this.mode &= ~writeMode; + } + }, + isFolder: { + get: /** @this{FSNode} */function() { + return FS.isDir(this.mode); + } + }, + isDevice: { + get: /** @this{FSNode} */function() { + return FS.isChrdev(this.mode); + } + } + }); + FS.FSNode = FSNode; + FS.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 GLctx;; +for (var i = 0; i < 32; ++i) tempFixedLengthArray.push(new Array(i));; +var miniTempWebGLFloatBuffersStorage = new Float32Array(288); + for (/**@suppress{duplicate}*/var i = 0; i < 288; ++i) { + miniTempWebGLFloatBuffers[i] = miniTempWebGLFloatBuffersStorage.subarray(0, i+1); + } + ; +var __miniTempWebGLIntBuffersStorage = new Int32Array(288); + for (/**@suppress{duplicate}*/var i = 0; i < 288; ++i) { + __miniTempWebGLIntBuffers[i] = __miniTempWebGLIntBuffersStorage.subarray(0, i+1); + } + ; +var ASSERTIONS = false; + + + +/** @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(''); +} + + +var asmLibraryArg = { + "__assert_fail": ___assert_fail, + "__cxa_allocate_exception": ___cxa_allocate_exception, + "__cxa_atexit": ___cxa_atexit, + "__cxa_throw": ___cxa_throw, + "__syscall_fcntl64": ___syscall_fcntl64, + "__syscall_fstat64": ___syscall_fstat64, + "__syscall_ioctl": ___syscall_ioctl, + "__syscall_open": ___syscall_open, + "_embind_finalize_value_object": __embind_finalize_value_object, + "_embind_register_bigint": __embind_register_bigint, + "_embind_register_bool": __embind_register_bool, + "_embind_register_class": __embind_register_class, + "_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_object": __embind_register_value_object, + "_embind_register_value_object_field": __embind_register_value_object_field, + "_embind_register_void": __embind_register_void, + "_emval_as": __emval_as, + "_emval_call_void_method": __emval_call_void_method, + "_emval_decref": __emval_decref, + "_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_new": __emval_new, + "_emval_new_cstring": __emval_new_cstring, + "_emval_new_object": __emval_new_object, + "_emval_run_destructors": __emval_run_destructors, + "_emval_set_property": __emval_set_property, + "_emval_take_value": __emval_take_value, + "abort": _abort, + "emscripten_get_heap_max": _emscripten_get_heap_max, + "emscripten_glActiveTexture": _emscripten_glActiveTexture, + "emscripten_glAttachShader": _emscripten_glAttachShader, + "emscripten_glBeginQuery": _emscripten_glBeginQuery, + "emscripten_glBeginQueryEXT": _emscripten_glBeginQueryEXT, + "emscripten_glBeginTransformFeedback": _emscripten_glBeginTransformFeedback, + "emscripten_glBindAttribLocation": _emscripten_glBindAttribLocation, + "emscripten_glBindBuffer": _emscripten_glBindBuffer, + "emscripten_glBindBufferBase": _emscripten_glBindBufferBase, + "emscripten_glBindBufferRange": _emscripten_glBindBufferRange, + "emscripten_glBindFramebuffer": _emscripten_glBindFramebuffer, + "emscripten_glBindRenderbuffer": _emscripten_glBindRenderbuffer, + "emscripten_glBindSampler": _emscripten_glBindSampler, + "emscripten_glBindTexture": _emscripten_glBindTexture, + "emscripten_glBindTransformFeedback": _emscripten_glBindTransformFeedback, + "emscripten_glBindVertexArray": _emscripten_glBindVertexArray, + "emscripten_glBindVertexArrayOES": _emscripten_glBindVertexArrayOES, + "emscripten_glBlendColor": _emscripten_glBlendColor, + "emscripten_glBlendEquation": _emscripten_glBlendEquation, + "emscripten_glBlendEquationSeparate": _emscripten_glBlendEquationSeparate, + "emscripten_glBlendFunc": _emscripten_glBlendFunc, + "emscripten_glBlendFuncSeparate": _emscripten_glBlendFuncSeparate, + "emscripten_glBlitFramebuffer": _emscripten_glBlitFramebuffer, + "emscripten_glBufferData": _emscripten_glBufferData, + "emscripten_glBufferSubData": _emscripten_glBufferSubData, + "emscripten_glCheckFramebufferStatus": _emscripten_glCheckFramebufferStatus, + "emscripten_glClear": _emscripten_glClear, + "emscripten_glClearBufferfi": _emscripten_glClearBufferfi, + "emscripten_glClearBufferfv": _emscripten_glClearBufferfv, + "emscripten_glClearBufferiv": _emscripten_glClearBufferiv, + "emscripten_glClearBufferuiv": _emscripten_glClearBufferuiv, + "emscripten_glClearColor": _emscripten_glClearColor, + "emscripten_glClearDepthf": _emscripten_glClearDepthf, + "emscripten_glClearStencil": _emscripten_glClearStencil, + "emscripten_glClientWaitSync": _emscripten_glClientWaitSync, + "emscripten_glColorMask": _emscripten_glColorMask, + "emscripten_glCompileShader": _emscripten_glCompileShader, + "emscripten_glCompressedTexImage2D": _emscripten_glCompressedTexImage2D, + "emscripten_glCompressedTexImage3D": _emscripten_glCompressedTexImage3D, + "emscripten_glCompressedTexSubImage2D": _emscripten_glCompressedTexSubImage2D, + "emscripten_glCompressedTexSubImage3D": _emscripten_glCompressedTexSubImage3D, + "emscripten_glCopyBufferSubData": _emscripten_glCopyBufferSubData, + "emscripten_glCopyTexImage2D": _emscripten_glCopyTexImage2D, + "emscripten_glCopyTexSubImage2D": _emscripten_glCopyTexSubImage2D, + "emscripten_glCopyTexSubImage3D": _emscripten_glCopyTexSubImage3D, + "emscripten_glCreateProgram": _emscripten_glCreateProgram, + "emscripten_glCreateShader": _emscripten_glCreateShader, + "emscripten_glCullFace": _emscripten_glCullFace, + "emscripten_glDeleteBuffers": _emscripten_glDeleteBuffers, + "emscripten_glDeleteFramebuffers": _emscripten_glDeleteFramebuffers, + "emscripten_glDeleteProgram": _emscripten_glDeleteProgram, + "emscripten_glDeleteQueries": _emscripten_glDeleteQueries, + "emscripten_glDeleteQueriesEXT": _emscripten_glDeleteQueriesEXT, + "emscripten_glDeleteRenderbuffers": _emscripten_glDeleteRenderbuffers, + "emscripten_glDeleteSamplers": _emscripten_glDeleteSamplers, + "emscripten_glDeleteShader": _emscripten_glDeleteShader, + "emscripten_glDeleteSync": _emscripten_glDeleteSync, + "emscripten_glDeleteTextures": _emscripten_glDeleteTextures, + "emscripten_glDeleteTransformFeedbacks": _emscripten_glDeleteTransformFeedbacks, + "emscripten_glDeleteVertexArrays": _emscripten_glDeleteVertexArrays, + "emscripten_glDeleteVertexArraysOES": _emscripten_glDeleteVertexArraysOES, + "emscripten_glDepthFunc": _emscripten_glDepthFunc, + "emscripten_glDepthMask": _emscripten_glDepthMask, + "emscripten_glDepthRangef": _emscripten_glDepthRangef, + "emscripten_glDetachShader": _emscripten_glDetachShader, + "emscripten_glDisable": _emscripten_glDisable, + "emscripten_glDisableVertexAttribArray": _emscripten_glDisableVertexAttribArray, + "emscripten_glDrawArrays": _emscripten_glDrawArrays, + "emscripten_glDrawArraysInstanced": _emscripten_glDrawArraysInstanced, + "emscripten_glDrawArraysInstancedANGLE": _emscripten_glDrawArraysInstancedANGLE, + "emscripten_glDrawArraysInstancedARB": _emscripten_glDrawArraysInstancedARB, + "emscripten_glDrawArraysInstancedEXT": _emscripten_glDrawArraysInstancedEXT, + "emscripten_glDrawArraysInstancedNV": _emscripten_glDrawArraysInstancedNV, + "emscripten_glDrawBuffers": _emscripten_glDrawBuffers, + "emscripten_glDrawBuffersEXT": _emscripten_glDrawBuffersEXT, + "emscripten_glDrawBuffersWEBGL": _emscripten_glDrawBuffersWEBGL, + "emscripten_glDrawElements": _emscripten_glDrawElements, + "emscripten_glDrawElementsInstanced": _emscripten_glDrawElementsInstanced, + "emscripten_glDrawElementsInstancedANGLE": _emscripten_glDrawElementsInstancedANGLE, + "emscripten_glDrawElementsInstancedARB": _emscripten_glDrawElementsInstancedARB, + "emscripten_glDrawElementsInstancedEXT": _emscripten_glDrawElementsInstancedEXT, + "emscripten_glDrawElementsInstancedNV": _emscripten_glDrawElementsInstancedNV, + "emscripten_glDrawRangeElements": _emscripten_glDrawRangeElements, + "emscripten_glEnable": _emscripten_glEnable, + "emscripten_glEnableVertexAttribArray": _emscripten_glEnableVertexAttribArray, + "emscripten_glEndQuery": _emscripten_glEndQuery, + "emscripten_glEndQueryEXT": _emscripten_glEndQueryEXT, + "emscripten_glEndTransformFeedback": _emscripten_glEndTransformFeedback, + "emscripten_glFenceSync": _emscripten_glFenceSync, + "emscripten_glFinish": _emscripten_glFinish, + "emscripten_glFlush": _emscripten_glFlush, + "emscripten_glFlushMappedBufferRange": _emscripten_glFlushMappedBufferRange, + "emscripten_glFramebufferRenderbuffer": _emscripten_glFramebufferRenderbuffer, + "emscripten_glFramebufferTexture2D": _emscripten_glFramebufferTexture2D, + "emscripten_glFramebufferTextureLayer": _emscripten_glFramebufferTextureLayer, + "emscripten_glFrontFace": _emscripten_glFrontFace, + "emscripten_glGenBuffers": _emscripten_glGenBuffers, + "emscripten_glGenFramebuffers": _emscripten_glGenFramebuffers, + "emscripten_glGenQueries": _emscripten_glGenQueries, + "emscripten_glGenQueriesEXT": _emscripten_glGenQueriesEXT, + "emscripten_glGenRenderbuffers": _emscripten_glGenRenderbuffers, + "emscripten_glGenSamplers": _emscripten_glGenSamplers, + "emscripten_glGenTextures": _emscripten_glGenTextures, + "emscripten_glGenTransformFeedbacks": _emscripten_glGenTransformFeedbacks, + "emscripten_glGenVertexArrays": _emscripten_glGenVertexArrays, + "emscripten_glGenVertexArraysOES": _emscripten_glGenVertexArraysOES, + "emscripten_glGenerateMipmap": _emscripten_glGenerateMipmap, + "emscripten_glGetActiveAttrib": _emscripten_glGetActiveAttrib, + "emscripten_glGetActiveUniform": _emscripten_glGetActiveUniform, + "emscripten_glGetActiveUniformBlockName": _emscripten_glGetActiveUniformBlockName, + "emscripten_glGetActiveUniformBlockiv": _emscripten_glGetActiveUniformBlockiv, + "emscripten_glGetActiveUniformsiv": _emscripten_glGetActiveUniformsiv, + "emscripten_glGetAttachedShaders": _emscripten_glGetAttachedShaders, + "emscripten_glGetAttribLocation": _emscripten_glGetAttribLocation, + "emscripten_glGetBooleanv": _emscripten_glGetBooleanv, + "emscripten_glGetBufferParameteri64v": _emscripten_glGetBufferParameteri64v, + "emscripten_glGetBufferParameteriv": _emscripten_glGetBufferParameteriv, + "emscripten_glGetBufferPointerv": _emscripten_glGetBufferPointerv, + "emscripten_glGetError": _emscripten_glGetError, + "emscripten_glGetFloatv": _emscripten_glGetFloatv, + "emscripten_glGetFragDataLocation": _emscripten_glGetFragDataLocation, + "emscripten_glGetFramebufferAttachmentParameteriv": _emscripten_glGetFramebufferAttachmentParameteriv, + "emscripten_glGetInteger64i_v": _emscripten_glGetInteger64i_v, + "emscripten_glGetInteger64v": _emscripten_glGetInteger64v, + "emscripten_glGetIntegeri_v": _emscripten_glGetIntegeri_v, + "emscripten_glGetIntegerv": _emscripten_glGetIntegerv, + "emscripten_glGetInternalformativ": _emscripten_glGetInternalformativ, + "emscripten_glGetProgramBinary": _emscripten_glGetProgramBinary, + "emscripten_glGetProgramInfoLog": _emscripten_glGetProgramInfoLog, + "emscripten_glGetProgramiv": _emscripten_glGetProgramiv, + "emscripten_glGetQueryObjecti64vEXT": _emscripten_glGetQueryObjecti64vEXT, + "emscripten_glGetQueryObjectivEXT": _emscripten_glGetQueryObjectivEXT, + "emscripten_glGetQueryObjectui64vEXT": _emscripten_glGetQueryObjectui64vEXT, + "emscripten_glGetQueryObjectuiv": _emscripten_glGetQueryObjectuiv, + "emscripten_glGetQueryObjectuivEXT": _emscripten_glGetQueryObjectuivEXT, + "emscripten_glGetQueryiv": _emscripten_glGetQueryiv, + "emscripten_glGetQueryivEXT": _emscripten_glGetQueryivEXT, + "emscripten_glGetRenderbufferParameteriv": _emscripten_glGetRenderbufferParameteriv, + "emscripten_glGetSamplerParameterfv": _emscripten_glGetSamplerParameterfv, + "emscripten_glGetSamplerParameteriv": _emscripten_glGetSamplerParameteriv, + "emscripten_glGetShaderInfoLog": _emscripten_glGetShaderInfoLog, + "emscripten_glGetShaderPrecisionFormat": _emscripten_glGetShaderPrecisionFormat, + "emscripten_glGetShaderSource": _emscripten_glGetShaderSource, + "emscripten_glGetShaderiv": _emscripten_glGetShaderiv, + "emscripten_glGetString": _emscripten_glGetString, + "emscripten_glGetStringi": _emscripten_glGetStringi, + "emscripten_glGetSynciv": _emscripten_glGetSynciv, + "emscripten_glGetTexParameterfv": _emscripten_glGetTexParameterfv, + "emscripten_glGetTexParameteriv": _emscripten_glGetTexParameteriv, + "emscripten_glGetTransformFeedbackVarying": _emscripten_glGetTransformFeedbackVarying, + "emscripten_glGetUniformBlockIndex": _emscripten_glGetUniformBlockIndex, + "emscripten_glGetUniformIndices": _emscripten_glGetUniformIndices, + "emscripten_glGetUniformLocation": _emscripten_glGetUniformLocation, + "emscripten_glGetUniformfv": _emscripten_glGetUniformfv, + "emscripten_glGetUniformiv": _emscripten_glGetUniformiv, + "emscripten_glGetUniformuiv": _emscripten_glGetUniformuiv, + "emscripten_glGetVertexAttribIiv": _emscripten_glGetVertexAttribIiv, + "emscripten_glGetVertexAttribIuiv": _emscripten_glGetVertexAttribIuiv, + "emscripten_glGetVertexAttribPointerv": _emscripten_glGetVertexAttribPointerv, + "emscripten_glGetVertexAttribfv": _emscripten_glGetVertexAttribfv, + "emscripten_glGetVertexAttribiv": _emscripten_glGetVertexAttribiv, + "emscripten_glHint": _emscripten_glHint, + "emscripten_glInvalidateFramebuffer": _emscripten_glInvalidateFramebuffer, + "emscripten_glInvalidateSubFramebuffer": _emscripten_glInvalidateSubFramebuffer, + "emscripten_glIsBuffer": _emscripten_glIsBuffer, + "emscripten_glIsEnabled": _emscripten_glIsEnabled, + "emscripten_glIsFramebuffer": _emscripten_glIsFramebuffer, + "emscripten_glIsProgram": _emscripten_glIsProgram, + "emscripten_glIsQuery": _emscripten_glIsQuery, + "emscripten_glIsQueryEXT": _emscripten_glIsQueryEXT, + "emscripten_glIsRenderbuffer": _emscripten_glIsRenderbuffer, + "emscripten_glIsSampler": _emscripten_glIsSampler, + "emscripten_glIsShader": _emscripten_glIsShader, + "emscripten_glIsSync": _emscripten_glIsSync, + "emscripten_glIsTexture": _emscripten_glIsTexture, + "emscripten_glIsTransformFeedback": _emscripten_glIsTransformFeedback, + "emscripten_glIsVertexArray": _emscripten_glIsVertexArray, + "emscripten_glIsVertexArrayOES": _emscripten_glIsVertexArrayOES, + "emscripten_glLineWidth": _emscripten_glLineWidth, + "emscripten_glLinkProgram": _emscripten_glLinkProgram, + "emscripten_glMapBufferRange": _emscripten_glMapBufferRange, + "emscripten_glPauseTransformFeedback": _emscripten_glPauseTransformFeedback, + "emscripten_glPixelStorei": _emscripten_glPixelStorei, + "emscripten_glPolygonOffset": _emscripten_glPolygonOffset, + "emscripten_glProgramBinary": _emscripten_glProgramBinary, + "emscripten_glProgramParameteri": _emscripten_glProgramParameteri, + "emscripten_glQueryCounterEXT": _emscripten_glQueryCounterEXT, + "emscripten_glReadBuffer": _emscripten_glReadBuffer, + "emscripten_glReadPixels": _emscripten_glReadPixels, + "emscripten_glReleaseShaderCompiler": _emscripten_glReleaseShaderCompiler, + "emscripten_glRenderbufferStorage": _emscripten_glRenderbufferStorage, + "emscripten_glRenderbufferStorageMultisample": _emscripten_glRenderbufferStorageMultisample, + "emscripten_glResumeTransformFeedback": _emscripten_glResumeTransformFeedback, + "emscripten_glSampleCoverage": _emscripten_glSampleCoverage, + "emscripten_glSamplerParameterf": _emscripten_glSamplerParameterf, + "emscripten_glSamplerParameterfv": _emscripten_glSamplerParameterfv, + "emscripten_glSamplerParameteri": _emscripten_glSamplerParameteri, + "emscripten_glSamplerParameteriv": _emscripten_glSamplerParameteriv, + "emscripten_glScissor": _emscripten_glScissor, + "emscripten_glShaderBinary": _emscripten_glShaderBinary, + "emscripten_glShaderSource": _emscripten_glShaderSource, + "emscripten_glStencilFunc": _emscripten_glStencilFunc, + "emscripten_glStencilFuncSeparate": _emscripten_glStencilFuncSeparate, + "emscripten_glStencilMask": _emscripten_glStencilMask, + "emscripten_glStencilMaskSeparate": _emscripten_glStencilMaskSeparate, + "emscripten_glStencilOp": _emscripten_glStencilOp, + "emscripten_glStencilOpSeparate": _emscripten_glStencilOpSeparate, + "emscripten_glTexImage2D": _emscripten_glTexImage2D, + "emscripten_glTexImage3D": _emscripten_glTexImage3D, + "emscripten_glTexParameterf": _emscripten_glTexParameterf, + "emscripten_glTexParameterfv": _emscripten_glTexParameterfv, + "emscripten_glTexParameteri": _emscripten_glTexParameteri, + "emscripten_glTexParameteriv": _emscripten_glTexParameteriv, + "emscripten_glTexStorage2D": _emscripten_glTexStorage2D, + "emscripten_glTexStorage3D": _emscripten_glTexStorage3D, + "emscripten_glTexSubImage2D": _emscripten_glTexSubImage2D, + "emscripten_glTexSubImage3D": _emscripten_glTexSubImage3D, + "emscripten_glTransformFeedbackVaryings": _emscripten_glTransformFeedbackVaryings, + "emscripten_glUniform1f": _emscripten_glUniform1f, + "emscripten_glUniform1fv": _emscripten_glUniform1fv, + "emscripten_glUniform1i": _emscripten_glUniform1i, + "emscripten_glUniform1iv": _emscripten_glUniform1iv, + "emscripten_glUniform1ui": _emscripten_glUniform1ui, + "emscripten_glUniform1uiv": _emscripten_glUniform1uiv, + "emscripten_glUniform2f": _emscripten_glUniform2f, + "emscripten_glUniform2fv": _emscripten_glUniform2fv, + "emscripten_glUniform2i": _emscripten_glUniform2i, + "emscripten_glUniform2iv": _emscripten_glUniform2iv, + "emscripten_glUniform2ui": _emscripten_glUniform2ui, + "emscripten_glUniform2uiv": _emscripten_glUniform2uiv, + "emscripten_glUniform3f": _emscripten_glUniform3f, + "emscripten_glUniform3fv": _emscripten_glUniform3fv, + "emscripten_glUniform3i": _emscripten_glUniform3i, + "emscripten_glUniform3iv": _emscripten_glUniform3iv, + "emscripten_glUniform3ui": _emscripten_glUniform3ui, + "emscripten_glUniform3uiv": _emscripten_glUniform3uiv, + "emscripten_glUniform4f": _emscripten_glUniform4f, + "emscripten_glUniform4fv": _emscripten_glUniform4fv, + "emscripten_glUniform4i": _emscripten_glUniform4i, + "emscripten_glUniform4iv": _emscripten_glUniform4iv, + "emscripten_glUniform4ui": _emscripten_glUniform4ui, + "emscripten_glUniform4uiv": _emscripten_glUniform4uiv, + "emscripten_glUniformBlockBinding": _emscripten_glUniformBlockBinding, + "emscripten_glUniformMatrix2fv": _emscripten_glUniformMatrix2fv, + "emscripten_glUniformMatrix2x3fv": _emscripten_glUniformMatrix2x3fv, + "emscripten_glUniformMatrix2x4fv": _emscripten_glUniformMatrix2x4fv, + "emscripten_glUniformMatrix3fv": _emscripten_glUniformMatrix3fv, + "emscripten_glUniformMatrix3x2fv": _emscripten_glUniformMatrix3x2fv, + "emscripten_glUniformMatrix3x4fv": _emscripten_glUniformMatrix3x4fv, + "emscripten_glUniformMatrix4fv": _emscripten_glUniformMatrix4fv, + "emscripten_glUniformMatrix4x2fv": _emscripten_glUniformMatrix4x2fv, + "emscripten_glUniformMatrix4x3fv": _emscripten_glUniformMatrix4x3fv, + "emscripten_glUnmapBuffer": _emscripten_glUnmapBuffer, + "emscripten_glUseProgram": _emscripten_glUseProgram, + "emscripten_glValidateProgram": _emscripten_glValidateProgram, + "emscripten_glVertexAttrib1f": _emscripten_glVertexAttrib1f, + "emscripten_glVertexAttrib1fv": _emscripten_glVertexAttrib1fv, + "emscripten_glVertexAttrib2f": _emscripten_glVertexAttrib2f, + "emscripten_glVertexAttrib2fv": _emscripten_glVertexAttrib2fv, + "emscripten_glVertexAttrib3f": _emscripten_glVertexAttrib3f, + "emscripten_glVertexAttrib3fv": _emscripten_glVertexAttrib3fv, + "emscripten_glVertexAttrib4f": _emscripten_glVertexAttrib4f, + "emscripten_glVertexAttrib4fv": _emscripten_glVertexAttrib4fv, + "emscripten_glVertexAttribDivisor": _emscripten_glVertexAttribDivisor, + "emscripten_glVertexAttribDivisorANGLE": _emscripten_glVertexAttribDivisorANGLE, + "emscripten_glVertexAttribDivisorARB": _emscripten_glVertexAttribDivisorARB, + "emscripten_glVertexAttribDivisorEXT": _emscripten_glVertexAttribDivisorEXT, + "emscripten_glVertexAttribDivisorNV": _emscripten_glVertexAttribDivisorNV, + "emscripten_glVertexAttribI4i": _emscripten_glVertexAttribI4i, + "emscripten_glVertexAttribI4iv": _emscripten_glVertexAttribI4iv, + "emscripten_glVertexAttribI4ui": _emscripten_glVertexAttribI4ui, + "emscripten_glVertexAttribI4uiv": _emscripten_glVertexAttribI4uiv, + "emscripten_glVertexAttribIPointer": _emscripten_glVertexAttribIPointer, + "emscripten_glVertexAttribPointer": _emscripten_glVertexAttribPointer, + "emscripten_glViewport": _emscripten_glViewport, + "emscripten_glWaitSync": _emscripten_glWaitSync, + "emscripten_memcpy_big": _emscripten_memcpy_big, + "emscripten_resize_heap": _emscripten_resize_heap, + "environ_get": _environ_get, + "environ_sizes_get": _environ_sizes_get, + "exit": _exit, + "fd_close": _fd_close, + "fd_read": _fd_read, + "fd_seek": _fd_seek, + "fd_write": _fd_write, + "gettimeofday": _gettimeofday, + "setTempRet0": _setTempRet0, + "strftime_l": _strftime_l +}; +var asm = createWasm(); +/** @type {function(...*):?} */ +var ___wasm_call_ctors = Module["___wasm_call_ctors"] = function() { + return (___wasm_call_ctors = Module["___wasm_call_ctors"] = Module["asm"]["__wasm_call_ctors"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var _free = Module["_free"] = function() { + return (_free = Module["_free"] = Module["asm"]["free"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var _malloc = Module["_malloc"] = function() { + return (_malloc = Module["_malloc"] = Module["asm"]["malloc"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var ___errno_location = Module["___errno_location"] = function() { + return (___errno_location = Module["___errno_location"] = Module["asm"]["__errno_location"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var ___getTypeName = Module["___getTypeName"] = function() { + return (___getTypeName = Module["___getTypeName"] = Module["asm"]["__getTypeName"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var ___embind_register_native_and_builtin_types = Module["___embind_register_native_and_builtin_types"] = function() { + return (___embind_register_native_and_builtin_types = Module["___embind_register_native_and_builtin_types"] = Module["asm"]["__embind_register_native_and_builtin_types"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var _emscripten_main_thread_process_queued_calls = Module["_emscripten_main_thread_process_queued_calls"] = function() { + return (_emscripten_main_thread_process_queued_calls = Module["_emscripten_main_thread_process_queued_calls"] = Module["asm"]["emscripten_main_thread_process_queued_calls"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var stackSave = Module["stackSave"] = function() { + return (stackSave = Module["stackSave"] = Module["asm"]["stackSave"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var stackRestore = Module["stackRestore"] = function() { + return (stackRestore = Module["stackRestore"] = Module["asm"]["stackRestore"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var stackAlloc = Module["stackAlloc"] = function() { + return (stackAlloc = Module["stackAlloc"] = Module["asm"]["stackAlloc"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var dynCall_iij = Module["dynCall_iij"] = function() { + return (dynCall_iij = Module["dynCall_iij"] = Module["asm"]["dynCall_iij"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var dynCall_iiiiiijii = Module["dynCall_iiiiiijii"] = function() { + return (dynCall_iiiiiijii = Module["dynCall_iiiiiijii"] = Module["asm"]["dynCall_iiiiiijii"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var dynCall_jiiii = Module["dynCall_jiiii"] = function() { + return (dynCall_jiiii = Module["dynCall_jiiii"] = Module["asm"]["dynCall_jiiii"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var dynCall_jiji = Module["dynCall_jiji"] = function() { + return (dynCall_jiji = Module["dynCall_jiji"] = Module["asm"]["dynCall_jiji"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var dynCall_viijii = Module["dynCall_viijii"] = function() { + return (dynCall_viijii = Module["dynCall_viijii"] = Module["asm"]["dynCall_viijii"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var dynCall_iiiiij = Module["dynCall_iiiiij"] = function() { + return (dynCall_iiiiij = Module["dynCall_iiiiij"] = Module["asm"]["dynCall_iiiiij"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var dynCall_iiiiijj = Module["dynCall_iiiiijj"] = function() { + return (dynCall_iiiiijj = Module["dynCall_iiiiijj"] = Module["asm"]["dynCall_iiiiijj"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var dynCall_iiiiiijj = Module["dynCall_iiiiiijj"] = function() { + return (dynCall_iiiiiijj = Module["dynCall_iiiiiijj"] = Module["asm"]["dynCall_iiiiiijj"]).apply(null, arguments); +}; + + + + + +// === Auto-generated postamble setup entry stuff === + +Module["GL"] = GL; + +var calledRun; + +/** + * @constructor + * @this {ExitStatus} + */ +function ExitStatus(status) { + this.name = "ExitStatus"; + this.message = "Program terminated with exit(" + status + ")"; + this.status = status; +} + +var calledMain = false; + +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 (!calledRun) run(); + if (!calledRun) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled +}; + +/** @type {function(Array=)} */ +function run(args) { + args = args || arguments_; + + if (runDependencies > 0) { + return; + } + + preRun(); + + // a preRun added a dependency, run will be called later + if (runDependencies > 0) { + return; + } + + function doRun() { + // run may have just been called through dependencies being fulfilled just in this very frame, + // or while the async setStatus time below was happening + if (calledRun) return; + calledRun = true; + Module['calledRun'] = true; + + if (ABORT) return; + + initRuntime(); + + readyPromiseResolve(Module); + if (Module['onRuntimeInitialized']) Module['onRuntimeInitialized'](); + + postRun(); + } + + if (Module['setStatus']) { + Module['setStatus']('Running...'); + setTimeout(function() { + setTimeout(function() { + Module['setStatus'](''); + }, 1); + doRun(); + }, 1); + } else + { + doRun(); + } +} +Module['run'] = run; + +/** @param {boolean|number=} implicit */ +function exit(status, implicit) { + EXITSTATUS = status; + + if (keepRuntimeAlive()) { + } else { + exitRuntime(); + } + + procExit(status); +} + +function procExit(code) { + EXITSTATUS = code; + if (!keepRuntimeAlive()) { + if (Module['onExit']) Module['onExit'](code); + ABORT = true; + } + quit_(code, new ExitStatus(code)); +} + +if (Module['preInit']) { + if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']]; + while (Module['preInit'].length > 0) { + Module['preInit'].pop()(); + } +} + +run(); + + + + + + + + return LIBKTX.ready +} +); +})(); +if (typeof exports === 'object' && typeof module === 'object') + module.exports = LIBKTX; +else if (typeof define === 'function' && define['amd']) + define([], function() { return LIBKTX; }); +else if (typeof exports === 'object') + exports["LIBKTX"] = LIBKTX; diff --git a/ktx2/libktx.wasm b/ktx2/libktx.wasm new file mode 100644 index 0000000000000000000000000000000000000000..4078a49c0fa46950c6e2cc5881932b880c33f998 GIT binary patch literal 1999219 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

!yP zHPBK>g61A$#jfB;9mw*lrhFz$b)i!#nk}>~>efbuQ*auUk#bbH+F;(O2-zAHd>l0@ zeT|AV11#%EE)!B7r*KG(3`0cEi;*dYqxe01SRy|xk;3&IJ}gpq%srBzo{}4Rk#syA zs|^d2n(uHnG!<2vvbg%Vj4K${5sJzExUko?acN#49fl3eI2ao)oWn=u!1yt#)f`&q z#{_Xn+A+e>Yh)q~5XjQVV0N{UL3vL&ML#mJoR1)On3A8m6SAis`_$zy%0g3@N>wCt zRx2YjM&cMVTK{S2qjKn3esvoYy4PJf84#SVXU+43B-+v0zV5w=d=zveB)7_{Kq!NG zYmJ@}FR%rs81gV5&63@T8cBoPO@<-%qsbb=Ohv!R(K|F;BQOD>7DbLxy~IR#1^zJd zqiIfCIL;(biK&y!D(hYuGdevq9JK=bChYt$!RfSKWPQSS0%avWS{lB(ReM5q`K;En z*C{CxpO~NJz`P9B1#!@euu@qdt;4IS<V%J%*zL_;cF_vJf2DK49ph6nTx0 zX$Lo^=@)NLds^GEYSt@Qpje%uksErx%=cEapY}3M2e`7^Mwvr73JW!=%b90vfv0#0 zdo+E_TEih;oy{V!7Ydm+KN3$Z8>@Mh4L-@XOI83HZ#mWKI^Wxk-?yeoRM-=rM7PTs>{5ZceFEMm@*fFQ9;gXQo_{Dwav>+nQ6K zyeZD_{wOZdN&d-uyzP~ETr=4462?$JtoZ&7I;Iuu0$Es}+a5?Gk*aLheNO{zQn6&p zw3xQdG}BgRs7Vyg52}h0tJ(WpSyxFRnU1e$EsS3Y0s_KJ=8RlL4P8-#pWC2AOsSv- zk0awt9uvdV;Agd9ff``Aey=?$YG7PVuFSvj^~kXCdrAK0*I1nJ{Er`U2D+gH(FIQJ z)Z1tSRI8j$i+v2R5s7RVRptQqiOS-bfA<|8<2RQDGMWV~nHvz{-}BCIcuNE~L$gj? zJJ**#;yCH*oP@mtbI?#4T?W?2)hA6UQ4m+Y?1PZH!vqg|Z3f)ry5b+lW{v*anM(^+*`3G^LK(Z!(2qCKKTTWPwGf;gg{@R8(1x#?`s z(^wIlY!veSl3^quFqAf<$E*Q_9o1S~5Q9GZszBh`oX!V6x$IFBwAdf?SEFhwtQG6xhHY!5O2?4x8Ao(!i7;#lE3lwe$-mU zc=_M3hl^USWtWP{fObzr98wKH@rZz5Jc1e?u~D|v*%tN|J+hNsrP-hh)Z}Dp?b+(v zbGk>#Cf@L~euK4wush^sb6`#$B~Jn*sC zdeYu;H3B5Girdo=ty(gc`*6au=qqKK5)f??GhggGg~%mlM6qa@_~U~Y#;#qp`_D{2EP2ndsuVN6BcuDy8qL;m8jt-ayN z-eFO0o{qCyrvEE2@&Et+e+>gr(HH*uyPs1$YFLN-!pGkRf93)~i$iYr2Tm?pJhf!$ zam$WBVS4$Bm8;T0cH-)jPCjML+I6R{-*DQ-O;32@lTJTl^Omh=o^|#)=WaW1d%olR zCtq;kMLRFP)YfxE@s>JGUVy5Dy%axZp&;Qr9P#J$x0k^5u!GIyJMx%(6M3inF) zr|wnmc6Wz+wR??wt$Urj)4krk!M)MF$=&7dc7NvH?B3$u>fYww?m`%mH-6>jR~(ob zAHUyy(*33Tl>009Y4_LeZ`=d!GwyHQXWi%A=Sd2hZhrp@l(6#w_d)j|_hI)D_fhvT z_i^`qA3`Oc`;%wu`^wL|zjI%354yj1Uvyt`Uv~e~{e$~o?kn!A?rZKJ-9NdnyKlH} zx`*7i+_&9#+;`pg+&{a2aSywHb^lhh>9$wjprTg1-Mxe2i~ru~-sS$>z1zK~gnZxK zE@%g>AO-? zYm>#_sQl(p%H&s1BFI>vILcwxW5Jpjrc?j6dLjI z8Ynd4V>M7{#7AqO(1?%JK%o&IF6P+zQq#_pYuzoamB?|A$r zg|U14<1ZB4HTAuyKA7Z1l&~vg(cuk zHBiehzi%{9TyMl1YM{`F*VjOy5qH)=p%JgEfkGo*TLXngyru>Ujd->n1_~K(tbszt=NTxjXS|^X z3K@T|1_~LUYoMf_@%kDlWc=M4C}h0OK=>q8O?^%c6f$001BHywHZD=^0gt{}yRWvD zdsnf*4($QkeyP63GoQ_9Ll7G`$J&Z<&JDGv_Qh=eLb|JIQJ-&d|3+^{wv%3KPpH_b9pz{ z=>Vl^`&_?KK~U(bU%M2VXQ-Un3KH5ggNbW6&97IGkmecPd}KJy(cFr4Ps zDo9B4tKHo9wd~h_t019Y{}ub&a5=wHK|-2e?&f2|Y5q$E33dIFAi`o<*V8IUNb`#x zf`3s#8^2INLYn_9NQ;unG(TTKLYklR5YF!w<@{^~32B}xNT*)T&s30*=BGWRR?bgV zkdWplJ%pK1)b*b#NJ#S&f{fPddP)TeX@1;8YIXfs1qo>`^N?CymsXIF<`NI#^it8D ziz`S-vr~{BEh^JoR6#9@aA{EK@!k9pqW%qF{`dSkDZP@c)pWRZFS& zoL|d%p_U_!|FPHNYy6Q?!nV-3BT>R*ZQPHPCeF3Sd72=Um}o))j*dnX=a8jN6VH>5 zJJ3X-?>;I`oE;EyB$~KhgkETD^{iGw2c`=TG-0~%qte7#p_U`j#Ie`%e}E>=42?Sy zO+41d{YYs-=MxOy!hK*}b#D5>+W6cP#z$O}9J>zK*R)KT<4h?&cFFA%QC| zRh=QokW_VgkVdPu>q&wPrFmjiPFT&JP?ZxPo2qgGWMfrMfSjgP(U%;gybXeQNhd(o zdx&I~06A3e_54jdskdSLp1qrz(Jw*9J zu6_jxxj6o#l9eXp8ZRK6x9}|_KA}&8SA>W3DoDu1W!j#8%3PxrB;*>YAR!m==9Noy z7wT$PkdUiYK|-!(0l^pBw+BxnUk(ShJ%kem1tjFMb6cz)57)TaLwXK^*fCpJA5C#~ ztObdc`OsK#_nS=)9G!^cOYntcW8BEwI>uBuJYs}3H%IQ3%6FxacYKs(w$s0B3cpZ60?G=P6!0Ts4E|k$j)2hXV_VPU0rpWABT|59f!& zapXPEpt5Bb%R^DVA9(fYVk3%Ah;*%%0+{6>1?OP$RXW5<;7?V%dS*Z>+M03-c3yGE zQ39TNYSK!)sR^DTR~}A(?9USrq#Iu+c-*a%u5E?W<6y-VJ{F*F0ntRLm%yDMfF{H^ zLsEbsMVm$sZ&PRt9#+ND^e& zIXw%udYtmdp_Z}1Ror|sTXq=MJ85zd#EyL+k&n!h3AZ%v`5vF)fYTU`^te^VJBi7g zrsGd1x;kT{6AY{N?i-AOHg(te?v8j@8{yY?mwS@ub(ae!YzWkK>u`MtS{KmNvd=!4 zuP(2~KV2^SKfxo_F%r3;Gzb@$)X^(l`Xcm#RnC-M0qxGpD@~5P_~*8|Z)@uMm$%_5 z>G3Exx#oI^vMVRka4>*l7%H!qUxRxt@rF1($3Rk*oH?%s+4yT}WC?!GSr%cApa`5h z;vlevwUnnRg^fa<_}nqw?DC(k4i~UkhiF_70Fk#yPwEX3n~VK+@Km5ZGpT_lh>yw4 z0u=AT_nGvRdwBX}IK3_}04bbh2nUmCf}FcmP*rF1@H!1-bwVLN>;&fsHKyPe%vx9J zs6w$rLH!rBvoE(MFOPOZ=YB2%e46acspO%$R=3vc`p_cS8L$kul z*D#eiS_@Kp7LFb)-~pEr;bx8T7)BgARFZwUyF!;G7-AK&%*UX&qqJQ8y~2NjRI?d0_8?ttpK|iujtS%;H<@(OaB26>>%c*mFvT#l*X@X}JD>y|j*P%t;+Z=S z?6|3MV8?-Hr>#4mN;ypeYH)6Vs_=e>nc}95`zbAee{*AJjKcyc{(K| z`(|_9g(I@oiqU*}{_7U9i*NYLH+3(m#x zWvZbV;lc@dlWD;6hR*YiXc>?XF|jTD(U!Dna{xzXe>(*@w$J#p%mys~W3Xeu6r=WRs)e47MOf6G?56cTHOv0Na3|lfrn4V0DkquEYa1!C*3R+?j zQ>yP1{=0aU|4vvwn?{&2t6jTHHt>@=y)E+e7A_Pj*q9@9n+~Oe8P0Hdn$y`H7}=<3 zZkn}I+;x$sxY2^E*$GM7tI$QrM)Z_WjTI(R0-&&o3Ajwu2?EF!M8|^#->^|3M4PB8 zG3J;j7C*4)e$m-oQ%npjB3(s#3!mD=BGp_|lp5J2y z9TRj4`6fD3*xyI(^m zNXR4?$q(sa|@@8A> zU;`AQb6VOnvx`y`_=7Y1^8OVHIjhw;2#TX{S9l4b%WOPR+mIQiK;#Nbr=zp9ra!~X z%_epD@*?W&z~|WFrOmS?KCQxoG{4g=x(Da;e+jiM!SN398l_d^Dpg@%$7`*E&bl3OGt?2? zeuROUms#GWw(j28i^pJ)n$So74^@W+?S(md#t9RIG}`D#+;#9!X-LFIduf=wVx2_9 z;V3py+<@iiXBDu(IBA&I1QXHB*3KU`*VK#_#tC15^+dTC0D^buCNyIGrp-ZAa!$p& zl`?!EXa7A3T7V2R$tr=8#>JHaayZ^Pla84_Q58jEeN3y%kYVR#0IW0cOgL5VUs3{2 zOS_`Bw9=lI7qUq|Bqg$;A7Wx^iRNjn;-^SM-wG3DT=Te^pgc#T2FM?X=JnHXy0rPF>d5yqTx}}s^`WwkO7Tf5L2#`-}L4<|0Gx9 zedeJk|JvVJV0v{$+D;TeeK@QlS6dWxn&ya~>w82DfIcERb7ZmSu|3aYd*ZRJz+)9Z zglN85FRruN#Z0aqyo3Epd=Z35?`Pn@@NHr?!D9aI zT^@VSt+1Eh@q7<^eg&IPHEaj+x4z9Mds&q%fADk82IJ*5*tfarQ3LeW3T9`o{Q$x3 z7!ad6=C&!>ApxidYND^k*3s(16Qu?B(30PSTdf4m-O^2JQnT`Ehf4pLComY|X~9q7 zp(V6UvLks*2fI7+}zp8bh_jw1!ASMGly_a?mMD z(XsB$q%_Rlu?a|#TEv9)E7Mm)quyIPNu0?R4M}+DPe%xA zBYDpU*RWN@^CPiMCWWycF(dVKJaLgj78c`3;1pv-Ae7u5-a(3Dn9~QyO;Lb&FvYqz zsfa^Siar$?7y+2Jbng=olB_*q_i7gmWFH?WjImbW*ubiEp_o=SF)wV+@BV@(tA{EC z<*&cfkL33%*teVL+O=w0uM)bF$sz$uUL{@?u@iu+4~R>nS%9S~|D733JH%PrXR8s5 zDG}nSmPQW7_~jOdz_uIWb>8yDk6&z<_?XTjH~{-LkqZMqMqym73DH>{4bx}YCUCX}zQCZ+_?j=h=g9S1FpxZ0EW_9WXmklQ18EjVJ$p!Qy< zRtc!qWccyfB2A2RolnTz=o3Q-fSSD1D#jD75t}=jrrz}OJt}XgabDm-`0>~jIU>Mt zAuBRXImqcwQ zd5#zD07%6^`3j^?!_aF(S0ZQ(6tPL@{06+kY@wP5AAY%?2jBb_QF!jNU`JnS$D;?E zSCv%naug-g%=V^8N*ltq-w-k#P~=-1+IgBL*wWAqqz!&MkXh&AX=ON=v$az^K}=%U zLd;=L*0y_)gYKLoPUp6?J$q+1xnmb%JTruDrfniTvDGB14*xW59Ee6sBe@;38^SVo z&3g2T8kmNfEG8xe8j+E?{E&`Ffbmy&`|m{Dyz{DzrR@4_>UMUol5?Pbb9msgksZ80 zJDt4lSx^D$yxZ=YnmGerv*@~~BCU(5gc{SP3YPf`yR!D7j8!k}NKsRZ92o^37z)ht zK0+2`#cUHh3X@(lQA>jpeZumt$Z71X49{rgcG=EmzhNTSjE$`7*r}FR_M@$nqJHVU=REAkkvCwT-Uu%2Ew~$^7lay7}zd)Trpxx!jjsngn!r-44+9Vkw5Y|I2 z`IlzIl0=uc4imX-uW~?Py8$B%)Q4E?OnSJ<%}1izU1wGgG9R?y1YS zIURlG0Hg*sns)Ally)3UCwCk?!0&Ui#RmfEMjBIaD zr*7v4Kg};#AoJm{K_U!HvDp1dSlDj;HW&ZhVw3zW9W89kHY$M1n5ZB}6I=r}Bj+3K zJG5&Naioonk=%8p*}>6cTJw030nZIszldgvu6GZ=Juc>xih071uTm@>b?DThelaUk1WbyW?*Z9 zlEa0p1zaAk7Pwh@q88}-jWVmm3`smO;N4)*eKe0OcjfzxfF`!cOvC#LskppKeh>Ct0BX=N2mpG@+&=tPgk5!`ZxHrFjBeQ{&73QRUVaVZp(n^lti^^E z6H1upo=mJ~=Bc8l+TAX`XXE>IrAsx^>KW#)p`P_cRro0Qp7B;C$C@_WvqsS~TML2} zA99)3GqsYQHbO7(o-@-6v`0r7H1(&?`rV{I_{A{F=!P}=SQu(3L-Hsp%o+v8m~-H; zjxpw?4k0{D)NQP5X-~2L+g#`Xo}JI7@Vew;a)W0&E85`~Ug&c%k!2oI7N0?aJst2F zSlPuNxtJ=tNa_(S2=LzSryYT%5V+wIAWeQE``{At>x*o~(RG-ySc(PT6N4~f#19J^ z%-}N#6D%Q@jXgzBrMb|kY9cAZfx6N%HZn#0m)I=bimm#T43XHy5KJ9v7&J&2N>gK` zz~CQKr09w!1(|f!HGEutKDsXU?_T9)o{xVw%I98h?C^_iuE($rSht9279)UW#Y>OR$?IF|moWqt=Xhq+HWvpM$BvS!lxQC_Jf6^5FIm?=qvvG?Q{&9Msi z=%KbzxDiG4i$0C%L2fmP^j3x}g!~FwilWxqpL1>4u=5jyp5)^Teb8->OT!0$4^e^l zHBm>b4iV%CRpG_DP>G6!dW5RR%BsfbN;Sl5BF%ySOTEH+@_(mS`IL2t zklG-YxGv8h{mLIKJcyXdZZjV~MNe#DLk^ZAbIvQPiL{Q|Fl~8OAd#-l3T(E@QOuk` z5s@eoS+-yiFb2#3{g*IT6VJM?iwXBy?rLDmx_9l}rV(d?!gv@2b5{O=EMMe@*MMP! zpZ*`Vjf2S1&U3fVn)@*9fVr-z4a1SJU{fB87L2GIw^rJsWyN$;2Lqe?-|W46l;l@g z?_IyD>aMD;s_yFhZKh|}Z+b2XM355(U-Z@da!kT7vln1qTJqVjaV=(q6X&6JdMM4U~#yOP~)Ke!>-5i&svcju8AF#`H*`m3Tm4JlW zh*sGXsA$s@sxLetu)|E{3c$mj!ZeU|W^>)%ii948s9Lj9jpVCzx(>o^t{MN;(6B_8 z0k&tTEKGYwP#*n2Y_6?=YT$6OxMcE zheSzK8=*68I@~_Mm$+$S`Ps34wtz|Wq9%uA? zg;pA_MWliq(vQfel58-Eqd;lE4Yi1aeHF}Z&=k%kSUp}^<4d8$D8V0zWK+gg9>#5c zV`ek~rT_(Gs%a=4`+2~mRY);n(?#*nkdiR_8KXP30H_IUr^@C+g(+CK~%e z4B{iJ8VM8d+5YFC=dRp5!mu{r`$WU@2j|TQNn#DNykpPF!w^#E`Wn;12T3Ey9#m3_ zizKuDFv|B8u842ZF>sjLL7lp zH;$SC(L@rp7y1-8jILz&VPeQ86E4${d>Fe0gO^5Vvrc0A#!gL&oI zhfLV)L)PTvkr-n{)Mu8v!O#B}W9CaPw%3%!hY@N}vVS59lQTcVa ztaVrf;w3hH7{gpF(1fY3A+nbFq19!u0o5|zaTwMWaaM{&S6*2Iz}S|hI3Js;eW~W) zQdYy}c5Fb{p@@Ld@?P=_H*_tUwy|biHdRqk9M;OFHmFC2E1z*b5Og;3K&WwpnGxeJ zfrJGNGkY;?=s9(1hb6mw1%7g-P~wPi$J?a5%yNw7BrX9|qK3T~m4ZJ4bI_(E)_~-l zf&07{O8C=XHSY81vfq05Ai0`3xA{lVWsCQQ1ULua_Ktb`IYFf zxBAswEhBB_RD`XB86)tWv~-Yz@)-m+jCrdXHEY$3s8ROi@FZ)LMK)_xE}-gjqQ?+{ zKrEWJ6iQH_vnf9inE)XJg2V?{8*%`|gAr3iOyH7*RN+FE$#zV>@WHPne!NN_OU4;k zM140N3$AERI1dA;YXEfyP)`RSOA}5vba>HJ>c}-yA43I#vS6_~y|9Fv$ums_Fkws3 znhjRPZ>UUkQGo=2yR{ZGD#%`y*4L@G>_s+gOYkL{r`m*3LyVpO&Us3z3@m-Xju^lM z5uA?HXOzGaBl#=xs|M7==fW$!P=!#>g@|)?x+5tcYHBhW83ZH_0AzJFgN;Q`Gaj9n zA|HWx9sgN%G7z&?FgG?jJlP-`Mnmzx5u}TVXcUg3!&s85%CyE#J3Ms!;fN@Uo{-#* zx#Cr1X_B;ozW8c82&QS}>5Jq!~tId`SQ|;%U*JWdBNj!;&9wqHW*C`BdQb!m470{nN4oeRSiG> z2W#azJ)~wgaf!LSU0VdvLk!yfXjJ#Y5`u}481eJ3A{T>$rve+nb0WJrrzEmeaSind zEl6F2y3o|TI@<#ix|+A3Wlzcq3bH8Q6k%%fl7Q(?#@(b-*8xGYPOuv5 zh$dBE_gMc$tt^gSi}Zpg{WV(SBiK^!N1_3lp)lQw92sle6v;LT?L~mVMhqaaFu=a> zMISe}86-qAQMUoW5dTeb$Ed?O1$?k>0b#5__(Qa&`FgDy8nOnoLC&{Z#WsU8L-7f! zi_!pA8inoOIgYe~euA_lwHeZ28?huQH-Q&h=37*M#MSd3`P?7A{!MSY^Uur-S8 zy7>v4IX9JIQ|G29h;F@4inkaYink?zMpt!sO9OJKsP{ZVYPI!Qo>SB)M!PPK>rb+; z$}{PnmDTB&a-ceag~ozQ!{-A-(@0c z1Xp_LGF%Fj=>)TOX_DE41aYyQ1Y!J=)jE;M1Tz`DRo0-Y9Wq6oYA383HDA3@#*Dg1 zzMQJWeSWi7WzYP@#;b`eZwc-rRd_BHYBytFb@Y}OrDk%&Z+Wffu}4eE&z)luXjUyE z2aZ7nRBe1Cdzc14z^ zvIYcMVZ&q!JeuP45O5imK_kR5A5ZeoXZ;ZV@}En|E&DZu@%$_hgT3O+{3w2_b`*eBX^Xb5@aHbt3z8kou_kBoDsFHq(!Ldq$wT z8xuPcEOMMf=@il~S>`B24?t{k3m}k=-P-CcMiOvxrLj$$Dq0<2vPzin>KC_dSC0@l z_zPBU$rgce+xnB51r+EnZplQK-X$qXr<-|AYg9j)tfqJAG#IbN`BJ*;DfuE_QUmQ} z(5NF?!eNTyg*E9S#>oMI>?vZQaZOX#BykpyO!l+)EVNS5wtU;!_U%IcwpWxjm6zEp zt;Tp_SiI9NWle7S46tj4rz<%Ft9aX4MS7PF3?3#9B6Zu3nIo}r4jQ0&rEv?GLYV1c zEW3ic9;Lb%rXbU6kR($*tfv&cCbPmQ^G$;8R;9cyrdY#)rTW@nWS~a`$ysC=nGG%y z`v!Me)0(pVeWe~rp_yESmZC#I%{V2vE7T`np_zoB7kL(20-$x=nU&Dld2m%p#+eMN zl{kDH00#YN2Ft^MNGgpE+Yk>t+L+&|MrX+Y5Jj%QW+*1>Fu4(%<~2HNCCn-;EjDnp zVECGl39C&WEJ>%6Md@ck*y=4A_hepgR`>^Ley^>TM?LjtBu zQj63yHyhYaVTL4OZZSx#9L!xR4DotkDD8uf$J1l#a-2qDz@^3)cNq-^2N^4%N|xkM zh~Z)j_2c@7t>T|4z3@d;A3@8_T4k(y~Uiwz~M64 z%CQTXF9|{Cu&mK0%|lg{|LS4x?r9b;t_!lnB@|cQF%7Af{xh`o*ZWDm) zN{7Wd6oXL(N*r(ZY8fXTBy@$3b^vr184*DyimHjsigUCreFD5%Jd&hLjA=d~Cdg?G zYi!JWK?wMjC`R*1_mZ|apZbS_(9=K5C__9H>20toQ6n^}UbKdKK4^_ugaJx~?golwOP|Tp@M{^W*!2(dqVYmXh1Q zU>h1>E`D^d*{#OMws3XUM+VSUMZYTQ=A2R~1-%!^ZDQD1iZ4tO=ZT0AH^`zY@OK?v``DAkULy;F%i70`;B!*1dSK&A z2%x6ptLXlkAFMq3uaDT9Cna`?*9G$RL$k@ef78$oFf_Jt6iXN8@j*Y2ZC{xm)ma+V z*?v^dvQaUC8C5=kAxIQWBcXIuZO!^;TT4B(?^z0jeNImM&0<$P%d>g+9Z)Mc@uH5= z_jBktv`@0qK>NO%k%0f5qLk-ptm>KZMIi4Qfy4uQ)TRJW;Pmg`SuM6?8j)kX2tq_+#bAD%waku=hfBLu6!}5fS|l69n;1&U zlbO0NVGfZf;l-^Z&E)4k@6~~KJyuHo<@sj1_)IWee3eIk=^uUIW8Mn$xA~*1g0bP2 zd<7X)*`Gh`>wjNf|9~b3l-gM@c2?KUN~}fyZmw0ZwSvmQ+PI@ z8v_~`P-*~@-V^ZlwPzaM26Sw|AP11e&PqLD=nSZSz@q{EIt}dZ3>Hs#NY9Lky0bwJ z0PN1d|Ae74p!xxi2K4KUBHW9`W_yIE%fHaKD0;!w@=KCICzExNuAJg)P~Vh6)ng2veDQ*&}XC>u;|kGgeT1si}hHs z8c(Y>-s*ty4w_j{bQ&=gu+n+Gs;S8!BQ|=K_7ir@rr@DzdKF>V7hnJa=c2p%F#%AN z2*dC+7&I%N4vlIBM$8OGgN$=j=7X_Jvl?q-W41D~belCyDJ00^Tv1OjQC@)M2&5?j zQy~biI0mZ72bUTskX*IB%6z4?5q9xZZ1d^}HtPW#=#28(fokDj1VQN+{HhXbmAqK|H^L?eAxT4el5*<&lRV2bOHV7O;$C}BC_yAkwjWLzOC z?+RQH)y_>d>@q$kxK2#497po#9N}x05N%|a`veyswLvDBG^x(EQ_J{WL*qaxwrUhB zYWSrZg;VF%jDB}X(QtHu4{f%lHSqCHYmnz9tpS6-KExzWAYe>qF;%Bk%2`=k_g#uY zmm<0(r$yQ&x`Ca1UET*HzV~_|{WH+P-H)0*GWqlH?DGSjePzJ2uN9uX@qNC&zt5lD zGa9vRLzi(X{3wDH{AnLM*6BN5UhV#HE+P(mH0ipsg@_XmPQ>?UvSPjGQ3NJ&Q7A&3 z*~mNXhlq#|=fnVju1N7wBE|W4c$qO*leheT7GlAM2?Azmh|om&=}V-e#2ZkS-JgJg zG`~1r2Yg_>l`pU+CkFmUvf-ppu+qw?tZg5p_QCVOJeHSlJjC2(w|GR0Z(G@|x$f{4 z$i|5Q)r^yL3-e^DP3v#9#F~IVH4)=a9mR=7_J-_(@m#LI58s!N zE0m<1vR9ZpguZfjIBu!0TsbZnmBmWYB7GH#5r!~Xup^qK;lmI5+4P0Hhr2;Ltup&r z--vJ*V8InTAUZeKn%`)!dD15&Z{ZSUE5o63OJS^SO+HH3)**SqL&zk;jZP6DI7fSn zloTPk`jBK7ZFsbu1+1f%^;;QcH#YPM0q|@alq;Y_j4J{vLJZgRnms>UW0;Y7nMUPJ zgnSiUKx_&k3=>3o9V|h{m}ZEajue8`+GtP!I=@m&Gm~H8JXrS^J={?!b#T=83m+{YvWm`X}UeP?tOsAbh8o-Cq8JO+*(5GjI zBVEl7!U=u**0c!?5is~JYeShfV?@?lJ!ek{&0d^VY7nuQG#jbLY^|{wx`n)KA#x2( zSA||espQ5x+C`|O5y6p+R$@Stn#syN7C&8UUsOjCfzR{TUI}mq3Z-eMdh?}uO z4hl&Up|ad88_fdO{r0rkc?S`03X5i9c|>YmfRB)XPdjXgnSKnf^162U(zeKcT)5+- zheyPdI$@3L1ga4LDVPD?r;KRxs0eed4Zs{0(hGA-B@cv@6U@VW1elYvMP1?uv}5t4 z0K<4D1*^+=<+&8Bz&{v)wb`ai@!>o@AnhBhLsbS|VKV(lYq9T*RueXA6$ruB9}z=O z$D+JrhV;IU8C3}KzKw{EY1x727CQ!7$mObOvrYfB25HL34M9>*tvemf6m1~aB=4KQ z9KfTQl@?Me`@#dx=pgFK6BOUFO04MVC|0UE+t$U6z^%9QS zVCiHG#)-Dh2R?kds=$x8^u)&cpfL5LqCs~AU%XW z$u%vdoNF;ga{Iy1rAkpknXOnRm@u{s6LwNR4Butmap3UbW&YNVC`H(DoJ%ZxK=K%J zMd_kr$sd-I4;kB(HFUp zP-a^kmxrXyKT-?&C5<_Xu__@-n2ckvBxqL~{ooxa3W|k%PE?9p&^%erE?oBM%BWts zWl3)bAuE)LjC;qE6C^%E>Hy!2&qCWT^AX)t1Hznb7iCEGE6^!I|3%@W&nb}%L1O)t zx-P}-Y6o`&(J!Z!S zS%+kRs51}*xZ|#Ug?4+Bhmh8h(O6>`jqkTbylm>YMO|s*I1MxtXX)!IN!Kg_EfB3e z;1xEFYavDp*0ykom8iolH^w_FgB_rPMSy>H#WUMGPRJt2Que{eCyr?Ucv$vn$aVx{ zQPfOgIo2OwYP-lE*>m_9d&h0fXS@a$WsMqRU5*SfLJHuoVhIF*M2(^byXuc&?%_v_ zi|uel{8a+lbQTpIHncHZ6M)9;)UHNOdmu*VcyVOah`%rd%NA6Di(S$-k=(V#AI8bs z!B3+-o_z66zp_61i&65nTWw<_Euf`Pz^GZZ9&S%0kA2k7uz$@9s-BD6(%!^FP|}!4 zocZ|qH~EtHFPD?Izi{l47a7oNR+)r7dKZpa`7 za#@^$dM+UB=WE702Z z`LR)w`Nm6aBT|rbgGI2RFA-cPlFv4{V5M~07m59|YbhBfpwkIvP@UP;;JFUZVTLl5 zn9;}4t} zef0~T^nN>k_NjI>bESkEr5p_j`gE+HvH>ykjkjtinD{8$_k<5wc@&l6gC$W{!GEl6 zC@B0JaNl@}AJXDYu4AxLT0Di5XKC>SP^zDnZpeN%Soch*e#Tcn3*1{64;Z-BOz?Nr zs-)&QU-Q(uo3ok~7@pNE8l~oWH&4xF)w~dDUhp+9irG?0TC<(1r_NIIQdaYl)y%uR z<}!%rB#->T%o?9EU>2@4OB+rt>*W+X^Nz+#@{T|likXHD>Z>%2vjuTQ&f31|gTA7< zVntLidX(}cOhe{f;_A`pD6So=vIVUzyE(bn3iWj(UrtE_=j>CR2T=B=0)7O-coKul zg8o6$%j>aOJ|gZ5W0+#BG=1F79gF8Q0yQ^@65H3DT2T(Yw6&(QRUie1Dsq!ogu1#6 z!Yz}?TLKk%%hj7D<@HAX%mG+vyo-j+kg^{1jCG1W6Ph{4kSCKzHDtm{8DvB94MJLX zw<~v7)Re-|x)Dp+JX20MH$^kvV|ZdWDs+-2DAeB6jDA+IvsRtR&wns!A1vzwpU7|N z3dddk!EPpk740r#vh5ia8TJqwcWp{mSUyVc!D5*tdIsnT;HTNMq((^ZLbgDeiZbdN zJ=)#H633jm!cit~8Zn9{N!)2kdvL^cxDknU+%Bd8M1)v7$JL{cPl$>FS~09~5KW9% zfKQaNk5AyE%UjVl8a=%;+V-_BrL~e3@EDmBK=E1^GZu*0lVo(w!(>rdS+XN_#QQu_ zt3au@=_Mgm2}qYbQqdx-Ozr{DjzJ^>K`@!fZl=kgIiP>c zgC)+d^?FjzT=t~Mu72jhWZL1f=D}uwP11m$2fm?ZFZOL7beIQL7ZlI%5K2XyWz1}h zcfkA$Wi|e+aX;NtM1gQW1(=&*3b+-Jup1Q00s?=rRPs0q+(HqAD}fq)zDH5coFkvM z55ZMZF;R||s5IZ>O!4d8A@!qDY+Axd>S?`vIlVR^b-&P z`m9X}m;MvmqpK1!7njx*dC&^!hLG}F&A(ZU_DiKY!SRr!ybyu*{)aI15ZSTVY;$ji z>-##UhTs>#^n($?-rO;j-2dTH=QlD3iB>YU>|V$Yo`|W(mL)`FZHlCt`#SjDu0<(q zA$#Ak=zUh#n9Z037CIt@LU&AwrOJa35zRZ$lW=zUmEB~66$J6p(q?uw6->Awy&(mv=f7n$^ zL;;nrb@%XeWz8B}<+Eu^A;0JrbRyP@TX2i0PZxL5M!Ku6)?JaU5a9+&PEllV9@&%}OMFuM%*({tPCM`?J4?R{43w6Am(oUWLu{r?2_k_~<^d`V%e&L$vtf7#sU5WwHwuHcP648$-2;Z3 z8cGhW^3NY-ErY)GLr>@nLK%I5QDM;ECozRq_o-`_@yZ(%wOZJNDt2@2yM%((Tbw8R z8KAVT1LBIID(~Rzqz+CAQRQeyV!U8$|?NiUWbbGr8b*uh` zudK`-GZbm6bk7p8Upv}8JCqkX_5pkn){Mpn1O}){vj!SsZ00Ls?@h0J=*5k?d;(1g03EUjVlr?;o$0qDn=mNuV+aQ#RifZ%yCN)RDR$Y^}9c zBl{k5$!)*PG#Ev&{ptp@duIC$_rYAoR5AMZ3Sswv_nsWkI5jO~>8lA3C!S}T>s`Mb zCGYSA1e_|E^fv0r-JaZl22fZAdYGHIym&1>%iJxDjjiUOUWnat_$~(<#t39QiLOdQ;8|FKOiRvQC%L$a$8gRtjHWi zT5E?&W~(c&!$>1xG4Nkf!9<=5K#`V%kk>*F#9<*(WCE$ODcH{@>evk*?eU=OA(Nr( z6a0RY&;c}Cx95c=`@wdZY($qcO|+gc$<=*(%_;=nhbL;KVcp!X{wwyt%2LN;Z999D{1bdGuPOE6XI+?vWivd>t9RCP-^K1*$%rLZmL4MsS}&xK?OyZu+Z z<>9k$jgsHF+g1S&MHU<2sGuI0OPWs7FMa_5g1X_2O83Lj6vlBp`G1qkuoN=IR*#ap z5?Ux_w2&^L{HixvgyCJ7Eiv;$J{WokWT`vHVo+Z0>Zk4wkpF`r?pZ^?n$yo5gXL%5 z%M6Qf43m@G{%+SD?Cx#4Rq7TsC}D$Zx?SFdwxmab2Or?P(3&NtfSn4vi9x?`2YSMt zzM@-n(Z~st7^!)LVI**IaZwMX%fRKYt@+W)8m)5##qBjR@lon2hfo2sSlOiDa526G zxm~blkxwRhXbm|)w;$On0YKKXQMc=?@|X9%pdxX~#cr=4X7U}=(=T%SE4;A9%*BD+ zp|lvx1qrb1B|wu4g9Ml^^-!v^1kudsSv2v2^6f$t%aetmfvUD&kU&`Z0_}f}%j4B* z6iM6zbjU&bc<4)e*{K{PEf4A2%H4gE$o%LKLp5)SnzPZ}fq3Ee9imMYsYz&Sx>zt^ zoD%Ys{3Z13%X?)h-@E1xc)*DIBG>~3&>hnJ3$J;fH$DH^e~Xg8{#P&8oCx-{`wGu~ z`|ZBmPeb`9NWWSuHIrWs&)!gY_WJPb)A=%&d?B>)w}txN`$0dG-u$+_-A96F{14w4 zC3k(%`f_tC>PXpf%oohMpsx;v^V5=slI#-Fl|6OPe@aDg-gu>qJ6BAA$Tn)1 zht@xdocGobc!T7acFa?fl%Q90T4&)4KD`=k$BvSyklRIVVn^yL$7Ep}Gdv)am+VCb z_~iTSOa+!~Ja=*ckLv(K&g@P*4F^y@Ims}+c zt5iNLjTD=x4rpp1|2L3GsS_)5CjVp8mPSb|T2dmX1mZuA!-jX*CK2EuM1-hsgN&j@ zeAE^8>@l3AxYJND88B)hhYB$?nb5F_*A-d?^@cDkY~kR8^Np0>gS9}4sKpC1M6$#f zh^CBJ>6~sx79xTgYSsp$gg~eebqz?|mLW)yP!yJ|<0uvbUa9w5)fm1Mi3v?FbxWL5 zsraqRMqZ_v^{KLpSFC*jXX++8)&k=m`brth5h+7D$!WeEBajMAw3O~u_fr6nQVOdI zuoI!sfZPb(8R3M60|2HA0GJg3<~9Rhb~6CTw`{}LKy62W`k;ou2O%=6Mc?J)0BLMz5z-)aczm1`2mgP4Se29JHjv5m>^zuB|K>+Xt@U;SQjM$HFS9dM>N&p8XhYA6J2 z+@ckx8NcU62`8*;b(;f_dWl6LduQB34H11I`HIDj_5cy0mY(2bP|QHu6HsiCl{Ot{ z86IiN9l=ly@K#P9*t=$aEJmT*hxV?S&n$piDx>C$65;qcjUS5D(7L1WP3%3i{1$9T z)#R7Z_+hTQ0OCk;pP7|zef3)BHbkm}<(WXks4xf13ta--50*P!yK4bIo8Ewk&K)XW zBLVOx)#k@|J$1>8$s86pRwI1*Yl`S#U~3 zD1%BFx`dyaLr{e&X#8}{LS{rKz)+b1iS`x#oqc{T$0vBM$Qu%aftT=hOa$bVK#&AR6f;?Zvz=d%pmNvua*a*DV z`~sIWZ~>_~j0rZOiA6P%mwN(;jR+5Nkn5FCk-4g=;|db-V5p@ouv$QkkhfMAx1RL($J zn)Fl2q$GAp1StuAta(LG!@Qy#*~?l&1fgOF%MXxF@quMvQcWH}!|FgWasZYSiI2B& z;P6B+z`>w8zh1*R!qmd0Vp%7h4!6R9>%l1S5!_5oe8=~bR+pMiO?VT@%}Vh))_GTP zqXrHUi+2)d>kt@%V+|KH$1p_M#+`p<1JAX8?Da{|7ns5xL(!g83M`^%BcKRgB@~Sp zQRKA8?c^xh^Aw_pwS%7aps1dq=sr+%pGVPsph$rW9z{grck%(+h?X0StvvHL~IPo8Rqnft-a{T?&-_f4Lw32K@M*6Domps=LK zvB~4@t2uJ`Dw{fLIJIt1B)7_5x&72J1hJqMr_P;&5agIdOjYKQc7-Vj9d4ZNl6x?p zY{~yT;nmR36`%DVah6>BXM;3W#yqM z$)mEUkZs#9_sRFOU?OHdgzlw|A1rT7#|i|uQQT?HyO^~`y*^=gE^_6`vUM!#T&GO~ z$;LDR4fetH(-NQj2W4=ELv%1+fZ=@GjrQcXi5aq%nE;JOR zxEe#@4bU#zpd!HypqV(~Lfa8`1A7kqti=i>it6m2;l|t@x=~WUZr=@PT6~%i4X7jY zN*sA2d0((38N0+~nrptHObER1Z~j-9D8-R}>amBCu3OrB3IcT9iHU_(@FdqWDudlk z0Ob!2*d7$ysjBx2u^@NeQ3;t;dZewiouB_*uk(EVHBs^fzZ?0n-}8_DI)C)Z-}jFm z${)S|fQdw3$e;X`fAYor$!~_wzLY=u>5uz)_2vB0Tm5(cD|_-YQJ4nmH6xegEg|j6A-ay{?NfjNjGlQWf%rxk2Og}p~1}YrMCe=tbsdU_oh*xjZNj2h0Tr!nG-=bzm zrEp158nsDPhZ4ghczc*s4Na=L+2d?*RhuYuRvKeEsjAte!hNE)nN-TE>aS9+gY6-O zAj3DP!&6R~Ed+i7th5nU{+8Zs& zJ%%~DDMc~hLxUk0p;WH0nn?M_Px9o&{Hw$m%I9DCgUkGKT8L=W z@L9Ga$;YPq5Mv3LKYpx({hM4 zCx=%Urh*wIccW3bNZL7Pa6;X@!2lo+0o}39wa9d`kT*Qs#>8lCq*z_FC}Nc4jVeqQ z(R7$A3)CfB1hsQ^i{7{0h*~eP=Cuk9e)M#NWeh{>OVf3jg8O428*64|-nwNuE9UCa;X% z^d|r8LpiE{x?*XS8J@(Bx}t_7z|XAVhz!F4J8#_R4==ydjsAcF`7yL9qByDWAMQ`2 zMR5{#vRt_QW1bAaCA6h|k=kX!>jel=*=f1Uprp5ukeT4Ahf>w!+H2iNr1(v8fR12K zrC6z~JN4sTRVxfe2TL$+u#?D*&RrG#iXWZp;;_XYSw4%?45P&1XJaP@c4TF30Vsq#=+z#abYkM z`N#Z&2VJida$q&)6)(xysQ$IB8W|Hg9uT`3-d2v#IaIz8i4RhQTk!8N3esCR$TdOd z#<8ZEGR7pChEeg4Ng_&T$Cl{PwV5aEVB$Xw^?u*XI1?th$KvDsl$n62WgU?%OvDZM z5M}eghJR}qqVXgW7zJHH+lVmf+oT-}x&k&5uPa#iAi9E?xpBs~;Ps3P>ff zU~G1XdVu;E?*z_L>BqVq^@AQ0Ejq~qE*~(m;q0u9jYoe{%uQPcAAelOY-#E~IC260 z06roBMfZ1`i<=A+Kuuc(qRt)OKw=DU!m3xPxMD!R1MfDx2P}BglCbRMBdmLL%gd)z z3Uxpv@n8w!Q*yIitium0mx(_^efEUe`(mjG_IbDNrxLx3R7i9x8I2t`@bGl8#vhx> z4eW);B%XRE@zj|fUgBW`Rd!|aM;V51ujrokYV$)Y@CIyLCgZTyO-TYUL;|BbMl@a2 z;Y?Q=os1Zt)VK(>PQAAY#jcd2*lg)GByO{&8rlY(=<_^QH8k-cxPCg+*(O^@_Ujo-o;^?Q@XN`I|GhAjh! zMYw{VukY==heIIMS^u18igEQ1?*Qx)JJY7IkwfpIhXODduN!Cl9!hG;z{mi30tO)m zPfWI9$GG2}NDBcrw@l%sC@#}C*@MD5eSUSS5jl9}hXkt!g{%##ipW_e&pr z`$L~ISs7D6UOyYB&i}-x|Lpyr{G)gM#rcw?iR0zbr~l?P|NAT7{ONyq(0`#$Ua!i% zGO8G3&<%X>M2#j7?_E3pYKei7)PPYrnM^?J_}kP4Wd=GZ_+a@?)M!X9>im|rLHm8a zdR#@UMJ%(~VKby*n_!s=p2j_$1#%YIrg)_@hCeui+!_$hdh&foIT8i3!}!e-)JIA_ zz9x{G8o+yWXVtJu`#67z)3Nnijx^Ql4J)40z%x+NjVjQN{H$;sXG-IT6$%0iv>ro4 zwqnYUbqh3OADL52GS2rMZBvhK9~$8sMt5yFtbRE#CJtJ7%fP%O?c?v*LF!?Qn zxytzmn81;z0P?KJH<=Qb6{Hf`lU8vq38pzPoI_pgR-R9lq4AjGlWoY!vP} z=Ilx_ThIKs@NyZCyfG`V!Zqgl5uFtwgOcFLYVn{&0ilke?cDZ|S5QCjTTybAw=pE2 z`jXdxK3aJ8_!s@NKQ27GC1^??D?GdLgTB6d3eVmi6yDE%BT7E;U1q0y^RN42e_AMZ z(+B*s+g=wX_nu|Ne&(*n z(seA8oHIQdVurbt+7LQYk;&G{Ngj5*g zl@aWCQtY(77m;3h?P#%zCM8#b9x`xO$3qJ27y&Qu;K($xV-UtAzcvakMa|3SgGE^O*Y+PVVhW%!m4)JCXHyvqbYLwssD72jo|{&%vwzB7dw;{;>%8E zo%FgO-K)|qd3oxD4UlkQCpX1>^0GB{e$8W=VB^=k0&JHPM})36eH|>n6xHA2ymqSs z=z^tjo&8qh;844?knUycCIIhXsg(TI-~ZL${p4kCm*0XaSb#U)L|x}*x?SH>{jHqm z=HTzM*tLkYj`_B`mr8826e9r+v*MaAuMw&qQ!#?@oCTT9xxE*LkO7FqGMg$FsLD9& zO?R)xtA53Mlj!oU6GiNGB*&Fm!J4vD!RVs$>!fYYg*N>*n9Ws> z&#H{tvJVjaE{g0XBUl`jgtFnfiVqJ>>HsZl0$tGL_6RS8=o=)vf+Wy3ryBN4Kad8% z9m8VBW=m+WRmX}p!c-hr-i;JqWAq(p@rDHiXEDd?vSAf-NK&E3q-sHpfJjF@cDmEV z+t3B*TSf$bUl9R~Kmu{~oKgv-ay818K&28Ig}SHcNG6l42~|2aO2<%JAtSm)IeWkh zIqPETpay^|W4NxAyTKz^z^20qc{zd3=!J1rF|P^>r$SOdlYz&UyI?S7fK z@$*sg`41akhejHtVhN$8 zdwyc}FDpj0+FM>&wNKDi*A3@3{v|0G%4%R?S3))%!dJzQqFDHDUWG6|Gjb=OUZ^)b zP(_rW3{Hir{-D$={0|P!C;qvE=UlZ>&+bW$D1;Gog#j9$8(3znlpS$$SLE}`9xVzE zrLzDzd%Q4A!fa55OQjc-)T34XPzfmrDNT@hhik*~HMJ05ZAI6VH zqTXt(_pghX@4_M*JD1R>)Q>U?_Dyf5N8eaN$4e$VUd213gIO;B0|9OdpQR0 zuA^}wl3mAUg#tnh0`kzhWgB?7)l3sjX%cF!qq{moytk~r!j2<|bH!pQ1)nRL;M)C$?bNtq7lm-2mv#V^OZy10XNGGRmUWh6Rtd<1cnGPB`TYi zd2m|OBmEE1k7=Q0MHI_-;EMH}Yca@aqK|mnno`}i=F_otRz?4{V>5!L7|CX|Xz)Wl z;_kM7TppY9KW>bv>KPMkQEO@+W72x#%NrxnC&*XpRxfpu7(t{qQe;ea@T98hV@x9u zT@PbYMOstR^^f(;Acqna-~uK#aVtG=n^y+KA|5$rYJX z1GF0Pg?Zn|m{Zk^u%b0h1djNH|A~lzDU~7Ku$!|$mzbAjOcDv@oiq}H+C2%0Z5as( zvmzY&!rmw&qzK$KlYb5(@*Cb5B_IE^-=XuKZ+g|^jfH2gf3`(dTvvQ_wmo`N;nAP` zga7i^3(tNZm!M8%es|$niDlE1aq?B4H}iM$WiA=?#dbB{RH*r<{?@nlt6$~Ng_bE? z10KD;zv}}AI0y~{;N|38EGex+kU=GR!cs_pf#bGBD#4gz3Gn40#VP`y2)2@&T4v^U zmZ9Hh*-i73#S<2Z_IlqfL1nxyN^bd>$H={p_)+~8P~7k zd7-tl@T9UilCnyYw7e*rb0(xolz5uNN5%=%Efx5o*s&tKC7bak>bj(SQrVn*e#Q+9 z2&X5Tt2bUY*Hyo49-2CJ*<7+SRd15bA-{rb-jul3C!2>RpO9>>O(i|Dc~i1^3a`zw zdGmB-b33A1Qsqfyb2Qyv*&IM@Et{tu-bOYj!+lFe-kYIEnZxyoy~u}{vpY>pLZ6Xb@nInwk{ zHun;75e@@ob1zg9?ZiAYVYDEfv-jCeZkEo2$bJgad9aErj4O!UV>Fgq#j$InAqT&k ztl}m~qb>G|-B`uhdJ&sdoV_Y!V@2%7>LnRHD;%uiGs_C$@>cOBa+Dx;bJES;pnMbE zAj7)Z!lz{mH=8TsvUG7mfO>4^&`$_&h(D#25L&B;Li-aUn8#xHY_WX^H{QNgR_SV0B<0Y?l`>uH>no*Fxv3;I}^u3Do zjZr)OuYygkTX(xKz>!{WMFK5H7Ri30^x}fWxYVcB-fH93cPf{q9hqc8mFr~2acrA1 zmLa>DaeUUBmMxQ@%n)Rg!-74F+=G%fE2&c1NodUn2x55i#xyx52DRQ@HHm3cE0k8( zcV%|+U1|lV&?-RCC*+uHNEV;V?BsPeaHBp_Bml|8#8G8w+~u5x-~xQHxnog>(MpNI zZsR*xH;XjM4`f$QP30KUy{UZlod!Y7(W$Lm0Ey?IE!oQJ&`EbT*vc7;Y~?Mql%lQN z-*2*&&zYGn$m1%prLA121;*Z1PC3kjY=8Ii_)4&l1M6^wOWPyCfDXdVR?Z&uU@Kpd zAg&67t$dcw*0-{i%LbR(%DdEvNp4P(<(!wt`2inu;48@EyJP^{Wy{{KLAG)Z_rvbk zTVBhaeX{1}@Ey??>cl21lhny<<mCy!4v=yaZ0wcdQby}4Lz zds{jAf>U{X?zH6bxl|s9;Gc9`Ikptd9jv^mDPLA$Sy=Eq?!Z>wda`Zh^Ia%pfUR6{ zxFe@*D{nm=wsIo}SlOw{<7P-<9(s8kj`-x*%J;}tUMH`P*~%xi{UW!O_b*Y#D9Opt zV=&*M7^c)<9o{RZu~)1l{g0)ru7%jF<_;2!>+3KLEirq$qz{2v7H#JBg3Y{pdN%W% zL7miQZVc*VHuJ!swzQec-_*Mx`_+b3_jGLM@T(r%xou4fzOARnb`E|;NFdW}=MdJ@ zYdhZ?$ogBtcJ8H5Im%5wH#x>z&p8Gm!K^O%ycMkHdmU-cd03P6ycMkHd(C=2y|wjx zD4!3I&o>@^?8%VNi`72$@_E+!P(H`+HX1 z^0zDQe2ZddNJLl4h~5yFE%wCZAuDd1ZJ{R#abYWqwwn@s6Jqe5Xo!m{B9Jwh(0f8z z4Tz^IqT4>07(LV5L-ECs4>J{36^spg)UiGx zmZdkqB}Ap4dVtGNK;I;w_xQffoPb`e_LOYsXGB2HS|1ANeKz!=fIf^tX9LD6_JQ6c z3!{D&9oo=`HuQlu^ruZg&$xMJ98Y7=dj$0UVnYEv7ts5mGZfH=HuRm_(6u>qD4?&! zC*3Q0rY-0_9>g;!pci~top@9Aj6VOv`ei8w_uh>vP zF9_&;&>0HoLjnDnBcR{;i&1&$%4#?!(Xu3PvaLTit1rFc2=3(&2cvw!KF^C1qLZnm zH_uCBos5W_@4C*$?mWFB2X`}Uxmy_DXQlZN?%z1r8#VjiIh9w?3|F7@<`MW}R`X17|Z~(9+SB%Fv z1uxwRzum8EkP1KQE>rgcXK|IX>{#=be>L8v5EasKSpJ)Mx01h*>D7F1c2mP`8N1$Y zD4in-Uz*zY-{!sb^ash7Zr$$o^%9-W%7R3EGxWhaa$&n72V%|H0gQ`b;LA$Bvdlq@ zWT~k+osg{ayWBKw;o{^NfN6O;$tJsU8l$3F!|4*~;X`*U&wo9!edjBjr%DkL@fw~< zeZrYtrEZ;P%FxSES;~~#Rz`xhr7>x@YD)QCQyyCAP-%KeH**Om?F!n)4rrcH2t*vt&oz zS-Z;K-_vf}r5_WOt$ymh zkafDQ9Ns+lo#y1zxj1JJEbLkQ|*jZTAUes~5i)Ij_*kh`SLsw&3Hl^}5u zXLR}gQob;7XqfQ=B6ZxZg-9c=BBFBwvs7A3MtOq~t+eg*As||G784L6MB8L7B0A8d z5t!wy* zVkx45auLzwVF1wqUh2$pV!#(4FgDGxf0lD<&??|oG!X}-HzJ>-l55v`l50Z)uCgAN zLTaO$CD~qbQzQxrlW@t|dBzpEez$8x;wp@qTg6V)T{nbKkS~g^lH*_Fj(AZ@QyS@r zMJ=ZKsiZlBAP`@pSWB_Sny<0sQyQrnW3Z$ct%Gwu>g3(X(*K8U@YdN|(*IZT^#As@ z!xJjuAQgUMmKs6@pd*_`6~4??QwhtD-nYZe~SPE#5c%IYgi z|8LJM{l8sV`hUB!^#68c>HqD@(*N6)rT;e;!Yy#(V4Wpq7JWCmYk6{jK8h)gIMX-T zKK*~itt1u88-!S>tnG^lv0kFIMJ4{%VaHW*&}1!udfw(eN9YW z@<$)9uZeFJdA+0$f2M*UV`n1hf-^!m>#M*Rz=^W%4`2*6NDao2M#X-6G6pFf#uyOC zPtF*|o-W3~%K8Kt!`L&0F_0_!WQ;-YOHvla6-?MO)}S+;(cO$OkhM|7yb5C+bnrob z#zRHL@?%0+Bm5Z;#>hB@57Emlilw0j68?!yzMB~r!{sE)_o_;MiROqvsZ|xlfl6T- zREBd+wTz>sNxeuj@p>)ISp^GJAUSKm>+o#@20xh!%v!M}7j;>^biCRHZMJXlZOmC) zC{SEoq$egACsL^(;Y`%#)Fp&DOZuoE=*OgHulX!Vs8|Zpy$N4^nom^Jd{o{9Ont(+ zzmo1vE;>ynrixeuz2vX}7Qz8x0cf%l#5E84?jVrs9V0UVsmKED!DiV=N70uN6igm_ABozFppobpoO$U2&Xnp}fUT zV|Y1Pjrn=0oq1I&7_!X7(K7?xX_~U;UALGJG4@$&;stNaf`tlD{l+Y%@{Kojq`RjK zlPnms)Z5IMwP$-{)&gAA_;oO5VZo5wam^GPr6WtRV7XvWdF1blF zXThb-oK^GYtVz$Ko*Hx3DS$Ybvvv+*GiU7_#9NuOx|_^d(o<4%R!v5ZCFALX%~`b` zbC%XUW+m2!vXKGwpPHd$Ny*JwR_}tAi`>d#A3s&*tkzDG-pkr)&+BxU1|<|i4F7Gn+rz=BxqAQolKCv&jq1uIQEGB#1$pnm1_82ZI(3 z4bbMGMQ;(4VPh(lo42xRq1HZAY+9$q$-GSq$av@%PWK5)u2~KSnzb^}pN3gWvQg2j zRpf$Cr&$X-%h0S~=8%aEOro0_$zFlz-{S8mptGPBmM zt<744PR$*fx)hh8*qkTH)RphM`qnaao$|P(@r$yDrY;MOORb4RQd zH8gc$Hry(5YiR2FR*Kvjnz}G$KSLw8hNiAgEkx;_mV$U@BDaR7uA!+*ey?*%Pijc# zzm>?XGiU1R(`W{mx(1XPn!3*4=m*P|5nMx4*PvLZ0U=QX0;jf%%qqkfC)<^K`Xji8 zrmhgH`K=b!m1ipX7Bh8aJF|B@== z*q%{zTMnbT`gUltv^?pX6t@cAXw$fMnSKjzQXHDPhNdpt`15q^UhcPn52L!sH8C`G zg-wcQ(A2eAqZwrC>Mt`ibz$o21Iy6VHQcP2JhP&@21I&&aJoEmW%TO3B=%U3M^^n- z!|tfNJrZkr}!Zo*EBz5f?sN8ZhVmVVPwQ(2(uUG0UjY*7u{LN=$G z=WLI4(`T2WSA0oDjH~I$b1|wG*|?pR*IAeL$r|wOTD|njb?8uQt@Hj`caF_#uJGss zdQ@&EAOE0FiE+o*qU7OO32((xCn%-f&H2PL`kuWbjpXr(Bf>V|s$ap0Xo6Fdy<5DV zb#u!$pb?Tsfa1C3cs{Yr98FT8wb;s_)L&FdO#%W>wQWi-n@PpZQ~R15Bjs1c3Tf}y ztU~@t=ds3(HhG1w*j+TIhUc`)mL1P-wyWm#ITe#{WL}tV(B=dKwHBvE4h`kaXogK? z4JFJFWcg|OLLC*NIcrtz=?xDASAK;G+GWElgBhGhgH6NAqfz$>b~?Iifj7Fj9=Ae* zojRMzCwN4boN-T6+>lfw>_}Rqq23)yqz1|o?5LxyG{H{OwbBGTO=Z?W-swrOL%tgp zeu5PHwPCBVV~m1Zk)!eoDOH1!;6j>5qfj;r)39fjV8^b^8*5jVV8^a3 z!H!*7f*rfE1Umu{-)DiV1dFC(ond=9Mp@;#$h1F{ji7+H5hW>^hvy zxlt9~Z12(7Hu*A|g?t%gu3)pBnEV5gSXx*jj7I<`UQO_{!PfE$+yf>s0TT$f^kb6A z0F-BW-w+qJ3>NC2IIfrg6WiYEYnXwhvzW-)tZ|vDo6ww^NE^`1ndoJm8LPDopna@1 z+J@Cmh}Bx?Vbh%!Z&5`|6v4Ncjl%XiI{58X8}&=tBc72==!ex31~LjbU?4SSsTK&q zsE3D4Y~mpk84sx{eFjUgP|ngMl*0;rLM2i2)+os`{Ck`)RGFUxjXQ+8AC50*PI2kl9KOYX45ry+v{X(xPA3W_W&n~C~E_P*OpuB33t zlG-{>*0OFx86;|CkeE@8FO>|*I@xXO=jB~n6m|JPM6X8Oh_d>PD%%-6whpCpCoykg zJ&BHryNpXjJQ_A2O|Xmf5{zmfB}j34|D5x=8x5ZW_;yyTaUc&Eu>LB{y=Yyep|N z{YWLlFyh$(17R4nJ$ATVW|9e^t>bY?@;T@|vfS-}Glb?zSJn@kMkG;9bH|#%ih|Ik z27ueBYaiCmYNbR{Rs@#zS6M!aX)a;6MpyYaz?Tw~FSjLFgRJ|!LJ_$bJtHpp#GJ~3>C#>BwPaMX1ycT6*Q5}X7YTWM z&H~<()KL|w-U%hR9l>6qmc(Z3VY_Y#fI|0cu5398kS#6uZRg^41uo3O-@Je;5#yxM zLVz&MA^4V>$tQo&%i9nCU6j1xXUoA_3TSE2ur>S6@kzy^=XGD(2-q9)1^46oXOdX7_oQ?b$JiG2Q9&sPepD{u|ab1{g1JveZz_XL_VbLBSQQn|$4LSJrzIL_{gL}T$BHmv`FT0aK?Iqx>SxLbCpXDuYEBu~v z2LiuEU`^#-^5mJQ8E+c=AXbY>T2^a`ypzZnChMBWJMBf@mKS-k_IZ)FZL-;TkI36j zWwREi+%fPcEb=x_UF0>}!|95=?X5*#5?~fY-nJKcQQ)yYNZ9H~@AO)BLX1uhd zv_W?!J+T;xTttQP_%-||Yq(mhUg~UkQ6%j`rVw!nJ zkkxR2G^`?i%>-HWfaU9|d|{PR1jUvx=;cl+9S~A{gi}g~ik#djrQBa%0o zg(}d%5xIorr{IWem{GwfAGwAb0n&GY_UI|ZG7nJA5!s}1jEb2fa!F>h1=^fD1%IKc z=<^qX&D>vzvr6otf^n~lX?&Bdzu}fMf1wyh<}bvMp85+L+xQE~b-bxY(%7oT;4f4) zW>mvpC|ecX=;YnV{Dq+#ymj`r*I#IFGk;-2{zC8u?g47iUkHwJe__M>3n$e4wu5KX z6W(8_fj$YngwVXdPzj|Sf*aV7iMqKancWar@E0-&s742JG>o@U7OLs-7fz)9!a~{1 zUue(FUuak6FSIN37uuEi3+>AMg?45BLQw})8T^G!I6Qri6Gn9?{ zx=#;u% ziQOb{*D#6Q)GCwMB}DT@uf)D2U5mJ$jO}OV8q!$dTtj90zdT-+wzX{9Ryfzta=LS} zrX+Se$Y!=tJ9&9|mhBTn6)&;Zy{fe!o}Zr6he#{&Fr3}QCnmAiopPr4`0gZ=28rD_ zDq$VyUFI4EiM;{CB-jf{8fiR4Bi7SVmd`8dVsizFJ?LWDqiuDutP~P^s*8DZ@RYYCLS1tq=Q3sWP-fA(nGkdgcY-d)= zVmqaF;{E5xqpccmM%#~~YO#qTplwcM)l?@#+>Z4NQ9`osB2?^^tHo5gTJ*{lZ-i|X zSVXyM0F8ojwJ7DvsGWKX%9Xy#l`GCblCf)n#uq4-MtL@*TrHlWas>_cD_09evzXYOvQkpn#o%GJPN%&Z%kauvE^%9Y;sDp&S4Q?8n) z6pWcGS6QpsQIEb=Mje!^-eAnE{OR^GQ?9tExP?r)B2HAwl@M4^t|$|fD>K}1yR~vv zD4Qu)_Uw!VV=kN#<*Koza&?A-F&8!~SBt&MRk-a{t`<*OxxxfttYS;Mn2%*IC|8OZ z#IE4&iV*iEyI5Xc#w;^~noYCUH1DPq%WFV>DBnw#8^xs({gXLQl_%@TQ?5W=*f^J| zO`vY;jdNKkP=~W;s9a%m_B-8%$`#xF!cMoLa#g}xCe`bdce)Lgt3jTtp>kE~4wb9O z_A$J%;NuyfnGDchw%f5*+}ZYTY`5E6C(Emu=c>9|!e*2Q_hO?Vq-Vs-;r)O8<_p{E zw##p+iDY1oWV9-O%2-vBEAm zY@W6auB~lw4Yt7@Wb2dP-llMkh^=&CXB&2ivwF9o9Sqyq6ogBVFsI_lS~Nz3gx^+< zg7B&>g?j>#ZG?CB2MTgt$5$#&;h{Q)x9}l4x zQ7?=FR0E(CcFcL()F=!bEZ-Rg@W+#wqJaj9C*mn^*;!Lb?vqI6bT)T;UGH6U-L(tZ zDdK6OP^S56Mq#t;Tow@lSdb9o)bPWsX$ueb$cwOB&n9JplR%N}k)5S|)ZjTnSSUo_ z{PDLT>cu_*Z|9d@z;URqPQVh|&@iBnVFmL?ZPziStGnGr8lB@%oSDM_X#up-?N+?( zmX5@`_`4SG=IJtI>vk>2E0?fYc%CF|zJo%~99`zr+g_;b@%?vdt_$7F%K7CyXqIx& z)Yjdi9@eR`zV2#(BNjMTG`hX~V481hp1IlXD!==b)WQD;OqVd}Qum14r+-SoA+!Fn z486N9Xk+*%%f(u}U%QEM4RLVnZZ6|-O~mo84rA62FUAj+@RRZ9^7w%IdBB`>HKLRO zO$dn$r!}`PAyQd;4-4frneCG`H%@py^(KG!v6Au9&wMFLe*adBSWZ6jF(1YJ#rzp< z*W6z9*Fq=LgNj4wWbvS4;0`*?nb&hru^MbLu9`;1QPd5$!bVh`N$xxfG(i35_9I7Q z;I;@5Rpwk%bE+x2iCmQ|A6=)o?5;iM1KtP~wQd*s*(X1W73vCZ9vWT88xCV$1zYhd z^yNvh>0&_4MC>Z13oZGdSuqhP)?R5o;SuU+hH6rQqW$!`l@k7{2xrAQ&dzwM6A{P* zWKs2wpOi9075v)`stnyrKx3c&K@SIlPms|l`1t_v5%L=#iK_VFMIpX*T*w~}$S=mj z=E&C&ODXbIUdXpk*5JWbFLlCC3jbJq; z5&{K9B*cKNibz&+BAN0;vJX;N@kBzQ6(f@FZks*vs&FBP8s#V7o;uN0o$e1{i^K9x_{8t2z5KhuQBq!iv>+c>4Cqv{0OiHF7Xdju%?IY8tWFMJv)99wl@vIb#jt|yE$&-C#UK@pFrYhP; zh(IjZN9JTfV544cADKnpKtZuxL4Ed-`J#OU!w8!lhzT_N$P$gtV-J~?eMBcU^RgB1 za?3~J-OCt8;uW6ml6_?Na=b_O5zHl_gTl)^U0&X7A923_U8%V-aJ7`3T>-I4;Ye-B zbcB6mNe_tvPVFOm1&%!$-6}t+7K|ZCTJZiJ`-m(d)IEX%$iLJ+VkbT9&g~-ya{I{2 zN$n#ja42azw~wg2G*SEHiP=Y1ccMxI_igMWEA$|>kL*e9BOV2redNF<`-r!LK=9B_ zu#a@5`o_8HYm`~*#;CsgGy6zfu#d=cf+D_8s_(vnePpj!ePgfl1~W;>MLKUlHeC;Ld62qCkNV3(79WRE8jX15lW!bbc91^dW>Z*TiZ znjk_V$lH8^h{=+}-2zi4mvd6;++Aya0n=%<6@o5Y2ZHO3AJEQpq|ZRuwF`S7WI5 zelVrOrW3d5#YBRIkq-}+e>&;N>Fc zotq{ZbOKLXKb}Nx2KR{IWz}87Jyt+|+HxATlMS`b6zL>)EUv{fa1(2Zj$BJoK5xT# zRZV-DhSt=svU1Nr5eN_9S7}46qK$)UoGu^dor*^MH^%p!E7p(mqn)kGaXae@^|$E? zKUH<5nyjiPbmZFcv?B~#P`N%G_9^$rJcO^&{!$9f6CB&>=^MS`$cLo-mjgwVYOP@gy7d&Mz-@XL!gLFM@z7 z-Ks|x&^(|qPBozeKYN*B|l9o&G>Xux`-$GS|ku1 ziy>9YOt~qQnNpc4D>J1sc;^@e{wK;30!Sj@l20RI||pg6|Qe7T;Ei5K7>oOGhEXMO`a%0W?ZzcxHQ>wIh+S~T!XftDB~!qkNS~DJT1BQ z6=DlUMxq^m8 ze=vck&y+yLIR&MZMB}Q={*XS^!FBapr_cIr#Z&g%i6`xMCT6|j`9eHvzq{f&`*rcW z{jQR1UGERZi}w5Mc*%aB8{;VE`MEI)5x?IR@3!CXiC66Rym*iOet+!j_eF8neqR#D z_WJ|zUi3*=Xtj8 zzBAl^r>#g;_uO#*+(YH7nQ`tp;r=;?%9?@hJHq{U94f;_-8td*oI_K6!Eg)Hc{#TS!tH@W<(F~0Kiuv=RDLP9 z`@-$MLuDp74n9w+tB1-z%$h-kMJT%B)xipzRKUA6vghoYu%x^6|2p{4y*?{oL(;?(skO!n-Gu z4H&@~EIKfPnUv`(9z`juwaA$Gnlk;Fly)RLpjtyd$+;JTuCUw;D5p1C0>a|pYY2TWRI#W1hmG?HjT2-Z$`UUmG*Nx3-fQD6o6j8DPsUHv3`n z_#P~1kMB9W++9^NgX4)@FRxl7LjWoJ4`Z++UdZeI_x|IIjdCxe<20|8gwtO1`oiUS zm&~)(5f`v;6tDpj zUQRHm6}7^q<|NN^lb5b{t1?4PCimVuBlAobn`T~z6k^#=j1IVYyU1Mxbulmk? zt9_~3yK2|?EF-SC_)!o zjVav+FXgfu(|0RhAY{k~hV+(nZ>HZF)%hcc_iAFN-8RJFj)f$XH+OpQ4lN}{_Df6` zPf?6-`6CKK`6CKO`Qx89Dj$En`tge@KOU4m3C5!{TkM;3%K(X6iHcd=Vu_)c*sXYJsY#R`88A>AHHiP%I3w_tH(!ghXP>Fr2?xSNXt=|)Qc_Kzh-^BQ zD4L>wi>x+SJfSF>K7x9ugL~5-dOr*BdAujw7{p(?%apWR6D{dG`MOw473{dv`mUyX zMYxPyY)B!ZrW?}_p>@*srU+v+{pMeF!q_yz_$oT@tvGV}9nD0+oE=+_krVPLU=O1- ziI9oohS?Cfa)z>u9n0*?eG`^t?fJzq?Cvh`4faND7I?$j-kLL1n1I$M2X76TYvzXHr3RZ(yzfr3*JP! zPr*)vfP*OD&l6V#O%lbUR*sD{jyPiacty+&oOWpie%`F&n`sdO~vr*0shX^klxvSQm0_9U?QVPm|6N`7qZE zm(kL>6#sur0mi=p9;|hBhQjt9J1MX`#k$fPmOoS|IM}s3!&~z2@zW4*0xuoP+;m|J zpgS}JoNXgtw;}em;%IU6%b0Wk$8;tfXYKUo&mXZgX{_o-ye-7tVA%e zyahBam`f!P!MCmJ5Q-!dSgTvYrnIk#>(gruO2)LB*vyAZD{FCgZ8}+O1dH_7Zch@e z*dUCEOtwj9XC|62I*MSxG}L69gb=>l<8K|pGGDaK__`!WbqnRH{iU7+CXByY-s^%r=(Pc+fZNfg_hxOyXOEr0mY+Wd02KHB06NGIeeJuMefT#*AmAe*s(_@+ z98Bja7^682!PenDVmQcvVp6p2$1F!=hb~)8#4~H}q~&6Z!KwHT5wK(phziAwG7->W zgV~LpTm(QuJ7LM#fvj-~rD9VT{G8T6xJpkj-Yz}`s3OJ)cA~sYH-xwFEDDFwaljhO z&eJJGC{$qrzL29O0lK8br!D4NmynT^K7YI_++QrPlP{{;-93 zGeZ=2jr9FD6pSA~BIiuy>xAV9F-cMaONn2siB8s7LpDE@g8qvT+vCf0FC4PId}0Uj zTs0RJAt{o;Tw(&CWI7U+vovuiM6vkQI?TbGn5nHsL&2N;h`&7gh{!Qt-x@Y`fpY-Sc1ke2sr-ngf-TRT!t^a%M z%C{HaDfZ?pnc$tD)-~+fsd&D&ujUS^VR9W!mia(@0K+jO?9+WFTdDv#Ntr^VgUkZt zffW0F69xr$6br5h17Mx1Fc{^+039Tn66jFtE)3SH!a!<*OO9?X_9Tu(2OGICklZW_ z18HZ4Fla?#&L9dYh9M517Z?@H^DEqes~=46 zh%h#%?|i`os$8Tan(W9*6OWA`BOXglo&AKT^Ri!Cm;Tzm;Mb0TN0HDwQE`m>h{Wf5 zBKjCgZO00 zo7~ZV<+7|K$5wskjw`(!O@o!7N8pp=oup!sqkSBX#CErzfUsr4L95&R$46!R+X|nT zrx6?(g^=F85pciL7&@B5j70A=zO5HzsuxY(fX<5+wRfs5ZhB2;H3Jon2uE?p>JyDI z-LNgAEfsGXc{gY>*sr$X?o@u2Mo1$9&B@UoC1lH@G3ob_*Gk@&5$#h=hqJyC2C56r z(~<7KbS7wOlxI&Sf|?K%@JjU86>0N1 zLj;Qx@+hAWmqdK=+u)OTLvblo5Rxa%PQzVzL<{iuKUvC?-R{b&B&w|z}( z`b+LFsY#-J-BQHwi9Pvlw5OPFuI8&O4@0?{aHgmJAEoRM*>&Gv`mV;AligZUac83M zexbMWU*FdH?>@7l?;2C!LX?gBi^79TU-l331(P%dlTE-*5j#iexz89pJd=WwWWq0E z@IH%U@aiM*j4TjQJxDB43b5ycMc}E;R}g`>VG5bMztPu;z+1NnJoAAQ3|fuA+gL>4 zeW5~c-uyKlMhJ(<-V#)kz5U$c?VaLnDBgmtWY?mWWpB|tv$xlez$-DDx(Ga5UMNGF z3@d#<5qQ~JL!;M^z}v_}De|};J$u6<@WzJL#;6?vfczJQU(`kISp*(ASFka5!j8t^ zO%hks0Ph0jGE~H)24e)?cBD@!CwNK)lU^Nx=aF~A7 zG4k$j$H=?4$H==ci;;KF#mKuakCAuph>>?+5hL&J#mKv_ijjBkjDdGAWr24@;CbL3 z5qST-0SrXoeV!n`x}XO|;9+-|*Z=ck1YRj34->Lej>xkJyi!EoOZxqD;{8PAVF{LF zD8MH}DIgEqvK)~26?`lORn}0`k6$kEMXTxAUVw{-h?u9V9-&pQy1fF6QTH_Bzr_M#-0B8ObooC^1#}=WNK4=VF zm=-Z`98d=xRty~S-DBY7)gdCzL*WuUV;&0kL}({Vc%5&;fJ>op^a;<do~bmh+d(2``LcVv493v!qtIhZ2^na3L=_-xEcYr zdthjJ+X34!lK^p&&BVB7thZ5nL+Ao$wnSokqueCg%nNNpmSD%PdD0Vr-j2i`-u=cQ(F9oK;#wBHNA$;6nv64>-fO$hNHAkZ2=a8R16BdD+%; zk!{4jI61UD1nxMDS#4Zj_lQ>EzwH;%+0HQ^AkUe&H$}3o%T>huE2!?RL=_b=Z(Rt7 zKs13(_iWC?`il^xzSYdlJw-7p9R&o`L>2tW_ql`M$au9xq2HiXb_j z>O^9FeBQ>xs?rsnznwD{Z2wXuo&4QumkyRA>2^etMI;^70{l@#HWoy=9iPWm&=SY+ zVTIXgD)rFkQ*yXOh9=B`>VNaWaZIQ^+hXh#9;`m`T^3`vPHY$-i|3Bxb18Ce>&27C z&$D1WNf*vV-_Zci(5l4fJF@xWVw#J-gKh^J*=R^Z5O54hN@23%M&Ub~n;jyMZ2Aq%+J&I2xh zGb;fX;sW~7P$Gt3iN4ceQ98;lv_qzsMBh17n(SQ`eW#}Q3pv2)3*3eQxMR^GsU z#g=;njNkz?=_v6|ZA1@RVK!BFTmn-;cX3b62+NFt5_Aj0%61lu4)cn%1w|t)S?7|{ zP>R2+(HQ3A@5t(__&Wvco2)6~@3!HOJsyFpe;eCuk6P6Xq9*=sl8|UQ%*NksOEX|~ zaRt(8Be6bIJ_aSh0e%DQgcrryVRmL)Jfn%JV(x5z=KKaGDT$V;5K2K|n~mVPwDTfM zt(*>um6u0cG{&8kD7@lUYuJMDnBy!UL4mYJZX7v}aoDUajeHf`yx4>pvoTKiT_`eH zFNgz}lQ6p7OnHUxA!oKKa>ivpnuj0qQ#t&w=GRjAVa>0l@WaZlG5l~t;fEU* zk`+U)s=aZ?-s={A*ps}!@9@JNg&%@`XVP9Lx=c&h$fdo?a>~a$K=2Fh_t=(t%;reS6ez^Tm!VfvF z)R2y(@I#DT4?kq1Tr>P|qZ)p=gjS>Q!=>a{C!1vZhk;`#4#*1M@Zi9uMR1^Hmbm}m zz<<_iwqqvXB~?&@NMqD9AHbHgV7DUXRK_SAZ0Pj~6t@cW%@^pJz0lRi&UApCW_&2L zUjRI~Z+7IUBkC5YVVzxz|a?f3tnIsN0$5tvjwg_-)Wg$1UZa_3oJjs5%d zWc*9Lm2W+1-FkQHU22FPFeK*9=PT`jenxY=@t&7H&V`^qtx_ClbH^lPDc}R5Ar?dj`@Bq@YQ&dpV8pq(_i$y z4#EJ{kd1{R1O6a`QJD)ty*MYmqldK=_3B29YJ2g5YvB&?8mZ&@W+dx4id z%*_>!L+hHiCmg-kY5oIV&^8Zw;mqXGG_Xv`F^Cnf-=DluvC3x&Je+w;5rxGhUvRWvE_W`SwKUieLWo z-}+ZItyjN25#VE&|K5kc^{3`9pZWI0L4-y#OILmTqPl&jk>{`GixXNzt2j$edF5q^ zsqD#B6Cnfih-ES<+{BXuta~eLB)3C64BZ9{O8R#Fa@d5#Zk?xF&!l%I$rHAxt#Zz? za5g))^aSQ2&raT;Zgtg*=H28C3bwXqL4nYw4xQS~x*&Zryg_?gchZkNCFv#XgqNu( zzRU8ysiCcJuWv~QljMX8$lrZi6s<9y)zPM+7yDsmv~Va9C#&2i zN0vDzx+>?i8BVpXr;)60i>z<^%s?TkNwgHY+=VBJ1LDJ_m6hoa{DO1hpa1>l^c#N8 zII%CM;~6p|jFj}ev=2R@^|sHFC#N0AMg)}JCLC%n^d~8WnVL*~gBLc40>{@q6BoQN)(9Pwd+5bE=@RTlj;wJ|T01)bZ+^F1IVKyji%-O5asw zFQ(XXey`F)hKlKa#+5R{*cGehB;``u>VCb}%WgRf{qtm%b+s9If|-%h+Wj1^?(mz;x``Sx7(-st*e zgJ;yY{eYMT`YQC24ShhryQ0@d7>G(5vd}n@f7=#_UiV%|yHFN0#2}#V(g86O%-Rxg zkgnkxw+jm`zgBlO{eT$n;sG(<#RFoziwDGb7Y~T>E*=o$UHO2R=p&`4Y$p0{bcd=Z za)3U{rd1!+`SJr|jX=IiX^?$cXscp7Z0cuqUYUi2%XBLZF4JHEDi^*=IRv= zaBwqxt`Ot1_f>urF>`}ogQ~%-K)g3G1GW&dD1RFSW#B_ZsiOoYi~jDrGEn$hI*Lis zCGKZ6Xx7xyxAL2bj}z@!$&o=6P_D==Q3y1gAg8GO$tp`u-4+Ew1X^X?WjA>F#uJ*o zo0{m}GC9?)aurG%<@gDHwdZPW6T2=PIiVFnm{;lL{7ce9;PsBNj?o` zq{$$cPaRc6pt_~DABj}NPK=X~gonnkB&(c6XICR9DLQGK1S#p9q%St-oTT6aCH=io zCHQW%?&i!sGYceQU>BABERr+X^X8YTdsRf`Kg{eyrgS3Z2RxVT^iR7=_(O$CIDLRaqF?7lC;wsTRA{e8IR!&!64v=qXBiqg zC;aQ*2`zAElVcCN_o*@Uo702Zpg+LC@jVGc<`gx?Ir06;iQWjEQQ}5mnf=h7gJt$tJFR9zuuPi`m)32SOd~?tu$Czds@Y~iMg=y!*r2w)fg3q zwXcQObsVvOT1BZKmmZxCH~(gK5$l&-L{6Be(<3-f(O5%`iQLGQ_m!b7%r0q@VxJ*1 z_$D)7ny75t@;QOL0Y}Ecp@ZiSInYCnCuF=%hj~w!A$oR<@M-G}$qcz=jOuVSNkceB z+7J1_AJRUNv>%3pX9*A09bDW}RsfCa&Aab?-`&)baUGhFJRA;WmR5x%^+cEv-QYq} z*Gov+E#%@pPY#Dj85J2$6D>1Es8jTIXkC3emIjj0rz3UH`V`csqtI2*i|*iJ`Xu-& zB>XqirLMZ95p!jZ(gv`aN~Yr-?U5P}7lhiTYv}Ow*B&2;ITO zbm>Ts&|KY3EoADzX6XPtrkEwkWDGrKiBvzj-e*bIYrESmU2R9&CWsPy=LwyzzWiOjlQ`9m>2hM<%)o3~;V7hZ@>kjeA5_H(@eM z8Pw1g#vs|4Lk-6Y2EV+;C5IZ+3|qA=l%Ne!bJIAv$!F_E4mGsB8~hsV*DBOtzvfVb z+DZ|ZC8z=UUWOXzo_MUJKBsJxqszO>s1NF(1~9~#UdG9ay_92{Nhtv$Ol9872#6fH z!m^!cf3faZ%%Tgia0~Cms4|?P4Ye^n7vT(T_Dh%w+*D`=*9}QzcE%-y zqKaQdi_URWu`;gH=+Q#N?7IAiMTfb8Ac3C~Scp=4I7xuACHZT?Z~*$eBgp? zJ8;M)lTd__YYc5;gp*iW4~`Vw0k2EiOcxNnfhO075 zN>EwLTqA_baSAcl2;o|z=P9*0jIZ_#!Zp5%Dq%gY^3}-D^7xp@(71V+h_4O{zB;V% zRrqLyul6%$CFO$O@)q$SiBk_VzB-h?@+$CEp-|1 z$%2p=au|xc8e{GAg6bRDDsKJcNDMS{RsG6;Y);?ruCzy)sjAz?{+}8xO*1T`l-r86 z?SybmZIXiqXq&a# z1l{Lqr7P6BUTUS?QlnNLm9^s|sl{rl(2k>8c_g;j;lB(5%+$(5!YeQlMcXoNv7V%P zi_c=P^^9YRzqU{|%z4pPLqqY`A@AObqssX!lg#zf1>vY>zdLK@8=B`U!zQq=%7QNQ z6xKkOCg>p3*?!Z(xDH2|pkp0!L3f~aKyxydTM=|J>CAp|L07V$YN6O-9m@7oZm1yW z9*%mihRjs7b-;S}1rRDshY?!Yl$w7M7EydwunQ|EkCJ977kWCw<1-%D#${g@c@SP9A0K;}NBBr4^Zw|ulX;CgnO8VYOo_#4Y=32R!L~~-SQQF@iNN`# zXmILFW+%s*iDhYk6apS@0Y6e{2PFYE1131yX3Jq7TV4yPB%YO^VtxqOiEi4W zlg4d8YMt8{^zGcH*#4o|{OZ!YBgg_VvY)EkS4a14AiAr%KP`wN-ZirqMPs%FvH%Gj zL2Ln=5A8Xq46p6bd0Cxz#D4>NGCm32!8c{8iFY<}J3MUk>AK#}0bE;5fzF5)M{gT- zym(}d53|m%$q1V6(;WY#g@K9vZXg*7A-JzU{t7c3nw?CFBUPwh-lC`0!n~7|9Ph_9? z6O}$;g$(^r;bihB;)7JEJ0aw`AGR}9z#%2#2v#w|e`dl_GCwdb8z)0!)&p?}=X{gy zE4*bAopL=wKzI1tIJcLb^RPiY{VtE2m=Di3+hVWinK50C(2}|I#5Gb;1Y!=-;s{?@8E~%++0XL)fRWaF}yQXOGkuu<%Sh!P@6R zfMVjPE4p4i$T%utYVJzeKew_3bb<3Ok)!U2qpn1b%1IkcYw*p%6qcqhe+%WI2#+iAr@hs7yU|42tGOZ949~{D z+M~3ccu(=wujwm7e1GYuJzn6)|ExLv#CAOCk>B`#a+OWY)cp0jzpa?6m)D=s#(`|f zlDlF)S`b}0jJL{V1k6k3;*cJulsDrOjyMa*mp?8!Fha9{I1YH4ySR@T3`vVjpwr2O zc6oaP**=-16G#pn!g9m-QcJtidMmD3l|7Pu7H}sJVaH_iWG2gFn)#r~+K~<3!@#HN z5ktECp9IoH9;zLWgN+_4jg%>Y#tcN=L53+M8z!)6C-jNv4YPm6umc+n$WvGuABA-i z8kjq$G}Ds|M5X^3h`J*5l%eSbJ;~!>V=O>m4_8~HD3e;8IEbodp!*d$r{r-(AsrXp z$PLQa4So&wD{h~5;r6j#$9y9Xm$k*pC{6_mYN*#FsppeXM;@k2l(=RFG@PzqHhAuj z&M6J_Rp=!fXqA5Nz%saZsQqSDg}h-&1(vX(*A ztNl}`oYD+X^@O1AD+E@qseN&B5~-AqD-tZ1X+-T@Z8MFCC3lTTbeobS0x3lmaaYgo zzz3v#Mp>G(fzZ}K!swaNm`UvtRHMze&Q~b^V$U(E1SZUsnRL{qMT+UAQE~eI%#`={3N~y#BO~L?0YZ?eL+%1YG);e>xz?n++rdhZhx<90_?N>#2T1A zttx5lBt|+g3MLofVtfJlp{eFuGY?Sk35A!QZ)dRMVOL1xeC7XMY3-oyn{JV**V85G zeofc!amg;}-2qRiMi|-!<5b=y-cCPY!H4(AM+VE`Jk)s@=#c82*6xJ#gEA7}ZoKrd zVHzszs{k~Pzw;qRGOpf3#3Y012QfzpEsTdm*L2f!p2b6NKh~skKv~*{_$uxOL`|QW z;FAmw0`HnHh`WyYJb1w@y|tity0QVeAEW;i?q}w&pA}GWvd2nyh^d1KR~ljBrGwP9 z(~s>Cu&m~|jh2|2yaPI1bHTku9|&+}Xz&OkyOuIt!N)o?o@;jnfgDEnWHKty?_k=N zSIbs=Ei~&p#87ztGS8nXIH4IKj$}>q-PH4ermiy#j{esULk($$ zD9}o|+8bJP^=JB@Kj4S&fA|y4>2H2*JQez&4-=K>VWuk(Qpgr~3Zg(8!{pLVZNOp~ z_E~6YLir?GMPXAkrvQ$0ptOc!AzQ|W;>KcZNcI7e`=yr{XfuGsOy3jFjs8?Ig6TK? zwi}v1SNiVP{;7ZWiBC7Dzx>UXouGxTXzYT%+8)0q7*x;tMFUz(RSf$~V*UAPj|XJ^ zbM4#*>z}*#!C3!XbJea~gZ0n0uweZXG7Hu(`L$sEj~MI!%Wo=J|37)}1F`=9u+qFi z_8KHdq4P`RzKV>08c^y{33JtdwXFKDnd*;wL1|%#mX^l9?j5{R;~!)iKb5dU&ozEL z43Kc<{-NxQ&h{t`h~zd0IbG47QT8kMOT(UTqRL^xW}=>-KURAF{B6aPFIDmHy8~kJ ztM?RgnQ8ZfsAOZ7(+%>_{otSf&ZqzWJ5+gxDVXE$YZcXg(^Y$Aw??&>o8OfAvTDEM zs=cg!RC{v9CxZ)B`$4AKQ|-P`?YZ?b)m~}L!{}nw9{i3aQ$IlY_itBd>A#oan>7$saAsgYSLx?Wwh zTTHLt&9q?>HeXAx-@8B|Mz7zMUOfuH&udacmFQ=cPw6P?^^|CmPN(nftDr%It=W;( z>h%V8T|AOeNv}62_*Le~MS8s&(hSMVw}P>Am0tfq56kp=JHTD9*8}X9^m>Z~AvL)4 zdJn&oUa!r%J+IgI3cY@CAA0?Vzq4TOFMrzuG50?^Y#l#J9$Xf42Ufz`%8?sS((X=) zV=)gdtF0BE@!+cH!34r~4=%PgaLR#vxQDq9SBDo59R234qu)2+aPGr37pu_kL!sXs zm^}3S1==IRL^+|yfk*jpak`nLnHc(=A7(s+8S)21u)~ZvMYWA|m)#Hq|He~#r9)(g z&JYen!t_cHBGOh2!JNtmw(VvPkxg`P(9Gi^aP~lkeik@;APZlu@nYCE*NGu8{x|6| z{>uV>)s`5-G2``k*=6-uqtC`U_L1247Po98S+<_d$1PV!Vho`)l9{+=o}S0cnh*D? zVHo;dKa5hmEN)Qq<=&6?)+0wk?w7@TE6>FAO7E>EmYG1A#rub+S z10aZ2UR;DTpC%->gKB6Jtd>;+JP|b$&Vclep$cIlu+2RAP&~Qv%5+X#NuIn{5cFP&z5gbW1VqXa-QTiE`WUih_>}4OxiHIF% zk%+wR_3#if!oX@wD5pcB@_W z!LwLhKOk0(ZFp$CgcKFquv-(`&~?(Yv$wnKb_mNN4I1;Y4MOD8T^It8@9PoUVB~;0 zT8>A!kJyHuVjI}Z9@}srrvJ)f8+JXm0p4Yyr*p9l$M_97N);-x4aa;jVcX}i4G26k z{t^*`Yn~~;AhsdX?nSsw-hIV3@bs#{d!?}rYDhDLRtE>(6|XEuJlDoH95_e4I=0~yvaa%#gPf^$+`P2d z2I>K64_q_0q3EQ=Hc$%LV;jV7Q`-ZGupnYz#5P!}sB(U)>&7-H+)1oKu?>)ic@@P9 z(A*nHmP^7Ie)Xi4ENtF|&AYI9gDj;O#QchFUQ!hiDq^51tz8(uESonPy5ysPmtz0& zMhbk@*2P+pB7SJ*Nyltmi!fg221Nf+j_K^X=s)IrY+bz^&)T{QIJB@v&P6?)Vx=E} z)8Qjp%j^za9;b1JnbghZlWci9bQ=7y9O@1{2; z`fr-(KXO|)T8Q?b1;yup&3FDGUjQ`s-t-Tc=n*}8ydCRa%ha+R$sz%H|OkKNYIzhWm?^{ra;C%+0?*Ns8V zimY8(wr=enxwYGQo-P*F?mos0NCRhbIJ$4R2IzwYAMI)`WN7h1m^~9$A$x;(j&rh) z5YM4QJbF2tCHtJWA4fd%7?2~9z3?%p;E=}=&U73#K}w=BBjA}gAs%5m8N`!1#3RcY zk{3E<3oA07gLopIX$YL!=Rpit#9|PSNB_=1JjXenxf0Sy_J^XE3>!Jrtf)0!ViaTQ z8t-#B=CmpMM3}YXR#ap8P7vo`W9r z=4o7Otc{U;Cq14a`7a0H;ou15ehj%Es&6amq(z`=8CfO(Z!M(9uG@(lWsVl(hf&)> z6F*j^$|g|1hzTY>1L^3n6b#CWnqLRfQ6Kg*NQWaoega4Rx%l5@kd9n9eUUhJ$&en> z^Yau4#2_8z{Aux3>A1?I6j^->s;*ieE8$iJ(%CH_o!ttgqr5#e$5n1&iq{FYXkWM-O!6nC4jxFVoAf5cFrL#JEDyx572kGS3 zKWH!6TY_{5=GOrV4jaVdDjejI9Ml5pxJu0Va}lKDzCD9qy?qvW3#Ksx)FX@|3rj^fP^fu&y$NQdqq;EF?+M-p(CK|1qpE_v#t z!McE(J+9(zE*PH_s4Ap$bWKPHnJLY@Gb`XKkd76|GU#Rj=~S5NJfxE`)mInNIYizq zAf1|&tqn5*tHFiPhZezYp8eURhi z3rOd``f>IvilIH^j47`^r1M9+tvh*?PUjTAz-9mP!y=ZCWZLjNBpq^7a6IrJ?J0W% zN6C~GA4+QB03vpfpN4W{WvNP%fxddqGmyO9+=Du_&tZP^P!Cipjo4wX_ar2sxpowB zq%0%@vXH3!yeAnM;7MqL;>7$SWERBdQBDRz)ol5OQymhdv*flAFuzQ%MlVd;`axNB zI3Z{?w`iA;h@PCA97rUaH!d%w59rP238^%z651CwYgrtv4VtFV@CE(TX+-)*Q{F!g zhSm44MLHD%CCo>`EPk-5l(h}zj3n%G$`KS&%8=(VG|3st`Y=4^(KEZ;OO!7N*G9Du zaaQ9*t?n${zhg7Xwr%f-Z$7emkGDfDObNx<6T=Hd+W(I#2 zjZIS3Mj@GF%3&>vs;SgC)5;R0+hOd3i7vvjTo)XzvVPcPCA$oI zn}S}ODtWX6QSl==I?3OX_9n^#y~nqt?A%vMAdaZKjlxYgNZR95B=VpNAfD%$RXOk( zv|xZEme)$Q9{N;S5+Gli{<-DSWCc|eFZ5Xs^U#xz=PU{4*G&>$a15uA%?W1{PkFtW z9VBHv$nMh+ZwM;d&L6=#BbD?bqmFcXM#5n{rNvVD@WInoTklpFd8VtB`tBo&rz?Kx zcG4Gu#tV(zR)~Y*7Vf5Z6c2Mp?i}6KC%?3|pJtM!l@q8R2uUEs9FmfD*C1C)i1l{EZjOzZo7d?vH0kmQs9Nq|4tNc!1G?7Z7m!!XBh{V;4e6d1p~5}q(7%WAM*%0DFfNp2}j;?o~#SnTR=von9< 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�W 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

+^0EP{6R8<1*c6NFAYAb+uMxD;Nd_ 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%0AZE?%m2DC)qB{}U?XsKx0 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

2%t>x2-s)G}-izb5V1h2hsS`?V$fT5i8) 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%0A_aS_GAa#np0O5 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

YGn$btOQ+=^VR7Q`8r4`YAPIp5-XenGA#uL$3s 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%0D3zFf-v3;n_Q5w1nQee+j| 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 UZNhDjHLrJB$8!LTtUfpPA7L}P=l}o! literal 0 HcmV?d00001

jEMGaL@JgZq(0Od=?qU_ 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