daikan-international/public/sdk/4.10.7/images/loaders/KTX2Loader/basis/basis_transcoder.js

var BASIS = (function () {
    var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined
    if (typeof __filename !== 'undefined') _scriptDir = _scriptDir || __filename
    return function (BASIS) {
        BASIS = BASIS || {}

        var Module = typeof BASIS !== 'undefined' ? BASIS : {}
        var readyPromiseResolve, readyPromiseReject
        Module['ready'] = new Promise(function (resolve, reject) {
            readyPromiseResolve = resolve
            readyPromiseReject = reject
        })
        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
        }
        var ENVIRONMENT_IS_WEB = false
        var ENVIRONMENT_IS_WORKER = false
        var ENVIRONMENT_IS_NODE = false
        var ENVIRONMENT_IS_SHELL = false
        ENVIRONMENT_IS_WEB = typeof window === 'object'
        ENVIRONMENT_IS_WORKER = typeof importScripts === 'function'
        ENVIRONMENT_IS_NODE = typeof process === 'object' && typeof process.versions === 'object' && typeof process.versions.node === 'string'
        ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER
        var scriptDirectory = ''
        function locateFile(path) {
            if (Module['locateFile']) {
                return Module['locateFile'](path, scriptDirectory)
            }
            return scriptDirectory + path
        }
        var read_, readAsync, readBinary, setWindowTitle
        var nodeFS
        var nodePath
        if (ENVIRONMENT_IS_NODE) {
            if (ENVIRONMENT_IS_WORKER) {
                scriptDirectory = require('path').dirname(scriptDirectory) + '/'
            } else {
                scriptDirectory = __dirname + '/'
            }
            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
            }
            if (process['argv'].length > 1) {
                thisProgram = process['argv'][1].replace(/\\/g, '/')
            }
            arguments_ = process['argv'].slice(2)
            process['on']('uncaughtException', function (ex) {
                if (!(ex instanceof ExitStatus)) {
                    throw ex
                }
            })
            process['on']('unhandledRejection', abort)
            quit_ = function (status) {
                process['exit'](status)
            }
            Module['inspect'] = function () {
                return '[Emscripten Module object]'
            }
        } else if (ENVIRONMENT_IS_SHELL) {
            if (typeof read != 'undefined') {
                read_ = function shell_read(f) {
                    return read(f)
                }
            }
            readBinary = function readBinary(f) {
                var data
                if (typeof readbuffer === 'function') {
                    return new Uint8Array(readbuffer(f))
                }
                data = read(f, 'binary')
                assert(typeof data === 'object')
                return data
            }
            if (typeof scriptArgs != 'undefined') {
                arguments_ = scriptArgs
            } else if (typeof arguments != 'undefined') {
                arguments_ = arguments
            }
            if (typeof quit === 'function') {
                quit_ = function (status) {
                    quit(status)
                }
            }
            if (typeof print !== 'undefined') {
                if (typeof console === 'undefined') console = {}
                console.log = print
                console.warn = console.error = typeof printErr !== 'undefined' ? printErr : print
            }
        } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
            if (ENVIRONMENT_IS_WORKER) {
                scriptDirectory = self.location.href
            } else if (typeof document !== 'undefined' && document.currentScript) {
                scriptDirectory = document.currentScript.src
            }
            if (_scriptDir) {
                scriptDirectory = _scriptDir
            }
            if (scriptDirectory.indexOf('blob:') !== 0) {
                scriptDirectory = scriptDirectory.substr(0, scriptDirectory.lastIndexOf('/') + 1)
            } else {
                scriptDirectory = ''
            }
            {
                read_ = function shell_read(url) {
                    var xhr = new XMLHttpRequest()
                    xhr.open('GET', url, false)
                    xhr.send(null)
                    return xhr.responseText
                }
                if (ENVIRONMENT_IS_WORKER) {
                    readBinary = function readBinary(url) {
                        var xhr = new XMLHttpRequest()
                        xhr.open('GET', url, false)
                        xhr.responseType = 'arraybuffer'
                        xhr.send(null)
                        return new Uint8Array(xhr.response)
                    }
                }
                readAsync = function readAsync(url, onload, onerror) {
                    var xhr = new XMLHttpRequest()
                    xhr.open('GET', url, true)
                    xhr.responseType = 'arraybuffer'
                    xhr.onload = function xhr_onload() {
                        if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) {
                            onload(xhr.response)
                            return
                        }
                        onerror()
                    }
                    xhr.onerror = onerror
                    xhr.send(null)
                }
            }
            setWindowTitle = function (title) {
                document.title = title
            }
        } else {
        }
        var out = Module['print'] || console.log.bind(console)
        var err = Module['printErr'] || console.warn.bind(console)
        for (key in moduleOverrides) {
            if (moduleOverrides.hasOwnProperty(key)) {
                Module[key] = moduleOverrides[key]
            }
        }
        moduleOverrides = null
        if (Module['arguments']) arguments_ = Module['arguments']
        if (Module['thisProgram']) thisProgram = Module['thisProgram']
        if (Module['quit']) quit_ = Module['quit']
        var tempRet0 = 0
        var setTempRet0 = function (value) {
            tempRet0 = value
        }
        var wasmBinary
        if (Module['wasmBinary']) wasmBinary = Module['wasmBinary']
        var noExitRuntime
        if (Module['noExitRuntime']) noExitRuntime = Module['noExitRuntime']
        if (typeof WebAssembly !== 'object') {
            abort('no native wasm support detected')
        }
        var wasmMemory
        var ABORT = false
        var EXITSTATUS
        function assert(condition, text) {
            if (!condition) {
                abort('Assertion failed: ' + text)
            }
        }
        var UTF8Decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf8') : undefined
        function UTF8ArrayToString(heap, idx, maxBytesToRead) {
            var endIdx = idx + maxBytesToRead
            var endPtr = idx
            while (heap[endPtr] && !(endPtr >= endIdx)) ++endPtr
            if (endPtr - idx > 16 && heap.subarray && UTF8Decoder) {
                return UTF8Decoder.decode(heap.subarray(idx, endPtr))
            } else {
                var str = ''
                while (idx < endPtr) {
                    var u0 = heap[idx++]
                    if (!(u0 & 128)) {
                        str += String.fromCharCode(u0)
                        continue
                    }
                    var u1 = heap[idx++] & 63
                    if ((u0 & 224) == 192) {
                        str += String.fromCharCode(((u0 & 31) << 6) | u1)
                        continue
                    }
                    var u2 = heap[idx++] & 63
                    if ((u0 & 240) == 224) {
                        u0 = ((u0 & 15) << 12) | (u1 << 6) | u2
                    } else {
                        u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heap[idx++] & 63)
                    }
                    if (u0 < 65536) {
                        str += String.fromCharCode(u0)
                    } else {
                        var ch = u0 - 65536
                        str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023))
                    }
                }
            }
            return str
        }
        function UTF8ToString(ptr, maxBytesToRead) {
            return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : ''
        }
        function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {
            if (!(maxBytesToWrite > 0)) return 0
            var startIdx = outIdx
            var endIdx = outIdx + maxBytesToWrite - 1
            for (var i = 0; i < str.length; ++i) {
                var u = str.charCodeAt(i)
                if (u >= 55296 && u <= 57343) {
                    var u1 = str.charCodeAt(++i)
                    u = (65536 + ((u & 1023) << 10)) | (u1 & 1023)
                }
                if (u <= 127) {
                    if (outIdx >= endIdx) break
                    heap[outIdx++] = u
                } else if (u <= 2047) {
                    if (outIdx + 1 >= endIdx) break
                    heap[outIdx++] = 192 | (u >> 6)
                    heap[outIdx++] = 128 | (u & 63)
                } else if (u <= 65535) {
                    if (outIdx + 2 >= endIdx) break
                    heap[outIdx++] = 224 | (u >> 12)
                    heap[outIdx++] = 128 | ((u >> 6) & 63)
                    heap[outIdx++] = 128 | (u & 63)
                } else {
                    if (outIdx + 3 >= endIdx) break
                    heap[outIdx++] = 240 | (u >> 18)
                    heap[outIdx++] = 128 | ((u >> 12) & 63)
                    heap[outIdx++] = 128 | ((u >> 6) & 63)
                    heap[outIdx++] = 128 | (u & 63)
                }
            }
            heap[outIdx] = 0
            return outIdx - startIdx
        }
        function stringToUTF8(str, outPtr, maxBytesToWrite) {
            return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite)
        }
        function lengthBytesUTF8(str) {
            var len = 0
            for (var i = 0; i < str.length; ++i) {
                var u = str.charCodeAt(i)
                if (u >= 55296 && u <= 57343) u = (65536 + ((u & 1023) << 10)) | (str.charCodeAt(++i) & 1023)
                if (u <= 127) ++len
                else if (u <= 2047) len += 2
                else if (u <= 65535) len += 3
                else len += 4
            }
            return len
        }
        var UTF16Decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-16le') : undefined
        function UTF16ToString(ptr, maxBytesToRead) {
            var endPtr = ptr
            var idx = endPtr >> 1
            var maxIdx = idx + maxBytesToRead / 2
            while (!(idx >= maxIdx) && HEAPU16[idx]) ++idx
            endPtr = idx << 1
            if (endPtr - ptr > 32 && UTF16Decoder) {
                return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr))
            } else {
                var str = ''
                for (var i = 0; !(i >= maxBytesToRead / 2); ++i) {
                    var codeUnit = HEAP16[(ptr + i * 2) >> 1]
                    if (codeUnit == 0) break
                    str += String.fromCharCode(codeUnit)
                }
                return str
            }
        }
        function stringToUTF16(str, outPtr, maxBytesToWrite) {
            if (maxBytesToWrite === undefined) {
                maxBytesToWrite = 2147483647
            }
            if (maxBytesToWrite < 2) return 0
            maxBytesToWrite -= 2
            var startPtr = outPtr
            var numCharsToWrite = maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length
            for (var i = 0; i < numCharsToWrite; ++i) {
                var codeUnit = str.charCodeAt(i)
                HEAP16[outPtr >> 1] = codeUnit
                outPtr += 2
            }
            HEAP16[outPtr >> 1] = 0
            return outPtr - startPtr
        }
        function lengthBytesUTF16(str) {
            return str.length * 2
        }
        function UTF32ToString(ptr, maxBytesToRead) {
            var i = 0
            var str = ''
            while (!(i >= maxBytesToRead / 4)) {
                var utf32 = HEAP32[(ptr + i * 4) >> 2]
                if (utf32 == 0) break
                ++i
                if (utf32 >= 65536) {
                    var ch = utf32 - 65536
                    str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023))
                } else {
                    str += String.fromCharCode(utf32)
                }
            }
            return str
        }
        function stringToUTF32(str, outPtr, maxBytesToWrite) {
            if (maxBytesToWrite === undefined) {
                maxBytesToWrite = 2147483647
            }
            if (maxBytesToWrite < 4) return 0
            var startPtr = outPtr
            var endPtr = startPtr + maxBytesToWrite - 4
            for (var i = 0; i < str.length; ++i) {
                var codeUnit = str.charCodeAt(i)
                if (codeUnit >= 55296 && codeUnit <= 57343) {
                    var trailSurrogate = str.charCodeAt(++i)
                    codeUnit = (65536 + ((codeUnit & 1023) << 10)) | (trailSurrogate & 1023)
                }
                HEAP32[outPtr >> 2] = codeUnit
                outPtr += 4
                if (outPtr + 4 > endPtr) break
            }
            HEAP32[outPtr >> 2] = 0
            return outPtr - startPtr
        }
        function lengthBytesUTF32(str) {
            var len = 0
            for (var i = 0; i < str.length; ++i) {
                var codeUnit = str.charCodeAt(i)
                if (codeUnit >= 55296 && codeUnit <= 57343) ++i
                len += 4
            }
            return len
        }
        function alignUp(x, multiple) {
            if (x % multiple > 0) {
                x += multiple - (x % multiple)
            }
            return x
        }
        var buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, 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 INITIAL_MEMORY = Module['INITIAL_MEMORY'] || 16777216
        var wasmTable
        var __ATPRERUN__ = []
        var __ATINIT__ = []
        var __ATMAIN__ = []
        var __ATPOSTRUN__ = []
        var runtimeInitialized = false
        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
            callRuntimeCallbacks(__ATINIT__)
        }
        function preMain() {
            callRuntimeCallbacks(__ATMAIN__)
        }
        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 addOnPostRun(cb) {
            __ATPOSTRUN__.unshift(cb)
        }
        var runDependencies = 0
        var runDependencyWatcher = null
        var dependenciesFulfilled = null
        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()
                }
            }
        }
        Module['preloadedImages'] = {}
        Module['preloadedAudios'] = {}
        function abort(what) {
            if (Module['onAbort']) {
                Module['onAbort'](what)
            }
            what += ''
            err(what)
            ABORT = true
            EXITSTATUS = 1
            what = 'abort(' + what + '). Build with -s ASSERTIONS=1 for more info.'
            var e = new WebAssembly.RuntimeError(what)
            readyPromiseReject(e)
            throw e
        }
        function hasPrefix(str, prefix) {
            return String.prototype.startsWith ? str.startsWith(prefix) : str.indexOf(prefix) === 0
        }
        var dataURIPrefix = 'data:application/octet-stream;base64,'
        function isDataURI(filename) {
            return hasPrefix(filename, dataURIPrefix)
        }
        var fileURIPrefix = 'file://'
        function isFileURI(filename) {
            return hasPrefix(filename, fileURIPrefix)
        }
        var wasmBinaryFile = 'basis_transcoder.wasm'
        if (!isDataURI(wasmBinaryFile)) {
            wasmBinaryFile = locateFile(wasmBinaryFile)
        }
        function getBinary() {
            try {
                if (wasmBinary) {
                    return new Uint8Array(wasmBinary)
                }
                if (readBinary) {
                    return readBinary(wasmBinaryFile)
                } else {
                    throw 'both async and sync fetching of the wasm failed'
                }
            } catch (err) {
                abort(err)
            }
        }
        function getBinaryPromise() {
            if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) && 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()
                    })
            }
            return Promise.resolve().then(getBinary)
        }
        function createWasm() {
            var info = { a: asmLibraryArg }
            function receiveInstance(instance, module) {
                var exports = instance.exports
                Module['asm'] = exports
                wasmMemory = Module['asm']['K']
                updateGlobalBufferAndViews(wasmMemory.buffer)
                wasmTable = Module['asm']['L']
                removeRunDependency('wasm-instantiate')
            }
            addRunDependency('wasm-instantiate')
            function receiveInstantiatedSource(output) {
                receiveInstance(output['instance'])
            }
            function instantiateArrayBuffer(receiver) {
                return getBinaryPromise()
                    .then(function (binary) {
                        return WebAssembly.instantiate(binary, info)
                    })
                    .then(receiver, function (reason) {
                        err('failed to asynchronously prepare wasm: ' + reason)
                        abort(reason)
                    })
            }
            function instantiateAsync() {
                if (!wasmBinary && typeof WebAssembly.instantiateStreaming === 'function' && !isDataURI(wasmBinaryFile) && !isFileURI(wasmBinaryFile) && typeof fetch === 'function') {
                    return fetch(wasmBinaryFile, { credentials: 'same-origin' }).then(function (response) {
                        var result = WebAssembly.instantiateStreaming(response, info)
                        return result.then(receiveInstantiatedSource, function (reason) {
                            err('wasm streaming compile failed: ' + reason)
                            err('falling back to ArrayBuffer instantiation')
                            return instantiateArrayBuffer(receiveInstantiatedSource)
                        })
                    })
                } else {
                    return instantiateArrayBuffer(receiveInstantiatedSource)
                }
            }
            if (Module['instantiateWasm']) {
                try {
                    var exports = Module['instantiateWasm'](info, receiveInstance)
                    return exports
                } catch (e) {
                    err('Module.instantiateWasm callback failed with error: ' + e)
                    return false
                }
            }
            instantiateAsync().catch(readyPromiseReject)
            return {}
        }
        function callRuntimeCallbacks(callbacks) {
            while (callbacks.length > 0) {
                var callback = callbacks.shift()
                if (typeof callback == 'function') {
                    callback(Module)
                    continue
                }
                var func = callback.func
                if (typeof func === 'number') {
                    if (callback.arg === undefined) {
                        wasmTable.get(func)()
                    } else {
                        wasmTable.get(func)(callback.arg)
                    }
                } else {
                    func(callback.arg === undefined ? null : callback.arg)
                }
            }
        }
        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)
            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) {
                            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 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)
        }
        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) {
                    return !!wt
                },
                toWireType: function (destructors, o) {
                    return o ? trueValue : falseValue
                },
                argPackAdvance: 8,
                readValueFromPointer: function (pointer) {
                    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,
            })
        }
        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 finalizationGroup = 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 FinalizationGroup) {
                attachFinalizer = function (handle) {
                    return handle
                }
                return handle
            }
            finalizationGroup = new FinalizationGroup(function (iter) {
                for (var result = iter.next(); !result.done; result = iter.next()) {
                    var $$ = result.value
                    if (!$$.ptr) {
                        console.warn('object already deleted: ' + $$.ptr)
                    } else {
                        releaseClassHandle($$)
                    }
                }
            })
            attachFinalizer = function (handle) {
                finalizationGroup.register(handle, handle.$$, handle.$$)
                return handle
            }
            detachFinalizer = function (handle) {
                finalizationGroup.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]
                proto[methodName] = function () {
                    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)
                }
                proto[methodName].overloadTable = []
                proto[methodName].overloadTable[prevFunc.argCount] = prevFunc
            }
        }
        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")
                }
                ensureOverloadTable(Module, name, name)
                if (Module.hasOwnProperty(numArguments)) {
                    throwBindingError('Cannot register multiple overloads of a function with the same number of arguments (' + numArguments + ')!')
                }
                Module[name].overloadTable[numArguments] = value
            } else {
                Module[name] = value
                if (undefined !== numArguments) {
                    Module[name].numArguments = numArguments
                }
            }
        }
        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) {
                if (undefined === handle.$$.smartPtr) {
                    throwBindingError('Passing raw pointer to smart pointer is illegal')
                }
                switch (this.sharingPolicy) {
                    case 0:
                        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:
                        ptr = handle.$$.smartPtr
                        break
                    case 2:
                        if (handle.$$.smartPtrType === this) {
                            ptr = handle.$$.smartPtr
                        } else {
                            var clonedHandle = handle['clone']()
                            ptr = this.rawShare(
                                ptr,
                                __emval_register(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
            }
            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) {
            var rawPointer = this.getPointee(ptr)
            if (!rawPointer) {
                this.destructor(ptr)
                return null
            }
            var registeredInstance = getInheritedInstance(this.registeredClass, rawPointer)
            if (undefined !== registeredInstance) {
                if (0 === registeredInstance.$$.count.value) {
                    registeredInstance.$$.ptr = rawPointer
                    registeredInstance.$$.smartPtr = ptr
                    return registeredInstance['clone']()
                } else {
                    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
        }
        function RegisteredPointer(name, registeredClass, isReference, isConst, isSmartPointer, pointeeType, sharingPolicy, rawGetPointee, rawConstructor, rawShare, rawDestructor) {
            this.name = name
            this.registeredClass = registeredClass
            this.isReference = isReference
            this.isConst = isConst
            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
            }
        }
        function replacePublicSymbol(name, value, numArguments) {
            if (!Module.hasOwnProperty(name)) {
                throwInternalError('Replacing nonexistant public symbol')
            }
            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) {
            if (args && args.length) {
                return Module['dynCall_' + sig].apply(null, [ptr].concat(args))
            }
            return Module['dynCall_' + sig].call(null, ptr)
        }
        function dynCall(sig, ptr, args) {
            if (sig.indexOf('j') != -1) {
                return dynCallLegacy(sig, ptr, args)
            }
            return wasmTable.get(ptr).apply(null, args)
        }
        function getDynCaller(sig, ptr) {
            assert(sig.indexOf('j') >= 0, 'getDynCaller should only be called with i64 sigs')
            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.indexOf('j') != -1) {
                    return getDynCaller(signature, rawFunction)
                }
                return wasmTable.get(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 () {
                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) {
                    classType.registeredClass.constructor_body[argCount - 1] = function constructor_body() {
                        if (arguments.length !== argCount - 1) {
                            throwBindingError(humanName + ' called with ' + arguments.length + ' arguments, expected ' + (argCount - 1))
                        }
                        destructors.length = 0
                        args.length = argCount
                        for (var i = 1; i < argCount; ++i) {
                            args[i] = argTypes[i]['toWireType'](destructors, arguments[i - 1])
                        }
                        var ptr = invoker.apply(null, args)
                        runDestructors(destructors)
                        return argTypes[0]['fromWireType'](ptr)
                    }
                    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')
            }
            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) {
            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
            var needsDestructorStack = false
            for (var i = 1; i < argTypes.length; ++i) {
                if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) {
                    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) {
                    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, 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 (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)) {
                    unboundTypesHandler.argCount = argCount - 2
                    unboundTypesHandler.className = classType.name
                    proto[methodName] = unboundTypesHandler
                } else {
                    ensureOverloadTable(proto, methodName, humanName)
                    proto[methodName].overloadTable[argCount - 2] = unboundTypesHandler
                }
                whenDependentTypesAreResolved([], rawArgTypes, function (argTypes) {
                    var memberFunction = craftInvokerFunction(humanName, argTypes, classType, rawInvoker, context)
                    if (undefined === proto[methodName].overloadTable) {
                        memberFunction.argCount = argCount - 2
                        proto[methodName] = memberFunction
                    } else {
                        proto[methodName].overloadTable[argCount - 2] = memberFunction
                    }
                    return []
                })
                return []
            })
        }
        function __embind_register_constant(name, type, value) {
            name = readLatin1String(name)
            whenDependentTypesAreResolved([], [type], function (type) {
                type = type[0]
                Module[name] = type['fromWireType'](value)
                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
        }
        function __emval_register(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_handle_array[handle].value
                    __emval_decref(handle)
                    return rv
                },
                toWireType: function (destructors, value) {
                    return __emval_register(value)
                },
                argPackAdvance: 8,
                readValueFromPointer: simpleReadValueFromPointer,
                destructorFunction: null,
            })
        }
        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) {
                    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,
            })
        }
        function __embind_register_function(name, argCount, rawArgTypesAddr, signature, rawInvoker, fn) {
            var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr)
            name = readLatin1String(name)
            rawInvoker = embind__requireFunction(signature, rawInvoker)
            exposePublicSymbol(
                name,
                function () {
                    throwUnboundTypeError('Cannot call ' + name + ' due to unbound types', argTypes)
                },
                argCount - 1
            )
            whenDependentTypesAreResolved([], argTypes, function (argTypes) {
                var invokerArgsArray = [argTypes[0], null].concat(argTypes.slice(1))
                replacePublicSymbol(name, craftInvokerFunction(name, invokerArgsArray, null, rawInvoker, fn), argCount - 1)
                return []
            })
        }
        function integerReadValueFromPointer(name, shift, signed) {
            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) {
                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.indexOf('unsigned') != -1
            registerType(primitiveType, {
                name: name,
                fromWireType: fromWireType,
                toWireType: function (destructors, value) {
                    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,
            })
        }
        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]
                var data = heap[handle + 1]
                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 = name === 'std::string'
            registerType(rawType, {
                name: name,
                fromWireType: function (value) {
                    var length = HEAPU32[value >> 2]
                    var str
                    if (stdStringIsUTF8) {
                        var decodeStartPtr = value + 4
                        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
                        }
                    }
                    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) {
                    var length = HEAPU32[value >> 2]
                    var HEAP = getHeap()
                    var str
                    var decodeStartPtr = value + 4
                    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)
                    }
                    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,
                name: name,
                argPackAdvance: 0,
                fromWireType: function () {
                    return undefined
                },
                toWireType: function (destructors, o) {
                    return undefined
                },
            })
        }
        function requireHandle(handle) {
            if (!handle) {
                throwBindingError('Cannot use deleted val. handle = ' + handle)
            }
            return emval_handle_array[handle].value
        }
        function __emval_as(handle, returnType, destructorsRef) {
            handle = requireHandle(handle)
            returnType = requireRegisteredType(returnType, 'emval::as')
            var destructors = []
            var rd = __emval_register(destructors)
            HEAP32[destructorsRef >> 2] = rd
            return returnType['toWireType'](destructors, handle)
        }
        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 = requireHandle(handle)
            methodName = getStringOrSymbol(methodName)
            caller(handle, methodName, null, args)
        }
        function emval_get_global() {
            if (typeof globalThis === 'object') {
                return globalThis
            }
            return (function () {
                return Function
            })()('return this')()
        }
        function __emval_get_global(name) {
            if (name === 0) {
                return __emval_register(emval_get_global())
            } else {
                name = getStringOrSymbol(name)
                return __emval_register(emval_get_global()[name])
            }
        }
        function __emval_addMethodCaller(caller) {
            var id = emval_methodCallers.length
            emval_methodCallers.push(caller)
            return id
        }
        function __emval_lookupTypes(argCount, argTypes) {
            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 = ''
            for (var i = 0; i < argCount - 1; ++i) {
                argsList += (i !== 0 ? ', ' : '') + 'arg' + i
                params.push('argType' + i)
                args.push(types[1 + i])
            }
            var functionName = makeLegalFunctionName('methodCaller_' + signatureName)
            var functionBody = 'return function ' + functionName + '(handle, name, destructors, args) {\n'
            var offset = 0
            for (var i = 0; i < argCount - 1; ++i) {
                functionBody += '    var arg' + i + ' = argType' + i + '.readValueFromPointer(args' + (offset ? '+' + offset : '') + ');\n'
                offset += types[i + 1]['argPackAdvance']
            }
            functionBody += '    var rv = handle[name](' + argsList + ');\n'
            for (var i = 0; i < argCount - 1; ++i) {
                if (types[i + 1]['deleteObject']) {
                    functionBody += '    argType' + i + '.deleteObject(arg' + i + ');\n'
                }
            }
            if (!retType.isVoid) {
                functionBody += '    return retType.toWireType(destructors, rv);\n'
            }
            functionBody += '};\n'
            params.push(functionBody)
            var invokerFunction = new_(Function, params).apply(null, args)
            return __emval_addMethodCaller(invokerFunction)
        }
        function __emval_get_module_property(name) {
            name = getStringOrSymbol(name)
            return __emval_register(Module[name])
        }
        function __emval_get_property(handle, key) {
            handle = requireHandle(handle)
            key = requireHandle(key)
            return __emval_register(handle[key])
        }
        function __emval_incref(handle) {
            if (handle > 4) {
                emval_handle_array[handle].refcount += 1
            }
        }
        function craftEmvalAllocator(argCount) {
            var argsList = ''
            for (var i = 0; i < argCount; ++i) {
                argsList += (i !== 0 ? ', ' : '') + 'arg' + i
            }
            var functionBody = 'return function emval_allocator_' + argCount + '(constructor, argTypes, args) {\n'
            for (var i = 0; i < argCount; ++i) {
                functionBody +=
                    'var argType' +
                    i +
                    " = requireRegisteredType(Module['HEAP32'][(argTypes >>> 2) + " +
                    i +
                    '], "parameter ' +
                    i +
                    '");\n' +
                    'var arg' +
                    i +
                    ' = argType' +
                    i +
                    '.readValueFromPointer(args);\n' +
                    'args += argType' +
                    i +
                    "['argPackAdvance'];\n"
            }
            functionBody += 'var obj = new constructor(' + argsList + ');\n' + 'return __emval_register(obj);\n' + '}\n'
            return new Function('requireRegisteredType', 'Module', '__emval_register', functionBody)(requireRegisteredType, Module, __emval_register)
        }
        var emval_newers = {}
        function __emval_new(handle, argCount, argTypes, args) {
            handle = requireHandle(handle)
            var newer = emval_newers[argCount]
            if (!newer) {
                newer = craftEmvalAllocator(argCount)
                emval_newers[argCount] = newer
            }
            return newer(handle, argTypes, args)
        }
        function __emval_new_cstring(v) {
            return __emval_register(getStringOrSymbol(v))
        }
        function __emval_run_destructors(handle) {
            var destructors = emval_handle_array[handle].value
            runDestructors(destructors)
            __emval_decref(handle)
        }
        function _abort() {
            abort()
        }
        function _emscripten_memcpy_big(dest, src, num) {
            HEAPU8.copyWithin(dest, src, src + num)
        }
        function _emscripten_get_heap_size() {
            return HEAPU8.length
        }
        function emscripten_realloc_buffer(size) {
            try {
                wasmMemory.grow((size - buffer.byteLength + 65535) >>> 16)
                updateGlobalBufferAndViews(wasmMemory.buffer)
                return 1
            } catch (e) {}
        }
        function _emscripten_resize_heap(requestedSize) {
            requestedSize = requestedSize >>> 0
            var oldSize = _emscripten_get_heap_size()
            var maxHeapSize = 2147483648
            if (requestedSize > maxHeapSize) {
                return false
            }
            var minHeapSize = 16777216
            for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
                var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown)
                overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296)
                var newSize = Math.min(maxHeapSize, alignUp(Math.max(minHeapSize, requestedSize, overGrownHeapSize), 65536))
                var replacement = emscripten_realloc_buffer(newSize)
                if (replacement) {
                    return true
                }
            }
            return false
        }
        var SYSCALLS = {
            mappings: {},
            buffers: [null, [], []],
            printChar: function (stream, curr) {
                var buffer = SYSCALLS.buffers[stream]
                if (curr === 0 || curr === 10) {
                    ;(stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0))
                    buffer.length = 0
                } else {
                    buffer.push(curr)
                }
            },
            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
            },
            get64: function (low, high) {
                return low
            },
        }
        function _fd_close(fd) {
            return 0
        }
        function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {}
        function _fd_write(fd, iov, iovcnt, pnum) {
            var num = 0
            for (var i = 0; i < iovcnt; i++) {
                var ptr = HEAP32[(iov + i * 8) >> 2]
                var len = HEAP32[(iov + (i * 8 + 4)) >> 2]
                for (var j = 0; j < len; j++) {
                    SYSCALLS.printChar(fd, HEAPU8[ptr + j])
                }
                num += len
            }
            HEAP32[pnum >> 2] = num
            return 0
        }
        function _setTempRet0($i) {
            setTempRet0($i | 0)
        }
        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()
        __ATINIT__.push({
            func: function () {
                ___wasm_call_ctors()
            },
        })
        var asmLibraryArg = {
            t: __embind_finalize_value_object,
            I: __embind_register_bool,
            x: __embind_register_class,
            w: __embind_register_class_constructor,
            d: __embind_register_class_function,
            k: __embind_register_constant,
            H: __embind_register_emval,
            n: __embind_register_enum,
            a: __embind_register_enum_value,
            A: __embind_register_float,
            i: __embind_register_function,
            j: __embind_register_integer,
            h: __embind_register_memory_view,
            B: __embind_register_std_string,
            v: __embind_register_std_wstring,
            u: __embind_register_value_object,
            c: __embind_register_value_object_field,
            J: __embind_register_void,
            m: __emval_as,
            s: __emval_call_void_method,
            b: __emval_decref,
            y: __emval_get_global,
            p: __emval_get_method_caller,
            r: __emval_get_module_property,
            e: __emval_get_property,
            g: __emval_incref,
            q: __emval_new,
            f: __emval_new_cstring,
            l: __emval_run_destructors,
            o: _abort,
            E: _emscripten_memcpy_big,
            F: _emscripten_resize_heap,
            G: _fd_close,
            C: _fd_seek,
            z: _fd_write,
            D: _setTempRet0,
        }
        var asm = createWasm()
        var ___wasm_call_ctors = (Module['___wasm_call_ctors'] = function () {
            return (___wasm_call_ctors = Module['___wasm_call_ctors'] = Module['asm']['M']).apply(null, arguments)
        })
        var _malloc = (Module['_malloc'] = function () {
            return (_malloc = Module['_malloc'] = Module['asm']['N']).apply(null, arguments)
        })
        var _free = (Module['_free'] = function () {
            return (_free = Module['_free'] = Module['asm']['O']).apply(null, arguments)
        })
        var ___getTypeName = (Module['___getTypeName'] = function () {
            return (___getTypeName = Module['___getTypeName'] = Module['asm']['P']).apply(null, arguments)
        })
        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']['Q']).apply(null, arguments)
        })
        var dynCall_jiji = (Module['dynCall_jiji'] = function () {
            return (dynCall_jiji = Module['dynCall_jiji'] = Module['asm']['R']).apply(null, arguments)
        })
        var calledRun
        function ExitStatus(status) {
            this.name = 'ExitStatus'
            this.message = 'Program terminated with exit(' + status + ')'
            this.status = status
        }
        dependenciesFulfilled = function runCaller() {
            if (!calledRun) run()
            if (!calledRun) dependenciesFulfilled = runCaller
        }
        function run(args) {
            args = args || arguments_
            if (runDependencies > 0) {
                return
            }
            preRun()
            if (runDependencies > 0) return
            function doRun() {
                if (calledRun) return
                calledRun = true
                Module['calledRun'] = true
                if (ABORT) return
                initRuntime()
                preMain()
                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
        if (Module['preInit']) {
            if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']]
            while (Module['preInit'].length > 0) {
                Module['preInit'].pop()()
            }
        }
        noExitRuntime = true
        run()

        return BASIS.ready
    }
})()
if (typeof exports === 'object' && typeof module === 'object') module.exports = BASIS
else if (typeof define === 'function' && define['amd'])
    define([], function () {
        return BASIS
    })
else if (typeof exports === 'object') exports['BASIS'] = BASIS