这样能领多少
https://github.com/WebAssembly/wabt/blob/main/docs/decompiler.md
test.dcmp（114.71 KB）
小米MIX2s(白)
@TabKey9，有的有的，北海、中南海、什刹海、后海都可以的。 小米MIX2s(白)
@大尨，检测微信判断 ua 就行了吧 小米MIX2s(白)
var Module = typeof Module != "undefined" ? Module : {}; var moduleOverrides = Object.assign({}, Module); var arguments_ = []; var thisProgram = "./this.program"; var quit_ = (status, toThrow) => { throw toThrow; }; var ENVIRONMENT_IS_WEB = typeof window == "object"; var ENVIRONMENT_IS_WORKER = typeof importScripts == "function"; var ENVIRONMENT_IS_NODE = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string"; var scriptDirectory = ""; function locateFile(path) { if (Module["locateFile"]) { return Module["locateFile"](path, scriptDirectory); } return scriptDirectory + path; } var read_, readAsync, readBinary, setWindowTitle; function logExceptionOnExit(e) { if (e instanceof ExitStatus) return; let toLog = e; err("exiting due to exception: " + toLog); } if (ENVIRONMENT_IS_NODE) { if (ENVIRONMENT_IS_WORKER) { scriptDirectory = require("path").dirname(scriptDirectory) + "/"; } else { scriptDirectory = __dirname + "/"; } var fs, nodePath; if (typeof require === "function") { fs = require("fs"); nodePath = require("path"); } read_ = (filename, binary) => { filename = nodePath["normalize"](filename); return fs.readFileSync(filename, binary ? undefined : "utf8"); }; readBinary = (filename) => { var ret = read_(filename, true); if (!ret.buffer) { ret = new Uint8Array(ret); } return ret; }; readAsync = (filename, onload, onerror) => { filename = nodePath["normalize"](filename); fs.readFile(filename, function (err, data) { if (err) onerror(err); else onload(data.buffer); }); }; if (process["argv"].length > 1) { thisProgram = process["argv"][1].replace(/\\/g, "/"); } arguments_ = process["argv"].slice(2); if (typeof module != "undefined") { module["exports"] = Module; } process["on"]("uncaughtException", function (ex) { if (!(ex instanceof ExitStatus)) { throw ex; } }); process["on"]("unhandledRejection", function (reason) { throw reason; }); quit_ = (status, toThrow) => { if (keepRuntimeAlive()) { process["exitCode"] = status; throw toThrow; } logExceptionOnExit(toThrow); process["exit"](status); }; Module["inspect"] = function () { return "[Emscripten Module object]"; }; } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) { if (ENVIRONMENT_IS_WORKER) { scriptDirectory = self.location.href; } else if (typeof document != "undefined" && document.currentScript) { scriptDirectory = document.currentScript.src; } if (scriptDirectory.indexOf("blob:") !== 0) { scriptDirectory = scriptDirectory.substr( 0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1 ); } else { scriptDirectory = ""; } { read_ = (url) => { var xhr = new XMLHttpRequest(); xhr.open("GET", url, false); xhr.send(null); return xhr.responseText; }; if (ENVIRONMENT_IS_WORKER) { readBinary = (url) => { var xhr = new XMLHttpRequest(); xhr.open("GET", url, false); xhr.responseType = "arraybuffer"; xhr.send(null); return new Uint8Array(xhr.response); }; } readAsync = (url, onload, onerror) => { var xhr = new XMLHttpRequest(); xhr.open("GET", url, true); xhr.responseType = "arraybuffer"; xhr.onload = () => { if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { onload(xhr.response); return; } onerror(); }; xhr.onerror = onerror; xhr.send(null); }; } setWindowTitle = (title) => (document.title = title); } else { } var out = Module["print"] || console.log.bind(console); var err = Module["printErr"] || console.warn.bind(console); Object.assign(Module, moduleOverrides); moduleOverrides = null; if (Module["arguments"]) arguments_ = Module["arguments"]; if (Module["thisProgram"]) thisProgram = Module["thisProgram"]; if (Module["quit"]) quit_ = Module["quit"]; var wasmBinary; if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"]; var noExitRuntime = Module["noExitRuntime"] || true; if (typeof WebAssembly != "object") { abort("no native wasm support detected"); } var wasmMemory; var ABORT = false; var EXITSTATUS; var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : undefined; function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) { var endIdx = idx + maxBytesToRead; var endPtr = idx; while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr; if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) { return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr)); } var str = ""; while (idx < endPtr) { var u0 = heapOrArray[idx++]; if (!(u0 & 128)) { str += String.fromCharCode(u0); continue; } var u1 = heapOrArray[idx++] & 63; if ((u0 & 224) == 192) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; } var u2 = heapOrArray[idx++] & 63; if ((u0 & 240) == 224) { u0 = ((u0 & 15) << 12) | (u1 << 6) | u2; } else { u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[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 c = str.charCodeAt(i); if (c <= 127) { len++; } else if (c <= 2047) { len += 2; } else if (c >= 55296 && c <= 57343) { len += 4; ++i; } else { len += 3; } } return len; } 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 keepRuntimeAlive() { return noExitRuntime; } 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 addOnInit(cb) { __ATINIT__.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(); } } } function abort(what) { { if (Module["onAbort"]) { Module["onAbort"](what); } } what = "Aborted(" + what + ")"; err(what); ABORT = true; EXITSTATUS = 1; what += ". Build with -sASSERTIONS for more info."; var e = new WebAssembly.RuntimeError(what); throw e; } var dataURIPrefix = "data:application/octet-stream;base64,"; function isDataURI(filename) { return filename.startsWith(dataURIPrefix); } function isFileURI(filename) { return filename.startsWith("file://"); } var wasmBinaryFile; wasmBinaryFile = "magic.wasm"; if (!isDataURI(wasmBinaryFile)) { wasmBinaryFile = locateFile(wasmBinaryFile); } function getBinary(file) { try { if (file == wasmBinaryFile && wasmBinary) { return new Uint8Array(wasmBinary); } if (readBinary) { return readBinary(file); } throw "both async and sync fetching of the wasm failed"; } catch (err) { abort(err); } } function getBinaryPromise() { if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) { if (typeof fetch == "function" && !isFileURI(wasmBinaryFile)) { return fetch(wasmBinaryFile, { credentials: "same-origin" }) .then(function (response) { if (!response["ok"]) { throw "failed to load wasm binary file at '" + wasmBinaryFile + "'"; } return response["arrayBuffer"](); }) .catch(function () { return getBinary(wasmBinaryFile); }); } else { if (readAsync) { return new Promise(function (resolve, reject) { readAsync( wasmBinaryFile, function (response) { resolve(new Uint8Array(response)); }, reject ); }); } } } return Promise.resolve().then(function () { return getBinary(wasmBinaryFile); }); } function createWasm() { var info = { a: asmLibraryArg }; function receiveInstance(instance, module) { var exports = instance.exports; Module["asm"] = exports; wasmMemory = Module["asm"]["v"]; updateGlobalBufferAndViews(wasmMemory.buffer); wasmTable = Module["asm"]["x"]; addOnInit(Module["asm"]["w"]); removeRunDependency("wasm-instantiate"); } addRunDependency("wasm-instantiate"); function receiveInstantiationResult(result) { receiveInstance(result["instance"]); } function instantiateArrayBuffer(receiver) { return getBinaryPromise() .then(function (binary) { return WebAssembly.instantiate(binary, info); }) .then(function (instance) { return instance; }) .then(receiver, function (reason) { err("failed to asynchronously prepare wasm: " + reason); abort(reason); }); } function instantiateAsync() { if ( !wasmBinary && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(wasmBinaryFile) && !isFileURI(wasmBinaryFile) && !ENVIRONMENT_IS_NODE && typeof fetch == "function" ) { return fetch(wasmBinaryFile, { credentials: "same-origin" }).then( function (response) { var result = WebAssembly.instantiateStreaming(response, info); return result.then(receiveInstantiationResult, function (reason) { err("wasm streaming compile failed: " + reason); err("falling back to ArrayBuffer instantiation"); return instantiateArrayBuffer(receiveInstantiationResult); }); } ); } else { return instantiateArrayBuffer(receiveInstantiationResult); } } 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(); return {}; } function ExitStatus(status) { this.name = "ExitStatus"; this.message = "Program terminated with exit(" + status + ")"; this.status = status; } function callRuntimeCallbacks(callbacks) { while (callbacks.length > 0) { callbacks.shift()(Module); } } function ___cxa_allocate_exception(size) { return _malloc(size + 24) + 24; } function ExceptionInfo(excPtr) { this.excPtr = excPtr; this.ptr = excPtr - 24; this.set_type = function (type) { HEAPU32[(this.ptr + 4) >> 2] = type; }; this.get_type = function () { return HEAPU32[(this.ptr + 4) >> 2]; }; this.set_destructor = function (destructor) { HEAPU32[(this.ptr + 8) >> 2] = destructor; }; this.get_destructor = function () { return HEAPU32[(this.ptr + 8) >> 2]; }; this.set_refcount = function (refcount) { HEAP32[this.ptr >> 2] = refcount; }; this.set_caught = function (caught) { caught = caught ? 1 : 0; HEAP8[(this.ptr + 12) >> 0] = caught; }; this.get_caught = function () { return HEAP8[(this.ptr + 12) >> 0] != 0; }; this.set_rethrown = function (rethrown) { rethrown = rethrown ? 1 : 0; HEAP8[(this.ptr + 13) >> 0] = rethrown; }; this.get_rethrown = function () { return HEAP8[(this.ptr + 13) >> 0] != 0; }; this.init = function (type, destructor) { this.set_adjusted_ptr(0); this.set_type(type); this.set_destructor(destructor); this.set_refcount(0); this.set_caught(false); this.set_rethrown(false); }; this.add_ref = function () { var value = HEAP32[this.ptr >> 2]; HEAP32[this.ptr >> 2] = value + 1; }; this.release_ref = function () { var prev = HEAP32[this.ptr >> 2]; HEAP32[this.ptr >> 2] = prev - 1; return prev === 1; }; this.set_adjusted_ptr = function (adjustedPtr) { HEAPU32[(this.ptr + 16) >> 2] = adjustedPtr; }; this.get_adjusted_ptr = function () { return HEAPU32[(this.ptr + 16) >> 2]; }; this.get_exception_ptr = function () { var isPointer = ___cxa_is_pointer_type(this.get_type()); if (isPointer) { return HEAPU32[this.excPtr >> 2]; } var adjusted = this.get_adjusted_ptr(); if (adjusted !== 0) return adjusted; return this.excPtr; }; } var exceptionLast = 0; var uncaughtExceptionCount = 0; function ___cxa_throw(ptr, type, destructor) { var info = new ExceptionInfo(ptr); info.init(type, destructor); exceptionLast = ptr; uncaughtExceptionCount++; throw ptr; } function __embind_register_bigint( primitiveType, name, size, minRange, maxRange ) {} function getShiftFromSize(size) { switch (size) { case 1: return 0; case 2: return 1; case 4: return 2; case 8: return 3; default: throw new TypeError("Unknown type size: " + size); } } function embind_init_charCodes() { var codes = new Array(256); for (var i = 0; i < 256; ++i) { codes[i] = String.fromCharCode(i); } embind_charCodes = codes; } var embind_charCodes = undefined; function readLatin1String(ptr) { var ret = ""; var c = ptr; while (HEAPU8[c]) { ret += embind_charCodes[HEAPU8[c++]]; } return ret; } var 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; } 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 BindingError = undefined; function throwBindingError(message) { throw new BindingError(message); } 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((dt, i) => { if (registeredTypes.hasOwnProperty(dt)) { typeConverters[i] = registeredTypes[dt]; } else { unregisteredTypes.push(dt); if (!awaitingDependencies.hasOwnProperty(dt)) { awaitingDependencies[dt] = []; } awaitingDependencies[dt].push(() => { typeConverters[i] = registeredTypes[dt]; ++registered; if (registered === unregisteredTypes.length) { onComplete(typeConverters); } }); } }); if (0 === unregisteredTypes.length) { onComplete(typeConverters); } } function registerType(rawType, registeredInstance, 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((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 }); } var emval_free_list = []; var emval_handle_array = [ {}, { value: undefined }, { value: null }, { value: true }, { value: false } ]; function __emval_decref(handle) { if (handle > 4 && 0 === --emval_handle_array[handle].refcount) { emval_handle_array[handle] = undefined; emval_free_list.push(handle); } } function count_emval_handles() { var count = 0; for (var i = 5; i < emval_handle_array.length; ++i) { if (emval_handle_array[i] !== undefined) { ++count; } } return count; } function get_first_emval() { for (var i = 5; i < emval_handle_array.length; ++i) { if (emval_handle_array[i] !== undefined) { return emval_handle_array[i]; } } return null; } function init_emval() { Module["count_emval_handles"] = count_emval_handles; Module["get_first_emval"] = get_first_emval; } var Emval = { toValue: (handle) => { if (!handle) { throwBindingError("Cannot use deleted val. handle = " + handle); } return emval_handle_array[handle].value; }, toHandle: (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 simpleReadValueFromPointer(pointer) { return this["fromWireType"](HEAP32[pointer >> 2]); } function __embind_register_emval(rawType, name) { name = readLatin1String(name); registerType(rawType, { name: name, fromWireType: function (handle) { var rv = Emval.toValue(handle); __emval_decref(handle); return rv; }, toWireType: function (destructors, value) { return Emval.toHandle(value); }, argPackAdvance: 8, readValueFromPointer: simpleReadValueFromPointer, destructorFunction: null }); } 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) { return value; }, argPackAdvance: 8, readValueFromPointer: floatReadValueFromPointer(name, shift), destructorFunction: null }); } 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 runDestructors(destructors) { while (destructors.length) { var ptr = destructors.pop(); var del = destructors.pop(); del(ptr); } } 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 < .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); console.log('invokerFnBody：', invokerFnBody, invokerFunction); return invokerFunction; } 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 heap32VectorToArray(count, firstElement) { var array = []; for (var i = 0; i < count; i++) { array.push(HEAPU32[(firstElement + i * 4) >> 2]); } return array; } 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) { var f = Module["dynCall_" + sig]; return args && args.length ? f.apply(null, [ptr].concat(args)) : f.call(null, ptr); } function getWasmTableEntry(funcPtr) { return wasmTable.get(funcPtr); } function dynCall(sig, ptr, args) { if (sig.includes("j")) { return dynCallLegacy(sig, ptr, args); } var rtn = getWasmTableEntry(ptr).apply(null, args); return rtn; } function getDynCaller(sig, ptr) { var argCache = []; return function () { argCache.length = 0; Object.assign(argCache, arguments); return dynCall(sig, ptr, argCache); }; } function embind__requireFunction(signature, rawFunction) { signature = readLatin1String(signature); function makeDynCaller() { if (signature.includes("j")) { return getDynCaller(signature, rawFunction); } return getWasmTableEntry(rawFunction); } var fp = makeDynCaller(); if (typeof fp != "function") { throwBindingError( "unknown function pointer with signature " + signature + ": " + rawFunction ); } return fp; } var UnboundTypeError = undefined; function getTypeName(type) { var ptr = ___getTypeName(type); var rv = readLatin1String(ptr); _free(ptr); return rv; } function throwUnboundTypeError(message, types) { var unboundTypes = []; var seen = {}; function visit(type) { if (seen[type]) { return; } if (registeredTypes[type]) { return; } if (typeDependencies[type]) { typeDependencies[type].forEach(visit); return; } unboundTypes.push(type); seen[type] = true; } types.forEach(visit); throw new UnboundTypeError( message + ": " + unboundTypes.map(getTypeName).join([", "]) ); } function __embind_register_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 = (value) => value; if (minRange === 0) { var bitshift = 32 - 8 * size; fromWireType = (value) => (value << bitshift) >>> bitshift; } var isUnsignedType = name.includes("unsigned"); var checkAssertions = (value, toTypeName) => {}; var toWireType; if (isUnsignedType) { toWireType = function (destructors, value) { checkAssertions(value, this.name); return value >>> 0; }; } else { toWireType = function (destructors, value) { checkAssertions(value, this.name); return value; }; } registerType(primitiveType, { name: name, fromWireType: fromWireType, toWireType: toWireType, 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 payload = value + 4; var str; if (stdStringIsUTF8) { var decodeStartPtr = payload; for (var i = 0; i <= length; ++i) { var currentBytePtr = payload + 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[payload + i]); } str = a.join(""); } _free(value); return str; }, toWireType: function (destructors, value) { if (value instanceof ArrayBuffer) { value = new Uint8Array(value); } var length; 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) { length = lengthBytesUTF8(value); } else { length = value.length; } var base = _malloc(4 + length + 1); var ptr = base + 4; HEAPU32[base >> 2] = length; if (stdStringIsUTF8 && valueIsOfTypeString) { stringToUTF8(value, ptr, 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 + i] = charCode; } } else { for (var i = 0; i < length; ++i) { HEAPU8[ptr + i] = value[i]; } } } if (destructors !== null) { destructors.push(_free, base); } return base; }, argPackAdvance: 8, readValueFromPointer: simpleReadValueFromPointer, destructorFunction: function (ptr) { _free(ptr); } }); } 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)); 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 __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 = () => HEAPU16; shift = 1; } else if (charSize === 4) { decodeString = UTF32ToString; encodeString = stringToUTF32; lengthBytesUTF = lengthBytesUTF32; getHeap = () => 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_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 requireRegisteredType(rawType, humanName) { var impl = registeredTypes[rawType]; if (undefined === impl) { throwBindingError(humanName + " has unknown type " + getTypeName(rawType)); } return impl; } function __emval_as(handle, returnType, destructorsRef) { handle = Emval.toValue(handle); returnType = requireRegisteredType(returnType, "emval::as"); var destructors = []; var rd = Emval.toHandle(destructors); HEAPU32[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); } return symbol; } 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.toHandle(emval_get_global()); } else { name = getStringOrSymbol(name); return Emval.toHandle(emval_get_global()[name]); } } function __emval_get_property(handle, key) { handle = Emval.toValue(handle); key = Emval.toValue(key); return Emval.toHandle(handle[key]); } function __emval_run_destructors(handle) { var destructors = Emval.toValue(handle); runDestructors(destructors); __emval_decref(handle); } function __emval_take_value(type, arg) { type = requireRegisteredType(type, "_emval_take_value"); var v = type["readValueFromPointer"](arg); return Emval.toHandle(v); } function _abort() { abort(""); } function abortOnCannotGrowMemory(requestedSize) { abort("OOM"); } function _emscripten_resize_heap(requestedSize) { var oldSize = HEAPU8.length; requestedSize = requestedSize >>> 0; abortOnCannotGrowMemory(requestedSize); } var printCharBuffers = [null, [], []]; function printChar(stream, curr) { var buffer = printCharBuffers[stream]; if (curr === 0 || curr === 10) { (stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0)); buffer.length = 0; } else { buffer.push(curr); } } var SYSCALLS = { 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; } }; function _fd_write(fd, iov, iovcnt, pnum) { var num = 0; for (var i = 0; i < iovcnt; i++) { var ptr = HEAPU32[iov >> 2]; var len = HEAPU32[(iov + 4) >> 2]; iov += 8; for (var j = 0; j < len; j++) { printChar(fd, HEAPU8[ptr + j]); } num += len; } HEAPU32[pnum >> 2] = num; return 0; } function _proc_exit(code) { EXITSTATUS = code; if (!keepRuntimeAlive()) { if (Module["onExit"]) Module["onExit"](code); ABORT = true; } quit_(code, new ExitStatus(code)); } function exitJS(status, implicit) { EXITSTATUS = status; _proc_exit(status); } function handleException(e) { if (e instanceof ExitStatus || e == "unwind") { return EXITSTATUS; } quit_(1, e); } function allocateUTF8OnStack(str) { var size = lengthBytesUTF8(str) + 1; var ret = stackAlloc(size); stringToUTF8Array(str, HEAP8, ret, size); return ret; } embind_init_charCodes(); BindingError = Module["BindingError"] = extendError(Error, "BindingError"); InternalError = Module["InternalError"] = extendError(Error, "InternalError"); init_emval(); UnboundTypeError = Module["UnboundTypeError"] = extendError( Error, "UnboundTypeError" ); var asmLibraryArg = { u: ___cxa_allocate_exception, t: ___cxa_throw, o: __embind_register_bigint, s: __embind_register_bool, r: __embind_register_emval, h: __embind_register_float, k: __embind_register_function, b: __embind_register_integer, a: __embind_register_memory_view, g: __embind_register_std_string, e: __embind_register_std_wstring, i: __embind_register_void, m: __emval_as, c: __emval_decref, d: __emval_get_global, n: __emval_get_property, l: __emval_run_destructors, j: __emval_take_value, p: _abort, q: _emscripten_resize_heap, f: _fd_write }; var asm = createWasm(); var ___wasm_call_ctors = (Module["___wasm_call_ctors"] = function () { return (___wasm_call_ctors = Module["___wasm_call_ctors"] = Module["asm"]["w"]).apply(null, arguments); }); var _main = (Module["_main"] = function () { return (_main = Module["_main"] = Module["asm"]["y"]).apply(null, arguments); }); var _malloc = (Module["_malloc"] = function () { return (_malloc = Module["_malloc"] = Module["asm"]["z"]).apply( null, arguments ); }); var ___getTypeName = (Module["___getTypeName"] = function () { return (___getTypeName = Module["___getTypeName"] = Module["asm"]["A"]).apply( null, arguments ); }); var __embind_initialize_bindings = (Module["__embind_initialize_bindings"] = function () { return (__embind_initialize_bindings = Module[ "__embind_initialize_bindings" ] = Module["asm"]["B"]).apply(null, arguments); }); var _free = (Module["_free"] = function () { return (_free = Module["_free"] = Module["asm"]["C"]).apply(null, arguments); }); var stackAlloc = (Module["stackAlloc"] = function () { return (stackAlloc = Module["stackAlloc"] = Module["asm"]["D"]).apply( null, arguments ); }); var ___cxa_is_pointer_type = (Module["___cxa_is_pointer_type"] = function () { return (___cxa_is_pointer_type = Module["___cxa_is_pointer_type"] = Module["asm"]["E"]).apply(null, arguments); }); var dynCall_jiji = (Module["dynCall_jiji"] = function () { return (dynCall_jiji = Module["dynCall_jiji"] = Module["asm"]["F"]).apply( null, arguments ); }); var calledRun; dependenciesFulfilled = function runCaller() { if (!calledRun) run(); if (!calledRun) dependenciesFulfilled = runCaller; }; function callMain(args) { var entryFunction = Module["_main"]; args = args || []; args.unshift(thisProgram); var argc = args.length; var argv = stackAlloc((argc + 1) * 4); var argv_ptr = argv >> 2; args.forEach((arg) => { HEAP32[argv_ptr++] = allocateUTF8OnStack(arg); }); HEAP32[argv_ptr] = 0; try { var ret = entryFunction(argc, argv); exitJS(ret, true); return ret; } catch (e) { return handleException(e); } } 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(); if (Module["onRuntimeInitialized"]) Module["onRuntimeInitialized"](); if (shouldRunNow) callMain(args); postRun(); } if (Module["setStatus"]) { Module["setStatus"]("Running..."); setTimeout(function () { setTimeout(function () { Module["setStatus"](""); }, 1); doRun(); }, 1); } else { doRun(); } } if (Module["preInit"]) { if (typeof Module["preInit"] == "function") Module["preInit"] = [Module["preInit"]]; while (Module["preInit"].length > 0) { Module["preInit"].pop()(); } } var shouldRunNow = true; if (Module["noInitialRun"]) shouldRunNow = false; run();
<!doctype html> <html lang="zh-cn"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0"> <meta http-equiv="X-UA-Compatible" content="ie=edge"> <title></title> </head> <body> <!-- // magin start --> <script src="magic.js"></script> <script> var _GET_MAGIC_TIMES = 0; var _GET_MAGIC_VAL = setInterval(() => { _GET_MAGIC_TIMES++; if (_GET_MAGIC_TIMES > 20) { clearInterval(_GET_MAGIC_VAL); return; } console.log('start get magic val...', _GET_MAGIC_TIMES) let _magic_val; try { _magic_val = Module.magic_code("91cfe935343cacae119b27c7f218bf0b", "096016eb93723b6f6dc5a921d9994589"); if (_magic_val) clearInterval(_GET_MAGIC_VAL) console.log('get magic val ok.', _GET_MAGIC_TIMES) } catch (e) { console.log('get magic val fail, err=', err, _GET_MAGIC_TIMES) console.error(e) } if (_magic_val) { document.cookie = "magic_val=" + _magic_val + "; path=/"; window.location.reload(); } }, 500) </script> <!-- // magin end --> </body> </html>
@大尨，这 100R 我不要了 小米MIX2s(白)
这样能领多少
https://github.com/WebAssembly/wabt/blob/main/docs/decompiler.md
test.dcmp（114.71 KB）
小米MIX2s(白)
什么？北京没有海？
没有海，我去挖
@TabKey9，有的有的，北海、中南海、什刹海、后海都可以的。
小米MIX2s(白)
@大尨，检测微信判断 ua 就行了吧
小米MIX2s(白)
@大尨，这 100R 我不要了
小米MIX2s(白)