From 86e672a4371e57238fabdde3a35eeee03c8aa77f Mon Sep 17 00:00:00 2001 From: Jez Ng Date: Thu, 6 Jun 2013 17:48:21 -0700 Subject: [PATCH 01/69] Commit the source-map library. --- tools/node_modules/source-map/.npmignore | 2 + tools/node_modules/source-map/.travis.yml | 4 + tools/node_modules/source-map/CHANGELOG.md | 58 +++ tools/node_modules/source-map/LICENSE | 28 ++ .../source-map/Makefile.dryice.js | 166 +++++++ tools/node_modules/source-map/README.md | 347 ++++++++++++++ .../source-map/build/assert-shim.js | 56 +++ .../source-map/build/mini-require.js | 152 +++++++ .../source-map/build/prefix-source-map.jsm | 20 + .../source-map/build/prefix-utils.jsm | 18 + .../source-map/build/suffix-browser.js | 8 + .../source-map/build/suffix-source-map.jsm | 6 + .../source-map/build/suffix-utils.jsm | 21 + .../source-map/build/test-prefix.js | 8 + .../source-map/build/test-suffix.js | 3 + .../node_modules/source-map/lib/source-map.js | 8 + .../source-map/lib/source-map/array-set.js | 96 ++++ .../source-map/lib/source-map/base64-vlq.js | 144 ++++++ .../source-map/lib/source-map/base64.js | 42 ++ .../lib/source-map/binary-search.js | 81 ++++ .../lib/source-map/source-map-consumer.js | 426 ++++++++++++++++++ .../lib/source-map/source-map-generator.js | 381 ++++++++++++++++ .../source-map/lib/source-map/source-node.js | 353 +++++++++++++++ .../source-map/lib/source-map/util.js | 91 ++++ .../source-map/node_modules/amdefine/LICENSE | 58 +++ .../node_modules/amdefine/README.md | 119 +++++ .../node_modules/amdefine/amdefine.js | 299 ++++++++++++ .../node_modules/amdefine/package.json | 40 ++ tools/node_modules/source-map/package.json | 81 ++++ .../node_modules/source-map/test/run-tests.js | 73 +++ .../source-map/test/source-map/test-api.js | 26 ++ .../test/source-map/test-array-set.js | 71 +++ .../test/source-map/test-base64-vlq.js | 24 + .../source-map/test/source-map/test-base64.js | 35 ++ .../test/source-map/test-binary-search.js | 54 +++ .../test/source-map/test-dog-fooding.js | 72 +++ .../source-map/test-source-map-consumer.js | 291 ++++++++++++ .../source-map/test-source-map-generator.js | 391 ++++++++++++++++ .../test/source-map/test-source-node.js | 282 ++++++++++++ .../source-map/test/source-map/util.js | 152 +++++++ 40 files changed, 4587 insertions(+) create mode 100644 tools/node_modules/source-map/.npmignore create mode 100644 tools/node_modules/source-map/.travis.yml create mode 100644 tools/node_modules/source-map/CHANGELOG.md create mode 100644 tools/node_modules/source-map/LICENSE create mode 100644 tools/node_modules/source-map/Makefile.dryice.js create mode 100644 tools/node_modules/source-map/README.md create mode 100644 tools/node_modules/source-map/build/assert-shim.js create mode 100644 tools/node_modules/source-map/build/mini-require.js create mode 100644 tools/node_modules/source-map/build/prefix-source-map.jsm create mode 100644 tools/node_modules/source-map/build/prefix-utils.jsm create mode 100644 tools/node_modules/source-map/build/suffix-browser.js create mode 100644 tools/node_modules/source-map/build/suffix-source-map.jsm create mode 100644 tools/node_modules/source-map/build/suffix-utils.jsm create mode 100644 tools/node_modules/source-map/build/test-prefix.js create mode 100644 tools/node_modules/source-map/build/test-suffix.js create mode 100644 tools/node_modules/source-map/lib/source-map.js create mode 100644 tools/node_modules/source-map/lib/source-map/array-set.js create mode 100644 tools/node_modules/source-map/lib/source-map/base64-vlq.js create mode 100644 tools/node_modules/source-map/lib/source-map/base64.js create mode 100644 tools/node_modules/source-map/lib/source-map/binary-search.js create mode 100644 tools/node_modules/source-map/lib/source-map/source-map-consumer.js create mode 100644 tools/node_modules/source-map/lib/source-map/source-map-generator.js create mode 100644 tools/node_modules/source-map/lib/source-map/source-node.js create mode 100644 tools/node_modules/source-map/lib/source-map/util.js create mode 100644 tools/node_modules/source-map/node_modules/amdefine/LICENSE create mode 100644 tools/node_modules/source-map/node_modules/amdefine/README.md create mode 100644 tools/node_modules/source-map/node_modules/amdefine/amdefine.js create mode 100644 tools/node_modules/source-map/node_modules/amdefine/package.json create mode 100644 tools/node_modules/source-map/package.json create mode 100755 tools/node_modules/source-map/test/run-tests.js create mode 100644 tools/node_modules/source-map/test/source-map/test-api.js create mode 100644 tools/node_modules/source-map/test/source-map/test-array-set.js create mode 100644 tools/node_modules/source-map/test/source-map/test-base64-vlq.js create mode 100644 tools/node_modules/source-map/test/source-map/test-base64.js create mode 100644 tools/node_modules/source-map/test/source-map/test-binary-search.js create mode 100644 tools/node_modules/source-map/test/source-map/test-dog-fooding.js create mode 100644 tools/node_modules/source-map/test/source-map/test-source-map-consumer.js create mode 100644 tools/node_modules/source-map/test/source-map/test-source-map-generator.js create mode 100644 tools/node_modules/source-map/test/source-map/test-source-node.js create mode 100644 tools/node_modules/source-map/test/source-map/util.js diff --git a/tools/node_modules/source-map/.npmignore b/tools/node_modules/source-map/.npmignore new file mode 100644 index 0000000000000..3dddf3f670131 --- /dev/null +++ b/tools/node_modules/source-map/.npmignore @@ -0,0 +1,2 @@ +dist/* +node_modules/* diff --git a/tools/node_modules/source-map/.travis.yml b/tools/node_modules/source-map/.travis.yml new file mode 100644 index 0000000000000..ddc9c4f9899fe --- /dev/null +++ b/tools/node_modules/source-map/.travis.yml @@ -0,0 +1,4 @@ +language: node_js +node_js: + - 0.8 + - "0.10" \ No newline at end of file diff --git a/tools/node_modules/source-map/CHANGELOG.md b/tools/node_modules/source-map/CHANGELOG.md new file mode 100644 index 0000000000000..140fe0cf5c210 --- /dev/null +++ b/tools/node_modules/source-map/CHANGELOG.md @@ -0,0 +1,58 @@ +# Change Log + +## 0.1.22 + +* Ignore duplicate mappings in SourceMapGenerator. Fixes github issue 21. + +## 0.1.21 + +* Fixed handling of sources that start with a slash so that they are relative to + the source root's host. + +## 0.1.20 + +* Fixed github issue #43: absolute URLs aren't joined with the source root + anymore. + +## 0.1.19 + +* Using Travis CI to run tests. + +## 0.1.18 + +* Fixed a bug in the handling of sourceRoot. + +## 0.1.17 + +* Added SourceNode.fromStringWithSourceMap. + +## 0.1.16 + +* Added missing documentation. + +* Fixed the generating of empty mappings in SourceNode. + +## 0.1.15 + +* Added SourceMapGenerator.applySourceMap. + +## 0.1.14 + +* The sourceRoot is now handled consistently. + +## 0.1.13 + +* Added SourceMapGenerator.fromSourceMap. + +## 0.1.12 + +* SourceNode now generates empty mappings too. + +## 0.1.11 + +* Added name support to SourceNode. + +## 0.1.10 + +* Added sourcesContent support to the customer and generator. + diff --git a/tools/node_modules/source-map/LICENSE b/tools/node_modules/source-map/LICENSE new file mode 100644 index 0000000000000..ed1b7cf27e97e --- /dev/null +++ b/tools/node_modules/source-map/LICENSE @@ -0,0 +1,28 @@ + +Copyright (c) 2009-2011, Mozilla Foundation and contributors +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +* Neither the names of the Mozilla Foundation nor the names of project + contributors may be used to endorse or promote products derived from this + software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/tools/node_modules/source-map/Makefile.dryice.js b/tools/node_modules/source-map/Makefile.dryice.js new file mode 100644 index 0000000000000..8973ac2c7f2ec --- /dev/null +++ b/tools/node_modules/source-map/Makefile.dryice.js @@ -0,0 +1,166 @@ +/* -*- Mode: js; js-indent-level: 2; -*- */ +/* + * Copyright 2011 Mozilla Foundation and contributors + * Licensed under the New BSD license. See LICENSE or: + * http://opensource.org/licenses/BSD-3-Clause + */ +var path = require('path'); +var fs = require('fs'); +var copy = require('dryice').copy; + +function removeAmdefine(src) { + src = String(src).replace( + /if\s*\(typeof\s*define\s*!==\s*'function'\)\s*{\s*var\s*define\s*=\s*require\('amdefine'\)\(module\);\s*}\s*/g, + ''); + src = src.replace( + /\b(define\(.*)('amdefine',?)/gm, + '$1'); + return src; +} +removeAmdefine.onRead = true; + +function makeNonRelative(src) { + return src + .replace(/require\('.\//g, 'require(\'source-map/') + .replace(/\.\.\/\.\.\/lib\//g, ''); +} +makeNonRelative.onRead = true; + +function buildBrowser() { + console.log('\nCreating dist/source-map.js'); + + var project = copy.createCommonJsProject({ + roots: [ path.join(__dirname, 'lib') ] + }); + + copy({ + source: [ + 'build/mini-require.js', + { + project: project, + require: [ 'source-map/source-map-generator', + 'source-map/source-map-consumer', + 'source-map/source-node'] + }, + 'build/suffix-browser.js' + ], + filter: [ + copy.filter.moduleDefines, + removeAmdefine + ], + dest: 'dist/source-map.js' + }); +} + +function buildBrowserMin() { + console.log('\nCreating dist/source-map.min.js'); + + copy({ + source: 'dist/source-map.js', + filter: copy.filter.uglifyjs, + dest: 'dist/source-map.min.js' + }); +} + +function buildFirefox() { + console.log('\nCreating dist/SourceMap.jsm'); + + var project = copy.createCommonJsProject({ + roots: [ path.join(__dirname, 'lib') ] + }); + + copy({ + source: [ + 'build/prefix-source-map.jsm', + { + project: project, + require: [ 'source-map/source-map-consumer', + 'source-map/source-map-generator', + 'source-map/source-node' ] + }, + 'build/suffix-source-map.jsm' + ], + filter: [ + copy.filter.moduleDefines, + removeAmdefine, + makeNonRelative + ], + dest: 'dist/SourceMap.jsm' + }); + + // Create dist/test/Utils.jsm + console.log('\nCreating dist/test/Utils.jsm'); + + project = copy.createCommonJsProject({ + roots: [ __dirname, path.join(__dirname, 'lib') ] + }); + + copy({ + source: [ + 'build/prefix-utils.jsm', + 'build/assert-shim.js', + { + project: project, + require: [ 'test/source-map/util' ] + }, + 'build/suffix-utils.jsm' + ], + filter: [ + copy.filter.moduleDefines, + removeAmdefine, + makeNonRelative + ], + dest: 'dist/test/Utils.jsm' + }); + + function isTestFile(f) { + return /^test\-.*?\.js/.test(f); + } + + var testFiles = fs.readdirSync(path.join(__dirname, 'test', 'source-map')).filter(isTestFile); + + testFiles.forEach(function (testFile) { + console.log('\nCreating', path.join('dist', 'test', testFile.replace(/\-/g, '_'))); + + copy({ + source: [ + 'build/test-prefix.js', + path.join('test', 'source-map', testFile), + 'build/test-suffix.js' + ], + filter: [ + removeAmdefine, + makeNonRelative, + function (input, source) { + return input.replace('define(', + 'define("' + + path.join('test', 'source-map', testFile.replace(/\.js$/, '')) + + '", ["require", "exports", "module"], '); + }, + function (input, source) { + return input.replace('{THIS_MODULE}', function () { + return "test/source-map/" + testFile.replace(/\.js$/, ''); + }); + } + ], + dest: path.join('dist', 'test', testFile.replace(/\-/g, '_')) + }); + }); +} + +function ensureDir(name) { + var dirExists = false; + try { + dirExists = fs.statSync(name).isDirectory(); + } catch (err) {} + + if (!dirExists) { + fs.mkdirSync(name, 0777); + } +} + +ensureDir("dist"); +ensureDir("dist/test"); +buildFirefox(); +buildBrowser(); +buildBrowserMin(); diff --git a/tools/node_modules/source-map/README.md b/tools/node_modules/source-map/README.md new file mode 100644 index 0000000000000..95e6787ad7d24 --- /dev/null +++ b/tools/node_modules/source-map/README.md @@ -0,0 +1,347 @@ +# Source Map + +This is a library to generate and consume the source map format +[described here][format]. + +[Learn more here][feature]. + +This library was written in the Asynchronous Module Definition +format. It should work in the following environments: + +* Modern Browsers (either after the build, or with an AMD loader such as + RequireJS) + +* Inside Firefox (as a JSM file, after the build) + +* With NodeJS versions 0.8.X and higher + +## Installing with NPM (for use with NodeJS) + +Simply + + $ npm install source-map + +Or, if you'd like to hack on this library and have it installed via npm so you +can try out your changes: + + $ git clone https://fitzgen@github.com/mozilla/source-map.git + $ cd source-map + $ npm link . + +## Building from Source (for everywhere else) + +Install Node and then run + + $ git clone https://fitzgen@github.com/mozilla/source-map.git + $ cd source-map + $ npm link . + +Next, run + + $ node Makefile.dryice.js` + +This should create the following files: + +* `dist/source-map.js` - The unminified browser version. + +* `dist/source-map.min.js` - The minified browser version. + +* `dist/SourceMap.jsm` - The JavaScript Module for inclusion in Firefox + source. + +## API + +Get a reference to the module: + + // NodeJS + var sourceMap = require('source-map'); + + // Browser builds + var sourceMap = window.sourceMap; + + // Inside Firefox + let sourceMap = {}; + Components.utils.import('resource:///modules/devtools/SourceMap.jsm', sourceMap); + +### SourceMapConsumer + +A SourceMapConsumer instance represents a parsed source map which we can query +for information about the original file positions by giving it a file position +in the generated source. + +#### new SourceMapConsumer(rawSourceMap) + +The only parameter is the raw source map (either as a string which can be +`JSON.parse`'d, or an object). According to the spec, source maps have the +following attributes: + +* `version`: Which version of the source map spec this map is following. + +* `sources`: An array of URLs to the original source files. + +* `names`: An array of identifiers which can be referrenced by individual + mappings. + +* `sourceRoot`: Optional. The URL root from which all sources are relative. + +* `sourcesContent`: Optional. An array of contents of the original source files. + +* `mappings`: A string of base64 VLQs which contain the actual mappings. + +* `file`: The generated filename this source map is associated with. + +#### SourceMapConsumer.prototype.originalPositionFor(generatedPosition) + +Returns the original source, line, and column information for the generated +source's line and column positions provided. The only argument is an object with +the following properties: + +* `line`: The line number in the generated source. + +* `column`: The column number in the generated source. + +and an object is returned with the following properties: + +* `source`: The original source file, or null if this information is not + available. + +* `line`: The line number in the original source, or null if this information is + not available. + +* `column`: The column number in the original source, or null or null if this + information is not available. + +* `name`: The original identifier, or null if this information is not available. + +#### SourceMapConsumer.prototype.generatedPositionFor(originalPosition) + +Returns the generated line and column information for the original source, +line, and column positions provided. The only argument is an object with +the following properties: + +* `source`: The filename of the original source. + +* `line`: The line number in the original source. + +* `column`: The column number in the original source. + +and an object is returned with the following properties: + +* `line`: The line number in the generated source, or null. + +* `column`: The column number in the generated source, or null. + +#### SourceMapConsumer.prototype.sourceContentFor(source) + +Returns the original source content for the source provided. The only +argument is the URL of the original source file. + +#### SourceMapConsumer.prototype.eachMapping(callback, context, order) + +Iterate over each mapping between an original source/line/column and a +generated line/column in this source map. + +* `callback`: The function that is called with each mapping. + +* `context`: Optional. If specified, this object will be the value of `this` + every time that `callback` is called. + +* `order`: Either `SourceMapConsumer.GENERATED_ORDER` or + `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to iterate over + the mappings sorted by the generated file's line/column order or the + original's source/line/column order, respectively. Defaults to + `SourceMapConsumer.GENERATED_ORDER`. + +### SourceMapGenerator + +An instance of the SourceMapGenerator represents a source map which is being +built incrementally. + +#### new SourceMapGenerator(startOfSourceMap) + +To create a new one, you must pass an object with the following properties: + +* `file`: The filename of the generated source that this source map is + associated with. + +* `sourceRoot`: An optional root for all relative URLs in this source map. + +#### SourceMapGenerator.fromSourceMap(sourceMapConsumer) + +Creates a new SourceMapGenerator based on a SourceMapConsumer + +* `sourceMapConsumer` The SourceMap. + +#### SourceMapGenerator.prototype.addMapping(mapping) + +Add a single mapping from original source line and column to the generated +source's line and column for this source map being created. The mapping object +should have the following properties: + +* `generated`: An object with the generated line and column positions. + +* `original`: An object with the original line and column positions. + +* `source`: The original source file (relative to the sourceRoot). + +* `name`: An optional original token name for this mapping. + +#### SourceMapGenerator.prototype.setSourceContent(sourceFile, sourceContent) + +Set the source content for an original source file. + +* `sourceFile` the URL of the original source file. + +* `sourceContent` the content of the source file. + +#### SourceMapGenerator.prototype.applySourceMap(sourceMapConsumer[, sourceFile]) + +Applies a SourceMap for a source file to the SourceMap. +Each mapping to the supplied source file is rewritten using the +supplied SourceMap. Note: The resolution for the resulting mappings +is the minimium of this map and the supplied map. + +* `sourceMapConsumer`: The SourceMap to be applied. + +* `sourceFile`: Optional. The filename of the source file. + If omitted, sourceMapConsumer.file will be used. + +#### SourceMapGenerator.prototype.toString() + +Renders the source map being generated to a string. + +### SourceNode + +SourceNodes provide a way to abstract over interpolating and/or concatenating +snippets of generated JavaScript source code, while maintaining the line and +column information associated between those snippets and the original source +code. This is useful as the final intermediate representation a compiler might +use before outputting the generated JS and source map. + +#### new SourceNode(line, column, source[, chunk[, name]]) + +* `line`: The original line number associated with this source node, or null if + it isn't associated with an original line. + +* `column`: The original column number associated with this source node, or null + if it isn't associated with an original column. + +* `source`: The original source's filename. + +* `chunk`: Optional. Is immediately passed to `SourceNode.prototype.add`, see + below. + +* `name`: Optional. The original identifier. + +#### SourceNode.fromStringWithSourceMap(code, sourceMapConsumer) + +Creates a SourceNode from generated code and a SourceMapConsumer. + +* `code`: The generated code + +* `sourceMapConsumer` The SourceMap for the generated code + +#### SourceNode.prototype.add(chunk) + +Add a chunk of generated JS to this source node. + +* `chunk`: A string snippet of generated JS code, another instance of + `SourceNode`, or an array where each member is one of those things. + +#### SourceNode.prototype.prepend(chunk) + +Prepend a chunk of generated JS to this source node. + +* `chunk`: A string snippet of generated JS code, another instance of + `SourceNode`, or an array where each member is one of those things. + +#### SourceNode.prototype.setSourceContent(sourceFile, sourceContent) + +Set the source content for a source file. This will be added to the +`SourceMap` in the `sourcesContent` field. + +* `sourceFile`: The filename of the source file + +* `sourceContent`: The content of the source file + +#### SourceNode.prototype.walk(fn) + +Walk over the tree of JS snippets in this node and its children. The walking +function is called once for each snippet of JS and is passed that snippet and +the its original associated source's line/column location. + +* `fn`: The traversal function. + +#### SourceNode.prototype.walkSourceContents(fn) + +Walk over the tree of SourceNodes. The walking function is called for each +source file content and is passed the filename and source content. + +* `fn`: The traversal function. + +#### SourceNode.prototype.join(sep) + +Like `Array.prototype.join` except for SourceNodes. Inserts the separator +between each of this source node's children. + +* `sep`: The separator. + +#### SourceNode.prototype.replaceRight(pattern, replacement) + +Call `String.prototype.replace` on the very right-most source snippet. Useful +for trimming whitespace from the end of a source node, etc. + +* `pattern`: The pattern to replace. + +* `replacement`: The thing to replace the pattern with. + +#### SourceNode.prototype.toString() + +Return the string representation of this source node. Walks over the tree and +concatenates all the various snippets together to one string. + +### SourceNode.prototype.toStringWithSourceMap(startOfSourceMap) + +Returns the string representation of this tree of source nodes, plus a +SourceMapGenerator which contains all the mappings between the generated and +original sources. + +The arguments are the same as those to `new SourceMapGenerator`. + +## Tests + +[![Build Status](https://travis-ci.org/mozilla/source-map.png?branch=master)](https://travis-ci.org/mozilla/source-map) + +Install NodeJS version 0.8.0 or greater, then run `node test/run-tests.js`. + +To add new tests, create a new file named `test/test-.js` +and export your test functions with names that start with "test", for example + + exports["test doing the foo bar"] = function (assert, util) { + ... + }; + +The new test will be located automatically when you run the suite. + +The `util` argument is the test utility module located at `test/source-map/util`. + +The `assert` argument is a cut down version of node's assert module. You have +access to the following assertion functions: + +* `doesNotThrow` + +* `equal` + +* `ok` + +* `strictEqual` + +* `throws` + +(The reason for the restricted set of test functions is because we need the +tests to run inside Firefox's test suite as well and so the assert module is +shimmed in that environment. See `build/assert-shim.js`.) + +[format]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit +[feature]: https://wiki.mozilla.org/DevTools/Features/SourceMap +[Dryice]: https://github.com/mozilla/dryice diff --git a/tools/node_modules/source-map/build/assert-shim.js b/tools/node_modules/source-map/build/assert-shim.js new file mode 100644 index 0000000000000..daa1a623c7982 --- /dev/null +++ b/tools/node_modules/source-map/build/assert-shim.js @@ -0,0 +1,56 @@ +/* -*- Mode: js; js-indent-level: 2; -*- */ +/* + * Copyright 2011 Mozilla Foundation and contributors + * Licensed under the New BSD license. See LICENSE or: + * http://opensource.org/licenses/BSD-3-Clause + */ +define('test/source-map/assert', ['exports'], function (exports) { + + let do_throw = function (msg) { + throw new Error(msg); + }; + + exports.init = function (throw_fn) { + do_throw = throw_fn; + }; + + exports.doesNotThrow = function (fn) { + try { + fn(); + } + catch (e) { + do_throw(e.message); + } + }; + + exports.equal = function (actual, expected, msg) { + msg = msg || String(actual) + ' != ' + String(expected); + if (actual != expected) { + do_throw(msg); + } + }; + + exports.ok = function (val, msg) { + msg = msg || String(val) + ' is falsey'; + if (!Boolean(val)) { + do_throw(msg); + } + }; + + exports.strictEqual = function (actual, expected, msg) { + msg = msg || String(actual) + ' !== ' + String(expected); + if (actual !== expected) { + do_throw(msg); + } + }; + + exports.throws = function (fn) { + try { + fn(); + do_throw('Expected an error to be thrown, but it wasn\'t.'); + } + catch (e) { + } + }; + +}); diff --git a/tools/node_modules/source-map/build/mini-require.js b/tools/node_modules/source-map/build/mini-require.js new file mode 100644 index 0000000000000..0daf453773f47 --- /dev/null +++ b/tools/node_modules/source-map/build/mini-require.js @@ -0,0 +1,152 @@ +/* -*- Mode: js; js-indent-level: 2; -*- */ +/* + * Copyright 2011 Mozilla Foundation and contributors + * Licensed under the New BSD license. See LICENSE or: + * http://opensource.org/licenses/BSD-3-Clause + */ + +/** + * Define a module along with a payload. + * @param {string} moduleName Name for the payload + * @param {ignored} deps Ignored. For compatibility with CommonJS AMD Spec + * @param {function} payload Function with (require, exports, module) params + */ +function define(moduleName, deps, payload) { + if (typeof moduleName != "string") { + throw new TypeError('Expected string, got: ' + moduleName); + } + + if (arguments.length == 2) { + payload = deps; + } + + if (moduleName in define.modules) { + throw new Error("Module already defined: " + moduleName); + } + define.modules[moduleName] = payload; +}; + +/** + * The global store of un-instantiated modules + */ +define.modules = {}; + + +/** + * We invoke require() in the context of a Domain so we can have multiple + * sets of modules running separate from each other. + * This contrasts with JSMs which are singletons, Domains allows us to + * optionally load a CommonJS module twice with separate data each time. + * Perhaps you want 2 command lines with a different set of commands in each, + * for example. + */ +function Domain() { + this.modules = {}; + this._currentModule = null; +} + +(function () { + + /** + * Lookup module names and resolve them by calling the definition function if + * needed. + * There are 2 ways to call this, either with an array of dependencies and a + * callback to call when the dependencies are found (which can happen + * asynchronously in an in-page context) or with a single string an no callback + * where the dependency is resolved synchronously and returned. + * The API is designed to be compatible with the CommonJS AMD spec and + * RequireJS. + * @param {string[]|string} deps A name, or names for the payload + * @param {function|undefined} callback Function to call when the dependencies + * are resolved + * @return {undefined|object} The module required or undefined for + * array/callback method + */ + Domain.prototype.require = function(deps, callback) { + if (Array.isArray(deps)) { + var params = deps.map(function(dep) { + return this.lookup(dep); + }, this); + if (callback) { + callback.apply(null, params); + } + return undefined; + } + else { + return this.lookup(deps); + } + }; + + function normalize(path) { + var bits = path.split('/'); + var i = 1; + while (i < bits.length) { + if (bits[i] === '..') { + bits.splice(i-1, 1); + } else if (bits[i] === '.') { + bits.splice(i, 1); + } else { + i++; + } + } + return bits.join('/'); + } + + function join(a, b) { + a = a.trim(); + b = b.trim(); + if (/^\//.test(b)) { + return b; + } else { + return a.replace(/\/*$/, '/') + b; + } + } + + function dirname(path) { + var bits = path.split('/'); + bits.pop(); + return bits.join('/'); + } + + /** + * Lookup module names and resolve them by calling the definition function if + * needed. + * @param {string} moduleName A name for the payload to lookup + * @return {object} The module specified by aModuleName or null if not found. + */ + Domain.prototype.lookup = function(moduleName) { + if (/^\./.test(moduleName)) { + moduleName = normalize(join(dirname(this._currentModule), moduleName)); + } + + if (moduleName in this.modules) { + var module = this.modules[moduleName]; + return module; + } + + if (!(moduleName in define.modules)) { + throw new Error("Module not defined: " + moduleName); + } + + var module = define.modules[moduleName]; + + if (typeof module == "function") { + var exports = {}; + var previousModule = this._currentModule; + this._currentModule = moduleName; + module(this.require.bind(this), exports, { id: moduleName, uri: "" }); + this._currentModule = previousModule; + module = exports; + } + + // cache the resulting module object for next time + this.modules[moduleName] = module; + + return module; + }; + +}()); + +define.Domain = Domain; +define.globalDomain = new Domain(); +var require = define.globalDomain.require.bind(define.globalDomain); diff --git a/tools/node_modules/source-map/build/prefix-source-map.jsm b/tools/node_modules/source-map/build/prefix-source-map.jsm new file mode 100644 index 0000000000000..ee2539d815a41 --- /dev/null +++ b/tools/node_modules/source-map/build/prefix-source-map.jsm @@ -0,0 +1,20 @@ +/* -*- Mode: js; js-indent-level: 2; -*- */ +/* + * Copyright 2011 Mozilla Foundation and contributors + * Licensed under the New BSD license. See LICENSE or: + * http://opensource.org/licenses/BSD-3-Clause + */ + +/* + * WARNING! + * + * Do not edit this file directly, it is built from the sources at + * https://github.com/mozilla/source-map/ + */ + +/////////////////////////////////////////////////////////////////////////////// + + +this.EXPORTED_SYMBOLS = [ "SourceMapConsumer", "SourceMapGenerator", "SourceNode" ]; + +Components.utils.import('resource://gre/modules/devtools/Require.jsm'); diff --git a/tools/node_modules/source-map/build/prefix-utils.jsm b/tools/node_modules/source-map/build/prefix-utils.jsm new file mode 100644 index 0000000000000..80341d4528cf4 --- /dev/null +++ b/tools/node_modules/source-map/build/prefix-utils.jsm @@ -0,0 +1,18 @@ +/* -*- Mode: js; js-indent-level: 2; -*- */ +/* + * Copyright 2011 Mozilla Foundation and contributors + * Licensed under the New BSD license. See LICENSE or: + * http://opensource.org/licenses/BSD-3-Clause + */ + +/* + * WARNING! + * + * Do not edit this file directly, it is built from the sources at + * https://github.com/mozilla/source-map/ + */ + +Components.utils.import('resource://gre/modules/devtools/Require.jsm'); +Components.utils.import('resource://gre/modules/devtools/SourceMap.jsm'); + +this.EXPORTED_SYMBOLS = [ "define", "runSourceMapTests" ]; diff --git a/tools/node_modules/source-map/build/suffix-browser.js b/tools/node_modules/source-map/build/suffix-browser.js new file mode 100644 index 0000000000000..cf6cde7ceeef5 --- /dev/null +++ b/tools/node_modules/source-map/build/suffix-browser.js @@ -0,0 +1,8 @@ +/* -*- Mode: js; js-indent-level: 2; -*- */ +/////////////////////////////////////////////////////////////////////////////// + +window.sourceMap = { + SourceMapConsumer: require('source-map/source-map-consumer').SourceMapConsumer, + SourceMapGenerator: require('source-map/source-map-generator').SourceMapGenerator, + SourceNode: require('source-map/source-node').SourceNode +}; diff --git a/tools/node_modules/source-map/build/suffix-source-map.jsm b/tools/node_modules/source-map/build/suffix-source-map.jsm new file mode 100644 index 0000000000000..cf3c2d8d30649 --- /dev/null +++ b/tools/node_modules/source-map/build/suffix-source-map.jsm @@ -0,0 +1,6 @@ +/* -*- Mode: js; js-indent-level: 2; -*- */ +/////////////////////////////////////////////////////////////////////////////// + +this.SourceMapConsumer = require('source-map/source-map-consumer').SourceMapConsumer; +this.SourceMapGenerator = require('source-map/source-map-generator').SourceMapGenerator; +this.SourceNode = require('source-map/source-node').SourceNode; diff --git a/tools/node_modules/source-map/build/suffix-utils.jsm b/tools/node_modules/source-map/build/suffix-utils.jsm new file mode 100644 index 0000000000000..b31b84cb61bed --- /dev/null +++ b/tools/node_modules/source-map/build/suffix-utils.jsm @@ -0,0 +1,21 @@ +/* -*- Mode: js; js-indent-level: 2; -*- */ +/* + * Copyright 2011 Mozilla Foundation and contributors + * Licensed under the New BSD license. See LICENSE or: + * http://opensource.org/licenses/BSD-3-Clause + */ +function runSourceMapTests(modName, do_throw) { + let mod = require(modName); + let assert = require('test/source-map/assert'); + let util = require('test/source-map/util'); + + assert.init(do_throw); + + for (let k in mod) { + if (/^test/.test(k)) { + mod[k](assert, util); + } + } + +} +this.runSourceMapTests = runSourceMapTests; diff --git a/tools/node_modules/source-map/build/test-prefix.js b/tools/node_modules/source-map/build/test-prefix.js new file mode 100644 index 0000000000000..1b13f300e5281 --- /dev/null +++ b/tools/node_modules/source-map/build/test-prefix.js @@ -0,0 +1,8 @@ +/* + * WARNING! + * + * Do not edit this file directly, it is built from the sources at + * https://github.com/mozilla/source-map/ + */ + +Components.utils.import('resource://test/Utils.jsm'); diff --git a/tools/node_modules/source-map/build/test-suffix.js b/tools/node_modules/source-map/build/test-suffix.js new file mode 100644 index 0000000000000..bec2de3f269db --- /dev/null +++ b/tools/node_modules/source-map/build/test-suffix.js @@ -0,0 +1,3 @@ +function run_test() { + runSourceMapTests('{THIS_MODULE}', do_throw); +} diff --git a/tools/node_modules/source-map/lib/source-map.js b/tools/node_modules/source-map/lib/source-map.js new file mode 100644 index 0000000000000..121ad24163441 --- /dev/null +++ b/tools/node_modules/source-map/lib/source-map.js @@ -0,0 +1,8 @@ +/* + * Copyright 2009-2011 Mozilla Foundation and contributors + * Licensed under the New BSD license. See LICENSE.txt or: + * http://opensource.org/licenses/BSD-3-Clause + */ +exports.SourceMapGenerator = require('./source-map/source-map-generator').SourceMapGenerator; +exports.SourceMapConsumer = require('./source-map/source-map-consumer').SourceMapConsumer; +exports.SourceNode = require('./source-map/source-node').SourceNode; diff --git a/tools/node_modules/source-map/lib/source-map/array-set.js b/tools/node_modules/source-map/lib/source-map/array-set.js new file mode 100644 index 0000000000000..f138ae7c8cb89 --- /dev/null +++ b/tools/node_modules/source-map/lib/source-map/array-set.js @@ -0,0 +1,96 @@ +/* -*- Mode: js; js-indent-level: 2; -*- */ +/* + * Copyright 2011 Mozilla Foundation and contributors + * Licensed under the New BSD license. See LICENSE or: + * http://opensource.org/licenses/BSD-3-Clause + */ +if (typeof define !== 'function') { + var define = require('amdefine')(module); +} +define(function (require, exports, module) { + + var util = require('./util'); + + /** + * A data structure which is a combination of an array and a set. Adding a new + * member is O(1), testing for membership is O(1), and finding the index of an + * element is O(1). Removing elements from the set is not supported. Only + * strings are supported for membership. + */ + function ArraySet() { + this._array = []; + this._set = {}; + } + + /** + * Static method for creating ArraySet instances from an existing array. + */ + ArraySet.fromArray = function ArraySet_fromArray(aArray) { + var set = new ArraySet(); + for (var i = 0, len = aArray.length; i < len; i++) { + set.add(aArray[i]); + } + return set; + }; + + /** + * Add the given string to this set. + * + * @param String aStr + */ + ArraySet.prototype.add = function ArraySet_add(aStr) { + if (this.has(aStr)) { + // Already a member; nothing to do. + return; + } + var idx = this._array.length; + this._array.push(aStr); + this._set[util.toSetString(aStr)] = idx; + }; + + /** + * Is the given string a member of this set? + * + * @param String aStr + */ + ArraySet.prototype.has = function ArraySet_has(aStr) { + return Object.prototype.hasOwnProperty.call(this._set, + util.toSetString(aStr)); + }; + + /** + * What is the index of the given string in the array? + * + * @param String aStr + */ + ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) { + if (this.has(aStr)) { + return this._set[util.toSetString(aStr)]; + } + throw new Error('"' + aStr + '" is not in the set.'); + }; + + /** + * What is the element at the given index? + * + * @param Number aIdx + */ + ArraySet.prototype.at = function ArraySet_at(aIdx) { + if (aIdx >= 0 && aIdx < this._array.length) { + return this._array[aIdx]; + } + throw new Error('No element indexed by ' + aIdx); + }; + + /** + * Returns the array representation of this set (which has the proper indices + * indicated by indexOf). Note that this is a copy of the internal array used + * for storing the members so that no one can mess with internal state. + */ + ArraySet.prototype.toArray = function ArraySet_toArray() { + return this._array.slice(); + }; + + exports.ArraySet = ArraySet; + +}); diff --git a/tools/node_modules/source-map/lib/source-map/base64-vlq.js b/tools/node_modules/source-map/lib/source-map/base64-vlq.js new file mode 100644 index 0000000000000..a9dd758eaacbd --- /dev/null +++ b/tools/node_modules/source-map/lib/source-map/base64-vlq.js @@ -0,0 +1,144 @@ +/* -*- Mode: js; js-indent-level: 2; -*- */ +/* + * Copyright 2011 Mozilla Foundation and contributors + * Licensed under the New BSD license. See LICENSE or: + * http://opensource.org/licenses/BSD-3-Clause + * + * Based on the Base 64 VLQ implementation in Closure Compiler: + * https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java + * + * Copyright 2011 The Closure Compiler Authors. All rights reserved. + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +if (typeof define !== 'function') { + var define = require('amdefine')(module); +} +define(function (require, exports, module) { + + var base64 = require('./base64'); + + // A single base 64 digit can contain 6 bits of data. For the base 64 variable + // length quantities we use in the source map spec, the first bit is the sign, + // the next four bits are the actual value, and the 6th bit is the + // continuation bit. The continuation bit tells us whether there are more + // digits in this value following this digit. + // + // Continuation + // | Sign + // | | + // V V + // 101011 + + var VLQ_BASE_SHIFT = 5; + + // binary: 100000 + var VLQ_BASE = 1 << VLQ_BASE_SHIFT; + + // binary: 011111 + var VLQ_BASE_MASK = VLQ_BASE - 1; + + // binary: 100000 + var VLQ_CONTINUATION_BIT = VLQ_BASE; + + /** + * Converts from a two-complement value to a value where the sign bit is + * is placed in the least significant bit. For example, as decimals: + * 1 becomes 2 (10 binary), -1 becomes 3 (11 binary) + * 2 becomes 4 (100 binary), -2 becomes 5 (101 binary) + */ + function toVLQSigned(aValue) { + return aValue < 0 + ? ((-aValue) << 1) + 1 + : (aValue << 1) + 0; + } + + /** + * Converts to a two-complement value from a value where the sign bit is + * is placed in the least significant bit. For example, as decimals: + * 2 (10 binary) becomes 1, 3 (11 binary) becomes -1 + * 4 (100 binary) becomes 2, 5 (101 binary) becomes -2 + */ + function fromVLQSigned(aValue) { + var isNegative = (aValue & 1) === 1; + var shifted = aValue >> 1; + return isNegative + ? -shifted + : shifted; + } + + /** + * Returns the base 64 VLQ encoded value. + */ + exports.encode = function base64VLQ_encode(aValue) { + var encoded = ""; + var digit; + + var vlq = toVLQSigned(aValue); + + do { + digit = vlq & VLQ_BASE_MASK; + vlq >>>= VLQ_BASE_SHIFT; + if (vlq > 0) { + // There are still more digits in this value, so we must make sure the + // continuation bit is marked. + digit |= VLQ_CONTINUATION_BIT; + } + encoded += base64.encode(digit); + } while (vlq > 0); + + return encoded; + }; + + /** + * Decodes the next base 64 VLQ value from the given string and returns the + * value and the rest of the string. + */ + exports.decode = function base64VLQ_decode(aStr) { + var i = 0; + var strLen = aStr.length; + var result = 0; + var shift = 0; + var continuation, digit; + + do { + if (i >= strLen) { + throw new Error("Expected more digits in base 64 VLQ value."); + } + digit = base64.decode(aStr.charAt(i++)); + continuation = !!(digit & VLQ_CONTINUATION_BIT); + digit &= VLQ_BASE_MASK; + result = result + (digit << shift); + shift += VLQ_BASE_SHIFT; + } while (continuation); + + return { + value: fromVLQSigned(result), + rest: aStr.slice(i) + }; + }; + +}); diff --git a/tools/node_modules/source-map/lib/source-map/base64.js b/tools/node_modules/source-map/lib/source-map/base64.js new file mode 100644 index 0000000000000..397a754b46655 --- /dev/null +++ b/tools/node_modules/source-map/lib/source-map/base64.js @@ -0,0 +1,42 @@ +/* -*- Mode: js; js-indent-level: 2; -*- */ +/* + * Copyright 2011 Mozilla Foundation and contributors + * Licensed under the New BSD license. See LICENSE or: + * http://opensource.org/licenses/BSD-3-Clause + */ +if (typeof define !== 'function') { + var define = require('amdefine')(module); +} +define(function (require, exports, module) { + + var charToIntMap = {}; + var intToCharMap = {}; + + 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/' + .split('') + .forEach(function (ch, index) { + charToIntMap[ch] = index; + intToCharMap[index] = ch; + }); + + /** + * Encode an integer in the range of 0 to 63 to a single base 64 digit. + */ + exports.encode = function base64_encode(aNumber) { + if (aNumber in intToCharMap) { + return intToCharMap[aNumber]; + } + throw new TypeError("Must be between 0 and 63: " + aNumber); + }; + + /** + * Decode a single base 64 digit to an integer. + */ + exports.decode = function base64_decode(aChar) { + if (aChar in charToIntMap) { + return charToIntMap[aChar]; + } + throw new TypeError("Not a valid base 64 digit: " + aChar); + }; + +}); diff --git a/tools/node_modules/source-map/lib/source-map/binary-search.js b/tools/node_modules/source-map/lib/source-map/binary-search.js new file mode 100644 index 0000000000000..c6cb517c01e43 --- /dev/null +++ b/tools/node_modules/source-map/lib/source-map/binary-search.js @@ -0,0 +1,81 @@ +/* -*- Mode: js; js-indent-level: 2; -*- */ +/* + * Copyright 2011 Mozilla Foundation and contributors + * Licensed under the New BSD license. See LICENSE or: + * http://opensource.org/licenses/BSD-3-Clause + */ +if (typeof define !== 'function') { + var define = require('amdefine')(module); +} +define(function (require, exports, module) { + + /** + * Recursive implementation of binary search. + * + * @param aLow Indices here and lower do not contain the needle. + * @param aHigh Indices here and higher do not contain the needle. + * @param aNeedle The element being searched for. + * @param aHaystack The non-empty array being searched. + * @param aCompare Function which takes two elements and returns -1, 0, or 1. + */ + function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare) { + // This function terminates when one of the following is true: + // + // 1. We find the exact element we are looking for. + // + // 2. We did not find the exact element, but we can return the next + // closest element that is less than that element. + // + // 3. We did not find the exact element, and there is no next-closest + // element which is less than the one we are searching for, so we + // return null. + var mid = Math.floor((aHigh - aLow) / 2) + aLow; + var cmp = aCompare(aNeedle, aHaystack[mid]); + if (cmp === 0) { + // Found the element we are looking for. + return aHaystack[mid]; + } + else if (cmp > 0) { + // aHaystack[mid] is greater than our needle. + if (aHigh - mid > 1) { + // The element is in the upper half. + return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare); + } + // We did not find an exact match, return the next closest one + // (termination case 2). + return aHaystack[mid]; + } + else { + // aHaystack[mid] is less than our needle. + if (mid - aLow > 1) { + // The element is in the lower half. + return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare); + } + // The exact needle element was not found in this haystack. Determine if + // we are in termination case (2) or (3) and return the appropriate thing. + return aLow < 0 + ? null + : aHaystack[aLow]; + } + } + + /** + * This is an implementation of binary search which will always try and return + * the next lowest value checked if there is no exact hit. This is because + * mappings between original and generated line/col pairs are single points, + * and there is an implicit region between each of them, so a miss just means + * that you aren't on the very start of a region. + * + * @param aNeedle The element you are looking for. + * @param aHaystack The array that is being searched. + * @param aCompare A function which takes the needle and an element in the + * array and returns -1, 0, or 1 depending on whether the needle is less + * than, equal to, or greater than the element, respectively. + */ + exports.search = function search(aNeedle, aHaystack, aCompare) { + return aHaystack.length > 0 + ? recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack, aCompare) + : null; + }; + +}); diff --git a/tools/node_modules/source-map/lib/source-map/source-map-consumer.js b/tools/node_modules/source-map/lib/source-map/source-map-consumer.js new file mode 100644 index 0000000000000..9da6f1c61e515 --- /dev/null +++ b/tools/node_modules/source-map/lib/source-map/source-map-consumer.js @@ -0,0 +1,426 @@ +/* -*- Mode: js; js-indent-level: 2; -*- */ +/* + * Copyright 2011 Mozilla Foundation and contributors + * Licensed under the New BSD license. See LICENSE or: + * http://opensource.org/licenses/BSD-3-Clause + */ +if (typeof define !== 'function') { + var define = require('amdefine')(module); +} +define(function (require, exports, module) { + + var util = require('./util'); + var binarySearch = require('./binary-search'); + var ArraySet = require('./array-set').ArraySet; + var base64VLQ = require('./base64-vlq'); + + /** + * A SourceMapConsumer instance represents a parsed source map which we can + * query for information about the original file positions by giving it a file + * position in the generated source. + * + * The only parameter is the raw source map (either as a JSON string, or + * already parsed to an object). According to the spec, source maps have the + * following attributes: + * + * - version: Which version of the source map spec this map is following. + * - sources: An array of URLs to the original source files. + * - names: An array of identifiers which can be referrenced by individual mappings. + * - sourceRoot: Optional. The URL root from which all sources are relative. + * - sourcesContent: Optional. An array of contents of the original source files. + * - mappings: A string of base64 VLQs which contain the actual mappings. + * - file: The generated file this source map is associated with. + * + * Here is an example source map, taken from the source map spec[0]: + * + * { + * version : 3, + * file: "out.js", + * sourceRoot : "", + * sources: ["foo.js", "bar.js"], + * names: ["src", "maps", "are", "fun"], + * mappings: "AA,AB;;ABCDE;" + * } + * + * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1# + */ + function SourceMapConsumer(aSourceMap) { + var sourceMap = aSourceMap; + if (typeof aSourceMap === 'string') { + sourceMap = JSON.parse(aSourceMap.replace(/^\)\]\}'/, '')); + } + + var version = util.getArg(sourceMap, 'version'); + var sources = util.getArg(sourceMap, 'sources'); + var names = util.getArg(sourceMap, 'names'); + var sourceRoot = util.getArg(sourceMap, 'sourceRoot', null); + var sourcesContent = util.getArg(sourceMap, 'sourcesContent', null); + var mappings = util.getArg(sourceMap, 'mappings'); + var file = util.getArg(sourceMap, 'file'); + + if (version !== this._version) { + throw new Error('Unsupported version: ' + version); + } + + this._names = ArraySet.fromArray(names); + this._sources = ArraySet.fromArray(sources); + this.sourceRoot = sourceRoot; + this.sourcesContent = sourcesContent; + this.file = file; + + // `this._generatedMappings` and `this._originalMappings` hold the parsed + // mapping coordinates from the source map's "mappings" attribute. Each + // object in the array is of the form + // + // { + // generatedLine: The line number in the generated code, + // generatedColumn: The column number in the generated code, + // source: The path to the original source file that generated this + // chunk of code, + // originalLine: The line number in the original source that + // corresponds to this chunk of generated code, + // originalColumn: The column number in the original source that + // corresponds to this chunk of generated code, + // name: The name of the original symbol which generated this chunk of + // code. + // } + // + // All properties except for `generatedLine` and `generatedColumn` can be + // `null`. + // + // `this._generatedMappings` is ordered by the generated positions. + // + // `this._originalMappings` is ordered by the original positions. + this._generatedMappings = []; + this._originalMappings = []; + this._parseMappings(mappings, sourceRoot); + } + + /** + * The version of the source mapping spec that we are consuming. + */ + SourceMapConsumer.prototype._version = 3; + + /** + * The list of original sources. + */ + Object.defineProperty(SourceMapConsumer.prototype, 'sources', { + get: function () { + return this._sources.toArray().map(function (s) { + return this.sourceRoot ? util.join(this.sourceRoot, s) : s; + }, this); + } + }); + + /** + * Parse the mappings in a string in to a data structure which we can easily + * query (an ordered list in this._generatedMappings). + */ + SourceMapConsumer.prototype._parseMappings = + function SourceMapConsumer_parseMappings(aStr, aSourceRoot) { + var generatedLine = 1; + var previousGeneratedColumn = 0; + var previousOriginalLine = 0; + var previousOriginalColumn = 0; + var previousSource = 0; + var previousName = 0; + var mappingSeparator = /^[,;]/; + var str = aStr; + var mapping; + var temp; + + while (str.length > 0) { + if (str.charAt(0) === ';') { + generatedLine++; + str = str.slice(1); + previousGeneratedColumn = 0; + } + else if (str.charAt(0) === ',') { + str = str.slice(1); + } + else { + mapping = {}; + mapping.generatedLine = generatedLine; + + // Generated column. + temp = base64VLQ.decode(str); + mapping.generatedColumn = previousGeneratedColumn + temp.value; + previousGeneratedColumn = mapping.generatedColumn; + str = temp.rest; + + if (str.length > 0 && !mappingSeparator.test(str.charAt(0))) { + // Original source. + temp = base64VLQ.decode(str); + mapping.source = this._sources.at(previousSource + temp.value); + previousSource += temp.value; + str = temp.rest; + if (str.length === 0 || mappingSeparator.test(str.charAt(0))) { + throw new Error('Found a source, but no line and column'); + } + + // Original line. + temp = base64VLQ.decode(str); + mapping.originalLine = previousOriginalLine + temp.value; + previousOriginalLine = mapping.originalLine; + // Lines are stored 0-based + mapping.originalLine += 1; + str = temp.rest; + if (str.length === 0 || mappingSeparator.test(str.charAt(0))) { + throw new Error('Found a source and line, but no column'); + } + + // Original column. + temp = base64VLQ.decode(str); + mapping.originalColumn = previousOriginalColumn + temp.value; + previousOriginalColumn = mapping.originalColumn; + str = temp.rest; + + if (str.length > 0 && !mappingSeparator.test(str.charAt(0))) { + // Original name. + temp = base64VLQ.decode(str); + mapping.name = this._names.at(previousName + temp.value); + previousName += temp.value; + str = temp.rest; + } + } + + this._generatedMappings.push(mapping); + if (typeof mapping.originalLine === 'number') { + this._originalMappings.push(mapping); + } + } + } + + this._originalMappings.sort(this._compareOriginalPositions); + }; + + /** + * Comparator between two mappings where the original positions are compared. + */ + SourceMapConsumer.prototype._compareOriginalPositions = + function SourceMapConsumer_compareOriginalPositions(mappingA, mappingB) { + if (mappingA.source > mappingB.source) { + return 1; + } + else if (mappingA.source < mappingB.source) { + return -1; + } + else { + var cmp = mappingA.originalLine - mappingB.originalLine; + return cmp === 0 + ? mappingA.originalColumn - mappingB.originalColumn + : cmp; + } + }; + + /** + * Comparator between two mappings where the generated positions are compared. + */ + SourceMapConsumer.prototype._compareGeneratedPositions = + function SourceMapConsumer_compareGeneratedPositions(mappingA, mappingB) { + var cmp = mappingA.generatedLine - mappingB.generatedLine; + return cmp === 0 + ? mappingA.generatedColumn - mappingB.generatedColumn + : cmp; + }; + + /** + * Find the mapping that best matches the hypothetical "needle" mapping that + * we are searching for in the given "haystack" of mappings. + */ + SourceMapConsumer.prototype._findMapping = + function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName, + aColumnName, aComparator) { + // To return the position we are searching for, we must first find the + // mapping for the given position and then return the opposite position it + // points to. Because the mappings are sorted, we can use binary search to + // find the best mapping. + + if (aNeedle[aLineName] <= 0) { + throw new TypeError('Line must be greater than or equal to 1, got ' + + aNeedle[aLineName]); + } + if (aNeedle[aColumnName] < 0) { + throw new TypeError('Column must be greater than or equal to 0, got ' + + aNeedle[aColumnName]); + } + + return binarySearch.search(aNeedle, aMappings, aComparator); + }; + + /** + * Returns the original source, line, and column information for the generated + * source's line and column positions provided. The only argument is an object + * with the following properties: + * + * - line: The line number in the generated source. + * - column: The column number in the generated source. + * + * and an object is returned with the following properties: + * + * - source: The original source file, or null. + * - line: The line number in the original source, or null. + * - column: The column number in the original source, or null. + * - name: The original identifier, or null. + */ + SourceMapConsumer.prototype.originalPositionFor = + function SourceMapConsumer_originalPositionFor(aArgs) { + var needle = { + generatedLine: util.getArg(aArgs, 'line'), + generatedColumn: util.getArg(aArgs, 'column') + }; + + var mapping = this._findMapping(needle, + this._generatedMappings, + "generatedLine", + "generatedColumn", + this._compareGeneratedPositions); + + if (mapping) { + var source = util.getArg(mapping, 'source', null); + if (source && this.sourceRoot) { + source = util.join(this.sourceRoot, source); + } + return { + source: source, + line: util.getArg(mapping, 'originalLine', null), + column: util.getArg(mapping, 'originalColumn', null), + name: util.getArg(mapping, 'name', null) + }; + } + + return { + source: null, + line: null, + column: null, + name: null + }; + }; + + /** + * Returns the original source content. The only argument is + * the url of the original source file. Returns null if no + * original source content is availible. + */ + SourceMapConsumer.prototype.sourceContentFor = + function SourceMapConsumer_sourceContentFor(aSource) { + if (!this.sourcesContent) { + return null; + } + + if (this.sourceRoot) { + // Try to remove the sourceRoot + var relativeUrl = util.relative(this.sourceRoot, aSource); + if (this._sources.has(relativeUrl)) { + return this.sourcesContent[this._sources.indexOf(relativeUrl)]; + } + } + + if (this._sources.has(aSource)) { + return this.sourcesContent[this._sources.indexOf(aSource)]; + } + + throw new Error('"' + aSource + '" is not in the SourceMap.'); + }; + + /** + * Returns the generated line and column information for the original source, + * line, and column positions provided. The only argument is an object with + * the following properties: + * + * - source: The filename of the original source. + * - line: The line number in the original source. + * - column: The column number in the original source. + * + * and an object is returned with the following properties: + * + * - line: The line number in the generated source, or null. + * - column: The column number in the generated source, or null. + */ + SourceMapConsumer.prototype.generatedPositionFor = + function SourceMapConsumer_generatedPositionFor(aArgs) { + var needle = { + source: util.getArg(aArgs, 'source'), + originalLine: util.getArg(aArgs, 'line'), + originalColumn: util.getArg(aArgs, 'column') + }; + + if (this.sourceRoot) { + needle.source = util.relative(this.sourceRoot, needle.source); + } + + var mapping = this._findMapping(needle, + this._originalMappings, + "originalLine", + "originalColumn", + this._compareOriginalPositions); + + if (mapping) { + return { + line: util.getArg(mapping, 'generatedLine', null), + column: util.getArg(mapping, 'generatedColumn', null) + }; + } + + return { + line: null, + column: null + }; + }; + + SourceMapConsumer.GENERATED_ORDER = 1; + SourceMapConsumer.ORIGINAL_ORDER = 2; + + /** + * Iterate over each mapping between an original source/line/column and a + * generated line/column in this source map. + * + * @param Function aCallback + * The function that is called with each mapping. + * @param Object aContext + * Optional. If specified, this object will be the value of `this` every + * time that `aCallback` is called. + * @param aOrder + * Either `SourceMapConsumer.GENERATED_ORDER` or + * `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to + * iterate over the mappings sorted by the generated file's line/column + * order or the original's source/line/column order, respectively. Defaults to + * `SourceMapConsumer.GENERATED_ORDER`. + */ + SourceMapConsumer.prototype.eachMapping = + function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) { + var context = aContext || null; + var order = aOrder || SourceMapConsumer.GENERATED_ORDER; + + var mappings; + switch (order) { + case SourceMapConsumer.GENERATED_ORDER: + mappings = this._generatedMappings; + break; + case SourceMapConsumer.ORIGINAL_ORDER: + mappings = this._originalMappings; + break; + default: + throw new Error("Unknown order of iteration."); + } + + var sourceRoot = this.sourceRoot; + mappings.map(function (mapping) { + var source = mapping.source; + if (source && sourceRoot) { + source = util.join(sourceRoot, source); + } + return { + source: source, + generatedLine: mapping.generatedLine, + generatedColumn: mapping.generatedColumn, + originalLine: mapping.originalLine, + originalColumn: mapping.originalColumn, + name: mapping.name + }; + }).forEach(aCallback, context); + }; + + exports.SourceMapConsumer = SourceMapConsumer; + +}); diff --git a/tools/node_modules/source-map/lib/source-map/source-map-generator.js b/tools/node_modules/source-map/lib/source-map/source-map-generator.js new file mode 100644 index 0000000000000..b3f62f51af3e5 --- /dev/null +++ b/tools/node_modules/source-map/lib/source-map/source-map-generator.js @@ -0,0 +1,381 @@ +/* -*- Mode: js; js-indent-level: 2; -*- */ +/* + * Copyright 2011 Mozilla Foundation and contributors + * Licensed under the New BSD license. See LICENSE or: + * http://opensource.org/licenses/BSD-3-Clause + */ +if (typeof define !== 'function') { + var define = require('amdefine')(module); +} +define(function (require, exports, module) { + + var base64VLQ = require('./base64-vlq'); + var util = require('./util'); + var ArraySet = require('./array-set').ArraySet; + + /** + * An instance of the SourceMapGenerator represents a source map which is + * being built incrementally. To create a new one, you must pass an object + * with the following properties: + * + * - file: The filename of the generated source. + * - sourceRoot: An optional root for all URLs in this source map. + */ + function SourceMapGenerator(aArgs) { + this._file = util.getArg(aArgs, 'file'); + this._sourceRoot = util.getArg(aArgs, 'sourceRoot', null); + this._sources = new ArraySet(); + this._names = new ArraySet(); + this._mappings = []; + this._sourcesContents = null; + } + + SourceMapGenerator.prototype._version = 3; + + /** + * Creates a new SourceMapGenerator based on a SourceMapConsumer + * + * @param aSourceMapConsumer The SourceMap. + */ + SourceMapGenerator.fromSourceMap = + function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) { + var sourceRoot = aSourceMapConsumer.sourceRoot; + var generator = new SourceMapGenerator({ + file: aSourceMapConsumer.file, + sourceRoot: sourceRoot + }); + aSourceMapConsumer.eachMapping(function (mapping) { + var newMapping = { + generated: { + line: mapping.generatedLine, + column: mapping.generatedColumn + } + }; + + if (mapping.source) { + newMapping.source = mapping.source; + if (sourceRoot) { + newMapping.source = util.relative(sourceRoot, newMapping.source); + } + + newMapping.original = { + line: mapping.originalLine, + column: mapping.originalColumn + }; + + if (mapping.name) { + newMapping.name = mapping.name; + } + } + + generator.addMapping(newMapping); + }); + aSourceMapConsumer.sources.forEach(function (sourceFile) { + var content = aSourceMapConsumer.sourceContentFor(sourceFile); + if (content) { + generator.setSourceContent(sourceFile, content); + } + }); + return generator; + }; + + /** + * Add a single mapping from original source line and column to the generated + * source's line and column for this source map being created. The mapping + * object should have the following properties: + * + * - generated: An object with the generated line and column positions. + * - original: An object with the original line and column positions. + * - source: The original source file (relative to the sourceRoot). + * - name: An optional original token name for this mapping. + */ + SourceMapGenerator.prototype.addMapping = + function SourceMapGenerator_addMapping(aArgs) { + var generated = util.getArg(aArgs, 'generated'); + var original = util.getArg(aArgs, 'original', null); + var source = util.getArg(aArgs, 'source', null); + var name = util.getArg(aArgs, 'name', null); + + this._validateMapping(generated, original, source, name); + + if (source && !this._sources.has(source)) { + this._sources.add(source); + } + + if (name && !this._names.has(name)) { + this._names.add(name); + } + + this._mappings.push({ + generated: generated, + original: original, + source: source, + name: name + }); + }; + + /** + * Set the source content for a source file. + */ + SourceMapGenerator.prototype.setSourceContent = + function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) { + var source = aSourceFile; + if (this._sourceRoot) { + source = util.relative(this._sourceRoot, source); + } + + if (aSourceContent !== null) { + // Add the source content to the _sourcesContents map. + // Create a new _sourcesContents map if the property is null. + if (!this._sourcesContents) { + this._sourcesContents = {}; + } + this._sourcesContents[util.toSetString(source)] = aSourceContent; + } else { + // Remove the source file from the _sourcesContents map. + // If the _sourcesContents map is empty, set the property to null. + delete this._sourcesContents[util.toSetString(source)]; + if (Object.keys(this._sourcesContents).length === 0) { + this._sourcesContents = null; + } + } + }; + + /** + * Applies the mappings of a sub-source-map for a specific source file to the + * source map being generated. Each mapping to the supplied source file is + * rewritten using the supplied source map. Note: The resolution for the + * resulting mappings is the minimium of this map and the supplied map. + * + * @param aSourceMapConsumer The source map to be applied. + * @param aSourceFile Optional. The filename of the source file. + * If omitted, SourceMapConsumer's file property will be used. + */ + SourceMapGenerator.prototype.applySourceMap = + function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile) { + // If aSourceFile is omitted, we will use the file property of the SourceMap + if (!aSourceFile) { + aSourceFile = aSourceMapConsumer.file; + } + var sourceRoot = this._sourceRoot; + // Make "aSourceFile" relative if an absolute Url is passed. + if (sourceRoot) { + aSourceFile = util.relative(sourceRoot, aSourceFile); + } + // Applying the SourceMap can add and remove items from the sources and + // the names array. + var newSources = new ArraySet(); + var newNames = new ArraySet(); + + // Find mappings for the "aSourceFile" + this._mappings.forEach(function (mapping) { + if (mapping.source === aSourceFile && mapping.original) { + // Check if it can be mapped by the source map, then update the mapping. + var original = aSourceMapConsumer.originalPositionFor({ + line: mapping.original.line, + column: mapping.original.column + }); + if (original.source !== null) { + // Copy mapping + if (sourceRoot) { + mapping.source = util.relative(sourceRoot, original.source); + } else { + mapping.source = original.source; + } + mapping.original.line = original.line; + mapping.original.column = original.column; + if (original.name !== null && mapping.name !== null) { + // Only use the identifier name if it's an identifier + // in both SourceMaps + mapping.name = original.name; + } + } + } + + var source = mapping.source; + if (source && !newSources.has(source)) { + newSources.add(source); + } + + var name = mapping.name; + if (name && !newNames.has(name)) { + newNames.add(name); + } + + }, this); + this._sources = newSources; + this._names = newNames; + + // Copy sourcesContents of applied map. + aSourceMapConsumer.sources.forEach(function (sourceFile) { + var content = aSourceMapConsumer.sourceContentFor(sourceFile); + if (content) { + if (sourceRoot) { + sourceFile = util.relative(sourceRoot, sourceFile); + } + this.setSourceContent(sourceFile, content); + } + }, this); + }; + + /** + * A mapping can have one of the three levels of data: + * + * 1. Just the generated position. + * 2. The Generated position, original position, and original source. + * 3. Generated and original position, original source, as well as a name + * token. + * + * To maintain consistency, we validate that any new mapping being added falls + * in to one of these categories. + */ + SourceMapGenerator.prototype._validateMapping = + function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource, + aName) { + if (aGenerated && 'line' in aGenerated && 'column' in aGenerated + && aGenerated.line > 0 && aGenerated.column >= 0 + && !aOriginal && !aSource && !aName) { + // Case 1. + return; + } + else if (aGenerated && 'line' in aGenerated && 'column' in aGenerated + && aOriginal && 'line' in aOriginal && 'column' in aOriginal + && aGenerated.line > 0 && aGenerated.column >= 0 + && aOriginal.line > 0 && aOriginal.column >= 0 + && aSource) { + // Cases 2 and 3. + return; + } + else { + throw new Error('Invalid mapping.'); + } + }; + + function cmpLocation(loc1, loc2) { + var cmp = (loc1 && loc1.line) - (loc2 && loc2.line); + return cmp ? cmp : (loc1 && loc1.column) - (loc2 && loc2.column); + } + + function strcmp(str1, str2) { + str1 = str1 || ''; + str2 = str2 || ''; + return (str1 > str2) - (str1 < str2); + } + + function cmpMapping(mappingA, mappingB) { + return cmpLocation(mappingA.generated, mappingB.generated) || + cmpLocation(mappingA.original, mappingB.original) || + strcmp(mappingA.source, mappingB.source) || + strcmp(mappingA.name, mappingB.name); + } + + /** + * Serialize the accumulated mappings in to the stream of base 64 VLQs + * specified by the source map format. + */ + SourceMapGenerator.prototype._serializeMappings = + function SourceMapGenerator_serializeMappings() { + var previousGeneratedColumn = 0; + var previousGeneratedLine = 1; + var previousOriginalColumn = 0; + var previousOriginalLine = 0; + var previousName = 0; + var previousSource = 0; + var result = ''; + var mapping; + + // The mappings must be guarenteed to be in sorted order before we start + // serializing them or else the generated line numbers (which are defined + // via the ';' separators) will be all messed up. Note: it might be more + // performant to maintain the sorting as we insert them, rather than as we + // serialize them, but the big O is the same either way. + this._mappings.sort(cmpMapping); + + for (var i = 0, len = this._mappings.length; i < len; i++) { + mapping = this._mappings[i]; + + if (mapping.generated.line !== previousGeneratedLine) { + previousGeneratedColumn = 0; + while (mapping.generated.line !== previousGeneratedLine) { + result += ';'; + previousGeneratedLine++; + } + } + else { + if (i > 0) { + if (!cmpMapping(mapping, this._mappings[i - 1])) { + continue; + } + result += ','; + } + } + + result += base64VLQ.encode(mapping.generated.column + - previousGeneratedColumn); + previousGeneratedColumn = mapping.generated.column; + + if (mapping.source && mapping.original) { + result += base64VLQ.encode(this._sources.indexOf(mapping.source) + - previousSource); + previousSource = this._sources.indexOf(mapping.source); + + // lines are stored 0-based in SourceMap spec version 3 + result += base64VLQ.encode(mapping.original.line - 1 + - previousOriginalLine); + previousOriginalLine = mapping.original.line - 1; + + result += base64VLQ.encode(mapping.original.column + - previousOriginalColumn); + previousOriginalColumn = mapping.original.column; + + if (mapping.name) { + result += base64VLQ.encode(this._names.indexOf(mapping.name) + - previousName); + previousName = this._names.indexOf(mapping.name); + } + } + } + + return result; + }; + + /** + * Externalize the source map. + */ + SourceMapGenerator.prototype.toJSON = + function SourceMapGenerator_toJSON() { + var map = { + version: this._version, + file: this._file, + sources: this._sources.toArray(), + names: this._names.toArray(), + mappings: this._serializeMappings() + }; + if (this._sourceRoot) { + map.sourceRoot = this._sourceRoot; + } + if (this._sourcesContents) { + map.sourcesContent = map.sources.map(function (source) { + if (map.sourceRoot) { + source = util.relative(map.sourceRoot, source); + } + return Object.prototype.hasOwnProperty.call( + this._sourcesContents, util.toSetString(source)) + ? this._sourcesContents[util.toSetString(source)] + : null; + }, this); + } + return map; + }; + + /** + * Render the source map being generated to a string. + */ + SourceMapGenerator.prototype.toString = + function SourceMapGenerator_toString() { + return JSON.stringify(this); + }; + + exports.SourceMapGenerator = SourceMapGenerator; + +}); diff --git a/tools/node_modules/source-map/lib/source-map/source-node.js b/tools/node_modules/source-map/lib/source-map/source-node.js new file mode 100644 index 0000000000000..4c3314a8613a4 --- /dev/null +++ b/tools/node_modules/source-map/lib/source-map/source-node.js @@ -0,0 +1,353 @@ +/* -*- Mode: js; js-indent-level: 2; -*- */ +/* + * Copyright 2011 Mozilla Foundation and contributors + * Licensed under the New BSD license. See LICENSE or: + * http://opensource.org/licenses/BSD-3-Clause + */ +if (typeof define !== 'function') { + var define = require('amdefine')(module); +} +define(function (require, exports, module) { + + var SourceMapGenerator = require('./source-map-generator').SourceMapGenerator; + var util = require('./util'); + + /** + * SourceNodes provide a way to abstract over interpolating/concatenating + * snippets of generated JavaScript source code while maintaining the line and + * column information associated with the original source code. + * + * @param aLine The original line number. + * @param aColumn The original column number. + * @param aSource The original source's filename. + * @param aChunks Optional. An array of strings which are snippets of + * generated JS, or other SourceNodes. + * @param aName The original identifier. + */ + function SourceNode(aLine, aColumn, aSource, aChunks, aName) { + this.children = []; + this.sourceContents = {}; + this.line = aLine === undefined ? null : aLine; + this.column = aColumn === undefined ? null : aColumn; + this.source = aSource === undefined ? null : aSource; + this.name = aName === undefined ? null : aName; + if (aChunks != null) this.add(aChunks); + } + + /** + * Creates a SourceNode from generated code and a SourceMapConsumer. + * + * @param aGeneratedCode The generated code + * @param aSourceMapConsumer The SourceMap for the generated code + */ + SourceNode.fromStringWithSourceMap = + function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer) { + // The SourceNode we want to fill with the generated code + // and the SourceMap + var node = new SourceNode(); + + // The generated code + // Processed fragments are removed from this array. + var remainingLines = aGeneratedCode.split('\n'); + + // We need to remember the position of "remainingLines" + var lastGeneratedLine = 1, lastGeneratedColumn = 0; + + // The generate SourceNodes we need a code range. + // To extract it current and last mapping is used. + // Here we store the last mapping. + var lastMapping = null; + + aSourceMapConsumer.eachMapping(function (mapping) { + if (lastMapping === null) { + // We add the generated code until the first mapping + // to the SourceNode without any mapping. + // Each line is added as separate string. + while (lastGeneratedLine < mapping.generatedLine) { + node.add(remainingLines.shift() + "\n"); + lastGeneratedLine++; + } + if (lastGeneratedColumn < mapping.generatedColumn) { + var nextLine = remainingLines[0]; + node.add(nextLine.substr(0, mapping.generatedColumn)); + remainingLines[0] = nextLine.substr(mapping.generatedColumn); + lastGeneratedColumn = mapping.generatedColumn; + } + } else { + // We add the code from "lastMapping" to "mapping": + // First check if there is a new line in between. + if (lastGeneratedLine < mapping.generatedLine) { + var code = ""; + // Associate full lines with "lastMapping" + do { + code += remainingLines.shift() + "\n"; + lastGeneratedLine++; + lastGeneratedColumn = 0; + } while (lastGeneratedLine < mapping.generatedLine); + // When we reached the correct line, we add code until we + // reach the correct column too. + if (lastGeneratedColumn < mapping.generatedColumn) { + var nextLine = remainingLines[0]; + code += nextLine.substr(0, mapping.generatedColumn); + remainingLines[0] = nextLine.substr(mapping.generatedColumn); + lastGeneratedColumn = mapping.generatedColumn; + } + // Create the SourceNode. + addMappingWithCode(lastMapping, code); + } else { + // There is no new line in between. + // Associate the code between "lastGeneratedColumn" and + // "mapping.generatedColumn" with "lastMapping" + var nextLine = remainingLines[0]; + var code = nextLine.substr(0, mapping.generatedColumn - + lastGeneratedColumn); + remainingLines[0] = nextLine.substr(mapping.generatedColumn - + lastGeneratedColumn); + lastGeneratedColumn = mapping.generatedColumn; + addMappingWithCode(lastMapping, code); + } + } + lastMapping = mapping; + }, this); + // We have processed all mappings. + // Associate the remaining code in the current line with "lastMapping" + // and add the remaining lines without any mapping + addMappingWithCode(lastMapping, remainingLines.join("\n")); + + // Copy sourcesContent into SourceNode + aSourceMapConsumer.sources.forEach(function (sourceFile) { + var content = aSourceMapConsumer.sourceContentFor(sourceFile); + if (content) { + node.setSourceContent(sourceFile, content); + } + }); + + return node; + + function addMappingWithCode(mapping, code) { + if (mapping.source === undefined) { + node.add(code); + } else { + node.add(new SourceNode(mapping.originalLine, + mapping.originalColumn, + mapping.source, + code, + mapping.name)); + } + } + }; + + /** + * Add a chunk of generated JS to this source node. + * + * @param aChunk A string snippet of generated JS code, another instance of + * SourceNode, or an array where each member is one of those things. + */ + SourceNode.prototype.add = function SourceNode_add(aChunk) { + if (Array.isArray(aChunk)) { + aChunk.forEach(function (chunk) { + this.add(chunk); + }, this); + } + else if (aChunk instanceof SourceNode || typeof aChunk === "string") { + if (aChunk) { + this.children.push(aChunk); + } + } + else { + throw new TypeError( + "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk + ); + } + return this; + }; + + /** + * Add a chunk of generated JS to the beginning of this source node. + * + * @param aChunk A string snippet of generated JS code, another instance of + * SourceNode, or an array where each member is one of those things. + */ + SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) { + if (Array.isArray(aChunk)) { + for (var i = aChunk.length-1; i >= 0; i--) { + this.prepend(aChunk[i]); + } + } + else if (aChunk instanceof SourceNode || typeof aChunk === "string") { + this.children.unshift(aChunk); + } + else { + throw new TypeError( + "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk + ); + } + return this; + }; + + /** + * Walk over the tree of JS snippets in this node and its children. The + * walking function is called once for each snippet of JS and is passed that + * snippet and the its original associated source's line/column location. + * + * @param aFn The traversal function. + */ + SourceNode.prototype.walk = function SourceNode_walk(aFn) { + this.children.forEach(function (chunk) { + if (chunk instanceof SourceNode) { + chunk.walk(aFn); + } + else { + if (chunk !== '') { + aFn(chunk, { source: this.source, + line: this.line, + column: this.column, + name: this.name }); + } + } + }, this); + }; + + /** + * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between + * each of `this.children`. + * + * @param aSep The separator. + */ + SourceNode.prototype.join = function SourceNode_join(aSep) { + var newChildren; + var i; + var len = this.children.length; + if (len > 0) { + newChildren = []; + for (i = 0; i < len-1; i++) { + newChildren.push(this.children[i]); + newChildren.push(aSep); + } + newChildren.push(this.children[i]); + this.children = newChildren; + } + return this; + }; + + /** + * Call String.prototype.replace on the very right-most source snippet. Useful + * for trimming whitespace from the end of a source node, etc. + * + * @param aPattern The pattern to replace. + * @param aReplacement The thing to replace the pattern with. + */ + SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) { + var lastChild = this.children[this.children.length - 1]; + if (lastChild instanceof SourceNode) { + lastChild.replaceRight(aPattern, aReplacement); + } + else if (typeof lastChild === 'string') { + this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement); + } + else { + this.children.push(''.replace(aPattern, aReplacement)); + } + return this; + }; + + /** + * Set the source content for a source file. This will be added to the SourceMapGenerator + * in the sourcesContent field. + * + * @param aSourceFile The filename of the source file + * @param aSourceContent The content of the source file + */ + SourceNode.prototype.setSourceContent = + function SourceNode_setSourceContent(aSourceFile, aSourceContent) { + this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent; + }; + + /** + * Walk over the tree of SourceNodes. The walking function is called for each + * source file content and is passed the filename and source content. + * + * @param aFn The traversal function. + */ + SourceNode.prototype.walkSourceContents = + function SourceNode_walkSourceContents(aFn) { + this.children.forEach(function (chunk) { + if (chunk instanceof SourceNode) { + chunk.walkSourceContents(aFn); + } + }, this); + Object.keys(this.sourceContents).forEach(function (sourceFileKey) { + aFn(util.fromSetString(sourceFileKey), this.sourceContents[sourceFileKey]); + }, this); + }; + + /** + * Return the string representation of this source node. Walks over the tree + * and concatenates all the various snippets together to one string. + */ + SourceNode.prototype.toString = function SourceNode_toString() { + var str = ""; + this.walk(function (chunk) { + str += chunk; + }); + return str; + }; + + /** + * Returns the string representation of this source node along with a source + * map. + */ + SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) { + var generated = { + code: "", + line: 1, + column: 0 + }; + var map = new SourceMapGenerator(aArgs); + var sourceMappingActive = false; + this.walk(function (chunk, original) { + generated.code += chunk; + if (original.source !== null + && original.line !== null + && original.column !== null) { + map.addMapping({ + source: original.source, + original: { + line: original.line, + column: original.column + }, + generated: { + line: generated.line, + column: generated.column + }, + name: original.name + }); + sourceMappingActive = true; + } else if (sourceMappingActive) { + map.addMapping({ + generated: { + line: generated.line, + column: generated.column + } + }); + sourceMappingActive = false; + } + chunk.split('').forEach(function (ch) { + if (ch === '\n') { + generated.line++; + generated.column = 0; + } else { + generated.column++; + } + }); + }); + this.walkSourceContents(function (sourceFile, sourceContent) { + map.setSourceContent(sourceFile, sourceContent); + }); + + return { code: generated.code, map: map }; + }; + + exports.SourceNode = SourceNode; + +}); diff --git a/tools/node_modules/source-map/lib/source-map/util.js b/tools/node_modules/source-map/lib/source-map/util.js new file mode 100644 index 0000000000000..d59b25743a0ec --- /dev/null +++ b/tools/node_modules/source-map/lib/source-map/util.js @@ -0,0 +1,91 @@ +/* -*- Mode: js; js-indent-level: 2; -*- */ +/* + * Copyright 2011 Mozilla Foundation and contributors + * Licensed under the New BSD license. See LICENSE or: + * http://opensource.org/licenses/BSD-3-Clause + */ +if (typeof define !== 'function') { + var define = require('amdefine')(module); +} +define(function (require, exports, module) { + + /** + * This is a helper function for getting values from parameter/options + * objects. + * + * @param args The object we are extracting values from + * @param name The name of the property we are getting. + * @param defaultValue An optional value to return if the property is missing + * from the object. If this is not specified and the property is missing, an + * error will be thrown. + */ + function getArg(aArgs, aName, aDefaultValue) { + if (aName in aArgs) { + return aArgs[aName]; + } else if (arguments.length === 3) { + return aDefaultValue; + } else { + throw new Error('"' + aName + '" is a required argument.'); + } + } + exports.getArg = getArg; + + var urlRegexp = /([\w+\-.]+):\/\/((\w+:\w+)@)?([\w.]+)?(:(\d+))?(\S+)?/; + + function urlParse(aUrl) { + var match = aUrl.match(urlRegexp); + if (!match) { + return null; + } + return { + scheme: match[1], + auth: match[3], + host: match[4], + port: match[6], + path: match[7] + }; + } + + function join(aRoot, aPath) { + var url; + + if (aPath.match(urlRegexp)) { + return aPath; + } + + if (aPath.charAt(0) === '/' && (url = urlParse(aRoot))) { + return aRoot.replace(url.path, '') + aPath; + } + + return aRoot.replace(/\/$/, '') + '/' + aPath; + } + exports.join = join; + + /** + * Because behavior goes wacky when you set `__proto__` on objects, we + * have to prefix all the strings in our set with an arbitrary character. + * + * See https://github.com/mozilla/source-map/pull/31 and + * https://github.com/mozilla/source-map/issues/30 + * + * @param String aStr + */ + function toSetString(aStr) { + return '$' + aStr; + } + exports.toSetString = toSetString; + + function fromSetString(aStr) { + return aStr.substr(1); + } + exports.fromSetString = fromSetString; + + function relative(aRoot, aPath) { + aRoot = aRoot.replace(/\/$/, ''); + return aPath.indexOf(aRoot + '/') === 0 + ? aPath.substr(aRoot.length + 1) + : aPath; + } + exports.relative = relative; + +}); diff --git a/tools/node_modules/source-map/node_modules/amdefine/LICENSE b/tools/node_modules/source-map/node_modules/amdefine/LICENSE new file mode 100644 index 0000000000000..f33d665de5951 --- /dev/null +++ b/tools/node_modules/source-map/node_modules/amdefine/LICENSE @@ -0,0 +1,58 @@ +amdefine is released under two licenses: new BSD, and MIT. You may pick the +license that best suits your development needs. The text of both licenses are +provided below. + + +The "New" BSD License: +---------------------- + +Copyright (c) 2011, The Dojo Foundation +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + * Neither the name of the Dojo Foundation nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + + +MIT License +----------- + +Copyright (c) 2011, The Dojo Foundation + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/tools/node_modules/source-map/node_modules/amdefine/README.md b/tools/node_modules/source-map/node_modules/amdefine/README.md new file mode 100644 index 0000000000000..8ebbc7392a111 --- /dev/null +++ b/tools/node_modules/source-map/node_modules/amdefine/README.md @@ -0,0 +1,119 @@ +# amdefine + +A module that can be used to implement AMD's define() in Node. This allows you +to code to the AMD API and have the module work in node programs without +requiring those other programs to use AMD. + +## Usage + +**1)** Update your package.json to indicate amdefine as a dependency: + +```javascript + "dependencies": { + "amdefine": ">=0.0.5" + } +``` + +Then run `npm install` to get amdefine into your project. + +**2)** At the top of each module that uses define(), place this code: + +```javascript +if (typeof define !== 'function') { var define = require('amdefine')(module) } +``` + +**Only use these snippets** when loading amdefine. If you preserve the basic structure, +with the braces, it will be stripped out when using the [RequireJS optimizer](#optimizer). + +You can add spaces, line breaks and even require amdefine with a local path, but +keep the rest of the structure to get the stripping behavior. + +As you may know, because `if` statements in JavaScript don't have their own scope, the var +declaration in the above snippet is made whether the `if` expression is truthy or not. If +RequireJS is loaded then the declaration is superfluous because `define` is already already +declared in the same scope in RequireJS. Fortunately JavaScript handles multiple `var` +declarations of the same variable in the same scope gracefully. + +If you want to deliver amdefine.js with your code rather than specifying it as a dependency +with npm, then just download the latest release and refer to it using a relative path: + +[Latest Version](https://github.com/jrburke/amdefine/raw/latest/amdefine.js) + +## define() usage + +It is best if you use the anonymous forms of define() in your module: + +```javascript +define(function (require) { + var dependency = require('dependency'); +}); +``` + +or + +```javascript +define(['dependency'], function (dependency) { + +}); +``` + +## RequireJS optimizer integration. + +Version 1.0.3 of the [RequireJS optimizer](http://requirejs.org/docs/optimization.html) +will have support for stripping the `if (typeof define !== 'function')` check +mentioned above, so you can include this snippet for code that runs in the +browser, but avoid taking the cost of the if() statement once the code is +optimized for deployment. + +## Node 0.4 Support + +If you want to support Node 0.4, then add `require` as the second parameter to amdefine: + +```javascript +//Only if you want Node 0.4. If using 0.5 or later, use the above snippet. +if (typeof define !== 'function') { var define = require('amdefine')(module, require) } +``` + +## Limitations + +### Synchronous vs Asynchronous + +amdefine creates a define() function that is callable by your code. It will +execute and trace dependencies and call the factory function *synchronously*, +to keep the behavior in line with Node's synchronous dependency tracing. + +The exception: calling AMD's callback-style require() from inside a factory +function. The require callback is called on process.nextTick(): + +```javascript +define(function (require) { + require(['a'], function(a) { + //'a' is loaded synchronously, but + //this callback is called on process.nextTick(). + }); +}); +``` + +### Loader Plugins + +Loader plugins are supported as long as they call their load() callbacks +synchronously. So ones that do network requests will not work. However plugins +like [text](http://requirejs.org/docs/api.html#text) can load text files locally. + +The plugin API's `load.fromText()` is **not supported** in amdefine, so this means +transpiler plugins like the [CoffeeScript loader plugin](https://github.com/jrburke/require-cs) +will not work. This may be fixable, but it is a bit complex, and I do not have +enough node-fu to figure it out yet. See the source for amdefine.js if you want +to get an idea of the issues involved. + +## Tests + +To run the tests, cd to **tests** and run: + +``` +node all.js +``` + +## License + +New BSD and MIT. Check the LICENSE file for all the details. diff --git a/tools/node_modules/source-map/node_modules/amdefine/amdefine.js b/tools/node_modules/source-map/node_modules/amdefine/amdefine.js new file mode 100644 index 0000000000000..d074c94cc161a --- /dev/null +++ b/tools/node_modules/source-map/node_modules/amdefine/amdefine.js @@ -0,0 +1,299 @@ +/** vim: et:ts=4:sw=4:sts=4 + * @license amdefine 0.0.5 Copyright (c) 2011, The Dojo Foundation All Rights Reserved. + * Available via the MIT or new BSD license. + * see: http://github.com/jrburke/amdefine for details + */ + +/*jslint node: true */ +/*global module, process */ +'use strict'; + +var path = require('path'); + +/** + * Creates a define for node. + * @param {Object} module the "module" object that is defined by Node for the + * current module. + * @param {Function} [require]. Node's require function for the current module. + * It only needs to be passed in Node versions before 0.5, when module.require + * did not exist. + * @returns {Function} a define function that is usable for the current node + * module. + */ +function amdefine(module, require) { + var defineCache = {}, + loaderCache = {}, + alreadyCalled = false, + makeRequire, stringRequire; + + /** + * Trims the . and .. from an array of path segments. + * It will keep a leading path segment if a .. will become + * the first path segment, to help with module name lookups, + * which act like paths, but can be remapped. But the end result, + * all paths that use this function should look normalized. + * NOTE: this method MODIFIES the input array. + * @param {Array} ary the array of path segments. + */ + function trimDots(ary) { + var i, part; + for (i = 0; ary[i]; i+= 1) { + part = ary[i]; + if (part === '.') { + ary.splice(i, 1); + i -= 1; + } else if (part === '..') { + if (i === 1 && (ary[2] === '..' || ary[0] === '..')) { + //End of the line. Keep at least one non-dot + //path segment at the front so it can be mapped + //correctly to disk. Otherwise, there is likely + //no path mapping for a path starting with '..'. + //This can still fail, but catches the most reasonable + //uses of .. + break; + } else if (i > 0) { + ary.splice(i - 1, 2); + i -= 2; + } + } + } + } + + function normalize(name, baseName) { + var baseParts; + + //Adjust any relative paths. + if (name && name.charAt(0) === '.') { + //If have a base name, try to normalize against it, + //otherwise, assume it is a top-level require that will + //be relative to baseUrl in the end. + if (baseName) { + baseParts = baseName.split('/'); + baseParts = baseParts.slice(0, baseParts.length - 1); + baseParts = baseParts.concat(name.split('/')); + trimDots(baseParts); + name = baseParts.join('/'); + } + } + + return name; + } + + /** + * Create the normalize() function passed to a loader plugin's + * normalize method. + */ + function makeNormalize(relName) { + return function (name) { + return normalize(name, relName); + }; + } + + function makeLoad(id) { + function load(value) { + loaderCache[id] = value; + } + + load.fromText = function (id, text) { + //This one is difficult because the text can/probably uses + //define, and any relative paths and requires should be relative + //to that id was it would be found on disk. But this would require + //bootstrapping a module/require fairly deeply from node core. + //Not sure how best to go about that yet. + throw new Error('amdefine does not implement load.fromText'); + }; + + return load; + } + + makeRequire = function (systemRequire, exports, module, relId) { + function amdRequire(deps, callback) { + if (typeof deps === 'string') { + //Synchronous, single module require('') + return stringRequire(systemRequire, exports, module, deps, relId); + } else { + //Array of dependencies with a callback. + + //Convert the dependencies to modules. + deps = deps.map(function (depName) { + return stringRequire(systemRequire, exports, module, depName, relId); + }); + + //Wait for next tick to call back the require call. + process.nextTick(function () { + callback.apply(null, deps); + }); + } + } + + amdRequire.toUrl = function (filePath) { + if (filePath.indexOf('.') === 0) { + return normalize(filePath, path.dirname(module.filename)); + } else { + return filePath; + } + }; + + return amdRequire; + }; + + //Favor explicit value, passed in if the module wants to support Node 0.4. + require = require || function req() { + return module.require.apply(module, arguments); + }; + + function runFactory(id, deps, factory) { + var r, e, m, result; + + if (id) { + e = loaderCache[id] = {}; + m = { + id: id, + uri: __filename, + exports: e + }; + r = makeRequire(require, e, m, id); + } else { + //Only support one define call per file + if (alreadyCalled) { + throw new Error('amdefine with no module ID cannot be called more than once per file.'); + } + alreadyCalled = true; + + //Use the real variables from node + //Use module.exports for exports, since + //the exports in here is amdefine exports. + e = module.exports; + m = module; + r = makeRequire(require, e, m, module.id); + } + + //If there are dependencies, they are strings, so need + //to convert them to dependency values. + if (deps) { + deps = deps.map(function (depName) { + return r(depName); + }); + } + + //Call the factory with the right dependencies. + if (typeof factory === 'function') { + result = factory.apply(module.exports, deps); + } else { + result = factory; + } + + if (result !== undefined) { + m.exports = result; + if (id) { + loaderCache[id] = m.exports; + } + } + } + + stringRequire = function (systemRequire, exports, module, id, relId) { + //Split the ID by a ! so that + var index = id.indexOf('!'), + originalId = id, + prefix, plugin; + + if (index === -1) { + id = normalize(id, relId); + + //Straight module lookup. If it is one of the special dependencies, + //deal with it, otherwise, delegate to node. + if (id === 'require') { + return makeRequire(systemRequire, exports, module, relId); + } else if (id === 'exports') { + return exports; + } else if (id === 'module') { + return module; + } else if (loaderCache.hasOwnProperty(id)) { + return loaderCache[id]; + } else if (defineCache[id]) { + runFactory.apply(null, defineCache[id]); + return loaderCache[id]; + } else { + if(systemRequire) { + return systemRequire(originalId); + } else { + throw new Error('No module with ID: ' + id); + } + } + } else { + //There is a plugin in play. + prefix = id.substring(0, index); + id = id.substring(index + 1, id.length); + + plugin = stringRequire(systemRequire, exports, module, prefix, relId); + + if (plugin.normalize) { + id = plugin.normalize(id, makeNormalize(relId)); + } else { + //Normalize the ID normally. + id = normalize(id, relId); + } + + if (loaderCache[id]) { + return loaderCache[id]; + } else { + plugin.load(id, makeRequire(systemRequire, exports, module, relId), makeLoad(id), {}); + + return loaderCache[id]; + } + } + }; + + //Create a define function specific to the module asking for amdefine. + function define(id, deps, factory) { + if (Array.isArray(id)) { + factory = deps; + deps = id; + id = undefined; + } else if (typeof id !== 'string') { + factory = id; + id = deps = undefined; + } + + if (deps && !Array.isArray(deps)) { + factory = deps; + deps = undefined; + } + + if (!deps) { + deps = ['require', 'exports', 'module']; + } + + //Set up properties for this module. If an ID, then use + //internal cache. If no ID, then use the external variables + //for this node module. + if (id) { + //Put the module in deep freeze until there is a + //require call for it. + defineCache[id] = [id, deps, factory]; + } else { + runFactory(id, deps, factory); + } + } + + //define.require, which has access to all the values in the + //cache. Useful for AMD modules that all have IDs in the file, + //but need to finally export a value to node based on one of those + //IDs. + define.require = function (id) { + if (loaderCache[id]) { + return loaderCache[id]; + } + + if (defineCache[id]) { + runFactory.apply(null, defineCache[id]); + return loaderCache[id]; + } + }; + + define.amd = {}; + + return define; +} + +module.exports = amdefine; diff --git a/tools/node_modules/source-map/node_modules/amdefine/package.json b/tools/node_modules/source-map/node_modules/amdefine/package.json new file mode 100644 index 0000000000000..549197a6a659e --- /dev/null +++ b/tools/node_modules/source-map/node_modules/amdefine/package.json @@ -0,0 +1,40 @@ +{ + "name": "amdefine", + "description": "Provide AMD's define() API for declaring modules in the AMD format", + "version": "0.0.5", + "homepage": "http://github.com/jrburke/amdefine", + "author": { + "name": "James Burke", + "email": "jrburke@gmail.com", + "url": "http://github.com/jrburke" + }, + "licenses": [ + { + "type": "BSD", + "url": "https://github.com/jrburke/amdefine/blob/master/LICENSE" + }, + { + "type": "MIT", + "url": "https://github.com/jrburke/amdefine/blob/master/LICENSE" + } + ], + "repository": { + "type": "git", + "url": "https://github.com/jrburke/amdefine.git" + }, + "main": "./amdefine.js", + "engines": { + "node": ">=0.4.2" + }, + "readme": "# amdefine\n\nA module that can be used to implement AMD's define() in Node. This allows you\nto code to the AMD API and have the module work in node programs without\nrequiring those other programs to use AMD.\n\n## Usage\n\n**1)** Update your package.json to indicate amdefine as a dependency:\n\n```javascript\n \"dependencies\": {\n \"amdefine\": \">=0.0.5\"\n }\n```\n\nThen run `npm install` to get amdefine into your project.\n\n**2)** At the top of each module that uses define(), place this code:\n\n```javascript\nif (typeof define !== 'function') { var define = require('amdefine')(module) }\n```\n\n**Only use these snippets** when loading amdefine. If you preserve the basic structure,\nwith the braces, it will be stripped out when using the [RequireJS optimizer](#optimizer).\n\nYou can add spaces, line breaks and even require amdefine with a local path, but\nkeep the rest of the structure to get the stripping behavior.\n\nAs you may know, because `if` statements in JavaScript don't have their own scope, the var\ndeclaration in the above snippet is made whether the `if` expression is truthy or not. If\nRequireJS is loaded then the declaration is superfluous because `define` is already already\ndeclared in the same scope in RequireJS. Fortunately JavaScript handles multiple `var`\ndeclarations of the same variable in the same scope gracefully.\n\nIf you want to deliver amdefine.js with your code rather than specifying it as a dependency\nwith npm, then just download the latest release and refer to it using a relative path:\n\n[Latest Version](https://github.com/jrburke/amdefine/raw/latest/amdefine.js)\n\n## define() usage\n\nIt is best if you use the anonymous forms of define() in your module:\n\n```javascript\ndefine(function (require) {\n var dependency = require('dependency');\n});\n```\n\nor\n\n```javascript\ndefine(['dependency'], function (dependency) {\n\n});\n```\n\n## RequireJS optimizer integration. \n\nVersion 1.0.3 of the [RequireJS optimizer](http://requirejs.org/docs/optimization.html)\nwill have support for stripping the `if (typeof define !== 'function')` check\nmentioned above, so you can include this snippet for code that runs in the\nbrowser, but avoid taking the cost of the if() statement once the code is\noptimized for deployment.\n\n## Node 0.4 Support\n\nIf you want to support Node 0.4, then add `require` as the second parameter to amdefine:\n\n```javascript\n//Only if you want Node 0.4. If using 0.5 or later, use the above snippet.\nif (typeof define !== 'function') { var define = require('amdefine')(module, require) }\n```\n\n## Limitations\n\n### Synchronous vs Asynchronous\n\namdefine creates a define() function that is callable by your code. It will\nexecute and trace dependencies and call the factory function *synchronously*,\nto keep the behavior in line with Node's synchronous dependency tracing.\n\nThe exception: calling AMD's callback-style require() from inside a factory\nfunction. The require callback is called on process.nextTick():\n\n```javascript\ndefine(function (require) {\n require(['a'], function(a) {\n //'a' is loaded synchronously, but\n //this callback is called on process.nextTick().\n });\n});\n```\n\n### Loader Plugins\n\nLoader plugins are supported as long as they call their load() callbacks\nsynchronously. So ones that do network requests will not work. However plugins\nlike [text](http://requirejs.org/docs/api.html#text) can load text files locally.\n\nThe plugin API's `load.fromText()` is **not supported** in amdefine, so this means\ntranspiler plugins like the [CoffeeScript loader plugin](https://github.com/jrburke/require-cs)\nwill not work. This may be fixable, but it is a bit complex, and I do not have\nenough node-fu to figure it out yet. See the source for amdefine.js if you want\nto get an idea of the issues involved.\n\n## Tests\n\nTo run the tests, cd to **tests** and run:\n\n```\nnode all.js\n```\n\n## License\n\nNew BSD and MIT. Check the LICENSE file for all the details.\n", + "readmeFilename": "README.md", + "bugs": { + "url": "https://github.com/jrburke/amdefine/issues" + }, + "_id": "amdefine@0.0.5", + "dist": { + "shasum": "86b6e9470f8cde955ef7daa3cf5d544ba81aa3db" + }, + "_from": "amdefine@>=0.0.4", + "_resolved": "https://registry.npmjs.org/amdefine/-/amdefine-0.0.5.tgz" +} diff --git a/tools/node_modules/source-map/package.json b/tools/node_modules/source-map/package.json new file mode 100644 index 0000000000000..4d2e37253649e --- /dev/null +++ b/tools/node_modules/source-map/package.json @@ -0,0 +1,81 @@ +{ + "name": "source-map", + "description": "Generates and consumes source maps", + "version": "0.1.22", + "homepage": "https://github.com/mozilla/source-map", + "author": { + "name": "Nick Fitzgerald", + "email": "nfitzgerald@mozilla.com" + }, + "contributors": [ + { + "name": "Stephen Crane" + }, + { + "name": "Ryan Seddon" + }, + { + "name": "Mihai Bazon", + "email": "mihai.bazon@gmail.com" + }, + { + "name": "Michael Ficarra", + "email": "github.public.email@michael.ficarra.me" + }, + { + "name": "Todd Wolfson", + "email": "todd@twolfson.com" + }, + { + "name": "Alexander Solovyov", + "email": "alexander@solovyov.net" + }, + { + "name": "Felix Gnass" + }, + { + "name": "Conrad Irwin", + "email": "conrad.irwin@gmail.com" + }, + { + "name": "github.com/usrbincc" + } + ], + "repository": { + "type": "git", + "url": "http://github.com/mozilla/source-map.git" + }, + "directories": { + "lib": "./lib" + }, + "main": "./lib/source-map.js", + "engines": { + "node": ">=0.8.0" + }, + "licenses": [ + { + "type": "BSD", + "url": "http://opensource.org/licenses/BSD-3-Clause" + } + ], + "dependencies": { + "amdefine": ">=0.0.4" + }, + "devDependencies": { + "dryice": ">=0.4.8" + }, + "scripts": { + "test": "node test/run-tests.js" + }, + "readme": "# Source Map\n\nThis is a library to generate and consume the source map format\n[described here][format].\n\n[Learn more here][feature].\n\nThis library was written in the Asynchronous Module Definition\nformat. It should work in the following environments:\n\n* Modern Browsers (either after the build, or with an AMD loader such as\n RequireJS)\n\n* Inside Firefox (as a JSM file, after the build)\n\n* With NodeJS versions 0.8.X and higher\n\n## Installing with NPM (for use with NodeJS)\n\nSimply\n\n $ npm install source-map\n\nOr, if you'd like to hack on this library and have it installed via npm so you\ncan try out your changes:\n\n $ git clone https://fitzgen@github.com/mozilla/source-map.git\n $ cd source-map\n $ npm link .\n\n## Building from Source (for everywhere else)\n\nInstall Node and then run\n\n $ git clone https://fitzgen@github.com/mozilla/source-map.git\n $ cd source-map\n $ npm link .\n\nNext, run\n\n $ node Makefile.dryice.js`\n\nThis should create the following files:\n\n* `dist/source-map.js` - The unminified browser version.\n\n* `dist/source-map.min.js` - The minified browser version.\n\n* `dist/SourceMap.jsm` - The JavaScript Module for inclusion in Firefox\n source.\n\n## API\n\nGet a reference to the module:\n\n // NodeJS\n var sourceMap = require('source-map');\n\n // Browser builds\n var sourceMap = window.sourceMap;\n\n // Inside Firefox\n let sourceMap = {};\n Components.utils.import('resource:///modules/devtools/SourceMap.jsm', sourceMap);\n\n### SourceMapConsumer\n\nA SourceMapConsumer instance represents a parsed source map which we can query\nfor information about the original file positions by giving it a file position\nin the generated source.\n\n#### new SourceMapConsumer(rawSourceMap)\n\nThe only parameter is the raw source map (either as a string which can be\n`JSON.parse`'d, or an object). According to the spec, source maps have the\nfollowing attributes:\n\n* `version`: Which version of the source map spec this map is following.\n\n* `sources`: An array of URLs to the original source files.\n\n* `names`: An array of identifiers which can be referrenced by individual\n mappings.\n\n* `sourceRoot`: Optional. The URL root from which all sources are relative.\n\n* `sourcesContent`: Optional. An array of contents of the original source files.\n\n* `mappings`: A string of base64 VLQs which contain the actual mappings.\n\n* `file`: The generated filename this source map is associated with.\n\n#### SourceMapConsumer.prototype.originalPositionFor(generatedPosition)\n\nReturns the original source, line, and column information for the generated\nsource's line and column positions provided. The only argument is an object with\nthe following properties:\n\n* `line`: The line number in the generated source.\n\n* `column`: The column number in the generated source.\n\nand an object is returned with the following properties:\n\n* `source`: The original source file, or null if this information is not\n available.\n\n* `line`: The line number in the original source, or null if this information is\n not available.\n\n* `column`: The column number in the original source, or null or null if this\n information is not available.\n\n* `name`: The original identifier, or null if this information is not available.\n\n#### SourceMapConsumer.prototype.generatedPositionFor(originalPosition)\n\nReturns the generated line and column information for the original source,\nline, and column positions provided. The only argument is an object with\nthe following properties:\n\n* `source`: The filename of the original source.\n\n* `line`: The line number in the original source.\n\n* `column`: The column number in the original source.\n\nand an object is returned with the following properties:\n\n* `line`: The line number in the generated source, or null.\n\n* `column`: The column number in the generated source, or null.\n\n#### SourceMapConsumer.prototype.sourceContentFor(source)\n\nReturns the original source content for the source provided. The only\nargument is the URL of the original source file.\n\n#### SourceMapConsumer.prototype.eachMapping(callback, context, order)\n\nIterate over each mapping between an original source/line/column and a\ngenerated line/column in this source map.\n\n* `callback`: The function that is called with each mapping.\n\n* `context`: Optional. If specified, this object will be the value of `this`\n every time that `callback` is called.\n\n* `order`: Either `SourceMapConsumer.GENERATED_ORDER` or\n `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to iterate over\n the mappings sorted by the generated file's line/column order or the\n original's source/line/column order, respectively. Defaults to\n `SourceMapConsumer.GENERATED_ORDER`.\n\n### SourceMapGenerator\n\nAn instance of the SourceMapGenerator represents a source map which is being\nbuilt incrementally.\n\n#### new SourceMapGenerator(startOfSourceMap)\n\nTo create a new one, you must pass an object with the following properties:\n\n* `file`: The filename of the generated source that this source map is\n associated with.\n\n* `sourceRoot`: An optional root for all relative URLs in this source map.\n\n#### SourceMapGenerator.fromSourceMap(sourceMapConsumer)\n\nCreates a new SourceMapGenerator based on a SourceMapConsumer\n\n* `sourceMapConsumer` The SourceMap.\n\n#### SourceMapGenerator.prototype.addMapping(mapping)\n\nAdd a single mapping from original source line and column to the generated\nsource's line and column for this source map being created. The mapping object\nshould have the following properties:\n\n* `generated`: An object with the generated line and column positions.\n\n* `original`: An object with the original line and column positions.\n\n* `source`: The original source file (relative to the sourceRoot).\n\n* `name`: An optional original token name for this mapping.\n\n#### SourceMapGenerator.prototype.setSourceContent(sourceFile, sourceContent)\n\nSet the source content for an original source file.\n\n* `sourceFile` the URL of the original source file.\n\n* `sourceContent` the content of the source file.\n\n#### SourceMapGenerator.prototype.applySourceMap(sourceMapConsumer[, sourceFile])\n\nApplies a SourceMap for a source file to the SourceMap.\nEach mapping to the supplied source file is rewritten using the\nsupplied SourceMap. Note: The resolution for the resulting mappings\nis the minimium of this map and the supplied map.\n\n* `sourceMapConsumer`: The SourceMap to be applied.\n\n* `sourceFile`: Optional. The filename of the source file.\n If omitted, sourceMapConsumer.file will be used.\n\n#### SourceMapGenerator.prototype.toString()\n\nRenders the source map being generated to a string.\n\n### SourceNode\n\nSourceNodes provide a way to abstract over interpolating and/or concatenating\nsnippets of generated JavaScript source code, while maintaining the line and\ncolumn information associated between those snippets and the original source\ncode. This is useful as the final intermediate representation a compiler might\nuse before outputting the generated JS and source map.\n\n#### new SourceNode(line, column, source[, chunk[, name]])\n\n* `line`: The original line number associated with this source node, or null if\n it isn't associated with an original line.\n\n* `column`: The original column number associated with this source node, or null\n if it isn't associated with an original column.\n\n* `source`: The original source's filename.\n\n* `chunk`: Optional. Is immediately passed to `SourceNode.prototype.add`, see\n below.\n\n* `name`: Optional. The original identifier.\n\n#### SourceNode.fromStringWithSourceMap(code, sourceMapConsumer)\n\nCreates a SourceNode from generated code and a SourceMapConsumer.\n\n* `code`: The generated code\n\n* `sourceMapConsumer` The SourceMap for the generated code\n\n#### SourceNode.prototype.add(chunk)\n\nAdd a chunk of generated JS to this source node.\n\n* `chunk`: A string snippet of generated JS code, another instance of\n `SourceNode`, or an array where each member is one of those things.\n\n#### SourceNode.prototype.prepend(chunk)\n\nPrepend a chunk of generated JS to this source node.\n\n* `chunk`: A string snippet of generated JS code, another instance of\n `SourceNode`, or an array where each member is one of those things.\n\n#### SourceNode.prototype.setSourceContent(sourceFile, sourceContent)\n\nSet the source content for a source file. This will be added to the\n`SourceMap` in the `sourcesContent` field.\n\n* `sourceFile`: The filename of the source file\n\n* `sourceContent`: The content of the source file\n\n#### SourceNode.prototype.walk(fn)\n\nWalk over the tree of JS snippets in this node and its children. The walking\nfunction is called once for each snippet of JS and is passed that snippet and\nthe its original associated source's line/column location.\n\n* `fn`: The traversal function.\n\n#### SourceNode.prototype.walkSourceContents(fn)\n\nWalk over the tree of SourceNodes. The walking function is called for each\nsource file content and is passed the filename and source content.\n\n* `fn`: The traversal function.\n\n#### SourceNode.prototype.join(sep)\n\nLike `Array.prototype.join` except for SourceNodes. Inserts the separator\nbetween each of this source node's children.\n\n* `sep`: The separator.\n\n#### SourceNode.prototype.replaceRight(pattern, replacement)\n\nCall `String.prototype.replace` on the very right-most source snippet. Useful\nfor trimming whitespace from the end of a source node, etc.\n\n* `pattern`: The pattern to replace.\n\n* `replacement`: The thing to replace the pattern with.\n\n#### SourceNode.prototype.toString()\n\nReturn the string representation of this source node. Walks over the tree and\nconcatenates all the various snippets together to one string.\n\n### SourceNode.prototype.toStringWithSourceMap(startOfSourceMap)\n\nReturns the string representation of this tree of source nodes, plus a\nSourceMapGenerator which contains all the mappings between the generated and\noriginal sources.\n\nThe arguments are the same as those to `new SourceMapGenerator`.\n\n## Tests\n\n[![Build Status](https://travis-ci.org/mozilla/source-map.png?branch=master)](https://travis-ci.org/mozilla/source-map)\n\nInstall NodeJS version 0.8.0 or greater, then run `node test/run-tests.js`.\n\nTo add new tests, create a new file named `test/test-.js`\nand export your test functions with names that start with \"test\", for example\n\n exports[\"test doing the foo bar\"] = function (assert, util) {\n ...\n };\n\nThe new test will be located automatically when you run the suite.\n\nThe `util` argument is the test utility module located at `test/source-map/util`.\n\nThe `assert` argument is a cut down version of node's assert module. You have\naccess to the following assertion functions:\n\n* `doesNotThrow`\n\n* `equal`\n\n* `ok`\n\n* `strictEqual`\n\n* `throws`\n\n(The reason for the restricted set of test functions is because we need the\ntests to run inside Firefox's test suite as well and so the assert module is\nshimmed in that environment. See `build/assert-shim.js`.)\n\n[format]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit\n[feature]: https://wiki.mozilla.org/DevTools/Features/SourceMap\n[Dryice]: https://github.com/mozilla/dryice\n", + "readmeFilename": "README.md", + "bugs": { + "url": "https://github.com/mozilla/source-map/issues" + }, + "_id": "source-map@0.1.22", + "dist": { + "shasum": "9fae7473bfa775de276dc258aa265802478a3db9" + }, + "_from": "source-map@", + "_resolved": "https://registry.npmjs.org/source-map/-/source-map-0.1.22.tgz" +} diff --git a/tools/node_modules/source-map/test/run-tests.js b/tools/node_modules/source-map/test/run-tests.js new file mode 100755 index 0000000000000..8bf2256ffb3a2 --- /dev/null +++ b/tools/node_modules/source-map/test/run-tests.js @@ -0,0 +1,73 @@ +#!/usr/bin/env node +/* -*- Mode: js; js-indent-level: 2; -*- */ +/* + * Copyright 2011 Mozilla Foundation and contributors + * Licensed under the New BSD license. See LICENSE or: + * http://opensource.org/licenses/BSD-3-Clause + */ +var assert = require('assert'); +var fs = require('fs'); +var path = require('path'); +var util = require('./source-map/util'); + +function run(tests) { + var failures = []; + var total = 0; + var passed = 0; + + for (var i = 0; i < tests.length; i++) { + for (var k in tests[i].testCase) { + if (/^test/.test(k)) { + total++; + try { + tests[i].testCase[k](assert, util); + passed++; + process.stdout.write('.'); + } + catch (e) { + failures.push({ + name: tests[i].name + ': ' + k, + error: e + }); + process.stdout.write('E'); + } + } + } + } + + process.stdout.write('\n'); + console.log(passed + ' / ' + total + ' tests passed.'); + + failures.forEach(function (f) { + console.log('================================================================================'); + console.log(f.name); + console.log('--------------------------------------------------------------------------------'); + console.log(f.error.stack); + }); + + return failures.length; +} + +var code; + +process.stdout.on('close', function () { + process.exit(code); +}); + +function isTestFile(f) { + return /^test\-.*?\.js/.test(f); +} + +function toModule(f) { + return './source-map/' + f.replace(/\.js$/, ''); +} + +var requires = fs.readdirSync(path.join(__dirname, 'source-map')).filter(isTestFile).map(toModule); + +code = run(requires.map(require).map(function (mod, i) { + return { + name: requires[i], + testCase: mod + }; +})); +process.exit(code); diff --git a/tools/node_modules/source-map/test/source-map/test-api.js b/tools/node_modules/source-map/test/source-map/test-api.js new file mode 100644 index 0000000000000..63eb45a002258 --- /dev/null +++ b/tools/node_modules/source-map/test/source-map/test-api.js @@ -0,0 +1,26 @@ +/* -*- Mode: js; js-indent-level: 2; -*- */ +/* + * Copyright 2012 Mozilla Foundation and contributors + * Licensed under the New BSD license. See LICENSE or: + * http://opensource.org/licenses/BSD-3-Clause + */ +if (typeof define !== 'function') { + var define = require('amdefine')(module); +} +define(function (require, exports, module) { + + var sourceMap; + try { + sourceMap = require('../../lib/source-map'); + } catch (e) { + sourceMap = {}; + Components.utils.import('resource:///modules/devtools/SourceMap.jsm', sourceMap); + } + + exports['test that the api is properly exposed in the top level'] = function (assert, util) { + assert.equal(typeof sourceMap.SourceMapGenerator, "function"); + assert.equal(typeof sourceMap.SourceMapConsumer, "function"); + assert.equal(typeof sourceMap.SourceNode, "function"); + }; + +}); diff --git a/tools/node_modules/source-map/test/source-map/test-array-set.js b/tools/node_modules/source-map/test/source-map/test-array-set.js new file mode 100644 index 0000000000000..c4e88d364f917 --- /dev/null +++ b/tools/node_modules/source-map/test/source-map/test-array-set.js @@ -0,0 +1,71 @@ +/* -*- Mode: js; js-indent-level: 2; -*- */ +/* + * Copyright 2011 Mozilla Foundation and contributors + * Licensed under the New BSD license. See LICENSE or: + * http://opensource.org/licenses/BSD-3-Clause + */ +if (typeof define !== 'function') { + var define = require('amdefine')(module); +} +define(function (require, exports, module) { + + var ArraySet = require('../../lib/source-map/array-set').ArraySet; + + function makeTestSet() { + var set = new ArraySet(); + for (var i = 0; i < 100; i++) { + set.add(String(i)); + } + return set; + } + + exports['test .has() membership'] = function (assert, util) { + var set = makeTestSet(); + for (var i = 0; i < 100; i++) { + assert.ok(set.has(String(i))); + } + }; + + exports['test .indexOf() elements'] = function (assert, util) { + var set = makeTestSet(); + for (var i = 0; i < 100; i++) { + assert.strictEqual(set.indexOf(String(i)), i); + } + }; + + exports['test .at() indexing'] = function (assert, util) { + var set = makeTestSet(); + for (var i = 0; i < 100; i++) { + assert.strictEqual(set.at(i), String(i)); + } + }; + + exports['test creating from an array'] = function (assert, util) { + var set = ArraySet.fromArray(['foo', 'bar', 'baz', 'quux', 'hasOwnProperty']); + + assert.ok(set.has('foo')); + assert.ok(set.has('bar')); + assert.ok(set.has('baz')); + assert.ok(set.has('quux')); + assert.ok(set.has('hasOwnProperty')); + + assert.strictEqual(set.indexOf('foo'), 0); + assert.strictEqual(set.indexOf('bar'), 1); + assert.strictEqual(set.indexOf('baz'), 2); + assert.strictEqual(set.indexOf('quux'), 3); + + assert.strictEqual(set.at(0), 'foo'); + assert.strictEqual(set.at(1), 'bar'); + assert.strictEqual(set.at(2), 'baz'); + assert.strictEqual(set.at(3), 'quux'); + }; + + exports['test that you can add __proto__; see github issue #30'] = function (assert, util) { + var set = new ArraySet(); + set.add('__proto__'); + assert.ok(set.has('__proto__')); + assert.strictEqual(set.at(0), '__proto__'); + assert.strictEqual(set.indexOf('__proto__'), 0); + }; + +}); diff --git a/tools/node_modules/source-map/test/source-map/test-base64-vlq.js b/tools/node_modules/source-map/test/source-map/test-base64-vlq.js new file mode 100644 index 0000000000000..7100da3522ea1 --- /dev/null +++ b/tools/node_modules/source-map/test/source-map/test-base64-vlq.js @@ -0,0 +1,24 @@ +/* -*- Mode: js; js-indent-level: 2; -*- */ +/* + * Copyright 2011 Mozilla Foundation and contributors + * Licensed under the New BSD license. See LICENSE or: + * http://opensource.org/licenses/BSD-3-Clause + */ +if (typeof define !== 'function') { + var define = require('amdefine')(module); +} +define(function (require, exports, module) { + + var base64VLQ = require('../../lib/source-map/base64-vlq'); + + exports['test normal encoding and decoding'] = function (assert, util) { + var result; + for (var i = -255; i < 256; i++) { + result = base64VLQ.decode(base64VLQ.encode(i)); + assert.ok(result); + assert.equal(result.value, i); + assert.equal(result.rest, ""); + } + }; + +}); diff --git a/tools/node_modules/source-map/test/source-map/test-base64.js b/tools/node_modules/source-map/test/source-map/test-base64.js new file mode 100644 index 0000000000000..23e0f886a9edc --- /dev/null +++ b/tools/node_modules/source-map/test/source-map/test-base64.js @@ -0,0 +1,35 @@ +/* -*- Mode: js; js-indent-level: 2; -*- */ +/* + * Copyright 2011 Mozilla Foundation and contributors + * Licensed under the New BSD license. See LICENSE or: + * http://opensource.org/licenses/BSD-3-Clause + */ +if (typeof define !== 'function') { + var define = require('amdefine')(module); +} +define(function (require, exports, module) { + + var base64 = require('../../lib/source-map/base64'); + + exports['test out of range encoding'] = function (assert, util) { + assert.throws(function () { + base64.encode(-1); + }); + assert.throws(function () { + base64.encode(64); + }); + }; + + exports['test out of range decoding'] = function (assert, util) { + assert.throws(function () { + base64.decode('='); + }); + }; + + exports['test normal encoding and decoding'] = function (assert, util) { + for (var i = 0; i < 64; i++) { + assert.equal(base64.decode(base64.encode(i)), i); + } + }; + +}); diff --git a/tools/node_modules/source-map/test/source-map/test-binary-search.js b/tools/node_modules/source-map/test/source-map/test-binary-search.js new file mode 100644 index 0000000000000..41d0bf859b4e0 --- /dev/null +++ b/tools/node_modules/source-map/test/source-map/test-binary-search.js @@ -0,0 +1,54 @@ +/* -*- Mode: js; js-indent-level: 2; -*- */ +/* + * Copyright 2011 Mozilla Foundation and contributors + * Licensed under the New BSD license. See LICENSE or: + * http://opensource.org/licenses/BSD-3-Clause + */ +if (typeof define !== 'function') { + var define = require('amdefine')(module); +} +define(function (require, exports, module) { + + var binarySearch = require('../../lib/source-map/binary-search'); + + function numberCompare(a, b) { + return a - b; + } + + exports['test too high'] = function (assert, util) { + var needle = 30; + var haystack = [2,4,6,8,10,12,14,16,18,20]; + + assert.doesNotThrow(function () { + binarySearch.search(needle, haystack, numberCompare); + }); + + assert.equal(binarySearch.search(needle, haystack, numberCompare), 20); + }; + + exports['test too low'] = function (assert, util) { + var needle = 1; + var haystack = [2,4,6,8,10,12,14,16,18,20]; + + assert.doesNotThrow(function () { + binarySearch.search(needle, haystack, numberCompare); + }); + + assert.equal(binarySearch.search(needle, haystack, numberCompare), null); + }; + + exports['test exact search'] = function (assert, util) { + var needle = 4; + var haystack = [2,4,6,8,10,12,14,16,18,20]; + + assert.equal(binarySearch.search(needle, haystack, numberCompare), 4); + }; + + exports['test fuzzy search'] = function (assert, util) { + var needle = 19; + var haystack = [2,4,6,8,10,12,14,16,18,20]; + + assert.equal(binarySearch.search(needle, haystack, numberCompare), 18); + }; + +}); diff --git a/tools/node_modules/source-map/test/source-map/test-dog-fooding.js b/tools/node_modules/source-map/test/source-map/test-dog-fooding.js new file mode 100644 index 0000000000000..d433bf6bf83b5 --- /dev/null +++ b/tools/node_modules/source-map/test/source-map/test-dog-fooding.js @@ -0,0 +1,72 @@ +/* -*- Mode: js; js-indent-level: 2; -*- */ +/* + * Copyright 2011 Mozilla Foundation and contributors + * Licensed under the New BSD license. See LICENSE or: + * http://opensource.org/licenses/BSD-3-Clause + */ +if (typeof define !== 'function') { + var define = require('amdefine')(module); +} +define(function (require, exports, module) { + + var SourceMapConsumer = require('../../lib/source-map/source-map-consumer').SourceMapConsumer; + var SourceMapGenerator = require('../../lib/source-map/source-map-generator').SourceMapGenerator; + + exports['test eating our own dog food'] = function (assert, util) { + var smg = new SourceMapGenerator({ + file: 'testing.js', + sourceRoot: '/wu/tang' + }); + + smg.addMapping({ + source: 'gza.coffee', + original: { line: 1, column: 0 }, + generated: { line: 2, column: 2 } + }); + + smg.addMapping({ + source: 'gza.coffee', + original: { line: 2, column: 0 }, + generated: { line: 3, column: 2 } + }); + + smg.addMapping({ + source: 'gza.coffee', + original: { line: 3, column: 0 }, + generated: { line: 4, column: 2 } + }); + + smg.addMapping({ + source: 'gza.coffee', + original: { line: 4, column: 0 }, + generated: { line: 5, column: 2 } + }); + + var smc = new SourceMapConsumer(smg.toString()); + + // Exact + util.assertMapping(2, 2, '/wu/tang/gza.coffee', 1, 0, null, smc, assert); + util.assertMapping(3, 2, '/wu/tang/gza.coffee', 2, 0, null, smc, assert); + util.assertMapping(4, 2, '/wu/tang/gza.coffee', 3, 0, null, smc, assert); + util.assertMapping(5, 2, '/wu/tang/gza.coffee', 4, 0, null, smc, assert); + + // Fuzzy + + // Original to generated + util.assertMapping(2, 0, null, null, null, null, smc, assert, true); + util.assertMapping(2, 9, '/wu/tang/gza.coffee', 1, 0, null, smc, assert, true); + util.assertMapping(3, 0, '/wu/tang/gza.coffee', 1, 0, null, smc, assert, true); + util.assertMapping(3, 9, '/wu/tang/gza.coffee', 2, 0, null, smc, assert, true); + util.assertMapping(4, 0, '/wu/tang/gza.coffee', 2, 0, null, smc, assert, true); + util.assertMapping(4, 9, '/wu/tang/gza.coffee', 3, 0, null, smc, assert, true); + util.assertMapping(5, 0, '/wu/tang/gza.coffee', 3, 0, null, smc, assert, true); + util.assertMapping(5, 9, '/wu/tang/gza.coffee', 4, 0, null, smc, assert, true); + + // Generated to original + util.assertMapping(2, 2, '/wu/tang/gza.coffee', 1, 1, null, smc, assert, null, true); + util.assertMapping(3, 2, '/wu/tang/gza.coffee', 2, 3, null, smc, assert, null, true); + util.assertMapping(4, 2, '/wu/tang/gza.coffee', 3, 6, null, smc, assert, null, true); + util.assertMapping(5, 2, '/wu/tang/gza.coffee', 4, 9, null, smc, assert, null, true); + }; + +}); diff --git a/tools/node_modules/source-map/test/source-map/test-source-map-consumer.js b/tools/node_modules/source-map/test/source-map/test-source-map-consumer.js new file mode 100644 index 0000000000000..610d4635e0fe1 --- /dev/null +++ b/tools/node_modules/source-map/test/source-map/test-source-map-consumer.js @@ -0,0 +1,291 @@ +/* -*- Mode: js; js-indent-level: 2; -*- */ +/* + * Copyright 2011 Mozilla Foundation and contributors + * Licensed under the New BSD license. See LICENSE or: + * http://opensource.org/licenses/BSD-3-Clause + */ +if (typeof define !== 'function') { + var define = require('amdefine')(module); +} +define(function (require, exports, module) { + + var SourceMapConsumer = require('../../lib/source-map/source-map-consumer').SourceMapConsumer; + var SourceMapGenerator = require('../../lib/source-map/source-map-generator').SourceMapGenerator; + + exports['test that we can instantiate with a string or an objects'] = function (assert, util) { + assert.doesNotThrow(function () { + var map = new SourceMapConsumer(util.testMap); + }); + assert.doesNotThrow(function () { + var map = new SourceMapConsumer(JSON.stringify(util.testMap)); + }); + }; + + exports['test that the `sources` field has the original sources'] = function (assert, util) { + var map = new SourceMapConsumer(util.testMap); + var sources = map.sources; + + assert.equal(sources[0], '/the/root/one.js'); + assert.equal(sources[1], '/the/root/two.js'); + assert.equal(sources.length, 2); + }; + + exports['test that the source root is reflected in a mapping\'s source field'] = function (assert, util) { + var map = new SourceMapConsumer(util.testMap); + var mapping; + + mapping = map.originalPositionFor({ + line: 2, + column: 1 + }); + assert.equal(mapping.source, '/the/root/two.js'); + + mapping = map.originalPositionFor({ + line: 1, + column: 1 + }); + assert.equal(mapping.source, '/the/root/one.js'); + }; + + exports['test mapping tokens back exactly'] = function (assert, util) { + var map = new SourceMapConsumer(util.testMap); + + util.assertMapping(1, 1, '/the/root/one.js', 1, 1, null, map, assert); + util.assertMapping(1, 5, '/the/root/one.js', 1, 5, null, map, assert); + util.assertMapping(1, 9, '/the/root/one.js', 1, 11, null, map, assert); + util.assertMapping(1, 18, '/the/root/one.js', 1, 21, 'bar', map, assert); + util.assertMapping(1, 21, '/the/root/one.js', 2, 3, null, map, assert); + util.assertMapping(1, 28, '/the/root/one.js', 2, 10, 'baz', map, assert); + util.assertMapping(1, 32, '/the/root/one.js', 2, 14, 'bar', map, assert); + + util.assertMapping(2, 1, '/the/root/two.js', 1, 1, null, map, assert); + util.assertMapping(2, 5, '/the/root/two.js', 1, 5, null, map, assert); + util.assertMapping(2, 9, '/the/root/two.js', 1, 11, null, map, assert); + util.assertMapping(2, 18, '/the/root/two.js', 1, 21, 'n', map, assert); + util.assertMapping(2, 21, '/the/root/two.js', 2, 3, null, map, assert); + util.assertMapping(2, 28, '/the/root/two.js', 2, 10, 'n', map, assert); + }; + + exports['test mapping tokens fuzzy'] = function (assert, util) { + var map = new SourceMapConsumer(util.testMap); + + // Finding original positions + util.assertMapping(1, 20, '/the/root/one.js', 1, 21, 'bar', map, assert, true); + util.assertMapping(1, 30, '/the/root/one.js', 2, 10, 'baz', map, assert, true); + util.assertMapping(2, 12, '/the/root/two.js', 1, 11, null, map, assert, true); + + // Finding generated positions + util.assertMapping(1, 18, '/the/root/one.js', 1, 22, 'bar', map, assert, null, true); + util.assertMapping(1, 28, '/the/root/one.js', 2, 13, 'baz', map, assert, null, true); + util.assertMapping(2, 9, '/the/root/two.js', 1, 16, null, map, assert, null, true); + }; + + exports['test creating source map consumers with )]}\' prefix'] = function (assert, util) { + assert.doesNotThrow(function () { + var map = new SourceMapConsumer(")]}'" + JSON.stringify(util.testMap)); + }); + }; + + exports['test eachMapping'] = function (assert, util) { + var map = new SourceMapConsumer(util.testMap); + var previousLine = -Infinity; + var previousColumn = -Infinity; + map.eachMapping(function (mapping) { + assert.ok(mapping.generatedLine >= previousLine); + + if (mapping.source) { + assert.equal(mapping.source.indexOf(util.testMap.sourceRoot), 0); + } + + if (mapping.generatedLine === previousLine) { + assert.ok(mapping.generatedColumn >= previousColumn); + previousColumn = mapping.generatedColumn; + } + else { + previousLine = mapping.generatedLine; + previousColumn = -Infinity; + } + }); + }; + + exports['test iterating over mappings in a different order'] = function (assert, util) { + var map = new SourceMapConsumer(util.testMap); + var previousLine = -Infinity; + var previousColumn = -Infinity; + var previousSource = ""; + map.eachMapping(function (mapping) { + assert.ok(mapping.source >= previousSource); + + if (mapping.source === previousSource) { + assert.ok(mapping.originalLine >= previousLine); + + if (mapping.originalLine === previousLine) { + assert.ok(mapping.originalColumn >= previousColumn); + previousColumn = mapping.originalColumn; + } + else { + previousLine = mapping.originalLine; + previousColumn = -Infinity; + } + } + else { + previousSource = mapping.source; + previousLine = -Infinity; + previousColumn = -Infinity; + } + }, null, SourceMapConsumer.ORIGINAL_ORDER); + }; + + exports['test that we can set the context for `this` in eachMapping'] = function (assert, util) { + var map = new SourceMapConsumer(util.testMap); + var context = {}; + map.eachMapping(function () { + assert.equal(this, context); + }, context); + }; + + exports['test that the `sourcesContent` field has the original sources'] = function (assert, util) { + var map = new SourceMapConsumer(util.testMapWithSourcesContent); + var sourcesContent = map.sourcesContent; + + assert.equal(sourcesContent[0], ' ONE.foo = function (bar) {\n return baz(bar);\n };'); + assert.equal(sourcesContent[1], ' TWO.inc = function (n) {\n return n + 1;\n };'); + assert.equal(sourcesContent.length, 2); + }; + + exports['test that we can get the original sources for the sources'] = function (assert, util) { + var map = new SourceMapConsumer(util.testMapWithSourcesContent); + var sources = map.sources; + + assert.equal(map.sourceContentFor(sources[0]), ' ONE.foo = function (bar) {\n return baz(bar);\n };'); + assert.equal(map.sourceContentFor(sources[1]), ' TWO.inc = function (n) {\n return n + 1;\n };'); + assert.equal(map.sourceContentFor("one.js"), ' ONE.foo = function (bar) {\n return baz(bar);\n };'); + assert.equal(map.sourceContentFor("two.js"), ' TWO.inc = function (n) {\n return n + 1;\n };'); + assert.throws(function () { + map.sourceContentFor(""); + }, Error); + assert.throws(function () { + map.sourceContentFor("/the/root/three.js"); + }, Error); + assert.throws(function () { + map.sourceContentFor("three.js"); + }, Error); + }; + + exports['test sourceRoot + generatedPositionFor'] = function (assert, util) { + var map = new SourceMapGenerator({ + sourceRoot: 'foo/bar', + file: 'baz.js' + }); + map.addMapping({ + original: { line: 1, column: 1 }, + generated: { line: 2, column: 2 }, + source: 'bang.coffee' + }); + map.addMapping({ + original: { line: 5, column: 5 }, + generated: { line: 6, column: 6 }, + source: 'bang.coffee' + }); + map = new SourceMapConsumer(map.toString()); + + // Should handle without sourceRoot. + var pos = map.generatedPositionFor({ + line: 1, + column: 1, + source: 'bang.coffee' + }); + + assert.equal(pos.line, 2); + assert.equal(pos.column, 2); + + // Should handle with sourceRoot. + var pos = map.generatedPositionFor({ + line: 1, + column: 1, + source: 'foo/bar/bang.coffee' + }); + + assert.equal(pos.line, 2); + assert.equal(pos.column, 2); + }; + + exports['test sourceRoot + originalPositionFor'] = function (assert, util) { + var map = new SourceMapGenerator({ + sourceRoot: 'foo/bar', + file: 'baz.js' + }); + map.addMapping({ + original: { line: 1, column: 1 }, + generated: { line: 2, column: 2 }, + source: 'bang.coffee' + }); + map = new SourceMapConsumer(map.toString()); + + var pos = map.originalPositionFor({ + line: 2, + column: 2, + }); + + // Should always have the prepended source root + assert.equal(pos.source, 'foo/bar/bang.coffee'); + assert.equal(pos.line, 1); + assert.equal(pos.column, 1); + }; + + exports['test github issue #56'] = function (assert, util) { + var map = new SourceMapGenerator({ + sourceRoot: 'http://', + file: 'www.example.com/foo.js' + }); + map.addMapping({ + original: { line: 1, column: 1 }, + generated: { line: 2, column: 2 }, + source: 'www.example.com/original.js' + }); + map = new SourceMapConsumer(map.toString()); + + var sources = map.sources; + assert.equal(sources.length, 1); + assert.equal(sources[0], 'http://www.example.com/original.js'); + }; + + exports['test github issue #43'] = function (assert, util) { + var map = new SourceMapGenerator({ + sourceRoot: 'http://example.com', + file: 'foo.js' + }); + map.addMapping({ + original: { line: 1, column: 1 }, + generated: { line: 2, column: 2 }, + source: 'http://cdn.example.com/original.js' + }); + map = new SourceMapConsumer(map.toString()); + + var sources = map.sources; + assert.equal(sources.length, 1, + 'Should only be one source.'); + assert.equal(sources[0], 'http://cdn.example.com/original.js', + 'Should not be joined with the sourceRoot.'); + }; + + exports['test absolute path, but same host sources'] = function (assert, util) { + var map = new SourceMapGenerator({ + sourceRoot: 'http://example.com/foo/bar', + file: 'foo.js' + }); + map.addMapping({ + original: { line: 1, column: 1 }, + generated: { line: 2, column: 2 }, + source: '/original.js' + }); + map = new SourceMapConsumer(map.toString()); + + var sources = map.sources; + assert.equal(sources.length, 1, + 'Should only be one source.'); + assert.equal(sources[0], 'http://example.com/original.js', + 'Source should be relative the host of the source root.'); + }; + +}); diff --git a/tools/node_modules/source-map/test/source-map/test-source-map-generator.js b/tools/node_modules/source-map/test/source-map/test-source-map-generator.js new file mode 100644 index 0000000000000..2c42c8cac985e --- /dev/null +++ b/tools/node_modules/source-map/test/source-map/test-source-map-generator.js @@ -0,0 +1,391 @@ +/* -*- Mode: js; js-indent-level: 2; -*- */ +/* + * Copyright 2011 Mozilla Foundation and contributors + * Licensed under the New BSD license. See LICENSE or: + * http://opensource.org/licenses/BSD-3-Clause + */ +if (typeof define !== 'function') { + var define = require('amdefine')(module); +} +define(function (require, exports, module) { + + var SourceMapGenerator = require('../../lib/source-map/source-map-generator').SourceMapGenerator; + var SourceMapConsumer = require('../../lib/source-map/source-map-consumer').SourceMapConsumer; + var SourceNode = require('../../lib/source-map/source-node').SourceNode; + var util = require('./util'); + + exports['test some simple stuff'] = function (assert, util) { + var map = new SourceMapGenerator({ + file: 'foo.js', + sourceRoot: '.' + }); + assert.ok(true); + }; + + exports['test JSON serialization'] = function (assert, util) { + var map = new SourceMapGenerator({ + file: 'foo.js', + sourceRoot: '.' + }); + assert.equal(map.toString(), JSON.stringify(map)); + }; + + exports['test adding mappings (case 1)'] = function (assert, util) { + var map = new SourceMapGenerator({ + file: 'generated-foo.js', + sourceRoot: '.' + }); + + assert.doesNotThrow(function () { + map.addMapping({ + generated: { line: 1, column: 1 } + }); + }); + }; + + exports['test adding mappings (case 2)'] = function (assert, util) { + var map = new SourceMapGenerator({ + file: 'generated-foo.js', + sourceRoot: '.' + }); + + assert.doesNotThrow(function () { + map.addMapping({ + generated: { line: 1, column: 1 }, + source: 'bar.js', + original: { line: 1, column: 1 } + }); + }); + }; + + exports['test adding mappings (case 3)'] = function (assert, util) { + var map = new SourceMapGenerator({ + file: 'generated-foo.js', + sourceRoot: '.' + }); + + assert.doesNotThrow(function () { + map.addMapping({ + generated: { line: 1, column: 1 }, + source: 'bar.js', + original: { line: 1, column: 1 }, + name: 'someToken' + }); + }); + }; + + exports['test adding mappings (invalid)'] = function (assert, util) { + var map = new SourceMapGenerator({ + file: 'generated-foo.js', + sourceRoot: '.' + }); + + // Not enough info. + assert.throws(function () { + map.addMapping({}); + }); + + // Original file position, but no source. + assert.throws(function () { + map.addMapping({ + generated: { line: 1, column: 1 }, + original: { line: 1, column: 1 } + }); + }); + }; + + exports['test that the correct mappings are being generated'] = function (assert, util) { + var map = new SourceMapGenerator({ + file: 'min.js', + sourceRoot: '/the/root' + }); + + map.addMapping({ + generated: { line: 1, column: 1 }, + original: { line: 1, column: 1 }, + source: 'one.js' + }); + map.addMapping({ + generated: { line: 1, column: 5 }, + original: { line: 1, column: 5 }, + source: 'one.js' + }); + map.addMapping({ + generated: { line: 1, column: 9 }, + original: { line: 1, column: 11 }, + source: 'one.js' + }); + map.addMapping({ + generated: { line: 1, column: 18 }, + original: { line: 1, column: 21 }, + source: 'one.js', + name: 'bar' + }); + map.addMapping({ + generated: { line: 1, column: 21 }, + original: { line: 2, column: 3 }, + source: 'one.js' + }); + map.addMapping({ + generated: { line: 1, column: 28 }, + original: { line: 2, column: 10 }, + source: 'one.js', + name: 'baz' + }); + map.addMapping({ + generated: { line: 1, column: 32 }, + original: { line: 2, column: 14 }, + source: 'one.js', + name: 'bar' + }); + + map.addMapping({ + generated: { line: 2, column: 1 }, + original: { line: 1, column: 1 }, + source: 'two.js' + }); + map.addMapping({ + generated: { line: 2, column: 5 }, + original: { line: 1, column: 5 }, + source: 'two.js' + }); + map.addMapping({ + generated: { line: 2, column: 9 }, + original: { line: 1, column: 11 }, + source: 'two.js' + }); + map.addMapping({ + generated: { line: 2, column: 18 }, + original: { line: 1, column: 21 }, + source: 'two.js', + name: 'n' + }); + map.addMapping({ + generated: { line: 2, column: 21 }, + original: { line: 2, column: 3 }, + source: 'two.js' + }); + map.addMapping({ + generated: { line: 2, column: 28 }, + original: { line: 2, column: 10 }, + source: 'two.js', + name: 'n' + }); + + map = JSON.parse(map.toString()); + + util.assertEqualMaps(assert, map, util.testMap); + }; + + exports['test that source content can be set'] = function (assert, util) { + var map = new SourceMapGenerator({ + file: 'min.js', + sourceRoot: '/the/root' + }); + map.addMapping({ + generated: { line: 1, column: 1 }, + original: { line: 1, column: 1 }, + source: 'one.js' + }); + map.addMapping({ + generated: { line: 2, column: 1 }, + original: { line: 1, column: 1 }, + source: 'two.js' + }); + map.setSourceContent('one.js', 'one file content'); + + map = JSON.parse(map.toString()); + assert.equal(map.sources[0], 'one.js'); + assert.equal(map.sources[1], 'two.js'); + assert.equal(map.sourcesContent[0], 'one file content'); + assert.equal(map.sourcesContent[1], null); + }; + + exports['test .fromSourceMap'] = function (assert, util) { + var map = SourceMapGenerator.fromSourceMap(new SourceMapConsumer(util.testMap)); + util.assertEqualMaps(assert, map.toJSON(), util.testMap); + }; + + exports['test .fromSourceMap with sourcesContent'] = function (assert, util) { + var map = SourceMapGenerator.fromSourceMap( + new SourceMapConsumer(util.testMapWithSourcesContent)); + util.assertEqualMaps(assert, map.toJSON(), util.testMapWithSourcesContent); + }; + + exports['test applySourceMap'] = function (assert, util) { + var node = new SourceNode(null, null, null, [ + new SourceNode(2, 0, 'fileX', 'lineX2\n'), + 'genA1\n', + new SourceNode(2, 0, 'fileY', 'lineY2\n'), + 'genA2\n', + new SourceNode(1, 0, 'fileX', 'lineX1\n'), + 'genA3\n', + new SourceNode(1, 0, 'fileY', 'lineY1\n') + ]); + var mapStep1 = node.toStringWithSourceMap({ + file: 'fileA' + }).map; + mapStep1.setSourceContent('fileX', 'lineX1\nlineX2\n'); + mapStep1 = mapStep1.toJSON(); + + node = new SourceNode(null, null, null, [ + 'gen1\n', + new SourceNode(1, 0, 'fileA', 'lineA1\n'), + new SourceNode(2, 0, 'fileA', 'lineA2\n'), + new SourceNode(3, 0, 'fileA', 'lineA3\n'), + new SourceNode(4, 0, 'fileA', 'lineA4\n'), + new SourceNode(1, 0, 'fileB', 'lineB1\n'), + new SourceNode(2, 0, 'fileB', 'lineB2\n'), + 'gen2\n' + ]); + var mapStep2 = node.toStringWithSourceMap({ + file: 'fileGen' + }).map; + mapStep2.setSourceContent('fileB', 'lineB1\nlineB2\n'); + mapStep2 = mapStep2.toJSON(); + + node = new SourceNode(null, null, null, [ + 'gen1\n', + new SourceNode(2, 0, 'fileX', 'lineA1\n'), + new SourceNode(2, 0, 'fileA', 'lineA2\n'), + new SourceNode(2, 0, 'fileY', 'lineA3\n'), + new SourceNode(4, 0, 'fileA', 'lineA4\n'), + new SourceNode(1, 0, 'fileB', 'lineB1\n'), + new SourceNode(2, 0, 'fileB', 'lineB2\n'), + 'gen2\n' + ]); + var expectedMap = node.toStringWithSourceMap({ + file: 'fileGen' + }).map; + expectedMap.setSourceContent('fileX', 'lineX1\nlineX2\n'); + expectedMap.setSourceContent('fileB', 'lineB1\nlineB2\n'); + expectedMap = expectedMap.toJSON(); + + // apply source map "mapStep1" to "mapStep2" + var generator = SourceMapGenerator.fromSourceMap(new SourceMapConsumer(mapStep2)); + generator.applySourceMap(new SourceMapConsumer(mapStep1)); + var actualMap = generator.toJSON(); + + util.assertEqualMaps(assert, actualMap, expectedMap); + }; + + exports['test sorting with duplicate generated mappings'] = function (assert, util) { + var map = new SourceMapGenerator({ + file: 'test.js' + }); + map.addMapping({ + generated: { line: 3, column: 0 }, + original: { line: 2, column: 0 }, + source: 'a.js' + }); + map.addMapping({ + generated: { line: 2, column: 0 } + }); + map.addMapping({ + generated: { line: 2, column: 0 } + }); + map.addMapping({ + generated: { line: 1, column: 0 }, + original: { line: 1, column: 0 }, + source: 'a.js' + }); + + util.assertEqualMaps(assert, map.toJSON(), { + version: 3, + file: 'test.js', + sources: ['a.js'], + names: [], + mappings: 'AAAA;A;AACA' + }); + }; + + exports['test ignore duplicate mappings.'] = function (assert, util) { + var init = { file: 'min.js', sourceRoot: '/the/root' }; + var map1, map2; + + // null original source location + var nullMapping1 = { + generated: { line: 1, column: 0 } + }; + var nullMapping2 = { + generated: { line: 2, column: 2 } + }; + + map1 = new SourceMapGenerator(init); + map2 = new SourceMapGenerator(init); + + map1.addMapping(nullMapping1); + map1.addMapping(nullMapping1); + + map2.addMapping(nullMapping1); + + util.assertEqualMaps(assert, map1.toJSON(), map2.toJSON()); + + map1.addMapping(nullMapping2); + map1.addMapping(nullMapping1); + + map2.addMapping(nullMapping2); + + util.assertEqualMaps(assert, map1.toJSON(), map2.toJSON()); + + // original source location + var srcMapping1 = { + generated: { line: 1, column: 0 }, + original: { line: 11, column: 0 }, + source: 'srcMapping1.js' + }; + var srcMapping2 = { + generated: { line: 2, column: 2 }, + original: { line: 11, column: 0 }, + source: 'srcMapping2.js' + }; + + map1 = new SourceMapGenerator(init); + map2 = new SourceMapGenerator(init); + + map1.addMapping(srcMapping1); + map1.addMapping(srcMapping1); + + map2.addMapping(srcMapping1); + + util.assertEqualMaps(assert, map1.toJSON(), map2.toJSON()); + + map1.addMapping(srcMapping2); + map1.addMapping(srcMapping1); + + map2.addMapping(srcMapping2); + + util.assertEqualMaps(assert, map1.toJSON(), map2.toJSON()); + + // full original source and name information + var fullMapping1 = { + generated: { line: 1, column: 0 }, + original: { line: 11, column: 0 }, + source: 'fullMapping1.js', + name: 'fullMapping1' + }; + var fullMapping2 = { + generated: { line: 2, column: 2 }, + original: { line: 11, column: 0 }, + source: 'fullMapping2.js', + name: 'fullMapping2' + }; + + map1 = new SourceMapGenerator(init); + map2 = new SourceMapGenerator(init); + + map1.addMapping(fullMapping1); + map1.addMapping(fullMapping1); + + map2.addMapping(fullMapping1); + + util.assertEqualMaps(assert, map1.toJSON(), map2.toJSON()); + + map1.addMapping(fullMapping2); + map1.addMapping(fullMapping1); + + map2.addMapping(fullMapping2); + + util.assertEqualMaps(assert, map1.toJSON(), map2.toJSON()); + }; +}); diff --git a/tools/node_modules/source-map/test/source-map/test-source-node.js b/tools/node_modules/source-map/test/source-map/test-source-node.js new file mode 100644 index 0000000000000..231dd7bd9eb03 --- /dev/null +++ b/tools/node_modules/source-map/test/source-map/test-source-node.js @@ -0,0 +1,282 @@ +/* -*- Mode: js; js-indent-level: 2; -*- */ +/* + * Copyright 2011 Mozilla Foundation and contributors + * Licensed under the New BSD license. See LICENSE or: + * http://opensource.org/licenses/BSD-3-Clause + */ +if (typeof define !== 'function') { + var define = require('amdefine')(module); +} +define(function (require, exports, module) { + + var SourceMapGenerator = require('../../lib/source-map/source-map-generator').SourceMapGenerator; + var SourceMapConsumer = require('../../lib/source-map/source-map-consumer').SourceMapConsumer; + var SourceNode = require('../../lib/source-map/source-node').SourceNode; + + exports['test .add()'] = function (assert, util) { + var node = new SourceNode(null, null, null); + + // Adding a string works. + node.add('function noop() {}'); + + // Adding another source node works. + node.add(new SourceNode(null, null, null)); + + // Adding an array works. + node.add(['function foo() {', + new SourceNode(null, null, null, + 'return 10;'), + '}']); + + // Adding other stuff doesn't. + assert.throws(function () { + node.add({}); + }); + assert.throws(function () { + node.add(function () {}); + }); + }; + + exports['test .prepend()'] = function (assert, util) { + var node = new SourceNode(null, null, null); + + // Prepending a string works. + node.prepend('function noop() {}'); + assert.equal(node.children[0], 'function noop() {}'); + assert.equal(node.children.length, 1); + + // Prepending another source node works. + node.prepend(new SourceNode(null, null, null)); + assert.equal(node.children[0], ''); + assert.equal(node.children[1], 'function noop() {}'); + assert.equal(node.children.length, 2); + + // Prepending an array works. + node.prepend(['function foo() {', + new SourceNode(null, null, null, + 'return 10;'), + '}']); + assert.equal(node.children[0], 'function foo() {'); + assert.equal(node.children[1], 'return 10;'); + assert.equal(node.children[2], '}'); + assert.equal(node.children[3], ''); + assert.equal(node.children[4], 'function noop() {}'); + assert.equal(node.children.length, 5); + + // Prepending other stuff doesn't. + assert.throws(function () { + node.prepend({}); + }); + assert.throws(function () { + node.prepend(function () {}); + }); + }; + + exports['test .toString()'] = function (assert, util) { + assert.equal((new SourceNode(null, null, null, + ['function foo() {', + new SourceNode(null, null, null, 'return 10;'), + '}'])).toString(), + 'function foo() {return 10;}'); + }; + + exports['test .join()'] = function (assert, util) { + assert.equal((new SourceNode(null, null, null, + ['a', 'b', 'c', 'd'])).join(', ').toString(), + 'a, b, c, d'); + }; + + exports['test .walk()'] = function (assert, util) { + var node = new SourceNode(null, null, null, + ['(function () {\n', + ' ', new SourceNode(1, 0, 'a.js', ['someCall()']), ';\n', + ' ', new SourceNode(2, 0, 'b.js', ['if (foo) bar()']), ';\n', + '}());']); + var expected = [ + { str: '(function () {\n', source: null, line: null, column: null }, + { str: ' ', source: null, line: null, column: null }, + { str: 'someCall()', source: 'a.js', line: 1, column: 0 }, + { str: ';\n', source: null, line: null, column: null }, + { str: ' ', source: null, line: null, column: null }, + { str: 'if (foo) bar()', source: 'b.js', line: 2, column: 0 }, + { str: ';\n', source: null, line: null, column: null }, + { str: '}());', source: null, line: null, column: null }, + ]; + var i = 0; + node.walk(function (chunk, loc) { + assert.equal(expected[i].str, chunk); + assert.equal(expected[i].source, loc.source); + assert.equal(expected[i].line, loc.line); + assert.equal(expected[i].column, loc.column); + i++; + }); + }; + + exports['test .replaceRight'] = function (assert, util) { + var node; + + // Not nested + node = new SourceNode(null, null, null, 'hello world'); + node.replaceRight(/world/, 'universe'); + assert.equal(node.toString(), 'hello universe'); + + // Nested + node = new SourceNode(null, null, null, + [new SourceNode(null, null, null, 'hey sexy mama, '), + new SourceNode(null, null, null, 'want to kill all humans?')]); + node.replaceRight(/kill all humans/, 'watch Futurama'); + assert.equal(node.toString(), 'hey sexy mama, want to watch Futurama?'); + }; + + exports['test .toStringWithSourceMap()'] = function (assert, util) { + var node = new SourceNode(null, null, null, + ['(function () {\n', + ' ', + new SourceNode(1, 0, 'a.js', 'someCall', 'originalCall'), + new SourceNode(1, 8, 'a.js', '()'), + ';\n', + ' ', new SourceNode(2, 0, 'b.js', ['if (foo) bar()']), ';\n', + '}());']); + var map = node.toStringWithSourceMap({ + file: 'foo.js' + }).map; + + assert.ok(map instanceof SourceMapGenerator, 'map instanceof SourceMapGenerator'); + map = new SourceMapConsumer(map.toString()); + + var actual; + + actual = map.originalPositionFor({ + line: 1, + column: 4 + }); + assert.equal(actual.source, null); + assert.equal(actual.line, null); + assert.equal(actual.column, null); + + actual = map.originalPositionFor({ + line: 2, + column: 2 + }); + assert.equal(actual.source, 'a.js'); + assert.equal(actual.line, 1); + assert.equal(actual.column, 0); + assert.equal(actual.name, 'originalCall'); + + actual = map.originalPositionFor({ + line: 3, + column: 2 + }); + assert.equal(actual.source, 'b.js'); + assert.equal(actual.line, 2); + assert.equal(actual.column, 0); + + actual = map.originalPositionFor({ + line: 3, + column: 16 + }); + assert.equal(actual.source, null); + assert.equal(actual.line, null); + assert.equal(actual.column, null); + + actual = map.originalPositionFor({ + line: 4, + column: 2 + }); + assert.equal(actual.source, null); + assert.equal(actual.line, null); + assert.equal(actual.column, null); + }; + + exports['test .fromStringWithSourceMap()'] = function (assert, util) { + var node = SourceNode.fromStringWithSourceMap( + util.testGeneratedCode, + new SourceMapConsumer(util.testMap)); + + var result = node.toStringWithSourceMap({ + file: 'min.js' + }); + var map = result.map; + var code = result.code; + + assert.equal(code, util.testGeneratedCode); + assert.ok(map instanceof SourceMapGenerator, 'map instanceof SourceMapGenerator'); + map = map.toJSON(); + assert.equal(map.version, util.testMap.version); + assert.equal(map.file, util.testMap.file); + assert.equal(map.mappings, util.testMap.mappings); + }; + + exports['test .fromStringWithSourceMap() complex version'] = function (assert, util) { + var input = new SourceNode(null, null, null, [ + "(function() {\n", + " var Test = {};\n", + " ", new SourceNode(1, 0, "a.js", "Test.A = { value: 1234 };\n"), + " ", new SourceNode(2, 0, "a.js", "Test.A.x = 'xyz';"), "\n", + "}());\n", + "/* Generated Source */"]); + input = input.toStringWithSourceMap({ + file: 'foo.js' + }); + + var node = SourceNode.fromStringWithSourceMap( + input.code, + new SourceMapConsumer(input.map.toString())); + + var result = node.toStringWithSourceMap({ + file: 'foo.js' + }); + var map = result.map; + var code = result.code; + + assert.equal(code, input.code); + assert.ok(map instanceof SourceMapGenerator, 'map instanceof SourceMapGenerator'); + map = map.toJSON(); + var inputMap = input.map.toJSON(); + util.assertEqualMaps(assert, map, inputMap); + }; + + exports['test setSourceContent with toStringWithSourceMap'] = function (assert, util) { + var aNode = new SourceNode(1, 1, 'a.js', 'a'); + aNode.setSourceContent('a.js', 'someContent'); + var node = new SourceNode(null, null, null, + ['(function () {\n', + ' ', aNode, + ' ', new SourceNode(1, 1, 'b.js', 'b'), + '}());']); + node.setSourceContent('b.js', 'otherContent'); + var map = node.toStringWithSourceMap({ + file: 'foo.js' + }).map; + + assert.ok(map instanceof SourceMapGenerator, 'map instanceof SourceMapGenerator'); + map = new SourceMapConsumer(map.toString()); + + assert.equal(map.sources.length, 2); + assert.equal(map.sources[0], 'a.js'); + assert.equal(map.sources[1], 'b.js'); + assert.equal(map.sourcesContent.length, 2); + assert.equal(map.sourcesContent[0], 'someContent'); + assert.equal(map.sourcesContent[1], 'otherContent'); + }; + + exports['test walkSourceContents'] = function (assert, util) { + var aNode = new SourceNode(1, 1, 'a.js', 'a'); + aNode.setSourceContent('a.js', 'someContent'); + var node = new SourceNode(null, null, null, + ['(function () {\n', + ' ', aNode, + ' ', new SourceNode(1, 1, 'b.js', 'b'), + '}());']); + node.setSourceContent('b.js', 'otherContent'); + var results = []; + node.walkSourceContents(function (sourceFile, sourceContent) { + results.push([sourceFile, sourceContent]); + }); + assert.equal(results.length, 2); + assert.equal(results[0][0], 'a.js'); + assert.equal(results[0][1], 'someContent'); + assert.equal(results[1][0], 'b.js'); + assert.equal(results[1][1], 'otherContent'); + }; +}); diff --git a/tools/node_modules/source-map/test/source-map/util.js b/tools/node_modules/source-map/test/source-map/util.js new file mode 100644 index 0000000000000..3e19fc90d51f8 --- /dev/null +++ b/tools/node_modules/source-map/test/source-map/util.js @@ -0,0 +1,152 @@ +/* -*- Mode: js; js-indent-level: 2; -*- */ +/* + * Copyright 2011 Mozilla Foundation and contributors + * Licensed under the New BSD license. See LICENSE or: + * http://opensource.org/licenses/BSD-3-Clause + */ +if (typeof define !== 'function') { + var define = require('amdefine')(module); +} +define(function (require, exports, module) { + + var util = require('../../lib/source-map/util'); + + // This is a test mapping which maps functions from two different files + // (one.js and two.js) to a minified generated source. + // + // Here is one.js: + // + // ONE.foo = function (bar) { + // return baz(bar); + // }; + // + // Here is two.js: + // + // TWO.inc = function (n) { + // return n + 1; + // }; + // + // And here is the generated code (min.js): + // + // ONE.foo=function(a){return baz(a);}; + // TWO.inc=function(a){return a+1;}; + exports.testGeneratedCode = " ONE.foo=function(a){return baz(a);};\n"+ + " TWO.inc=function(a){return a+1;};"; + exports.testMap = { + version: 3, + file: 'min.js', + names: ['bar', 'baz', 'n'], + sources: ['one.js', 'two.js'], + sourceRoot: '/the/root', + mappings: 'CAAC,IAAI,IAAM,SAAUA,GAClB,OAAOC,IAAID;CCDb,IAAI,IAAM,SAAUE,GAClB,OAAOA' + }; + exports.testMapWithSourcesContent = { + version: 3, + file: 'min.js', + names: ['bar', 'baz', 'n'], + sources: ['one.js', 'two.js'], + sourcesContent: [ + ' ONE.foo = function (bar) {\n' + + ' return baz(bar);\n' + + ' };', + ' TWO.inc = function (n) {\n' + + ' return n + 1;\n' + + ' };' + ], + sourceRoot: '/the/root', + mappings: 'CAAC,IAAI,IAAM,SAAUA,GAClB,OAAOC,IAAID;CCDb,IAAI,IAAM,SAAUE,GAClB,OAAOA' + }; + + function assertMapping(generatedLine, generatedColumn, originalSource, + originalLine, originalColumn, name, map, assert, + dontTestGenerated, dontTestOriginal) { + if (!dontTestOriginal) { + var origMapping = map.originalPositionFor({ + line: generatedLine, + column: generatedColumn + }); + assert.equal(origMapping.name, name, + 'Incorrect name, expected ' + JSON.stringify(name) + + ', got ' + JSON.stringify(origMapping.name)); + assert.equal(origMapping.line, originalLine, + 'Incorrect line, expected ' + JSON.stringify(originalLine) + + ', got ' + JSON.stringify(origMapping.line)); + assert.equal(origMapping.column, originalColumn, + 'Incorrect column, expected ' + JSON.stringify(originalColumn) + + ', got ' + JSON.stringify(origMapping.column)); + + var expectedSource; + + if (originalSource && map.sourceRoot && originalSource.indexOf(map.sourceRoot) === 0) { + expectedSource = originalSource; + } else if (originalSource) { + expectedSource = map.sourceRoot + ? util.join(map.sourceRoot, originalSource) + : originalSource; + } else { + expectedSource = null; + } + + assert.equal(origMapping.source, expectedSource, + 'Incorrect source, expected ' + JSON.stringify(expectedSource) + + ', got ' + JSON.stringify(origMapping.source)); + } + + if (!dontTestGenerated) { + var genMapping = map.generatedPositionFor({ + source: originalSource, + line: originalLine, + column: originalColumn + }); + assert.equal(genMapping.line, generatedLine, + 'Incorrect line, expected ' + JSON.stringify(generatedLine) + + ', got ' + JSON.stringify(genMapping.line)); + assert.equal(genMapping.column, generatedColumn, + 'Incorrect column, expected ' + JSON.stringify(generatedColumn) + + ', got ' + JSON.stringify(genMapping.column)); + } + } + exports.assertMapping = assertMapping; + + function assertEqualMaps(assert, actualMap, expectedMap) { + assert.equal(actualMap.version, expectedMap.version, "version mismatch"); + assert.equal(actualMap.file, expectedMap.file, "file mismatch"); + assert.equal(actualMap.names.length, + expectedMap.names.length, + "names length mismatch: " + + actualMap.names.join(", ") + " != " + expectedMap.names.join(", ")); + for (var i = 0; i < actualMap.names.length; i++) { + assert.equal(actualMap.names[i], + expectedMap.names[i], + "names[" + i + "] mismatch: " + + actualMap.names.join(", ") + " != " + expectedMap.names.join(", ")); + } + assert.equal(actualMap.sources.length, + expectedMap.sources.length, + "sources length mismatch: " + + actualMap.sources.join(", ") + " != " + expectedMap.sources.join(", ")); + for (var i = 0; i < actualMap.sources.length; i++) { + assert.equal(actualMap.sources[i], + expectedMap.sources[i], + "sources[" + i + "] length mismatch: " + + actualMap.sources.join(", ") + " != " + expectedMap.sources.join(", ")); + } + assert.equal(actualMap.sourceRoot, + expectedMap.sourceRoot, + "sourceRoot mismatch: " + + actualMap.sourceRoot + " != " + expectedMap.sourceRoot); + assert.equal(actualMap.mappings, expectedMap.mappings, "mappings mismatch"); + if (actualMap.sourcesContent) { + assert.equal(actualMap.sourcesContent.length, + expectedMap.sourcesContent.length, + "sourcesContent length mismatch"); + for (var i = 0; i < actualMap.sourcesContent.length; i++) { + assert.equal(actualMap.sourcesContent[i], + expectedMap.sourcesContent[i], + "sourcesContent[" + i + "] mismatch"); + } + } + } + exports.assertEqualMaps = assertEqualMaps; + +}); From 747f74e1055feaea11222978d46c421ac92602ea Mon Sep 17 00:00:00 2001 From: Jez Ng Date: Thu, 6 Jun 2013 17:46:13 -0700 Subject: [PATCH 02/69] Implement basic source maps. Closes #1252. --- emcc | 9 +++- tools/sourcemapper.js | 118 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 126 insertions(+), 1 deletion(-) create mode 100755 tools/sourcemapper.js diff --git a/emcc b/emcc index b8230e95dea9d..9c3514f3b92f2 100755 --- a/emcc +++ b/emcc @@ -49,7 +49,7 @@ emcc can be influenced by a few environment variables: import os, sys, shutil, tempfile, subprocess, shlex, time, re, logging from subprocess import PIPE, STDOUT -from tools import shared +from tools import shared, jsrun from tools.shared import Compression, execute, suffix, unsuffixed, unsuffixed_basename from tools.response_file import read_response_file @@ -1585,12 +1585,17 @@ try: else: logging.debug('did not see memory initialization') + def generate_source_maps(filename, mapFileBaseName): + jsrun.run_js(shared.path_from_root('tools', 'sourcemapper.js'), + shared.NODE_JS, [filename, os.getcwd(), mapFileBaseName]) + # If we were asked to also generate HTML, do that if final_suffix == 'html': logging.debug('generating HTML') shell = open(shell_path).read() html = open(target, 'w') if not Compression.on: + if keep_js_debug: generate_source_maps(final, target) html.write(shell.replace('{{{ SCRIPT_CODE }}}', open(final).read())) else: # Compress the main code @@ -1661,6 +1666,8 @@ try: from tools.split import split_javascript_file split_javascript_file(final, unsuffixed(target), split_js_file) else: + if keep_js_debug: generate_source_maps(final, target) + # copy final JS to output shutil.move(final, target) diff --git a/tools/sourcemapper.js b/tools/sourcemapper.js new file mode 100755 index 0000000000000..1f28b3712bc41 --- /dev/null +++ b/tools/sourcemapper.js @@ -0,0 +1,118 @@ +#! /usr/bin/env node + +"use strict"; + +function countLines(s) { + var count = 0; + for (var i = 0, l = s.length; i < l; i ++) { + var c = s[i]; + if (c === '\n') count++; + } + return count; +} + +/* + * Extracts the line (not block) comments from the generated function code and + * invokes commentHandler with (comment content, line number of comment). This + * function implements a simplistic lexer with the following assumptions: + * 1. "// EMSCRIPTEN_START_FUNCS" and "// EMSCRIPTEN_END_FUNCS" are unique + * markers for separating library code from generated function code. Things + * will break if they appear as part of a string in library code (but OK if + * they occur in generated code). + * 2. Between these two markers, no regexes are used. + */ +function extractComments(source, commentHandler) { + var state = 'code'; + var commentContent = ''; + var functionStartIdx = source.indexOf('// EMSCRIPTEN_START_FUNCS'); + var functionEndIdx = source.lastIndexOf('// EMSCRIPTEN_END_FUNCS'); + var lineCount = countLines(source.slice(0, functionStartIdx)); + + for (var i = functionStartIdx; i < functionEndIdx; i++) { + var c = source[i]; + var nextC = source[i+1]; + if (c === '\n') lineCount++; + switch (state) { + case 'code': + if (c === '/') { + if (nextC === '/') { state = 'lineComment'; i++; } + else if (nextC === '*') { state = 'blockComment'; i++; } + } + else if (c === '"') state = 'doubleQuotedString'; + else if (c === '\'') state = 'singleQuotedString'; + break; + case 'lineComment': + if (c === '\n') { + state = 'code'; + commentHandler(commentContent, lineCount); + commentContent = ""; + } else { + commentContent += c; + } + break; + case 'blockComment': + if (c === '*' && nextC === '/') state = 'code'; + case 'singleQuotedString': + if (c === '\\') i++; + else if (c === '\'') state = 'code'; + break; + case 'doubleQuotedString': + if (c === '\\') i++; + else if (c === '"') state = 'code'; + break; + } + } +} + +function generateMap(fileName, sourceRoot, mapFileBaseName) { + var fs = require('fs'); + var path = require('path'); + var SourceMapGenerator = require('source-map').SourceMapGenerator; + + var generator = new SourceMapGenerator({ file: fileName }); + var generatedSource = fs.readFileSync(fileName, 'utf-8'); + var seenFiles = Object.create(null); + + extractComments(generatedSource, function(content, generatedLineNumber) { + console.log(content, generatedLineNumber) + var matches = /@line (\d+) "([^"]*)"/.exec(content); + if (matches === null) return; + var originalLineNumber = parseInt(matches[1], 10); + var originalFileName = matches[2]; + + if (!(originalFileName in seenFiles)) { + seenFiles[originalFileName] = true; + try { + generator.setSourceContent(originalFileName, + fs.readFileSync(sourceRoot + "/" + originalFileName)); + } catch (e) { + console.warn("Unable to find original file for " + originalFileName); + } + } + + generator.addMapping({ + generated: { line: generatedLineNumber, column: 0 }, + original: { line: originalLineNumber, column: 0 }, + source: originalFileName + }); + }); + + var mapFileName = mapFileBaseName + '.map'; + fs.writeFileSync(mapFileName, generator.toString()); + + var lastLine = generatedSource.slice(generatedSource.lastIndexOf('\n')); + if (!/sourceMappingURL/.test(lastLine)) + fs.appendFileSync(fileName, '//@ sourceMappingURL=' + path.basename(mapFileName)); +} + +if (require.main === module) { + if (process.argv.length < 3) { + console.log('Usage: ./sourcemapper.js ' + + ''); + process.exit(1); + } else { + var sourceRoot = process.argv.length > 3 ? process.argv[3] : "."; + var mapFileBaseName = process.argv.length > 4 ? process.argv[4] : process.argv[2]; + generateMap(process.argv[2], sourceRoot, mapFileBaseName); + } +} From 165befaa29b7226b28caecd2f30bae91dc20f26f Mon Sep 17 00:00:00 2001 From: Jez Ng Date: Thu, 6 Jun 2013 18:12:39 -0700 Subject: [PATCH 03/69] Add check for keep_llvm_debug + minor touchups. --- emcc | 4 ++-- tools/sourcemapper.js | 4 +--- 2 files changed, 3 insertions(+), 5 deletions(-) diff --git a/emcc b/emcc index 9c3514f3b92f2..7eb9effaf78be 100755 --- a/emcc +++ b/emcc @@ -1595,7 +1595,7 @@ try: shell = open(shell_path).read() html = open(target, 'w') if not Compression.on: - if keep_js_debug: generate_source_maps(final, target) + if keep_llvm_debug and keep_js_debug: generate_source_maps(final, target) html.write(shell.replace('{{{ SCRIPT_CODE }}}', open(final).read())) else: # Compress the main code @@ -1666,7 +1666,7 @@ try: from tools.split import split_javascript_file split_javascript_file(final, unsuffixed(target), split_js_file) else: - if keep_js_debug: generate_source_maps(final, target) + if keep_llvm_debug and keep_js_debug: generate_source_maps(final, target) # copy final JS to output shutil.move(final, target) diff --git a/tools/sourcemapper.js b/tools/sourcemapper.js index 1f28b3712bc41..3d8dbe99c8611 100755 --- a/tools/sourcemapper.js +++ b/tools/sourcemapper.js @@ -5,8 +5,7 @@ function countLines(s) { var count = 0; for (var i = 0, l = s.length; i < l; i ++) { - var c = s[i]; - if (c === '\n') count++; + if (s[i] === '\n') count++; } return count; } @@ -74,7 +73,6 @@ function generateMap(fileName, sourceRoot, mapFileBaseName) { var seenFiles = Object.create(null); extractComments(generatedSource, function(content, generatedLineNumber) { - console.log(content, generatedLineNumber) var matches = /@line (\d+) "([^"]*)"/.exec(content); if (matches === null) return; var originalLineNumber = parseInt(matches[1], 10); From 2f16717540cbeaa8e2e6b653bc31849111ccd9f2 Mon Sep 17 00:00:00 2001 From: Jez Ng Date: Fri, 7 Jun 2013 15:37:47 -0700 Subject: [PATCH 04/69] Add test for source maps. Tweak behavior of post_build; the `post2` hook now expects a function. --- emcc | 4 +- tests/runner.py | 235 +++++++++++++++++++++++----------------- tools/sourcemap2json.js | 15 +++ tools/sourcemapper.js | 10 +- 4 files changed, 157 insertions(+), 107 deletions(-) create mode 100644 tools/sourcemap2json.js diff --git a/emcc b/emcc index 7eb9effaf78be..8dc7652ae5e72 100755 --- a/emcc +++ b/emcc @@ -1585,9 +1585,9 @@ try: else: logging.debug('did not see memory initialization') - def generate_source_maps(filename, mapFileBaseName): + def generate_source_maps(filename, map_file_base_name): jsrun.run_js(shared.path_from_root('tools', 'sourcemapper.js'), - shared.NODE_JS, [filename, os.getcwd(), mapFileBaseName]) + shared.NODE_JS, [filename, os.getcwd(), map_file_base_name]) # If we were asked to also generate HTML, do that if final_suffix == 'html': diff --git a/tests/runner.py b/tests/runner.py index 610a39f690ff7..f90911d5f5022 100755 --- a/tests/runner.py +++ b/tests/runner.py @@ -170,16 +170,13 @@ def ll_to_js(self, filename, extra_emscripten_args, post_build): post1 = post_build post2 = None - def run_post(post): - if not post: return - exec post in locals() - shutil.copyfile(filename + '.o.js', filename + '.o.js.prepost.js') - process(filename + '.o.js') - if self.emcc_args is None: Building.emscripten(filename, append_ext=True, extra_args=extra_emscripten_args) - run_post(post1) - run_post(post2) + if post1: + exec post1 in locals() + shutil.copyfile(filename + '.o.js', filename + '.o.js.prepost.js') + process(filename + '.o.js') + if post2: post2(filename + '.o.js') else: transform_args = [] if post1: @@ -196,7 +193,7 @@ def run_post(post): transform.close() transform_args = ['--js-transform', "%s %s" % (PYTHON, transform_filename)] Building.emcc(filename + '.o.ll', Settings.serialize() + self.emcc_args + transform_args + Building.COMPILER_TEST_OPTS, filename + '.o.js') - run_post(post2) + if post2: post2(filename + '.o.js') # Build JavaScript code from source code def build(self, src, dirname, filename, output_processor=None, main_file=None, additional_files=[], libraries=[], includes=[], build_ll_hook=None, extra_emscripten_args=[], post_build=None): @@ -9215,97 +9212,92 @@ def process(filename): src.close() ''' - post3 = ''' -def process(filename): - script_src_2 = \'\'\' - var sme = new Module.Parent(42); - sme.mulVal(2); - Module.print('*') - Module.print(sme.getVal()); - - Module.print('c1'); - - var c1 = new Module.Child1(); - Module.print(c1.getVal()); - c1.mulVal(2); - Module.print(c1.getVal()); - Module.print(c1.getValSqr()); - Module.print(c1.getValSqr(3)); - Module.print(c1.getValTimes()); // default argument should be 1 - Module.print(c1.getValTimes(2)); - - Module.print('c1 v2'); - - c1 = new Module.Child1(8); // now with a parameter, we should handle the overloading automatically and properly and use constructor #2 - Module.print(c1.getVal()); - c1.mulVal(2); - Module.print(c1.getVal()); - Module.print(c1.getValSqr()); - Module.print(c1.getValSqr(3)); - - Module.print('c2') - - var c2 = new Module.Child2(); - Module.print(c2.getVal()); - c2.mulVal(2); - Module.print(c2.getVal()); - Module.print(c2.getValCube()); - var succeeded; - try { - succeeded = 0; - Module.print(c2.doSomethingSecret()); // should fail since private - succeeded = 1; - } catch(e) {} - Module.print(succeeded); - try { - succeeded = 0; - Module.print(c2.getValSqr()); // function from the other class - succeeded = 1; - } catch(e) {} - Module.print(succeeded); - try { - succeeded = 0; - c2.getValCube(); // sanity - succeeded = 1; - } catch(e) {} - Module.print(succeeded); - - Module.Child2.prototype.printStatic(); // static calls go through the prototype - - // virtual function - c2.virtualFunc(); - Module.Child2.prototype.runVirtualFunc(c2); - c2.virtualFunc2(); - -''' + (''' - // extend the class from JS - var c3 = new Module.Child2; - Module.customizeVTable(c3, [{ - original: Module.Child2.prototype.virtualFunc, - replacement: function() { - Module.print('*js virtualf replacement*'); - } - }, { - original: Module.Child2.prototype.virtualFunc2, - replacement: function() { - Module.print('*js virtualf2 replacement*'); - } - }]); - c3.virtualFunc(); - Module.Child2.prototype.runVirtualFunc(c3); - c3.virtualFunc2(); - - c2.virtualFunc(); // original should remain the same - Module.Child2.prototype.runVirtualFunc(c2); - c2.virtualFunc2(); -''') + ''' - - Module.print('*ok*'); - \'\'\' - src = open(filename, 'a') - src.write(script_src_2 + '\\n') - src.close() -''' + def post3(filename): + script_src_2 = ''' + var sme = new Module.Parent(42); + sme.mulVal(2); + Module.print('*') + Module.print(sme.getVal()); + + Module.print('c1'); + + var c1 = new Module.Child1(); + Module.print(c1.getVal()); + c1.mulVal(2); + Module.print(c1.getVal()); + Module.print(c1.getValSqr()); + Module.print(c1.getValSqr(3)); + Module.print(c1.getValTimes()); // default argument should be 1 + Module.print(c1.getValTimes(2)); + + Module.print('c1 v2'); + + c1 = new Module.Child1(8); // now with a parameter, we should handle the overloading automatically and properly and use constructor #2 + Module.print(c1.getVal()); + c1.mulVal(2); + Module.print(c1.getVal()); + Module.print(c1.getValSqr()); + Module.print(c1.getValSqr(3)); + + Module.print('c2') + + var c2 = new Module.Child2(); + Module.print(c2.getVal()); + c2.mulVal(2); + Module.print(c2.getVal()); + Module.print(c2.getValCube()); + var succeeded; + try { + succeeded = 0; + Module.print(c2.doSomethingSecret()); // should fail since private + succeeded = 1; + } catch(e) {} + Module.print(succeeded); + try { + succeeded = 0; + Module.print(c2.getValSqr()); // function from the other class + succeeded = 1; + } catch(e) {} + Module.print(succeeded); + try { + succeeded = 0; + c2.getValCube(); // sanity + succeeded = 1; + } catch(e) {} + Module.print(succeeded); + + Module.Child2.prototype.printStatic(); // static calls go through the prototype + + // virtual function + c2.virtualFunc(); + Module.Child2.prototype.runVirtualFunc(c2); + c2.virtualFunc2(); + + // extend the class from JS + var c3 = new Module.Child2; + Module.customizeVTable(c3, [{ + original: Module.Child2.prototype.virtualFunc, + replacement: function() { + Module.print('*js virtualf replacement*'); + } + }, { + original: Module.Child2.prototype.virtualFunc2, + replacement: function() { + Module.print('*js virtualf2 replacement*'); + } + }]); + c3.virtualFunc(); + Module.Child2.prototype.runVirtualFunc(c3); + c3.virtualFunc2(); + + c2.virtualFunc(); // original should remain the same + Module.Child2.prototype.runVirtualFunc(c2); + c2.virtualFunc2(); + Module.print('*ok*'); + ''' + src = open(filename, 'a') + src.write(script_src_2 + '\n') + src.close() Settings.RESERVED_FUNCTION_POINTERS = 20 @@ -9349,7 +9341,7 @@ def process(filename): *virtualf* *virtualf2*''') + ''' *ok* -''', post_build=[post2, post3]) +''', post_build=(post2, post3)) def test_scriptaclass_2(self): if self.emcc_args is None: return self.skip('requires emcc') @@ -9592,6 +9584,47 @@ def process(filename): # This test *should* fail assert 'Assertion failed' in str(e), str(e) + def test_source_map(self): + if '-g' not in Building.COMPILER_TEST_OPTS: Building.COMPILER_TEST_OPTS.append('-g') + if self.emcc_args is not None: + if '-O1' in self.emcc_args or '-O2' in self.emcc_args: return self.skip('optimizations remove LLVM debug info') + + src = ''' + #include + #include + + int foo() { + return 1; // line 6 + } + + int main() { + int i = foo(); // line 10 + return 0; // line 11 + } + ''' + + dirname = self.get_dir() + src_filename = os.path.join(dirname, 'src.cpp') + + def post(filename): + import json + map_filename = filename + '.map' + data = json.load(open(map_filename, 'r')) + self.assertIdentical(filename, data['file']) + self.assertIdentical(src_filename, data['sources'][0]) + self.assertIdentical(src, data['sourcesContent'][0]) + mappings = json.loads(jsrun.run_js( + path_from_root('tools', 'sourcemap2json.js'), + tools.shared.NODE_JS, [map_filename])) + seen_lines = set() + for m in mappings: + self.assertIdentical(src_filename, m['source']) + seen_lines.add(m['originalLine']) + # ensure that all the 'meaningful' lines in the original code get mapped + assert seen_lines.issuperset([6, 10, 11]) + + self.build(src, dirname, src_filename, post_build=(None,post)) + def test_linespecific(self): if Settings.ASM_JS: return self.skip('asm always has corrections on') diff --git a/tools/sourcemap2json.js b/tools/sourcemap2json.js new file mode 100644 index 0000000000000..5dd162b28462e --- /dev/null +++ b/tools/sourcemap2json.js @@ -0,0 +1,15 @@ +/* + * Quick utility script for the Python test script to call. Could be replaced if + * a good Python source map library is found. + */ +var SourceMapConsumer = require('source-map').SourceMapConsumer; +var fs = require('fs'); + +var consumer = new SourceMapConsumer(fs.readFileSync(process.argv[2], 'utf-8')); +var mappings = []; + +consumer.eachMapping(function(mapping) { + mappings.push(mapping); +}); + +console.log(JSON.stringify(mappings)); diff --git a/tools/sourcemapper.js b/tools/sourcemapper.js index 3d8dbe99c8611..fce9251f386ec 100755 --- a/tools/sourcemapper.js +++ b/tools/sourcemapper.js @@ -68,7 +68,7 @@ function generateMap(fileName, sourceRoot, mapFileBaseName) { var path = require('path'); var SourceMapGenerator = require('source-map').SourceMapGenerator; - var generator = new SourceMapGenerator({ file: fileName }); + var generator = new SourceMapGenerator({ file: mapFileBaseName }); var generatedSource = fs.readFileSync(fileName, 'utf-8'); var seenFiles = Object.create(null); @@ -80,11 +80,13 @@ function generateMap(fileName, sourceRoot, mapFileBaseName) { if (!(originalFileName in seenFiles)) { seenFiles[originalFileName] = true; + var rootedPath = originalFileName[0] === path.sep ? + originalFileName : path.join(sourceRoot, originalFileName); try { - generator.setSourceContent(originalFileName, - fs.readFileSync(sourceRoot + "/" + originalFileName)); + generator.setSourceContent(originalFileName, fs.readFileSync(rootedPath, 'utf-8')); } catch (e) { - console.warn("Unable to find original file for " + originalFileName); + console.warn("Unable to find original file for " + originalFileName + + " at " + rootedPath); } } From 2c0dcd9aa43b630b39deafc7f8ca1426301ebc5a Mon Sep 17 00:00:00 2001 From: Jez Ng Date: Sat, 8 Jun 2013 09:50:34 -0700 Subject: [PATCH 05/69] Ensure line numbers are the same in HTML. Chrome and FF seem to be able to handle the extra empty lines, but no harm making things more accurate. One thing less to worry about when debugging. --- src/shell.html | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/src/shell.html b/src/shell.html index f7eb9e1f018c3..00765271149d5 100644 --- a/src/shell.html +++ b/src/shell.html @@ -87,10 +87,6 @@ }; Module.setStatus('Downloading...'); - + From af52a9aacbe6b137b231a42e745bfb8002ffca8b Mon Sep 17 00:00:00 2001 From: Jez Ng Date: Sun, 9 Jun 2013 21:26:28 -0700 Subject: [PATCH 06/69] Fix source map line numbering for inline scripts. --- emcc | 13 +++++++++---- tools/sourcemapper.js | 11 +++++++---- 2 files changed, 16 insertions(+), 8 deletions(-) diff --git a/emcc b/emcc index 8dc7652ae5e72..5b6d00dc93f29 100755 --- a/emcc +++ b/emcc @@ -1585,9 +1585,9 @@ try: else: logging.debug('did not see memory initialization') - def generate_source_maps(filename, map_file_base_name): + def generate_source_map(filename, map_file_base_name, offset=0): jsrun.run_js(shared.path_from_root('tools', 'sourcemapper.js'), - shared.NODE_JS, [filename, os.getcwd(), map_file_base_name]) + shared.NODE_JS, [filename, os.getcwd(), map_file_base_name, str(offset)]) # If we were asked to also generate HTML, do that if final_suffix == 'html': @@ -1595,7 +1595,12 @@ try: shell = open(shell_path).read() html = open(target, 'w') if not Compression.on: - if keep_llvm_debug and keep_js_debug: generate_source_maps(final, target) + if keep_llvm_debug and keep_js_debug: + match = re.match('.*?]*>{{{ SCRIPT_CODE }}}', shell, + re.DOTALL) + if match is None: + raise RuntimeError('Could not find script insertion point') + generate_source_map(final, target, match.group().count('\n')) html.write(shell.replace('{{{ SCRIPT_CODE }}}', open(final).read())) else: # Compress the main code @@ -1666,7 +1671,7 @@ try: from tools.split import split_javascript_file split_javascript_file(final, unsuffixed(target), split_js_file) else: - if keep_llvm_debug and keep_js_debug: generate_source_maps(final, target) + if keep_llvm_debug and keep_js_debug: generate_source_map(final, target) # copy final JS to output shutil.move(final, target) diff --git a/tools/sourcemapper.js b/tools/sourcemapper.js index fce9251f386ec..c7021a0fb941e 100755 --- a/tools/sourcemapper.js +++ b/tools/sourcemapper.js @@ -63,7 +63,7 @@ function extractComments(source, commentHandler) { } } -function generateMap(fileName, sourceRoot, mapFileBaseName) { +function generateMap(fileName, sourceRoot, mapFileBaseName, generatedLineOffset) { var fs = require('fs'); var path = require('path'); var SourceMapGenerator = require('source-map').SourceMapGenerator; @@ -91,7 +91,7 @@ function generateMap(fileName, sourceRoot, mapFileBaseName) { } generator.addMapping({ - generated: { line: generatedLineNumber, column: 0 }, + generated: { line: generatedLineNumber + generatedLineOffset, column: 0 }, original: { line: originalLineNumber, column: 0 }, source: originalFileName }); @@ -108,11 +108,14 @@ function generateMap(fileName, sourceRoot, mapFileBaseName) { if (require.main === module) { if (process.argv.length < 3) { console.log('Usage: ./sourcemapper.js ' + - ''); + '' + + ''); process.exit(1); } else { var sourceRoot = process.argv.length > 3 ? process.argv[3] : "."; var mapFileBaseName = process.argv.length > 4 ? process.argv[4] : process.argv[2]; - generateMap(process.argv[2], sourceRoot, mapFileBaseName); + var generatedLineOffset = process.argv.length > 5 ? + parseInt(process.argv[5], 10) : 0; + generateMap(process.argv[2], sourceRoot, mapFileBaseName, generatedLineOffset); } } From be5d45fe2932f9452c623b63720cb7d9857a1baa Mon Sep 17 00:00:00 2001 From: Jez Ng Date: Mon, 10 Jun 2013 14:52:46 -0700 Subject: [PATCH 07/69] Add test for HTML source map generation. --- tests/runner.py | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) diff --git a/tests/runner.py b/tests/runner.py index f90911d5f5022..b3cfd1ae5f882 100755 --- a/tests/runner.py +++ b/tests/runner.py @@ -11731,6 +11731,37 @@ def test_html(self): self.btest('hello_world_sdl.cpp', reference='htmltest.png', message='You should see "hello, world!" and a colored cube.') + def test_html_source_map(self): + cpp_file = os.path.join(self.get_dir(), 'src.cpp') + html_file = os.path.join(self.get_dir(), 'src.html') + # browsers will try to 'guess' the corresponding original line if a + # generated line is unmapped, so if we want to make sure that our + # numbering is correct, we need to provide a couple of 'possible wrong + # answers'. thus, we add some printf calls so that the cpp file gets + # multiple mapped lines. in other words, if the program consists of a + # single 'throw' statement, browsers may just map any thrown exception to + # that line, because it will be the only mapped line. + with open(cpp_file, 'w') as f: + f.write(r''' + #include + + int main() { + printf("Starting test\n"); + try { + throw 42; // line 8 + } catch (int e) { } + printf("done\n"); + return 0; + } + ''') + Popen([PYTHON, EMCC, cpp_file, '-o', html_file, '-g']).communicate() + webbrowser.open_new('file://' + html_file) + print ''' +Set the debugger to pause on exceptions +You should see an exception thrown at src.cpp:7. +Press any key to continue.''' + raw_input() + def build_native_lzma(self): lzma_native = path_from_root('third_party', 'lzma.js', 'lzma-native') if os.path.isfile(lzma_native) and os.access(lzma_native, os.X_OK): return From 6d6490e61ef9a63cbf314faa19e152796a21f3d3 Mon Sep 17 00:00:00 2001 From: manny/MADE Date: Wed, 12 Jun 2013 13:27:22 +0200 Subject: [PATCH 08/69] IMPROVED: ADDED resizeListener that invokes the GLUT.reshapeFunc if specified --- src/library_glut.js | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/src/library_glut.js b/src/library_glut.js index 38cfe55bc00fa..ac045d6b8e6a1 100644 --- a/src/library_glut.js +++ b/src/library_glut.js @@ -262,6 +262,7 @@ var LibraryGLUT = { glutGetModifiers: function() { return GLUT.modifiers; }, + glutInit__deps: ['$Browser'], glutInit: function(argcp, argv) { // Ignore arguments GLUT.initTime = Date.now(); @@ -271,6 +272,13 @@ var LibraryGLUT = { window.addEventListener("mousemove", GLUT.onMousemove, true); window.addEventListener("mousedown", GLUT.onMouseButtonDown, true); window.addEventListener("mouseup", GLUT.onMouseButtonUp, true); + + Browser.resizeListeners.push(function(width, height) { + + if (GLUT.reshapeFunc) { + Runtime.dynCall('vii', GLUT.reshapeFunc, [width, height]); + } + }); __ATEXIT__.push({ func: function() { window.removeEventListener("keydown", GLUT.onKeydown, true); @@ -355,7 +363,7 @@ var LibraryGLUT = { GLUT.specialUpFunc = func; }, - glutReshapeFunc: function(func) { + glutReshapeFunc: function(func) { GLUT.reshapeFunc = func; }, From 824d5ce83528914f54c1e43563e98c4e1b1e371c Mon Sep 17 00:00:00 2001 From: manny/MADE Date: Wed, 12 Jun 2013 13:27:35 +0200 Subject: [PATCH 09/69] BUGFIX: several SDL related bugfixes --- src/library_browser.js | 36 +++++++++++++++++++++++++++--------- 1 file changed, 27 insertions(+), 9 deletions(-) diff --git a/src/library_browser.js b/src/library_browser.js index 9800fedf355a9..7e99054bb4442 100644 --- a/src/library_browser.js +++ b/src/library_browser.js @@ -425,8 +425,18 @@ mergeInto(LibraryManager.library, { Browser.mouseMovementX = Browser.getMovementX(event); Browser.mouseMovementY = Browser.getMovementY(event); } - Browser.mouseX = SDL.mouseX + Browser.mouseMovementX; - Browser.mouseY = SDL.mouseY + Browser.mouseMovementY; + + // MADE: FIX: check for SDL + if (typeof SDL != "undefined") + { + Browser.mouseX = SDL.mouseX + Browser.mouseMovementX; + Browser.mouseY = SDL.mouseY + Browser.mouseMovementY; + } + else + { + Browser.mouseX = Browser.mouseMovementX; + Browser.mouseY = Browser.mouseMovementY; + } } else { // Otherwise, calculate the movement based on the changes // in the coordinates. @@ -502,10 +512,14 @@ mergeInto(LibraryManager.library, { this.windowedWidth = canvas.width; this.windowedHeight = canvas.height; canvas.width = screen.width; - canvas.height = screen.height; - var flags = {{{ makeGetValue('SDL.screen+Runtime.QUANTUM_SIZE*0', '0', 'i32', 0, 1) }}}; - flags = flags | 0x00800000; // set SDL_FULLSCREEN flag - {{{ makeSetValue('SDL.screen+Runtime.QUANTUM_SIZE*0', '0', 'flags', 'i32') }}} + canvas.height = screen.height; + // MADE: FIX: check if SDL is available + if (typeof SDL != "undefined") + { + var flags = {{{ makeGetValue('SDL.screen+Runtime.QUANTUM_SIZE*0', '0', 'i32', 0, 1) }}}; + flags = flags | 0x00800000; // set SDL_FULLSCREEN flag + {{{ makeSetValue('SDL.screen+Runtime.QUANTUM_SIZE*0', '0', 'flags', 'i32') }}} + } Browser.updateResizeListeners(); }, @@ -513,9 +527,13 @@ mergeInto(LibraryManager.library, { var canvas = Module['canvas']; canvas.width = this.windowedWidth; canvas.height = this.windowedHeight; - var flags = {{{ makeGetValue('SDL.screen+Runtime.QUANTUM_SIZE*0', '0', 'i32', 0, 1) }}}; - flags = flags & ~0x00800000; // clear SDL_FULLSCREEN flag - {{{ makeSetValue('SDL.screen+Runtime.QUANTUM_SIZE*0', '0', 'flags', 'i32') }}} + // MADE: FIX: check if SDL is available + if (typeof SDL != "undefined") + { + var flags = {{{ makeGetValue('SDL.screen+Runtime.QUANTUM_SIZE*0', '0', 'i32', 0, 1) }}}; + flags = flags & ~0x00800000; // clear SDL_FULLSCREEN flag + {{{ makeSetValue('SDL.screen+Runtime.QUANTUM_SIZE*0', '0', 'flags', 'i32') }}} + } Browser.updateResizeListeners(); } From 2092ea86815cb84bb25ffdb60651a4d9b11ff317 Mon Sep 17 00:00:00 2001 From: manny/MADE Date: Wed, 12 Jun 2013 13:36:46 +0200 Subject: [PATCH 10/69] ADDED: GLUT_SCREEN_WIDTH + GLUT_SCREEN_HEIGHT in glutGet --- src/library_glut.js | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/library_glut.js b/src/library_glut.js index ac045d6b8e6a1..8f268fb996153 100644 --- a/src/library_glut.js +++ b/src/library_glut.js @@ -309,6 +309,10 @@ var LibraryGLUT = { return Module['canvas'].width; case 103: /* GLUT_WINDOW_HEIGHT */ return Module['canvas'].height; + case 200: /* GLUT_SCREEN_WIDTH */ + return Module['canvas'].width; + case 201: /* GLUT_SCREEN_HEIGHT */ + return Module['canvas'].height; case 500: /* GLUT_INIT_WINDOW_X */ return 0; /* TODO */ case 501: /* GLUT_INIT_WINDOW_Y */ From d8e1f50bd929f8bd08c82b2dfd116fa1c3fb538e Mon Sep 17 00:00:00 2001 From: manny/MADE Date: Wed, 19 Jun 2013 13:14:08 +0200 Subject: [PATCH 11/69] CHANGED: removed "MADE"-tag from comments --- src/library_browser.js | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/library_browser.js b/src/library_browser.js index 7e99054bb4442..a5cec33788a93 100644 --- a/src/library_browser.js +++ b/src/library_browser.js @@ -426,7 +426,7 @@ mergeInto(LibraryManager.library, { Browser.mouseMovementY = Browser.getMovementY(event); } - // MADE: FIX: check for SDL + // check if SDL is available if (typeof SDL != "undefined") { Browser.mouseX = SDL.mouseX + Browser.mouseMovementX; @@ -513,7 +513,7 @@ mergeInto(LibraryManager.library, { this.windowedHeight = canvas.height; canvas.width = screen.width; canvas.height = screen.height; - // MADE: FIX: check if SDL is available + // check if SDL is available if (typeof SDL != "undefined") { var flags = {{{ makeGetValue('SDL.screen+Runtime.QUANTUM_SIZE*0', '0', 'i32', 0, 1) }}}; @@ -527,7 +527,7 @@ mergeInto(LibraryManager.library, { var canvas = Module['canvas']; canvas.width = this.windowedWidth; canvas.height = this.windowedHeight; - // MADE: FIX: check if SDL is available + // check if SDL is available if (typeof SDL != "undefined") { var flags = {{{ makeGetValue('SDL.screen+Runtime.QUANTUM_SIZE*0', '0', 'i32', 0, 1) }}}; From 0aceb30743c746a5b3b79b323cd2c3fcd9c73ce1 Mon Sep 17 00:00:00 2001 From: manny/MADE Date: Wed, 19 Jun 2013 13:15:41 +0200 Subject: [PATCH 12/69] IMPROVED: removed empty line and white-space at EOL --- src/library_glut.js | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/library_glut.js b/src/library_glut.js index 8f268fb996153..6fc935743ee96 100644 --- a/src/library_glut.js +++ b/src/library_glut.js @@ -274,7 +274,6 @@ var LibraryGLUT = { window.addEventListener("mouseup", GLUT.onMouseButtonUp, true); Browser.resizeListeners.push(function(width, height) { - if (GLUT.reshapeFunc) { Runtime.dynCall('vii', GLUT.reshapeFunc, [width, height]); } @@ -367,7 +366,7 @@ var LibraryGLUT = { GLUT.specialUpFunc = func; }, - glutReshapeFunc: function(func) { + glutReshapeFunc: function(func) { GLUT.reshapeFunc = func; }, From 7656f948388b5a3421996196ea36c7bb052bb884 Mon Sep 17 00:00:00 2001 From: Jez Ng Date: Wed, 19 Jun 2013 01:56:47 -0700 Subject: [PATCH 13/69] Lay the groundwork for optimized source maps. --- emcc | 7 ++++--- tools/js-optimizer.js | 12 +++++++++++- tools/js_optimizer.py | 20 +++++++++++++------- tools/shared.py | 4 ++-- 4 files changed, 30 insertions(+), 13 deletions(-) diff --git a/emcc b/emcc index 5b6d00dc93f29..8f9d195c65cda 100755 --- a/emcc +++ b/emcc @@ -869,7 +869,6 @@ try: if llvm_opts is None: llvm_opts = LLVM_OPT_LEVEL[opt_level] if llvm_lto is None: llvm_lto = opt_level >= 3 if opt_level <= 0: keep_llvm_debug = keep_js_debug = True # always keep debug in -O0 - if opt_level > 0: keep_llvm_debug = False # JS optimizer wipes out llvm debug info from being visible if closure is None and opt_level == 3: closure = True if DEBUG: start_time = time.time() # done after parsing arguments, which might affect debug state @@ -1496,7 +1495,8 @@ try: if shared.Settings.ASM_JS: js_optimizer_queue = ['asm'] + js_optimizer_queue logging.debug('applying js optimization passes: %s', js_optimizer_queue) - final = shared.Building.js_optimizer(final, js_optimizer_queue, jcache) + final = shared.Building.js_optimizer(final, js_optimizer_queue, jcache, + keep_llvm_debug and keep_js_debug) if DEBUG: save_intermediate('js_opts') else: for name in js_optimizer_queue: @@ -1504,7 +1504,8 @@ try: if shared.Settings.ASM_JS: passes = ['asm'] + passes logging.debug('applying js optimization pass: %s', passes) - final = shared.Building.js_optimizer(final, passes, jcache) + final = shared.Building.js_optimizer(final, passes, jcache, + keep_llvm_debug and keep_js_debug) save_intermediate(name) js_optimizer_queue = [] diff --git a/tools/js-optimizer.js b/tools/js-optimizer.js index 07317e0a22d69..21ce54a89079c 100644 --- a/tools/js-optimizer.js +++ b/tools/js-optimizer.js @@ -11,6 +11,7 @@ // *** Environment setup code *** var arguments_ = []; +var debug = false; var ENVIRONMENT_IS_NODE = typeof process === 'object'; var ENVIRONMENT_IS_WEB = typeof window === 'object'; @@ -146,7 +147,7 @@ var generatedFunctions = false; // whether we have received only generated funct var minifierInfo = null; function srcToAst(src) { - return uglify.parser.parse(src); + return uglify.parser.parse(src, false, debug); } function astToSrc(ast, compress) { @@ -2750,6 +2751,14 @@ var passes = { var suffix = ''; +arguments_ = arguments_.filter(function (arg) { + if (!/^--/.test(arg)) return true; + + if (arg === '--debug') debug = true; + else throw new Error('Unrecognized flag: ' + arg); +}); + + var src = read(arguments_[0]); var ast = srcToAst(src); //printErr(JSON.stringify(ast)); throw 1; @@ -2758,6 +2767,7 @@ var minifierInfoStart = src.indexOf('// MINIFY_INFO:') if (minifierInfoStart > 0) minifierInfo = JSON.parse(src.substr(minifierInfoStart + 15)); //printErr(JSON.stringify(minifierInfo)); + arguments_.slice(1).forEach(function(arg) { passes[arg](ast); }); diff --git a/tools/js_optimizer.py b/tools/js_optimizer.py index 0452a72595e26..e99c02bedf677 100644 --- a/tools/js_optimizer.py +++ b/tools/js_optimizer.py @@ -57,7 +57,7 @@ def __init__(self, js, js_engine): if curr not in INVALID_3: self.names.append(curr) #print >> sys.stderr, self.names - def minify_shell(self, shell, compress): + def minify_shell(self, shell, compress, debug=False): #print >> sys.stderr, "MINIFY SHELL 1111111111", shell, "\n222222222222222" # Run through js-optimizer.js to find and minify the global symbols # We send it the globals, which it parses at the proper time. JS decides how @@ -77,7 +77,11 @@ def minify_shell(self, shell, compress): f.write('// MINIFY_INFO:' + self.serialize()) f.close() - output = subprocess.Popen(self.js_engine + [JS_OPTIMIZER, temp_file, 'minifyGlobals', 'noPrintMetadata'] + (['compress'] if compress else []), stdout=subprocess.PIPE).communicate()[0] + output = subprocess.Popen(self.js_engine + + [JS_OPTIMIZER, temp_file, 'minifyGlobals', 'noPrintMetadata'] + + (['compress'] if compress else []) + + (['--debug'] if debug else []), + stdout=subprocess.PIPE).communicate()[0] assert len(output) > 0 and not output.startswith('Assertion failed'), 'Error in js optimizer: ' + output #print >> sys.stderr, "minified SHELL 3333333333333333", output, "\n44444444444444444444" code, metadata = output.split('// MINIFY_INFO:') @@ -103,7 +107,7 @@ def run_on_chunk(command): if DEBUG and not shared.WINDOWS: print >> sys.stderr, '.' # Skip debug progress indicator on Windows, since it doesn't buffer well with multiple threads printing to console. return filename -def run_on_js(filename, passes, js_engine, jcache): +def run_on_js(filename, passes, js_engine, jcache, debug=False): if isinstance(jcache, bool) and jcache: jcache = shared.JCache if jcache: shared.JCache.ensure() @@ -171,7 +175,7 @@ def process(line): js = js[start_funcs + len(start_funcs_marker):end_funcs] minifier = Minifier(js, js_engine) - asm_shell_pre, asm_shell_post = minifier.minify_shell(asm_shell, 'compress' in passes).split('EMSCRIPTEN_FUNCS();'); + asm_shell_pre, asm_shell_post = minifier.minify_shell(asm_shell, 'compress' in passes, debug).split('EMSCRIPTEN_FUNCS();'); asm_shell_post = asm_shell_post.replace('});', '})'); pre += asm_shell_pre + '\n' + start_funcs_marker post = end_funcs_marker + asm_shell_post + post @@ -247,7 +251,9 @@ def write_chunk(chunk, i): if len(filenames) > 0: # XXX Use '--nocrankshaft' to disable crankshaft to work around v8 bug 1895, needed for older v8/node (node 0.6.8+ should be ok) - commands = map(lambda filename: js_engine + [JS_OPTIMIZER, filename, 'noPrintMetadata'] + passes, filenames) + commands = map(lambda filename: js_engine + + [JS_OPTIMIZER, filename, 'noPrintMetadata'] + + (['--debug'] if debug else []) + passes, filenames) #print [' '.join(command) for command in commands] cores = min(cores, filenames) @@ -315,6 +321,6 @@ def write_chunk(chunk, i): return filename -def run(filename, passes, js_engine, jcache): - return temp_files.run_and_clean(lambda: run_on_js(filename, passes, js_engine, jcache)) +def run(filename, passes, js_engine, jcache, debug=False): + return temp_files.run_and_clean(lambda: run_on_js(filename, passes, js_engine, jcache, debug)) diff --git a/tools/shared.py b/tools/shared.py index c16c91154af85..89ceeccb28386 100644 --- a/tools/shared.py +++ b/tools/shared.py @@ -1213,8 +1213,8 @@ def pick_llvm_opts(optimization_level): return opts @staticmethod - def js_optimizer(filename, passes, jcache): - return js_optimizer.run(filename, passes, listify(NODE_JS), jcache) + def js_optimizer(filename, passes, jcache, debug): + return js_optimizer.run(filename, passes, listify(NODE_JS), jcache, debug) @staticmethod def closure_compiler(filename, pretty=True): From 0c3cb9305358d34d0f7cdcee6cdb3d60a7b4b507 Mon Sep 17 00:00:00 2001 From: Jez Ng Date: Wed, 19 Jun 2013 02:14:37 -0700 Subject: [PATCH 14/69] Delete uglify code that was only needed for compression. This makes it easier to reason about the remainder... --- .../node_modules/uglify-js/lib/process.js | 2560 +++++------------ 1 file changed, 742 insertions(+), 1818 deletions(-) diff --git a/tools/eliminator/node_modules/uglify-js/lib/process.js b/tools/eliminator/node_modules/uglify-js/lib/process.js index c3abb6f8742fc..70a4b0a43e291 100644 --- a/tools/eliminator/node_modules/uglify-js/lib/process.js +++ b/tools/eliminator/node_modules/uglify-js/lib/process.js @@ -1,6 +1,6 @@ /*********************************************************************** - A JavaScript tokenizer / parser / beautifier / compressor. + A JavaScript tokenizer / parser / beautifier. This version is suitable for Node.js. With minimal changes (the exports stuff) it should work on any JS platform. @@ -10,12 +10,6 @@ Exported functions: - - ast_mangle(ast, options) -- mangles the variable/function names - in the AST. Returns an AST. - - - ast_squeeze(ast) -- employs various optimizations to make the - final generated code even smaller. Returns an AST. - - gen_code(ast, options) -- generates JS code from the AST. Pass true (or an object, see the code for some options) as second argument to get "pretty" (indented) code. @@ -67,1835 +61,773 @@ var jsp = require("./parse-js"), /* -----[ helper for AST traversal ]----- */ function ast_walker() { - function _vardefs(defs) { - return [ this[0], MAP(defs, function(def){ - var a = [ def[0] ]; - if (def.length > 1) - a[1] = walk(def[1]); - return a; - }) ]; - }; - function _block(statements) { - var out = [ this[0] ]; - if (statements != null) - out.push(MAP(statements, walk)); - return out; - }; - var walkers = { - "string": function(str) { - return [ this[0], str ]; - }, - "num": function(num) { - return [ this[0], num ]; - }, - "name": function(name) { - return [ this[0], name ]; - }, - "toplevel": function(statements) { - return [ this[0], MAP(statements, walk) ]; - }, - "block": _block, - "splice": _block, - "var": _vardefs, - "const": _vardefs, - "try": function(t, c, f) { - return [ - this[0], - MAP(t, walk), - c != null ? [ c[0], MAP(c[1], walk) ] : null, - f != null ? MAP(f, walk) : null - ]; - }, - "throw": function(expr) { - return [ this[0], walk(expr) ]; - }, - "new": function(ctor, args) { - return [ this[0], walk(ctor), MAP(args, walk) ]; - }, - "switch": function(expr, body) { - return [ this[0], walk(expr), MAP(body, function(branch){ - return [ branch[0] ? walk(branch[0]) : null, - MAP(branch[1], walk) ]; - }) ]; - }, - "break": function(label) { - return [ this[0], label ]; - }, - "continue": function(label) { - return [ this[0], label ]; - }, - "conditional": function(cond, t, e) { - return [ this[0], walk(cond), walk(t), walk(e) ]; - }, - "assign": function(op, lvalue, rvalue) { - return [ this[0], op, walk(lvalue), walk(rvalue) ]; - }, - "dot": function(expr) { - return [ this[0], walk(expr) ].concat(slice(arguments, 1)); - }, - "call": function(expr, args) { - return [ this[0], walk(expr), MAP(args, walk) ]; - }, - "function": function(name, args, body) { - return [ this[0], name, args.slice(), MAP(body, walk) ]; - }, - "defun": function(name, args, body) { - return [ this[0], name, args.slice(), MAP(body, walk) ]; - }, - "if": function(conditional, t, e) { - return [ this[0], walk(conditional), walk(t), walk(e) ]; - }, - "for": function(init, cond, step, block) { - return [ this[0], walk(init), walk(cond), walk(step), walk(block) ]; - }, - "for-in": function(vvar, key, hash, block) { - return [ this[0], walk(vvar), walk(key), walk(hash), walk(block) ]; - }, - "while": function(cond, block) { - return [ this[0], walk(cond), walk(block) ]; - }, - "do": function(cond, block) { - return [ this[0], walk(cond), walk(block) ]; - }, - "return": function(expr) { - return [ this[0], walk(expr) ]; - }, - "binary": function(op, left, right) { - return [ this[0], op, walk(left), walk(right) ]; - }, - "unary-prefix": function(op, expr) { - return [ this[0], op, walk(expr) ]; - }, - "unary-postfix": function(op, expr) { - return [ this[0], op, walk(expr) ]; - }, - "sub": function(expr, subscript) { - return [ this[0], walk(expr), walk(subscript) ]; - }, - "object": function(props) { - return [ this[0], MAP(props, function(p){ - return p.length == 2 - ? [ p[0], walk(p[1]) ] - : [ p[0], walk(p[1]), p[2] ]; // get/set-ter - }) ]; - }, - "regexp": function(rx, mods) { - return [ this[0], rx, mods ]; - }, - "array": function(elements) { - return [ this[0], MAP(elements, walk) ]; - }, - "stat": function(stat) { - return [ this[0], walk(stat) ]; - }, - "seq": function() { - return [ this[0] ].concat(MAP(slice(arguments), walk)); - }, - "label": function(name, block) { - return [ this[0], name, walk(block) ]; - }, - "with": function(expr, block) { - return [ this[0], walk(expr), walk(block) ]; - }, - "atom": function(name) { - return [ this[0], name ]; - } - }; - - var user = {}; - var stack = []; - function walk(ast) { - if (ast == null) - return null; - try { - stack.push(ast); - var type = ast[0]; - var gen = user[type]; - if (gen) { - var ret = gen.apply(ast, ast.slice(1)); - if (ret != null) - return ret; - } - gen = walkers[type]; - return gen.apply(ast, ast.slice(1)); - } finally { - stack.pop(); - } - }; - - function with_walkers(walkers, cont){ - var save = {}, i; - for (i in walkers) if (HOP(walkers, i)) { - save[i] = user[i]; - user[i] = walkers[i]; - } - var ret = cont(); - for (i in save) if (HOP(save, i)) { - if (!save[i]) delete user[i]; - else user[i] = save[i]; - } - return ret; - }; - - return { - walk: walk, - with_walkers: with_walkers, - parent: function() { - return stack[stack.length - 2]; // last one is current node - }, - stack: function() { - return stack; - } - }; + function _vardefs(defs) { + return [ this[0], MAP(defs, function(def){ + var a = [ def[0] ]; + if (def.length > 1) + a[1] = walk(def[1]); + return a; + }) ]; + }; + function _block(statements) { + var out = [ this[0] ]; + if (statements != null) + out.push(MAP(statements, walk)); + return out; + }; + var walkers = { + "string": function(str) { + return [ this[0], str ]; + }, + "num": function(num) { + return [ this[0], num ]; + }, + "name": function(name) { + return [ this[0], name ]; + }, + "toplevel": function(statements) { + return [ this[0], MAP(statements, walk) ]; + }, + "block": _block, + "splice": _block, + "var": _vardefs, + "const": _vardefs, + "try": function(t, c, f) { + return [ + this[0], + MAP(t, walk), + c != null ? [ c[0], MAP(c[1], walk) ] : null, + f != null ? MAP(f, walk) : null + ]; + }, + "throw": function(expr) { + return [ this[0], walk(expr) ]; + }, + "new": function(ctor, args) { + return [ this[0], walk(ctor), MAP(args, walk) ]; + }, + "switch": function(expr, body) { + return [ this[0], walk(expr), MAP(body, function(branch){ + return [ branch[0] ? walk(branch[0]) : null, + MAP(branch[1], walk) ]; + }) ]; + }, + "break": function(label) { + return [ this[0], label ]; + }, + "continue": function(label) { + return [ this[0], label ]; + }, + "conditional": function(cond, t, e) { + return [ this[0], walk(cond), walk(t), walk(e) ]; + }, + "assign": function(op, lvalue, rvalue) { + return [ this[0], op, walk(lvalue), walk(rvalue) ]; + }, + "dot": function(expr) { + return [ this[0], walk(expr) ].concat(slice(arguments, 1)); + }, + "call": function(expr, args) { + return [ this[0], walk(expr), MAP(args, walk) ]; + }, + "function": function(name, args, body) { + return [ this[0], name, args.slice(), MAP(body, walk) ]; + }, + "defun": function(name, args, body) { + return [ this[0], name, args.slice(), MAP(body, walk) ]; + }, + "if": function(conditional, t, e) { + return [ this[0], walk(conditional), walk(t), walk(e) ]; + }, + "for": function(init, cond, step, block) { + return [ this[0], walk(init), walk(cond), walk(step), walk(block) ]; + }, + "for-in": function(vvar, key, hash, block) { + return [ this[0], walk(vvar), walk(key), walk(hash), walk(block) ]; + }, + "while": function(cond, block) { + return [ this[0], walk(cond), walk(block) ]; + }, + "do": function(cond, block) { + return [ this[0], walk(cond), walk(block) ]; + }, + "return": function(expr) { + return [ this[0], walk(expr) ]; + }, + "binary": function(op, left, right) { + return [ this[0], op, walk(left), walk(right) ]; + }, + "unary-prefix": function(op, expr) { + return [ this[0], op, walk(expr) ]; + }, + "unary-postfix": function(op, expr) { + return [ this[0], op, walk(expr) ]; + }, + "sub": function(expr, subscript) { + return [ this[0], walk(expr), walk(subscript) ]; + }, + "object": function(props) { + return [ this[0], MAP(props, function(p){ + return p.length == 2 + ? [ p[0], walk(p[1]) ] + : [ p[0], walk(p[1]), p[2] ]; // get/set-ter + }) ]; + }, + "regexp": function(rx, mods) { + return [ this[0], rx, mods ]; + }, + "array": function(elements) { + return [ this[0], MAP(elements, walk) ]; + }, + "stat": function(stat) { + return [ this[0], walk(stat) ]; + }, + "seq": function() { + return [ this[0] ].concat(MAP(slice(arguments), walk)); + }, + "label": function(name, block) { + return [ this[0], name, walk(block) ]; + }, + "with": function(expr, block) { + return [ this[0], walk(expr), walk(block) ]; + }, + "atom": function(name) { + return [ this[0], name ]; + } + }; + + var user = {}; + var stack = []; + function walk(ast) { + if (ast == null) + return null; + try { + stack.push(ast); + var type = ast[0]; + var gen = user[type]; + if (gen) { + var ret = gen.apply(ast, ast.slice(1)); + if (ret != null) + return ret; + } + gen = walkers[type]; + return gen.apply(ast, ast.slice(1)); + } finally { + stack.pop(); + } + }; + + function with_walkers(walkers, cont){ + var save = {}, i; + for (i in walkers) if (HOP(walkers, i)) { + save[i] = user[i]; + user[i] = walkers[i]; + } + var ret = cont(); + for (i in save) if (HOP(save, i)) { + if (!save[i]) delete user[i]; + else user[i] = save[i]; + } + return ret; + }; + + return { + walk: walk, + with_walkers: with_walkers, + parent: function() { + return stack[stack.length - 2]; // last one is current node + }, + stack: function() { + return stack; + } + }; }; -/* -----[ Scope and mangling ]----- */ - -function Scope(parent) { - this.names = {}; // names defined in this scope - this.mangled = {}; // mangled names (orig.name => mangled) - this.rev_mangled = {}; // reverse lookup (mangled => orig.name) - this.cname = -1; // current mangled name - this.refs = {}; // names referenced from this scope - this.uses_with = false; // will become TRUE if with() is detected in this or any subscopes - this.uses_eval = false; // will become TRUE if eval() is detected in this or any subscopes - this.parent = parent; // parent scope - this.children = []; // sub-scopes - if (parent) { - this.level = parent.level + 1; - parent.children.push(this); - } else { - this.level = 0; - } -}; - -var base54 = (function(){ - var DIGITS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_"; - return function(num) { - var ret = ""; - do { - ret = DIGITS.charAt(num % 54) + ret; - num = Math.floor(num / 54); - } while (num > 0); - return ret; - }; -})(); - -Scope.prototype = { - has: function(name) { - for (var s = this; s; s = s.parent) - if (HOP(s.names, name)) - return s; - }, - has_mangled: function(mname) { - for (var s = this; s; s = s.parent) - if (HOP(s.rev_mangled, mname)) - return s; - }, - toJSON: function() { - return { - names: this.names, - uses_eval: this.uses_eval, - uses_with: this.uses_with - }; - }, - - next_mangled: function() { - // we must be careful that the new mangled name: - // - // 1. doesn't shadow a mangled name from a parent - // scope, unless we don't reference the original - // name from this scope OR from any sub-scopes! - // This will get slow. - // - // 2. doesn't shadow an original name from a parent - // scope, in the event that the name is not mangled - // in the parent scope and we reference that name - // here OR IN ANY SUBSCOPES! - // - // 3. doesn't shadow a name that is referenced but not - // defined (possibly global defined elsewhere). - for (;;) { - var m = base54(++this.cname), prior; - - // case 1. - prior = this.has_mangled(m); - if (prior && this.refs[prior.rev_mangled[m]] === prior) - continue; - - // case 2. - prior = this.has(m); - if (prior && prior !== this && this.refs[m] === prior && !prior.has_mangled(m)) - continue; - - // case 3. - if (HOP(this.refs, m) && this.refs[m] == null) - continue; - - // I got "do" once. :-/ - if (!is_identifier(m)) - continue; - - return m; - } - }, - set_mangle: function(name, m) { - this.rev_mangled[m] = name; - return this.mangled[name] = m; - }, - get_mangled: function(name, newMangle) { - if (this.uses_eval || this.uses_with) return name; // no mangle if eval or with is in use - var s = this.has(name); - if (!s) return name; // not in visible scope, no mangle - if (HOP(s.mangled, name)) return s.mangled[name]; // already mangled in this scope - if (!newMangle) return name; // not found and no mangling requested - return s.set_mangle(name, s.next_mangled()); - }, - references: function(name) { - return name && !this.parent || this.uses_with || this.uses_eval || this.refs[name]; - }, - define: function(name, type) { - if (name != null) { - if (type == "var" || !HOP(this.names, name)) - this.names[name] = type || "var"; - return name; - } - } -}; - -function ast_add_scope(ast) { - - var current_scope = null; - var w = ast_walker(), walk = w.walk; - var having_eval = []; - - function with_new_scope(cont) { - current_scope = new Scope(current_scope); - var ret = current_scope.body = cont(); - ret.scope = current_scope; - current_scope = current_scope.parent; - return ret; - }; - - function define(name, type) { - return current_scope.define(name, type); - }; - - function reference(name) { - current_scope.refs[name] = true; - }; - - function _lambda(name, args, body) { - var is_defun = this[0] == "defun"; - return [ this[0], is_defun ? define(name, "defun") : name, args, with_new_scope(function(){ - if (!is_defun) define(name, "lambda"); - MAP(args, function(name){ define(name, "arg") }); - return MAP(body, walk); - })]; - }; - - function _vardefs(type) { - return function(defs) { - MAP(defs, function(d){ - define(d[0], type); - if (d[1]) reference(d[0]); - }); - }; - }; - - return with_new_scope(function(){ - // process AST - var ret = w.with_walkers({ - "function": _lambda, - "defun": _lambda, - "label": function(name, stat) { define(name, "label") }, - "break": function(label) { if (label) reference(label) }, - "continue": function(label) { if (label) reference(label) }, - "with": function(expr, block) { - for (var s = current_scope; s; s = s.parent) - s.uses_with = true; - }, - "var": _vardefs("var"), - "const": _vardefs("const"), - "try": function(t, c, f) { - if (c != null) return [ - this[0], - MAP(t, walk), - [ define(c[0], "catch"), MAP(c[1], walk) ], - f != null ? MAP(f, walk) : null - ]; - }, - "name": function(name) { - if (name == "eval") - having_eval.push(current_scope); - reference(name); - } - }, function(){ - return walk(ast); - }); - - // the reason why we need an additional pass here is - // that names can be used prior to their definition. - - // scopes where eval was detected and their parents - // are marked with uses_eval, unless they define the - // "eval" name. - MAP(having_eval, function(scope){ - if (!scope.has("eval")) while (scope) { - scope.uses_eval = true; - scope = scope.parent; - } - }); - - // for referenced names it might be useful to know - // their origin scope. current_scope here is the - // toplevel one. - function fixrefs(scope, i) { - // do children first; order shouldn't matter - for (i = scope.children.length; --i >= 0;) - fixrefs(scope.children[i]); - for (i in scope.refs) if (HOP(scope.refs, i)) { - // find origin scope and propagate the reference to origin - for (var origin = scope.has(i), s = scope; s; s = s.parent) { - s.refs[i] = origin; - if (s === origin) break; - } - } - }; - fixrefs(current_scope); - - return ret; - }); - -}; - -/* -----[ mangle names ]----- */ - -function ast_mangle(ast, options) { - var w = ast_walker(), walk = w.walk, scope; - options = options || {}; - - function get_mangled(name, newMangle) { - if (!options.toplevel && !scope.parent) return name; // don't mangle toplevel - if (options.except && member(name, options.except)) - return name; - return scope.get_mangled(name, newMangle); - }; - - function get_define(name) { - if (options.defines) { - // we always lookup a defined symbol for the current scope FIRST, so declared - // vars trump a DEFINE symbol, but if no such var is found, then match a DEFINE value - if (!scope.has(name)) { - if (HOP(options.defines, name)) { - return options.defines[name]; - } - } - return null; - } - }; - - function _lambda(name, args, body) { - var is_defun = this[0] == "defun", extra; - if (name) { - if (is_defun) name = get_mangled(name); - else { - extra = {}; - if (!(scope.uses_eval || scope.uses_with)) - name = extra[name] = scope.next_mangled(); - else - extra[name] = name; - } - } - body = with_scope(body.scope, function(){ - args = MAP(args, function(name){ return get_mangled(name) }); - return MAP(body, walk); - }, extra); - return [ this[0], name, args, body ]; - }; - - function with_scope(s, cont, extra) { - var _scope = scope; - scope = s; - if (extra) for (var i in extra) if (HOP(extra, i)) { - s.set_mangle(i, extra[i]); - } - for (var i in s.names) if (HOP(s.names, i)) { - get_mangled(i, true); - } - var ret = cont(); - ret.scope = s; - scope = _scope; - return ret; - }; - - function _vardefs(defs) { - return [ this[0], MAP(defs, function(d){ - return [ get_mangled(d[0]), walk(d[1]) ]; - }) ]; - }; - - return w.with_walkers({ - "function": _lambda, - "defun": function() { - // move function declarations to the top when - // they are not in some block. - var ast = _lambda.apply(this, arguments); - switch (w.parent()[0]) { - case "toplevel": - case "function": - case "defun": - return MAP.at_top(ast); - } - return ast; - }, - "label": function(label, stat) { return [ this[0], get_mangled(label), walk(stat) ] }, - "break": function(label) { if (label) return [ this[0], get_mangled(label) ] }, - "continue": function(label) { if (label) return [ this[0], get_mangled(label) ] }, - "var": _vardefs, - "const": _vardefs, - "name": function(name) { - return get_define(name) || [ this[0], get_mangled(name) ]; - }, - "try": function(t, c, f) { - return [ this[0], - MAP(t, walk), - c != null ? [ get_mangled(c[0]), MAP(c[1], walk) ] : null, - f != null ? MAP(f, walk) : null ]; - }, - "toplevel": function(body) { - var self = this; - return with_scope(self.scope, function(){ - return [ self[0], MAP(body, walk) ]; - }); - } - }, function() { - return walk(ast_add_scope(ast)); - }); -}; - -/* -----[ - - compress foo["bar"] into foo.bar, - - remove block brackets {} where possible - - join consecutive var declarations - - various optimizations for IFs: - - if (cond) foo(); else bar(); ==> cond?foo():bar(); - - if (cond) foo(); ==> cond&&foo(); - - if (foo) return bar(); else return baz(); ==> return foo?bar():baz(); // also for throw - - if (foo) return bar(); else something(); ==> {if(foo)return bar();something()} - ]----- */ - var warn = function(){}; function best_of(ast1, ast2) { - return gen_code(ast1).length > gen_code(ast2[0] == "stat" ? ast2[1] : ast2).length ? ast2 : ast1; + return gen_code(ast1).length > gen_code(ast2[0] == "stat" ? ast2[1] : ast2).length ? ast2 : ast1; }; function last_stat(b) { - if (b[0] == "block" && b[1] && b[1].length > 0) - return b[1][b[1].length - 1]; - return b; + if (b[0] == "block" && b[1] && b[1].length > 0) + return b[1][b[1].length - 1]; + return b; } function aborts(t) { - if (t) switch (last_stat(t)[0]) { - case "return": - case "break": - case "continue": - case "throw": - return true; - } + if (t) switch (last_stat(t)[0]) { + case "return": + case "break": + case "continue": + case "throw": + return true; + } }; function boolean_expr(expr) { - return ( (expr[0] == "unary-prefix" - && member(expr[1], [ "!", "delete" ])) || - - (expr[0] == "binary" - && member(expr[1], [ "in", "instanceof", "==", "!=", "===", "!==", "<", "<=", ">=", ">" ])) || + return ((expr[0] == "unary-prefix" + && member(expr[1], [ "!", "delete" ])) || - (expr[0] == "binary" - && member(expr[1], [ "&&", "||" ]) - && boolean_expr(expr[2]) - && boolean_expr(expr[3])) || + (expr[0] == "binary" + && member(expr[1], [ "in", "instanceof", "==", "!=", "===", "!==", "<", "<=", ">=", ">" ])) || - (expr[0] == "conditional" - && boolean_expr(expr[2]) - && boolean_expr(expr[3])) || + (expr[0] == "binary" + && member(expr[1], [ "&&", "||" ]) + && boolean_expr(expr[2]) + && boolean_expr(expr[3])) || - (expr[0] == "assign" - && expr[1] === true - && boolean_expr(expr[3])) || + (expr[0] == "conditional" + && boolean_expr(expr[2]) + && boolean_expr(expr[3])) || - (expr[0] == "seq" - && boolean_expr(expr[expr.length - 1])) - ); -}; + (expr[0] == "assign" + && expr[1] === true + && boolean_expr(expr[3])) || -function make_conditional(c, t, e) { - var make_real_conditional = function() { - if (c[0] == "unary-prefix" && c[1] == "!") { - return e ? [ "conditional", c[2], e, t ] : [ "binary", "||", c[2], t ]; - } else { - return e ? [ "conditional", c, t, e ] : [ "binary", "&&", c, t ]; - } - }; - // shortcut the conditional if the expression has a constant value - return when_constant(c, function(ast, val){ - warn_unreachable(val ? e : t); - return (val ? t : e); - }, make_real_conditional); + (expr[0] == "seq" + && boolean_expr(expr[expr.length - 1]))); }; function empty(b) { - return !b || (b[0] == "block" && (!b[1] || b[1].length == 0)); + return !b || (b[0] == "block" && (!b[1] || b[1].length == 0)); }; function is_string(node) { - return (node[0] == "string" || - node[0] == "unary-prefix" && node[1] == "typeof" || - node[0] == "binary" && node[1] == "+" && - (is_string(node[2]) || is_string(node[3]))); -}; - -var when_constant = (function(){ - - var $NOT_CONSTANT = {}; - - // this can only evaluate constant expressions. If it finds anything - // not constant, it throws $NOT_CONSTANT. - function evaluate(expr) { - switch (expr[0]) { - case "string": - case "num": - return expr[1]; - case "name": - case "atom": - switch (expr[1]) { - case "true": return true; - case "false": return false; - } - break; - case "unary-prefix": - switch (expr[1]) { - case "!": return !evaluate(expr[2]); - case "typeof": return typeof evaluate(expr[2]); - case "~": return ~evaluate(expr[2]); - case "-": return -evaluate(expr[2]); - case "+": return +evaluate(expr[2]); - } - break; - case "binary": - var left = expr[2], right = expr[3]; - switch (expr[1]) { - case "&&" : return evaluate(left) && evaluate(right); - case "||" : return evaluate(left) || evaluate(right); - case "|" : return evaluate(left) | evaluate(right); - case "&" : return evaluate(left) & evaluate(right); - case "^" : return evaluate(left) ^ evaluate(right); - case "+" : return evaluate(left) + evaluate(right); - case "*" : return evaluate(left) * evaluate(right); - case "/" : return evaluate(left) / evaluate(right); - case "-" : return evaluate(left) - evaluate(right); - case "<<" : return evaluate(left) << evaluate(right); - case ">>" : return evaluate(left) >> evaluate(right); - case ">>>" : return evaluate(left) >>> evaluate(right); - case "==" : return evaluate(left) == evaluate(right); - case "===" : return evaluate(left) === evaluate(right); - case "!=" : return evaluate(left) != evaluate(right); - case "!==" : return evaluate(left) !== evaluate(right); - case "<" : return evaluate(left) < evaluate(right); - case "<=" : return evaluate(left) <= evaluate(right); - case ">" : return evaluate(left) > evaluate(right); - case ">=" : return evaluate(left) >= evaluate(right); - case "in" : return evaluate(left) in evaluate(right); - case "instanceof" : return evaluate(left) instanceof evaluate(right); - } - } - throw $NOT_CONSTANT; - }; - - return function(expr, yes, no) { - try { - var val = evaluate(expr), ast; - switch (typeof val) { - case "string": ast = [ "string", val ]; break; - case "number": ast = [ "num", val ]; break; - case "boolean": ast = [ "name", String(val) ]; break; - default: throw new Error("Can't handle constant of type: " + (typeof val)); - } - return yes.call(expr, ast, val); - } catch(ex) { - if (ex === $NOT_CONSTANT) { - if (expr[0] == "binary" - && (expr[1] == "===" || expr[1] == "!==") - && ((is_string(expr[2]) && is_string(expr[3])) - || (boolean_expr(expr[2]) && boolean_expr(expr[3])))) { - expr[1] = expr[1].substr(0, 2); - } - else if (no && expr[0] == "binary" - && (expr[1] == "||" || expr[1] == "&&")) { - // the whole expression is not constant but the lval may be... - try { - var lval = evaluate(expr[2]); - expr = ((expr[1] == "&&" && (lval ? expr[3] : lval)) || - (expr[1] == "||" && (lval ? lval : expr[3])) || - expr); - } catch(ex2) { - // IGNORE... lval is not constant - } - } - return no ? no.call(expr, expr) : null; - } - else throw ex; - } - }; - -})(); - -function warn_unreachable(ast) { - if (!empty(ast)) - warn("Dropping unreachable code: " + gen_code(ast, true)); -}; - -function prepare_ifs(ast) { - var w = ast_walker(), walk = w.walk; - // In this first pass, we rewrite ifs which abort with no else with an - // if-else. For example: - // - // if (x) { - // blah(); - // return y; - // } - // foobar(); - // - // is rewritten into: - // - // if (x) { - // blah(); - // return y; - // } else { - // foobar(); - // } - function redo_if(statements) { - statements = MAP(statements, walk); - - for (var i = 0; i < statements.length; ++i) { - var fi = statements[i]; - if (fi[0] != "if") continue; - - if (fi[3] && walk(fi[3])) continue; - - var t = walk(fi[2]); - if (!aborts(t)) continue; - - var conditional = walk(fi[1]); - - var e_body = statements.slice(i + 1); - var e = e_body.length == 1 ? e_body[0] : [ "block", e_body ]; - - var ret = statements.slice(0, i).concat([ [ - fi[0], // "if" - conditional, // conditional - t, // then - e // else - ] ]); - - return redo_if(ret); - } - - return statements; - }; - - function redo_if_lambda(name, args, body) { - body = redo_if(body); - return [ this[0], name, args, body ]; - }; - - function redo_if_block(statements) { - return [ this[0], statements != null ? redo_if(statements) : null ]; - }; - - return w.with_walkers({ - "defun": redo_if_lambda, - "function": redo_if_lambda, - "block": redo_if_block, - "splice": redo_if_block, - "toplevel": function(statements) { - return [ this[0], redo_if(statements) ]; - }, - "try": function(t, c, f) { - return [ - this[0], - redo_if(t), - c != null ? [ c[0], redo_if(c[1]) ] : null, - f != null ? redo_if(f) : null - ]; - } - }, function() { - return walk(ast); - }); -}; - -function for_side_effects(ast, handler) { - var w = ast_walker(), walk = w.walk; - var $stop = {}, $restart = {}; - function stop() { throw $stop }; - function restart() { throw $restart }; - function found(){ return handler.call(this, this, w, stop, restart) }; - function unary(op) { - if (op == "++" || op == "--") - return found.apply(this, arguments); - }; - return w.with_walkers({ - "try": found, - "throw": found, - "return": found, - "new": found, - "switch": found, - "break": found, - "continue": found, - "assign": found, - "call": found, - "if": found, - "for": found, - "for-in": found, - "while": found, - "do": found, - "return": found, - "unary-prefix": unary, - "unary-postfix": unary, - "defun": found - }, function(){ - while (true) try { - walk(ast); - break; - } catch(ex) { - if (ex === $stop) break; - if (ex === $restart) continue; - throw ex; - } - }); -}; - -function ast_lift_variables(ast) { - var w = ast_walker(), walk = w.walk, scope; - function do_body(body, env) { - var _scope = scope; - scope = env; - body = MAP(body, walk); - var hash = {}, names = MAP(env.names, function(type, name){ - if (type != "var") return MAP.skip; - if (!env.references(name)) return MAP.skip; - hash[name] = true; - return [ name ]; - }); - if (names.length > 0) { - // looking for assignments to any of these variables. - // we can save considerable space by moving the definitions - // in the var declaration. - for_side_effects([ "block", body ], function(ast, walker, stop, restart) { - if (ast[0] == "assign" - && ast[1] === true - && ast[2][0] == "name" - && HOP(hash, ast[2][1])) { - // insert the definition into the var declaration - for (var i = names.length; --i >= 0;) { - if (names[i][0] == ast[2][1]) { - if (names[i][1]) // this name already defined, we must stop - stop(); - names[i][1] = ast[3]; // definition - names.push(names.splice(i, 1)[0]); - break; - } - } - // remove this assignment from the AST. - var p = walker.parent(); - if (p[0] == "seq") { - var a = p[2]; - a.unshift(0, p.length); - p.splice.apply(p, a); - } - else if (p[0] == "stat") { - p.splice(0, p.length, "block"); // empty statement - } - else { - stop(); - } - restart(); - } - stop(); - }); - body.unshift([ "var", names ]); - } - scope = _scope; - return body; - }; - function _vardefs(defs) { - var ret = null; - for (var i = defs.length; --i >= 0;) { - var d = defs[i]; - if (!d[1]) continue; - d = [ "assign", true, [ "name", d[0] ], d[1] ]; - if (ret == null) ret = d; - else ret = [ "seq", d, ret ]; - } - if (ret == null) { - if (w.parent()[0] == "for-in") - return [ "name", defs[0][0] ]; - return MAP.skip; - } - return [ "stat", ret ]; - }; - function _toplevel(body) { - return [ this[0], do_body(body, this.scope) ]; - }; - return w.with_walkers({ - "function": function(name, args, body){ - for (var i = args.length; --i >= 0 && !body.scope.references(args[i]);) - args.pop(); - if (!body.scope.references(name)) name = null; - return [ this[0], name, args, do_body(body, body.scope) ]; - }, - "defun": function(name, args, body){ - if (!scope.references(name)) return MAP.skip; - for (var i = args.length; --i >= 0 && !body.scope.references(args[i]);) - args.pop(); - return [ this[0], name, args, do_body(body, body.scope) ]; - }, - "var": _vardefs, - "toplevel": _toplevel - }, function(){ - return walk(ast_add_scope(ast)); - }); -}; - -function ast_squeeze(ast, options) { - options = defaults(options, { - make_seqs : true, - dead_code : true, - keep_comps : true, - no_warnings : false - }); - - var w = ast_walker(), walk = w.walk, scope; - - function negate(c) { - var not_c = [ "unary-prefix", "!", c ]; - switch (c[0]) { - case "unary-prefix": - return c[1] == "!" && boolean_expr(c[2]) ? c[2] : not_c; - case "seq": - c = slice(c); - c[c.length - 1] = negate(c[c.length - 1]); - return c; - case "conditional": - return best_of(not_c, [ "conditional", c[1], negate(c[2]), negate(c[3]) ]); - case "binary": - var op = c[1], left = c[2], right = c[3]; - if (!options.keep_comps) switch (op) { - case "<=" : return [ "binary", ">", left, right ]; - case "<" : return [ "binary", ">=", left, right ]; - case ">=" : return [ "binary", "<", left, right ]; - case ">" : return [ "binary", "<=", left, right ]; - } - switch (op) { - case "==" : return [ "binary", "!=", left, right ]; - case "!=" : return [ "binary", "==", left, right ]; - case "===" : return [ "binary", "!==", left, right ]; - case "!==" : return [ "binary", "===", left, right ]; - case "&&" : return best_of(not_c, [ "binary", "||", negate(left), negate(right) ]); - case "||" : return best_of(not_c, [ "binary", "&&", negate(left), negate(right) ]); - } - break; - } - return not_c; - }; - - function with_scope(s, cont) { - var _scope = scope; - scope = s; - var ret = cont(); - ret.scope = s; - scope = _scope; - return ret; - }; - - function rmblock(block) { - if (block != null && block[0] == "block" && block[1]) { - if (block[1].length == 1) - block = block[1][0]; - else if (block[1].length == 0) - block = [ "block" ]; - } - return block; - }; - - function _lambda(name, args, body) { - var is_defun = this[0] == "defun"; - body = with_scope(body.scope, function(){ - var ret = tighten(body, "lambda"); - if (!is_defun && name && !scope.references(name)) - name = null; - return ret; - }); - return [ this[0], name, args, body ]; - }; - - // this function does a few things: - // 1. discard useless blocks - // 2. join consecutive var declarations - // 3. remove obviously dead code - // 4. transform consecutive statements using the comma operator - // 5. if block_type == "lambda" and it detects constructs like if(foo) return ... - rewrite like if (!foo) { ... } - function tighten(statements, block_type) { - statements = MAP(statements, walk); - - statements = statements.reduce(function(a, stat){ - if (stat[0] == "block") { - if (stat[1]) { - a.push.apply(a, stat[1]); - } - } else { - a.push(stat); - } - return a; - }, []); - - statements = (function(a, prev){ - statements.forEach(function(cur){ - if (prev && ((cur[0] == "var" && prev[0] == "var") || - (cur[0] == "const" && prev[0] == "const"))) { - prev[1] = prev[1].concat(cur[1]); - } else { - a.push(cur); - prev = cur; - } - }); - return a; - })([]); - - if (options.dead_code) statements = (function(a, has_quit){ - statements.forEach(function(st){ - if (has_quit) { - if (st[0] == "function" || st[0] == "defun") { - a.push(st); - } - else if (st[0] == "var" || st[0] == "const") { - if (!options.no_warnings) - warn("Variables declared in unreachable code"); - st[1] = MAP(st[1], function(def){ - if (def[1] && !options.no_warnings) - warn_unreachable([ "assign", true, [ "name", def[0] ], def[1] ]); - return [ def[0] ]; - }); - a.push(st); - } - else if (!options.no_warnings) - warn_unreachable(st); - } - else { - a.push(st); - if (member(st[0], [ "return", "throw", "break", "continue" ])) - has_quit = true; - } - }); - return a; - })([]); - - if (options.make_seqs) statements = (function(a, prev) { - statements.forEach(function(cur){ - if (prev && prev[0] == "stat" && cur[0] == "stat") { - prev[1] = [ "seq", prev[1], cur[1] ]; - } else { - a.push(cur); - prev = cur; - } - }); - if (a.length >= 2 - && a[a.length-2][0] == "stat" - && (a[a.length-1][0] == "return" || a[a.length-1][0] == "throw") - && a[a.length-1][1]) - { - a.splice(a.length - 2, 2, - [ a[a.length-1][0], - [ "seq", a[a.length-2][1], a[a.length-1][1] ]]); - } - return a; - })([]); - - // this increases jQuery by 1K. Probably not such a good idea after all.. - // part of this is done in prepare_ifs anyway. - // if (block_type == "lambda") statements = (function(i, a, stat){ - // while (i < statements.length) { - // stat = statements[i++]; - // if (stat[0] == "if" && !stat[3]) { - // if (stat[2][0] == "return" && stat[2][1] == null) { - // a.push(make_if(negate(stat[1]), [ "block", statements.slice(i) ])); - // break; - // } - // var last = last_stat(stat[2]); - // if (last[0] == "return" && last[1] == null) { - // a.push(make_if(stat[1], [ "block", stat[2][1].slice(0, -1) ], [ "block", statements.slice(i) ])); - // break; - // } - // } - // a.push(stat); - // } - // return a; - // })(0, []); - - return statements; - }; - - function make_if(c, t, e) { - return when_constant(c, function(ast, val){ - if (val) { - warn_unreachable(e); - return t; - } else { - warn_unreachable(t); - return e; - } - }, function() { - return make_real_if(c, t, e); - }); - }; - - function make_real_if(c, t, e) { - c = walk(c); - t = walk(t); - e = walk(e); - - if (empty(t)) { - c = negate(c); - t = e; - e = null; - } else if (empty(e)) { - e = null; - } else { - // if we have both else and then, maybe it makes sense to switch them? - (function(){ - var a = gen_code(c); - var n = negate(c); - var b = gen_code(n); - if (b.length < a.length) { - var tmp = t; - t = e; - e = tmp; - c = n; - } - })(); - } - if (empty(e) && empty(t)) - return [ "stat", c ]; - var ret = [ "if", c, t, e ]; - if (t[0] == "if" && empty(t[3]) && empty(e)) { - ret = best_of(ret, walk([ "if", [ "binary", "&&", c, t[1] ], t[2] ])); - } - else if (t[0] == "stat") { - if (e) { - if (e[0] == "stat") { - ret = best_of(ret, [ "stat", make_conditional(c, t[1], e[1]) ]); - } - } - else { - ret = best_of(ret, [ "stat", make_conditional(c, t[1]) ]); - } - } - else if (e && t[0] == e[0] && (t[0] == "return" || t[0] == "throw") && t[1] && e[1]) { - ret = best_of(ret, [ t[0], make_conditional(c, t[1], e[1] ) ]); - } - else if (e && aborts(t)) { - ret = [ [ "if", c, t ] ]; - if (e[0] == "block") { - if (e[1]) ret = ret.concat(e[1]); - } - else { - ret.push(e); - } - ret = walk([ "block", ret ]); - } - else if (t && aborts(e)) { - ret = [ [ "if", negate(c), e ] ]; - if (t[0] == "block") { - if (t[1]) ret = ret.concat(t[1]); - } else { - ret.push(t); - } - ret = walk([ "block", ret ]); - } - return ret; - }; - - function _do_while(cond, body) { - return when_constant(cond, function(cond, val){ - if (!val) { - warn_unreachable(body); - return [ "block" ]; - } else { - return [ "for", null, null, null, walk(body) ]; - } - }); - }; - - return w.with_walkers({ - "sub": function(expr, subscript) { - if (subscript[0] == "string") { - var name = subscript[1]; - if (is_identifier(name)) - return [ "dot", walk(expr), name ]; - else if (/^[1-9][0-9]*$/.test(name) || name === "0") - return [ "sub", walk(expr), [ "num", parseInt(name, 10) ] ]; - } - }, - "if": make_if, - "toplevel": function(body) { - return [ "toplevel", with_scope(this.scope, function(){ - return tighten(body); - }) ]; - }, - "switch": function(expr, body) { - var last = body.length - 1; - return [ "switch", walk(expr), MAP(body, function(branch, i){ - var block = tighten(branch[1]); - if (i == last && block.length > 0) { - var node = block[block.length - 1]; - if (node[0] == "break" && !node[1]) - block.pop(); - } - return [ branch[0] ? walk(branch[0]) : null, block ]; - }) ]; - }, - "function": _lambda, - "defun": _lambda, - "block": function(body) { - if (body) return rmblock([ "block", tighten(body) ]); - }, - "binary": function(op, left, right) { - return when_constant([ "binary", op, walk(left), walk(right) ], function yes(c){ - return best_of(walk(c), this); - }, function no() { - return this; - }); - }, - "conditional": function(c, t, e) { - return make_conditional(walk(c), walk(t), walk(e)); - }, - "try": function(t, c, f) { - return [ - "try", - tighten(t), - c != null ? [ c[0], tighten(c[1]) ] : null, - f != null ? tighten(f) : null - ]; - }, - "unary-prefix": function(op, expr) { - expr = walk(expr); - var ret = [ "unary-prefix", op, expr ]; - if (op == "!") - ret = best_of(ret, negate(expr)); - return when_constant(ret, function(ast, val){ - return walk(ast); // it's either true or false, so minifies to !0 or !1 - }, function() { return ret }); - }, - "name": function(name) { - switch (name) { - case "true": return [ "unary-prefix", "!", [ "num", 0 ]]; - case "false": return [ "unary-prefix", "!", [ "num", 1 ]]; - } - }, - "while": _do_while - }, function() { - for (var i = 0; i < 2; ++i) { - ast = prepare_ifs(ast); - ast = ast_add_scope(ast); - ast = walk(ast); - } - return ast; - }); + return (node[0] == "string" || + node[0] == "unary-prefix" && node[1] == "typeof" || + node[0] == "binary" && node[1] == "+" && + (is_string(node[2]) || is_string(node[3]))); }; /* -----[ re-generate code from the AST ]----- */ var DOT_CALL_NO_PARENS = jsp.array_to_hash([ - "name", - "array", - "object", - "string", - "dot", - "sub", - "call", - "regexp" -]); + "name", "array", "object", "string", "dot", "sub", "call", "regexp" ]); function make_string(str, ascii_only) { - var dq = 0, sq = 0; - str = str.replace(/[\\\b\f\n\r\t\x22\x27\u2028\u2029]/g, function(s){ - switch (s) { - case "\\": return "\\\\"; - case "\b": return "\\b"; - case "\f": return "\\f"; - case "\n": return "\\n"; - case "\r": return "\\r"; - case "\t": return "\\t"; - case "\u2028": return "\\u2028"; - case "\u2029": return "\\u2029"; - case '"': ++dq; return '"'; - case "'": ++sq; return "'"; - } - return s; - }); - if (ascii_only) str = to_ascii(str); - if (dq > sq) return "'" + str.replace(/\x27/g, "\\'") + "'"; - else return '"' + str.replace(/\x22/g, '\\"') + '"'; + var dq = 0, sq = 0; + str = str.replace(/[\\\b\f\n\r\t\x22\x27\u2028\u2029]/g, function(s){ + switch (s) { + case "\\": return "\\\\"; + case "\b": return "\\b"; + case "\f": return "\\f"; + case "\n": return "\\n"; + case "\r": return "\\r"; + case "\t": return "\\t"; + case "\u2028": return "\\u2028"; + case "\u2029": return "\\u2029"; + case '"': ++dq; return '"'; + case "'": ++sq; return "'"; + } + return s; + }); + if (ascii_only) str = to_ascii(str); + if (dq > sq) return "'" + str.replace(/\x27/g, "\\'") + "'"; + else return '"' + str.replace(/\x22/g, '\\"') + '"'; }; function to_ascii(str) { - return str.replace(/[\u0080-\uffff]/g, function(ch) { - var code = ch.charCodeAt(0).toString(16); - while (code.length < 4) code = "0" + code; - return "\\u" + code; - }); + return str.replace(/[\u0080-\uffff]/g, function(ch) { + var code = ch.charCodeAt(0).toString(16); + while (code.length < 4) code = "0" + code; + return "\\u" + code; + }); }; var SPLICE_NEEDS_BRACKETS = jsp.array_to_hash([ "if", "while", "do", "for", "for-in", "with" ]); function gen_code(ast, options) { - options = defaults(options, { - indent_start : 0, - indent_level : 4, - quote_keys : false, - space_colon : false, - beautify : false, - ascii_only : false, - inline_script: false - }); - var beautify = !!options.beautify; - var indentation = 0, - newline = beautify ? "\n" : "", - space = beautify ? " " : ""; - - function encode_string(str) { - var ret = make_string(str, options.ascii_only); - if (options.inline_script) - ret = ret.replace(/<\x2fscript([>/\t\n\f\r ])/gi, "<\\/script$1"); - return ret; - }; - - function make_name(name) { - name = name.toString(); - if (options.ascii_only) - name = to_ascii(name); - return name; - }; - - function indent(line) { - if (line == null) - line = ""; - if (beautify) - line = repeat_string(" ", options.indent_start + indentation * options.indent_level) + line; - return line; - }; - - function with_indent(cont, incr) { - if (incr == null) incr = 1; - indentation += incr; - try { return cont.apply(null, slice(arguments, 1)); } - finally { indentation -= incr; } - }; - - function add_spaces(a) { - if (beautify) - return a.join(" "); - var b = []; - for (var i = 0; i < a.length; ++i) { - var next = a[i + 1]; - b.push(a[i]); - if (next && - ((/[a-z0-9_\x24]$/i.test(a[i].toString()) && /^[a-z0-9_\x24]/i.test(next.toString())) || - (/[\+\-]$/.test(a[i].toString()) && /^[\+\-]/.test(next.toString())))) { - b.push(" "); - } - } - return b.join(""); - }; - - function add_commas(a) { - return a.join("," + space); - }; - - function parenthesize(expr) { - var gen = make(expr); - for (var i = 1; i < arguments.length; ++i) { - var el = arguments[i]; - if ((el instanceof Function && el(expr)) || expr[0] == el) - return "(" + gen + ")"; - } - return gen; - }; - - function best_of(a) { - if (a.length == 1) { - return a[0]; - } - if (a.length == 2) { - var b = a[1]; - a = a[0]; - return a.length <= b.length ? a : b; - } - return best_of([ a[0], best_of(a.slice(1)) ]); - }; - - function needs_parens(expr) { - if (expr[0] == "function" || expr[0] == "object") { - // dot/call on a literal function requires the - // function literal itself to be parenthesized - // only if it's the first "thing" in a - // statement. This means that the parent is - // "stat", but it could also be a "seq" and - // we're the first in this "seq" and the - // parent is "stat", and so on. Messy stuff, - // but it worths the trouble. - var a = slice(w.stack()), self = a.pop(), p = a.pop(); - while (p) { - if (p[0] == "stat") return true; - if (((p[0] == "seq" || p[0] == "call" || p[0] == "dot" || p[0] == "sub" || p[0] == "conditional") && p[1] === self) || - ((p[0] == "binary" || p[0] == "assign" || p[0] == "unary-postfix") && p[2] === self)) { - self = p; - p = a.pop(); - } else { - return false; - } - } - } - return !HOP(DOT_CALL_NO_PARENS, expr[0]); - }; - - function make_num(num) { - var str = num.toString(10), a = [ str.replace(/^0\./, ".") ], m; - if (Math.floor(num) === num) { - a.push("0x" + num.toString(16).toLowerCase(), // probably pointless - "0" + num.toString(8)); // same. - if ((m = /^(.*?)(0+)$/.exec(num))) { - a.push(m[1] + "e" + m[2].length); - } - } else if ((m = /^0?\.(0+)(.*)$/.exec(num))) { - a.push(m[2] + "e-" + (m[1].length + m[2].length), - str.substr(str.indexOf("."))); - } - return best_of(a); - }; - - var w = ast_walker(); - var make = w.walk; - return w.with_walkers({ - "string": encode_string, - "num": make_num, - "name": make_name, - "toplevel": function(statements) { - return make_block_statements(statements) - .join(newline + newline); - }, - "splice": function(statements) { - var parent = w.parent(); - if (HOP(SPLICE_NEEDS_BRACKETS, parent)) { - // we need block brackets in this case - return make_block.apply(this, arguments); - } else { - return MAP(make_block_statements(statements, true), - function(line, i) { - // the first line is already indented - return i > 0 ? indent(line) : line; - }).join(newline); - } - }, - "block": make_block, - "var": function(defs) { - return "var " + add_commas(MAP(defs, make_1vardef)) + ";"; - }, - "const": function(defs) { - return "const " + add_commas(MAP(defs, make_1vardef)) + ";"; - }, - "try": function(tr, ca, fi) { - var out = [ "try", make_block(tr) ]; - if (ca) out.push("catch", "(" + ca[0] + ")", make_block(ca[1])); - if (fi) out.push("finally", make_block(fi)); - return add_spaces(out); - }, - "throw": function(expr) { - return add_spaces([ "throw", make(expr) ]) + ";"; - }, - "new": function(ctor, args) { - args = args.length > 0 ? "(" + add_commas(MAP(args, make)) + ")" : ""; - return add_spaces([ "new", parenthesize(ctor, "seq", "binary", "conditional", "assign", function(expr){ - var w = ast_walker(), has_call = {}; - try { - w.with_walkers({ - "call": function() { throw has_call }, - "function": function() { return this } - }, function(){ - w.walk(expr); - }); - } catch(ex) { - if (ex === has_call) - return true; - throw ex; - } - }) + args ]); - }, - "switch": function(expr, body) { - return add_spaces([ "switch", "(" + make(expr) + ")", make_switch_block(body) ]); - }, - "break": function(label) { - var out = "break"; - if (label != null) - out += " " + make_name(label); - return out + ";"; - }, - "continue": function(label) { - var out = "continue"; - if (label != null) - out += " " + make_name(label); - return out + ";"; - }, - "conditional": function(co, th, el) { - return add_spaces([ parenthesize(co, "assign", "seq", "conditional"), "?", - parenthesize(th, "seq"), ":", - parenthesize(el, "seq") ]); - }, - "assign": function(op, lvalue, rvalue) { - if (op && op !== true) op += "="; - else op = "="; - return add_spaces([ make(lvalue), op, parenthesize(rvalue, "seq") ]); - }, - "dot": function(expr) { - var out = make(expr), i = 1; - if (expr[0] == "num") { - if (!/\./.test(expr[1])) - out += "."; - } else if (needs_parens(expr)) - out = "(" + out + ")"; - while (i < arguments.length) - out += "." + make_name(arguments[i++]); - return out; - }, - "call": function(func, args) { - var f = make(func); - if (needs_parens(func)) - f = "(" + f + ")"; - return f + "(" + add_commas(MAP(args, function(expr){ - return parenthesize(expr, "seq"); - })) + ")"; - }, - "function": make_function, - "defun": make_function, - "if": function(co, th, el) { - var out = [ "if", "(" + make(co) + ")", el ? make_then(th) : make(th) ]; - if (el) { - out.push("else", make(el)); - } - return add_spaces(out); - }, - "for": function(init, cond, step, block) { - var out = [ "for" ]; - init = (init != null ? make(init) : "").replace(/;*\s*$/, ";" + space); - cond = (cond != null ? make(cond) : "").replace(/;*\s*$/, ";" + space); - step = (step != null ? make(step) : "").replace(/;*\s*$/, ""); - var args = init + cond + step; - if (args == "; ; ") args = ";;"; - out.push("(" + args + ")", make(block)); - return add_spaces(out); - }, - "for-in": function(vvar, key, hash, block) { - return add_spaces([ "for", "(" + - (vvar ? make(vvar).replace(/;+$/, "") : make(key)), - "in", - make(hash) + ")", make(block) ]); - }, - "while": function(condition, block) { - return add_spaces([ "while", "(" + make(condition) + ")", make(block) ]); - }, - "do": function(condition, block) { - return add_spaces([ "do", make(block), "while", "(" + make(condition) + ")" ]) + ";"; - }, - "return": function(expr) { - var out = [ "return" ]; - if (expr != null) out.push(make(expr)); - return add_spaces(out) + ";"; - }, - "binary": function(operator, lvalue, rvalue) { - var left = make(lvalue), right = make(rvalue); - // XXX: I'm pretty sure other cases will bite here. - // we need to be smarter. - // adding parens all the time is the safest bet. - if (member(lvalue[0], [ "assign", "conditional", "seq" ]) || - lvalue[0] == "binary" && PRECEDENCE[operator] > PRECEDENCE[lvalue[1]]) { - left = "(" + left + ")"; - } - if (member(rvalue[0], [ "assign", "conditional", "seq" ]) || - rvalue[0] == "binary" && PRECEDENCE[operator] >= PRECEDENCE[rvalue[1]] && - !(rvalue[1] == operator && member(operator, [ "&&", "||", "*" ]))) { - right = "(" + right + ")"; - } - else if (!beautify && options.inline_script && (operator == "<" || operator == "<<") - && rvalue[0] == "regexp" && /^script/i.test(rvalue[1])) { - right = " " + right; - } - return add_spaces([ left, operator, right ]); - }, - "unary-prefix": function(operator, expr) { - var val = make(expr); - if (!(expr[0] == "num" || (expr[0] == "unary-prefix" && !HOP(OPERATORS, operator + expr[1])) || !needs_parens(expr))) - val = "(" + val + ")"; - return operator + (jsp.is_alphanumeric_char(operator.charAt(0)) ? " " : "") + val; - }, - "unary-postfix": function(operator, expr) { - var val = make(expr); - if (!(expr[0] == "num" || (expr[0] == "unary-postfix" && !HOP(OPERATORS, operator + expr[1])) || !needs_parens(expr))) - val = "(" + val + ")"; - return val + operator; - }, - "sub": function(expr, subscript) { - var hash = make(expr); - if (needs_parens(expr)) - hash = "(" + hash + ")"; - return hash + "[" + make(subscript) + "]"; - }, - "object": function(props) { - if (props.length == 0) - return "{}"; - return "{" + newline + with_indent(function(){ - return MAP(props, function(p){ - if (p.length == 3) { - // getter/setter. The name is in p[0], the arg.list in p[1][2], the - // body in p[1][3] and type ("get" / "set") in p[2]. - return indent(make_function(p[0], p[1][2], p[1][3], p[2])); - } - var key = p[0], val = parenthesize(p[1], "seq"); - if (options.quote_keys || p.quoted) { - key = encode_string(key); - } else if ((typeof key == "number" || !beautify && +key + "" == key) - && parseFloat(key) >= 0) { - key = make_num(+key); - } else if (!is_identifier(key)) { - key = encode_string(key); - } - return indent(add_spaces(beautify && options.space_colon - ? [ key, ":", val ] - : [ key + ":", val ])); - }).join("," + newline); - }) + newline + indent("}"); - }, - "regexp": function(rx, mods) { - return "/" + rx + "/" + mods; - }, - "array": function(elements) { - if (elements.length == 0) return "[]"; - return add_spaces([ "[", add_commas(MAP(elements, function(el){ - if (!beautify && el[0] == "atom" && el[1] == "undefined") return ""; - return parenthesize(el, "seq"); - })), "]" ]); - }, - "stat": function(stmt) { - return make(stmt).replace(/;*\s*$/, ";"); - }, - "seq": function() { - return add_commas(MAP(slice(arguments), make)); - }, - "label": function(name, block) { - return add_spaces([ make_name(name), ":", make(block) ]); - }, - "with": function(expr, block) { - return add_spaces([ "with", "(" + make(expr) + ")", make(block) ]); - }, - "atom": function(name) { - return make_name(name); - } - }, function(){ return make(ast) }); - - // The squeezer replaces "block"-s that contain only a single - // statement with the statement itself; technically, the AST - // is correct, but this can create problems when we output an - // IF having an ELSE clause where the THEN clause ends in an - // IF *without* an ELSE block (then the outer ELSE would refer - // to the inner IF). This function checks for this case and - // adds the block brackets if needed. - function make_then(th) { - if (th[0] == "do") { - // https://github.com/mishoo/UglifyJS/issues/#issue/57 - // IE croaks with "syntax error" on code like this: - // if (foo) do ... while(cond); else ... - // we need block brackets around do/while - return make_block([ th ]); - } - var b = th; - while (true) { - var type = b[0]; - if (type == "if") { - if (!b[3]) - // no else, we must add the block - return make([ "block", [ th ]]); - b = b[3]; - } - else if (type == "while" || type == "do") b = b[2]; - else if (type == "for" || type == "for-in") b = b[4]; - else break; - } - return make(th); - }; - - function make_function(name, args, body, keyword) { - var out = keyword || "function"; - if (name) { - out += " " + make_name(name); - } - out += "(" + add_commas(MAP(args, make_name)) + ")"; - var result = add_spaces([ out, make_block(body) ]) - if (!name) result = "(" + result + ")"; - return result; - }; - - function must_has_semicolon(node) { - switch (node[0]) { - case "with": - case "while": - return empty(node[2]); // `with' or `while' with empty body? - case "for": - case "for-in": - return empty(node[4]); // `for' with empty body? - case "if": - if (empty(node[2]) && !node[3]) return true; // `if' with empty `then' and no `else' - if (node[3]) { - if (empty(node[3])) return true; // `else' present but empty - return must_has_semicolon(node[3]); // dive into the `else' branch - } - return must_has_semicolon(node[2]); // dive into the `then' branch - } - }; - - function make_block_statements(statements, noindent) { - for (var a = [], last = statements.length - 1, i = 0; i <= last; ++i) { - var stat = statements[i]; - var code = make(stat); - if (code != ";") { - if (!beautify && i == last && !must_has_semicolon(stat)) { - code = code.replace(/;+\s*$/, ""); - } - a.push(code); - } - } - return noindent ? a : MAP(a, indent); - }; - - function make_switch_block(body) { - var n = body.length; - if (n == 0) return "{}"; - return "{" + newline + MAP(body, function(branch, i){ - var has_body = branch[1].length > 0, code = with_indent(function(){ - return indent(branch[0] - ? add_spaces([ "case", make(branch[0]) + ":" ]) - : "default:"); - }, 0.5) + (has_body ? newline + with_indent(function(){ - return make_block_statements(branch[1]).join(newline); - }) : ""); - if (!beautify && has_body && i < n - 1) - code += ";"; - return code; - }).join(newline) + newline + indent("}"); - }; - - function make_block(statements) { - if (!statements) return ";"; - if (statements.length == 0) return "{}"; - return "{" + newline + with_indent(function(){ - return make_block_statements(statements).join(newline); - }) + newline + indent("}"); - }; - - function make_1vardef(def) { - var name = def[0], val = def[1]; - if (val != null) - name = add_spaces([ make_name(name), "=", parenthesize(val, "seq") ]); - return name; - }; - -}; + options = defaults(options, { + indent_start : 0, + indent_level : 4, + quote_keys : false, + space_colon : false, + beautify : false, + ascii_only : false, + inline_script: false + }); + var beautify = !!options.beautify; + var indentation = 0, + newline = beautify ? "\n" : "", + space = beautify ? " " : ""; + + function encode_string(str) { + var ret = make_string(str, options.ascii_only); + if (options.inline_script) + ret = ret.replace(/<\x2fscript([>/\t\n\f\r ])/gi, "<\\/script$1"); + return ret; + }; + + function make_name(name) { + name = name.toString(); + if (options.ascii_only) + name = to_ascii(name); + return name; + }; + + function indent(line) { + if (line == null) + line = ""; + if (beautify) + line = repeat_string(" ", options.indent_start + indentation * options.indent_level) + line; + return line; + }; + + function with_indent(cont, incr) { + if (incr == null) incr = 1; + indentation += incr; + try { return cont.apply(null, slice(arguments, 1)); } + finally { indentation -= incr; } + }; + + function add_spaces(a) { + if (beautify) + return a.join(" "); + var b = []; + for (var i = 0; i < a.length; ++i) { + var next = a[i + 1]; + b.push(a[i]); + if (next && + ((/[a-z0-9_\x24]$/i.test(a[i].toString()) && /^[a-z0-9_\x24]/i.test(next.toString())) || + (/[\+\-]$/.test(a[i].toString()) && /^[\+\-]/.test(next.toString())))) { + b.push(" "); + } + } + return b.join(""); + }; + + function add_commas(a) { + return a.join("," + space); + }; + + function parenthesize(expr) { + var gen = make(expr); + for (var i = 1; i < arguments.length; ++i) { + var el = arguments[i]; + if ((el instanceof Function && el(expr)) || expr[0] == el) + return "(" + gen + ")"; + } + return gen; + }; + + function best_of(a) { + if (a.length == 1) { + return a[0]; + } + if (a.length == 2) { + var b = a[1]; + a = a[0]; + return a.length <= b.length ? a : b; + } + return best_of([ a[0], best_of(a.slice(1)) ]); + }; + + function needs_parens(expr) { + if (expr[0] == "function" || expr[0] == "object") { + // dot/call on a literal function requires the + // function literal itself to be parenthesized + // only if it's the first "thing" in a + // statement. This means that the parent is + // "stat", but it could also be a "seq" and + // we're the first in this "seq" and the + // parent is "stat", and so on. Messy stuff, + // but it worths the trouble. + var a = slice(w.stack()), self = a.pop(), p = a.pop(); + while (p) { + if (p[0] == "stat") return true; + if (((p[0] == "seq" || p[0] == "call" || p[0] == "dot" || p[0] == "sub" || p[0] == "conditional") && p[1] === self) || + ((p[0] == "binary" || p[0] == "assign" || p[0] == "unary-postfix") && p[2] === self)) { + self = p; + p = a.pop(); + } else { + return false; + } + } + } + return !HOP(DOT_CALL_NO_PARENS, expr[0]); + }; + + function make_num(num) { + var str = num.toString(10), a = [ str.replace(/^0\./, ".") ], m; + if (Math.floor(num) === num) { + a.push("0x" + num.toString(16).toLowerCase(), // probably pointless + "0" + num.toString(8)); // same. + if ((m = /^(.*?)(0+)$/.exec(num))) { + a.push(m[1] + "e" + m[2].length); + } + } else if ((m = /^0?\.(0+)(.*)$/.exec(num))) { + a.push(m[2] + "e-" + (m[1].length + m[2].length), + str.substr(str.indexOf("."))); + } + return best_of(a); + }; + + var w = ast_walker(); + var make = w.walk; + return w.with_walkers({ + "string": encode_string, + "num": make_num, + "name": make_name, + "toplevel": function(statements) { + return make_block_statements(statements) + .join(newline + newline); + }, + "splice": function(statements) { + var parent = w.parent(); + if (HOP(SPLICE_NEEDS_BRACKETS, parent)) { + // we need block brackets in this case + return make_block.apply(this, arguments); + } else { + return MAP(make_block_statements(statements, true), function(line, i) { + // the first line is already indented + return i > 0 ? indent(line) : line; + }).join(newline); + } + }, + "block": make_block, + "var": function(defs) { + return "var " + add_commas(MAP(defs, make_1vardef)) + ";"; + }, + "const": function(defs) { + return "const " + add_commas(MAP(defs, make_1vardef)) + ";"; + }, + "try": function(tr, ca, fi) { + var out = [ "try", make_block(tr) ]; + if (ca) out.push("catch", "(" + ca[0] + ")", make_block(ca[1])); + if (fi) out.push("finally", make_block(fi)); + return add_spaces(out); + }, + "throw": function(expr) { + return add_spaces([ "throw", make(expr) ]) + ";"; + }, + "new": function(ctor, args) { + args = args.length > 0 ? "(" + add_commas(MAP(args, make)) + ")" : ""; + return add_spaces([ "new", parenthesize(ctor, "seq", "binary", "conditional", "assign", function(expr){ + var w = ast_walker(), has_call = {}; + try { + w.with_walkers({ + "call": function() { throw has_call }, + "function": function() { return this } + }, function(){ + w.walk(expr); + }); + } catch(ex) { + if (ex === has_call) + return true; + throw ex; + } + }) + args ]); + }, + "switch": function(expr, body) { + return add_spaces([ "switch", "(" + make(expr) + ")", make_switch_block(body) ]); + }, + "break": function(label) { + var out = "break"; + if (label != null) + out += " " + make_name(label); + return out + ";"; + }, + "continue": function(label) { + var out = "continue"; + if (label != null) + out += " " + make_name(label); + return out + ";"; + }, + "conditional": function(co, th, el) { + return add_spaces([ parenthesize(co, "assign", "seq", "conditional"), "?", + parenthesize(th, "seq"), ":", + parenthesize(el, "seq") ]); + }, + "assign": function(op, lvalue, rvalue) { + if (op && op !== true) op += "="; + else op = "="; + return add_spaces([ make(lvalue), op, parenthesize(rvalue, "seq") ]); + }, + "dot": function(expr) { + var out = make(expr), i = 1; + if (expr[0] == "num") { + if (!/\./.test(expr[1])) + out += "."; + } else if (needs_parens(expr)) + out = "(" + out + ")"; + while (i < arguments.length) + out += "." + make_name(arguments[i++]); + return out; + }, + "call": function(func, args) { + var f = make(func); + if (needs_parens(func)) + f = "(" + f + ")"; + return f + "(" + add_commas(MAP(args, function(expr){ + return parenthesize(expr, "seq"); + })) + ")"; + }, + "function": make_function, + "defun": make_function, + "if": function(co, th, el) { + var out = [ "if", "(" + make(co) + ")", el ? make_then(th) : make(th) ]; + if (el) { + out.push("else", make(el)); + } + return add_spaces(out); + }, + "for": function(init, cond, step, block) { + var out = [ "for" ]; + init = (init != null ? make(init) : "").replace(/;*\s*$/, ";" + space); + cond = (cond != null ? make(cond) : "").replace(/;*\s*$/, ";" + space); + step = (step != null ? make(step) : "").replace(/;*\s*$/, ""); + var args = init + cond + step; + if (args == "; ; ") args = ";;"; + out.push("(" + args + ")", make(block)); + return add_spaces(out); + }, + "for-in": function(vvar, key, hash, block) { + return add_spaces([ "for", "(" + + (vvar ? make(vvar).replace(/;+$/, "") : make(key)), + "in", + make(hash) + ")", make(block) ]); + }, + "while": function(condition, block) { + return add_spaces([ "while", "(" + make(condition) + ")", make(block) ]); + }, + "do": function(condition, block) { + return add_spaces([ "do", make(block), "while", "(" + make(condition) + ")" ]) + ";"; + }, + "return": function(expr) { + var out = [ "return" ]; + if (expr != null) out.push(make(expr)); + return add_spaces(out) + ";"; + }, + "binary": function(operator, lvalue, rvalue) { + var left = make(lvalue), right = make(rvalue); + // XXX: I'm pretty sure other cases will bite here. + // we need to be smarter. + // adding parens all the time is the safest bet. + if (member(lvalue[0], [ "assign", "conditional", "seq" ]) || + lvalue[0] == "binary" && PRECEDENCE[operator] > PRECEDENCE[lvalue[1]]) { + left = "(" + left + ")"; + } + if (member(rvalue[0], [ "assign", "conditional", "seq" ]) || + rvalue[0] == "binary" && PRECEDENCE[operator] >= PRECEDENCE[rvalue[1]] && + !(rvalue[1] == operator && member(operator, [ "&&", "||", "*" ]))) { + right = "(" + right + ")"; + } + else if (!beautify && options.inline_script && (operator == "<" || operator == "<<") + && rvalue[0] == "regexp" && /^script/i.test(rvalue[1])) { + right = " " + right; + } + return add_spaces([ left, operator, right ]); + }, + "unary-prefix": function(operator, expr) { + var val = make(expr); + if (!(expr[0] == "num" || (expr[0] == "unary-prefix" && !HOP(OPERATORS, operator + expr[1])) || !needs_parens(expr))) + val = "(" + val + ")"; + return operator + (jsp.is_alphanumeric_char(operator.charAt(0)) ? " " : "") + val; + }, + "unary-postfix": function(operator, expr) { + var val = make(expr); + if (!(expr[0] == "num" || (expr[0] == "unary-postfix" && !HOP(OPERATORS, operator + expr[1])) || !needs_parens(expr))) + val = "(" + val + ")"; + return val + operator; + }, + "sub": function(expr, subscript) { + var hash = make(expr); + if (needs_parens(expr)) + hash = "(" + hash + ")"; + return hash + "[" + make(subscript) + "]"; + }, + "object": function(props) { + if (props.length == 0) + return "{}"; + return "{" + newline + with_indent(function(){ + return MAP(props, function(p){ + if (p.length == 3) { + // getter/setter. The name is in p[0], the arg.list in p[1][2], the + // body in p[1][3] and type ("get" / "set") in p[2]. + return indent(make_function(p[0], p[1][2], p[1][3], p[2])); + } + var key = p[0], val = parenthesize(p[1], "seq"); + if (options.quote_keys || p.quoted) { + key = encode_string(key); + } else if ((typeof key == "number" || !beautify && +key + "" == key) + && parseFloat(key) >= 0) { + key = make_num(+key); + } else if (!is_identifier(key)) { + key = encode_string(key); + } + return indent(add_spaces(beautify && options.space_colon + ? [ key, ":", val ] + : [ key + ":", val ])); + }).join("," + newline); + }) + newline + indent("}"); + }, + "regexp": function(rx, mods) { + return "/" + rx + "/" + mods; + }, + "array": function(elements) { + if (elements.length == 0) return "[]"; + return add_spaces([ "[", add_commas(MAP(elements, function(el){ + if (!beautify && el[0] == "atom" && el[1] == "undefined") return ""; + return parenthesize(el, "seq"); + })), "]" ]); + }, + "stat": function(stmt) { + return make(stmt).replace(/;*\s*$/, ";"); + }, + "seq": function() { + return add_commas(MAP(slice(arguments), make)); + }, + "label": function(name, block) { + return add_spaces([ make_name(name), ":", make(block) ]); + }, + "with": function(expr, block) { + return add_spaces([ "with", "(" + make(expr) + ")", make(block) ]); + }, + "atom": function(name) { + return make_name(name); + } + }, function(){ return make(ast) }); + + // The squeezer replaces "block"-s that contain only a single + // statement with the statement itself; technically, the AST + // is correct, but this can create problems when we output an + // IF having an ELSE clause where the THEN clause ends in an + // IF *without* an ELSE block (then the outer ELSE would refer + // to the inner IF). This function checks for this case and + // adds the block brackets if needed. + function make_then(th) { + if (th[0] == "do") { + // https://github.com/mishoo/UglifyJS/issues/#issue/57 + // IE croaks with "syntax error" on code like this: + // if (foo) do ... while(cond); else ... + // we need block brackets around do/while + return make_block([ th ]); + } + var b = th; + while (true) { + var type = b[0]; + if (type == "if") { + if (!b[3]) + // no else, we must add the block + return make([ "block", [ th ]]); + b = b[3]; + } + else if (type == "while" || type == "do") b = b[2]; + else if (type == "for" || type == "for-in") b = b[4]; + else break; + } + return make(th); + }; + + function make_function(name, args, body, keyword) { + var out = keyword || "function"; + if (name) { + out += " " + make_name(name); + } + out += "(" + add_commas(MAP(args, make_name)) + ")"; + var result = add_spaces([ out, make_block(body) ]) + if (!name) result = "(" + result + ")"; + return result; + }; + + function must_has_semicolon(node) { + switch (node[0]) { + case "with": + case "while": + return empty(node[2]); // `with' or `while' with empty body? + case "for": + case "for-in": + return empty(node[4]); // `for' with empty body? + case "if": + if (empty(node[2]) && !node[3]) return true; // `if' with empty `then' and no `else' + if (node[3]) { + if (empty(node[3])) return true; // `else' present but empty + return must_has_semicolon(node[3]); // dive into the `else' branch + } + return must_has_semicolon(node[2]); // dive into the `then' branch + } + }; + + function make_block_statements(statements, noindent) { + for (var a = [], last = statements.length - 1, i = 0; i <= last; ++i) { + var stat = statements[i]; + var code = make(stat); + if (code != ";") { + if (!beautify && i == last && !must_has_semicolon(stat)) { + code = code.replace(/;+\s*$/, ""); + } + a.push(code); + } + } + return noindent ? a : MAP(a, indent); + }; + + function make_switch_block(body) { + var n = body.length; + if (n == 0) return "{}"; + return "{" + newline + MAP(body, function(branch, i){ + var has_body = branch[1].length > 0, code = with_indent(function(){ + return indent(branch[0] + ? add_spaces([ "case", make(branch[0]) + ":" ]) + : "default:"); + }, 0.5) + (has_body ? newline + with_indent(function(){ + return make_block_statements(branch[1]).join(newline); + }) : ""); + if (!beautify && has_body && i < n - 1) + code += ";"; + return code; + }).join(newline) + newline + indent("}"); + }; + + function make_block(statements) { + if (!statements) return ";"; + if (statements.length == 0) return "{}"; + return "{" + newline + with_indent(function(){ + return make_block_statements(statements).join(newline); + }) + newline + indent("}"); + }; + + function make_1vardef(def) { + var name = def[0], val = def[1]; + if (val != null) + name = add_spaces([ make_name(name), "=", parenthesize(val, "seq") ]); + return name; + }; -function split_lines(code, max_line_length) { - var splits = [ 0 ]; - jsp.parse(function(){ - var next_token = jsp.tokenizer(code); - var last_split = 0; - var prev_token; - function current_length(tok) { - return tok.pos - last_split; - }; - function split_here(tok) { - last_split = tok.pos; - splits.push(last_split); - }; - function custom(){ - var tok = next_token.apply(this, arguments); - out: { - if (prev_token) { - if (prev_token.type == "keyword") break out; - } - if (current_length(tok) > max_line_length) { - switch (tok.type) { - case "keyword": - case "atom": - case "name": - case "punc": - split_here(tok); - break out; - } - } - } - prev_token = tok; - return tok; - }; - custom.context = function() { - return next_token.context.apply(this, arguments); - }; - return custom; - }()); - return splits.map(function(pos, i){ - return code.substring(pos, splits[i + 1] || code.length); - }).join("\n"); }; /* -----[ Utilities ]----- */ function repeat_string(str, i) { - if (i <= 0) return ""; - if (i == 1) return str; - var d = repeat_string(str, i >> 1); - d += d; - if (i & 1) d += str; - return d; + if (i <= 0) return ""; + if (i == 1) return str; + var d = repeat_string(str, i >> 1); + d += d; + if (i & 1) d += str; + return d; }; function defaults(args, defs) { - var ret = {}; - if (args === true) - args = {}; - for (var i in defs) if (HOP(defs, i)) { - ret[i] = (args && HOP(args, i)) ? args[i] : defs[i]; - } - return ret; + var ret = {}; + if (args === true) + args = {}; + for (var i in defs) if (HOP(defs, i)) { + ret[i] = (args && HOP(args, i)) ? args[i] : defs[i]; + } + return ret; }; function is_identifier(name) { - return /^[a-z_$][a-z0-9_$]*$/i.test(name) - && name != "this" - && !HOP(jsp.KEYWORDS_ATOM, name) - && !HOP(jsp.RESERVED_WORDS, name) - && !HOP(jsp.KEYWORDS, name); + return /^[a-z_$][a-z0-9_$]*$/i.test(name) + && name != "this" + && !HOP(jsp.KEYWORDS_ATOM, name) + && !HOP(jsp.RESERVED_WORDS, name) + && !HOP(jsp.KEYWORDS, name); }; function HOP(obj, prop) { - return Object.prototype.hasOwnProperty.call(obj, prop); + return Object.prototype.hasOwnProperty.call(obj, prop); }; // some utilities @@ -1903,49 +835,41 @@ function HOP(obj, prop) { var MAP; (function(){ - MAP = function(a, f, o) { - var ret = [], top = [], i; - function doit() { - var val = f.call(o, a[i], i); - if (val instanceof AtTop) { - val = val.v; - if (val instanceof Splice) { - top.push.apply(top, val.v); - } else { - top.push(val); - } - } - else if (val != skip) { - if (val instanceof Splice) { - ret.push.apply(ret, val.v); - } else { - ret.push(val); - } - } - }; - if (a instanceof Array) for (i = 0; i < a.length; ++i) doit(); - else for (i in a) if (HOP(a, i)) doit(); - return top.concat(ret); - }; - MAP.at_top = function(val) { return new AtTop(val) }; - MAP.splice = function(val) { return new Splice(val) }; - var skip = MAP.skip = {}; - function AtTop(val) { this.v = val }; - function Splice(val) { this.v = val }; + MAP = function(a, f, o) { + var ret = [], top = [], i; + function doit() { + var val = f.call(o, a[i], i); + if (val instanceof AtTop) { + val = val.v; + if (val instanceof Splice) { + top.push.apply(top, val.v); + } else { + top.push(val); + } + } + else if (val != skip) { + if (val instanceof Splice) { + ret.push.apply(ret, val.v); + } else { + ret.push(val); + } + } + }; + if (a instanceof Array) for (i = 0; i < a.length; ++i) doit(); + else for (i in a) if (HOP(a, i)) doit(); + return top.concat(ret); + }; + MAP.at_top = function(val) { return new AtTop(val) }; + MAP.splice = function(val) { return new Splice(val) }; + var skip = MAP.skip = {}; + function AtTop(val) { this.v = val }; + function Splice(val) { this.v = val }; })(); /* -----[ Exports ]----- */ exports.ast_walker = ast_walker; -exports.ast_mangle = ast_mangle; -exports.ast_squeeze = ast_squeeze; -exports.ast_lift_variables = ast_lift_variables; exports.gen_code = gen_code; -exports.ast_add_scope = ast_add_scope; exports.set_logger = function(logger) { warn = logger }; exports.make_string = make_string; -exports.split_lines = split_lines; exports.MAP = MAP; - -// keep this last! -exports.ast_squeeze_more = require("./squeeze-more").ast_squeeze_more; From 0f73e28bab1c1b8caa8f7b77692bebd705bebe6a Mon Sep 17 00:00:00 2001 From: Jez Ng Date: Wed, 19 Jun 2013 04:53:35 -0700 Subject: [PATCH 15/69] Map source lines for assignment statements. --- .../node_modules/uglify-js/lib/process.js | 29 +++++++++++++++---- tools/js-optimizer.js | 1 + 2 files changed, 24 insertions(+), 6 deletions(-) diff --git a/tools/eliminator/node_modules/uglify-js/lib/process.js b/tools/eliminator/node_modules/uglify-js/lib/process.js index 70a4b0a43e291..660001aabb85b 100644 --- a/tools/eliminator/node_modules/uglify-js/lib/process.js +++ b/tools/eliminator/node_modules/uglify-js/lib/process.js @@ -58,6 +58,18 @@ var jsp = require("./parse-js"), PRECEDENCE = jsp.PRECEDENCE, OPERATORS = jsp.OPERATORS; +function NodeWithLine(str, line) { + this.str = str; + this.line = line; +} + +NodeWithLine.prototype = new String(); +NodeWithLine.prototype.toString = function() { return this.str; } +NodeWithLine.prototype.lineComment = function() { return " // @line " + this.line; } + +// XXX ugly hack +String.prototype.lineComment = function() { return ""; } + /* -----[ helper for AST traversal ]----- */ function ast_walker() { @@ -339,6 +351,7 @@ var SPLICE_NEEDS_BRACKETS = jsp.array_to_hash([ "if", "while", "do", "for", "for function gen_code(ast, options) { options = defaults(options, { + debug: false, indent_start : 0, indent_level : 4, quote_keys : false, @@ -470,8 +483,7 @@ function gen_code(ast, options) { "num": make_num, "name": make_name, "toplevel": function(statements) { - return make_block_statements(statements) - .join(newline + newline); + return make_block_statements(statements).join(newline + newline); }, "splice": function(statements) { var parent = w.parent(); @@ -542,7 +554,10 @@ function gen_code(ast, options) { "assign": function(op, lvalue, rvalue) { if (op && op !== true) op += "="; else op = "="; - return add_spaces([ make(lvalue), op, parenthesize(rvalue, "seq") ]); + var s = add_spaces([ make(lvalue), op, parenthesize(rvalue, "seq") ]); + if (options.debug && lvalue[0].start) + return new NodeWithLine(s, lvalue[0].start.line); + return s; }, "dot": function(expr) { var out = make(expr), i = 1; @@ -596,8 +611,9 @@ function gen_code(ast, options) { }, "return": function(expr) { var out = [ "return" ]; - if (expr != null) out.push(make(expr)); - return add_spaces(out) + ";"; + var str = make(expr); + if (expr != null) out.push(str); + return add_spaces(out) + ";" + str.lineComment(); }, "binary": function(operator, lvalue, rvalue) { var left = make(lvalue), right = make(rvalue); @@ -673,7 +689,8 @@ function gen_code(ast, options) { })), "]" ]); }, "stat": function(stmt) { - return make(stmt).replace(/;*\s*$/, ";"); + var str = make(stmt); + return str.replace(/;*\s*$/, ";") + str.lineComment(); }, "seq": function() { return add_commas(MAP(slice(arguments), make)); diff --git a/tools/js-optimizer.js b/tools/js-optimizer.js index 21ce54a89079c..f86bb0d6e4604 100644 --- a/tools/js-optimizer.js +++ b/tools/js-optimizer.js @@ -152,6 +152,7 @@ function srcToAst(src) { function astToSrc(ast, compress) { return uglify.uglify.gen_code(ast, { + debug: debug, ascii_only: true, beautify: !compress, indent_level: 2 From 54a59bee849be1da0c6d1de0dc4a6a73744c6d04 Mon Sep 17 00:00:00 2001 From: Jez Ng Date: Wed, 19 Jun 2013 05:08:43 -0700 Subject: [PATCH 16/69] Move source mapping files into their own folder. --- emcc | 2 +- tests/runner.py | 2 +- tools/{ => source-maps}/sourcemap2json.js | 0 tools/{ => source-maps}/sourcemapper.js | 0 4 files changed, 2 insertions(+), 2 deletions(-) rename tools/{ => source-maps}/sourcemap2json.js (100%) rename tools/{ => source-maps}/sourcemapper.js (100%) diff --git a/emcc b/emcc index 8f9d195c65cda..423ebe912b0df 100755 --- a/emcc +++ b/emcc @@ -1587,7 +1587,7 @@ try: logging.debug('did not see memory initialization') def generate_source_map(filename, map_file_base_name, offset=0): - jsrun.run_js(shared.path_from_root('tools', 'sourcemapper.js'), + jsrun.run_js(shared.path_from_root('tools', 'source-maps', 'sourcemapper.js'), shared.NODE_JS, [filename, os.getcwd(), map_file_base_name, str(offset)]) # If we were asked to also generate HTML, do that diff --git a/tests/runner.py b/tests/runner.py index b3cfd1ae5f882..63f5048a8ddbf 100755 --- a/tests/runner.py +++ b/tests/runner.py @@ -9614,7 +9614,7 @@ def post(filename): self.assertIdentical(src_filename, data['sources'][0]) self.assertIdentical(src, data['sourcesContent'][0]) mappings = json.loads(jsrun.run_js( - path_from_root('tools', 'sourcemap2json.js'), + path_from_root('tools', 'source-maps', 'sourcemap2json.js'), tools.shared.NODE_JS, [map_filename])) seen_lines = set() for m in mappings: diff --git a/tools/sourcemap2json.js b/tools/source-maps/sourcemap2json.js similarity index 100% rename from tools/sourcemap2json.js rename to tools/source-maps/sourcemap2json.js diff --git a/tools/sourcemapper.js b/tools/source-maps/sourcemapper.js similarity index 100% rename from tools/sourcemapper.js rename to tools/source-maps/sourcemapper.js From 050335fd91a09cde7ccea9f1fc0ecf536918b95a Mon Sep 17 00:00:00 2001 From: Jez Ng Date: Wed, 19 Jun 2013 05:08:58 -0700 Subject: [PATCH 17/69] Update the source-map library. --- .../lib/source-map/source-map-consumer.js | 14 ++++++---- .../source-map/lib/source-map/util.js | 28 ++++++++++++++++++- .../node_modules/amdefine/package.json | 9 +----- tools/node_modules/source-map/package.json | 13 ++------- .../source-map/test-source-map-consumer.js | 15 ++++++++++ 5 files changed, 55 insertions(+), 24 deletions(-) diff --git a/tools/node_modules/source-map/lib/source-map/source-map-consumer.js b/tools/node_modules/source-map/lib/source-map/source-map-consumer.js index 9da6f1c61e515..e7b3538e9e485 100644 --- a/tools/node_modules/source-map/lib/source-map/source-map-consumer.js +++ b/tools/node_modules/source-map/lib/source-map/source-map-consumer.js @@ -309,17 +309,21 @@ define(function (require, exports, module) { } if (this.sourceRoot) { - // Try to remove the sourceRoot - var relativeUrl = util.relative(this.sourceRoot, aSource); - if (this._sources.has(relativeUrl)) { - return this.sourcesContent[this._sources.indexOf(relativeUrl)]; - } + aSource = util.relative(this.sourceRoot, aSource); } if (this._sources.has(aSource)) { return this.sourcesContent[this._sources.indexOf(aSource)]; } + var url; + if (this.sourceRoot + && (url = util.urlParse(this.sourceRoot)) + && (!url.path || url.path == "/") + && this._sources.has("/" + aSource)) { + return this.sourcesContent[this._sources.indexOf("/" + aSource)]; + } + throw new Error('"' + aSource + '" is not in the SourceMap.'); }; diff --git a/tools/node_modules/source-map/lib/source-map/util.js b/tools/node_modules/source-map/lib/source-map/util.js index d59b25743a0ec..af5c58b42ed51 100644 --- a/tools/node_modules/source-map/lib/source-map/util.js +++ b/tools/node_modules/source-map/lib/source-map/util.js @@ -45,6 +45,25 @@ define(function (require, exports, module) { path: match[7] }; } + exports.urlParse = urlParse; + + function urlGenerate(aParsedUrl) { + var url = aParsedUrl.scheme + "://"; + if (aParsedUrl.auth) { + url += aParsedUrl.auth + "@" + } + if (aParsedUrl.host) { + url += aParsedUrl.host; + } + if (aParsedUrl.port) { + url += ":" + aParsedUrl.port + } + if (aParsedUrl.path) { + url += aParsedUrl.path; + } + return url; + } + exports.urlGenerate = urlGenerate; function join(aRoot, aPath) { var url; @@ -54,7 +73,8 @@ define(function (require, exports, module) { } if (aPath.charAt(0) === '/' && (url = urlParse(aRoot))) { - return aRoot.replace(url.path, '') + aPath; + url.path = aPath; + return urlGenerate(url); } return aRoot.replace(/\/$/, '') + '/' + aPath; @@ -82,6 +102,12 @@ define(function (require, exports, module) { function relative(aRoot, aPath) { aRoot = aRoot.replace(/\/$/, ''); + + var url = urlParse(aRoot); + if (aPath.charAt(0) == "/" && url && url.path == "/") { + return aPath.slice(1); + } + return aPath.indexOf(aRoot + '/') === 0 ? aPath.substr(aRoot.length + 1) : aPath; diff --git a/tools/node_modules/source-map/node_modules/amdefine/package.json b/tools/node_modules/source-map/node_modules/amdefine/package.json index 549197a6a659e..87ac416328333 100644 --- a/tools/node_modules/source-map/node_modules/amdefine/package.json +++ b/tools/node_modules/source-map/node_modules/amdefine/package.json @@ -28,13 +28,6 @@ }, "readme": "# amdefine\n\nA module that can be used to implement AMD's define() in Node. This allows you\nto code to the AMD API and have the module work in node programs without\nrequiring those other programs to use AMD.\n\n## Usage\n\n**1)** Update your package.json to indicate amdefine as a dependency:\n\n```javascript\n \"dependencies\": {\n \"amdefine\": \">=0.0.5\"\n }\n```\n\nThen run `npm install` to get amdefine into your project.\n\n**2)** At the top of each module that uses define(), place this code:\n\n```javascript\nif (typeof define !== 'function') { var define = require('amdefine')(module) }\n```\n\n**Only use these snippets** when loading amdefine. If you preserve the basic structure,\nwith the braces, it will be stripped out when using the [RequireJS optimizer](#optimizer).\n\nYou can add spaces, line breaks and even require amdefine with a local path, but\nkeep the rest of the structure to get the stripping behavior.\n\nAs you may know, because `if` statements in JavaScript don't have their own scope, the var\ndeclaration in the above snippet is made whether the `if` expression is truthy or not. If\nRequireJS is loaded then the declaration is superfluous because `define` is already already\ndeclared in the same scope in RequireJS. Fortunately JavaScript handles multiple `var`\ndeclarations of the same variable in the same scope gracefully.\n\nIf you want to deliver amdefine.js with your code rather than specifying it as a dependency\nwith npm, then just download the latest release and refer to it using a relative path:\n\n[Latest Version](https://github.com/jrburke/amdefine/raw/latest/amdefine.js)\n\n## define() usage\n\nIt is best if you use the anonymous forms of define() in your module:\n\n```javascript\ndefine(function (require) {\n var dependency = require('dependency');\n});\n```\n\nor\n\n```javascript\ndefine(['dependency'], function (dependency) {\n\n});\n```\n\n## RequireJS optimizer integration. \n\nVersion 1.0.3 of the [RequireJS optimizer](http://requirejs.org/docs/optimization.html)\nwill have support for stripping the `if (typeof define !== 'function')` check\nmentioned above, so you can include this snippet for code that runs in the\nbrowser, but avoid taking the cost of the if() statement once the code is\noptimized for deployment.\n\n## Node 0.4 Support\n\nIf you want to support Node 0.4, then add `require` as the second parameter to amdefine:\n\n```javascript\n//Only if you want Node 0.4. If using 0.5 or later, use the above snippet.\nif (typeof define !== 'function') { var define = require('amdefine')(module, require) }\n```\n\n## Limitations\n\n### Synchronous vs Asynchronous\n\namdefine creates a define() function that is callable by your code. It will\nexecute and trace dependencies and call the factory function *synchronously*,\nto keep the behavior in line with Node's synchronous dependency tracing.\n\nThe exception: calling AMD's callback-style require() from inside a factory\nfunction. The require callback is called on process.nextTick():\n\n```javascript\ndefine(function (require) {\n require(['a'], function(a) {\n //'a' is loaded synchronously, but\n //this callback is called on process.nextTick().\n });\n});\n```\n\n### Loader Plugins\n\nLoader plugins are supported as long as they call their load() callbacks\nsynchronously. So ones that do network requests will not work. However plugins\nlike [text](http://requirejs.org/docs/api.html#text) can load text files locally.\n\nThe plugin API's `load.fromText()` is **not supported** in amdefine, so this means\ntranspiler plugins like the [CoffeeScript loader plugin](https://github.com/jrburke/require-cs)\nwill not work. This may be fixable, but it is a bit complex, and I do not have\nenough node-fu to figure it out yet. See the source for amdefine.js if you want\nto get an idea of the issues involved.\n\n## Tests\n\nTo run the tests, cd to **tests** and run:\n\n```\nnode all.js\n```\n\n## License\n\nNew BSD and MIT. Check the LICENSE file for all the details.\n", "readmeFilename": "README.md", - "bugs": { - "url": "https://github.com/jrburke/amdefine/issues" - }, "_id": "amdefine@0.0.5", - "dist": { - "shasum": "86b6e9470f8cde955ef7daa3cf5d544ba81aa3db" - }, - "_from": "amdefine@>=0.0.4", - "_resolved": "https://registry.npmjs.org/amdefine/-/amdefine-0.0.5.tgz" + "_from": "amdefine@>=0.0.4" } diff --git a/tools/node_modules/source-map/package.json b/tools/node_modules/source-map/package.json index 4d2e37253649e..730e042ed2b23 100644 --- a/tools/node_modules/source-map/package.json +++ b/tools/node_modules/source-map/package.json @@ -1,7 +1,7 @@ { "name": "source-map", "description": "Generates and consumes source maps", - "version": "0.1.22", + "version": "0.1.23", "homepage": "https://github.com/mozilla/source-map", "author": { "name": "Nick Fitzgerald", @@ -69,13 +69,6 @@ }, "readme": "# Source Map\n\nThis is a library to generate and consume the source map format\n[described here][format].\n\n[Learn more here][feature].\n\nThis library was written in the Asynchronous Module Definition\nformat. It should work in the following environments:\n\n* Modern Browsers (either after the build, or with an AMD loader such as\n RequireJS)\n\n* Inside Firefox (as a JSM file, after the build)\n\n* With NodeJS versions 0.8.X and higher\n\n## Installing with NPM (for use with NodeJS)\n\nSimply\n\n $ npm install source-map\n\nOr, if you'd like to hack on this library and have it installed via npm so you\ncan try out your changes:\n\n $ git clone https://fitzgen@github.com/mozilla/source-map.git\n $ cd source-map\n $ npm link .\n\n## Building from Source (for everywhere else)\n\nInstall Node and then run\n\n $ git clone https://fitzgen@github.com/mozilla/source-map.git\n $ cd source-map\n $ npm link .\n\nNext, run\n\n $ node Makefile.dryice.js`\n\nThis should create the following files:\n\n* `dist/source-map.js` - The unminified browser version.\n\n* `dist/source-map.min.js` - The minified browser version.\n\n* `dist/SourceMap.jsm` - The JavaScript Module for inclusion in Firefox\n source.\n\n## API\n\nGet a reference to the module:\n\n // NodeJS\n var sourceMap = require('source-map');\n\n // Browser builds\n var sourceMap = window.sourceMap;\n\n // Inside Firefox\n let sourceMap = {};\n Components.utils.import('resource:///modules/devtools/SourceMap.jsm', sourceMap);\n\n### SourceMapConsumer\n\nA SourceMapConsumer instance represents a parsed source map which we can query\nfor information about the original file positions by giving it a file position\nin the generated source.\n\n#### new SourceMapConsumer(rawSourceMap)\n\nThe only parameter is the raw source map (either as a string which can be\n`JSON.parse`'d, or an object). According to the spec, source maps have the\nfollowing attributes:\n\n* `version`: Which version of the source map spec this map is following.\n\n* `sources`: An array of URLs to the original source files.\n\n* `names`: An array of identifiers which can be referrenced by individual\n mappings.\n\n* `sourceRoot`: Optional. The URL root from which all sources are relative.\n\n* `sourcesContent`: Optional. An array of contents of the original source files.\n\n* `mappings`: A string of base64 VLQs which contain the actual mappings.\n\n* `file`: The generated filename this source map is associated with.\n\n#### SourceMapConsumer.prototype.originalPositionFor(generatedPosition)\n\nReturns the original source, line, and column information for the generated\nsource's line and column positions provided. The only argument is an object with\nthe following properties:\n\n* `line`: The line number in the generated source.\n\n* `column`: The column number in the generated source.\n\nand an object is returned with the following properties:\n\n* `source`: The original source file, or null if this information is not\n available.\n\n* `line`: The line number in the original source, or null if this information is\n not available.\n\n* `column`: The column number in the original source, or null or null if this\n information is not available.\n\n* `name`: The original identifier, or null if this information is not available.\n\n#### SourceMapConsumer.prototype.generatedPositionFor(originalPosition)\n\nReturns the generated line and column information for the original source,\nline, and column positions provided. The only argument is an object with\nthe following properties:\n\n* `source`: The filename of the original source.\n\n* `line`: The line number in the original source.\n\n* `column`: The column number in the original source.\n\nand an object is returned with the following properties:\n\n* `line`: The line number in the generated source, or null.\n\n* `column`: The column number in the generated source, or null.\n\n#### SourceMapConsumer.prototype.sourceContentFor(source)\n\nReturns the original source content for the source provided. The only\nargument is the URL of the original source file.\n\n#### SourceMapConsumer.prototype.eachMapping(callback, context, order)\n\nIterate over each mapping between an original source/line/column and a\ngenerated line/column in this source map.\n\n* `callback`: The function that is called with each mapping.\n\n* `context`: Optional. If specified, this object will be the value of `this`\n every time that `callback` is called.\n\n* `order`: Either `SourceMapConsumer.GENERATED_ORDER` or\n `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to iterate over\n the mappings sorted by the generated file's line/column order or the\n original's source/line/column order, respectively. Defaults to\n `SourceMapConsumer.GENERATED_ORDER`.\n\n### SourceMapGenerator\n\nAn instance of the SourceMapGenerator represents a source map which is being\nbuilt incrementally.\n\n#### new SourceMapGenerator(startOfSourceMap)\n\nTo create a new one, you must pass an object with the following properties:\n\n* `file`: The filename of the generated source that this source map is\n associated with.\n\n* `sourceRoot`: An optional root for all relative URLs in this source map.\n\n#### SourceMapGenerator.fromSourceMap(sourceMapConsumer)\n\nCreates a new SourceMapGenerator based on a SourceMapConsumer\n\n* `sourceMapConsumer` The SourceMap.\n\n#### SourceMapGenerator.prototype.addMapping(mapping)\n\nAdd a single mapping from original source line and column to the generated\nsource's line and column for this source map being created. The mapping object\nshould have the following properties:\n\n* `generated`: An object with the generated line and column positions.\n\n* `original`: An object with the original line and column positions.\n\n* `source`: The original source file (relative to the sourceRoot).\n\n* `name`: An optional original token name for this mapping.\n\n#### SourceMapGenerator.prototype.setSourceContent(sourceFile, sourceContent)\n\nSet the source content for an original source file.\n\n* `sourceFile` the URL of the original source file.\n\n* `sourceContent` the content of the source file.\n\n#### SourceMapGenerator.prototype.applySourceMap(sourceMapConsumer[, sourceFile])\n\nApplies a SourceMap for a source file to the SourceMap.\nEach mapping to the supplied source file is rewritten using the\nsupplied SourceMap. Note: The resolution for the resulting mappings\nis the minimium of this map and the supplied map.\n\n* `sourceMapConsumer`: The SourceMap to be applied.\n\n* `sourceFile`: Optional. The filename of the source file.\n If omitted, sourceMapConsumer.file will be used.\n\n#### SourceMapGenerator.prototype.toString()\n\nRenders the source map being generated to a string.\n\n### SourceNode\n\nSourceNodes provide a way to abstract over interpolating and/or concatenating\nsnippets of generated JavaScript source code, while maintaining the line and\ncolumn information associated between those snippets and the original source\ncode. This is useful as the final intermediate representation a compiler might\nuse before outputting the generated JS and source map.\n\n#### new SourceNode(line, column, source[, chunk[, name]])\n\n* `line`: The original line number associated with this source node, or null if\n it isn't associated with an original line.\n\n* `column`: The original column number associated with this source node, or null\n if it isn't associated with an original column.\n\n* `source`: The original source's filename.\n\n* `chunk`: Optional. Is immediately passed to `SourceNode.prototype.add`, see\n below.\n\n* `name`: Optional. The original identifier.\n\n#### SourceNode.fromStringWithSourceMap(code, sourceMapConsumer)\n\nCreates a SourceNode from generated code and a SourceMapConsumer.\n\n* `code`: The generated code\n\n* `sourceMapConsumer` The SourceMap for the generated code\n\n#### SourceNode.prototype.add(chunk)\n\nAdd a chunk of generated JS to this source node.\n\n* `chunk`: A string snippet of generated JS code, another instance of\n `SourceNode`, or an array where each member is one of those things.\n\n#### SourceNode.prototype.prepend(chunk)\n\nPrepend a chunk of generated JS to this source node.\n\n* `chunk`: A string snippet of generated JS code, another instance of\n `SourceNode`, or an array where each member is one of those things.\n\n#### SourceNode.prototype.setSourceContent(sourceFile, sourceContent)\n\nSet the source content for a source file. This will be added to the\n`SourceMap` in the `sourcesContent` field.\n\n* `sourceFile`: The filename of the source file\n\n* `sourceContent`: The content of the source file\n\n#### SourceNode.prototype.walk(fn)\n\nWalk over the tree of JS snippets in this node and its children. The walking\nfunction is called once for each snippet of JS and is passed that snippet and\nthe its original associated source's line/column location.\n\n* `fn`: The traversal function.\n\n#### SourceNode.prototype.walkSourceContents(fn)\n\nWalk over the tree of SourceNodes. The walking function is called for each\nsource file content and is passed the filename and source content.\n\n* `fn`: The traversal function.\n\n#### SourceNode.prototype.join(sep)\n\nLike `Array.prototype.join` except for SourceNodes. Inserts the separator\nbetween each of this source node's children.\n\n* `sep`: The separator.\n\n#### SourceNode.prototype.replaceRight(pattern, replacement)\n\nCall `String.prototype.replace` on the very right-most source snippet. Useful\nfor trimming whitespace from the end of a source node, etc.\n\n* `pattern`: The pattern to replace.\n\n* `replacement`: The thing to replace the pattern with.\n\n#### SourceNode.prototype.toString()\n\nReturn the string representation of this source node. Walks over the tree and\nconcatenates all the various snippets together to one string.\n\n### SourceNode.prototype.toStringWithSourceMap(startOfSourceMap)\n\nReturns the string representation of this tree of source nodes, plus a\nSourceMapGenerator which contains all the mappings between the generated and\noriginal sources.\n\nThe arguments are the same as those to `new SourceMapGenerator`.\n\n## Tests\n\n[![Build Status](https://travis-ci.org/mozilla/source-map.png?branch=master)](https://travis-ci.org/mozilla/source-map)\n\nInstall NodeJS version 0.8.0 or greater, then run `node test/run-tests.js`.\n\nTo add new tests, create a new file named `test/test-.js`\nand export your test functions with names that start with \"test\", for example\n\n exports[\"test doing the foo bar\"] = function (assert, util) {\n ...\n };\n\nThe new test will be located automatically when you run the suite.\n\nThe `util` argument is the test utility module located at `test/source-map/util`.\n\nThe `assert` argument is a cut down version of node's assert module. You have\naccess to the following assertion functions:\n\n* `doesNotThrow`\n\n* `equal`\n\n* `ok`\n\n* `strictEqual`\n\n* `throws`\n\n(The reason for the restricted set of test functions is because we need the\ntests to run inside Firefox's test suite as well and so the assert module is\nshimmed in that environment. See `build/assert-shim.js`.)\n\n[format]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit\n[feature]: https://wiki.mozilla.org/DevTools/Features/SourceMap\n[Dryice]: https://github.com/mozilla/dryice\n", "readmeFilename": "README.md", - "bugs": { - "url": "https://github.com/mozilla/source-map/issues" - }, - "_id": "source-map@0.1.22", - "dist": { - "shasum": "9fae7473bfa775de276dc258aa265802478a3db9" - }, - "_from": "source-map@", - "_resolved": "https://registry.npmjs.org/source-map/-/source-map-0.1.22.tgz" + "_id": "source-map@0.1.23", + "_from": "source-map@" } diff --git a/tools/node_modules/source-map/test/source-map/test-source-map-consumer.js b/tools/node_modules/source-map/test/source-map/test-source-map-consumer.js index 610d4635e0fe1..2f9a23d0ff218 100644 --- a/tools/node_modules/source-map/test/source-map/test-source-map-consumer.js +++ b/tools/node_modules/source-map/test/source-map/test-source-map-consumer.js @@ -288,4 +288,19 @@ define(function (require, exports, module) { 'Source should be relative the host of the source root.'); }; + exports['test github issue #64'] = function (assert, util) { + var map = new SourceMapConsumer({ + "version": 3, + "file": "foo.js", + "sourceRoot": "http://example.com/", + "sources": ["/a"], + "names": [], + "mappings": "AACA", + "sourcesContent": ["foo"] + }); + + assert.equal(map.sourceContentFor("a"), "foo"); + assert.equal(map.sourceContentFor("/a"), "foo"); + }; + }); From d680f5e81b4bae6cbc46ba04b24c5809679d0bcc Mon Sep 17 00:00:00 2001 From: Jez Ng Date: Wed, 19 Jun 2013 11:22:35 -0700 Subject: [PATCH 18/69] Implement source maps for optimized builds. --- emcc | 22 +++- tests/runner.py | 14 +-- .../node_modules/uglify-js/lib/process.js | 34 ++++-- tools/source-maps/sourcemapper.js | 106 +++++++++++++----- 4 files changed, 130 insertions(+), 46 deletions(-) diff --git a/emcc b/emcc index 423ebe912b0df..2b2048e3fdf49 100755 --- a/emcc +++ b/emcc @@ -1477,6 +1477,7 @@ try: open(final, 'w').write(src) if DEBUG: save_intermediate('bind') + # TODO: support source maps with js_transform # Apply a source code transformation, if requested if js_transform: shutil.copyfile(final, final + '.tr.js') @@ -1486,6 +1487,8 @@ try: execute(shlex.split(js_transform, posix=posix) + [os.path.abspath(final)]) if DEBUG: save_intermediate('transformed') + js_transform_tempfiles = [final] + # It is useful to run several js optimizer passes together, to save on unneeded unparsing/reparsing js_optimizer_queue = [] def flush_js_optimizer_queue(): @@ -1497,6 +1500,7 @@ try: logging.debug('applying js optimization passes: %s', js_optimizer_queue) final = shared.Building.js_optimizer(final, js_optimizer_queue, jcache, keep_llvm_debug and keep_js_debug) + js_transform_tempfiles.append(final) if DEBUG: save_intermediate('js_opts') else: for name in js_optimizer_queue: @@ -1506,6 +1510,7 @@ try: logging.debug('applying js optimization pass: %s', passes) final = shared.Building.js_optimizer(final, passes, jcache, keep_llvm_debug and keep_js_debug) + js_transform_tempfiles.append(final) save_intermediate(name) js_optimizer_queue = [] @@ -1514,7 +1519,8 @@ try: if DEBUG == '2': # Clean up the syntax a bit - final = shared.Building.js_optimizer(final, [], jcache) + final = shared.Building.js_optimizer(final, [], jcache, + keep_llvm_debug and keep_js_debug) if DEBUG: save_intermediate('pretty') def get_eliminate(): @@ -1532,6 +1538,8 @@ try: flush_js_optimizer_queue() logging.debug('running closure') + # no need to add this to js_transform_tempfiles, because closure and + # keep_js_debug are never simultaneously true final = shared.Building.closure_compiler(final) if DEBUG: save_intermediate('closure') @@ -1579,6 +1587,7 @@ try: src = re.sub('/\* memory initializer \*/ allocate\(([\d,\.concat\(\)\[\]\\n ]+)"i8", ALLOC_NONE, Runtime\.GLOBAL_BASE\)', repl, src, count=1) open(final + '.mem.js', 'w').write(src) final += '.mem.js' + js_transform_tempfiles[-1] = final # simple text substitution preserves comment line number mappings if DEBUG: if os.path.exists(memfile): save_intermediate('meminit') @@ -1586,9 +1595,12 @@ try: else: logging.debug('did not see memory initialization') - def generate_source_map(filename, map_file_base_name, offset=0): + def generate_source_map(map_file_base_name, offset=0): jsrun.run_js(shared.path_from_root('tools', 'source-maps', 'sourcemapper.js'), - shared.NODE_JS, [filename, os.getcwd(), map_file_base_name, str(offset)]) + shared.NODE_JS, js_transform_tempfiles + + ['--sourceRoot', os.getcwd(), + '--mapFileBaseName', map_file_base_name, + '--offset', str(offset)]) # If we were asked to also generate HTML, do that if final_suffix == 'html': @@ -1601,7 +1613,7 @@ try: re.DOTALL) if match is None: raise RuntimeError('Could not find script insertion point') - generate_source_map(final, target, match.group().count('\n')) + generate_source_map(target, match.group().count('\n')) html.write(shell.replace('{{{ SCRIPT_CODE }}}', open(final).read())) else: # Compress the main code @@ -1672,7 +1684,7 @@ try: from tools.split import split_javascript_file split_javascript_file(final, unsuffixed(target), split_js_file) else: - if keep_llvm_debug and keep_js_debug: generate_source_map(final, target) + if keep_llvm_debug and keep_js_debug: generate_source_map(target) # copy final JS to output shutil.move(final, target) diff --git a/tests/runner.py b/tests/runner.py index 63f5048a8ddbf..1697294d910dd 100755 --- a/tests/runner.py +++ b/tests/runner.py @@ -9585,21 +9585,21 @@ def process(filename): assert 'Assertion failed' in str(e), str(e) def test_source_map(self): + if Settings.USE_TYPED_ARRAYS != 2: return self.skip("doesn't pass without typed arrays") if '-g' not in Building.COMPILER_TEST_OPTS: Building.COMPILER_TEST_OPTS.append('-g') - if self.emcc_args is not None: - if '-O1' in self.emcc_args or '-O2' in self.emcc_args: return self.skip('optimizations remove LLVM debug info') src = ''' #include #include - int foo() { - return 1; // line 6 + __attribute__((noinline)) int foo() { + printf("hi"); // line 6 + return 1; // line 7 } int main() { - int i = foo(); // line 10 - return 0; // line 11 + printf("%d", foo()); // line 11 + return 0; // line 12 } ''' @@ -9621,7 +9621,7 @@ def post(filename): self.assertIdentical(src_filename, m['source']) seen_lines.add(m['originalLine']) # ensure that all the 'meaningful' lines in the original code get mapped - assert seen_lines.issuperset([6, 10, 11]) + assert seen_lines.issuperset([6, 7, 11, 12]) self.build(src, dirname, src_filename, post_build=(None,post)) diff --git a/tools/eliminator/node_modules/uglify-js/lib/process.js b/tools/eliminator/node_modules/uglify-js/lib/process.js index 660001aabb85b..39ccde37ac38d 100644 --- a/tools/eliminator/node_modules/uglify-js/lib/process.js +++ b/tools/eliminator/node_modules/uglify-js/lib/process.js @@ -65,6 +65,7 @@ function NodeWithLine(str, line) { NodeWithLine.prototype = new String(); NodeWithLine.prototype.toString = function() { return this.str; } +NodeWithLine.prototype.valueOf = function() { return this.str; } NodeWithLine.prototype.lineComment = function() { return " // @line " + this.line; } // XXX ugly hack @@ -473,7 +474,10 @@ function gen_code(ast, options) { a.push(m[2] + "e-" + (m[1].length + m[2].length), str.substr(str.indexOf("."))); } - return best_of(a); + var best = best_of(a); + if (options.debug && this[0].start) + return new NodeWithLine(best, this[0].start.line); + return best; }; var w = ast_walker(); @@ -499,7 +503,16 @@ function gen_code(ast, options) { }, "block": make_block, "var": function(defs) { - return "var " + add_commas(MAP(defs, make_1vardef)) + ";"; + var s = "var " + add_commas(MAP(defs, make_1vardef)) + ";"; + if (options.debug) { + // hack: we don't support mapping one optimized line to more than one + // generated line, so in case of multiple comma-separated var definitions, + // just take the first + if (defs[0][1] && defs[0][1][0] && defs[0][1][0].start) { + return s + (new NodeWithLine(s, defs[0][1][0].start.line)).lineComment(); + } + } + return s; }, "const": function(defs) { return "const " + add_commas(MAP(defs, make_1vardef)) + ";"; @@ -555,8 +568,8 @@ function gen_code(ast, options) { if (op && op !== true) op += "="; else op = "="; var s = add_spaces([ make(lvalue), op, parenthesize(rvalue, "seq") ]); - if (options.debug && lvalue[0].start) - return new NodeWithLine(s, lvalue[0].start.line); + if (options.debug && this[0].start) + return new NodeWithLine(s, this[0].start.line); return s; }, "dot": function(expr) { @@ -574,9 +587,12 @@ function gen_code(ast, options) { var f = make(func); if (needs_parens(func)) f = "(" + f + ")"; - return f + "(" + add_commas(MAP(args, function(expr){ + var str = f + "(" + add_commas(MAP(args, function(expr){ return parenthesize(expr, "seq"); })) + ")"; + if (options.debug && this[0].start) + return new NodeWithLine(str, this[0].start.line) + return str; }, "function": make_function, "defun": make_function, @@ -613,7 +629,7 @@ function gen_code(ast, options) { var out = [ "return" ]; var str = make(expr); if (expr != null) out.push(str); - return add_spaces(out) + ";" + str.lineComment(); + return add_spaces(out) + ";" + (str ? str.lineComment() : ''); }, "binary": function(operator, lvalue, rvalue) { var left = make(lvalue), right = make(rvalue); @@ -633,7 +649,11 @@ function gen_code(ast, options) { && rvalue[0] == "regexp" && /^script/i.test(rvalue[1])) { right = " " + right; } - return add_spaces([ left, operator, right ]); + var tok = this[0]; + var str = add_spaces([ left, operator, right ]); + if (options.debug && tok.start) + return new NodeWithLine(str, tok.start.line); + return str; }, "unary-prefix": function(operator, expr) { var val = make(expr); diff --git a/tools/source-maps/sourcemapper.js b/tools/source-maps/sourcemapper.js index c7021a0fb941e..ba993aa1f6f07 100755 --- a/tools/source-maps/sourcemapper.js +++ b/tools/source-maps/sourcemapper.js @@ -2,6 +2,9 @@ "use strict"; +var fs = require('fs'); +var path = require('path'); + function countLines(s) { var count = 0; for (var i = 0, l = s.length; i < l; i ++) { @@ -63,21 +66,39 @@ function extractComments(source, commentHandler) { } } -function generateMap(fileName, sourceRoot, mapFileBaseName, generatedLineOffset) { - var fs = require('fs'); - var path = require('path'); +function getMappings(source) { + // generatedLineNumber -> { originalLineNumber, originalFileName } + var mappings = {}; + extractComments(source, function(content, generatedLineNumber) { + var matches = /@line (\d+)(?: "([^"]*)")?/.exec(content); + if (matches === null) return; + var originalFileName = matches[2]; + mappings[generatedLineNumber] = { + originalLineNumber: parseInt(matches[1], 10), + originalFileName: originalFileName + } + }); + return mappings; +} + +function generateMap(mappings, sourceRoot, mapFileBaseName, generatedLineOffset) { var SourceMapGenerator = require('source-map').SourceMapGenerator; var generator = new SourceMapGenerator({ file: mapFileBaseName }); - var generatedSource = fs.readFileSync(fileName, 'utf-8'); var seenFiles = Object.create(null); - extractComments(generatedSource, function(content, generatedLineNumber) { - var matches = /@line (\d+) "([^"]*)"/.exec(content); - if (matches === null) return; - var originalLineNumber = parseInt(matches[1], 10); - var originalFileName = matches[2]; + for (var generatedLineNumber in mappings) { + var generatedLineNumber = parseInt(generatedLineNumber, 10); + var mapping = mappings[generatedLineNumber]; + var originalFileName = mapping.originalFileName; + generator.addMapping({ + generated: { line: generatedLineNumber + generatedLineOffset, column: 0 }, + original: { line: mapping.originalLineNumber, column: 0 }, + source: originalFileName + }); + // we could call setSourceContent repeatedly, but readFileSync is slow, so + // avoid doing it unnecessarily if (!(originalFileName in seenFiles)) { seenFiles[originalFileName] = true; var rootedPath = originalFileName[0] === path.sep ? @@ -89,33 +110,64 @@ function generateMap(fileName, sourceRoot, mapFileBaseName, generatedLineOffset) " at " + rootedPath); } } + } - generator.addMapping({ - generated: { line: generatedLineNumber + generatedLineOffset, column: 0 }, - original: { line: originalLineNumber, column: 0 }, - source: originalFileName - }); - }); - - var mapFileName = mapFileBaseName + '.map'; - fs.writeFileSync(mapFileName, generator.toString()); + fs.writeFileSync(mapFileBaseName + '.map', generator.toString()); +} - var lastLine = generatedSource.slice(generatedSource.lastIndexOf('\n')); +function appendMappingURL(fileName, source, mapFileName) { + var lastLine = source.slice(source.lastIndexOf('\n')); if (!/sourceMappingURL/.test(lastLine)) fs.appendFileSync(fileName, '//@ sourceMappingURL=' + path.basename(mapFileName)); } +function parseArgs(args) { + var rv = { _: [] }; // unflagged args go into `_`; similar to the optimist library + for (var i = 0; i < args.length; i++) { + if (/^--/.test(args[i])) rv[args[i].slice(2)] = args[++i]; + else rv._.push(args[i]); + } + return rv; +} + if (require.main === module) { if (process.argv.length < 3) { - console.log('Usage: ./sourcemapper.js ' + - '' + - ''); + console.log('Usage: ./sourcemapper.js \\\n' + + '\t--sourceRoot \\\n' + + '\t--mapFileBaseName \\\n' + + '\t--offset '); process.exit(1); } else { - var sourceRoot = process.argv.length > 3 ? process.argv[3] : "."; - var mapFileBaseName = process.argv.length > 4 ? process.argv[4] : process.argv[2]; - var generatedLineOffset = process.argv.length > 5 ? - parseInt(process.argv[5], 10) : 0; - generateMap(process.argv[2], sourceRoot, mapFileBaseName, generatedLineOffset); + var opts = parseArgs(process.argv.slice(2)); + var fileName = opts._[0]; + var sourceRoot = opts.sourceRoot ? opts.sourceRoot : "."; + var mapFileBaseName = opts.mapFileBaseName ? opts.mapFileBaseName : fileName; + var generatedLineOffset = opts.offset ? parseInt(opts.offset, 10) : 0; + + var generatedSource = fs.readFileSync(fileName, 'utf-8'); + var source = generatedSource; + var mappings = getMappings(generatedSource); + for (var i = 1, l = opts._.length; i < l; i ++) { + var optimizedSource = fs.readFileSync(opts._[i], 'utf-8') + var optimizedMappings = getMappings(optimizedSource); + var newMappings = {}; + // uglify processes the code between EMSCRIPTEN_START_FUNCS and + // EMSCRIPTEN_END_FUNCS, so its line number maps are relative to those + // markers. we correct for that here. + var startFuncsLineNumber = countLines( + source.slice(0, source.indexOf('// EMSCRIPTEN_START_FUNCS'))) + 2; + for (var line in optimizedMappings) { + var originalLineNumber = optimizedMappings[line].originalLineNumber + startFuncsLineNumber; + if (originalLineNumber in mappings) { + newMappings[line] = mappings[originalLineNumber]; + } + } + mappings = newMappings; + source = optimizedSource; + } + + generateMap(mappings, sourceRoot, mapFileBaseName, generatedLineOffset); + appendMappingURL(opts._[opts._.length - 1], generatedSource, + opts.mapFileBaseName + '.map'); } } From 1911d7bdd0c4571a0cbc0a97321cc1c4dbdb863e Mon Sep 17 00:00:00 2001 From: "Michael J. Bishop" Date: Wed, 19 Jun 2013 19:30:17 -0400 Subject: [PATCH 19/69] Fixed error where SDL_Mixer would run out of channels because sound instances weren't removed when they were finished playing. --- src/library_sdl.js | 25 ++++++++++++++++++++----- 1 file changed, 20 insertions(+), 5 deletions(-) diff --git a/src/library_sdl.js b/src/library_sdl.js index 356c974644ba7..4e75f5948d2fa 100644 --- a/src/library_sdl.js +++ b/src/library_sdl.js @@ -1385,26 +1385,28 @@ var LibrarySDL = { // If the user asks us to allocate a channel automatically, get the first // free one. if (channel == -1) { - channel = SDL.channelMinimumNumber; for (var i = SDL.channelMinimumNumber; i < SDL.numChannels; i++) { if (!SDL.channels[i].audio) { channel = i; break; } } + if (channel == -1) { + Module.printErr('All ' + SDL.numChannels + ' channels in use!'); + return -1; + } } - // We clone the audio node to utilize the preloaded audio buffer, since // the browser has already preloaded the audio file. var channelInfo = SDL.channels[channel]; channelInfo.audio = audio = audio.cloneNode(true); audio.numChannels = info.audio.numChannels; audio.frequency = info.audio.frequency; - // TODO: handle N loops. Behavior matches Mix_PlayMusic audio.loop = loops != 0; - if (SDL.channelFinished) { - audio['onended'] = function() { // TODO: cache these + audio['onended'] = function() { // TODO: cache these + channelInfo.audio = null; + if (SDL.channelFinished) { Runtime.getFuncWrapper(SDL.channelFinished, 'vi')(channel); } } @@ -1475,6 +1477,8 @@ var LibrarySDL = { if (info.audio) { info.audio.pause(); info.audio = null; + } else { + Module.printErr('No Audio for channel: ' + channel); } if (SDL.channelFinished) { Runtime.getFuncWrapper(SDL.channelFinished, 'vi')(channel); @@ -1512,6 +1516,13 @@ var LibrarySDL = { } audio.volume = SDL.music.volume; audio['onended'] = _Mix_HaltMusic; // will send callback + if (SDL.music.audio) { + if (!SDL.music.audio.paused) { + Module.printErr('Music is already playing. ' + SDL.music.source); + } + SDL.music.audio.pause(); + SDL.music.audio.paused = true; + } SDL.music.audio = audio; return 0; }, @@ -1520,6 +1531,7 @@ var LibrarySDL = { var audio = SDL.music.audio; if (!audio) return 0; audio.pause(); + audio.paused = true; return 0; }, @@ -1527,6 +1539,7 @@ var LibrarySDL = { var audio = SDL.music.audio; if (!audio) return 0; audio.play(); + audio.paused = false; return 0; }, @@ -1578,6 +1591,8 @@ var LibrarySDL = { if (info && info.audio) { info.audio.pause(); info.audio.paused = true; + } else { + Module.printErr('Mix_Pause: no sound found for channel: ' + channel); } }, From 486413cf381e903fae1b6db9c473cfec3b5c5ab7 Mon Sep 17 00:00:00 2001 From: Jez Ng Date: Wed, 19 Jun 2013 20:02:06 -0700 Subject: [PATCH 20/69] Make sure the line numbers sync up. --- tools/source-maps/sourcemapper.js | 22 +++++++++++++--------- 1 file changed, 13 insertions(+), 9 deletions(-) diff --git a/tools/source-maps/sourcemapper.js b/tools/source-maps/sourcemapper.js index ba993aa1f6f07..0001e7c786813 100755 --- a/tools/source-maps/sourcemapper.js +++ b/tools/source-maps/sourcemapper.js @@ -5,6 +5,9 @@ var fs = require('fs'); var path = require('path'); +var START_MARKER = '// EMSCRIPTEN_START_FUNCS\n'; +var END_MARKER = '// EMSCRIPTEN_END_FUNCS\n'; + function countLines(s) { var count = 0; for (var i = 0, l = s.length; i < l; i ++) { @@ -26,14 +29,13 @@ function countLines(s) { function extractComments(source, commentHandler) { var state = 'code'; var commentContent = ''; - var functionStartIdx = source.indexOf('// EMSCRIPTEN_START_FUNCS'); - var functionEndIdx = source.lastIndexOf('// EMSCRIPTEN_END_FUNCS'); - var lineCount = countLines(source.slice(0, functionStartIdx)); + var functionStartIdx = source.indexOf(START_MARKER); + var functionEndIdx = source.lastIndexOf(END_MARKER); + var lineCount = countLines(source.slice(0, functionStartIdx)) + 2; - for (var i = functionStartIdx; i < functionEndIdx; i++) { + for (var i = functionStartIdx + START_MARKER.length; i < functionEndIdx; i++) { var c = source[i]; var nextC = source[i+1]; - if (c === '\n') lineCount++; switch (state) { case 'code': if (c === '/') { @@ -62,7 +64,9 @@ function extractComments(source, commentHandler) { if (c === '\\') i++; else if (c === '"') state = 'code'; break; - } + } + + if (c === '\n') lineCount++; } } @@ -153,9 +157,9 @@ if (require.main === module) { var newMappings = {}; // uglify processes the code between EMSCRIPTEN_START_FUNCS and // EMSCRIPTEN_END_FUNCS, so its line number maps are relative to those - // markers. we correct for that here. - var startFuncsLineNumber = countLines( - source.slice(0, source.indexOf('// EMSCRIPTEN_START_FUNCS'))) + 2; + // markers. we correct for that here. +2 = 1 for the newline in the marker + // and 1 to make it a 1-based index. + var startFuncsLineNumber = countLines(source.slice(0, source.indexOf(START_MARKER))) + 2; for (var line in optimizedMappings) { var originalLineNumber = optimizedMappings[line].originalLineNumber + startFuncsLineNumber; if (originalLineNumber in mappings) { From 5c97a8d4bd2254f54b21e8094d581e8c0126844b Mon Sep 17 00:00:00 2001 From: "Michael J. Bishop" Date: Fri, 21 Jun 2013 13:42:17 -0400 Subject: [PATCH 21/69] Added test to make sure channel allocation failed when it was exhausted. To run it: python tests/runner.py browser.test_sdl_audio_mix_channels --- tests/runner.py | 7 ++++ tests/sdl_audio_mix_channels.c | 59 ++++++++++++++++++++++++++++++++++ 2 files changed, 66 insertions(+) create mode 100644 tests/sdl_audio_mix_channels.c diff --git a/tests/runner.py b/tests/runner.py index 610a39f690ff7..1b4b1f0f531c2 100755 --- a/tests/runner.py +++ b/tests/runner.py @@ -12401,6 +12401,13 @@ def test_sdl_audio(self): Popen([PYTHON, EMCC, '-O2', '--closure', '1', '--minify', '0', os.path.join(self.get_dir(), 'sdl_audio.c'), '--preload-file', 'sound.ogg', '--preload-file', 'sound2.wav', '--preload-file', 'bad.ogg', '-o', 'page.html', '-s', 'EXPORTED_FUNCTIONS=["_main", "_play", "_play2"]']).communicate() self.run_browser('page.html', '', '/report_result?1') + def test_sdl_audio_mix_channels(self): + shutil.copyfile(path_from_root('tests', 'sounds', 'noise.ogg'), os.path.join(self.get_dir(), 'sound.ogg')) + open(os.path.join(self.get_dir(), 'sdl_audio_mix_channels.c'), 'w').write(self.with_report_result(open(path_from_root('tests', 'sdl_audio_mix_channels.c')).read())) + + Popen([PYTHON, EMCC, '-O2', '--minify', '0', os.path.join(self.get_dir(), 'sdl_audio_mix_channels.c'), '--preload-file', 'sound.ogg', '-o', 'page.html']).communicate() + self.run_browser('page.html', '', '/report_result?1') + def test_sdl_audio_mix(self): shutil.copyfile(path_from_root('tests', 'sounds', 'pluck.ogg'), os.path.join(self.get_dir(), 'sound.ogg')) shutil.copyfile(path_from_root('tests', 'sounds', 'the_entertainer.ogg'), os.path.join(self.get_dir(), 'music.ogg')) diff --git a/tests/sdl_audio_mix_channels.c b/tests/sdl_audio_mix_channels.c new file mode 100644 index 0000000000000..dd91d594f8809 --- /dev/null +++ b/tests/sdl_audio_mix_channels.c @@ -0,0 +1,59 @@ +#include +#include +#include +#include +#include + +static Mix_Chunk *sound = NULL; +static Mix_Chunk *noiseLoop = NULL; +static Mix_Music *music = NULL; + +static int soundChannel = 0; +static int noiseLoopChannel = 0; + +static const int kNumChannels = 40; + +static int loadAndPlay() +{ + return Mix_PlayChannel(-1, sound, -1); +} + +int main(int argc, char **argv) { + SDL_Init(SDL_INIT_AUDIO); + Mix_Init(MIX_INIT_OGG); + + int ret = Mix_OpenAudio(0, 0, 0, 0); // we ignore all these.. + assert(ret == 0); + + Mix_AllocateChannels(kNumChannels); + + sound = Mix_LoadWAV("sound.ogg"); + + // allocate all the channels + for ( int i = 0; i < kNumChannels; i++ ) + { + assert(loadAndPlay() != -1); + } + + // This point, we should have exhausted our channels + + + + + int lastChannel = loadAndPlay(); + +#if EMSCRIPTEN + int result = (lastChannel == -1); + REPORT_RESULT(); +#endif + + assert(lastChannel == -1); + + // force a quit + while(Mix_Init(0)) + Mix_Quit(); + Mix_CloseAudio(); + + return 0; +} + From df420614de18bf8fa8e45a88feabbecd3618b892 Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Fri, 21 Jun 2013 16:37:48 -0700 Subject: [PATCH 22/69] update tests --- .../eliminator/asm-eliminator-test-output.js | 10078 ++++----- tools/eliminator/asm-eliminator-test.js | 13536 ++++++------ tools/eliminator/eliminator-test-output.js | 11816 +++++------ tools/eliminator/eliminator-test.js | 17274 ++++++++-------- .../eliminator/safe-eliminator-test-output.js | 164 +- tools/eliminator/safe-eliminator-test.js | 198 +- tools/test-js-optimizer-asm-last-output.js | 82 +- tools/test-js-optimizer-asm-last.js | 94 +- tools/test-js-optimizer-asm-pre-output.js | 978 +- tools/test-js-optimizer-asm-pre.js | 988 +- .../test-js-optimizer-asm-regs-min-output.js | 50 +- tools/test-js-optimizer-asm-regs-min.js | 50 +- tools/test-js-optimizer-asm-regs-output.js | 180 +- tools/test-js-optimizer-asm-regs.js | 186 +- tools/test-js-optimizer-output.js | 482 +- tools/test-js-optimizer-regs-output.js | 426 +- tools/test-js-optimizer-regs.js | 436 +- tools/test-js-optimizer-t2-output.js | 176 +- tools/test-js-optimizer-t2.js | 176 +- tools/test-js-optimizer-t2c-output.js | 28 +- tools/test-js-optimizer-t2c.js | 30 +- tools/test-js-optimizer-t3-output.js | 90 +- tools/test-js-optimizer-t3.js | 90 +- tools/test-js-optimizer.js | 666 +- 24 files changed, 29137 insertions(+), 29137 deletions(-) diff --git a/tools/eliminator/asm-eliminator-test-output.js b/tools/eliminator/asm-eliminator-test-output.js index 358a83df8f92b..b28fbd4a425b7 100644 --- a/tools/eliminator/asm-eliminator-test-output.js +++ b/tools/eliminator/asm-eliminator-test-output.js @@ -1,333 +1,150 @@ function asm(x, y) { - x = +x; - y = y | 0; - var a = 0; - a = cheez(y + ~~x | 0) | 0; - fleefl(a * a | 0, a | 0); + x = +x; + y = y | 0; + var a = 0; + a = cheez(y + ~~x | 0) | 0; + fleefl(a * a | 0, a | 0); } function __Z11printResultPiS_j($needle, $haystack, $len) { - $needle = $needle | 0; - $haystack = $haystack | 0; - $len = $len | 0; - var $3 = 0, __stackBase__ = 0; - __stackBase__ = STACKTOP; - $3 = _bsearch($needle, $haystack, $len, 4, 2); - if (($3 | 0) == 0) { - _puts(_str | 0); - STACKTOP = __stackBase__; - return; - } else { - _printf(__str1 | 0, (tempInt = STACKTOP, STACKTOP = STACKTOP + 4 | 0, HEAP32[(tempInt & 16777215) >> 2] = HEAP32[($3 & 16777215) >> 2] | 0, tempInt)); - STACKTOP = __stackBase__; - return; - } + $needle = $needle | 0; + $haystack = $haystack | 0; + $len = $len | 0; + var $3 = 0, __stackBase__ = 0; + __stackBase__ = STACKTOP; + $3 = _bsearch($needle, $haystack, $len, 4, 2); + if (($3 | 0) == 0) { + _puts(_str | 0); + STACKTOP = __stackBase__; + return; + } else { + _printf(__str1 | 0, (tempInt = STACKTOP, STACKTOP = STACKTOP + 4 | 0, HEAP32[(tempInt & 16777215) >> 2] = HEAP32[($3 & 16777215) >> 2] | 0, tempInt)); + STACKTOP = __stackBase__; + return; + } } function _segment_holding($addr) { - $addr = $addr | 0; - var $sp_0 = 0, $3 = 0, $12 = 0, $_0 = 0, label = 0; - $sp_0 = __gm_ + 444 | 0; - while (1) { - $3 = HEAP32[(($sp_0 | 0) & 16777215) >> 2] | 0; - if (!($3 >>> 0 > $addr >>> 0)) { - if (($3 + (HEAP32[(($sp_0 + 4 | 0) & 16777215) >> 2] | 0) | 0) >>> 0 > $addr >>> 0) { - $_0 = $sp_0; - label = 1658; - break; - } - } - $12 = HEAP32[(($sp_0 + 8 | 0) & 16777215) >> 2] | 0; - if (($12 | 0) == 0) { - $_0 = 0; - label = 1659; - break; - } else { - $sp_0 = $12; - } + $addr = $addr | 0; + var $sp_0 = 0, $3 = 0, $12 = 0, $_0 = 0, label = 0; + $sp_0 = __gm_ + 444 | 0; + while (1) { + $3 = HEAP32[(($sp_0 | 0) & 16777215) >> 2] | 0; + if (!($3 >>> 0 > $addr >>> 0)) { + if (($3 + (HEAP32[(($sp_0 + 4 | 0) & 16777215) >> 2] | 0) | 0) >>> 0 > $addr >>> 0) { + $_0 = $sp_0; + label = 1658; + break; + } } - if (label == 1659) { - return $_0; - } else if (label == 1658) { - return $_0; + $12 = HEAP32[(($sp_0 + 8 | 0) & 16777215) >> 2] | 0; + if (($12 | 0) == 0) { + $_0 = 0; + label = 1659; + break; + } else { + $sp_0 = $12; } + } + if (label == 1659) { + return $_0; + } else if (label == 1658) { + return $_0; + } } function __ZN5identC2EiPKcPci($this, $n, $a) { - $this = $this | 0; - $n = $n | 0; - $a = $a | 0; - HEAP32[($this & 16777215) >> 2] = __ZTV5ident + 8 | 0; - HEAP32[($this + 4 & 16777215) >> 2] = 5; - HEAP32[($this + 8 & 16777215) >> 2] = $n; - HEAP32[($this + 20 & 16777215) >> 2] = 2147483647; - HEAP32[($this + 24 & 16777215) >> 2] = 0; - HEAP32[($this + 28 & 16777215) >> 2] = $a; - HEAP32[($this + 32 & 16777215) >> 2] = 0; - HEAP32[($this + 40 & 16777215) >> 2] = 1; - return; + $this = $this | 0; + $n = $n | 0; + $a = $a | 0; + HEAP32[($this & 16777215) >> 2] = __ZTV5ident + 8 | 0; + HEAP32[($this + 4 & 16777215) >> 2] = 5; + HEAP32[($this + 8 & 16777215) >> 2] = $n; + HEAP32[($this + 20 & 16777215) >> 2] = 2147483647; + HEAP32[($this + 24 & 16777215) >> 2] = 0; + HEAP32[($this + 28 & 16777215) >> 2] = $a; + HEAP32[($this + 32 & 16777215) >> 2] = 0; + HEAP32[($this + 40 & 16777215) >> 2] = 1; + return; } function _vec2Length($this) { - $this = $this | 0; - var __stackBase__ = 0; - __stackBase__ = STACKTOP; - STACKTOP = STACKTOP + 8 | 0; - STACKTOP = __stackBase__; - return 0; + $this = $this | 0; + var __stackBase__ = 0; + __stackBase__ = STACKTOP; + STACKTOP = STACKTOP + 8 | 0; + STACKTOP = __stackBase__; + return 0; } function exc($this) { - $this = $this | 0; - var $1 = 0, $5 = 0; - $1 = (function() { - try { - __THREW__ = false; - return __ZNSt3__16locale8__globalEv(); - } catch (e) { - if (typeof e != "number") throw e; - if (ABORT) throw e; - __THREW__ = true; - Module.print("Exception: " + e + ", currently at: " + (new Error).stack); - return null; - } - })(); - if (!__THREW__) { - $5 = HEAP32[(($1 | 0) & 16777215) >> 2] | 0; - HEAP32[(($this | 0) & 16777215) >> 2] = $5; - __ZNSt3__114__shared_count12__add_sharedEv($5 | 0); - return; - } else { - $8$0 = ___cxa_find_matching_catch(HEAP32[(_llvm_eh_exception.buf & 16777215) >> 2] | 0, HEAP32[(_llvm_eh_exception.buf + 4 & 16777215) >> 2] | 0, []); - $8$1 = tempRet0; - ___cxa_call_unexpected($8$0); + $this = $this | 0; + var $1 = 0, $5 = 0; + $1 = (function() { + try { + __THREW__ = false; + return __ZNSt3__16locale8__globalEv(); + } catch (e) { + if (typeof e != "number") throw e; + if (ABORT) throw e; + __THREW__ = true; + Module.print("Exception: " + e + ", currently at: " + (new Error).stack); + return null; } + })(); + if (!__THREW__) { + $5 = HEAP32[(($1 | 0) & 16777215) >> 2] | 0; + HEAP32[(($this | 0) & 16777215) >> 2] = $5; + __ZNSt3__114__shared_count12__add_sharedEv($5 | 0); + return; + } else { + $8$0 = ___cxa_find_matching_catch(HEAP32[(_llvm_eh_exception.buf & 16777215) >> 2] | 0, HEAP32[(_llvm_eh_exception.buf + 4 & 16777215) >> 2] | 0, []); + $8$1 = tempRet0; + ___cxa_call_unexpected($8$0); + } } function label() { - if (f()) { - g(); - } - L100 : if (h()) { - i(); - } + if (f()) { + g(); + } + L100 : if (h()) { + i(); + } } function switchy() { - var yes = 0; - while (1) switch (label | 0) { - case 1: - break; - case 2: - yes = 111; - yes = yes * 2; - print(yes); - yes--; - print(yes / 2); - continue; - case 3: - break; - } + var yes = 0; + while (1) switch (label | 0) { + case 1: + break; + case 2: + yes = 111; + yes = yes * 2; + print(yes); + yes--; + print(yes / 2); + continue; + case 3: + break; + } } function confuusion() { - var i = +0, j = +0; - func1(+i); - j = i; - func2(+j); + var i = +0, j = +0; + func1(+i); + j = i; + func2(+j); } function tempDouble(a) { - a = +a; - f(a * a); + a = +a; + f(a * a); } function _org_apache_harmony_luni_util_NumberConverter_freeFormat__($me) { - $me = $me | 0; - var $_r2_sroa_0 = 0, $_r3_sroa_0 = 0, $$etemp$1 = 0, $6 = 0, $7 = 0, $10 = 0, $11 = +0, $15 = 0, $_r2_sroa_0_0_cast283 = 0, $_r3_sroa_0_0_cast247 = 0, $_r3_sroa_0_0_load244 = +0, $_r3_sroa_0_0_load244$$SHADOW$0 = 0, $_r2_sroa_0_0_load = +0, $_r2_sroa_0_0_load$$SHADOW$0 = 0, $trunc297 = 0, $25 = 0, $26 = 0, $smax = 0, $28 = 0, $_r3_sroa_0_0_load239 = +0, $_pre_phi301 = 0, $_r3_sroa_0_0_cast264_pre_phi = 0, $_r2_sroa_0_0_load265 = +0, $33 = 0, $34 = 0, $_r3_sroa_0_0_cast253 = 0, $36 = 0, $37 = 0, $_r3_sroa_0_0_load243 = +0, $_r2_sroa_0_0_cast = 0, $45 = 0, $_sink_in = +0, $_r3_sroa_0_0_load241 = +0, $_r2_sroa_0_0_load266287 = 0, $_r1_sroa_0_0 = +0, $47 = 0, $48$0 = 0, $48$1 = 0, $_r1_sroa_0_0_extract_trunc185 = 0, $_r1_sroa_0_1_in$0 = 0, $_r1_sroa_0_1_in$1 = 0, $_r1_sroa_0_0_extract_trunc169 = 0, $_r1_sroa_0_2 = +0, $64 = 0, $65 = 0, $69 = 0, $76 = 0, $82 = 0, $_r1_sroa_0_0_extract_trunc = 0, $$etemp$15 = 0, $105 = 0, $106 = 0, $107 = 0, $108 = 0, $109 = 0, $110 = 0, $112 = 0, $113 = 0, $118 = 0, $_r3_sroa_0_0_load242 = +0, label = 0, __stackBase__ = 0; - __stackBase__ = STACKTOP; - STACKTOP = STACKTOP + 16 | 0; - $_r2_sroa_0 = __stackBase__ | 0; - $_r3_sroa_0 = __stackBase__ + 8 | 0; - if ((HEAP32[(114668 | 0) >> 2] | 0 | 0) == 0) { - HEAP32[(114664 | 0) >> 2] = 1; - HEAP32[(114668 | 0) >> 2] = 1; - $$etemp$1 = 114672 | 0; - HEAP32[($$etemp$1 | 0) >> 2] = -1; - HEAP32[($$etemp$1 + 4 | 0) >> 2] = -1; - HEAP32[(114684 | 0) >> 2] = 25296 | 0; - HEAP32[(114704 | 0) >> 2] = 110728; - HEAP32[(114712 | 0) >> 2] = 8; - HEAP32[(114784 | 0 | 0) >> 2] = HEAP32[(107856 | 0 | 0) >> 2] | 0; - HEAP32[(114784 | 0 | 0) + 4 >> 2] = HEAP32[(107856 | 0 | 0) + 4 >> 2] | 0; - HEAP32[(114784 | 0 | 0) + 8 >> 2] = HEAP32[(107856 | 0 | 0) + 8 >> 2] | 0; - HEAP32[(114784 | 0 | 0) + 12 >> 2] = HEAP32[(107856 | 0 | 0) + 12 >> 2] | 0; - HEAP32[(114784 | 0 | 0) + 16 >> 2] = HEAP32[(107856 | 0 | 0) + 16 >> 2] | 0; - HEAP32[(114784 | 0 | 0) + 20 >> 2] = HEAP32[(107856 | 0 | 0) + 20 >> 2] | 0; - } - $6 = _org_xmlvm_runtime_XMLVMArray_createSingleDimension___java_lang_Class_int(HEAP32[138960 >> 2] | 0, 25) | 0; - $7 = $me + 8 | 0; - $10 = HEAP32[($me + 20 | 0) >> 2] | 0; - $11 = (HEAP32[tempDoublePtr >> 2] = $10, HEAP32[tempDoublePtr + 4 >> 2] = 0, +HEAPF64[tempDoublePtr >> 3]); - if (($10 | 0) > -1) { - HEAP32[$_r2_sroa_0 >> 2] = 0; - $_r2_sroa_0_0_load265 = +HEAPF64[$_r2_sroa_0 >> 3]; - $_r3_sroa_0_0_cast264_pre_phi = $_r3_sroa_0; - $_pre_phi301 = $6 + 16 | 0; - } else { - $15 = $6 + 16 | 0; - HEAP16[(HEAP32[$15 >> 2] | 0) >> 1] = 48; - $_r2_sroa_0_0_cast283 = $_r2_sroa_0; - HEAP16[((HEAP32[$15 >> 2] | 0) + 2 | 0) >> 1] = 46; - HEAP32[$_r2_sroa_0_0_cast283 >> 2] = 2; - $_r3_sroa_0_0_cast247 = $_r3_sroa_0; - HEAP32[$_r3_sroa_0_0_cast247 >> 2] = $10 + 1 | 0; - $_r3_sroa_0_0_load244 = +HEAPF64[$_r3_sroa_0 >> 3]; - $_r3_sroa_0_0_load244$$SHADOW$0 = HEAP32[($_r3_sroa_0 | 0) >> 2] | 0; - $_r2_sroa_0_0_load = +HEAPF64[$_r2_sroa_0 >> 3]; - $_r2_sroa_0_0_load$$SHADOW$0 = HEAP32[($_r2_sroa_0 | 0) >> 2] | 0; - HEAPF64[$_r3_sroa_0 >> 3] = $_r2_sroa_0_0_load; - HEAPF64[$_r2_sroa_0 >> 3] = $_r3_sroa_0_0_load244; - $trunc297 = $_r3_sroa_0_0_load244$$SHADOW$0; - $25 = $_r2_sroa_0_0_load$$SHADOW$0; - if (($trunc297 | 0) < 0) { - $26 = $trunc297 + 1 | 0; - $smax = ($26 | 0) > 0 ? $26 : 0; - $28 = $25 + $smax | 0; - $113 = $25; - $112 = $trunc297; - while (1) { - HEAP16[((HEAP32[$15 >> 2] | 0) + ($113 << 1) | 0) >> 1] = 48; - $118 = $112 + 1 | 0; - if (($118 | 0) < 0) { - $113 = $113 + 1 | 0; - $112 = $118; - } else { - break; - } - } - HEAP32[$_r3_sroa_0_0_cast247 >> 2] = $28 - $trunc297 | 0; - HEAP32[$_r2_sroa_0_0_cast283 >> 2] = $smax; - $_r3_sroa_0_0_load239 = +HEAPF64[$_r3_sroa_0 >> 3]; - } else { - $_r3_sroa_0_0_load239 = $_r2_sroa_0_0_load; - } - HEAPF64[$_r2_sroa_0 >> 3] = $_r3_sroa_0_0_load239; - $_r2_sroa_0_0_load265 = $_r3_sroa_0_0_load239; - $_r3_sroa_0_0_cast264_pre_phi = $_r3_sroa_0_0_cast247; - $_pre_phi301 = $15; - } - $33 = $me + 16 | 0; - $34 = HEAP32[$33 >> 2] | 0; - $_r3_sroa_0_0_cast253 = $_r3_sroa_0; - HEAP32[$_r3_sroa_0_0_cast253 >> 2] = $34; - $36 = $me + 12 | 0; - $37 = HEAP32[$36 >> 2] | 0; - HEAP32[$36 >> 2] = $37 + 1 | 0; - HEAP32[$_r3_sroa_0_0_cast264_pre_phi >> 2] = HEAP32[((HEAP32[($34 + 16 | 0) >> 2] | 0) + ($37 << 2) | 0) >> 2] | 0; - $_r3_sroa_0_0_load243 = +HEAPF64[$_r3_sroa_0 >> 3]; - HEAPF64[$_r3_sroa_0 >> 3] = $_r2_sroa_0_0_load265; - HEAPF64[$_r2_sroa_0 >> 3] = $11; - $_r2_sroa_0_0_cast = $_r2_sroa_0; - $45 = $7; - $_r1_sroa_0_0 = $_r3_sroa_0_0_load243; - $_r2_sroa_0_0_load266287 = $10; - $_r3_sroa_0_0_load241 = $_r2_sroa_0_0_load265; - $_sink_in = $_r2_sroa_0_0_load265; - while (1) { - HEAPF64[tempDoublePtr >> 3] = $_sink_in; - $47 = HEAP32[tempDoublePtr >> 2] | 0; - HEAPF64[tempDoublePtr >> 3] = $_r1_sroa_0_0; - $48$0 = HEAP32[tempDoublePtr >> 2] | 0; - $48$1 = HEAP32[tempDoublePtr + 4 >> 2] | 0; - $_r1_sroa_0_0_extract_trunc185 = $48$0; - do { - if (($_r1_sroa_0_0_extract_trunc185 | 0) == -1) { - if (($_r2_sroa_0_0_load266287 | 0) < -1) { - $_r1_sroa_0_2 = $_r3_sroa_0_0_load241; - break; - } - HEAP16[((HEAP32[$_pre_phi301 >> 2] | 0) + ($47 << 1) | 0) >> 1] = 48; - $_r1_sroa_0_1_in$1 = 0 | $48$1 & -1; - $_r1_sroa_0_1_in$0 = $47 + 1 | 0 | $48$0 & 0; - label = 785; - break; - } else { - HEAP16[((HEAP32[$_pre_phi301 >> 2] | 0) + ($47 << 1) | 0) >> 1] = ($_r1_sroa_0_0_extract_trunc185 + 48 | 0) & 65535; - $_r1_sroa_0_1_in$1 = 0; - $_r1_sroa_0_1_in$0 = $47 + 1 | 0; - label = 785; - break; - } - } while (0); - do { - if ((label | 0) == 785) { - label = 0; - if (!(($_r2_sroa_0_0_load266287 | 0) == 0)) { - $_r1_sroa_0_2 = (HEAP32[tempDoublePtr >> 2] = $_r1_sroa_0_1_in$0, HEAP32[tempDoublePtr + 4 >> 2] = $_r1_sroa_0_1_in$1, +HEAPF64[tempDoublePtr >> 3]); - break; - } - $_r1_sroa_0_0_extract_trunc169 = $_r1_sroa_0_1_in$0; - HEAP32[$_r3_sroa_0_0_cast264_pre_phi >> 2] = $_r1_sroa_0_0_extract_trunc169 + 1 | 0; - HEAP16[((HEAP32[$_pre_phi301 >> 2] | 0) + ($_r1_sroa_0_0_extract_trunc169 << 1) | 0) >> 1] = 46; - $_r1_sroa_0_2 = +HEAPF64[$_r3_sroa_0 >> 3]; - } - } while (0); - $64 = $_r2_sroa_0_0_load266287 - 1 | 0; - $65 = HEAP32[$36 >> 2] | 0; - HEAP32[$_r3_sroa_0_0_cast264_pre_phi >> 2] = $65; - if (($65 | 0) < (HEAP32[$45 >> 2] | 0 | 0)) { - $69 = HEAP32[$33 >> 2] | 0; - HEAP32[$_r3_sroa_0_0_cast253 >> 2] = $69; - HEAP32[$36 >> 2] = $65 + 1 | 0; - $76 = HEAP32[((HEAP32[($69 + 16 | 0) >> 2] | 0) + ($65 << 2) | 0) >> 2] | 0; - HEAP32[$_r3_sroa_0_0_cast264_pre_phi >> 2] = $76; - if (!(($76 | 0) != -1 | ($64 | 0) > -2)) { - break; - } - } else { - HEAP32[$_r3_sroa_0_0_cast264_pre_phi >> 2] = -1; - if (!(($64 | 0) > -2)) { - break; - } - } - $_r3_sroa_0_0_load242 = +HEAPF64[$_r3_sroa_0 >> 3]; - HEAPF64[$_r3_sroa_0 >> 3] = $_r1_sroa_0_2; - $_r1_sroa_0_0 = $_r3_sroa_0_0_load242; - $_r2_sroa_0_0_load266287 = $64; - $_r3_sroa_0_0_load241 = $_r1_sroa_0_2; - $_sink_in = $_r1_sroa_0_2; - } - HEAP32[$_r2_sroa_0_0_cast >> 2] = $64; - if ((HEAP32[(106148 | 0) >> 2] | 0 | 0) == 0) { - ___INIT_java_lang_String(); - } - $82 = _GC_MALLOC(36 | 0) | 0; - HEAP32[$82 >> 2] = 106144; - _memset($82 + 4 | 0 | 0 | 0, 0 | 0 | 0, 32 | 0 | 0); - HEAP32[$_r2_sroa_0 >> 2] = $82; - HEAPF64[tempDoublePtr >> 3] = $_r1_sroa_0_2; - $_r1_sroa_0_0_extract_trunc = HEAP32[tempDoublePtr >> 2] | 0; - HEAP32[($82 + 8 | 0) >> 2] = 0; - HEAP32[($82 + 12 | 0) >> 2] = 0; - HEAP32[($82 + 16 | 0) >> 2] = 0; - if (($_r1_sroa_0_0_extract_trunc | 0) < 0) { - _XMLVM_ERROR(16136 | 0, 13208 | 0, 132112 | 0, 830); - return 0 | 0; - } - if ((HEAP32[($6 + 12 | 0) >> 2] | 0 | 0) < ($_r1_sroa_0_0_extract_trunc | 0)) { - _XMLVM_ERROR(16136 | 0, 13208 | 0, 132112 | 0, 830); - return 0 | 0; - } - HEAP32[($82 + 24 | 0) >> 2] = 0; - if (!((HEAP32[(114668 | 0) >> 2] | 0 | 0) == 0)) { - $105 = HEAP32[138960 >> 2] | 0; - $106 = _org_xmlvm_runtime_XMLVMArray_createSingleDimension___java_lang_Class_int($105, $_r1_sroa_0_0_extract_trunc) | 0; - $107 = $82 + 20 | 0; - $108 = $107; - HEAP32[$108 >> 2] = $106; - $109 = $82 + 28 | 0; - $110 = $109; - HEAP32[$110 >> 2] = $_r1_sroa_0_0_extract_trunc; - _java_lang_System_arraycopy___java_lang_Object_int_java_lang_Object_int_int($6, 0, $106, 0, $_r1_sroa_0_0_extract_trunc); - STACKTOP = __stackBase__; - return $82 | 0; - } + $me = $me | 0; + var $_r2_sroa_0 = 0, $_r3_sroa_0 = 0, $$etemp$1 = 0, $6 = 0, $7 = 0, $10 = 0, $11 = +0, $15 = 0, $_r2_sroa_0_0_cast283 = 0, $_r3_sroa_0_0_cast247 = 0, $_r3_sroa_0_0_load244 = +0, $_r3_sroa_0_0_load244$$SHADOW$0 = 0, $_r2_sroa_0_0_load = +0, $_r2_sroa_0_0_load$$SHADOW$0 = 0, $trunc297 = 0, $25 = 0, $26 = 0, $smax = 0, $28 = 0, $_r3_sroa_0_0_load239 = +0, $_pre_phi301 = 0, $_r3_sroa_0_0_cast264_pre_phi = 0, $_r2_sroa_0_0_load265 = +0, $33 = 0, $34 = 0, $_r3_sroa_0_0_cast253 = 0, $36 = 0, $37 = 0, $_r3_sroa_0_0_load243 = +0, $_r2_sroa_0_0_cast = 0, $45 = 0, $_sink_in = +0, $_r3_sroa_0_0_load241 = +0, $_r2_sroa_0_0_load266287 = 0, $_r1_sroa_0_0 = +0, $47 = 0, $48$0 = 0, $48$1 = 0, $_r1_sroa_0_0_extract_trunc185 = 0, $_r1_sroa_0_1_in$0 = 0, $_r1_sroa_0_1_in$1 = 0, $_r1_sroa_0_0_extract_trunc169 = 0, $_r1_sroa_0_2 = +0, $64 = 0, $65 = 0, $69 = 0, $76 = 0, $82 = 0, $_r1_sroa_0_0_extract_trunc = 0, $$etemp$15 = 0, $105 = 0, $106 = 0, $107 = 0, $108 = 0, $109 = 0, $110 = 0, $112 = 0, $113 = 0, $118 = 0, $_r3_sroa_0_0_load242 = +0, label = 0, __stackBase__ = 0; + __stackBase__ = STACKTOP; + STACKTOP = STACKTOP + 16 | 0; + $_r2_sroa_0 = __stackBase__ | 0; + $_r3_sroa_0 = __stackBase__ + 8 | 0; + if ((HEAP32[(114668 | 0) >> 2] | 0 | 0) == 0) { HEAP32[(114664 | 0) >> 2] = 1; HEAP32[(114668 | 0) >> 2] = 1; - $$etemp$15 = 114672 | 0; - HEAP32[($$etemp$15 | 0) >> 2] = -1; - HEAP32[($$etemp$15 + 4 | 0) >> 2] = -1; + $$etemp$1 = 114672 | 0; + HEAP32[($$etemp$1 | 0) >> 2] = -1; + HEAP32[($$etemp$1 + 4 | 0) >> 2] = -1; HEAP32[(114684 | 0) >> 2] = 25296 | 0; HEAP32[(114704 | 0) >> 2] = 110728; HEAP32[(114712 | 0) >> 2] = 8; @@ -337,6 +154,163 @@ function _org_apache_harmony_luni_util_NumberConverter_freeFormat__($me) { HEAP32[(114784 | 0 | 0) + 12 >> 2] = HEAP32[(107856 | 0 | 0) + 12 >> 2] | 0; HEAP32[(114784 | 0 | 0) + 16 >> 2] = HEAP32[(107856 | 0 | 0) + 16 >> 2] | 0; HEAP32[(114784 | 0 | 0) + 20 >> 2] = HEAP32[(107856 | 0 | 0) + 20 >> 2] | 0; + } + $6 = _org_xmlvm_runtime_XMLVMArray_createSingleDimension___java_lang_Class_int(HEAP32[138960 >> 2] | 0, 25) | 0; + $7 = $me + 8 | 0; + $10 = HEAP32[($me + 20 | 0) >> 2] | 0; + $11 = (HEAP32[tempDoublePtr >> 2] = $10, HEAP32[tempDoublePtr + 4 >> 2] = 0, +HEAPF64[tempDoublePtr >> 3]); + if (($10 | 0) > -1) { + HEAP32[$_r2_sroa_0 >> 2] = 0; + $_r2_sroa_0_0_load265 = +HEAPF64[$_r2_sroa_0 >> 3]; + $_r3_sroa_0_0_cast264_pre_phi = $_r3_sroa_0; + $_pre_phi301 = $6 + 16 | 0; + } else { + $15 = $6 + 16 | 0; + HEAP16[(HEAP32[$15 >> 2] | 0) >> 1] = 48; + $_r2_sroa_0_0_cast283 = $_r2_sroa_0; + HEAP16[((HEAP32[$15 >> 2] | 0) + 2 | 0) >> 1] = 46; + HEAP32[$_r2_sroa_0_0_cast283 >> 2] = 2; + $_r3_sroa_0_0_cast247 = $_r3_sroa_0; + HEAP32[$_r3_sroa_0_0_cast247 >> 2] = $10 + 1 | 0; + $_r3_sroa_0_0_load244 = +HEAPF64[$_r3_sroa_0 >> 3]; + $_r3_sroa_0_0_load244$$SHADOW$0 = HEAP32[($_r3_sroa_0 | 0) >> 2] | 0; + $_r2_sroa_0_0_load = +HEAPF64[$_r2_sroa_0 >> 3]; + $_r2_sroa_0_0_load$$SHADOW$0 = HEAP32[($_r2_sroa_0 | 0) >> 2] | 0; + HEAPF64[$_r3_sroa_0 >> 3] = $_r2_sroa_0_0_load; + HEAPF64[$_r2_sroa_0 >> 3] = $_r3_sroa_0_0_load244; + $trunc297 = $_r3_sroa_0_0_load244$$SHADOW$0; + $25 = $_r2_sroa_0_0_load$$SHADOW$0; + if (($trunc297 | 0) < 0) { + $26 = $trunc297 + 1 | 0; + $smax = ($26 | 0) > 0 ? $26 : 0; + $28 = $25 + $smax | 0; + $113 = $25; + $112 = $trunc297; + while (1) { + HEAP16[((HEAP32[$15 >> 2] | 0) + ($113 << 1) | 0) >> 1] = 48; + $118 = $112 + 1 | 0; + if (($118 | 0) < 0) { + $113 = $113 + 1 | 0; + $112 = $118; + } else { + break; + } + } + HEAP32[$_r3_sroa_0_0_cast247 >> 2] = $28 - $trunc297 | 0; + HEAP32[$_r2_sroa_0_0_cast283 >> 2] = $smax; + $_r3_sroa_0_0_load239 = +HEAPF64[$_r3_sroa_0 >> 3]; + } else { + $_r3_sroa_0_0_load239 = $_r2_sroa_0_0_load; + } + HEAPF64[$_r2_sroa_0 >> 3] = $_r3_sroa_0_0_load239; + $_r2_sroa_0_0_load265 = $_r3_sroa_0_0_load239; + $_r3_sroa_0_0_cast264_pre_phi = $_r3_sroa_0_0_cast247; + $_pre_phi301 = $15; + } + $33 = $me + 16 | 0; + $34 = HEAP32[$33 >> 2] | 0; + $_r3_sroa_0_0_cast253 = $_r3_sroa_0; + HEAP32[$_r3_sroa_0_0_cast253 >> 2] = $34; + $36 = $me + 12 | 0; + $37 = HEAP32[$36 >> 2] | 0; + HEAP32[$36 >> 2] = $37 + 1 | 0; + HEAP32[$_r3_sroa_0_0_cast264_pre_phi >> 2] = HEAP32[((HEAP32[($34 + 16 | 0) >> 2] | 0) + ($37 << 2) | 0) >> 2] | 0; + $_r3_sroa_0_0_load243 = +HEAPF64[$_r3_sroa_0 >> 3]; + HEAPF64[$_r3_sroa_0 >> 3] = $_r2_sroa_0_0_load265; + HEAPF64[$_r2_sroa_0 >> 3] = $11; + $_r2_sroa_0_0_cast = $_r2_sroa_0; + $45 = $7; + $_r1_sroa_0_0 = $_r3_sroa_0_0_load243; + $_r2_sroa_0_0_load266287 = $10; + $_r3_sroa_0_0_load241 = $_r2_sroa_0_0_load265; + $_sink_in = $_r2_sroa_0_0_load265; + while (1) { + HEAPF64[tempDoublePtr >> 3] = $_sink_in; + $47 = HEAP32[tempDoublePtr >> 2] | 0; + HEAPF64[tempDoublePtr >> 3] = $_r1_sroa_0_0; + $48$0 = HEAP32[tempDoublePtr >> 2] | 0; + $48$1 = HEAP32[tempDoublePtr + 4 >> 2] | 0; + $_r1_sroa_0_0_extract_trunc185 = $48$0; + do { + if (($_r1_sroa_0_0_extract_trunc185 | 0) == -1) { + if (($_r2_sroa_0_0_load266287 | 0) < -1) { + $_r1_sroa_0_2 = $_r3_sroa_0_0_load241; + break; + } + HEAP16[((HEAP32[$_pre_phi301 >> 2] | 0) + ($47 << 1) | 0) >> 1] = 48; + $_r1_sroa_0_1_in$1 = 0 | $48$1 & -1; + $_r1_sroa_0_1_in$0 = $47 + 1 | 0 | $48$0 & 0; + label = 785; + break; + } else { + HEAP16[((HEAP32[$_pre_phi301 >> 2] | 0) + ($47 << 1) | 0) >> 1] = ($_r1_sroa_0_0_extract_trunc185 + 48 | 0) & 65535; + $_r1_sroa_0_1_in$1 = 0; + $_r1_sroa_0_1_in$0 = $47 + 1 | 0; + label = 785; + break; + } + } while (0); + do { + if ((label | 0) == 785) { + label = 0; + if (!(($_r2_sroa_0_0_load266287 | 0) == 0)) { + $_r1_sroa_0_2 = (HEAP32[tempDoublePtr >> 2] = $_r1_sroa_0_1_in$0, HEAP32[tempDoublePtr + 4 >> 2] = $_r1_sroa_0_1_in$1, +HEAPF64[tempDoublePtr >> 3]); + break; + } + $_r1_sroa_0_0_extract_trunc169 = $_r1_sroa_0_1_in$0; + HEAP32[$_r3_sroa_0_0_cast264_pre_phi >> 2] = $_r1_sroa_0_0_extract_trunc169 + 1 | 0; + HEAP16[((HEAP32[$_pre_phi301 >> 2] | 0) + ($_r1_sroa_0_0_extract_trunc169 << 1) | 0) >> 1] = 46; + $_r1_sroa_0_2 = +HEAPF64[$_r3_sroa_0 >> 3]; + } + } while (0); + $64 = $_r2_sroa_0_0_load266287 - 1 | 0; + $65 = HEAP32[$36 >> 2] | 0; + HEAP32[$_r3_sroa_0_0_cast264_pre_phi >> 2] = $65; + if (($65 | 0) < (HEAP32[$45 >> 2] | 0 | 0)) { + $69 = HEAP32[$33 >> 2] | 0; + HEAP32[$_r3_sroa_0_0_cast253 >> 2] = $69; + HEAP32[$36 >> 2] = $65 + 1 | 0; + $76 = HEAP32[((HEAP32[($69 + 16 | 0) >> 2] | 0) + ($65 << 2) | 0) >> 2] | 0; + HEAP32[$_r3_sroa_0_0_cast264_pre_phi >> 2] = $76; + if (!(($76 | 0) != -1 | ($64 | 0) > -2)) { + break; + } + } else { + HEAP32[$_r3_sroa_0_0_cast264_pre_phi >> 2] = -1; + if (!(($64 | 0) > -2)) { + break; + } + } + $_r3_sroa_0_0_load242 = +HEAPF64[$_r3_sroa_0 >> 3]; + HEAPF64[$_r3_sroa_0 >> 3] = $_r1_sroa_0_2; + $_r1_sroa_0_0 = $_r3_sroa_0_0_load242; + $_r2_sroa_0_0_load266287 = $64; + $_r3_sroa_0_0_load241 = $_r1_sroa_0_2; + $_sink_in = $_r1_sroa_0_2; + } + HEAP32[$_r2_sroa_0_0_cast >> 2] = $64; + if ((HEAP32[(106148 | 0) >> 2] | 0 | 0) == 0) { + ___INIT_java_lang_String(); + } + $82 = _GC_MALLOC(36 | 0) | 0; + HEAP32[$82 >> 2] = 106144; + _memset($82 + 4 | 0 | 0 | 0, 0 | 0 | 0, 32 | 0 | 0); + HEAP32[$_r2_sroa_0 >> 2] = $82; + HEAPF64[tempDoublePtr >> 3] = $_r1_sroa_0_2; + $_r1_sroa_0_0_extract_trunc = HEAP32[tempDoublePtr >> 2] | 0; + HEAP32[($82 + 8 | 0) >> 2] = 0; + HEAP32[($82 + 12 | 0) >> 2] = 0; + HEAP32[($82 + 16 | 0) >> 2] = 0; + if (($_r1_sroa_0_0_extract_trunc | 0) < 0) { + _XMLVM_ERROR(16136 | 0, 13208 | 0, 132112 | 0, 830); + return 0 | 0; + } + if ((HEAP32[($6 + 12 | 0) >> 2] | 0 | 0) < ($_r1_sroa_0_0_extract_trunc | 0)) { + _XMLVM_ERROR(16136 | 0, 13208 | 0, 132112 | 0, 830); + return 0 | 0; + } + HEAP32[($82 + 24 | 0) >> 2] = 0; + if (!((HEAP32[(114668 | 0) >> 2] | 0 | 0) == 0)) { $105 = HEAP32[138960 >> 2] | 0; $106 = _org_xmlvm_runtime_XMLVMArray_createSingleDimension___java_lang_Class_int($105, $_r1_sroa_0_0_extract_trunc) | 0; $107 = $82 + 20 | 0; @@ -348,4777 +322,4803 @@ function _org_apache_harmony_luni_util_NumberConverter_freeFormat__($me) { _java_lang_System_arraycopy___java_lang_Object_int_java_lang_Object_int_int($6, 0, $106, 0, $_r1_sroa_0_0_extract_trunc); STACKTOP = __stackBase__; return $82 | 0; + } + HEAP32[(114664 | 0) >> 2] = 1; + HEAP32[(114668 | 0) >> 2] = 1; + $$etemp$15 = 114672 | 0; + HEAP32[($$etemp$15 | 0) >> 2] = -1; + HEAP32[($$etemp$15 + 4 | 0) >> 2] = -1; + HEAP32[(114684 | 0) >> 2] = 25296 | 0; + HEAP32[(114704 | 0) >> 2] = 110728; + HEAP32[(114712 | 0) >> 2] = 8; + HEAP32[(114784 | 0 | 0) >> 2] = HEAP32[(107856 | 0 | 0) >> 2] | 0; + HEAP32[(114784 | 0 | 0) + 4 >> 2] = HEAP32[(107856 | 0 | 0) + 4 >> 2] | 0; + HEAP32[(114784 | 0 | 0) + 8 >> 2] = HEAP32[(107856 | 0 | 0) + 8 >> 2] | 0; + HEAP32[(114784 | 0 | 0) + 12 >> 2] = HEAP32[(107856 | 0 | 0) + 12 >> 2] | 0; + HEAP32[(114784 | 0 | 0) + 16 >> 2] = HEAP32[(107856 | 0 | 0) + 16 >> 2] | 0; + HEAP32[(114784 | 0 | 0) + 20 >> 2] = HEAP32[(107856 | 0 | 0) + 20 >> 2] | 0; + $105 = HEAP32[138960 >> 2] | 0; + $106 = _org_xmlvm_runtime_XMLVMArray_createSingleDimension___java_lang_Class_int($105, $_r1_sroa_0_0_extract_trunc) | 0; + $107 = $82 + 20 | 0; + $108 = $107; + HEAP32[$108 >> 2] = $106; + $109 = $82 + 28 | 0; + $110 = $109; + HEAP32[$110 >> 2] = $_r1_sroa_0_0_extract_trunc; + _java_lang_System_arraycopy___java_lang_Object_int_java_lang_Object_int_int($6, 0, $106, 0, $_r1_sroa_0_0_extract_trunc); + STACKTOP = __stackBase__; + return $82 | 0; } function __ZN23b2EdgeAndPolygonContact8EvaluateEP10b2ManifoldRK11b2TransformS4_($this, $manifold, $xfA, $xfB) { - $this = $this | 0; - $manifold = $manifold | 0; - $xfA = $xfA | 0; - $xfB = $xfB | 0; - var __stackBase__ = 0; - __stackBase__ = STACKTOP; - STACKTOP = STACKTOP + 256 | 0; - __ZN12b2EPCollider7CollideEP10b2ManifoldPK11b2EdgeShapeRK11b2TransformPK14b2PolygonShapeS7_(__stackBase__ | 0, $manifold, HEAP32[((HEAP32[($this + 48 | 0) >> 2] | 0) + 12 | 0) >> 2] | 0, $xfA, HEAP32[((HEAP32[($this + 52 | 0) >> 2] | 0) + 12 | 0) >> 2] | 0, $xfB); - STACKTOP = __stackBase__; - return; + $this = $this | 0; + $manifold = $manifold | 0; + $xfA = $xfA | 0; + $xfB = $xfB | 0; + var __stackBase__ = 0; + __stackBase__ = STACKTOP; + STACKTOP = STACKTOP + 256 | 0; + __ZN12b2EPCollider7CollideEP10b2ManifoldPK11b2EdgeShapeRK11b2TransformPK14b2PolygonShapeS7_(__stackBase__ | 0, $manifold, HEAP32[((HEAP32[($this + 48 | 0) >> 2] | 0) + 12 | 0) >> 2] | 0, $xfA, HEAP32[((HEAP32[($this + 52 | 0) >> 2] | 0) + 12 | 0) >> 2] | 0, $xfB); + STACKTOP = __stackBase__; + return; } function _java_nio_charset_Charset_forNameInternal___java_lang_String($n1) { - $n1 = $n1 | 0; - var $_r0_sroa_0 = 0, $_r0_sroa_1 = 0, $_r1_sroa_0 = 0, $_r2_sroa_0 = 0, $_r3_sroa_0 = 0, $_r3_sroa_1 = 0, $_r5_sroa_0 = 0, $local_env_w4567aaac23b1b6 = 0, $local_env_w4567aaac23b1c16 = 0, $local_env_w4567aaac23b1c22 = 0, $local_env_w4567aaac23b1c24 = 0, $local_env_w4567aaac23b1c26 = 0, $local_env_w4567aaac23b1c29 = 0, $local_env_w4567aaac23b1c31 = 0, $local_env_w4567aaac23b1c35 = 0, $local_env_w4567aaac23b1c40 = 0, $local_env_w4567aaac23b1c42 = 0, $local_env_w4567aaac23b1c44 = 0, $local_env_w4567aaac23b1c48 = 0, $local_env_w4567aaac23b1c50 = 0, $5 = 0, $16 = 0, $18 = 0, $19 = 0, $21 = 0, $25 = 0, $40 = 0, $52 = 0, $57 = 0, $61 = 0, $tib1_0_ph_i543 = 0, $72 = 0, $tib1_0_lcssa_i546 = 0, $dimension_tib1_0_lcssa_i547 = 0, $77 = 0, $79 = 0, $dimension_tib1_029_i549 = 0, $82 = 0, $83 = 0, $86 = 0, $88 = 0, $dimension_tib2_024_i551 = 0, $91 = 0, $92 = 0, $95 = 0, $tib2_0_lcssa_in_i553 = 0, $dimension_tib2_0_lcssa_i554 = 0, $tib2_0_lcssa_i555 = 0, $tib1_121_i558 = 0, $i_0_i561 = 0, $113 = 0, $_r1_sroa_0_0_load600 = 0, $119 = 0, $122 = 0, $139 = 0, $145 = 0, $149 = 0, $151 = 0, $153 = 0, $155 = 0, $159 = 0, $170 = 0, $175 = 0, $179 = 0, $tib1_0_ph_i521 = 0, $190 = 0, $tib1_0_lcssa_i524 = 0, $dimension_tib1_0_lcssa_i525 = 0, $195 = 0, $197 = 0, $dimension_tib1_029_i527 = 0, $200 = 0, $201 = 0, $204 = 0, $206 = 0, $dimension_tib2_024_i529 = 0, $209 = 0, $210 = 0, $213 = 0, $tib2_0_lcssa_in_i531 = 0, $dimension_tib2_0_lcssa_i532 = 0, $tib2_0_lcssa_i533 = 0, $tib1_121_i536 = 0, $i_0_i539 = 0, $231 = 0, $238 = 0, $240 = 0, $_r1_sroa_0_0_load = 0, $246 = 0, $249 = 0, $266 = 0, $273 = 0, $275 = 0, $284 = 0, $286 = 0, $290 = 0, $305 = 0, $310 = 0, $323 = 0, $328 = 0, $332 = 0, $tib1_0_ph_i500 = 0, $343 = 0, $tib1_0_lcssa_i503 = 0, $dimension_tib1_0_lcssa_i504 = 0, $348 = 0, $350 = 0, $dimension_tib1_029_i506 = 0, $353 = 0, $354 = 0, $357 = 0, $359 = 0, $dimension_tib2_024_i508 = 0, $362 = 0, $363 = 0, $366 = 0, $tib2_0_lcssa_in_i510 = 0, $dimension_tib2_0_lcssa_i511 = 0, $tib2_0_lcssa_i512 = 0, $tib1_121_i515 = 0, $i_0_i518 = 0, $384 = 0, $392 = 0, $394 = 0, $395 = 0, $397 = 0, $401 = 0, $416 = 0, $424 = 0, $426 = 0, $427 = 0, $429 = 0, $433 = 0, $446 = 0, $451 = 0, $455 = 0, $tib1_0_ph_i479 = 0, $466 = 0, $tib1_0_lcssa_i482 = 0, $dimension_tib1_0_lcssa_i483 = 0, $471 = 0, $473 = 0, $dimension_tib1_029_i485 = 0, $476 = 0, $477 = 0, $480 = 0, $482 = 0, $dimension_tib2_024_i487 = 0, $485 = 0, $486 = 0, $489 = 0, $tib2_0_lcssa_in_i489 = 0, $dimension_tib2_0_lcssa_i490 = 0, $tib2_0_lcssa_i491 = 0, $tib1_121_i494 = 0, $i_0_i497 = 0, $507 = 0, $519 = 0, $521 = 0, $525 = 0, $534 = 0, $539 = 0, $542 = 0, $546 = 0, $548 = 0, $557 = 0, $562 = 0, $566 = 0, $tib1_0_ph_i458 = 0, $577 = 0, $tib1_0_lcssa_i461 = 0, $dimension_tib1_0_lcssa_i462 = 0, $582 = 0, $584 = 0, $dimension_tib1_029_i464 = 0, $587 = 0, $588 = 0, $591 = 0, $593 = 0, $dimension_tib2_024_i466 = 0, $596 = 0, $597 = 0, $600 = 0, $tib2_0_lcssa_in_i468 = 0, $dimension_tib2_0_lcssa_i469 = 0, $tib2_0_lcssa_i470 = 0, $tib1_121_i473 = 0, $i_0_i476 = 0, $618 = 0, $623 = 0, $625 = 0, $629 = 0, $632 = 0, $643 = 0, $644 = 0, $649 = 0, $653 = 0, $tib1_0_ph_i437 = 0, $664 = 0, $tib1_0_lcssa_i440 = 0, $dimension_tib1_0_lcssa_i441 = 0, $669 = 0, $671 = 0, $dimension_tib1_029_i443 = 0, $674 = 0, $675 = 0, $678 = 0, $680 = 0, $dimension_tib2_024_i445 = 0, $683 = 0, $684 = 0, $687 = 0, $tib2_0_lcssa_in_i447 = 0, $dimension_tib2_0_lcssa_i448 = 0, $tib2_0_lcssa_i449 = 0, $tib1_121_i452 = 0, $i_0_i455 = 0, $705 = 0, $711 = 0, $716 = 0, $720 = 0, $tib1_0_ph_i416 = 0, $731 = 0, $tib1_0_lcssa_i419 = 0, $dimension_tib1_0_lcssa_i420 = 0, $736 = 0, $738 = 0, $dimension_tib1_029_i422 = 0, $741 = 0, $742 = 0, $745 = 0, $747 = 0, $dimension_tib2_024_i424 = 0, $750 = 0, $751 = 0, $754 = 0, $tib2_0_lcssa_in_i426 = 0, $dimension_tib2_0_lcssa_i427 = 0, $tib2_0_lcssa_i428 = 0, $tib1_121_i431 = 0, $i_0_i434 = 0, $772 = 0, $780 = 0, $782 = 0, $783 = 0, $785 = 0, $789 = 0, $798 = 0, $808 = 0, $809 = 0, $814 = 0, $818 = 0, $tib1_0_ph_i395 = 0, $829 = 0, $tib1_0_lcssa_i398 = 0, $dimension_tib1_0_lcssa_i399 = 0, $834 = 0, $836 = 0, $dimension_tib1_029_i401 = 0, $839 = 0, $840 = 0, $843 = 0, $845 = 0, $dimension_tib2_024_i403 = 0, $848 = 0, $849 = 0, $852 = 0, $tib2_0_lcssa_in_i405 = 0, $dimension_tib2_0_lcssa_i406 = 0, $tib2_0_lcssa_i407 = 0, $tib1_121_i410 = 0, $i_0_i413 = 0, $870 = 0, $876 = 0, $881 = 0, $885 = 0, $tib1_0_ph_i374 = 0, $896 = 0, $tib1_0_lcssa_i377 = 0, $dimension_tib1_0_lcssa_i378 = 0, $901 = 0, $903 = 0, $dimension_tib1_029_i380 = 0, $906 = 0, $907 = 0, $910 = 0, $912 = 0, $dimension_tib2_024_i382 = 0, $915 = 0, $916 = 0, $919 = 0, $tib2_0_lcssa_in_i384 = 0, $dimension_tib2_0_lcssa_i385 = 0, $tib2_0_lcssa_i386 = 0, $tib1_121_i389 = 0, $i_0_i392 = 0, $937 = 0, $945 = 0, $947 = 0, $948 = 0, $950 = 0, $954 = 0, $_r0_sroa_0_0_load607 = 0, $969 = 0, $974 = 0, $978 = 0, $tib1_0_ph_i353 = 0, $989 = 0, $tib1_0_lcssa_i356 = 0, $dimension_tib1_0_lcssa_i357 = 0, $994 = 0, $996 = 0, $dimension_tib1_029_i359 = 0, $999 = 0, $1000 = 0, $1003 = 0, $1005 = 0, $dimension_tib2_024_i361 = 0, $1008 = 0, $1009 = 0, $1012 = 0, $tib2_0_lcssa_in_i363 = 0, $dimension_tib2_0_lcssa_i364 = 0, $tib2_0_lcssa_i365 = 0, $tib1_121_i368 = 0, $i_0_i371 = 0, $1030 = 0, $1036 = 0, $1038 = 0, $1042 = 0, $1050 = 0, $1056 = 0, $1064 = 0, $1066 = 0, $1067 = 0, $1069 = 0, $1073 = 0, $1083 = 0, $1084 = 0, $1089 = 0, $1093 = 0, $tib1_0_ph_i332 = 0, $1104 = 0, $tib1_0_lcssa_i335 = 0, $dimension_tib1_0_lcssa_i336 = 0, $1109 = 0, $1111 = 0, $dimension_tib1_029_i338 = 0, $1114 = 0, $1115 = 0, $1118 = 0, $1120 = 0, $dimension_tib2_024_i340 = 0, $1123 = 0, $1124 = 0, $1127 = 0, $tib2_0_lcssa_in_i342 = 0, $dimension_tib2_0_lcssa_i343 = 0, $tib2_0_lcssa_i344 = 0, $tib1_121_i347 = 0, $i_0_i350 = 0, $1145 = 0, $1151 = 0, $1156 = 0, $1160 = 0, $tib1_0_ph_i311 = 0, $1171 = 0, $tib1_0_lcssa_i314 = 0, $dimension_tib1_0_lcssa_i315 = 0, $1176 = 0, $1178 = 0, $dimension_tib1_029_i317 = 0, $1181 = 0, $1182 = 0, $1185 = 0, $1187 = 0, $dimension_tib2_024_i319 = 0, $1190 = 0, $1191 = 0, $1194 = 0, $tib2_0_lcssa_in_i321 = 0, $dimension_tib2_0_lcssa_i322 = 0, $tib2_0_lcssa_i323 = 0, $tib1_121_i326 = 0, $i_0_i329 = 0, $1212 = 0, $1222 = 0, $1232 = 0, $1233 = 0, $1238 = 0, $1242 = 0, $tib1_0_ph_i290 = 0, $1253 = 0, $tib1_0_lcssa_i293 = 0, $dimension_tib1_0_lcssa_i294 = 0, $1258 = 0, $1260 = 0, $dimension_tib1_029_i296 = 0, $1263 = 0, $1264 = 0, $1267 = 0, $1269 = 0, $dimension_tib2_024_i298 = 0, $1272 = 0, $1273 = 0, $1276 = 0, $tib2_0_lcssa_in_i300 = 0, $dimension_tib2_0_lcssa_i301 = 0, $tib2_0_lcssa_i302 = 0, $tib1_121_i305 = 0, $i_0_i308 = 0, $1294 = 0, $1300 = 0, $1305 = 0, $1309 = 0, $tib1_0_ph_i269 = 0, $1320 = 0, $tib1_0_lcssa_i272 = 0, $dimension_tib1_0_lcssa_i273 = 0, $1325 = 0, $1327 = 0, $dimension_tib1_029_i275 = 0, $1330 = 0, $1331 = 0, $1334 = 0, $1336 = 0, $dimension_tib2_024_i277 = 0, $1339 = 0, $1340 = 0, $1343 = 0, $tib2_0_lcssa_in_i279 = 0, $dimension_tib2_0_lcssa_i280 = 0, $tib2_0_lcssa_i281 = 0, $tib1_121_i284 = 0, $i_0_i287 = 0, $1361 = 0, $1369 = 0, $1371 = 0, $1372 = 0, $1374 = 0, $1378 = 0, $_r0_sroa_0_0_load604 = 0, $1391 = 0, $1400 = 0, $1401 = 0, $1406 = 0, $1410 = 0, $tib1_0_ph_i248 = 0, $1421 = 0, $tib1_0_lcssa_i251 = 0, $dimension_tib1_0_lcssa_i252 = 0, $1426 = 0, $1428 = 0, $dimension_tib1_029_i254 = 0, $1431 = 0, $1432 = 0, $1435 = 0, $1437 = 0, $dimension_tib2_024_i256 = 0, $1440 = 0, $1441 = 0, $1444 = 0, $tib2_0_lcssa_in_i258 = 0, $dimension_tib2_0_lcssa_i259 = 0, $tib2_0_lcssa_i260 = 0, $tib1_121_i263 = 0, $i_0_i266 = 0, $1462 = 0, $1468 = 0, $1473 = 0, $1477 = 0, $tib1_0_ph_i227 = 0, $1488 = 0, $tib1_0_lcssa_i230 = 0, $dimension_tib1_0_lcssa_i231 = 0, $1493 = 0, $1495 = 0, $dimension_tib1_029_i233 = 0, $1498 = 0, $1499 = 0, $1502 = 0, $1504 = 0, $dimension_tib2_024_i235 = 0, $1507 = 0, $1508 = 0, $1511 = 0, $tib2_0_lcssa_in_i237 = 0, $dimension_tib2_0_lcssa_i238 = 0, $tib2_0_lcssa_i239 = 0, $tib1_121_i242 = 0, $i_0_i245 = 0, $1529 = 0, $1536 = 0, $1538 = 0, $1539 = 0, $1541 = 0, $1545 = 0, $1551 = 0, $1553 = 0, $_r0_sroa_0_0_load602 = 0, $1570 = 0, $1575 = 0, $1579 = 0, $tib1_0_ph_i185 = 0, $1590 = 0, $tib1_0_lcssa_i188 = 0, $dimension_tib1_0_lcssa_i189 = 0, $1595 = 0, $1597 = 0, $dimension_tib1_029_i191 = 0, $1600 = 0, $1601 = 0, $1604 = 0, $1606 = 0, $dimension_tib2_024_i193 = 0, $1609 = 0, $1610 = 0, $1613 = 0, $tib2_0_lcssa_in_i195 = 0, $dimension_tib2_0_lcssa_i196 = 0, $tib2_0_lcssa_i197 = 0, $tib1_121_i200 = 0, $i_0_i203 = 0, $1631 = 0, $1638 = 0, $1640 = 0, $1641 = 0, $1643 = 0, $1647 = 0, $1653 = 0, $1655 = 0, $_r2_sroa_0_0_load = 0, $1666 = 0, $1668 = 0, $1684 = 0, $1689 = 0, $1693 = 0, $tib1_0_ph_i = 0, $1704 = 0, $tib1_0_lcssa_i = 0, $dimension_tib1_0_lcssa_i = 0, $1709 = 0, $1711 = 0, $dimension_tib1_029_i = 0, $1714 = 0, $1715 = 0, $1718 = 0, $1720 = 0, $dimension_tib2_024_i = 0, $1723 = 0, $1724 = 0, $1727 = 0, $tib2_0_lcssa_in_i = 0, $dimension_tib2_0_lcssa_i = 0, $tib2_0_lcssa_i = 0, $tib1_121_i = 0, $i_0_i = 0, $1745 = 0, label = 0, __stackBase__ = 0, setjmpLabel = 0, setjmpTable = 0; - __stackBase__ = STACKTOP; - STACKTOP = STACKTOP + 536 | 0; - label = 1; - setjmpLabel = 0; - setjmpTable = STACKTOP; - STACKTOP = STACKTOP + 168 | 0; - HEAP32[setjmpTable >> 2] = 0; - while (1) switch (label | 0) { - case 1: - $_r0_sroa_1 = __stackBase__ | 0; - $_r3_sroa_1 = __stackBase__ + 8 | 0; - $local_env_w4567aaac23b1b6 = __stackBase__ + 16 | 0; - $local_env_w4567aaac23b1c16 = __stackBase__ + 56 | 0; - $local_env_w4567aaac23b1c22 = __stackBase__ + 96 | 0; - $local_env_w4567aaac23b1c24 = __stackBase__ + 136 | 0; - $local_env_w4567aaac23b1c26 = __stackBase__ + 176 | 0; - $local_env_w4567aaac23b1c29 = __stackBase__ + 216 | 0; - $local_env_w4567aaac23b1c31 = __stackBase__ + 256 | 0; - $local_env_w4567aaac23b1c35 = __stackBase__ + 296 | 0; - $local_env_w4567aaac23b1c40 = __stackBase__ + 336 | 0; - $local_env_w4567aaac23b1c42 = __stackBase__ + 376 | 0; - $local_env_w4567aaac23b1c44 = __stackBase__ + 416 | 0; - $local_env_w4567aaac23b1c48 = __stackBase__ + 456 | 0; - $local_env_w4567aaac23b1c50 = __stackBase__ + 496 | 0; - if ((HEAP32[(98772 | 0) >> 2] | 0 | 0) == 0) { - label = 2; - break; - } else { - label = 3; - break; - } - case 2: - invoke_v(702); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 3; - break; - case 3: - $_r5_sroa_0 = $n1; - $5 = invoke_ii(556, 709 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $_r0_sroa_0 = $5; - if ((HEAP32[(98772 | 0) >> 2] | 0 | 0) == 0) { - label = 4; - break; - } else { - label = 5; - break; - } - case 4: - invoke_v(702); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 5; - break; - case 5: - $_r1_sroa_0 = HEAP32[136048 >> 2] | 0; - invoke_ii(202, $_r1_sroa_0 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - if ((HEAP32[(105500 | 0) >> 2] | 0 | 0) == 0) { - label = 6; - break; - } else { - label = 7; - break; - } - case 6: - invoke_v(30); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 7; - break; - case 7: - $16 = invoke_i(70) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $18 = invoke_iii(364, $16 | 0, 0 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $19 = $local_env_w4567aaac23b1b6; - $21 = $18 + 16 | 0; - _memcpy($19 | 0, HEAP32[$21 >> 2] | 0 | 0, 40); - $25 = _saveSetjmp(HEAP32[$21 >> 2] | 0 | 0, label, setjmpTable) | 0; - label = 413; - break; - case 413: - if (($25 | 0) == 0) { - label = 8; - break; - } else { - label = 11; - break; - } - case 8: - if ((HEAP32[(98772 | 0) >> 2] | 0 | 0) == 0) { - label = 9; - break; - } else { - label = 10; - break; - } - case 9: - invoke_v(702); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 10; - break; - case 10: - $_r0_sroa_0 = HEAP32[140056 >> 2] | 0; - $40 = invoke_iii(HEAP32[((HEAP32[($_r0_sroa_0 | 0) >> 2] | 0) + 160 | 0) >> 2] | 0 | 0, $_r0_sroa_0 | 0, $_r5_sroa_0 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $_r0_sroa_0 = $40; - $_r0_sroa_0 = $_r0_sroa_0; - _memcpy(HEAP32[$21 >> 2] | 0 | 0, $19 | 0, 40); - if (($_r0_sroa_0 | 0) == 0) { - label = 32; - break; - } else { - label = 28; - break; - } - case 11: - _memcpy(HEAP32[$21 >> 2] | 0 | 0, $19 | 0, 40); - if ((HEAP32[(107740 | 0) >> 2] | 0 | 0) == 0) { - label = 12; - break; - } else { - label = 13; - break; - } - case 12: - invoke_v(374); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 13; - break; - case 13: - $52 = HEAP32[($18 + 20 | 0) >> 2] | 0; - if (($52 | 0) == 0) { - label = 27; - break; - } else { - label = 14; - break; - } - case 14: - $57 = HEAP32[$52 >> 2] | 0; - $61 = HEAP32[((HEAP32[137616 >> 2] | 0) + 8 | 0) >> 2] | 0; - if (($57 | 0) == 82712) { - label = 15; - break; - } else { - $tib1_0_ph_i543 = $57; - label = 16; - break; - } - case 15: - $tib1_0_ph_i543 = HEAP32[((HEAP32[($52 + 8 | 0) >> 2] | 0) + 8 | 0) >> 2] | 0; - label = 16; - break; - case 16: - $72 = HEAP32[($tib1_0_ph_i543 + 56 | 0) >> 2] | 0; - if (($72 | 0) == 0) { - $dimension_tib1_0_lcssa_i547 = 0; - $tib1_0_lcssa_i546 = $tib1_0_ph_i543; - label = 18; - break; - } else { - $dimension_tib1_029_i549 = 0; - $79 = $72; - label = 19; - break; - } - case 17: - $dimension_tib1_0_lcssa_i547 = $83; - $tib1_0_lcssa_i546 = $82; - label = 18; - break; - case 18: - $77 = HEAP32[($61 + 56 | 0) >> 2] | 0; - if (($77 | 0) == 0) { - $dimension_tib2_0_lcssa_i554 = 0; - $tib2_0_lcssa_in_i553 = $61; - label = 21; - break; - } else { - $dimension_tib2_024_i551 = 0; - $88 = $77; - label = 20; - break; - } - case 19: - $82 = HEAP32[($79 + 8 | 0) >> 2] | 0; - $83 = $dimension_tib1_029_i549 + 1 | 0; - $86 = HEAP32[($82 + 56 | 0) >> 2] | 0; - if (($86 | 0) == 0) { - label = 17; - break; - } else { - $dimension_tib1_029_i549 = $83; - $79 = $86; - label = 19; - break; - } - case 20: - $91 = HEAP32[($88 + 8 | 0) >> 2] | 0; - $92 = $dimension_tib2_024_i551 + 1 | 0; - $95 = HEAP32[($91 + 56 | 0) >> 2] | 0; - if (($95 | 0) == 0) { - $dimension_tib2_0_lcssa_i554 = $92; - $tib2_0_lcssa_in_i553 = $91; - label = 21; - break; - } else { - $dimension_tib2_024_i551 = $92; - $88 = $95; - label = 20; - break; - } - case 21: - $tib2_0_lcssa_i555 = $tib2_0_lcssa_in_i553; - if (($dimension_tib1_0_lcssa_i547 | 0) < ($dimension_tib2_0_lcssa_i554 | 0) | ($tib1_0_lcssa_i546 | 0) == 0) { - label = 27; - break; - } else { - $tib1_121_i558 = $tib1_0_lcssa_i546; - label = 22; - break; - } - case 22: - if (($tib1_121_i558 | 0) == ($tib2_0_lcssa_i555 | 0)) { - label = 54; - break; - } else { - label = 23; - break; - } - case 23: - $i_0_i561 = 0; - label = 24; - break; - case 24: - if (($i_0_i561 | 0) < (HEAP32[($tib1_121_i558 + 108 | 0) >> 2] | 0 | 0)) { - label = 25; - break; - } else { - label = 26; - break; - } - case 25: - if ((HEAP32[((HEAP32[($tib1_121_i558 + 112 | 0) >> 2] | 0) + ($i_0_i561 << 2) | 0) >> 2] | 0 | 0) == ($tib2_0_lcssa_i555 | 0)) { - label = 54; - break; - } else { - $i_0_i561 = $i_0_i561 + 1 | 0; - label = 24; - break; - } - case 26: - $113 = HEAP32[($tib1_121_i558 + 40 | 0) >> 2] | 0; - if (($113 | 0) == 0) { - label = 27; - break; - } else { - $tib1_121_i558 = $113; - label = 22; - break; - } - case 27: - invoke_vii(48, HEAP32[$21 >> 2] | 0 | 0, 0 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case 28: - $_r1_sroa_0_0_load600 = $_r1_sroa_0; - $119 = $_r1_sroa_0_0_load600 + 4 | 0; - $122 = (HEAP32[$119 >> 2] | 0) + 8 | 0; - HEAP32[$122 >> 2] = (HEAP32[$122 >> 2] | 0) - 1 | 0; - if ((HEAP32[((HEAP32[$119 >> 2] | 0) + 8 | 0) >> 2] | 0 | 0) == 0) { - label = 29; - break; - } else { - label = 31; - break; - } - case 29: - invoke_vi(28, $_r1_sroa_0_0_load600 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $139; - if (($139 | 0) == 0) { - label = 31; - break; - } else { - label = 30; - break; - } - case 30: - invoke_iii(268, 31e3 | 0 | 0, (tempInt = STACKTOP, STACKTOP = STACKTOP + 8 | 0, HEAP32[tempInt >> 2] = $139, tempInt) | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 31; - break; - case 31: - STACKTOP = __stackBase__; - return $_r0_sroa_0 | 0; - case 32: - $145 = ($_r5_sroa_0 | 0) == 0; - if ((HEAP32[(105500 | 0) >> 2] | 0 | 0) == 0) { - label = 33; - break; - } else { - label = 34; - break; - } - case 33: - invoke_v(30); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 34; - break; - case 34: - $149 = invoke_i(70) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $151 = invoke_iii(364, $149 | 0, 0 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - if ($145) { - label = 35; - break; - } else { - label = 62; - break; - } - case 35: - $153 = $local_env_w4567aaac23b1c16; - $155 = $151 + 16 | 0; - _memcpy($153 | 0, HEAP32[$155 >> 2] | 0 | 0, 40); - $159 = _saveSetjmp(HEAP32[$155 >> 2] | 0 | 0, label, setjmpTable) | 0; - label = 414; - break; - case 414: - if (($159 | 0) == 0) { - label = 36; - break; - } else { - label = 37; - break; - } - case 36: - invoke_viiii(14, 16136 | 0 | 0, 11648 | 0 | 0, 126872 | 0 | 0, 1457 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case 37: - _memcpy(HEAP32[$155 >> 2] | 0 | 0, $153 | 0, 40); - if ((HEAP32[(107740 | 0) >> 2] | 0 | 0) == 0) { - label = 38; - break; - } else { - label = 39; - break; - } - case 38: - invoke_v(374); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 39; - break; - case 39: - $170 = HEAP32[($151 + 20 | 0) >> 2] | 0; - if (($170 | 0) == 0) { - label = 53; - break; - } else { - label = 40; - break; - } - case 40: - $175 = HEAP32[$170 >> 2] | 0; - $179 = HEAP32[((HEAP32[137616 >> 2] | 0) + 8 | 0) >> 2] | 0; - if (($175 | 0) == 82712) { - label = 41; - break; - } else { - $tib1_0_ph_i521 = $175; - label = 42; - break; - } - case 41: - $tib1_0_ph_i521 = HEAP32[((HEAP32[($170 + 8 | 0) >> 2] | 0) + 8 | 0) >> 2] | 0; - label = 42; - break; - case 42: - $190 = HEAP32[($tib1_0_ph_i521 + 56 | 0) >> 2] | 0; - if (($190 | 0) == 0) { - $dimension_tib1_0_lcssa_i525 = 0; - $tib1_0_lcssa_i524 = $tib1_0_ph_i521; - label = 44; - break; - } else { - $dimension_tib1_029_i527 = 0; - $197 = $190; - label = 45; - break; - } - case 43: - $dimension_tib1_0_lcssa_i525 = $201; - $tib1_0_lcssa_i524 = $200; - label = 44; - break; - case 44: - $195 = HEAP32[($179 + 56 | 0) >> 2] | 0; - if (($195 | 0) == 0) { - $dimension_tib2_0_lcssa_i532 = 0; - $tib2_0_lcssa_in_i531 = $179; - label = 47; - break; - } else { - $dimension_tib2_024_i529 = 0; - $206 = $195; - label = 46; - break; - } - case 45: - $200 = HEAP32[($197 + 8 | 0) >> 2] | 0; - $201 = $dimension_tib1_029_i527 + 1 | 0; - $204 = HEAP32[($200 + 56 | 0) >> 2] | 0; - if (($204 | 0) == 0) { - label = 43; - break; - } else { - $dimension_tib1_029_i527 = $201; - $197 = $204; - label = 45; - break; - } - case 46: - $209 = HEAP32[($206 + 8 | 0) >> 2] | 0; - $210 = $dimension_tib2_024_i529 + 1 | 0; - $213 = HEAP32[($209 + 56 | 0) >> 2] | 0; - if (($213 | 0) == 0) { - $dimension_tib2_0_lcssa_i532 = $210; - $tib2_0_lcssa_in_i531 = $209; - label = 47; - break; - } else { - $dimension_tib2_024_i529 = $210; - $206 = $213; - label = 46; - break; - } - case 47: - $tib2_0_lcssa_i533 = $tib2_0_lcssa_in_i531; - if (($dimension_tib1_0_lcssa_i525 | 0) < ($dimension_tib2_0_lcssa_i532 | 0) | ($tib1_0_lcssa_i524 | 0) == 0) { - label = 53; - break; - } else { - $tib1_121_i536 = $tib1_0_lcssa_i524; - label = 48; - break; - } - case 48: - if (($tib1_121_i536 | 0) == ($tib2_0_lcssa_i533 | 0)) { - label = 54; - break; - } else { - label = 49; - break; - } - case 49: - $i_0_i539 = 0; - label = 50; - break; - case 50: - if (($i_0_i539 | 0) < (HEAP32[($tib1_121_i536 + 108 | 0) >> 2] | 0 | 0)) { - label = 51; - break; - } else { - label = 52; - break; - } - case 51: - if ((HEAP32[((HEAP32[($tib1_121_i536 + 112 | 0) >> 2] | 0) + ($i_0_i539 << 2) | 0) >> 2] | 0 | 0) == ($tib2_0_lcssa_i533 | 0)) { - label = 54; - break; - } else { - $i_0_i539 = $i_0_i539 + 1 | 0; - label = 50; - break; - } - case 52: - $231 = HEAP32[($tib1_121_i536 + 40 | 0) >> 2] | 0; - if (($231 | 0) == 0) { - label = 53; - break; - } else { - $tib1_121_i536 = $231; - label = 48; - break; - } - case 53: - invoke_vii(48, HEAP32[$155 >> 2] | 0 | 0, 0 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case 54: - if ((HEAP32[(105500 | 0) >> 2] | 0 | 0) == 0) { - label = 55; - break; - } else { - label = 56; - break; - } - case 55: - invoke_v(30); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 56; - break; - case 56: - $238 = invoke_i(70) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $240 = invoke_iii(364, $238 | 0, 0 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $_r0_sroa_0 = HEAP32[($240 + 20 | 0) >> 2] | 0; - $_r1_sroa_0_0_load = $_r1_sroa_0; - $246 = $_r1_sroa_0_0_load + 4 | 0; - $249 = (HEAP32[$246 >> 2] | 0) + 8 | 0; - HEAP32[$249 >> 2] = (HEAP32[$249 >> 2] | 0) - 1 | 0; - if ((HEAP32[((HEAP32[$246 >> 2] | 0) + 8 | 0) >> 2] | 0 | 0) == 0) { - label = 57; - break; - } else { - label = 59; - break; - } - case 57: - invoke_vi(28, $_r1_sroa_0_0_load | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $266; - if (($266 | 0) == 0) { - label = 59; - break; - } else { - label = 58; - break; - } - case 58: - invoke_iii(268, 31e3 | 0 | 0, (tempInt = STACKTOP, STACKTOP = STACKTOP + 8 | 0, HEAP32[tempInt >> 2] = $266, tempInt) | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 59; - break; - case 59: - if ((HEAP32[(105500 | 0) >> 2] | 0 | 0) == 0) { - label = 60; - break; - } else { - label = 61; - break; - } - case 60: - invoke_v(30); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 61; - break; - case 61: - $273 = invoke_i(70) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $275 = invoke_iii(364, $273 | 0, 0 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - HEAP32[($275 + 20 | 0) >> 2] = $_r0_sroa_0; - invoke_vii(48, HEAP32[($275 + 16 | 0) >> 2] | 0 | 0, 0 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case 62: - $284 = $local_env_w4567aaac23b1c22; - $286 = $151 + 16 | 0; - _memcpy($284 | 0, HEAP32[$286 >> 2] | 0 | 0, 40); - $290 = _saveSetjmp(HEAP32[$286 >> 2] | 0 | 0, label, setjmpTable) | 0; - label = 415; - break; - case 415: - if (($290 | 0) == 0) { - label = 63; - break; - } else { - label = 72; - break; - } - case 63: - invoke_vi(44, $_r5_sroa_0 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - if ((HEAP32[(98772 | 0) >> 2] | 0 | 0) == 0) { - label = 64; - break; - } else { - label = 65; - break; - } - case 64: - invoke_v(702); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 65; - break; - case 65: - $_r0_sroa_0 = HEAP32[140064 >> 2] | 0; - if (($_r0_sroa_0 | 0) == 0) { - label = 67; - break; - } else { - label = 66; - break; - } - case 66: - _memcpy(HEAP32[$286 >> 2] | 0 | 0, $284 | 0, 40); - label = 89; - break; - case 67: - if ((HEAP32[(84292 | 0) >> 2] | 0 | 0) == 0) { - label = 68; - break; - } else { - label = 69; - break; - } - case 68: - invoke_v(584); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 69; - break; - case 69: - $305 = invoke_ii(338, 20 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - HEAP32[$305 >> 2] = 84288; - _memset($305 + 4 | 0 | 0 | 0, 0 | 0 | 0, 16 | 0 | 0); - $_r0_sroa_0 = $305; - invoke_vi(34, $_r0_sroa_0 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $310 = $_r0_sroa_0; - if ((HEAP32[(98772 | 0) >> 2] | 0 | 0) == 0) { - label = 70; - break; - } else { - label = 71; - break; - } - case 70: - invoke_v(702); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 71; - break; - case 71: - HEAP32[140064 >> 2] = $310; - _memcpy(HEAP32[$286 >> 2] | 0 | 0, $284 | 0, 40); - label = 89; - break; - case 72: - _memcpy(HEAP32[$286 >> 2] | 0 | 0, $284 | 0, 40); - if ((HEAP32[(107740 | 0) >> 2] | 0 | 0) == 0) { - label = 73; - break; - } else { - label = 74; - break; - } - case 73: - invoke_v(374); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 74; - break; - case 74: - $323 = HEAP32[($151 + 20 | 0) >> 2] | 0; - if (($323 | 0) == 0) { - label = 88; - break; - } else { - label = 75; - break; - } - case 75: - $328 = HEAP32[$323 >> 2] | 0; - $332 = HEAP32[((HEAP32[137616 >> 2] | 0) + 8 | 0) >> 2] | 0; - if (($328 | 0) == 82712) { - label = 76; - break; - } else { - $tib1_0_ph_i500 = $328; - label = 77; - break; - } - case 76: - $tib1_0_ph_i500 = HEAP32[((HEAP32[($323 + 8 | 0) >> 2] | 0) + 8 | 0) >> 2] | 0; - label = 77; - break; - case 77: - $343 = HEAP32[($tib1_0_ph_i500 + 56 | 0) >> 2] | 0; - if (($343 | 0) == 0) { - $dimension_tib1_0_lcssa_i504 = 0; - $tib1_0_lcssa_i503 = $tib1_0_ph_i500; - label = 79; - break; - } else { - $dimension_tib1_029_i506 = 0; - $350 = $343; - label = 80; - break; - } - case 78: - $dimension_tib1_0_lcssa_i504 = $354; - $tib1_0_lcssa_i503 = $353; - label = 79; - break; - case 79: - $348 = HEAP32[($332 + 56 | 0) >> 2] | 0; - if (($348 | 0) == 0) { - $dimension_tib2_0_lcssa_i511 = 0; - $tib2_0_lcssa_in_i510 = $332; - label = 82; - break; - } else { - $dimension_tib2_024_i508 = 0; - $359 = $348; - label = 81; - break; - } - case 80: - $353 = HEAP32[($350 + 8 | 0) >> 2] | 0; - $354 = $dimension_tib1_029_i506 + 1 | 0; - $357 = HEAP32[($353 + 56 | 0) >> 2] | 0; - if (($357 | 0) == 0) { - label = 78; - break; - } else { - $dimension_tib1_029_i506 = $354; - $350 = $357; - label = 80; - break; - } - case 81: - $362 = HEAP32[($359 + 8 | 0) >> 2] | 0; - $363 = $dimension_tib2_024_i508 + 1 | 0; - $366 = HEAP32[($362 + 56 | 0) >> 2] | 0; - if (($366 | 0) == 0) { - $dimension_tib2_0_lcssa_i511 = $363; - $tib2_0_lcssa_in_i510 = $362; - label = 82; - break; - } else { - $dimension_tib2_024_i508 = $363; - $359 = $366; - label = 81; - break; - } - case 82: - $tib2_0_lcssa_i512 = $tib2_0_lcssa_in_i510; - if (($dimension_tib1_0_lcssa_i504 | 0) < ($dimension_tib2_0_lcssa_i511 | 0) | ($tib1_0_lcssa_i503 | 0) == 0) { - label = 88; - break; - } else { - $tib1_121_i515 = $tib1_0_lcssa_i503; - label = 83; - break; - } - case 83: - if (($tib1_121_i515 | 0) == ($tib2_0_lcssa_i512 | 0)) { - label = 54; - break; - } else { - label = 84; - break; - } - case 84: - $i_0_i518 = 0; - label = 85; - break; - case 85: - if (($i_0_i518 | 0) < (HEAP32[($tib1_121_i515 + 108 | 0) >> 2] | 0 | 0)) { - label = 86; - break; - } else { - label = 87; - break; - } - case 86: - if ((HEAP32[((HEAP32[($tib1_121_i515 + 112 | 0) >> 2] | 0) + ($i_0_i518 << 2) | 0) >> 2] | 0 | 0) == ($tib2_0_lcssa_i512 | 0)) { - label = 54; - break; - } else { - $i_0_i518 = $i_0_i518 + 1 | 0; - label = 85; - break; - } - case 87: - $384 = HEAP32[($tib1_121_i515 + 40 | 0) >> 2] | 0; - if (($384 | 0) == 0) { - label = 88; - break; - } else { - $tib1_121_i515 = $384; - label = 83; - break; - } - case 88: - invoke_vii(48, HEAP32[$286 >> 2] | 0 | 0, 0 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case 89: - if ((HEAP32[(105500 | 0) >> 2] | 0 | 0) == 0) { - label = 90; - break; - } else { - label = 91; - break; - } - case 90: - invoke_v(30); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 91; - break; - case 91: - $392 = invoke_i(70) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $394 = invoke_iii(364, $392 | 0, 0 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $395 = $local_env_w4567aaac23b1c24; - $397 = $394 + 16 | 0; - _memcpy($395 | 0, HEAP32[$397 >> 2] | 0 | 0, 40); - $401 = _saveSetjmp(HEAP32[$397 >> 2] | 0 | 0, label, setjmpTable) | 0; - label = 416; - break; - case 416: - if (($401 | 0) == 0) { - label = 92; - break; - } else { - label = 99; - break; - } - case 92: - if ((HEAP32[(98772 | 0) >> 2] | 0 | 0) == 0) { - label = 93; - break; - } else { - label = 94; - break; - } - case 93: - invoke_v(702); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 94; - break; - case 94: - $_r0_sroa_0 = HEAP32[140064 >> 2] | 0; - $416 = invoke_iii(HEAP32[((HEAP32[($_r0_sroa_0 | 0) >> 2] | 0) + 144 | 0) >> 2] | 0 | 0, $_r0_sroa_0 | 0, $_r5_sroa_0 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $_r0_sroa_0 = $416; - if (($_r0_sroa_0 | 0) == 0) { - label = 95; - break; - } else { - label = 98; - break; - } - case 95: - _memcpy(HEAP32[$397 >> 2] | 0 | 0, $395 | 0, 40); - if ((HEAP32[(105500 | 0) >> 2] | 0 | 0) == 0) { - label = 96; - break; - } else { - label = 97; - break; - } - case 96: - invoke_v(30); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 97; - break; - case 97: - $424 = invoke_i(70) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $426 = invoke_iii(364, $424 | 0, 0 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $427 = $local_env_w4567aaac23b1c26; - $429 = $426 + 16 | 0; - _memcpy($427 | 0, HEAP32[$429 >> 2] | 0 | 0, 40); - $433 = _saveSetjmp(HEAP32[$429 >> 2] | 0 | 0, label, setjmpTable) | 0; - label = 417; - break; - case 417: - if (($433 | 0) == 0) { - label = 116; - break; - } else { - label = 127; - break; - } - case 98: - invoke_vii(24, $_r0_sroa_0 | 0, $_r5_sroa_0 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - _memcpy(HEAP32[$397 >> 2] | 0 | 0, $395 | 0, 40); - label = 28; - break; - case 99: - _memcpy(HEAP32[$397 >> 2] | 0 | 0, $395 | 0, 40); - if ((HEAP32[(107740 | 0) >> 2] | 0 | 0) == 0) { - label = 100; - break; - } else { - label = 101; - break; - } - case 100: - invoke_v(374); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 101; - break; - case 101: - $446 = HEAP32[($394 + 20 | 0) >> 2] | 0; - if (($446 | 0) == 0) { - label = 115; - break; - } else { - label = 102; - break; - } - case 102: - $451 = HEAP32[$446 >> 2] | 0; - $455 = HEAP32[((HEAP32[137616 >> 2] | 0) + 8 | 0) >> 2] | 0; - if (($451 | 0) == 82712) { - label = 103; - break; - } else { - $tib1_0_ph_i479 = $451; - label = 104; - break; - } - case 103: - $tib1_0_ph_i479 = HEAP32[((HEAP32[($446 + 8 | 0) >> 2] | 0) + 8 | 0) >> 2] | 0; - label = 104; - break; - case 104: - $466 = HEAP32[($tib1_0_ph_i479 + 56 | 0) >> 2] | 0; - if (($466 | 0) == 0) { - $dimension_tib1_0_lcssa_i483 = 0; - $tib1_0_lcssa_i482 = $tib1_0_ph_i479; - label = 106; - break; - } else { - $dimension_tib1_029_i485 = 0; - $473 = $466; - label = 107; - break; - } - case 105: - $dimension_tib1_0_lcssa_i483 = $477; - $tib1_0_lcssa_i482 = $476; - label = 106; - break; - case 106: - $471 = HEAP32[($455 + 56 | 0) >> 2] | 0; - if (($471 | 0) == 0) { - $dimension_tib2_0_lcssa_i490 = 0; - $tib2_0_lcssa_in_i489 = $455; - label = 109; - break; - } else { - $dimension_tib2_024_i487 = 0; - $482 = $471; - label = 108; - break; - } - case 107: - $476 = HEAP32[($473 + 8 | 0) >> 2] | 0; - $477 = $dimension_tib1_029_i485 + 1 | 0; - $480 = HEAP32[($476 + 56 | 0) >> 2] | 0; - if (($480 | 0) == 0) { - label = 105; - break; - } else { - $dimension_tib1_029_i485 = $477; - $473 = $480; - label = 107; - break; - } - case 108: - $485 = HEAP32[($482 + 8 | 0) >> 2] | 0; - $486 = $dimension_tib2_024_i487 + 1 | 0; - $489 = HEAP32[($485 + 56 | 0) >> 2] | 0; - if (($489 | 0) == 0) { - $dimension_tib2_0_lcssa_i490 = $486; - $tib2_0_lcssa_in_i489 = $485; - label = 109; - break; - } else { - $dimension_tib2_024_i487 = $486; - $482 = $489; - label = 108; - break; - } - case 109: - $tib2_0_lcssa_i491 = $tib2_0_lcssa_in_i489; - if (($dimension_tib1_0_lcssa_i483 | 0) < ($dimension_tib2_0_lcssa_i490 | 0) | ($tib1_0_lcssa_i482 | 0) == 0) { - label = 115; - break; - } else { - $tib1_121_i494 = $tib1_0_lcssa_i482; - label = 110; - break; - } - case 110: - if (($tib1_121_i494 | 0) == ($tib2_0_lcssa_i491 | 0)) { - label = 54; - break; - } else { - label = 111; - break; - } - case 111: - $i_0_i497 = 0; - label = 112; - break; - case 112: - if (($i_0_i497 | 0) < (HEAP32[($tib1_121_i494 + 108 | 0) >> 2] | 0 | 0)) { - label = 113; - break; - } else { - label = 114; - break; - } - case 113: - if ((HEAP32[((HEAP32[($tib1_121_i494 + 112 | 0) >> 2] | 0) + ($i_0_i497 << 2) | 0) >> 2] | 0 | 0) == ($tib2_0_lcssa_i491 | 0)) { - label = 54; - break; - } else { - $i_0_i497 = $i_0_i497 + 1 | 0; - label = 112; - break; - } - case 114: - $507 = HEAP32[($tib1_121_i494 + 40 | 0) >> 2] | 0; - if (($507 | 0) == 0) { - label = 115; - break; - } else { - $tib1_121_i494 = $507; - label = 110; - break; - } - case 115: - invoke_vii(48, HEAP32[$397 >> 2] | 0 | 0, 0 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case 116: - if ((HEAP32[(98772 | 0) >> 2] | 0 | 0) == 0) { - label = 117; - break; - } else { - label = 118; - break; - } - case 117: - invoke_v(702); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 118; - break; - case 118: - if ((HEAP32[(105500 | 0) >> 2] | 0 | 0) == 0) { - label = 119; - break; - } else { - label = 120; - break; - } - case 119: - invoke_v(30); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 120; - break; - case 120: - $519 = invoke_i(70) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $521 = invoke_iii(364, $519 | 0, 0 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - if ((HEAP32[(98148 | 0) >> 2] | 0 | 0) == 0) { - label = 121; - break; - } else { - label = 122; - break; - } - case 121: - invoke_v(408); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 122; - break; - case 122: - $525 = invoke_ii(338, 12 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - HEAP32[$525 >> 2] = 98144; - HEAP32[($525 + 4 | 0) >> 2] = 0; - HEAP32[($525 + 8 | 0) >> 2] = $521; - if ((HEAP32[(97532 | 0) >> 2] | 0 | 0) == 0) { - label = 123; - break; - } else { - $534 = 98144; - label = 124; - break; - } - case 123: - invoke_v(568); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $534 = HEAP32[$525 >> 2] | 0; - label = 124; - break; - case 124: - $539 = invoke_ii(HEAP32[(HEAP32[($534 + 116 | 0) >> 2] | 0) >> 2] | 0 | 0, $525 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $_r2_sroa_0 = $539; - _memcpy(HEAP32[$429 >> 2] | 0 | 0, $427 | 0, 40); - $542 = ($_r2_sroa_0 | 0) == 0; - if ((HEAP32[(105500 | 0) >> 2] | 0 | 0) == 0) { - label = 125; - break; - } else { - label = 126; - break; - } - case 125: - invoke_v(30); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 126; - break; - case 126: - $546 = invoke_i(70) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $548 = invoke_iii(364, $546 | 0, 0 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - if ($542) { - label = 240; - break; - } else { - label = 144; - break; - } - case 127: - _memcpy(HEAP32[$429 >> 2] | 0 | 0, $427 | 0, 40); - if ((HEAP32[(107740 | 0) >> 2] | 0 | 0) == 0) { - label = 128; - break; - } else { - label = 129; - break; - } - case 128: - invoke_v(374); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 129; - break; - case 129: - $557 = HEAP32[($426 + 20 | 0) >> 2] | 0; - if (($557 | 0) == 0) { - label = 143; - break; - } else { - label = 130; - break; - } - case 130: - $562 = HEAP32[$557 >> 2] | 0; - $566 = HEAP32[((HEAP32[137616 >> 2] | 0) + 8 | 0) >> 2] | 0; - if (($562 | 0) == 82712) { - label = 131; - break; - } else { - $tib1_0_ph_i458 = $562; - label = 132; - break; - } - case 131: - $tib1_0_ph_i458 = HEAP32[((HEAP32[($557 + 8 | 0) >> 2] | 0) + 8 | 0) >> 2] | 0; - label = 132; - break; - case 132: - $577 = HEAP32[($tib1_0_ph_i458 + 56 | 0) >> 2] | 0; - if (($577 | 0) == 0) { - $dimension_tib1_0_lcssa_i462 = 0; - $tib1_0_lcssa_i461 = $tib1_0_ph_i458; - label = 134; - break; - } else { - $dimension_tib1_029_i464 = 0; - $584 = $577; - label = 135; - break; - } - case 133: - $dimension_tib1_0_lcssa_i462 = $588; - $tib1_0_lcssa_i461 = $587; - label = 134; - break; - case 134: - $582 = HEAP32[($566 + 56 | 0) >> 2] | 0; - if (($582 | 0) == 0) { - $dimension_tib2_0_lcssa_i469 = 0; - $tib2_0_lcssa_in_i468 = $566; - label = 137; - break; - } else { - $dimension_tib2_024_i466 = 0; - $593 = $582; - label = 136; - break; - } - case 135: - $587 = HEAP32[($584 + 8 | 0) >> 2] | 0; - $588 = $dimension_tib1_029_i464 + 1 | 0; - $591 = HEAP32[($587 + 56 | 0) >> 2] | 0; - if (($591 | 0) == 0) { - label = 133; - break; - } else { - $dimension_tib1_029_i464 = $588; - $584 = $591; - label = 135; - break; - } - case 136: - $596 = HEAP32[($593 + 8 | 0) >> 2] | 0; - $597 = $dimension_tib2_024_i466 + 1 | 0; - $600 = HEAP32[($596 + 56 | 0) >> 2] | 0; - if (($600 | 0) == 0) { - $dimension_tib2_0_lcssa_i469 = $597; - $tib2_0_lcssa_in_i468 = $596; - label = 137; - break; - } else { - $dimension_tib2_024_i466 = $597; - $593 = $600; - label = 136; - break; - } - case 137: - $tib2_0_lcssa_i470 = $tib2_0_lcssa_in_i468; - if (($dimension_tib1_0_lcssa_i462 | 0) < ($dimension_tib2_0_lcssa_i469 | 0) | ($tib1_0_lcssa_i461 | 0) == 0) { - label = 143; - break; - } else { - $tib1_121_i473 = $tib1_0_lcssa_i461; - label = 138; - break; - } - case 138: - if (($tib1_121_i473 | 0) == ($tib2_0_lcssa_i470 | 0)) { - label = 54; - break; - } else { - label = 139; - break; - } - case 139: - $i_0_i476 = 0; - label = 140; - break; - case 140: - if (($i_0_i476 | 0) < (HEAP32[($tib1_121_i473 + 108 | 0) >> 2] | 0 | 0)) { - label = 141; - break; - } else { - label = 142; - break; - } - case 141: - if ((HEAP32[((HEAP32[($tib1_121_i473 + 112 | 0) >> 2] | 0) + ($i_0_i476 << 2) | 0) >> 2] | 0 | 0) == ($tib2_0_lcssa_i470 | 0)) { - label = 54; - break; - } else { - $i_0_i476 = $i_0_i476 + 1 | 0; - label = 140; - break; - } - case 142: - $618 = HEAP32[($tib1_121_i473 + 40 | 0) >> 2] | 0; - if (($618 | 0) == 0) { - label = 143; - break; - } else { - $tib1_121_i473 = $618; - label = 138; - break; - } - case 143: - invoke_vii(48, HEAP32[$429 >> 2] | 0 | 0, 0 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case 144: - $623 = $local_env_w4567aaac23b1c29; - $625 = $548 + 16 | 0; - _memcpy($623 | 0, HEAP32[$625 >> 2] | 0 | 0, 40); - $629 = _saveSetjmp(HEAP32[$625 >> 2] | 0 | 0, label, setjmpTable) | 0; - label = 418; - break; - case 418: - if (($629 | 0) == 0) { - label = 145; - break; - } else { - label = 146; - break; - } - case 145: - $632 = invoke_ii(556, 709 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $_r0_sroa_0 = $632; - $_r0_sroa_0 = 0; - $_r3_sroa_0 = $_r0_sroa_0; - HEAP32[($_r3_sroa_1 | 0) >> 2] = HEAP32[($_r0_sroa_1 | 0) >> 2] | 0; - _memcpy(HEAP32[$625 >> 2] | 0 | 0, $623 | 0, 40); - label = 179; - break; - case 146: - _memcpy(HEAP32[$625 >> 2] | 0 | 0, $623 | 0, 40); - if ((HEAP32[(113236 | 0) >> 2] | 0 | 0) == 0) { - label = 147; - break; - } else { - label = 148; - break; - } - case 147: - invoke_v(538); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 148; - break; - case 148: - $643 = $548 + 20 | 0; - $644 = HEAP32[$643 >> 2] | 0; - if (($644 | 0) == 0) { - label = 162; - break; - } else { - label = 149; - break; - } - case 149: - $649 = HEAP32[$644 >> 2] | 0; - $653 = HEAP32[((HEAP32[138672 >> 2] | 0) + 8 | 0) >> 2] | 0; - if (($649 | 0) == 82712) { - label = 150; - break; - } else { - $tib1_0_ph_i437 = $649; - label = 151; - break; - } - case 150: - $tib1_0_ph_i437 = HEAP32[((HEAP32[($644 + 8 | 0) >> 2] | 0) + 8 | 0) >> 2] | 0; - label = 151; - break; - case 151: - $664 = HEAP32[($tib1_0_ph_i437 + 56 | 0) >> 2] | 0; - if (($664 | 0) == 0) { - $dimension_tib1_0_lcssa_i441 = 0; - $tib1_0_lcssa_i440 = $tib1_0_ph_i437; - label = 153; - break; - } else { - $dimension_tib1_029_i443 = 0; - $671 = $664; - label = 154; - break; - } - case 152: - $dimension_tib1_0_lcssa_i441 = $675; - $tib1_0_lcssa_i440 = $674; - label = 153; - break; - case 153: - $669 = HEAP32[($653 + 56 | 0) >> 2] | 0; - if (($669 | 0) == 0) { - $dimension_tib2_0_lcssa_i448 = 0; - $tib2_0_lcssa_in_i447 = $653; - label = 156; - break; - } else { - $dimension_tib2_024_i445 = 0; - $680 = $669; - label = 155; - break; - } - case 154: - $674 = HEAP32[($671 + 8 | 0) >> 2] | 0; - $675 = $dimension_tib1_029_i443 + 1 | 0; - $678 = HEAP32[($674 + 56 | 0) >> 2] | 0; - if (($678 | 0) == 0) { - label = 152; - break; - } else { - $dimension_tib1_029_i443 = $675; - $671 = $678; - label = 154; - break; - } - case 155: - $683 = HEAP32[($680 + 8 | 0) >> 2] | 0; - $684 = $dimension_tib2_024_i445 + 1 | 0; - $687 = HEAP32[($683 + 56 | 0) >> 2] | 0; - if (($687 | 0) == 0) { - $dimension_tib2_0_lcssa_i448 = $684; - $tib2_0_lcssa_in_i447 = $683; - label = 156; - break; - } else { - $dimension_tib2_024_i445 = $684; - $680 = $687; - label = 155; - break; - } - case 156: - $tib2_0_lcssa_i449 = $tib2_0_lcssa_in_i447; - if (($dimension_tib1_0_lcssa_i441 | 0) < ($dimension_tib2_0_lcssa_i448 | 0) | ($tib1_0_lcssa_i440 | 0) == 0) { - label = 162; - break; - } else { - $tib1_121_i452 = $tib1_0_lcssa_i440; - label = 157; - break; - } - case 157: - if (($tib1_121_i452 | 0) == ($tib2_0_lcssa_i449 | 0)) { - label = 361; - break; - } else { - label = 158; - break; - } - case 158: - $i_0_i455 = 0; - label = 159; - break; - case 159: - if (($i_0_i455 | 0) < (HEAP32[($tib1_121_i452 + 108 | 0) >> 2] | 0 | 0)) { - label = 160; - break; - } else { - label = 161; - break; - } - case 160: - if ((HEAP32[((HEAP32[($tib1_121_i452 + 112 | 0) >> 2] | 0) + ($i_0_i455 << 2) | 0) >> 2] | 0 | 0) == ($tib2_0_lcssa_i449 | 0)) { - label = 361; - break; - } else { - $i_0_i455 = $i_0_i455 + 1 | 0; - label = 159; - break; - } - case 161: - $705 = HEAP32[($tib1_121_i452 + 40 | 0) >> 2] | 0; - if (($705 | 0) == 0) { - label = 162; - break; - } else { - $tib1_121_i452 = $705; - label = 157; - break; - } - case 162: - if ((HEAP32[(107740 | 0) >> 2] | 0 | 0) == 0) { - label = 163; - break; - } else { - label = 164; - break; - } - case 163: - invoke_v(374); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 164; - break; - case 164: - $711 = HEAP32[$643 >> 2] | 0; - if (($711 | 0) == 0) { - label = 178; - break; - } else { - label = 165; - break; - } - case 165: - $716 = HEAP32[$711 >> 2] | 0; - $720 = HEAP32[((HEAP32[137616 >> 2] | 0) + 8 | 0) >> 2] | 0; - if (($716 | 0) == 82712) { - label = 166; - break; - } else { - $tib1_0_ph_i416 = $716; - label = 167; - break; - } - case 166: - $tib1_0_ph_i416 = HEAP32[((HEAP32[($711 + 8 | 0) >> 2] | 0) + 8 | 0) >> 2] | 0; - label = 167; - break; - case 167: - $731 = HEAP32[($tib1_0_ph_i416 + 56 | 0) >> 2] | 0; - if (($731 | 0) == 0) { - $dimension_tib1_0_lcssa_i420 = 0; - $tib1_0_lcssa_i419 = $tib1_0_ph_i416; - label = 169; - break; - } else { - $dimension_tib1_029_i422 = 0; - $738 = $731; - label = 170; - break; - } - case 168: - $dimension_tib1_0_lcssa_i420 = $742; - $tib1_0_lcssa_i419 = $741; - label = 169; - break; - case 169: - $736 = HEAP32[($720 + 56 | 0) >> 2] | 0; - if (($736 | 0) == 0) { - $dimension_tib2_0_lcssa_i427 = 0; - $tib2_0_lcssa_in_i426 = $720; - label = 172; - break; - } else { - $dimension_tib2_024_i424 = 0; - $747 = $736; - label = 171; - break; - } - case 170: - $741 = HEAP32[($738 + 8 | 0) >> 2] | 0; - $742 = $dimension_tib1_029_i422 + 1 | 0; - $745 = HEAP32[($741 + 56 | 0) >> 2] | 0; - if (($745 | 0) == 0) { - label = 168; - break; - } else { - $dimension_tib1_029_i422 = $742; - $738 = $745; - label = 170; - break; - } - case 171: - $750 = HEAP32[($747 + 8 | 0) >> 2] | 0; - $751 = $dimension_tib2_024_i424 + 1 | 0; - $754 = HEAP32[($750 + 56 | 0) >> 2] | 0; - if (($754 | 0) == 0) { - $dimension_tib2_0_lcssa_i427 = $751; - $tib2_0_lcssa_in_i426 = $750; - label = 172; - break; - } else { - $dimension_tib2_024_i424 = $751; - $747 = $754; - label = 171; - break; - } - case 172: - $tib2_0_lcssa_i428 = $tib2_0_lcssa_in_i426; - if (($dimension_tib1_0_lcssa_i420 | 0) < ($dimension_tib2_0_lcssa_i427 | 0) | ($tib1_0_lcssa_i419 | 0) == 0) { - label = 178; - break; - } else { - $tib1_121_i431 = $tib1_0_lcssa_i419; - label = 173; - break; - } - case 173: - if (($tib1_121_i431 | 0) == ($tib2_0_lcssa_i428 | 0)) { - label = 386; - break; - } else { - label = 174; - break; - } - case 174: - $i_0_i434 = 0; - label = 175; - break; - case 175: - if (($i_0_i434 | 0) < (HEAP32[($tib1_121_i431 + 108 | 0) >> 2] | 0 | 0)) { - label = 176; - break; - } else { - label = 177; - break; - } - case 176: - if ((HEAP32[((HEAP32[($tib1_121_i431 + 112 | 0) >> 2] | 0) + ($i_0_i434 << 2) | 0) >> 2] | 0 | 0) == ($tib2_0_lcssa_i428 | 0)) { - label = 386; - break; - } else { - $i_0_i434 = $i_0_i434 + 1 | 0; - label = 175; - break; - } - case 177: - $772 = HEAP32[($tib1_121_i431 + 40 | 0) >> 2] | 0; - if (($772 | 0) == 0) { - label = 178; - break; - } else { - $tib1_121_i431 = $772; - label = 173; - break; - } - case 178: - invoke_vii(48, HEAP32[$625 >> 2] | 0 | 0, 0 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case 179: - if ((HEAP32[(105500 | 0) >> 2] | 0 | 0) == 0) { - label = 180; - break; - } else { - label = 181; - break; - } - case 180: - invoke_v(30); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 181; - break; - case 181: - $780 = invoke_i(70) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $782 = invoke_iii(364, $780 | 0, 0 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $783 = $local_env_w4567aaac23b1c31; - $785 = $782 + 16 | 0; - _memcpy($783 | 0, HEAP32[$785 >> 2] | 0 | 0, 40); - $789 = _saveSetjmp(HEAP32[$785 >> 2] | 0 | 0, label, setjmpTable) | 0; - label = 419; - break; - case 419: - if (($789 | 0) == 0) { - label = 182; - break; - } else { - label = 183; - break; - } - case 182: - $798 = invoke_ii(HEAP32[(HEAP32[((HEAP32[$_r3_sroa_0 >> 2] | 0) + 116 | 0) >> 2] | 0) >> 2] | 0 | 0, $_r3_sroa_0 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $_r0_sroa_0 = $798; - _memcpy(HEAP32[$785 >> 2] | 0 | 0, $783 | 0, 40); - if (($_r0_sroa_0 | 0) == 0) { - label = 216; - break; - } else { - label = 322; - break; - } - case 183: - _memcpy(HEAP32[$785 >> 2] | 0 | 0, $783 | 0, 40); - if ((HEAP32[(113236 | 0) >> 2] | 0 | 0) == 0) { - label = 184; - break; - } else { - label = 185; - break; - } - case 184: - invoke_v(538); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 185; - break; - case 185: - $808 = $782 + 20 | 0; - $809 = HEAP32[$808 >> 2] | 0; - if (($809 | 0) == 0) { - label = 199; - break; - } else { - label = 186; - break; - } - case 186: - $814 = HEAP32[$809 >> 2] | 0; - $818 = HEAP32[((HEAP32[138672 >> 2] | 0) + 8 | 0) >> 2] | 0; - if (($814 | 0) == 82712) { - label = 187; - break; - } else { - $tib1_0_ph_i395 = $814; - label = 188; - break; - } - case 187: - $tib1_0_ph_i395 = HEAP32[((HEAP32[($809 + 8 | 0) >> 2] | 0) + 8 | 0) >> 2] | 0; - label = 188; - break; - case 188: - $829 = HEAP32[($tib1_0_ph_i395 + 56 | 0) >> 2] | 0; - if (($829 | 0) == 0) { - $dimension_tib1_0_lcssa_i399 = 0; - $tib1_0_lcssa_i398 = $tib1_0_ph_i395; - label = 190; - break; - } else { - $dimension_tib1_029_i401 = 0; - $836 = $829; - label = 191; - break; - } - case 189: - $dimension_tib1_0_lcssa_i399 = $840; - $tib1_0_lcssa_i398 = $839; - label = 190; - break; - case 190: - $834 = HEAP32[($818 + 56 | 0) >> 2] | 0; - if (($834 | 0) == 0) { - $dimension_tib2_0_lcssa_i406 = 0; - $tib2_0_lcssa_in_i405 = $818; - label = 193; - break; - } else { - $dimension_tib2_024_i403 = 0; - $845 = $834; - label = 192; - break; - } - case 191: - $839 = HEAP32[($836 + 8 | 0) >> 2] | 0; - $840 = $dimension_tib1_029_i401 + 1 | 0; - $843 = HEAP32[($839 + 56 | 0) >> 2] | 0; - if (($843 | 0) == 0) { - label = 189; - break; - } else { - $dimension_tib1_029_i401 = $840; - $836 = $843; - label = 191; - break; - } - case 192: - $848 = HEAP32[($845 + 8 | 0) >> 2] | 0; - $849 = $dimension_tib2_024_i403 + 1 | 0; - $852 = HEAP32[($848 + 56 | 0) >> 2] | 0; - if (($852 | 0) == 0) { - $dimension_tib2_0_lcssa_i406 = $849; - $tib2_0_lcssa_in_i405 = $848; - label = 193; - break; - } else { - $dimension_tib2_024_i403 = $849; - $845 = $852; - label = 192; - break; - } - case 193: - $tib2_0_lcssa_i407 = $tib2_0_lcssa_in_i405; - if (($dimension_tib1_0_lcssa_i399 | 0) < ($dimension_tib2_0_lcssa_i406 | 0) | ($tib1_0_lcssa_i398 | 0) == 0) { - label = 199; - break; - } else { - $tib1_121_i410 = $tib1_0_lcssa_i398; - label = 194; - break; - } - case 194: - if (($tib1_121_i410 | 0) == ($tib2_0_lcssa_i407 | 0)) { - label = 361; - break; - } else { - label = 195; - break; - } - case 195: - $i_0_i413 = 0; - label = 196; - break; - case 196: - if (($i_0_i413 | 0) < (HEAP32[($tib1_121_i410 + 108 | 0) >> 2] | 0 | 0)) { - label = 197; - break; - } else { - label = 198; - break; - } - case 197: - if ((HEAP32[((HEAP32[($tib1_121_i410 + 112 | 0) >> 2] | 0) + ($i_0_i413 << 2) | 0) >> 2] | 0 | 0) == ($tib2_0_lcssa_i407 | 0)) { - label = 361; - break; - } else { - $i_0_i413 = $i_0_i413 + 1 | 0; - label = 196; - break; - } - case 198: - $870 = HEAP32[($tib1_121_i410 + 40 | 0) >> 2] | 0; - if (($870 | 0) == 0) { - label = 199; - break; - } else { - $tib1_121_i410 = $870; - label = 194; - break; - } - case 199: - if ((HEAP32[(107740 | 0) >> 2] | 0 | 0) == 0) { - label = 200; - break; - } else { - label = 201; - break; - } - case 200: - invoke_v(374); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 201; - break; - case 201: - $876 = HEAP32[$808 >> 2] | 0; - if (($876 | 0) == 0) { - label = 215; - break; - } else { - label = 202; - break; - } - case 202: - $881 = HEAP32[$876 >> 2] | 0; - $885 = HEAP32[((HEAP32[137616 >> 2] | 0) + 8 | 0) >> 2] | 0; - if (($881 | 0) == 82712) { - label = 203; - break; - } else { - $tib1_0_ph_i374 = $881; - label = 204; - break; - } - case 203: - $tib1_0_ph_i374 = HEAP32[((HEAP32[($876 + 8 | 0) >> 2] | 0) + 8 | 0) >> 2] | 0; - label = 204; - break; - case 204: - $896 = HEAP32[($tib1_0_ph_i374 + 56 | 0) >> 2] | 0; - if (($896 | 0) == 0) { - $dimension_tib1_0_lcssa_i378 = 0; - $tib1_0_lcssa_i377 = $tib1_0_ph_i374; - label = 206; - break; - } else { - $dimension_tib1_029_i380 = 0; - $903 = $896; - label = 207; - break; - } - case 205: - $dimension_tib1_0_lcssa_i378 = $907; - $tib1_0_lcssa_i377 = $906; - label = 206; - break; - case 206: - $901 = HEAP32[($885 + 56 | 0) >> 2] | 0; - if (($901 | 0) == 0) { - $dimension_tib2_0_lcssa_i385 = 0; - $tib2_0_lcssa_in_i384 = $885; - label = 209; - break; - } else { - $dimension_tib2_024_i382 = 0; - $912 = $901; - label = 208; - break; - } - case 207: - $906 = HEAP32[($903 + 8 | 0) >> 2] | 0; - $907 = $dimension_tib1_029_i380 + 1 | 0; - $910 = HEAP32[($906 + 56 | 0) >> 2] | 0; - if (($910 | 0) == 0) { - label = 205; - break; - } else { - $dimension_tib1_029_i380 = $907; - $903 = $910; - label = 207; - break; - } - case 208: - $915 = HEAP32[($912 + 8 | 0) >> 2] | 0; - $916 = $dimension_tib2_024_i382 + 1 | 0; - $919 = HEAP32[($915 + 56 | 0) >> 2] | 0; - if (($919 | 0) == 0) { - $dimension_tib2_0_lcssa_i385 = $916; - $tib2_0_lcssa_in_i384 = $915; - label = 209; - break; - } else { - $dimension_tib2_024_i382 = $916; - $912 = $919; - label = 208; - break; - } - case 209: - $tib2_0_lcssa_i386 = $tib2_0_lcssa_in_i384; - if (($dimension_tib1_0_lcssa_i378 | 0) < ($dimension_tib2_0_lcssa_i385 | 0) | ($tib1_0_lcssa_i377 | 0) == 0) { - label = 215; - break; - } else { - $tib1_121_i389 = $tib1_0_lcssa_i377; - label = 210; - break; - } - case 210: - if (($tib1_121_i389 | 0) == ($tib2_0_lcssa_i386 | 0)) { - label = 386; - break; - } else { - label = 211; - break; - } - case 211: - $i_0_i392 = 0; - label = 212; - break; - case 212: - if (($i_0_i392 | 0) < (HEAP32[($tib1_121_i389 + 108 | 0) >> 2] | 0 | 0)) { - label = 213; - break; - } else { - label = 214; - break; - } - case 213: - if ((HEAP32[((HEAP32[($tib1_121_i389 + 112 | 0) >> 2] | 0) + ($i_0_i392 << 2) | 0) >> 2] | 0 | 0) == ($tib2_0_lcssa_i386 | 0)) { - label = 386; - break; - } else { - $i_0_i392 = $i_0_i392 + 1 | 0; - label = 212; - break; - } - case 214: - $937 = HEAP32[($tib1_121_i389 + 40 | 0) >> 2] | 0; - if (($937 | 0) == 0) { - label = 215; - break; - } else { - $tib1_121_i389 = $937; - label = 210; - break; - } - case 215: - invoke_vii(48, HEAP32[$785 >> 2] | 0 | 0, 0 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case 216: - $_r0_sroa_0 = 0; - if ((HEAP32[(105500 | 0) >> 2] | 0 | 0) == 0) { - label = 217; - break; - } else { - label = 218; - break; - } - case 217: - invoke_v(30); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 218; - break; - case 218: - $945 = invoke_i(70) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $947 = invoke_iii(364, $945 | 0, 0 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $948 = $local_env_w4567aaac23b1c35; - $950 = $947 + 16 | 0; - _memcpy($948 | 0, HEAP32[$950 >> 2] | 0 | 0, 40); - $954 = _saveSetjmp(HEAP32[$950 >> 2] | 0 | 0, label, setjmpTable) | 0; - label = 420; - break; - case 420: - if (($954 | 0) == 0) { - label = 219; - break; - } else { - label = 222; - break; - } - case 219: - $_r0_sroa_0_0_load607 = $_r0_sroa_0; - if ((HEAP32[(98772 | 0) >> 2] | 0 | 0) == 0) { - label = 220; - break; - } else { - label = 221; - break; - } - case 220: - invoke_v(702); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 221; - break; - case 221: - HEAP32[140048 >> 2] = $_r0_sroa_0_0_load607; - _memcpy(HEAP32[$950 >> 2] | 0 | 0, $948 | 0, 40); - label = 239; - break; - case 222: - _memcpy(HEAP32[$950 >> 2] | 0 | 0, $948 | 0, 40); - if ((HEAP32[(107740 | 0) >> 2] | 0 | 0) == 0) { - label = 223; - break; - } else { - label = 224; - break; - } - case 223: - invoke_v(374); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 224; - break; - case 224: - $969 = HEAP32[($947 + 20 | 0) >> 2] | 0; - if (($969 | 0) == 0) { - label = 238; - break; - } else { - label = 225; - break; - } - case 225: - $974 = HEAP32[$969 >> 2] | 0; - $978 = HEAP32[((HEAP32[137616 >> 2] | 0) + 8 | 0) >> 2] | 0; - if (($974 | 0) == 82712) { - label = 226; - break; - } else { - $tib1_0_ph_i353 = $974; - label = 227; - break; - } - case 226: - $tib1_0_ph_i353 = HEAP32[((HEAP32[($969 + 8 | 0) >> 2] | 0) + 8 | 0) >> 2] | 0; - label = 227; - break; - case 227: - $989 = HEAP32[($tib1_0_ph_i353 + 56 | 0) >> 2] | 0; - if (($989 | 0) == 0) { - $dimension_tib1_0_lcssa_i357 = 0; - $tib1_0_lcssa_i356 = $tib1_0_ph_i353; - label = 229; - break; - } else { - $dimension_tib1_029_i359 = 0; - $996 = $989; - label = 230; - break; - } - case 228: - $dimension_tib1_0_lcssa_i357 = $1000; - $tib1_0_lcssa_i356 = $999; - label = 229; - break; - case 229: - $994 = HEAP32[($978 + 56 | 0) >> 2] | 0; - if (($994 | 0) == 0) { - $dimension_tib2_0_lcssa_i364 = 0; - $tib2_0_lcssa_in_i363 = $978; - label = 232; - break; - } else { - $dimension_tib2_024_i361 = 0; - $1005 = $994; - label = 231; - break; - } - case 230: - $999 = HEAP32[($996 + 8 | 0) >> 2] | 0; - $1000 = $dimension_tib1_029_i359 + 1 | 0; - $1003 = HEAP32[($999 + 56 | 0) >> 2] | 0; - if (($1003 | 0) == 0) { - label = 228; - break; - } else { - $dimension_tib1_029_i359 = $1000; - $996 = $1003; - label = 230; - break; - } - case 231: - $1008 = HEAP32[($1005 + 8 | 0) >> 2] | 0; - $1009 = $dimension_tib2_024_i361 + 1 | 0; - $1012 = HEAP32[($1008 + 56 | 0) >> 2] | 0; - if (($1012 | 0) == 0) { - $dimension_tib2_0_lcssa_i364 = $1009; - $tib2_0_lcssa_in_i363 = $1008; - label = 232; - break; - } else { - $dimension_tib2_024_i361 = $1009; - $1005 = $1012; - label = 231; - break; - } - case 232: - $tib2_0_lcssa_i365 = $tib2_0_lcssa_in_i363; - if (($dimension_tib1_0_lcssa_i357 | 0) < ($dimension_tib2_0_lcssa_i364 | 0) | ($tib1_0_lcssa_i356 | 0) == 0) { - label = 238; - break; - } else { - $tib1_121_i368 = $tib1_0_lcssa_i356; - label = 233; - break; - } - case 233: - if (($tib1_121_i368 | 0) == ($tib2_0_lcssa_i365 | 0)) { - label = 54; - break; - } else { - label = 234; - break; - } - case 234: - $i_0_i371 = 0; - label = 235; - break; - case 235: - if (($i_0_i371 | 0) < (HEAP32[($tib1_121_i368 + 108 | 0) >> 2] | 0 | 0)) { - label = 236; - break; - } else { - label = 237; - break; - } - case 236: - if ((HEAP32[((HEAP32[($tib1_121_i368 + 112 | 0) >> 2] | 0) + ($i_0_i371 << 2) | 0) >> 2] | 0 | 0) == ($tib2_0_lcssa_i365 | 0)) { - label = 54; - break; - } else { - $i_0_i371 = $i_0_i371 + 1 | 0; - label = 235; - break; - } - case 237: - $1030 = HEAP32[($tib1_121_i368 + 40 | 0) >> 2] | 0; - if (($1030 | 0) == 0) { - label = 238; - break; - } else { - $tib1_121_i368 = $1030; - label = 233; - break; - } - case 238: - invoke_vii(48, HEAP32[$950 >> 2] | 0 | 0, 0 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case 239: - $_r0_sroa_0 = 0; - label = 28; - break; - case 240: - $1036 = $local_env_w4567aaac23b1c40; - $1038 = $548 + 16 | 0; - _memcpy($1036 | 0, HEAP32[$1038 >> 2] | 0 | 0, 40); - $1042 = _saveSetjmp(HEAP32[$1038 >> 2] | 0 | 0, label, setjmpTable) | 0; - label = 421; - break; - case 421: - if (($1042 | 0) == 0) { - label = 241; - break; - } else { - label = 253; - break; - } - case 241: - if ((HEAP32[(98772 | 0) >> 2] | 0 | 0) == 0) { - label = 242; - break; - } else { - label = 244; - break; - } - case 242: - invoke_v(702); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - if ((HEAP32[(98772 | 0) >> 2] | 0 | 0) == 0) { - label = 243; - break; - } else { - label = 244; - break; - } - case 243: - invoke_v(702); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 244; - break; - case 244: - $1050 = HEAP32[140040 >> 2] | 0; - if (($1050 | 0) == 0) { - label = 245; - break; - } else { - label = 246; - break; - } - case 245: - invoke_viiii(14, 16136 | 0 | 0, 11648 | 0 | 0, 126768 | 0 | 0, 573 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case 246: - if ((HEAP32[(98772 | 0) >> 2] | 0 | 0) == 0) { - label = 247; - break; - } else { - $1056 = $1050; - label = 248; - break; - } - case 247: - invoke_v(702); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $1056 = HEAP32[140040 >> 2] | 0; - label = 248; - break; - case 248: - $_r0_sroa_0 = $1056; - if (($_r0_sroa_0 | 0) == 0) { - label = 252; - break; - } else { - label = 249; - break; - } - case 249: - _memcpy(HEAP32[$1038 >> 2] | 0 | 0, $1036 | 0, 40); - if ((HEAP32[(105500 | 0) >> 2] | 0 | 0) == 0) { - label = 250; - break; - } else { - label = 251; - break; - } - case 250: - invoke_v(30); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 251; - break; - case 251: - $1064 = invoke_i(70) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $1066 = invoke_iii(364, $1064 | 0, 0 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $1067 = $local_env_w4567aaac23b1c42; - $1069 = $1066 + 16 | 0; - _memcpy($1067 | 0, HEAP32[$1069 >> 2] | 0 | 0, 40); - $1073 = _saveSetjmp(HEAP32[$1069 >> 2] | 0 | 0, label, setjmpTable) | 0; - label = 422; - break; - case 422: - if (($1073 | 0) == 0) { - label = 286; - break; - } else { - label = 289; - break; - } - case 252: - invoke_viiii(14, 16136 | 0 | 0, 11648 | 0 | 0, 126872 | 0 | 0, 1581 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case 253: - _memcpy(HEAP32[$1038 >> 2] | 0 | 0, $1036 | 0, 40); - if ((HEAP32[(113236 | 0) >> 2] | 0 | 0) == 0) { - label = 254; - break; - } else { - label = 255; - break; - } - case 254: - invoke_v(538); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 255; - break; - case 255: - $1083 = $548 + 20 | 0; - $1084 = HEAP32[$1083 >> 2] | 0; - if (($1084 | 0) == 0) { - label = 269; - break; - } else { - label = 256; - break; - } - case 256: - $1089 = HEAP32[$1084 >> 2] | 0; - $1093 = HEAP32[((HEAP32[138672 >> 2] | 0) + 8 | 0) >> 2] | 0; - if (($1089 | 0) == 82712) { - label = 257; - break; - } else { - $tib1_0_ph_i332 = $1089; - label = 258; - break; - } - case 257: - $tib1_0_ph_i332 = HEAP32[((HEAP32[($1084 + 8 | 0) >> 2] | 0) + 8 | 0) >> 2] | 0; - label = 258; - break; - case 258: - $1104 = HEAP32[($tib1_0_ph_i332 + 56 | 0) >> 2] | 0; - if (($1104 | 0) == 0) { - $dimension_tib1_0_lcssa_i336 = 0; - $tib1_0_lcssa_i335 = $tib1_0_ph_i332; - label = 260; - break; - } else { - $dimension_tib1_029_i338 = 0; - $1111 = $1104; - label = 261; - break; - } - case 259: - $dimension_tib1_0_lcssa_i336 = $1115; - $tib1_0_lcssa_i335 = $1114; - label = 260; - break; - case 260: - $1109 = HEAP32[($1093 + 56 | 0) >> 2] | 0; - if (($1109 | 0) == 0) { - $dimension_tib2_0_lcssa_i343 = 0; - $tib2_0_lcssa_in_i342 = $1093; - label = 263; - break; - } else { - $dimension_tib2_024_i340 = 0; - $1120 = $1109; - label = 262; - break; - } - case 261: - $1114 = HEAP32[($1111 + 8 | 0) >> 2] | 0; - $1115 = $dimension_tib1_029_i338 + 1 | 0; - $1118 = HEAP32[($1114 + 56 | 0) >> 2] | 0; - if (($1118 | 0) == 0) { - label = 259; - break; - } else { - $dimension_tib1_029_i338 = $1115; - $1111 = $1118; - label = 261; - break; - } - case 262: - $1123 = HEAP32[($1120 + 8 | 0) >> 2] | 0; - $1124 = $dimension_tib2_024_i340 + 1 | 0; - $1127 = HEAP32[($1123 + 56 | 0) >> 2] | 0; - if (($1127 | 0) == 0) { - $dimension_tib2_0_lcssa_i343 = $1124; - $tib2_0_lcssa_in_i342 = $1123; - label = 263; - break; - } else { - $dimension_tib2_024_i340 = $1124; - $1120 = $1127; - label = 262; - break; - } - case 263: - $tib2_0_lcssa_i344 = $tib2_0_lcssa_in_i342; - if (($dimension_tib1_0_lcssa_i336 | 0) < ($dimension_tib2_0_lcssa_i343 | 0) | ($tib1_0_lcssa_i335 | 0) == 0) { - label = 269; - break; - } else { - $tib1_121_i347 = $tib1_0_lcssa_i335; - label = 264; - break; - } - case 264: - if (($tib1_121_i347 | 0) == ($tib2_0_lcssa_i344 | 0)) { - label = 361; - break; - } else { - label = 265; - break; - } - case 265: - $i_0_i350 = 0; - label = 266; - break; - case 266: - if (($i_0_i350 | 0) < (HEAP32[($tib1_121_i347 + 108 | 0) >> 2] | 0 | 0)) { - label = 267; - break; - } else { - label = 268; - break; - } - case 267: - if ((HEAP32[((HEAP32[($tib1_121_i347 + 112 | 0) >> 2] | 0) + ($i_0_i350 << 2) | 0) >> 2] | 0 | 0) == ($tib2_0_lcssa_i344 | 0)) { - label = 361; - break; - } else { - $i_0_i350 = $i_0_i350 + 1 | 0; - label = 266; - break; - } - case 268: - $1145 = HEAP32[($tib1_121_i347 + 40 | 0) >> 2] | 0; - if (($1145 | 0) == 0) { - label = 269; - break; - } else { - $tib1_121_i347 = $1145; - label = 264; - break; - } - case 269: - if ((HEAP32[(107740 | 0) >> 2] | 0 | 0) == 0) { - label = 270; - break; - } else { - label = 271; - break; - } - case 270: - invoke_v(374); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 271; - break; - case 271: - $1151 = HEAP32[$1083 >> 2] | 0; - if (($1151 | 0) == 0) { - label = 285; - break; - } else { - label = 272; - break; - } - case 272: - $1156 = HEAP32[$1151 >> 2] | 0; - $1160 = HEAP32[((HEAP32[137616 >> 2] | 0) + 8 | 0) >> 2] | 0; - if (($1156 | 0) == 82712) { - label = 273; - break; - } else { - $tib1_0_ph_i311 = $1156; - label = 274; - break; - } - case 273: - $tib1_0_ph_i311 = HEAP32[((HEAP32[($1151 + 8 | 0) >> 2] | 0) + 8 | 0) >> 2] | 0; - label = 274; - break; - case 274: - $1171 = HEAP32[($tib1_0_ph_i311 + 56 | 0) >> 2] | 0; - if (($1171 | 0) == 0) { - $dimension_tib1_0_lcssa_i315 = 0; - $tib1_0_lcssa_i314 = $tib1_0_ph_i311; - label = 276; - break; - } else { - $dimension_tib1_029_i317 = 0; - $1178 = $1171; - label = 277; - break; - } - case 275: - $dimension_tib1_0_lcssa_i315 = $1182; - $tib1_0_lcssa_i314 = $1181; - label = 276; - break; - case 276: - $1176 = HEAP32[($1160 + 56 | 0) >> 2] | 0; - if (($1176 | 0) == 0) { - $dimension_tib2_0_lcssa_i322 = 0; - $tib2_0_lcssa_in_i321 = $1160; - label = 279; - break; - } else { - $dimension_tib2_024_i319 = 0; - $1187 = $1176; - label = 278; - break; - } - case 277: - $1181 = HEAP32[($1178 + 8 | 0) >> 2] | 0; - $1182 = $dimension_tib1_029_i317 + 1 | 0; - $1185 = HEAP32[($1181 + 56 | 0) >> 2] | 0; - if (($1185 | 0) == 0) { - label = 275; - break; - } else { - $dimension_tib1_029_i317 = $1182; - $1178 = $1185; - label = 277; - break; - } - case 278: - $1190 = HEAP32[($1187 + 8 | 0) >> 2] | 0; - $1191 = $dimension_tib2_024_i319 + 1 | 0; - $1194 = HEAP32[($1190 + 56 | 0) >> 2] | 0; - if (($1194 | 0) == 0) { - $dimension_tib2_0_lcssa_i322 = $1191; - $tib2_0_lcssa_in_i321 = $1190; - label = 279; - break; - } else { - $dimension_tib2_024_i319 = $1191; - $1187 = $1194; - label = 278; - break; - } - case 279: - $tib2_0_lcssa_i323 = $tib2_0_lcssa_in_i321; - if (($dimension_tib1_0_lcssa_i315 | 0) < ($dimension_tib2_0_lcssa_i322 | 0) | ($tib1_0_lcssa_i314 | 0) == 0) { - label = 285; - break; - } else { - $tib1_121_i326 = $tib1_0_lcssa_i314; - label = 280; - break; - } - case 280: - if (($tib1_121_i326 | 0) == ($tib2_0_lcssa_i323 | 0)) { - label = 386; - break; - } else { - label = 281; - break; - } - case 281: - $i_0_i329 = 0; - label = 282; - break; - case 282: - if (($i_0_i329 | 0) < (HEAP32[($tib1_121_i326 + 108 | 0) >> 2] | 0 | 0)) { - label = 283; - break; - } else { - label = 284; - break; - } - case 283: - if ((HEAP32[((HEAP32[($tib1_121_i326 + 112 | 0) >> 2] | 0) + ($i_0_i329 << 2) | 0) >> 2] | 0 | 0) == ($tib2_0_lcssa_i323 | 0)) { - label = 386; - break; - } else { - $i_0_i329 = $i_0_i329 + 1 | 0; - label = 282; - break; - } - case 284: - $1212 = HEAP32[($tib1_121_i326 + 40 | 0) >> 2] | 0; - if (($1212 | 0) == 0) { - label = 285; - break; - } else { - $tib1_121_i326 = $1212; - label = 280; - break; - } - case 285: - invoke_vii(48, HEAP32[$1038 >> 2] | 0 | 0, 0 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case 286: - if ((HEAP32[(98772 | 0) >> 2] | 0 | 0) == 0) { - label = 287; - break; - } else { - label = 288; - break; - } - case 287: - invoke_v(702); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 288; - break; - case 288: - $_r0_sroa_0 = HEAP32[140040 >> 2] | 0; - $1222 = invoke_ii(556, 709 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $_r3_sroa_0 = $1222; - $_r0_sroa_0 = 0; - $_r3_sroa_0 = $_r0_sroa_0; - HEAP32[($_r3_sroa_1 | 0) >> 2] = HEAP32[($_r0_sroa_1 | 0) >> 2] | 0; - _memcpy(HEAP32[$1069 >> 2] | 0 | 0, $1067 | 0, 40); - label = 179; - break; - case 289: - _memcpy(HEAP32[$1069 >> 2] | 0 | 0, $1067 | 0, 40); - if ((HEAP32[(113236 | 0) >> 2] | 0 | 0) == 0) { - label = 290; - break; - } else { - label = 291; - break; - } - case 290: - invoke_v(538); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 291; - break; - case 291: - $1232 = $1066 + 20 | 0; - $1233 = HEAP32[$1232 >> 2] | 0; - if (($1233 | 0) == 0) { - label = 305; - break; - } else { - label = 292; - break; - } - case 292: - $1238 = HEAP32[$1233 >> 2] | 0; - $1242 = HEAP32[((HEAP32[138672 >> 2] | 0) + 8 | 0) >> 2] | 0; - if (($1238 | 0) == 82712) { - label = 293; - break; - } else { - $tib1_0_ph_i290 = $1238; - label = 294; - break; - } - case 293: - $tib1_0_ph_i290 = HEAP32[((HEAP32[($1233 + 8 | 0) >> 2] | 0) + 8 | 0) >> 2] | 0; - label = 294; - break; - case 294: - $1253 = HEAP32[($tib1_0_ph_i290 + 56 | 0) >> 2] | 0; - if (($1253 | 0) == 0) { - $dimension_tib1_0_lcssa_i294 = 0; - $tib1_0_lcssa_i293 = $tib1_0_ph_i290; - label = 296; - break; - } else { - $dimension_tib1_029_i296 = 0; - $1260 = $1253; - label = 297; - break; - } - case 295: - $dimension_tib1_0_lcssa_i294 = $1264; - $tib1_0_lcssa_i293 = $1263; - label = 296; - break; - case 296: - $1258 = HEAP32[($1242 + 56 | 0) >> 2] | 0; - if (($1258 | 0) == 0) { - $dimension_tib2_0_lcssa_i301 = 0; - $tib2_0_lcssa_in_i300 = $1242; - label = 299; - break; - } else { - $dimension_tib2_024_i298 = 0; - $1269 = $1258; - label = 298; - break; - } - case 297: - $1263 = HEAP32[($1260 + 8 | 0) >> 2] | 0; - $1264 = $dimension_tib1_029_i296 + 1 | 0; - $1267 = HEAP32[($1263 + 56 | 0) >> 2] | 0; - if (($1267 | 0) == 0) { - label = 295; - break; - } else { - $dimension_tib1_029_i296 = $1264; - $1260 = $1267; - label = 297; - break; - } - case 298: - $1272 = HEAP32[($1269 + 8 | 0) >> 2] | 0; - $1273 = $dimension_tib2_024_i298 + 1 | 0; - $1276 = HEAP32[($1272 + 56 | 0) >> 2] | 0; - if (($1276 | 0) == 0) { - $dimension_tib2_0_lcssa_i301 = $1273; - $tib2_0_lcssa_in_i300 = $1272; - label = 299; - break; - } else { - $dimension_tib2_024_i298 = $1273; - $1269 = $1276; - label = 298; - break; - } - case 299: - $tib2_0_lcssa_i302 = $tib2_0_lcssa_in_i300; - if (($dimension_tib1_0_lcssa_i294 | 0) < ($dimension_tib2_0_lcssa_i301 | 0) | ($tib1_0_lcssa_i293 | 0) == 0) { - label = 305; - break; - } else { - $tib1_121_i305 = $tib1_0_lcssa_i293; - label = 300; - break; - } - case 300: - if (($tib1_121_i305 | 0) == ($tib2_0_lcssa_i302 | 0)) { - label = 361; - break; - } else { - label = 301; - break; - } - case 301: - $i_0_i308 = 0; - label = 302; - break; - case 302: - if (($i_0_i308 | 0) < (HEAP32[($tib1_121_i305 + 108 | 0) >> 2] | 0 | 0)) { - label = 303; - break; - } else { - label = 304; - break; - } - case 303: - if ((HEAP32[((HEAP32[($tib1_121_i305 + 112 | 0) >> 2] | 0) + ($i_0_i308 << 2) | 0) >> 2] | 0 | 0) == ($tib2_0_lcssa_i302 | 0)) { - label = 361; - break; - } else { - $i_0_i308 = $i_0_i308 + 1 | 0; - label = 302; - break; - } - case 304: - $1294 = HEAP32[($tib1_121_i305 + 40 | 0) >> 2] | 0; - if (($1294 | 0) == 0) { - label = 305; - break; - } else { - $tib1_121_i305 = $1294; - label = 300; - break; - } - case 305: - if ((HEAP32[(107740 | 0) >> 2] | 0 | 0) == 0) { - label = 306; - break; - } else { - label = 307; - break; - } - case 306: - invoke_v(374); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 307; - break; - case 307: - $1300 = HEAP32[$1232 >> 2] | 0; - if (($1300 | 0) == 0) { - label = 321; - break; - } else { - label = 308; - break; - } - case 308: - $1305 = HEAP32[$1300 >> 2] | 0; - $1309 = HEAP32[((HEAP32[137616 >> 2] | 0) + 8 | 0) >> 2] | 0; - if (($1305 | 0) == 82712) { - label = 309; - break; - } else { - $tib1_0_ph_i269 = $1305; - label = 310; - break; - } - case 309: - $tib1_0_ph_i269 = HEAP32[((HEAP32[($1300 + 8 | 0) >> 2] | 0) + 8 | 0) >> 2] | 0; - label = 310; - break; - case 310: - $1320 = HEAP32[($tib1_0_ph_i269 + 56 | 0) >> 2] | 0; - if (($1320 | 0) == 0) { - $dimension_tib1_0_lcssa_i273 = 0; - $tib1_0_lcssa_i272 = $tib1_0_ph_i269; - label = 312; - break; - } else { - $dimension_tib1_029_i275 = 0; - $1327 = $1320; - label = 313; - break; - } - case 311: - $dimension_tib1_0_lcssa_i273 = $1331; - $tib1_0_lcssa_i272 = $1330; - label = 312; - break; - case 312: - $1325 = HEAP32[($1309 + 56 | 0) >> 2] | 0; - if (($1325 | 0) == 0) { - $dimension_tib2_0_lcssa_i280 = 0; - $tib2_0_lcssa_in_i279 = $1309; - label = 315; - break; - } else { - $dimension_tib2_024_i277 = 0; - $1336 = $1325; - label = 314; - break; - } - case 313: - $1330 = HEAP32[($1327 + 8 | 0) >> 2] | 0; - $1331 = $dimension_tib1_029_i275 + 1 | 0; - $1334 = HEAP32[($1330 + 56 | 0) >> 2] | 0; - if (($1334 | 0) == 0) { - label = 311; - break; - } else { - $dimension_tib1_029_i275 = $1331; - $1327 = $1334; - label = 313; - break; - } - case 314: - $1339 = HEAP32[($1336 + 8 | 0) >> 2] | 0; - $1340 = $dimension_tib2_024_i277 + 1 | 0; - $1343 = HEAP32[($1339 + 56 | 0) >> 2] | 0; - if (($1343 | 0) == 0) { - $dimension_tib2_0_lcssa_i280 = $1340; - $tib2_0_lcssa_in_i279 = $1339; - label = 315; - break; - } else { - $dimension_tib2_024_i277 = $1340; - $1336 = $1343; - label = 314; - break; - } - case 315: - $tib2_0_lcssa_i281 = $tib2_0_lcssa_in_i279; - if (($dimension_tib1_0_lcssa_i273 | 0) < ($dimension_tib2_0_lcssa_i280 | 0) | ($tib1_0_lcssa_i272 | 0) == 0) { - label = 321; - break; - } else { - $tib1_121_i284 = $tib1_0_lcssa_i272; - label = 316; - break; - } - case 316: - if (($tib1_121_i284 | 0) == ($tib2_0_lcssa_i281 | 0)) { - label = 386; - break; - } else { - label = 317; - break; - } - case 317: - $i_0_i287 = 0; - label = 318; - break; - case 318: - if (($i_0_i287 | 0) < (HEAP32[($tib1_121_i284 + 108 | 0) >> 2] | 0 | 0)) { - label = 319; - break; - } else { - label = 320; - break; - } - case 319: - if ((HEAP32[((HEAP32[($tib1_121_i284 + 112 | 0) >> 2] | 0) + ($i_0_i287 << 2) | 0) >> 2] | 0 | 0) == ($tib2_0_lcssa_i281 | 0)) { - label = 386; - break; - } else { - $i_0_i287 = $i_0_i287 + 1 | 0; - label = 318; - break; - } - case 320: - $1361 = HEAP32[($tib1_121_i284 + 40 | 0) >> 2] | 0; - if (($1361 | 0) == 0) { - label = 321; - break; - } else { - $tib1_121_i284 = $1361; - label = 316; - break; - } - case 321: - invoke_vii(48, HEAP32[$1069 >> 2] | 0 | 0, 0 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case 322: - if ((HEAP32[(105500 | 0) >> 2] | 0 | 0) == 0) { - label = 323; - break; - } else { - label = 324; - break; - } - case 323: - invoke_v(30); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 324; - break; - case 324: - $1369 = invoke_i(70) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $1371 = invoke_iii(364, $1369 | 0, 0 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $1372 = $local_env_w4567aaac23b1c44; - $1374 = $1371 + 16 | 0; - _memcpy($1372 | 0, HEAP32[$1374 >> 2] | 0 | 0, 40); - $1378 = _saveSetjmp(HEAP32[$1374 >> 2] | 0 | 0, label, setjmpTable) | 0; - label = 423; - break; - case 423: - if (($1378 | 0) == 0) { - label = 325; - break; - } else { - label = 328; - break; - } - case 325: - $_r0_sroa_0 = 1; - $_r0_sroa_0_0_load604 = $_r0_sroa_0; - if ((HEAP32[(98772 | 0) >> 2] | 0 | 0) == 0) { - label = 326; - break; - } else { - label = 327; - break; - } - case 326: - invoke_v(702); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 327; - break; - case 327: - HEAP32[140048 >> 2] = $_r0_sroa_0_0_load604; - $1391 = invoke_ii(HEAP32[((HEAP32[((HEAP32[$_r3_sroa_0 >> 2] | 0) + 116 | 0) >> 2] | 0) + 4 | 0) >> 2] | 0 | 0, $_r3_sroa_0 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $_r0_sroa_0 = $1391; - invoke_viiii(14, 16136 | 0 | 0, 11648 | 0 | 0, 126872 | 0 | 0, 1630 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case 328: - _memcpy(HEAP32[$1374 >> 2] | 0 | 0, $1372 | 0, 40); - if ((HEAP32[(113236 | 0) >> 2] | 0 | 0) == 0) { - label = 329; - break; - } else { - label = 330; - break; - } - case 329: - invoke_v(538); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 330; - break; - case 330: - $1400 = $1371 + 20 | 0; - $1401 = HEAP32[$1400 >> 2] | 0; - if (($1401 | 0) == 0) { - label = 344; - break; - } else { - label = 331; - break; - } - case 331: - $1406 = HEAP32[$1401 >> 2] | 0; - $1410 = HEAP32[((HEAP32[138672 >> 2] | 0) + 8 | 0) >> 2] | 0; - if (($1406 | 0) == 82712) { - label = 332; - break; - } else { - $tib1_0_ph_i248 = $1406; - label = 333; - break; - } - case 332: - $tib1_0_ph_i248 = HEAP32[((HEAP32[($1401 + 8 | 0) >> 2] | 0) + 8 | 0) >> 2] | 0; - label = 333; - break; - case 333: - $1421 = HEAP32[($tib1_0_ph_i248 + 56 | 0) >> 2] | 0; - if (($1421 | 0) == 0) { - $dimension_tib1_0_lcssa_i252 = 0; - $tib1_0_lcssa_i251 = $tib1_0_ph_i248; - label = 335; - break; - } else { - $dimension_tib1_029_i254 = 0; - $1428 = $1421; - label = 336; - break; - } - case 334: - $dimension_tib1_0_lcssa_i252 = $1432; - $tib1_0_lcssa_i251 = $1431; - label = 335; - break; - case 335: - $1426 = HEAP32[($1410 + 56 | 0) >> 2] | 0; - if (($1426 | 0) == 0) { - $dimension_tib2_0_lcssa_i259 = 0; - $tib2_0_lcssa_in_i258 = $1410; - label = 338; - break; - } else { - $dimension_tib2_024_i256 = 0; - $1437 = $1426; - label = 337; - break; - } - case 336: - $1431 = HEAP32[($1428 + 8 | 0) >> 2] | 0; - $1432 = $dimension_tib1_029_i254 + 1 | 0; - $1435 = HEAP32[($1431 + 56 | 0) >> 2] | 0; - if (($1435 | 0) == 0) { - label = 334; - break; - } else { - $dimension_tib1_029_i254 = $1432; - $1428 = $1435; - label = 336; - break; - } - case 337: - $1440 = HEAP32[($1437 + 8 | 0) >> 2] | 0; - $1441 = $dimension_tib2_024_i256 + 1 | 0; - $1444 = HEAP32[($1440 + 56 | 0) >> 2] | 0; - if (($1444 | 0) == 0) { - $dimension_tib2_0_lcssa_i259 = $1441; - $tib2_0_lcssa_in_i258 = $1440; - label = 338; - break; - } else { - $dimension_tib2_024_i256 = $1441; - $1437 = $1444; - label = 337; - break; - } - case 338: - $tib2_0_lcssa_i260 = $tib2_0_lcssa_in_i258; - if (($dimension_tib1_0_lcssa_i252 | 0) < ($dimension_tib2_0_lcssa_i259 | 0) | ($tib1_0_lcssa_i251 | 0) == 0) { - label = 344; - break; - } else { - $tib1_121_i263 = $tib1_0_lcssa_i251; - label = 339; - break; - } - case 339: - if (($tib1_121_i263 | 0) == ($tib2_0_lcssa_i260 | 0)) { - label = 361; - break; - } else { - label = 340; - break; - } - case 340: - $i_0_i266 = 0; - label = 341; - break; - case 341: - if (($i_0_i266 | 0) < (HEAP32[($tib1_121_i263 + 108 | 0) >> 2] | 0 | 0)) { - label = 342; - break; - } else { - label = 343; - break; - } - case 342: - if ((HEAP32[((HEAP32[($tib1_121_i263 + 112 | 0) >> 2] | 0) + ($i_0_i266 << 2) | 0) >> 2] | 0 | 0) == ($tib2_0_lcssa_i260 | 0)) { - label = 361; - break; - } else { - $i_0_i266 = $i_0_i266 + 1 | 0; - label = 341; - break; - } - case 343: - $1462 = HEAP32[($tib1_121_i263 + 40 | 0) >> 2] | 0; - if (($1462 | 0) == 0) { - label = 344; - break; - } else { - $tib1_121_i263 = $1462; - label = 339; - break; - } - case 344: - if ((HEAP32[(107740 | 0) >> 2] | 0 | 0) == 0) { - label = 345; - break; - } else { - label = 346; - break; - } - case 345: - invoke_v(374); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 346; - break; - case 346: - $1468 = HEAP32[$1400 >> 2] | 0; - if (($1468 | 0) == 0) { - label = 360; - break; - } else { - label = 347; - break; - } - case 347: - $1473 = HEAP32[$1468 >> 2] | 0; - $1477 = HEAP32[((HEAP32[137616 >> 2] | 0) + 8 | 0) >> 2] | 0; - if (($1473 | 0) == 82712) { - label = 348; - break; - } else { - $tib1_0_ph_i227 = $1473; - label = 349; - break; - } - case 348: - $tib1_0_ph_i227 = HEAP32[((HEAP32[($1468 + 8 | 0) >> 2] | 0) + 8 | 0) >> 2] | 0; - label = 349; - break; - case 349: - $1488 = HEAP32[($tib1_0_ph_i227 + 56 | 0) >> 2] | 0; - if (($1488 | 0) == 0) { - $dimension_tib1_0_lcssa_i231 = 0; - $tib1_0_lcssa_i230 = $tib1_0_ph_i227; - label = 351; - break; - } else { - $dimension_tib1_029_i233 = 0; - $1495 = $1488; - label = 352; - break; - } - case 350: - $dimension_tib1_0_lcssa_i231 = $1499; - $tib1_0_lcssa_i230 = $1498; - label = 351; - break; - case 351: - $1493 = HEAP32[($1477 + 56 | 0) >> 2] | 0; - if (($1493 | 0) == 0) { - $dimension_tib2_0_lcssa_i238 = 0; - $tib2_0_lcssa_in_i237 = $1477; - label = 354; - break; - } else { - $dimension_tib2_024_i235 = 0; - $1504 = $1493; - label = 353; - break; - } - case 352: - $1498 = HEAP32[($1495 + 8 | 0) >> 2] | 0; - $1499 = $dimension_tib1_029_i233 + 1 | 0; - $1502 = HEAP32[($1498 + 56 | 0) >> 2] | 0; - if (($1502 | 0) == 0) { - label = 350; - break; - } else { - $dimension_tib1_029_i233 = $1499; - $1495 = $1502; - label = 352; - break; - } - case 353: - $1507 = HEAP32[($1504 + 8 | 0) >> 2] | 0; - $1508 = $dimension_tib2_024_i235 + 1 | 0; - $1511 = HEAP32[($1507 + 56 | 0) >> 2] | 0; - if (($1511 | 0) == 0) { - $dimension_tib2_0_lcssa_i238 = $1508; - $tib2_0_lcssa_in_i237 = $1507; - label = 354; - break; - } else { - $dimension_tib2_024_i235 = $1508; - $1504 = $1511; - label = 353; - break; - } - case 354: - $tib2_0_lcssa_i239 = $tib2_0_lcssa_in_i237; - if (($dimension_tib1_0_lcssa_i231 | 0) < ($dimension_tib2_0_lcssa_i238 | 0) | ($tib1_0_lcssa_i230 | 0) == 0) { - label = 360; - break; - } else { - $tib1_121_i242 = $tib1_0_lcssa_i230; - label = 355; - break; - } - case 355: - if (($tib1_121_i242 | 0) == ($tib2_0_lcssa_i239 | 0)) { - label = 386; - break; - } else { - label = 356; - break; - } - case 356: - $i_0_i245 = 0; - label = 357; - break; - case 357: - if (($i_0_i245 | 0) < (HEAP32[($tib1_121_i242 + 108 | 0) >> 2] | 0 | 0)) { - label = 358; - break; - } else { - label = 359; - break; - } - case 358: - if ((HEAP32[((HEAP32[($tib1_121_i242 + 112 | 0) >> 2] | 0) + ($i_0_i245 << 2) | 0) >> 2] | 0 | 0) == ($tib2_0_lcssa_i239 | 0)) { - label = 386; - break; - } else { - $i_0_i245 = $i_0_i245 + 1 | 0; - label = 357; - break; - } - case 359: - $1529 = HEAP32[($tib1_121_i242 + 40 | 0) >> 2] | 0; - if (($1529 | 0) == 0) { - label = 360; - break; - } else { - $tib1_121_i242 = $1529; - label = 355; - break; - } - case 360: - invoke_vii(48, HEAP32[$1374 >> 2] | 0 | 0, 0 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case 361: - if ((HEAP32[(105500 | 0) >> 2] | 0 | 0) == 0) { - label = 362; - break; - } else { - label = 363; - break; - } - case 362: - invoke_v(30); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 363; - break; - case 363: - $1536 = invoke_i(70) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $1538 = invoke_iii(364, $1536 | 0, 0 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $1539 = $local_env_w4567aaac23b1c48; - $1541 = $1538 + 16 | 0; - _memcpy($1539 | 0, HEAP32[$1541 >> 2] | 0 | 0, 40); - $1545 = _saveSetjmp(HEAP32[$1541 >> 2] | 0 | 0, label, setjmpTable) | 0; - label = 424; - break; - case 424: - if (($1545 | 0) == 0) { - label = 364; - break; - } else { - label = 369; - break; - } - case 364: - if ((HEAP32[(105500 | 0) >> 2] | 0 | 0) == 0) { - label = 365; - break; - } else { - label = 366; - break; - } - case 365: - invoke_v(30); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 366; - break; - case 366: - $1551 = invoke_i(70) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $1553 = invoke_iii(364, $1551 | 0, 0 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $_r0_sroa_0 = HEAP32[($1553 + 20 | 0) >> 2] | 0; - $_r0_sroa_0 = 0; - $_r0_sroa_0_0_load602 = $_r0_sroa_0; - if ((HEAP32[(98772 | 0) >> 2] | 0 | 0) == 0) { - label = 367; - break; - } else { - label = 368; - break; - } - case 367: - invoke_v(702); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 368; - break; - case 368: - HEAP32[140048 >> 2] = $_r0_sroa_0_0_load602; - _memcpy(HEAP32[$1541 >> 2] | 0 | 0, $1539 | 0, 40); - label = 239; - break; - case 369: - _memcpy(HEAP32[$1541 >> 2] | 0 | 0, $1539 | 0, 40); - if ((HEAP32[(107740 | 0) >> 2] | 0 | 0) == 0) { - label = 370; - break; - } else { - label = 371; - break; - } - case 370: - invoke_v(374); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 371; - break; - case 371: - $1570 = HEAP32[($1538 + 20 | 0) >> 2] | 0; - if (($1570 | 0) == 0) { - label = 385; - break; - } else { - label = 372; - break; - } - case 372: - $1575 = HEAP32[$1570 >> 2] | 0; - $1579 = HEAP32[((HEAP32[137616 >> 2] | 0) + 8 | 0) >> 2] | 0; - if (($1575 | 0) == 82712) { - label = 373; - break; - } else { - $tib1_0_ph_i185 = $1575; - label = 374; - break; - } - case 373: - $tib1_0_ph_i185 = HEAP32[((HEAP32[($1570 + 8 | 0) >> 2] | 0) + 8 | 0) >> 2] | 0; - label = 374; - break; - case 374: - $1590 = HEAP32[($tib1_0_ph_i185 + 56 | 0) >> 2] | 0; - if (($1590 | 0) == 0) { - $dimension_tib1_0_lcssa_i189 = 0; - $tib1_0_lcssa_i188 = $tib1_0_ph_i185; - label = 376; - break; - } else { - $dimension_tib1_029_i191 = 0; - $1597 = $1590; - label = 377; - break; - } - case 375: - $dimension_tib1_0_lcssa_i189 = $1601; - $tib1_0_lcssa_i188 = $1600; - label = 376; - break; - case 376: - $1595 = HEAP32[($1579 + 56 | 0) >> 2] | 0; - if (($1595 | 0) == 0) { - $dimension_tib2_0_lcssa_i196 = 0; - $tib2_0_lcssa_in_i195 = $1579; - label = 379; - break; - } else { - $dimension_tib2_024_i193 = 0; - $1606 = $1595; - label = 378; - break; - } - case 377: - $1600 = HEAP32[($1597 + 8 | 0) >> 2] | 0; - $1601 = $dimension_tib1_029_i191 + 1 | 0; - $1604 = HEAP32[($1600 + 56 | 0) >> 2] | 0; - if (($1604 | 0) == 0) { - label = 375; - break; - } else { - $dimension_tib1_029_i191 = $1601; - $1597 = $1604; - label = 377; - break; - } - case 378: - $1609 = HEAP32[($1606 + 8 | 0) >> 2] | 0; - $1610 = $dimension_tib2_024_i193 + 1 | 0; - $1613 = HEAP32[($1609 + 56 | 0) >> 2] | 0; - if (($1613 | 0) == 0) { - $dimension_tib2_0_lcssa_i196 = $1610; - $tib2_0_lcssa_in_i195 = $1609; - label = 379; - break; - } else { - $dimension_tib2_024_i193 = $1610; - $1606 = $1613; - label = 378; - break; - } - case 379: - $tib2_0_lcssa_i197 = $tib2_0_lcssa_in_i195; - if (($dimension_tib1_0_lcssa_i189 | 0) < ($dimension_tib2_0_lcssa_i196 | 0) | ($tib1_0_lcssa_i188 | 0) == 0) { - label = 385; - break; - } else { - $tib1_121_i200 = $tib1_0_lcssa_i188; - label = 380; - break; - } - case 380: - if (($tib1_121_i200 | 0) == ($tib2_0_lcssa_i197 | 0)) { - label = 54; - break; - } else { - label = 381; - break; - } - case 381: - $i_0_i203 = 0; - label = 382; - break; - case 382: - if (($i_0_i203 | 0) < (HEAP32[($tib1_121_i200 + 108 | 0) >> 2] | 0 | 0)) { - label = 383; - break; - } else { - label = 384; - break; - } - case 383: - if ((HEAP32[((HEAP32[($tib1_121_i200 + 112 | 0) >> 2] | 0) + ($i_0_i203 << 2) | 0) >> 2] | 0 | 0) == ($tib2_0_lcssa_i197 | 0)) { - label = 54; - break; - } else { - $i_0_i203 = $i_0_i203 + 1 | 0; - label = 382; - break; - } - case 384: - $1631 = HEAP32[($tib1_121_i200 + 40 | 0) >> 2] | 0; - if (($1631 | 0) == 0) { - label = 385; - break; - } else { - $tib1_121_i200 = $1631; - label = 380; - break; - } - case 385: - invoke_vii(48, HEAP32[$1541 >> 2] | 0 | 0, 0 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case 386: - if ((HEAP32[(105500 | 0) >> 2] | 0 | 0) == 0) { - label = 387; - break; - } else { - label = 388; - break; - } - case 387: - invoke_v(30); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 388; - break; - case 388: - $1638 = invoke_i(70) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $1640 = invoke_iii(364, $1638 | 0, 0 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $1641 = $local_env_w4567aaac23b1c50; - $1643 = $1640 + 16 | 0; - _memcpy($1641 | 0, HEAP32[$1643 >> 2] | 0 | 0, 40); - $1647 = _saveSetjmp(HEAP32[$1643 >> 2] | 0 | 0, label, setjmpTable) | 0; - label = 425; - break; - case 425: - if (($1647 | 0) == 0) { - label = 389; - break; - } else { - label = 396; - break; - } - case 389: - if ((HEAP32[(105500 | 0) >> 2] | 0 | 0) == 0) { - label = 390; - break; - } else { - label = 391; - break; - } - case 390: - invoke_v(30); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 391; - break; - case 391: - $1653 = invoke_i(70) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $1655 = invoke_iii(364, $1653 | 0, 0 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $_r0_sroa_0 = HEAP32[($1655 + 20 | 0) >> 2] | 0; - $_r2_sroa_0 = 0; - $_r2_sroa_0_0_load = $_r2_sroa_0; - if ((HEAP32[(98772 | 0) >> 2] | 0 | 0) == 0) { - label = 392; - break; - } else { - label = 393; - break; - } - case 392: - invoke_v(702); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 393; - break; - case 393: - HEAP32[140048 >> 2] = $_r2_sroa_0_0_load; - if ((HEAP32[(105500 | 0) >> 2] | 0 | 0) == 0) { - label = 394; - break; - } else { - label = 395; - break; - } - case 394: - invoke_v(30); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 395; - break; - case 395: - $1666 = invoke_i(70) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $1668 = invoke_iii(364, $1666 | 0, 0 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - HEAP32[($1668 + 20 | 0) >> 2] = $_r0_sroa_0; - invoke_vii(48, HEAP32[($1668 + 16 | 0) >> 2] | 0 | 0, 0 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case 396: - _memcpy(HEAP32[$1643 >> 2] | 0 | 0, $1641 | 0, 40); - if ((HEAP32[(107740 | 0) >> 2] | 0 | 0) == 0) { - label = 397; - break; - } else { - label = 398; - break; - } - case 397: - invoke_v(374); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 398; - break; - case 398: - $1684 = HEAP32[($1640 + 20 | 0) >> 2] | 0; - if (($1684 | 0) == 0) { - label = 412; - break; - } else { - label = 399; - break; - } - case 399: - $1689 = HEAP32[$1684 >> 2] | 0; - $1693 = HEAP32[((HEAP32[137616 >> 2] | 0) + 8 | 0) >> 2] | 0; - if (($1689 | 0) == 82712) { - label = 400; - break; - } else { - $tib1_0_ph_i = $1689; - label = 401; - break; - } - case 400: - $tib1_0_ph_i = HEAP32[((HEAP32[($1684 + 8 | 0) >> 2] | 0) + 8 | 0) >> 2] | 0; - label = 401; - break; - case 401: - $1704 = HEAP32[($tib1_0_ph_i + 56 | 0) >> 2] | 0; - if (($1704 | 0) == 0) { - $dimension_tib1_0_lcssa_i = 0; - $tib1_0_lcssa_i = $tib1_0_ph_i; - label = 403; - break; - } else { - $dimension_tib1_029_i = 0; - $1711 = $1704; - label = 404; - break; - } - case 402: - $dimension_tib1_0_lcssa_i = $1715; - $tib1_0_lcssa_i = $1714; - label = 403; - break; - case 403: - $1709 = HEAP32[($1693 + 56 | 0) >> 2] | 0; - if (($1709 | 0) == 0) { - $dimension_tib2_0_lcssa_i = 0; - $tib2_0_lcssa_in_i = $1693; - label = 406; - break; - } else { - $dimension_tib2_024_i = 0; - $1720 = $1709; - label = 405; - break; - } - case 404: - $1714 = HEAP32[($1711 + 8 | 0) >> 2] | 0; - $1715 = $dimension_tib1_029_i + 1 | 0; - $1718 = HEAP32[($1714 + 56 | 0) >> 2] | 0; - if (($1718 | 0) == 0) { - label = 402; - break; - } else { - $dimension_tib1_029_i = $1715; - $1711 = $1718; - label = 404; - break; - } - case 405: - $1723 = HEAP32[($1720 + 8 | 0) >> 2] | 0; - $1724 = $dimension_tib2_024_i + 1 | 0; - $1727 = HEAP32[($1723 + 56 | 0) >> 2] | 0; - if (($1727 | 0) == 0) { - $dimension_tib2_0_lcssa_i = $1724; - $tib2_0_lcssa_in_i = $1723; - label = 406; - break; - } else { - $dimension_tib2_024_i = $1724; - $1720 = $1727; - label = 405; - break; - } - case 406: - $tib2_0_lcssa_i = $tib2_0_lcssa_in_i; - if (($dimension_tib1_0_lcssa_i | 0) < ($dimension_tib2_0_lcssa_i | 0) | ($tib1_0_lcssa_i | 0) == 0) { - label = 412; - break; - } else { - $tib1_121_i = $tib1_0_lcssa_i; - label = 407; - break; - } - case 407: - if (($tib1_121_i | 0) == ($tib2_0_lcssa_i | 0)) { - label = 54; - break; - } else { - label = 408; - break; - } - case 408: - $i_0_i = 0; - label = 409; - break; - case 409: - if (($i_0_i | 0) < (HEAP32[($tib1_121_i + 108 | 0) >> 2] | 0 | 0)) { - label = 410; - break; - } else { - label = 411; - break; - } - case 410: - if ((HEAP32[((HEAP32[($tib1_121_i + 112 | 0) >> 2] | 0) + ($i_0_i << 2) | 0) >> 2] | 0 | 0) == ($tib2_0_lcssa_i | 0)) { - label = 54; - break; - } else { - $i_0_i = $i_0_i + 1 | 0; - label = 409; - break; - } - case 411: - $1745 = HEAP32[($tib1_121_i + 40 | 0) >> 2] | 0; - if (($1745 | 0) == 0) { - label = 412; - break; - } else { - $tib1_121_i = $1745; - label = 407; - break; - } - case 412: - invoke_vii(48, HEAP32[$1643 >> 2] | 0 | 0, 0 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case -1111: - if ((setjmpLabel | 0) == 7) { - $25 = threwValue; - label = 413; - } else if ((setjmpLabel | 0) == 35) { - $159 = threwValue; - label = 414; - } else if ((setjmpLabel | 0) == 62) { - $290 = threwValue; - label = 415; - } else if ((setjmpLabel | 0) == 91) { - $401 = threwValue; - label = 416; - } else if ((setjmpLabel | 0) == 97) { - $433 = threwValue; - label = 417; - } else if ((setjmpLabel | 0) == 144) { - $629 = threwValue; - label = 418; - } else if ((setjmpLabel | 0) == 181) { - $789 = threwValue; - label = 419; - } else if ((setjmpLabel | 0) == 218) { - $954 = threwValue; - label = 420; - } else if ((setjmpLabel | 0) == 240) { - $1042 = threwValue; - label = 421; - } else if ((setjmpLabel | 0) == 251) { - $1073 = threwValue; - label = 422; - } else if ((setjmpLabel | 0) == 324) { - $1378 = threwValue; - label = 423; - } else if ((setjmpLabel | 0) == 363) { - $1545 = threwValue; - label = 424; - } else if ((setjmpLabel | 0) == 388) { - $1647 = threwValue; - label = 425; - } - __THREW__ = threwValue = 0; - break; + $n1 = $n1 | 0; + var $_r0_sroa_0 = 0, $_r0_sroa_1 = 0, $_r1_sroa_0 = 0, $_r2_sroa_0 = 0, $_r3_sroa_0 = 0, $_r3_sroa_1 = 0, $_r5_sroa_0 = 0, $local_env_w4567aaac23b1b6 = 0, $local_env_w4567aaac23b1c16 = 0, $local_env_w4567aaac23b1c22 = 0, $local_env_w4567aaac23b1c24 = 0, $local_env_w4567aaac23b1c26 = 0, $local_env_w4567aaac23b1c29 = 0, $local_env_w4567aaac23b1c31 = 0, $local_env_w4567aaac23b1c35 = 0, $local_env_w4567aaac23b1c40 = 0, $local_env_w4567aaac23b1c42 = 0, $local_env_w4567aaac23b1c44 = 0, $local_env_w4567aaac23b1c48 = 0, $local_env_w4567aaac23b1c50 = 0, $5 = 0, $16 = 0, $18 = 0, $19 = 0, $21 = 0, $25 = 0, $40 = 0, $52 = 0, $57 = 0, $61 = 0, $tib1_0_ph_i543 = 0, $72 = 0, $tib1_0_lcssa_i546 = 0, $dimension_tib1_0_lcssa_i547 = 0, $77 = 0, $79 = 0, $dimension_tib1_029_i549 = 0, $82 = 0, $83 = 0, $86 = 0, $88 = 0, $dimension_tib2_024_i551 = 0, $91 = 0, $92 = 0, $95 = 0, $tib2_0_lcssa_in_i553 = 0, $dimension_tib2_0_lcssa_i554 = 0, $tib2_0_lcssa_i555 = 0, $tib1_121_i558 = 0, $i_0_i561 = 0, $113 = 0, $_r1_sroa_0_0_load600 = 0, $119 = 0, $122 = 0, $139 = 0, $145 = 0, $149 = 0, $151 = 0, $153 = 0, $155 = 0, $159 = 0, $170 = 0, $175 = 0, $179 = 0, $tib1_0_ph_i521 = 0, $190 = 0, $tib1_0_lcssa_i524 = 0, $dimension_tib1_0_lcssa_i525 = 0, $195 = 0, $197 = 0, $dimension_tib1_029_i527 = 0, $200 = 0, $201 = 0, $204 = 0, $206 = 0, $dimension_tib2_024_i529 = 0, $209 = 0, $210 = 0, $213 = 0, $tib2_0_lcssa_in_i531 = 0, $dimension_tib2_0_lcssa_i532 = 0, $tib2_0_lcssa_i533 = 0, $tib1_121_i536 = 0, $i_0_i539 = 0, $231 = 0, $238 = 0, $240 = 0, $_r1_sroa_0_0_load = 0, $246 = 0, $249 = 0, $266 = 0, $273 = 0, $275 = 0, $284 = 0, $286 = 0, $290 = 0, $305 = 0, $310 = 0, $323 = 0, $328 = 0, $332 = 0, $tib1_0_ph_i500 = 0, $343 = 0, $tib1_0_lcssa_i503 = 0, $dimension_tib1_0_lcssa_i504 = 0, $348 = 0, $350 = 0, $dimension_tib1_029_i506 = 0, $353 = 0, $354 = 0, $357 = 0, $359 = 0, $dimension_tib2_024_i508 = 0, $362 = 0, $363 = 0, $366 = 0, $tib2_0_lcssa_in_i510 = 0, $dimension_tib2_0_lcssa_i511 = 0, $tib2_0_lcssa_i512 = 0, $tib1_121_i515 = 0, $i_0_i518 = 0, $384 = 0, $392 = 0, $394 = 0, $395 = 0, $397 = 0, $401 = 0, $416 = 0, $424 = 0, $426 = 0, $427 = 0, $429 = 0, $433 = 0, $446 = 0, $451 = 0, $455 = 0, $tib1_0_ph_i479 = 0, $466 = 0, $tib1_0_lcssa_i482 = 0, $dimension_tib1_0_lcssa_i483 = 0, $471 = 0, $473 = 0, $dimension_tib1_029_i485 = 0, $476 = 0, $477 = 0, $480 = 0, $482 = 0, $dimension_tib2_024_i487 = 0, $485 = 0, $486 = 0, $489 = 0, $tib2_0_lcssa_in_i489 = 0, $dimension_tib2_0_lcssa_i490 = 0, $tib2_0_lcssa_i491 = 0, $tib1_121_i494 = 0, $i_0_i497 = 0, $507 = 0, $519 = 0, $521 = 0, $525 = 0, $534 = 0, $539 = 0, $542 = 0, $546 = 0, $548 = 0, $557 = 0, $562 = 0, $566 = 0, $tib1_0_ph_i458 = 0, $577 = 0, $tib1_0_lcssa_i461 = 0, $dimension_tib1_0_lcssa_i462 = 0, $582 = 0, $584 = 0, $dimension_tib1_029_i464 = 0, $587 = 0, $588 = 0, $591 = 0, $593 = 0, $dimension_tib2_024_i466 = 0, $596 = 0, $597 = 0, $600 = 0, $tib2_0_lcssa_in_i468 = 0, $dimension_tib2_0_lcssa_i469 = 0, $tib2_0_lcssa_i470 = 0, $tib1_121_i473 = 0, $i_0_i476 = 0, $618 = 0, $623 = 0, $625 = 0, $629 = 0, $632 = 0, $643 = 0, $644 = 0, $649 = 0, $653 = 0, $tib1_0_ph_i437 = 0, $664 = 0, $tib1_0_lcssa_i440 = 0, $dimension_tib1_0_lcssa_i441 = 0, $669 = 0, $671 = 0, $dimension_tib1_029_i443 = 0, $674 = 0, $675 = 0, $678 = 0, $680 = 0, $dimension_tib2_024_i445 = 0, $683 = 0, $684 = 0, $687 = 0, $tib2_0_lcssa_in_i447 = 0, $dimension_tib2_0_lcssa_i448 = 0, $tib2_0_lcssa_i449 = 0, $tib1_121_i452 = 0, $i_0_i455 = 0, $705 = 0, $711 = 0, $716 = 0, $720 = 0, $tib1_0_ph_i416 = 0, $731 = 0, $tib1_0_lcssa_i419 = 0, $dimension_tib1_0_lcssa_i420 = 0, $736 = 0, $738 = 0, $dimension_tib1_029_i422 = 0, $741 = 0, $742 = 0, $745 = 0, $747 = 0, $dimension_tib2_024_i424 = 0, $750 = 0, $751 = 0, $754 = 0, $tib2_0_lcssa_in_i426 = 0, $dimension_tib2_0_lcssa_i427 = 0, $tib2_0_lcssa_i428 = 0, $tib1_121_i431 = 0, $i_0_i434 = 0, $772 = 0, $780 = 0, $782 = 0, $783 = 0, $785 = 0, $789 = 0, $798 = 0, $808 = 0, $809 = 0, $814 = 0, $818 = 0, $tib1_0_ph_i395 = 0, $829 = 0, $tib1_0_lcssa_i398 = 0, $dimension_tib1_0_lcssa_i399 = 0, $834 = 0, $836 = 0, $dimension_tib1_029_i401 = 0, $839 = 0, $840 = 0, $843 = 0, $845 = 0, $dimension_tib2_024_i403 = 0, $848 = 0, $849 = 0, $852 = 0, $tib2_0_lcssa_in_i405 = 0, $dimension_tib2_0_lcssa_i406 = 0, $tib2_0_lcssa_i407 = 0, $tib1_121_i410 = 0, $i_0_i413 = 0, $870 = 0, $876 = 0, $881 = 0, $885 = 0, $tib1_0_ph_i374 = 0, $896 = 0, $tib1_0_lcssa_i377 = 0, $dimension_tib1_0_lcssa_i378 = 0, $901 = 0, $903 = 0, $dimension_tib1_029_i380 = 0, $906 = 0, $907 = 0, $910 = 0, $912 = 0, $dimension_tib2_024_i382 = 0, $915 = 0, $916 = 0, $919 = 0, $tib2_0_lcssa_in_i384 = 0, $dimension_tib2_0_lcssa_i385 = 0, $tib2_0_lcssa_i386 = 0, $tib1_121_i389 = 0, $i_0_i392 = 0, $937 = 0, $945 = 0, $947 = 0, $948 = 0, $950 = 0, $954 = 0, $_r0_sroa_0_0_load607 = 0, $969 = 0, $974 = 0, $978 = 0, $tib1_0_ph_i353 = 0, $989 = 0, $tib1_0_lcssa_i356 = 0, $dimension_tib1_0_lcssa_i357 = 0, $994 = 0, $996 = 0, $dimension_tib1_029_i359 = 0, $999 = 0, $1000 = 0, $1003 = 0, $1005 = 0, $dimension_tib2_024_i361 = 0, $1008 = 0, $1009 = 0, $1012 = 0, $tib2_0_lcssa_in_i363 = 0, $dimension_tib2_0_lcssa_i364 = 0, $tib2_0_lcssa_i365 = 0, $tib1_121_i368 = 0, $i_0_i371 = 0, $1030 = 0, $1036 = 0, $1038 = 0, $1042 = 0, $1050 = 0, $1056 = 0, $1064 = 0, $1066 = 0, $1067 = 0, $1069 = 0, $1073 = 0, $1083 = 0, $1084 = 0, $1089 = 0, $1093 = 0, $tib1_0_ph_i332 = 0, $1104 = 0, $tib1_0_lcssa_i335 = 0, $dimension_tib1_0_lcssa_i336 = 0, $1109 = 0, $1111 = 0, $dimension_tib1_029_i338 = 0, $1114 = 0, $1115 = 0, $1118 = 0, $1120 = 0, $dimension_tib2_024_i340 = 0, $1123 = 0, $1124 = 0, $1127 = 0, $tib2_0_lcssa_in_i342 = 0, $dimension_tib2_0_lcssa_i343 = 0, $tib2_0_lcssa_i344 = 0, $tib1_121_i347 = 0, $i_0_i350 = 0, $1145 = 0, $1151 = 0, $1156 = 0, $1160 = 0, $tib1_0_ph_i311 = 0, $1171 = 0, $tib1_0_lcssa_i314 = 0, $dimension_tib1_0_lcssa_i315 = 0, $1176 = 0, $1178 = 0, $dimension_tib1_029_i317 = 0, $1181 = 0, $1182 = 0, $1185 = 0, $1187 = 0, $dimension_tib2_024_i319 = 0, $1190 = 0, $1191 = 0, $1194 = 0, $tib2_0_lcssa_in_i321 = 0, $dimension_tib2_0_lcssa_i322 = 0, $tib2_0_lcssa_i323 = 0, $tib1_121_i326 = 0, $i_0_i329 = 0, $1212 = 0, $1222 = 0, $1232 = 0, $1233 = 0, $1238 = 0, $1242 = 0, $tib1_0_ph_i290 = 0, $1253 = 0, $tib1_0_lcssa_i293 = 0, $dimension_tib1_0_lcssa_i294 = 0, $1258 = 0, $1260 = 0, $dimension_tib1_029_i296 = 0, $1263 = 0, $1264 = 0, $1267 = 0, $1269 = 0, $dimension_tib2_024_i298 = 0, $1272 = 0, $1273 = 0, $1276 = 0, $tib2_0_lcssa_in_i300 = 0, $dimension_tib2_0_lcssa_i301 = 0, $tib2_0_lcssa_i302 = 0, $tib1_121_i305 = 0, $i_0_i308 = 0, $1294 = 0, $1300 = 0, $1305 = 0, $1309 = 0, $tib1_0_ph_i269 = 0, $1320 = 0, $tib1_0_lcssa_i272 = 0, $dimension_tib1_0_lcssa_i273 = 0, $1325 = 0, $1327 = 0, $dimension_tib1_029_i275 = 0, $1330 = 0, $1331 = 0, $1334 = 0, $1336 = 0, $dimension_tib2_024_i277 = 0, $1339 = 0, $1340 = 0, $1343 = 0, $tib2_0_lcssa_in_i279 = 0, $dimension_tib2_0_lcssa_i280 = 0, $tib2_0_lcssa_i281 = 0, $tib1_121_i284 = 0, $i_0_i287 = 0, $1361 = 0, $1369 = 0, $1371 = 0, $1372 = 0, $1374 = 0, $1378 = 0, $_r0_sroa_0_0_load604 = 0, $1391 = 0, $1400 = 0, $1401 = 0, $1406 = 0, $1410 = 0, $tib1_0_ph_i248 = 0, $1421 = 0, $tib1_0_lcssa_i251 = 0, $dimension_tib1_0_lcssa_i252 = 0, $1426 = 0, $1428 = 0, $dimension_tib1_029_i254 = 0, $1431 = 0, $1432 = 0, $1435 = 0, $1437 = 0, $dimension_tib2_024_i256 = 0, $1440 = 0, $1441 = 0, $1444 = 0, $tib2_0_lcssa_in_i258 = 0, $dimension_tib2_0_lcssa_i259 = 0, $tib2_0_lcssa_i260 = 0, $tib1_121_i263 = 0, $i_0_i266 = 0, $1462 = 0, $1468 = 0, $1473 = 0, $1477 = 0, $tib1_0_ph_i227 = 0, $1488 = 0, $tib1_0_lcssa_i230 = 0, $dimension_tib1_0_lcssa_i231 = 0, $1493 = 0, $1495 = 0, $dimension_tib1_029_i233 = 0, $1498 = 0, $1499 = 0, $1502 = 0, $1504 = 0, $dimension_tib2_024_i235 = 0, $1507 = 0, $1508 = 0, $1511 = 0, $tib2_0_lcssa_in_i237 = 0, $dimension_tib2_0_lcssa_i238 = 0, $tib2_0_lcssa_i239 = 0, $tib1_121_i242 = 0, $i_0_i245 = 0, $1529 = 0, $1536 = 0, $1538 = 0, $1539 = 0, $1541 = 0, $1545 = 0, $1551 = 0, $1553 = 0, $_r0_sroa_0_0_load602 = 0, $1570 = 0, $1575 = 0, $1579 = 0, $tib1_0_ph_i185 = 0, $1590 = 0, $tib1_0_lcssa_i188 = 0, $dimension_tib1_0_lcssa_i189 = 0, $1595 = 0, $1597 = 0, $dimension_tib1_029_i191 = 0, $1600 = 0, $1601 = 0, $1604 = 0, $1606 = 0, $dimension_tib2_024_i193 = 0, $1609 = 0, $1610 = 0, $1613 = 0, $tib2_0_lcssa_in_i195 = 0, $dimension_tib2_0_lcssa_i196 = 0, $tib2_0_lcssa_i197 = 0, $tib1_121_i200 = 0, $i_0_i203 = 0, $1631 = 0, $1638 = 0, $1640 = 0, $1641 = 0, $1643 = 0, $1647 = 0, $1653 = 0, $1655 = 0, $_r2_sroa_0_0_load = 0, $1666 = 0, $1668 = 0, $1684 = 0, $1689 = 0, $1693 = 0, $tib1_0_ph_i = 0, $1704 = 0, $tib1_0_lcssa_i = 0, $dimension_tib1_0_lcssa_i = 0, $1709 = 0, $1711 = 0, $dimension_tib1_029_i = 0, $1714 = 0, $1715 = 0, $1718 = 0, $1720 = 0, $dimension_tib2_024_i = 0, $1723 = 0, $1724 = 0, $1727 = 0, $tib2_0_lcssa_in_i = 0, $dimension_tib2_0_lcssa_i = 0, $tib2_0_lcssa_i = 0, $tib1_121_i = 0, $i_0_i = 0, $1745 = 0, label = 0, __stackBase__ = 0, setjmpLabel = 0, setjmpTable = 0; + __stackBase__ = STACKTOP; + STACKTOP = STACKTOP + 536 | 0; + label = 1; + setjmpLabel = 0; + setjmpTable = STACKTOP; + STACKTOP = STACKTOP + 168 | 0; + HEAP32[setjmpTable >> 2] = 0; + while (1) switch (label | 0) { + case 1: + $_r0_sroa_1 = __stackBase__ | 0; + $_r3_sroa_1 = __stackBase__ + 8 | 0; + $local_env_w4567aaac23b1b6 = __stackBase__ + 16 | 0; + $local_env_w4567aaac23b1c16 = __stackBase__ + 56 | 0; + $local_env_w4567aaac23b1c22 = __stackBase__ + 96 | 0; + $local_env_w4567aaac23b1c24 = __stackBase__ + 136 | 0; + $local_env_w4567aaac23b1c26 = __stackBase__ + 176 | 0; + $local_env_w4567aaac23b1c29 = __stackBase__ + 216 | 0; + $local_env_w4567aaac23b1c31 = __stackBase__ + 256 | 0; + $local_env_w4567aaac23b1c35 = __stackBase__ + 296 | 0; + $local_env_w4567aaac23b1c40 = __stackBase__ + 336 | 0; + $local_env_w4567aaac23b1c42 = __stackBase__ + 376 | 0; + $local_env_w4567aaac23b1c44 = __stackBase__ + 416 | 0; + $local_env_w4567aaac23b1c48 = __stackBase__ + 456 | 0; + $local_env_w4567aaac23b1c50 = __stackBase__ + 496 | 0; + if ((HEAP32[(98772 | 0) >> 2] | 0 | 0) == 0) { + label = 2; + break; + } else { + label = 3; + break; + } + case 2: + invoke_v(702); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 3; + break; + case 3: + $_r5_sroa_0 = $n1; + $5 = invoke_ii(556, 709 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $_r0_sroa_0 = $5; + if ((HEAP32[(98772 | 0) >> 2] | 0 | 0) == 0) { + label = 4; + break; + } else { + label = 5; + break; + } + case 4: + invoke_v(702); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 5; + break; + case 5: + $_r1_sroa_0 = HEAP32[136048 >> 2] | 0; + invoke_ii(202, $_r1_sroa_0 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + if ((HEAP32[(105500 | 0) >> 2] | 0 | 0) == 0) { + label = 6; + break; + } else { + label = 7; + break; + } + case 6: + invoke_v(30); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 7; + break; + case 7: + $16 = invoke_i(70) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $18 = invoke_iii(364, $16 | 0, 0 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $19 = $local_env_w4567aaac23b1b6; + $21 = $18 + 16 | 0; + _memcpy($19 | 0, HEAP32[$21 >> 2] | 0 | 0, 40); + $25 = _saveSetjmp(HEAP32[$21 >> 2] | 0 | 0, label, setjmpTable) | 0; + label = 413; + break; + case 413: + if (($25 | 0) == 0) { + label = 8; + break; + } else { + label = 11; + break; + } + case 8: + if ((HEAP32[(98772 | 0) >> 2] | 0 | 0) == 0) { + label = 9; + break; + } else { + label = 10; + break; + } + case 9: + invoke_v(702); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 10; + break; + case 10: + $_r0_sroa_0 = HEAP32[140056 >> 2] | 0; + $40 = invoke_iii(HEAP32[((HEAP32[($_r0_sroa_0 | 0) >> 2] | 0) + 160 | 0) >> 2] | 0 | 0, $_r0_sroa_0 | 0, $_r5_sroa_0 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $_r0_sroa_0 = $40; + $_r0_sroa_0 = $_r0_sroa_0; + _memcpy(HEAP32[$21 >> 2] | 0 | 0, $19 | 0, 40); + if (($_r0_sroa_0 | 0) == 0) { + label = 32; + break; + } else { + label = 28; + break; + } + case 11: + _memcpy(HEAP32[$21 >> 2] | 0 | 0, $19 | 0, 40); + if ((HEAP32[(107740 | 0) >> 2] | 0 | 0) == 0) { + label = 12; + break; + } else { + label = 13; + break; + } + case 12: + invoke_v(374); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 13; + break; + case 13: + $52 = HEAP32[($18 + 20 | 0) >> 2] | 0; + if (($52 | 0) == 0) { + label = 27; + break; + } else { + label = 14; + break; + } + case 14: + $57 = HEAP32[$52 >> 2] | 0; + $61 = HEAP32[((HEAP32[137616 >> 2] | 0) + 8 | 0) >> 2] | 0; + if (($57 | 0) == 82712) { + label = 15; + break; + } else { + $tib1_0_ph_i543 = $57; + label = 16; + break; + } + case 15: + $tib1_0_ph_i543 = HEAP32[((HEAP32[($52 + 8 | 0) >> 2] | 0) + 8 | 0) >> 2] | 0; + label = 16; + break; + case 16: + $72 = HEAP32[($tib1_0_ph_i543 + 56 | 0) >> 2] | 0; + if (($72 | 0) == 0) { + $dimension_tib1_0_lcssa_i547 = 0; + $tib1_0_lcssa_i546 = $tib1_0_ph_i543; + label = 18; + break; + } else { + $dimension_tib1_029_i549 = 0; + $79 = $72; + label = 19; + break; + } + case 17: + $dimension_tib1_0_lcssa_i547 = $83; + $tib1_0_lcssa_i546 = $82; + label = 18; + break; + case 18: + $77 = HEAP32[($61 + 56 | 0) >> 2] | 0; + if (($77 | 0) == 0) { + $dimension_tib2_0_lcssa_i554 = 0; + $tib2_0_lcssa_in_i553 = $61; + label = 21; + break; + } else { + $dimension_tib2_024_i551 = 0; + $88 = $77; + label = 20; + break; + } + case 19: + $82 = HEAP32[($79 + 8 | 0) >> 2] | 0; + $83 = $dimension_tib1_029_i549 + 1 | 0; + $86 = HEAP32[($82 + 56 | 0) >> 2] | 0; + if (($86 | 0) == 0) { + label = 17; + break; + } else { + $dimension_tib1_029_i549 = $83; + $79 = $86; + label = 19; + break; + } + case 20: + $91 = HEAP32[($88 + 8 | 0) >> 2] | 0; + $92 = $dimension_tib2_024_i551 + 1 | 0; + $95 = HEAP32[($91 + 56 | 0) >> 2] | 0; + if (($95 | 0) == 0) { + $dimension_tib2_0_lcssa_i554 = $92; + $tib2_0_lcssa_in_i553 = $91; + label = 21; + break; + } else { + $dimension_tib2_024_i551 = $92; + $88 = $95; + label = 20; + break; + } + case 21: + $tib2_0_lcssa_i555 = $tib2_0_lcssa_in_i553; + if (($dimension_tib1_0_lcssa_i547 | 0) < ($dimension_tib2_0_lcssa_i554 | 0) | ($tib1_0_lcssa_i546 | 0) == 0) { + label = 27; + break; + } else { + $tib1_121_i558 = $tib1_0_lcssa_i546; + label = 22; + break; + } + case 22: + if (($tib1_121_i558 | 0) == ($tib2_0_lcssa_i555 | 0)) { + label = 54; + break; + } else { + label = 23; + break; + } + case 23: + $i_0_i561 = 0; + label = 24; + break; + case 24: + if (($i_0_i561 | 0) < (HEAP32[($tib1_121_i558 + 108 | 0) >> 2] | 0 | 0)) { + label = 25; + break; + } else { + label = 26; + break; + } + case 25: + if ((HEAP32[((HEAP32[($tib1_121_i558 + 112 | 0) >> 2] | 0) + ($i_0_i561 << 2) | 0) >> 2] | 0 | 0) == ($tib2_0_lcssa_i555 | 0)) { + label = 54; + break; + } else { + $i_0_i561 = $i_0_i561 + 1 | 0; + label = 24; + break; + } + case 26: + $113 = HEAP32[($tib1_121_i558 + 40 | 0) >> 2] | 0; + if (($113 | 0) == 0) { + label = 27; + break; + } else { + $tib1_121_i558 = $113; + label = 22; + break; + } + case 27: + invoke_vii(48, HEAP32[$21 >> 2] | 0 | 0, 0 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case 28: + $_r1_sroa_0_0_load600 = $_r1_sroa_0; + $119 = $_r1_sroa_0_0_load600 + 4 | 0; + $122 = (HEAP32[$119 >> 2] | 0) + 8 | 0; + HEAP32[$122 >> 2] = (HEAP32[$122 >> 2] | 0) - 1 | 0; + if ((HEAP32[((HEAP32[$119 >> 2] | 0) + 8 | 0) >> 2] | 0 | 0) == 0) { + label = 29; + break; + } else { + label = 31; + break; + } + case 29: + invoke_vi(28, $_r1_sroa_0_0_load600 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $139; + if (($139 | 0) == 0) { + label = 31; + break; + } else { + label = 30; + break; + } + case 30: + invoke_iii(268, 31e3 | 0 | 0, (tempInt = STACKTOP, STACKTOP = STACKTOP + 8 | 0, HEAP32[tempInt >> 2] = $139, tempInt) | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 31; + break; + case 31: + STACKTOP = __stackBase__; + return $_r0_sroa_0 | 0; + case 32: + $145 = ($_r5_sroa_0 | 0) == 0; + if ((HEAP32[(105500 | 0) >> 2] | 0 | 0) == 0) { + label = 33; + break; + } else { + label = 34; + break; + } + case 33: + invoke_v(30); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 34; + break; + case 34: + $149 = invoke_i(70) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $151 = invoke_iii(364, $149 | 0, 0 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + if ($145) { + label = 35; + break; + } else { + label = 62; + break; + } + case 35: + $153 = $local_env_w4567aaac23b1c16; + $155 = $151 + 16 | 0; + _memcpy($153 | 0, HEAP32[$155 >> 2] | 0 | 0, 40); + $159 = _saveSetjmp(HEAP32[$155 >> 2] | 0 | 0, label, setjmpTable) | 0; + label = 414; + break; + case 414: + if (($159 | 0) == 0) { + label = 36; + break; + } else { + label = 37; + break; + } + case 36: + invoke_viiii(14, 16136 | 0 | 0, 11648 | 0 | 0, 126872 | 0 | 0, 1457 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case 37: + _memcpy(HEAP32[$155 >> 2] | 0 | 0, $153 | 0, 40); + if ((HEAP32[(107740 | 0) >> 2] | 0 | 0) == 0) { + label = 38; + break; + } else { + label = 39; + break; + } + case 38: + invoke_v(374); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 39; + break; + case 39: + $170 = HEAP32[($151 + 20 | 0) >> 2] | 0; + if (($170 | 0) == 0) { + label = 53; + break; + } else { + label = 40; + break; + } + case 40: + $175 = HEAP32[$170 >> 2] | 0; + $179 = HEAP32[((HEAP32[137616 >> 2] | 0) + 8 | 0) >> 2] | 0; + if (($175 | 0) == 82712) { + label = 41; + break; + } else { + $tib1_0_ph_i521 = $175; + label = 42; + break; + } + case 41: + $tib1_0_ph_i521 = HEAP32[((HEAP32[($170 + 8 | 0) >> 2] | 0) + 8 | 0) >> 2] | 0; + label = 42; + break; + case 42: + $190 = HEAP32[($tib1_0_ph_i521 + 56 | 0) >> 2] | 0; + if (($190 | 0) == 0) { + $dimension_tib1_0_lcssa_i525 = 0; + $tib1_0_lcssa_i524 = $tib1_0_ph_i521; + label = 44; + break; + } else { + $dimension_tib1_029_i527 = 0; + $197 = $190; + label = 45; + break; + } + case 43: + $dimension_tib1_0_lcssa_i525 = $201; + $tib1_0_lcssa_i524 = $200; + label = 44; + break; + case 44: + $195 = HEAP32[($179 + 56 | 0) >> 2] | 0; + if (($195 | 0) == 0) { + $dimension_tib2_0_lcssa_i532 = 0; + $tib2_0_lcssa_in_i531 = $179; + label = 47; + break; + } else { + $dimension_tib2_024_i529 = 0; + $206 = $195; + label = 46; + break; + } + case 45: + $200 = HEAP32[($197 + 8 | 0) >> 2] | 0; + $201 = $dimension_tib1_029_i527 + 1 | 0; + $204 = HEAP32[($200 + 56 | 0) >> 2] | 0; + if (($204 | 0) == 0) { + label = 43; + break; + } else { + $dimension_tib1_029_i527 = $201; + $197 = $204; + label = 45; + break; + } + case 46: + $209 = HEAP32[($206 + 8 | 0) >> 2] | 0; + $210 = $dimension_tib2_024_i529 + 1 | 0; + $213 = HEAP32[($209 + 56 | 0) >> 2] | 0; + if (($213 | 0) == 0) { + $dimension_tib2_0_lcssa_i532 = $210; + $tib2_0_lcssa_in_i531 = $209; + label = 47; + break; + } else { + $dimension_tib2_024_i529 = $210; + $206 = $213; + label = 46; + break; + } + case 47: + $tib2_0_lcssa_i533 = $tib2_0_lcssa_in_i531; + if (($dimension_tib1_0_lcssa_i525 | 0) < ($dimension_tib2_0_lcssa_i532 | 0) | ($tib1_0_lcssa_i524 | 0) == 0) { + label = 53; + break; + } else { + $tib1_121_i536 = $tib1_0_lcssa_i524; + label = 48; + break; + } + case 48: + if (($tib1_121_i536 | 0) == ($tib2_0_lcssa_i533 | 0)) { + label = 54; + break; + } else { + label = 49; + break; + } + case 49: + $i_0_i539 = 0; + label = 50; + break; + case 50: + if (($i_0_i539 | 0) < (HEAP32[($tib1_121_i536 + 108 | 0) >> 2] | 0 | 0)) { + label = 51; + break; + } else { + label = 52; + break; + } + case 51: + if ((HEAP32[((HEAP32[($tib1_121_i536 + 112 | 0) >> 2] | 0) + ($i_0_i539 << 2) | 0) >> 2] | 0 | 0) == ($tib2_0_lcssa_i533 | 0)) { + label = 54; + break; + } else { + $i_0_i539 = $i_0_i539 + 1 | 0; + label = 50; + break; + } + case 52: + $231 = HEAP32[($tib1_121_i536 + 40 | 0) >> 2] | 0; + if (($231 | 0) == 0) { + label = 53; + break; + } else { + $tib1_121_i536 = $231; + label = 48; + break; + } + case 53: + invoke_vii(48, HEAP32[$155 >> 2] | 0 | 0, 0 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case 54: + if ((HEAP32[(105500 | 0) >> 2] | 0 | 0) == 0) { + label = 55; + break; + } else { + label = 56; + break; + } + case 55: + invoke_v(30); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 56; + break; + case 56: + $238 = invoke_i(70) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $240 = invoke_iii(364, $238 | 0, 0 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $_r0_sroa_0 = HEAP32[($240 + 20 | 0) >> 2] | 0; + $_r1_sroa_0_0_load = $_r1_sroa_0; + $246 = $_r1_sroa_0_0_load + 4 | 0; + $249 = (HEAP32[$246 >> 2] | 0) + 8 | 0; + HEAP32[$249 >> 2] = (HEAP32[$249 >> 2] | 0) - 1 | 0; + if ((HEAP32[((HEAP32[$246 >> 2] | 0) + 8 | 0) >> 2] | 0 | 0) == 0) { + label = 57; + break; + } else { + label = 59; + break; + } + case 57: + invoke_vi(28, $_r1_sroa_0_0_load | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $266; + if (($266 | 0) == 0) { + label = 59; + break; + } else { + label = 58; + break; + } + case 58: + invoke_iii(268, 31e3 | 0 | 0, (tempInt = STACKTOP, STACKTOP = STACKTOP + 8 | 0, HEAP32[tempInt >> 2] = $266, tempInt) | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 59; + break; + case 59: + if ((HEAP32[(105500 | 0) >> 2] | 0 | 0) == 0) { + label = 60; + break; + } else { + label = 61; + break; + } + case 60: + invoke_v(30); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 61; + break; + case 61: + $273 = invoke_i(70) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $275 = invoke_iii(364, $273 | 0, 0 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + HEAP32[($275 + 20 | 0) >> 2] = $_r0_sroa_0; + invoke_vii(48, HEAP32[($275 + 16 | 0) >> 2] | 0 | 0, 0 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case 62: + $284 = $local_env_w4567aaac23b1c22; + $286 = $151 + 16 | 0; + _memcpy($284 | 0, HEAP32[$286 >> 2] | 0 | 0, 40); + $290 = _saveSetjmp(HEAP32[$286 >> 2] | 0 | 0, label, setjmpTable) | 0; + label = 415; + break; + case 415: + if (($290 | 0) == 0) { + label = 63; + break; + } else { + label = 72; + break; + } + case 63: + invoke_vi(44, $_r5_sroa_0 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + if ((HEAP32[(98772 | 0) >> 2] | 0 | 0) == 0) { + label = 64; + break; + } else { + label = 65; + break; + } + case 64: + invoke_v(702); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 65; + break; + case 65: + $_r0_sroa_0 = HEAP32[140064 >> 2] | 0; + if (($_r0_sroa_0 | 0) == 0) { + label = 67; + break; + } else { + label = 66; + break; + } + case 66: + _memcpy(HEAP32[$286 >> 2] | 0 | 0, $284 | 0, 40); + label = 89; + break; + case 67: + if ((HEAP32[(84292 | 0) >> 2] | 0 | 0) == 0) { + label = 68; + break; + } else { + label = 69; + break; + } + case 68: + invoke_v(584); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 69; + break; + case 69: + $305 = invoke_ii(338, 20 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + HEAP32[$305 >> 2] = 84288; + _memset($305 + 4 | 0 | 0 | 0, 0 | 0 | 0, 16 | 0 | 0); + $_r0_sroa_0 = $305; + invoke_vi(34, $_r0_sroa_0 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $310 = $_r0_sroa_0; + if ((HEAP32[(98772 | 0) >> 2] | 0 | 0) == 0) { + label = 70; + break; + } else { + label = 71; + break; + } + case 70: + invoke_v(702); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 71; + break; + case 71: + HEAP32[140064 >> 2] = $310; + _memcpy(HEAP32[$286 >> 2] | 0 | 0, $284 | 0, 40); + label = 89; + break; + case 72: + _memcpy(HEAP32[$286 >> 2] | 0 | 0, $284 | 0, 40); + if ((HEAP32[(107740 | 0) >> 2] | 0 | 0) == 0) { + label = 73; + break; + } else { + label = 74; + break; + } + case 73: + invoke_v(374); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 74; + break; + case 74: + $323 = HEAP32[($151 + 20 | 0) >> 2] | 0; + if (($323 | 0) == 0) { + label = 88; + break; + } else { + label = 75; + break; + } + case 75: + $328 = HEAP32[$323 >> 2] | 0; + $332 = HEAP32[((HEAP32[137616 >> 2] | 0) + 8 | 0) >> 2] | 0; + if (($328 | 0) == 82712) { + label = 76; + break; + } else { + $tib1_0_ph_i500 = $328; + label = 77; + break; + } + case 76: + $tib1_0_ph_i500 = HEAP32[((HEAP32[($323 + 8 | 0) >> 2] | 0) + 8 | 0) >> 2] | 0; + label = 77; + break; + case 77: + $343 = HEAP32[($tib1_0_ph_i500 + 56 | 0) >> 2] | 0; + if (($343 | 0) == 0) { + $dimension_tib1_0_lcssa_i504 = 0; + $tib1_0_lcssa_i503 = $tib1_0_ph_i500; + label = 79; + break; + } else { + $dimension_tib1_029_i506 = 0; + $350 = $343; + label = 80; + break; + } + case 78: + $dimension_tib1_0_lcssa_i504 = $354; + $tib1_0_lcssa_i503 = $353; + label = 79; + break; + case 79: + $348 = HEAP32[($332 + 56 | 0) >> 2] | 0; + if (($348 | 0) == 0) { + $dimension_tib2_0_lcssa_i511 = 0; + $tib2_0_lcssa_in_i510 = $332; + label = 82; + break; + } else { + $dimension_tib2_024_i508 = 0; + $359 = $348; + label = 81; + break; + } + case 80: + $353 = HEAP32[($350 + 8 | 0) >> 2] | 0; + $354 = $dimension_tib1_029_i506 + 1 | 0; + $357 = HEAP32[($353 + 56 | 0) >> 2] | 0; + if (($357 | 0) == 0) { + label = 78; + break; + } else { + $dimension_tib1_029_i506 = $354; + $350 = $357; + label = 80; + break; + } + case 81: + $362 = HEAP32[($359 + 8 | 0) >> 2] | 0; + $363 = $dimension_tib2_024_i508 + 1 | 0; + $366 = HEAP32[($362 + 56 | 0) >> 2] | 0; + if (($366 | 0) == 0) { + $dimension_tib2_0_lcssa_i511 = $363; + $tib2_0_lcssa_in_i510 = $362; + label = 82; + break; + } else { + $dimension_tib2_024_i508 = $363; + $359 = $366; + label = 81; + break; + } + case 82: + $tib2_0_lcssa_i512 = $tib2_0_lcssa_in_i510; + if (($dimension_tib1_0_lcssa_i504 | 0) < ($dimension_tib2_0_lcssa_i511 | 0) | ($tib1_0_lcssa_i503 | 0) == 0) { + label = 88; + break; + } else { + $tib1_121_i515 = $tib1_0_lcssa_i503; + label = 83; + break; + } + case 83: + if (($tib1_121_i515 | 0) == ($tib2_0_lcssa_i512 | 0)) { + label = 54; + break; + } else { + label = 84; + break; + } + case 84: + $i_0_i518 = 0; + label = 85; + break; + case 85: + if (($i_0_i518 | 0) < (HEAP32[($tib1_121_i515 + 108 | 0) >> 2] | 0 | 0)) { + label = 86; + break; + } else { + label = 87; + break; + } + case 86: + if ((HEAP32[((HEAP32[($tib1_121_i515 + 112 | 0) >> 2] | 0) + ($i_0_i518 << 2) | 0) >> 2] | 0 | 0) == ($tib2_0_lcssa_i512 | 0)) { + label = 54; + break; + } else { + $i_0_i518 = $i_0_i518 + 1 | 0; + label = 85; + break; + } + case 87: + $384 = HEAP32[($tib1_121_i515 + 40 | 0) >> 2] | 0; + if (($384 | 0) == 0) { + label = 88; + break; + } else { + $tib1_121_i515 = $384; + label = 83; + break; + } + case 88: + invoke_vii(48, HEAP32[$286 >> 2] | 0 | 0, 0 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case 89: + if ((HEAP32[(105500 | 0) >> 2] | 0 | 0) == 0) { + label = 90; + break; + } else { + label = 91; + break; + } + case 90: + invoke_v(30); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 91; + break; + case 91: + $392 = invoke_i(70) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $394 = invoke_iii(364, $392 | 0, 0 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $395 = $local_env_w4567aaac23b1c24; + $397 = $394 + 16 | 0; + _memcpy($395 | 0, HEAP32[$397 >> 2] | 0 | 0, 40); + $401 = _saveSetjmp(HEAP32[$397 >> 2] | 0 | 0, label, setjmpTable) | 0; + label = 416; + break; + case 416: + if (($401 | 0) == 0) { + label = 92; + break; + } else { + label = 99; + break; + } + case 92: + if ((HEAP32[(98772 | 0) >> 2] | 0 | 0) == 0) { + label = 93; + break; + } else { + label = 94; + break; + } + case 93: + invoke_v(702); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 94; + break; + case 94: + $_r0_sroa_0 = HEAP32[140064 >> 2] | 0; + $416 = invoke_iii(HEAP32[((HEAP32[($_r0_sroa_0 | 0) >> 2] | 0) + 144 | 0) >> 2] | 0 | 0, $_r0_sroa_0 | 0, $_r5_sroa_0 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $_r0_sroa_0 = $416; + if (($_r0_sroa_0 | 0) == 0) { + label = 95; + break; + } else { + label = 98; + break; + } + case 95: + _memcpy(HEAP32[$397 >> 2] | 0 | 0, $395 | 0, 40); + if ((HEAP32[(105500 | 0) >> 2] | 0 | 0) == 0) { + label = 96; + break; + } else { + label = 97; + break; + } + case 96: + invoke_v(30); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 97; + break; + case 97: + $424 = invoke_i(70) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $426 = invoke_iii(364, $424 | 0, 0 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $427 = $local_env_w4567aaac23b1c26; + $429 = $426 + 16 | 0; + _memcpy($427 | 0, HEAP32[$429 >> 2] | 0 | 0, 40); + $433 = _saveSetjmp(HEAP32[$429 >> 2] | 0 | 0, label, setjmpTable) | 0; + label = 417; + break; + case 417: + if (($433 | 0) == 0) { + label = 116; + break; + } else { + label = 127; + break; + } + case 98: + invoke_vii(24, $_r0_sroa_0 | 0, $_r5_sroa_0 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + _memcpy(HEAP32[$397 >> 2] | 0 | 0, $395 | 0, 40); + label = 28; + break; + case 99: + _memcpy(HEAP32[$397 >> 2] | 0 | 0, $395 | 0, 40); + if ((HEAP32[(107740 | 0) >> 2] | 0 | 0) == 0) { + label = 100; + break; + } else { + label = 101; + break; + } + case 100: + invoke_v(374); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 101; + break; + case 101: + $446 = HEAP32[($394 + 20 | 0) >> 2] | 0; + if (($446 | 0) == 0) { + label = 115; + break; + } else { + label = 102; + break; + } + case 102: + $451 = HEAP32[$446 >> 2] | 0; + $455 = HEAP32[((HEAP32[137616 >> 2] | 0) + 8 | 0) >> 2] | 0; + if (($451 | 0) == 82712) { + label = 103; + break; + } else { + $tib1_0_ph_i479 = $451; + label = 104; + break; + } + case 103: + $tib1_0_ph_i479 = HEAP32[((HEAP32[($446 + 8 | 0) >> 2] | 0) + 8 | 0) >> 2] | 0; + label = 104; + break; + case 104: + $466 = HEAP32[($tib1_0_ph_i479 + 56 | 0) >> 2] | 0; + if (($466 | 0) == 0) { + $dimension_tib1_0_lcssa_i483 = 0; + $tib1_0_lcssa_i482 = $tib1_0_ph_i479; + label = 106; + break; + } else { + $dimension_tib1_029_i485 = 0; + $473 = $466; + label = 107; + break; + } + case 105: + $dimension_tib1_0_lcssa_i483 = $477; + $tib1_0_lcssa_i482 = $476; + label = 106; + break; + case 106: + $471 = HEAP32[($455 + 56 | 0) >> 2] | 0; + if (($471 | 0) == 0) { + $dimension_tib2_0_lcssa_i490 = 0; + $tib2_0_lcssa_in_i489 = $455; + label = 109; + break; + } else { + $dimension_tib2_024_i487 = 0; + $482 = $471; + label = 108; + break; + } + case 107: + $476 = HEAP32[($473 + 8 | 0) >> 2] | 0; + $477 = $dimension_tib1_029_i485 + 1 | 0; + $480 = HEAP32[($476 + 56 | 0) >> 2] | 0; + if (($480 | 0) == 0) { + label = 105; + break; + } else { + $dimension_tib1_029_i485 = $477; + $473 = $480; + label = 107; + break; + } + case 108: + $485 = HEAP32[($482 + 8 | 0) >> 2] | 0; + $486 = $dimension_tib2_024_i487 + 1 | 0; + $489 = HEAP32[($485 + 56 | 0) >> 2] | 0; + if (($489 | 0) == 0) { + $dimension_tib2_0_lcssa_i490 = $486; + $tib2_0_lcssa_in_i489 = $485; + label = 109; + break; + } else { + $dimension_tib2_024_i487 = $486; + $482 = $489; + label = 108; + break; + } + case 109: + $tib2_0_lcssa_i491 = $tib2_0_lcssa_in_i489; + if (($dimension_tib1_0_lcssa_i483 | 0) < ($dimension_tib2_0_lcssa_i490 | 0) | ($tib1_0_lcssa_i482 | 0) == 0) { + label = 115; + break; + } else { + $tib1_121_i494 = $tib1_0_lcssa_i482; + label = 110; + break; + } + case 110: + if (($tib1_121_i494 | 0) == ($tib2_0_lcssa_i491 | 0)) { + label = 54; + break; + } else { + label = 111; + break; + } + case 111: + $i_0_i497 = 0; + label = 112; + break; + case 112: + if (($i_0_i497 | 0) < (HEAP32[($tib1_121_i494 + 108 | 0) >> 2] | 0 | 0)) { + label = 113; + break; + } else { + label = 114; + break; + } + case 113: + if ((HEAP32[((HEAP32[($tib1_121_i494 + 112 | 0) >> 2] | 0) + ($i_0_i497 << 2) | 0) >> 2] | 0 | 0) == ($tib2_0_lcssa_i491 | 0)) { + label = 54; + break; + } else { + $i_0_i497 = $i_0_i497 + 1 | 0; + label = 112; + break; + } + case 114: + $507 = HEAP32[($tib1_121_i494 + 40 | 0) >> 2] | 0; + if (($507 | 0) == 0) { + label = 115; + break; + } else { + $tib1_121_i494 = $507; + label = 110; + break; + } + case 115: + invoke_vii(48, HEAP32[$397 >> 2] | 0 | 0, 0 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case 116: + if ((HEAP32[(98772 | 0) >> 2] | 0 | 0) == 0) { + label = 117; + break; + } else { + label = 118; + break; + } + case 117: + invoke_v(702); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 118; + break; + case 118: + if ((HEAP32[(105500 | 0) >> 2] | 0 | 0) == 0) { + label = 119; + break; + } else { + label = 120; + break; + } + case 119: + invoke_v(30); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 120; + break; + case 120: + $519 = invoke_i(70) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $521 = invoke_iii(364, $519 | 0, 0 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + if ((HEAP32[(98148 | 0) >> 2] | 0 | 0) == 0) { + label = 121; + break; + } else { + label = 122; + break; + } + case 121: + invoke_v(408); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 122; + break; + case 122: + $525 = invoke_ii(338, 12 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + HEAP32[$525 >> 2] = 98144; + HEAP32[($525 + 4 | 0) >> 2] = 0; + HEAP32[($525 + 8 | 0) >> 2] = $521; + if ((HEAP32[(97532 | 0) >> 2] | 0 | 0) == 0) { + label = 123; + break; + } else { + $534 = 98144; + label = 124; + break; + } + case 123: + invoke_v(568); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $534 = HEAP32[$525 >> 2] | 0; + label = 124; + break; + case 124: + $539 = invoke_ii(HEAP32[(HEAP32[($534 + 116 | 0) >> 2] | 0) >> 2] | 0 | 0, $525 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $_r2_sroa_0 = $539; + _memcpy(HEAP32[$429 >> 2] | 0 | 0, $427 | 0, 40); + $542 = ($_r2_sroa_0 | 0) == 0; + if ((HEAP32[(105500 | 0) >> 2] | 0 | 0) == 0) { + label = 125; + break; + } else { + label = 126; + break; + } + case 125: + invoke_v(30); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 126; + break; + case 126: + $546 = invoke_i(70) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $548 = invoke_iii(364, $546 | 0, 0 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + if ($542) { + label = 240; + break; + } else { + label = 144; + break; + } + case 127: + _memcpy(HEAP32[$429 >> 2] | 0 | 0, $427 | 0, 40); + if ((HEAP32[(107740 | 0) >> 2] | 0 | 0) == 0) { + label = 128; + break; + } else { + label = 129; + break; + } + case 128: + invoke_v(374); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 129; + break; + case 129: + $557 = HEAP32[($426 + 20 | 0) >> 2] | 0; + if (($557 | 0) == 0) { + label = 143; + break; + } else { + label = 130; + break; + } + case 130: + $562 = HEAP32[$557 >> 2] | 0; + $566 = HEAP32[((HEAP32[137616 >> 2] | 0) + 8 | 0) >> 2] | 0; + if (($562 | 0) == 82712) { + label = 131; + break; + } else { + $tib1_0_ph_i458 = $562; + label = 132; + break; + } + case 131: + $tib1_0_ph_i458 = HEAP32[((HEAP32[($557 + 8 | 0) >> 2] | 0) + 8 | 0) >> 2] | 0; + label = 132; + break; + case 132: + $577 = HEAP32[($tib1_0_ph_i458 + 56 | 0) >> 2] | 0; + if (($577 | 0) == 0) { + $dimension_tib1_0_lcssa_i462 = 0; + $tib1_0_lcssa_i461 = $tib1_0_ph_i458; + label = 134; + break; + } else { + $dimension_tib1_029_i464 = 0; + $584 = $577; + label = 135; + break; + } + case 133: + $dimension_tib1_0_lcssa_i462 = $588; + $tib1_0_lcssa_i461 = $587; + label = 134; + break; + case 134: + $582 = HEAP32[($566 + 56 | 0) >> 2] | 0; + if (($582 | 0) == 0) { + $dimension_tib2_0_lcssa_i469 = 0; + $tib2_0_lcssa_in_i468 = $566; + label = 137; + break; + } else { + $dimension_tib2_024_i466 = 0; + $593 = $582; + label = 136; + break; + } + case 135: + $587 = HEAP32[($584 + 8 | 0) >> 2] | 0; + $588 = $dimension_tib1_029_i464 + 1 | 0; + $591 = HEAP32[($587 + 56 | 0) >> 2] | 0; + if (($591 | 0) == 0) { + label = 133; + break; + } else { + $dimension_tib1_029_i464 = $588; + $584 = $591; + label = 135; + break; + } + case 136: + $596 = HEAP32[($593 + 8 | 0) >> 2] | 0; + $597 = $dimension_tib2_024_i466 + 1 | 0; + $600 = HEAP32[($596 + 56 | 0) >> 2] | 0; + if (($600 | 0) == 0) { + $dimension_tib2_0_lcssa_i469 = $597; + $tib2_0_lcssa_in_i468 = $596; + label = 137; + break; + } else { + $dimension_tib2_024_i466 = $597; + $593 = $600; + label = 136; + break; + } + case 137: + $tib2_0_lcssa_i470 = $tib2_0_lcssa_in_i468; + if (($dimension_tib1_0_lcssa_i462 | 0) < ($dimension_tib2_0_lcssa_i469 | 0) | ($tib1_0_lcssa_i461 | 0) == 0) { + label = 143; + break; + } else { + $tib1_121_i473 = $tib1_0_lcssa_i461; + label = 138; + break; + } + case 138: + if (($tib1_121_i473 | 0) == ($tib2_0_lcssa_i470 | 0)) { + label = 54; + break; + } else { + label = 139; + break; + } + case 139: + $i_0_i476 = 0; + label = 140; + break; + case 140: + if (($i_0_i476 | 0) < (HEAP32[($tib1_121_i473 + 108 | 0) >> 2] | 0 | 0)) { + label = 141; + break; + } else { + label = 142; + break; + } + case 141: + if ((HEAP32[((HEAP32[($tib1_121_i473 + 112 | 0) >> 2] | 0) + ($i_0_i476 << 2) | 0) >> 2] | 0 | 0) == ($tib2_0_lcssa_i470 | 0)) { + label = 54; + break; + } else { + $i_0_i476 = $i_0_i476 + 1 | 0; + label = 140; + break; + } + case 142: + $618 = HEAP32[($tib1_121_i473 + 40 | 0) >> 2] | 0; + if (($618 | 0) == 0) { + label = 143; + break; + } else { + $tib1_121_i473 = $618; + label = 138; + break; + } + case 143: + invoke_vii(48, HEAP32[$429 >> 2] | 0 | 0, 0 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case 144: + $623 = $local_env_w4567aaac23b1c29; + $625 = $548 + 16 | 0; + _memcpy($623 | 0, HEAP32[$625 >> 2] | 0 | 0, 40); + $629 = _saveSetjmp(HEAP32[$625 >> 2] | 0 | 0, label, setjmpTable) | 0; + label = 418; + break; + case 418: + if (($629 | 0) == 0) { + label = 145; + break; + } else { + label = 146; + break; + } + case 145: + $632 = invoke_ii(556, 709 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $_r0_sroa_0 = $632; + $_r0_sroa_0 = 0; + $_r3_sroa_0 = $_r0_sroa_0; + HEAP32[($_r3_sroa_1 | 0) >> 2] = HEAP32[($_r0_sroa_1 | 0) >> 2] | 0; + _memcpy(HEAP32[$625 >> 2] | 0 | 0, $623 | 0, 40); + label = 179; + break; + case 146: + _memcpy(HEAP32[$625 >> 2] | 0 | 0, $623 | 0, 40); + if ((HEAP32[(113236 | 0) >> 2] | 0 | 0) == 0) { + label = 147; + break; + } else { + label = 148; + break; + } + case 147: + invoke_v(538); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 148; + break; + case 148: + $643 = $548 + 20 | 0; + $644 = HEAP32[$643 >> 2] | 0; + if (($644 | 0) == 0) { + label = 162; + break; + } else { + label = 149; + break; + } + case 149: + $649 = HEAP32[$644 >> 2] | 0; + $653 = HEAP32[((HEAP32[138672 >> 2] | 0) + 8 | 0) >> 2] | 0; + if (($649 | 0) == 82712) { + label = 150; + break; + } else { + $tib1_0_ph_i437 = $649; + label = 151; + break; + } + case 150: + $tib1_0_ph_i437 = HEAP32[((HEAP32[($644 + 8 | 0) >> 2] | 0) + 8 | 0) >> 2] | 0; + label = 151; + break; + case 151: + $664 = HEAP32[($tib1_0_ph_i437 + 56 | 0) >> 2] | 0; + if (($664 | 0) == 0) { + $dimension_tib1_0_lcssa_i441 = 0; + $tib1_0_lcssa_i440 = $tib1_0_ph_i437; + label = 153; + break; + } else { + $dimension_tib1_029_i443 = 0; + $671 = $664; + label = 154; + break; + } + case 152: + $dimension_tib1_0_lcssa_i441 = $675; + $tib1_0_lcssa_i440 = $674; + label = 153; + break; + case 153: + $669 = HEAP32[($653 + 56 | 0) >> 2] | 0; + if (($669 | 0) == 0) { + $dimension_tib2_0_lcssa_i448 = 0; + $tib2_0_lcssa_in_i447 = $653; + label = 156; + break; + } else { + $dimension_tib2_024_i445 = 0; + $680 = $669; + label = 155; + break; + } + case 154: + $674 = HEAP32[($671 + 8 | 0) >> 2] | 0; + $675 = $dimension_tib1_029_i443 + 1 | 0; + $678 = HEAP32[($674 + 56 | 0) >> 2] | 0; + if (($678 | 0) == 0) { + label = 152; + break; + } else { + $dimension_tib1_029_i443 = $675; + $671 = $678; + label = 154; + break; + } + case 155: + $683 = HEAP32[($680 + 8 | 0) >> 2] | 0; + $684 = $dimension_tib2_024_i445 + 1 | 0; + $687 = HEAP32[($683 + 56 | 0) >> 2] | 0; + if (($687 | 0) == 0) { + $dimension_tib2_0_lcssa_i448 = $684; + $tib2_0_lcssa_in_i447 = $683; + label = 156; + break; + } else { + $dimension_tib2_024_i445 = $684; + $680 = $687; + label = 155; + break; + } + case 156: + $tib2_0_lcssa_i449 = $tib2_0_lcssa_in_i447; + if (($dimension_tib1_0_lcssa_i441 | 0) < ($dimension_tib2_0_lcssa_i448 | 0) | ($tib1_0_lcssa_i440 | 0) == 0) { + label = 162; + break; + } else { + $tib1_121_i452 = $tib1_0_lcssa_i440; + label = 157; + break; + } + case 157: + if (($tib1_121_i452 | 0) == ($tib2_0_lcssa_i449 | 0)) { + label = 361; + break; + } else { + label = 158; + break; + } + case 158: + $i_0_i455 = 0; + label = 159; + break; + case 159: + if (($i_0_i455 | 0) < (HEAP32[($tib1_121_i452 + 108 | 0) >> 2] | 0 | 0)) { + label = 160; + break; + } else { + label = 161; + break; + } + case 160: + if ((HEAP32[((HEAP32[($tib1_121_i452 + 112 | 0) >> 2] | 0) + ($i_0_i455 << 2) | 0) >> 2] | 0 | 0) == ($tib2_0_lcssa_i449 | 0)) { + label = 361; + break; + } else { + $i_0_i455 = $i_0_i455 + 1 | 0; + label = 159; + break; + } + case 161: + $705 = HEAP32[($tib1_121_i452 + 40 | 0) >> 2] | 0; + if (($705 | 0) == 0) { + label = 162; + break; + } else { + $tib1_121_i452 = $705; + label = 157; + break; + } + case 162: + if ((HEAP32[(107740 | 0) >> 2] | 0 | 0) == 0) { + label = 163; + break; + } else { + label = 164; + break; + } + case 163: + invoke_v(374); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 164; + break; + case 164: + $711 = HEAP32[$643 >> 2] | 0; + if (($711 | 0) == 0) { + label = 178; + break; + } else { + label = 165; + break; + } + case 165: + $716 = HEAP32[$711 >> 2] | 0; + $720 = HEAP32[((HEAP32[137616 >> 2] | 0) + 8 | 0) >> 2] | 0; + if (($716 | 0) == 82712) { + label = 166; + break; + } else { + $tib1_0_ph_i416 = $716; + label = 167; + break; + } + case 166: + $tib1_0_ph_i416 = HEAP32[((HEAP32[($711 + 8 | 0) >> 2] | 0) + 8 | 0) >> 2] | 0; + label = 167; + break; + case 167: + $731 = HEAP32[($tib1_0_ph_i416 + 56 | 0) >> 2] | 0; + if (($731 | 0) == 0) { + $dimension_tib1_0_lcssa_i420 = 0; + $tib1_0_lcssa_i419 = $tib1_0_ph_i416; + label = 169; + break; + } else { + $dimension_tib1_029_i422 = 0; + $738 = $731; + label = 170; + break; + } + case 168: + $dimension_tib1_0_lcssa_i420 = $742; + $tib1_0_lcssa_i419 = $741; + label = 169; + break; + case 169: + $736 = HEAP32[($720 + 56 | 0) >> 2] | 0; + if (($736 | 0) == 0) { + $dimension_tib2_0_lcssa_i427 = 0; + $tib2_0_lcssa_in_i426 = $720; + label = 172; + break; + } else { + $dimension_tib2_024_i424 = 0; + $747 = $736; + label = 171; + break; + } + case 170: + $741 = HEAP32[($738 + 8 | 0) >> 2] | 0; + $742 = $dimension_tib1_029_i422 + 1 | 0; + $745 = HEAP32[($741 + 56 | 0) >> 2] | 0; + if (($745 | 0) == 0) { + label = 168; + break; + } else { + $dimension_tib1_029_i422 = $742; + $738 = $745; + label = 170; + break; + } + case 171: + $750 = HEAP32[($747 + 8 | 0) >> 2] | 0; + $751 = $dimension_tib2_024_i424 + 1 | 0; + $754 = HEAP32[($750 + 56 | 0) >> 2] | 0; + if (($754 | 0) == 0) { + $dimension_tib2_0_lcssa_i427 = $751; + $tib2_0_lcssa_in_i426 = $750; + label = 172; + break; + } else { + $dimension_tib2_024_i424 = $751; + $747 = $754; + label = 171; + break; + } + case 172: + $tib2_0_lcssa_i428 = $tib2_0_lcssa_in_i426; + if (($dimension_tib1_0_lcssa_i420 | 0) < ($dimension_tib2_0_lcssa_i427 | 0) | ($tib1_0_lcssa_i419 | 0) == 0) { + label = 178; + break; + } else { + $tib1_121_i431 = $tib1_0_lcssa_i419; + label = 173; + break; + } + case 173: + if (($tib1_121_i431 | 0) == ($tib2_0_lcssa_i428 | 0)) { + label = 386; + break; + } else { + label = 174; + break; + } + case 174: + $i_0_i434 = 0; + label = 175; + break; + case 175: + if (($i_0_i434 | 0) < (HEAP32[($tib1_121_i431 + 108 | 0) >> 2] | 0 | 0)) { + label = 176; + break; + } else { + label = 177; + break; + } + case 176: + if ((HEAP32[((HEAP32[($tib1_121_i431 + 112 | 0) >> 2] | 0) + ($i_0_i434 << 2) | 0) >> 2] | 0 | 0) == ($tib2_0_lcssa_i428 | 0)) { + label = 386; + break; + } else { + $i_0_i434 = $i_0_i434 + 1 | 0; + label = 175; + break; + } + case 177: + $772 = HEAP32[($tib1_121_i431 + 40 | 0) >> 2] | 0; + if (($772 | 0) == 0) { + label = 178; + break; + } else { + $tib1_121_i431 = $772; + label = 173; + break; + } + case 178: + invoke_vii(48, HEAP32[$625 >> 2] | 0 | 0, 0 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case 179: + if ((HEAP32[(105500 | 0) >> 2] | 0 | 0) == 0) { + label = 180; + break; + } else { + label = 181; + break; + } + case 180: + invoke_v(30); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 181; + break; + case 181: + $780 = invoke_i(70) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $782 = invoke_iii(364, $780 | 0, 0 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $783 = $local_env_w4567aaac23b1c31; + $785 = $782 + 16 | 0; + _memcpy($783 | 0, HEAP32[$785 >> 2] | 0 | 0, 40); + $789 = _saveSetjmp(HEAP32[$785 >> 2] | 0 | 0, label, setjmpTable) | 0; + label = 419; + break; + case 419: + if (($789 | 0) == 0) { + label = 182; + break; + } else { + label = 183; + break; + } + case 182: + $798 = invoke_ii(HEAP32[(HEAP32[((HEAP32[$_r3_sroa_0 >> 2] | 0) + 116 | 0) >> 2] | 0) >> 2] | 0 | 0, $_r3_sroa_0 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $_r0_sroa_0 = $798; + _memcpy(HEAP32[$785 >> 2] | 0 | 0, $783 | 0, 40); + if (($_r0_sroa_0 | 0) == 0) { + label = 216; + break; + } else { + label = 322; + break; + } + case 183: + _memcpy(HEAP32[$785 >> 2] | 0 | 0, $783 | 0, 40); + if ((HEAP32[(113236 | 0) >> 2] | 0 | 0) == 0) { + label = 184; + break; + } else { + label = 185; + break; + } + case 184: + invoke_v(538); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 185; + break; + case 185: + $808 = $782 + 20 | 0; + $809 = HEAP32[$808 >> 2] | 0; + if (($809 | 0) == 0) { + label = 199; + break; + } else { + label = 186; + break; + } + case 186: + $814 = HEAP32[$809 >> 2] | 0; + $818 = HEAP32[((HEAP32[138672 >> 2] | 0) + 8 | 0) >> 2] | 0; + if (($814 | 0) == 82712) { + label = 187; + break; + } else { + $tib1_0_ph_i395 = $814; + label = 188; + break; + } + case 187: + $tib1_0_ph_i395 = HEAP32[((HEAP32[($809 + 8 | 0) >> 2] | 0) + 8 | 0) >> 2] | 0; + label = 188; + break; + case 188: + $829 = HEAP32[($tib1_0_ph_i395 + 56 | 0) >> 2] | 0; + if (($829 | 0) == 0) { + $dimension_tib1_0_lcssa_i399 = 0; + $tib1_0_lcssa_i398 = $tib1_0_ph_i395; + label = 190; + break; + } else { + $dimension_tib1_029_i401 = 0; + $836 = $829; + label = 191; + break; + } + case 189: + $dimension_tib1_0_lcssa_i399 = $840; + $tib1_0_lcssa_i398 = $839; + label = 190; + break; + case 190: + $834 = HEAP32[($818 + 56 | 0) >> 2] | 0; + if (($834 | 0) == 0) { + $dimension_tib2_0_lcssa_i406 = 0; + $tib2_0_lcssa_in_i405 = $818; + label = 193; + break; + } else { + $dimension_tib2_024_i403 = 0; + $845 = $834; + label = 192; + break; + } + case 191: + $839 = HEAP32[($836 + 8 | 0) >> 2] | 0; + $840 = $dimension_tib1_029_i401 + 1 | 0; + $843 = HEAP32[($839 + 56 | 0) >> 2] | 0; + if (($843 | 0) == 0) { + label = 189; + break; + } else { + $dimension_tib1_029_i401 = $840; + $836 = $843; + label = 191; + break; + } + case 192: + $848 = HEAP32[($845 + 8 | 0) >> 2] | 0; + $849 = $dimension_tib2_024_i403 + 1 | 0; + $852 = HEAP32[($848 + 56 | 0) >> 2] | 0; + if (($852 | 0) == 0) { + $dimension_tib2_0_lcssa_i406 = $849; + $tib2_0_lcssa_in_i405 = $848; + label = 193; + break; + } else { + $dimension_tib2_024_i403 = $849; + $845 = $852; + label = 192; + break; + } + case 193: + $tib2_0_lcssa_i407 = $tib2_0_lcssa_in_i405; + if (($dimension_tib1_0_lcssa_i399 | 0) < ($dimension_tib2_0_lcssa_i406 | 0) | ($tib1_0_lcssa_i398 | 0) == 0) { + label = 199; + break; + } else { + $tib1_121_i410 = $tib1_0_lcssa_i398; + label = 194; + break; + } + case 194: + if (($tib1_121_i410 | 0) == ($tib2_0_lcssa_i407 | 0)) { + label = 361; + break; + } else { + label = 195; + break; + } + case 195: + $i_0_i413 = 0; + label = 196; + break; + case 196: + if (($i_0_i413 | 0) < (HEAP32[($tib1_121_i410 + 108 | 0) >> 2] | 0 | 0)) { + label = 197; + break; + } else { + label = 198; + break; + } + case 197: + if ((HEAP32[((HEAP32[($tib1_121_i410 + 112 | 0) >> 2] | 0) + ($i_0_i413 << 2) | 0) >> 2] | 0 | 0) == ($tib2_0_lcssa_i407 | 0)) { + label = 361; + break; + } else { + $i_0_i413 = $i_0_i413 + 1 | 0; + label = 196; + break; + } + case 198: + $870 = HEAP32[($tib1_121_i410 + 40 | 0) >> 2] | 0; + if (($870 | 0) == 0) { + label = 199; + break; + } else { + $tib1_121_i410 = $870; + label = 194; + break; + } + case 199: + if ((HEAP32[(107740 | 0) >> 2] | 0 | 0) == 0) { + label = 200; + break; + } else { + label = 201; + break; + } + case 200: + invoke_v(374); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 201; + break; + case 201: + $876 = HEAP32[$808 >> 2] | 0; + if (($876 | 0) == 0) { + label = 215; + break; + } else { + label = 202; + break; + } + case 202: + $881 = HEAP32[$876 >> 2] | 0; + $885 = HEAP32[((HEAP32[137616 >> 2] | 0) + 8 | 0) >> 2] | 0; + if (($881 | 0) == 82712) { + label = 203; + break; + } else { + $tib1_0_ph_i374 = $881; + label = 204; + break; + } + case 203: + $tib1_0_ph_i374 = HEAP32[((HEAP32[($876 + 8 | 0) >> 2] | 0) + 8 | 0) >> 2] | 0; + label = 204; + break; + case 204: + $896 = HEAP32[($tib1_0_ph_i374 + 56 | 0) >> 2] | 0; + if (($896 | 0) == 0) { + $dimension_tib1_0_lcssa_i378 = 0; + $tib1_0_lcssa_i377 = $tib1_0_ph_i374; + label = 206; + break; + } else { + $dimension_tib1_029_i380 = 0; + $903 = $896; + label = 207; + break; + } + case 205: + $dimension_tib1_0_lcssa_i378 = $907; + $tib1_0_lcssa_i377 = $906; + label = 206; + break; + case 206: + $901 = HEAP32[($885 + 56 | 0) >> 2] | 0; + if (($901 | 0) == 0) { + $dimension_tib2_0_lcssa_i385 = 0; + $tib2_0_lcssa_in_i384 = $885; + label = 209; + break; + } else { + $dimension_tib2_024_i382 = 0; + $912 = $901; + label = 208; + break; + } + case 207: + $906 = HEAP32[($903 + 8 | 0) >> 2] | 0; + $907 = $dimension_tib1_029_i380 + 1 | 0; + $910 = HEAP32[($906 + 56 | 0) >> 2] | 0; + if (($910 | 0) == 0) { + label = 205; + break; + } else { + $dimension_tib1_029_i380 = $907; + $903 = $910; + label = 207; + break; + } + case 208: + $915 = HEAP32[($912 + 8 | 0) >> 2] | 0; + $916 = $dimension_tib2_024_i382 + 1 | 0; + $919 = HEAP32[($915 + 56 | 0) >> 2] | 0; + if (($919 | 0) == 0) { + $dimension_tib2_0_lcssa_i385 = $916; + $tib2_0_lcssa_in_i384 = $915; + label = 209; + break; + } else { + $dimension_tib2_024_i382 = $916; + $912 = $919; + label = 208; + break; + } + case 209: + $tib2_0_lcssa_i386 = $tib2_0_lcssa_in_i384; + if (($dimension_tib1_0_lcssa_i378 | 0) < ($dimension_tib2_0_lcssa_i385 | 0) | ($tib1_0_lcssa_i377 | 0) == 0) { + label = 215; + break; + } else { + $tib1_121_i389 = $tib1_0_lcssa_i377; + label = 210; + break; + } + case 210: + if (($tib1_121_i389 | 0) == ($tib2_0_lcssa_i386 | 0)) { + label = 386; + break; + } else { + label = 211; + break; + } + case 211: + $i_0_i392 = 0; + label = 212; + break; + case 212: + if (($i_0_i392 | 0) < (HEAP32[($tib1_121_i389 + 108 | 0) >> 2] | 0 | 0)) { + label = 213; + break; + } else { + label = 214; + break; + } + case 213: + if ((HEAP32[((HEAP32[($tib1_121_i389 + 112 | 0) >> 2] | 0) + ($i_0_i392 << 2) | 0) >> 2] | 0 | 0) == ($tib2_0_lcssa_i386 | 0)) { + label = 386; + break; + } else { + $i_0_i392 = $i_0_i392 + 1 | 0; + label = 212; + break; + } + case 214: + $937 = HEAP32[($tib1_121_i389 + 40 | 0) >> 2] | 0; + if (($937 | 0) == 0) { + label = 215; + break; + } else { + $tib1_121_i389 = $937; + label = 210; + break; + } + case 215: + invoke_vii(48, HEAP32[$785 >> 2] | 0 | 0, 0 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case 216: + $_r0_sroa_0 = 0; + if ((HEAP32[(105500 | 0) >> 2] | 0 | 0) == 0) { + label = 217; + break; + } else { + label = 218; + break; + } + case 217: + invoke_v(30); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 218; + break; + case 218: + $945 = invoke_i(70) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $947 = invoke_iii(364, $945 | 0, 0 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $948 = $local_env_w4567aaac23b1c35; + $950 = $947 + 16 | 0; + _memcpy($948 | 0, HEAP32[$950 >> 2] | 0 | 0, 40); + $954 = _saveSetjmp(HEAP32[$950 >> 2] | 0 | 0, label, setjmpTable) | 0; + label = 420; + break; + case 420: + if (($954 | 0) == 0) { + label = 219; + break; + } else { + label = 222; + break; + } + case 219: + $_r0_sroa_0_0_load607 = $_r0_sroa_0; + if ((HEAP32[(98772 | 0) >> 2] | 0 | 0) == 0) { + label = 220; + break; + } else { + label = 221; + break; + } + case 220: + invoke_v(702); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 221; + break; + case 221: + HEAP32[140048 >> 2] = $_r0_sroa_0_0_load607; + _memcpy(HEAP32[$950 >> 2] | 0 | 0, $948 | 0, 40); + label = 239; + break; + case 222: + _memcpy(HEAP32[$950 >> 2] | 0 | 0, $948 | 0, 40); + if ((HEAP32[(107740 | 0) >> 2] | 0 | 0) == 0) { + label = 223; + break; + } else { + label = 224; + break; + } + case 223: + invoke_v(374); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 224; + break; + case 224: + $969 = HEAP32[($947 + 20 | 0) >> 2] | 0; + if (($969 | 0) == 0) { + label = 238; + break; + } else { + label = 225; + break; + } + case 225: + $974 = HEAP32[$969 >> 2] | 0; + $978 = HEAP32[((HEAP32[137616 >> 2] | 0) + 8 | 0) >> 2] | 0; + if (($974 | 0) == 82712) { + label = 226; + break; + } else { + $tib1_0_ph_i353 = $974; + label = 227; + break; + } + case 226: + $tib1_0_ph_i353 = HEAP32[((HEAP32[($969 + 8 | 0) >> 2] | 0) + 8 | 0) >> 2] | 0; + label = 227; + break; + case 227: + $989 = HEAP32[($tib1_0_ph_i353 + 56 | 0) >> 2] | 0; + if (($989 | 0) == 0) { + $dimension_tib1_0_lcssa_i357 = 0; + $tib1_0_lcssa_i356 = $tib1_0_ph_i353; + label = 229; + break; + } else { + $dimension_tib1_029_i359 = 0; + $996 = $989; + label = 230; + break; + } + case 228: + $dimension_tib1_0_lcssa_i357 = $1000; + $tib1_0_lcssa_i356 = $999; + label = 229; + break; + case 229: + $994 = HEAP32[($978 + 56 | 0) >> 2] | 0; + if (($994 | 0) == 0) { + $dimension_tib2_0_lcssa_i364 = 0; + $tib2_0_lcssa_in_i363 = $978; + label = 232; + break; + } else { + $dimension_tib2_024_i361 = 0; + $1005 = $994; + label = 231; + break; + } + case 230: + $999 = HEAP32[($996 + 8 | 0) >> 2] | 0; + $1000 = $dimension_tib1_029_i359 + 1 | 0; + $1003 = HEAP32[($999 + 56 | 0) >> 2] | 0; + if (($1003 | 0) == 0) { + label = 228; + break; + } else { + $dimension_tib1_029_i359 = $1000; + $996 = $1003; + label = 230; + break; + } + case 231: + $1008 = HEAP32[($1005 + 8 | 0) >> 2] | 0; + $1009 = $dimension_tib2_024_i361 + 1 | 0; + $1012 = HEAP32[($1008 + 56 | 0) >> 2] | 0; + if (($1012 | 0) == 0) { + $dimension_tib2_0_lcssa_i364 = $1009; + $tib2_0_lcssa_in_i363 = $1008; + label = 232; + break; + } else { + $dimension_tib2_024_i361 = $1009; + $1005 = $1012; + label = 231; + break; + } + case 232: + $tib2_0_lcssa_i365 = $tib2_0_lcssa_in_i363; + if (($dimension_tib1_0_lcssa_i357 | 0) < ($dimension_tib2_0_lcssa_i364 | 0) | ($tib1_0_lcssa_i356 | 0) == 0) { + label = 238; + break; + } else { + $tib1_121_i368 = $tib1_0_lcssa_i356; + label = 233; + break; + } + case 233: + if (($tib1_121_i368 | 0) == ($tib2_0_lcssa_i365 | 0)) { + label = 54; + break; + } else { + label = 234; + break; + } + case 234: + $i_0_i371 = 0; + label = 235; + break; + case 235: + if (($i_0_i371 | 0) < (HEAP32[($tib1_121_i368 + 108 | 0) >> 2] | 0 | 0)) { + label = 236; + break; + } else { + label = 237; + break; + } + case 236: + if ((HEAP32[((HEAP32[($tib1_121_i368 + 112 | 0) >> 2] | 0) + ($i_0_i371 << 2) | 0) >> 2] | 0 | 0) == ($tib2_0_lcssa_i365 | 0)) { + label = 54; + break; + } else { + $i_0_i371 = $i_0_i371 + 1 | 0; + label = 235; + break; + } + case 237: + $1030 = HEAP32[($tib1_121_i368 + 40 | 0) >> 2] | 0; + if (($1030 | 0) == 0) { + label = 238; + break; + } else { + $tib1_121_i368 = $1030; + label = 233; + break; + } + case 238: + invoke_vii(48, HEAP32[$950 >> 2] | 0 | 0, 0 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case 239: + $_r0_sroa_0 = 0; + label = 28; + break; + case 240: + $1036 = $local_env_w4567aaac23b1c40; + $1038 = $548 + 16 | 0; + _memcpy($1036 | 0, HEAP32[$1038 >> 2] | 0 | 0, 40); + $1042 = _saveSetjmp(HEAP32[$1038 >> 2] | 0 | 0, label, setjmpTable) | 0; + label = 421; + break; + case 421: + if (($1042 | 0) == 0) { + label = 241; + break; + } else { + label = 253; + break; + } + case 241: + if ((HEAP32[(98772 | 0) >> 2] | 0 | 0) == 0) { + label = 242; + break; + } else { + label = 244; + break; + } + case 242: + invoke_v(702); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + if ((HEAP32[(98772 | 0) >> 2] | 0 | 0) == 0) { + label = 243; + break; + } else { + label = 244; + break; + } + case 243: + invoke_v(702); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 244; + break; + case 244: + $1050 = HEAP32[140040 >> 2] | 0; + if (($1050 | 0) == 0) { + label = 245; + break; + } else { + label = 246; + break; + } + case 245: + invoke_viiii(14, 16136 | 0 | 0, 11648 | 0 | 0, 126768 | 0 | 0, 573 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case 246: + if ((HEAP32[(98772 | 0) >> 2] | 0 | 0) == 0) { + label = 247; + break; + } else { + $1056 = $1050; + label = 248; + break; + } + case 247: + invoke_v(702); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $1056 = HEAP32[140040 >> 2] | 0; + label = 248; + break; + case 248: + $_r0_sroa_0 = $1056; + if (($_r0_sroa_0 | 0) == 0) { + label = 252; + break; + } else { + label = 249; + break; + } + case 249: + _memcpy(HEAP32[$1038 >> 2] | 0 | 0, $1036 | 0, 40); + if ((HEAP32[(105500 | 0) >> 2] | 0 | 0) == 0) { + label = 250; + break; + } else { + label = 251; + break; + } + case 250: + invoke_v(30); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 251; + break; + case 251: + $1064 = invoke_i(70) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $1066 = invoke_iii(364, $1064 | 0, 0 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $1067 = $local_env_w4567aaac23b1c42; + $1069 = $1066 + 16 | 0; + _memcpy($1067 | 0, HEAP32[$1069 >> 2] | 0 | 0, 40); + $1073 = _saveSetjmp(HEAP32[$1069 >> 2] | 0 | 0, label, setjmpTable) | 0; + label = 422; + break; + case 422: + if (($1073 | 0) == 0) { + label = 286; + break; + } else { + label = 289; + break; + } + case 252: + invoke_viiii(14, 16136 | 0 | 0, 11648 | 0 | 0, 126872 | 0 | 0, 1581 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case 253: + _memcpy(HEAP32[$1038 >> 2] | 0 | 0, $1036 | 0, 40); + if ((HEAP32[(113236 | 0) >> 2] | 0 | 0) == 0) { + label = 254; + break; + } else { + label = 255; + break; + } + case 254: + invoke_v(538); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 255; + break; + case 255: + $1083 = $548 + 20 | 0; + $1084 = HEAP32[$1083 >> 2] | 0; + if (($1084 | 0) == 0) { + label = 269; + break; + } else { + label = 256; + break; + } + case 256: + $1089 = HEAP32[$1084 >> 2] | 0; + $1093 = HEAP32[((HEAP32[138672 >> 2] | 0) + 8 | 0) >> 2] | 0; + if (($1089 | 0) == 82712) { + label = 257; + break; + } else { + $tib1_0_ph_i332 = $1089; + label = 258; + break; + } + case 257: + $tib1_0_ph_i332 = HEAP32[((HEAP32[($1084 + 8 | 0) >> 2] | 0) + 8 | 0) >> 2] | 0; + label = 258; + break; + case 258: + $1104 = HEAP32[($tib1_0_ph_i332 + 56 | 0) >> 2] | 0; + if (($1104 | 0) == 0) { + $dimension_tib1_0_lcssa_i336 = 0; + $tib1_0_lcssa_i335 = $tib1_0_ph_i332; + label = 260; + break; + } else { + $dimension_tib1_029_i338 = 0; + $1111 = $1104; + label = 261; + break; + } + case 259: + $dimension_tib1_0_lcssa_i336 = $1115; + $tib1_0_lcssa_i335 = $1114; + label = 260; + break; + case 260: + $1109 = HEAP32[($1093 + 56 | 0) >> 2] | 0; + if (($1109 | 0) == 0) { + $dimension_tib2_0_lcssa_i343 = 0; + $tib2_0_lcssa_in_i342 = $1093; + label = 263; + break; + } else { + $dimension_tib2_024_i340 = 0; + $1120 = $1109; + label = 262; + break; + } + case 261: + $1114 = HEAP32[($1111 + 8 | 0) >> 2] | 0; + $1115 = $dimension_tib1_029_i338 + 1 | 0; + $1118 = HEAP32[($1114 + 56 | 0) >> 2] | 0; + if (($1118 | 0) == 0) { + label = 259; + break; + } else { + $dimension_tib1_029_i338 = $1115; + $1111 = $1118; + label = 261; + break; + } + case 262: + $1123 = HEAP32[($1120 + 8 | 0) >> 2] | 0; + $1124 = $dimension_tib2_024_i340 + 1 | 0; + $1127 = HEAP32[($1123 + 56 | 0) >> 2] | 0; + if (($1127 | 0) == 0) { + $dimension_tib2_0_lcssa_i343 = $1124; + $tib2_0_lcssa_in_i342 = $1123; + label = 263; + break; + } else { + $dimension_tib2_024_i340 = $1124; + $1120 = $1127; + label = 262; + break; + } + case 263: + $tib2_0_lcssa_i344 = $tib2_0_lcssa_in_i342; + if (($dimension_tib1_0_lcssa_i336 | 0) < ($dimension_tib2_0_lcssa_i343 | 0) | ($tib1_0_lcssa_i335 | 0) == 0) { + label = 269; + break; + } else { + $tib1_121_i347 = $tib1_0_lcssa_i335; + label = 264; + break; + } + case 264: + if (($tib1_121_i347 | 0) == ($tib2_0_lcssa_i344 | 0)) { + label = 361; + break; + } else { + label = 265; + break; + } + case 265: + $i_0_i350 = 0; + label = 266; + break; + case 266: + if (($i_0_i350 | 0) < (HEAP32[($tib1_121_i347 + 108 | 0) >> 2] | 0 | 0)) { + label = 267; + break; + } else { + label = 268; + break; + } + case 267: + if ((HEAP32[((HEAP32[($tib1_121_i347 + 112 | 0) >> 2] | 0) + ($i_0_i350 << 2) | 0) >> 2] | 0 | 0) == ($tib2_0_lcssa_i344 | 0)) { + label = 361; + break; + } else { + $i_0_i350 = $i_0_i350 + 1 | 0; + label = 266; + break; + } + case 268: + $1145 = HEAP32[($tib1_121_i347 + 40 | 0) >> 2] | 0; + if (($1145 | 0) == 0) { + label = 269; + break; + } else { + $tib1_121_i347 = $1145; + label = 264; + break; + } + case 269: + if ((HEAP32[(107740 | 0) >> 2] | 0 | 0) == 0) { + label = 270; + break; + } else { + label = 271; + break; + } + case 270: + invoke_v(374); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 271; + break; + case 271: + $1151 = HEAP32[$1083 >> 2] | 0; + if (($1151 | 0) == 0) { + label = 285; + break; + } else { + label = 272; + break; + } + case 272: + $1156 = HEAP32[$1151 >> 2] | 0; + $1160 = HEAP32[((HEAP32[137616 >> 2] | 0) + 8 | 0) >> 2] | 0; + if (($1156 | 0) == 82712) { + label = 273; + break; + } else { + $tib1_0_ph_i311 = $1156; + label = 274; + break; + } + case 273: + $tib1_0_ph_i311 = HEAP32[((HEAP32[($1151 + 8 | 0) >> 2] | 0) + 8 | 0) >> 2] | 0; + label = 274; + break; + case 274: + $1171 = HEAP32[($tib1_0_ph_i311 + 56 | 0) >> 2] | 0; + if (($1171 | 0) == 0) { + $dimension_tib1_0_lcssa_i315 = 0; + $tib1_0_lcssa_i314 = $tib1_0_ph_i311; + label = 276; + break; + } else { + $dimension_tib1_029_i317 = 0; + $1178 = $1171; + label = 277; + break; } + case 275: + $dimension_tib1_0_lcssa_i315 = $1182; + $tib1_0_lcssa_i314 = $1181; + label = 276; + break; + case 276: + $1176 = HEAP32[($1160 + 56 | 0) >> 2] | 0; + if (($1176 | 0) == 0) { + $dimension_tib2_0_lcssa_i322 = 0; + $tib2_0_lcssa_in_i321 = $1160; + label = 279; + break; + } else { + $dimension_tib2_024_i319 = 0; + $1187 = $1176; + label = 278; + break; + } + case 277: + $1181 = HEAP32[($1178 + 8 | 0) >> 2] | 0; + $1182 = $dimension_tib1_029_i317 + 1 | 0; + $1185 = HEAP32[($1181 + 56 | 0) >> 2] | 0; + if (($1185 | 0) == 0) { + label = 275; + break; + } else { + $dimension_tib1_029_i317 = $1182; + $1178 = $1185; + label = 277; + break; + } + case 278: + $1190 = HEAP32[($1187 + 8 | 0) >> 2] | 0; + $1191 = $dimension_tib2_024_i319 + 1 | 0; + $1194 = HEAP32[($1190 + 56 | 0) >> 2] | 0; + if (($1194 | 0) == 0) { + $dimension_tib2_0_lcssa_i322 = $1191; + $tib2_0_lcssa_in_i321 = $1190; + label = 279; + break; + } else { + $dimension_tib2_024_i319 = $1191; + $1187 = $1194; + label = 278; + break; + } + case 279: + $tib2_0_lcssa_i323 = $tib2_0_lcssa_in_i321; + if (($dimension_tib1_0_lcssa_i315 | 0) < ($dimension_tib2_0_lcssa_i322 | 0) | ($tib1_0_lcssa_i314 | 0) == 0) { + label = 285; + break; + } else { + $tib1_121_i326 = $tib1_0_lcssa_i314; + label = 280; + break; + } + case 280: + if (($tib1_121_i326 | 0) == ($tib2_0_lcssa_i323 | 0)) { + label = 386; + break; + } else { + label = 281; + break; + } + case 281: + $i_0_i329 = 0; + label = 282; + break; + case 282: + if (($i_0_i329 | 0) < (HEAP32[($tib1_121_i326 + 108 | 0) >> 2] | 0 | 0)) { + label = 283; + break; + } else { + label = 284; + break; + } + case 283: + if ((HEAP32[((HEAP32[($tib1_121_i326 + 112 | 0) >> 2] | 0) + ($i_0_i329 << 2) | 0) >> 2] | 0 | 0) == ($tib2_0_lcssa_i323 | 0)) { + label = 386; + break; + } else { + $i_0_i329 = $i_0_i329 + 1 | 0; + label = 282; + break; + } + case 284: + $1212 = HEAP32[($tib1_121_i326 + 40 | 0) >> 2] | 0; + if (($1212 | 0) == 0) { + label = 285; + break; + } else { + $tib1_121_i326 = $1212; + label = 280; + break; + } + case 285: + invoke_vii(48, HEAP32[$1038 >> 2] | 0 | 0, 0 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case 286: + if ((HEAP32[(98772 | 0) >> 2] | 0 | 0) == 0) { + label = 287; + break; + } else { + label = 288; + break; + } + case 287: + invoke_v(702); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 288; + break; + case 288: + $_r0_sroa_0 = HEAP32[140040 >> 2] | 0; + $1222 = invoke_ii(556, 709 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $_r3_sroa_0 = $1222; + $_r0_sroa_0 = 0; + $_r3_sroa_0 = $_r0_sroa_0; + HEAP32[($_r3_sroa_1 | 0) >> 2] = HEAP32[($_r0_sroa_1 | 0) >> 2] | 0; + _memcpy(HEAP32[$1069 >> 2] | 0 | 0, $1067 | 0, 40); + label = 179; + break; + case 289: + _memcpy(HEAP32[$1069 >> 2] | 0 | 0, $1067 | 0, 40); + if ((HEAP32[(113236 | 0) >> 2] | 0 | 0) == 0) { + label = 290; + break; + } else { + label = 291; + break; + } + case 290: + invoke_v(538); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 291; + break; + case 291: + $1232 = $1066 + 20 | 0; + $1233 = HEAP32[$1232 >> 2] | 0; + if (($1233 | 0) == 0) { + label = 305; + break; + } else { + label = 292; + break; + } + case 292: + $1238 = HEAP32[$1233 >> 2] | 0; + $1242 = HEAP32[((HEAP32[138672 >> 2] | 0) + 8 | 0) >> 2] | 0; + if (($1238 | 0) == 82712) { + label = 293; + break; + } else { + $tib1_0_ph_i290 = $1238; + label = 294; + break; + } + case 293: + $tib1_0_ph_i290 = HEAP32[((HEAP32[($1233 + 8 | 0) >> 2] | 0) + 8 | 0) >> 2] | 0; + label = 294; + break; + case 294: + $1253 = HEAP32[($tib1_0_ph_i290 + 56 | 0) >> 2] | 0; + if (($1253 | 0) == 0) { + $dimension_tib1_0_lcssa_i294 = 0; + $tib1_0_lcssa_i293 = $tib1_0_ph_i290; + label = 296; + break; + } else { + $dimension_tib1_029_i296 = 0; + $1260 = $1253; + label = 297; + break; + } + case 295: + $dimension_tib1_0_lcssa_i294 = $1264; + $tib1_0_lcssa_i293 = $1263; + label = 296; + break; + case 296: + $1258 = HEAP32[($1242 + 56 | 0) >> 2] | 0; + if (($1258 | 0) == 0) { + $dimension_tib2_0_lcssa_i301 = 0; + $tib2_0_lcssa_in_i300 = $1242; + label = 299; + break; + } else { + $dimension_tib2_024_i298 = 0; + $1269 = $1258; + label = 298; + break; + } + case 297: + $1263 = HEAP32[($1260 + 8 | 0) >> 2] | 0; + $1264 = $dimension_tib1_029_i296 + 1 | 0; + $1267 = HEAP32[($1263 + 56 | 0) >> 2] | 0; + if (($1267 | 0) == 0) { + label = 295; + break; + } else { + $dimension_tib1_029_i296 = $1264; + $1260 = $1267; + label = 297; + break; + } + case 298: + $1272 = HEAP32[($1269 + 8 | 0) >> 2] | 0; + $1273 = $dimension_tib2_024_i298 + 1 | 0; + $1276 = HEAP32[($1272 + 56 | 0) >> 2] | 0; + if (($1276 | 0) == 0) { + $dimension_tib2_0_lcssa_i301 = $1273; + $tib2_0_lcssa_in_i300 = $1272; + label = 299; + break; + } else { + $dimension_tib2_024_i298 = $1273; + $1269 = $1276; + label = 298; + break; + } + case 299: + $tib2_0_lcssa_i302 = $tib2_0_lcssa_in_i300; + if (($dimension_tib1_0_lcssa_i294 | 0) < ($dimension_tib2_0_lcssa_i301 | 0) | ($tib1_0_lcssa_i293 | 0) == 0) { + label = 305; + break; + } else { + $tib1_121_i305 = $tib1_0_lcssa_i293; + label = 300; + break; + } + case 300: + if (($tib1_121_i305 | 0) == ($tib2_0_lcssa_i302 | 0)) { + label = 361; + break; + } else { + label = 301; + break; + } + case 301: + $i_0_i308 = 0; + label = 302; + break; + case 302: + if (($i_0_i308 | 0) < (HEAP32[($tib1_121_i305 + 108 | 0) >> 2] | 0 | 0)) { + label = 303; + break; + } else { + label = 304; + break; + } + case 303: + if ((HEAP32[((HEAP32[($tib1_121_i305 + 112 | 0) >> 2] | 0) + ($i_0_i308 << 2) | 0) >> 2] | 0 | 0) == ($tib2_0_lcssa_i302 | 0)) { + label = 361; + break; + } else { + $i_0_i308 = $i_0_i308 + 1 | 0; + label = 302; + break; + } + case 304: + $1294 = HEAP32[($tib1_121_i305 + 40 | 0) >> 2] | 0; + if (($1294 | 0) == 0) { + label = 305; + break; + } else { + $tib1_121_i305 = $1294; + label = 300; + break; + } + case 305: + if ((HEAP32[(107740 | 0) >> 2] | 0 | 0) == 0) { + label = 306; + break; + } else { + label = 307; + break; + } + case 306: + invoke_v(374); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 307; + break; + case 307: + $1300 = HEAP32[$1232 >> 2] | 0; + if (($1300 | 0) == 0) { + label = 321; + break; + } else { + label = 308; + break; + } + case 308: + $1305 = HEAP32[$1300 >> 2] | 0; + $1309 = HEAP32[((HEAP32[137616 >> 2] | 0) + 8 | 0) >> 2] | 0; + if (($1305 | 0) == 82712) { + label = 309; + break; + } else { + $tib1_0_ph_i269 = $1305; + label = 310; + break; + } + case 309: + $tib1_0_ph_i269 = HEAP32[((HEAP32[($1300 + 8 | 0) >> 2] | 0) + 8 | 0) >> 2] | 0; + label = 310; + break; + case 310: + $1320 = HEAP32[($tib1_0_ph_i269 + 56 | 0) >> 2] | 0; + if (($1320 | 0) == 0) { + $dimension_tib1_0_lcssa_i273 = 0; + $tib1_0_lcssa_i272 = $tib1_0_ph_i269; + label = 312; + break; + } else { + $dimension_tib1_029_i275 = 0; + $1327 = $1320; + label = 313; + break; + } + case 311: + $dimension_tib1_0_lcssa_i273 = $1331; + $tib1_0_lcssa_i272 = $1330; + label = 312; + break; + case 312: + $1325 = HEAP32[($1309 + 56 | 0) >> 2] | 0; + if (($1325 | 0) == 0) { + $dimension_tib2_0_lcssa_i280 = 0; + $tib2_0_lcssa_in_i279 = $1309; + label = 315; + break; + } else { + $dimension_tib2_024_i277 = 0; + $1336 = $1325; + label = 314; + break; + } + case 313: + $1330 = HEAP32[($1327 + 8 | 0) >> 2] | 0; + $1331 = $dimension_tib1_029_i275 + 1 | 0; + $1334 = HEAP32[($1330 + 56 | 0) >> 2] | 0; + if (($1334 | 0) == 0) { + label = 311; + break; + } else { + $dimension_tib1_029_i275 = $1331; + $1327 = $1334; + label = 313; + break; + } + case 314: + $1339 = HEAP32[($1336 + 8 | 0) >> 2] | 0; + $1340 = $dimension_tib2_024_i277 + 1 | 0; + $1343 = HEAP32[($1339 + 56 | 0) >> 2] | 0; + if (($1343 | 0) == 0) { + $dimension_tib2_0_lcssa_i280 = $1340; + $tib2_0_lcssa_in_i279 = $1339; + label = 315; + break; + } else { + $dimension_tib2_024_i277 = $1340; + $1336 = $1343; + label = 314; + break; + } + case 315: + $tib2_0_lcssa_i281 = $tib2_0_lcssa_in_i279; + if (($dimension_tib1_0_lcssa_i273 | 0) < ($dimension_tib2_0_lcssa_i280 | 0) | ($tib1_0_lcssa_i272 | 0) == 0) { + label = 321; + break; + } else { + $tib1_121_i284 = $tib1_0_lcssa_i272; + label = 316; + break; + } + case 316: + if (($tib1_121_i284 | 0) == ($tib2_0_lcssa_i281 | 0)) { + label = 386; + break; + } else { + label = 317; + break; + } + case 317: + $i_0_i287 = 0; + label = 318; + break; + case 318: + if (($i_0_i287 | 0) < (HEAP32[($tib1_121_i284 + 108 | 0) >> 2] | 0 | 0)) { + label = 319; + break; + } else { + label = 320; + break; + } + case 319: + if ((HEAP32[((HEAP32[($tib1_121_i284 + 112 | 0) >> 2] | 0) + ($i_0_i287 << 2) | 0) >> 2] | 0 | 0) == ($tib2_0_lcssa_i281 | 0)) { + label = 386; + break; + } else { + $i_0_i287 = $i_0_i287 + 1 | 0; + label = 318; + break; + } + case 320: + $1361 = HEAP32[($tib1_121_i284 + 40 | 0) >> 2] | 0; + if (($1361 | 0) == 0) { + label = 321; + break; + } else { + $tib1_121_i284 = $1361; + label = 316; + break; + } + case 321: + invoke_vii(48, HEAP32[$1069 >> 2] | 0 | 0, 0 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case 322: + if ((HEAP32[(105500 | 0) >> 2] | 0 | 0) == 0) { + label = 323; + break; + } else { + label = 324; + break; + } + case 323: + invoke_v(30); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 324; + break; + case 324: + $1369 = invoke_i(70) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $1371 = invoke_iii(364, $1369 | 0, 0 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $1372 = $local_env_w4567aaac23b1c44; + $1374 = $1371 + 16 | 0; + _memcpy($1372 | 0, HEAP32[$1374 >> 2] | 0 | 0, 40); + $1378 = _saveSetjmp(HEAP32[$1374 >> 2] | 0 | 0, label, setjmpTable) | 0; + label = 423; + break; + case 423: + if (($1378 | 0) == 0) { + label = 325; + break; + } else { + label = 328; + break; + } + case 325: + $_r0_sroa_0 = 1; + $_r0_sroa_0_0_load604 = $_r0_sroa_0; + if ((HEAP32[(98772 | 0) >> 2] | 0 | 0) == 0) { + label = 326; + break; + } else { + label = 327; + break; + } + case 326: + invoke_v(702); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 327; + break; + case 327: + HEAP32[140048 >> 2] = $_r0_sroa_0_0_load604; + $1391 = invoke_ii(HEAP32[((HEAP32[((HEAP32[$_r3_sroa_0 >> 2] | 0) + 116 | 0) >> 2] | 0) + 4 | 0) >> 2] | 0 | 0, $_r3_sroa_0 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $_r0_sroa_0 = $1391; + invoke_viiii(14, 16136 | 0 | 0, 11648 | 0 | 0, 126872 | 0 | 0, 1630 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case 328: + _memcpy(HEAP32[$1374 >> 2] | 0 | 0, $1372 | 0, 40); + if ((HEAP32[(113236 | 0) >> 2] | 0 | 0) == 0) { + label = 329; + break; + } else { + label = 330; + break; + } + case 329: + invoke_v(538); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 330; + break; + case 330: + $1400 = $1371 + 20 | 0; + $1401 = HEAP32[$1400 >> 2] | 0; + if (($1401 | 0) == 0) { + label = 344; + break; + } else { + label = 331; + break; + } + case 331: + $1406 = HEAP32[$1401 >> 2] | 0; + $1410 = HEAP32[((HEAP32[138672 >> 2] | 0) + 8 | 0) >> 2] | 0; + if (($1406 | 0) == 82712) { + label = 332; + break; + } else { + $tib1_0_ph_i248 = $1406; + label = 333; + break; + } + case 332: + $tib1_0_ph_i248 = HEAP32[((HEAP32[($1401 + 8 | 0) >> 2] | 0) + 8 | 0) >> 2] | 0; + label = 333; + break; + case 333: + $1421 = HEAP32[($tib1_0_ph_i248 + 56 | 0) >> 2] | 0; + if (($1421 | 0) == 0) { + $dimension_tib1_0_lcssa_i252 = 0; + $tib1_0_lcssa_i251 = $tib1_0_ph_i248; + label = 335; + break; + } else { + $dimension_tib1_029_i254 = 0; + $1428 = $1421; + label = 336; + break; + } + case 334: + $dimension_tib1_0_lcssa_i252 = $1432; + $tib1_0_lcssa_i251 = $1431; + label = 335; + break; + case 335: + $1426 = HEAP32[($1410 + 56 | 0) >> 2] | 0; + if (($1426 | 0) == 0) { + $dimension_tib2_0_lcssa_i259 = 0; + $tib2_0_lcssa_in_i258 = $1410; + label = 338; + break; + } else { + $dimension_tib2_024_i256 = 0; + $1437 = $1426; + label = 337; + break; + } + case 336: + $1431 = HEAP32[($1428 + 8 | 0) >> 2] | 0; + $1432 = $dimension_tib1_029_i254 + 1 | 0; + $1435 = HEAP32[($1431 + 56 | 0) >> 2] | 0; + if (($1435 | 0) == 0) { + label = 334; + break; + } else { + $dimension_tib1_029_i254 = $1432; + $1428 = $1435; + label = 336; + break; + } + case 337: + $1440 = HEAP32[($1437 + 8 | 0) >> 2] | 0; + $1441 = $dimension_tib2_024_i256 + 1 | 0; + $1444 = HEAP32[($1440 + 56 | 0) >> 2] | 0; + if (($1444 | 0) == 0) { + $dimension_tib2_0_lcssa_i259 = $1441; + $tib2_0_lcssa_in_i258 = $1440; + label = 338; + break; + } else { + $dimension_tib2_024_i256 = $1441; + $1437 = $1444; + label = 337; + break; + } + case 338: + $tib2_0_lcssa_i260 = $tib2_0_lcssa_in_i258; + if (($dimension_tib1_0_lcssa_i252 | 0) < ($dimension_tib2_0_lcssa_i259 | 0) | ($tib1_0_lcssa_i251 | 0) == 0) { + label = 344; + break; + } else { + $tib1_121_i263 = $tib1_0_lcssa_i251; + label = 339; + break; + } + case 339: + if (($tib1_121_i263 | 0) == ($tib2_0_lcssa_i260 | 0)) { + label = 361; + break; + } else { + label = 340; + break; + } + case 340: + $i_0_i266 = 0; + label = 341; + break; + case 341: + if (($i_0_i266 | 0) < (HEAP32[($tib1_121_i263 + 108 | 0) >> 2] | 0 | 0)) { + label = 342; + break; + } else { + label = 343; + break; + } + case 342: + if ((HEAP32[((HEAP32[($tib1_121_i263 + 112 | 0) >> 2] | 0) + ($i_0_i266 << 2) | 0) >> 2] | 0 | 0) == ($tib2_0_lcssa_i260 | 0)) { + label = 361; + break; + } else { + $i_0_i266 = $i_0_i266 + 1 | 0; + label = 341; + break; + } + case 343: + $1462 = HEAP32[($tib1_121_i263 + 40 | 0) >> 2] | 0; + if (($1462 | 0) == 0) { + label = 344; + break; + } else { + $tib1_121_i263 = $1462; + label = 339; + break; + } + case 344: + if ((HEAP32[(107740 | 0) >> 2] | 0 | 0) == 0) { + label = 345; + break; + } else { + label = 346; + break; + } + case 345: + invoke_v(374); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 346; + break; + case 346: + $1468 = HEAP32[$1400 >> 2] | 0; + if (($1468 | 0) == 0) { + label = 360; + break; + } else { + label = 347; + break; + } + case 347: + $1473 = HEAP32[$1468 >> 2] | 0; + $1477 = HEAP32[((HEAP32[137616 >> 2] | 0) + 8 | 0) >> 2] | 0; + if (($1473 | 0) == 82712) { + label = 348; + break; + } else { + $tib1_0_ph_i227 = $1473; + label = 349; + break; + } + case 348: + $tib1_0_ph_i227 = HEAP32[((HEAP32[($1468 + 8 | 0) >> 2] | 0) + 8 | 0) >> 2] | 0; + label = 349; + break; + case 349: + $1488 = HEAP32[($tib1_0_ph_i227 + 56 | 0) >> 2] | 0; + if (($1488 | 0) == 0) { + $dimension_tib1_0_lcssa_i231 = 0; + $tib1_0_lcssa_i230 = $tib1_0_ph_i227; + label = 351; + break; + } else { + $dimension_tib1_029_i233 = 0; + $1495 = $1488; + label = 352; + break; + } + case 350: + $dimension_tib1_0_lcssa_i231 = $1499; + $tib1_0_lcssa_i230 = $1498; + label = 351; + break; + case 351: + $1493 = HEAP32[($1477 + 56 | 0) >> 2] | 0; + if (($1493 | 0) == 0) { + $dimension_tib2_0_lcssa_i238 = 0; + $tib2_0_lcssa_in_i237 = $1477; + label = 354; + break; + } else { + $dimension_tib2_024_i235 = 0; + $1504 = $1493; + label = 353; + break; + } + case 352: + $1498 = HEAP32[($1495 + 8 | 0) >> 2] | 0; + $1499 = $dimension_tib1_029_i233 + 1 | 0; + $1502 = HEAP32[($1498 + 56 | 0) >> 2] | 0; + if (($1502 | 0) == 0) { + label = 350; + break; + } else { + $dimension_tib1_029_i233 = $1499; + $1495 = $1502; + label = 352; + break; + } + case 353: + $1507 = HEAP32[($1504 + 8 | 0) >> 2] | 0; + $1508 = $dimension_tib2_024_i235 + 1 | 0; + $1511 = HEAP32[($1507 + 56 | 0) >> 2] | 0; + if (($1511 | 0) == 0) { + $dimension_tib2_0_lcssa_i238 = $1508; + $tib2_0_lcssa_in_i237 = $1507; + label = 354; + break; + } else { + $dimension_tib2_024_i235 = $1508; + $1504 = $1511; + label = 353; + break; + } + case 354: + $tib2_0_lcssa_i239 = $tib2_0_lcssa_in_i237; + if (($dimension_tib1_0_lcssa_i231 | 0) < ($dimension_tib2_0_lcssa_i238 | 0) | ($tib1_0_lcssa_i230 | 0) == 0) { + label = 360; + break; + } else { + $tib1_121_i242 = $tib1_0_lcssa_i230; + label = 355; + break; + } + case 355: + if (($tib1_121_i242 | 0) == ($tib2_0_lcssa_i239 | 0)) { + label = 386; + break; + } else { + label = 356; + break; + } + case 356: + $i_0_i245 = 0; + label = 357; + break; + case 357: + if (($i_0_i245 | 0) < (HEAP32[($tib1_121_i242 + 108 | 0) >> 2] | 0 | 0)) { + label = 358; + break; + } else { + label = 359; + break; + } + case 358: + if ((HEAP32[((HEAP32[($tib1_121_i242 + 112 | 0) >> 2] | 0) + ($i_0_i245 << 2) | 0) >> 2] | 0 | 0) == ($tib2_0_lcssa_i239 | 0)) { + label = 386; + break; + } else { + $i_0_i245 = $i_0_i245 + 1 | 0; + label = 357; + break; + } + case 359: + $1529 = HEAP32[($tib1_121_i242 + 40 | 0) >> 2] | 0; + if (($1529 | 0) == 0) { + label = 360; + break; + } else { + $tib1_121_i242 = $1529; + label = 355; + break; + } + case 360: + invoke_vii(48, HEAP32[$1374 >> 2] | 0 | 0, 0 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case 361: + if ((HEAP32[(105500 | 0) >> 2] | 0 | 0) == 0) { + label = 362; + break; + } else { + label = 363; + break; + } + case 362: + invoke_v(30); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 363; + break; + case 363: + $1536 = invoke_i(70) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $1538 = invoke_iii(364, $1536 | 0, 0 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $1539 = $local_env_w4567aaac23b1c48; + $1541 = $1538 + 16 | 0; + _memcpy($1539 | 0, HEAP32[$1541 >> 2] | 0 | 0, 40); + $1545 = _saveSetjmp(HEAP32[$1541 >> 2] | 0 | 0, label, setjmpTable) | 0; + label = 424; + break; + case 424: + if (($1545 | 0) == 0) { + label = 364; + break; + } else { + label = 369; + break; + } + case 364: + if ((HEAP32[(105500 | 0) >> 2] | 0 | 0) == 0) { + label = 365; + break; + } else { + label = 366; + break; + } + case 365: + invoke_v(30); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 366; + break; + case 366: + $1551 = invoke_i(70) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $1553 = invoke_iii(364, $1551 | 0, 0 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $_r0_sroa_0 = HEAP32[($1553 + 20 | 0) >> 2] | 0; + $_r0_sroa_0 = 0; + $_r0_sroa_0_0_load602 = $_r0_sroa_0; + if ((HEAP32[(98772 | 0) >> 2] | 0 | 0) == 0) { + label = 367; + break; + } else { + label = 368; + break; + } + case 367: + invoke_v(702); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 368; + break; + case 368: + HEAP32[140048 >> 2] = $_r0_sroa_0_0_load602; + _memcpy(HEAP32[$1541 >> 2] | 0 | 0, $1539 | 0, 40); + label = 239; + break; + case 369: + _memcpy(HEAP32[$1541 >> 2] | 0 | 0, $1539 | 0, 40); + if ((HEAP32[(107740 | 0) >> 2] | 0 | 0) == 0) { + label = 370; + break; + } else { + label = 371; + break; + } + case 370: + invoke_v(374); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 371; + break; + case 371: + $1570 = HEAP32[($1538 + 20 | 0) >> 2] | 0; + if (($1570 | 0) == 0) { + label = 385; + break; + } else { + label = 372; + break; + } + case 372: + $1575 = HEAP32[$1570 >> 2] | 0; + $1579 = HEAP32[((HEAP32[137616 >> 2] | 0) + 8 | 0) >> 2] | 0; + if (($1575 | 0) == 82712) { + label = 373; + break; + } else { + $tib1_0_ph_i185 = $1575; + label = 374; + break; + } + case 373: + $tib1_0_ph_i185 = HEAP32[((HEAP32[($1570 + 8 | 0) >> 2] | 0) + 8 | 0) >> 2] | 0; + label = 374; + break; + case 374: + $1590 = HEAP32[($tib1_0_ph_i185 + 56 | 0) >> 2] | 0; + if (($1590 | 0) == 0) { + $dimension_tib1_0_lcssa_i189 = 0; + $tib1_0_lcssa_i188 = $tib1_0_ph_i185; + label = 376; + break; + } else { + $dimension_tib1_029_i191 = 0; + $1597 = $1590; + label = 377; + break; + } + case 375: + $dimension_tib1_0_lcssa_i189 = $1601; + $tib1_0_lcssa_i188 = $1600; + label = 376; + break; + case 376: + $1595 = HEAP32[($1579 + 56 | 0) >> 2] | 0; + if (($1595 | 0) == 0) { + $dimension_tib2_0_lcssa_i196 = 0; + $tib2_0_lcssa_in_i195 = $1579; + label = 379; + break; + } else { + $dimension_tib2_024_i193 = 0; + $1606 = $1595; + label = 378; + break; + } + case 377: + $1600 = HEAP32[($1597 + 8 | 0) >> 2] | 0; + $1601 = $dimension_tib1_029_i191 + 1 | 0; + $1604 = HEAP32[($1600 + 56 | 0) >> 2] | 0; + if (($1604 | 0) == 0) { + label = 375; + break; + } else { + $dimension_tib1_029_i191 = $1601; + $1597 = $1604; + label = 377; + break; + } + case 378: + $1609 = HEAP32[($1606 + 8 | 0) >> 2] | 0; + $1610 = $dimension_tib2_024_i193 + 1 | 0; + $1613 = HEAP32[($1609 + 56 | 0) >> 2] | 0; + if (($1613 | 0) == 0) { + $dimension_tib2_0_lcssa_i196 = $1610; + $tib2_0_lcssa_in_i195 = $1609; + label = 379; + break; + } else { + $dimension_tib2_024_i193 = $1610; + $1606 = $1613; + label = 378; + break; + } + case 379: + $tib2_0_lcssa_i197 = $tib2_0_lcssa_in_i195; + if (($dimension_tib1_0_lcssa_i189 | 0) < ($dimension_tib2_0_lcssa_i196 | 0) | ($tib1_0_lcssa_i188 | 0) == 0) { + label = 385; + break; + } else { + $tib1_121_i200 = $tib1_0_lcssa_i188; + label = 380; + break; + } + case 380: + if (($tib1_121_i200 | 0) == ($tib2_0_lcssa_i197 | 0)) { + label = 54; + break; + } else { + label = 381; + break; + } + case 381: + $i_0_i203 = 0; + label = 382; + break; + case 382: + if (($i_0_i203 | 0) < (HEAP32[($tib1_121_i200 + 108 | 0) >> 2] | 0 | 0)) { + label = 383; + break; + } else { + label = 384; + break; + } + case 383: + if ((HEAP32[((HEAP32[($tib1_121_i200 + 112 | 0) >> 2] | 0) + ($i_0_i203 << 2) | 0) >> 2] | 0 | 0) == ($tib2_0_lcssa_i197 | 0)) { + label = 54; + break; + } else { + $i_0_i203 = $i_0_i203 + 1 | 0; + label = 382; + break; + } + case 384: + $1631 = HEAP32[($tib1_121_i200 + 40 | 0) >> 2] | 0; + if (($1631 | 0) == 0) { + label = 385; + break; + } else { + $tib1_121_i200 = $1631; + label = 380; + break; + } + case 385: + invoke_vii(48, HEAP32[$1541 >> 2] | 0 | 0, 0 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case 386: + if ((HEAP32[(105500 | 0) >> 2] | 0 | 0) == 0) { + label = 387; + break; + } else { + label = 388; + break; + } + case 387: + invoke_v(30); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 388; + break; + case 388: + $1638 = invoke_i(70) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $1640 = invoke_iii(364, $1638 | 0, 0 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $1641 = $local_env_w4567aaac23b1c50; + $1643 = $1640 + 16 | 0; + _memcpy($1641 | 0, HEAP32[$1643 >> 2] | 0 | 0, 40); + $1647 = _saveSetjmp(HEAP32[$1643 >> 2] | 0 | 0, label, setjmpTable) | 0; + label = 425; + break; + case 425: + if (($1647 | 0) == 0) { + label = 389; + break; + } else { + label = 396; + break; + } + case 389: + if ((HEAP32[(105500 | 0) >> 2] | 0 | 0) == 0) { + label = 390; + break; + } else { + label = 391; + break; + } + case 390: + invoke_v(30); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 391; + break; + case 391: + $1653 = invoke_i(70) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $1655 = invoke_iii(364, $1653 | 0, 0 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $_r0_sroa_0 = HEAP32[($1655 + 20 | 0) >> 2] | 0; + $_r2_sroa_0 = 0; + $_r2_sroa_0_0_load = $_r2_sroa_0; + if ((HEAP32[(98772 | 0) >> 2] | 0 | 0) == 0) { + label = 392; + break; + } else { + label = 393; + break; + } + case 392: + invoke_v(702); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 393; + break; + case 393: + HEAP32[140048 >> 2] = $_r2_sroa_0_0_load; + if ((HEAP32[(105500 | 0) >> 2] | 0 | 0) == 0) { + label = 394; + break; + } else { + label = 395; + break; + } + case 394: + invoke_v(30); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 395; + break; + case 395: + $1666 = invoke_i(70) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $1668 = invoke_iii(364, $1666 | 0, 0 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + HEAP32[($1668 + 20 | 0) >> 2] = $_r0_sroa_0; + invoke_vii(48, HEAP32[($1668 + 16 | 0) >> 2] | 0 | 0, 0 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case 396: + _memcpy(HEAP32[$1643 >> 2] | 0 | 0, $1641 | 0, 40); + if ((HEAP32[(107740 | 0) >> 2] | 0 | 0) == 0) { + label = 397; + break; + } else { + label = 398; + break; + } + case 397: + invoke_v(374); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 398; + break; + case 398: + $1684 = HEAP32[($1640 + 20 | 0) >> 2] | 0; + if (($1684 | 0) == 0) { + label = 412; + break; + } else { + label = 399; + break; + } + case 399: + $1689 = HEAP32[$1684 >> 2] | 0; + $1693 = HEAP32[((HEAP32[137616 >> 2] | 0) + 8 | 0) >> 2] | 0; + if (($1689 | 0) == 82712) { + label = 400; + break; + } else { + $tib1_0_ph_i = $1689; + label = 401; + break; + } + case 400: + $tib1_0_ph_i = HEAP32[((HEAP32[($1684 + 8 | 0) >> 2] | 0) + 8 | 0) >> 2] | 0; + label = 401; + break; + case 401: + $1704 = HEAP32[($tib1_0_ph_i + 56 | 0) >> 2] | 0; + if (($1704 | 0) == 0) { + $dimension_tib1_0_lcssa_i = 0; + $tib1_0_lcssa_i = $tib1_0_ph_i; + label = 403; + break; + } else { + $dimension_tib1_029_i = 0; + $1711 = $1704; + label = 404; + break; + } + case 402: + $dimension_tib1_0_lcssa_i = $1715; + $tib1_0_lcssa_i = $1714; + label = 403; + break; + case 403: + $1709 = HEAP32[($1693 + 56 | 0) >> 2] | 0; + if (($1709 | 0) == 0) { + $dimension_tib2_0_lcssa_i = 0; + $tib2_0_lcssa_in_i = $1693; + label = 406; + break; + } else { + $dimension_tib2_024_i = 0; + $1720 = $1709; + label = 405; + break; + } + case 404: + $1714 = HEAP32[($1711 + 8 | 0) >> 2] | 0; + $1715 = $dimension_tib1_029_i + 1 | 0; + $1718 = HEAP32[($1714 + 56 | 0) >> 2] | 0; + if (($1718 | 0) == 0) { + label = 402; + break; + } else { + $dimension_tib1_029_i = $1715; + $1711 = $1718; + label = 404; + break; + } + case 405: + $1723 = HEAP32[($1720 + 8 | 0) >> 2] | 0; + $1724 = $dimension_tib2_024_i + 1 | 0; + $1727 = HEAP32[($1723 + 56 | 0) >> 2] | 0; + if (($1727 | 0) == 0) { + $dimension_tib2_0_lcssa_i = $1724; + $tib2_0_lcssa_in_i = $1723; + label = 406; + break; + } else { + $dimension_tib2_024_i = $1724; + $1720 = $1727; + label = 405; + break; + } + case 406: + $tib2_0_lcssa_i = $tib2_0_lcssa_in_i; + if (($dimension_tib1_0_lcssa_i | 0) < ($dimension_tib2_0_lcssa_i | 0) | ($tib1_0_lcssa_i | 0) == 0) { + label = 412; + break; + } else { + $tib1_121_i = $tib1_0_lcssa_i; + label = 407; + break; + } + case 407: + if (($tib1_121_i | 0) == ($tib2_0_lcssa_i | 0)) { + label = 54; + break; + } else { + label = 408; + break; + } + case 408: + $i_0_i = 0; + label = 409; + break; + case 409: + if (($i_0_i | 0) < (HEAP32[($tib1_121_i + 108 | 0) >> 2] | 0 | 0)) { + label = 410; + break; + } else { + label = 411; + break; + } + case 410: + if ((HEAP32[((HEAP32[($tib1_121_i + 112 | 0) >> 2] | 0) + ($i_0_i << 2) | 0) >> 2] | 0 | 0) == ($tib2_0_lcssa_i | 0)) { + label = 54; + break; + } else { + $i_0_i = $i_0_i + 1 | 0; + label = 409; + break; + } + case 411: + $1745 = HEAP32[($tib1_121_i + 40 | 0) >> 2] | 0; + if (($1745 | 0) == 0) { + label = 412; + break; + } else { + $tib1_121_i = $1745; + label = 407; + break; + } + case 412: + invoke_vii(48, HEAP32[$1643 >> 2] | 0 | 0, 0 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case -1111: + if ((setjmpLabel | 0) == 7) { + $25 = threwValue; + label = 413; + } else if ((setjmpLabel | 0) == 35) { + $159 = threwValue; + label = 414; + } else if ((setjmpLabel | 0) == 62) { + $290 = threwValue; + label = 415; + } else if ((setjmpLabel | 0) == 91) { + $401 = threwValue; + label = 416; + } else if ((setjmpLabel | 0) == 97) { + $433 = threwValue; + label = 417; + } else if ((setjmpLabel | 0) == 144) { + $629 = threwValue; + label = 418; + } else if ((setjmpLabel | 0) == 181) { + $789 = threwValue; + label = 419; + } else if ((setjmpLabel | 0) == 218) { + $954 = threwValue; + label = 420; + } else if ((setjmpLabel | 0) == 240) { + $1042 = threwValue; + label = 421; + } else if ((setjmpLabel | 0) == 251) { + $1073 = threwValue; + label = 422; + } else if ((setjmpLabel | 0) == 324) { + $1378 = threwValue; + label = 423; + } else if ((setjmpLabel | 0) == 363) { + $1545 = threwValue; + label = 424; + } else if ((setjmpLabel | 0) == 388) { + $1647 = threwValue; + label = 425; + } + __THREW__ = threwValue = 0; + break; + } } function looop2() { - var i = 0; - while (1) { - do_it(); - i = i + 1 | 0; - if (condition(i)) { - break; - } + var i = 0; + while (1) { + do_it(); + i = i + 1 | 0; + if (condition(i)) { + break; } + } } function looop3() { - var i = 0; - while (1) { - do_it(); - i = i + 1 | 0; - if (!condition(i)) { - break; - } + var i = 0; + while (1) { + do_it(); + i = i + 1 | 0; + if (!condition(i)) { + break; } + } } function looop4() { - var i = 0, helper = 0; - while (1) { - do_it(); - helper = i + 1 | 0; - f(i, helper); - if (condition()) { - i = helper; - } else { - break; - } + var i = 0, helper = 0; + while (1) { + do_it(); + helper = i + 1 | 0; + f(i, helper); + if (condition()) { + i = helper; + } else { + break; } + } } function looop4b() { - var i = 0, helper = 0; - while (1) { - do_it(); - helper = i + 1 | 0; - g(helper); - if (condition(i)) { - i = helper; - } else { - break; - } + var i = 0, helper = 0; + while (1) { + do_it(); + helper = i + 1 | 0; + g(helper); + if (condition(i)) { + i = helper; + } else { + break; } + } } function looop5() { - var i = 0, helper = 0; - while (1) { - do_it(); - helper = i + 1 | 0; - if (condition(helper)) { - i = helper; - } else { - break; - } + var i = 0, helper = 0; + while (1) { + do_it(); + helper = i + 1 | 0; + if (condition(helper)) { + i = helper; + } else { + break; } - moar(i); + } + moar(i); } function looop6() { - var i = 0; - while (1) { - do_it(); - i = i + 1 | 0; - if (!condition(i)) { - break; - } + var i = 0; + while (1) { + do_it(); + i = i + 1 | 0; + if (!condition(i)) { + break; } - moar(i); + } + moar(i); } function looop7() { - var $old_0_i107_i = 0, $current_0_i108_i = 0, $696 = 0; - $old_0_i107_i = $draw_left_i; - while (1) { - $current_0_i108_i = HEAP32[$old_0_i107_i >> 2] | 0; - if (($current_0_i108_i | 0) == 0) { - break; - } - $696 = $current_0_i108_i + 4 | 0; - if (($current_0_i108_i | 0) == ($P_3207_i | 0)) { - break; - } else { - $old_0_i107_i = $696; - } + var $old_0_i107_i = 0, $current_0_i108_i = 0, $696 = 0; + $old_0_i107_i = $draw_left_i; + while (1) { + $current_0_i108_i = HEAP32[$old_0_i107_i >> 2] | 0; + if (($current_0_i108_i | 0) == 0) { + break; + } + $696 = $current_0_i108_i + 4 | 0; + if (($current_0_i108_i | 0) == ($P_3207_i | 0)) { + break; + } else { + $old_0_i107_i = $696; } - HEAP32[$old_0_i107_i >> 2] = HEAP32[$696 >> 2] | 0; - while (1) {} + } + HEAP32[$old_0_i107_i >> 2] = HEAP32[$696 >> 2] | 0; + while (1) {} } function looop8() { - var i = 0, j = 0, a = 0; - while (1) { - do_it(i, j); - a = i + j | 0; - if (condition(helper)) { - break; - } else { - i = a; - j = a; - } + var i = 0, j = 0, a = 0; + while (1) { + do_it(i, j); + a = i + j | 0; + if (condition(helper)) { + break; + } else { + i = a; + j = a; } + } } function multiloop($n_0, $35) { - $n_0 = $n_0 | 0; - $35 = $35 | 0; - var $p_0 = 0, $41 = 0; - $n_0 = $35; - $p_0 = (HEAP32[$15 >> 2] | 0) + ($35 << 1) | 0; - while (1) { - $p_0 = $p_0 - 2 | 0; - $41 = HEAPU16[$p_0 >> 1] | 0; - if ($41 >>> 0 < $2 >>> 0) { - $_off0 = 0; - } else { - $_off0 = $41 - $2 & 65535; - } - HEAP16[$p_0 >> 1] = $_off0; - $n_0 = $n_0 - 1 | 0; - if (($n_0 | 0) == 0) { - break; - } + $n_0 = $n_0 | 0; + $35 = $35 | 0; + var $p_0 = 0, $41 = 0; + $n_0 = $35; + $p_0 = (HEAP32[$15 >> 2] | 0) + ($35 << 1) | 0; + while (1) { + $p_0 = $p_0 - 2 | 0; + $41 = HEAPU16[$p_0 >> 1] | 0; + if ($41 >>> 0 < $2 >>> 0) { + $_off0 = 0; + } else { + $_off0 = $41 - $2 & 65535; } + HEAP16[$p_0 >> 1] = $_off0; + $n_0 = $n_0 - 1 | 0; + if (($n_0 | 0) == 0) { + break; + } + } } function multiloop2($n_0, $35) { - $n_0 = $n_0 | 0; - $35 = $35 | 0; - var $p_0 = 0, $39 = 0, $41 = 0, $46 = 0; - $n_0 = $35; - $p_0 = (HEAP32[$15 >> 2] | 0) + ($35 << 1) | 0; - while (1) { - $39 = $p_0 - 2 | 0; - $41 = HEAPU16[$39 >> 1] | 0; - if ($41 >>> 0 < $2 >>> 0) { - $_off0 = 0; - } else { - $_off0 = $41 - $2 & 65535; - } - HEAP16[$39 >> 1] = $p_0; - $46 = $n_0 - 1 | 0; - if (($46 | 0) == 0) { - break; - } else { - $n_0 = $46; - $p_0 = $39; - } + $n_0 = $n_0 | 0; + $35 = $35 | 0; + var $p_0 = 0, $39 = 0, $41 = 0, $46 = 0; + $n_0 = $35; + $p_0 = (HEAP32[$15 >> 2] | 0) + ($35 << 1) | 0; + while (1) { + $39 = $p_0 - 2 | 0; + $41 = HEAPU16[$39 >> 1] | 0; + if ($41 >>> 0 < $2 >>> 0) { + $_off0 = 0; + } else { + $_off0 = $41 - $2 & 65535; + } + HEAP16[$39 >> 1] = $p_0; + $46 = $n_0 - 1 | 0; + if (($46 | 0) == 0) { + break; + } else { + $n_0 = $46; + $p_0 = $39; } + } } function tempDouble2($46, $14, $28, $42, $20, $32, $45) { - $46 = $46 | 0; - $14 = $14 | 0; - $28 = $28 | 0; - $42 = $42 | 0; - $20 = $20 | 0; - $32 = $32 | 0; - $45 = $45 | 0; - var $_sroa_06_0_insert_insert$1 = 0; - $_sroa_06_0_insert_insert$1 = (HEAPF32[tempDoublePtr >> 2] = ($20 < $32 ? $20 : $32) - $42, HEAP32[tempDoublePtr >> 2] | 0) | 0; - HEAP32[$45 >> 2] = 0 | (HEAPF32[tempDoublePtr >> 2] = ($14 < $28 ? $14 : $28) - $42, HEAP32[tempDoublePtr >> 2] | 0); - HEAP32[$45 + 4 >> 2] = $_sroa_06_0_insert_insert$1; - HEAP32[$45 + 8 >> 2] = $_sroa_06_0_insert_insert$1; + $46 = $46 | 0; + $14 = $14 | 0; + $28 = $28 | 0; + $42 = $42 | 0; + $20 = $20 | 0; + $32 = $32 | 0; + $45 = $45 | 0; + var $_sroa_06_0_insert_insert$1 = 0; + $_sroa_06_0_insert_insert$1 = (HEAPF32[tempDoublePtr >> 2] = ($20 < $32 ? $20 : $32) - $42, HEAP32[tempDoublePtr >> 2] | 0) | 0; + HEAP32[$45 >> 2] = 0 | (HEAPF32[tempDoublePtr >> 2] = ($14 < $28 ? $14 : $28) - $42, HEAP32[tempDoublePtr >> 2] | 0); + HEAP32[$45 + 4 >> 2] = $_sroa_06_0_insert_insert$1; + HEAP32[$45 + 8 >> 2] = $_sroa_06_0_insert_insert$1; } diff --git a/tools/eliminator/asm-eliminator-test.js b/tools/eliminator/asm-eliminator-test.js index d082f70a56817..f90c355773779 100644 --- a/tools/eliminator/asm-eliminator-test.js +++ b/tools/eliminator/asm-eliminator-test.js @@ -1,550 +1,226 @@ function asm(x, y) { - x = +x; - y = y|0; - var a = 0, b = +0, c = 0; - var label = 0; - a = cheez((y+~~x)|0)|0; - b = a*a; - fleefl(b|0, a|0); + x = +x; + y = y|0; + var a = 0, b = +0, c = 0; + var label = 0; + a = cheez((y+~~x)|0)|0; + b = a*a; + fleefl(b|0, a|0); } function __Z11printResultPiS_j($needle, $haystack, $len) { - $needle = $needle | 0; - $haystack = $haystack | 0; - $len = $len | 0; - var $1 = 0, $2 = 0, $3 = 0, $4 = 0, $puts = 0, $7 = 0, $8 = 0, $9 = 0; - var label = 0; - var __stackBase__ = 0; - __stackBase__ = STACKTOP; - $1 = $needle; - $2 = $haystack; - $3 = _bsearch($1, $2, $len, 4, 2); - $4 = ($3 | 0) == 0; - if ($4) { - $puts = _puts(_str | 0); - STACKTOP = __stackBase__; - return; - } else { - $7 = $3; - $8 = HEAP32[($7 & 16777215) >> 2] | 0; - $9 = _printf(__str1 | 0, (tempInt = STACKTOP, STACKTOP = STACKTOP + 4 | 0, HEAP32[(tempInt & 16777215) >> 2] = $8, tempInt)); - STACKTOP = __stackBase__; - return; - } + $needle = $needle | 0; + $haystack = $haystack | 0; + $len = $len | 0; + var $1 = 0, $2 = 0, $3 = 0, $4 = 0, $puts = 0, $7 = 0, $8 = 0, $9 = 0; + var label = 0; + var __stackBase__ = 0; + __stackBase__ = STACKTOP; + $1 = $needle; + $2 = $haystack; + $3 = _bsearch($1, $2, $len, 4, 2); + $4 = ($3 | 0) == 0; + if ($4) { + $puts = _puts(_str | 0); + STACKTOP = __stackBase__; + return; + } else { + $7 = $3; + $8 = HEAP32[($7 & 16777215) >> 2] | 0; + $9 = _printf(__str1 | 0, (tempInt = STACKTOP, STACKTOP = STACKTOP + 4 | 0, HEAP32[(tempInt & 16777215) >> 2] = $8, tempInt)); + STACKTOP = __stackBase__; + return; + } } function _segment_holding($addr) { - $addr = $addr | 0; - var $sp_0 = 0, $2 = 0, $3 = 0, $4 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0; - var $11 = 0, $12 = 0, $13 = 0, $_0 = 0; - var label = 0; - $sp_0 = __gm_ + 444 | 0; - while (1) { - $2 = $sp_0 | 0; - $3 = HEAP32[($2 & 16777215) >> 2] | 0; - $4 = $3 >>> 0 > $addr >>> 0; - if (!$4) { - $6 = $sp_0 + 4 | 0; - $7 = HEAP32[($6 & 16777215) >> 2] | 0; - $8 = $3 + $7 | 0; - $9 = $8 >>> 0 > $addr >>> 0; - if ($9) { - $_0 = $sp_0; - label = 1658; - break; - } - } - $11 = $sp_0 + 8 | 0; - $12 = HEAP32[($11 & 16777215) >> 2] | 0; - $13 = ($12 | 0) == 0; - if ($13) { - $_0 = 0; - label = 1659; - break; - } else { - $sp_0 = $12; - } + $addr = $addr | 0; + var $sp_0 = 0, $2 = 0, $3 = 0, $4 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0; + var $11 = 0, $12 = 0, $13 = 0, $_0 = 0; + var label = 0; + $sp_0 = __gm_ + 444 | 0; + while (1) { + $2 = $sp_0 | 0; + $3 = HEAP32[($2 & 16777215) >> 2] | 0; + $4 = $3 >>> 0 > $addr >>> 0; + if (!$4) { + $6 = $sp_0 + 4 | 0; + $7 = HEAP32[($6 & 16777215) >> 2] | 0; + $8 = $3 + $7 | 0; + $9 = $8 >>> 0 > $addr >>> 0; + if ($9) { + $_0 = $sp_0; + label = 1658; + break; + } } - if (label == 1659) { - return $_0; - } else if (label == 1658) { - return $_0; + $11 = $sp_0 + 8 | 0; + $12 = HEAP32[($11 & 16777215) >> 2] | 0; + $13 = ($12 | 0) == 0; + if ($13) { + $_0 = 0; + label = 1659; + break; + } else { + $sp_0 = $12; } + } + if (label == 1659) { + return $_0; + } else if (label == 1658) { + return $_0; + } } function __ZN5identC2EiPKcPci($this, $n, $a) { - $this = $this | 0; - $n = $n | 0; - $a = $a | 0; - HEAP32[($this & 16777215) >> 2] = __ZTV5ident + 8 | 0; - HEAP32[($this + 4 & 16777215) >> 2] = 5; - HEAP32[($this + 8 & 16777215) >> 2] = $n; - HEAP32[($this + 20 & 16777215) >> 2] = 2147483647; - HEAP32[($this + 24 & 16777215) >> 2] = 0; - HEAP32[($this + 28 & 16777215) >> 2] = $a; - HEAP32[($this + 32 & 16777215) >> 2] = 0; - HEAP32[($this + 40 & 16777215) >> 2] = 1; - return; + $this = $this | 0; + $n = $n | 0; + $a = $a | 0; + HEAP32[($this & 16777215) >> 2] = __ZTV5ident + 8 | 0; + HEAP32[($this + 4 & 16777215) >> 2] = 5; + HEAP32[($this + 8 & 16777215) >> 2] = $n; + HEAP32[($this + 20 & 16777215) >> 2] = 2147483647; + HEAP32[($this + 24 & 16777215) >> 2] = 0; + HEAP32[($this + 28 & 16777215) >> 2] = $a; + HEAP32[($this + 32 & 16777215) >> 2] = 0; + HEAP32[($this + 40 & 16777215) >> 2] = 1; + return; } function _vec2Length($this) { - $this = $this | 0; - var $__first_addr_i = 0, $__last_addr_i = 0, $__comp_addr_i = 0, $a13 = 0, $a14 = 0, $a18 = 0, $a19 = 0; - var label = 0; - var __stackBase__ = 0; - __stackBase__ = STACKTOP; - STACKTOP = STACKTOP + 8 | 0; - $__first_addr_i = __stackBase__; - $__last_addr_i = __stackBase__ + 4; - $a13 = $__first_addr_i; - $a14 = $__last_addr_i; - $a18 = $__first_addr_i; - $a19 = $__last_addr_i; - STACKTOP = __stackBase__; - return 0; + $this = $this | 0; + var $__first_addr_i = 0, $__last_addr_i = 0, $__comp_addr_i = 0, $a13 = 0, $a14 = 0, $a18 = 0, $a19 = 0; + var label = 0; + var __stackBase__ = 0; + __stackBase__ = STACKTOP; + STACKTOP = STACKTOP + 8 | 0; + $__first_addr_i = __stackBase__; + $__last_addr_i = __stackBase__ + 4; + $a13 = $__first_addr_i; + $a14 = $__last_addr_i; + $a18 = $__first_addr_i; + $a19 = $__last_addr_i; + STACKTOP = __stackBase__; + return 0; } function exc($this) { - $this = $this | 0; - var $1 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $8 = +0, $9 = 0; - var label = 0; - var $1 = (function() { - try { - __THREW__ = false; - return __ZNSt3__16locale8__globalEv(); - } catch (e) { - if (typeof e != "number") throw e; - if (ABORT) throw e; - __THREW__ = true; - Module.print("Exception: " + e + ", currently at: " + (new Error).stack); - return null; - } - })(); - if (!__THREW__) { - $3 = $this | 0; - $4 = $1 | 0; - $5 = HEAP32[($4 & 16777215) >> 2] | 0; - HEAP32[($3 & 16777215) >> 2] = $5; - $6 = $5 | 0; - __ZNSt3__114__shared_count12__add_sharedEv($6); - return; - } else { - $8$0 = ___cxa_find_matching_catch(HEAP32[(_llvm_eh_exception.buf & 16777215) >> 2] | 0, HEAP32[(_llvm_eh_exception.buf + 4 & 16777215) >> 2] | 0, []); - $8$1 = tempRet0; - $9 = $8$0; - ___cxa_call_unexpected($9); + $this = $this | 0; + var $1 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $8 = +0, $9 = 0; + var label = 0; + var $1 = (function() { + try { + __THREW__ = false; + return __ZNSt3__16locale8__globalEv(); + } catch (e) { + if (typeof e != "number") throw e; + if (ABORT) throw e; + __THREW__ = true; + Module.print("Exception: " + e + ", currently at: " + (new Error).stack); + return null; } + })(); + if (!__THREW__) { + $3 = $this | 0; + $4 = $1 | 0; + $5 = HEAP32[($4 & 16777215) >> 2] | 0; + HEAP32[($3 & 16777215) >> 2] = $5; + $6 = $5 | 0; + __ZNSt3__114__shared_count12__add_sharedEv($6); + return; + } else { + $8$0 = ___cxa_find_matching_catch(HEAP32[(_llvm_eh_exception.buf & 16777215) >> 2] | 0, HEAP32[(_llvm_eh_exception.buf + 4 & 16777215) >> 2] | 0, []); + $8$1 = tempRet0; + $9 = $8$0; + ___cxa_call_unexpected($9); + } } function label() { - var $1 = 0, $2 = 0; - $1 = f(); - if ($1) { - g(); - } - $2 = h(); - L100: if ($2) { - i(); - } + var $1 = 0, $2 = 0; + $1 = f(); + if ($1) { + g(); + } + $2 = h(); + L100: if ($2) { + i(); + } } function switchy() { - var no = 0, yes = 0; - var a = 0, b = 0; - while (1) switch (label | 0) { - case 1: - no = 100; // eliminatable in theory, but eliminator does not look into switch. must leave def above as well. - break; - case 2: - yes = 111; - yes = yes*2; - print(yes); - yes--; - print(yes/2); - continue; - case 3: - a = 5; - b = a; - break; - } + var no = 0, yes = 0; + var a = 0, b = 0; + while (1) switch (label | 0) { + case 1: + no = 100; // eliminatable in theory, but eliminator does not look into switch. must leave def above as well. + break; + case 2: + yes = 111; + yes = yes*2; + print(yes); + yes--; + print(yes/2); + continue; + case 3: + a = 5; + b = a; + break; + } } function confuusion() { - var i = +0; - func1(+i); - var j = i; // add this var in the middle. should show up with right type later, auto-inferred from i's type - func2(+j); + var i = +0; + func1(+i); + var j = i; // add this var in the middle. should show up with right type later, auto-inferred from i's type + func2(+j); } function tempDouble(a) { - a = +a; - var x = +0, y = +0; - // CastAway can leave things like this as variables no longer needed. We need to identify that x's value has no side effects so it can be completely cleaned up - x = (HEAP32[((tempDoublePtr)>>2)]=((HEAP32[(($_sroa_0_0__idx1)>>2)])|0),HEAP32[(((tempDoublePtr)+(4))>>2)]=((HEAP32[((($_sroa_0_0__idx1)+(4))>>2)])|0),(+(HEAPF64[(tempDoublePtr)>>3]))); - y = a*a; - f(y); + a = +a; + var x = +0, y = +0; + // CastAway can leave things like this as variables no longer needed. We need to identify that x's value has no side effects so it can be completely cleaned up + x = (HEAP32[((tempDoublePtr)>>2)]=((HEAP32[(($_sroa_0_0__idx1)>>2)])|0),HEAP32[(((tempDoublePtr)+(4))>>2)]=((HEAP32[((($_sroa_0_0__idx1)+(4))>>2)])|0),(+(HEAPF64[(tempDoublePtr)>>3]))); + y = a*a; + f(y); } function _org_apache_harmony_luni_util_NumberConverter_freeFormat__($me) { - $me = $me | 0; - var $_r2_sroa_0 = 0, $_r3_sroa_0 = 0, $1 = 0, $2 = 0, $$etemp$1 = 0, $$etemp$0$0 = 0, $$etemp$0$1 = 0, $st$2$0 = 0; - var $st$3$1 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $_r1_sroa_0_0_insert_ext191$0 = 0; - var $_r1_sroa_0_0_insert_ext191$1 = 0, $11 = +0, $12 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $_r2_sroa_0_0_cast283 = 0; - var $18 = 0, $19 = 0, $20 = 0, $21 = 0, $_r3_sroa_0_0_cast247 = 0, $_r3_sroa_0_0_load244 = +0, $ld$4$0 = 0, $_r3_sroa_0_0_load244$$SHADOW$0 = 0; - var $ld$5$1 = 0, $_r3_sroa_0_0_load244$$SHADOW$1 = 0, $_r2_sroa_0_0_load = +0, $ld$6$0 = 0, $_r2_sroa_0_0_load$$SHADOW$0 = 0, $ld$7$1 = 0, $_r2_sroa_0_0_load$$SHADOW$1 = 0, $22$0 = 0; - var $22$1 = 0, $trunc297$0 = 0, $trunc297 = 0, $23 = 0, $24$0 = 0, $24$1 = 0, $25$0 = 0, $25 = 0; - var $26 = 0, $27 = 0, $smax = 0, $28 = 0, $29 = 0, $_r3_sroa_0_0_load239_pre = +0, $ld$8$0 = 0, $_r3_sroa_0_0_load239_pre$$SHADOW$0 = 0; - var $ld$9$1 = 0, $_r3_sroa_0_0_load239_pre$$SHADOW$1 = 0, $_r3_sroa_0_0_load239 = +0, $_pre_phi301 = 0, $_r3_sroa_0_0_cast264_pre_phi = 0, $_r2_sroa_0_0_load265 = +0, $32 = 0, $33 = 0; - var $34 = 0, $_r3_sroa_0_0_cast253 = 0, $35 = 0, $36 = 0, $37 = 0, $38 = 0, $39 = 0, $40 = 0; - var $41 = 0, $42 = 0, $43 = 0, $44 = 0, $_r3_sroa_0_0_load243 = +0, $ld$10$0 = 0, $_r3_sroa_0_0_load243$$SHADOW$0 = 0, $ld$11$1 = 0; - var $_r3_sroa_0_0_load243$$SHADOW$1 = 0, $_r2_sroa_0_0_cast = 0, $45 = 0, $_sink_in = +0, $_r3_sroa_0_0_load241 = +0, $_r2_sroa_0_0_load266287 = 0, $_r1_sroa_0_0 = +0, $_sink$0 = 0, $_sink$1 = 0; - var $47$0 = 0, $47 = 0, $48$0 = 0, $48$1 = 0, $_r1_sroa_0_0_extract_trunc185$0 = 0, $_r1_sroa_0_0_extract_trunc185 = 0, $49 = 0, $51 = 0, $52 = 0; - var $53 = 0, $54 = 0, $55 = 0, $56 = 0, $_r1_sroa_0_0_insert_ext195$0 = 0, $_r1_sroa_0_0_insert_ext195$1 = 0, $_r1_sroa_0_1_in$0 = 0, $_r1_sroa_0_1_in$1 = 0; - var $_r1_sroa_0_1 = +0, $58 = 0, $_r1_sroa_0_0_extract_trunc169$0 = 0, $_r1_sroa_0_0_extract_trunc169 = 0, $60 = 0, $61 = 0, $62 = 0, $63 = 0; - var $_r3_sroa_0_0_load240 = +0, $ld$12$0 = 0, $_r3_sroa_0_0_load240$$SHADOW$0 = 0, $ld$13$1 = 0, $_r3_sroa_0_0_load240$$SHADOW$1 = 0, $_r1_sroa_0_2 = +0, $64 = 0, $65 = 0; - var $66 = 0, $67 = 0, $69 = 0, $70 = 0, $71 = 0, $72 = 0, $73 = 0, $74 = 0; - var $75 = 0, $76 = 0, $phitmp = 0, $77 = 0, $or_cond = 0, $79 = 0, $80 = 0, $82 = 0; - var $83 = 0, $84 = 0, $_r2_sroa_0_0_cast269 = 0, $85$0 = 0, $85$1 = 0, $_r1_sroa_0_0_extract_trunc$0 = 0, $_r1_sroa_0_0_extract_trunc = 0, $86 = 0, $87 = 0; - var $88 = 0, $89 = 0, $90 = 0, $91 = 0, $92 = 0, $94 = 0, $95 = 0, $96 = 0; - var $97 = 0, $99 = 0, $100 = 0, $101 = 0, $102 = 0, $$etemp$15 = 0, $$etemp$14$0 = 0, $$etemp$14$1 = 0; - var $st$16$0 = 0, $st$17$1 = 0, $105 = 0, $106 = 0, $107 = 0, $108 = 0, $109 = 0, $110 = 0; - var $112 = 0, $113 = 0, $114 = 0, $115 = 0, $116 = 0, $117 = 0, $118 = 0, $119 = 0; - var $121 = 0, $123 = 0, $_r1_sroa_0_0_insert_ext$0 = 0, $_r1_sroa_0_0_insert_ext$1 = 0, $$etemp$18$0 = 0, $$etemp$18$1 = 0, $_r1_sroa_0_0_insert_mask$0 = 0, $_r1_sroa_0_0_insert_mask$1 = 0; - var $_r1_sroa_0_0_insert_insert$0 = 0, $_r1_sroa_0_0_insert_insert$1 = 0, $124 = 0, $125 = 0, $126 = 0, $_old = 0, $_r3_sroa_0_0_load242 = +0, $ld$19$0 = 0; - var $_r3_sroa_0_0_load242$$SHADOW$0 = 0, $ld$20$1 = 0, $_r3_sroa_0_0_load242$$SHADOW$1 = 0, $_r2_sroa_0_0_cast284 = 0, $_r2_sroa_0_0_load265_pre = +0, $ld$21$0 = 0, $_r2_sroa_0_0_load265_pre$$SHADOW$0 = 0, $ld$22$1 = 0; - var $_r2_sroa_0_0_load265_pre$$SHADOW$1 = 0, $_r3_sroa_0_0_cast264_pre = 0, $_pre = 0, $_pre300 = 0; - var label = 0; - var __stackBase__ = 0; - __stackBase__ = STACKTOP; - STACKTOP = STACKTOP + 16 | 0; - $_r2_sroa_0 = __stackBase__ | 0; - $_r3_sroa_0 = __stackBase__ + 8 | 0; - $1 = HEAP32[(114668 | 0) >> 2] | 0; - $2 = ($1 | 0) == 0; - if ($2) { - HEAP32[(114664 | 0) >> 2] = 1; - HEAP32[(114668 | 0) >> 2] = 1; - $$etemp$1 = 114672 | 0; - $$etemp$0$0 = -1; - $$etemp$0$1 = -1; - $st$2$0 = $$etemp$1 | 0; - HEAP32[$st$2$0 >> 2] = $$etemp$0$0; - $st$3$1 = $$etemp$1 + 4 | 0; - HEAP32[$st$3$1 >> 2] = $$etemp$0$1; - HEAP32[(114684 | 0) >> 2] = 25296 | 0; - HEAP32[(114704 | 0) >> 2] = 110728; - HEAP32[(114712 | 0) >> 2] = 8; - HEAP32[(114784 | 0 | 0) >> 2] = HEAP32[(107856 | 0 | 0) >> 2] | 0; - HEAP32[(114784 | 0 | 0) + 4 >> 2] = HEAP32[(107856 | 0 | 0) + 4 >> 2] | 0; - HEAP32[(114784 | 0 | 0) + 8 >> 2] = HEAP32[(107856 | 0 | 0) + 8 >> 2] | 0; - HEAP32[(114784 | 0 | 0) + 12 >> 2] = HEAP32[(107856 | 0 | 0) + 12 >> 2] | 0; - HEAP32[(114784 | 0 | 0) + 16 >> 2] = HEAP32[(107856 | 0 | 0) + 16 >> 2] | 0; - HEAP32[(114784 | 0 | 0) + 20 >> 2] = HEAP32[(107856 | 0 | 0) + 20 >> 2] | 0; - } - $5 = HEAP32[138960 >> 2] | 0; - $6 = _org_xmlvm_runtime_XMLVMArray_createSingleDimension___java_lang_Class_int($5, 25) | 0; - $7 = $me + 8 | 0; - $8 = $me + 20 | 0; - $9 = $8; - $10 = HEAP32[$9 >> 2] | 0; - $_r1_sroa_0_0_insert_ext191$0 = $10; - $_r1_sroa_0_0_insert_ext191$1 = 0; - $11 = (HEAP32[tempDoublePtr >> 2] = $_r1_sroa_0_0_insert_ext191$0, HEAP32[tempDoublePtr + 4 >> 2] = $_r1_sroa_0_0_insert_ext191$1, +HEAPF64[tempDoublePtr >> 3]); - $12 = ($10 | 0) > -1; - if ($12) { - $_r2_sroa_0_0_cast284 = $_r2_sroa_0; - HEAP32[$_r2_sroa_0_0_cast284 >> 2] = 0; - $_r2_sroa_0_0_load265_pre = +HEAPF64[$_r2_sroa_0 >> 3]; - $ld$21$0 = $_r2_sroa_0 | 0; - $_r2_sroa_0_0_load265_pre$$SHADOW$0 = HEAP32[$ld$21$0 >> 2] | 0; - $ld$22$1 = $_r2_sroa_0 + 4 | 0; - $_r2_sroa_0_0_load265_pre$$SHADOW$1 = HEAP32[$ld$22$1 >> 2] | 0; - $_r3_sroa_0_0_cast264_pre = $_r3_sroa_0; - $_pre = $6 + 16 | 0; - $_pre300 = $_pre; - var $_r2_sroa_0_0_load265 = $_r2_sroa_0_0_load265_pre; - var $_r3_sroa_0_0_cast264_pre_phi = $_r3_sroa_0_0_cast264_pre; - var $_pre_phi301 = $_pre300; - } else { - $14 = $6 + 16 | 0; - $15 = $14; - $16 = HEAP32[$15 >> 2] | 0; - $17 = $16; - HEAP16[$17 >> 1] = 48; - $_r2_sroa_0_0_cast283 = $_r2_sroa_0; - $18 = HEAP32[$15 >> 2] | 0; - $19 = $18 + 2 | 0; - $20 = $19; - HEAP16[$20 >> 1] = 46; - HEAP32[$_r2_sroa_0_0_cast283 >> 2] = 2; - $21 = $10 + 1 | 0; - $_r3_sroa_0_0_cast247 = $_r3_sroa_0; - HEAP32[$_r3_sroa_0_0_cast247 >> 2] = $21; - $_r3_sroa_0_0_load244 = +HEAPF64[$_r3_sroa_0 >> 3]; - $ld$4$0 = $_r3_sroa_0 | 0; - $_r3_sroa_0_0_load244$$SHADOW$0 = HEAP32[$ld$4$0 >> 2] | 0; - $ld$5$1 = $_r3_sroa_0 + 4 | 0; - $_r3_sroa_0_0_load244$$SHADOW$1 = HEAP32[$ld$5$1 >> 2] | 0; - $_r2_sroa_0_0_load = +HEAPF64[$_r2_sroa_0 >> 3]; - $ld$6$0 = $_r2_sroa_0 | 0; - $_r2_sroa_0_0_load$$SHADOW$0 = HEAP32[$ld$6$0 >> 2] | 0; - $ld$7$1 = $_r2_sroa_0 + 4 | 0; - $_r2_sroa_0_0_load$$SHADOW$1 = HEAP32[$ld$7$1 >> 2] | 0; - HEAPF64[$_r3_sroa_0 >> 3] = $_r2_sroa_0_0_load; - HEAPF64[$_r2_sroa_0 >> 3] = $_r3_sroa_0_0_load244; - $22$0 = $_r3_sroa_0_0_load244$$SHADOW$0; - $22$1 = $_r3_sroa_0_0_load244$$SHADOW$1; - $trunc297$0 = $22$0; - $trunc297 = $trunc297$0; - $23 = ($trunc297 | 0) < 0; - $24$0 = $_r2_sroa_0_0_load$$SHADOW$0; - $24$1 = $_r2_sroa_0_0_load$$SHADOW$1; - $25$0 = $24$0; - $25 = $25$0; - if ($23) { - $26 = $trunc297 + 1 | 0; - $27 = ($26 | 0) > 0; - $smax = $27 ? $26 : 0; - $28 = $25 + $smax | 0; - var $113 = $25; - var $112 = $trunc297; - while (1) { - $114 = $113 + 1 | 0; - $115 = HEAP32[$15 >> 2] | 0; - $116 = $115; - $117 = $116 + ($113 << 1) | 0; - HEAP16[$117 >> 1] = 48; - $118 = $112 + 1 | 0; - $119 = ($118 | 0) < 0; - if ($119) { - var $113 = $114; - var $112 = $118; - } else { - break; - } - } - $29 = $28 - $trunc297 | 0; - HEAP32[$_r3_sroa_0_0_cast247 >> 2] = $29; - HEAP32[$_r2_sroa_0_0_cast283 >> 2] = $smax; - $_r3_sroa_0_0_load239_pre = +HEAPF64[$_r3_sroa_0 >> 3]; - $ld$8$0 = $_r3_sroa_0 | 0; - $_r3_sroa_0_0_load239_pre$$SHADOW$0 = HEAP32[$ld$8$0 >> 2] | 0; - $ld$9$1 = $_r3_sroa_0 + 4 | 0; - $_r3_sroa_0_0_load239_pre$$SHADOW$1 = HEAP32[$ld$9$1 >> 2] | 0; - $_r3_sroa_0_0_load239 = $_r3_sroa_0_0_load239_pre; - } else { - $_r3_sroa_0_0_load239 = $_r2_sroa_0_0_load; - } - HEAPF64[$_r2_sroa_0 >> 3] = $_r3_sroa_0_0_load239; - var $_r2_sroa_0_0_load265 = $_r3_sroa_0_0_load239; - var $_r3_sroa_0_0_cast264_pre_phi = $_r3_sroa_0_0_cast247; - var $_pre_phi301 = $15; - } - $32 = $me + 16 | 0; - $33 = $32; - $34 = HEAP32[$33 >> 2] | 0; - $_r3_sroa_0_0_cast253 = $_r3_sroa_0; - HEAP32[$_r3_sroa_0_0_cast253 >> 2] = $34; - $35 = $me + 12 | 0; - $36 = $35; - $37 = HEAP32[$36 >> 2] | 0; - $38 = $37 + 1 | 0; - HEAP32[$36 >> 2] = $38; - $39 = $34 + 16 | 0; - $40 = $39; - $41 = HEAP32[$40 >> 2] | 0; - $42 = $41; - $43 = $42 + ($37 << 2) | 0; - $44 = HEAP32[$43 >> 2] | 0; - HEAP32[$_r3_sroa_0_0_cast264_pre_phi >> 2] = $44; - $_r3_sroa_0_0_load243 = +HEAPF64[$_r3_sroa_0 >> 3]; - $ld$10$0 = $_r3_sroa_0 | 0; - $_r3_sroa_0_0_load243$$SHADOW$0 = HEAP32[$ld$10$0 >> 2] | 0; - $ld$11$1 = $_r3_sroa_0 + 4 | 0; - $_r3_sroa_0_0_load243$$SHADOW$1 = HEAP32[$ld$11$1 >> 2] | 0; - HEAPF64[$_r3_sroa_0 >> 3] = $_r2_sroa_0_0_load265; - HEAPF64[$_r2_sroa_0 >> 3] = $11; - $_r2_sroa_0_0_cast = $_r2_sroa_0; - $45 = $7; - var $_r1_sroa_0_0 = $_r3_sroa_0_0_load243; - var $_r2_sroa_0_0_load266287 = $10; - var $_r3_sroa_0_0_load241 = $_r2_sroa_0_0_load265; - var $_sink_in = $_r2_sroa_0_0_load265; - while (1) { - HEAPF64[tempDoublePtr >> 3] = $_sink_in; - var $_sink$0 = HEAP32[tempDoublePtr >> 2] | 0; - var $_sink$1 = HEAP32[tempDoublePtr + 4 >> 2] | 0; - $47$0 = $_sink$0; - $47 = $47$0; - HEAPF64[tempDoublePtr >> 3] = $_r1_sroa_0_0; - var $48$0 = HEAP32[tempDoublePtr >> 2] | 0; - var $48$1 = HEAP32[tempDoublePtr + 4 >> 2] | 0; - $_r1_sroa_0_0_extract_trunc185$0 = $48$0; - $_r1_sroa_0_0_extract_trunc185 = $_r1_sroa_0_0_extract_trunc185$0; - $49 = ($_r1_sroa_0_0_extract_trunc185 | 0) == -1; - do { - if ($49) { - $121 = ($_r2_sroa_0_0_load266287 | 0) < -1; - if ($121) { - $_r1_sroa_0_2 = $_r3_sroa_0_0_load241; - break; - } - $123 = $47 + 1 | 0; - $_r1_sroa_0_0_insert_ext$0 = $123; - $_r1_sroa_0_0_insert_ext$1 = 0; - $$etemp$18$0 = 0; - $$etemp$18$1 = -1; - $_r1_sroa_0_0_insert_mask$0 = $48$0 & $$etemp$18$0; - $_r1_sroa_0_0_insert_mask$1 = $48$1 & $$etemp$18$1; - $_r1_sroa_0_0_insert_insert$0 = $_r1_sroa_0_0_insert_ext$0 | $_r1_sroa_0_0_insert_mask$0; - $_r1_sroa_0_0_insert_insert$1 = $_r1_sroa_0_0_insert_ext$1 | $_r1_sroa_0_0_insert_mask$1; - $124 = HEAP32[$_pre_phi301 >> 2] | 0; - $125 = $124; - $126 = $125 + ($47 << 1) | 0; - HEAP16[$126 >> 1] = 48; - var $_r1_sroa_0_1_in$1 = $_r1_sroa_0_0_insert_insert$1; - var $_r1_sroa_0_1_in$0 = $_r1_sroa_0_0_insert_insert$0; - label = 785; - break; - } else { - $51 = $47 + 1 | 0; - $52 = $_r1_sroa_0_0_extract_trunc185 + 48 | 0; - $53 = $52 & 65535; - $54 = HEAP32[$_pre_phi301 >> 2] | 0; - $55 = $54; - $56 = $55 + ($47 << 1) | 0; - HEAP16[$56 >> 1] = $53; - $_r1_sroa_0_0_insert_ext195$0 = $51; - $_r1_sroa_0_0_insert_ext195$1 = 0; - var $_r1_sroa_0_1_in$1 = $_r1_sroa_0_0_insert_ext195$1; - var $_r1_sroa_0_1_in$0 = $_r1_sroa_0_0_insert_ext195$0; - label = 785; - break; - } - } while (0); - do { - if ((label | 0) == 785) { - label = 0; - $_r1_sroa_0_1 = (HEAP32[tempDoublePtr >> 2] = $_r1_sroa_0_1_in$0, HEAP32[tempDoublePtr + 4 >> 2] = $_r1_sroa_0_1_in$1, +HEAPF64[tempDoublePtr >> 3]); - $58 = ($_r2_sroa_0_0_load266287 | 0) == 0; - if (!$58) { - $_r1_sroa_0_2 = $_r1_sroa_0_1; - break; - } - $_r1_sroa_0_0_extract_trunc169$0 = $_r1_sroa_0_1_in$0; - $_r1_sroa_0_0_extract_trunc169 = $_r1_sroa_0_0_extract_trunc169$0; - $60 = $_r1_sroa_0_0_extract_trunc169 + 1 | 0; - HEAP32[$_r3_sroa_0_0_cast264_pre_phi >> 2] = $60; - $61 = HEAP32[$_pre_phi301 >> 2] | 0; - $62 = $61; - $63 = $62 + ($_r1_sroa_0_0_extract_trunc169 << 1) | 0; - HEAP16[$63 >> 1] = 46; - $_r3_sroa_0_0_load240 = +HEAPF64[$_r3_sroa_0 >> 3]; - $ld$12$0 = $_r3_sroa_0 | 0; - $_r3_sroa_0_0_load240$$SHADOW$0 = HEAP32[$ld$12$0 >> 2] | 0; - $ld$13$1 = $_r3_sroa_0 + 4 | 0; - $_r3_sroa_0_0_load240$$SHADOW$1 = HEAP32[$ld$13$1 >> 2] | 0; - $_r1_sroa_0_2 = $_r3_sroa_0_0_load240; - } - } while (0); - $64 = $_r2_sroa_0_0_load266287 - 1 | 0; - $65 = HEAP32[$36 >> 2] | 0; - HEAP32[$_r3_sroa_0_0_cast264_pre_phi >> 2] = $65; - $66 = HEAP32[$45 >> 2] | 0; - $67 = ($65 | 0) < ($66 | 0); - if ($67) { - $69 = HEAP32[$33 >> 2] | 0; - HEAP32[$_r3_sroa_0_0_cast253 >> 2] = $69; - $70 = $65 + 1 | 0; - HEAP32[$36 >> 2] = $70; - $71 = $69 + 16 | 0; - $72 = $71; - $73 = HEAP32[$72 >> 2] | 0; - $74 = $73; - $75 = $74 + ($65 << 2) | 0; - $76 = HEAP32[$75 >> 2] | 0; - HEAP32[$_r3_sroa_0_0_cast264_pre_phi >> 2] = $76; - $phitmp = ($76 | 0) != -1; - $77 = ($64 | 0) > -2; - $or_cond = $phitmp | $77; - if (!$or_cond) { - break; - } - } else { - HEAP32[$_r3_sroa_0_0_cast264_pre_phi >> 2] = -1; - $_old = ($64 | 0) > -2; - if (!$_old) { - break; - } - } - $_r3_sroa_0_0_load242 = +HEAPF64[$_r3_sroa_0 >> 3]; - $ld$19$0 = $_r3_sroa_0 | 0; - $_r3_sroa_0_0_load242$$SHADOW$0 = HEAP32[$ld$19$0 >> 2] | 0; - $ld$20$1 = $_r3_sroa_0 + 4 | 0; - $_r3_sroa_0_0_load242$$SHADOW$1 = HEAP32[$ld$20$1 >> 2] | 0; - HEAPF64[$_r3_sroa_0 >> 3] = $_r1_sroa_0_2; - var $_r1_sroa_0_0 = $_r3_sroa_0_0_load242; - var $_r2_sroa_0_0_load266287 = $64; - var $_r3_sroa_0_0_load241 = $_r1_sroa_0_2; - var $_sink_in = $_r1_sroa_0_2; - } - HEAP32[$_r2_sroa_0_0_cast >> 2] = $64; - $79 = HEAP32[(106148 | 0) >> 2] | 0; - $80 = ($79 | 0) == 0; - if ($80) { - ___INIT_java_lang_String(); - } - $82 = _GC_MALLOC(36 | 0) | 0; - $83 = $82; - HEAP32[$83 >> 2] = 106144; - $84 = $82 + 4 | 0; - _memset($84 | 0 | 0, 0 | 0 | 0, 32 | 0 | 0); - $_r2_sroa_0_0_cast269 = $_r2_sroa_0; - HEAP32[$_r2_sroa_0_0_cast269 >> 2] = $82; - HEAPF64[tempDoublePtr >> 3] = $_r1_sroa_0_2; - var $85$0 = HEAP32[tempDoublePtr >> 2] | 0; - var $85$1 = HEAP32[tempDoublePtr + 4 >> 2] | 0; - $_r1_sroa_0_0_extract_trunc$0 = $85$0; - $_r1_sroa_0_0_extract_trunc = $_r1_sroa_0_0_extract_trunc$0; - $86 = $82 + 8 | 0; - $87 = $86; - HEAP32[$87 >> 2] = 0; - $88 = $82 + 12 | 0; - $89 = $88; - HEAP32[$89 >> 2] = 0; - $90 = $82 + 16 | 0; - $91 = $90; - HEAP32[$91 >> 2] = 0; - $92 = ($_r1_sroa_0_0_extract_trunc | 0) < 0; - if ($92) { - _XMLVM_ERROR(16136 | 0, 13208 | 0, 132112 | 0, 830); - return 0 | 0; - } - $94 = $6 + 12 | 0; - $95 = $94; - $96 = HEAP32[$95 >> 2] | 0; - $97 = ($96 | 0) < ($_r1_sroa_0_0_extract_trunc | 0); - if ($97) { - _XMLVM_ERROR(16136 | 0, 13208 | 0, 132112 | 0, 830); - return 0 | 0; - } - $99 = $82 + 24 | 0; - $100 = $99; - HEAP32[$100 >> 2] = 0; - $101 = HEAP32[(114668 | 0) >> 2] | 0; - $102 = ($101 | 0) == 0; - if (!$102) { - $105 = HEAP32[138960 >> 2] | 0; - $106 = _org_xmlvm_runtime_XMLVMArray_createSingleDimension___java_lang_Class_int($105, $_r1_sroa_0_0_extract_trunc) | 0; - $107 = $82 + 20 | 0; - $108 = $107; - HEAP32[$108 >> 2] = $106; - $109 = $82 + 28 | 0; - $110 = $109; - HEAP32[$110 >> 2] = $_r1_sroa_0_0_extract_trunc; - _java_lang_System_arraycopy___java_lang_Object_int_java_lang_Object_int_int($6, 0, $106, 0, $_r1_sroa_0_0_extract_trunc); - STACKTOP = __stackBase__; - return $82 | 0; - } + $me = $me | 0; + var $_r2_sroa_0 = 0, $_r3_sroa_0 = 0, $1 = 0, $2 = 0, $$etemp$1 = 0, $$etemp$0$0 = 0, $$etemp$0$1 = 0, $st$2$0 = 0; + var $st$3$1 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $_r1_sroa_0_0_insert_ext191$0 = 0; + var $_r1_sroa_0_0_insert_ext191$1 = 0, $11 = +0, $12 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $_r2_sroa_0_0_cast283 = 0; + var $18 = 0, $19 = 0, $20 = 0, $21 = 0, $_r3_sroa_0_0_cast247 = 0, $_r3_sroa_0_0_load244 = +0, $ld$4$0 = 0, $_r3_sroa_0_0_load244$$SHADOW$0 = 0; + var $ld$5$1 = 0, $_r3_sroa_0_0_load244$$SHADOW$1 = 0, $_r2_sroa_0_0_load = +0, $ld$6$0 = 0, $_r2_sroa_0_0_load$$SHADOW$0 = 0, $ld$7$1 = 0, $_r2_sroa_0_0_load$$SHADOW$1 = 0, $22$0 = 0; + var $22$1 = 0, $trunc297$0 = 0, $trunc297 = 0, $23 = 0, $24$0 = 0, $24$1 = 0, $25$0 = 0, $25 = 0; + var $26 = 0, $27 = 0, $smax = 0, $28 = 0, $29 = 0, $_r3_sroa_0_0_load239_pre = +0, $ld$8$0 = 0, $_r3_sroa_0_0_load239_pre$$SHADOW$0 = 0; + var $ld$9$1 = 0, $_r3_sroa_0_0_load239_pre$$SHADOW$1 = 0, $_r3_sroa_0_0_load239 = +0, $_pre_phi301 = 0, $_r3_sroa_0_0_cast264_pre_phi = 0, $_r2_sroa_0_0_load265 = +0, $32 = 0, $33 = 0; + var $34 = 0, $_r3_sroa_0_0_cast253 = 0, $35 = 0, $36 = 0, $37 = 0, $38 = 0, $39 = 0, $40 = 0; + var $41 = 0, $42 = 0, $43 = 0, $44 = 0, $_r3_sroa_0_0_load243 = +0, $ld$10$0 = 0, $_r3_sroa_0_0_load243$$SHADOW$0 = 0, $ld$11$1 = 0; + var $_r3_sroa_0_0_load243$$SHADOW$1 = 0, $_r2_sroa_0_0_cast = 0, $45 = 0, $_sink_in = +0, $_r3_sroa_0_0_load241 = +0, $_r2_sroa_0_0_load266287 = 0, $_r1_sroa_0_0 = +0, $_sink$0 = 0, $_sink$1 = 0; + var $47$0 = 0, $47 = 0, $48$0 = 0, $48$1 = 0, $_r1_sroa_0_0_extract_trunc185$0 = 0, $_r1_sroa_0_0_extract_trunc185 = 0, $49 = 0, $51 = 0, $52 = 0; + var $53 = 0, $54 = 0, $55 = 0, $56 = 0, $_r1_sroa_0_0_insert_ext195$0 = 0, $_r1_sroa_0_0_insert_ext195$1 = 0, $_r1_sroa_0_1_in$0 = 0, $_r1_sroa_0_1_in$1 = 0; + var $_r1_sroa_0_1 = +0, $58 = 0, $_r1_sroa_0_0_extract_trunc169$0 = 0, $_r1_sroa_0_0_extract_trunc169 = 0, $60 = 0, $61 = 0, $62 = 0, $63 = 0; + var $_r3_sroa_0_0_load240 = +0, $ld$12$0 = 0, $_r3_sroa_0_0_load240$$SHADOW$0 = 0, $ld$13$1 = 0, $_r3_sroa_0_0_load240$$SHADOW$1 = 0, $_r1_sroa_0_2 = +0, $64 = 0, $65 = 0; + var $66 = 0, $67 = 0, $69 = 0, $70 = 0, $71 = 0, $72 = 0, $73 = 0, $74 = 0; + var $75 = 0, $76 = 0, $phitmp = 0, $77 = 0, $or_cond = 0, $79 = 0, $80 = 0, $82 = 0; + var $83 = 0, $84 = 0, $_r2_sroa_0_0_cast269 = 0, $85$0 = 0, $85$1 = 0, $_r1_sroa_0_0_extract_trunc$0 = 0, $_r1_sroa_0_0_extract_trunc = 0, $86 = 0, $87 = 0; + var $88 = 0, $89 = 0, $90 = 0, $91 = 0, $92 = 0, $94 = 0, $95 = 0, $96 = 0; + var $97 = 0, $99 = 0, $100 = 0, $101 = 0, $102 = 0, $$etemp$15 = 0, $$etemp$14$0 = 0, $$etemp$14$1 = 0; + var $st$16$0 = 0, $st$17$1 = 0, $105 = 0, $106 = 0, $107 = 0, $108 = 0, $109 = 0, $110 = 0; + var $112 = 0, $113 = 0, $114 = 0, $115 = 0, $116 = 0, $117 = 0, $118 = 0, $119 = 0; + var $121 = 0, $123 = 0, $_r1_sroa_0_0_insert_ext$0 = 0, $_r1_sroa_0_0_insert_ext$1 = 0, $$etemp$18$0 = 0, $$etemp$18$1 = 0, $_r1_sroa_0_0_insert_mask$0 = 0, $_r1_sroa_0_0_insert_mask$1 = 0; + var $_r1_sroa_0_0_insert_insert$0 = 0, $_r1_sroa_0_0_insert_insert$1 = 0, $124 = 0, $125 = 0, $126 = 0, $_old = 0, $_r3_sroa_0_0_load242 = +0, $ld$19$0 = 0; + var $_r3_sroa_0_0_load242$$SHADOW$0 = 0, $ld$20$1 = 0, $_r3_sroa_0_0_load242$$SHADOW$1 = 0, $_r2_sroa_0_0_cast284 = 0, $_r2_sroa_0_0_load265_pre = +0, $ld$21$0 = 0, $_r2_sroa_0_0_load265_pre$$SHADOW$0 = 0, $ld$22$1 = 0; + var $_r2_sroa_0_0_load265_pre$$SHADOW$1 = 0, $_r3_sroa_0_0_cast264_pre = 0, $_pre = 0, $_pre300 = 0; + var label = 0; + var __stackBase__ = 0; + __stackBase__ = STACKTOP; + STACKTOP = STACKTOP + 16 | 0; + $_r2_sroa_0 = __stackBase__ | 0; + $_r3_sroa_0 = __stackBase__ + 8 | 0; + $1 = HEAP32[(114668 | 0) >> 2] | 0; + $2 = ($1 | 0) == 0; + if ($2) { HEAP32[(114664 | 0) >> 2] = 1; HEAP32[(114668 | 0) >> 2] = 1; - $$etemp$15 = 114672 | 0; - $$etemp$14$0 = -1; - $$etemp$14$1 = -1; - $st$16$0 = $$etemp$15 | 0; - HEAP32[$st$16$0 >> 2] = $$etemp$14$0; - $st$17$1 = $$etemp$15 + 4 | 0; - HEAP32[$st$17$1 >> 2] = $$etemp$14$1; + $$etemp$1 = 114672 | 0; + $$etemp$0$0 = -1; + $$etemp$0$1 = -1; + $st$2$0 = $$etemp$1 | 0; + HEAP32[$st$2$0 >> 2] = $$etemp$0$0; + $st$3$1 = $$etemp$1 + 4 | 0; + HEAP32[$st$3$1 >> 2] = $$etemp$0$1; HEAP32[(114684 | 0) >> 2] = 25296 | 0; HEAP32[(114704 | 0) >> 2] = 110728; HEAP32[(114712 | 0) >> 2] = 8; @@ -554,6 +230,300 @@ function _org_apache_harmony_luni_util_NumberConverter_freeFormat__($me) { HEAP32[(114784 | 0 | 0) + 12 >> 2] = HEAP32[(107856 | 0 | 0) + 12 >> 2] | 0; HEAP32[(114784 | 0 | 0) + 16 >> 2] = HEAP32[(107856 | 0 | 0) + 16 >> 2] | 0; HEAP32[(114784 | 0 | 0) + 20 >> 2] = HEAP32[(107856 | 0 | 0) + 20 >> 2] | 0; + } + $5 = HEAP32[138960 >> 2] | 0; + $6 = _org_xmlvm_runtime_XMLVMArray_createSingleDimension___java_lang_Class_int($5, 25) | 0; + $7 = $me + 8 | 0; + $8 = $me + 20 | 0; + $9 = $8; + $10 = HEAP32[$9 >> 2] | 0; + $_r1_sroa_0_0_insert_ext191$0 = $10; + $_r1_sroa_0_0_insert_ext191$1 = 0; + $11 = (HEAP32[tempDoublePtr >> 2] = $_r1_sroa_0_0_insert_ext191$0, HEAP32[tempDoublePtr + 4 >> 2] = $_r1_sroa_0_0_insert_ext191$1, +HEAPF64[tempDoublePtr >> 3]); + $12 = ($10 | 0) > -1; + if ($12) { + $_r2_sroa_0_0_cast284 = $_r2_sroa_0; + HEAP32[$_r2_sroa_0_0_cast284 >> 2] = 0; + $_r2_sroa_0_0_load265_pre = +HEAPF64[$_r2_sroa_0 >> 3]; + $ld$21$0 = $_r2_sroa_0 | 0; + $_r2_sroa_0_0_load265_pre$$SHADOW$0 = HEAP32[$ld$21$0 >> 2] | 0; + $ld$22$1 = $_r2_sroa_0 + 4 | 0; + $_r2_sroa_0_0_load265_pre$$SHADOW$1 = HEAP32[$ld$22$1 >> 2] | 0; + $_r3_sroa_0_0_cast264_pre = $_r3_sroa_0; + $_pre = $6 + 16 | 0; + $_pre300 = $_pre; + var $_r2_sroa_0_0_load265 = $_r2_sroa_0_0_load265_pre; + var $_r3_sroa_0_0_cast264_pre_phi = $_r3_sroa_0_0_cast264_pre; + var $_pre_phi301 = $_pre300; + } else { + $14 = $6 + 16 | 0; + $15 = $14; + $16 = HEAP32[$15 >> 2] | 0; + $17 = $16; + HEAP16[$17 >> 1] = 48; + $_r2_sroa_0_0_cast283 = $_r2_sroa_0; + $18 = HEAP32[$15 >> 2] | 0; + $19 = $18 + 2 | 0; + $20 = $19; + HEAP16[$20 >> 1] = 46; + HEAP32[$_r2_sroa_0_0_cast283 >> 2] = 2; + $21 = $10 + 1 | 0; + $_r3_sroa_0_0_cast247 = $_r3_sroa_0; + HEAP32[$_r3_sroa_0_0_cast247 >> 2] = $21; + $_r3_sroa_0_0_load244 = +HEAPF64[$_r3_sroa_0 >> 3]; + $ld$4$0 = $_r3_sroa_0 | 0; + $_r3_sroa_0_0_load244$$SHADOW$0 = HEAP32[$ld$4$0 >> 2] | 0; + $ld$5$1 = $_r3_sroa_0 + 4 | 0; + $_r3_sroa_0_0_load244$$SHADOW$1 = HEAP32[$ld$5$1 >> 2] | 0; + $_r2_sroa_0_0_load = +HEAPF64[$_r2_sroa_0 >> 3]; + $ld$6$0 = $_r2_sroa_0 | 0; + $_r2_sroa_0_0_load$$SHADOW$0 = HEAP32[$ld$6$0 >> 2] | 0; + $ld$7$1 = $_r2_sroa_0 + 4 | 0; + $_r2_sroa_0_0_load$$SHADOW$1 = HEAP32[$ld$7$1 >> 2] | 0; + HEAPF64[$_r3_sroa_0 >> 3] = $_r2_sroa_0_0_load; + HEAPF64[$_r2_sroa_0 >> 3] = $_r3_sroa_0_0_load244; + $22$0 = $_r3_sroa_0_0_load244$$SHADOW$0; + $22$1 = $_r3_sroa_0_0_load244$$SHADOW$1; + $trunc297$0 = $22$0; + $trunc297 = $trunc297$0; + $23 = ($trunc297 | 0) < 0; + $24$0 = $_r2_sroa_0_0_load$$SHADOW$0; + $24$1 = $_r2_sroa_0_0_load$$SHADOW$1; + $25$0 = $24$0; + $25 = $25$0; + if ($23) { + $26 = $trunc297 + 1 | 0; + $27 = ($26 | 0) > 0; + $smax = $27 ? $26 : 0; + $28 = $25 + $smax | 0; + var $113 = $25; + var $112 = $trunc297; + while (1) { + $114 = $113 + 1 | 0; + $115 = HEAP32[$15 >> 2] | 0; + $116 = $115; + $117 = $116 + ($113 << 1) | 0; + HEAP16[$117 >> 1] = 48; + $118 = $112 + 1 | 0; + $119 = ($118 | 0) < 0; + if ($119) { + var $113 = $114; + var $112 = $118; + } else { + break; + } + } + $29 = $28 - $trunc297 | 0; + HEAP32[$_r3_sroa_0_0_cast247 >> 2] = $29; + HEAP32[$_r2_sroa_0_0_cast283 >> 2] = $smax; + $_r3_sroa_0_0_load239_pre = +HEAPF64[$_r3_sroa_0 >> 3]; + $ld$8$0 = $_r3_sroa_0 | 0; + $_r3_sroa_0_0_load239_pre$$SHADOW$0 = HEAP32[$ld$8$0 >> 2] | 0; + $ld$9$1 = $_r3_sroa_0 + 4 | 0; + $_r3_sroa_0_0_load239_pre$$SHADOW$1 = HEAP32[$ld$9$1 >> 2] | 0; + $_r3_sroa_0_0_load239 = $_r3_sroa_0_0_load239_pre; + } else { + $_r3_sroa_0_0_load239 = $_r2_sroa_0_0_load; + } + HEAPF64[$_r2_sroa_0 >> 3] = $_r3_sroa_0_0_load239; + var $_r2_sroa_0_0_load265 = $_r3_sroa_0_0_load239; + var $_r3_sroa_0_0_cast264_pre_phi = $_r3_sroa_0_0_cast247; + var $_pre_phi301 = $15; + } + $32 = $me + 16 | 0; + $33 = $32; + $34 = HEAP32[$33 >> 2] | 0; + $_r3_sroa_0_0_cast253 = $_r3_sroa_0; + HEAP32[$_r3_sroa_0_0_cast253 >> 2] = $34; + $35 = $me + 12 | 0; + $36 = $35; + $37 = HEAP32[$36 >> 2] | 0; + $38 = $37 + 1 | 0; + HEAP32[$36 >> 2] = $38; + $39 = $34 + 16 | 0; + $40 = $39; + $41 = HEAP32[$40 >> 2] | 0; + $42 = $41; + $43 = $42 + ($37 << 2) | 0; + $44 = HEAP32[$43 >> 2] | 0; + HEAP32[$_r3_sroa_0_0_cast264_pre_phi >> 2] = $44; + $_r3_sroa_0_0_load243 = +HEAPF64[$_r3_sroa_0 >> 3]; + $ld$10$0 = $_r3_sroa_0 | 0; + $_r3_sroa_0_0_load243$$SHADOW$0 = HEAP32[$ld$10$0 >> 2] | 0; + $ld$11$1 = $_r3_sroa_0 + 4 | 0; + $_r3_sroa_0_0_load243$$SHADOW$1 = HEAP32[$ld$11$1 >> 2] | 0; + HEAPF64[$_r3_sroa_0 >> 3] = $_r2_sroa_0_0_load265; + HEAPF64[$_r2_sroa_0 >> 3] = $11; + $_r2_sroa_0_0_cast = $_r2_sroa_0; + $45 = $7; + var $_r1_sroa_0_0 = $_r3_sroa_0_0_load243; + var $_r2_sroa_0_0_load266287 = $10; + var $_r3_sroa_0_0_load241 = $_r2_sroa_0_0_load265; + var $_sink_in = $_r2_sroa_0_0_load265; + while (1) { + HEAPF64[tempDoublePtr >> 3] = $_sink_in; + var $_sink$0 = HEAP32[tempDoublePtr >> 2] | 0; + var $_sink$1 = HEAP32[tempDoublePtr + 4 >> 2] | 0; + $47$0 = $_sink$0; + $47 = $47$0; + HEAPF64[tempDoublePtr >> 3] = $_r1_sroa_0_0; + var $48$0 = HEAP32[tempDoublePtr >> 2] | 0; + var $48$1 = HEAP32[tempDoublePtr + 4 >> 2] | 0; + $_r1_sroa_0_0_extract_trunc185$0 = $48$0; + $_r1_sroa_0_0_extract_trunc185 = $_r1_sroa_0_0_extract_trunc185$0; + $49 = ($_r1_sroa_0_0_extract_trunc185 | 0) == -1; + do { + if ($49) { + $121 = ($_r2_sroa_0_0_load266287 | 0) < -1; + if ($121) { + $_r1_sroa_0_2 = $_r3_sroa_0_0_load241; + break; + } + $123 = $47 + 1 | 0; + $_r1_sroa_0_0_insert_ext$0 = $123; + $_r1_sroa_0_0_insert_ext$1 = 0; + $$etemp$18$0 = 0; + $$etemp$18$1 = -1; + $_r1_sroa_0_0_insert_mask$0 = $48$0 & $$etemp$18$0; + $_r1_sroa_0_0_insert_mask$1 = $48$1 & $$etemp$18$1; + $_r1_sroa_0_0_insert_insert$0 = $_r1_sroa_0_0_insert_ext$0 | $_r1_sroa_0_0_insert_mask$0; + $_r1_sroa_0_0_insert_insert$1 = $_r1_sroa_0_0_insert_ext$1 | $_r1_sroa_0_0_insert_mask$1; + $124 = HEAP32[$_pre_phi301 >> 2] | 0; + $125 = $124; + $126 = $125 + ($47 << 1) | 0; + HEAP16[$126 >> 1] = 48; + var $_r1_sroa_0_1_in$1 = $_r1_sroa_0_0_insert_insert$1; + var $_r1_sroa_0_1_in$0 = $_r1_sroa_0_0_insert_insert$0; + label = 785; + break; + } else { + $51 = $47 + 1 | 0; + $52 = $_r1_sroa_0_0_extract_trunc185 + 48 | 0; + $53 = $52 & 65535; + $54 = HEAP32[$_pre_phi301 >> 2] | 0; + $55 = $54; + $56 = $55 + ($47 << 1) | 0; + HEAP16[$56 >> 1] = $53; + $_r1_sroa_0_0_insert_ext195$0 = $51; + $_r1_sroa_0_0_insert_ext195$1 = 0; + var $_r1_sroa_0_1_in$1 = $_r1_sroa_0_0_insert_ext195$1; + var $_r1_sroa_0_1_in$0 = $_r1_sroa_0_0_insert_ext195$0; + label = 785; + break; + } + } while (0); + do { + if ((label | 0) == 785) { + label = 0; + $_r1_sroa_0_1 = (HEAP32[tempDoublePtr >> 2] = $_r1_sroa_0_1_in$0, HEAP32[tempDoublePtr + 4 >> 2] = $_r1_sroa_0_1_in$1, +HEAPF64[tempDoublePtr >> 3]); + $58 = ($_r2_sroa_0_0_load266287 | 0) == 0; + if (!$58) { + $_r1_sroa_0_2 = $_r1_sroa_0_1; + break; + } + $_r1_sroa_0_0_extract_trunc169$0 = $_r1_sroa_0_1_in$0; + $_r1_sroa_0_0_extract_trunc169 = $_r1_sroa_0_0_extract_trunc169$0; + $60 = $_r1_sroa_0_0_extract_trunc169 + 1 | 0; + HEAP32[$_r3_sroa_0_0_cast264_pre_phi >> 2] = $60; + $61 = HEAP32[$_pre_phi301 >> 2] | 0; + $62 = $61; + $63 = $62 + ($_r1_sroa_0_0_extract_trunc169 << 1) | 0; + HEAP16[$63 >> 1] = 46; + $_r3_sroa_0_0_load240 = +HEAPF64[$_r3_sroa_0 >> 3]; + $ld$12$0 = $_r3_sroa_0 | 0; + $_r3_sroa_0_0_load240$$SHADOW$0 = HEAP32[$ld$12$0 >> 2] | 0; + $ld$13$1 = $_r3_sroa_0 + 4 | 0; + $_r3_sroa_0_0_load240$$SHADOW$1 = HEAP32[$ld$13$1 >> 2] | 0; + $_r1_sroa_0_2 = $_r3_sroa_0_0_load240; + } + } while (0); + $64 = $_r2_sroa_0_0_load266287 - 1 | 0; + $65 = HEAP32[$36 >> 2] | 0; + HEAP32[$_r3_sroa_0_0_cast264_pre_phi >> 2] = $65; + $66 = HEAP32[$45 >> 2] | 0; + $67 = ($65 | 0) < ($66 | 0); + if ($67) { + $69 = HEAP32[$33 >> 2] | 0; + HEAP32[$_r3_sroa_0_0_cast253 >> 2] = $69; + $70 = $65 + 1 | 0; + HEAP32[$36 >> 2] = $70; + $71 = $69 + 16 | 0; + $72 = $71; + $73 = HEAP32[$72 >> 2] | 0; + $74 = $73; + $75 = $74 + ($65 << 2) | 0; + $76 = HEAP32[$75 >> 2] | 0; + HEAP32[$_r3_sroa_0_0_cast264_pre_phi >> 2] = $76; + $phitmp = ($76 | 0) != -1; + $77 = ($64 | 0) > -2; + $or_cond = $phitmp | $77; + if (!$or_cond) { + break; + } + } else { + HEAP32[$_r3_sroa_0_0_cast264_pre_phi >> 2] = -1; + $_old = ($64 | 0) > -2; + if (!$_old) { + break; + } + } + $_r3_sroa_0_0_load242 = +HEAPF64[$_r3_sroa_0 >> 3]; + $ld$19$0 = $_r3_sroa_0 | 0; + $_r3_sroa_0_0_load242$$SHADOW$0 = HEAP32[$ld$19$0 >> 2] | 0; + $ld$20$1 = $_r3_sroa_0 + 4 | 0; + $_r3_sroa_0_0_load242$$SHADOW$1 = HEAP32[$ld$20$1 >> 2] | 0; + HEAPF64[$_r3_sroa_0 >> 3] = $_r1_sroa_0_2; + var $_r1_sroa_0_0 = $_r3_sroa_0_0_load242; + var $_r2_sroa_0_0_load266287 = $64; + var $_r3_sroa_0_0_load241 = $_r1_sroa_0_2; + var $_sink_in = $_r1_sroa_0_2; + } + HEAP32[$_r2_sroa_0_0_cast >> 2] = $64; + $79 = HEAP32[(106148 | 0) >> 2] | 0; + $80 = ($79 | 0) == 0; + if ($80) { + ___INIT_java_lang_String(); + } + $82 = _GC_MALLOC(36 | 0) | 0; + $83 = $82; + HEAP32[$83 >> 2] = 106144; + $84 = $82 + 4 | 0; + _memset($84 | 0 | 0, 0 | 0 | 0, 32 | 0 | 0); + $_r2_sroa_0_0_cast269 = $_r2_sroa_0; + HEAP32[$_r2_sroa_0_0_cast269 >> 2] = $82; + HEAPF64[tempDoublePtr >> 3] = $_r1_sroa_0_2; + var $85$0 = HEAP32[tempDoublePtr >> 2] | 0; + var $85$1 = HEAP32[tempDoublePtr + 4 >> 2] | 0; + $_r1_sroa_0_0_extract_trunc$0 = $85$0; + $_r1_sroa_0_0_extract_trunc = $_r1_sroa_0_0_extract_trunc$0; + $86 = $82 + 8 | 0; + $87 = $86; + HEAP32[$87 >> 2] = 0; + $88 = $82 + 12 | 0; + $89 = $88; + HEAP32[$89 >> 2] = 0; + $90 = $82 + 16 | 0; + $91 = $90; + HEAP32[$91 >> 2] = 0; + $92 = ($_r1_sroa_0_0_extract_trunc | 0) < 0; + if ($92) { + _XMLVM_ERROR(16136 | 0, 13208 | 0, 132112 | 0, 830); + return 0 | 0; + } + $94 = $6 + 12 | 0; + $95 = $94; + $96 = HEAP32[$95 >> 2] | 0; + $97 = ($96 | 0) < ($_r1_sroa_0_0_extract_trunc | 0); + if ($97) { + _XMLVM_ERROR(16136 | 0, 13208 | 0, 132112 | 0, 830); + return 0 | 0; + } + $99 = $82 + 24 | 0; + $100 = $99; + HEAP32[$100 >> 2] = 0; + $101 = HEAP32[(114668 | 0) >> 2] | 0; + $102 = ($101 | 0) == 0; + if (!$102) { $105 = HEAP32[138960 >> 2] | 0; $106 = _org_xmlvm_runtime_XMLVMArray_createSingleDimension___java_lang_Class_int($105, $_r1_sroa_0_0_extract_trunc) | 0; $107 = $82 + 20 | 0; @@ -565,6291 +535,6321 @@ function _org_apache_harmony_luni_util_NumberConverter_freeFormat__($me) { _java_lang_System_arraycopy___java_lang_Object_int_java_lang_Object_int_int($6, 0, $106, 0, $_r1_sroa_0_0_extract_trunc); STACKTOP = __stackBase__; return $82 | 0; + } + HEAP32[(114664 | 0) >> 2] = 1; + HEAP32[(114668 | 0) >> 2] = 1; + $$etemp$15 = 114672 | 0; + $$etemp$14$0 = -1; + $$etemp$14$1 = -1; + $st$16$0 = $$etemp$15 | 0; + HEAP32[$st$16$0 >> 2] = $$etemp$14$0; + $st$17$1 = $$etemp$15 + 4 | 0; + HEAP32[$st$17$1 >> 2] = $$etemp$14$1; + HEAP32[(114684 | 0) >> 2] = 25296 | 0; + HEAP32[(114704 | 0) >> 2] = 110728; + HEAP32[(114712 | 0) >> 2] = 8; + HEAP32[(114784 | 0 | 0) >> 2] = HEAP32[(107856 | 0 | 0) >> 2] | 0; + HEAP32[(114784 | 0 | 0) + 4 >> 2] = HEAP32[(107856 | 0 | 0) + 4 >> 2] | 0; + HEAP32[(114784 | 0 | 0) + 8 >> 2] = HEAP32[(107856 | 0 | 0) + 8 >> 2] | 0; + HEAP32[(114784 | 0 | 0) + 12 >> 2] = HEAP32[(107856 | 0 | 0) + 12 >> 2] | 0; + HEAP32[(114784 | 0 | 0) + 16 >> 2] = HEAP32[(107856 | 0 | 0) + 16 >> 2] | 0; + HEAP32[(114784 | 0 | 0) + 20 >> 2] = HEAP32[(107856 | 0 | 0) + 20 >> 2] | 0; + $105 = HEAP32[138960 >> 2] | 0; + $106 = _org_xmlvm_runtime_XMLVMArray_createSingleDimension___java_lang_Class_int($105, $_r1_sroa_0_0_extract_trunc) | 0; + $107 = $82 + 20 | 0; + $108 = $107; + HEAP32[$108 >> 2] = $106; + $109 = $82 + 28 | 0; + $110 = $109; + HEAP32[$110 >> 2] = $_r1_sroa_0_0_extract_trunc; + _java_lang_System_arraycopy___java_lang_Object_int_java_lang_Object_int_int($6, 0, $106, 0, $_r1_sroa_0_0_extract_trunc); + STACKTOP = __stackBase__; + return $82 | 0; } function __ZN23b2EdgeAndPolygonContact8EvaluateEP10b2ManifoldRK11b2TransformS4_($this, $manifold, $xfA, $xfB) { - $this = $this | 0; - $manifold = $manifold | 0; - $xfA = $xfA | 0; - $xfB = $xfB | 0; - var $collider_i = 0, $1 = 0, $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0; - var $8 = 0, $9 = 0, $10 = 0, $11 = 0; - var label = 0; - var __stackBase__ = 0; - __stackBase__ = STACKTOP; - STACKTOP = STACKTOP + 256 | 0; - $collider_i = __stackBase__ | 0; - $1 = $this + 48 | 0; - $2 = HEAP32[$1 >> 2] | 0; - $3 = $2 + 12 | 0; - $4 = HEAP32[$3 >> 2] | 0; - $5 = $4; - $6 = $this + 52 | 0; - $7 = HEAP32[$6 >> 2] | 0; - $8 = $7 + 12 | 0; - $9 = HEAP32[$8 >> 2] | 0; - $10 = $9; - $11 = $collider_i; - __ZN12b2EPCollider7CollideEP10b2ManifoldPK11b2EdgeShapeRK11b2TransformPK14b2PolygonShapeS7_($collider_i, $manifold, $5, $xfA, $10, $xfB); - STACKTOP = __stackBase__; - return; + $this = $this | 0; + $manifold = $manifold | 0; + $xfA = $xfA | 0; + $xfB = $xfB | 0; + var $collider_i = 0, $1 = 0, $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0; + var $8 = 0, $9 = 0, $10 = 0, $11 = 0; + var label = 0; + var __stackBase__ = 0; + __stackBase__ = STACKTOP; + STACKTOP = STACKTOP + 256 | 0; + $collider_i = __stackBase__ | 0; + $1 = $this + 48 | 0; + $2 = HEAP32[$1 >> 2] | 0; + $3 = $2 + 12 | 0; + $4 = HEAP32[$3 >> 2] | 0; + $5 = $4; + $6 = $this + 52 | 0; + $7 = HEAP32[$6 >> 2] | 0; + $8 = $7 + 12 | 0; + $9 = HEAP32[$8 >> 2] | 0; + $10 = $9; + $11 = $collider_i; + __ZN12b2EPCollider7CollideEP10b2ManifoldPK11b2EdgeShapeRK11b2TransformPK14b2PolygonShapeS7_($collider_i, $manifold, $5, $xfA, $10, $xfB); + STACKTOP = __stackBase__; + return; } function _java_nio_charset_Charset_forNameInternal___java_lang_String($n1) { - $n1 = $n1 | 0; - var $_r0_sroa_0 = 0, $_r0_sroa_1 = 0, $_r1_sroa_0 = 0, $_r2_sroa_0 = 0, $_r3_sroa_0 = 0, $_r3_sroa_1 = 0, $_r5_sroa_0 = 0, $local_env_w4567aaac23b1b6 = 0; - var $local_env_w4567aaac23b1c16 = 0, $local_env_w4567aaac23b1c22 = 0, $local_env_w4567aaac23b1c24 = 0, $local_env_w4567aaac23b1c26 = 0, $local_env_w4567aaac23b1c29 = 0, $local_env_w4567aaac23b1c31 = 0, $local_env_w4567aaac23b1c35 = 0, $local_env_w4567aaac23b1c40 = 0; - var $local_env_w4567aaac23b1c42 = 0, $local_env_w4567aaac23b1c44 = 0, $local_env_w4567aaac23b1c48 = 0, $local_env_w4567aaac23b1c50 = 0, $1 = 0, $2 = 0, $5 = 0, $6 = 0; - var $7 = 0, $8 = 0, $11 = 0, $_r1_sroa_0_0_load601 = 0, $12 = 0, $13 = 0, $14 = 0, $16 = 0; - var $17$0 = 0, $17$1 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0, $23 = 0; - var $24 = 0, $25 = 0, $26 = 0, $28 = 0, $29 = 0, $31 = 0, $32 = 0, $_r0_sroa_0_0_load622 = 0; - var $33 = 0, $34 = 0, $35 = 0, $36 = 0, $37 = 0, $38 = 0, $_r0_sroa_0_0_load621 = 0, $39 = 0; - var $_r5_sroa_0_0_load592 = 0, $40 = 0, $41 = 0, $_r0_sroa_0_0_load620 = 0, $42 = 0, $_r0_sroa_0_0_load619 = 0, $43 = 0, $45 = 0; - var $46 = 0, $47 = 0, $50 = 0, $51 = 0, $52 = 0, $53 = 0, $55 = 0, $56 = 0; - var $57 = 0, $58 = 0, $59 = 0, $60 = 0, $61 = 0, $62 = 0, $64 = 0, $65 = 0; - var $66 = 0, $67 = 0, $68 = 0, $69 = 0, $70 = 0, $tib1_0_ph_i543 = 0, $71 = 0, $72 = 0; - var $73 = 0, $74 = 0, $tib1_0_lcssa_i546 = 0, $dimension_tib1_0_lcssa_i547 = 0, $75 = 0, $76 = 0, $77 = 0, $78 = 0; - var $79 = 0, $dimension_tib1_029_i549 = 0, $80 = 0, $81 = 0, $82 = 0, $83 = 0, $84 = 0, $85 = 0; - var $86 = 0, $87 = 0, $88 = 0, $dimension_tib2_024_i551 = 0, $89 = 0, $90 = 0, $91 = 0, $92 = 0; - var $93 = 0, $94 = 0, $95 = 0, $96 = 0, $tib2_0_lcssa_in_i553 = 0, $dimension_tib2_0_lcssa_i554 = 0, $tib2_0_lcssa_i555 = 0, $97 = 0; - var $98 = 0, $or_cond_i556 = 0, $tib1_121_i558 = 0, $99 = 0, $100 = 0, $101 = 0, $102 = 0, $i_0_i561 = 0; - var $104 = 0, $106 = 0, $107 = 0, $108 = 0, $109 = 0, $110 = 0, $112 = 0, $113 = 0; - var $114 = 0, $115 = 0, $116 = 0, $_r1_sroa_0_0_load600 = 0, $118 = 0, $119 = 0, $120 = 0, $121 = 0; - var $122 = 0, $123 = 0, $124 = 0, $125 = 0, $126 = 0, $127 = 0, $128 = 0, $129 = 0; - var $131 = 0, $132 = 0, $133 = 0, $134 = 0, $135 = 0, $136 = 0, $137 = 0, $138 = 0; - var $139 = 0, $140 = 0, $142 = 0, $_r0_sroa_0_0_load618 = 0, $143 = 0, $_r5_sroa_0_0_load591 = 0, $145 = 0, $146 = 0; - var $147 = 0, $149 = 0, $150$0 = 0, $150$1 = 0, $151 = 0, $153 = 0, $154 = 0, $155 = 0; - var $156 = 0, $157 = 0, $158 = 0, $159 = 0, $160 = 0, $163 = 0, $164 = 0, $165 = 0; - var $168 = 0, $169 = 0, $170 = 0, $171 = 0, $173 = 0, $174 = 0, $175 = 0, $176 = 0; - var $177 = 0, $178 = 0, $179 = 0, $180 = 0, $182 = 0, $183 = 0, $184 = 0, $185 = 0; - var $186 = 0, $187 = 0, $188 = 0, $tib1_0_ph_i521 = 0, $189 = 0, $190 = 0, $191 = 0, $192 = 0; - var $tib1_0_lcssa_i524 = 0, $dimension_tib1_0_lcssa_i525 = 0, $193 = 0, $194 = 0, $195 = 0, $196 = 0, $197 = 0, $dimension_tib1_029_i527 = 0; - var $198 = 0, $199 = 0, $200 = 0, $201 = 0, $202 = 0, $203 = 0, $204 = 0, $205 = 0; - var $206 = 0, $dimension_tib2_024_i529 = 0, $207 = 0, $208 = 0, $209 = 0, $210 = 0, $211 = 0, $212 = 0; - var $213 = 0, $214 = 0, $tib2_0_lcssa_in_i531 = 0, $dimension_tib2_0_lcssa_i532 = 0, $tib2_0_lcssa_i533 = 0, $215 = 0, $216 = 0, $or_cond_i534 = 0; - var $tib1_121_i536 = 0, $217 = 0, $218 = 0, $219 = 0, $220 = 0, $i_0_i539 = 0, $222 = 0, $224 = 0; - var $225 = 0, $226 = 0, $227 = 0, $228 = 0, $230 = 0, $231 = 0, $232 = 0, $233 = 0; - var $234 = 0, $235 = 0, $236 = 0, $238 = 0, $239$0 = 0, $239$1 = 0, $240 = 0, $241 = 0; - var $242 = 0, $243 = 0, $244 = 0, $_r1_sroa_0_0_load = 0, $245 = 0, $246 = 0, $247 = 0, $248 = 0; - var $249 = 0, $250 = 0, $251 = 0, $252 = 0, $253 = 0, $254 = 0, $255 = 0, $256 = 0; - var $258 = 0, $259 = 0, $260 = 0, $261 = 0, $262 = 0, $263 = 0, $264 = 0, $265 = 0; - var $266 = 0, $267 = 0, $269 = 0, $270 = 0, $271 = 0, $273 = 0, $274$0 = 0, $274$1 = 0; - var $275 = 0, $_r0_sroa_0_0_load617 = 0, $276 = 0, $277 = 0, $278 = 0, $279 = 0, $280 = 0, $281 = 0; - var $282 = 0, $284 = 0, $285 = 0, $286 = 0, $287 = 0, $288 = 0, $289 = 0, $290 = 0; - var $291 = 0, $_r5_sroa_0_0_load590 = 0, $293 = 0, $294 = 0, $296 = 0, $297 = 0, $_r0_sroa_0_0_load616 = 0, $298 = 0; - var $300 = 0, $302 = 0, $303 = 0, $305 = 0, $306 = 0, $307 = 0, $308 = 0, $_r0_sroa_0_0_load615 = 0; - var $309 = 0, $_r0_sroa_0_0_load614 = 0, $310 = 0, $311 = 0, $312 = 0, $314 = 0, $316 = 0, $317 = 0; - var $318 = 0, $321 = 0, $322 = 0, $323 = 0, $324 = 0, $326 = 0, $327 = 0, $328 = 0; - var $329 = 0, $330 = 0, $331 = 0, $332 = 0, $333 = 0, $335 = 0, $336 = 0, $337 = 0; - var $338 = 0, $339 = 0, $340 = 0, $341 = 0, $tib1_0_ph_i500 = 0, $342 = 0, $343 = 0, $344 = 0; - var $345 = 0, $tib1_0_lcssa_i503 = 0, $dimension_tib1_0_lcssa_i504 = 0, $346 = 0, $347 = 0, $348 = 0, $349 = 0, $350 = 0; - var $dimension_tib1_029_i506 = 0, $351 = 0, $352 = 0, $353 = 0, $354 = 0, $355 = 0, $356 = 0, $357 = 0; - var $358 = 0, $359 = 0, $dimension_tib2_024_i508 = 0, $360 = 0, $361 = 0, $362 = 0, $363 = 0, $364 = 0; - var $365 = 0, $366 = 0, $367 = 0, $tib2_0_lcssa_in_i510 = 0, $dimension_tib2_0_lcssa_i511 = 0, $tib2_0_lcssa_i512 = 0, $368 = 0, $369 = 0; - var $or_cond_i513 = 0, $tib1_121_i515 = 0, $370 = 0, $371 = 0, $372 = 0, $373 = 0, $i_0_i518 = 0, $375 = 0; - var $377 = 0, $378 = 0, $379 = 0, $380 = 0, $381 = 0, $383 = 0, $384 = 0, $385 = 0; - var $386 = 0, $387 = 0, $389 = 0, $390 = 0, $392 = 0, $393$0 = 0, $393$1 = 0, $394 = 0; - var $395 = 0, $396 = 0, $397 = 0, $398 = 0, $399 = 0, $400 = 0, $401 = 0, $402 = 0; - var $404 = 0, $405 = 0, $407 = 0, $408 = 0, $_r0_sroa_0_0_load613 = 0, $409 = 0, $410 = 0, $411 = 0; - var $412 = 0, $413 = 0, $414 = 0, $_r0_sroa_0_0_load612 = 0, $415 = 0, $_r5_sroa_0_0_load589 = 0, $416 = 0, $417 = 0; - var $_r0_sroa_0_0_load611 = 0, $418 = 0, $420 = 0, $421 = 0, $422 = 0, $424 = 0, $425$0 = 0, $425$1 = 0; - var $426 = 0, $427 = 0, $428 = 0, $429 = 0, $430 = 0, $431 = 0, $432 = 0, $433 = 0; - var $434 = 0, $_r0_sroa_0_0_load610 = 0, $436 = 0, $_r5_sroa_0_0_load588 = 0, $437 = 0, $439 = 0, $440 = 0, $441 = 0; - var $444 = 0, $445 = 0, $446 = 0, $447 = 0, $449 = 0, $450 = 0, $451 = 0, $452 = 0; - var $453 = 0, $454 = 0, $455 = 0, $456 = 0, $458 = 0, $459 = 0, $460 = 0, $461 = 0; - var $462 = 0, $463 = 0, $464 = 0, $tib1_0_ph_i479 = 0, $465 = 0, $466 = 0, $467 = 0, $468 = 0; - var $tib1_0_lcssa_i482 = 0, $dimension_tib1_0_lcssa_i483 = 0, $469 = 0, $470 = 0, $471 = 0, $472 = 0, $473 = 0, $dimension_tib1_029_i485 = 0; - var $474 = 0, $475 = 0, $476 = 0, $477 = 0, $478 = 0, $479 = 0, $480 = 0, $481 = 0; - var $482 = 0, $dimension_tib2_024_i487 = 0, $483 = 0, $484 = 0, $485 = 0, $486 = 0, $487 = 0, $488 = 0; - var $489 = 0, $490 = 0, $tib2_0_lcssa_in_i489 = 0, $dimension_tib2_0_lcssa_i490 = 0, $tib2_0_lcssa_i491 = 0, $491 = 0, $492 = 0, $or_cond_i492 = 0; - var $tib1_121_i494 = 0, $493 = 0, $494 = 0, $495 = 0, $496 = 0, $i_0_i497 = 0, $498 = 0, $500 = 0; - var $501 = 0, $502 = 0, $503 = 0, $504 = 0, $506 = 0, $507 = 0, $508 = 0, $509 = 0; - var $510 = 0, $512 = 0, $513 = 0, $516 = 0, $517 = 0, $519 = 0, $520$0 = 0, $520$1 = 0; - var $521 = 0, $522 = 0, $523 = 0, $525 = 0, $526 = 0, $527 = 0, $528 = 0, $529 = 0; - var $530 = 0, $531 = 0, $532 = 0, $_phi_trans_insert = 0, $_pre = 0, $534 = 0, $535 = 0, $536 = 0; - var $537 = 0, $538 = 0, $539 = 0, $540 = 0, $541 = 0, $_r2_sroa_0_0_load599 = 0, $542 = 0, $543 = 0; - var $544 = 0, $546 = 0, $547$0 = 0, $547$1 = 0, $548 = 0, $550 = 0, $551 = 0, $552 = 0; - var $555 = 0, $556 = 0, $557 = 0, $558 = 0, $560 = 0, $561 = 0, $562 = 0, $563 = 0; - var $564 = 0, $565 = 0, $566 = 0, $567 = 0, $569 = 0, $570 = 0, $571 = 0, $572 = 0; - var $573 = 0, $574 = 0, $575 = 0, $tib1_0_ph_i458 = 0, $576 = 0, $577 = 0, $578 = 0, $579 = 0; - var $tib1_0_lcssa_i461 = 0, $dimension_tib1_0_lcssa_i462 = 0, $580 = 0, $581 = 0, $582 = 0, $583 = 0, $584 = 0, $dimension_tib1_029_i464 = 0; - var $585 = 0, $586 = 0, $587 = 0, $588 = 0, $589 = 0, $590 = 0, $591 = 0, $592 = 0; - var $593 = 0, $dimension_tib2_024_i466 = 0, $594 = 0, $595 = 0, $596 = 0, $597 = 0, $598 = 0, $599 = 0; - var $600 = 0, $601 = 0, $tib2_0_lcssa_in_i468 = 0, $dimension_tib2_0_lcssa_i469 = 0, $tib2_0_lcssa_i470 = 0, $602 = 0, $603 = 0, $or_cond_i471 = 0; - var $tib1_121_i473 = 0, $604 = 0, $605 = 0, $606 = 0, $607 = 0, $i_0_i476 = 0, $609 = 0, $611 = 0; - var $612 = 0, $613 = 0, $614 = 0, $615 = 0, $617 = 0, $618 = 0, $619 = 0, $620 = 0; - var $621 = 0, $623 = 0, $624 = 0, $625 = 0, $626 = 0, $627 = 0, $628 = 0, $629 = 0; - var $630 = 0, $632 = 0, $633 = 0, $_r2_sroa_0_0_load598 = 0, $_r0_sroa_0_0_load609 = 0, $_r0_sroa_0_0_load624 = 0, $634 = 0, $_r0_sroa_1_4__r3_sroa_1_4_idx108_idx = 0; - var $_r0_sroa_1_4_idx = 0, $635 = 0, $637 = 0, $638 = 0, $639 = 0, $642 = 0, $643 = 0, $644 = 0; - var $645 = 0, $647 = 0, $648 = 0, $649 = 0, $650 = 0, $651 = 0, $652 = 0, $653 = 0; - var $654 = 0, $656 = 0, $657 = 0, $658 = 0, $659 = 0, $660 = 0, $661 = 0, $662 = 0; - var $tib1_0_ph_i437 = 0, $663 = 0, $664 = 0, $665 = 0, $666 = 0, $tib1_0_lcssa_i440 = 0, $dimension_tib1_0_lcssa_i441 = 0, $667 = 0; - var $668 = 0, $669 = 0, $670 = 0, $671 = 0, $dimension_tib1_029_i443 = 0, $672 = 0, $673 = 0, $674 = 0; - var $675 = 0, $676 = 0, $677 = 0, $678 = 0, $679 = 0, $680 = 0, $dimension_tib2_024_i445 = 0, $681 = 0; - var $682 = 0, $683 = 0, $684 = 0, $685 = 0, $686 = 0, $687 = 0, $688 = 0, $tib2_0_lcssa_in_i447 = 0; - var $dimension_tib2_0_lcssa_i448 = 0, $tib2_0_lcssa_i449 = 0, $689 = 0, $690 = 0, $or_cond_i450 = 0, $tib1_121_i452 = 0, $691 = 0, $692 = 0; - var $693 = 0, $694 = 0, $i_0_i455 = 0, $696 = 0, $698 = 0, $699 = 0, $700 = 0, $701 = 0; - var $702 = 0, $704 = 0, $705 = 0, $706 = 0, $707 = 0, $708 = 0, $711 = 0, $712 = 0; - var $714 = 0, $715 = 0, $716 = 0, $717 = 0, $718 = 0, $719 = 0, $720 = 0, $721 = 0; - var $723 = 0, $724 = 0, $725 = 0, $726 = 0, $727 = 0, $728 = 0, $729 = 0, $tib1_0_ph_i416 = 0; - var $730 = 0, $731 = 0, $732 = 0, $733 = 0, $tib1_0_lcssa_i419 = 0, $dimension_tib1_0_lcssa_i420 = 0, $734 = 0, $735 = 0; - var $736 = 0, $737 = 0, $738 = 0, $dimension_tib1_029_i422 = 0, $739 = 0, $740 = 0, $741 = 0, $742 = 0; - var $743 = 0, $744 = 0, $745 = 0, $746 = 0, $747 = 0, $dimension_tib2_024_i424 = 0, $748 = 0, $749 = 0; - var $750 = 0, $751 = 0, $752 = 0, $753 = 0, $754 = 0, $755 = 0, $tib2_0_lcssa_in_i426 = 0, $dimension_tib2_0_lcssa_i427 = 0; - var $tib2_0_lcssa_i428 = 0, $756 = 0, $757 = 0, $or_cond_i429 = 0, $tib1_121_i431 = 0, $758 = 0, $759 = 0, $760 = 0; - var $761 = 0, $i_0_i434 = 0, $763 = 0, $765 = 0, $766 = 0, $767 = 0, $768 = 0, $769 = 0; - var $771 = 0, $772 = 0, $773 = 0, $774 = 0, $775 = 0, $777 = 0, $778 = 0, $780 = 0; - var $781$0 = 0, $781$1 = 0, $782 = 0, $783 = 0, $784 = 0, $785 = 0, $786 = 0, $787 = 0; - var $788 = 0, $789 = 0, $790 = 0, $_r3_sroa_0_0_load596 = 0, $792 = 0, $793 = 0, $794 = 0, $795 = 0; - var $796 = 0, $797 = 0, $_r3_sroa_0_0_load595 = 0, $798 = 0, $799 = 0, $_r0_sroa_0_0_load608 = 0, $800 = 0, $802 = 0; - var $803 = 0, $804 = 0, $807 = 0, $808 = 0, $809 = 0, $810 = 0, $812 = 0, $813 = 0; - var $814 = 0, $815 = 0, $816 = 0, $817 = 0, $818 = 0, $819 = 0, $821 = 0, $822 = 0; - var $823 = 0, $824 = 0, $825 = 0, $826 = 0, $827 = 0, $tib1_0_ph_i395 = 0, $828 = 0, $829 = 0; - var $830 = 0, $831 = 0, $tib1_0_lcssa_i398 = 0, $dimension_tib1_0_lcssa_i399 = 0, $832 = 0, $833 = 0, $834 = 0, $835 = 0; - var $836 = 0, $dimension_tib1_029_i401 = 0, $837 = 0, $838 = 0, $839 = 0, $840 = 0, $841 = 0, $842 = 0; - var $843 = 0, $844 = 0, $845 = 0, $dimension_tib2_024_i403 = 0, $846 = 0, $847 = 0, $848 = 0, $849 = 0; - var $850 = 0, $851 = 0, $852 = 0, $853 = 0, $tib2_0_lcssa_in_i405 = 0, $dimension_tib2_0_lcssa_i406 = 0, $tib2_0_lcssa_i407 = 0, $854 = 0; - var $855 = 0, $or_cond_i408 = 0, $tib1_121_i410 = 0, $856 = 0, $857 = 0, $858 = 0, $859 = 0, $i_0_i413 = 0; - var $861 = 0, $863 = 0, $864 = 0, $865 = 0, $866 = 0, $867 = 0, $869 = 0, $870 = 0; - var $871 = 0, $872 = 0, $873 = 0, $876 = 0, $877 = 0, $879 = 0, $880 = 0, $881 = 0; - var $882 = 0, $883 = 0, $884 = 0, $885 = 0, $886 = 0, $888 = 0, $889 = 0, $890 = 0; - var $891 = 0, $892 = 0, $893 = 0, $894 = 0, $tib1_0_ph_i374 = 0, $895 = 0, $896 = 0, $897 = 0; - var $898 = 0, $tib1_0_lcssa_i377 = 0, $dimension_tib1_0_lcssa_i378 = 0, $899 = 0, $900 = 0, $901 = 0, $902 = 0, $903 = 0; - var $dimension_tib1_029_i380 = 0, $904 = 0, $905 = 0, $906 = 0, $907 = 0, $908 = 0, $909 = 0, $910 = 0; - var $911 = 0, $912 = 0, $dimension_tib2_024_i382 = 0, $913 = 0, $914 = 0, $915 = 0, $916 = 0, $917 = 0; - var $918 = 0, $919 = 0, $920 = 0, $tib2_0_lcssa_in_i384 = 0, $dimension_tib2_0_lcssa_i385 = 0, $tib2_0_lcssa_i386 = 0, $921 = 0, $922 = 0; - var $or_cond_i387 = 0, $tib1_121_i389 = 0, $923 = 0, $924 = 0, $925 = 0, $926 = 0, $i_0_i392 = 0, $928 = 0; - var $930 = 0, $931 = 0, $932 = 0, $933 = 0, $934 = 0, $936 = 0, $937 = 0, $938 = 0; - var $939 = 0, $940 = 0, $942 = 0, $943 = 0, $945 = 0, $946$0 = 0, $946$1 = 0, $947 = 0; - var $948 = 0, $949 = 0, $950 = 0, $951 = 0, $952 = 0, $953 = 0, $954 = 0, $955 = 0; - var $_r0_sroa_0_0_load607 = 0, $957 = 0, $958 = 0, $960 = 0, $962 = 0, $963 = 0, $964 = 0, $967 = 0; - var $968 = 0, $969 = 0, $970 = 0, $972 = 0, $973 = 0, $974 = 0, $975 = 0, $976 = 0; - var $977 = 0, $978 = 0, $979 = 0, $981 = 0, $982 = 0, $983 = 0, $984 = 0, $985 = 0; - var $986 = 0, $987 = 0, $tib1_0_ph_i353 = 0, $988 = 0, $989 = 0, $990 = 0, $991 = 0, $tib1_0_lcssa_i356 = 0; - var $dimension_tib1_0_lcssa_i357 = 0, $992 = 0, $993 = 0, $994 = 0, $995 = 0, $996 = 0, $dimension_tib1_029_i359 = 0, $997 = 0; - var $998 = 0, $999 = 0, $1000 = 0, $1001 = 0, $1002 = 0, $1003 = 0, $1004 = 0, $1005 = 0; - var $dimension_tib2_024_i361 = 0, $1006 = 0, $1007 = 0, $1008 = 0, $1009 = 0, $1010 = 0, $1011 = 0, $1012 = 0; - var $1013 = 0, $tib2_0_lcssa_in_i363 = 0, $dimension_tib2_0_lcssa_i364 = 0, $tib2_0_lcssa_i365 = 0, $1014 = 0, $1015 = 0, $or_cond_i366 = 0, $tib1_121_i368 = 0; - var $1016 = 0, $1017 = 0, $1018 = 0, $1019 = 0, $i_0_i371 = 0, $1021 = 0, $1023 = 0, $1024 = 0; - var $1025 = 0, $1026 = 0, $1027 = 0, $1029 = 0, $1030 = 0, $1031 = 0, $1032 = 0, $1033 = 0; - var $1036 = 0, $1037 = 0, $1038 = 0, $1039 = 0, $1040 = 0, $1041 = 0, $1042 = 0, $1043 = 0; - var $1045 = 0, $1046 = 0, $_pr = 0, $1048 = 0, $1050 = 0, $1051 = 0, $1053 = 0, $1054 = 0; - var $_pre855 = 0, $1056 = 0, $1057 = 0, $_r0_sroa_0_0_load606 = 0, $1058 = 0, $1060 = 0, $1061 = 0, $1062 = 0; - var $1064 = 0, $1065$0 = 0, $1065$1 = 0, $1066 = 0, $1067 = 0, $1068 = 0, $1069 = 0, $1070 = 0; - var $1071 = 0, $1072 = 0, $1073 = 0, $1074 = 0, $1077 = 0, $1078 = 0, $1079 = 0, $1082 = 0; - var $1083 = 0, $1084 = 0, $1085 = 0, $1087 = 0, $1088 = 0, $1089 = 0, $1090 = 0, $1091 = 0; - var $1092 = 0, $1093 = 0, $1094 = 0, $1096 = 0, $1097 = 0, $1098 = 0, $1099 = 0, $1100 = 0; - var $1101 = 0, $1102 = 0, $tib1_0_ph_i332 = 0, $1103 = 0, $1104 = 0, $1105 = 0, $1106 = 0, $tib1_0_lcssa_i335 = 0; - var $dimension_tib1_0_lcssa_i336 = 0, $1107 = 0, $1108 = 0, $1109 = 0, $1110 = 0, $1111 = 0, $dimension_tib1_029_i338 = 0, $1112 = 0; - var $1113 = 0, $1114 = 0, $1115 = 0, $1116 = 0, $1117 = 0, $1118 = 0, $1119 = 0, $1120 = 0; - var $dimension_tib2_024_i340 = 0, $1121 = 0, $1122 = 0, $1123 = 0, $1124 = 0, $1125 = 0, $1126 = 0, $1127 = 0; - var $1128 = 0, $tib2_0_lcssa_in_i342 = 0, $dimension_tib2_0_lcssa_i343 = 0, $tib2_0_lcssa_i344 = 0, $1129 = 0, $1130 = 0, $or_cond_i345 = 0, $tib1_121_i347 = 0; - var $1131 = 0, $1132 = 0, $1133 = 0, $1134 = 0, $i_0_i350 = 0, $1136 = 0, $1138 = 0, $1139 = 0; - var $1140 = 0, $1141 = 0, $1142 = 0, $1144 = 0, $1145 = 0, $1146 = 0, $1147 = 0, $1148 = 0; - var $1151 = 0, $1152 = 0, $1154 = 0, $1155 = 0, $1156 = 0, $1157 = 0, $1158 = 0, $1159 = 0; - var $1160 = 0, $1161 = 0, $1163 = 0, $1164 = 0, $1165 = 0, $1166 = 0, $1167 = 0, $1168 = 0; - var $1169 = 0, $tib1_0_ph_i311 = 0, $1170 = 0, $1171 = 0, $1172 = 0, $1173 = 0, $tib1_0_lcssa_i314 = 0, $dimension_tib1_0_lcssa_i315 = 0; - var $1174 = 0, $1175 = 0, $1176 = 0, $1177 = 0, $1178 = 0, $dimension_tib1_029_i317 = 0, $1179 = 0, $1180 = 0; - var $1181 = 0, $1182 = 0, $1183 = 0, $1184 = 0, $1185 = 0, $1186 = 0, $1187 = 0, $dimension_tib2_024_i319 = 0; - var $1188 = 0, $1189 = 0, $1190 = 0, $1191 = 0, $1192 = 0, $1193 = 0, $1194 = 0, $1195 = 0; - var $tib2_0_lcssa_in_i321 = 0, $dimension_tib2_0_lcssa_i322 = 0, $tib2_0_lcssa_i323 = 0, $1196 = 0, $1197 = 0, $or_cond_i324 = 0, $tib1_121_i326 = 0, $1198 = 0; - var $1199 = 0, $1200 = 0, $1201 = 0, $i_0_i329 = 0, $1203 = 0, $1205 = 0, $1206 = 0, $1207 = 0; - var $1208 = 0, $1209 = 0, $1211 = 0, $1212 = 0, $1213 = 0, $1214 = 0, $1215 = 0, $1217 = 0; - var $1218 = 0, $1220 = 0, $1221 = 0, $1222 = 0, $_r0_sroa_0_0_load605 = 0, $_r3_sroa_0_0_load594 = 0, $_r0_sroa_0_0_load623 = 0, $1223 = 0; - var $_r0_sroa_1_4__r3_sroa_1_4_idx_idx = 0, $_r0_sroa_1_4_idx156 = 0, $1224 = 0, $1226 = 0, $1227 = 0, $1228 = 0, $1231 = 0, $1232 = 0; - var $1233 = 0, $1234 = 0, $1236 = 0, $1237 = 0, $1238 = 0, $1239 = 0, $1240 = 0, $1241 = 0; - var $1242 = 0, $1243 = 0, $1245 = 0, $1246 = 0, $1247 = 0, $1248 = 0, $1249 = 0, $1250 = 0; - var $1251 = 0, $tib1_0_ph_i290 = 0, $1252 = 0, $1253 = 0, $1254 = 0, $1255 = 0, $tib1_0_lcssa_i293 = 0, $dimension_tib1_0_lcssa_i294 = 0; - var $1256 = 0, $1257 = 0, $1258 = 0, $1259 = 0, $1260 = 0, $dimension_tib1_029_i296 = 0, $1261 = 0, $1262 = 0; - var $1263 = 0, $1264 = 0, $1265 = 0, $1266 = 0, $1267 = 0, $1268 = 0, $1269 = 0, $dimension_tib2_024_i298 = 0; - var $1270 = 0, $1271 = 0, $1272 = 0, $1273 = 0, $1274 = 0, $1275 = 0, $1276 = 0, $1277 = 0; - var $tib2_0_lcssa_in_i300 = 0, $dimension_tib2_0_lcssa_i301 = 0, $tib2_0_lcssa_i302 = 0, $1278 = 0, $1279 = 0, $or_cond_i303 = 0, $tib1_121_i305 = 0, $1280 = 0; - var $1281 = 0, $1282 = 0, $1283 = 0, $i_0_i308 = 0, $1285 = 0, $1287 = 0, $1288 = 0, $1289 = 0; - var $1290 = 0, $1291 = 0, $1293 = 0, $1294 = 0, $1295 = 0, $1296 = 0, $1297 = 0, $1300 = 0; - var $1301 = 0, $1303 = 0, $1304 = 0, $1305 = 0, $1306 = 0, $1307 = 0, $1308 = 0, $1309 = 0; - var $1310 = 0, $1312 = 0, $1313 = 0, $1314 = 0, $1315 = 0, $1316 = 0, $1317 = 0, $1318 = 0; - var $tib1_0_ph_i269 = 0, $1319 = 0, $1320 = 0, $1321 = 0, $1322 = 0, $tib1_0_lcssa_i272 = 0, $dimension_tib1_0_lcssa_i273 = 0, $1323 = 0; - var $1324 = 0, $1325 = 0, $1326 = 0, $1327 = 0, $dimension_tib1_029_i275 = 0, $1328 = 0, $1329 = 0, $1330 = 0; - var $1331 = 0, $1332 = 0, $1333 = 0, $1334 = 0, $1335 = 0, $1336 = 0, $dimension_tib2_024_i277 = 0, $1337 = 0; - var $1338 = 0, $1339 = 0, $1340 = 0, $1341 = 0, $1342 = 0, $1343 = 0, $1344 = 0, $tib2_0_lcssa_in_i279 = 0; - var $dimension_tib2_0_lcssa_i280 = 0, $tib2_0_lcssa_i281 = 0, $1345 = 0, $1346 = 0, $or_cond_i282 = 0, $tib1_121_i284 = 0, $1347 = 0, $1348 = 0; - var $1349 = 0, $1350 = 0, $i_0_i287 = 0, $1352 = 0, $1354 = 0, $1355 = 0, $1356 = 0, $1357 = 0; - var $1358 = 0, $1360 = 0, $1361 = 0, $1362 = 0, $1363 = 0, $1364 = 0, $1366 = 0, $1367 = 0; - var $1369 = 0, $1370$0 = 0, $1370$1 = 0, $1371 = 0, $1372 = 0, $1373 = 0, $1374 = 0, $1375 = 0; - var $1376 = 0, $1377 = 0, $1378 = 0, $1379 = 0, $_r0_sroa_0_0_load604 = 0, $1381 = 0, $1382 = 0, $_r3_sroa_0_0_load593 = 0; - var $1384 = 0, $1385 = 0, $1386 = 0, $1387 = 0, $1388 = 0, $1389 = 0, $1390 = 0, $_r3_sroa_0_0_load = 0; - var $1391 = 0, $1392 = 0, $1394 = 0, $1395 = 0, $1396 = 0, $1399 = 0, $1400 = 0, $1401 = 0; - var $1402 = 0, $1404 = 0, $1405 = 0, $1406 = 0, $1407 = 0, $1408 = 0, $1409 = 0, $1410 = 0; - var $1411 = 0, $1413 = 0, $1414 = 0, $1415 = 0, $1416 = 0, $1417 = 0, $1418 = 0, $1419 = 0; - var $tib1_0_ph_i248 = 0, $1420 = 0, $1421 = 0, $1422 = 0, $1423 = 0, $tib1_0_lcssa_i251 = 0, $dimension_tib1_0_lcssa_i252 = 0, $1424 = 0; - var $1425 = 0, $1426 = 0, $1427 = 0, $1428 = 0, $dimension_tib1_029_i254 = 0, $1429 = 0, $1430 = 0, $1431 = 0; - var $1432 = 0, $1433 = 0, $1434 = 0, $1435 = 0, $1436 = 0, $1437 = 0, $dimension_tib2_024_i256 = 0, $1438 = 0; - var $1439 = 0, $1440 = 0, $1441 = 0, $1442 = 0, $1443 = 0, $1444 = 0, $1445 = 0, $tib2_0_lcssa_in_i258 = 0; - var $dimension_tib2_0_lcssa_i259 = 0, $tib2_0_lcssa_i260 = 0, $1446 = 0, $1447 = 0, $or_cond_i261 = 0, $tib1_121_i263 = 0, $1448 = 0, $1449 = 0; - var $1450 = 0, $1451 = 0, $i_0_i266 = 0, $1453 = 0, $1455 = 0, $1456 = 0, $1457 = 0, $1458 = 0; - var $1459 = 0, $1461 = 0, $1462 = 0, $1463 = 0, $1464 = 0, $1465 = 0, $1468 = 0, $1469 = 0; - var $1471 = 0, $1472 = 0, $1473 = 0, $1474 = 0, $1475 = 0, $1476 = 0, $1477 = 0, $1478 = 0; - var $1480 = 0, $1481 = 0, $1482 = 0, $1483 = 0, $1484 = 0, $1485 = 0, $1486 = 0, $tib1_0_ph_i227 = 0; - var $1487 = 0, $1488 = 0, $1489 = 0, $1490 = 0, $tib1_0_lcssa_i230 = 0, $dimension_tib1_0_lcssa_i231 = 0, $1491 = 0, $1492 = 0; - var $1493 = 0, $1494 = 0, $1495 = 0, $dimension_tib1_029_i233 = 0, $1496 = 0, $1497 = 0, $1498 = 0, $1499 = 0; - var $1500 = 0, $1501 = 0, $1502 = 0, $1503 = 0, $1504 = 0, $dimension_tib2_024_i235 = 0, $1505 = 0, $1506 = 0; - var $1507 = 0, $1508 = 0, $1509 = 0, $1510 = 0, $1511 = 0, $1512 = 0, $tib2_0_lcssa_in_i237 = 0, $dimension_tib2_0_lcssa_i238 = 0; - var $tib2_0_lcssa_i239 = 0, $1513 = 0, $1514 = 0, $or_cond_i240 = 0, $tib1_121_i242 = 0, $1515 = 0, $1516 = 0, $1517 = 0; - var $1518 = 0, $i_0_i245 = 0, $1520 = 0, $1522 = 0, $1523 = 0, $1524 = 0, $1525 = 0, $1526 = 0; - var $1528 = 0, $1529 = 0, $1530 = 0, $1531 = 0, $1532 = 0, $1533 = 0, $1534 = 0, $1536 = 0; - var $1537$0 = 0, $1537$1 = 0, $1538 = 0, $1539 = 0, $1540 = 0, $1541 = 0, $1542 = 0, $1543 = 0; - var $1544 = 0, $1545 = 0, $1546 = 0, $1548 = 0, $1549 = 0, $1551 = 0, $1552$0 = 0, $1552$1 = 0; - var $1553 = 0, $1554 = 0, $1555 = 0, $1556 = 0, $1557 = 0, $_r0_sroa_0_0_load602 = 0, $1558 = 0, $1559 = 0; - var $1561 = 0, $1563 = 0, $1564 = 0, $1565 = 0, $1568 = 0, $1569 = 0, $1570 = 0, $1571 = 0; - var $1573 = 0, $1574 = 0, $1575 = 0, $1576 = 0, $1577 = 0, $1578 = 0, $1579 = 0, $1580 = 0; - var $1582 = 0, $1583 = 0, $1584 = 0, $1585 = 0, $1586 = 0, $1587 = 0, $1588 = 0, $tib1_0_ph_i185 = 0; - var $1589 = 0, $1590 = 0, $1591 = 0, $1592 = 0, $tib1_0_lcssa_i188 = 0, $dimension_tib1_0_lcssa_i189 = 0, $1593 = 0, $1594 = 0; - var $1595 = 0, $1596 = 0, $1597 = 0, $dimension_tib1_029_i191 = 0, $1598 = 0, $1599 = 0, $1600 = 0, $1601 = 0; - var $1602 = 0, $1603 = 0, $1604 = 0, $1605 = 0, $1606 = 0, $dimension_tib2_024_i193 = 0, $1607 = 0, $1608 = 0; - var $1609 = 0, $1610 = 0, $1611 = 0, $1612 = 0, $1613 = 0, $1614 = 0, $tib2_0_lcssa_in_i195 = 0, $dimension_tib2_0_lcssa_i196 = 0; - var $tib2_0_lcssa_i197 = 0, $1615 = 0, $1616 = 0, $or_cond_i198 = 0, $tib1_121_i200 = 0, $1617 = 0, $1618 = 0, $1619 = 0; - var $1620 = 0, $i_0_i203 = 0, $1622 = 0, $1624 = 0, $1625 = 0, $1626 = 0, $1627 = 0, $1628 = 0; - var $1630 = 0, $1631 = 0, $1632 = 0, $1633 = 0, $1634 = 0, $1635 = 0, $1636 = 0, $1638 = 0; - var $1639$0 = 0, $1639$1 = 0, $1640 = 0, $1641 = 0, $1642 = 0, $1643 = 0, $1644 = 0, $1645 = 0; - var $1646 = 0, $1647 = 0, $1648 = 0, $1650 = 0, $1651 = 0, $1653 = 0, $1654$0 = 0, $1654$1 = 0; - var $1655 = 0, $1656 = 0, $1657 = 0, $1658 = 0, $1659 = 0, $_r2_sroa_0_0_load = 0, $1660 = 0, $1661 = 0; - var $1663 = 0, $1664 = 0, $1666 = 0, $1667$0 = 0, $1667$1 = 0, $1668 = 0, $_r0_sroa_0_0_load = 0, $1669 = 0; - var $1670 = 0, $1671 = 0, $1672 = 0, $1673 = 0, $1674 = 0, $1675 = 0, $1677 = 0, $1678 = 0; - var $1679 = 0, $1682 = 0, $1683 = 0, $1684 = 0, $1685 = 0, $1687 = 0, $1688 = 0, $1689 = 0; - var $1690 = 0, $1691 = 0, $1692 = 0, $1693 = 0, $1694 = 0, $1696 = 0, $1697 = 0, $1698 = 0; - var $1699 = 0, $1700 = 0, $1701 = 0, $1702 = 0, $tib1_0_ph_i = 0, $1703 = 0, $1704 = 0, $1705 = 0; - var $1706 = 0, $tib1_0_lcssa_i = 0, $dimension_tib1_0_lcssa_i = 0, $1707 = 0, $1708 = 0, $1709 = 0, $1710 = 0, $1711 = 0; - var $dimension_tib1_029_i = 0, $1712 = 0, $1713 = 0, $1714 = 0, $1715 = 0, $1716 = 0, $1717 = 0, $1718 = 0; - var $1719 = 0, $1720 = 0, $dimension_tib2_024_i = 0, $1721 = 0, $1722 = 0, $1723 = 0, $1724 = 0, $1725 = 0; - var $1726 = 0, $1727 = 0, $1728 = 0, $tib2_0_lcssa_in_i = 0, $dimension_tib2_0_lcssa_i = 0, $tib2_0_lcssa_i = 0, $1729 = 0, $1730 = 0; - var $or_cond_i = 0, $tib1_121_i = 0, $1731 = 0, $1732 = 0, $1733 = 0, $1734 = 0, $i_0_i = 0, $1736 = 0; - var $1738 = 0, $1739 = 0, $1740 = 0, $1741 = 0, $1742 = 0, $1744 = 0, $1745 = 0, $1746 = 0; - var $1747 = 0, $1748 = 0; - var label = 0; - var __stackBase__ = 0; - __stackBase__ = STACKTOP; - STACKTOP = STACKTOP + 536 | 0; - label = 1; - var setjmpLabel = 0; - var setjmpTable = STACKTOP; - STACKTOP = STACKTOP + 168 | 0; - HEAP32[setjmpTable >> 2] = 0; - while (1) switch (label | 0) { - case 1: - $_r0_sroa_1 = __stackBase__ | 0; - $_r3_sroa_1 = __stackBase__ + 8 | 0; - $local_env_w4567aaac23b1b6 = __stackBase__ + 16 | 0; - $local_env_w4567aaac23b1c16 = __stackBase__ + 56 | 0; - $local_env_w4567aaac23b1c22 = __stackBase__ + 96 | 0; - $local_env_w4567aaac23b1c24 = __stackBase__ + 136 | 0; - $local_env_w4567aaac23b1c26 = __stackBase__ + 176 | 0; - $local_env_w4567aaac23b1c29 = __stackBase__ + 216 | 0; - $local_env_w4567aaac23b1c31 = __stackBase__ + 256 | 0; - $local_env_w4567aaac23b1c35 = __stackBase__ + 296 | 0; - $local_env_w4567aaac23b1c40 = __stackBase__ + 336 | 0; - $local_env_w4567aaac23b1c42 = __stackBase__ + 376 | 0; - $local_env_w4567aaac23b1c44 = __stackBase__ + 416 | 0; - $local_env_w4567aaac23b1c48 = __stackBase__ + 456 | 0; - $local_env_w4567aaac23b1c50 = __stackBase__ + 496 | 0; - $1 = HEAP32[(98772 | 0) >> 2] | 0; - $2 = ($1 | 0) == 0; - if ($2) { - label = 2; - break; - } else { - label = 3; - break; - } - case 2: - invoke_v(702); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 3; - break; - case 3: - $_r5_sroa_0 = $n1; - $5 = invoke_ii(556, 709 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $6 = $5; - $_r0_sroa_0 = $6; - $7 = HEAP32[(98772 | 0) >> 2] | 0; - $8 = ($7 | 0) == 0; - if ($8) { - label = 4; - break; - } else { - label = 5; - break; - } - case 4: - invoke_v(702); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 5; - break; - case 5: - $11 = HEAP32[136048 >> 2] | 0; - $_r1_sroa_0 = $11; - $_r1_sroa_0_0_load601 = $_r1_sroa_0; - $12 = invoke_ii(202, $_r1_sroa_0_0_load601 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $13 = HEAP32[(105500 | 0) >> 2] | 0; - $14 = ($13 | 0) == 0; - if ($14) { - label = 6; - break; - } else { - label = 7; - break; - } - case 6: - invoke_v(30); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 7; - break; - case 7: - $16 = invoke_i(70) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $17$0 = $16; - $17$1 = 0; - $18 = invoke_iii(364, $17$0 | 0, $17$1 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $19 = $local_env_w4567aaac23b1b6; - $20 = $18 + 16 | 0; - $21 = $20; - $22 = HEAP32[$21 >> 2] | 0; - _memcpy($19 | 0, $22 | 0, 40); - $23 = HEAP32[$21 >> 2] | 0; - $24 = $23; - $25 = _saveSetjmp($24 | 0, label, setjmpTable) | 0; - label = 413; - break; - case 413: - $26 = ($25 | 0) == 0; - if ($26) { - label = 8; - break; - } else { - label = 11; - break; - } - case 8: - $28 = HEAP32[(98772 | 0) >> 2] | 0; - $29 = ($28 | 0) == 0; - if ($29) { - label = 9; - break; - } else { - label = 10; - break; - } - case 9: - invoke_v(702); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 10; - break; - case 10: - $31 = HEAP32[140056 >> 2] | 0; - $32 = $31; - $_r0_sroa_0 = $32; - $_r0_sroa_0_0_load622 = $_r0_sroa_0; - $33 = $_r0_sroa_0_0_load622; - $34 = $33 | 0; - $35 = HEAP32[$34 >> 2] | 0; - $36 = $35 + 160 | 0; - $37 = HEAP32[$36 >> 2] | 0; - $38 = $37; - $_r0_sroa_0_0_load621 = $_r0_sroa_0; - $39 = $_r0_sroa_0_0_load621; - $_r5_sroa_0_0_load592 = $_r5_sroa_0; - $40 = invoke_iii($38 | 0, $39 | 0, $_r5_sroa_0_0_load592 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $41 = $40; - $_r0_sroa_0 = $41; - $_r0_sroa_0_0_load620 = $_r0_sroa_0; - $_r0_sroa_0 = $_r0_sroa_0_0_load620; - $42 = HEAP32[$21 >> 2] | 0; - _memcpy($42 | 0, $19 | 0, 40); - $_r0_sroa_0_0_load619 = $_r0_sroa_0; - $43 = ($_r0_sroa_0_0_load619 | 0) == 0; - if ($43) { - label = 32; - break; - } else { - label = 28; - break; - } - case 11: - $45 = HEAP32[$21 >> 2] | 0; - _memcpy($45 | 0, $19 | 0, 40); - $46 = HEAP32[(107740 | 0) >> 2] | 0; - $47 = ($46 | 0) == 0; - if ($47) { - label = 12; - break; - } else { - label = 13; - break; - } - case 12: - invoke_v(374); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 13; - break; - case 13: - $50 = $18 + 20 | 0; - $51 = $50; - $52 = HEAP32[$51 >> 2] | 0; - $53 = ($52 | 0) == 0; - if ($53) { - label = 27; - break; - } else { - label = 14; - break; - } - case 14: - $55 = HEAP32[137616 >> 2] | 0; - $56 = $52; - $57 = HEAP32[$56 >> 2] | 0; - $58 = $57; - $59 = $55 + 8 | 0; - $60 = $59; - $61 = HEAP32[$60 >> 2] | 0; - $62 = ($57 | 0) == 82712; - if ($62) { - label = 15; - break; - } else { - $tib1_0_ph_i543 = $58; - label = 16; - break; - } - case 15: - $64 = $52 + 8 | 0; - $65 = $64; - $66 = HEAP32[$65 >> 2] | 0; - $67 = $66 + 8 | 0; - $68 = $67; - $69 = HEAP32[$68 >> 2] | 0; - $70 = $69; - $tib1_0_ph_i543 = $70; - label = 16; - break; - case 16: - $71 = $tib1_0_ph_i543 + 56 | 0; - $72 = HEAP32[$71 >> 2] | 0; - $73 = ($72 | 0) == 0; - if ($73) { - var $dimension_tib1_0_lcssa_i547 = 0; - var $tib1_0_lcssa_i546 = $tib1_0_ph_i543; - label = 18; - break; - } else { - var $dimension_tib1_029_i549 = 0; - var $79 = $72; - label = 19; - break; - } - case 17: - $74 = $82; - var $dimension_tib1_0_lcssa_i547 = $83; - var $tib1_0_lcssa_i546 = $74; - label = 18; - break; - case 18: - $75 = $61 + 56 | 0; - $76 = $75; - $77 = HEAP32[$76 >> 2] | 0; - $78 = ($77 | 0) == 0; - if ($78) { - var $dimension_tib2_0_lcssa_i554 = 0; - var $tib2_0_lcssa_in_i553 = $61; - label = 21; - break; - } else { - var $dimension_tib2_024_i551 = 0; - var $88 = $77; - label = 20; - break; - } - case 19: - $80 = $79 + 8 | 0; - $81 = $80; - $82 = HEAP32[$81 >> 2] | 0; - $83 = $dimension_tib1_029_i549 + 1 | 0; - $84 = $82 + 56 | 0; - $85 = $84; - $86 = HEAP32[$85 >> 2] | 0; - $87 = ($86 | 0) == 0; - if ($87) { - label = 17; - break; - } else { - var $dimension_tib1_029_i549 = $83; - var $79 = $86; - label = 19; - break; - } - case 20: - $89 = $88 + 8 | 0; - $90 = $89; - $91 = HEAP32[$90 >> 2] | 0; - $92 = $dimension_tib2_024_i551 + 1 | 0; - $93 = $91 + 56 | 0; - $94 = $93; - $95 = HEAP32[$94 >> 2] | 0; - $96 = ($95 | 0) == 0; - if ($96) { - var $dimension_tib2_0_lcssa_i554 = $92; - var $tib2_0_lcssa_in_i553 = $91; - label = 21; - break; - } else { - var $dimension_tib2_024_i551 = $92; - var $88 = $95; - label = 20; - break; - } - case 21: - $tib2_0_lcssa_i555 = $tib2_0_lcssa_in_i553; - $97 = ($dimension_tib1_0_lcssa_i547 | 0) < ($dimension_tib2_0_lcssa_i554 | 0); - $98 = ($tib1_0_lcssa_i546 | 0) == 0; - $or_cond_i556 = $97 | $98; - if ($or_cond_i556) { - label = 27; - break; - } else { - $tib1_121_i558 = $tib1_0_lcssa_i546; - label = 22; - break; - } - case 22: - $99 = ($tib1_121_i558 | 0) == ($tib2_0_lcssa_i555 | 0); - if ($99) { - label = 54; - break; - } else { - label = 23; - break; - } - case 23: - $100 = $tib1_121_i558 + 108 | 0; - $101 = HEAP32[$100 >> 2] | 0; - $102 = $tib1_121_i558 + 112 | 0; - $i_0_i561 = 0; - label = 24; - break; - case 24: - $104 = ($i_0_i561 | 0) < ($101 | 0); - if ($104) { - label = 25; - break; - } else { - label = 26; - break; - } - case 25: - $106 = HEAP32[$102 >> 2] | 0; - $107 = $106 + ($i_0_i561 << 2) | 0; - $108 = HEAP32[$107 >> 2] | 0; - $109 = ($108 | 0) == ($tib2_0_lcssa_i555 | 0); - $110 = $i_0_i561 + 1 | 0; - if ($109) { - label = 54; - break; - } else { - $i_0_i561 = $110; - label = 24; - break; - } - case 26: - $112 = $tib1_121_i558 + 40 | 0; - $113 = HEAP32[$112 >> 2] | 0; - $114 = ($113 | 0) == 0; - if ($114) { - label = 27; - break; - } else { - $tib1_121_i558 = $113; - label = 22; - break; - } - case 27: - $115 = HEAP32[$21 >> 2] | 0; - $116 = $115; - invoke_vii(48, $116 | 0, 0 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case 28: - $_r1_sroa_0_0_load600 = $_r1_sroa_0; - $118 = $_r1_sroa_0_0_load600 + 4 | 0; - $119 = $118; - $120 = HEAP32[$119 >> 2] | 0; - $121 = $120 + 8 | 0; - $122 = $121; - $123 = HEAP32[$122 >> 2] | 0; - $124 = $123 - 1 | 0; - HEAP32[$122 >> 2] = $124; - $125 = HEAP32[$119 >> 2] | 0; - $126 = $125 + 8 | 0; - $127 = $126; - $128 = HEAP32[$127 >> 2] | 0; - $129 = ($128 | 0) == 0; - if ($129) { - label = 29; - break; - } else { - label = 31; - break; - } - case 29: - invoke_vi(28, $_r1_sroa_0_0_load600 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $131 = HEAP32[$119 >> 2] | 0; - $132 = $131 + 16 | 0; - $133 = $132; - $134 = HEAP32[$133 >> 2] | 0; - $135 = $134 + 8 | 0; - $136 = $135; - $137 = HEAP32[$136 >> 2] | 0; - $138 = $137; - $139; - $140 = ($139 | 0) == 0; - if ($140) { - label = 31; - break; - } else { - label = 30; - break; - } - case 30: - $142 = invoke_iii(268, 31e3 | 0 | 0, (tempInt = STACKTOP, STACKTOP = STACKTOP + 8 | 0, HEAP32[tempInt >> 2] = $139, tempInt) | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 31; - break; - case 31: - $_r0_sroa_0_0_load618 = $_r0_sroa_0; - $143 = $_r0_sroa_0_0_load618; - STACKTOP = __stackBase__; - return $143 | 0; - case 32: - $_r5_sroa_0_0_load591 = $_r5_sroa_0; - $145 = ($_r5_sroa_0_0_load591 | 0) == 0; - $146 = HEAP32[(105500 | 0) >> 2] | 0; - $147 = ($146 | 0) == 0; - if ($147) { - label = 33; - break; - } else { - label = 34; - break; - } - case 33: - invoke_v(30); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 34; - break; - case 34: - $149 = invoke_i(70) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $150$0 = $149; - $150$1 = 0; - $151 = invoke_iii(364, $150$0 | 0, $150$1 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - if ($145) { - label = 35; - break; - } else { - label = 62; - break; - } - case 35: - $153 = $local_env_w4567aaac23b1c16; - $154 = $151 + 16 | 0; - $155 = $154; - $156 = HEAP32[$155 >> 2] | 0; - _memcpy($153 | 0, $156 | 0, 40); - $157 = HEAP32[$155 >> 2] | 0; - $158 = $157; - $159 = _saveSetjmp($158 | 0, label, setjmpTable) | 0; - label = 414; - break; - case 414: - $160 = ($159 | 0) == 0; - if ($160) { - label = 36; - break; - } else { - label = 37; - break; - } - case 36: - invoke_viiii(14, 16136 | 0 | 0, 11648 | 0 | 0, 126872 | 0 | 0, 1457 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case 37: - $163 = HEAP32[$155 >> 2] | 0; - _memcpy($163 | 0, $153 | 0, 40); - $164 = HEAP32[(107740 | 0) >> 2] | 0; - $165 = ($164 | 0) == 0; - if ($165) { - label = 38; - break; - } else { - label = 39; - break; - } - case 38: - invoke_v(374); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 39; - break; - case 39: - $168 = $151 + 20 | 0; - $169 = $168; - $170 = HEAP32[$169 >> 2] | 0; - $171 = ($170 | 0) == 0; - if ($171) { - label = 53; - break; - } else { - label = 40; - break; - } - case 40: - $173 = HEAP32[137616 >> 2] | 0; - $174 = $170; - $175 = HEAP32[$174 >> 2] | 0; - $176 = $175; - $177 = $173 + 8 | 0; - $178 = $177; - $179 = HEAP32[$178 >> 2] | 0; - $180 = ($175 | 0) == 82712; - if ($180) { - label = 41; - break; - } else { - $tib1_0_ph_i521 = $176; - label = 42; - break; - } - case 41: - $182 = $170 + 8 | 0; - $183 = $182; - $184 = HEAP32[$183 >> 2] | 0; - $185 = $184 + 8 | 0; - $186 = $185; - $187 = HEAP32[$186 >> 2] | 0; - $188 = $187; - $tib1_0_ph_i521 = $188; - label = 42; - break; - case 42: - $189 = $tib1_0_ph_i521 + 56 | 0; - $190 = HEAP32[$189 >> 2] | 0; - $191 = ($190 | 0) == 0; - if ($191) { - var $dimension_tib1_0_lcssa_i525 = 0; - var $tib1_0_lcssa_i524 = $tib1_0_ph_i521; - label = 44; - break; - } else { - var $dimension_tib1_029_i527 = 0; - var $197 = $190; - label = 45; - break; - } - case 43: - $192 = $200; - var $dimension_tib1_0_lcssa_i525 = $201; - var $tib1_0_lcssa_i524 = $192; - label = 44; - break; - case 44: - $193 = $179 + 56 | 0; - $194 = $193; - $195 = HEAP32[$194 >> 2] | 0; - $196 = ($195 | 0) == 0; - if ($196) { - var $dimension_tib2_0_lcssa_i532 = 0; - var $tib2_0_lcssa_in_i531 = $179; - label = 47; - break; - } else { - var $dimension_tib2_024_i529 = 0; - var $206 = $195; - label = 46; - break; - } - case 45: - $198 = $197 + 8 | 0; - $199 = $198; - $200 = HEAP32[$199 >> 2] | 0; - $201 = $dimension_tib1_029_i527 + 1 | 0; - $202 = $200 + 56 | 0; - $203 = $202; - $204 = HEAP32[$203 >> 2] | 0; - $205 = ($204 | 0) == 0; - if ($205) { - label = 43; - break; - } else { - var $dimension_tib1_029_i527 = $201; - var $197 = $204; - label = 45; - break; - } - case 46: - $207 = $206 + 8 | 0; - $208 = $207; - $209 = HEAP32[$208 >> 2] | 0; - $210 = $dimension_tib2_024_i529 + 1 | 0; - $211 = $209 + 56 | 0; - $212 = $211; - $213 = HEAP32[$212 >> 2] | 0; - $214 = ($213 | 0) == 0; - if ($214) { - var $dimension_tib2_0_lcssa_i532 = $210; - var $tib2_0_lcssa_in_i531 = $209; - label = 47; - break; - } else { - var $dimension_tib2_024_i529 = $210; - var $206 = $213; - label = 46; - break; - } - case 47: - $tib2_0_lcssa_i533 = $tib2_0_lcssa_in_i531; - $215 = ($dimension_tib1_0_lcssa_i525 | 0) < ($dimension_tib2_0_lcssa_i532 | 0); - $216 = ($tib1_0_lcssa_i524 | 0) == 0; - $or_cond_i534 = $215 | $216; - if ($or_cond_i534) { - label = 53; - break; - } else { - $tib1_121_i536 = $tib1_0_lcssa_i524; - label = 48; - break; - } - case 48: - $217 = ($tib1_121_i536 | 0) == ($tib2_0_lcssa_i533 | 0); - if ($217) { - label = 54; - break; - } else { - label = 49; - break; - } - case 49: - $218 = $tib1_121_i536 + 108 | 0; - $219 = HEAP32[$218 >> 2] | 0; - $220 = $tib1_121_i536 + 112 | 0; - $i_0_i539 = 0; - label = 50; - break; - case 50: - $222 = ($i_0_i539 | 0) < ($219 | 0); - if ($222) { - label = 51; - break; - } else { - label = 52; - break; - } - case 51: - $224 = HEAP32[$220 >> 2] | 0; - $225 = $224 + ($i_0_i539 << 2) | 0; - $226 = HEAP32[$225 >> 2] | 0; - $227 = ($226 | 0) == ($tib2_0_lcssa_i533 | 0); - $228 = $i_0_i539 + 1 | 0; - if ($227) { - label = 54; - break; - } else { - $i_0_i539 = $228; - label = 50; - break; - } - case 52: - $230 = $tib1_121_i536 + 40 | 0; - $231 = HEAP32[$230 >> 2] | 0; - $232 = ($231 | 0) == 0; - if ($232) { - label = 53; - break; - } else { - $tib1_121_i536 = $231; - label = 48; - break; - } - case 53: - $233 = HEAP32[$155 >> 2] | 0; - $234 = $233; - invoke_vii(48, $234 | 0, 0 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case 54: - $235 = HEAP32[(105500 | 0) >> 2] | 0; - $236 = ($235 | 0) == 0; - if ($236) { - label = 55; - break; - } else { - label = 56; - break; - } - case 55: - invoke_v(30); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 56; - break; - case 56: - $238 = invoke_i(70) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $239$0 = $238; - $239$1 = 0; - $240 = invoke_iii(364, $239$0 | 0, $239$1 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $241 = $240 + 20 | 0; - $242 = $241; - $243 = HEAP32[$242 >> 2] | 0; - $244 = $243; - $_r0_sroa_0 = $244; - $_r1_sroa_0_0_load = $_r1_sroa_0; - $245 = $_r1_sroa_0_0_load + 4 | 0; - $246 = $245; - $247 = HEAP32[$246 >> 2] | 0; - $248 = $247 + 8 | 0; - $249 = $248; - $250 = HEAP32[$249 >> 2] | 0; - $251 = $250 - 1 | 0; - HEAP32[$249 >> 2] = $251; - $252 = HEAP32[$246 >> 2] | 0; - $253 = $252 + 8 | 0; - $254 = $253; - $255 = HEAP32[$254 >> 2] | 0; - $256 = ($255 | 0) == 0; - if ($256) { - label = 57; - break; - } else { - label = 59; - break; - } - case 57: - invoke_vi(28, $_r1_sroa_0_0_load | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $258 = HEAP32[$246 >> 2] | 0; - $259 = $258 + 16 | 0; - $260 = $259; - $261 = HEAP32[$260 >> 2] | 0; - $262 = $261 + 8 | 0; - $263 = $262; - $264 = HEAP32[$263 >> 2] | 0; - $265 = $264; - $266; - $267 = ($266 | 0) == 0; - if ($267) { - label = 59; - break; - } else { - label = 58; - break; - } - case 58: - $269 = invoke_iii(268, 31e3 | 0 | 0, (tempInt = STACKTOP, STACKTOP = STACKTOP + 8 | 0, HEAP32[tempInt >> 2] = $266, tempInt) | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 59; - break; - case 59: - $270 = HEAP32[(105500 | 0) >> 2] | 0; - $271 = ($270 | 0) == 0; - if ($271) { - label = 60; - break; - } else { - label = 61; - break; - } - case 60: - invoke_v(30); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 61; - break; - case 61: - $273 = invoke_i(70) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $274$0 = $273; - $274$1 = 0; - $275 = invoke_iii(364, $274$0 | 0, $274$1 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $_r0_sroa_0_0_load617 = $_r0_sroa_0; - $276 = $_r0_sroa_0_0_load617; - $277 = $275 + 16 | 0; - $278 = $275 + 20 | 0; - $279 = $278; - HEAP32[$279 >> 2] = $276; - $280 = $277; - $281 = HEAP32[$280 >> 2] | 0; - $282 = $281; - invoke_vii(48, $282 | 0, 0 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case 62: - $284 = $local_env_w4567aaac23b1c22; - $285 = $151 + 16 | 0; - $286 = $285; - $287 = HEAP32[$286 >> 2] | 0; - _memcpy($284 | 0, $287 | 0, 40); - $288 = HEAP32[$286 >> 2] | 0; - $289 = $288; - $290 = _saveSetjmp($289 | 0, label, setjmpTable) | 0; - label = 415; - break; - case 415: - $291 = ($290 | 0) == 0; - if ($291) { - label = 63; - break; - } else { - label = 72; - break; - } - case 63: - $_r5_sroa_0_0_load590 = $_r5_sroa_0; - invoke_vi(44, $_r5_sroa_0_0_load590 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $293 = HEAP32[(98772 | 0) >> 2] | 0; - $294 = ($293 | 0) == 0; - if ($294) { - label = 64; - break; - } else { - label = 65; - break; - } - case 64: - invoke_v(702); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 65; - break; - case 65: - $296 = HEAP32[140064 >> 2] | 0; - $297 = $296; - $_r0_sroa_0 = $297; - $_r0_sroa_0_0_load616 = $_r0_sroa_0; - $298 = ($_r0_sroa_0_0_load616 | 0) == 0; - if ($298) { - label = 67; - break; - } else { - label = 66; - break; - } - case 66: - $300 = HEAP32[$286 >> 2] | 0; - _memcpy($300 | 0, $284 | 0, 40); - label = 89; - break; - case 67: - $302 = HEAP32[(84292 | 0) >> 2] | 0; - $303 = ($302 | 0) == 0; - if ($303) { - label = 68; - break; - } else { - label = 69; - break; - } - case 68: - invoke_v(584); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 69; - break; - case 69: - $305 = invoke_ii(338, 20 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $306 = $305; - HEAP32[$306 >> 2] = 84288; - $307 = $305 + 4 | 0; - _memset($307 | 0 | 0, 0 | 0 | 0, 16 | 0 | 0); - $308 = $305; - $_r0_sroa_0 = $308; - $_r0_sroa_0_0_load615 = $_r0_sroa_0; - $309 = $_r0_sroa_0_0_load615; - invoke_vi(34, $309 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $_r0_sroa_0_0_load614 = $_r0_sroa_0; - $310 = $_r0_sroa_0_0_load614; - $311 = HEAP32[(98772 | 0) >> 2] | 0; - $312 = ($311 | 0) == 0; - if ($312) { - label = 70; - break; - } else { - label = 71; - break; - } - case 70: - invoke_v(702); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 71; - break; - case 71: - HEAP32[140064 >> 2] = $310; - $314 = HEAP32[$286 >> 2] | 0; - _memcpy($314 | 0, $284 | 0, 40); - label = 89; - break; - case 72: - $316 = HEAP32[$286 >> 2] | 0; - _memcpy($316 | 0, $284 | 0, 40); - $317 = HEAP32[(107740 | 0) >> 2] | 0; - $318 = ($317 | 0) == 0; - if ($318) { - label = 73; - break; - } else { - label = 74; - break; - } - case 73: - invoke_v(374); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 74; - break; - case 74: - $321 = $151 + 20 | 0; - $322 = $321; - $323 = HEAP32[$322 >> 2] | 0; - $324 = ($323 | 0) == 0; - if ($324) { - label = 88; - break; - } else { - label = 75; - break; - } - case 75: - $326 = HEAP32[137616 >> 2] | 0; - $327 = $323; - $328 = HEAP32[$327 >> 2] | 0; - $329 = $328; - $330 = $326 + 8 | 0; - $331 = $330; - $332 = HEAP32[$331 >> 2] | 0; - $333 = ($328 | 0) == 82712; - if ($333) { - label = 76; - break; - } else { - $tib1_0_ph_i500 = $329; - label = 77; - break; - } - case 76: - $335 = $323 + 8 | 0; - $336 = $335; - $337 = HEAP32[$336 >> 2] | 0; - $338 = $337 + 8 | 0; - $339 = $338; - $340 = HEAP32[$339 >> 2] | 0; - $341 = $340; - $tib1_0_ph_i500 = $341; - label = 77; - break; - case 77: - $342 = $tib1_0_ph_i500 + 56 | 0; - $343 = HEAP32[$342 >> 2] | 0; - $344 = ($343 | 0) == 0; - if ($344) { - var $dimension_tib1_0_lcssa_i504 = 0; - var $tib1_0_lcssa_i503 = $tib1_0_ph_i500; - label = 79; - break; - } else { - var $dimension_tib1_029_i506 = 0; - var $350 = $343; - label = 80; - break; - } - case 78: - $345 = $353; - var $dimension_tib1_0_lcssa_i504 = $354; - var $tib1_0_lcssa_i503 = $345; - label = 79; - break; - case 79: - $346 = $332 + 56 | 0; - $347 = $346; - $348 = HEAP32[$347 >> 2] | 0; - $349 = ($348 | 0) == 0; - if ($349) { - var $dimension_tib2_0_lcssa_i511 = 0; - var $tib2_0_lcssa_in_i510 = $332; - label = 82; - break; - } else { - var $dimension_tib2_024_i508 = 0; - var $359 = $348; - label = 81; - break; - } - case 80: - $351 = $350 + 8 | 0; - $352 = $351; - $353 = HEAP32[$352 >> 2] | 0; - $354 = $dimension_tib1_029_i506 + 1 | 0; - $355 = $353 + 56 | 0; - $356 = $355; - $357 = HEAP32[$356 >> 2] | 0; - $358 = ($357 | 0) == 0; - if ($358) { - label = 78; - break; - } else { - var $dimension_tib1_029_i506 = $354; - var $350 = $357; - label = 80; - break; - } - case 81: - $360 = $359 + 8 | 0; - $361 = $360; - $362 = HEAP32[$361 >> 2] | 0; - $363 = $dimension_tib2_024_i508 + 1 | 0; - $364 = $362 + 56 | 0; - $365 = $364; - $366 = HEAP32[$365 >> 2] | 0; - $367 = ($366 | 0) == 0; - if ($367) { - var $dimension_tib2_0_lcssa_i511 = $363; - var $tib2_0_lcssa_in_i510 = $362; - label = 82; - break; - } else { - var $dimension_tib2_024_i508 = $363; - var $359 = $366; - label = 81; - break; - } - case 82: - $tib2_0_lcssa_i512 = $tib2_0_lcssa_in_i510; - $368 = ($dimension_tib1_0_lcssa_i504 | 0) < ($dimension_tib2_0_lcssa_i511 | 0); - $369 = ($tib1_0_lcssa_i503 | 0) == 0; - $or_cond_i513 = $368 | $369; - if ($or_cond_i513) { - label = 88; - break; - } else { - $tib1_121_i515 = $tib1_0_lcssa_i503; - label = 83; - break; - } - case 83: - $370 = ($tib1_121_i515 | 0) == ($tib2_0_lcssa_i512 | 0); - if ($370) { - label = 54; - break; - } else { - label = 84; - break; - } - case 84: - $371 = $tib1_121_i515 + 108 | 0; - $372 = HEAP32[$371 >> 2] | 0; - $373 = $tib1_121_i515 + 112 | 0; - $i_0_i518 = 0; - label = 85; - break; - case 85: - $375 = ($i_0_i518 | 0) < ($372 | 0); - if ($375) { - label = 86; - break; - } else { - label = 87; - break; - } - case 86: - $377 = HEAP32[$373 >> 2] | 0; - $378 = $377 + ($i_0_i518 << 2) | 0; - $379 = HEAP32[$378 >> 2] | 0; - $380 = ($379 | 0) == ($tib2_0_lcssa_i512 | 0); - $381 = $i_0_i518 + 1 | 0; - if ($380) { - label = 54; - break; - } else { - $i_0_i518 = $381; - label = 85; - break; - } - case 87: - $383 = $tib1_121_i515 + 40 | 0; - $384 = HEAP32[$383 >> 2] | 0; - $385 = ($384 | 0) == 0; - if ($385) { - label = 88; - break; - } else { - $tib1_121_i515 = $384; - label = 83; - break; - } - case 88: - $386 = HEAP32[$286 >> 2] | 0; - $387 = $386; - invoke_vii(48, $387 | 0, 0 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case 89: - $389 = HEAP32[(105500 | 0) >> 2] | 0; - $390 = ($389 | 0) == 0; - if ($390) { - label = 90; - break; - } else { - label = 91; - break; - } - case 90: - invoke_v(30); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 91; - break; - case 91: - $392 = invoke_i(70) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $393$0 = $392; - $393$1 = 0; - $394 = invoke_iii(364, $393$0 | 0, $393$1 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $395 = $local_env_w4567aaac23b1c24; - $396 = $394 + 16 | 0; - $397 = $396; - $398 = HEAP32[$397 >> 2] | 0; - _memcpy($395 | 0, $398 | 0, 40); - $399 = HEAP32[$397 >> 2] | 0; - $400 = $399; - $401 = _saveSetjmp($400 | 0, label, setjmpTable) | 0; - label = 416; - break; - case 416: - $402 = ($401 | 0) == 0; - if ($402) { - label = 92; - break; - } else { - label = 99; - break; - } - case 92: - $404 = HEAP32[(98772 | 0) >> 2] | 0; - $405 = ($404 | 0) == 0; - if ($405) { - label = 93; - break; - } else { - label = 94; - break; - } - case 93: - invoke_v(702); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 94; - break; - case 94: - $407 = HEAP32[140064 >> 2] | 0; - $408 = $407; - $_r0_sroa_0 = $408; - $_r0_sroa_0_0_load613 = $_r0_sroa_0; - $409 = $_r0_sroa_0_0_load613; - $410 = $409 | 0; - $411 = HEAP32[$410 >> 2] | 0; - $412 = $411 + 144 | 0; - $413 = HEAP32[$412 >> 2] | 0; - $414 = $413; - $_r0_sroa_0_0_load612 = $_r0_sroa_0; - $415 = $_r0_sroa_0_0_load612; - $_r5_sroa_0_0_load589 = $_r5_sroa_0; - $416 = invoke_iii($414 | 0, $415 | 0, $_r5_sroa_0_0_load589 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $417 = $416; - $_r0_sroa_0 = $417; - $_r0_sroa_0_0_load611 = $_r0_sroa_0; - $418 = ($_r0_sroa_0_0_load611 | 0) == 0; - if ($418) { - label = 95; - break; - } else { - label = 98; - break; - } - case 95: - $420 = HEAP32[$397 >> 2] | 0; - _memcpy($420 | 0, $395 | 0, 40); - $421 = HEAP32[(105500 | 0) >> 2] | 0; - $422 = ($421 | 0) == 0; - if ($422) { - label = 96; - break; - } else { - label = 97; - break; - } - case 96: - invoke_v(30); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 97; - break; - case 97: - $424 = invoke_i(70) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $425$0 = $424; - $425$1 = 0; - $426 = invoke_iii(364, $425$0 | 0, $425$1 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $427 = $local_env_w4567aaac23b1c26; - $428 = $426 + 16 | 0; - $429 = $428; - $430 = HEAP32[$429 >> 2] | 0; - _memcpy($427 | 0, $430 | 0, 40); - $431 = HEAP32[$429 >> 2] | 0; - $432 = $431; - $433 = _saveSetjmp($432 | 0, label, setjmpTable) | 0; - label = 417; - break; - case 417: - $434 = ($433 | 0) == 0; - if ($434) { - label = 116; - break; - } else { - label = 127; - break; - } - case 98: - $_r0_sroa_0_0_load610 = $_r0_sroa_0; - $436 = $_r0_sroa_0_0_load610; - $_r5_sroa_0_0_load588 = $_r5_sroa_0; - invoke_vii(24, $436 | 0, $_r5_sroa_0_0_load588 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $437 = HEAP32[$397 >> 2] | 0; - _memcpy($437 | 0, $395 | 0, 40); - label = 28; - break; - case 99: - $439 = HEAP32[$397 >> 2] | 0; - _memcpy($439 | 0, $395 | 0, 40); - $440 = HEAP32[(107740 | 0) >> 2] | 0; - $441 = ($440 | 0) == 0; - if ($441) { - label = 100; - break; - } else { - label = 101; - break; - } - case 100: - invoke_v(374); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 101; - break; - case 101: - $444 = $394 + 20 | 0; - $445 = $444; - $446 = HEAP32[$445 >> 2] | 0; - $447 = ($446 | 0) == 0; - if ($447) { - label = 115; - break; - } else { - label = 102; - break; - } - case 102: - $449 = HEAP32[137616 >> 2] | 0; - $450 = $446; - $451 = HEAP32[$450 >> 2] | 0; - $452 = $451; - $453 = $449 + 8 | 0; - $454 = $453; - $455 = HEAP32[$454 >> 2] | 0; - $456 = ($451 | 0) == 82712; - if ($456) { - label = 103; - break; - } else { - $tib1_0_ph_i479 = $452; - label = 104; - break; - } - case 103: - $458 = $446 + 8 | 0; - $459 = $458; - $460 = HEAP32[$459 >> 2] | 0; - $461 = $460 + 8 | 0; - $462 = $461; - $463 = HEAP32[$462 >> 2] | 0; - $464 = $463; - $tib1_0_ph_i479 = $464; - label = 104; - break; - case 104: - $465 = $tib1_0_ph_i479 + 56 | 0; - $466 = HEAP32[$465 >> 2] | 0; - $467 = ($466 | 0) == 0; - if ($467) { - var $dimension_tib1_0_lcssa_i483 = 0; - var $tib1_0_lcssa_i482 = $tib1_0_ph_i479; - label = 106; - break; - } else { - var $dimension_tib1_029_i485 = 0; - var $473 = $466; - label = 107; - break; - } - case 105: - $468 = $476; - var $dimension_tib1_0_lcssa_i483 = $477; - var $tib1_0_lcssa_i482 = $468; - label = 106; - break; - case 106: - $469 = $455 + 56 | 0; - $470 = $469; - $471 = HEAP32[$470 >> 2] | 0; - $472 = ($471 | 0) == 0; - if ($472) { - var $dimension_tib2_0_lcssa_i490 = 0; - var $tib2_0_lcssa_in_i489 = $455; - label = 109; - break; - } else { - var $dimension_tib2_024_i487 = 0; - var $482 = $471; - label = 108; - break; - } - case 107: - $474 = $473 + 8 | 0; - $475 = $474; - $476 = HEAP32[$475 >> 2] | 0; - $477 = $dimension_tib1_029_i485 + 1 | 0; - $478 = $476 + 56 | 0; - $479 = $478; - $480 = HEAP32[$479 >> 2] | 0; - $481 = ($480 | 0) == 0; - if ($481) { - label = 105; - break; - } else { - var $dimension_tib1_029_i485 = $477; - var $473 = $480; - label = 107; - break; - } - case 108: - $483 = $482 + 8 | 0; - $484 = $483; - $485 = HEAP32[$484 >> 2] | 0; - $486 = $dimension_tib2_024_i487 + 1 | 0; - $487 = $485 + 56 | 0; - $488 = $487; - $489 = HEAP32[$488 >> 2] | 0; - $490 = ($489 | 0) == 0; - if ($490) { - var $dimension_tib2_0_lcssa_i490 = $486; - var $tib2_0_lcssa_in_i489 = $485; - label = 109; - break; - } else { - var $dimension_tib2_024_i487 = $486; - var $482 = $489; - label = 108; - break; - } - case 109: - $tib2_0_lcssa_i491 = $tib2_0_lcssa_in_i489; - $491 = ($dimension_tib1_0_lcssa_i483 | 0) < ($dimension_tib2_0_lcssa_i490 | 0); - $492 = ($tib1_0_lcssa_i482 | 0) == 0; - $or_cond_i492 = $491 | $492; - if ($or_cond_i492) { - label = 115; - break; - } else { - $tib1_121_i494 = $tib1_0_lcssa_i482; - label = 110; - break; - } - case 110: - $493 = ($tib1_121_i494 | 0) == ($tib2_0_lcssa_i491 | 0); - if ($493) { - label = 54; - break; - } else { - label = 111; - break; - } - case 111: - $494 = $tib1_121_i494 + 108 | 0; - $495 = HEAP32[$494 >> 2] | 0; - $496 = $tib1_121_i494 + 112 | 0; - $i_0_i497 = 0; - label = 112; - break; - case 112: - $498 = ($i_0_i497 | 0) < ($495 | 0); - if ($498) { - label = 113; - break; - } else { - label = 114; - break; - } - case 113: - $500 = HEAP32[$496 >> 2] | 0; - $501 = $500 + ($i_0_i497 << 2) | 0; - $502 = HEAP32[$501 >> 2] | 0; - $503 = ($502 | 0) == ($tib2_0_lcssa_i491 | 0); - $504 = $i_0_i497 + 1 | 0; - if ($503) { - label = 54; - break; - } else { - $i_0_i497 = $504; - label = 112; - break; - } - case 114: - $506 = $tib1_121_i494 + 40 | 0; - $507 = HEAP32[$506 >> 2] | 0; - $508 = ($507 | 0) == 0; - if ($508) { - label = 115; - break; - } else { - $tib1_121_i494 = $507; - label = 110; - break; - } - case 115: - $509 = HEAP32[$397 >> 2] | 0; - $510 = $509; - invoke_vii(48, $510 | 0, 0 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case 116: - $512 = HEAP32[(98772 | 0) >> 2] | 0; - $513 = ($512 | 0) == 0; - if ($513) { - label = 117; - break; - } else { - label = 118; - break; - } - case 117: - invoke_v(702); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 118; - break; - case 118: - $516 = HEAP32[(105500 | 0) >> 2] | 0; - $517 = ($516 | 0) == 0; - if ($517) { - label = 119; - break; - } else { - label = 120; - break; - } - case 119: - invoke_v(30); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 120; - break; - case 120: - $519 = invoke_i(70) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $520$0 = $519; - $520$1 = 0; - $521 = invoke_iii(364, $520$0 | 0, $520$1 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $522 = HEAP32[(98148 | 0) >> 2] | 0; - $523 = ($522 | 0) == 0; - if ($523) { - label = 121; - break; - } else { - label = 122; - break; - } - case 121: - invoke_v(408); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 122; - break; - case 122: - $525 = invoke_ii(338, 12 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $526 = $525; - HEAP32[$526 >> 2] = 98144; - $527 = $525 + 4 | 0; - $528 = $527; - HEAP32[$528 >> 2] = 0; - $529 = $525 + 8 | 0; - $530 = $529; - HEAP32[$530 >> 2] = $521; - $531 = HEAP32[(97532 | 0) >> 2] | 0; - $532 = ($531 | 0) == 0; - if ($532) { - label = 123; - break; - } else { - $534 = 98144; - label = 124; - break; - } - case 123: - invoke_v(568); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $_phi_trans_insert = $525; - $_pre = HEAP32[$_phi_trans_insert >> 2] | 0; - $534 = $_pre; - label = 124; - break; - case 124: - $535 = $534 + 116 | 0; - $536 = HEAP32[$535 >> 2] | 0; - $537 = HEAP32[$536 >> 2] | 0; - $538 = $537; - $539 = invoke_ii($538 | 0, $525 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $540 = $539; - $_r2_sroa_0 = $540; - $541 = HEAP32[$429 >> 2] | 0; - _memcpy($541 | 0, $427 | 0, 40); - $_r2_sroa_0_0_load599 = $_r2_sroa_0; - $542 = ($_r2_sroa_0_0_load599 | 0) == 0; - $543 = HEAP32[(105500 | 0) >> 2] | 0; - $544 = ($543 | 0) == 0; - if ($544) { - label = 125; - break; - } else { - label = 126; - break; - } - case 125: - invoke_v(30); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 126; - break; - case 126: - $546 = invoke_i(70) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $547$0 = $546; - $547$1 = 0; - $548 = invoke_iii(364, $547$0 | 0, $547$1 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - if ($542) { - label = 240; - break; - } else { - label = 144; - break; - } - case 127: - $550 = HEAP32[$429 >> 2] | 0; - _memcpy($550 | 0, $427 | 0, 40); - $551 = HEAP32[(107740 | 0) >> 2] | 0; - $552 = ($551 | 0) == 0; - if ($552) { - label = 128; - break; - } else { - label = 129; - break; - } - case 128: - invoke_v(374); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 129; - break; - case 129: - $555 = $426 + 20 | 0; - $556 = $555; - $557 = HEAP32[$556 >> 2] | 0; - $558 = ($557 | 0) == 0; - if ($558) { - label = 143; - break; - } else { - label = 130; - break; - } - case 130: - $560 = HEAP32[137616 >> 2] | 0; - $561 = $557; - $562 = HEAP32[$561 >> 2] | 0; - $563 = $562; - $564 = $560 + 8 | 0; - $565 = $564; - $566 = HEAP32[$565 >> 2] | 0; - $567 = ($562 | 0) == 82712; - if ($567) { - label = 131; - break; - } else { - $tib1_0_ph_i458 = $563; - label = 132; - break; - } - case 131: - $569 = $557 + 8 | 0; - $570 = $569; - $571 = HEAP32[$570 >> 2] | 0; - $572 = $571 + 8 | 0; - $573 = $572; - $574 = HEAP32[$573 >> 2] | 0; - $575 = $574; - $tib1_0_ph_i458 = $575; - label = 132; - break; - case 132: - $576 = $tib1_0_ph_i458 + 56 | 0; - $577 = HEAP32[$576 >> 2] | 0; - $578 = ($577 | 0) == 0; - if ($578) { - var $dimension_tib1_0_lcssa_i462 = 0; - var $tib1_0_lcssa_i461 = $tib1_0_ph_i458; - label = 134; - break; - } else { - var $dimension_tib1_029_i464 = 0; - var $584 = $577; - label = 135; - break; - } - case 133: - $579 = $587; - var $dimension_tib1_0_lcssa_i462 = $588; - var $tib1_0_lcssa_i461 = $579; - label = 134; - break; - case 134: - $580 = $566 + 56 | 0; - $581 = $580; - $582 = HEAP32[$581 >> 2] | 0; - $583 = ($582 | 0) == 0; - if ($583) { - var $dimension_tib2_0_lcssa_i469 = 0; - var $tib2_0_lcssa_in_i468 = $566; - label = 137; - break; - } else { - var $dimension_tib2_024_i466 = 0; - var $593 = $582; - label = 136; - break; - } - case 135: - $585 = $584 + 8 | 0; - $586 = $585; - $587 = HEAP32[$586 >> 2] | 0; - $588 = $dimension_tib1_029_i464 + 1 | 0; - $589 = $587 + 56 | 0; - $590 = $589; - $591 = HEAP32[$590 >> 2] | 0; - $592 = ($591 | 0) == 0; - if ($592) { - label = 133; - break; - } else { - var $dimension_tib1_029_i464 = $588; - var $584 = $591; - label = 135; - break; - } - case 136: - $594 = $593 + 8 | 0; - $595 = $594; - $596 = HEAP32[$595 >> 2] | 0; - $597 = $dimension_tib2_024_i466 + 1 | 0; - $598 = $596 + 56 | 0; - $599 = $598; - $600 = HEAP32[$599 >> 2] | 0; - $601 = ($600 | 0) == 0; - if ($601) { - var $dimension_tib2_0_lcssa_i469 = $597; - var $tib2_0_lcssa_in_i468 = $596; - label = 137; - break; - } else { - var $dimension_tib2_024_i466 = $597; - var $593 = $600; - label = 136; - break; - } - case 137: - $tib2_0_lcssa_i470 = $tib2_0_lcssa_in_i468; - $602 = ($dimension_tib1_0_lcssa_i462 | 0) < ($dimension_tib2_0_lcssa_i469 | 0); - $603 = ($tib1_0_lcssa_i461 | 0) == 0; - $or_cond_i471 = $602 | $603; - if ($or_cond_i471) { - label = 143; - break; - } else { - $tib1_121_i473 = $tib1_0_lcssa_i461; - label = 138; - break; - } - case 138: - $604 = ($tib1_121_i473 | 0) == ($tib2_0_lcssa_i470 | 0); - if ($604) { - label = 54; - break; - } else { - label = 139; - break; - } - case 139: - $605 = $tib1_121_i473 + 108 | 0; - $606 = HEAP32[$605 >> 2] | 0; - $607 = $tib1_121_i473 + 112 | 0; - $i_0_i476 = 0; - label = 140; - break; - case 140: - $609 = ($i_0_i476 | 0) < ($606 | 0); - if ($609) { - label = 141; - break; - } else { - label = 142; - break; - } - case 141: - $611 = HEAP32[$607 >> 2] | 0; - $612 = $611 + ($i_0_i476 << 2) | 0; - $613 = HEAP32[$612 >> 2] | 0; - $614 = ($613 | 0) == ($tib2_0_lcssa_i470 | 0); - $615 = $i_0_i476 + 1 | 0; - if ($614) { - label = 54; - break; - } else { - $i_0_i476 = $615; - label = 140; - break; - } - case 142: - $617 = $tib1_121_i473 + 40 | 0; - $618 = HEAP32[$617 >> 2] | 0; - $619 = ($618 | 0) == 0; - if ($619) { - label = 143; - break; - } else { - $tib1_121_i473 = $618; - label = 138; - break; - } - case 143: - $620 = HEAP32[$429 >> 2] | 0; - $621 = $620; - invoke_vii(48, $621 | 0, 0 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case 144: - $623 = $local_env_w4567aaac23b1c29; - $624 = $548 + 16 | 0; - $625 = $624; - $626 = HEAP32[$625 >> 2] | 0; - _memcpy($623 | 0, $626 | 0, 40); - $627 = HEAP32[$625 >> 2] | 0; - $628 = $627; - $629 = _saveSetjmp($628 | 0, label, setjmpTable) | 0; - label = 418; - break; - case 418: - $630 = ($629 | 0) == 0; - if ($630) { - label = 145; - break; - } else { - label = 146; - break; - } - case 145: - $632 = invoke_ii(556, 709 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $633 = $632; - $_r0_sroa_0 = $633; - $_r2_sroa_0_0_load598 = $_r2_sroa_0; - $_r0_sroa_0_0_load609 = $_r0_sroa_0; - $_r0_sroa_0 = 0; - $_r0_sroa_0_0_load624 = $_r0_sroa_0; - $634 = $_r0_sroa_0_0_load624; - $_r3_sroa_0 = $634; - $_r0_sroa_1_4__r3_sroa_1_4_idx108_idx = $_r3_sroa_1 | 0; - $_r0_sroa_1_4_idx = $_r0_sroa_1 | 0; - HEAP32[$_r0_sroa_1_4__r3_sroa_1_4_idx108_idx >> 2] = HEAP32[$_r0_sroa_1_4_idx >> 2] | 0; - $635 = HEAP32[$625 >> 2] | 0; - _memcpy($635 | 0, $623 | 0, 40); - label = 179; - break; - case 146: - $637 = HEAP32[$625 >> 2] | 0; - _memcpy($637 | 0, $623 | 0, 40); - $638 = HEAP32[(113236 | 0) >> 2] | 0; - $639 = ($638 | 0) == 0; - if ($639) { - label = 147; - break; - } else { - label = 148; - break; - } - case 147: - invoke_v(538); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 148; - break; - case 148: - $642 = $548 + 20 | 0; - $643 = $642; - $644 = HEAP32[$643 >> 2] | 0; - $645 = ($644 | 0) == 0; - if ($645) { - label = 162; - break; - } else { - label = 149; - break; - } - case 149: - $647 = HEAP32[138672 >> 2] | 0; - $648 = $644; - $649 = HEAP32[$648 >> 2] | 0; - $650 = $649; - $651 = $647 + 8 | 0; - $652 = $651; - $653 = HEAP32[$652 >> 2] | 0; - $654 = ($649 | 0) == 82712; - if ($654) { - label = 150; - break; - } else { - $tib1_0_ph_i437 = $650; - label = 151; - break; - } - case 150: - $656 = $644 + 8 | 0; - $657 = $656; - $658 = HEAP32[$657 >> 2] | 0; - $659 = $658 + 8 | 0; - $660 = $659; - $661 = HEAP32[$660 >> 2] | 0; - $662 = $661; - $tib1_0_ph_i437 = $662; - label = 151; - break; - case 151: - $663 = $tib1_0_ph_i437 + 56 | 0; - $664 = HEAP32[$663 >> 2] | 0; - $665 = ($664 | 0) == 0; - if ($665) { - var $dimension_tib1_0_lcssa_i441 = 0; - var $tib1_0_lcssa_i440 = $tib1_0_ph_i437; - label = 153; - break; - } else { - var $dimension_tib1_029_i443 = 0; - var $671 = $664; - label = 154; - break; - } - case 152: - $666 = $674; - var $dimension_tib1_0_lcssa_i441 = $675; - var $tib1_0_lcssa_i440 = $666; - label = 153; - break; - case 153: - $667 = $653 + 56 | 0; - $668 = $667; - $669 = HEAP32[$668 >> 2] | 0; - $670 = ($669 | 0) == 0; - if ($670) { - var $dimension_tib2_0_lcssa_i448 = 0; - var $tib2_0_lcssa_in_i447 = $653; - label = 156; - break; - } else { - var $dimension_tib2_024_i445 = 0; - var $680 = $669; - label = 155; - break; - } - case 154: - $672 = $671 + 8 | 0; - $673 = $672; - $674 = HEAP32[$673 >> 2] | 0; - $675 = $dimension_tib1_029_i443 + 1 | 0; - $676 = $674 + 56 | 0; - $677 = $676; - $678 = HEAP32[$677 >> 2] | 0; - $679 = ($678 | 0) == 0; - if ($679) { - label = 152; - break; - } else { - var $dimension_tib1_029_i443 = $675; - var $671 = $678; - label = 154; - break; - } - case 155: - $681 = $680 + 8 | 0; - $682 = $681; - $683 = HEAP32[$682 >> 2] | 0; - $684 = $dimension_tib2_024_i445 + 1 | 0; - $685 = $683 + 56 | 0; - $686 = $685; - $687 = HEAP32[$686 >> 2] | 0; - $688 = ($687 | 0) == 0; - if ($688) { - var $dimension_tib2_0_lcssa_i448 = $684; - var $tib2_0_lcssa_in_i447 = $683; - label = 156; - break; - } else { - var $dimension_tib2_024_i445 = $684; - var $680 = $687; - label = 155; - break; - } - case 156: - $tib2_0_lcssa_i449 = $tib2_0_lcssa_in_i447; - $689 = ($dimension_tib1_0_lcssa_i441 | 0) < ($dimension_tib2_0_lcssa_i448 | 0); - $690 = ($tib1_0_lcssa_i440 | 0) == 0; - $or_cond_i450 = $689 | $690; - if ($or_cond_i450) { - label = 162; - break; - } else { - $tib1_121_i452 = $tib1_0_lcssa_i440; - label = 157; - break; - } - case 157: - $691 = ($tib1_121_i452 | 0) == ($tib2_0_lcssa_i449 | 0); - if ($691) { - label = 361; - break; - } else { - label = 158; - break; - } - case 158: - $692 = $tib1_121_i452 + 108 | 0; - $693 = HEAP32[$692 >> 2] | 0; - $694 = $tib1_121_i452 + 112 | 0; - $i_0_i455 = 0; - label = 159; - break; - case 159: - $696 = ($i_0_i455 | 0) < ($693 | 0); - if ($696) { - label = 160; - break; - } else { - label = 161; - break; - } - case 160: - $698 = HEAP32[$694 >> 2] | 0; - $699 = $698 + ($i_0_i455 << 2) | 0; - $700 = HEAP32[$699 >> 2] | 0; - $701 = ($700 | 0) == ($tib2_0_lcssa_i449 | 0); - $702 = $i_0_i455 + 1 | 0; - if ($701) { - label = 361; - break; - } else { - $i_0_i455 = $702; - label = 159; - break; - } - case 161: - $704 = $tib1_121_i452 + 40 | 0; - $705 = HEAP32[$704 >> 2] | 0; - $706 = ($705 | 0) == 0; - if ($706) { - label = 162; - break; - } else { - $tib1_121_i452 = $705; - label = 157; - break; - } - case 162: - $707 = HEAP32[(107740 | 0) >> 2] | 0; - $708 = ($707 | 0) == 0; - if ($708) { - label = 163; - break; - } else { - label = 164; - break; - } - case 163: - invoke_v(374); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 164; - break; - case 164: - $711 = HEAP32[$643 >> 2] | 0; - $712 = ($711 | 0) == 0; - if ($712) { - label = 178; - break; - } else { - label = 165; - break; - } - case 165: - $714 = HEAP32[137616 >> 2] | 0; - $715 = $711; - $716 = HEAP32[$715 >> 2] | 0; - $717 = $716; - $718 = $714 + 8 | 0; - $719 = $718; - $720 = HEAP32[$719 >> 2] | 0; - $721 = ($716 | 0) == 82712; - if ($721) { - label = 166; - break; - } else { - $tib1_0_ph_i416 = $717; - label = 167; - break; - } - case 166: - $723 = $711 + 8 | 0; - $724 = $723; - $725 = HEAP32[$724 >> 2] | 0; - $726 = $725 + 8 | 0; - $727 = $726; - $728 = HEAP32[$727 >> 2] | 0; - $729 = $728; - $tib1_0_ph_i416 = $729; - label = 167; - break; - case 167: - $730 = $tib1_0_ph_i416 + 56 | 0; - $731 = HEAP32[$730 >> 2] | 0; - $732 = ($731 | 0) == 0; - if ($732) { - var $dimension_tib1_0_lcssa_i420 = 0; - var $tib1_0_lcssa_i419 = $tib1_0_ph_i416; - label = 169; - break; - } else { - var $dimension_tib1_029_i422 = 0; - var $738 = $731; - label = 170; - break; - } - case 168: - $733 = $741; - var $dimension_tib1_0_lcssa_i420 = $742; - var $tib1_0_lcssa_i419 = $733; - label = 169; - break; - case 169: - $734 = $720 + 56 | 0; - $735 = $734; - $736 = HEAP32[$735 >> 2] | 0; - $737 = ($736 | 0) == 0; - if ($737) { - var $dimension_tib2_0_lcssa_i427 = 0; - var $tib2_0_lcssa_in_i426 = $720; - label = 172; - break; - } else { - var $dimension_tib2_024_i424 = 0; - var $747 = $736; - label = 171; - break; - } - case 170: - $739 = $738 + 8 | 0; - $740 = $739; - $741 = HEAP32[$740 >> 2] | 0; - $742 = $dimension_tib1_029_i422 + 1 | 0; - $743 = $741 + 56 | 0; - $744 = $743; - $745 = HEAP32[$744 >> 2] | 0; - $746 = ($745 | 0) == 0; - if ($746) { - label = 168; - break; - } else { - var $dimension_tib1_029_i422 = $742; - var $738 = $745; - label = 170; - break; - } - case 171: - $748 = $747 + 8 | 0; - $749 = $748; - $750 = HEAP32[$749 >> 2] | 0; - $751 = $dimension_tib2_024_i424 + 1 | 0; - $752 = $750 + 56 | 0; - $753 = $752; - $754 = HEAP32[$753 >> 2] | 0; - $755 = ($754 | 0) == 0; - if ($755) { - var $dimension_tib2_0_lcssa_i427 = $751; - var $tib2_0_lcssa_in_i426 = $750; - label = 172; - break; - } else { - var $dimension_tib2_024_i424 = $751; - var $747 = $754; - label = 171; - break; - } - case 172: - $tib2_0_lcssa_i428 = $tib2_0_lcssa_in_i426; - $756 = ($dimension_tib1_0_lcssa_i420 | 0) < ($dimension_tib2_0_lcssa_i427 | 0); - $757 = ($tib1_0_lcssa_i419 | 0) == 0; - $or_cond_i429 = $756 | $757; - if ($or_cond_i429) { - label = 178; - break; - } else { - $tib1_121_i431 = $tib1_0_lcssa_i419; - label = 173; - break; - } - case 173: - $758 = ($tib1_121_i431 | 0) == ($tib2_0_lcssa_i428 | 0); - if ($758) { - label = 386; - break; - } else { - label = 174; - break; - } - case 174: - $759 = $tib1_121_i431 + 108 | 0; - $760 = HEAP32[$759 >> 2] | 0; - $761 = $tib1_121_i431 + 112 | 0; - $i_0_i434 = 0; - label = 175; - break; - case 175: - $763 = ($i_0_i434 | 0) < ($760 | 0); - if ($763) { - label = 176; - break; - } else { - label = 177; - break; - } - case 176: - $765 = HEAP32[$761 >> 2] | 0; - $766 = $765 + ($i_0_i434 << 2) | 0; - $767 = HEAP32[$766 >> 2] | 0; - $768 = ($767 | 0) == ($tib2_0_lcssa_i428 | 0); - $769 = $i_0_i434 + 1 | 0; - if ($768) { - label = 386; - break; - } else { - $i_0_i434 = $769; - label = 175; - break; - } - case 177: - $771 = $tib1_121_i431 + 40 | 0; - $772 = HEAP32[$771 >> 2] | 0; - $773 = ($772 | 0) == 0; - if ($773) { - label = 178; - break; - } else { - $tib1_121_i431 = $772; - label = 173; - break; - } - case 178: - $774 = HEAP32[$625 >> 2] | 0; - $775 = $774; - invoke_vii(48, $775 | 0, 0 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case 179: - $777 = HEAP32[(105500 | 0) >> 2] | 0; - $778 = ($777 | 0) == 0; - if ($778) { - label = 180; - break; - } else { - label = 181; - break; - } - case 180: - invoke_v(30); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 181; - break; - case 181: - $780 = invoke_i(70) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $781$0 = $780; - $781$1 = 0; - $782 = invoke_iii(364, $781$0 | 0, $781$1 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $783 = $local_env_w4567aaac23b1c31; - $784 = $782 + 16 | 0; - $785 = $784; - $786 = HEAP32[$785 >> 2] | 0; - _memcpy($783 | 0, $786 | 0, 40); - $787 = HEAP32[$785 >> 2] | 0; - $788 = $787; - $789 = _saveSetjmp($788 | 0, label, setjmpTable) | 0; - label = 419; - break; - case 419: - $790 = ($789 | 0) == 0; - if ($790) { - label = 182; - break; - } else { - label = 183; - break; - } - case 182: - $_r3_sroa_0_0_load596 = $_r3_sroa_0; - $792 = $_r3_sroa_0_0_load596; - $793 = HEAP32[$792 >> 2] | 0; - $794 = $793 + 116 | 0; - $795 = HEAP32[$794 >> 2] | 0; - $796 = HEAP32[$795 >> 2] | 0; - $797 = $796; - $_r3_sroa_0_0_load595 = $_r3_sroa_0; - $798 = invoke_ii($797 | 0, $_r3_sroa_0_0_load595 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $_r0_sroa_0 = $798; - $799 = HEAP32[$785 >> 2] | 0; - _memcpy($799 | 0, $783 | 0, 40); - $_r0_sroa_0_0_load608 = $_r0_sroa_0; - $800 = ($_r0_sroa_0_0_load608 | 0) == 0; - if ($800) { - label = 216; - break; - } else { - label = 322; - break; - } - case 183: - $802 = HEAP32[$785 >> 2] | 0; - _memcpy($802 | 0, $783 | 0, 40); - $803 = HEAP32[(113236 | 0) >> 2] | 0; - $804 = ($803 | 0) == 0; - if ($804) { - label = 184; - break; - } else { - label = 185; - break; - } - case 184: - invoke_v(538); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 185; - break; - case 185: - $807 = $782 + 20 | 0; - $808 = $807; - $809 = HEAP32[$808 >> 2] | 0; - $810 = ($809 | 0) == 0; - if ($810) { - label = 199; - break; - } else { - label = 186; - break; - } - case 186: - $812 = HEAP32[138672 >> 2] | 0; - $813 = $809; - $814 = HEAP32[$813 >> 2] | 0; - $815 = $814; - $816 = $812 + 8 | 0; - $817 = $816; - $818 = HEAP32[$817 >> 2] | 0; - $819 = ($814 | 0) == 82712; - if ($819) { - label = 187; - break; - } else { - $tib1_0_ph_i395 = $815; - label = 188; - break; - } - case 187: - $821 = $809 + 8 | 0; - $822 = $821; - $823 = HEAP32[$822 >> 2] | 0; - $824 = $823 + 8 | 0; - $825 = $824; - $826 = HEAP32[$825 >> 2] | 0; - $827 = $826; - $tib1_0_ph_i395 = $827; - label = 188; - break; - case 188: - $828 = $tib1_0_ph_i395 + 56 | 0; - $829 = HEAP32[$828 >> 2] | 0; - $830 = ($829 | 0) == 0; - if ($830) { - var $dimension_tib1_0_lcssa_i399 = 0; - var $tib1_0_lcssa_i398 = $tib1_0_ph_i395; - label = 190; - break; - } else { - var $dimension_tib1_029_i401 = 0; - var $836 = $829; - label = 191; - break; - } - case 189: - $831 = $839; - var $dimension_tib1_0_lcssa_i399 = $840; - var $tib1_0_lcssa_i398 = $831; - label = 190; - break; - case 190: - $832 = $818 + 56 | 0; - $833 = $832; - $834 = HEAP32[$833 >> 2] | 0; - $835 = ($834 | 0) == 0; - if ($835) { - var $dimension_tib2_0_lcssa_i406 = 0; - var $tib2_0_lcssa_in_i405 = $818; - label = 193; - break; - } else { - var $dimension_tib2_024_i403 = 0; - var $845 = $834; - label = 192; - break; - } - case 191: - $837 = $836 + 8 | 0; - $838 = $837; - $839 = HEAP32[$838 >> 2] | 0; - $840 = $dimension_tib1_029_i401 + 1 | 0; - $841 = $839 + 56 | 0; - $842 = $841; - $843 = HEAP32[$842 >> 2] | 0; - $844 = ($843 | 0) == 0; - if ($844) { - label = 189; - break; - } else { - var $dimension_tib1_029_i401 = $840; - var $836 = $843; - label = 191; - break; - } - case 192: - $846 = $845 + 8 | 0; - $847 = $846; - $848 = HEAP32[$847 >> 2] | 0; - $849 = $dimension_tib2_024_i403 + 1 | 0; - $850 = $848 + 56 | 0; - $851 = $850; - $852 = HEAP32[$851 >> 2] | 0; - $853 = ($852 | 0) == 0; - if ($853) { - var $dimension_tib2_0_lcssa_i406 = $849; - var $tib2_0_lcssa_in_i405 = $848; - label = 193; - break; - } else { - var $dimension_tib2_024_i403 = $849; - var $845 = $852; - label = 192; - break; - } - case 193: - $tib2_0_lcssa_i407 = $tib2_0_lcssa_in_i405; - $854 = ($dimension_tib1_0_lcssa_i399 | 0) < ($dimension_tib2_0_lcssa_i406 | 0); - $855 = ($tib1_0_lcssa_i398 | 0) == 0; - $or_cond_i408 = $854 | $855; - if ($or_cond_i408) { - label = 199; - break; - } else { - $tib1_121_i410 = $tib1_0_lcssa_i398; - label = 194; - break; - } - case 194: - $856 = ($tib1_121_i410 | 0) == ($tib2_0_lcssa_i407 | 0); - if ($856) { - label = 361; - break; - } else { - label = 195; - break; - } - case 195: - $857 = $tib1_121_i410 + 108 | 0; - $858 = HEAP32[$857 >> 2] | 0; - $859 = $tib1_121_i410 + 112 | 0; - $i_0_i413 = 0; - label = 196; - break; - case 196: - $861 = ($i_0_i413 | 0) < ($858 | 0); - if ($861) { - label = 197; - break; - } else { - label = 198; - break; - } - case 197: - $863 = HEAP32[$859 >> 2] | 0; - $864 = $863 + ($i_0_i413 << 2) | 0; - $865 = HEAP32[$864 >> 2] | 0; - $866 = ($865 | 0) == ($tib2_0_lcssa_i407 | 0); - $867 = $i_0_i413 + 1 | 0; - if ($866) { - label = 361; - break; - } else { - $i_0_i413 = $867; - label = 196; - break; - } - case 198: - $869 = $tib1_121_i410 + 40 | 0; - $870 = HEAP32[$869 >> 2] | 0; - $871 = ($870 | 0) == 0; - if ($871) { - label = 199; - break; - } else { - $tib1_121_i410 = $870; - label = 194; - break; - } - case 199: - $872 = HEAP32[(107740 | 0) >> 2] | 0; - $873 = ($872 | 0) == 0; - if ($873) { - label = 200; - break; - } else { - label = 201; - break; - } - case 200: - invoke_v(374); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 201; - break; - case 201: - $876 = HEAP32[$808 >> 2] | 0; - $877 = ($876 | 0) == 0; - if ($877) { - label = 215; - break; - } else { - label = 202; - break; - } - case 202: - $879 = HEAP32[137616 >> 2] | 0; - $880 = $876; - $881 = HEAP32[$880 >> 2] | 0; - $882 = $881; - $883 = $879 + 8 | 0; - $884 = $883; - $885 = HEAP32[$884 >> 2] | 0; - $886 = ($881 | 0) == 82712; - if ($886) { - label = 203; - break; - } else { - $tib1_0_ph_i374 = $882; - label = 204; - break; - } - case 203: - $888 = $876 + 8 | 0; - $889 = $888; - $890 = HEAP32[$889 >> 2] | 0; - $891 = $890 + 8 | 0; - $892 = $891; - $893 = HEAP32[$892 >> 2] | 0; - $894 = $893; - $tib1_0_ph_i374 = $894; - label = 204; - break; - case 204: - $895 = $tib1_0_ph_i374 + 56 | 0; - $896 = HEAP32[$895 >> 2] | 0; - $897 = ($896 | 0) == 0; - if ($897) { - var $dimension_tib1_0_lcssa_i378 = 0; - var $tib1_0_lcssa_i377 = $tib1_0_ph_i374; - label = 206; - break; - } else { - var $dimension_tib1_029_i380 = 0; - var $903 = $896; - label = 207; - break; - } - case 205: - $898 = $906; - var $dimension_tib1_0_lcssa_i378 = $907; - var $tib1_0_lcssa_i377 = $898; - label = 206; - break; - case 206: - $899 = $885 + 56 | 0; - $900 = $899; - $901 = HEAP32[$900 >> 2] | 0; - $902 = ($901 | 0) == 0; - if ($902) { - var $dimension_tib2_0_lcssa_i385 = 0; - var $tib2_0_lcssa_in_i384 = $885; - label = 209; - break; - } else { - var $dimension_tib2_024_i382 = 0; - var $912 = $901; - label = 208; - break; - } - case 207: - $904 = $903 + 8 | 0; - $905 = $904; - $906 = HEAP32[$905 >> 2] | 0; - $907 = $dimension_tib1_029_i380 + 1 | 0; - $908 = $906 + 56 | 0; - $909 = $908; - $910 = HEAP32[$909 >> 2] | 0; - $911 = ($910 | 0) == 0; - if ($911) { - label = 205; - break; - } else { - var $dimension_tib1_029_i380 = $907; - var $903 = $910; - label = 207; - break; - } - case 208: - $913 = $912 + 8 | 0; - $914 = $913; - $915 = HEAP32[$914 >> 2] | 0; - $916 = $dimension_tib2_024_i382 + 1 | 0; - $917 = $915 + 56 | 0; - $918 = $917; - $919 = HEAP32[$918 >> 2] | 0; - $920 = ($919 | 0) == 0; - if ($920) { - var $dimension_tib2_0_lcssa_i385 = $916; - var $tib2_0_lcssa_in_i384 = $915; - label = 209; - break; - } else { - var $dimension_tib2_024_i382 = $916; - var $912 = $919; - label = 208; - break; - } - case 209: - $tib2_0_lcssa_i386 = $tib2_0_lcssa_in_i384; - $921 = ($dimension_tib1_0_lcssa_i378 | 0) < ($dimension_tib2_0_lcssa_i385 | 0); - $922 = ($tib1_0_lcssa_i377 | 0) == 0; - $or_cond_i387 = $921 | $922; - if ($or_cond_i387) { - label = 215; - break; - } else { - $tib1_121_i389 = $tib1_0_lcssa_i377; - label = 210; - break; - } - case 210: - $923 = ($tib1_121_i389 | 0) == ($tib2_0_lcssa_i386 | 0); - if ($923) { - label = 386; - break; - } else { - label = 211; - break; - } - case 211: - $924 = $tib1_121_i389 + 108 | 0; - $925 = HEAP32[$924 >> 2] | 0; - $926 = $tib1_121_i389 + 112 | 0; - $i_0_i392 = 0; - label = 212; - break; - case 212: - $928 = ($i_0_i392 | 0) < ($925 | 0); - if ($928) { - label = 213; - break; - } else { - label = 214; - break; - } - case 213: - $930 = HEAP32[$926 >> 2] | 0; - $931 = $930 + ($i_0_i392 << 2) | 0; - $932 = HEAP32[$931 >> 2] | 0; - $933 = ($932 | 0) == ($tib2_0_lcssa_i386 | 0); - $934 = $i_0_i392 + 1 | 0; - if ($933) { - label = 386; - break; - } else { - $i_0_i392 = $934; - label = 212; - break; - } - case 214: - $936 = $tib1_121_i389 + 40 | 0; - $937 = HEAP32[$936 >> 2] | 0; - $938 = ($937 | 0) == 0; - if ($938) { - label = 215; - break; - } else { - $tib1_121_i389 = $937; - label = 210; - break; - } - case 215: - $939 = HEAP32[$785 >> 2] | 0; - $940 = $939; - invoke_vii(48, $940 | 0, 0 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case 216: - $_r0_sroa_0 = 0; - $942 = HEAP32[(105500 | 0) >> 2] | 0; - $943 = ($942 | 0) == 0; - if ($943) { - label = 217; - break; - } else { - label = 218; - break; - } - case 217: - invoke_v(30); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 218; - break; - case 218: - $945 = invoke_i(70) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $946$0 = $945; - $946$1 = 0; - $947 = invoke_iii(364, $946$0 | 0, $946$1 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $948 = $local_env_w4567aaac23b1c35; - $949 = $947 + 16 | 0; - $950 = $949; - $951 = HEAP32[$950 >> 2] | 0; - _memcpy($948 | 0, $951 | 0, 40); - $952 = HEAP32[$950 >> 2] | 0; - $953 = $952; - $954 = _saveSetjmp($953 | 0, label, setjmpTable) | 0; - label = 420; - break; - case 420: - $955 = ($954 | 0) == 0; - if ($955) { - label = 219; - break; - } else { - label = 222; - break; - } - case 219: - $_r0_sroa_0_0_load607 = $_r0_sroa_0; - $957 = HEAP32[(98772 | 0) >> 2] | 0; - $958 = ($957 | 0) == 0; - if ($958) { - label = 220; - break; - } else { - label = 221; - break; - } - case 220: - invoke_v(702); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 221; - break; - case 221: - HEAP32[140048 >> 2] = $_r0_sroa_0_0_load607; - $960 = HEAP32[$950 >> 2] | 0; - _memcpy($960 | 0, $948 | 0, 40); - label = 239; - break; - case 222: - $962 = HEAP32[$950 >> 2] | 0; - _memcpy($962 | 0, $948 | 0, 40); - $963 = HEAP32[(107740 | 0) >> 2] | 0; - $964 = ($963 | 0) == 0; - if ($964) { - label = 223; - break; - } else { - label = 224; - break; - } - case 223: - invoke_v(374); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 224; - break; - case 224: - $967 = $947 + 20 | 0; - $968 = $967; - $969 = HEAP32[$968 >> 2] | 0; - $970 = ($969 | 0) == 0; - if ($970) { - label = 238; - break; - } else { - label = 225; - break; - } - case 225: - $972 = HEAP32[137616 >> 2] | 0; - $973 = $969; - $974 = HEAP32[$973 >> 2] | 0; - $975 = $974; - $976 = $972 + 8 | 0; - $977 = $976; - $978 = HEAP32[$977 >> 2] | 0; - $979 = ($974 | 0) == 82712; - if ($979) { - label = 226; - break; - } else { - $tib1_0_ph_i353 = $975; - label = 227; - break; - } - case 226: - $981 = $969 + 8 | 0; - $982 = $981; - $983 = HEAP32[$982 >> 2] | 0; - $984 = $983 + 8 | 0; - $985 = $984; - $986 = HEAP32[$985 >> 2] | 0; - $987 = $986; - $tib1_0_ph_i353 = $987; - label = 227; - break; - case 227: - $988 = $tib1_0_ph_i353 + 56 | 0; - $989 = HEAP32[$988 >> 2] | 0; - $990 = ($989 | 0) == 0; - if ($990) { - var $dimension_tib1_0_lcssa_i357 = 0; - var $tib1_0_lcssa_i356 = $tib1_0_ph_i353; - label = 229; - break; - } else { - var $dimension_tib1_029_i359 = 0; - var $996 = $989; - label = 230; - break; - } - case 228: - $991 = $999; - var $dimension_tib1_0_lcssa_i357 = $1000; - var $tib1_0_lcssa_i356 = $991; - label = 229; - break; - case 229: - $992 = $978 + 56 | 0; - $993 = $992; - $994 = HEAP32[$993 >> 2] | 0; - $995 = ($994 | 0) == 0; - if ($995) { - var $dimension_tib2_0_lcssa_i364 = 0; - var $tib2_0_lcssa_in_i363 = $978; - label = 232; - break; - } else { - var $dimension_tib2_024_i361 = 0; - var $1005 = $994; - label = 231; - break; - } - case 230: - $997 = $996 + 8 | 0; - $998 = $997; - $999 = HEAP32[$998 >> 2] | 0; - $1000 = $dimension_tib1_029_i359 + 1 | 0; - $1001 = $999 + 56 | 0; - $1002 = $1001; - $1003 = HEAP32[$1002 >> 2] | 0; - $1004 = ($1003 | 0) == 0; - if ($1004) { - label = 228; - break; - } else { - var $dimension_tib1_029_i359 = $1000; - var $996 = $1003; - label = 230; - break; - } - case 231: - $1006 = $1005 + 8 | 0; - $1007 = $1006; - $1008 = HEAP32[$1007 >> 2] | 0; - $1009 = $dimension_tib2_024_i361 + 1 | 0; - $1010 = $1008 + 56 | 0; - $1011 = $1010; - $1012 = HEAP32[$1011 >> 2] | 0; - $1013 = ($1012 | 0) == 0; - if ($1013) { - var $dimension_tib2_0_lcssa_i364 = $1009; - var $tib2_0_lcssa_in_i363 = $1008; - label = 232; - break; - } else { - var $dimension_tib2_024_i361 = $1009; - var $1005 = $1012; - label = 231; - break; - } - case 232: - $tib2_0_lcssa_i365 = $tib2_0_lcssa_in_i363; - $1014 = ($dimension_tib1_0_lcssa_i357 | 0) < ($dimension_tib2_0_lcssa_i364 | 0); - $1015 = ($tib1_0_lcssa_i356 | 0) == 0; - $or_cond_i366 = $1014 | $1015; - if ($or_cond_i366) { - label = 238; - break; - } else { - $tib1_121_i368 = $tib1_0_lcssa_i356; - label = 233; - break; - } - case 233: - $1016 = ($tib1_121_i368 | 0) == ($tib2_0_lcssa_i365 | 0); - if ($1016) { - label = 54; - break; - } else { - label = 234; - break; - } - case 234: - $1017 = $tib1_121_i368 + 108 | 0; - $1018 = HEAP32[$1017 >> 2] | 0; - $1019 = $tib1_121_i368 + 112 | 0; - $i_0_i371 = 0; - label = 235; - break; - case 235: - $1021 = ($i_0_i371 | 0) < ($1018 | 0); - if ($1021) { - label = 236; - break; - } else { - label = 237; - break; - } - case 236: - $1023 = HEAP32[$1019 >> 2] | 0; - $1024 = $1023 + ($i_0_i371 << 2) | 0; - $1025 = HEAP32[$1024 >> 2] | 0; - $1026 = ($1025 | 0) == ($tib2_0_lcssa_i365 | 0); - $1027 = $i_0_i371 + 1 | 0; - if ($1026) { - label = 54; - break; - } else { - $i_0_i371 = $1027; - label = 235; - break; - } - case 237: - $1029 = $tib1_121_i368 + 40 | 0; - $1030 = HEAP32[$1029 >> 2] | 0; - $1031 = ($1030 | 0) == 0; - if ($1031) { - label = 238; - break; - } else { - $tib1_121_i368 = $1030; - label = 233; - break; - } - case 238: - $1032 = HEAP32[$950 >> 2] | 0; - $1033 = $1032; - invoke_vii(48, $1033 | 0, 0 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case 239: - $_r0_sroa_0 = 0; - label = 28; - break; - case 240: - $1036 = $local_env_w4567aaac23b1c40; - $1037 = $548 + 16 | 0; - $1038 = $1037; - $1039 = HEAP32[$1038 >> 2] | 0; - _memcpy($1036 | 0, $1039 | 0, 40); - $1040 = HEAP32[$1038 >> 2] | 0; - $1041 = $1040; - $1042 = _saveSetjmp($1041 | 0, label, setjmpTable) | 0; - label = 421; - break; - case 421: - $1043 = ($1042 | 0) == 0; - if ($1043) { - label = 241; - break; - } else { - label = 253; - break; - } - case 241: - $1045 = HEAP32[(98772 | 0) >> 2] | 0; - $1046 = ($1045 | 0) == 0; - if ($1046) { - label = 242; - break; - } else { - label = 244; - break; - } - case 242: - invoke_v(702); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $_pr = HEAP32[(98772 | 0) >> 2] | 0; - $1048 = ($_pr | 0) == 0; - if ($1048) { - label = 243; - break; - } else { - label = 244; - break; - } - case 243: - invoke_v(702); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 244; - break; - case 244: - $1050 = HEAP32[140040 >> 2] | 0; - $1051 = ($1050 | 0) == 0; - if ($1051) { - label = 245; - break; - } else { - label = 246; - break; - } - case 245: - invoke_viiii(14, 16136 | 0 | 0, 11648 | 0 | 0, 126768 | 0 | 0, 573 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case 246: - $1053 = HEAP32[(98772 | 0) >> 2] | 0; - $1054 = ($1053 | 0) == 0; - if ($1054) { - label = 247; - break; - } else { - $1056 = $1050; - label = 248; - break; - } - case 247: - invoke_v(702); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $_pre855 = HEAP32[140040 >> 2] | 0; - $1056 = $_pre855; - label = 248; - break; - case 248: - $1057 = $1056; - $_r0_sroa_0 = $1057; - $_r0_sroa_0_0_load606 = $_r0_sroa_0; - $1058 = ($_r0_sroa_0_0_load606 | 0) == 0; - if ($1058) { - label = 252; - break; - } else { - label = 249; - break; - } - case 249: - $1060 = HEAP32[$1038 >> 2] | 0; - _memcpy($1060 | 0, $1036 | 0, 40); - $1061 = HEAP32[(105500 | 0) >> 2] | 0; - $1062 = ($1061 | 0) == 0; - if ($1062) { - label = 250; - break; - } else { - label = 251; - break; - } - case 250: - invoke_v(30); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 251; - break; - case 251: - $1064 = invoke_i(70) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $1065$0 = $1064; - $1065$1 = 0; - $1066 = invoke_iii(364, $1065$0 | 0, $1065$1 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $1067 = $local_env_w4567aaac23b1c42; - $1068 = $1066 + 16 | 0; - $1069 = $1068; - $1070 = HEAP32[$1069 >> 2] | 0; - _memcpy($1067 | 0, $1070 | 0, 40); - $1071 = HEAP32[$1069 >> 2] | 0; - $1072 = $1071; - $1073 = _saveSetjmp($1072 | 0, label, setjmpTable) | 0; - label = 422; - break; - case 422: - $1074 = ($1073 | 0) == 0; - if ($1074) { - label = 286; - break; - } else { - label = 289; - break; - } - case 252: - invoke_viiii(14, 16136 | 0 | 0, 11648 | 0 | 0, 126872 | 0 | 0, 1581 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case 253: - $1077 = HEAP32[$1038 >> 2] | 0; - _memcpy($1077 | 0, $1036 | 0, 40); - $1078 = HEAP32[(113236 | 0) >> 2] | 0; - $1079 = ($1078 | 0) == 0; - if ($1079) { - label = 254; - break; - } else { - label = 255; - break; - } - case 254: - invoke_v(538); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 255; - break; - case 255: - $1082 = $548 + 20 | 0; - $1083 = $1082; - $1084 = HEAP32[$1083 >> 2] | 0; - $1085 = ($1084 | 0) == 0; - if ($1085) { - label = 269; - break; - } else { - label = 256; - break; - } - case 256: - $1087 = HEAP32[138672 >> 2] | 0; - $1088 = $1084; - $1089 = HEAP32[$1088 >> 2] | 0; - $1090 = $1089; - $1091 = $1087 + 8 | 0; - $1092 = $1091; - $1093 = HEAP32[$1092 >> 2] | 0; - $1094 = ($1089 | 0) == 82712; - if ($1094) { - label = 257; - break; - } else { - $tib1_0_ph_i332 = $1090; - label = 258; - break; - } - case 257: - $1096 = $1084 + 8 | 0; - $1097 = $1096; - $1098 = HEAP32[$1097 >> 2] | 0; - $1099 = $1098 + 8 | 0; - $1100 = $1099; - $1101 = HEAP32[$1100 >> 2] | 0; - $1102 = $1101; - $tib1_0_ph_i332 = $1102; - label = 258; - break; - case 258: - $1103 = $tib1_0_ph_i332 + 56 | 0; - $1104 = HEAP32[$1103 >> 2] | 0; - $1105 = ($1104 | 0) == 0; - if ($1105) { - var $dimension_tib1_0_lcssa_i336 = 0; - var $tib1_0_lcssa_i335 = $tib1_0_ph_i332; - label = 260; - break; - } else { - var $dimension_tib1_029_i338 = 0; - var $1111 = $1104; - label = 261; - break; - } - case 259: - $1106 = $1114; - var $dimension_tib1_0_lcssa_i336 = $1115; - var $tib1_0_lcssa_i335 = $1106; - label = 260; - break; - case 260: - $1107 = $1093 + 56 | 0; - $1108 = $1107; - $1109 = HEAP32[$1108 >> 2] | 0; - $1110 = ($1109 | 0) == 0; - if ($1110) { - var $dimension_tib2_0_lcssa_i343 = 0; - var $tib2_0_lcssa_in_i342 = $1093; - label = 263; - break; - } else { - var $dimension_tib2_024_i340 = 0; - var $1120 = $1109; - label = 262; - break; - } - case 261: - $1112 = $1111 + 8 | 0; - $1113 = $1112; - $1114 = HEAP32[$1113 >> 2] | 0; - $1115 = $dimension_tib1_029_i338 + 1 | 0; - $1116 = $1114 + 56 | 0; - $1117 = $1116; - $1118 = HEAP32[$1117 >> 2] | 0; - $1119 = ($1118 | 0) == 0; - if ($1119) { - label = 259; - break; - } else { - var $dimension_tib1_029_i338 = $1115; - var $1111 = $1118; - label = 261; - break; - } - case 262: - $1121 = $1120 + 8 | 0; - $1122 = $1121; - $1123 = HEAP32[$1122 >> 2] | 0; - $1124 = $dimension_tib2_024_i340 + 1 | 0; - $1125 = $1123 + 56 | 0; - $1126 = $1125; - $1127 = HEAP32[$1126 >> 2] | 0; - $1128 = ($1127 | 0) == 0; - if ($1128) { - var $dimension_tib2_0_lcssa_i343 = $1124; - var $tib2_0_lcssa_in_i342 = $1123; - label = 263; - break; - } else { - var $dimension_tib2_024_i340 = $1124; - var $1120 = $1127; - label = 262; - break; - } - case 263: - $tib2_0_lcssa_i344 = $tib2_0_lcssa_in_i342; - $1129 = ($dimension_tib1_0_lcssa_i336 | 0) < ($dimension_tib2_0_lcssa_i343 | 0); - $1130 = ($tib1_0_lcssa_i335 | 0) == 0; - $or_cond_i345 = $1129 | $1130; - if ($or_cond_i345) { - label = 269; - break; - } else { - $tib1_121_i347 = $tib1_0_lcssa_i335; - label = 264; - break; - } - case 264: - $1131 = ($tib1_121_i347 | 0) == ($tib2_0_lcssa_i344 | 0); - if ($1131) { - label = 361; - break; - } else { - label = 265; - break; - } - case 265: - $1132 = $tib1_121_i347 + 108 | 0; - $1133 = HEAP32[$1132 >> 2] | 0; - $1134 = $tib1_121_i347 + 112 | 0; - $i_0_i350 = 0; - label = 266; - break; - case 266: - $1136 = ($i_0_i350 | 0) < ($1133 | 0); - if ($1136) { - label = 267; - break; - } else { - label = 268; - break; - } - case 267: - $1138 = HEAP32[$1134 >> 2] | 0; - $1139 = $1138 + ($i_0_i350 << 2) | 0; - $1140 = HEAP32[$1139 >> 2] | 0; - $1141 = ($1140 | 0) == ($tib2_0_lcssa_i344 | 0); - $1142 = $i_0_i350 + 1 | 0; - if ($1141) { - label = 361; - break; - } else { - $i_0_i350 = $1142; - label = 266; - break; - } - case 268: - $1144 = $tib1_121_i347 + 40 | 0; - $1145 = HEAP32[$1144 >> 2] | 0; - $1146 = ($1145 | 0) == 0; - if ($1146) { - label = 269; - break; - } else { - $tib1_121_i347 = $1145; - label = 264; - break; - } - case 269: - $1147 = HEAP32[(107740 | 0) >> 2] | 0; - $1148 = ($1147 | 0) == 0; - if ($1148) { - label = 270; - break; - } else { - label = 271; - break; - } - case 270: - invoke_v(374); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 271; - break; - case 271: - $1151 = HEAP32[$1083 >> 2] | 0; - $1152 = ($1151 | 0) == 0; - if ($1152) { - label = 285; - break; - } else { - label = 272; - break; - } - case 272: - $1154 = HEAP32[137616 >> 2] | 0; - $1155 = $1151; - $1156 = HEAP32[$1155 >> 2] | 0; - $1157 = $1156; - $1158 = $1154 + 8 | 0; - $1159 = $1158; - $1160 = HEAP32[$1159 >> 2] | 0; - $1161 = ($1156 | 0) == 82712; - if ($1161) { - label = 273; - break; - } else { - $tib1_0_ph_i311 = $1157; - label = 274; - break; - } - case 273: - $1163 = $1151 + 8 | 0; - $1164 = $1163; - $1165 = HEAP32[$1164 >> 2] | 0; - $1166 = $1165 + 8 | 0; - $1167 = $1166; - $1168 = HEAP32[$1167 >> 2] | 0; - $1169 = $1168; - $tib1_0_ph_i311 = $1169; - label = 274; - break; - case 274: - $1170 = $tib1_0_ph_i311 + 56 | 0; - $1171 = HEAP32[$1170 >> 2] | 0; - $1172 = ($1171 | 0) == 0; - if ($1172) { - var $dimension_tib1_0_lcssa_i315 = 0; - var $tib1_0_lcssa_i314 = $tib1_0_ph_i311; - label = 276; - break; - } else { - var $dimension_tib1_029_i317 = 0; - var $1178 = $1171; - label = 277; - break; - } - case 275: - $1173 = $1181; - var $dimension_tib1_0_lcssa_i315 = $1182; - var $tib1_0_lcssa_i314 = $1173; - label = 276; - break; - case 276: - $1174 = $1160 + 56 | 0; - $1175 = $1174; - $1176 = HEAP32[$1175 >> 2] | 0; - $1177 = ($1176 | 0) == 0; - if ($1177) { - var $dimension_tib2_0_lcssa_i322 = 0; - var $tib2_0_lcssa_in_i321 = $1160; - label = 279; - break; - } else { - var $dimension_tib2_024_i319 = 0; - var $1187 = $1176; - label = 278; - break; - } - case 277: - $1179 = $1178 + 8 | 0; - $1180 = $1179; - $1181 = HEAP32[$1180 >> 2] | 0; - $1182 = $dimension_tib1_029_i317 + 1 | 0; - $1183 = $1181 + 56 | 0; - $1184 = $1183; - $1185 = HEAP32[$1184 >> 2] | 0; - $1186 = ($1185 | 0) == 0; - if ($1186) { - label = 275; - break; - } else { - var $dimension_tib1_029_i317 = $1182; - var $1178 = $1185; - label = 277; - break; - } - case 278: - $1188 = $1187 + 8 | 0; - $1189 = $1188; - $1190 = HEAP32[$1189 >> 2] | 0; - $1191 = $dimension_tib2_024_i319 + 1 | 0; - $1192 = $1190 + 56 | 0; - $1193 = $1192; - $1194 = HEAP32[$1193 >> 2] | 0; - $1195 = ($1194 | 0) == 0; - if ($1195) { - var $dimension_tib2_0_lcssa_i322 = $1191; - var $tib2_0_lcssa_in_i321 = $1190; - label = 279; - break; - } else { - var $dimension_tib2_024_i319 = $1191; - var $1187 = $1194; - label = 278; - break; - } - case 279: - $tib2_0_lcssa_i323 = $tib2_0_lcssa_in_i321; - $1196 = ($dimension_tib1_0_lcssa_i315 | 0) < ($dimension_tib2_0_lcssa_i322 | 0); - $1197 = ($tib1_0_lcssa_i314 | 0) == 0; - $or_cond_i324 = $1196 | $1197; - if ($or_cond_i324) { - label = 285; - break; - } else { - $tib1_121_i326 = $tib1_0_lcssa_i314; - label = 280; - break; - } - case 280: - $1198 = ($tib1_121_i326 | 0) == ($tib2_0_lcssa_i323 | 0); - if ($1198) { - label = 386; - break; - } else { - label = 281; - break; - } - case 281: - $1199 = $tib1_121_i326 + 108 | 0; - $1200 = HEAP32[$1199 >> 2] | 0; - $1201 = $tib1_121_i326 + 112 | 0; - $i_0_i329 = 0; - label = 282; - break; - case 282: - $1203 = ($i_0_i329 | 0) < ($1200 | 0); - if ($1203) { - label = 283; - break; - } else { - label = 284; - break; - } - case 283: - $1205 = HEAP32[$1201 >> 2] | 0; - $1206 = $1205 + ($i_0_i329 << 2) | 0; - $1207 = HEAP32[$1206 >> 2] | 0; - $1208 = ($1207 | 0) == ($tib2_0_lcssa_i323 | 0); - $1209 = $i_0_i329 + 1 | 0; - if ($1208) { - label = 386; - break; - } else { - $i_0_i329 = $1209; - label = 282; - break; - } - case 284: - $1211 = $tib1_121_i326 + 40 | 0; - $1212 = HEAP32[$1211 >> 2] | 0; - $1213 = ($1212 | 0) == 0; - if ($1213) { - label = 285; - break; - } else { - $tib1_121_i326 = $1212; - label = 280; - break; - } - case 285: - $1214 = HEAP32[$1038 >> 2] | 0; - $1215 = $1214; - invoke_vii(48, $1215 | 0, 0 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case 286: - $1217 = HEAP32[(98772 | 0) >> 2] | 0; - $1218 = ($1217 | 0) == 0; - if ($1218) { - label = 287; - break; - } else { - label = 288; - break; - } - case 287: - invoke_v(702); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 288; - break; - case 288: - $1220 = HEAP32[140040 >> 2] | 0; - $1221 = $1220; - $_r0_sroa_0 = $1221; - $1222 = invoke_ii(556, 709 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $_r3_sroa_0 = $1222; - $_r0_sroa_0_0_load605 = $_r0_sroa_0; - $_r3_sroa_0_0_load594 = $_r3_sroa_0; - $_r0_sroa_0 = 0; - $_r0_sroa_0_0_load623 = $_r0_sroa_0; - $1223 = $_r0_sroa_0_0_load623; - $_r3_sroa_0 = $1223; - $_r0_sroa_1_4__r3_sroa_1_4_idx_idx = $_r3_sroa_1 | 0; - $_r0_sroa_1_4_idx156 = $_r0_sroa_1 | 0; - HEAP32[$_r0_sroa_1_4__r3_sroa_1_4_idx_idx >> 2] = HEAP32[$_r0_sroa_1_4_idx156 >> 2] | 0; - $1224 = HEAP32[$1069 >> 2] | 0; - _memcpy($1224 | 0, $1067 | 0, 40); - label = 179; - break; - case 289: - $1226 = HEAP32[$1069 >> 2] | 0; - _memcpy($1226 | 0, $1067 | 0, 40); - $1227 = HEAP32[(113236 | 0) >> 2] | 0; - $1228 = ($1227 | 0) == 0; - if ($1228) { - label = 290; - break; - } else { - label = 291; - break; - } - case 290: - invoke_v(538); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 291; - break; - case 291: - $1231 = $1066 + 20 | 0; - $1232 = $1231; - $1233 = HEAP32[$1232 >> 2] | 0; - $1234 = ($1233 | 0) == 0; - if ($1234) { - label = 305; - break; - } else { - label = 292; - break; - } - case 292: - $1236 = HEAP32[138672 >> 2] | 0; - $1237 = $1233; - $1238 = HEAP32[$1237 >> 2] | 0; - $1239 = $1238; - $1240 = $1236 + 8 | 0; - $1241 = $1240; - $1242 = HEAP32[$1241 >> 2] | 0; - $1243 = ($1238 | 0) == 82712; - if ($1243) { - label = 293; - break; - } else { - $tib1_0_ph_i290 = $1239; - label = 294; - break; - } - case 293: - $1245 = $1233 + 8 | 0; - $1246 = $1245; - $1247 = HEAP32[$1246 >> 2] | 0; - $1248 = $1247 + 8 | 0; - $1249 = $1248; - $1250 = HEAP32[$1249 >> 2] | 0; - $1251 = $1250; - $tib1_0_ph_i290 = $1251; - label = 294; - break; - case 294: - $1252 = $tib1_0_ph_i290 + 56 | 0; - $1253 = HEAP32[$1252 >> 2] | 0; - $1254 = ($1253 | 0) == 0; - if ($1254) { - var $dimension_tib1_0_lcssa_i294 = 0; - var $tib1_0_lcssa_i293 = $tib1_0_ph_i290; - label = 296; - break; - } else { - var $dimension_tib1_029_i296 = 0; - var $1260 = $1253; - label = 297; - break; - } - case 295: - $1255 = $1263; - var $dimension_tib1_0_lcssa_i294 = $1264; - var $tib1_0_lcssa_i293 = $1255; - label = 296; - break; - case 296: - $1256 = $1242 + 56 | 0; - $1257 = $1256; - $1258 = HEAP32[$1257 >> 2] | 0; - $1259 = ($1258 | 0) == 0; - if ($1259) { - var $dimension_tib2_0_lcssa_i301 = 0; - var $tib2_0_lcssa_in_i300 = $1242; - label = 299; - break; - } else { - var $dimension_tib2_024_i298 = 0; - var $1269 = $1258; - label = 298; - break; - } - case 297: - $1261 = $1260 + 8 | 0; - $1262 = $1261; - $1263 = HEAP32[$1262 >> 2] | 0; - $1264 = $dimension_tib1_029_i296 + 1 | 0; - $1265 = $1263 + 56 | 0; - $1266 = $1265; - $1267 = HEAP32[$1266 >> 2] | 0; - $1268 = ($1267 | 0) == 0; - if ($1268) { - label = 295; - break; - } else { - var $dimension_tib1_029_i296 = $1264; - var $1260 = $1267; - label = 297; - break; - } - case 298: - $1270 = $1269 + 8 | 0; - $1271 = $1270; - $1272 = HEAP32[$1271 >> 2] | 0; - $1273 = $dimension_tib2_024_i298 + 1 | 0; - $1274 = $1272 + 56 | 0; - $1275 = $1274; - $1276 = HEAP32[$1275 >> 2] | 0; - $1277 = ($1276 | 0) == 0; - if ($1277) { - var $dimension_tib2_0_lcssa_i301 = $1273; - var $tib2_0_lcssa_in_i300 = $1272; - label = 299; - break; - } else { - var $dimension_tib2_024_i298 = $1273; - var $1269 = $1276; - label = 298; - break; - } - case 299: - $tib2_0_lcssa_i302 = $tib2_0_lcssa_in_i300; - $1278 = ($dimension_tib1_0_lcssa_i294 | 0) < ($dimension_tib2_0_lcssa_i301 | 0); - $1279 = ($tib1_0_lcssa_i293 | 0) == 0; - $or_cond_i303 = $1278 | $1279; - if ($or_cond_i303) { - label = 305; - break; - } else { - $tib1_121_i305 = $tib1_0_lcssa_i293; - label = 300; - break; - } - case 300: - $1280 = ($tib1_121_i305 | 0) == ($tib2_0_lcssa_i302 | 0); - if ($1280) { - label = 361; - break; - } else { - label = 301; - break; - } - case 301: - $1281 = $tib1_121_i305 + 108 | 0; - $1282 = HEAP32[$1281 >> 2] | 0; - $1283 = $tib1_121_i305 + 112 | 0; - $i_0_i308 = 0; - label = 302; - break; - case 302: - $1285 = ($i_0_i308 | 0) < ($1282 | 0); - if ($1285) { - label = 303; - break; - } else { - label = 304; - break; - } - case 303: - $1287 = HEAP32[$1283 >> 2] | 0; - $1288 = $1287 + ($i_0_i308 << 2) | 0; - $1289 = HEAP32[$1288 >> 2] | 0; - $1290 = ($1289 | 0) == ($tib2_0_lcssa_i302 | 0); - $1291 = $i_0_i308 + 1 | 0; - if ($1290) { - label = 361; - break; - } else { - $i_0_i308 = $1291; - label = 302; - break; - } - case 304: - $1293 = $tib1_121_i305 + 40 | 0; - $1294 = HEAP32[$1293 >> 2] | 0; - $1295 = ($1294 | 0) == 0; - if ($1295) { - label = 305; - break; - } else { - $tib1_121_i305 = $1294; - label = 300; - break; - } - case 305: - $1296 = HEAP32[(107740 | 0) >> 2] | 0; - $1297 = ($1296 | 0) == 0; - if ($1297) { - label = 306; - break; - } else { - label = 307; - break; - } - case 306: - invoke_v(374); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 307; - break; - case 307: - $1300 = HEAP32[$1232 >> 2] | 0; - $1301 = ($1300 | 0) == 0; - if ($1301) { - label = 321; - break; - } else { - label = 308; - break; - } - case 308: - $1303 = HEAP32[137616 >> 2] | 0; - $1304 = $1300; - $1305 = HEAP32[$1304 >> 2] | 0; - $1306 = $1305; - $1307 = $1303 + 8 | 0; - $1308 = $1307; - $1309 = HEAP32[$1308 >> 2] | 0; - $1310 = ($1305 | 0) == 82712; - if ($1310) { - label = 309; - break; - } else { - $tib1_0_ph_i269 = $1306; - label = 310; - break; - } - case 309: - $1312 = $1300 + 8 | 0; - $1313 = $1312; - $1314 = HEAP32[$1313 >> 2] | 0; - $1315 = $1314 + 8 | 0; - $1316 = $1315; - $1317 = HEAP32[$1316 >> 2] | 0; - $1318 = $1317; - $tib1_0_ph_i269 = $1318; - label = 310; - break; - case 310: - $1319 = $tib1_0_ph_i269 + 56 | 0; - $1320 = HEAP32[$1319 >> 2] | 0; - $1321 = ($1320 | 0) == 0; - if ($1321) { - var $dimension_tib1_0_lcssa_i273 = 0; - var $tib1_0_lcssa_i272 = $tib1_0_ph_i269; - label = 312; - break; - } else { - var $dimension_tib1_029_i275 = 0; - var $1327 = $1320; - label = 313; - break; - } - case 311: - $1322 = $1330; - var $dimension_tib1_0_lcssa_i273 = $1331; - var $tib1_0_lcssa_i272 = $1322; - label = 312; - break; - case 312: - $1323 = $1309 + 56 | 0; - $1324 = $1323; - $1325 = HEAP32[$1324 >> 2] | 0; - $1326 = ($1325 | 0) == 0; - if ($1326) { - var $dimension_tib2_0_lcssa_i280 = 0; - var $tib2_0_lcssa_in_i279 = $1309; - label = 315; - break; - } else { - var $dimension_tib2_024_i277 = 0; - var $1336 = $1325; - label = 314; - break; - } - case 313: - $1328 = $1327 + 8 | 0; - $1329 = $1328; - $1330 = HEAP32[$1329 >> 2] | 0; - $1331 = $dimension_tib1_029_i275 + 1 | 0; - $1332 = $1330 + 56 | 0; - $1333 = $1332; - $1334 = HEAP32[$1333 >> 2] | 0; - $1335 = ($1334 | 0) == 0; - if ($1335) { - label = 311; - break; - } else { - var $dimension_tib1_029_i275 = $1331; - var $1327 = $1334; - label = 313; - break; - } - case 314: - $1337 = $1336 + 8 | 0; - $1338 = $1337; - $1339 = HEAP32[$1338 >> 2] | 0; - $1340 = $dimension_tib2_024_i277 + 1 | 0; - $1341 = $1339 + 56 | 0; - $1342 = $1341; - $1343 = HEAP32[$1342 >> 2] | 0; - $1344 = ($1343 | 0) == 0; - if ($1344) { - var $dimension_tib2_0_lcssa_i280 = $1340; - var $tib2_0_lcssa_in_i279 = $1339; - label = 315; - break; - } else { - var $dimension_tib2_024_i277 = $1340; - var $1336 = $1343; - label = 314; - break; - } - case 315: - $tib2_0_lcssa_i281 = $tib2_0_lcssa_in_i279; - $1345 = ($dimension_tib1_0_lcssa_i273 | 0) < ($dimension_tib2_0_lcssa_i280 | 0); - $1346 = ($tib1_0_lcssa_i272 | 0) == 0; - $or_cond_i282 = $1345 | $1346; - if ($or_cond_i282) { - label = 321; - break; - } else { - $tib1_121_i284 = $tib1_0_lcssa_i272; - label = 316; - break; - } - case 316: - $1347 = ($tib1_121_i284 | 0) == ($tib2_0_lcssa_i281 | 0); - if ($1347) { - label = 386; - break; - } else { - label = 317; - break; - } - case 317: - $1348 = $tib1_121_i284 + 108 | 0; - $1349 = HEAP32[$1348 >> 2] | 0; - $1350 = $tib1_121_i284 + 112 | 0; - $i_0_i287 = 0; - label = 318; - break; - case 318: - $1352 = ($i_0_i287 | 0) < ($1349 | 0); - if ($1352) { - label = 319; - break; - } else { - label = 320; - break; - } - case 319: - $1354 = HEAP32[$1350 >> 2] | 0; - $1355 = $1354 + ($i_0_i287 << 2) | 0; - $1356 = HEAP32[$1355 >> 2] | 0; - $1357 = ($1356 | 0) == ($tib2_0_lcssa_i281 | 0); - $1358 = $i_0_i287 + 1 | 0; - if ($1357) { - label = 386; - break; - } else { - $i_0_i287 = $1358; - label = 318; - break; - } - case 320: - $1360 = $tib1_121_i284 + 40 | 0; - $1361 = HEAP32[$1360 >> 2] | 0; - $1362 = ($1361 | 0) == 0; - if ($1362) { - label = 321; - break; - } else { - $tib1_121_i284 = $1361; - label = 316; - break; - } - case 321: - $1363 = HEAP32[$1069 >> 2] | 0; - $1364 = $1363; - invoke_vii(48, $1364 | 0, 0 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case 322: - $1366 = HEAP32[(105500 | 0) >> 2] | 0; - $1367 = ($1366 | 0) == 0; - if ($1367) { - label = 323; - break; - } else { - label = 324; - break; - } - case 323: - invoke_v(30); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 324; - break; - case 324: - $1369 = invoke_i(70) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $1370$0 = $1369; - $1370$1 = 0; - $1371 = invoke_iii(364, $1370$0 | 0, $1370$1 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $1372 = $local_env_w4567aaac23b1c44; - $1373 = $1371 + 16 | 0; - $1374 = $1373; - $1375 = HEAP32[$1374 >> 2] | 0; - _memcpy($1372 | 0, $1375 | 0, 40); - $1376 = HEAP32[$1374 >> 2] | 0; - $1377 = $1376; - $1378 = _saveSetjmp($1377 | 0, label, setjmpTable) | 0; - label = 423; - break; - case 423: - $1379 = ($1378 | 0) == 0; - if ($1379) { - label = 325; - break; - } else { - label = 328; - break; - } - case 325: - $_r0_sroa_0 = 1; - $_r0_sroa_0_0_load604 = $_r0_sroa_0; - $1381 = HEAP32[(98772 | 0) >> 2] | 0; - $1382 = ($1381 | 0) == 0; - if ($1382) { - label = 326; - break; - } else { - label = 327; - break; - } - case 326: - invoke_v(702); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 327; - break; - case 327: - HEAP32[140048 >> 2] = $_r0_sroa_0_0_load604; - $_r3_sroa_0_0_load593 = $_r3_sroa_0; - $1384 = $_r3_sroa_0_0_load593; - $1385 = HEAP32[$1384 >> 2] | 0; - $1386 = $1385 + 116 | 0; - $1387 = HEAP32[$1386 >> 2] | 0; - $1388 = $1387 + 4 | 0; - $1389 = HEAP32[$1388 >> 2] | 0; - $1390 = $1389; - $_r3_sroa_0_0_load = $_r3_sroa_0; - $1391 = invoke_ii($1390 | 0, $_r3_sroa_0_0_load | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $1392 = $1391; - $_r0_sroa_0 = $1392; - invoke_viiii(14, 16136 | 0 | 0, 11648 | 0 | 0, 126872 | 0 | 0, 1630 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case 328: - $1394 = HEAP32[$1374 >> 2] | 0; - _memcpy($1394 | 0, $1372 | 0, 40); - $1395 = HEAP32[(113236 | 0) >> 2] | 0; - $1396 = ($1395 | 0) == 0; - if ($1396) { - label = 329; - break; - } else { - label = 330; - break; - } - case 329: - invoke_v(538); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 330; - break; - case 330: - $1399 = $1371 + 20 | 0; - $1400 = $1399; - $1401 = HEAP32[$1400 >> 2] | 0; - $1402 = ($1401 | 0) == 0; - if ($1402) { - label = 344; - break; - } else { - label = 331; - break; - } - case 331: - $1404 = HEAP32[138672 >> 2] | 0; - $1405 = $1401; - $1406 = HEAP32[$1405 >> 2] | 0; - $1407 = $1406; - $1408 = $1404 + 8 | 0; - $1409 = $1408; - $1410 = HEAP32[$1409 >> 2] | 0; - $1411 = ($1406 | 0) == 82712; - if ($1411) { - label = 332; - break; - } else { - $tib1_0_ph_i248 = $1407; - label = 333; - break; - } - case 332: - $1413 = $1401 + 8 | 0; - $1414 = $1413; - $1415 = HEAP32[$1414 >> 2] | 0; - $1416 = $1415 + 8 | 0; - $1417 = $1416; - $1418 = HEAP32[$1417 >> 2] | 0; - $1419 = $1418; - $tib1_0_ph_i248 = $1419; - label = 333; - break; - case 333: - $1420 = $tib1_0_ph_i248 + 56 | 0; - $1421 = HEAP32[$1420 >> 2] | 0; - $1422 = ($1421 | 0) == 0; - if ($1422) { - var $dimension_tib1_0_lcssa_i252 = 0; - var $tib1_0_lcssa_i251 = $tib1_0_ph_i248; - label = 335; - break; - } else { - var $dimension_tib1_029_i254 = 0; - var $1428 = $1421; - label = 336; - break; - } - case 334: - $1423 = $1431; - var $dimension_tib1_0_lcssa_i252 = $1432; - var $tib1_0_lcssa_i251 = $1423; - label = 335; - break; - case 335: - $1424 = $1410 + 56 | 0; - $1425 = $1424; - $1426 = HEAP32[$1425 >> 2] | 0; - $1427 = ($1426 | 0) == 0; - if ($1427) { - var $dimension_tib2_0_lcssa_i259 = 0; - var $tib2_0_lcssa_in_i258 = $1410; - label = 338; - break; - } else { - var $dimension_tib2_024_i256 = 0; - var $1437 = $1426; - label = 337; - break; - } - case 336: - $1429 = $1428 + 8 | 0; - $1430 = $1429; - $1431 = HEAP32[$1430 >> 2] | 0; - $1432 = $dimension_tib1_029_i254 + 1 | 0; - $1433 = $1431 + 56 | 0; - $1434 = $1433; - $1435 = HEAP32[$1434 >> 2] | 0; - $1436 = ($1435 | 0) == 0; - if ($1436) { - label = 334; - break; - } else { - var $dimension_tib1_029_i254 = $1432; - var $1428 = $1435; - label = 336; - break; - } - case 337: - $1438 = $1437 + 8 | 0; - $1439 = $1438; - $1440 = HEAP32[$1439 >> 2] | 0; - $1441 = $dimension_tib2_024_i256 + 1 | 0; - $1442 = $1440 + 56 | 0; - $1443 = $1442; - $1444 = HEAP32[$1443 >> 2] | 0; - $1445 = ($1444 | 0) == 0; - if ($1445) { - var $dimension_tib2_0_lcssa_i259 = $1441; - var $tib2_0_lcssa_in_i258 = $1440; - label = 338; - break; - } else { - var $dimension_tib2_024_i256 = $1441; - var $1437 = $1444; - label = 337; - break; - } - case 338: - $tib2_0_lcssa_i260 = $tib2_0_lcssa_in_i258; - $1446 = ($dimension_tib1_0_lcssa_i252 | 0) < ($dimension_tib2_0_lcssa_i259 | 0); - $1447 = ($tib1_0_lcssa_i251 | 0) == 0; - $or_cond_i261 = $1446 | $1447; - if ($or_cond_i261) { - label = 344; - break; - } else { - $tib1_121_i263 = $tib1_0_lcssa_i251; - label = 339; - break; - } - case 339: - $1448 = ($tib1_121_i263 | 0) == ($tib2_0_lcssa_i260 | 0); - if ($1448) { - label = 361; - break; - } else { - label = 340; - break; - } - case 340: - $1449 = $tib1_121_i263 + 108 | 0; - $1450 = HEAP32[$1449 >> 2] | 0; - $1451 = $tib1_121_i263 + 112 | 0; - $i_0_i266 = 0; - label = 341; - break; - case 341: - $1453 = ($i_0_i266 | 0) < ($1450 | 0); - if ($1453) { - label = 342; - break; - } else { - label = 343; - break; - } - case 342: - $1455 = HEAP32[$1451 >> 2] | 0; - $1456 = $1455 + ($i_0_i266 << 2) | 0; - $1457 = HEAP32[$1456 >> 2] | 0; - $1458 = ($1457 | 0) == ($tib2_0_lcssa_i260 | 0); - $1459 = $i_0_i266 + 1 | 0; - if ($1458) { - label = 361; - break; - } else { - $i_0_i266 = $1459; - label = 341; - break; - } - case 343: - $1461 = $tib1_121_i263 + 40 | 0; - $1462 = HEAP32[$1461 >> 2] | 0; - $1463 = ($1462 | 0) == 0; - if ($1463) { - label = 344; - break; - } else { - $tib1_121_i263 = $1462; - label = 339; - break; - } - case 344: - $1464 = HEAP32[(107740 | 0) >> 2] | 0; - $1465 = ($1464 | 0) == 0; - if ($1465) { - label = 345; - break; - } else { - label = 346; - break; - } - case 345: - invoke_v(374); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 346; - break; - case 346: - $1468 = HEAP32[$1400 >> 2] | 0; - $1469 = ($1468 | 0) == 0; - if ($1469) { - label = 360; - break; - } else { - label = 347; - break; - } - case 347: - $1471 = HEAP32[137616 >> 2] | 0; - $1472 = $1468; - $1473 = HEAP32[$1472 >> 2] | 0; - $1474 = $1473; - $1475 = $1471 + 8 | 0; - $1476 = $1475; - $1477 = HEAP32[$1476 >> 2] | 0; - $1478 = ($1473 | 0) == 82712; - if ($1478) { - label = 348; - break; - } else { - $tib1_0_ph_i227 = $1474; - label = 349; - break; - } - case 348: - $1480 = $1468 + 8 | 0; - $1481 = $1480; - $1482 = HEAP32[$1481 >> 2] | 0; - $1483 = $1482 + 8 | 0; - $1484 = $1483; - $1485 = HEAP32[$1484 >> 2] | 0; - $1486 = $1485; - $tib1_0_ph_i227 = $1486; - label = 349; - break; - case 349: - $1487 = $tib1_0_ph_i227 + 56 | 0; - $1488 = HEAP32[$1487 >> 2] | 0; - $1489 = ($1488 | 0) == 0; - if ($1489) { - var $dimension_tib1_0_lcssa_i231 = 0; - var $tib1_0_lcssa_i230 = $tib1_0_ph_i227; - label = 351; - break; - } else { - var $dimension_tib1_029_i233 = 0; - var $1495 = $1488; - label = 352; - break; - } - case 350: - $1490 = $1498; - var $dimension_tib1_0_lcssa_i231 = $1499; - var $tib1_0_lcssa_i230 = $1490; - label = 351; - break; - case 351: - $1491 = $1477 + 56 | 0; - $1492 = $1491; - $1493 = HEAP32[$1492 >> 2] | 0; - $1494 = ($1493 | 0) == 0; - if ($1494) { - var $dimension_tib2_0_lcssa_i238 = 0; - var $tib2_0_lcssa_in_i237 = $1477; - label = 354; - break; - } else { - var $dimension_tib2_024_i235 = 0; - var $1504 = $1493; - label = 353; - break; - } - case 352: - $1496 = $1495 + 8 | 0; - $1497 = $1496; - $1498 = HEAP32[$1497 >> 2] | 0; - $1499 = $dimension_tib1_029_i233 + 1 | 0; - $1500 = $1498 + 56 | 0; - $1501 = $1500; - $1502 = HEAP32[$1501 >> 2] | 0; - $1503 = ($1502 | 0) == 0; - if ($1503) { - label = 350; - break; - } else { - var $dimension_tib1_029_i233 = $1499; - var $1495 = $1502; - label = 352; - break; - } - case 353: - $1505 = $1504 + 8 | 0; - $1506 = $1505; - $1507 = HEAP32[$1506 >> 2] | 0; - $1508 = $dimension_tib2_024_i235 + 1 | 0; - $1509 = $1507 + 56 | 0; - $1510 = $1509; - $1511 = HEAP32[$1510 >> 2] | 0; - $1512 = ($1511 | 0) == 0; - if ($1512) { - var $dimension_tib2_0_lcssa_i238 = $1508; - var $tib2_0_lcssa_in_i237 = $1507; - label = 354; - break; - } else { - var $dimension_tib2_024_i235 = $1508; - var $1504 = $1511; - label = 353; - break; - } - case 354: - $tib2_0_lcssa_i239 = $tib2_0_lcssa_in_i237; - $1513 = ($dimension_tib1_0_lcssa_i231 | 0) < ($dimension_tib2_0_lcssa_i238 | 0); - $1514 = ($tib1_0_lcssa_i230 | 0) == 0; - $or_cond_i240 = $1513 | $1514; - if ($or_cond_i240) { - label = 360; - break; - } else { - $tib1_121_i242 = $tib1_0_lcssa_i230; - label = 355; - break; - } - case 355: - $1515 = ($tib1_121_i242 | 0) == ($tib2_0_lcssa_i239 | 0); - if ($1515) { - label = 386; - break; - } else { - label = 356; - break; - } - case 356: - $1516 = $tib1_121_i242 + 108 | 0; - $1517 = HEAP32[$1516 >> 2] | 0; - $1518 = $tib1_121_i242 + 112 | 0; - $i_0_i245 = 0; - label = 357; - break; - case 357: - $1520 = ($i_0_i245 | 0) < ($1517 | 0); - if ($1520) { - label = 358; - break; - } else { - label = 359; - break; - } - case 358: - $1522 = HEAP32[$1518 >> 2] | 0; - $1523 = $1522 + ($i_0_i245 << 2) | 0; - $1524 = HEAP32[$1523 >> 2] | 0; - $1525 = ($1524 | 0) == ($tib2_0_lcssa_i239 | 0); - $1526 = $i_0_i245 + 1 | 0; - if ($1525) { - label = 386; - break; - } else { - $i_0_i245 = $1526; - label = 357; - break; - } - case 359: - $1528 = $tib1_121_i242 + 40 | 0; - $1529 = HEAP32[$1528 >> 2] | 0; - $1530 = ($1529 | 0) == 0; - if ($1530) { - label = 360; - break; - } else { - $tib1_121_i242 = $1529; - label = 355; - break; - } - case 360: - $1531 = HEAP32[$1374 >> 2] | 0; - $1532 = $1531; - invoke_vii(48, $1532 | 0, 0 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case 361: - $1533 = HEAP32[(105500 | 0) >> 2] | 0; - $1534 = ($1533 | 0) == 0; - if ($1534) { - label = 362; - break; - } else { - label = 363; - break; - } - case 362: - invoke_v(30); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 363; - break; - case 363: - $1536 = invoke_i(70) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $1537$0 = $1536; - $1537$1 = 0; - $1538 = invoke_iii(364, $1537$0 | 0, $1537$1 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $1539 = $local_env_w4567aaac23b1c48; - $1540 = $1538 + 16 | 0; - $1541 = $1540; - $1542 = HEAP32[$1541 >> 2] | 0; - _memcpy($1539 | 0, $1542 | 0, 40); - $1543 = HEAP32[$1541 >> 2] | 0; - $1544 = $1543; - $1545 = _saveSetjmp($1544 | 0, label, setjmpTable) | 0; - label = 424; - break; - case 424: - $1546 = ($1545 | 0) == 0; - if ($1546) { - label = 364; - break; - } else { - label = 369; - break; - } - case 364: - $1548 = HEAP32[(105500 | 0) >> 2] | 0; - $1549 = ($1548 | 0) == 0; - if ($1549) { - label = 365; - break; - } else { - label = 366; - break; - } - case 365: - invoke_v(30); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 366; - break; - case 366: - $1551 = invoke_i(70) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $1552$0 = $1551; - $1552$1 = 0; - $1553 = invoke_iii(364, $1552$0 | 0, $1552$1 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $1554 = $1553 + 20 | 0; - $1555 = $1554; - $1556 = HEAP32[$1555 >> 2] | 0; - $1557 = $1556; - $_r0_sroa_0 = $1557; - $_r0_sroa_0 = 0; - $_r0_sroa_0_0_load602 = $_r0_sroa_0; - $1558 = HEAP32[(98772 | 0) >> 2] | 0; - $1559 = ($1558 | 0) == 0; - if ($1559) { - label = 367; - break; - } else { - label = 368; - break; - } - case 367: - invoke_v(702); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 368; - break; - case 368: - HEAP32[140048 >> 2] = $_r0_sroa_0_0_load602; - $1561 = HEAP32[$1541 >> 2] | 0; - _memcpy($1561 | 0, $1539 | 0, 40); - label = 239; - break; - case 369: - $1563 = HEAP32[$1541 >> 2] | 0; - _memcpy($1563 | 0, $1539 | 0, 40); - $1564 = HEAP32[(107740 | 0) >> 2] | 0; - $1565 = ($1564 | 0) == 0; - if ($1565) { - label = 370; - break; - } else { - label = 371; - break; - } - case 370: - invoke_v(374); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 371; - break; - case 371: - $1568 = $1538 + 20 | 0; - $1569 = $1568; - $1570 = HEAP32[$1569 >> 2] | 0; - $1571 = ($1570 | 0) == 0; - if ($1571) { - label = 385; - break; - } else { - label = 372; - break; - } - case 372: - $1573 = HEAP32[137616 >> 2] | 0; - $1574 = $1570; - $1575 = HEAP32[$1574 >> 2] | 0; - $1576 = $1575; - $1577 = $1573 + 8 | 0; - $1578 = $1577; - $1579 = HEAP32[$1578 >> 2] | 0; - $1580 = ($1575 | 0) == 82712; - if ($1580) { - label = 373; - break; - } else { - $tib1_0_ph_i185 = $1576; - label = 374; - break; - } - case 373: - $1582 = $1570 + 8 | 0; - $1583 = $1582; - $1584 = HEAP32[$1583 >> 2] | 0; - $1585 = $1584 + 8 | 0; - $1586 = $1585; - $1587 = HEAP32[$1586 >> 2] | 0; - $1588 = $1587; - $tib1_0_ph_i185 = $1588; - label = 374; - break; - case 374: - $1589 = $tib1_0_ph_i185 + 56 | 0; - $1590 = HEAP32[$1589 >> 2] | 0; - $1591 = ($1590 | 0) == 0; - if ($1591) { - var $dimension_tib1_0_lcssa_i189 = 0; - var $tib1_0_lcssa_i188 = $tib1_0_ph_i185; - label = 376; - break; - } else { - var $dimension_tib1_029_i191 = 0; - var $1597 = $1590; - label = 377; - break; - } - case 375: - $1592 = $1600; - var $dimension_tib1_0_lcssa_i189 = $1601; - var $tib1_0_lcssa_i188 = $1592; - label = 376; - break; - case 376: - $1593 = $1579 + 56 | 0; - $1594 = $1593; - $1595 = HEAP32[$1594 >> 2] | 0; - $1596 = ($1595 | 0) == 0; - if ($1596) { - var $dimension_tib2_0_lcssa_i196 = 0; - var $tib2_0_lcssa_in_i195 = $1579; - label = 379; - break; - } else { - var $dimension_tib2_024_i193 = 0; - var $1606 = $1595; - label = 378; - break; - } - case 377: - $1598 = $1597 + 8 | 0; - $1599 = $1598; - $1600 = HEAP32[$1599 >> 2] | 0; - $1601 = $dimension_tib1_029_i191 + 1 | 0; - $1602 = $1600 + 56 | 0; - $1603 = $1602; - $1604 = HEAP32[$1603 >> 2] | 0; - $1605 = ($1604 | 0) == 0; - if ($1605) { - label = 375; - break; - } else { - var $dimension_tib1_029_i191 = $1601; - var $1597 = $1604; - label = 377; - break; - } - case 378: - $1607 = $1606 + 8 | 0; - $1608 = $1607; - $1609 = HEAP32[$1608 >> 2] | 0; - $1610 = $dimension_tib2_024_i193 + 1 | 0; - $1611 = $1609 + 56 | 0; - $1612 = $1611; - $1613 = HEAP32[$1612 >> 2] | 0; - $1614 = ($1613 | 0) == 0; - if ($1614) { - var $dimension_tib2_0_lcssa_i196 = $1610; - var $tib2_0_lcssa_in_i195 = $1609; - label = 379; - break; - } else { - var $dimension_tib2_024_i193 = $1610; - var $1606 = $1613; - label = 378; - break; - } - case 379: - $tib2_0_lcssa_i197 = $tib2_0_lcssa_in_i195; - $1615 = ($dimension_tib1_0_lcssa_i189 | 0) < ($dimension_tib2_0_lcssa_i196 | 0); - $1616 = ($tib1_0_lcssa_i188 | 0) == 0; - $or_cond_i198 = $1615 | $1616; - if ($or_cond_i198) { - label = 385; - break; - } else { - $tib1_121_i200 = $tib1_0_lcssa_i188; - label = 380; - break; - } - case 380: - $1617 = ($tib1_121_i200 | 0) == ($tib2_0_lcssa_i197 | 0); - if ($1617) { - label = 54; - break; - } else { - label = 381; - break; - } - case 381: - $1618 = $tib1_121_i200 + 108 | 0; - $1619 = HEAP32[$1618 >> 2] | 0; - $1620 = $tib1_121_i200 + 112 | 0; - $i_0_i203 = 0; - label = 382; - break; - case 382: - $1622 = ($i_0_i203 | 0) < ($1619 | 0); - if ($1622) { - label = 383; - break; - } else { - label = 384; - break; - } - case 383: - $1624 = HEAP32[$1620 >> 2] | 0; - $1625 = $1624 + ($i_0_i203 << 2) | 0; - $1626 = HEAP32[$1625 >> 2] | 0; - $1627 = ($1626 | 0) == ($tib2_0_lcssa_i197 | 0); - $1628 = $i_0_i203 + 1 | 0; - if ($1627) { - label = 54; - break; - } else { - $i_0_i203 = $1628; - label = 382; - break; - } - case 384: - $1630 = $tib1_121_i200 + 40 | 0; - $1631 = HEAP32[$1630 >> 2] | 0; - $1632 = ($1631 | 0) == 0; - if ($1632) { - label = 385; - break; - } else { - $tib1_121_i200 = $1631; - label = 380; - break; - } - case 385: - $1633 = HEAP32[$1541 >> 2] | 0; - $1634 = $1633; - invoke_vii(48, $1634 | 0, 0 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case 386: - $1635 = HEAP32[(105500 | 0) >> 2] | 0; - $1636 = ($1635 | 0) == 0; - if ($1636) { - label = 387; - break; - } else { - label = 388; - break; - } - case 387: - invoke_v(30); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 388; - break; - case 388: - $1638 = invoke_i(70) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $1639$0 = $1638; - $1639$1 = 0; - $1640 = invoke_iii(364, $1639$0 | 0, $1639$1 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $1641 = $local_env_w4567aaac23b1c50; - $1642 = $1640 + 16 | 0; - $1643 = $1642; - $1644 = HEAP32[$1643 >> 2] | 0; - _memcpy($1641 | 0, $1644 | 0, 40); - $1645 = HEAP32[$1643 >> 2] | 0; - $1646 = $1645; - $1647 = _saveSetjmp($1646 | 0, label, setjmpTable) | 0; - label = 425; - break; - case 425: - $1648 = ($1647 | 0) == 0; - if ($1648) { - label = 389; - break; - } else { - label = 396; - break; - } - case 389: - $1650 = HEAP32[(105500 | 0) >> 2] | 0; - $1651 = ($1650 | 0) == 0; - if ($1651) { - label = 390; - break; - } else { - label = 391; - break; - } - case 390: - invoke_v(30); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 391; - break; - case 391: - $1653 = invoke_i(70) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $1654$0 = $1653; - $1654$1 = 0; - $1655 = invoke_iii(364, $1654$0 | 0, $1654$1 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $1656 = $1655 + 20 | 0; - $1657 = $1656; - $1658 = HEAP32[$1657 >> 2] | 0; - $1659 = $1658; - $_r0_sroa_0 = $1659; - $_r2_sroa_0 = 0; - $_r2_sroa_0_0_load = $_r2_sroa_0; - $1660 = HEAP32[(98772 | 0) >> 2] | 0; - $1661 = ($1660 | 0) == 0; - if ($1661) { - label = 392; - break; - } else { - label = 393; - break; - } - case 392: - invoke_v(702); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 393; - break; - case 393: - HEAP32[140048 >> 2] = $_r2_sroa_0_0_load; - $1663 = HEAP32[(105500 | 0) >> 2] | 0; - $1664 = ($1663 | 0) == 0; - if ($1664) { - label = 394; - break; - } else { - label = 395; - break; - } - case 394: - invoke_v(30); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 395; - break; - case 395: - $1666 = invoke_i(70) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $1667$0 = $1666; - $1667$1 = 0; - $1668 = invoke_iii(364, $1667$0 | 0, $1667$1 | 0) | 0; - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - $_r0_sroa_0_0_load = $_r0_sroa_0; - $1669 = $_r0_sroa_0_0_load; - $1670 = $1668 + 16 | 0; - $1671 = $1668 + 20 | 0; - $1672 = $1671; - HEAP32[$1672 >> 2] = $1669; - $1673 = $1670; - $1674 = HEAP32[$1673 >> 2] | 0; - $1675 = $1674; - invoke_vii(48, $1675 | 0, 0 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case 396: - $1677 = HEAP32[$1643 >> 2] | 0; - _memcpy($1677 | 0, $1641 | 0, 40); - $1678 = HEAP32[(107740 | 0) >> 2] | 0; - $1679 = ($1678 | 0) == 0; - if ($1679) { - label = 397; - break; - } else { - label = 398; - break; - } - case 397: - invoke_v(374); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - label = 398; - break; - case 398: - $1682 = $1640 + 20 | 0; - $1683 = $1682; - $1684 = HEAP32[$1683 >> 2] | 0; - $1685 = ($1684 | 0) == 0; - if ($1685) { - label = 412; - break; - } else { - label = 399; - break; - } - case 399: - $1687 = HEAP32[137616 >> 2] | 0; - $1688 = $1684; - $1689 = HEAP32[$1688 >> 2] | 0; - $1690 = $1689; - $1691 = $1687 + 8 | 0; - $1692 = $1691; - $1693 = HEAP32[$1692 >> 2] | 0; - $1694 = ($1689 | 0) == 82712; - if ($1694) { - label = 400; - break; - } else { - $tib1_0_ph_i = $1690; - label = 401; - break; - } - case 400: - $1696 = $1684 + 8 | 0; - $1697 = $1696; - $1698 = HEAP32[$1697 >> 2] | 0; - $1699 = $1698 + 8 | 0; - $1700 = $1699; - $1701 = HEAP32[$1700 >> 2] | 0; - $1702 = $1701; - $tib1_0_ph_i = $1702; - label = 401; - break; - case 401: - $1703 = $tib1_0_ph_i + 56 | 0; - $1704 = HEAP32[$1703 >> 2] | 0; - $1705 = ($1704 | 0) == 0; - if ($1705) { - var $dimension_tib1_0_lcssa_i = 0; - var $tib1_0_lcssa_i = $tib1_0_ph_i; - label = 403; - break; - } else { - var $dimension_tib1_029_i = 0; - var $1711 = $1704; - label = 404; - break; - } - case 402: - $1706 = $1714; - var $dimension_tib1_0_lcssa_i = $1715; - var $tib1_0_lcssa_i = $1706; - label = 403; - break; - case 403: - $1707 = $1693 + 56 | 0; - $1708 = $1707; - $1709 = HEAP32[$1708 >> 2] | 0; - $1710 = ($1709 | 0) == 0; - if ($1710) { - var $dimension_tib2_0_lcssa_i = 0; - var $tib2_0_lcssa_in_i = $1693; - label = 406; - break; - } else { - var $dimension_tib2_024_i = 0; - var $1720 = $1709; - label = 405; - break; - } - case 404: - $1712 = $1711 + 8 | 0; - $1713 = $1712; - $1714 = HEAP32[$1713 >> 2] | 0; - $1715 = $dimension_tib1_029_i + 1 | 0; - $1716 = $1714 + 56 | 0; - $1717 = $1716; - $1718 = HEAP32[$1717 >> 2] | 0; - $1719 = ($1718 | 0) == 0; - if ($1719) { - label = 402; - break; - } else { - var $dimension_tib1_029_i = $1715; - var $1711 = $1718; - label = 404; - break; - } - case 405: - $1721 = $1720 + 8 | 0; - $1722 = $1721; - $1723 = HEAP32[$1722 >> 2] | 0; - $1724 = $dimension_tib2_024_i + 1 | 0; - $1725 = $1723 + 56 | 0; - $1726 = $1725; - $1727 = HEAP32[$1726 >> 2] | 0; - $1728 = ($1727 | 0) == 0; - if ($1728) { - var $dimension_tib2_0_lcssa_i = $1724; - var $tib2_0_lcssa_in_i = $1723; - label = 406; - break; - } else { - var $dimension_tib2_024_i = $1724; - var $1720 = $1727; - label = 405; - break; - } - case 406: - $tib2_0_lcssa_i = $tib2_0_lcssa_in_i; - $1729 = ($dimension_tib1_0_lcssa_i | 0) < ($dimension_tib2_0_lcssa_i | 0); - $1730 = ($tib1_0_lcssa_i | 0) == 0; - $or_cond_i = $1729 | $1730; - if ($or_cond_i) { - label = 412; - break; - } else { - $tib1_121_i = $tib1_0_lcssa_i; - label = 407; - break; - } - case 407: - $1731 = ($tib1_121_i | 0) == ($tib2_0_lcssa_i | 0); - if ($1731) { - label = 54; - break; - } else { - label = 408; - break; - } - case 408: - $1732 = $tib1_121_i + 108 | 0; - $1733 = HEAP32[$1732 >> 2] | 0; - $1734 = $tib1_121_i + 112 | 0; - $i_0_i = 0; - label = 409; - break; - case 409: - $1736 = ($i_0_i | 0) < ($1733 | 0); - if ($1736) { - label = 410; - break; - } else { - label = 411; - break; - } - case 410: - $1738 = HEAP32[$1734 >> 2] | 0; - $1739 = $1738 + ($i_0_i << 2) | 0; - $1740 = HEAP32[$1739 >> 2] | 0; - $1741 = ($1740 | 0) == ($tib2_0_lcssa_i | 0); - $1742 = $i_0_i + 1 | 0; - if ($1741) { - label = 54; - break; - } else { - $i_0_i = $1742; - label = 409; - break; - } - case 411: - $1744 = $tib1_121_i + 40 | 0; - $1745 = HEAP32[$1744 >> 2] | 0; - $1746 = ($1745 | 0) == 0; - if ($1746) { - label = 412; - break; - } else { - $tib1_121_i = $1745; - label = 407; - break; - } - case 412: - $1747 = HEAP32[$1643 >> 2] | 0; - $1748 = $1747; - invoke_vii(48, $1748 | 0, 0 | 0); - if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { - setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; - if ((setjmpLabel | 0) > 0) { - label = -1111; - break; - } else return 0 | 0; - } - __THREW__ = threwValue = 0; - return 0 | 0; - case -1111: - if ((setjmpLabel | 0) == 7) { - $25 = threwValue; - label = 413; - } else if ((setjmpLabel | 0) == 35) { - $159 = threwValue; - label = 414; - } else if ((setjmpLabel | 0) == 62) { - $290 = threwValue; - label = 415; - } else if ((setjmpLabel | 0) == 91) { - $401 = threwValue; - label = 416; - } else if ((setjmpLabel | 0) == 97) { - $433 = threwValue; - label = 417; - } else if ((setjmpLabel | 0) == 144) { - $629 = threwValue; - label = 418; - } else if ((setjmpLabel | 0) == 181) { - $789 = threwValue; - label = 419; - } else if ((setjmpLabel | 0) == 218) { - $954 = threwValue; - label = 420; - } else if ((setjmpLabel | 0) == 240) { - $1042 = threwValue; - label = 421; - } else if ((setjmpLabel | 0) == 251) { - $1073 = threwValue; - label = 422; - } else if ((setjmpLabel | 0) == 324) { - $1378 = threwValue; - label = 423; - } else if ((setjmpLabel | 0) == 363) { - $1545 = threwValue; - label = 424; - } else if ((setjmpLabel | 0) == 388) { - $1647 = threwValue; - label = 425; - } - __THREW__ = threwValue = 0; - break; + $n1 = $n1 | 0; + var $_r0_sroa_0 = 0, $_r0_sroa_1 = 0, $_r1_sroa_0 = 0, $_r2_sroa_0 = 0, $_r3_sroa_0 = 0, $_r3_sroa_1 = 0, $_r5_sroa_0 = 0, $local_env_w4567aaac23b1b6 = 0; + var $local_env_w4567aaac23b1c16 = 0, $local_env_w4567aaac23b1c22 = 0, $local_env_w4567aaac23b1c24 = 0, $local_env_w4567aaac23b1c26 = 0, $local_env_w4567aaac23b1c29 = 0, $local_env_w4567aaac23b1c31 = 0, $local_env_w4567aaac23b1c35 = 0, $local_env_w4567aaac23b1c40 = 0; + var $local_env_w4567aaac23b1c42 = 0, $local_env_w4567aaac23b1c44 = 0, $local_env_w4567aaac23b1c48 = 0, $local_env_w4567aaac23b1c50 = 0, $1 = 0, $2 = 0, $5 = 0, $6 = 0; + var $7 = 0, $8 = 0, $11 = 0, $_r1_sroa_0_0_load601 = 0, $12 = 0, $13 = 0, $14 = 0, $16 = 0; + var $17$0 = 0, $17$1 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0, $23 = 0; + var $24 = 0, $25 = 0, $26 = 0, $28 = 0, $29 = 0, $31 = 0, $32 = 0, $_r0_sroa_0_0_load622 = 0; + var $33 = 0, $34 = 0, $35 = 0, $36 = 0, $37 = 0, $38 = 0, $_r0_sroa_0_0_load621 = 0, $39 = 0; + var $_r5_sroa_0_0_load592 = 0, $40 = 0, $41 = 0, $_r0_sroa_0_0_load620 = 0, $42 = 0, $_r0_sroa_0_0_load619 = 0, $43 = 0, $45 = 0; + var $46 = 0, $47 = 0, $50 = 0, $51 = 0, $52 = 0, $53 = 0, $55 = 0, $56 = 0; + var $57 = 0, $58 = 0, $59 = 0, $60 = 0, $61 = 0, $62 = 0, $64 = 0, $65 = 0; + var $66 = 0, $67 = 0, $68 = 0, $69 = 0, $70 = 0, $tib1_0_ph_i543 = 0, $71 = 0, $72 = 0; + var $73 = 0, $74 = 0, $tib1_0_lcssa_i546 = 0, $dimension_tib1_0_lcssa_i547 = 0, $75 = 0, $76 = 0, $77 = 0, $78 = 0; + var $79 = 0, $dimension_tib1_029_i549 = 0, $80 = 0, $81 = 0, $82 = 0, $83 = 0, $84 = 0, $85 = 0; + var $86 = 0, $87 = 0, $88 = 0, $dimension_tib2_024_i551 = 0, $89 = 0, $90 = 0, $91 = 0, $92 = 0; + var $93 = 0, $94 = 0, $95 = 0, $96 = 0, $tib2_0_lcssa_in_i553 = 0, $dimension_tib2_0_lcssa_i554 = 0, $tib2_0_lcssa_i555 = 0, $97 = 0; + var $98 = 0, $or_cond_i556 = 0, $tib1_121_i558 = 0, $99 = 0, $100 = 0, $101 = 0, $102 = 0, $i_0_i561 = 0; + var $104 = 0, $106 = 0, $107 = 0, $108 = 0, $109 = 0, $110 = 0, $112 = 0, $113 = 0; + var $114 = 0, $115 = 0, $116 = 0, $_r1_sroa_0_0_load600 = 0, $118 = 0, $119 = 0, $120 = 0, $121 = 0; + var $122 = 0, $123 = 0, $124 = 0, $125 = 0, $126 = 0, $127 = 0, $128 = 0, $129 = 0; + var $131 = 0, $132 = 0, $133 = 0, $134 = 0, $135 = 0, $136 = 0, $137 = 0, $138 = 0; + var $139 = 0, $140 = 0, $142 = 0, $_r0_sroa_0_0_load618 = 0, $143 = 0, $_r5_sroa_0_0_load591 = 0, $145 = 0, $146 = 0; + var $147 = 0, $149 = 0, $150$0 = 0, $150$1 = 0, $151 = 0, $153 = 0, $154 = 0, $155 = 0; + var $156 = 0, $157 = 0, $158 = 0, $159 = 0, $160 = 0, $163 = 0, $164 = 0, $165 = 0; + var $168 = 0, $169 = 0, $170 = 0, $171 = 0, $173 = 0, $174 = 0, $175 = 0, $176 = 0; + var $177 = 0, $178 = 0, $179 = 0, $180 = 0, $182 = 0, $183 = 0, $184 = 0, $185 = 0; + var $186 = 0, $187 = 0, $188 = 0, $tib1_0_ph_i521 = 0, $189 = 0, $190 = 0, $191 = 0, $192 = 0; + var $tib1_0_lcssa_i524 = 0, $dimension_tib1_0_lcssa_i525 = 0, $193 = 0, $194 = 0, $195 = 0, $196 = 0, $197 = 0, $dimension_tib1_029_i527 = 0; + var $198 = 0, $199 = 0, $200 = 0, $201 = 0, $202 = 0, $203 = 0, $204 = 0, $205 = 0; + var $206 = 0, $dimension_tib2_024_i529 = 0, $207 = 0, $208 = 0, $209 = 0, $210 = 0, $211 = 0, $212 = 0; + var $213 = 0, $214 = 0, $tib2_0_lcssa_in_i531 = 0, $dimension_tib2_0_lcssa_i532 = 0, $tib2_0_lcssa_i533 = 0, $215 = 0, $216 = 0, $or_cond_i534 = 0; + var $tib1_121_i536 = 0, $217 = 0, $218 = 0, $219 = 0, $220 = 0, $i_0_i539 = 0, $222 = 0, $224 = 0; + var $225 = 0, $226 = 0, $227 = 0, $228 = 0, $230 = 0, $231 = 0, $232 = 0, $233 = 0; + var $234 = 0, $235 = 0, $236 = 0, $238 = 0, $239$0 = 0, $239$1 = 0, $240 = 0, $241 = 0; + var $242 = 0, $243 = 0, $244 = 0, $_r1_sroa_0_0_load = 0, $245 = 0, $246 = 0, $247 = 0, $248 = 0; + var $249 = 0, $250 = 0, $251 = 0, $252 = 0, $253 = 0, $254 = 0, $255 = 0, $256 = 0; + var $258 = 0, $259 = 0, $260 = 0, $261 = 0, $262 = 0, $263 = 0, $264 = 0, $265 = 0; + var $266 = 0, $267 = 0, $269 = 0, $270 = 0, $271 = 0, $273 = 0, $274$0 = 0, $274$1 = 0; + var $275 = 0, $_r0_sroa_0_0_load617 = 0, $276 = 0, $277 = 0, $278 = 0, $279 = 0, $280 = 0, $281 = 0; + var $282 = 0, $284 = 0, $285 = 0, $286 = 0, $287 = 0, $288 = 0, $289 = 0, $290 = 0; + var $291 = 0, $_r5_sroa_0_0_load590 = 0, $293 = 0, $294 = 0, $296 = 0, $297 = 0, $_r0_sroa_0_0_load616 = 0, $298 = 0; + var $300 = 0, $302 = 0, $303 = 0, $305 = 0, $306 = 0, $307 = 0, $308 = 0, $_r0_sroa_0_0_load615 = 0; + var $309 = 0, $_r0_sroa_0_0_load614 = 0, $310 = 0, $311 = 0, $312 = 0, $314 = 0, $316 = 0, $317 = 0; + var $318 = 0, $321 = 0, $322 = 0, $323 = 0, $324 = 0, $326 = 0, $327 = 0, $328 = 0; + var $329 = 0, $330 = 0, $331 = 0, $332 = 0, $333 = 0, $335 = 0, $336 = 0, $337 = 0; + var $338 = 0, $339 = 0, $340 = 0, $341 = 0, $tib1_0_ph_i500 = 0, $342 = 0, $343 = 0, $344 = 0; + var $345 = 0, $tib1_0_lcssa_i503 = 0, $dimension_tib1_0_lcssa_i504 = 0, $346 = 0, $347 = 0, $348 = 0, $349 = 0, $350 = 0; + var $dimension_tib1_029_i506 = 0, $351 = 0, $352 = 0, $353 = 0, $354 = 0, $355 = 0, $356 = 0, $357 = 0; + var $358 = 0, $359 = 0, $dimension_tib2_024_i508 = 0, $360 = 0, $361 = 0, $362 = 0, $363 = 0, $364 = 0; + var $365 = 0, $366 = 0, $367 = 0, $tib2_0_lcssa_in_i510 = 0, $dimension_tib2_0_lcssa_i511 = 0, $tib2_0_lcssa_i512 = 0, $368 = 0, $369 = 0; + var $or_cond_i513 = 0, $tib1_121_i515 = 0, $370 = 0, $371 = 0, $372 = 0, $373 = 0, $i_0_i518 = 0, $375 = 0; + var $377 = 0, $378 = 0, $379 = 0, $380 = 0, $381 = 0, $383 = 0, $384 = 0, $385 = 0; + var $386 = 0, $387 = 0, $389 = 0, $390 = 0, $392 = 0, $393$0 = 0, $393$1 = 0, $394 = 0; + var $395 = 0, $396 = 0, $397 = 0, $398 = 0, $399 = 0, $400 = 0, $401 = 0, $402 = 0; + var $404 = 0, $405 = 0, $407 = 0, $408 = 0, $_r0_sroa_0_0_load613 = 0, $409 = 0, $410 = 0, $411 = 0; + var $412 = 0, $413 = 0, $414 = 0, $_r0_sroa_0_0_load612 = 0, $415 = 0, $_r5_sroa_0_0_load589 = 0, $416 = 0, $417 = 0; + var $_r0_sroa_0_0_load611 = 0, $418 = 0, $420 = 0, $421 = 0, $422 = 0, $424 = 0, $425$0 = 0, $425$1 = 0; + var $426 = 0, $427 = 0, $428 = 0, $429 = 0, $430 = 0, $431 = 0, $432 = 0, $433 = 0; + var $434 = 0, $_r0_sroa_0_0_load610 = 0, $436 = 0, $_r5_sroa_0_0_load588 = 0, $437 = 0, $439 = 0, $440 = 0, $441 = 0; + var $444 = 0, $445 = 0, $446 = 0, $447 = 0, $449 = 0, $450 = 0, $451 = 0, $452 = 0; + var $453 = 0, $454 = 0, $455 = 0, $456 = 0, $458 = 0, $459 = 0, $460 = 0, $461 = 0; + var $462 = 0, $463 = 0, $464 = 0, $tib1_0_ph_i479 = 0, $465 = 0, $466 = 0, $467 = 0, $468 = 0; + var $tib1_0_lcssa_i482 = 0, $dimension_tib1_0_lcssa_i483 = 0, $469 = 0, $470 = 0, $471 = 0, $472 = 0, $473 = 0, $dimension_tib1_029_i485 = 0; + var $474 = 0, $475 = 0, $476 = 0, $477 = 0, $478 = 0, $479 = 0, $480 = 0, $481 = 0; + var $482 = 0, $dimension_tib2_024_i487 = 0, $483 = 0, $484 = 0, $485 = 0, $486 = 0, $487 = 0, $488 = 0; + var $489 = 0, $490 = 0, $tib2_0_lcssa_in_i489 = 0, $dimension_tib2_0_lcssa_i490 = 0, $tib2_0_lcssa_i491 = 0, $491 = 0, $492 = 0, $or_cond_i492 = 0; + var $tib1_121_i494 = 0, $493 = 0, $494 = 0, $495 = 0, $496 = 0, $i_0_i497 = 0, $498 = 0, $500 = 0; + var $501 = 0, $502 = 0, $503 = 0, $504 = 0, $506 = 0, $507 = 0, $508 = 0, $509 = 0; + var $510 = 0, $512 = 0, $513 = 0, $516 = 0, $517 = 0, $519 = 0, $520$0 = 0, $520$1 = 0; + var $521 = 0, $522 = 0, $523 = 0, $525 = 0, $526 = 0, $527 = 0, $528 = 0, $529 = 0; + var $530 = 0, $531 = 0, $532 = 0, $_phi_trans_insert = 0, $_pre = 0, $534 = 0, $535 = 0, $536 = 0; + var $537 = 0, $538 = 0, $539 = 0, $540 = 0, $541 = 0, $_r2_sroa_0_0_load599 = 0, $542 = 0, $543 = 0; + var $544 = 0, $546 = 0, $547$0 = 0, $547$1 = 0, $548 = 0, $550 = 0, $551 = 0, $552 = 0; + var $555 = 0, $556 = 0, $557 = 0, $558 = 0, $560 = 0, $561 = 0, $562 = 0, $563 = 0; + var $564 = 0, $565 = 0, $566 = 0, $567 = 0, $569 = 0, $570 = 0, $571 = 0, $572 = 0; + var $573 = 0, $574 = 0, $575 = 0, $tib1_0_ph_i458 = 0, $576 = 0, $577 = 0, $578 = 0, $579 = 0; + var $tib1_0_lcssa_i461 = 0, $dimension_tib1_0_lcssa_i462 = 0, $580 = 0, $581 = 0, $582 = 0, $583 = 0, $584 = 0, $dimension_tib1_029_i464 = 0; + var $585 = 0, $586 = 0, $587 = 0, $588 = 0, $589 = 0, $590 = 0, $591 = 0, $592 = 0; + var $593 = 0, $dimension_tib2_024_i466 = 0, $594 = 0, $595 = 0, $596 = 0, $597 = 0, $598 = 0, $599 = 0; + var $600 = 0, $601 = 0, $tib2_0_lcssa_in_i468 = 0, $dimension_tib2_0_lcssa_i469 = 0, $tib2_0_lcssa_i470 = 0, $602 = 0, $603 = 0, $or_cond_i471 = 0; + var $tib1_121_i473 = 0, $604 = 0, $605 = 0, $606 = 0, $607 = 0, $i_0_i476 = 0, $609 = 0, $611 = 0; + var $612 = 0, $613 = 0, $614 = 0, $615 = 0, $617 = 0, $618 = 0, $619 = 0, $620 = 0; + var $621 = 0, $623 = 0, $624 = 0, $625 = 0, $626 = 0, $627 = 0, $628 = 0, $629 = 0; + var $630 = 0, $632 = 0, $633 = 0, $_r2_sroa_0_0_load598 = 0, $_r0_sroa_0_0_load609 = 0, $_r0_sroa_0_0_load624 = 0, $634 = 0, $_r0_sroa_1_4__r3_sroa_1_4_idx108_idx = 0; + var $_r0_sroa_1_4_idx = 0, $635 = 0, $637 = 0, $638 = 0, $639 = 0, $642 = 0, $643 = 0, $644 = 0; + var $645 = 0, $647 = 0, $648 = 0, $649 = 0, $650 = 0, $651 = 0, $652 = 0, $653 = 0; + var $654 = 0, $656 = 0, $657 = 0, $658 = 0, $659 = 0, $660 = 0, $661 = 0, $662 = 0; + var $tib1_0_ph_i437 = 0, $663 = 0, $664 = 0, $665 = 0, $666 = 0, $tib1_0_lcssa_i440 = 0, $dimension_tib1_0_lcssa_i441 = 0, $667 = 0; + var $668 = 0, $669 = 0, $670 = 0, $671 = 0, $dimension_tib1_029_i443 = 0, $672 = 0, $673 = 0, $674 = 0; + var $675 = 0, $676 = 0, $677 = 0, $678 = 0, $679 = 0, $680 = 0, $dimension_tib2_024_i445 = 0, $681 = 0; + var $682 = 0, $683 = 0, $684 = 0, $685 = 0, $686 = 0, $687 = 0, $688 = 0, $tib2_0_lcssa_in_i447 = 0; + var $dimension_tib2_0_lcssa_i448 = 0, $tib2_0_lcssa_i449 = 0, $689 = 0, $690 = 0, $or_cond_i450 = 0, $tib1_121_i452 = 0, $691 = 0, $692 = 0; + var $693 = 0, $694 = 0, $i_0_i455 = 0, $696 = 0, $698 = 0, $699 = 0, $700 = 0, $701 = 0; + var $702 = 0, $704 = 0, $705 = 0, $706 = 0, $707 = 0, $708 = 0, $711 = 0, $712 = 0; + var $714 = 0, $715 = 0, $716 = 0, $717 = 0, $718 = 0, $719 = 0, $720 = 0, $721 = 0; + var $723 = 0, $724 = 0, $725 = 0, $726 = 0, $727 = 0, $728 = 0, $729 = 0, $tib1_0_ph_i416 = 0; + var $730 = 0, $731 = 0, $732 = 0, $733 = 0, $tib1_0_lcssa_i419 = 0, $dimension_tib1_0_lcssa_i420 = 0, $734 = 0, $735 = 0; + var $736 = 0, $737 = 0, $738 = 0, $dimension_tib1_029_i422 = 0, $739 = 0, $740 = 0, $741 = 0, $742 = 0; + var $743 = 0, $744 = 0, $745 = 0, $746 = 0, $747 = 0, $dimension_tib2_024_i424 = 0, $748 = 0, $749 = 0; + var $750 = 0, $751 = 0, $752 = 0, $753 = 0, $754 = 0, $755 = 0, $tib2_0_lcssa_in_i426 = 0, $dimension_tib2_0_lcssa_i427 = 0; + var $tib2_0_lcssa_i428 = 0, $756 = 0, $757 = 0, $or_cond_i429 = 0, $tib1_121_i431 = 0, $758 = 0, $759 = 0, $760 = 0; + var $761 = 0, $i_0_i434 = 0, $763 = 0, $765 = 0, $766 = 0, $767 = 0, $768 = 0, $769 = 0; + var $771 = 0, $772 = 0, $773 = 0, $774 = 0, $775 = 0, $777 = 0, $778 = 0, $780 = 0; + var $781$0 = 0, $781$1 = 0, $782 = 0, $783 = 0, $784 = 0, $785 = 0, $786 = 0, $787 = 0; + var $788 = 0, $789 = 0, $790 = 0, $_r3_sroa_0_0_load596 = 0, $792 = 0, $793 = 0, $794 = 0, $795 = 0; + var $796 = 0, $797 = 0, $_r3_sroa_0_0_load595 = 0, $798 = 0, $799 = 0, $_r0_sroa_0_0_load608 = 0, $800 = 0, $802 = 0; + var $803 = 0, $804 = 0, $807 = 0, $808 = 0, $809 = 0, $810 = 0, $812 = 0, $813 = 0; + var $814 = 0, $815 = 0, $816 = 0, $817 = 0, $818 = 0, $819 = 0, $821 = 0, $822 = 0; + var $823 = 0, $824 = 0, $825 = 0, $826 = 0, $827 = 0, $tib1_0_ph_i395 = 0, $828 = 0, $829 = 0; + var $830 = 0, $831 = 0, $tib1_0_lcssa_i398 = 0, $dimension_tib1_0_lcssa_i399 = 0, $832 = 0, $833 = 0, $834 = 0, $835 = 0; + var $836 = 0, $dimension_tib1_029_i401 = 0, $837 = 0, $838 = 0, $839 = 0, $840 = 0, $841 = 0, $842 = 0; + var $843 = 0, $844 = 0, $845 = 0, $dimension_tib2_024_i403 = 0, $846 = 0, $847 = 0, $848 = 0, $849 = 0; + var $850 = 0, $851 = 0, $852 = 0, $853 = 0, $tib2_0_lcssa_in_i405 = 0, $dimension_tib2_0_lcssa_i406 = 0, $tib2_0_lcssa_i407 = 0, $854 = 0; + var $855 = 0, $or_cond_i408 = 0, $tib1_121_i410 = 0, $856 = 0, $857 = 0, $858 = 0, $859 = 0, $i_0_i413 = 0; + var $861 = 0, $863 = 0, $864 = 0, $865 = 0, $866 = 0, $867 = 0, $869 = 0, $870 = 0; + var $871 = 0, $872 = 0, $873 = 0, $876 = 0, $877 = 0, $879 = 0, $880 = 0, $881 = 0; + var $882 = 0, $883 = 0, $884 = 0, $885 = 0, $886 = 0, $888 = 0, $889 = 0, $890 = 0; + var $891 = 0, $892 = 0, $893 = 0, $894 = 0, $tib1_0_ph_i374 = 0, $895 = 0, $896 = 0, $897 = 0; + var $898 = 0, $tib1_0_lcssa_i377 = 0, $dimension_tib1_0_lcssa_i378 = 0, $899 = 0, $900 = 0, $901 = 0, $902 = 0, $903 = 0; + var $dimension_tib1_029_i380 = 0, $904 = 0, $905 = 0, $906 = 0, $907 = 0, $908 = 0, $909 = 0, $910 = 0; + var $911 = 0, $912 = 0, $dimension_tib2_024_i382 = 0, $913 = 0, $914 = 0, $915 = 0, $916 = 0, $917 = 0; + var $918 = 0, $919 = 0, $920 = 0, $tib2_0_lcssa_in_i384 = 0, $dimension_tib2_0_lcssa_i385 = 0, $tib2_0_lcssa_i386 = 0, $921 = 0, $922 = 0; + var $or_cond_i387 = 0, $tib1_121_i389 = 0, $923 = 0, $924 = 0, $925 = 0, $926 = 0, $i_0_i392 = 0, $928 = 0; + var $930 = 0, $931 = 0, $932 = 0, $933 = 0, $934 = 0, $936 = 0, $937 = 0, $938 = 0; + var $939 = 0, $940 = 0, $942 = 0, $943 = 0, $945 = 0, $946$0 = 0, $946$1 = 0, $947 = 0; + var $948 = 0, $949 = 0, $950 = 0, $951 = 0, $952 = 0, $953 = 0, $954 = 0, $955 = 0; + var $_r0_sroa_0_0_load607 = 0, $957 = 0, $958 = 0, $960 = 0, $962 = 0, $963 = 0, $964 = 0, $967 = 0; + var $968 = 0, $969 = 0, $970 = 0, $972 = 0, $973 = 0, $974 = 0, $975 = 0, $976 = 0; + var $977 = 0, $978 = 0, $979 = 0, $981 = 0, $982 = 0, $983 = 0, $984 = 0, $985 = 0; + var $986 = 0, $987 = 0, $tib1_0_ph_i353 = 0, $988 = 0, $989 = 0, $990 = 0, $991 = 0, $tib1_0_lcssa_i356 = 0; + var $dimension_tib1_0_lcssa_i357 = 0, $992 = 0, $993 = 0, $994 = 0, $995 = 0, $996 = 0, $dimension_tib1_029_i359 = 0, $997 = 0; + var $998 = 0, $999 = 0, $1000 = 0, $1001 = 0, $1002 = 0, $1003 = 0, $1004 = 0, $1005 = 0; + var $dimension_tib2_024_i361 = 0, $1006 = 0, $1007 = 0, $1008 = 0, $1009 = 0, $1010 = 0, $1011 = 0, $1012 = 0; + var $1013 = 0, $tib2_0_lcssa_in_i363 = 0, $dimension_tib2_0_lcssa_i364 = 0, $tib2_0_lcssa_i365 = 0, $1014 = 0, $1015 = 0, $or_cond_i366 = 0, $tib1_121_i368 = 0; + var $1016 = 0, $1017 = 0, $1018 = 0, $1019 = 0, $i_0_i371 = 0, $1021 = 0, $1023 = 0, $1024 = 0; + var $1025 = 0, $1026 = 0, $1027 = 0, $1029 = 0, $1030 = 0, $1031 = 0, $1032 = 0, $1033 = 0; + var $1036 = 0, $1037 = 0, $1038 = 0, $1039 = 0, $1040 = 0, $1041 = 0, $1042 = 0, $1043 = 0; + var $1045 = 0, $1046 = 0, $_pr = 0, $1048 = 0, $1050 = 0, $1051 = 0, $1053 = 0, $1054 = 0; + var $_pre855 = 0, $1056 = 0, $1057 = 0, $_r0_sroa_0_0_load606 = 0, $1058 = 0, $1060 = 0, $1061 = 0, $1062 = 0; + var $1064 = 0, $1065$0 = 0, $1065$1 = 0, $1066 = 0, $1067 = 0, $1068 = 0, $1069 = 0, $1070 = 0; + var $1071 = 0, $1072 = 0, $1073 = 0, $1074 = 0, $1077 = 0, $1078 = 0, $1079 = 0, $1082 = 0; + var $1083 = 0, $1084 = 0, $1085 = 0, $1087 = 0, $1088 = 0, $1089 = 0, $1090 = 0, $1091 = 0; + var $1092 = 0, $1093 = 0, $1094 = 0, $1096 = 0, $1097 = 0, $1098 = 0, $1099 = 0, $1100 = 0; + var $1101 = 0, $1102 = 0, $tib1_0_ph_i332 = 0, $1103 = 0, $1104 = 0, $1105 = 0, $1106 = 0, $tib1_0_lcssa_i335 = 0; + var $dimension_tib1_0_lcssa_i336 = 0, $1107 = 0, $1108 = 0, $1109 = 0, $1110 = 0, $1111 = 0, $dimension_tib1_029_i338 = 0, $1112 = 0; + var $1113 = 0, $1114 = 0, $1115 = 0, $1116 = 0, $1117 = 0, $1118 = 0, $1119 = 0, $1120 = 0; + var $dimension_tib2_024_i340 = 0, $1121 = 0, $1122 = 0, $1123 = 0, $1124 = 0, $1125 = 0, $1126 = 0, $1127 = 0; + var $1128 = 0, $tib2_0_lcssa_in_i342 = 0, $dimension_tib2_0_lcssa_i343 = 0, $tib2_0_lcssa_i344 = 0, $1129 = 0, $1130 = 0, $or_cond_i345 = 0, $tib1_121_i347 = 0; + var $1131 = 0, $1132 = 0, $1133 = 0, $1134 = 0, $i_0_i350 = 0, $1136 = 0, $1138 = 0, $1139 = 0; + var $1140 = 0, $1141 = 0, $1142 = 0, $1144 = 0, $1145 = 0, $1146 = 0, $1147 = 0, $1148 = 0; + var $1151 = 0, $1152 = 0, $1154 = 0, $1155 = 0, $1156 = 0, $1157 = 0, $1158 = 0, $1159 = 0; + var $1160 = 0, $1161 = 0, $1163 = 0, $1164 = 0, $1165 = 0, $1166 = 0, $1167 = 0, $1168 = 0; + var $1169 = 0, $tib1_0_ph_i311 = 0, $1170 = 0, $1171 = 0, $1172 = 0, $1173 = 0, $tib1_0_lcssa_i314 = 0, $dimension_tib1_0_lcssa_i315 = 0; + var $1174 = 0, $1175 = 0, $1176 = 0, $1177 = 0, $1178 = 0, $dimension_tib1_029_i317 = 0, $1179 = 0, $1180 = 0; + var $1181 = 0, $1182 = 0, $1183 = 0, $1184 = 0, $1185 = 0, $1186 = 0, $1187 = 0, $dimension_tib2_024_i319 = 0; + var $1188 = 0, $1189 = 0, $1190 = 0, $1191 = 0, $1192 = 0, $1193 = 0, $1194 = 0, $1195 = 0; + var $tib2_0_lcssa_in_i321 = 0, $dimension_tib2_0_lcssa_i322 = 0, $tib2_0_lcssa_i323 = 0, $1196 = 0, $1197 = 0, $or_cond_i324 = 0, $tib1_121_i326 = 0, $1198 = 0; + var $1199 = 0, $1200 = 0, $1201 = 0, $i_0_i329 = 0, $1203 = 0, $1205 = 0, $1206 = 0, $1207 = 0; + var $1208 = 0, $1209 = 0, $1211 = 0, $1212 = 0, $1213 = 0, $1214 = 0, $1215 = 0, $1217 = 0; + var $1218 = 0, $1220 = 0, $1221 = 0, $1222 = 0, $_r0_sroa_0_0_load605 = 0, $_r3_sroa_0_0_load594 = 0, $_r0_sroa_0_0_load623 = 0, $1223 = 0; + var $_r0_sroa_1_4__r3_sroa_1_4_idx_idx = 0, $_r0_sroa_1_4_idx156 = 0, $1224 = 0, $1226 = 0, $1227 = 0, $1228 = 0, $1231 = 0, $1232 = 0; + var $1233 = 0, $1234 = 0, $1236 = 0, $1237 = 0, $1238 = 0, $1239 = 0, $1240 = 0, $1241 = 0; + var $1242 = 0, $1243 = 0, $1245 = 0, $1246 = 0, $1247 = 0, $1248 = 0, $1249 = 0, $1250 = 0; + var $1251 = 0, $tib1_0_ph_i290 = 0, $1252 = 0, $1253 = 0, $1254 = 0, $1255 = 0, $tib1_0_lcssa_i293 = 0, $dimension_tib1_0_lcssa_i294 = 0; + var $1256 = 0, $1257 = 0, $1258 = 0, $1259 = 0, $1260 = 0, $dimension_tib1_029_i296 = 0, $1261 = 0, $1262 = 0; + var $1263 = 0, $1264 = 0, $1265 = 0, $1266 = 0, $1267 = 0, $1268 = 0, $1269 = 0, $dimension_tib2_024_i298 = 0; + var $1270 = 0, $1271 = 0, $1272 = 0, $1273 = 0, $1274 = 0, $1275 = 0, $1276 = 0, $1277 = 0; + var $tib2_0_lcssa_in_i300 = 0, $dimension_tib2_0_lcssa_i301 = 0, $tib2_0_lcssa_i302 = 0, $1278 = 0, $1279 = 0, $or_cond_i303 = 0, $tib1_121_i305 = 0, $1280 = 0; + var $1281 = 0, $1282 = 0, $1283 = 0, $i_0_i308 = 0, $1285 = 0, $1287 = 0, $1288 = 0, $1289 = 0; + var $1290 = 0, $1291 = 0, $1293 = 0, $1294 = 0, $1295 = 0, $1296 = 0, $1297 = 0, $1300 = 0; + var $1301 = 0, $1303 = 0, $1304 = 0, $1305 = 0, $1306 = 0, $1307 = 0, $1308 = 0, $1309 = 0; + var $1310 = 0, $1312 = 0, $1313 = 0, $1314 = 0, $1315 = 0, $1316 = 0, $1317 = 0, $1318 = 0; + var $tib1_0_ph_i269 = 0, $1319 = 0, $1320 = 0, $1321 = 0, $1322 = 0, $tib1_0_lcssa_i272 = 0, $dimension_tib1_0_lcssa_i273 = 0, $1323 = 0; + var $1324 = 0, $1325 = 0, $1326 = 0, $1327 = 0, $dimension_tib1_029_i275 = 0, $1328 = 0, $1329 = 0, $1330 = 0; + var $1331 = 0, $1332 = 0, $1333 = 0, $1334 = 0, $1335 = 0, $1336 = 0, $dimension_tib2_024_i277 = 0, $1337 = 0; + var $1338 = 0, $1339 = 0, $1340 = 0, $1341 = 0, $1342 = 0, $1343 = 0, $1344 = 0, $tib2_0_lcssa_in_i279 = 0; + var $dimension_tib2_0_lcssa_i280 = 0, $tib2_0_lcssa_i281 = 0, $1345 = 0, $1346 = 0, $or_cond_i282 = 0, $tib1_121_i284 = 0, $1347 = 0, $1348 = 0; + var $1349 = 0, $1350 = 0, $i_0_i287 = 0, $1352 = 0, $1354 = 0, $1355 = 0, $1356 = 0, $1357 = 0; + var $1358 = 0, $1360 = 0, $1361 = 0, $1362 = 0, $1363 = 0, $1364 = 0, $1366 = 0, $1367 = 0; + var $1369 = 0, $1370$0 = 0, $1370$1 = 0, $1371 = 0, $1372 = 0, $1373 = 0, $1374 = 0, $1375 = 0; + var $1376 = 0, $1377 = 0, $1378 = 0, $1379 = 0, $_r0_sroa_0_0_load604 = 0, $1381 = 0, $1382 = 0, $_r3_sroa_0_0_load593 = 0; + var $1384 = 0, $1385 = 0, $1386 = 0, $1387 = 0, $1388 = 0, $1389 = 0, $1390 = 0, $_r3_sroa_0_0_load = 0; + var $1391 = 0, $1392 = 0, $1394 = 0, $1395 = 0, $1396 = 0, $1399 = 0, $1400 = 0, $1401 = 0; + var $1402 = 0, $1404 = 0, $1405 = 0, $1406 = 0, $1407 = 0, $1408 = 0, $1409 = 0, $1410 = 0; + var $1411 = 0, $1413 = 0, $1414 = 0, $1415 = 0, $1416 = 0, $1417 = 0, $1418 = 0, $1419 = 0; + var $tib1_0_ph_i248 = 0, $1420 = 0, $1421 = 0, $1422 = 0, $1423 = 0, $tib1_0_lcssa_i251 = 0, $dimension_tib1_0_lcssa_i252 = 0, $1424 = 0; + var $1425 = 0, $1426 = 0, $1427 = 0, $1428 = 0, $dimension_tib1_029_i254 = 0, $1429 = 0, $1430 = 0, $1431 = 0; + var $1432 = 0, $1433 = 0, $1434 = 0, $1435 = 0, $1436 = 0, $1437 = 0, $dimension_tib2_024_i256 = 0, $1438 = 0; + var $1439 = 0, $1440 = 0, $1441 = 0, $1442 = 0, $1443 = 0, $1444 = 0, $1445 = 0, $tib2_0_lcssa_in_i258 = 0; + var $dimension_tib2_0_lcssa_i259 = 0, $tib2_0_lcssa_i260 = 0, $1446 = 0, $1447 = 0, $or_cond_i261 = 0, $tib1_121_i263 = 0, $1448 = 0, $1449 = 0; + var $1450 = 0, $1451 = 0, $i_0_i266 = 0, $1453 = 0, $1455 = 0, $1456 = 0, $1457 = 0, $1458 = 0; + var $1459 = 0, $1461 = 0, $1462 = 0, $1463 = 0, $1464 = 0, $1465 = 0, $1468 = 0, $1469 = 0; + var $1471 = 0, $1472 = 0, $1473 = 0, $1474 = 0, $1475 = 0, $1476 = 0, $1477 = 0, $1478 = 0; + var $1480 = 0, $1481 = 0, $1482 = 0, $1483 = 0, $1484 = 0, $1485 = 0, $1486 = 0, $tib1_0_ph_i227 = 0; + var $1487 = 0, $1488 = 0, $1489 = 0, $1490 = 0, $tib1_0_lcssa_i230 = 0, $dimension_tib1_0_lcssa_i231 = 0, $1491 = 0, $1492 = 0; + var $1493 = 0, $1494 = 0, $1495 = 0, $dimension_tib1_029_i233 = 0, $1496 = 0, $1497 = 0, $1498 = 0, $1499 = 0; + var $1500 = 0, $1501 = 0, $1502 = 0, $1503 = 0, $1504 = 0, $dimension_tib2_024_i235 = 0, $1505 = 0, $1506 = 0; + var $1507 = 0, $1508 = 0, $1509 = 0, $1510 = 0, $1511 = 0, $1512 = 0, $tib2_0_lcssa_in_i237 = 0, $dimension_tib2_0_lcssa_i238 = 0; + var $tib2_0_lcssa_i239 = 0, $1513 = 0, $1514 = 0, $or_cond_i240 = 0, $tib1_121_i242 = 0, $1515 = 0, $1516 = 0, $1517 = 0; + var $1518 = 0, $i_0_i245 = 0, $1520 = 0, $1522 = 0, $1523 = 0, $1524 = 0, $1525 = 0, $1526 = 0; + var $1528 = 0, $1529 = 0, $1530 = 0, $1531 = 0, $1532 = 0, $1533 = 0, $1534 = 0, $1536 = 0; + var $1537$0 = 0, $1537$1 = 0, $1538 = 0, $1539 = 0, $1540 = 0, $1541 = 0, $1542 = 0, $1543 = 0; + var $1544 = 0, $1545 = 0, $1546 = 0, $1548 = 0, $1549 = 0, $1551 = 0, $1552$0 = 0, $1552$1 = 0; + var $1553 = 0, $1554 = 0, $1555 = 0, $1556 = 0, $1557 = 0, $_r0_sroa_0_0_load602 = 0, $1558 = 0, $1559 = 0; + var $1561 = 0, $1563 = 0, $1564 = 0, $1565 = 0, $1568 = 0, $1569 = 0, $1570 = 0, $1571 = 0; + var $1573 = 0, $1574 = 0, $1575 = 0, $1576 = 0, $1577 = 0, $1578 = 0, $1579 = 0, $1580 = 0; + var $1582 = 0, $1583 = 0, $1584 = 0, $1585 = 0, $1586 = 0, $1587 = 0, $1588 = 0, $tib1_0_ph_i185 = 0; + var $1589 = 0, $1590 = 0, $1591 = 0, $1592 = 0, $tib1_0_lcssa_i188 = 0, $dimension_tib1_0_lcssa_i189 = 0, $1593 = 0, $1594 = 0; + var $1595 = 0, $1596 = 0, $1597 = 0, $dimension_tib1_029_i191 = 0, $1598 = 0, $1599 = 0, $1600 = 0, $1601 = 0; + var $1602 = 0, $1603 = 0, $1604 = 0, $1605 = 0, $1606 = 0, $dimension_tib2_024_i193 = 0, $1607 = 0, $1608 = 0; + var $1609 = 0, $1610 = 0, $1611 = 0, $1612 = 0, $1613 = 0, $1614 = 0, $tib2_0_lcssa_in_i195 = 0, $dimension_tib2_0_lcssa_i196 = 0; + var $tib2_0_lcssa_i197 = 0, $1615 = 0, $1616 = 0, $or_cond_i198 = 0, $tib1_121_i200 = 0, $1617 = 0, $1618 = 0, $1619 = 0; + var $1620 = 0, $i_0_i203 = 0, $1622 = 0, $1624 = 0, $1625 = 0, $1626 = 0, $1627 = 0, $1628 = 0; + var $1630 = 0, $1631 = 0, $1632 = 0, $1633 = 0, $1634 = 0, $1635 = 0, $1636 = 0, $1638 = 0; + var $1639$0 = 0, $1639$1 = 0, $1640 = 0, $1641 = 0, $1642 = 0, $1643 = 0, $1644 = 0, $1645 = 0; + var $1646 = 0, $1647 = 0, $1648 = 0, $1650 = 0, $1651 = 0, $1653 = 0, $1654$0 = 0, $1654$1 = 0; + var $1655 = 0, $1656 = 0, $1657 = 0, $1658 = 0, $1659 = 0, $_r2_sroa_0_0_load = 0, $1660 = 0, $1661 = 0; + var $1663 = 0, $1664 = 0, $1666 = 0, $1667$0 = 0, $1667$1 = 0, $1668 = 0, $_r0_sroa_0_0_load = 0, $1669 = 0; + var $1670 = 0, $1671 = 0, $1672 = 0, $1673 = 0, $1674 = 0, $1675 = 0, $1677 = 0, $1678 = 0; + var $1679 = 0, $1682 = 0, $1683 = 0, $1684 = 0, $1685 = 0, $1687 = 0, $1688 = 0, $1689 = 0; + var $1690 = 0, $1691 = 0, $1692 = 0, $1693 = 0, $1694 = 0, $1696 = 0, $1697 = 0, $1698 = 0; + var $1699 = 0, $1700 = 0, $1701 = 0, $1702 = 0, $tib1_0_ph_i = 0, $1703 = 0, $1704 = 0, $1705 = 0; + var $1706 = 0, $tib1_0_lcssa_i = 0, $dimension_tib1_0_lcssa_i = 0, $1707 = 0, $1708 = 0, $1709 = 0, $1710 = 0, $1711 = 0; + var $dimension_tib1_029_i = 0, $1712 = 0, $1713 = 0, $1714 = 0, $1715 = 0, $1716 = 0, $1717 = 0, $1718 = 0; + var $1719 = 0, $1720 = 0, $dimension_tib2_024_i = 0, $1721 = 0, $1722 = 0, $1723 = 0, $1724 = 0, $1725 = 0; + var $1726 = 0, $1727 = 0, $1728 = 0, $tib2_0_lcssa_in_i = 0, $dimension_tib2_0_lcssa_i = 0, $tib2_0_lcssa_i = 0, $1729 = 0, $1730 = 0; + var $or_cond_i = 0, $tib1_121_i = 0, $1731 = 0, $1732 = 0, $1733 = 0, $1734 = 0, $i_0_i = 0, $1736 = 0; + var $1738 = 0, $1739 = 0, $1740 = 0, $1741 = 0, $1742 = 0, $1744 = 0, $1745 = 0, $1746 = 0; + var $1747 = 0, $1748 = 0; + var label = 0; + var __stackBase__ = 0; + __stackBase__ = STACKTOP; + STACKTOP = STACKTOP + 536 | 0; + label = 1; + var setjmpLabel = 0; + var setjmpTable = STACKTOP; + STACKTOP = STACKTOP + 168 | 0; + HEAP32[setjmpTable >> 2] = 0; + while (1) switch (label | 0) { + case 1: + $_r0_sroa_1 = __stackBase__ | 0; + $_r3_sroa_1 = __stackBase__ + 8 | 0; + $local_env_w4567aaac23b1b6 = __stackBase__ + 16 | 0; + $local_env_w4567aaac23b1c16 = __stackBase__ + 56 | 0; + $local_env_w4567aaac23b1c22 = __stackBase__ + 96 | 0; + $local_env_w4567aaac23b1c24 = __stackBase__ + 136 | 0; + $local_env_w4567aaac23b1c26 = __stackBase__ + 176 | 0; + $local_env_w4567aaac23b1c29 = __stackBase__ + 216 | 0; + $local_env_w4567aaac23b1c31 = __stackBase__ + 256 | 0; + $local_env_w4567aaac23b1c35 = __stackBase__ + 296 | 0; + $local_env_w4567aaac23b1c40 = __stackBase__ + 336 | 0; + $local_env_w4567aaac23b1c42 = __stackBase__ + 376 | 0; + $local_env_w4567aaac23b1c44 = __stackBase__ + 416 | 0; + $local_env_w4567aaac23b1c48 = __stackBase__ + 456 | 0; + $local_env_w4567aaac23b1c50 = __stackBase__ + 496 | 0; + $1 = HEAP32[(98772 | 0) >> 2] | 0; + $2 = ($1 | 0) == 0; + if ($2) { + label = 2; + break; + } else { + label = 3; + break; + } + case 2: + invoke_v(702); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 3; + break; + case 3: + $_r5_sroa_0 = $n1; + $5 = invoke_ii(556, 709 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $6 = $5; + $_r0_sroa_0 = $6; + $7 = HEAP32[(98772 | 0) >> 2] | 0; + $8 = ($7 | 0) == 0; + if ($8) { + label = 4; + break; + } else { + label = 5; + break; + } + case 4: + invoke_v(702); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 5; + break; + case 5: + $11 = HEAP32[136048 >> 2] | 0; + $_r1_sroa_0 = $11; + $_r1_sroa_0_0_load601 = $_r1_sroa_0; + $12 = invoke_ii(202, $_r1_sroa_0_0_load601 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $13 = HEAP32[(105500 | 0) >> 2] | 0; + $14 = ($13 | 0) == 0; + if ($14) { + label = 6; + break; + } else { + label = 7; + break; + } + case 6: + invoke_v(30); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 7; + break; + case 7: + $16 = invoke_i(70) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $17$0 = $16; + $17$1 = 0; + $18 = invoke_iii(364, $17$0 | 0, $17$1 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $19 = $local_env_w4567aaac23b1b6; + $20 = $18 + 16 | 0; + $21 = $20; + $22 = HEAP32[$21 >> 2] | 0; + _memcpy($19 | 0, $22 | 0, 40); + $23 = HEAP32[$21 >> 2] | 0; + $24 = $23; + $25 = _saveSetjmp($24 | 0, label, setjmpTable) | 0; + label = 413; + break; + case 413: + $26 = ($25 | 0) == 0; + if ($26) { + label = 8; + break; + } else { + label = 11; + break; + } + case 8: + $28 = HEAP32[(98772 | 0) >> 2] | 0; + $29 = ($28 | 0) == 0; + if ($29) { + label = 9; + break; + } else { + label = 10; + break; + } + case 9: + invoke_v(702); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 10; + break; + case 10: + $31 = HEAP32[140056 >> 2] | 0; + $32 = $31; + $_r0_sroa_0 = $32; + $_r0_sroa_0_0_load622 = $_r0_sroa_0; + $33 = $_r0_sroa_0_0_load622; + $34 = $33 | 0; + $35 = HEAP32[$34 >> 2] | 0; + $36 = $35 + 160 | 0; + $37 = HEAP32[$36 >> 2] | 0; + $38 = $37; + $_r0_sroa_0_0_load621 = $_r0_sroa_0; + $39 = $_r0_sroa_0_0_load621; + $_r5_sroa_0_0_load592 = $_r5_sroa_0; + $40 = invoke_iii($38 | 0, $39 | 0, $_r5_sroa_0_0_load592 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $41 = $40; + $_r0_sroa_0 = $41; + $_r0_sroa_0_0_load620 = $_r0_sroa_0; + $_r0_sroa_0 = $_r0_sroa_0_0_load620; + $42 = HEAP32[$21 >> 2] | 0; + _memcpy($42 | 0, $19 | 0, 40); + $_r0_sroa_0_0_load619 = $_r0_sroa_0; + $43 = ($_r0_sroa_0_0_load619 | 0) == 0; + if ($43) { + label = 32; + break; + } else { + label = 28; + break; + } + case 11: + $45 = HEAP32[$21 >> 2] | 0; + _memcpy($45 | 0, $19 | 0, 40); + $46 = HEAP32[(107740 | 0) >> 2] | 0; + $47 = ($46 | 0) == 0; + if ($47) { + label = 12; + break; + } else { + label = 13; + break; + } + case 12: + invoke_v(374); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 13; + break; + case 13: + $50 = $18 + 20 | 0; + $51 = $50; + $52 = HEAP32[$51 >> 2] | 0; + $53 = ($52 | 0) == 0; + if ($53) { + label = 27; + break; + } else { + label = 14; + break; + } + case 14: + $55 = HEAP32[137616 >> 2] | 0; + $56 = $52; + $57 = HEAP32[$56 >> 2] | 0; + $58 = $57; + $59 = $55 + 8 | 0; + $60 = $59; + $61 = HEAP32[$60 >> 2] | 0; + $62 = ($57 | 0) == 82712; + if ($62) { + label = 15; + break; + } else { + $tib1_0_ph_i543 = $58; + label = 16; + break; + } + case 15: + $64 = $52 + 8 | 0; + $65 = $64; + $66 = HEAP32[$65 >> 2] | 0; + $67 = $66 + 8 | 0; + $68 = $67; + $69 = HEAP32[$68 >> 2] | 0; + $70 = $69; + $tib1_0_ph_i543 = $70; + label = 16; + break; + case 16: + $71 = $tib1_0_ph_i543 + 56 | 0; + $72 = HEAP32[$71 >> 2] | 0; + $73 = ($72 | 0) == 0; + if ($73) { + var $dimension_tib1_0_lcssa_i547 = 0; + var $tib1_0_lcssa_i546 = $tib1_0_ph_i543; + label = 18; + break; + } else { + var $dimension_tib1_029_i549 = 0; + var $79 = $72; + label = 19; + break; + } + case 17: + $74 = $82; + var $dimension_tib1_0_lcssa_i547 = $83; + var $tib1_0_lcssa_i546 = $74; + label = 18; + break; + case 18: + $75 = $61 + 56 | 0; + $76 = $75; + $77 = HEAP32[$76 >> 2] | 0; + $78 = ($77 | 0) == 0; + if ($78) { + var $dimension_tib2_0_lcssa_i554 = 0; + var $tib2_0_lcssa_in_i553 = $61; + label = 21; + break; + } else { + var $dimension_tib2_024_i551 = 0; + var $88 = $77; + label = 20; + break; + } + case 19: + $80 = $79 + 8 | 0; + $81 = $80; + $82 = HEAP32[$81 >> 2] | 0; + $83 = $dimension_tib1_029_i549 + 1 | 0; + $84 = $82 + 56 | 0; + $85 = $84; + $86 = HEAP32[$85 >> 2] | 0; + $87 = ($86 | 0) == 0; + if ($87) { + label = 17; + break; + } else { + var $dimension_tib1_029_i549 = $83; + var $79 = $86; + label = 19; + break; + } + case 20: + $89 = $88 + 8 | 0; + $90 = $89; + $91 = HEAP32[$90 >> 2] | 0; + $92 = $dimension_tib2_024_i551 + 1 | 0; + $93 = $91 + 56 | 0; + $94 = $93; + $95 = HEAP32[$94 >> 2] | 0; + $96 = ($95 | 0) == 0; + if ($96) { + var $dimension_tib2_0_lcssa_i554 = $92; + var $tib2_0_lcssa_in_i553 = $91; + label = 21; + break; + } else { + var $dimension_tib2_024_i551 = $92; + var $88 = $95; + label = 20; + break; + } + case 21: + $tib2_0_lcssa_i555 = $tib2_0_lcssa_in_i553; + $97 = ($dimension_tib1_0_lcssa_i547 | 0) < ($dimension_tib2_0_lcssa_i554 | 0); + $98 = ($tib1_0_lcssa_i546 | 0) == 0; + $or_cond_i556 = $97 | $98; + if ($or_cond_i556) { + label = 27; + break; + } else { + $tib1_121_i558 = $tib1_0_lcssa_i546; + label = 22; + break; + } + case 22: + $99 = ($tib1_121_i558 | 0) == ($tib2_0_lcssa_i555 | 0); + if ($99) { + label = 54; + break; + } else { + label = 23; + break; + } + case 23: + $100 = $tib1_121_i558 + 108 | 0; + $101 = HEAP32[$100 >> 2] | 0; + $102 = $tib1_121_i558 + 112 | 0; + $i_0_i561 = 0; + label = 24; + break; + case 24: + $104 = ($i_0_i561 | 0) < ($101 | 0); + if ($104) { + label = 25; + break; + } else { + label = 26; + break; + } + case 25: + $106 = HEAP32[$102 >> 2] | 0; + $107 = $106 + ($i_0_i561 << 2) | 0; + $108 = HEAP32[$107 >> 2] | 0; + $109 = ($108 | 0) == ($tib2_0_lcssa_i555 | 0); + $110 = $i_0_i561 + 1 | 0; + if ($109) { + label = 54; + break; + } else { + $i_0_i561 = $110; + label = 24; + break; + } + case 26: + $112 = $tib1_121_i558 + 40 | 0; + $113 = HEAP32[$112 >> 2] | 0; + $114 = ($113 | 0) == 0; + if ($114) { + label = 27; + break; + } else { + $tib1_121_i558 = $113; + label = 22; + break; + } + case 27: + $115 = HEAP32[$21 >> 2] | 0; + $116 = $115; + invoke_vii(48, $116 | 0, 0 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case 28: + $_r1_sroa_0_0_load600 = $_r1_sroa_0; + $118 = $_r1_sroa_0_0_load600 + 4 | 0; + $119 = $118; + $120 = HEAP32[$119 >> 2] | 0; + $121 = $120 + 8 | 0; + $122 = $121; + $123 = HEAP32[$122 >> 2] | 0; + $124 = $123 - 1 | 0; + HEAP32[$122 >> 2] = $124; + $125 = HEAP32[$119 >> 2] | 0; + $126 = $125 + 8 | 0; + $127 = $126; + $128 = HEAP32[$127 >> 2] | 0; + $129 = ($128 | 0) == 0; + if ($129) { + label = 29; + break; + } else { + label = 31; + break; + } + case 29: + invoke_vi(28, $_r1_sroa_0_0_load600 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $131 = HEAP32[$119 >> 2] | 0; + $132 = $131 + 16 | 0; + $133 = $132; + $134 = HEAP32[$133 >> 2] | 0; + $135 = $134 + 8 | 0; + $136 = $135; + $137 = HEAP32[$136 >> 2] | 0; + $138 = $137; + $139; + $140 = ($139 | 0) == 0; + if ($140) { + label = 31; + break; + } else { + label = 30; + break; + } + case 30: + $142 = invoke_iii(268, 31e3 | 0 | 0, (tempInt = STACKTOP, STACKTOP = STACKTOP + 8 | 0, HEAP32[tempInt >> 2] = $139, tempInt) | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 31; + break; + case 31: + $_r0_sroa_0_0_load618 = $_r0_sroa_0; + $143 = $_r0_sroa_0_0_load618; + STACKTOP = __stackBase__; + return $143 | 0; + case 32: + $_r5_sroa_0_0_load591 = $_r5_sroa_0; + $145 = ($_r5_sroa_0_0_load591 | 0) == 0; + $146 = HEAP32[(105500 | 0) >> 2] | 0; + $147 = ($146 | 0) == 0; + if ($147) { + label = 33; + break; + } else { + label = 34; + break; + } + case 33: + invoke_v(30); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 34; + break; + case 34: + $149 = invoke_i(70) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $150$0 = $149; + $150$1 = 0; + $151 = invoke_iii(364, $150$0 | 0, $150$1 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + if ($145) { + label = 35; + break; + } else { + label = 62; + break; + } + case 35: + $153 = $local_env_w4567aaac23b1c16; + $154 = $151 + 16 | 0; + $155 = $154; + $156 = HEAP32[$155 >> 2] | 0; + _memcpy($153 | 0, $156 | 0, 40); + $157 = HEAP32[$155 >> 2] | 0; + $158 = $157; + $159 = _saveSetjmp($158 | 0, label, setjmpTable) | 0; + label = 414; + break; + case 414: + $160 = ($159 | 0) == 0; + if ($160) { + label = 36; + break; + } else { + label = 37; + break; + } + case 36: + invoke_viiii(14, 16136 | 0 | 0, 11648 | 0 | 0, 126872 | 0 | 0, 1457 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case 37: + $163 = HEAP32[$155 >> 2] | 0; + _memcpy($163 | 0, $153 | 0, 40); + $164 = HEAP32[(107740 | 0) >> 2] | 0; + $165 = ($164 | 0) == 0; + if ($165) { + label = 38; + break; + } else { + label = 39; + break; + } + case 38: + invoke_v(374); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 39; + break; + case 39: + $168 = $151 + 20 | 0; + $169 = $168; + $170 = HEAP32[$169 >> 2] | 0; + $171 = ($170 | 0) == 0; + if ($171) { + label = 53; + break; + } else { + label = 40; + break; + } + case 40: + $173 = HEAP32[137616 >> 2] | 0; + $174 = $170; + $175 = HEAP32[$174 >> 2] | 0; + $176 = $175; + $177 = $173 + 8 | 0; + $178 = $177; + $179 = HEAP32[$178 >> 2] | 0; + $180 = ($175 | 0) == 82712; + if ($180) { + label = 41; + break; + } else { + $tib1_0_ph_i521 = $176; + label = 42; + break; + } + case 41: + $182 = $170 + 8 | 0; + $183 = $182; + $184 = HEAP32[$183 >> 2] | 0; + $185 = $184 + 8 | 0; + $186 = $185; + $187 = HEAP32[$186 >> 2] | 0; + $188 = $187; + $tib1_0_ph_i521 = $188; + label = 42; + break; + case 42: + $189 = $tib1_0_ph_i521 + 56 | 0; + $190 = HEAP32[$189 >> 2] | 0; + $191 = ($190 | 0) == 0; + if ($191) { + var $dimension_tib1_0_lcssa_i525 = 0; + var $tib1_0_lcssa_i524 = $tib1_0_ph_i521; + label = 44; + break; + } else { + var $dimension_tib1_029_i527 = 0; + var $197 = $190; + label = 45; + break; + } + case 43: + $192 = $200; + var $dimension_tib1_0_lcssa_i525 = $201; + var $tib1_0_lcssa_i524 = $192; + label = 44; + break; + case 44: + $193 = $179 + 56 | 0; + $194 = $193; + $195 = HEAP32[$194 >> 2] | 0; + $196 = ($195 | 0) == 0; + if ($196) { + var $dimension_tib2_0_lcssa_i532 = 0; + var $tib2_0_lcssa_in_i531 = $179; + label = 47; + break; + } else { + var $dimension_tib2_024_i529 = 0; + var $206 = $195; + label = 46; + break; + } + case 45: + $198 = $197 + 8 | 0; + $199 = $198; + $200 = HEAP32[$199 >> 2] | 0; + $201 = $dimension_tib1_029_i527 + 1 | 0; + $202 = $200 + 56 | 0; + $203 = $202; + $204 = HEAP32[$203 >> 2] | 0; + $205 = ($204 | 0) == 0; + if ($205) { + label = 43; + break; + } else { + var $dimension_tib1_029_i527 = $201; + var $197 = $204; + label = 45; + break; + } + case 46: + $207 = $206 + 8 | 0; + $208 = $207; + $209 = HEAP32[$208 >> 2] | 0; + $210 = $dimension_tib2_024_i529 + 1 | 0; + $211 = $209 + 56 | 0; + $212 = $211; + $213 = HEAP32[$212 >> 2] | 0; + $214 = ($213 | 0) == 0; + if ($214) { + var $dimension_tib2_0_lcssa_i532 = $210; + var $tib2_0_lcssa_in_i531 = $209; + label = 47; + break; + } else { + var $dimension_tib2_024_i529 = $210; + var $206 = $213; + label = 46; + break; + } + case 47: + $tib2_0_lcssa_i533 = $tib2_0_lcssa_in_i531; + $215 = ($dimension_tib1_0_lcssa_i525 | 0) < ($dimension_tib2_0_lcssa_i532 | 0); + $216 = ($tib1_0_lcssa_i524 | 0) == 0; + $or_cond_i534 = $215 | $216; + if ($or_cond_i534) { + label = 53; + break; + } else { + $tib1_121_i536 = $tib1_0_lcssa_i524; + label = 48; + break; + } + case 48: + $217 = ($tib1_121_i536 | 0) == ($tib2_0_lcssa_i533 | 0); + if ($217) { + label = 54; + break; + } else { + label = 49; + break; + } + case 49: + $218 = $tib1_121_i536 + 108 | 0; + $219 = HEAP32[$218 >> 2] | 0; + $220 = $tib1_121_i536 + 112 | 0; + $i_0_i539 = 0; + label = 50; + break; + case 50: + $222 = ($i_0_i539 | 0) < ($219 | 0); + if ($222) { + label = 51; + break; + } else { + label = 52; + break; + } + case 51: + $224 = HEAP32[$220 >> 2] | 0; + $225 = $224 + ($i_0_i539 << 2) | 0; + $226 = HEAP32[$225 >> 2] | 0; + $227 = ($226 | 0) == ($tib2_0_lcssa_i533 | 0); + $228 = $i_0_i539 + 1 | 0; + if ($227) { + label = 54; + break; + } else { + $i_0_i539 = $228; + label = 50; + break; + } + case 52: + $230 = $tib1_121_i536 + 40 | 0; + $231 = HEAP32[$230 >> 2] | 0; + $232 = ($231 | 0) == 0; + if ($232) { + label = 53; + break; + } else { + $tib1_121_i536 = $231; + label = 48; + break; + } + case 53: + $233 = HEAP32[$155 >> 2] | 0; + $234 = $233; + invoke_vii(48, $234 | 0, 0 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case 54: + $235 = HEAP32[(105500 | 0) >> 2] | 0; + $236 = ($235 | 0) == 0; + if ($236) { + label = 55; + break; + } else { + label = 56; + break; + } + case 55: + invoke_v(30); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 56; + break; + case 56: + $238 = invoke_i(70) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $239$0 = $238; + $239$1 = 0; + $240 = invoke_iii(364, $239$0 | 0, $239$1 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $241 = $240 + 20 | 0; + $242 = $241; + $243 = HEAP32[$242 >> 2] | 0; + $244 = $243; + $_r0_sroa_0 = $244; + $_r1_sroa_0_0_load = $_r1_sroa_0; + $245 = $_r1_sroa_0_0_load + 4 | 0; + $246 = $245; + $247 = HEAP32[$246 >> 2] | 0; + $248 = $247 + 8 | 0; + $249 = $248; + $250 = HEAP32[$249 >> 2] | 0; + $251 = $250 - 1 | 0; + HEAP32[$249 >> 2] = $251; + $252 = HEAP32[$246 >> 2] | 0; + $253 = $252 + 8 | 0; + $254 = $253; + $255 = HEAP32[$254 >> 2] | 0; + $256 = ($255 | 0) == 0; + if ($256) { + label = 57; + break; + } else { + label = 59; + break; + } + case 57: + invoke_vi(28, $_r1_sroa_0_0_load | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $258 = HEAP32[$246 >> 2] | 0; + $259 = $258 + 16 | 0; + $260 = $259; + $261 = HEAP32[$260 >> 2] | 0; + $262 = $261 + 8 | 0; + $263 = $262; + $264 = HEAP32[$263 >> 2] | 0; + $265 = $264; + $266; + $267 = ($266 | 0) == 0; + if ($267) { + label = 59; + break; + } else { + label = 58; + break; + } + case 58: + $269 = invoke_iii(268, 31e3 | 0 | 0, (tempInt = STACKTOP, STACKTOP = STACKTOP + 8 | 0, HEAP32[tempInt >> 2] = $266, tempInt) | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 59; + break; + case 59: + $270 = HEAP32[(105500 | 0) >> 2] | 0; + $271 = ($270 | 0) == 0; + if ($271) { + label = 60; + break; + } else { + label = 61; + break; + } + case 60: + invoke_v(30); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 61; + break; + case 61: + $273 = invoke_i(70) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $274$0 = $273; + $274$1 = 0; + $275 = invoke_iii(364, $274$0 | 0, $274$1 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $_r0_sroa_0_0_load617 = $_r0_sroa_0; + $276 = $_r0_sroa_0_0_load617; + $277 = $275 + 16 | 0; + $278 = $275 + 20 | 0; + $279 = $278; + HEAP32[$279 >> 2] = $276; + $280 = $277; + $281 = HEAP32[$280 >> 2] | 0; + $282 = $281; + invoke_vii(48, $282 | 0, 0 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case 62: + $284 = $local_env_w4567aaac23b1c22; + $285 = $151 + 16 | 0; + $286 = $285; + $287 = HEAP32[$286 >> 2] | 0; + _memcpy($284 | 0, $287 | 0, 40); + $288 = HEAP32[$286 >> 2] | 0; + $289 = $288; + $290 = _saveSetjmp($289 | 0, label, setjmpTable) | 0; + label = 415; + break; + case 415: + $291 = ($290 | 0) == 0; + if ($291) { + label = 63; + break; + } else { + label = 72; + break; + } + case 63: + $_r5_sroa_0_0_load590 = $_r5_sroa_0; + invoke_vi(44, $_r5_sroa_0_0_load590 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $293 = HEAP32[(98772 | 0) >> 2] | 0; + $294 = ($293 | 0) == 0; + if ($294) { + label = 64; + break; + } else { + label = 65; + break; + } + case 64: + invoke_v(702); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 65; + break; + case 65: + $296 = HEAP32[140064 >> 2] | 0; + $297 = $296; + $_r0_sroa_0 = $297; + $_r0_sroa_0_0_load616 = $_r0_sroa_0; + $298 = ($_r0_sroa_0_0_load616 | 0) == 0; + if ($298) { + label = 67; + break; + } else { + label = 66; + break; + } + case 66: + $300 = HEAP32[$286 >> 2] | 0; + _memcpy($300 | 0, $284 | 0, 40); + label = 89; + break; + case 67: + $302 = HEAP32[(84292 | 0) >> 2] | 0; + $303 = ($302 | 0) == 0; + if ($303) { + label = 68; + break; + } else { + label = 69; + break; + } + case 68: + invoke_v(584); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 69; + break; + case 69: + $305 = invoke_ii(338, 20 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $306 = $305; + HEAP32[$306 >> 2] = 84288; + $307 = $305 + 4 | 0; + _memset($307 | 0 | 0, 0 | 0 | 0, 16 | 0 | 0); + $308 = $305; + $_r0_sroa_0 = $308; + $_r0_sroa_0_0_load615 = $_r0_sroa_0; + $309 = $_r0_sroa_0_0_load615; + invoke_vi(34, $309 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $_r0_sroa_0_0_load614 = $_r0_sroa_0; + $310 = $_r0_sroa_0_0_load614; + $311 = HEAP32[(98772 | 0) >> 2] | 0; + $312 = ($311 | 0) == 0; + if ($312) { + label = 70; + break; + } else { + label = 71; + break; + } + case 70: + invoke_v(702); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 71; + break; + case 71: + HEAP32[140064 >> 2] = $310; + $314 = HEAP32[$286 >> 2] | 0; + _memcpy($314 | 0, $284 | 0, 40); + label = 89; + break; + case 72: + $316 = HEAP32[$286 >> 2] | 0; + _memcpy($316 | 0, $284 | 0, 40); + $317 = HEAP32[(107740 | 0) >> 2] | 0; + $318 = ($317 | 0) == 0; + if ($318) { + label = 73; + break; + } else { + label = 74; + break; + } + case 73: + invoke_v(374); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 74; + break; + case 74: + $321 = $151 + 20 | 0; + $322 = $321; + $323 = HEAP32[$322 >> 2] | 0; + $324 = ($323 | 0) == 0; + if ($324) { + label = 88; + break; + } else { + label = 75; + break; + } + case 75: + $326 = HEAP32[137616 >> 2] | 0; + $327 = $323; + $328 = HEAP32[$327 >> 2] | 0; + $329 = $328; + $330 = $326 + 8 | 0; + $331 = $330; + $332 = HEAP32[$331 >> 2] | 0; + $333 = ($328 | 0) == 82712; + if ($333) { + label = 76; + break; + } else { + $tib1_0_ph_i500 = $329; + label = 77; + break; + } + case 76: + $335 = $323 + 8 | 0; + $336 = $335; + $337 = HEAP32[$336 >> 2] | 0; + $338 = $337 + 8 | 0; + $339 = $338; + $340 = HEAP32[$339 >> 2] | 0; + $341 = $340; + $tib1_0_ph_i500 = $341; + label = 77; + break; + case 77: + $342 = $tib1_0_ph_i500 + 56 | 0; + $343 = HEAP32[$342 >> 2] | 0; + $344 = ($343 | 0) == 0; + if ($344) { + var $dimension_tib1_0_lcssa_i504 = 0; + var $tib1_0_lcssa_i503 = $tib1_0_ph_i500; + label = 79; + break; + } else { + var $dimension_tib1_029_i506 = 0; + var $350 = $343; + label = 80; + break; + } + case 78: + $345 = $353; + var $dimension_tib1_0_lcssa_i504 = $354; + var $tib1_0_lcssa_i503 = $345; + label = 79; + break; + case 79: + $346 = $332 + 56 | 0; + $347 = $346; + $348 = HEAP32[$347 >> 2] | 0; + $349 = ($348 | 0) == 0; + if ($349) { + var $dimension_tib2_0_lcssa_i511 = 0; + var $tib2_0_lcssa_in_i510 = $332; + label = 82; + break; + } else { + var $dimension_tib2_024_i508 = 0; + var $359 = $348; + label = 81; + break; + } + case 80: + $351 = $350 + 8 | 0; + $352 = $351; + $353 = HEAP32[$352 >> 2] | 0; + $354 = $dimension_tib1_029_i506 + 1 | 0; + $355 = $353 + 56 | 0; + $356 = $355; + $357 = HEAP32[$356 >> 2] | 0; + $358 = ($357 | 0) == 0; + if ($358) { + label = 78; + break; + } else { + var $dimension_tib1_029_i506 = $354; + var $350 = $357; + label = 80; + break; + } + case 81: + $360 = $359 + 8 | 0; + $361 = $360; + $362 = HEAP32[$361 >> 2] | 0; + $363 = $dimension_tib2_024_i508 + 1 | 0; + $364 = $362 + 56 | 0; + $365 = $364; + $366 = HEAP32[$365 >> 2] | 0; + $367 = ($366 | 0) == 0; + if ($367) { + var $dimension_tib2_0_lcssa_i511 = $363; + var $tib2_0_lcssa_in_i510 = $362; + label = 82; + break; + } else { + var $dimension_tib2_024_i508 = $363; + var $359 = $366; + label = 81; + break; + } + case 82: + $tib2_0_lcssa_i512 = $tib2_0_lcssa_in_i510; + $368 = ($dimension_tib1_0_lcssa_i504 | 0) < ($dimension_tib2_0_lcssa_i511 | 0); + $369 = ($tib1_0_lcssa_i503 | 0) == 0; + $or_cond_i513 = $368 | $369; + if ($or_cond_i513) { + label = 88; + break; + } else { + $tib1_121_i515 = $tib1_0_lcssa_i503; + label = 83; + break; + } + case 83: + $370 = ($tib1_121_i515 | 0) == ($tib2_0_lcssa_i512 | 0); + if ($370) { + label = 54; + break; + } else { + label = 84; + break; + } + case 84: + $371 = $tib1_121_i515 + 108 | 0; + $372 = HEAP32[$371 >> 2] | 0; + $373 = $tib1_121_i515 + 112 | 0; + $i_0_i518 = 0; + label = 85; + break; + case 85: + $375 = ($i_0_i518 | 0) < ($372 | 0); + if ($375) { + label = 86; + break; + } else { + label = 87; + break; + } + case 86: + $377 = HEAP32[$373 >> 2] | 0; + $378 = $377 + ($i_0_i518 << 2) | 0; + $379 = HEAP32[$378 >> 2] | 0; + $380 = ($379 | 0) == ($tib2_0_lcssa_i512 | 0); + $381 = $i_0_i518 + 1 | 0; + if ($380) { + label = 54; + break; + } else { + $i_0_i518 = $381; + label = 85; + break; + } + case 87: + $383 = $tib1_121_i515 + 40 | 0; + $384 = HEAP32[$383 >> 2] | 0; + $385 = ($384 | 0) == 0; + if ($385) { + label = 88; + break; + } else { + $tib1_121_i515 = $384; + label = 83; + break; + } + case 88: + $386 = HEAP32[$286 >> 2] | 0; + $387 = $386; + invoke_vii(48, $387 | 0, 0 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case 89: + $389 = HEAP32[(105500 | 0) >> 2] | 0; + $390 = ($389 | 0) == 0; + if ($390) { + label = 90; + break; + } else { + label = 91; + break; + } + case 90: + invoke_v(30); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 91; + break; + case 91: + $392 = invoke_i(70) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $393$0 = $392; + $393$1 = 0; + $394 = invoke_iii(364, $393$0 | 0, $393$1 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $395 = $local_env_w4567aaac23b1c24; + $396 = $394 + 16 | 0; + $397 = $396; + $398 = HEAP32[$397 >> 2] | 0; + _memcpy($395 | 0, $398 | 0, 40); + $399 = HEAP32[$397 >> 2] | 0; + $400 = $399; + $401 = _saveSetjmp($400 | 0, label, setjmpTable) | 0; + label = 416; + break; + case 416: + $402 = ($401 | 0) == 0; + if ($402) { + label = 92; + break; + } else { + label = 99; + break; + } + case 92: + $404 = HEAP32[(98772 | 0) >> 2] | 0; + $405 = ($404 | 0) == 0; + if ($405) { + label = 93; + break; + } else { + label = 94; + break; + } + case 93: + invoke_v(702); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 94; + break; + case 94: + $407 = HEAP32[140064 >> 2] | 0; + $408 = $407; + $_r0_sroa_0 = $408; + $_r0_sroa_0_0_load613 = $_r0_sroa_0; + $409 = $_r0_sroa_0_0_load613; + $410 = $409 | 0; + $411 = HEAP32[$410 >> 2] | 0; + $412 = $411 + 144 | 0; + $413 = HEAP32[$412 >> 2] | 0; + $414 = $413; + $_r0_sroa_0_0_load612 = $_r0_sroa_0; + $415 = $_r0_sroa_0_0_load612; + $_r5_sroa_0_0_load589 = $_r5_sroa_0; + $416 = invoke_iii($414 | 0, $415 | 0, $_r5_sroa_0_0_load589 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $417 = $416; + $_r0_sroa_0 = $417; + $_r0_sroa_0_0_load611 = $_r0_sroa_0; + $418 = ($_r0_sroa_0_0_load611 | 0) == 0; + if ($418) { + label = 95; + break; + } else { + label = 98; + break; + } + case 95: + $420 = HEAP32[$397 >> 2] | 0; + _memcpy($420 | 0, $395 | 0, 40); + $421 = HEAP32[(105500 | 0) >> 2] | 0; + $422 = ($421 | 0) == 0; + if ($422) { + label = 96; + break; + } else { + label = 97; + break; + } + case 96: + invoke_v(30); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 97; + break; + case 97: + $424 = invoke_i(70) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $425$0 = $424; + $425$1 = 0; + $426 = invoke_iii(364, $425$0 | 0, $425$1 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $427 = $local_env_w4567aaac23b1c26; + $428 = $426 + 16 | 0; + $429 = $428; + $430 = HEAP32[$429 >> 2] | 0; + _memcpy($427 | 0, $430 | 0, 40); + $431 = HEAP32[$429 >> 2] | 0; + $432 = $431; + $433 = _saveSetjmp($432 | 0, label, setjmpTable) | 0; + label = 417; + break; + case 417: + $434 = ($433 | 0) == 0; + if ($434) { + label = 116; + break; + } else { + label = 127; + break; + } + case 98: + $_r0_sroa_0_0_load610 = $_r0_sroa_0; + $436 = $_r0_sroa_0_0_load610; + $_r5_sroa_0_0_load588 = $_r5_sroa_0; + invoke_vii(24, $436 | 0, $_r5_sroa_0_0_load588 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $437 = HEAP32[$397 >> 2] | 0; + _memcpy($437 | 0, $395 | 0, 40); + label = 28; + break; + case 99: + $439 = HEAP32[$397 >> 2] | 0; + _memcpy($439 | 0, $395 | 0, 40); + $440 = HEAP32[(107740 | 0) >> 2] | 0; + $441 = ($440 | 0) == 0; + if ($441) { + label = 100; + break; + } else { + label = 101; + break; + } + case 100: + invoke_v(374); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 101; + break; + case 101: + $444 = $394 + 20 | 0; + $445 = $444; + $446 = HEAP32[$445 >> 2] | 0; + $447 = ($446 | 0) == 0; + if ($447) { + label = 115; + break; + } else { + label = 102; + break; + } + case 102: + $449 = HEAP32[137616 >> 2] | 0; + $450 = $446; + $451 = HEAP32[$450 >> 2] | 0; + $452 = $451; + $453 = $449 + 8 | 0; + $454 = $453; + $455 = HEAP32[$454 >> 2] | 0; + $456 = ($451 | 0) == 82712; + if ($456) { + label = 103; + break; + } else { + $tib1_0_ph_i479 = $452; + label = 104; + break; + } + case 103: + $458 = $446 + 8 | 0; + $459 = $458; + $460 = HEAP32[$459 >> 2] | 0; + $461 = $460 + 8 | 0; + $462 = $461; + $463 = HEAP32[$462 >> 2] | 0; + $464 = $463; + $tib1_0_ph_i479 = $464; + label = 104; + break; + case 104: + $465 = $tib1_0_ph_i479 + 56 | 0; + $466 = HEAP32[$465 >> 2] | 0; + $467 = ($466 | 0) == 0; + if ($467) { + var $dimension_tib1_0_lcssa_i483 = 0; + var $tib1_0_lcssa_i482 = $tib1_0_ph_i479; + label = 106; + break; + } else { + var $dimension_tib1_029_i485 = 0; + var $473 = $466; + label = 107; + break; + } + case 105: + $468 = $476; + var $dimension_tib1_0_lcssa_i483 = $477; + var $tib1_0_lcssa_i482 = $468; + label = 106; + break; + case 106: + $469 = $455 + 56 | 0; + $470 = $469; + $471 = HEAP32[$470 >> 2] | 0; + $472 = ($471 | 0) == 0; + if ($472) { + var $dimension_tib2_0_lcssa_i490 = 0; + var $tib2_0_lcssa_in_i489 = $455; + label = 109; + break; + } else { + var $dimension_tib2_024_i487 = 0; + var $482 = $471; + label = 108; + break; + } + case 107: + $474 = $473 + 8 | 0; + $475 = $474; + $476 = HEAP32[$475 >> 2] | 0; + $477 = $dimension_tib1_029_i485 + 1 | 0; + $478 = $476 + 56 | 0; + $479 = $478; + $480 = HEAP32[$479 >> 2] | 0; + $481 = ($480 | 0) == 0; + if ($481) { + label = 105; + break; + } else { + var $dimension_tib1_029_i485 = $477; + var $473 = $480; + label = 107; + break; + } + case 108: + $483 = $482 + 8 | 0; + $484 = $483; + $485 = HEAP32[$484 >> 2] | 0; + $486 = $dimension_tib2_024_i487 + 1 | 0; + $487 = $485 + 56 | 0; + $488 = $487; + $489 = HEAP32[$488 >> 2] | 0; + $490 = ($489 | 0) == 0; + if ($490) { + var $dimension_tib2_0_lcssa_i490 = $486; + var $tib2_0_lcssa_in_i489 = $485; + label = 109; + break; + } else { + var $dimension_tib2_024_i487 = $486; + var $482 = $489; + label = 108; + break; + } + case 109: + $tib2_0_lcssa_i491 = $tib2_0_lcssa_in_i489; + $491 = ($dimension_tib1_0_lcssa_i483 | 0) < ($dimension_tib2_0_lcssa_i490 | 0); + $492 = ($tib1_0_lcssa_i482 | 0) == 0; + $or_cond_i492 = $491 | $492; + if ($or_cond_i492) { + label = 115; + break; + } else { + $tib1_121_i494 = $tib1_0_lcssa_i482; + label = 110; + break; + } + case 110: + $493 = ($tib1_121_i494 | 0) == ($tib2_0_lcssa_i491 | 0); + if ($493) { + label = 54; + break; + } else { + label = 111; + break; + } + case 111: + $494 = $tib1_121_i494 + 108 | 0; + $495 = HEAP32[$494 >> 2] | 0; + $496 = $tib1_121_i494 + 112 | 0; + $i_0_i497 = 0; + label = 112; + break; + case 112: + $498 = ($i_0_i497 | 0) < ($495 | 0); + if ($498) { + label = 113; + break; + } else { + label = 114; + break; + } + case 113: + $500 = HEAP32[$496 >> 2] | 0; + $501 = $500 + ($i_0_i497 << 2) | 0; + $502 = HEAP32[$501 >> 2] | 0; + $503 = ($502 | 0) == ($tib2_0_lcssa_i491 | 0); + $504 = $i_0_i497 + 1 | 0; + if ($503) { + label = 54; + break; + } else { + $i_0_i497 = $504; + label = 112; + break; + } + case 114: + $506 = $tib1_121_i494 + 40 | 0; + $507 = HEAP32[$506 >> 2] | 0; + $508 = ($507 | 0) == 0; + if ($508) { + label = 115; + break; + } else { + $tib1_121_i494 = $507; + label = 110; + break; + } + case 115: + $509 = HEAP32[$397 >> 2] | 0; + $510 = $509; + invoke_vii(48, $510 | 0, 0 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case 116: + $512 = HEAP32[(98772 | 0) >> 2] | 0; + $513 = ($512 | 0) == 0; + if ($513) { + label = 117; + break; + } else { + label = 118; + break; + } + case 117: + invoke_v(702); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 118; + break; + case 118: + $516 = HEAP32[(105500 | 0) >> 2] | 0; + $517 = ($516 | 0) == 0; + if ($517) { + label = 119; + break; + } else { + label = 120; + break; + } + case 119: + invoke_v(30); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 120; + break; + case 120: + $519 = invoke_i(70) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $520$0 = $519; + $520$1 = 0; + $521 = invoke_iii(364, $520$0 | 0, $520$1 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $522 = HEAP32[(98148 | 0) >> 2] | 0; + $523 = ($522 | 0) == 0; + if ($523) { + label = 121; + break; + } else { + label = 122; + break; + } + case 121: + invoke_v(408); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 122; + break; + case 122: + $525 = invoke_ii(338, 12 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $526 = $525; + HEAP32[$526 >> 2] = 98144; + $527 = $525 + 4 | 0; + $528 = $527; + HEAP32[$528 >> 2] = 0; + $529 = $525 + 8 | 0; + $530 = $529; + HEAP32[$530 >> 2] = $521; + $531 = HEAP32[(97532 | 0) >> 2] | 0; + $532 = ($531 | 0) == 0; + if ($532) { + label = 123; + break; + } else { + $534 = 98144; + label = 124; + break; + } + case 123: + invoke_v(568); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $_phi_trans_insert = $525; + $_pre = HEAP32[$_phi_trans_insert >> 2] | 0; + $534 = $_pre; + label = 124; + break; + case 124: + $535 = $534 + 116 | 0; + $536 = HEAP32[$535 >> 2] | 0; + $537 = HEAP32[$536 >> 2] | 0; + $538 = $537; + $539 = invoke_ii($538 | 0, $525 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $540 = $539; + $_r2_sroa_0 = $540; + $541 = HEAP32[$429 >> 2] | 0; + _memcpy($541 | 0, $427 | 0, 40); + $_r2_sroa_0_0_load599 = $_r2_sroa_0; + $542 = ($_r2_sroa_0_0_load599 | 0) == 0; + $543 = HEAP32[(105500 | 0) >> 2] | 0; + $544 = ($543 | 0) == 0; + if ($544) { + label = 125; + break; + } else { + label = 126; + break; + } + case 125: + invoke_v(30); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 126; + break; + case 126: + $546 = invoke_i(70) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $547$0 = $546; + $547$1 = 0; + $548 = invoke_iii(364, $547$0 | 0, $547$1 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + if ($542) { + label = 240; + break; + } else { + label = 144; + break; + } + case 127: + $550 = HEAP32[$429 >> 2] | 0; + _memcpy($550 | 0, $427 | 0, 40); + $551 = HEAP32[(107740 | 0) >> 2] | 0; + $552 = ($551 | 0) == 0; + if ($552) { + label = 128; + break; + } else { + label = 129; + break; + } + case 128: + invoke_v(374); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 129; + break; + case 129: + $555 = $426 + 20 | 0; + $556 = $555; + $557 = HEAP32[$556 >> 2] | 0; + $558 = ($557 | 0) == 0; + if ($558) { + label = 143; + break; + } else { + label = 130; + break; + } + case 130: + $560 = HEAP32[137616 >> 2] | 0; + $561 = $557; + $562 = HEAP32[$561 >> 2] | 0; + $563 = $562; + $564 = $560 + 8 | 0; + $565 = $564; + $566 = HEAP32[$565 >> 2] | 0; + $567 = ($562 | 0) == 82712; + if ($567) { + label = 131; + break; + } else { + $tib1_0_ph_i458 = $563; + label = 132; + break; + } + case 131: + $569 = $557 + 8 | 0; + $570 = $569; + $571 = HEAP32[$570 >> 2] | 0; + $572 = $571 + 8 | 0; + $573 = $572; + $574 = HEAP32[$573 >> 2] | 0; + $575 = $574; + $tib1_0_ph_i458 = $575; + label = 132; + break; + case 132: + $576 = $tib1_0_ph_i458 + 56 | 0; + $577 = HEAP32[$576 >> 2] | 0; + $578 = ($577 | 0) == 0; + if ($578) { + var $dimension_tib1_0_lcssa_i462 = 0; + var $tib1_0_lcssa_i461 = $tib1_0_ph_i458; + label = 134; + break; + } else { + var $dimension_tib1_029_i464 = 0; + var $584 = $577; + label = 135; + break; + } + case 133: + $579 = $587; + var $dimension_tib1_0_lcssa_i462 = $588; + var $tib1_0_lcssa_i461 = $579; + label = 134; + break; + case 134: + $580 = $566 + 56 | 0; + $581 = $580; + $582 = HEAP32[$581 >> 2] | 0; + $583 = ($582 | 0) == 0; + if ($583) { + var $dimension_tib2_0_lcssa_i469 = 0; + var $tib2_0_lcssa_in_i468 = $566; + label = 137; + break; + } else { + var $dimension_tib2_024_i466 = 0; + var $593 = $582; + label = 136; + break; + } + case 135: + $585 = $584 + 8 | 0; + $586 = $585; + $587 = HEAP32[$586 >> 2] | 0; + $588 = $dimension_tib1_029_i464 + 1 | 0; + $589 = $587 + 56 | 0; + $590 = $589; + $591 = HEAP32[$590 >> 2] | 0; + $592 = ($591 | 0) == 0; + if ($592) { + label = 133; + break; + } else { + var $dimension_tib1_029_i464 = $588; + var $584 = $591; + label = 135; + break; + } + case 136: + $594 = $593 + 8 | 0; + $595 = $594; + $596 = HEAP32[$595 >> 2] | 0; + $597 = $dimension_tib2_024_i466 + 1 | 0; + $598 = $596 + 56 | 0; + $599 = $598; + $600 = HEAP32[$599 >> 2] | 0; + $601 = ($600 | 0) == 0; + if ($601) { + var $dimension_tib2_0_lcssa_i469 = $597; + var $tib2_0_lcssa_in_i468 = $596; + label = 137; + break; + } else { + var $dimension_tib2_024_i466 = $597; + var $593 = $600; + label = 136; + break; + } + case 137: + $tib2_0_lcssa_i470 = $tib2_0_lcssa_in_i468; + $602 = ($dimension_tib1_0_lcssa_i462 | 0) < ($dimension_tib2_0_lcssa_i469 | 0); + $603 = ($tib1_0_lcssa_i461 | 0) == 0; + $or_cond_i471 = $602 | $603; + if ($or_cond_i471) { + label = 143; + break; + } else { + $tib1_121_i473 = $tib1_0_lcssa_i461; + label = 138; + break; + } + case 138: + $604 = ($tib1_121_i473 | 0) == ($tib2_0_lcssa_i470 | 0); + if ($604) { + label = 54; + break; + } else { + label = 139; + break; + } + case 139: + $605 = $tib1_121_i473 + 108 | 0; + $606 = HEAP32[$605 >> 2] | 0; + $607 = $tib1_121_i473 + 112 | 0; + $i_0_i476 = 0; + label = 140; + break; + case 140: + $609 = ($i_0_i476 | 0) < ($606 | 0); + if ($609) { + label = 141; + break; + } else { + label = 142; + break; + } + case 141: + $611 = HEAP32[$607 >> 2] | 0; + $612 = $611 + ($i_0_i476 << 2) | 0; + $613 = HEAP32[$612 >> 2] | 0; + $614 = ($613 | 0) == ($tib2_0_lcssa_i470 | 0); + $615 = $i_0_i476 + 1 | 0; + if ($614) { + label = 54; + break; + } else { + $i_0_i476 = $615; + label = 140; + break; + } + case 142: + $617 = $tib1_121_i473 + 40 | 0; + $618 = HEAP32[$617 >> 2] | 0; + $619 = ($618 | 0) == 0; + if ($619) { + label = 143; + break; + } else { + $tib1_121_i473 = $618; + label = 138; + break; + } + case 143: + $620 = HEAP32[$429 >> 2] | 0; + $621 = $620; + invoke_vii(48, $621 | 0, 0 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case 144: + $623 = $local_env_w4567aaac23b1c29; + $624 = $548 + 16 | 0; + $625 = $624; + $626 = HEAP32[$625 >> 2] | 0; + _memcpy($623 | 0, $626 | 0, 40); + $627 = HEAP32[$625 >> 2] | 0; + $628 = $627; + $629 = _saveSetjmp($628 | 0, label, setjmpTable) | 0; + label = 418; + break; + case 418: + $630 = ($629 | 0) == 0; + if ($630) { + label = 145; + break; + } else { + label = 146; + break; + } + case 145: + $632 = invoke_ii(556, 709 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $633 = $632; + $_r0_sroa_0 = $633; + $_r2_sroa_0_0_load598 = $_r2_sroa_0; + $_r0_sroa_0_0_load609 = $_r0_sroa_0; + $_r0_sroa_0 = 0; + $_r0_sroa_0_0_load624 = $_r0_sroa_0; + $634 = $_r0_sroa_0_0_load624; + $_r3_sroa_0 = $634; + $_r0_sroa_1_4__r3_sroa_1_4_idx108_idx = $_r3_sroa_1 | 0; + $_r0_sroa_1_4_idx = $_r0_sroa_1 | 0; + HEAP32[$_r0_sroa_1_4__r3_sroa_1_4_idx108_idx >> 2] = HEAP32[$_r0_sroa_1_4_idx >> 2] | 0; + $635 = HEAP32[$625 >> 2] | 0; + _memcpy($635 | 0, $623 | 0, 40); + label = 179; + break; + case 146: + $637 = HEAP32[$625 >> 2] | 0; + _memcpy($637 | 0, $623 | 0, 40); + $638 = HEAP32[(113236 | 0) >> 2] | 0; + $639 = ($638 | 0) == 0; + if ($639) { + label = 147; + break; + } else { + label = 148; + break; + } + case 147: + invoke_v(538); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 148; + break; + case 148: + $642 = $548 + 20 | 0; + $643 = $642; + $644 = HEAP32[$643 >> 2] | 0; + $645 = ($644 | 0) == 0; + if ($645) { + label = 162; + break; + } else { + label = 149; + break; + } + case 149: + $647 = HEAP32[138672 >> 2] | 0; + $648 = $644; + $649 = HEAP32[$648 >> 2] | 0; + $650 = $649; + $651 = $647 + 8 | 0; + $652 = $651; + $653 = HEAP32[$652 >> 2] | 0; + $654 = ($649 | 0) == 82712; + if ($654) { + label = 150; + break; + } else { + $tib1_0_ph_i437 = $650; + label = 151; + break; + } + case 150: + $656 = $644 + 8 | 0; + $657 = $656; + $658 = HEAP32[$657 >> 2] | 0; + $659 = $658 + 8 | 0; + $660 = $659; + $661 = HEAP32[$660 >> 2] | 0; + $662 = $661; + $tib1_0_ph_i437 = $662; + label = 151; + break; + case 151: + $663 = $tib1_0_ph_i437 + 56 | 0; + $664 = HEAP32[$663 >> 2] | 0; + $665 = ($664 | 0) == 0; + if ($665) { + var $dimension_tib1_0_lcssa_i441 = 0; + var $tib1_0_lcssa_i440 = $tib1_0_ph_i437; + label = 153; + break; + } else { + var $dimension_tib1_029_i443 = 0; + var $671 = $664; + label = 154; + break; + } + case 152: + $666 = $674; + var $dimension_tib1_0_lcssa_i441 = $675; + var $tib1_0_lcssa_i440 = $666; + label = 153; + break; + case 153: + $667 = $653 + 56 | 0; + $668 = $667; + $669 = HEAP32[$668 >> 2] | 0; + $670 = ($669 | 0) == 0; + if ($670) { + var $dimension_tib2_0_lcssa_i448 = 0; + var $tib2_0_lcssa_in_i447 = $653; + label = 156; + break; + } else { + var $dimension_tib2_024_i445 = 0; + var $680 = $669; + label = 155; + break; + } + case 154: + $672 = $671 + 8 | 0; + $673 = $672; + $674 = HEAP32[$673 >> 2] | 0; + $675 = $dimension_tib1_029_i443 + 1 | 0; + $676 = $674 + 56 | 0; + $677 = $676; + $678 = HEAP32[$677 >> 2] | 0; + $679 = ($678 | 0) == 0; + if ($679) { + label = 152; + break; + } else { + var $dimension_tib1_029_i443 = $675; + var $671 = $678; + label = 154; + break; + } + case 155: + $681 = $680 + 8 | 0; + $682 = $681; + $683 = HEAP32[$682 >> 2] | 0; + $684 = $dimension_tib2_024_i445 + 1 | 0; + $685 = $683 + 56 | 0; + $686 = $685; + $687 = HEAP32[$686 >> 2] | 0; + $688 = ($687 | 0) == 0; + if ($688) { + var $dimension_tib2_0_lcssa_i448 = $684; + var $tib2_0_lcssa_in_i447 = $683; + label = 156; + break; + } else { + var $dimension_tib2_024_i445 = $684; + var $680 = $687; + label = 155; + break; + } + case 156: + $tib2_0_lcssa_i449 = $tib2_0_lcssa_in_i447; + $689 = ($dimension_tib1_0_lcssa_i441 | 0) < ($dimension_tib2_0_lcssa_i448 | 0); + $690 = ($tib1_0_lcssa_i440 | 0) == 0; + $or_cond_i450 = $689 | $690; + if ($or_cond_i450) { + label = 162; + break; + } else { + $tib1_121_i452 = $tib1_0_lcssa_i440; + label = 157; + break; + } + case 157: + $691 = ($tib1_121_i452 | 0) == ($tib2_0_lcssa_i449 | 0); + if ($691) { + label = 361; + break; + } else { + label = 158; + break; + } + case 158: + $692 = $tib1_121_i452 + 108 | 0; + $693 = HEAP32[$692 >> 2] | 0; + $694 = $tib1_121_i452 + 112 | 0; + $i_0_i455 = 0; + label = 159; + break; + case 159: + $696 = ($i_0_i455 | 0) < ($693 | 0); + if ($696) { + label = 160; + break; + } else { + label = 161; + break; + } + case 160: + $698 = HEAP32[$694 >> 2] | 0; + $699 = $698 + ($i_0_i455 << 2) | 0; + $700 = HEAP32[$699 >> 2] | 0; + $701 = ($700 | 0) == ($tib2_0_lcssa_i449 | 0); + $702 = $i_0_i455 + 1 | 0; + if ($701) { + label = 361; + break; + } else { + $i_0_i455 = $702; + label = 159; + break; + } + case 161: + $704 = $tib1_121_i452 + 40 | 0; + $705 = HEAP32[$704 >> 2] | 0; + $706 = ($705 | 0) == 0; + if ($706) { + label = 162; + break; + } else { + $tib1_121_i452 = $705; + label = 157; + break; + } + case 162: + $707 = HEAP32[(107740 | 0) >> 2] | 0; + $708 = ($707 | 0) == 0; + if ($708) { + label = 163; + break; + } else { + label = 164; + break; + } + case 163: + invoke_v(374); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 164; + break; + case 164: + $711 = HEAP32[$643 >> 2] | 0; + $712 = ($711 | 0) == 0; + if ($712) { + label = 178; + break; + } else { + label = 165; + break; + } + case 165: + $714 = HEAP32[137616 >> 2] | 0; + $715 = $711; + $716 = HEAP32[$715 >> 2] | 0; + $717 = $716; + $718 = $714 + 8 | 0; + $719 = $718; + $720 = HEAP32[$719 >> 2] | 0; + $721 = ($716 | 0) == 82712; + if ($721) { + label = 166; + break; + } else { + $tib1_0_ph_i416 = $717; + label = 167; + break; + } + case 166: + $723 = $711 + 8 | 0; + $724 = $723; + $725 = HEAP32[$724 >> 2] | 0; + $726 = $725 + 8 | 0; + $727 = $726; + $728 = HEAP32[$727 >> 2] | 0; + $729 = $728; + $tib1_0_ph_i416 = $729; + label = 167; + break; + case 167: + $730 = $tib1_0_ph_i416 + 56 | 0; + $731 = HEAP32[$730 >> 2] | 0; + $732 = ($731 | 0) == 0; + if ($732) { + var $dimension_tib1_0_lcssa_i420 = 0; + var $tib1_0_lcssa_i419 = $tib1_0_ph_i416; + label = 169; + break; + } else { + var $dimension_tib1_029_i422 = 0; + var $738 = $731; + label = 170; + break; + } + case 168: + $733 = $741; + var $dimension_tib1_0_lcssa_i420 = $742; + var $tib1_0_lcssa_i419 = $733; + label = 169; + break; + case 169: + $734 = $720 + 56 | 0; + $735 = $734; + $736 = HEAP32[$735 >> 2] | 0; + $737 = ($736 | 0) == 0; + if ($737) { + var $dimension_tib2_0_lcssa_i427 = 0; + var $tib2_0_lcssa_in_i426 = $720; + label = 172; + break; + } else { + var $dimension_tib2_024_i424 = 0; + var $747 = $736; + label = 171; + break; + } + case 170: + $739 = $738 + 8 | 0; + $740 = $739; + $741 = HEAP32[$740 >> 2] | 0; + $742 = $dimension_tib1_029_i422 + 1 | 0; + $743 = $741 + 56 | 0; + $744 = $743; + $745 = HEAP32[$744 >> 2] | 0; + $746 = ($745 | 0) == 0; + if ($746) { + label = 168; + break; + } else { + var $dimension_tib1_029_i422 = $742; + var $738 = $745; + label = 170; + break; + } + case 171: + $748 = $747 + 8 | 0; + $749 = $748; + $750 = HEAP32[$749 >> 2] | 0; + $751 = $dimension_tib2_024_i424 + 1 | 0; + $752 = $750 + 56 | 0; + $753 = $752; + $754 = HEAP32[$753 >> 2] | 0; + $755 = ($754 | 0) == 0; + if ($755) { + var $dimension_tib2_0_lcssa_i427 = $751; + var $tib2_0_lcssa_in_i426 = $750; + label = 172; + break; + } else { + var $dimension_tib2_024_i424 = $751; + var $747 = $754; + label = 171; + break; + } + case 172: + $tib2_0_lcssa_i428 = $tib2_0_lcssa_in_i426; + $756 = ($dimension_tib1_0_lcssa_i420 | 0) < ($dimension_tib2_0_lcssa_i427 | 0); + $757 = ($tib1_0_lcssa_i419 | 0) == 0; + $or_cond_i429 = $756 | $757; + if ($or_cond_i429) { + label = 178; + break; + } else { + $tib1_121_i431 = $tib1_0_lcssa_i419; + label = 173; + break; + } + case 173: + $758 = ($tib1_121_i431 | 0) == ($tib2_0_lcssa_i428 | 0); + if ($758) { + label = 386; + break; + } else { + label = 174; + break; + } + case 174: + $759 = $tib1_121_i431 + 108 | 0; + $760 = HEAP32[$759 >> 2] | 0; + $761 = $tib1_121_i431 + 112 | 0; + $i_0_i434 = 0; + label = 175; + break; + case 175: + $763 = ($i_0_i434 | 0) < ($760 | 0); + if ($763) { + label = 176; + break; + } else { + label = 177; + break; + } + case 176: + $765 = HEAP32[$761 >> 2] | 0; + $766 = $765 + ($i_0_i434 << 2) | 0; + $767 = HEAP32[$766 >> 2] | 0; + $768 = ($767 | 0) == ($tib2_0_lcssa_i428 | 0); + $769 = $i_0_i434 + 1 | 0; + if ($768) { + label = 386; + break; + } else { + $i_0_i434 = $769; + label = 175; + break; + } + case 177: + $771 = $tib1_121_i431 + 40 | 0; + $772 = HEAP32[$771 >> 2] | 0; + $773 = ($772 | 0) == 0; + if ($773) { + label = 178; + break; + } else { + $tib1_121_i431 = $772; + label = 173; + break; + } + case 178: + $774 = HEAP32[$625 >> 2] | 0; + $775 = $774; + invoke_vii(48, $775 | 0, 0 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case 179: + $777 = HEAP32[(105500 | 0) >> 2] | 0; + $778 = ($777 | 0) == 0; + if ($778) { + label = 180; + break; + } else { + label = 181; + break; + } + case 180: + invoke_v(30); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 181; + break; + case 181: + $780 = invoke_i(70) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $781$0 = $780; + $781$1 = 0; + $782 = invoke_iii(364, $781$0 | 0, $781$1 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $783 = $local_env_w4567aaac23b1c31; + $784 = $782 + 16 | 0; + $785 = $784; + $786 = HEAP32[$785 >> 2] | 0; + _memcpy($783 | 0, $786 | 0, 40); + $787 = HEAP32[$785 >> 2] | 0; + $788 = $787; + $789 = _saveSetjmp($788 | 0, label, setjmpTable) | 0; + label = 419; + break; + case 419: + $790 = ($789 | 0) == 0; + if ($790) { + label = 182; + break; + } else { + label = 183; + break; + } + case 182: + $_r3_sroa_0_0_load596 = $_r3_sroa_0; + $792 = $_r3_sroa_0_0_load596; + $793 = HEAP32[$792 >> 2] | 0; + $794 = $793 + 116 | 0; + $795 = HEAP32[$794 >> 2] | 0; + $796 = HEAP32[$795 >> 2] | 0; + $797 = $796; + $_r3_sroa_0_0_load595 = $_r3_sroa_0; + $798 = invoke_ii($797 | 0, $_r3_sroa_0_0_load595 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $_r0_sroa_0 = $798; + $799 = HEAP32[$785 >> 2] | 0; + _memcpy($799 | 0, $783 | 0, 40); + $_r0_sroa_0_0_load608 = $_r0_sroa_0; + $800 = ($_r0_sroa_0_0_load608 | 0) == 0; + if ($800) { + label = 216; + break; + } else { + label = 322; + break; + } + case 183: + $802 = HEAP32[$785 >> 2] | 0; + _memcpy($802 | 0, $783 | 0, 40); + $803 = HEAP32[(113236 | 0) >> 2] | 0; + $804 = ($803 | 0) == 0; + if ($804) { + label = 184; + break; + } else { + label = 185; + break; + } + case 184: + invoke_v(538); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 185; + break; + case 185: + $807 = $782 + 20 | 0; + $808 = $807; + $809 = HEAP32[$808 >> 2] | 0; + $810 = ($809 | 0) == 0; + if ($810) { + label = 199; + break; + } else { + label = 186; + break; + } + case 186: + $812 = HEAP32[138672 >> 2] | 0; + $813 = $809; + $814 = HEAP32[$813 >> 2] | 0; + $815 = $814; + $816 = $812 + 8 | 0; + $817 = $816; + $818 = HEAP32[$817 >> 2] | 0; + $819 = ($814 | 0) == 82712; + if ($819) { + label = 187; + break; + } else { + $tib1_0_ph_i395 = $815; + label = 188; + break; + } + case 187: + $821 = $809 + 8 | 0; + $822 = $821; + $823 = HEAP32[$822 >> 2] | 0; + $824 = $823 + 8 | 0; + $825 = $824; + $826 = HEAP32[$825 >> 2] | 0; + $827 = $826; + $tib1_0_ph_i395 = $827; + label = 188; + break; + case 188: + $828 = $tib1_0_ph_i395 + 56 | 0; + $829 = HEAP32[$828 >> 2] | 0; + $830 = ($829 | 0) == 0; + if ($830) { + var $dimension_tib1_0_lcssa_i399 = 0; + var $tib1_0_lcssa_i398 = $tib1_0_ph_i395; + label = 190; + break; + } else { + var $dimension_tib1_029_i401 = 0; + var $836 = $829; + label = 191; + break; + } + case 189: + $831 = $839; + var $dimension_tib1_0_lcssa_i399 = $840; + var $tib1_0_lcssa_i398 = $831; + label = 190; + break; + case 190: + $832 = $818 + 56 | 0; + $833 = $832; + $834 = HEAP32[$833 >> 2] | 0; + $835 = ($834 | 0) == 0; + if ($835) { + var $dimension_tib2_0_lcssa_i406 = 0; + var $tib2_0_lcssa_in_i405 = $818; + label = 193; + break; + } else { + var $dimension_tib2_024_i403 = 0; + var $845 = $834; + label = 192; + break; + } + case 191: + $837 = $836 + 8 | 0; + $838 = $837; + $839 = HEAP32[$838 >> 2] | 0; + $840 = $dimension_tib1_029_i401 + 1 | 0; + $841 = $839 + 56 | 0; + $842 = $841; + $843 = HEAP32[$842 >> 2] | 0; + $844 = ($843 | 0) == 0; + if ($844) { + label = 189; + break; + } else { + var $dimension_tib1_029_i401 = $840; + var $836 = $843; + label = 191; + break; + } + case 192: + $846 = $845 + 8 | 0; + $847 = $846; + $848 = HEAP32[$847 >> 2] | 0; + $849 = $dimension_tib2_024_i403 + 1 | 0; + $850 = $848 + 56 | 0; + $851 = $850; + $852 = HEAP32[$851 >> 2] | 0; + $853 = ($852 | 0) == 0; + if ($853) { + var $dimension_tib2_0_lcssa_i406 = $849; + var $tib2_0_lcssa_in_i405 = $848; + label = 193; + break; + } else { + var $dimension_tib2_024_i403 = $849; + var $845 = $852; + label = 192; + break; + } + case 193: + $tib2_0_lcssa_i407 = $tib2_0_lcssa_in_i405; + $854 = ($dimension_tib1_0_lcssa_i399 | 0) < ($dimension_tib2_0_lcssa_i406 | 0); + $855 = ($tib1_0_lcssa_i398 | 0) == 0; + $or_cond_i408 = $854 | $855; + if ($or_cond_i408) { + label = 199; + break; + } else { + $tib1_121_i410 = $tib1_0_lcssa_i398; + label = 194; + break; + } + case 194: + $856 = ($tib1_121_i410 | 0) == ($tib2_0_lcssa_i407 | 0); + if ($856) { + label = 361; + break; + } else { + label = 195; + break; + } + case 195: + $857 = $tib1_121_i410 + 108 | 0; + $858 = HEAP32[$857 >> 2] | 0; + $859 = $tib1_121_i410 + 112 | 0; + $i_0_i413 = 0; + label = 196; + break; + case 196: + $861 = ($i_0_i413 | 0) < ($858 | 0); + if ($861) { + label = 197; + break; + } else { + label = 198; + break; + } + case 197: + $863 = HEAP32[$859 >> 2] | 0; + $864 = $863 + ($i_0_i413 << 2) | 0; + $865 = HEAP32[$864 >> 2] | 0; + $866 = ($865 | 0) == ($tib2_0_lcssa_i407 | 0); + $867 = $i_0_i413 + 1 | 0; + if ($866) { + label = 361; + break; + } else { + $i_0_i413 = $867; + label = 196; + break; + } + case 198: + $869 = $tib1_121_i410 + 40 | 0; + $870 = HEAP32[$869 >> 2] | 0; + $871 = ($870 | 0) == 0; + if ($871) { + label = 199; + break; + } else { + $tib1_121_i410 = $870; + label = 194; + break; + } + case 199: + $872 = HEAP32[(107740 | 0) >> 2] | 0; + $873 = ($872 | 0) == 0; + if ($873) { + label = 200; + break; + } else { + label = 201; + break; + } + case 200: + invoke_v(374); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 201; + break; + case 201: + $876 = HEAP32[$808 >> 2] | 0; + $877 = ($876 | 0) == 0; + if ($877) { + label = 215; + break; + } else { + label = 202; + break; + } + case 202: + $879 = HEAP32[137616 >> 2] | 0; + $880 = $876; + $881 = HEAP32[$880 >> 2] | 0; + $882 = $881; + $883 = $879 + 8 | 0; + $884 = $883; + $885 = HEAP32[$884 >> 2] | 0; + $886 = ($881 | 0) == 82712; + if ($886) { + label = 203; + break; + } else { + $tib1_0_ph_i374 = $882; + label = 204; + break; + } + case 203: + $888 = $876 + 8 | 0; + $889 = $888; + $890 = HEAP32[$889 >> 2] | 0; + $891 = $890 + 8 | 0; + $892 = $891; + $893 = HEAP32[$892 >> 2] | 0; + $894 = $893; + $tib1_0_ph_i374 = $894; + label = 204; + break; + case 204: + $895 = $tib1_0_ph_i374 + 56 | 0; + $896 = HEAP32[$895 >> 2] | 0; + $897 = ($896 | 0) == 0; + if ($897) { + var $dimension_tib1_0_lcssa_i378 = 0; + var $tib1_0_lcssa_i377 = $tib1_0_ph_i374; + label = 206; + break; + } else { + var $dimension_tib1_029_i380 = 0; + var $903 = $896; + label = 207; + break; + } + case 205: + $898 = $906; + var $dimension_tib1_0_lcssa_i378 = $907; + var $tib1_0_lcssa_i377 = $898; + label = 206; + break; + case 206: + $899 = $885 + 56 | 0; + $900 = $899; + $901 = HEAP32[$900 >> 2] | 0; + $902 = ($901 | 0) == 0; + if ($902) { + var $dimension_tib2_0_lcssa_i385 = 0; + var $tib2_0_lcssa_in_i384 = $885; + label = 209; + break; + } else { + var $dimension_tib2_024_i382 = 0; + var $912 = $901; + label = 208; + break; + } + case 207: + $904 = $903 + 8 | 0; + $905 = $904; + $906 = HEAP32[$905 >> 2] | 0; + $907 = $dimension_tib1_029_i380 + 1 | 0; + $908 = $906 + 56 | 0; + $909 = $908; + $910 = HEAP32[$909 >> 2] | 0; + $911 = ($910 | 0) == 0; + if ($911) { + label = 205; + break; + } else { + var $dimension_tib1_029_i380 = $907; + var $903 = $910; + label = 207; + break; + } + case 208: + $913 = $912 + 8 | 0; + $914 = $913; + $915 = HEAP32[$914 >> 2] | 0; + $916 = $dimension_tib2_024_i382 + 1 | 0; + $917 = $915 + 56 | 0; + $918 = $917; + $919 = HEAP32[$918 >> 2] | 0; + $920 = ($919 | 0) == 0; + if ($920) { + var $dimension_tib2_0_lcssa_i385 = $916; + var $tib2_0_lcssa_in_i384 = $915; + label = 209; + break; + } else { + var $dimension_tib2_024_i382 = $916; + var $912 = $919; + label = 208; + break; + } + case 209: + $tib2_0_lcssa_i386 = $tib2_0_lcssa_in_i384; + $921 = ($dimension_tib1_0_lcssa_i378 | 0) < ($dimension_tib2_0_lcssa_i385 | 0); + $922 = ($tib1_0_lcssa_i377 | 0) == 0; + $or_cond_i387 = $921 | $922; + if ($or_cond_i387) { + label = 215; + break; + } else { + $tib1_121_i389 = $tib1_0_lcssa_i377; + label = 210; + break; + } + case 210: + $923 = ($tib1_121_i389 | 0) == ($tib2_0_lcssa_i386 | 0); + if ($923) { + label = 386; + break; + } else { + label = 211; + break; + } + case 211: + $924 = $tib1_121_i389 + 108 | 0; + $925 = HEAP32[$924 >> 2] | 0; + $926 = $tib1_121_i389 + 112 | 0; + $i_0_i392 = 0; + label = 212; + break; + case 212: + $928 = ($i_0_i392 | 0) < ($925 | 0); + if ($928) { + label = 213; + break; + } else { + label = 214; + break; + } + case 213: + $930 = HEAP32[$926 >> 2] | 0; + $931 = $930 + ($i_0_i392 << 2) | 0; + $932 = HEAP32[$931 >> 2] | 0; + $933 = ($932 | 0) == ($tib2_0_lcssa_i386 | 0); + $934 = $i_0_i392 + 1 | 0; + if ($933) { + label = 386; + break; + } else { + $i_0_i392 = $934; + label = 212; + break; + } + case 214: + $936 = $tib1_121_i389 + 40 | 0; + $937 = HEAP32[$936 >> 2] | 0; + $938 = ($937 | 0) == 0; + if ($938) { + label = 215; + break; + } else { + $tib1_121_i389 = $937; + label = 210; + break; + } + case 215: + $939 = HEAP32[$785 >> 2] | 0; + $940 = $939; + invoke_vii(48, $940 | 0, 0 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case 216: + $_r0_sroa_0 = 0; + $942 = HEAP32[(105500 | 0) >> 2] | 0; + $943 = ($942 | 0) == 0; + if ($943) { + label = 217; + break; + } else { + label = 218; + break; + } + case 217: + invoke_v(30); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 218; + break; + case 218: + $945 = invoke_i(70) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $946$0 = $945; + $946$1 = 0; + $947 = invoke_iii(364, $946$0 | 0, $946$1 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $948 = $local_env_w4567aaac23b1c35; + $949 = $947 + 16 | 0; + $950 = $949; + $951 = HEAP32[$950 >> 2] | 0; + _memcpy($948 | 0, $951 | 0, 40); + $952 = HEAP32[$950 >> 2] | 0; + $953 = $952; + $954 = _saveSetjmp($953 | 0, label, setjmpTable) | 0; + label = 420; + break; + case 420: + $955 = ($954 | 0) == 0; + if ($955) { + label = 219; + break; + } else { + label = 222; + break; + } + case 219: + $_r0_sroa_0_0_load607 = $_r0_sroa_0; + $957 = HEAP32[(98772 | 0) >> 2] | 0; + $958 = ($957 | 0) == 0; + if ($958) { + label = 220; + break; + } else { + label = 221; + break; + } + case 220: + invoke_v(702); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 221; + break; + case 221: + HEAP32[140048 >> 2] = $_r0_sroa_0_0_load607; + $960 = HEAP32[$950 >> 2] | 0; + _memcpy($960 | 0, $948 | 0, 40); + label = 239; + break; + case 222: + $962 = HEAP32[$950 >> 2] | 0; + _memcpy($962 | 0, $948 | 0, 40); + $963 = HEAP32[(107740 | 0) >> 2] | 0; + $964 = ($963 | 0) == 0; + if ($964) { + label = 223; + break; + } else { + label = 224; + break; + } + case 223: + invoke_v(374); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 224; + break; + case 224: + $967 = $947 + 20 | 0; + $968 = $967; + $969 = HEAP32[$968 >> 2] | 0; + $970 = ($969 | 0) == 0; + if ($970) { + label = 238; + break; + } else { + label = 225; + break; + } + case 225: + $972 = HEAP32[137616 >> 2] | 0; + $973 = $969; + $974 = HEAP32[$973 >> 2] | 0; + $975 = $974; + $976 = $972 + 8 | 0; + $977 = $976; + $978 = HEAP32[$977 >> 2] | 0; + $979 = ($974 | 0) == 82712; + if ($979) { + label = 226; + break; + } else { + $tib1_0_ph_i353 = $975; + label = 227; + break; + } + case 226: + $981 = $969 + 8 | 0; + $982 = $981; + $983 = HEAP32[$982 >> 2] | 0; + $984 = $983 + 8 | 0; + $985 = $984; + $986 = HEAP32[$985 >> 2] | 0; + $987 = $986; + $tib1_0_ph_i353 = $987; + label = 227; + break; + case 227: + $988 = $tib1_0_ph_i353 + 56 | 0; + $989 = HEAP32[$988 >> 2] | 0; + $990 = ($989 | 0) == 0; + if ($990) { + var $dimension_tib1_0_lcssa_i357 = 0; + var $tib1_0_lcssa_i356 = $tib1_0_ph_i353; + label = 229; + break; + } else { + var $dimension_tib1_029_i359 = 0; + var $996 = $989; + label = 230; + break; + } + case 228: + $991 = $999; + var $dimension_tib1_0_lcssa_i357 = $1000; + var $tib1_0_lcssa_i356 = $991; + label = 229; + break; + case 229: + $992 = $978 + 56 | 0; + $993 = $992; + $994 = HEAP32[$993 >> 2] | 0; + $995 = ($994 | 0) == 0; + if ($995) { + var $dimension_tib2_0_lcssa_i364 = 0; + var $tib2_0_lcssa_in_i363 = $978; + label = 232; + break; + } else { + var $dimension_tib2_024_i361 = 0; + var $1005 = $994; + label = 231; + break; + } + case 230: + $997 = $996 + 8 | 0; + $998 = $997; + $999 = HEAP32[$998 >> 2] | 0; + $1000 = $dimension_tib1_029_i359 + 1 | 0; + $1001 = $999 + 56 | 0; + $1002 = $1001; + $1003 = HEAP32[$1002 >> 2] | 0; + $1004 = ($1003 | 0) == 0; + if ($1004) { + label = 228; + break; + } else { + var $dimension_tib1_029_i359 = $1000; + var $996 = $1003; + label = 230; + break; + } + case 231: + $1006 = $1005 + 8 | 0; + $1007 = $1006; + $1008 = HEAP32[$1007 >> 2] | 0; + $1009 = $dimension_tib2_024_i361 + 1 | 0; + $1010 = $1008 + 56 | 0; + $1011 = $1010; + $1012 = HEAP32[$1011 >> 2] | 0; + $1013 = ($1012 | 0) == 0; + if ($1013) { + var $dimension_tib2_0_lcssa_i364 = $1009; + var $tib2_0_lcssa_in_i363 = $1008; + label = 232; + break; + } else { + var $dimension_tib2_024_i361 = $1009; + var $1005 = $1012; + label = 231; + break; + } + case 232: + $tib2_0_lcssa_i365 = $tib2_0_lcssa_in_i363; + $1014 = ($dimension_tib1_0_lcssa_i357 | 0) < ($dimension_tib2_0_lcssa_i364 | 0); + $1015 = ($tib1_0_lcssa_i356 | 0) == 0; + $or_cond_i366 = $1014 | $1015; + if ($or_cond_i366) { + label = 238; + break; + } else { + $tib1_121_i368 = $tib1_0_lcssa_i356; + label = 233; + break; + } + case 233: + $1016 = ($tib1_121_i368 | 0) == ($tib2_0_lcssa_i365 | 0); + if ($1016) { + label = 54; + break; + } else { + label = 234; + break; + } + case 234: + $1017 = $tib1_121_i368 + 108 | 0; + $1018 = HEAP32[$1017 >> 2] | 0; + $1019 = $tib1_121_i368 + 112 | 0; + $i_0_i371 = 0; + label = 235; + break; + case 235: + $1021 = ($i_0_i371 | 0) < ($1018 | 0); + if ($1021) { + label = 236; + break; + } else { + label = 237; + break; + } + case 236: + $1023 = HEAP32[$1019 >> 2] | 0; + $1024 = $1023 + ($i_0_i371 << 2) | 0; + $1025 = HEAP32[$1024 >> 2] | 0; + $1026 = ($1025 | 0) == ($tib2_0_lcssa_i365 | 0); + $1027 = $i_0_i371 + 1 | 0; + if ($1026) { + label = 54; + break; + } else { + $i_0_i371 = $1027; + label = 235; + break; + } + case 237: + $1029 = $tib1_121_i368 + 40 | 0; + $1030 = HEAP32[$1029 >> 2] | 0; + $1031 = ($1030 | 0) == 0; + if ($1031) { + label = 238; + break; + } else { + $tib1_121_i368 = $1030; + label = 233; + break; + } + case 238: + $1032 = HEAP32[$950 >> 2] | 0; + $1033 = $1032; + invoke_vii(48, $1033 | 0, 0 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case 239: + $_r0_sroa_0 = 0; + label = 28; + break; + case 240: + $1036 = $local_env_w4567aaac23b1c40; + $1037 = $548 + 16 | 0; + $1038 = $1037; + $1039 = HEAP32[$1038 >> 2] | 0; + _memcpy($1036 | 0, $1039 | 0, 40); + $1040 = HEAP32[$1038 >> 2] | 0; + $1041 = $1040; + $1042 = _saveSetjmp($1041 | 0, label, setjmpTable) | 0; + label = 421; + break; + case 421: + $1043 = ($1042 | 0) == 0; + if ($1043) { + label = 241; + break; + } else { + label = 253; + break; + } + case 241: + $1045 = HEAP32[(98772 | 0) >> 2] | 0; + $1046 = ($1045 | 0) == 0; + if ($1046) { + label = 242; + break; + } else { + label = 244; + break; + } + case 242: + invoke_v(702); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $_pr = HEAP32[(98772 | 0) >> 2] | 0; + $1048 = ($_pr | 0) == 0; + if ($1048) { + label = 243; + break; + } else { + label = 244; + break; + } + case 243: + invoke_v(702); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 244; + break; + case 244: + $1050 = HEAP32[140040 >> 2] | 0; + $1051 = ($1050 | 0) == 0; + if ($1051) { + label = 245; + break; + } else { + label = 246; + break; + } + case 245: + invoke_viiii(14, 16136 | 0 | 0, 11648 | 0 | 0, 126768 | 0 | 0, 573 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case 246: + $1053 = HEAP32[(98772 | 0) >> 2] | 0; + $1054 = ($1053 | 0) == 0; + if ($1054) { + label = 247; + break; + } else { + $1056 = $1050; + label = 248; + break; + } + case 247: + invoke_v(702); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $_pre855 = HEAP32[140040 >> 2] | 0; + $1056 = $_pre855; + label = 248; + break; + case 248: + $1057 = $1056; + $_r0_sroa_0 = $1057; + $_r0_sroa_0_0_load606 = $_r0_sroa_0; + $1058 = ($_r0_sroa_0_0_load606 | 0) == 0; + if ($1058) { + label = 252; + break; + } else { + label = 249; + break; + } + case 249: + $1060 = HEAP32[$1038 >> 2] | 0; + _memcpy($1060 | 0, $1036 | 0, 40); + $1061 = HEAP32[(105500 | 0) >> 2] | 0; + $1062 = ($1061 | 0) == 0; + if ($1062) { + label = 250; + break; + } else { + label = 251; + break; + } + case 250: + invoke_v(30); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 251; + break; + case 251: + $1064 = invoke_i(70) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $1065$0 = $1064; + $1065$1 = 0; + $1066 = invoke_iii(364, $1065$0 | 0, $1065$1 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $1067 = $local_env_w4567aaac23b1c42; + $1068 = $1066 + 16 | 0; + $1069 = $1068; + $1070 = HEAP32[$1069 >> 2] | 0; + _memcpy($1067 | 0, $1070 | 0, 40); + $1071 = HEAP32[$1069 >> 2] | 0; + $1072 = $1071; + $1073 = _saveSetjmp($1072 | 0, label, setjmpTable) | 0; + label = 422; + break; + case 422: + $1074 = ($1073 | 0) == 0; + if ($1074) { + label = 286; + break; + } else { + label = 289; + break; + } + case 252: + invoke_viiii(14, 16136 | 0 | 0, 11648 | 0 | 0, 126872 | 0 | 0, 1581 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case 253: + $1077 = HEAP32[$1038 >> 2] | 0; + _memcpy($1077 | 0, $1036 | 0, 40); + $1078 = HEAP32[(113236 | 0) >> 2] | 0; + $1079 = ($1078 | 0) == 0; + if ($1079) { + label = 254; + break; + } else { + label = 255; + break; + } + case 254: + invoke_v(538); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 255; + break; + case 255: + $1082 = $548 + 20 | 0; + $1083 = $1082; + $1084 = HEAP32[$1083 >> 2] | 0; + $1085 = ($1084 | 0) == 0; + if ($1085) { + label = 269; + break; + } else { + label = 256; + break; + } + case 256: + $1087 = HEAP32[138672 >> 2] | 0; + $1088 = $1084; + $1089 = HEAP32[$1088 >> 2] | 0; + $1090 = $1089; + $1091 = $1087 + 8 | 0; + $1092 = $1091; + $1093 = HEAP32[$1092 >> 2] | 0; + $1094 = ($1089 | 0) == 82712; + if ($1094) { + label = 257; + break; + } else { + $tib1_0_ph_i332 = $1090; + label = 258; + break; + } + case 257: + $1096 = $1084 + 8 | 0; + $1097 = $1096; + $1098 = HEAP32[$1097 >> 2] | 0; + $1099 = $1098 + 8 | 0; + $1100 = $1099; + $1101 = HEAP32[$1100 >> 2] | 0; + $1102 = $1101; + $tib1_0_ph_i332 = $1102; + label = 258; + break; + case 258: + $1103 = $tib1_0_ph_i332 + 56 | 0; + $1104 = HEAP32[$1103 >> 2] | 0; + $1105 = ($1104 | 0) == 0; + if ($1105) { + var $dimension_tib1_0_lcssa_i336 = 0; + var $tib1_0_lcssa_i335 = $tib1_0_ph_i332; + label = 260; + break; + } else { + var $dimension_tib1_029_i338 = 0; + var $1111 = $1104; + label = 261; + break; + } + case 259: + $1106 = $1114; + var $dimension_tib1_0_lcssa_i336 = $1115; + var $tib1_0_lcssa_i335 = $1106; + label = 260; + break; + case 260: + $1107 = $1093 + 56 | 0; + $1108 = $1107; + $1109 = HEAP32[$1108 >> 2] | 0; + $1110 = ($1109 | 0) == 0; + if ($1110) { + var $dimension_tib2_0_lcssa_i343 = 0; + var $tib2_0_lcssa_in_i342 = $1093; + label = 263; + break; + } else { + var $dimension_tib2_024_i340 = 0; + var $1120 = $1109; + label = 262; + break; + } + case 261: + $1112 = $1111 + 8 | 0; + $1113 = $1112; + $1114 = HEAP32[$1113 >> 2] | 0; + $1115 = $dimension_tib1_029_i338 + 1 | 0; + $1116 = $1114 + 56 | 0; + $1117 = $1116; + $1118 = HEAP32[$1117 >> 2] | 0; + $1119 = ($1118 | 0) == 0; + if ($1119) { + label = 259; + break; + } else { + var $dimension_tib1_029_i338 = $1115; + var $1111 = $1118; + label = 261; + break; + } + case 262: + $1121 = $1120 + 8 | 0; + $1122 = $1121; + $1123 = HEAP32[$1122 >> 2] | 0; + $1124 = $dimension_tib2_024_i340 + 1 | 0; + $1125 = $1123 + 56 | 0; + $1126 = $1125; + $1127 = HEAP32[$1126 >> 2] | 0; + $1128 = ($1127 | 0) == 0; + if ($1128) { + var $dimension_tib2_0_lcssa_i343 = $1124; + var $tib2_0_lcssa_in_i342 = $1123; + label = 263; + break; + } else { + var $dimension_tib2_024_i340 = $1124; + var $1120 = $1127; + label = 262; + break; + } + case 263: + $tib2_0_lcssa_i344 = $tib2_0_lcssa_in_i342; + $1129 = ($dimension_tib1_0_lcssa_i336 | 0) < ($dimension_tib2_0_lcssa_i343 | 0); + $1130 = ($tib1_0_lcssa_i335 | 0) == 0; + $or_cond_i345 = $1129 | $1130; + if ($or_cond_i345) { + label = 269; + break; + } else { + $tib1_121_i347 = $tib1_0_lcssa_i335; + label = 264; + break; + } + case 264: + $1131 = ($tib1_121_i347 | 0) == ($tib2_0_lcssa_i344 | 0); + if ($1131) { + label = 361; + break; + } else { + label = 265; + break; + } + case 265: + $1132 = $tib1_121_i347 + 108 | 0; + $1133 = HEAP32[$1132 >> 2] | 0; + $1134 = $tib1_121_i347 + 112 | 0; + $i_0_i350 = 0; + label = 266; + break; + case 266: + $1136 = ($i_0_i350 | 0) < ($1133 | 0); + if ($1136) { + label = 267; + break; + } else { + label = 268; + break; + } + case 267: + $1138 = HEAP32[$1134 >> 2] | 0; + $1139 = $1138 + ($i_0_i350 << 2) | 0; + $1140 = HEAP32[$1139 >> 2] | 0; + $1141 = ($1140 | 0) == ($tib2_0_lcssa_i344 | 0); + $1142 = $i_0_i350 + 1 | 0; + if ($1141) { + label = 361; + break; + } else { + $i_0_i350 = $1142; + label = 266; + break; + } + case 268: + $1144 = $tib1_121_i347 + 40 | 0; + $1145 = HEAP32[$1144 >> 2] | 0; + $1146 = ($1145 | 0) == 0; + if ($1146) { + label = 269; + break; + } else { + $tib1_121_i347 = $1145; + label = 264; + break; + } + case 269: + $1147 = HEAP32[(107740 | 0) >> 2] | 0; + $1148 = ($1147 | 0) == 0; + if ($1148) { + label = 270; + break; + } else { + label = 271; + break; + } + case 270: + invoke_v(374); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 271; + break; + case 271: + $1151 = HEAP32[$1083 >> 2] | 0; + $1152 = ($1151 | 0) == 0; + if ($1152) { + label = 285; + break; + } else { + label = 272; + break; + } + case 272: + $1154 = HEAP32[137616 >> 2] | 0; + $1155 = $1151; + $1156 = HEAP32[$1155 >> 2] | 0; + $1157 = $1156; + $1158 = $1154 + 8 | 0; + $1159 = $1158; + $1160 = HEAP32[$1159 >> 2] | 0; + $1161 = ($1156 | 0) == 82712; + if ($1161) { + label = 273; + break; + } else { + $tib1_0_ph_i311 = $1157; + label = 274; + break; + } + case 273: + $1163 = $1151 + 8 | 0; + $1164 = $1163; + $1165 = HEAP32[$1164 >> 2] | 0; + $1166 = $1165 + 8 | 0; + $1167 = $1166; + $1168 = HEAP32[$1167 >> 2] | 0; + $1169 = $1168; + $tib1_0_ph_i311 = $1169; + label = 274; + break; + case 274: + $1170 = $tib1_0_ph_i311 + 56 | 0; + $1171 = HEAP32[$1170 >> 2] | 0; + $1172 = ($1171 | 0) == 0; + if ($1172) { + var $dimension_tib1_0_lcssa_i315 = 0; + var $tib1_0_lcssa_i314 = $tib1_0_ph_i311; + label = 276; + break; + } else { + var $dimension_tib1_029_i317 = 0; + var $1178 = $1171; + label = 277; + break; + } + case 275: + $1173 = $1181; + var $dimension_tib1_0_lcssa_i315 = $1182; + var $tib1_0_lcssa_i314 = $1173; + label = 276; + break; + case 276: + $1174 = $1160 + 56 | 0; + $1175 = $1174; + $1176 = HEAP32[$1175 >> 2] | 0; + $1177 = ($1176 | 0) == 0; + if ($1177) { + var $dimension_tib2_0_lcssa_i322 = 0; + var $tib2_0_lcssa_in_i321 = $1160; + label = 279; + break; + } else { + var $dimension_tib2_024_i319 = 0; + var $1187 = $1176; + label = 278; + break; + } + case 277: + $1179 = $1178 + 8 | 0; + $1180 = $1179; + $1181 = HEAP32[$1180 >> 2] | 0; + $1182 = $dimension_tib1_029_i317 + 1 | 0; + $1183 = $1181 + 56 | 0; + $1184 = $1183; + $1185 = HEAP32[$1184 >> 2] | 0; + $1186 = ($1185 | 0) == 0; + if ($1186) { + label = 275; + break; + } else { + var $dimension_tib1_029_i317 = $1182; + var $1178 = $1185; + label = 277; + break; + } + case 278: + $1188 = $1187 + 8 | 0; + $1189 = $1188; + $1190 = HEAP32[$1189 >> 2] | 0; + $1191 = $dimension_tib2_024_i319 + 1 | 0; + $1192 = $1190 + 56 | 0; + $1193 = $1192; + $1194 = HEAP32[$1193 >> 2] | 0; + $1195 = ($1194 | 0) == 0; + if ($1195) { + var $dimension_tib2_0_lcssa_i322 = $1191; + var $tib2_0_lcssa_in_i321 = $1190; + label = 279; + break; + } else { + var $dimension_tib2_024_i319 = $1191; + var $1187 = $1194; + label = 278; + break; + } + case 279: + $tib2_0_lcssa_i323 = $tib2_0_lcssa_in_i321; + $1196 = ($dimension_tib1_0_lcssa_i315 | 0) < ($dimension_tib2_0_lcssa_i322 | 0); + $1197 = ($tib1_0_lcssa_i314 | 0) == 0; + $or_cond_i324 = $1196 | $1197; + if ($or_cond_i324) { + label = 285; + break; + } else { + $tib1_121_i326 = $tib1_0_lcssa_i314; + label = 280; + break; + } + case 280: + $1198 = ($tib1_121_i326 | 0) == ($tib2_0_lcssa_i323 | 0); + if ($1198) { + label = 386; + break; + } else { + label = 281; + break; + } + case 281: + $1199 = $tib1_121_i326 + 108 | 0; + $1200 = HEAP32[$1199 >> 2] | 0; + $1201 = $tib1_121_i326 + 112 | 0; + $i_0_i329 = 0; + label = 282; + break; + case 282: + $1203 = ($i_0_i329 | 0) < ($1200 | 0); + if ($1203) { + label = 283; + break; + } else { + label = 284; + break; + } + case 283: + $1205 = HEAP32[$1201 >> 2] | 0; + $1206 = $1205 + ($i_0_i329 << 2) | 0; + $1207 = HEAP32[$1206 >> 2] | 0; + $1208 = ($1207 | 0) == ($tib2_0_lcssa_i323 | 0); + $1209 = $i_0_i329 + 1 | 0; + if ($1208) { + label = 386; + break; + } else { + $i_0_i329 = $1209; + label = 282; + break; + } + case 284: + $1211 = $tib1_121_i326 + 40 | 0; + $1212 = HEAP32[$1211 >> 2] | 0; + $1213 = ($1212 | 0) == 0; + if ($1213) { + label = 285; + break; + } else { + $tib1_121_i326 = $1212; + label = 280; + break; + } + case 285: + $1214 = HEAP32[$1038 >> 2] | 0; + $1215 = $1214; + invoke_vii(48, $1215 | 0, 0 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case 286: + $1217 = HEAP32[(98772 | 0) >> 2] | 0; + $1218 = ($1217 | 0) == 0; + if ($1218) { + label = 287; + break; + } else { + label = 288; + break; + } + case 287: + invoke_v(702); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 288; + break; + case 288: + $1220 = HEAP32[140040 >> 2] | 0; + $1221 = $1220; + $_r0_sroa_0 = $1221; + $1222 = invoke_ii(556, 709 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $_r3_sroa_0 = $1222; + $_r0_sroa_0_0_load605 = $_r0_sroa_0; + $_r3_sroa_0_0_load594 = $_r3_sroa_0; + $_r0_sroa_0 = 0; + $_r0_sroa_0_0_load623 = $_r0_sroa_0; + $1223 = $_r0_sroa_0_0_load623; + $_r3_sroa_0 = $1223; + $_r0_sroa_1_4__r3_sroa_1_4_idx_idx = $_r3_sroa_1 | 0; + $_r0_sroa_1_4_idx156 = $_r0_sroa_1 | 0; + HEAP32[$_r0_sroa_1_4__r3_sroa_1_4_idx_idx >> 2] = HEAP32[$_r0_sroa_1_4_idx156 >> 2] | 0; + $1224 = HEAP32[$1069 >> 2] | 0; + _memcpy($1224 | 0, $1067 | 0, 40); + label = 179; + break; + case 289: + $1226 = HEAP32[$1069 >> 2] | 0; + _memcpy($1226 | 0, $1067 | 0, 40); + $1227 = HEAP32[(113236 | 0) >> 2] | 0; + $1228 = ($1227 | 0) == 0; + if ($1228) { + label = 290; + break; + } else { + label = 291; + break; + } + case 290: + invoke_v(538); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 291; + break; + case 291: + $1231 = $1066 + 20 | 0; + $1232 = $1231; + $1233 = HEAP32[$1232 >> 2] | 0; + $1234 = ($1233 | 0) == 0; + if ($1234) { + label = 305; + break; + } else { + label = 292; + break; + } + case 292: + $1236 = HEAP32[138672 >> 2] | 0; + $1237 = $1233; + $1238 = HEAP32[$1237 >> 2] | 0; + $1239 = $1238; + $1240 = $1236 + 8 | 0; + $1241 = $1240; + $1242 = HEAP32[$1241 >> 2] | 0; + $1243 = ($1238 | 0) == 82712; + if ($1243) { + label = 293; + break; + } else { + $tib1_0_ph_i290 = $1239; + label = 294; + break; + } + case 293: + $1245 = $1233 + 8 | 0; + $1246 = $1245; + $1247 = HEAP32[$1246 >> 2] | 0; + $1248 = $1247 + 8 | 0; + $1249 = $1248; + $1250 = HEAP32[$1249 >> 2] | 0; + $1251 = $1250; + $tib1_0_ph_i290 = $1251; + label = 294; + break; + case 294: + $1252 = $tib1_0_ph_i290 + 56 | 0; + $1253 = HEAP32[$1252 >> 2] | 0; + $1254 = ($1253 | 0) == 0; + if ($1254) { + var $dimension_tib1_0_lcssa_i294 = 0; + var $tib1_0_lcssa_i293 = $tib1_0_ph_i290; + label = 296; + break; + } else { + var $dimension_tib1_029_i296 = 0; + var $1260 = $1253; + label = 297; + break; + } + case 295: + $1255 = $1263; + var $dimension_tib1_0_lcssa_i294 = $1264; + var $tib1_0_lcssa_i293 = $1255; + label = 296; + break; + case 296: + $1256 = $1242 + 56 | 0; + $1257 = $1256; + $1258 = HEAP32[$1257 >> 2] | 0; + $1259 = ($1258 | 0) == 0; + if ($1259) { + var $dimension_tib2_0_lcssa_i301 = 0; + var $tib2_0_lcssa_in_i300 = $1242; + label = 299; + break; + } else { + var $dimension_tib2_024_i298 = 0; + var $1269 = $1258; + label = 298; + break; + } + case 297: + $1261 = $1260 + 8 | 0; + $1262 = $1261; + $1263 = HEAP32[$1262 >> 2] | 0; + $1264 = $dimension_tib1_029_i296 + 1 | 0; + $1265 = $1263 + 56 | 0; + $1266 = $1265; + $1267 = HEAP32[$1266 >> 2] | 0; + $1268 = ($1267 | 0) == 0; + if ($1268) { + label = 295; + break; + } else { + var $dimension_tib1_029_i296 = $1264; + var $1260 = $1267; + label = 297; + break; + } + case 298: + $1270 = $1269 + 8 | 0; + $1271 = $1270; + $1272 = HEAP32[$1271 >> 2] | 0; + $1273 = $dimension_tib2_024_i298 + 1 | 0; + $1274 = $1272 + 56 | 0; + $1275 = $1274; + $1276 = HEAP32[$1275 >> 2] | 0; + $1277 = ($1276 | 0) == 0; + if ($1277) { + var $dimension_tib2_0_lcssa_i301 = $1273; + var $tib2_0_lcssa_in_i300 = $1272; + label = 299; + break; + } else { + var $dimension_tib2_024_i298 = $1273; + var $1269 = $1276; + label = 298; + break; + } + case 299: + $tib2_0_lcssa_i302 = $tib2_0_lcssa_in_i300; + $1278 = ($dimension_tib1_0_lcssa_i294 | 0) < ($dimension_tib2_0_lcssa_i301 | 0); + $1279 = ($tib1_0_lcssa_i293 | 0) == 0; + $or_cond_i303 = $1278 | $1279; + if ($or_cond_i303) { + label = 305; + break; + } else { + $tib1_121_i305 = $tib1_0_lcssa_i293; + label = 300; + break; + } + case 300: + $1280 = ($tib1_121_i305 | 0) == ($tib2_0_lcssa_i302 | 0); + if ($1280) { + label = 361; + break; + } else { + label = 301; + break; + } + case 301: + $1281 = $tib1_121_i305 + 108 | 0; + $1282 = HEAP32[$1281 >> 2] | 0; + $1283 = $tib1_121_i305 + 112 | 0; + $i_0_i308 = 0; + label = 302; + break; + case 302: + $1285 = ($i_0_i308 | 0) < ($1282 | 0); + if ($1285) { + label = 303; + break; + } else { + label = 304; + break; + } + case 303: + $1287 = HEAP32[$1283 >> 2] | 0; + $1288 = $1287 + ($i_0_i308 << 2) | 0; + $1289 = HEAP32[$1288 >> 2] | 0; + $1290 = ($1289 | 0) == ($tib2_0_lcssa_i302 | 0); + $1291 = $i_0_i308 + 1 | 0; + if ($1290) { + label = 361; + break; + } else { + $i_0_i308 = $1291; + label = 302; + break; + } + case 304: + $1293 = $tib1_121_i305 + 40 | 0; + $1294 = HEAP32[$1293 >> 2] | 0; + $1295 = ($1294 | 0) == 0; + if ($1295) { + label = 305; + break; + } else { + $tib1_121_i305 = $1294; + label = 300; + break; + } + case 305: + $1296 = HEAP32[(107740 | 0) >> 2] | 0; + $1297 = ($1296 | 0) == 0; + if ($1297) { + label = 306; + break; + } else { + label = 307; + break; + } + case 306: + invoke_v(374); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 307; + break; + case 307: + $1300 = HEAP32[$1232 >> 2] | 0; + $1301 = ($1300 | 0) == 0; + if ($1301) { + label = 321; + break; + } else { + label = 308; + break; + } + case 308: + $1303 = HEAP32[137616 >> 2] | 0; + $1304 = $1300; + $1305 = HEAP32[$1304 >> 2] | 0; + $1306 = $1305; + $1307 = $1303 + 8 | 0; + $1308 = $1307; + $1309 = HEAP32[$1308 >> 2] | 0; + $1310 = ($1305 | 0) == 82712; + if ($1310) { + label = 309; + break; + } else { + $tib1_0_ph_i269 = $1306; + label = 310; + break; + } + case 309: + $1312 = $1300 + 8 | 0; + $1313 = $1312; + $1314 = HEAP32[$1313 >> 2] | 0; + $1315 = $1314 + 8 | 0; + $1316 = $1315; + $1317 = HEAP32[$1316 >> 2] | 0; + $1318 = $1317; + $tib1_0_ph_i269 = $1318; + label = 310; + break; + case 310: + $1319 = $tib1_0_ph_i269 + 56 | 0; + $1320 = HEAP32[$1319 >> 2] | 0; + $1321 = ($1320 | 0) == 0; + if ($1321) { + var $dimension_tib1_0_lcssa_i273 = 0; + var $tib1_0_lcssa_i272 = $tib1_0_ph_i269; + label = 312; + break; + } else { + var $dimension_tib1_029_i275 = 0; + var $1327 = $1320; + label = 313; + break; + } + case 311: + $1322 = $1330; + var $dimension_tib1_0_lcssa_i273 = $1331; + var $tib1_0_lcssa_i272 = $1322; + label = 312; + break; + case 312: + $1323 = $1309 + 56 | 0; + $1324 = $1323; + $1325 = HEAP32[$1324 >> 2] | 0; + $1326 = ($1325 | 0) == 0; + if ($1326) { + var $dimension_tib2_0_lcssa_i280 = 0; + var $tib2_0_lcssa_in_i279 = $1309; + label = 315; + break; + } else { + var $dimension_tib2_024_i277 = 0; + var $1336 = $1325; + label = 314; + break; + } + case 313: + $1328 = $1327 + 8 | 0; + $1329 = $1328; + $1330 = HEAP32[$1329 >> 2] | 0; + $1331 = $dimension_tib1_029_i275 + 1 | 0; + $1332 = $1330 + 56 | 0; + $1333 = $1332; + $1334 = HEAP32[$1333 >> 2] | 0; + $1335 = ($1334 | 0) == 0; + if ($1335) { + label = 311; + break; + } else { + var $dimension_tib1_029_i275 = $1331; + var $1327 = $1334; + label = 313; + break; + } + case 314: + $1337 = $1336 + 8 | 0; + $1338 = $1337; + $1339 = HEAP32[$1338 >> 2] | 0; + $1340 = $dimension_tib2_024_i277 + 1 | 0; + $1341 = $1339 + 56 | 0; + $1342 = $1341; + $1343 = HEAP32[$1342 >> 2] | 0; + $1344 = ($1343 | 0) == 0; + if ($1344) { + var $dimension_tib2_0_lcssa_i280 = $1340; + var $tib2_0_lcssa_in_i279 = $1339; + label = 315; + break; + } else { + var $dimension_tib2_024_i277 = $1340; + var $1336 = $1343; + label = 314; + break; + } + case 315: + $tib2_0_lcssa_i281 = $tib2_0_lcssa_in_i279; + $1345 = ($dimension_tib1_0_lcssa_i273 | 0) < ($dimension_tib2_0_lcssa_i280 | 0); + $1346 = ($tib1_0_lcssa_i272 | 0) == 0; + $or_cond_i282 = $1345 | $1346; + if ($or_cond_i282) { + label = 321; + break; + } else { + $tib1_121_i284 = $tib1_0_lcssa_i272; + label = 316; + break; + } + case 316: + $1347 = ($tib1_121_i284 | 0) == ($tib2_0_lcssa_i281 | 0); + if ($1347) { + label = 386; + break; + } else { + label = 317; + break; + } + case 317: + $1348 = $tib1_121_i284 + 108 | 0; + $1349 = HEAP32[$1348 >> 2] | 0; + $1350 = $tib1_121_i284 + 112 | 0; + $i_0_i287 = 0; + label = 318; + break; + case 318: + $1352 = ($i_0_i287 | 0) < ($1349 | 0); + if ($1352) { + label = 319; + break; + } else { + label = 320; + break; + } + case 319: + $1354 = HEAP32[$1350 >> 2] | 0; + $1355 = $1354 + ($i_0_i287 << 2) | 0; + $1356 = HEAP32[$1355 >> 2] | 0; + $1357 = ($1356 | 0) == ($tib2_0_lcssa_i281 | 0); + $1358 = $i_0_i287 + 1 | 0; + if ($1357) { + label = 386; + break; + } else { + $i_0_i287 = $1358; + label = 318; + break; + } + case 320: + $1360 = $tib1_121_i284 + 40 | 0; + $1361 = HEAP32[$1360 >> 2] | 0; + $1362 = ($1361 | 0) == 0; + if ($1362) { + label = 321; + break; + } else { + $tib1_121_i284 = $1361; + label = 316; + break; + } + case 321: + $1363 = HEAP32[$1069 >> 2] | 0; + $1364 = $1363; + invoke_vii(48, $1364 | 0, 0 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case 322: + $1366 = HEAP32[(105500 | 0) >> 2] | 0; + $1367 = ($1366 | 0) == 0; + if ($1367) { + label = 323; + break; + } else { + label = 324; + break; + } + case 323: + invoke_v(30); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 324; + break; + case 324: + $1369 = invoke_i(70) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $1370$0 = $1369; + $1370$1 = 0; + $1371 = invoke_iii(364, $1370$0 | 0, $1370$1 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $1372 = $local_env_w4567aaac23b1c44; + $1373 = $1371 + 16 | 0; + $1374 = $1373; + $1375 = HEAP32[$1374 >> 2] | 0; + _memcpy($1372 | 0, $1375 | 0, 40); + $1376 = HEAP32[$1374 >> 2] | 0; + $1377 = $1376; + $1378 = _saveSetjmp($1377 | 0, label, setjmpTable) | 0; + label = 423; + break; + case 423: + $1379 = ($1378 | 0) == 0; + if ($1379) { + label = 325; + break; + } else { + label = 328; + break; + } + case 325: + $_r0_sroa_0 = 1; + $_r0_sroa_0_0_load604 = $_r0_sroa_0; + $1381 = HEAP32[(98772 | 0) >> 2] | 0; + $1382 = ($1381 | 0) == 0; + if ($1382) { + label = 326; + break; + } else { + label = 327; + break; + } + case 326: + invoke_v(702); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 327; + break; + case 327: + HEAP32[140048 >> 2] = $_r0_sroa_0_0_load604; + $_r3_sroa_0_0_load593 = $_r3_sroa_0; + $1384 = $_r3_sroa_0_0_load593; + $1385 = HEAP32[$1384 >> 2] | 0; + $1386 = $1385 + 116 | 0; + $1387 = HEAP32[$1386 >> 2] | 0; + $1388 = $1387 + 4 | 0; + $1389 = HEAP32[$1388 >> 2] | 0; + $1390 = $1389; + $_r3_sroa_0_0_load = $_r3_sroa_0; + $1391 = invoke_ii($1390 | 0, $_r3_sroa_0_0_load | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $1392 = $1391; + $_r0_sroa_0 = $1392; + invoke_viiii(14, 16136 | 0 | 0, 11648 | 0 | 0, 126872 | 0 | 0, 1630 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case 328: + $1394 = HEAP32[$1374 >> 2] | 0; + _memcpy($1394 | 0, $1372 | 0, 40); + $1395 = HEAP32[(113236 | 0) >> 2] | 0; + $1396 = ($1395 | 0) == 0; + if ($1396) { + label = 329; + break; + } else { + label = 330; + break; + } + case 329: + invoke_v(538); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 330; + break; + case 330: + $1399 = $1371 + 20 | 0; + $1400 = $1399; + $1401 = HEAP32[$1400 >> 2] | 0; + $1402 = ($1401 | 0) == 0; + if ($1402) { + label = 344; + break; + } else { + label = 331; + break; + } + case 331: + $1404 = HEAP32[138672 >> 2] | 0; + $1405 = $1401; + $1406 = HEAP32[$1405 >> 2] | 0; + $1407 = $1406; + $1408 = $1404 + 8 | 0; + $1409 = $1408; + $1410 = HEAP32[$1409 >> 2] | 0; + $1411 = ($1406 | 0) == 82712; + if ($1411) { + label = 332; + break; + } else { + $tib1_0_ph_i248 = $1407; + label = 333; + break; + } + case 332: + $1413 = $1401 + 8 | 0; + $1414 = $1413; + $1415 = HEAP32[$1414 >> 2] | 0; + $1416 = $1415 + 8 | 0; + $1417 = $1416; + $1418 = HEAP32[$1417 >> 2] | 0; + $1419 = $1418; + $tib1_0_ph_i248 = $1419; + label = 333; + break; + case 333: + $1420 = $tib1_0_ph_i248 + 56 | 0; + $1421 = HEAP32[$1420 >> 2] | 0; + $1422 = ($1421 | 0) == 0; + if ($1422) { + var $dimension_tib1_0_lcssa_i252 = 0; + var $tib1_0_lcssa_i251 = $tib1_0_ph_i248; + label = 335; + break; + } else { + var $dimension_tib1_029_i254 = 0; + var $1428 = $1421; + label = 336; + break; + } + case 334: + $1423 = $1431; + var $dimension_tib1_0_lcssa_i252 = $1432; + var $tib1_0_lcssa_i251 = $1423; + label = 335; + break; + case 335: + $1424 = $1410 + 56 | 0; + $1425 = $1424; + $1426 = HEAP32[$1425 >> 2] | 0; + $1427 = ($1426 | 0) == 0; + if ($1427) { + var $dimension_tib2_0_lcssa_i259 = 0; + var $tib2_0_lcssa_in_i258 = $1410; + label = 338; + break; + } else { + var $dimension_tib2_024_i256 = 0; + var $1437 = $1426; + label = 337; + break; + } + case 336: + $1429 = $1428 + 8 | 0; + $1430 = $1429; + $1431 = HEAP32[$1430 >> 2] | 0; + $1432 = $dimension_tib1_029_i254 + 1 | 0; + $1433 = $1431 + 56 | 0; + $1434 = $1433; + $1435 = HEAP32[$1434 >> 2] | 0; + $1436 = ($1435 | 0) == 0; + if ($1436) { + label = 334; + break; + } else { + var $dimension_tib1_029_i254 = $1432; + var $1428 = $1435; + label = 336; + break; + } + case 337: + $1438 = $1437 + 8 | 0; + $1439 = $1438; + $1440 = HEAP32[$1439 >> 2] | 0; + $1441 = $dimension_tib2_024_i256 + 1 | 0; + $1442 = $1440 + 56 | 0; + $1443 = $1442; + $1444 = HEAP32[$1443 >> 2] | 0; + $1445 = ($1444 | 0) == 0; + if ($1445) { + var $dimension_tib2_0_lcssa_i259 = $1441; + var $tib2_0_lcssa_in_i258 = $1440; + label = 338; + break; + } else { + var $dimension_tib2_024_i256 = $1441; + var $1437 = $1444; + label = 337; + break; + } + case 338: + $tib2_0_lcssa_i260 = $tib2_0_lcssa_in_i258; + $1446 = ($dimension_tib1_0_lcssa_i252 | 0) < ($dimension_tib2_0_lcssa_i259 | 0); + $1447 = ($tib1_0_lcssa_i251 | 0) == 0; + $or_cond_i261 = $1446 | $1447; + if ($or_cond_i261) { + label = 344; + break; + } else { + $tib1_121_i263 = $tib1_0_lcssa_i251; + label = 339; + break; + } + case 339: + $1448 = ($tib1_121_i263 | 0) == ($tib2_0_lcssa_i260 | 0); + if ($1448) { + label = 361; + break; + } else { + label = 340; + break; + } + case 340: + $1449 = $tib1_121_i263 + 108 | 0; + $1450 = HEAP32[$1449 >> 2] | 0; + $1451 = $tib1_121_i263 + 112 | 0; + $i_0_i266 = 0; + label = 341; + break; + case 341: + $1453 = ($i_0_i266 | 0) < ($1450 | 0); + if ($1453) { + label = 342; + break; + } else { + label = 343; + break; + } + case 342: + $1455 = HEAP32[$1451 >> 2] | 0; + $1456 = $1455 + ($i_0_i266 << 2) | 0; + $1457 = HEAP32[$1456 >> 2] | 0; + $1458 = ($1457 | 0) == ($tib2_0_lcssa_i260 | 0); + $1459 = $i_0_i266 + 1 | 0; + if ($1458) { + label = 361; + break; + } else { + $i_0_i266 = $1459; + label = 341; + break; + } + case 343: + $1461 = $tib1_121_i263 + 40 | 0; + $1462 = HEAP32[$1461 >> 2] | 0; + $1463 = ($1462 | 0) == 0; + if ($1463) { + label = 344; + break; + } else { + $tib1_121_i263 = $1462; + label = 339; + break; + } + case 344: + $1464 = HEAP32[(107740 | 0) >> 2] | 0; + $1465 = ($1464 | 0) == 0; + if ($1465) { + label = 345; + break; + } else { + label = 346; + break; + } + case 345: + invoke_v(374); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 346; + break; + case 346: + $1468 = HEAP32[$1400 >> 2] | 0; + $1469 = ($1468 | 0) == 0; + if ($1469) { + label = 360; + break; + } else { + label = 347; + break; + } + case 347: + $1471 = HEAP32[137616 >> 2] | 0; + $1472 = $1468; + $1473 = HEAP32[$1472 >> 2] | 0; + $1474 = $1473; + $1475 = $1471 + 8 | 0; + $1476 = $1475; + $1477 = HEAP32[$1476 >> 2] | 0; + $1478 = ($1473 | 0) == 82712; + if ($1478) { + label = 348; + break; + } else { + $tib1_0_ph_i227 = $1474; + label = 349; + break; + } + case 348: + $1480 = $1468 + 8 | 0; + $1481 = $1480; + $1482 = HEAP32[$1481 >> 2] | 0; + $1483 = $1482 + 8 | 0; + $1484 = $1483; + $1485 = HEAP32[$1484 >> 2] | 0; + $1486 = $1485; + $tib1_0_ph_i227 = $1486; + label = 349; + break; + case 349: + $1487 = $tib1_0_ph_i227 + 56 | 0; + $1488 = HEAP32[$1487 >> 2] | 0; + $1489 = ($1488 | 0) == 0; + if ($1489) { + var $dimension_tib1_0_lcssa_i231 = 0; + var $tib1_0_lcssa_i230 = $tib1_0_ph_i227; + label = 351; + break; + } else { + var $dimension_tib1_029_i233 = 0; + var $1495 = $1488; + label = 352; + break; + } + case 350: + $1490 = $1498; + var $dimension_tib1_0_lcssa_i231 = $1499; + var $tib1_0_lcssa_i230 = $1490; + label = 351; + break; + case 351: + $1491 = $1477 + 56 | 0; + $1492 = $1491; + $1493 = HEAP32[$1492 >> 2] | 0; + $1494 = ($1493 | 0) == 0; + if ($1494) { + var $dimension_tib2_0_lcssa_i238 = 0; + var $tib2_0_lcssa_in_i237 = $1477; + label = 354; + break; + } else { + var $dimension_tib2_024_i235 = 0; + var $1504 = $1493; + label = 353; + break; + } + case 352: + $1496 = $1495 + 8 | 0; + $1497 = $1496; + $1498 = HEAP32[$1497 >> 2] | 0; + $1499 = $dimension_tib1_029_i233 + 1 | 0; + $1500 = $1498 + 56 | 0; + $1501 = $1500; + $1502 = HEAP32[$1501 >> 2] | 0; + $1503 = ($1502 | 0) == 0; + if ($1503) { + label = 350; + break; + } else { + var $dimension_tib1_029_i233 = $1499; + var $1495 = $1502; + label = 352; + break; + } + case 353: + $1505 = $1504 + 8 | 0; + $1506 = $1505; + $1507 = HEAP32[$1506 >> 2] | 0; + $1508 = $dimension_tib2_024_i235 + 1 | 0; + $1509 = $1507 + 56 | 0; + $1510 = $1509; + $1511 = HEAP32[$1510 >> 2] | 0; + $1512 = ($1511 | 0) == 0; + if ($1512) { + var $dimension_tib2_0_lcssa_i238 = $1508; + var $tib2_0_lcssa_in_i237 = $1507; + label = 354; + break; + } else { + var $dimension_tib2_024_i235 = $1508; + var $1504 = $1511; + label = 353; + break; + } + case 354: + $tib2_0_lcssa_i239 = $tib2_0_lcssa_in_i237; + $1513 = ($dimension_tib1_0_lcssa_i231 | 0) < ($dimension_tib2_0_lcssa_i238 | 0); + $1514 = ($tib1_0_lcssa_i230 | 0) == 0; + $or_cond_i240 = $1513 | $1514; + if ($or_cond_i240) { + label = 360; + break; + } else { + $tib1_121_i242 = $tib1_0_lcssa_i230; + label = 355; + break; + } + case 355: + $1515 = ($tib1_121_i242 | 0) == ($tib2_0_lcssa_i239 | 0); + if ($1515) { + label = 386; + break; + } else { + label = 356; + break; + } + case 356: + $1516 = $tib1_121_i242 + 108 | 0; + $1517 = HEAP32[$1516 >> 2] | 0; + $1518 = $tib1_121_i242 + 112 | 0; + $i_0_i245 = 0; + label = 357; + break; + case 357: + $1520 = ($i_0_i245 | 0) < ($1517 | 0); + if ($1520) { + label = 358; + break; + } else { + label = 359; + break; + } + case 358: + $1522 = HEAP32[$1518 >> 2] | 0; + $1523 = $1522 + ($i_0_i245 << 2) | 0; + $1524 = HEAP32[$1523 >> 2] | 0; + $1525 = ($1524 | 0) == ($tib2_0_lcssa_i239 | 0); + $1526 = $i_0_i245 + 1 | 0; + if ($1525) { + label = 386; + break; + } else { + $i_0_i245 = $1526; + label = 357; + break; + } + case 359: + $1528 = $tib1_121_i242 + 40 | 0; + $1529 = HEAP32[$1528 >> 2] | 0; + $1530 = ($1529 | 0) == 0; + if ($1530) { + label = 360; + break; + } else { + $tib1_121_i242 = $1529; + label = 355; + break; + } + case 360: + $1531 = HEAP32[$1374 >> 2] | 0; + $1532 = $1531; + invoke_vii(48, $1532 | 0, 0 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; } + __THREW__ = threwValue = 0; + return 0 | 0; + case 361: + $1533 = HEAP32[(105500 | 0) >> 2] | 0; + $1534 = ($1533 | 0) == 0; + if ($1534) { + label = 362; + break; + } else { + label = 363; + break; + } + case 362: + invoke_v(30); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 363; + break; + case 363: + $1536 = invoke_i(70) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $1537$0 = $1536; + $1537$1 = 0; + $1538 = invoke_iii(364, $1537$0 | 0, $1537$1 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $1539 = $local_env_w4567aaac23b1c48; + $1540 = $1538 + 16 | 0; + $1541 = $1540; + $1542 = HEAP32[$1541 >> 2] | 0; + _memcpy($1539 | 0, $1542 | 0, 40); + $1543 = HEAP32[$1541 >> 2] | 0; + $1544 = $1543; + $1545 = _saveSetjmp($1544 | 0, label, setjmpTable) | 0; + label = 424; + break; + case 424: + $1546 = ($1545 | 0) == 0; + if ($1546) { + label = 364; + break; + } else { + label = 369; + break; + } + case 364: + $1548 = HEAP32[(105500 | 0) >> 2] | 0; + $1549 = ($1548 | 0) == 0; + if ($1549) { + label = 365; + break; + } else { + label = 366; + break; + } + case 365: + invoke_v(30); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 366; + break; + case 366: + $1551 = invoke_i(70) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $1552$0 = $1551; + $1552$1 = 0; + $1553 = invoke_iii(364, $1552$0 | 0, $1552$1 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $1554 = $1553 + 20 | 0; + $1555 = $1554; + $1556 = HEAP32[$1555 >> 2] | 0; + $1557 = $1556; + $_r0_sroa_0 = $1557; + $_r0_sroa_0 = 0; + $_r0_sroa_0_0_load602 = $_r0_sroa_0; + $1558 = HEAP32[(98772 | 0) >> 2] | 0; + $1559 = ($1558 | 0) == 0; + if ($1559) { + label = 367; + break; + } else { + label = 368; + break; + } + case 367: + invoke_v(702); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 368; + break; + case 368: + HEAP32[140048 >> 2] = $_r0_sroa_0_0_load602; + $1561 = HEAP32[$1541 >> 2] | 0; + _memcpy($1561 | 0, $1539 | 0, 40); + label = 239; + break; + case 369: + $1563 = HEAP32[$1541 >> 2] | 0; + _memcpy($1563 | 0, $1539 | 0, 40); + $1564 = HEAP32[(107740 | 0) >> 2] | 0; + $1565 = ($1564 | 0) == 0; + if ($1565) { + label = 370; + break; + } else { + label = 371; + break; + } + case 370: + invoke_v(374); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 371; + break; + case 371: + $1568 = $1538 + 20 | 0; + $1569 = $1568; + $1570 = HEAP32[$1569 >> 2] | 0; + $1571 = ($1570 | 0) == 0; + if ($1571) { + label = 385; + break; + } else { + label = 372; + break; + } + case 372: + $1573 = HEAP32[137616 >> 2] | 0; + $1574 = $1570; + $1575 = HEAP32[$1574 >> 2] | 0; + $1576 = $1575; + $1577 = $1573 + 8 | 0; + $1578 = $1577; + $1579 = HEAP32[$1578 >> 2] | 0; + $1580 = ($1575 | 0) == 82712; + if ($1580) { + label = 373; + break; + } else { + $tib1_0_ph_i185 = $1576; + label = 374; + break; + } + case 373: + $1582 = $1570 + 8 | 0; + $1583 = $1582; + $1584 = HEAP32[$1583 >> 2] | 0; + $1585 = $1584 + 8 | 0; + $1586 = $1585; + $1587 = HEAP32[$1586 >> 2] | 0; + $1588 = $1587; + $tib1_0_ph_i185 = $1588; + label = 374; + break; + case 374: + $1589 = $tib1_0_ph_i185 + 56 | 0; + $1590 = HEAP32[$1589 >> 2] | 0; + $1591 = ($1590 | 0) == 0; + if ($1591) { + var $dimension_tib1_0_lcssa_i189 = 0; + var $tib1_0_lcssa_i188 = $tib1_0_ph_i185; + label = 376; + break; + } else { + var $dimension_tib1_029_i191 = 0; + var $1597 = $1590; + label = 377; + break; + } + case 375: + $1592 = $1600; + var $dimension_tib1_0_lcssa_i189 = $1601; + var $tib1_0_lcssa_i188 = $1592; + label = 376; + break; + case 376: + $1593 = $1579 + 56 | 0; + $1594 = $1593; + $1595 = HEAP32[$1594 >> 2] | 0; + $1596 = ($1595 | 0) == 0; + if ($1596) { + var $dimension_tib2_0_lcssa_i196 = 0; + var $tib2_0_lcssa_in_i195 = $1579; + label = 379; + break; + } else { + var $dimension_tib2_024_i193 = 0; + var $1606 = $1595; + label = 378; + break; + } + case 377: + $1598 = $1597 + 8 | 0; + $1599 = $1598; + $1600 = HEAP32[$1599 >> 2] | 0; + $1601 = $dimension_tib1_029_i191 + 1 | 0; + $1602 = $1600 + 56 | 0; + $1603 = $1602; + $1604 = HEAP32[$1603 >> 2] | 0; + $1605 = ($1604 | 0) == 0; + if ($1605) { + label = 375; + break; + } else { + var $dimension_tib1_029_i191 = $1601; + var $1597 = $1604; + label = 377; + break; + } + case 378: + $1607 = $1606 + 8 | 0; + $1608 = $1607; + $1609 = HEAP32[$1608 >> 2] | 0; + $1610 = $dimension_tib2_024_i193 + 1 | 0; + $1611 = $1609 + 56 | 0; + $1612 = $1611; + $1613 = HEAP32[$1612 >> 2] | 0; + $1614 = ($1613 | 0) == 0; + if ($1614) { + var $dimension_tib2_0_lcssa_i196 = $1610; + var $tib2_0_lcssa_in_i195 = $1609; + label = 379; + break; + } else { + var $dimension_tib2_024_i193 = $1610; + var $1606 = $1613; + label = 378; + break; + } + case 379: + $tib2_0_lcssa_i197 = $tib2_0_lcssa_in_i195; + $1615 = ($dimension_tib1_0_lcssa_i189 | 0) < ($dimension_tib2_0_lcssa_i196 | 0); + $1616 = ($tib1_0_lcssa_i188 | 0) == 0; + $or_cond_i198 = $1615 | $1616; + if ($or_cond_i198) { + label = 385; + break; + } else { + $tib1_121_i200 = $tib1_0_lcssa_i188; + label = 380; + break; + } + case 380: + $1617 = ($tib1_121_i200 | 0) == ($tib2_0_lcssa_i197 | 0); + if ($1617) { + label = 54; + break; + } else { + label = 381; + break; + } + case 381: + $1618 = $tib1_121_i200 + 108 | 0; + $1619 = HEAP32[$1618 >> 2] | 0; + $1620 = $tib1_121_i200 + 112 | 0; + $i_0_i203 = 0; + label = 382; + break; + case 382: + $1622 = ($i_0_i203 | 0) < ($1619 | 0); + if ($1622) { + label = 383; + break; + } else { + label = 384; + break; + } + case 383: + $1624 = HEAP32[$1620 >> 2] | 0; + $1625 = $1624 + ($i_0_i203 << 2) | 0; + $1626 = HEAP32[$1625 >> 2] | 0; + $1627 = ($1626 | 0) == ($tib2_0_lcssa_i197 | 0); + $1628 = $i_0_i203 + 1 | 0; + if ($1627) { + label = 54; + break; + } else { + $i_0_i203 = $1628; + label = 382; + break; + } + case 384: + $1630 = $tib1_121_i200 + 40 | 0; + $1631 = HEAP32[$1630 >> 2] | 0; + $1632 = ($1631 | 0) == 0; + if ($1632) { + label = 385; + break; + } else { + $tib1_121_i200 = $1631; + label = 380; + break; + } + case 385: + $1633 = HEAP32[$1541 >> 2] | 0; + $1634 = $1633; + invoke_vii(48, $1634 | 0, 0 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case 386: + $1635 = HEAP32[(105500 | 0) >> 2] | 0; + $1636 = ($1635 | 0) == 0; + if ($1636) { + label = 387; + break; + } else { + label = 388; + break; + } + case 387: + invoke_v(30); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 388; + break; + case 388: + $1638 = invoke_i(70) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $1639$0 = $1638; + $1639$1 = 0; + $1640 = invoke_iii(364, $1639$0 | 0, $1639$1 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $1641 = $local_env_w4567aaac23b1c50; + $1642 = $1640 + 16 | 0; + $1643 = $1642; + $1644 = HEAP32[$1643 >> 2] | 0; + _memcpy($1641 | 0, $1644 | 0, 40); + $1645 = HEAP32[$1643 >> 2] | 0; + $1646 = $1645; + $1647 = _saveSetjmp($1646 | 0, label, setjmpTable) | 0; + label = 425; + break; + case 425: + $1648 = ($1647 | 0) == 0; + if ($1648) { + label = 389; + break; + } else { + label = 396; + break; + } + case 389: + $1650 = HEAP32[(105500 | 0) >> 2] | 0; + $1651 = ($1650 | 0) == 0; + if ($1651) { + label = 390; + break; + } else { + label = 391; + break; + } + case 390: + invoke_v(30); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 391; + break; + case 391: + $1653 = invoke_i(70) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $1654$0 = $1653; + $1654$1 = 0; + $1655 = invoke_iii(364, $1654$0 | 0, $1654$1 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $1656 = $1655 + 20 | 0; + $1657 = $1656; + $1658 = HEAP32[$1657 >> 2] | 0; + $1659 = $1658; + $_r0_sroa_0 = $1659; + $_r2_sroa_0 = 0; + $_r2_sroa_0_0_load = $_r2_sroa_0; + $1660 = HEAP32[(98772 | 0) >> 2] | 0; + $1661 = ($1660 | 0) == 0; + if ($1661) { + label = 392; + break; + } else { + label = 393; + break; + } + case 392: + invoke_v(702); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 393; + break; + case 393: + HEAP32[140048 >> 2] = $_r2_sroa_0_0_load; + $1663 = HEAP32[(105500 | 0) >> 2] | 0; + $1664 = ($1663 | 0) == 0; + if ($1664) { + label = 394; + break; + } else { + label = 395; + break; + } + case 394: + invoke_v(30); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 395; + break; + case 395: + $1666 = invoke_i(70) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $1667$0 = $1666; + $1667$1 = 0; + $1668 = invoke_iii(364, $1667$0 | 0, $1667$1 | 0) | 0; + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + $_r0_sroa_0_0_load = $_r0_sroa_0; + $1669 = $_r0_sroa_0_0_load; + $1670 = $1668 + 16 | 0; + $1671 = $1668 + 20 | 0; + $1672 = $1671; + HEAP32[$1672 >> 2] = $1669; + $1673 = $1670; + $1674 = HEAP32[$1673 >> 2] | 0; + $1675 = $1674; + invoke_vii(48, $1675 | 0, 0 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case 396: + $1677 = HEAP32[$1643 >> 2] | 0; + _memcpy($1677 | 0, $1641 | 0, 40); + $1678 = HEAP32[(107740 | 0) >> 2] | 0; + $1679 = ($1678 | 0) == 0; + if ($1679) { + label = 397; + break; + } else { + label = 398; + break; + } + case 397: + invoke_v(374); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + label = 398; + break; + case 398: + $1682 = $1640 + 20 | 0; + $1683 = $1682; + $1684 = HEAP32[$1683 >> 2] | 0; + $1685 = ($1684 | 0) == 0; + if ($1685) { + label = 412; + break; + } else { + label = 399; + break; + } + case 399: + $1687 = HEAP32[137616 >> 2] | 0; + $1688 = $1684; + $1689 = HEAP32[$1688 >> 2] | 0; + $1690 = $1689; + $1691 = $1687 + 8 | 0; + $1692 = $1691; + $1693 = HEAP32[$1692 >> 2] | 0; + $1694 = ($1689 | 0) == 82712; + if ($1694) { + label = 400; + break; + } else { + $tib1_0_ph_i = $1690; + label = 401; + break; + } + case 400: + $1696 = $1684 + 8 | 0; + $1697 = $1696; + $1698 = HEAP32[$1697 >> 2] | 0; + $1699 = $1698 + 8 | 0; + $1700 = $1699; + $1701 = HEAP32[$1700 >> 2] | 0; + $1702 = $1701; + $tib1_0_ph_i = $1702; + label = 401; + break; + case 401: + $1703 = $tib1_0_ph_i + 56 | 0; + $1704 = HEAP32[$1703 >> 2] | 0; + $1705 = ($1704 | 0) == 0; + if ($1705) { + var $dimension_tib1_0_lcssa_i = 0; + var $tib1_0_lcssa_i = $tib1_0_ph_i; + label = 403; + break; + } else { + var $dimension_tib1_029_i = 0; + var $1711 = $1704; + label = 404; + break; + } + case 402: + $1706 = $1714; + var $dimension_tib1_0_lcssa_i = $1715; + var $tib1_0_lcssa_i = $1706; + label = 403; + break; + case 403: + $1707 = $1693 + 56 | 0; + $1708 = $1707; + $1709 = HEAP32[$1708 >> 2] | 0; + $1710 = ($1709 | 0) == 0; + if ($1710) { + var $dimension_tib2_0_lcssa_i = 0; + var $tib2_0_lcssa_in_i = $1693; + label = 406; + break; + } else { + var $dimension_tib2_024_i = 0; + var $1720 = $1709; + label = 405; + break; + } + case 404: + $1712 = $1711 + 8 | 0; + $1713 = $1712; + $1714 = HEAP32[$1713 >> 2] | 0; + $1715 = $dimension_tib1_029_i + 1 | 0; + $1716 = $1714 + 56 | 0; + $1717 = $1716; + $1718 = HEAP32[$1717 >> 2] | 0; + $1719 = ($1718 | 0) == 0; + if ($1719) { + label = 402; + break; + } else { + var $dimension_tib1_029_i = $1715; + var $1711 = $1718; + label = 404; + break; + } + case 405: + $1721 = $1720 + 8 | 0; + $1722 = $1721; + $1723 = HEAP32[$1722 >> 2] | 0; + $1724 = $dimension_tib2_024_i + 1 | 0; + $1725 = $1723 + 56 | 0; + $1726 = $1725; + $1727 = HEAP32[$1726 >> 2] | 0; + $1728 = ($1727 | 0) == 0; + if ($1728) { + var $dimension_tib2_0_lcssa_i = $1724; + var $tib2_0_lcssa_in_i = $1723; + label = 406; + break; + } else { + var $dimension_tib2_024_i = $1724; + var $1720 = $1727; + label = 405; + break; + } + case 406: + $tib2_0_lcssa_i = $tib2_0_lcssa_in_i; + $1729 = ($dimension_tib1_0_lcssa_i | 0) < ($dimension_tib2_0_lcssa_i | 0); + $1730 = ($tib1_0_lcssa_i | 0) == 0; + $or_cond_i = $1729 | $1730; + if ($or_cond_i) { + label = 412; + break; + } else { + $tib1_121_i = $tib1_0_lcssa_i; + label = 407; + break; + } + case 407: + $1731 = ($tib1_121_i | 0) == ($tib2_0_lcssa_i | 0); + if ($1731) { + label = 54; + break; + } else { + label = 408; + break; + } + case 408: + $1732 = $tib1_121_i + 108 | 0; + $1733 = HEAP32[$1732 >> 2] | 0; + $1734 = $tib1_121_i + 112 | 0; + $i_0_i = 0; + label = 409; + break; + case 409: + $1736 = ($i_0_i | 0) < ($1733 | 0); + if ($1736) { + label = 410; + break; + } else { + label = 411; + break; + } + case 410: + $1738 = HEAP32[$1734 >> 2] | 0; + $1739 = $1738 + ($i_0_i << 2) | 0; + $1740 = HEAP32[$1739 >> 2] | 0; + $1741 = ($1740 | 0) == ($tib2_0_lcssa_i | 0); + $1742 = $i_0_i + 1 | 0; + if ($1741) { + label = 54; + break; + } else { + $i_0_i = $1742; + label = 409; + break; + } + case 411: + $1744 = $tib1_121_i + 40 | 0; + $1745 = HEAP32[$1744 >> 2] | 0; + $1746 = ($1745 | 0) == 0; + if ($1746) { + label = 412; + break; + } else { + $tib1_121_i = $1745; + label = 407; + break; + } + case 412: + $1747 = HEAP32[$1643 >> 2] | 0; + $1748 = $1747; + invoke_vii(48, $1748 | 0, 0 | 0); + if ((__THREW__ | 0) != 0 & (threwValue | 0) != 0) { + setjmpLabel = _testSetjmp(HEAP32[__THREW__ >> 2] | 0, setjmpTable) | 0; + if ((setjmpLabel | 0) > 0) { + label = -1111; + break; + } else return 0 | 0; + } + __THREW__ = threwValue = 0; + return 0 | 0; + case -1111: + if ((setjmpLabel | 0) == 7) { + $25 = threwValue; + label = 413; + } else if ((setjmpLabel | 0) == 35) { + $159 = threwValue; + label = 414; + } else if ((setjmpLabel | 0) == 62) { + $290 = threwValue; + label = 415; + } else if ((setjmpLabel | 0) == 91) { + $401 = threwValue; + label = 416; + } else if ((setjmpLabel | 0) == 97) { + $433 = threwValue; + label = 417; + } else if ((setjmpLabel | 0) == 144) { + $629 = threwValue; + label = 418; + } else if ((setjmpLabel | 0) == 181) { + $789 = threwValue; + label = 419; + } else if ((setjmpLabel | 0) == 218) { + $954 = threwValue; + label = 420; + } else if ((setjmpLabel | 0) == 240) { + $1042 = threwValue; + label = 421; + } else if ((setjmpLabel | 0) == 251) { + $1073 = threwValue; + label = 422; + } else if ((setjmpLabel | 0) == 324) { + $1378 = threwValue; + label = 423; + } else if ((setjmpLabel | 0) == 363) { + $1545 = threwValue; + label = 424; + } else if ((setjmpLabel | 0) == 388) { + $1647 = threwValue; + label = 425; + } + __THREW__ = threwValue = 0; + break; + } } function looop2() { - var i = 0, helper = 0; - while (1) { - do_it(); - helper = (i + 1)|0; - if (condition(helper)) { - break; - } else { - i = helper; - } + var i = 0, helper = 0; + while (1) { + do_it(); + helper = (i + 1)|0; + if (condition(helper)) { + break; + } else { + i = helper; } + } } function looop3() { - var i = 0, helper = 0; - while (1) { - do_it(); - helper = (i + 1)|0; - if (condition(helper)) { - i = helper; - } else { - break; - } + var i = 0, helper = 0; + while (1) { + do_it(); + helper = (i + 1)|0; + if (condition(helper)) { + i = helper; + } else { + break; } + } } function looop4() { - var i = 0, helper = 0; - while (1) { - do_it(); - helper = (i + 1)|0; - f(i, helper); // i is used, cannot optimize! - if (condition()) { - i = helper; - } else { - break; - } + var i = 0, helper = 0; + while (1) { + do_it(); + helper = (i + 1)|0; + f(i, helper); // i is used, cannot optimize! + if (condition()) { + i = helper; + } else { + break; } + } } function looop4b() { - var i = 0, helper = 0; - while (1) { - do_it(); - helper = (i + 1)|0; - g(helper); - if (condition(i)) { // i is used, cannot optimize! - i = helper; - } else { - break; - } + var i = 0, helper = 0; + while (1) { + do_it(); + helper = (i + 1)|0; + g(helper); + if (condition(i)) { // i is used, cannot optimize! + i = helper; + } else { + break; } + } } function looop5() { - var i = 0, helper = 0; - while (1) { - do_it(); - helper = (i + 1)|0; - if (condition(helper)) { - i = helper; - } else { - break; - } + var i = 0, helper = 0; + while (1) { + do_it(); + helper = (i + 1)|0; + if (condition(helper)) { + i = helper; + } else { + break; } - moar(i); // i is still needed, cannot optimize! + } + moar(i); // i is still needed, cannot optimize! } function looop6() { - var i = 0, helper = 0; - while (1) { - do_it(); - helper = (i + 1)|0; - if (condition(helper)) { - i = helper; - } else { - break; - } + var i = 0, helper = 0; + while (1) { + do_it(); + helper = (i + 1)|0; + if (condition(helper)) { + i = helper; + } else { + break; } - moar(helper); // this is cool + } + moar(helper); // this is cool } function looop7() { - var $old_0_i107_i = 0, $current_0_i108_i = 0, $696 = 0; - $old_0_i107_i = $draw_left_i; - while (1) { - $current_0_i108_i = HEAP32[$old_0_i107_i >> 2] | 0; - if (($current_0_i108_i | 0) == 0) { - break; - } - $696 = $current_0_i108_i + 4 | 0; - if (($current_0_i108_i | 0) == ($P_3207_i | 0)) { - break; - } else { - $old_0_i107_i = $696; - } + var $old_0_i107_i = 0, $current_0_i108_i = 0, $696 = 0; + $old_0_i107_i = $draw_left_i; + while (1) { + $current_0_i108_i = HEAP32[$old_0_i107_i >> 2] | 0; + if (($current_0_i108_i | 0) == 0) { + break; } - HEAP32[$old_0_i107_i >> 2] = HEAP32[$696 >> 2] | 0; - // empty loop - while (1) { + $696 = $current_0_i108_i + 4 | 0; + if (($current_0_i108_i | 0) == ($P_3207_i | 0)) { + break; + } else { + $old_0_i107_i = $696; } + } + HEAP32[$old_0_i107_i >> 2] = HEAP32[$696 >> 2] | 0; + // empty loop + while (1) { + } } function looop8() { - var i = 0, j = 0, a = 0; - while (1) { - do_it(i, j); - a = (i + j)|0; - if (condition(helper)) { - break; - } else { - i = a; // helper used twice! - j = a; - } + var i = 0, j = 0, a = 0; + while (1) { + do_it(i, j); + a = (i + j)|0; + if (condition(helper)) { + break; + } else { + i = a; // helper used twice! + j = a; } + } } function multiloop($n_0, $35) { - $n_0 = $n_0 | 0; - $35 = $35 | 0; - var $p_0 = 0, $39 = 0, $41 = 0, $46 = 0; - $n_0 = $35; - $p_0 = (HEAP32[$15 >> 2] | 0) + ($35 << 1) | 0; - while (1) { - $39 = $p_0 - 2 | 0; - $41 = HEAPU16[$39 >> 1] | 0; - if ($41 >>> 0 < $2 >>> 0) { - $_off0 = 0; - } else { - $_off0 = $41 - $2 & 65535; - } - HEAP16[$39 >> 1] = $_off0; - $46 = $n_0 - 1 | 0; - if (($46 | 0) == 0) { - break; - } else { - $n_0 = $46; - $p_0 = $39; - } + $n_0 = $n_0 | 0; + $35 = $35 | 0; + var $p_0 = 0, $39 = 0, $41 = 0, $46 = 0; + $n_0 = $35; + $p_0 = (HEAP32[$15 >> 2] | 0) + ($35 << 1) | 0; + while (1) { + $39 = $p_0 - 2 | 0; + $41 = HEAPU16[$39 >> 1] | 0; + if ($41 >>> 0 < $2 >>> 0) { + $_off0 = 0; + } else { + $_off0 = $41 - $2 & 65535; + } + HEAP16[$39 >> 1] = $_off0; + $46 = $n_0 - 1 | 0; + if (($46 | 0) == 0) { + break; + } else { + $n_0 = $46; + $p_0 = $39; } + } } function multiloop2($n_0, $35) { - $n_0 = $n_0 | 0; - $35 = $35 | 0; - var $p_0 = 0, $39 = 0, $41 = 0, $46 = 0; - $n_0 = $35; - $p_0 = (HEAP32[$15 >> 2] | 0) + ($35 << 1) | 0; - while (1) { - $39 = $p_0 - 2 | 0; - $41 = HEAPU16[$39 >> 1] | 0; - if ($41 >>> 0 < $2 >>> 0) { - $_off0 = 0; - } else { - $_off0 = $41 - $2 & 65535; - } - HEAP16[$39 >> 1] = $p_0; // cannot optimize one, so none - $46 = $n_0 - 1 | 0; - if (($46 | 0) == 0) { - break; - } else { - $n_0 = $46; - $p_0 = $39; - } + $n_0 = $n_0 | 0; + $35 = $35 | 0; + var $p_0 = 0, $39 = 0, $41 = 0, $46 = 0; + $n_0 = $35; + $p_0 = (HEAP32[$15 >> 2] | 0) + ($35 << 1) | 0; + while (1) { + $39 = $p_0 - 2 | 0; + $41 = HEAPU16[$39 >> 1] | 0; + if ($41 >>> 0 < $2 >>> 0) { + $_off0 = 0; + } else { + $_off0 = $41 - $2 & 65535; + } + HEAP16[$39 >> 1] = $p_0; // cannot optimize one, so none + $46 = $n_0 - 1 | 0; + if (($46 | 0) == 0) { + break; + } else { + $n_0 = $46; + $p_0 = $39; } + } } function tempDouble2($46, $14, $28, $42, $20, $32, $45) { - $46 = $46 | 0; - $14 = $14 | 0; - $28 = $28 | 0; - $42 = $42 | 0; - $20 = $20 | 0; - $32 = $32 | 0; - $45 = $45 | 0; - var $46 = 0, $_sroa_06_0_insert_insert$1 = 0; - $46 = (HEAPF32[tempDoublePtr >> 2] = ($14 < $28 ? $14 : $28) - $42, HEAP32[tempDoublePtr >> 2] | 0); - $_sroa_06_0_insert_insert$1 = (HEAPF32[tempDoublePtr >> 2] = ($20 < $32 ? $20 : $32) - $42, HEAP32[tempDoublePtr >> 2] | 0) | 0; - HEAP32[$45 >> 2] = 0 | $46; - HEAP32[$45 + 4 >> 2] = $_sroa_06_0_insert_insert$1; - HEAP32[$45 + 8 >> 2] = $_sroa_06_0_insert_insert$1; + $46 = $46 | 0; + $14 = $14 | 0; + $28 = $28 | 0; + $42 = $42 | 0; + $20 = $20 | 0; + $32 = $32 | 0; + $45 = $45 | 0; + var $46 = 0, $_sroa_06_0_insert_insert$1 = 0; + $46 = (HEAPF32[tempDoublePtr >> 2] = ($14 < $28 ? $14 : $28) - $42, HEAP32[tempDoublePtr >> 2] | 0); + $_sroa_06_0_insert_insert$1 = (HEAPF32[tempDoublePtr >> 2] = ($20 < $32 ? $20 : $32) - $42, HEAP32[tempDoublePtr >> 2] | 0) | 0; + HEAP32[$45 >> 2] = 0 | $46; + HEAP32[$45 + 4 >> 2] = $_sroa_06_0_insert_insert$1; + HEAP32[$45 + 8 >> 2] = $_sroa_06_0_insert_insert$1; } // EMSCRIPTEN_GENERATED_FUNCTIONS: ["asm", "__Z11printResultPiS_j", "_segment_holding", "__ZN5identC2EiPKcPci", "_vec2Length", "exc", "label", "confuusion", "tempDouble", "_org_apache_harmony_luni_util_NumberConverter_freeFormat__", "__ZN23b2EdgeAndPolygonContact8EvaluateEP10b2ManifoldRK11b2TransformS4_", "_java_nio_charset_Charset_forNameInternal___java_lang_String", "looop2", "looop3", "looop4", "looop5", "looop6", "looop7", "looop8", "multiloop", "multiloop2", "tempDouble2"] diff --git a/tools/eliminator/eliminator-test-output.js b/tools/eliminator/eliminator-test-output.js index 69539e91c7eb7..801978edb7fb5 100644 --- a/tools/eliminator/eliminator-test-output.js +++ b/tools/eliminator/eliminator-test-output.js @@ -1,6125 +1,6125 @@ function a($directory) { - chak($directory + _strlen($directory) | 0); - var $210 = HEAP32[100]; - HEAP32[1e3] = HEAP32[5]; - HEAP32[90] = $210; - chak(); - var $210a = HEAP32[100]; - something(); - HEAP32[90] = $210a; - chak(); - HEAP32[1e3] = HEAP32[5]; - HEAP32[90] = $hack; - chak(); - var $b = HEAP32[11] + 7 | 0; - HEAP32[1e3] = HEAP32[5]; - HEAP32[90] = $b; - chak(); - var $bb2 = HEAP32[11]; - HEAP32[111] = 321; - HEAP32[1e3] = HEAP32[5]; - HEAP32[90] = $bb2 + 7 | 0; - chak(); - HEAP32[1e3] = HEAP32[100]; - chak(); - HEAP32[1e3] = func(); - chak(); - tor(func()); - chak(); - tor(HEAP[9]); - barrier(); - var $$210, $$210a, $$b, $$bb2; - $$210 = HEAP32[100]; - HEAP32[1e3] = HEAP32[5]; - HEAP32[90] = $$210; - chak(); - $$210a = HEAP32[100]; - something(); - HEAP32[90] = $$210a; - chak(); - HEAP32[1e3] = HEAP32[5]; - HEAP32[90] = $$hack; - chak(); - $$b = HEAP32[11] + 7 | 0; - HEAP32[1e3] = HEAP32[5]; - HEAP32[90] = $$b; - chak(); - $$bb2 = HEAP32[11]; - HEAP32[111] = 321; - HEAP32[1e3] = HEAP32[5]; - HEAP32[90] = $$bb2 + 7 | 0; - chak(); - HEAP32[1e3] = HEAP32[100]; - chak(); - HEAP32[1e3] = func(); - chak(); - tor(func()); - chak(); - tor(HEAP[9]); - barrier(); - var $65, $image, $51$s2; - HEAP32[$65 >> 2] = _int_ceildivpow2(HEAP32[$65 >> 2] - _int_ceildiv(HEAP32[$image >> 2], HEAP32[$51$s2]) | 0, HEAP32[$51$s2 + 10]); - barr(); - var ONCE = sheep(); - while (ONCE) { - work(); - } - var ONCEb = 75; - while (ONCEb) { - work(); - } - var $26 = __ZL3minIiET_S0_S0_12(4096, 4096 - $16 | 0); - print(FUNCTION_TABLE[$22]($18, $16 + ($this + 27) | 0, $26)); - chak(); - do { - print(10); - } while (0); - var zzz1 = 10; - do { - print(zzz1); - } while (1); + chak($directory + _strlen($directory) | 0); + var $210 = HEAP32[100]; + HEAP32[1e3] = HEAP32[5]; + HEAP32[90] = $210; + chak(); + var $210a = HEAP32[100]; + something(); + HEAP32[90] = $210a; + chak(); + HEAP32[1e3] = HEAP32[5]; + HEAP32[90] = $hack; + chak(); + var $b = HEAP32[11] + 7 | 0; + HEAP32[1e3] = HEAP32[5]; + HEAP32[90] = $b; + chak(); + var $bb2 = HEAP32[11]; + HEAP32[111] = 321; + HEAP32[1e3] = HEAP32[5]; + HEAP32[90] = $bb2 + 7 | 0; + chak(); + HEAP32[1e3] = HEAP32[100]; + chak(); + HEAP32[1e3] = func(); + chak(); + tor(func()); + chak(); + tor(HEAP[9]); + barrier(); + var $$210, $$210a, $$b, $$bb2; + $$210 = HEAP32[100]; + HEAP32[1e3] = HEAP32[5]; + HEAP32[90] = $$210; + chak(); + $$210a = HEAP32[100]; + something(); + HEAP32[90] = $$210a; + chak(); + HEAP32[1e3] = HEAP32[5]; + HEAP32[90] = $$hack; + chak(); + $$b = HEAP32[11] + 7 | 0; + HEAP32[1e3] = HEAP32[5]; + HEAP32[90] = $$b; + chak(); + $$bb2 = HEAP32[11]; + HEAP32[111] = 321; + HEAP32[1e3] = HEAP32[5]; + HEAP32[90] = $$bb2 + 7 | 0; + chak(); + HEAP32[1e3] = HEAP32[100]; + chak(); + HEAP32[1e3] = func(); + chak(); + tor(func()); + chak(); + tor(HEAP[9]); + barrier(); + var $65, $image, $51$s2; + HEAP32[$65 >> 2] = _int_ceildivpow2(HEAP32[$65 >> 2] - _int_ceildiv(HEAP32[$image >> 2], HEAP32[$51$s2]) | 0, HEAP32[$51$s2 + 10]); + barr(); + var ONCE = sheep(); + while (ONCE) { + work(); + } + var ONCEb = 75; + while (ONCEb) { + work(); + } + var $26 = __ZL3minIiET_S0_S0_12(4096, 4096 - $16 | 0); + print(FUNCTION_TABLE[$22]($18, $16 + ($this + 27) | 0, $26)); + chak(); + do { + print(10); + } while (0); + var zzz1 = 10; + do { + print(zzz1); + } while (1); } function b() { - var $148 = _sqlite3Strlen30($147); - var $150 = HEAP32[$pExpr + 16 >> 2]; - if (($150 | 0) == 0) { - var $156 = 0; - } else { - var $156 = HEAP32[$150 >> 2]; - } - var $156; - HEAP32[$139 + ($136 << 4) + 4 >> 2] = _sqlite3FindFunction($145, $147, $148, $156, $135, 0); - farr(); - f3(f1() + f2()); - farr(); - return cheez(); + var $148 = _sqlite3Strlen30($147); + var $150 = HEAP32[$pExpr + 16 >> 2]; + if (($150 | 0) == 0) { + var $156 = 0; + } else { + var $156 = HEAP32[$150 >> 2]; + } + var $156; + HEAP32[$139 + ($136 << 4) + 4 >> 2] = _sqlite3FindFunction($145, $147, $148, $156, $135, 0); + farr(); + f3(f1() + f2()); + farr(); + return cheez(); } function c() { - var x = MEM[100], y = callMe(5); - zoom(glob); - hail(x * 2); - sunk(y); - barrier(); - var y2 = $callMe2; - var w2 = MEM[100] * 2; - zoom(glob); - hail(w2); - sunk(y2); - you(fools); - var two = three(); - fools(you); - var noneed2; - noneed2 += fools(you2); - return; + var x = MEM[100], y = callMe(5); + zoom(glob); + hail(x * 2); + sunk(y); + barrier(); + var y2 = $callMe2; + var w2 = MEM[100] * 2; + zoom(glob); + hail(w2); + sunk(y2); + you(fools); + var two = three(); + fools(you); + var noneed2; + noneed2 += fools(you2); + return; } function f() { - HEAP[123] = (GLOB[1] + 1) / 2; + HEAP[123] = (GLOB[1] + 1) / 2; } function g(a1, a2) { - var a = 1; - var c = a * 2 - 1; - a = c; - foo(c); - foo(2); - for (var i = 0; i < 5; i++) { - { - a: 1 - } + [ 2, 3 ]; - } - for (var iterator in SOME_GLOBAL) { - quux(iterator); - } - var $0 = HEAP[5]; - MAYBE_HEAP[myglobal] = 123; - if ($0 < 0) { - __label__ = 1; - } else { - __label__ = 2; - } - new asd; - sadijn2 = "qwe%sert"; - this.Module || (this.Module = {}); + var a = 1; + var c = a * 2 - 1; + a = c; + foo(c); + foo(2); + for (var i = 0; i < 5; i++) { { - "quoted": 1, - "doublequoted": 2, - unquoted: 3, - 4: 5 - }; + a: 1 + } + [ 2, 3 ]; + } + for (var iterator in SOME_GLOBAL) { + quux(iterator); + } + var $0 = HEAP[5]; + MAYBE_HEAP[myglobal] = 123; + if ($0 < 0) { + __label__ = 1; + } else { + __label__ = 2; + } + new asd; + sadijn2 = "qwe%sert"; + this.Module || (this.Module = {}); + { + "quoted": 1, + "doublequoted": 2, + unquoted: 3, + 4: 5 + }; } function h() { - var out; - bar(hello); - var hello = 5; - if (0) { - var sb1 = 21; - } - out = sb1; - if (0) { - var sb2 = 23; - } else { - out = sb2; - } - if (0) { - out = sb3; - } else { - var sb3 = 23; - } - for (var it = 0; it < 5; it++) { - x = y ? x + 1 : 7; - var x = -5; - } - if (1) { - otherGlob = glob; - breakMe(); - } - var oneUse2 = glob2; - while (1) { - otherGlob2 = oneUse2; - breakMe(); - } - return out; + var out; + bar(hello); + var hello = 5; + if (0) { + var sb1 = 21; + } + out = sb1; + if (0) { + var sb2 = 23; + } else { + out = sb2; + } + if (0) { + out = sb3; + } else { + var sb3 = 23; + } + for (var it = 0; it < 5; it++) { + x = y ? x + 1 : 7; + var x = -5; + } + if (1) { + otherGlob = glob; + breakMe(); + } + var oneUse2 = glob2; + while (1) { + otherGlob2 = oneUse2; + breakMe(); + } + return out; } function strtok_part(b, j, f) { - var a; - for (;;) { - h = a == 13 ? h : 0; - a = HEAP[d + h]; - if (a == g != 0) break; - var h = h + 1; - if (a != 0) a = 13; - } + var a; + for (;;) { + h = a == 13 ? h : 0; + a = HEAP[d + h]; + if (a == g != 0) break; + var h = h + 1; + if (a != 0) a = 13; + } } function py() { - HEAP[HEAP[HEAP[__PyThreadState_Current] + 12] + 1 + 12] = 99; + HEAP[HEAP[HEAP[__PyThreadState_Current] + 12] + 1 + 12] = 99; } var anon = (function(x) { - var $4 = HEAP[__PyThreadState_Current]; - var $5 = $4 + 12; - var $7 = HEAP[$5] + 1; - var $8 = $4 + 12; - HEAP[$8] = $7; + var $4 = HEAP[__PyThreadState_Current]; + var $5 = $4 + 12; + var $7 = HEAP[$5] + 1; + var $8 = $4 + 12; + HEAP[$8] = $7; }); function r($0) { - HEAP[$0 + 7] = 107; + HEAP[$0 + 7] = 107; } function t() { - if ($10 < $11) { - __label__ = 3; - } - if (!($12 < $13)) { - __label__ = 4; - } + if ($10 < $11) { + __label__ = 3; + } + if (!($12 < $13)) { + __label__ = 4; + } } function f2() { - var $_pre = HEAPU32[($vla + ($storemerge312 << 2) | 0) >> 2]; - var $storemerge312 = $storemerge312 + 1 | 0; - c($_pre); + var $_pre = HEAPU32[($vla + ($storemerge312 << 2) | 0) >> 2]; + var $storemerge312 = $storemerge312 + 1 | 0; + c($_pre); } function f3($s, $tree, $k) { - var $0 = HEAPU32[($s + 2908 + ($k << 2) | 0) >> 2]; - while (1) { - HEAP32[($s + 2908 + ($storemerge_in << 2) | 0) >> 2] = $9; - } - HEAP32[($s + 2908 + ($storemerge_in << 2) | 0) >> 2] = $0; + var $0 = HEAPU32[($s + 2908 + ($k << 2) | 0) >> 2]; + while (1) { + HEAP32[($s + 2908 + ($storemerge_in << 2) | 0) >> 2] = $9; + } + HEAP32[($s + 2908 + ($storemerge_in << 2) | 0) >> 2] = $0; } function llvm3_1() { - while (check()) { - if ($curri_01 % $zj_0 == 0) { - break; - } - run(($aj_0 + 1) / 2); + while (check()) { + if ($curri_01 % $zj_0 == 0) { + break; } + run(($aj_0 + 1) / 2); + } } function _inflate($strm, $flush) { - var __stackBase__ = STACKTOP; - STACKTOP += 4; - var __label__; - var $hbuf = __stackBase__; - $_$2 : do { - if (($strm | 0) == 0) { + var __stackBase__ = STACKTOP; + STACKTOP += 4; + var __label__; + var $hbuf = __stackBase__; + $_$2 : do { + if (($strm | 0) == 0) { + var $retval_0 = -2; + } else { + var $0 = HEAPU32[($strm + 28 | 0) >> 2]; + if (($0 | 0) == 0) { + var $retval_0 = -2; + break; + } + var $next_out = $strm + 12 | 0; + var $1 = HEAP32[$next_out >> 2]; + if (($1 | 0) == 0) { + var $retval_0 = -2; + break; + } + var $next_in = $strm | 0; + var $2 = HEAP32[$next_in >> 2]; + if (($2 | 0) == 0) { + if (!((HEAP32[($strm + 4 | 0) >> 2] | 0) == 0)) { + var $retval_0 = -2; + break; + } + } + var $4 = $0; + var $mode = $0 | 0; + var $5 = HEAP32[$mode >> 2]; + if (($5 | 0) == 11) { + HEAP32[$mode >> 2] = 12; + var $8 = HEAP32[$next_out >> 2]; + var $7 = HEAP32[$next_in >> 2]; + var $6 = 12; + } else { + var $8 = $1; + var $7 = $2; + var $6 = $5; + } + var $6; + var $7; + var $8; + var $avail_out = $strm + 16 | 0; + var $9 = HEAP32[$avail_out >> 2]; + var $avail_in15 = $strm + 4 | 0; + var $10 = HEAPU32[$avail_in15 >> 2]; + var $11 = $0 + 56 | 0; + var $13 = $0 + 60 | 0; + var $15 = $0 + 8 | 0; + var $16 = $0 + 24 | 0; + var $arrayidx = $hbuf | 0; + var $arrayidx40 = $hbuf + 1 | 0; + var $17 = $0 + 16 | 0; + var $18 = $0 + 32 | 0; + var $msg = $strm + 24 | 0; + var $19 = $0 + 36 | 0; + var $20 = $0 + 20 | 0; + var $adler = $strm + 48 | 0; + var $21 = $0 + 64 | 0; + var $22 = $0 + 12 | 0; + var $23 = ($flush - 5 | 0) >>> 0 < 2; + var $24 = $0 + 4 | 0; + var $cmp660 = ($flush | 0) == 6; + var $25 = $0 + 7108 | 0; + var $26 = $0 + 84 | 0; + var $27 = $0 + 76 | 0; + var $28 = $0 + 72 | 0; + var $29 = $0 + 7112 | 0; + var $30 = $0 + 68 | 0; + var $31 = $0 + 44 | 0; + var $32 = $0 + 7104 | 0; + var $33 = $0 + 48 | 0; + var $34 = $0 + 52 | 0; + var $35 = $0 + 40 | 0; + var $total_out = $strm + 20 | 0; + var $36 = $0 + 28 | 0; + var $arrayidx199 = $hbuf + 2 | 0; + var $arrayidx202 = $hbuf + 3 | 0; + var $37 = $0 + 96 | 0; + var $38 = $0 + 100 | 0; + var $39 = $0 + 92 | 0; + var $40 = $0 + 104 | 0; + var $lens = $0 + 112 | 0; + var $41 = $lens; + var $next861 = $0 + 108 | 0; + var $42 = $next861; + var $43 = $next861 | 0; + var $arraydecay860_c = $0 + 1328 | 0; + var $44 = $0 + 76 | 0; + var $arraydecay864 = $lens; + var $arraydecay867 = $0 + 752 | 0; + var $45 = $0 + 624 | 0; + var $46 = $0 + 80 | 0; + var $47 = $0 + 88 | 0; + var $48 = $0 + 80 | 0; + var $ret_0 = 0; + var $next_0 = $7; + var $put_0 = $8; + var $have_0 = $10; + var $left_0 = $9; + var $hold_0 = HEAP32[$11 >> 2]; + var $bits_0 = HEAP32[$13 >> 2]; + var $out_0 = $9; + var $49 = $6; + $_$12 : while (1) { + var $49; + var $out_0; + var $bits_0; + var $hold_0; + var $left_0; + var $have_0; + var $put_0; + var $next_0; + var $ret_0; + $_$14 : do { + if (($49 | 0) == 0) { + var $50 = HEAPU32[$15 >> 2]; + if (($50 | 0) == 0) { + HEAP32[$mode >> 2] = 12; + var $ret_0_be = $ret_0; + var $next_0_be = $next_0; + var $put_0_be = $put_0; + var $have_0_be = $have_0; + var $left_0_be = $left_0; + var $hold_0_be = $hold_0; + var $bits_0_be = $bits_0; + var $out_0_be = $out_0; + __label__ = 268; + break; + } + var $next_1 = $next_0; + var $have_1 = $have_0; + var $hold_1 = $hold_0; + var $bits_1 = $bits_0; + while (1) { + var $bits_1; + var $hold_1; + var $have_1; + var $next_1; + if (!($bits_1 >>> 0 < 16)) { + break; + } + if (($have_1 | 0) == 0) { + var $ret_8 = $ret_0; + var $next_58 = $next_1; + var $have_58 = 0; + var $hold_54 = $hold_1; + var $bits_54 = $bits_1; + var $out_4 = $out_0; + break $_$12; + } + var $add = ((HEAPU8[$next_1] & 255) << $bits_1) + $hold_1 | 0; + var $next_1 = $next_1 + 1 | 0; + var $have_1 = $have_1 - 1 | 0; + var $hold_1 = $add; + var $bits_1 = $bits_1 + 8 | 0; + } + if (($50 & 2 | 0) != 0 & ($hold_1 | 0) == 35615) { + HEAP32[$16 >> 2] = _crc32(0, 0, 0); + HEAP8[$arrayidx] = 31; + HEAP8[$arrayidx40] = -117; + HEAP32[$16 >> 2] = _crc32(HEAP32[$16 >> 2], $arrayidx, 2); + HEAP32[$mode >> 2] = 1; + var $ret_0_be = $ret_0; + var $next_0_be = $next_1; + var $put_0_be = $put_0; + var $have_0_be = $have_1; + var $left_0_be = $left_0; + var $hold_0_be = 0; + var $bits_0_be = 0; + var $out_0_be = $out_0; + __label__ = 268; + break; + } + HEAP32[$17 >> 2] = 0; + var $53 = HEAP32[$18 >> 2]; + if (($53 | 0) == 0) { + var $54 = $50; + } else { + HEAP32[($53 + 48 | 0) >> 2] = -1; + var $54 = HEAP32[$15 >> 2]; + } + var $54; + do { + if (!(($54 & 1 | 0) == 0)) { + if (!((((($hold_1 << 8 & 65280) + ($hold_1 >>> 8) | 0) >>> 0) % 31 | 0) == 0)) { + break; + } + if (($hold_1 & 15 | 0) == 8) { + var $shr74 = $hold_1 >>> 4; + var $sub = $bits_1 - 4 | 0; + var $add77 = ($shr74 & 15) + 8 | 0; + var $55 = HEAPU32[$19 >> 2]; + do { + if (!(($55 | 0) == 0)) { + if (!($add77 >>> 0 > $55 >>> 0)) { + break; + } + HEAP32[$msg >> 2] = STRING_TABLE.__str3100 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $ret_0; + var $next_0_be = $next_1; + var $put_0_be = $put_0; + var $have_0_be = $have_1; + var $left_0_be = $left_0; + var $hold_0_be = $shr74; + var $bits_0_be = $sub; + var $out_0_be = $out_0; + __label__ = 268; + break $_$14; + } + HEAP32[$19 >> 2] = $add77; + } while (0); + HEAP32[$20 >> 2] = 1 << $add77; + var $call91 = _adler32(0, 0, 0); + HEAP32[$16 >> 2] = $call91; + HEAP32[$adler >> 2] = $call91; + HEAP32[$mode >> 2] = $hold_1 >>> 12 & 2 ^ 11; + var $ret_0_be = $ret_0; + var $next_0_be = $next_1; + var $put_0_be = $put_0; + var $have_0_be = $have_1; + var $left_0_be = $left_0; + var $hold_0_be = 0; + var $bits_0_be = 0; + var $out_0_be = $out_0; + __label__ = 268; + break $_$14; + } + HEAP32[$msg >> 2] = STRING_TABLE.__str299 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $ret_0; + var $next_0_be = $next_1; + var $put_0_be = $put_0; + var $have_0_be = $have_1; + var $left_0_be = $left_0; + var $hold_0_be = $hold_1; + var $bits_0_be = $bits_1; + var $out_0_be = $out_0; + __label__ = 268; + break $_$14; + } + } while (0); + HEAP32[$msg >> 2] = STRING_TABLE.__str198 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $ret_0; + var $next_0_be = $next_1; + var $put_0_be = $put_0; + var $have_0_be = $have_1; + var $left_0_be = $left_0; + var $hold_0_be = $hold_1; + var $bits_0_be = $bits_1; + var $out_0_be = $out_0; + __label__ = 268; + break; + } else if (($49 | 0) == 1) { + var $next_2 = $next_0; + var $have_2 = $have_0; + var $hold_2 = $hold_0; + var $bits_2 = $bits_0; + while (1) { + var $bits_2; + var $hold_2; + var $have_2; + var $next_2; + if (!($bits_2 >>> 0 < 16)) { + break; + } + if (($have_2 | 0) == 0) { + var $ret_8 = $ret_0; + var $next_58 = $next_2; + var $have_58 = 0; + var $hold_54 = $hold_2; + var $bits_54 = $bits_2; + var $out_4 = $out_0; + break $_$12; + } + var $add113 = ((HEAPU8[$next_2] & 255) << $bits_2) + $hold_2 | 0; + var $next_2 = $next_2 + 1 | 0; + var $have_2 = $have_2 - 1 | 0; + var $hold_2 = $add113; + var $bits_2 = $bits_2 + 8 | 0; + } + HEAP32[$17 >> 2] = $hold_2; + if (!(($hold_2 & 255 | 0) == 8)) { + HEAP32[$msg >> 2] = STRING_TABLE.__str299 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $ret_0; + var $next_0_be = $next_2; + var $put_0_be = $put_0; + var $have_0_be = $have_2; + var $left_0_be = $left_0; + var $hold_0_be = $hold_2; + var $bits_0_be = $bits_2; + var $out_0_be = $out_0; + __label__ = 268; + break; + } + if (($hold_2 & 57344 | 0) == 0) { + var $59 = HEAPU32[$18 >> 2]; + if (($59 | 0) == 0) { + var $60 = $hold_2; + } else { + HEAP32[($59 | 0) >> 2] = $hold_2 >>> 8 & 1; + var $60 = HEAP32[$17 >> 2]; + } + var $60; + if (!(($60 & 512 | 0) == 0)) { + HEAP8[$arrayidx] = $hold_2 & 255; + HEAP8[$arrayidx40] = $hold_2 >>> 8 & 255; + HEAP32[$16 >> 2] = _crc32(HEAP32[$16 >> 2], $arrayidx, 2); + } + HEAP32[$mode >> 2] = 2; + var $next_3 = $next_2; + var $have_3 = $have_2; + var $hold_3 = 0; + var $bits_3 = 0; + __label__ = 44; + break; + } + HEAP32[$msg >> 2] = STRING_TABLE.__str4101 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $ret_0; + var $next_0_be = $next_2; + var $put_0_be = $put_0; + var $have_0_be = $have_2; + var $left_0_be = $left_0; + var $hold_0_be = $hold_2; + var $bits_0_be = $bits_2; + var $out_0_be = $out_0; + __label__ = 268; + break; + } else if (($49 | 0) == 2) { + var $next_3 = $next_0; + var $have_3 = $have_0; + var $hold_3 = $hold_0; + var $bits_3 = $bits_0; + __label__ = 44; + } else if (($49 | 0) == 3) { + var $next_4 = $next_0; + var $have_4 = $have_0; + var $hold_4 = $hold_0; + var $bits_4 = $bits_0; + __label__ = 52; + } else if (($49 | 0) == 4) { + var $next_5 = $next_0; + var $have_5 = $have_0; + var $hold_5 = $hold_0; + var $bits_5 = $bits_0; + __label__ = 60; + } else if (($49 | 0) == 5) { + var $next_8 = $next_0; + var $have_8 = $have_0; + var $hold_8 = $hold_0; + var $bits_8 = $bits_0; + __label__ = 71; + } else if (($49 | 0) == 6) { + var $next_11 = $next_0; + var $have_11 = $have_0; + var $hold_9 = $hold_0; + var $bits_9 = $bits_0; + var $89 = HEAP32[$17 >> 2]; + __label__ = 81; + break; + } else if (($49 | 0) == 7) { + var $next_13 = $next_0; + var $have_13 = $have_0; + var $hold_10 = $hold_0; + var $bits_10 = $bits_0; + __label__ = 94; + } else if (($49 | 0) == 8) { + var $next_15 = $next_0; + var $have_15 = $have_0; + var $hold_11 = $hold_0; + var $bits_11 = $bits_0; + __label__ = 107; + } else if (($49 | 0) == 9) { + var $next_18 = $next_0; + var $have_18 = $have_0; + var $hold_14 = $hold_0; + var $bits_14 = $bits_0; + while (1) { + var $bits_14; + var $hold_14; + var $have_18; + var $next_18; + if (!($bits_14 >>> 0 < 32)) { + break; + } + if (($have_18 | 0) == 0) { + var $ret_8 = $ret_0; + var $next_58 = $next_18; + var $have_58 = 0; + var $hold_54 = $hold_14; + var $bits_54 = $bits_14; + var $out_4 = $out_0; + break $_$12; + } + var $add564 = ((HEAPU8[$next_18] & 255) << $bits_14) + $hold_14 | 0; + var $next_18 = $next_18 + 1 | 0; + var $have_18 = $have_18 - 1 | 0; + var $hold_14 = $add564; + var $bits_14 = $bits_14 + 8 | 0; + } + var $add581 = _llvm_bswap_i32($hold_14); + HEAP32[$16 >> 2] = $add581; + HEAP32[$adler >> 2] = $add581; + HEAP32[$mode >> 2] = 10; + var $next_19 = $next_18; + var $have_19 = $have_18; + var $hold_15 = 0; + var $bits_15 = 0; + __label__ = 120; + break; + } else if (($49 | 0) == 10) { + var $next_19 = $next_0; + var $have_19 = $have_0; + var $hold_15 = $hold_0; + var $bits_15 = $bits_0; + __label__ = 120; + } else if (($49 | 0) == 11) { + var $next_20 = $next_0; + var $have_20 = $have_0; + var $hold_16 = $hold_0; + var $bits_16 = $bits_0; + __label__ = 123; + } else if (($49 | 0) == 12) { + var $next_21 = $next_0; + var $have_21 = $have_0; + var $hold_17 = $hold_0; + var $bits_17 = $bits_0; + __label__ = 124; + } else if (($49 | 0) == 13) { + var $and681 = $bits_0 & 7; + var $next_23 = $next_0; + var $have_23 = $have_0; + var $hold_19 = $hold_0 >>> ($and681 >>> 0); + var $bits_19 = $bits_0 - $and681 | 0; + while (1) { + var $bits_19; + var $hold_19; + var $have_23; + var $next_23; + if (!($bits_19 >>> 0 < 32)) { + break; + } + if (($have_23 | 0) == 0) { + var $ret_8 = $ret_0; + var $next_58 = $next_23; + var $have_58 = 0; + var $hold_54 = $hold_19; + var $bits_54 = $bits_19; + var $out_4 = $out_0; + break $_$12; + } + var $add701 = ((HEAPU8[$next_23] & 255) << $bits_19) + $hold_19 | 0; + var $next_23 = $next_23 + 1 | 0; + var $have_23 = $have_23 - 1 | 0; + var $hold_19 = $add701; + var $bits_19 = $bits_19 + 8 | 0; + } + var $and708 = $hold_19 & 65535; + if (!(($and708 | 0) == ($hold_19 >>> 16 ^ 65535 | 0))) { + HEAP32[$msg >> 2] = STRING_TABLE.__str7104 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $ret_0; + var $next_0_be = $next_23; + var $put_0_be = $put_0; + var $have_0_be = $have_23; + var $left_0_be = $left_0; + var $hold_0_be = $hold_19; + var $bits_0_be = $bits_19; + var $out_0_be = $out_0; + __label__ = 268; + break; + } + HEAP32[$21 >> 2] = $and708; + HEAP32[$mode >> 2] = 14; + if ($cmp660) { + var $ret_8 = $ret_0; + var $next_58 = $next_23; + var $have_58 = $have_23; + var $hold_54 = 0; + var $bits_54 = 0; + var $out_4 = $out_0; + break $_$12; + } + var $next_24 = $next_23; + var $have_24 = $have_23; + var $hold_20 = 0; + var $bits_20 = 0; + __label__ = 143; + break; + } else if (($49 | 0) == 14) { + var $next_24 = $next_0; + var $have_24 = $have_0; + var $hold_20 = $hold_0; + var $bits_20 = $bits_0; + __label__ = 143; + } else if (($49 | 0) == 15) { + var $next_25 = $next_0; + var $have_25 = $have_0; + var $hold_21 = $hold_0; + var $bits_21 = $bits_0; + __label__ = 144; + } else if (($49 | 0) == 16) { + var $next_26 = $next_0; + var $have_26 = $have_0; + var $hold_22 = $hold_0; + var $bits_22 = $bits_0; + while (1) { + var $bits_22; + var $hold_22; + var $have_26; + var $next_26; + if (!($bits_22 >>> 0 < 14)) { + break; + } + if (($have_26 | 0) == 0) { + var $ret_8 = $ret_0; + var $next_58 = $next_26; + var $have_58 = 0; + var $hold_54 = $hold_22; + var $bits_54 = $bits_22; + var $out_4 = $out_0; + break $_$12; + } + var $add767 = ((HEAPU8[$next_26] & 255) << $bits_22) + $hold_22 | 0; + var $next_26 = $next_26 + 1 | 0; + var $have_26 = $have_26 - 1 | 0; + var $hold_22 = $add767; + var $bits_22 = $bits_22 + 8 | 0; + } + var $add775 = ($hold_22 & 31) + 257 | 0; + HEAP32[$37 >> 2] = $add775; + var $add782 = ($hold_22 >>> 5 & 31) + 1 | 0; + HEAP32[$38 >> 2] = $add782; + HEAP32[$39 >> 2] = ($hold_22 >>> 10 & 15) + 4 | 0; + var $shr791 = $hold_22 >>> 14; + var $sub792 = $bits_22 - 14 | 0; + if ($add775 >>> 0 > 286 | $add782 >>> 0 > 30) { + HEAP32[$msg >> 2] = STRING_TABLE.__str8105 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $ret_0; + var $next_0_be = $next_26; + var $put_0_be = $put_0; + var $have_0_be = $have_26; + var $left_0_be = $left_0; + var $hold_0_be = $shr791; + var $bits_0_be = $sub792; + var $out_0_be = $out_0; + __label__ = 268; + break; + } + HEAP32[$40 >> 2] = 0; + HEAP32[$mode >> 2] = 17; + var $next_27 = $next_26; + var $have_27 = $have_26; + var $hold_23 = $shr791; + var $bits_23 = $sub792; + __label__ = 154; + break; + } else if (($49 | 0) == 17) { + var $next_27 = $next_0; + var $have_27 = $have_0; + var $hold_23 = $hold_0; + var $bits_23 = $bits_0; + __label__ = 154; + } else if (($49 | 0) == 18) { + var $ret_1_ph = $ret_0; + var $next_29_ph = $next_0; + var $have_29_ph = $have_0; + var $hold_25_ph = $hold_0; + var $bits_25_ph = $bits_0; + __label__ = 164; + } else if (($49 | 0) == 19) { + var $ret_2 = $ret_0; + var $next_37 = $next_0; + var $have_37 = $have_0; + var $hold_33 = $hold_0; + var $bits_33 = $bits_0; + __label__ = 205; + } else if (($49 | 0) == 20) { + var $ret_3 = $ret_0; + var $next_38 = $next_0; + var $have_38 = $have_0; + var $hold_34 = $hold_0; + var $bits_34 = $bits_0; + __label__ = 206; + } else if (($49 | 0) == 21) { + var $ret_4 = $ret_0; + var $next_42 = $next_0; + var $have_42 = $have_0; + var $hold_38 = $hold_0; + var $bits_38 = $bits_0; + var $156 = HEAP32[$28 >> 2]; + __label__ = 227; + break; + } else if (($49 | 0) == 22) { + var $ret_5_ph = $ret_0; + var $next_45_ph = $next_0; + var $have_45_ph = $have_0; + var $hold_41_ph = $hold_0; + var $bits_41_ph = $bits_0; + __label__ = 234; + } else if (($49 | 0) == 23) { + var $ret_6 = $ret_0; + var $next_48 = $next_0; + var $have_48 = $have_0; + var $hold_44 = $hold_0; + var $bits_44 = $bits_0; + var $167 = HEAP32[$28 >> 2]; + __label__ = 248; + break; + } else if (($49 | 0) == 24) { + var $ret_7 = $ret_0; + var $next_51 = $next_0; + var $have_51 = $have_0; + var $hold_47 = $hold_0; + var $bits_47 = $bits_0; + __label__ = 254; + } else if (($49 | 0) == 25) { + if (($left_0 | 0) == 0) { + var $ret_8 = $ret_0; + var $next_58 = $next_0; + var $have_58 = $have_0; + var $hold_54 = $hold_0; + var $bits_54 = $bits_0; + var $out_4 = $out_0; + break $_$12; + } + HEAP8[$put_0] = HEAP32[$21 >> 2] & 255; + HEAP32[$mode >> 2] = 20; + var $ret_0_be = $ret_0; + var $next_0_be = $next_0; + var $put_0_be = $put_0 + 1 | 0; + var $have_0_be = $have_0; + var $left_0_be = $left_0 - 1 | 0; + var $hold_0_be = $hold_0; + var $bits_0_be = $bits_0; + var $out_0_be = $out_0; + __label__ = 268; + break; + } else if (($49 | 0) == 26) { + do { + if (!((HEAP32[$15 >> 2] | 0) == 0)) { + var $next_52 = $next_0; + var $have_52 = $have_0; + var $hold_48 = $hold_0; + var $bits_48 = $bits_0; + while (1) { + var $bits_48; + var $hold_48; + var $have_52; + var $next_52; + if (!($bits_48 >>> 0 < 32)) { + break; + } + if (($have_52 | 0) == 0) { + var $ret_8 = $ret_0; + var $next_58 = $next_52; + var $have_58 = 0; + var $hold_54 = $hold_48; + var $bits_54 = $bits_48; + var $out_4 = $out_0; + break $_$12; + } + var $add1642 = ((HEAPU8[$next_52] & 255) << $bits_48) + $hold_48 | 0; + var $next_52 = $next_52 + 1 | 0; + var $have_52 = $have_52 - 1 | 0; + var $hold_48 = $add1642; + var $bits_48 = $bits_48 + 8 | 0; + } + var $sub1649 = $out_0 - $left_0 | 0; + HEAP32[$total_out >> 2] = HEAP32[$total_out >> 2] + $sub1649 | 0; + HEAP32[$36 >> 2] = HEAP32[$36 >> 2] + $sub1649 | 0; + if (!(($out_0 | 0) == ($left_0 | 0))) { + var $192 = HEAP32[$16 >> 2]; + var $add_ptr1659 = $put_0 + (-$sub1649 | 0) | 0; + if ((HEAP32[$17 >> 2] | 0) == 0) { + var $cond1667 = _adler32($192, $add_ptr1659, $sub1649); + } else { + var $cond1667 = _crc32($192, $add_ptr1659, $sub1649); + } + var $cond1667; + HEAP32[$16 >> 2] = $cond1667; + HEAP32[$adler >> 2] = $cond1667; + } + if ((HEAP32[$17 >> 2] | 0) == 0) { + var $cond1687 = _llvm_bswap_i32($hold_48); + } else { + var $cond1687 = $hold_48; + } + var $cond1687; + if (($cond1687 | 0) == (HEAP32[$16 >> 2] | 0)) { + var $next_53 = $next_52; + var $have_53 = $have_52; + var $hold_49 = 0; + var $bits_49 = 0; + var $out_1 = $left_0; + break; + } + HEAP32[$msg >> 2] = STRING_TABLE.__str17114 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $ret_0; + var $next_0_be = $next_52; + var $put_0_be = $put_0; + var $have_0_be = $have_52; + var $left_0_be = $left_0; + var $hold_0_be = $hold_48; + var $bits_0_be = $bits_48; + var $out_0_be = $left_0; + __label__ = 268; + break $_$14; + } + var $next_53 = $next_0; + var $have_53 = $have_0; + var $hold_49 = $hold_0; + var $bits_49 = $bits_0; + var $out_1 = $out_0; + } while (0); + var $out_1; + var $bits_49; + var $hold_49; + var $have_53; + var $next_53; + HEAP32[$mode >> 2] = 27; + var $next_54 = $next_53; + var $have_54 = $have_53; + var $hold_50 = $hold_49; + var $bits_50 = $bits_49; + var $out_2 = $out_1; + __label__ = 286; + break; + } else if (($49 | 0) == 27) { + var $next_54 = $next_0; + var $have_54 = $have_0; + var $hold_50 = $hold_0; + var $bits_50 = $bits_0; + var $out_2 = $out_0; + __label__ = 286; + } else if (($49 | 0) == 28) { + var $ret_8 = 1; + var $next_58 = $next_0; + var $have_58 = $have_0; + var $hold_54 = $hold_0; + var $bits_54 = $bits_0; + var $out_4 = $out_0; + break $_$12; + } else if (($49 | 0) == 29) { + var $ret_8 = -3; + var $next_58 = $next_0; + var $have_58 = $have_0; + var $hold_54 = $hold_0; + var $bits_54 = $bits_0; + var $out_4 = $out_0; + break $_$12; + } else if (($49 | 0) == 30) { + var $retval_0 = -4; + break $_$2; + } else { var $retval_0 = -2; - } else { - var $0 = HEAPU32[($strm + 28 | 0) >> 2]; - if (($0 | 0) == 0) { - var $retval_0 = -2; + break $_$2; + } + } while (0); + $_$106 : do { + if (__label__ == 44) { + while (1) { + var $bits_3; + var $hold_3; + var $have_3; + var $next_3; + if (!($bits_3 >>> 0 < 32)) { break; + } + if (($have_3 | 0) == 0) { + var $ret_8 = $ret_0; + var $next_58 = $next_3; + var $have_58 = 0; + var $hold_54 = $hold_3; + var $bits_54 = $bits_3; + var $out_4 = $out_0; + break $_$12; + } + var $add176 = ((HEAPU8[$next_3] & 255) << $bits_3) + $hold_3 | 0; + var $next_3 = $next_3 + 1 | 0; + var $have_3 = $have_3 - 1 | 0; + var $hold_3 = $add176; + var $bits_3 = $bits_3 + 8 | 0; + } + var $63 = HEAP32[$18 >> 2]; + if (!(($63 | 0) == 0)) { + HEAP32[($63 + 4 | 0) >> 2] = $hold_3; + } + if (!((HEAP32[$17 >> 2] & 512 | 0) == 0)) { + HEAP8[$arrayidx] = $hold_3 & 255; + HEAP8[$arrayidx40] = $hold_3 >>> 8 & 255; + HEAP8[$arrayidx199] = $hold_3 >>> 16 & 255; + HEAP8[$arrayidx202] = $hold_3 >>> 24 & 255; + HEAP32[$16 >> 2] = _crc32(HEAP32[$16 >> 2], $arrayidx, 4); + } + HEAP32[$mode >> 2] = 3; + var $next_4 = $next_3; + var $have_4 = $have_3; + var $hold_4 = 0; + var $bits_4 = 0; + __label__ = 52; + break; + } else if (__label__ == 120) { + var $bits_15; + var $hold_15; + var $have_19; + var $next_19; + if ((HEAP32[$22 >> 2] | 0) == 0) { + HEAP32[$next_out >> 2] = $put_0; + HEAP32[$avail_out >> 2] = $left_0; + HEAP32[$next_in >> 2] = $next_19; + HEAP32[$avail_in15 >> 2] = $have_19; + HEAP32[$11 >> 2] = $hold_15; + HEAP32[$13 >> 2] = $bits_15; + var $retval_0 = 2; + break $_$2; } - var $next_out = $strm + 12 | 0; - var $1 = HEAP32[$next_out >> 2]; - if (($1 | 0) == 0) { - var $retval_0 = -2; + var $call602 = _adler32(0, 0, 0); + HEAP32[$16 >> 2] = $call602; + HEAP32[$adler >> 2] = $call602; + HEAP32[$mode >> 2] = 11; + var $next_20 = $next_19; + var $have_20 = $have_19; + var $hold_16 = $hold_15; + var $bits_16 = $bits_15; + __label__ = 123; + break; + } else if (__label__ == 143) { + var $bits_20; + var $hold_20; + var $have_24; + var $next_24; + HEAP32[$mode >> 2] = 15; + var $next_25 = $next_24; + var $have_25 = $have_24; + var $hold_21 = $hold_20; + var $bits_21 = $bits_20; + __label__ = 144; + break; + } else if (__label__ == 154) { + while (1) { + var $bits_23; + var $hold_23; + var $have_27; + var $next_27; + var $122 = HEAPU32[$40 >> 2]; + if (!($122 >>> 0 < HEAPU32[$39 >> 2] >>> 0)) { break; + } + var $next_28 = $next_27; + var $have_28 = $have_27; + var $hold_24 = $hold_23; + var $bits_24 = $bits_23; + while (1) { + var $bits_24; + var $hold_24; + var $have_28; + var $next_28; + if (!($bits_24 >>> 0 < 3)) { + break; + } + if (($have_28 | 0) == 0) { + var $ret_8 = $ret_0; + var $next_58 = $next_28; + var $have_58 = 0; + var $hold_54 = $hold_24; + var $bits_54 = $bits_24; + var $out_4 = $out_0; + break $_$12; + } + var $add829 = ((HEAPU8[$next_28] & 255) << $bits_24) + $hold_24 | 0; + var $next_28 = $next_28 + 1 | 0; + var $have_28 = $have_28 - 1 | 0; + var $hold_24 = $add829; + var $bits_24 = $bits_24 + 8 | 0; + } + HEAP32[$40 >> 2] = $122 + 1 | 0; + HEAP16[($41 + ((HEAPU16[(_inflate_order + ($122 << 1) | 0) >> 1] & 65535) << 1) | 0) >> 1] = $hold_24 & 65535 & 7; + var $next_27 = $next_28; + var $have_27 = $have_28; + var $hold_23 = $hold_24 >>> 3; + var $bits_23 = $bits_24 - 3 | 0; + } + $_$131 : do { + if ($122 >>> 0 < 19) { + var $126 = $122; + while (1) { + var $126; + HEAP32[$40 >> 2] = $126 + 1 | 0; + HEAP16[($41 + ((HEAPU16[(_inflate_order + ($126 << 1) | 0) >> 1] & 65535) << 1) | 0) >> 1] = 0; + var $_pr = HEAPU32[$40 >> 2]; + if (!($_pr >>> 0 < 19)) { + break $_$131; + } + var $126 = $_pr; + } + } + } while (0); + HEAP32[$43 >> 2] = $arraydecay860_c; + HEAP32[$44 >> 2] = $arraydecay860_c; + HEAP32[$26 >> 2] = 7; + var $call868 = _inflate_table(0, $arraydecay864, 19, $42, $26, $arraydecay867); + if (($call868 | 0) == 0) { + HEAP32[$40 >> 2] = 0; + HEAP32[$mode >> 2] = 18; + var $ret_1_ph = 0; + var $next_29_ph = $next_27; + var $have_29_ph = $have_27; + var $hold_25_ph = $hold_23; + var $bits_25_ph = $bits_23; + __label__ = 164; + break; } - var $next_in = $strm | 0; - var $2 = HEAP32[$next_in >> 2]; - if (($2 | 0) == 0) { - if (!((HEAP32[($strm + 4 | 0) >> 2] | 0) == 0)) { - var $retval_0 = -2; + HEAP32[$msg >> 2] = STRING_TABLE.__str9106 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $call868; + var $next_0_be = $next_27; + var $put_0_be = $put_0; + var $have_0_be = $have_27; + var $left_0_be = $left_0; + var $hold_0_be = $hold_23; + var $bits_0_be = $bits_23; + var $out_0_be = $out_0; + __label__ = 268; + break; + } else if (__label__ == 286) { + var $out_2; + var $bits_50; + var $hold_50; + var $have_54; + var $next_54; + do { + if (!((HEAP32[$15 >> 2] | 0) == 0)) { + if ((HEAP32[$17 >> 2] | 0) == 0) { + var $next_56 = $next_54; + var $have_56 = $have_54; + var $hold_52 = $hold_50; + var $bits_52 = $bits_50; + break; + } + var $next_55 = $next_54; + var $have_55 = $have_54; + var $hold_51 = $hold_50; + var $bits_51 = $bits_50; + while (1) { + var $bits_51; + var $hold_51; + var $have_55; + var $next_55; + if (!($bits_51 >>> 0 < 32)) { break; + } + if (($have_55 | 0) == 0) { + var $ret_8 = $ret_0; + var $next_58 = $next_55; + var $have_58 = 0; + var $hold_54 = $hold_51; + var $bits_54 = $bits_51; + var $out_4 = $out_2; + break $_$12; + } + var $add1721 = ((HEAPU8[$next_55] & 255) << $bits_51) + $hold_51 | 0; + var $next_55 = $next_55 + 1 | 0; + var $have_55 = $have_55 - 1 | 0; + var $hold_51 = $add1721; + var $bits_51 = $bits_51 + 8 | 0; } + if (($hold_51 | 0) == (HEAP32[$36 >> 2] | 0)) { + var $next_56 = $next_55; + var $have_56 = $have_55; + var $hold_52 = 0; + var $bits_52 = 0; + break; + } + HEAP32[$msg >> 2] = STRING_TABLE.__str18115 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $ret_0; + var $next_0_be = $next_55; + var $put_0_be = $put_0; + var $have_0_be = $have_55; + var $left_0_be = $left_0; + var $hold_0_be = $hold_51; + var $bits_0_be = $bits_51; + var $out_0_be = $out_2; + __label__ = 268; + break $_$106; + } + var $next_56 = $next_54; + var $have_56 = $have_54; + var $hold_52 = $hold_50; + var $bits_52 = $bits_50; + } while (0); + var $bits_52; + var $hold_52; + var $have_56; + var $next_56; + HEAP32[$mode >> 2] = 28; + var $ret_8 = 1; + var $next_58 = $next_56; + var $have_58 = $have_56; + var $hold_54 = $hold_52; + var $bits_54 = $bits_52; + var $out_4 = $out_2; + break $_$12; + } + } while (0); + $_$148 : do { + if (__label__ == 52) { + while (1) { + var $bits_4; + var $hold_4; + var $have_4; + var $next_4; + if (!($bits_4 >>> 0 < 16)) { + break; + } + if (($have_4 | 0) == 0) { + var $ret_8 = $ret_0; + var $next_58 = $next_4; + var $have_58 = 0; + var $hold_54 = $hold_4; + var $bits_54 = $bits_4; + var $out_4 = $out_0; + break $_$12; + } + var $add227 = ((HEAPU8[$next_4] & 255) << $bits_4) + $hold_4 | 0; + var $next_4 = $next_4 + 1 | 0; + var $have_4 = $have_4 - 1 | 0; + var $hold_4 = $add227; + var $bits_4 = $bits_4 + 8 | 0; } - var $4 = $0; - var $mode = $0 | 0; - var $5 = HEAP32[$mode >> 2]; - if (($5 | 0) == 11) { - HEAP32[$mode >> 2] = 12; - var $8 = HEAP32[$next_out >> 2]; - var $7 = HEAP32[$next_in >> 2]; - var $6 = 12; - } else { - var $8 = $1; - var $7 = $2; - var $6 = $5; + var $67 = HEAP32[$18 >> 2]; + if (!(($67 | 0) == 0)) { + HEAP32[($67 + 8 | 0) >> 2] = $hold_4 & 255; + HEAP32[(HEAP32[$18 >> 2] + 12 | 0) >> 2] = $hold_4 >>> 8; } - var $6; - var $7; - var $8; - var $avail_out = $strm + 16 | 0; - var $9 = HEAP32[$avail_out >> 2]; - var $avail_in15 = $strm + 4 | 0; - var $10 = HEAPU32[$avail_in15 >> 2]; - var $11 = $0 + 56 | 0; - var $13 = $0 + 60 | 0; - var $15 = $0 + 8 | 0; - var $16 = $0 + 24 | 0; - var $arrayidx = $hbuf | 0; - var $arrayidx40 = $hbuf + 1 | 0; - var $17 = $0 + 16 | 0; - var $18 = $0 + 32 | 0; - var $msg = $strm + 24 | 0; - var $19 = $0 + 36 | 0; - var $20 = $0 + 20 | 0; - var $adler = $strm + 48 | 0; - var $21 = $0 + 64 | 0; - var $22 = $0 + 12 | 0; - var $23 = ($flush - 5 | 0) >>> 0 < 2; - var $24 = $0 + 4 | 0; - var $cmp660 = ($flush | 0) == 6; - var $25 = $0 + 7108 | 0; - var $26 = $0 + 84 | 0; - var $27 = $0 + 76 | 0; - var $28 = $0 + 72 | 0; - var $29 = $0 + 7112 | 0; - var $30 = $0 + 68 | 0; - var $31 = $0 + 44 | 0; - var $32 = $0 + 7104 | 0; - var $33 = $0 + 48 | 0; - var $34 = $0 + 52 | 0; - var $35 = $0 + 40 | 0; - var $total_out = $strm + 20 | 0; - var $36 = $0 + 28 | 0; - var $arrayidx199 = $hbuf + 2 | 0; - var $arrayidx202 = $hbuf + 3 | 0; - var $37 = $0 + 96 | 0; - var $38 = $0 + 100 | 0; - var $39 = $0 + 92 | 0; - var $40 = $0 + 104 | 0; - var $lens = $0 + 112 | 0; - var $41 = $lens; - var $next861 = $0 + 108 | 0; - var $42 = $next861; - var $43 = $next861 | 0; - var $arraydecay860_c = $0 + 1328 | 0; - var $44 = $0 + 76 | 0; - var $arraydecay864 = $lens; - var $arraydecay867 = $0 + 752 | 0; - var $45 = $0 + 624 | 0; - var $46 = $0 + 80 | 0; - var $47 = $0 + 88 | 0; - var $48 = $0 + 80 | 0; - var $ret_0 = 0; - var $next_0 = $7; - var $put_0 = $8; - var $have_0 = $10; - var $left_0 = $9; - var $hold_0 = HEAP32[$11 >> 2]; - var $bits_0 = HEAP32[$13 >> 2]; - var $out_0 = $9; - var $49 = $6; - $_$12 : while (1) { - var $49; - var $out_0; - var $bits_0; - var $hold_0; - var $left_0; - var $have_0; - var $put_0; - var $next_0; - var $ret_0; - $_$14 : do { - if (($49 | 0) == 0) { - var $50 = HEAPU32[$15 >> 2]; - if (($50 | 0) == 0) { - HEAP32[$mode >> 2] = 12; - var $ret_0_be = $ret_0; - var $next_0_be = $next_0; - var $put_0_be = $put_0; - var $have_0_be = $have_0; - var $left_0_be = $left_0; - var $hold_0_be = $hold_0; - var $bits_0_be = $bits_0; - var $out_0_be = $out_0; - __label__ = 268; - break; - } - var $next_1 = $next_0; - var $have_1 = $have_0; - var $hold_1 = $hold_0; - var $bits_1 = $bits_0; - while (1) { - var $bits_1; - var $hold_1; - var $have_1; - var $next_1; - if (!($bits_1 >>> 0 < 16)) { - break; - } - if (($have_1 | 0) == 0) { - var $ret_8 = $ret_0; - var $next_58 = $next_1; - var $have_58 = 0; - var $hold_54 = $hold_1; - var $bits_54 = $bits_1; - var $out_4 = $out_0; - break $_$12; - } - var $add = ((HEAPU8[$next_1] & 255) << $bits_1) + $hold_1 | 0; - var $next_1 = $next_1 + 1 | 0; - var $have_1 = $have_1 - 1 | 0; - var $hold_1 = $add; - var $bits_1 = $bits_1 + 8 | 0; - } - if (($50 & 2 | 0) != 0 & ($hold_1 | 0) == 35615) { - HEAP32[$16 >> 2] = _crc32(0, 0, 0); - HEAP8[$arrayidx] = 31; - HEAP8[$arrayidx40] = -117; - HEAP32[$16 >> 2] = _crc32(HEAP32[$16 >> 2], $arrayidx, 2); - HEAP32[$mode >> 2] = 1; - var $ret_0_be = $ret_0; - var $next_0_be = $next_1; - var $put_0_be = $put_0; - var $have_0_be = $have_1; - var $left_0_be = $left_0; - var $hold_0_be = 0; - var $bits_0_be = 0; - var $out_0_be = $out_0; - __label__ = 268; - break; - } - HEAP32[$17 >> 2] = 0; - var $53 = HEAP32[$18 >> 2]; - if (($53 | 0) == 0) { - var $54 = $50; - } else { - HEAP32[($53 + 48 | 0) >> 2] = -1; - var $54 = HEAP32[$15 >> 2]; - } - var $54; - do { - if (!(($54 & 1 | 0) == 0)) { - if (!((((($hold_1 << 8 & 65280) + ($hold_1 >>> 8) | 0) >>> 0) % 31 | 0) == 0)) { - break; - } - if (($hold_1 & 15 | 0) == 8) { - var $shr74 = $hold_1 >>> 4; - var $sub = $bits_1 - 4 | 0; - var $add77 = ($shr74 & 15) + 8 | 0; - var $55 = HEAPU32[$19 >> 2]; - do { - if (!(($55 | 0) == 0)) { - if (!($add77 >>> 0 > $55 >>> 0)) { - break; - } - HEAP32[$msg >> 2] = STRING_TABLE.__str3100 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $ret_0; - var $next_0_be = $next_1; - var $put_0_be = $put_0; - var $have_0_be = $have_1; - var $left_0_be = $left_0; - var $hold_0_be = $shr74; - var $bits_0_be = $sub; - var $out_0_be = $out_0; - __label__ = 268; - break $_$14; - } - HEAP32[$19 >> 2] = $add77; - } while (0); - HEAP32[$20 >> 2] = 1 << $add77; - var $call91 = _adler32(0, 0, 0); - HEAP32[$16 >> 2] = $call91; - HEAP32[$adler >> 2] = $call91; - HEAP32[$mode >> 2] = $hold_1 >>> 12 & 2 ^ 11; - var $ret_0_be = $ret_0; - var $next_0_be = $next_1; - var $put_0_be = $put_0; - var $have_0_be = $have_1; - var $left_0_be = $left_0; - var $hold_0_be = 0; - var $bits_0_be = 0; - var $out_0_be = $out_0; - __label__ = 268; - break $_$14; - } - HEAP32[$msg >> 2] = STRING_TABLE.__str299 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $ret_0; - var $next_0_be = $next_1; - var $put_0_be = $put_0; - var $have_0_be = $have_1; - var $left_0_be = $left_0; - var $hold_0_be = $hold_1; - var $bits_0_be = $bits_1; - var $out_0_be = $out_0; - __label__ = 268; - break $_$14; - } - } while (0); - HEAP32[$msg >> 2] = STRING_TABLE.__str198 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $ret_0; - var $next_0_be = $next_1; - var $put_0_be = $put_0; - var $have_0_be = $have_1; - var $left_0_be = $left_0; - var $hold_0_be = $hold_1; - var $bits_0_be = $bits_1; - var $out_0_be = $out_0; - __label__ = 268; - break; - } else if (($49 | 0) == 1) { - var $next_2 = $next_0; - var $have_2 = $have_0; - var $hold_2 = $hold_0; - var $bits_2 = $bits_0; - while (1) { - var $bits_2; - var $hold_2; - var $have_2; - var $next_2; - if (!($bits_2 >>> 0 < 16)) { - break; - } - if (($have_2 | 0) == 0) { - var $ret_8 = $ret_0; - var $next_58 = $next_2; - var $have_58 = 0; - var $hold_54 = $hold_2; - var $bits_54 = $bits_2; - var $out_4 = $out_0; - break $_$12; - } - var $add113 = ((HEAPU8[$next_2] & 255) << $bits_2) + $hold_2 | 0; - var $next_2 = $next_2 + 1 | 0; - var $have_2 = $have_2 - 1 | 0; - var $hold_2 = $add113; - var $bits_2 = $bits_2 + 8 | 0; - } - HEAP32[$17 >> 2] = $hold_2; - if (!(($hold_2 & 255 | 0) == 8)) { - HEAP32[$msg >> 2] = STRING_TABLE.__str299 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $ret_0; - var $next_0_be = $next_2; - var $put_0_be = $put_0; - var $have_0_be = $have_2; - var $left_0_be = $left_0; - var $hold_0_be = $hold_2; - var $bits_0_be = $bits_2; - var $out_0_be = $out_0; - __label__ = 268; - break; - } - if (($hold_2 & 57344 | 0) == 0) { - var $59 = HEAPU32[$18 >> 2]; - if (($59 | 0) == 0) { - var $60 = $hold_2; - } else { - HEAP32[($59 | 0) >> 2] = $hold_2 >>> 8 & 1; - var $60 = HEAP32[$17 >> 2]; - } - var $60; - if (!(($60 & 512 | 0) == 0)) { - HEAP8[$arrayidx] = $hold_2 & 255; - HEAP8[$arrayidx40] = $hold_2 >>> 8 & 255; - HEAP32[$16 >> 2] = _crc32(HEAP32[$16 >> 2], $arrayidx, 2); - } - HEAP32[$mode >> 2] = 2; - var $next_3 = $next_2; - var $have_3 = $have_2; - var $hold_3 = 0; - var $bits_3 = 0; - __label__ = 44; - break; - } - HEAP32[$msg >> 2] = STRING_TABLE.__str4101 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $ret_0; - var $next_0_be = $next_2; - var $put_0_be = $put_0; - var $have_0_be = $have_2; - var $left_0_be = $left_0; - var $hold_0_be = $hold_2; - var $bits_0_be = $bits_2; - var $out_0_be = $out_0; - __label__ = 268; - break; - } else if (($49 | 0) == 2) { - var $next_3 = $next_0; - var $have_3 = $have_0; - var $hold_3 = $hold_0; - var $bits_3 = $bits_0; - __label__ = 44; - } else if (($49 | 0) == 3) { - var $next_4 = $next_0; - var $have_4 = $have_0; - var $hold_4 = $hold_0; - var $bits_4 = $bits_0; - __label__ = 52; - } else if (($49 | 0) == 4) { - var $next_5 = $next_0; - var $have_5 = $have_0; - var $hold_5 = $hold_0; - var $bits_5 = $bits_0; - __label__ = 60; - } else if (($49 | 0) == 5) { - var $next_8 = $next_0; - var $have_8 = $have_0; - var $hold_8 = $hold_0; - var $bits_8 = $bits_0; - __label__ = 71; - } else if (($49 | 0) == 6) { - var $next_11 = $next_0; - var $have_11 = $have_0; - var $hold_9 = $hold_0; - var $bits_9 = $bits_0; - var $89 = HEAP32[$17 >> 2]; - __label__ = 81; - break; - } else if (($49 | 0) == 7) { - var $next_13 = $next_0; - var $have_13 = $have_0; - var $hold_10 = $hold_0; - var $bits_10 = $bits_0; - __label__ = 94; - } else if (($49 | 0) == 8) { - var $next_15 = $next_0; - var $have_15 = $have_0; - var $hold_11 = $hold_0; - var $bits_11 = $bits_0; - __label__ = 107; - } else if (($49 | 0) == 9) { - var $next_18 = $next_0; - var $have_18 = $have_0; - var $hold_14 = $hold_0; - var $bits_14 = $bits_0; - while (1) { - var $bits_14; - var $hold_14; - var $have_18; - var $next_18; - if (!($bits_14 >>> 0 < 32)) { - break; - } - if (($have_18 | 0) == 0) { - var $ret_8 = $ret_0; - var $next_58 = $next_18; - var $have_58 = 0; - var $hold_54 = $hold_14; - var $bits_54 = $bits_14; - var $out_4 = $out_0; - break $_$12; - } - var $add564 = ((HEAPU8[$next_18] & 255) << $bits_14) + $hold_14 | 0; - var $next_18 = $next_18 + 1 | 0; - var $have_18 = $have_18 - 1 | 0; - var $hold_14 = $add564; - var $bits_14 = $bits_14 + 8 | 0; - } - var $add581 = _llvm_bswap_i32($hold_14); - HEAP32[$16 >> 2] = $add581; - HEAP32[$adler >> 2] = $add581; - HEAP32[$mode >> 2] = 10; - var $next_19 = $next_18; - var $have_19 = $have_18; - var $hold_15 = 0; - var $bits_15 = 0; - __label__ = 120; - break; - } else if (($49 | 0) == 10) { - var $next_19 = $next_0; - var $have_19 = $have_0; - var $hold_15 = $hold_0; - var $bits_15 = $bits_0; - __label__ = 120; - } else if (($49 | 0) == 11) { - var $next_20 = $next_0; - var $have_20 = $have_0; - var $hold_16 = $hold_0; - var $bits_16 = $bits_0; - __label__ = 123; - } else if (($49 | 0) == 12) { - var $next_21 = $next_0; - var $have_21 = $have_0; - var $hold_17 = $hold_0; - var $bits_17 = $bits_0; - __label__ = 124; - } else if (($49 | 0) == 13) { - var $and681 = $bits_0 & 7; - var $next_23 = $next_0; - var $have_23 = $have_0; - var $hold_19 = $hold_0 >>> ($and681 >>> 0); - var $bits_19 = $bits_0 - $and681 | 0; - while (1) { - var $bits_19; - var $hold_19; - var $have_23; - var $next_23; - if (!($bits_19 >>> 0 < 32)) { - break; - } - if (($have_23 | 0) == 0) { - var $ret_8 = $ret_0; - var $next_58 = $next_23; - var $have_58 = 0; - var $hold_54 = $hold_19; - var $bits_54 = $bits_19; - var $out_4 = $out_0; - break $_$12; - } - var $add701 = ((HEAPU8[$next_23] & 255) << $bits_19) + $hold_19 | 0; - var $next_23 = $next_23 + 1 | 0; - var $have_23 = $have_23 - 1 | 0; - var $hold_19 = $add701; - var $bits_19 = $bits_19 + 8 | 0; - } - var $and708 = $hold_19 & 65535; - if (!(($and708 | 0) == ($hold_19 >>> 16 ^ 65535 | 0))) { - HEAP32[$msg >> 2] = STRING_TABLE.__str7104 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $ret_0; - var $next_0_be = $next_23; - var $put_0_be = $put_0; - var $have_0_be = $have_23; - var $left_0_be = $left_0; - var $hold_0_be = $hold_19; - var $bits_0_be = $bits_19; - var $out_0_be = $out_0; - __label__ = 268; - break; - } - HEAP32[$21 >> 2] = $and708; - HEAP32[$mode >> 2] = 14; - if ($cmp660) { - var $ret_8 = $ret_0; - var $next_58 = $next_23; - var $have_58 = $have_23; - var $hold_54 = 0; - var $bits_54 = 0; - var $out_4 = $out_0; - break $_$12; - } - var $next_24 = $next_23; - var $have_24 = $have_23; - var $hold_20 = 0; - var $bits_20 = 0; - __label__ = 143; - break; - } else if (($49 | 0) == 14) { - var $next_24 = $next_0; - var $have_24 = $have_0; - var $hold_20 = $hold_0; - var $bits_20 = $bits_0; - __label__ = 143; - } else if (($49 | 0) == 15) { - var $next_25 = $next_0; - var $have_25 = $have_0; - var $hold_21 = $hold_0; - var $bits_21 = $bits_0; - __label__ = 144; - } else if (($49 | 0) == 16) { - var $next_26 = $next_0; - var $have_26 = $have_0; - var $hold_22 = $hold_0; - var $bits_22 = $bits_0; - while (1) { - var $bits_22; - var $hold_22; - var $have_26; - var $next_26; - if (!($bits_22 >>> 0 < 14)) { - break; - } - if (($have_26 | 0) == 0) { - var $ret_8 = $ret_0; - var $next_58 = $next_26; - var $have_58 = 0; - var $hold_54 = $hold_22; - var $bits_54 = $bits_22; - var $out_4 = $out_0; - break $_$12; - } - var $add767 = ((HEAPU8[$next_26] & 255) << $bits_22) + $hold_22 | 0; - var $next_26 = $next_26 + 1 | 0; - var $have_26 = $have_26 - 1 | 0; - var $hold_22 = $add767; - var $bits_22 = $bits_22 + 8 | 0; - } - var $add775 = ($hold_22 & 31) + 257 | 0; - HEAP32[$37 >> 2] = $add775; - var $add782 = ($hold_22 >>> 5 & 31) + 1 | 0; - HEAP32[$38 >> 2] = $add782; - HEAP32[$39 >> 2] = ($hold_22 >>> 10 & 15) + 4 | 0; - var $shr791 = $hold_22 >>> 14; - var $sub792 = $bits_22 - 14 | 0; - if ($add775 >>> 0 > 286 | $add782 >>> 0 > 30) { - HEAP32[$msg >> 2] = STRING_TABLE.__str8105 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $ret_0; - var $next_0_be = $next_26; - var $put_0_be = $put_0; - var $have_0_be = $have_26; - var $left_0_be = $left_0; - var $hold_0_be = $shr791; - var $bits_0_be = $sub792; - var $out_0_be = $out_0; - __label__ = 268; - break; - } - HEAP32[$40 >> 2] = 0; - HEAP32[$mode >> 2] = 17; - var $next_27 = $next_26; - var $have_27 = $have_26; - var $hold_23 = $shr791; - var $bits_23 = $sub792; - __label__ = 154; - break; - } else if (($49 | 0) == 17) { - var $next_27 = $next_0; - var $have_27 = $have_0; - var $hold_23 = $hold_0; - var $bits_23 = $bits_0; - __label__ = 154; - } else if (($49 | 0) == 18) { - var $ret_1_ph = $ret_0; - var $next_29_ph = $next_0; - var $have_29_ph = $have_0; - var $hold_25_ph = $hold_0; - var $bits_25_ph = $bits_0; - __label__ = 164; - } else if (($49 | 0) == 19) { - var $ret_2 = $ret_0; - var $next_37 = $next_0; - var $have_37 = $have_0; - var $hold_33 = $hold_0; - var $bits_33 = $bits_0; - __label__ = 205; - } else if (($49 | 0) == 20) { - var $ret_3 = $ret_0; - var $next_38 = $next_0; - var $have_38 = $have_0; - var $hold_34 = $hold_0; - var $bits_34 = $bits_0; - __label__ = 206; - } else if (($49 | 0) == 21) { - var $ret_4 = $ret_0; - var $next_42 = $next_0; - var $have_42 = $have_0; - var $hold_38 = $hold_0; - var $bits_38 = $bits_0; - var $156 = HEAP32[$28 >> 2]; - __label__ = 227; - break; - } else if (($49 | 0) == 22) { - var $ret_5_ph = $ret_0; - var $next_45_ph = $next_0; - var $have_45_ph = $have_0; - var $hold_41_ph = $hold_0; - var $bits_41_ph = $bits_0; - __label__ = 234; - } else if (($49 | 0) == 23) { - var $ret_6 = $ret_0; - var $next_48 = $next_0; - var $have_48 = $have_0; - var $hold_44 = $hold_0; - var $bits_44 = $bits_0; - var $167 = HEAP32[$28 >> 2]; - __label__ = 248; - break; - } else if (($49 | 0) == 24) { - var $ret_7 = $ret_0; - var $next_51 = $next_0; - var $have_51 = $have_0; - var $hold_47 = $hold_0; - var $bits_47 = $bits_0; - __label__ = 254; - } else if (($49 | 0) == 25) { - if (($left_0 | 0) == 0) { - var $ret_8 = $ret_0; - var $next_58 = $next_0; - var $have_58 = $have_0; - var $hold_54 = $hold_0; - var $bits_54 = $bits_0; - var $out_4 = $out_0; - break $_$12; - } - HEAP8[$put_0] = HEAP32[$21 >> 2] & 255; - HEAP32[$mode >> 2] = 20; - var $ret_0_be = $ret_0; - var $next_0_be = $next_0; - var $put_0_be = $put_0 + 1 | 0; - var $have_0_be = $have_0; - var $left_0_be = $left_0 - 1 | 0; - var $hold_0_be = $hold_0; - var $bits_0_be = $bits_0; - var $out_0_be = $out_0; - __label__ = 268; + if (!((HEAP32[$17 >> 2] & 512 | 0) == 0)) { + HEAP8[$arrayidx] = $hold_4 & 255; + HEAP8[$arrayidx40] = $hold_4 >>> 8 & 255; + HEAP32[$16 >> 2] = _crc32(HEAP32[$16 >> 2], $arrayidx, 2); + } + HEAP32[$mode >> 2] = 4; + var $next_5 = $next_4; + var $have_5 = $have_4; + var $hold_5 = 0; + var $bits_5 = 0; + __label__ = 60; + break; + } else if (__label__ == 123) { + var $bits_16; + var $hold_16; + var $have_20; + var $next_20; + if ($23) { + var $ret_8 = $ret_0; + var $next_58 = $next_20; + var $have_58 = $have_20; + var $hold_54 = $hold_16; + var $bits_54 = $bits_16; + var $out_4 = $out_0; + break $_$12; + } + var $next_21 = $next_20; + var $have_21 = $have_20; + var $hold_17 = $hold_16; + var $bits_17 = $bits_16; + __label__ = 124; + break; + } else if (__label__ == 144) { + var $bits_21; + var $hold_21; + var $have_25; + var $next_25; + var $119 = HEAPU32[$21 >> 2]; + if (($119 | 0) == 0) { + HEAP32[$mode >> 2] = 11; + var $ret_0_be = $ret_0; + var $next_0_be = $next_25; + var $put_0_be = $put_0; + var $have_0_be = $have_25; + var $left_0_be = $left_0; + var $hold_0_be = $hold_21; + var $bits_0_be = $bits_21; + var $out_0_be = $out_0; + __label__ = 268; + break; + } + var $copy_3 = $119 >>> 0 > $have_25 >>> 0 ? $have_25 : $119; + var $copy_4 = $copy_3 >>> 0 > $left_0 >>> 0 ? $left_0 : $copy_3; + if (($copy_4 | 0) == 0) { + var $ret_8 = $ret_0; + var $next_58 = $next_25; + var $have_58 = $have_25; + var $hold_54 = $hold_21; + var $bits_54 = $bits_21; + var $out_4 = $out_0; + break $_$12; + } + _memcpy($put_0, $next_25, $copy_4, 1); + HEAP32[$21 >> 2] = HEAP32[$21 >> 2] - $copy_4 | 0; + var $ret_0_be = $ret_0; + var $next_0_be = $next_25 + $copy_4 | 0; + var $put_0_be = $put_0 + $copy_4 | 0; + var $have_0_be = $have_25 - $copy_4 | 0; + var $left_0_be = $left_0 - $copy_4 | 0; + var $hold_0_be = $hold_21; + var $bits_0_be = $bits_21; + var $out_0_be = $out_0; + __label__ = 268; + break; + } else if (__label__ == 164) { + var $bits_25_ph; + var $hold_25_ph; + var $have_29_ph; + var $next_29_ph; + var $ret_1_ph; + var $next_29 = $next_29_ph; + var $have_29 = $have_29_ph; + var $hold_25 = $hold_25_ph; + var $bits_25 = $bits_25_ph; + $_$167 : while (1) { + var $bits_25; + var $hold_25; + var $have_29; + var $next_29; + var $128 = HEAPU32[$40 >> 2]; + var $129 = HEAPU32[$37 >> 2]; + var $add881 = HEAP32[$38 >> 2] + $129 | 0; + if ($128 >>> 0 < $add881 >>> 0) { + var $sub888 = (1 << HEAP32[$26 >> 2]) - 1 | 0; + var $132 = HEAPU32[$27 >> 2]; + var $next_30 = $next_29; + var $have_30 = $have_29; + var $hold_26 = $hold_25; + var $bits_26 = $bits_25; + while (1) { + var $bits_26; + var $hold_26; + var $have_30; + var $next_30; + var $and889 = $sub888 & $hold_26; + var $conv893 = HEAPU8[$132 + ($and889 << 2) + 1 | 0] & 255; + if (!($conv893 >>> 0 > $bits_26 >>> 0)) { + break; + } + if (($have_30 | 0) == 0) { + var $ret_8 = $ret_1_ph; + var $next_58 = $next_30; + var $have_58 = 0; + var $hold_54 = $hold_26; + var $bits_54 = $bits_26; + var $out_4 = $out_0; + break $_$12; + } + var $add907 = ((HEAPU8[$next_30] & 255) << $bits_26) + $hold_26 | 0; + var $next_30 = $next_30 + 1 | 0; + var $have_30 = $have_30 - 1 | 0; + var $hold_26 = $add907; + var $bits_26 = $bits_26 + 8 | 0; + } + var $tmp26 = HEAPU16[($132 + ($and889 << 2) + 2 | 0) >> 1]; + if (($tmp26 & 65535) < 16) { + var $next_31 = $next_30; + var $have_31 = $have_30; + var $hold_27 = $hold_26; + var $bits_27 = $bits_26; + while (1) { + var $bits_27; + var $hold_27; + var $have_31; + var $next_31; + if (!($bits_27 >>> 0 < $conv893 >>> 0)) { + break; + } + if (($have_31 | 0) == 0) { + var $ret_8 = $ret_1_ph; + var $next_58 = $next_31; + var $have_58 = 0; + var $hold_54 = $hold_27; + var $bits_54 = $bits_27; + var $out_4 = $out_0; + break $_$12; + } + var $add931 = ((HEAPU8[$next_31] & 255) << $bits_27) + $hold_27 | 0; + var $next_31 = $next_31 + 1 | 0; + var $have_31 = $have_31 - 1 | 0; + var $hold_27 = $add931; + var $bits_27 = $bits_27 + 8 | 0; + } + HEAP32[$40 >> 2] = $128 + 1 | 0; + HEAP16[($41 + ($128 << 1) | 0) >> 1] = $tmp26; + var $next_29 = $next_31; + var $have_29 = $have_31; + var $hold_25 = $hold_27 >>> ($conv893 >>> 0); + var $bits_25 = $bits_27 - $conv893 | 0; + } else { + if ($tmp26 << 16 >> 16 == 16) { + var $add962 = $conv893 + 2 | 0; + var $next_32 = $next_30; + var $have_32 = $have_30; + var $hold_28 = $hold_26; + var $bits_28 = $bits_26; + while (1) { + var $bits_28; + var $hold_28; + var $have_32; + var $next_32; + if (!($bits_28 >>> 0 < $add962 >>> 0)) { break; - } else if (($49 | 0) == 26) { - do { - if (!((HEAP32[$15 >> 2] | 0) == 0)) { - var $next_52 = $next_0; - var $have_52 = $have_0; - var $hold_48 = $hold_0; - var $bits_48 = $bits_0; - while (1) { - var $bits_48; - var $hold_48; - var $have_52; - var $next_52; - if (!($bits_48 >>> 0 < 32)) { - break; - } - if (($have_52 | 0) == 0) { - var $ret_8 = $ret_0; - var $next_58 = $next_52; - var $have_58 = 0; - var $hold_54 = $hold_48; - var $bits_54 = $bits_48; - var $out_4 = $out_0; - break $_$12; - } - var $add1642 = ((HEAPU8[$next_52] & 255) << $bits_48) + $hold_48 | 0; - var $next_52 = $next_52 + 1 | 0; - var $have_52 = $have_52 - 1 | 0; - var $hold_48 = $add1642; - var $bits_48 = $bits_48 + 8 | 0; - } - var $sub1649 = $out_0 - $left_0 | 0; - HEAP32[$total_out >> 2] = HEAP32[$total_out >> 2] + $sub1649 | 0; - HEAP32[$36 >> 2] = HEAP32[$36 >> 2] + $sub1649 | 0; - if (!(($out_0 | 0) == ($left_0 | 0))) { - var $192 = HEAP32[$16 >> 2]; - var $add_ptr1659 = $put_0 + (-$sub1649 | 0) | 0; - if ((HEAP32[$17 >> 2] | 0) == 0) { - var $cond1667 = _adler32($192, $add_ptr1659, $sub1649); - } else { - var $cond1667 = _crc32($192, $add_ptr1659, $sub1649); - } - var $cond1667; - HEAP32[$16 >> 2] = $cond1667; - HEAP32[$adler >> 2] = $cond1667; - } - if ((HEAP32[$17 >> 2] | 0) == 0) { - var $cond1687 = _llvm_bswap_i32($hold_48); - } else { - var $cond1687 = $hold_48; - } - var $cond1687; - if (($cond1687 | 0) == (HEAP32[$16 >> 2] | 0)) { - var $next_53 = $next_52; - var $have_53 = $have_52; - var $hold_49 = 0; - var $bits_49 = 0; - var $out_1 = $left_0; - break; - } - HEAP32[$msg >> 2] = STRING_TABLE.__str17114 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $ret_0; - var $next_0_be = $next_52; - var $put_0_be = $put_0; - var $have_0_be = $have_52; - var $left_0_be = $left_0; - var $hold_0_be = $hold_48; - var $bits_0_be = $bits_48; - var $out_0_be = $left_0; - __label__ = 268; - break $_$14; - } - var $next_53 = $next_0; - var $have_53 = $have_0; - var $hold_49 = $hold_0; - var $bits_49 = $bits_0; - var $out_1 = $out_0; - } while (0); - var $out_1; - var $bits_49; - var $hold_49; - var $have_53; - var $next_53; - HEAP32[$mode >> 2] = 27; - var $next_54 = $next_53; - var $have_54 = $have_53; - var $hold_50 = $hold_49; - var $bits_50 = $bits_49; - var $out_2 = $out_1; - __label__ = 286; + } + if (($have_32 | 0) == 0) { + var $ret_8 = $ret_1_ph; + var $next_58 = $next_32; + var $have_58 = 0; + var $hold_54 = $hold_28; + var $bits_54 = $bits_28; + var $out_4 = $out_0; + break $_$12; + } + var $add975 = ((HEAPU8[$next_32] & 255) << $bits_28) + $hold_28 | 0; + var $next_32 = $next_32 + 1 | 0; + var $have_32 = $have_32 - 1 | 0; + var $hold_28 = $add975; + var $bits_28 = $bits_28 + 8 | 0; + } + var $shr985 = $hold_28 >>> ($conv893 >>> 0); + var $sub988 = $bits_28 - $conv893 | 0; + if (($128 | 0) == 0) { + HEAP32[$msg >> 2] = STRING_TABLE.__str10107 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $ret_1_ph; + var $next_0_be = $next_32; + var $put_0_be = $put_0; + var $have_0_be = $have_32; + var $left_0_be = $left_0; + var $hold_0_be = $shr985; + var $bits_0_be = $sub988; + var $out_0_be = $out_0; + __label__ = 268; + break $_$148; + } + var $len_0 = HEAP16[($41 + (($128 - 1 | 0) << 1) | 0) >> 1]; + var $next_35 = $next_32; + var $have_35 = $have_32; + var $hold_31 = $shr985 >>> 2; + var $bits_31 = $sub988 - 2 | 0; + var $copy_5 = ($shr985 & 3) + 3 | 0; + } else if ($tmp26 << 16 >> 16 == 17) { + var $add1020 = $conv893 + 3 | 0; + var $next_33 = $next_30; + var $have_33 = $have_30; + var $hold_29 = $hold_26; + var $bits_29 = $bits_26; + while (1) { + var $bits_29; + var $hold_29; + var $have_33; + var $next_33; + if (!($bits_29 >>> 0 < $add1020 >>> 0)) { break; - } else if (($49 | 0) == 27) { - var $next_54 = $next_0; - var $have_54 = $have_0; - var $hold_50 = $hold_0; - var $bits_50 = $bits_0; - var $out_2 = $out_0; - __label__ = 286; - } else if (($49 | 0) == 28) { - var $ret_8 = 1; - var $next_58 = $next_0; - var $have_58 = $have_0; - var $hold_54 = $hold_0; - var $bits_54 = $bits_0; + } + if (($have_33 | 0) == 0) { + var $ret_8 = $ret_1_ph; + var $next_58 = $next_33; + var $have_58 = 0; + var $hold_54 = $hold_29; + var $bits_54 = $bits_29; var $out_4 = $out_0; break $_$12; - } else if (($49 | 0) == 29) { - var $ret_8 = -3; - var $next_58 = $next_0; - var $have_58 = $have_0; - var $hold_54 = $hold_0; - var $bits_54 = $bits_0; + } + var $add1033 = ((HEAPU8[$next_33] & 255) << $bits_29) + $hold_29 | 0; + var $next_33 = $next_33 + 1 | 0; + var $have_33 = $have_33 - 1 | 0; + var $hold_29 = $add1033; + var $bits_29 = $bits_29 + 8 | 0; + } + var $shr1043 = $hold_29 >>> ($conv893 >>> 0); + var $len_0 = 0; + var $next_35 = $next_33; + var $have_35 = $have_33; + var $hold_31 = $shr1043 >>> 3; + var $bits_31 = (-3 - $conv893 | 0) + $bits_29 | 0; + var $copy_5 = ($shr1043 & 7) + 3 | 0; + } else { + var $add1061 = $conv893 + 7 | 0; + var $next_34 = $next_30; + var $have_34 = $have_30; + var $hold_30 = $hold_26; + var $bits_30 = $bits_26; + while (1) { + var $bits_30; + var $hold_30; + var $have_34; + var $next_34; + if (!($bits_30 >>> 0 < $add1061 >>> 0)) { + break; + } + if (($have_34 | 0) == 0) { + var $ret_8 = $ret_1_ph; + var $next_58 = $next_34; + var $have_58 = 0; + var $hold_54 = $hold_30; + var $bits_54 = $bits_30; var $out_4 = $out_0; break $_$12; - } else if (($49 | 0) == 30) { - var $retval_0 = -4; - break $_$2; - } else { - var $retval_0 = -2; - break $_$2; + } + var $add1074 = ((HEAPU8[$next_34] & 255) << $bits_30) + $hold_30 | 0; + var $next_34 = $next_34 + 1 | 0; + var $have_34 = $have_34 - 1 | 0; + var $hold_30 = $add1074; + var $bits_30 = $bits_30 + 8 | 0; + } + var $shr1084 = $hold_30 >>> ($conv893 >>> 0); + var $len_0 = 0; + var $next_35 = $next_34; + var $have_35 = $have_34; + var $hold_31 = $shr1084 >>> 7; + var $bits_31 = (-7 - $conv893 | 0) + $bits_30 | 0; + var $copy_5 = ($shr1084 & 127) + 11 | 0; + } + var $copy_5; + var $bits_31; + var $hold_31; + var $have_35; + var $next_35; + var $len_0; + if (($128 + $copy_5 | 0) >>> 0 > $add881 >>> 0) { + HEAP32[$msg >> 2] = STRING_TABLE.__str10107 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $ret_1_ph; + var $next_0_be = $next_35; + var $put_0_be = $put_0; + var $have_0_be = $have_35; + var $left_0_be = $left_0; + var $hold_0_be = $hold_31; + var $bits_0_be = $bits_31; + var $out_0_be = $out_0; + __label__ = 268; + break $_$148; + } + var $copy_6127 = $copy_5; + var $139 = $128; + while (1) { + var $139; + var $copy_6127; + var $dec1111 = $copy_6127 - 1 | 0; + HEAP32[$40 >> 2] = $139 + 1 | 0; + HEAP16[($41 + ($139 << 1) | 0) >> 1] = $len_0; + if (($dec1111 | 0) == 0) { + var $next_29 = $next_35; + var $have_29 = $have_35; + var $hold_25 = $hold_31; + var $bits_25 = $bits_31; + continue $_$167; + } + var $copy_6127 = $dec1111; + var $139 = HEAP32[$40 >> 2]; + } + } + } else { + if ((HEAP32[$mode >> 2] | 0) == 29) { + var $ret_0_be = $ret_1_ph; + var $next_0_be = $next_29; + var $put_0_be = $put_0; + var $have_0_be = $have_29; + var $left_0_be = $left_0; + var $hold_0_be = $hold_25; + var $bits_0_be = $bits_25; + var $out_0_be = $out_0; + __label__ = 268; + break $_$148; + } + if (HEAP16[$45 >> 1] << 16 >> 16 == 0) { + HEAP32[$msg >> 2] = STRING_TABLE.__str11108 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $ret_1_ph; + var $next_0_be = $next_29; + var $put_0_be = $put_0; + var $have_0_be = $have_29; + var $left_0_be = $left_0; + var $hold_0_be = $hold_25; + var $bits_0_be = $bits_25; + var $out_0_be = $out_0; + __label__ = 268; + break $_$148; + } + HEAP32[$43 >> 2] = $arraydecay860_c; + HEAP32[$44 >> 2] = $arraydecay860_c; + HEAP32[$26 >> 2] = 9; + var $call1149 = _inflate_table(1, $arraydecay864, $129, $42, $26, $arraydecay867); + if (!(($call1149 | 0) == 0)) { + HEAP32[$msg >> 2] = STRING_TABLE.__str12109 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $call1149; + var $next_0_be = $next_29; + var $put_0_be = $put_0; + var $have_0_be = $have_29; + var $left_0_be = $left_0; + var $hold_0_be = $hold_25; + var $bits_0_be = $bits_25; + var $out_0_be = $out_0; + __label__ = 268; + break $_$148; + } + HEAP32[$46 >> 2] = HEAP32[$42 >> 2]; + HEAP32[$47 >> 2] = 6; + var $call1165 = _inflate_table(2, $arraydecay864 + (HEAP32[$37 >> 2] << 1) | 0, HEAP32[$38 >> 2], $42, $47, $arraydecay867); + if (!(($call1165 | 0) == 0)) { + HEAP32[$msg >> 2] = STRING_TABLE.__str13110 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $call1165; + var $next_0_be = $next_29; + var $put_0_be = $put_0; + var $have_0_be = $have_29; + var $left_0_be = $left_0; + var $hold_0_be = $hold_25; + var $bits_0_be = $bits_25; + var $out_0_be = $out_0; + __label__ = 268; + break $_$148; + } + HEAP32[$mode >> 2] = 19; + if ($cmp660) { + var $ret_8 = 0; + var $next_58 = $next_29; + var $have_58 = $have_29; + var $hold_54 = $hold_25; + var $bits_54 = $bits_25; + var $out_4 = $out_0; + break $_$12; + } + var $ret_2 = 0; + var $next_37 = $next_29; + var $have_37 = $have_29; + var $hold_33 = $hold_25; + var $bits_33 = $bits_25; + __label__ = 205; + break $_$148; + } + } + } + } while (0); + do { + if (__label__ == 60) { + var $bits_5; + var $hold_5; + var $have_5; + var $next_5; + var $71 = HEAPU32[$17 >> 2]; + do { + if (($71 & 1024 | 0) == 0) { + var $76 = HEAP32[$18 >> 2]; + if (($76 | 0) == 0) { + var $next_7 = $next_5; + var $have_7 = $have_5; + var $hold_7 = $hold_5; + var $bits_7 = $bits_5; + break; + } + HEAP32[($76 + 16 | 0) >> 2] = 0; + var $next_7 = $next_5; + var $have_7 = $have_5; + var $hold_7 = $hold_5; + var $bits_7 = $bits_5; + } else { + var $next_6 = $next_5; + var $have_6 = $have_5; + var $hold_6 = $hold_5; + var $bits_6 = $bits_5; + while (1) { + var $bits_6; + var $hold_6; + var $have_6; + var $next_6; + if (!($bits_6 >>> 0 < 16)) { + break; + } + if (($have_6 | 0) == 0) { + var $ret_8 = $ret_0; + var $next_58 = $next_6; + var $have_58 = 0; + var $hold_54 = $hold_6; + var $bits_54 = $bits_6; + var $out_4 = $out_0; + break $_$12; + } + var $add279 = ((HEAPU8[$next_6] & 255) << $bits_6) + $hold_6 | 0; + var $next_6 = $next_6 + 1 | 0; + var $have_6 = $have_6 - 1 | 0; + var $hold_6 = $add279; + var $bits_6 = $bits_6 + 8 | 0; + } + HEAP32[$21 >> 2] = $hold_6; + var $73 = HEAP32[$18 >> 2]; + if (($73 | 0) == 0) { + var $74 = $71; + } else { + HEAP32[($73 + 20 | 0) >> 2] = $hold_6; + var $74 = HEAP32[$17 >> 2]; + } + var $74; + if (($74 & 512 | 0) == 0) { + var $next_7 = $next_6; + var $have_7 = $have_6; + var $hold_7 = 0; + var $bits_7 = 0; + break; + } + HEAP8[$arrayidx] = $hold_6 & 255; + HEAP8[$arrayidx40] = $hold_6 >>> 8 & 255; + HEAP32[$16 >> 2] = _crc32(HEAP32[$16 >> 2], $arrayidx, 2); + var $next_7 = $next_6; + var $have_7 = $have_6; + var $hold_7 = 0; + var $bits_7 = 0; + } + } while (0); + var $bits_7; + var $hold_7; + var $have_7; + var $next_7; + HEAP32[$mode >> 2] = 5; + var $next_8 = $next_7; + var $have_8 = $have_7; + var $hold_8 = $hold_7; + var $bits_8 = $bits_7; + __label__ = 71; + break; + } else if (__label__ == 124) { + var $bits_17; + var $hold_17; + var $have_21; + var $next_21; + if ((HEAP32[$24 >> 2] | 0) == 0) { + var $next_22 = $next_21; + var $have_22 = $have_21; + var $hold_18 = $hold_17; + var $bits_18 = $bits_17; + while (1) { + var $bits_18; + var $hold_18; + var $have_22; + var $next_22; + if (!($bits_18 >>> 0 < 3)) { + break; + } + if (($have_22 | 0) == 0) { + var $ret_8 = $ret_0; + var $next_58 = $next_22; + var $have_58 = 0; + var $hold_54 = $hold_18; + var $bits_54 = $bits_18; + var $out_4 = $out_0; + break $_$12; + } + var $add641 = ((HEAPU8[$next_22] & 255) << $bits_18) + $hold_18 | 0; + var $next_22 = $next_22 + 1 | 0; + var $have_22 = $have_22 - 1 | 0; + var $hold_18 = $add641; + var $bits_18 = $bits_18 + 8 | 0; + } + HEAP32[$24 >> 2] = $hold_18 & 1; + var $and655 = $hold_18 >>> 1 & 3; + do { + if (($and655 | 0) == 0) { + HEAP32[$mode >> 2] = 13; + } else if (($and655 | 0) == 1) { + _fixedtables($4); + HEAP32[$mode >> 2] = 19; + if (!$cmp660) { + break; + } + var $ret_8 = $ret_0; + var $next_58 = $next_22; + var $have_58 = $have_22; + var $hold_54 = $hold_18 >>> 3; + var $bits_54 = $bits_18 - 3 | 0; + var $out_4 = $out_0; + break $_$12; + } else if (($and655 | 0) == 2) { + HEAP32[$mode >> 2] = 16; + } else if (($and655 | 0) == 3) { + HEAP32[$msg >> 2] = STRING_TABLE.__str6103 | 0; + HEAP32[$mode >> 2] = 29; + } + } while (0); + var $ret_0_be = $ret_0; + var $next_0_be = $next_22; + var $put_0_be = $put_0; + var $have_0_be = $have_22; + var $left_0_be = $left_0; + var $hold_0_be = $hold_18 >>> 3; + var $bits_0_be = $bits_18 - 3 | 0; + var $out_0_be = $out_0; + __label__ = 268; + break; + } + var $and619 = $bits_17 & 7; + HEAP32[$mode >> 2] = 26; + var $ret_0_be = $ret_0; + var $next_0_be = $next_21; + var $put_0_be = $put_0; + var $have_0_be = $have_21; + var $left_0_be = $left_0; + var $hold_0_be = $hold_17 >>> ($and619 >>> 0); + var $bits_0_be = $bits_17 - $and619 | 0; + var $out_0_be = $out_0; + __label__ = 268; + break; + } else if (__label__ == 205) { + var $bits_33; + var $hold_33; + var $have_37; + var $next_37; + var $ret_2; + HEAP32[$mode >> 2] = 20; + var $ret_3 = $ret_2; + var $next_38 = $next_37; + var $have_38 = $have_37; + var $hold_34 = $hold_33; + var $bits_34 = $bits_33; + __label__ = 206; + break; + } + } while (0); + do { + if (__label__ == 71) { + var $bits_8; + var $hold_8; + var $have_8; + var $next_8; + var $77 = HEAPU32[$17 >> 2]; + if (($77 & 1024 | 0) == 0) { + var $next_10 = $next_8; + var $have_10 = $have_8; + var $88 = $77; + } else { + var $78 = HEAPU32[$21 >> 2]; + var $copy_0 = $78 >>> 0 > $have_8 >>> 0 ? $have_8 : $78; + if (($copy_0 | 0) == 0) { + var $next_9 = $next_8; + var $have_9 = $have_8; + var $87 = $78; + var $86 = $77; + } else { + var $79 = HEAPU32[$18 >> 2]; + do { + if (($79 | 0) == 0) { + var $83 = $77; + } else { + var $80 = HEAP32[($79 + 16 | 0) >> 2]; + if (($80 | 0) == 0) { + var $83 = $77; + break; } + var $sub341 = HEAP32[($79 + 20 | 0) >> 2] - $78 | 0; + var $82 = HEAPU32[($79 + 24 | 0) >> 2]; + _memcpy($80 + $sub341 | 0, $next_8, ($sub341 + $copy_0 | 0) >>> 0 > $82 >>> 0 ? $82 - $sub341 | 0 : $copy_0, 1); + var $83 = HEAP32[$17 >> 2]; + } } while (0); - $_$106 : do { - if (__label__ == 44) { - while (1) { - var $bits_3; - var $hold_3; - var $have_3; - var $next_3; - if (!($bits_3 >>> 0 < 32)) { - break; - } - if (($have_3 | 0) == 0) { - var $ret_8 = $ret_0; - var $next_58 = $next_3; - var $have_58 = 0; - var $hold_54 = $hold_3; - var $bits_54 = $bits_3; - var $out_4 = $out_0; - break $_$12; - } - var $add176 = ((HEAPU8[$next_3] & 255) << $bits_3) + $hold_3 | 0; - var $next_3 = $next_3 + 1 | 0; - var $have_3 = $have_3 - 1 | 0; - var $hold_3 = $add176; - var $bits_3 = $bits_3 + 8 | 0; - } - var $63 = HEAP32[$18 >> 2]; - if (!(($63 | 0) == 0)) { - HEAP32[($63 + 4 | 0) >> 2] = $hold_3; - } - if (!((HEAP32[$17 >> 2] & 512 | 0) == 0)) { - HEAP8[$arrayidx] = $hold_3 & 255; - HEAP8[$arrayidx40] = $hold_3 >>> 8 & 255; - HEAP8[$arrayidx199] = $hold_3 >>> 16 & 255; - HEAP8[$arrayidx202] = $hold_3 >>> 24 & 255; - HEAP32[$16 >> 2] = _crc32(HEAP32[$16 >> 2], $arrayidx, 4); - } - HEAP32[$mode >> 2] = 3; - var $next_4 = $next_3; - var $have_4 = $have_3; - var $hold_4 = 0; - var $bits_4 = 0; - __label__ = 52; + var $83; + if (!(($83 & 512 | 0) == 0)) { + HEAP32[$16 >> 2] = _crc32(HEAP32[$16 >> 2], $next_8, $copy_0); + } + var $sub364 = HEAP32[$21 >> 2] - $copy_0 | 0; + HEAP32[$21 >> 2] = $sub364; + var $next_9 = $next_8 + $copy_0 | 0; + var $have_9 = $have_8 - $copy_0 | 0; + var $87 = $sub364; + var $86 = $83; + } + var $86; + var $87; + var $have_9; + var $next_9; + if (!(($87 | 0) == 0)) { + var $ret_8 = $ret_0; + var $next_58 = $next_9; + var $have_58 = $have_9; + var $hold_54 = $hold_8; + var $bits_54 = $bits_8; + var $out_4 = $out_0; + break $_$12; + } + var $next_10 = $next_9; + var $have_10 = $have_9; + var $88 = $86; + } + var $88; + var $have_10; + var $next_10; + HEAP32[$21 >> 2] = 0; + HEAP32[$mode >> 2] = 6; + var $next_11 = $next_10; + var $have_11 = $have_10; + var $hold_9 = $hold_8; + var $bits_9 = $bits_8; + var $89 = $88; + __label__ = 81; + break; + } else if (__label__ == 206) { + var $bits_34; + var $hold_34; + var $have_38; + var $next_38; + var $ret_3; + if ($have_38 >>> 0 > 5 & $left_0 >>> 0 > 257) { + HEAP32[$next_out >> 2] = $put_0; + HEAP32[$avail_out >> 2] = $left_0; + HEAP32[$next_in >> 2] = $next_38; + HEAP32[$avail_in15 >> 2] = $have_38; + HEAP32[$11 >> 2] = $hold_34; + HEAP32[$13 >> 2] = $bits_34; + _inflate_fast($strm, $out_0); + var $144 = HEAP32[$next_out >> 2]; + var $145 = HEAP32[$avail_out >> 2]; + var $146 = HEAP32[$next_in >> 2]; + var $147 = HEAP32[$avail_in15 >> 2]; + var $148 = HEAP32[$11 >> 2]; + var $149 = HEAP32[$13 >> 2]; + if (!((HEAP32[$mode >> 2] | 0) == 11)) { + var $ret_0_be = $ret_3; + var $next_0_be = $146; + var $put_0_be = $144; + var $have_0_be = $147; + var $left_0_be = $145; + var $hold_0_be = $148; + var $bits_0_be = $149; + var $out_0_be = $out_0; + __label__ = 268; + break; + } + HEAP32[$25 >> 2] = -1; + var $ret_0_be = $ret_3; + var $next_0_be = $146; + var $put_0_be = $144; + var $have_0_be = $147; + var $left_0_be = $145; + var $hold_0_be = $148; + var $bits_0_be = $149; + var $out_0_be = $out_0; + __label__ = 268; + break; + } + HEAP32[$25 >> 2] = 0; + var $sub1213 = (1 << HEAP32[$26 >> 2]) - 1 | 0; + var $152 = HEAPU32[$27 >> 2]; + var $next_39 = $next_38; + var $have_39 = $have_38; + var $hold_35 = $hold_34; + var $bits_35 = $bits_34; + while (1) { + var $bits_35; + var $hold_35; + var $have_39; + var $next_39; + var $and1214 = $sub1213 & $hold_35; + var $tmp22 = HEAPU8[$152 + ($and1214 << 2) + 1 | 0]; + var $conv1218 = $tmp22 & 255; + if (!($conv1218 >>> 0 > $bits_35 >>> 0)) { + break; + } + if (($have_39 | 0) == 0) { + var $ret_8 = $ret_3; + var $next_58 = $next_39; + var $have_58 = 0; + var $hold_54 = $hold_35; + var $bits_54 = $bits_35; + var $out_4 = $out_0; + break $_$12; + } + var $add1232 = ((HEAPU8[$next_39] & 255) << $bits_35) + $hold_35 | 0; + var $next_39 = $next_39 + 1 | 0; + var $have_39 = $have_39 - 1 | 0; + var $hold_35 = $add1232; + var $bits_35 = $bits_35 + 8 | 0; + } + var $tmp21 = HEAPU8[$152 + ($and1214 << 2) | 0]; + var $tmp23 = HEAPU16[($152 + ($and1214 << 2) + 2 | 0) >> 1]; + var $conv1237 = $tmp21 & 255; + do { + if ($tmp21 << 24 >> 24 == 0) { + var $next_41 = $next_39; + var $have_41 = $have_39; + var $hold_37 = $hold_35; + var $bits_37 = $bits_35; + var $here_09_0 = 0; + var $here_110_0 = $tmp22; + var $here_211_0 = $tmp23; + var $155 = 0; + } else { + if (!(($conv1237 & 240 | 0) == 0)) { + var $next_41 = $next_39; + var $have_41 = $have_39; + var $hold_37 = $hold_35; + var $bits_37 = $bits_35; + var $here_09_0 = $tmp21; + var $here_110_0 = $tmp22; + var $here_211_0 = $tmp23; + var $155 = 0; + break; + } + var $conv1248 = $tmp23 & 65535; + var $sub1255 = (1 << ($conv1218 + $conv1237 | 0)) - 1 | 0; + var $next_40 = $next_39; + var $have_40 = $have_39; + var $hold_36 = $hold_35; + var $bits_36 = $bits_35; + while (1) { + var $bits_36; + var $hold_36; + var $have_40; + var $next_40; + var $add1260 = (($hold_36 & $sub1255) >>> ($conv1218 >>> 0)) + $conv1248 | 0; + var $tmp19 = HEAPU8[$152 + ($add1260 << 2) + 1 | 0]; + if (!((($tmp19 & 255) + $conv1218 | 0) >>> 0 > $bits_36 >>> 0)) { + break; + } + if (($have_40 | 0) == 0) { + var $ret_8 = $ret_3; + var $next_58 = $next_40; + var $have_58 = 0; + var $hold_54 = $hold_36; + var $bits_54 = $bits_36; + var $out_4 = $out_0; + break $_$12; + } + var $add1281 = ((HEAPU8[$next_40] & 255) << $bits_36) + $hold_36 | 0; + var $next_40 = $next_40 + 1 | 0; + var $have_40 = $have_40 - 1 | 0; + var $hold_36 = $add1281; + var $bits_36 = $bits_36 + 8 | 0; + } + var $tmp20 = HEAP16[($152 + ($add1260 << 2) + 2 | 0) >> 1]; + var $tmp18 = HEAP8[$152 + ($add1260 << 2) | 0]; + HEAP32[$25 >> 2] = $conv1218; + var $next_41 = $next_40; + var $have_41 = $have_40; + var $hold_37 = $hold_36 >>> ($conv1218 >>> 0); + var $bits_37 = $bits_36 - $conv1218 | 0; + var $here_09_0 = $tmp18; + var $here_110_0 = $tmp19; + var $here_211_0 = $tmp20; + var $155 = $conv1218; + } + } while (0); + var $155; + var $here_211_0; + var $here_110_0; + var $here_09_0; + var $bits_37; + var $hold_37; + var $have_41; + var $next_41; + var $conv1302 = $here_110_0 & 255; + var $shr1303 = $hold_37 >>> ($conv1302 >>> 0); + var $sub1306 = $bits_37 - $conv1302 | 0; + HEAP32[$25 >> 2] = $155 + $conv1302 | 0; + HEAP32[$21 >> 2] = $here_211_0 & 65535; + var $conv1317 = $here_09_0 & 255; + if ($here_09_0 << 24 >> 24 == 0) { + HEAP32[$mode >> 2] = 25; + var $ret_0_be = $ret_3; + var $next_0_be = $next_41; + var $put_0_be = $put_0; + var $have_0_be = $have_41; + var $left_0_be = $left_0; + var $hold_0_be = $shr1303; + var $bits_0_be = $sub1306; + var $out_0_be = $out_0; + __label__ = 268; + break; + } + if (!(($conv1317 & 32 | 0) == 0)) { + HEAP32[$25 >> 2] = -1; + HEAP32[$mode >> 2] = 11; + var $ret_0_be = $ret_3; + var $next_0_be = $next_41; + var $put_0_be = $put_0; + var $have_0_be = $have_41; + var $left_0_be = $left_0; + var $hold_0_be = $shr1303; + var $bits_0_be = $sub1306; + var $out_0_be = $out_0; + __label__ = 268; + break; + } + if (($conv1317 & 64 | 0) == 0) { + var $and1341 = $conv1317 & 15; + HEAP32[$28 >> 2] = $and1341; + HEAP32[$mode >> 2] = 21; + var $ret_4 = $ret_3; + var $next_42 = $next_41; + var $have_42 = $have_41; + var $hold_38 = $shr1303; + var $bits_38 = $sub1306; + var $156 = $and1341; + __label__ = 227; + break; + } + HEAP32[$msg >> 2] = STRING_TABLE.__str2171 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $ret_3; + var $next_0_be = $next_41; + var $put_0_be = $put_0; + var $have_0_be = $have_41; + var $left_0_be = $left_0; + var $hold_0_be = $shr1303; + var $bits_0_be = $sub1306; + var $out_0_be = $out_0; + __label__ = 268; + break; + } + } while (0); + do { + if (__label__ == 81) { + var $89; + var $bits_9; + var $hold_9; + var $have_11; + var $next_11; + do { + if (($89 & 2048 | 0) == 0) { + var $98 = HEAP32[$18 >> 2]; + if (($98 | 0) == 0) { + var $next_12 = $next_11; + var $have_12 = $have_11; + break; + } + HEAP32[($98 + 28 | 0) >> 2] = 0; + var $next_12 = $next_11; + var $have_12 = $have_11; + } else { + if (($have_11 | 0) == 0) { + var $ret_8 = $ret_0; + var $next_58 = $next_11; + var $have_58 = 0; + var $hold_54 = $hold_9; + var $bits_54 = $bits_9; + var $out_4 = $out_0; + break $_$12; + } + var $copy_1 = 0; + while (1) { + var $copy_1; + var $inc = $copy_1 + 1 | 0; + var $90 = HEAP8[$next_11 + $copy_1 | 0]; + var $91 = HEAP32[$18 >> 2]; + do { + if (!(($91 | 0) == 0)) { + var $name = $91 + 28 | 0; + if ((HEAP32[$name >> 2] | 0) == 0) { break; - } else if (__label__ == 120) { - var $bits_15; - var $hold_15; - var $have_19; - var $next_19; - if ((HEAP32[$22 >> 2] | 0) == 0) { - HEAP32[$next_out >> 2] = $put_0; - HEAP32[$avail_out >> 2] = $left_0; - HEAP32[$next_in >> 2] = $next_19; - HEAP32[$avail_in15 >> 2] = $have_19; - HEAP32[$11 >> 2] = $hold_15; - HEAP32[$13 >> 2] = $bits_15; - var $retval_0 = 2; - break $_$2; - } - var $call602 = _adler32(0, 0, 0); - HEAP32[$16 >> 2] = $call602; - HEAP32[$adler >> 2] = $call602; - HEAP32[$mode >> 2] = 11; - var $next_20 = $next_19; - var $have_20 = $have_19; - var $hold_16 = $hold_15; - var $bits_16 = $bits_15; - __label__ = 123; + } + var $93 = HEAPU32[$21 >> 2]; + if (!($93 >>> 0 < HEAPU32[($91 + 32 | 0) >> 2] >>> 0)) { break; - } else if (__label__ == 143) { - var $bits_20; - var $hold_20; - var $have_24; - var $next_24; - HEAP32[$mode >> 2] = 15; - var $next_25 = $next_24; - var $have_25 = $have_24; - var $hold_21 = $hold_20; - var $bits_21 = $bits_20; - __label__ = 144; + } + HEAP32[$21 >> 2] = $93 + 1 | 0; + HEAP8[HEAP32[$name >> 2] + $93 | 0] = $90; + } + } while (0); + var $tobool405 = $90 << 24 >> 24 != 0; + if (!($tobool405 & $inc >>> 0 < $have_11 >>> 0)) { + break; + } + var $copy_1 = $inc; + } + if (!((HEAP32[$17 >> 2] & 512 | 0) == 0)) { + HEAP32[$16 >> 2] = _crc32(HEAP32[$16 >> 2], $next_11, $inc); + } + var $sub417 = $have_11 - $inc | 0; + var $add_ptr418 = $next_11 + $inc | 0; + if ($tobool405) { + var $ret_8 = $ret_0; + var $next_58 = $add_ptr418; + var $have_58 = $sub417; + var $hold_54 = $hold_9; + var $bits_54 = $bits_9; + var $out_4 = $out_0; + break $_$12; + } + var $next_12 = $add_ptr418; + var $have_12 = $sub417; + } + } while (0); + var $have_12; + var $next_12; + HEAP32[$21 >> 2] = 0; + HEAP32[$mode >> 2] = 7; + var $next_13 = $next_12; + var $have_13 = $have_12; + var $hold_10 = $hold_9; + var $bits_10 = $bits_9; + __label__ = 94; + break; + } else if (__label__ == 227) { + var $156; + var $bits_38; + var $hold_38; + var $have_42; + var $next_42; + var $ret_4; + if (($156 | 0) == 0) { + var $next_44 = $next_42; + var $have_44 = $have_42; + var $hold_40 = $hold_38; + var $bits_40 = $bits_38; + var $160 = HEAP32[$21 >> 2]; + } else { + var $next_43 = $next_42; + var $have_43 = $have_42; + var $hold_39 = $hold_38; + var $bits_39 = $bits_38; + while (1) { + var $bits_39; + var $hold_39; + var $have_43; + var $next_43; + if (!($bits_39 >>> 0 < $156 >>> 0)) { + break; + } + if (($have_43 | 0) == 0) { + var $ret_8 = $ret_4; + var $next_58 = $next_43; + var $have_58 = 0; + var $hold_54 = $hold_39; + var $bits_54 = $bits_39; + var $out_4 = $out_0; + break $_$12; + } + var $add1363 = ((HEAPU8[$next_43] & 255) << $bits_39) + $hold_39 | 0; + var $next_43 = $next_43 + 1 | 0; + var $have_43 = $have_43 - 1 | 0; + var $hold_39 = $add1363; + var $bits_39 = $bits_39 + 8 | 0; + } + var $add1375 = HEAP32[$21 >> 2] + (((1 << $156) - 1 | 0) & $hold_39) | 0; + HEAP32[$21 >> 2] = $add1375; + HEAP32[$25 >> 2] = HEAP32[$25 >> 2] + $156 | 0; + var $next_44 = $next_43; + var $have_44 = $have_43; + var $hold_40 = $hold_39 >>> ($156 >>> 0); + var $bits_40 = $bits_39 - $156 | 0; + var $160 = $add1375; + } + var $160; + var $bits_40; + var $hold_40; + var $have_44; + var $next_44; + HEAP32[$29 >> 2] = $160; + HEAP32[$mode >> 2] = 22; + var $ret_5_ph = $ret_4; + var $next_45_ph = $next_44; + var $have_45_ph = $have_44; + var $hold_41_ph = $hold_40; + var $bits_41_ph = $bits_40; + __label__ = 234; + break; + } + } while (0); + do { + if (__label__ == 94) { + var $bits_10; + var $hold_10; + var $have_13; + var $next_13; + do { + if ((HEAP32[$17 >> 2] & 4096 | 0) == 0) { + var $108 = HEAP32[$18 >> 2]; + if (($108 | 0) == 0) { + var $next_14 = $next_13; + var $have_14 = $have_13; + break; + } + HEAP32[($108 + 36 | 0) >> 2] = 0; + var $next_14 = $next_13; + var $have_14 = $have_13; + } else { + if (($have_13 | 0) == 0) { + var $ret_8 = $ret_0; + var $next_58 = $next_13; + var $have_58 = 0; + var $hold_54 = $hold_10; + var $bits_54 = $bits_10; + var $out_4 = $out_0; + break $_$12; + } + var $copy_2 = 0; + while (1) { + var $copy_2; + var $inc443 = $copy_2 + 1 | 0; + var $100 = HEAP8[$next_13 + $copy_2 | 0]; + var $101 = HEAP32[$18 >> 2]; + do { + if (!(($101 | 0) == 0)) { + var $comment = $101 + 36 | 0; + if ((HEAP32[$comment >> 2] | 0) == 0) { break; - } else if (__label__ == 154) { - while (1) { - var $bits_23; - var $hold_23; - var $have_27; - var $next_27; - var $122 = HEAPU32[$40 >> 2]; - if (!($122 >>> 0 < HEAPU32[$39 >> 2] >>> 0)) { - break; - } - var $next_28 = $next_27; - var $have_28 = $have_27; - var $hold_24 = $hold_23; - var $bits_24 = $bits_23; - while (1) { - var $bits_24; - var $hold_24; - var $have_28; - var $next_28; - if (!($bits_24 >>> 0 < 3)) { - break; - } - if (($have_28 | 0) == 0) { - var $ret_8 = $ret_0; - var $next_58 = $next_28; - var $have_58 = 0; - var $hold_54 = $hold_24; - var $bits_54 = $bits_24; - var $out_4 = $out_0; - break $_$12; - } - var $add829 = ((HEAPU8[$next_28] & 255) << $bits_24) + $hold_24 | 0; - var $next_28 = $next_28 + 1 | 0; - var $have_28 = $have_28 - 1 | 0; - var $hold_24 = $add829; - var $bits_24 = $bits_24 + 8 | 0; - } - HEAP32[$40 >> 2] = $122 + 1 | 0; - HEAP16[($41 + ((HEAPU16[(_inflate_order + ($122 << 1) | 0) >> 1] & 65535) << 1) | 0) >> 1] = $hold_24 & 65535 & 7; - var $next_27 = $next_28; - var $have_27 = $have_28; - var $hold_23 = $hold_24 >>> 3; - var $bits_23 = $bits_24 - 3 | 0; - } - $_$131 : do { - if ($122 >>> 0 < 19) { - var $126 = $122; - while (1) { - var $126; - HEAP32[$40 >> 2] = $126 + 1 | 0; - HEAP16[($41 + ((HEAPU16[(_inflate_order + ($126 << 1) | 0) >> 1] & 65535) << 1) | 0) >> 1] = 0; - var $_pr = HEAPU32[$40 >> 2]; - if (!($_pr >>> 0 < 19)) { - break $_$131; - } - var $126 = $_pr; - } - } - } while (0); - HEAP32[$43 >> 2] = $arraydecay860_c; - HEAP32[$44 >> 2] = $arraydecay860_c; - HEAP32[$26 >> 2] = 7; - var $call868 = _inflate_table(0, $arraydecay864, 19, $42, $26, $arraydecay867); - if (($call868 | 0) == 0) { - HEAP32[$40 >> 2] = 0; - HEAP32[$mode >> 2] = 18; - var $ret_1_ph = 0; - var $next_29_ph = $next_27; - var $have_29_ph = $have_27; - var $hold_25_ph = $hold_23; - var $bits_25_ph = $bits_23; - __label__ = 164; - break; - } - HEAP32[$msg >> 2] = STRING_TABLE.__str9106 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $call868; - var $next_0_be = $next_27; - var $put_0_be = $put_0; - var $have_0_be = $have_27; - var $left_0_be = $left_0; - var $hold_0_be = $hold_23; - var $bits_0_be = $bits_23; - var $out_0_be = $out_0; - __label__ = 268; - break; - } else if (__label__ == 286) { - var $out_2; - var $bits_50; - var $hold_50; - var $have_54; - var $next_54; - do { - if (!((HEAP32[$15 >> 2] | 0) == 0)) { - if ((HEAP32[$17 >> 2] | 0) == 0) { - var $next_56 = $next_54; - var $have_56 = $have_54; - var $hold_52 = $hold_50; - var $bits_52 = $bits_50; - break; - } - var $next_55 = $next_54; - var $have_55 = $have_54; - var $hold_51 = $hold_50; - var $bits_51 = $bits_50; - while (1) { - var $bits_51; - var $hold_51; - var $have_55; - var $next_55; - if (!($bits_51 >>> 0 < 32)) { - break; - } - if (($have_55 | 0) == 0) { - var $ret_8 = $ret_0; - var $next_58 = $next_55; - var $have_58 = 0; - var $hold_54 = $hold_51; - var $bits_54 = $bits_51; - var $out_4 = $out_2; - break $_$12; - } - var $add1721 = ((HEAPU8[$next_55] & 255) << $bits_51) + $hold_51 | 0; - var $next_55 = $next_55 + 1 | 0; - var $have_55 = $have_55 - 1 | 0; - var $hold_51 = $add1721; - var $bits_51 = $bits_51 + 8 | 0; - } - if (($hold_51 | 0) == (HEAP32[$36 >> 2] | 0)) { - var $next_56 = $next_55; - var $have_56 = $have_55; - var $hold_52 = 0; - var $bits_52 = 0; - break; - } - HEAP32[$msg >> 2] = STRING_TABLE.__str18115 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $ret_0; - var $next_0_be = $next_55; - var $put_0_be = $put_0; - var $have_0_be = $have_55; - var $left_0_be = $left_0; - var $hold_0_be = $hold_51; - var $bits_0_be = $bits_51; - var $out_0_be = $out_2; - __label__ = 268; - break $_$106; - } - var $next_56 = $next_54; - var $have_56 = $have_54; - var $hold_52 = $hold_50; - var $bits_52 = $bits_50; - } while (0); - var $bits_52; - var $hold_52; - var $have_56; - var $next_56; - HEAP32[$mode >> 2] = 28; - var $ret_8 = 1; - var $next_58 = $next_56; - var $have_58 = $have_56; - var $hold_54 = $hold_52; - var $bits_54 = $bits_52; - var $out_4 = $out_2; - break $_$12; - } - } while (0); - $_$148 : do { - if (__label__ == 52) { - while (1) { - var $bits_4; - var $hold_4; - var $have_4; - var $next_4; - if (!($bits_4 >>> 0 < 16)) { - break; - } - if (($have_4 | 0) == 0) { - var $ret_8 = $ret_0; - var $next_58 = $next_4; - var $have_58 = 0; - var $hold_54 = $hold_4; - var $bits_54 = $bits_4; - var $out_4 = $out_0; - break $_$12; - } - var $add227 = ((HEAPU8[$next_4] & 255) << $bits_4) + $hold_4 | 0; - var $next_4 = $next_4 + 1 | 0; - var $have_4 = $have_4 - 1 | 0; - var $hold_4 = $add227; - var $bits_4 = $bits_4 + 8 | 0; - } - var $67 = HEAP32[$18 >> 2]; - if (!(($67 | 0) == 0)) { - HEAP32[($67 + 8 | 0) >> 2] = $hold_4 & 255; - HEAP32[(HEAP32[$18 >> 2] + 12 | 0) >> 2] = $hold_4 >>> 8; - } - if (!((HEAP32[$17 >> 2] & 512 | 0) == 0)) { - HEAP8[$arrayidx] = $hold_4 & 255; - HEAP8[$arrayidx40] = $hold_4 >>> 8 & 255; - HEAP32[$16 >> 2] = _crc32(HEAP32[$16 >> 2], $arrayidx, 2); - } - HEAP32[$mode >> 2] = 4; - var $next_5 = $next_4; - var $have_5 = $have_4; - var $hold_5 = 0; - var $bits_5 = 0; - __label__ = 60; - break; - } else if (__label__ == 123) { - var $bits_16; - var $hold_16; - var $have_20; - var $next_20; - if ($23) { - var $ret_8 = $ret_0; - var $next_58 = $next_20; - var $have_58 = $have_20; - var $hold_54 = $hold_16; - var $bits_54 = $bits_16; - var $out_4 = $out_0; - break $_$12; - } - var $next_21 = $next_20; - var $have_21 = $have_20; - var $hold_17 = $hold_16; - var $bits_17 = $bits_16; - __label__ = 124; - break; - } else if (__label__ == 144) { - var $bits_21; - var $hold_21; - var $have_25; - var $next_25; - var $119 = HEAPU32[$21 >> 2]; - if (($119 | 0) == 0) { - HEAP32[$mode >> 2] = 11; - var $ret_0_be = $ret_0; - var $next_0_be = $next_25; - var $put_0_be = $put_0; - var $have_0_be = $have_25; - var $left_0_be = $left_0; - var $hold_0_be = $hold_21; - var $bits_0_be = $bits_21; - var $out_0_be = $out_0; - __label__ = 268; - break; - } - var $copy_3 = $119 >>> 0 > $have_25 >>> 0 ? $have_25 : $119; - var $copy_4 = $copy_3 >>> 0 > $left_0 >>> 0 ? $left_0 : $copy_3; - if (($copy_4 | 0) == 0) { - var $ret_8 = $ret_0; - var $next_58 = $next_25; - var $have_58 = $have_25; - var $hold_54 = $hold_21; - var $bits_54 = $bits_21; - var $out_4 = $out_0; - break $_$12; - } - _memcpy($put_0, $next_25, $copy_4, 1); - HEAP32[$21 >> 2] = HEAP32[$21 >> 2] - $copy_4 | 0; - var $ret_0_be = $ret_0; - var $next_0_be = $next_25 + $copy_4 | 0; - var $put_0_be = $put_0 + $copy_4 | 0; - var $have_0_be = $have_25 - $copy_4 | 0; - var $left_0_be = $left_0 - $copy_4 | 0; - var $hold_0_be = $hold_21; - var $bits_0_be = $bits_21; - var $out_0_be = $out_0; - __label__ = 268; - break; - } else if (__label__ == 164) { - var $bits_25_ph; - var $hold_25_ph; - var $have_29_ph; - var $next_29_ph; - var $ret_1_ph; - var $next_29 = $next_29_ph; - var $have_29 = $have_29_ph; - var $hold_25 = $hold_25_ph; - var $bits_25 = $bits_25_ph; - $_$167 : while (1) { - var $bits_25; - var $hold_25; - var $have_29; - var $next_29; - var $128 = HEAPU32[$40 >> 2]; - var $129 = HEAPU32[$37 >> 2]; - var $add881 = HEAP32[$38 >> 2] + $129 | 0; - if ($128 >>> 0 < $add881 >>> 0) { - var $sub888 = (1 << HEAP32[$26 >> 2]) - 1 | 0; - var $132 = HEAPU32[$27 >> 2]; - var $next_30 = $next_29; - var $have_30 = $have_29; - var $hold_26 = $hold_25; - var $bits_26 = $bits_25; - while (1) { - var $bits_26; - var $hold_26; - var $have_30; - var $next_30; - var $and889 = $sub888 & $hold_26; - var $conv893 = HEAPU8[$132 + ($and889 << 2) + 1 | 0] & 255; - if (!($conv893 >>> 0 > $bits_26 >>> 0)) { - break; - } - if (($have_30 | 0) == 0) { - var $ret_8 = $ret_1_ph; - var $next_58 = $next_30; - var $have_58 = 0; - var $hold_54 = $hold_26; - var $bits_54 = $bits_26; - var $out_4 = $out_0; - break $_$12; - } - var $add907 = ((HEAPU8[$next_30] & 255) << $bits_26) + $hold_26 | 0; - var $next_30 = $next_30 + 1 | 0; - var $have_30 = $have_30 - 1 | 0; - var $hold_26 = $add907; - var $bits_26 = $bits_26 + 8 | 0; - } - var $tmp26 = HEAPU16[($132 + ($and889 << 2) + 2 | 0) >> 1]; - if (($tmp26 & 65535) < 16) { - var $next_31 = $next_30; - var $have_31 = $have_30; - var $hold_27 = $hold_26; - var $bits_27 = $bits_26; - while (1) { - var $bits_27; - var $hold_27; - var $have_31; - var $next_31; - if (!($bits_27 >>> 0 < $conv893 >>> 0)) { - break; - } - if (($have_31 | 0) == 0) { - var $ret_8 = $ret_1_ph; - var $next_58 = $next_31; - var $have_58 = 0; - var $hold_54 = $hold_27; - var $bits_54 = $bits_27; - var $out_4 = $out_0; - break $_$12; - } - var $add931 = ((HEAPU8[$next_31] & 255) << $bits_27) + $hold_27 | 0; - var $next_31 = $next_31 + 1 | 0; - var $have_31 = $have_31 - 1 | 0; - var $hold_27 = $add931; - var $bits_27 = $bits_27 + 8 | 0; - } - HEAP32[$40 >> 2] = $128 + 1 | 0; - HEAP16[($41 + ($128 << 1) | 0) >> 1] = $tmp26; - var $next_29 = $next_31; - var $have_29 = $have_31; - var $hold_25 = $hold_27 >>> ($conv893 >>> 0); - var $bits_25 = $bits_27 - $conv893 | 0; - } else { - if ($tmp26 << 16 >> 16 == 16) { - var $add962 = $conv893 + 2 | 0; - var $next_32 = $next_30; - var $have_32 = $have_30; - var $hold_28 = $hold_26; - var $bits_28 = $bits_26; - while (1) { - var $bits_28; - var $hold_28; - var $have_32; - var $next_32; - if (!($bits_28 >>> 0 < $add962 >>> 0)) { - break; - } - if (($have_32 | 0) == 0) { - var $ret_8 = $ret_1_ph; - var $next_58 = $next_32; - var $have_58 = 0; - var $hold_54 = $hold_28; - var $bits_54 = $bits_28; - var $out_4 = $out_0; - break $_$12; - } - var $add975 = ((HEAPU8[$next_32] & 255) << $bits_28) + $hold_28 | 0; - var $next_32 = $next_32 + 1 | 0; - var $have_32 = $have_32 - 1 | 0; - var $hold_28 = $add975; - var $bits_28 = $bits_28 + 8 | 0; - } - var $shr985 = $hold_28 >>> ($conv893 >>> 0); - var $sub988 = $bits_28 - $conv893 | 0; - if (($128 | 0) == 0) { - HEAP32[$msg >> 2] = STRING_TABLE.__str10107 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $ret_1_ph; - var $next_0_be = $next_32; - var $put_0_be = $put_0; - var $have_0_be = $have_32; - var $left_0_be = $left_0; - var $hold_0_be = $shr985; - var $bits_0_be = $sub988; - var $out_0_be = $out_0; - __label__ = 268; - break $_$148; - } - var $len_0 = HEAP16[($41 + (($128 - 1 | 0) << 1) | 0) >> 1]; - var $next_35 = $next_32; - var $have_35 = $have_32; - var $hold_31 = $shr985 >>> 2; - var $bits_31 = $sub988 - 2 | 0; - var $copy_5 = ($shr985 & 3) + 3 | 0; - } else if ($tmp26 << 16 >> 16 == 17) { - var $add1020 = $conv893 + 3 | 0; - var $next_33 = $next_30; - var $have_33 = $have_30; - var $hold_29 = $hold_26; - var $bits_29 = $bits_26; - while (1) { - var $bits_29; - var $hold_29; - var $have_33; - var $next_33; - if (!($bits_29 >>> 0 < $add1020 >>> 0)) { - break; - } - if (($have_33 | 0) == 0) { - var $ret_8 = $ret_1_ph; - var $next_58 = $next_33; - var $have_58 = 0; - var $hold_54 = $hold_29; - var $bits_54 = $bits_29; - var $out_4 = $out_0; - break $_$12; - } - var $add1033 = ((HEAPU8[$next_33] & 255) << $bits_29) + $hold_29 | 0; - var $next_33 = $next_33 + 1 | 0; - var $have_33 = $have_33 - 1 | 0; - var $hold_29 = $add1033; - var $bits_29 = $bits_29 + 8 | 0; - } - var $shr1043 = $hold_29 >>> ($conv893 >>> 0); - var $len_0 = 0; - var $next_35 = $next_33; - var $have_35 = $have_33; - var $hold_31 = $shr1043 >>> 3; - var $bits_31 = (-3 - $conv893 | 0) + $bits_29 | 0; - var $copy_5 = ($shr1043 & 7) + 3 | 0; - } else { - var $add1061 = $conv893 + 7 | 0; - var $next_34 = $next_30; - var $have_34 = $have_30; - var $hold_30 = $hold_26; - var $bits_30 = $bits_26; - while (1) { - var $bits_30; - var $hold_30; - var $have_34; - var $next_34; - if (!($bits_30 >>> 0 < $add1061 >>> 0)) { - break; - } - if (($have_34 | 0) == 0) { - var $ret_8 = $ret_1_ph; - var $next_58 = $next_34; - var $have_58 = 0; - var $hold_54 = $hold_30; - var $bits_54 = $bits_30; - var $out_4 = $out_0; - break $_$12; - } - var $add1074 = ((HEAPU8[$next_34] & 255) << $bits_30) + $hold_30 | 0; - var $next_34 = $next_34 + 1 | 0; - var $have_34 = $have_34 - 1 | 0; - var $hold_30 = $add1074; - var $bits_30 = $bits_30 + 8 | 0; - } - var $shr1084 = $hold_30 >>> ($conv893 >>> 0); - var $len_0 = 0; - var $next_35 = $next_34; - var $have_35 = $have_34; - var $hold_31 = $shr1084 >>> 7; - var $bits_31 = (-7 - $conv893 | 0) + $bits_30 | 0; - var $copy_5 = ($shr1084 & 127) + 11 | 0; - } - var $copy_5; - var $bits_31; - var $hold_31; - var $have_35; - var $next_35; - var $len_0; - if (($128 + $copy_5 | 0) >>> 0 > $add881 >>> 0) { - HEAP32[$msg >> 2] = STRING_TABLE.__str10107 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $ret_1_ph; - var $next_0_be = $next_35; - var $put_0_be = $put_0; - var $have_0_be = $have_35; - var $left_0_be = $left_0; - var $hold_0_be = $hold_31; - var $bits_0_be = $bits_31; - var $out_0_be = $out_0; - __label__ = 268; - break $_$148; - } - var $copy_6127 = $copy_5; - var $139 = $128; - while (1) { - var $139; - var $copy_6127; - var $dec1111 = $copy_6127 - 1 | 0; - HEAP32[$40 >> 2] = $139 + 1 | 0; - HEAP16[($41 + ($139 << 1) | 0) >> 1] = $len_0; - if (($dec1111 | 0) == 0) { - var $next_29 = $next_35; - var $have_29 = $have_35; - var $hold_25 = $hold_31; - var $bits_25 = $bits_31; - continue $_$167; - } - var $copy_6127 = $dec1111; - var $139 = HEAP32[$40 >> 2]; - } - } - } else { - if ((HEAP32[$mode >> 2] | 0) == 29) { - var $ret_0_be = $ret_1_ph; - var $next_0_be = $next_29; - var $put_0_be = $put_0; - var $have_0_be = $have_29; - var $left_0_be = $left_0; - var $hold_0_be = $hold_25; - var $bits_0_be = $bits_25; - var $out_0_be = $out_0; - __label__ = 268; - break $_$148; - } - if (HEAP16[$45 >> 1] << 16 >> 16 == 0) { - HEAP32[$msg >> 2] = STRING_TABLE.__str11108 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $ret_1_ph; - var $next_0_be = $next_29; - var $put_0_be = $put_0; - var $have_0_be = $have_29; - var $left_0_be = $left_0; - var $hold_0_be = $hold_25; - var $bits_0_be = $bits_25; - var $out_0_be = $out_0; - __label__ = 268; - break $_$148; - } - HEAP32[$43 >> 2] = $arraydecay860_c; - HEAP32[$44 >> 2] = $arraydecay860_c; - HEAP32[$26 >> 2] = 9; - var $call1149 = _inflate_table(1, $arraydecay864, $129, $42, $26, $arraydecay867); - if (!(($call1149 | 0) == 0)) { - HEAP32[$msg >> 2] = STRING_TABLE.__str12109 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $call1149; - var $next_0_be = $next_29; - var $put_0_be = $put_0; - var $have_0_be = $have_29; - var $left_0_be = $left_0; - var $hold_0_be = $hold_25; - var $bits_0_be = $bits_25; - var $out_0_be = $out_0; - __label__ = 268; - break $_$148; - } - HEAP32[$46 >> 2] = HEAP32[$42 >> 2]; - HEAP32[$47 >> 2] = 6; - var $call1165 = _inflate_table(2, $arraydecay864 + (HEAP32[$37 >> 2] << 1) | 0, HEAP32[$38 >> 2], $42, $47, $arraydecay867); - if (!(($call1165 | 0) == 0)) { - HEAP32[$msg >> 2] = STRING_TABLE.__str13110 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $call1165; - var $next_0_be = $next_29; - var $put_0_be = $put_0; - var $have_0_be = $have_29; - var $left_0_be = $left_0; - var $hold_0_be = $hold_25; - var $bits_0_be = $bits_25; - var $out_0_be = $out_0; - __label__ = 268; - break $_$148; - } - HEAP32[$mode >> 2] = 19; - if ($cmp660) { - var $ret_8 = 0; - var $next_58 = $next_29; - var $have_58 = $have_29; - var $hold_54 = $hold_25; - var $bits_54 = $bits_25; - var $out_4 = $out_0; - break $_$12; - } - var $ret_2 = 0; - var $next_37 = $next_29; - var $have_37 = $have_29; - var $hold_33 = $hold_25; - var $bits_33 = $bits_25; - __label__ = 205; - break $_$148; - } - } - } - } while (0); - do { - if (__label__ == 60) { - var $bits_5; - var $hold_5; - var $have_5; - var $next_5; - var $71 = HEAPU32[$17 >> 2]; - do { - if (($71 & 1024 | 0) == 0) { - var $76 = HEAP32[$18 >> 2]; - if (($76 | 0) == 0) { - var $next_7 = $next_5; - var $have_7 = $have_5; - var $hold_7 = $hold_5; - var $bits_7 = $bits_5; - break; - } - HEAP32[($76 + 16 | 0) >> 2] = 0; - var $next_7 = $next_5; - var $have_7 = $have_5; - var $hold_7 = $hold_5; - var $bits_7 = $bits_5; - } else { - var $next_6 = $next_5; - var $have_6 = $have_5; - var $hold_6 = $hold_5; - var $bits_6 = $bits_5; - while (1) { - var $bits_6; - var $hold_6; - var $have_6; - var $next_6; - if (!($bits_6 >>> 0 < 16)) { - break; - } - if (($have_6 | 0) == 0) { - var $ret_8 = $ret_0; - var $next_58 = $next_6; - var $have_58 = 0; - var $hold_54 = $hold_6; - var $bits_54 = $bits_6; - var $out_4 = $out_0; - break $_$12; - } - var $add279 = ((HEAPU8[$next_6] & 255) << $bits_6) + $hold_6 | 0; - var $next_6 = $next_6 + 1 | 0; - var $have_6 = $have_6 - 1 | 0; - var $hold_6 = $add279; - var $bits_6 = $bits_6 + 8 | 0; - } - HEAP32[$21 >> 2] = $hold_6; - var $73 = HEAP32[$18 >> 2]; - if (($73 | 0) == 0) { - var $74 = $71; - } else { - HEAP32[($73 + 20 | 0) >> 2] = $hold_6; - var $74 = HEAP32[$17 >> 2]; - } - var $74; - if (($74 & 512 | 0) == 0) { - var $next_7 = $next_6; - var $have_7 = $have_6; - var $hold_7 = 0; - var $bits_7 = 0; - break; - } - HEAP8[$arrayidx] = $hold_6 & 255; - HEAP8[$arrayidx40] = $hold_6 >>> 8 & 255; - HEAP32[$16 >> 2] = _crc32(HEAP32[$16 >> 2], $arrayidx, 2); - var $next_7 = $next_6; - var $have_7 = $have_6; - var $hold_7 = 0; - var $bits_7 = 0; - } - } while (0); - var $bits_7; - var $hold_7; - var $have_7; - var $next_7; - HEAP32[$mode >> 2] = 5; - var $next_8 = $next_7; - var $have_8 = $have_7; - var $hold_8 = $hold_7; - var $bits_8 = $bits_7; - __label__ = 71; - break; - } else if (__label__ == 124) { - var $bits_17; - var $hold_17; - var $have_21; - var $next_21; - if ((HEAP32[$24 >> 2] | 0) == 0) { - var $next_22 = $next_21; - var $have_22 = $have_21; - var $hold_18 = $hold_17; - var $bits_18 = $bits_17; - while (1) { - var $bits_18; - var $hold_18; - var $have_22; - var $next_22; - if (!($bits_18 >>> 0 < 3)) { - break; - } - if (($have_22 | 0) == 0) { - var $ret_8 = $ret_0; - var $next_58 = $next_22; - var $have_58 = 0; - var $hold_54 = $hold_18; - var $bits_54 = $bits_18; - var $out_4 = $out_0; - break $_$12; - } - var $add641 = ((HEAPU8[$next_22] & 255) << $bits_18) + $hold_18 | 0; - var $next_22 = $next_22 + 1 | 0; - var $have_22 = $have_22 - 1 | 0; - var $hold_18 = $add641; - var $bits_18 = $bits_18 + 8 | 0; - } - HEAP32[$24 >> 2] = $hold_18 & 1; - var $and655 = $hold_18 >>> 1 & 3; - do { - if (($and655 | 0) == 0) { - HEAP32[$mode >> 2] = 13; - } else if (($and655 | 0) == 1) { - _fixedtables($4); - HEAP32[$mode >> 2] = 19; - if (!$cmp660) { - break; - } - var $ret_8 = $ret_0; - var $next_58 = $next_22; - var $have_58 = $have_22; - var $hold_54 = $hold_18 >>> 3; - var $bits_54 = $bits_18 - 3 | 0; - var $out_4 = $out_0; - break $_$12; - } else if (($and655 | 0) == 2) { - HEAP32[$mode >> 2] = 16; - } else if (($and655 | 0) == 3) { - HEAP32[$msg >> 2] = STRING_TABLE.__str6103 | 0; - HEAP32[$mode >> 2] = 29; - } - } while (0); - var $ret_0_be = $ret_0; - var $next_0_be = $next_22; - var $put_0_be = $put_0; - var $have_0_be = $have_22; - var $left_0_be = $left_0; - var $hold_0_be = $hold_18 >>> 3; - var $bits_0_be = $bits_18 - 3 | 0; - var $out_0_be = $out_0; - __label__ = 268; - break; - } - var $and619 = $bits_17 & 7; - HEAP32[$mode >> 2] = 26; - var $ret_0_be = $ret_0; - var $next_0_be = $next_21; - var $put_0_be = $put_0; - var $have_0_be = $have_21; - var $left_0_be = $left_0; - var $hold_0_be = $hold_17 >>> ($and619 >>> 0); - var $bits_0_be = $bits_17 - $and619 | 0; - var $out_0_be = $out_0; - __label__ = 268; - break; - } else if (__label__ == 205) { - var $bits_33; - var $hold_33; - var $have_37; - var $next_37; - var $ret_2; - HEAP32[$mode >> 2] = 20; - var $ret_3 = $ret_2; - var $next_38 = $next_37; - var $have_38 = $have_37; - var $hold_34 = $hold_33; - var $bits_34 = $bits_33; - __label__ = 206; - break; - } - } while (0); - do { - if (__label__ == 71) { - var $bits_8; - var $hold_8; - var $have_8; - var $next_8; - var $77 = HEAPU32[$17 >> 2]; - if (($77 & 1024 | 0) == 0) { - var $next_10 = $next_8; - var $have_10 = $have_8; - var $88 = $77; - } else { - var $78 = HEAPU32[$21 >> 2]; - var $copy_0 = $78 >>> 0 > $have_8 >>> 0 ? $have_8 : $78; - if (($copy_0 | 0) == 0) { - var $next_9 = $next_8; - var $have_9 = $have_8; - var $87 = $78; - var $86 = $77; - } else { - var $79 = HEAPU32[$18 >> 2]; - do { - if (($79 | 0) == 0) { - var $83 = $77; - } else { - var $80 = HEAP32[($79 + 16 | 0) >> 2]; - if (($80 | 0) == 0) { - var $83 = $77; - break; - } - var $sub341 = HEAP32[($79 + 20 | 0) >> 2] - $78 | 0; - var $82 = HEAPU32[($79 + 24 | 0) >> 2]; - _memcpy($80 + $sub341 | 0, $next_8, ($sub341 + $copy_0 | 0) >>> 0 > $82 >>> 0 ? $82 - $sub341 | 0 : $copy_0, 1); - var $83 = HEAP32[$17 >> 2]; - } - } while (0); - var $83; - if (!(($83 & 512 | 0) == 0)) { - HEAP32[$16 >> 2] = _crc32(HEAP32[$16 >> 2], $next_8, $copy_0); - } - var $sub364 = HEAP32[$21 >> 2] - $copy_0 | 0; - HEAP32[$21 >> 2] = $sub364; - var $next_9 = $next_8 + $copy_0 | 0; - var $have_9 = $have_8 - $copy_0 | 0; - var $87 = $sub364; - var $86 = $83; - } - var $86; - var $87; - var $have_9; - var $next_9; - if (!(($87 | 0) == 0)) { - var $ret_8 = $ret_0; - var $next_58 = $next_9; - var $have_58 = $have_9; - var $hold_54 = $hold_8; - var $bits_54 = $bits_8; - var $out_4 = $out_0; - break $_$12; - } - var $next_10 = $next_9; - var $have_10 = $have_9; - var $88 = $86; - } - var $88; - var $have_10; - var $next_10; - HEAP32[$21 >> 2] = 0; - HEAP32[$mode >> 2] = 6; - var $next_11 = $next_10; - var $have_11 = $have_10; - var $hold_9 = $hold_8; - var $bits_9 = $bits_8; - var $89 = $88; - __label__ = 81; - break; - } else if (__label__ == 206) { - var $bits_34; - var $hold_34; - var $have_38; - var $next_38; - var $ret_3; - if ($have_38 >>> 0 > 5 & $left_0 >>> 0 > 257) { - HEAP32[$next_out >> 2] = $put_0; - HEAP32[$avail_out >> 2] = $left_0; - HEAP32[$next_in >> 2] = $next_38; - HEAP32[$avail_in15 >> 2] = $have_38; - HEAP32[$11 >> 2] = $hold_34; - HEAP32[$13 >> 2] = $bits_34; - _inflate_fast($strm, $out_0); - var $144 = HEAP32[$next_out >> 2]; - var $145 = HEAP32[$avail_out >> 2]; - var $146 = HEAP32[$next_in >> 2]; - var $147 = HEAP32[$avail_in15 >> 2]; - var $148 = HEAP32[$11 >> 2]; - var $149 = HEAP32[$13 >> 2]; - if (!((HEAP32[$mode >> 2] | 0) == 11)) { - var $ret_0_be = $ret_3; - var $next_0_be = $146; - var $put_0_be = $144; - var $have_0_be = $147; - var $left_0_be = $145; - var $hold_0_be = $148; - var $bits_0_be = $149; - var $out_0_be = $out_0; - __label__ = 268; - break; - } - HEAP32[$25 >> 2] = -1; - var $ret_0_be = $ret_3; - var $next_0_be = $146; - var $put_0_be = $144; - var $have_0_be = $147; - var $left_0_be = $145; - var $hold_0_be = $148; - var $bits_0_be = $149; - var $out_0_be = $out_0; - __label__ = 268; - break; - } - HEAP32[$25 >> 2] = 0; - var $sub1213 = (1 << HEAP32[$26 >> 2]) - 1 | 0; - var $152 = HEAPU32[$27 >> 2]; - var $next_39 = $next_38; - var $have_39 = $have_38; - var $hold_35 = $hold_34; - var $bits_35 = $bits_34; - while (1) { - var $bits_35; - var $hold_35; - var $have_39; - var $next_39; - var $and1214 = $sub1213 & $hold_35; - var $tmp22 = HEAPU8[$152 + ($and1214 << 2) + 1 | 0]; - var $conv1218 = $tmp22 & 255; - if (!($conv1218 >>> 0 > $bits_35 >>> 0)) { - break; - } - if (($have_39 | 0) == 0) { - var $ret_8 = $ret_3; - var $next_58 = $next_39; - var $have_58 = 0; - var $hold_54 = $hold_35; - var $bits_54 = $bits_35; - var $out_4 = $out_0; - break $_$12; - } - var $add1232 = ((HEAPU8[$next_39] & 255) << $bits_35) + $hold_35 | 0; - var $next_39 = $next_39 + 1 | 0; - var $have_39 = $have_39 - 1 | 0; - var $hold_35 = $add1232; - var $bits_35 = $bits_35 + 8 | 0; - } - var $tmp21 = HEAPU8[$152 + ($and1214 << 2) | 0]; - var $tmp23 = HEAPU16[($152 + ($and1214 << 2) + 2 | 0) >> 1]; - var $conv1237 = $tmp21 & 255; - do { - if ($tmp21 << 24 >> 24 == 0) { - var $next_41 = $next_39; - var $have_41 = $have_39; - var $hold_37 = $hold_35; - var $bits_37 = $bits_35; - var $here_09_0 = 0; - var $here_110_0 = $tmp22; - var $here_211_0 = $tmp23; - var $155 = 0; - } else { - if (!(($conv1237 & 240 | 0) == 0)) { - var $next_41 = $next_39; - var $have_41 = $have_39; - var $hold_37 = $hold_35; - var $bits_37 = $bits_35; - var $here_09_0 = $tmp21; - var $here_110_0 = $tmp22; - var $here_211_0 = $tmp23; - var $155 = 0; - break; - } - var $conv1248 = $tmp23 & 65535; - var $sub1255 = (1 << ($conv1218 + $conv1237 | 0)) - 1 | 0; - var $next_40 = $next_39; - var $have_40 = $have_39; - var $hold_36 = $hold_35; - var $bits_36 = $bits_35; - while (1) { - var $bits_36; - var $hold_36; - var $have_40; - var $next_40; - var $add1260 = (($hold_36 & $sub1255) >>> ($conv1218 >>> 0)) + $conv1248 | 0; - var $tmp19 = HEAPU8[$152 + ($add1260 << 2) + 1 | 0]; - if (!((($tmp19 & 255) + $conv1218 | 0) >>> 0 > $bits_36 >>> 0)) { - break; - } - if (($have_40 | 0) == 0) { - var $ret_8 = $ret_3; - var $next_58 = $next_40; - var $have_58 = 0; - var $hold_54 = $hold_36; - var $bits_54 = $bits_36; - var $out_4 = $out_0; - break $_$12; - } - var $add1281 = ((HEAPU8[$next_40] & 255) << $bits_36) + $hold_36 | 0; - var $next_40 = $next_40 + 1 | 0; - var $have_40 = $have_40 - 1 | 0; - var $hold_36 = $add1281; - var $bits_36 = $bits_36 + 8 | 0; - } - var $tmp20 = HEAP16[($152 + ($add1260 << 2) + 2 | 0) >> 1]; - var $tmp18 = HEAP8[$152 + ($add1260 << 2) | 0]; - HEAP32[$25 >> 2] = $conv1218; - var $next_41 = $next_40; - var $have_41 = $have_40; - var $hold_37 = $hold_36 >>> ($conv1218 >>> 0); - var $bits_37 = $bits_36 - $conv1218 | 0; - var $here_09_0 = $tmp18; - var $here_110_0 = $tmp19; - var $here_211_0 = $tmp20; - var $155 = $conv1218; - } - } while (0); - var $155; - var $here_211_0; - var $here_110_0; - var $here_09_0; - var $bits_37; - var $hold_37; - var $have_41; - var $next_41; - var $conv1302 = $here_110_0 & 255; - var $shr1303 = $hold_37 >>> ($conv1302 >>> 0); - var $sub1306 = $bits_37 - $conv1302 | 0; - HEAP32[$25 >> 2] = $155 + $conv1302 | 0; - HEAP32[$21 >> 2] = $here_211_0 & 65535; - var $conv1317 = $here_09_0 & 255; - if ($here_09_0 << 24 >> 24 == 0) { - HEAP32[$mode >> 2] = 25; - var $ret_0_be = $ret_3; - var $next_0_be = $next_41; - var $put_0_be = $put_0; - var $have_0_be = $have_41; - var $left_0_be = $left_0; - var $hold_0_be = $shr1303; - var $bits_0_be = $sub1306; - var $out_0_be = $out_0; - __label__ = 268; - break; - } - if (!(($conv1317 & 32 | 0) == 0)) { - HEAP32[$25 >> 2] = -1; - HEAP32[$mode >> 2] = 11; - var $ret_0_be = $ret_3; - var $next_0_be = $next_41; - var $put_0_be = $put_0; - var $have_0_be = $have_41; - var $left_0_be = $left_0; - var $hold_0_be = $shr1303; - var $bits_0_be = $sub1306; - var $out_0_be = $out_0; - __label__ = 268; - break; - } - if (($conv1317 & 64 | 0) == 0) { - var $and1341 = $conv1317 & 15; - HEAP32[$28 >> 2] = $and1341; - HEAP32[$mode >> 2] = 21; - var $ret_4 = $ret_3; - var $next_42 = $next_41; - var $have_42 = $have_41; - var $hold_38 = $shr1303; - var $bits_38 = $sub1306; - var $156 = $and1341; - __label__ = 227; - break; - } - HEAP32[$msg >> 2] = STRING_TABLE.__str2171 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $ret_3; - var $next_0_be = $next_41; - var $put_0_be = $put_0; - var $have_0_be = $have_41; - var $left_0_be = $left_0; - var $hold_0_be = $shr1303; - var $bits_0_be = $sub1306; - var $out_0_be = $out_0; - __label__ = 268; - break; - } - } while (0); - do { - if (__label__ == 81) { - var $89; - var $bits_9; - var $hold_9; - var $have_11; - var $next_11; - do { - if (($89 & 2048 | 0) == 0) { - var $98 = HEAP32[$18 >> 2]; - if (($98 | 0) == 0) { - var $next_12 = $next_11; - var $have_12 = $have_11; - break; - } - HEAP32[($98 + 28 | 0) >> 2] = 0; - var $next_12 = $next_11; - var $have_12 = $have_11; - } else { - if (($have_11 | 0) == 0) { - var $ret_8 = $ret_0; - var $next_58 = $next_11; - var $have_58 = 0; - var $hold_54 = $hold_9; - var $bits_54 = $bits_9; - var $out_4 = $out_0; - break $_$12; - } - var $copy_1 = 0; - while (1) { - var $copy_1; - var $inc = $copy_1 + 1 | 0; - var $90 = HEAP8[$next_11 + $copy_1 | 0]; - var $91 = HEAP32[$18 >> 2]; - do { - if (!(($91 | 0) == 0)) { - var $name = $91 + 28 | 0; - if ((HEAP32[$name >> 2] | 0) == 0) { - break; - } - var $93 = HEAPU32[$21 >> 2]; - if (!($93 >>> 0 < HEAPU32[($91 + 32 | 0) >> 2] >>> 0)) { - break; - } - HEAP32[$21 >> 2] = $93 + 1 | 0; - HEAP8[HEAP32[$name >> 2] + $93 | 0] = $90; - } - } while (0); - var $tobool405 = $90 << 24 >> 24 != 0; - if (!($tobool405 & $inc >>> 0 < $have_11 >>> 0)) { - break; - } - var $copy_1 = $inc; - } - if (!((HEAP32[$17 >> 2] & 512 | 0) == 0)) { - HEAP32[$16 >> 2] = _crc32(HEAP32[$16 >> 2], $next_11, $inc); - } - var $sub417 = $have_11 - $inc | 0; - var $add_ptr418 = $next_11 + $inc | 0; - if ($tobool405) { - var $ret_8 = $ret_0; - var $next_58 = $add_ptr418; - var $have_58 = $sub417; - var $hold_54 = $hold_9; - var $bits_54 = $bits_9; - var $out_4 = $out_0; - break $_$12; - } - var $next_12 = $add_ptr418; - var $have_12 = $sub417; - } - } while (0); - var $have_12; - var $next_12; - HEAP32[$21 >> 2] = 0; - HEAP32[$mode >> 2] = 7; - var $next_13 = $next_12; - var $have_13 = $have_12; - var $hold_10 = $hold_9; - var $bits_10 = $bits_9; - __label__ = 94; - break; - } else if (__label__ == 227) { - var $156; - var $bits_38; - var $hold_38; - var $have_42; - var $next_42; - var $ret_4; - if (($156 | 0) == 0) { - var $next_44 = $next_42; - var $have_44 = $have_42; - var $hold_40 = $hold_38; - var $bits_40 = $bits_38; - var $160 = HEAP32[$21 >> 2]; - } else { - var $next_43 = $next_42; - var $have_43 = $have_42; - var $hold_39 = $hold_38; - var $bits_39 = $bits_38; - while (1) { - var $bits_39; - var $hold_39; - var $have_43; - var $next_43; - if (!($bits_39 >>> 0 < $156 >>> 0)) { - break; - } - if (($have_43 | 0) == 0) { - var $ret_8 = $ret_4; - var $next_58 = $next_43; - var $have_58 = 0; - var $hold_54 = $hold_39; - var $bits_54 = $bits_39; - var $out_4 = $out_0; - break $_$12; - } - var $add1363 = ((HEAPU8[$next_43] & 255) << $bits_39) + $hold_39 | 0; - var $next_43 = $next_43 + 1 | 0; - var $have_43 = $have_43 - 1 | 0; - var $hold_39 = $add1363; - var $bits_39 = $bits_39 + 8 | 0; - } - var $add1375 = HEAP32[$21 >> 2] + (((1 << $156) - 1 | 0) & $hold_39) | 0; - HEAP32[$21 >> 2] = $add1375; - HEAP32[$25 >> 2] = HEAP32[$25 >> 2] + $156 | 0; - var $next_44 = $next_43; - var $have_44 = $have_43; - var $hold_40 = $hold_39 >>> ($156 >>> 0); - var $bits_40 = $bits_39 - $156 | 0; - var $160 = $add1375; - } - var $160; - var $bits_40; - var $hold_40; - var $have_44; - var $next_44; - HEAP32[$29 >> 2] = $160; - HEAP32[$mode >> 2] = 22; - var $ret_5_ph = $ret_4; - var $next_45_ph = $next_44; - var $have_45_ph = $have_44; - var $hold_41_ph = $hold_40; - var $bits_41_ph = $bits_40; - __label__ = 234; + } + var $103 = HEAPU32[$21 >> 2]; + if (!($103 >>> 0 < HEAPU32[($101 + 40 | 0) >> 2] >>> 0)) { break; + } + HEAP32[$21 >> 2] = $103 + 1 | 0; + HEAP8[HEAP32[$comment >> 2] + $103 | 0] = $100; } - } while (0); - do { - if (__label__ == 94) { - var $bits_10; - var $hold_10; - var $have_13; - var $next_13; - do { - if ((HEAP32[$17 >> 2] & 4096 | 0) == 0) { - var $108 = HEAP32[$18 >> 2]; - if (($108 | 0) == 0) { - var $next_14 = $next_13; - var $have_14 = $have_13; - break; - } - HEAP32[($108 + 36 | 0) >> 2] = 0; - var $next_14 = $next_13; - var $have_14 = $have_13; - } else { - if (($have_13 | 0) == 0) { - var $ret_8 = $ret_0; - var $next_58 = $next_13; - var $have_58 = 0; - var $hold_54 = $hold_10; - var $bits_54 = $bits_10; - var $out_4 = $out_0; - break $_$12; - } - var $copy_2 = 0; - while (1) { - var $copy_2; - var $inc443 = $copy_2 + 1 | 0; - var $100 = HEAP8[$next_13 + $copy_2 | 0]; - var $101 = HEAP32[$18 >> 2]; - do { - if (!(($101 | 0) == 0)) { - var $comment = $101 + 36 | 0; - if ((HEAP32[$comment >> 2] | 0) == 0) { - break; - } - var $103 = HEAPU32[$21 >> 2]; - if (!($103 >>> 0 < HEAPU32[($101 + 40 | 0) >> 2] >>> 0)) { - break; - } - HEAP32[$21 >> 2] = $103 + 1 | 0; - HEAP8[HEAP32[$comment >> 2] + $103 | 0] = $100; - } - } while (0); - var $tobool467 = $100 << 24 >> 24 != 0; - if (!($tobool467 & $inc443 >>> 0 < $have_13 >>> 0)) { - break; - } - var $copy_2 = $inc443; - } - if (!((HEAP32[$17 >> 2] & 512 | 0) == 0)) { - HEAP32[$16 >> 2] = _crc32(HEAP32[$16 >> 2], $next_13, $inc443); - } - var $sub481 = $have_13 - $inc443 | 0; - var $add_ptr482 = $next_13 + $inc443 | 0; - if ($tobool467) { - var $ret_8 = $ret_0; - var $next_58 = $add_ptr482; - var $have_58 = $sub481; - var $hold_54 = $hold_10; - var $bits_54 = $bits_10; - var $out_4 = $out_0; - break $_$12; - } - var $next_14 = $add_ptr482; - var $have_14 = $sub481; - } - } while (0); - var $have_14; - var $next_14; - HEAP32[$mode >> 2] = 8; - var $next_15 = $next_14; - var $have_15 = $have_14; - var $hold_11 = $hold_10; - var $bits_11 = $bits_10; - __label__ = 107; - break; - } else if (__label__ == 234) { - var $bits_41_ph; - var $hold_41_ph; - var $have_45_ph; - var $next_45_ph; - var $ret_5_ph; - var $sub1393 = (1 << HEAP32[$47 >> 2]) - 1 | 0; - var $162 = HEAPU32[$48 >> 2]; - var $next_45 = $next_45_ph; - var $have_45 = $have_45_ph; - var $hold_41 = $hold_41_ph; - var $bits_41 = $bits_41_ph; - while (1) { - var $bits_41; - var $hold_41; - var $have_45; - var $next_45; - var $and1394 = $sub1393 & $hold_41; - var $tmp16 = HEAPU8[$162 + ($and1394 << 2) + 1 | 0]; - var $conv1398 = $tmp16 & 255; - if (!($conv1398 >>> 0 > $bits_41 >>> 0)) { - break; - } - if (($have_45 | 0) == 0) { - var $ret_8 = $ret_5_ph; - var $next_58 = $next_45; - var $have_58 = 0; - var $hold_54 = $hold_41; - var $bits_54 = $bits_41; - var $out_4 = $out_0; - break $_$12; - } - var $add1412 = ((HEAPU8[$next_45] & 255) << $bits_41) + $hold_41 | 0; - var $next_45 = $next_45 + 1 | 0; - var $have_45 = $have_45 - 1 | 0; - var $hold_41 = $add1412; - var $bits_41 = $bits_41 + 8 | 0; - } - var $tmp15 = HEAPU8[$162 + ($and1394 << 2) | 0]; - var $tmp17 = HEAPU16[($162 + ($and1394 << 2) + 2 | 0) >> 1]; - var $conv1418 = $tmp15 & 255; - if (($conv1418 & 240 | 0) == 0) { - var $conv1425 = $tmp17 & 65535; - var $sub1432 = (1 << ($conv1398 + $conv1418 | 0)) - 1 | 0; - var $next_46 = $next_45; - var $have_46 = $have_45; - var $hold_42 = $hold_41; - var $bits_42 = $bits_41; - while (1) { - var $bits_42; - var $hold_42; - var $have_46; - var $next_46; - var $add1437 = (($hold_42 & $sub1432) >>> ($conv1398 >>> 0)) + $conv1425 | 0; - var $tmp13 = HEAPU8[$162 + ($add1437 << 2) + 1 | 0]; - if (!((($tmp13 & 255) + $conv1398 | 0) >>> 0 > $bits_42 >>> 0)) { - break; - } - if (($have_46 | 0) == 0) { - var $ret_8 = $ret_5_ph; - var $next_58 = $next_46; - var $have_58 = 0; - var $hold_54 = $hold_42; - var $bits_54 = $bits_42; - var $out_4 = $out_0; - break $_$12; - } - var $add1458 = ((HEAPU8[$next_46] & 255) << $bits_42) + $hold_42 | 0; - var $next_46 = $next_46 + 1 | 0; - var $have_46 = $have_46 - 1 | 0; - var $hold_42 = $add1458; - var $bits_42 = $bits_42 + 8 | 0; - } - var $tmp14 = HEAP16[($162 + ($add1437 << 2) + 2 | 0) >> 1]; - var $tmp12 = HEAP8[$162 + ($add1437 << 2) | 0]; - var $add1475 = HEAP32[$25 >> 2] + $conv1398 | 0; - HEAP32[$25 >> 2] = $add1475; - var $next_47 = $next_46; - var $have_47 = $have_46; - var $hold_43 = $hold_42 >>> ($conv1398 >>> 0); - var $bits_43 = $bits_42 - $conv1398 | 0; - var $here_09_1 = $tmp12; - var $here_110_1 = $tmp13; - var $here_211_1 = $tmp14; - var $166 = $add1475; - } else { - var $next_47 = $next_45; - var $have_47 = $have_45; - var $hold_43 = $hold_41; - var $bits_43 = $bits_41; - var $here_09_1 = $tmp15; - var $here_110_1 = $tmp16; - var $here_211_1 = $tmp17; - var $166 = HEAP32[$25 >> 2]; - } - var $166; - var $here_211_1; - var $here_110_1; - var $here_09_1; - var $bits_43; - var $hold_43; - var $have_47; - var $next_47; - var $conv1479 = $here_110_1 & 255; - var $shr1480 = $hold_43 >>> ($conv1479 >>> 0); - var $sub1483 = $bits_43 - $conv1479 | 0; - HEAP32[$25 >> 2] = $166 + $conv1479 | 0; - var $conv1491 = $here_09_1 & 255; - if (($conv1491 & 64 | 0) == 0) { - HEAP32[$30 >> 2] = $here_211_1 & 65535; - var $and1502 = $conv1491 & 15; - HEAP32[$28 >> 2] = $and1502; - HEAP32[$mode >> 2] = 23; - var $ret_6 = $ret_5_ph; - var $next_48 = $next_47; - var $have_48 = $have_47; - var $hold_44 = $shr1480; - var $bits_44 = $sub1483; - var $167 = $and1502; - __label__ = 248; - break; - } - HEAP32[$msg >> 2] = STRING_TABLE.__str1170 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $ret_5_ph; - var $next_0_be = $next_47; - var $put_0_be = $put_0; - var $have_0_be = $have_47; - var $left_0_be = $left_0; - var $hold_0_be = $shr1480; - var $bits_0_be = $sub1483; - var $out_0_be = $out_0; - __label__ = 268; - break; - } - } while (0); - $_$359 : do { - if (__label__ == 107) { - var $bits_11; - var $hold_11; - var $have_15; - var $next_15; - var $109 = HEAPU32[$17 >> 2]; - do { - if (!(($109 & 512 | 0) == 0)) { - var $next_16 = $next_15; - var $have_16 = $have_15; - var $hold_12 = $hold_11; - var $bits_12 = $bits_11; - while (1) { - var $bits_12; - var $hold_12; - var $have_16; - var $next_16; - if (!($bits_12 >>> 0 < 16)) { - break; - } - if (($have_16 | 0) == 0) { - var $ret_8 = $ret_0; - var $next_58 = $next_16; - var $have_58 = 0; - var $hold_54 = $hold_12; - var $bits_54 = $bits_12; - var $out_4 = $out_0; - break $_$12; - } - var $add515 = ((HEAPU8[$next_16] & 255) << $bits_12) + $hold_12 | 0; - var $next_16 = $next_16 + 1 | 0; - var $have_16 = $have_16 - 1 | 0; - var $hold_12 = $add515; - var $bits_12 = $bits_12 + 8 | 0; - } - if (($hold_12 | 0) == (HEAP32[$16 >> 2] & 65535 | 0)) { - var $next_17 = $next_16; - var $have_17 = $have_16; - var $hold_13 = 0; - var $bits_13 = 0; - break; - } - HEAP32[$msg >> 2] = STRING_TABLE.__str5102 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $ret_0; - var $next_0_be = $next_16; - var $put_0_be = $put_0; - var $have_0_be = $have_16; - var $left_0_be = $left_0; - var $hold_0_be = $hold_12; - var $bits_0_be = $bits_12; - var $out_0_be = $out_0; - __label__ = 268; - break $_$359; - } - var $next_17 = $next_15; - var $have_17 = $have_15; - var $hold_13 = $hold_11; - var $bits_13 = $bits_11; - } while (0); - var $bits_13; - var $hold_13; - var $have_17; - var $next_17; - var $112 = HEAPU32[$18 >> 2]; - if (!(($112 | 0) == 0)) { - HEAP32[($112 + 44 | 0) >> 2] = $109 >>> 9 & 1; - HEAP32[(HEAP32[$18 >> 2] + 48 | 0) >> 2] = 1; - } - var $call545 = _crc32(0, 0, 0); - HEAP32[$16 >> 2] = $call545; - HEAP32[$adler >> 2] = $call545; - HEAP32[$mode >> 2] = 11; - var $ret_0_be = $ret_0; - var $next_0_be = $next_17; - var $put_0_be = $put_0; - var $have_0_be = $have_17; - var $left_0_be = $left_0; - var $hold_0_be = $hold_13; - var $bits_0_be = $bits_13; - var $out_0_be = $out_0; - __label__ = 268; - break; - } else if (__label__ == 248) { - var $167; - var $bits_44; - var $hold_44; - var $have_48; - var $next_48; - var $ret_6; - if (($167 | 0) == 0) { - var $next_50 = $next_48; - var $have_50 = $have_48; - var $hold_46 = $hold_44; - var $bits_46 = $bits_44; - } else { - var $next_49 = $next_48; - var $have_49 = $have_48; - var $hold_45 = $hold_44; - var $bits_45 = $bits_44; - while (1) { - var $bits_45; - var $hold_45; - var $have_49; - var $next_49; - if (!($bits_45 >>> 0 < $167 >>> 0)) { - break; - } - if (($have_49 | 0) == 0) { - var $ret_8 = $ret_6; - var $next_58 = $next_49; - var $have_58 = 0; - var $hold_54 = $hold_45; - var $bits_54 = $bits_45; - var $out_4 = $out_0; - break $_$12; - } - var $add1524 = ((HEAPU8[$next_49] & 255) << $bits_45) + $hold_45 | 0; - var $next_49 = $next_49 + 1 | 0; - var $have_49 = $have_49 - 1 | 0; - var $hold_45 = $add1524; - var $bits_45 = $bits_45 + 8 | 0; - } - HEAP32[$30 >> 2] = HEAP32[$30 >> 2] + (((1 << $167) - 1 | 0) & $hold_45) | 0; - HEAP32[$25 >> 2] = HEAP32[$25 >> 2] + $167 | 0; - var $next_50 = $next_49; - var $have_50 = $have_49; - var $hold_46 = $hold_45 >>> ($167 >>> 0); - var $bits_46 = $bits_45 - $167 | 0; - } - var $bits_46; - var $hold_46; - var $have_50; - var $next_50; - HEAP32[$mode >> 2] = 24; - var $ret_7 = $ret_6; - var $next_51 = $next_50; - var $have_51 = $have_50; - var $hold_47 = $hold_46; - var $bits_47 = $bits_46; - __label__ = 254; - break; - } - } while (0); - $_$380 : do { - if (__label__ == 254) { - var $bits_47; - var $hold_47; - var $have_51; - var $next_51; - var $ret_7; - if (($left_0 | 0) == 0) { - var $ret_8 = $ret_7; - var $next_58 = $next_51; - var $have_58 = $have_51; - var $hold_54 = $hold_47; - var $bits_54 = $bits_47; - var $out_4 = $out_0; - break $_$12; - } - var $sub1554 = $out_0 - $left_0 | 0; - var $171 = HEAPU32[$30 >> 2]; - do { - if ($171 >>> 0 > $sub1554 >>> 0) { - var $sub1560 = $171 - $sub1554 | 0; - do { - if ($sub1560 >>> 0 > HEAPU32[$31 >> 2] >>> 0) { - if ((HEAP32[$32 >> 2] | 0) == 0) { - break; - } - HEAP32[$msg >> 2] = STRING_TABLE.__str169 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $ret_7; - var $next_0_be = $next_51; - var $put_0_be = $put_0; - var $have_0_be = $have_51; - var $left_0_be = $left_0; - var $hold_0_be = $hold_47; - var $bits_0_be = $bits_47; - var $out_0_be = $out_0; - break $_$380; - } - } while (0); - var $174 = HEAPU32[$33 >> 2]; - if ($sub1560 >>> 0 > $174 >>> 0) { - var $sub1574 = $sub1560 - $174 | 0; - var $from_0 = HEAP32[$34 >> 2] + (HEAP32[$35 >> 2] - $sub1574 | 0) | 0; - var $copy_7 = $sub1574; - } else { - var $from_0 = HEAP32[$34 >> 2] + ($174 - $sub1560 | 0) | 0; - var $copy_7 = $sub1560; - } - var $copy_7; - var $from_0; - var $178 = HEAPU32[$21 >> 2]; - if (!($copy_7 >>> 0 > $178 >>> 0)) { - var $from_1 = $from_0; - var $copy_8 = $copy_7; - var $180 = $178; - break; - } - var $from_1 = $from_0; - var $copy_8 = $178; - var $180 = $178; - } else { - var $179 = HEAP32[$21 >> 2]; - var $from_1 = $put_0 + (-$171 | 0) | 0; - var $copy_8 = $179; - var $180 = $179; - } - } while (0); - var $180; - var $copy_8; - var $from_1; - var $copy_9 = $copy_8 >>> 0 > $left_0 >>> 0 ? $left_0 : $copy_8; - HEAP32[$21 >> 2] = $180 - $copy_9 | 0; - var $181 = $copy_8 ^ -1; - var $182 = $left_0 ^ -1; - var $umax = $181 >>> 0 > $182 >>> 0 ? $181 : $182; - var $from_2 = $from_1; - var $put_1 = $put_0; - var $copy_10 = $copy_9; - while (1) { - var $copy_10; - var $put_1; - var $from_2; - HEAP8[$put_1] = HEAP8[$from_2]; - var $dec1605 = $copy_10 - 1 | 0; - if (($dec1605 | 0) == 0) { - break; - } - var $from_2 = $from_2 + 1 | 0; - var $put_1 = $put_1 + 1 | 0; - var $copy_10 = $dec1605; - } - var $sub1598 = $left_0 - $copy_9 | 0; - var $scevgep632 = $put_0 + ($umax ^ -1) | 0; - if (!((HEAP32[$21 >> 2] | 0) == 0)) { - var $ret_0_be = $ret_7; - var $next_0_be = $next_51; - var $put_0_be = $scevgep632; - var $have_0_be = $have_51; - var $left_0_be = $sub1598; - var $hold_0_be = $hold_47; - var $bits_0_be = $bits_47; - var $out_0_be = $out_0; - break; - } - HEAP32[$mode >> 2] = 20; - var $ret_0_be = $ret_7; - var $next_0_be = $next_51; - var $put_0_be = $scevgep632; - var $have_0_be = $have_51; - var $left_0_be = $sub1598; - var $hold_0_be = $hold_47; - var $bits_0_be = $bits_47; - var $out_0_be = $out_0; - } - } while (0); - var $out_0_be; - var $bits_0_be; - var $hold_0_be; - var $left_0_be; - var $have_0_be; - var $put_0_be; - var $next_0_be; - var $ret_0_be; - var $ret_0 = $ret_0_be; - var $next_0 = $next_0_be; - var $put_0 = $put_0_be; - var $have_0 = $have_0_be; - var $left_0 = $left_0_be; - var $hold_0 = $hold_0_be; - var $bits_0 = $bits_0_be; - var $out_0 = $out_0_be; - var $49 = HEAP32[$mode >> 2]; + } while (0); + var $tobool467 = $100 << 24 >> 24 != 0; + if (!($tobool467 & $inc443 >>> 0 < $have_13 >>> 0)) { + break; + } + var $copy_2 = $inc443; + } + if (!((HEAP32[$17 >> 2] & 512 | 0) == 0)) { + HEAP32[$16 >> 2] = _crc32(HEAP32[$16 >> 2], $next_13, $inc443); + } + var $sub481 = $have_13 - $inc443 | 0; + var $add_ptr482 = $next_13 + $inc443 | 0; + if ($tobool467) { + var $ret_8 = $ret_0; + var $next_58 = $add_ptr482; + var $have_58 = $sub481; + var $hold_54 = $hold_10; + var $bits_54 = $bits_10; + var $out_4 = $out_0; + break $_$12; + } + var $next_14 = $add_ptr482; + var $have_14 = $sub481; + } + } while (0); + var $have_14; + var $next_14; + HEAP32[$mode >> 2] = 8; + var $next_15 = $next_14; + var $have_15 = $have_14; + var $hold_11 = $hold_10; + var $bits_11 = $bits_10; + __label__ = 107; + break; + } else if (__label__ == 234) { + var $bits_41_ph; + var $hold_41_ph; + var $have_45_ph; + var $next_45_ph; + var $ret_5_ph; + var $sub1393 = (1 << HEAP32[$47 >> 2]) - 1 | 0; + var $162 = HEAPU32[$48 >> 2]; + var $next_45 = $next_45_ph; + var $have_45 = $have_45_ph; + var $hold_41 = $hold_41_ph; + var $bits_41 = $bits_41_ph; + while (1) { + var $bits_41; + var $hold_41; + var $have_45; + var $next_45; + var $and1394 = $sub1393 & $hold_41; + var $tmp16 = HEAPU8[$162 + ($and1394 << 2) + 1 | 0]; + var $conv1398 = $tmp16 & 255; + if (!($conv1398 >>> 0 > $bits_41 >>> 0)) { + break; + } + if (($have_45 | 0) == 0) { + var $ret_8 = $ret_5_ph; + var $next_58 = $next_45; + var $have_58 = 0; + var $hold_54 = $hold_41; + var $bits_54 = $bits_41; + var $out_4 = $out_0; + break $_$12; + } + var $add1412 = ((HEAPU8[$next_45] & 255) << $bits_41) + $hold_41 | 0; + var $next_45 = $next_45 + 1 | 0; + var $have_45 = $have_45 - 1 | 0; + var $hold_41 = $add1412; + var $bits_41 = $bits_41 + 8 | 0; } - var $out_4; - var $bits_54; - var $hold_54; - var $have_58; - var $next_58; - var $ret_8; - HEAP32[$next_out >> 2] = $put_0; - HEAP32[$avail_out >> 2] = $left_0; - HEAP32[$next_in >> 2] = $next_58; - HEAP32[$avail_in15 >> 2] = $have_58; - HEAP32[$11 >> 2] = $hold_54; - HEAP32[$13 >> 2] = $bits_54; + var $tmp15 = HEAPU8[$162 + ($and1394 << 2) | 0]; + var $tmp17 = HEAPU16[($162 + ($and1394 << 2) + 2 | 0) >> 1]; + var $conv1418 = $tmp15 & 255; + if (($conv1418 & 240 | 0) == 0) { + var $conv1425 = $tmp17 & 65535; + var $sub1432 = (1 << ($conv1398 + $conv1418 | 0)) - 1 | 0; + var $next_46 = $next_45; + var $have_46 = $have_45; + var $hold_42 = $hold_41; + var $bits_42 = $bits_41; + while (1) { + var $bits_42; + var $hold_42; + var $have_46; + var $next_46; + var $add1437 = (($hold_42 & $sub1432) >>> ($conv1398 >>> 0)) + $conv1425 | 0; + var $tmp13 = HEAPU8[$162 + ($add1437 << 2) + 1 | 0]; + if (!((($tmp13 & 255) + $conv1398 | 0) >>> 0 > $bits_42 >>> 0)) { + break; + } + if (($have_46 | 0) == 0) { + var $ret_8 = $ret_5_ph; + var $next_58 = $next_46; + var $have_58 = 0; + var $hold_54 = $hold_42; + var $bits_54 = $bits_42; + var $out_4 = $out_0; + break $_$12; + } + var $add1458 = ((HEAPU8[$next_46] & 255) << $bits_42) + $hold_42 | 0; + var $next_46 = $next_46 + 1 | 0; + var $have_46 = $have_46 - 1 | 0; + var $hold_42 = $add1458; + var $bits_42 = $bits_42 + 8 | 0; + } + var $tmp14 = HEAP16[($162 + ($add1437 << 2) + 2 | 0) >> 1]; + var $tmp12 = HEAP8[$162 + ($add1437 << 2) | 0]; + var $add1475 = HEAP32[$25 >> 2] + $conv1398 | 0; + HEAP32[$25 >> 2] = $add1475; + var $next_47 = $next_46; + var $have_47 = $have_46; + var $hold_43 = $hold_42 >>> ($conv1398 >>> 0); + var $bits_43 = $bits_42 - $conv1398 | 0; + var $here_09_1 = $tmp12; + var $here_110_1 = $tmp13; + var $here_211_1 = $tmp14; + var $166 = $add1475; + } else { + var $next_47 = $next_45; + var $have_47 = $have_45; + var $hold_43 = $hold_41; + var $bits_43 = $bits_41; + var $here_09_1 = $tmp15; + var $here_110_1 = $tmp16; + var $here_211_1 = $tmp17; + var $166 = HEAP32[$25 >> 2]; + } + var $166; + var $here_211_1; + var $here_110_1; + var $here_09_1; + var $bits_43; + var $hold_43; + var $have_47; + var $next_47; + var $conv1479 = $here_110_1 & 255; + var $shr1480 = $hold_43 >>> ($conv1479 >>> 0); + var $sub1483 = $bits_43 - $conv1479 | 0; + HEAP32[$25 >> 2] = $166 + $conv1479 | 0; + var $conv1491 = $here_09_1 & 255; + if (($conv1491 & 64 | 0) == 0) { + HEAP32[$30 >> 2] = $here_211_1 & 65535; + var $and1502 = $conv1491 & 15; + HEAP32[$28 >> 2] = $and1502; + HEAP32[$mode >> 2] = 23; + var $ret_6 = $ret_5_ph; + var $next_48 = $next_47; + var $have_48 = $have_47; + var $hold_44 = $shr1480; + var $bits_44 = $sub1483; + var $167 = $and1502; + __label__ = 248; + break; + } + HEAP32[$msg >> 2] = STRING_TABLE.__str1170 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $ret_5_ph; + var $next_0_be = $next_47; + var $put_0_be = $put_0; + var $have_0_be = $have_47; + var $left_0_be = $left_0; + var $hold_0_be = $shr1480; + var $bits_0_be = $sub1483; + var $out_0_be = $out_0; + __label__ = 268; + break; + } + } while (0); + $_$359 : do { + if (__label__ == 107) { + var $bits_11; + var $hold_11; + var $have_15; + var $next_15; + var $109 = HEAPU32[$17 >> 2]; do { - if ((HEAP32[$35 >> 2] | 0) == 0) { - if (!(HEAPU32[$mode >> 2] >>> 0 < 26)) { - __label__ = 300; - break; - } - if (($out_4 | 0) == (HEAP32[$avail_out >> 2] | 0)) { - __label__ = 300; - break; - } - __label__ = 298; + if (!(($109 & 512 | 0) == 0)) { + var $next_16 = $next_15; + var $have_16 = $have_15; + var $hold_12 = $hold_11; + var $bits_12 = $bits_11; + while (1) { + var $bits_12; + var $hold_12; + var $have_16; + var $next_16; + if (!($bits_12 >>> 0 < 16)) { break; - } else { - __label__ = 298; + } + if (($have_16 | 0) == 0) { + var $ret_8 = $ret_0; + var $next_58 = $next_16; + var $have_58 = 0; + var $hold_54 = $hold_12; + var $bits_54 = $bits_12; + var $out_4 = $out_0; + break $_$12; + } + var $add515 = ((HEAPU8[$next_16] & 255) << $bits_12) + $hold_12 | 0; + var $next_16 = $next_16 + 1 | 0; + var $have_16 = $have_16 - 1 | 0; + var $hold_12 = $add515; + var $bits_12 = $bits_12 + 8 | 0; + } + if (($hold_12 | 0) == (HEAP32[$16 >> 2] & 65535 | 0)) { + var $next_17 = $next_16; + var $have_17 = $have_16; + var $hold_13 = 0; + var $bits_13 = 0; + break; } + HEAP32[$msg >> 2] = STRING_TABLE.__str5102 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $ret_0; + var $next_0_be = $next_16; + var $put_0_be = $put_0; + var $have_0_be = $have_16; + var $left_0_be = $left_0; + var $hold_0_be = $hold_12; + var $bits_0_be = $bits_12; + var $out_0_be = $out_0; + __label__ = 268; + break $_$359; + } + var $next_17 = $next_15; + var $have_17 = $have_15; + var $hold_13 = $hold_11; + var $bits_13 = $bits_11; } while (0); + var $bits_13; + var $hold_13; + var $have_17; + var $next_17; + var $112 = HEAPU32[$18 >> 2]; + if (!(($112 | 0) == 0)) { + HEAP32[($112 + 44 | 0) >> 2] = $109 >>> 9 & 1; + HEAP32[(HEAP32[$18 >> 2] + 48 | 0) >> 2] = 1; + } + var $call545 = _crc32(0, 0, 0); + HEAP32[$16 >> 2] = $call545; + HEAP32[$adler >> 2] = $call545; + HEAP32[$mode >> 2] = 11; + var $ret_0_be = $ret_0; + var $next_0_be = $next_17; + var $put_0_be = $put_0; + var $have_0_be = $have_17; + var $left_0_be = $left_0; + var $hold_0_be = $hold_13; + var $bits_0_be = $bits_13; + var $out_0_be = $out_0; + __label__ = 268; + break; + } else if (__label__ == 248) { + var $167; + var $bits_44; + var $hold_44; + var $have_48; + var $next_48; + var $ret_6; + if (($167 | 0) == 0) { + var $next_50 = $next_48; + var $have_50 = $have_48; + var $hold_46 = $hold_44; + var $bits_46 = $bits_44; + } else { + var $next_49 = $next_48; + var $have_49 = $have_48; + var $hold_45 = $hold_44; + var $bits_45 = $bits_44; + while (1) { + var $bits_45; + var $hold_45; + var $have_49; + var $next_49; + if (!($bits_45 >>> 0 < $167 >>> 0)) { + break; + } + if (($have_49 | 0) == 0) { + var $ret_8 = $ret_6; + var $next_58 = $next_49; + var $have_58 = 0; + var $hold_54 = $hold_45; + var $bits_54 = $bits_45; + var $out_4 = $out_0; + break $_$12; + } + var $add1524 = ((HEAPU8[$next_49] & 255) << $bits_45) + $hold_45 | 0; + var $next_49 = $next_49 + 1 | 0; + var $have_49 = $have_49 - 1 | 0; + var $hold_45 = $add1524; + var $bits_45 = $bits_45 + 8 | 0; + } + HEAP32[$30 >> 2] = HEAP32[$30 >> 2] + (((1 << $167) - 1 | 0) & $hold_45) | 0; + HEAP32[$25 >> 2] = HEAP32[$25 >> 2] + $167 | 0; + var $next_50 = $next_49; + var $have_50 = $have_49; + var $hold_46 = $hold_45 >>> ($167 >>> 0); + var $bits_46 = $bits_45 - $167 | 0; + } + var $bits_46; + var $hold_46; + var $have_50; + var $next_50; + HEAP32[$mode >> 2] = 24; + var $ret_7 = $ret_6; + var $next_51 = $next_50; + var $have_51 = $have_50; + var $hold_47 = $hold_46; + var $bits_47 = $bits_46; + __label__ = 254; + break; + } + } while (0); + $_$380 : do { + if (__label__ == 254) { + var $bits_47; + var $hold_47; + var $have_51; + var $next_51; + var $ret_7; + if (($left_0 | 0) == 0) { + var $ret_8 = $ret_7; + var $next_58 = $next_51; + var $have_58 = $have_51; + var $hold_54 = $hold_47; + var $bits_54 = $bits_47; + var $out_4 = $out_0; + break $_$12; + } + var $sub1554 = $out_0 - $left_0 | 0; + var $171 = HEAPU32[$30 >> 2]; do { - if (__label__ == 298) { - if ((_updatewindow($strm, $out_4) | 0) == 0) { - break; + if ($171 >>> 0 > $sub1554 >>> 0) { + var $sub1560 = $171 - $sub1554 | 0; + do { + if ($sub1560 >>> 0 > HEAPU32[$31 >> 2] >>> 0) { + if ((HEAP32[$32 >> 2] | 0) == 0) { + break; } - HEAP32[$mode >> 2] = 30; - var $retval_0 = -4; - break $_$2; - } - } while (0); - var $202 = HEAPU32[$avail_in15 >> 2]; - var $203 = HEAPU32[$avail_out >> 2]; - var $sub1774 = $out_4 - $203 | 0; - var $total_in = $strm + 8 | 0; - HEAP32[$total_in >> 2] = ($10 - $202 | 0) + HEAP32[$total_in >> 2] | 0; - HEAP32[$total_out >> 2] = HEAP32[$total_out >> 2] + $sub1774 | 0; - HEAP32[$36 >> 2] = HEAP32[$36 >> 2] + $sub1774 | 0; - var $tobool1783 = ($out_4 | 0) == ($203 | 0); - if (!((HEAP32[$15 >> 2] | 0) == 0 | $tobool1783)) { - var $209 = HEAP32[$16 >> 2]; - var $add_ptr1791 = HEAP32[$next_out >> 2] + (-$sub1774 | 0) | 0; - if ((HEAP32[$17 >> 2] | 0) == 0) { - var $cond1800 = _adler32($209, $add_ptr1791, $sub1774); + HEAP32[$msg >> 2] = STRING_TABLE.__str169 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $ret_7; + var $next_0_be = $next_51; + var $put_0_be = $put_0; + var $have_0_be = $have_51; + var $left_0_be = $left_0; + var $hold_0_be = $hold_47; + var $bits_0_be = $bits_47; + var $out_0_be = $out_0; + break $_$380; + } + } while (0); + var $174 = HEAPU32[$33 >> 2]; + if ($sub1560 >>> 0 > $174 >>> 0) { + var $sub1574 = $sub1560 - $174 | 0; + var $from_0 = HEAP32[$34 >> 2] + (HEAP32[$35 >> 2] - $sub1574 | 0) | 0; + var $copy_7 = $sub1574; } else { - var $cond1800 = _crc32($209, $add_ptr1791, $sub1774); + var $from_0 = HEAP32[$34 >> 2] + ($174 - $sub1560 | 0) | 0; + var $copy_7 = $sub1560; } - var $cond1800; - HEAP32[$16 >> 2] = $cond1800; - HEAP32[$adler >> 2] = $cond1800; + var $copy_7; + var $from_0; + var $178 = HEAPU32[$21 >> 2]; + if (!($copy_7 >>> 0 > $178 >>> 0)) { + var $from_1 = $from_0; + var $copy_8 = $copy_7; + var $180 = $178; + break; + } + var $from_1 = $from_0; + var $copy_8 = $178; + var $180 = $178; + } else { + var $179 = HEAP32[$21 >> 2]; + var $from_1 = $put_0 + (-$171 | 0) | 0; + var $copy_8 = $179; + var $180 = $179; + } + } while (0); + var $180; + var $copy_8; + var $from_1; + var $copy_9 = $copy_8 >>> 0 > $left_0 >>> 0 ? $left_0 : $copy_8; + HEAP32[$21 >> 2] = $180 - $copy_9 | 0; + var $181 = $copy_8 ^ -1; + var $182 = $left_0 ^ -1; + var $umax = $181 >>> 0 > $182 >>> 0 ? $181 : $182; + var $from_2 = $from_1; + var $put_1 = $put_0; + var $copy_10 = $copy_9; + while (1) { + var $copy_10; + var $put_1; + var $from_2; + HEAP8[$put_1] = HEAP8[$from_2]; + var $dec1605 = $copy_10 - 1 | 0; + if (($dec1605 | 0) == 0) { + break; + } + var $from_2 = $from_2 + 1 | 0; + var $put_1 = $put_1 + 1 | 0; + var $copy_10 = $dec1605; } - var $213 = HEAP32[$mode >> 2]; - if (($213 | 0) == 19) { - var $214 = 256; - } else { - var $214 = ($213 | 0) == 14 ? 256 : 0; + var $sub1598 = $left_0 - $copy_9 | 0; + var $scevgep632 = $put_0 + ($umax ^ -1) | 0; + if (!((HEAP32[$21 >> 2] | 0) == 0)) { + var $ret_0_be = $ret_7; + var $next_0_be = $next_51; + var $put_0_be = $scevgep632; + var $have_0_be = $have_51; + var $left_0_be = $sub1598; + var $hold_0_be = $hold_47; + var $bits_0_be = $bits_47; + var $out_0_be = $out_0; + break; } - var $214; - HEAP32[($strm + 44 | 0) >> 2] = ((((HEAP32[$24 >> 2] | 0) != 0 ? 64 : 0) + HEAP32[$13 >> 2] | 0) + (($213 | 0) == 11 ? 128 : 0) | 0) + $214 | 0; - var $retval_0 = (($10 | 0) == ($202 | 0) & $tobool1783 | ($flush | 0) == 4) & ($ret_8 | 0) == 0 ? -5 : $ret_8; + HEAP32[$mode >> 2] = 20; + var $ret_0_be = $ret_7; + var $next_0_be = $next_51; + var $put_0_be = $scevgep632; + var $have_0_be = $have_51; + var $left_0_be = $sub1598; + var $hold_0_be = $hold_47; + var $bits_0_be = $bits_47; + var $out_0_be = $out_0; + } + } while (0); + var $out_0_be; + var $bits_0_be; + var $hold_0_be; + var $left_0_be; + var $have_0_be; + var $put_0_be; + var $next_0_be; + var $ret_0_be; + var $ret_0 = $ret_0_be; + var $next_0 = $next_0_be; + var $put_0 = $put_0_be; + var $have_0 = $have_0_be; + var $left_0 = $left_0_be; + var $hold_0 = $hold_0_be; + var $bits_0 = $bits_0_be; + var $out_0 = $out_0_be; + var $49 = HEAP32[$mode >> 2]; + } + var $out_4; + var $bits_54; + var $hold_54; + var $have_58; + var $next_58; + var $ret_8; + HEAP32[$next_out >> 2] = $put_0; + HEAP32[$avail_out >> 2] = $left_0; + HEAP32[$next_in >> 2] = $next_58; + HEAP32[$avail_in15 >> 2] = $have_58; + HEAP32[$11 >> 2] = $hold_54; + HEAP32[$13 >> 2] = $bits_54; + do { + if ((HEAP32[$35 >> 2] | 0) == 0) { + if (!(HEAPU32[$mode >> 2] >>> 0 < 26)) { + __label__ = 300; + break; + } + if (($out_4 | 0) == (HEAP32[$avail_out >> 2] | 0)) { + __label__ = 300; + break; + } + __label__ = 298; + break; + } else { + __label__ = 298; } - } while (0); - var $retval_0; - STACKTOP = __stackBase__; - return $retval_0; - return null; + } while (0); + do { + if (__label__ == 298) { + if ((_updatewindow($strm, $out_4) | 0) == 0) { + break; + } + HEAP32[$mode >> 2] = 30; + var $retval_0 = -4; + break $_$2; + } + } while (0); + var $202 = HEAPU32[$avail_in15 >> 2]; + var $203 = HEAPU32[$avail_out >> 2]; + var $sub1774 = $out_4 - $203 | 0; + var $total_in = $strm + 8 | 0; + HEAP32[$total_in >> 2] = ($10 - $202 | 0) + HEAP32[$total_in >> 2] | 0; + HEAP32[$total_out >> 2] = HEAP32[$total_out >> 2] + $sub1774 | 0; + HEAP32[$36 >> 2] = HEAP32[$36 >> 2] + $sub1774 | 0; + var $tobool1783 = ($out_4 | 0) == ($203 | 0); + if (!((HEAP32[$15 >> 2] | 0) == 0 | $tobool1783)) { + var $209 = HEAP32[$16 >> 2]; + var $add_ptr1791 = HEAP32[$next_out >> 2] + (-$sub1774 | 0) | 0; + if ((HEAP32[$17 >> 2] | 0) == 0) { + var $cond1800 = _adler32($209, $add_ptr1791, $sub1774); + } else { + var $cond1800 = _crc32($209, $add_ptr1791, $sub1774); + } + var $cond1800; + HEAP32[$16 >> 2] = $cond1800; + HEAP32[$adler >> 2] = $cond1800; + } + var $213 = HEAP32[$mode >> 2]; + if (($213 | 0) == 19) { + var $214 = 256; + } else { + var $214 = ($213 | 0) == 14 ? 256 : 0; + } + var $214; + HEAP32[($strm + 44 | 0) >> 2] = ((((HEAP32[$24 >> 2] | 0) != 0 ? 64 : 0) + HEAP32[$13 >> 2] | 0) + (($213 | 0) == 11 ? 128 : 0) | 0) + $214 | 0; + var $retval_0 = (($10 | 0) == ($202 | 0) & $tobool1783 | ($flush | 0) == 4) & ($ret_8 | 0) == 0 ? -5 : $ret_8; + } + } while (0); + var $retval_0; + STACKTOP = __stackBase__; + return $retval_0; + return null; } function _malloc($bytes) { - var __label__; - $_$2 : do { - if ($bytes >>> 0 < 245) { - if ($bytes >>> 0 < 11) { - var $8 = 16; + var __label__; + $_$2 : do { + if ($bytes >>> 0 < 245) { + if ($bytes >>> 0 < 11) { + var $8 = 16; + } else { + var $8 = ($bytes + 11 | 0) & -8; + } + var $8; + var $9 = $8 >>> 3; + var $10 = HEAPU32[(__gm_ | 0) >> 2]; + var $11 = $10 >>> ($9 >>> 0); + if (!(($11 & 3 | 0) == 0)) { + var $17 = ($11 & 1 ^ 1) + $9 | 0; + var $18 = $17 << 1; + var $20 = __gm_ + 40 + ($18 << 2) | 0; + var $21 = __gm_ + 40 + (($18 + 2 | 0) << 2) | 0; + var $22 = HEAPU32[$21 >> 2]; + var $23 = $22 + 8 | 0; + var $24 = HEAPU32[$23 >> 2]; + if (($20 | 0) == ($24 | 0)) { + HEAP32[(__gm_ | 0) >> 2] = $10 & (1 << $17 ^ -1); + } else { + if ($24 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { + _abort(); + } else { + HEAP32[$21 >> 2] = $24; + HEAP32[($24 + 12 | 0) >> 2] = $20; + } + } + var $38 = $17 << 3; + HEAP32[($22 + 4 | 0) >> 2] = $38 | 3; + var $43 = $22 + ($38 | 4) | 0; + HEAP32[$43 >> 2] = HEAP32[$43 >> 2] | 1; + var $mem_0 = $23; + __label__ = 331; + break; + } + if (!($8 >>> 0 > HEAPU32[(__gm_ + 8 | 0) >> 2] >>> 0)) { + var $nb_0 = $8; + __label__ = 155; + break; + } + if (!(($11 | 0) == 0)) { + var $54 = 2 << $9; + var $57 = $11 << $9 & ($54 | (-$54 | 0)); + var $60 = ($57 & (-$57 | 0)) - 1 | 0; + var $62 = $60 >>> 12 & 16; + var $63 = $60 >>> ($62 >>> 0); + var $65 = $63 >>> 5 & 8; + var $66 = $63 >>> ($65 >>> 0); + var $68 = $66 >>> 2 & 4; + var $69 = $66 >>> ($68 >>> 0); + var $71 = $69 >>> 1 & 2; + var $72 = $69 >>> ($71 >>> 0); + var $74 = $72 >>> 1 & 1; + var $80 = ($65 | $62 | $68 | $71 | $74) + ($72 >>> ($74 >>> 0)) | 0; + var $81 = $80 << 1; + var $83 = __gm_ + 40 + ($81 << 2) | 0; + var $84 = __gm_ + 40 + (($81 + 2 | 0) << 2) | 0; + var $85 = HEAPU32[$84 >> 2]; + var $86 = $85 + 8 | 0; + var $87 = HEAPU32[$86 >> 2]; + if (($83 | 0) == ($87 | 0)) { + HEAP32[(__gm_ | 0) >> 2] = $10 & (1 << $80 ^ -1); + } else { + if ($87 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { + _abort(); + } else { + HEAP32[$84 >> 2] = $87; + HEAP32[($87 + 12 | 0) >> 2] = $83; + } + } + var $101 = $80 << 3; + var $102 = $101 - $8 | 0; + HEAP32[($85 + 4 | 0) >> 2] = $8 | 3; + var $105 = $85; + var $107 = $105 + $8 | 0; + HEAP32[($105 + ($8 | 4) | 0) >> 2] = $102 | 1; + HEAP32[($105 + $101 | 0) >> 2] = $102; + var $113 = HEAPU32[(__gm_ + 8 | 0) >> 2]; + if (!(($113 | 0) == 0)) { + var $116 = HEAP32[(__gm_ + 20 | 0) >> 2]; + var $119 = $113 >>> 2 & 1073741822; + var $121 = __gm_ + 40 + ($119 << 2) | 0; + var $122 = HEAPU32[(__gm_ | 0) >> 2]; + var $123 = 1 << ($113 >>> 3); + do { + if (($122 & $123 | 0) == 0) { + HEAP32[(__gm_ | 0) >> 2] = $122 | $123; + var $F4_0 = $121; + var $_pre_phi = __gm_ + 40 + (($119 + 2 | 0) << 2) | 0; } else { - var $8 = ($bytes + 11 | 0) & -8; - } - var $8; - var $9 = $8 >>> 3; - var $10 = HEAPU32[(__gm_ | 0) >> 2]; - var $11 = $10 >>> ($9 >>> 0); - if (!(($11 & 3 | 0) == 0)) { - var $17 = ($11 & 1 ^ 1) + $9 | 0; - var $18 = $17 << 1; - var $20 = __gm_ + 40 + ($18 << 2) | 0; - var $21 = __gm_ + 40 + (($18 + 2 | 0) << 2) | 0; - var $22 = HEAPU32[$21 >> 2]; - var $23 = $22 + 8 | 0; - var $24 = HEAPU32[$23 >> 2]; - if (($20 | 0) == ($24 | 0)) { - HEAP32[(__gm_ | 0) >> 2] = $10 & (1 << $17 ^ -1); - } else { - if ($24 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { - _abort(); - } else { - HEAP32[$21 >> 2] = $24; - HEAP32[($24 + 12 | 0) >> 2] = $20; - } - } - var $38 = $17 << 3; - HEAP32[($22 + 4 | 0) >> 2] = $38 | 3; - var $43 = $22 + ($38 | 4) | 0; - HEAP32[$43 >> 2] = HEAP32[$43 >> 2] | 1; - var $mem_0 = $23; - __label__ = 331; + var $129 = __gm_ + 40 + (($119 + 2 | 0) << 2) | 0; + var $130 = HEAPU32[$129 >> 2]; + if (!($130 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0)) { + var $F4_0 = $130; + var $_pre_phi = $129; break; + } + _abort(); } - if (!($8 >>> 0 > HEAPU32[(__gm_ + 8 | 0) >> 2] >>> 0)) { - var $nb_0 = $8; - __label__ = 155; - break; + } while (0); + var $_pre_phi; + var $F4_0; + HEAP32[$_pre_phi >> 2] = $116; + HEAP32[($F4_0 + 12 | 0) >> 2] = $116; + HEAP32[($116 + 8 | 0) >> 2] = $F4_0; + HEAP32[($116 + 12 | 0) >> 2] = $121; + } + HEAP32[(__gm_ + 8 | 0) >> 2] = $102; + HEAP32[(__gm_ + 20 | 0) >> 2] = $107; + var $mem_0 = $86; + __label__ = 331; + break; + } + var $142 = HEAP32[(__gm_ + 4 | 0) >> 2]; + if (($142 | 0) == 0) { + var $nb_0 = $8; + __label__ = 155; + break; + } + var $147 = ($142 & (-$142 | 0)) - 1 | 0; + var $149 = $147 >>> 12 & 16; + var $150 = $147 >>> ($149 >>> 0); + var $152 = $150 >>> 5 & 8; + var $153 = $150 >>> ($152 >>> 0); + var $155 = $153 >>> 2 & 4; + var $156 = $153 >>> ($155 >>> 0); + var $158 = $156 >>> 1 & 2; + var $159 = $156 >>> ($158 >>> 0); + var $161 = $159 >>> 1 & 1; + var $169 = HEAPU32[(__gm_ + 304 + ((($152 | $149 | $155 | $158 | $161) + ($159 >>> ($161 >>> 0)) | 0) << 2) | 0) >> 2]; + var $t_0_i = $169; + var $v_0_i = $169; + var $rsize_0_i = (HEAP32[($169 + 4 | 0) >> 2] & -8) - $8 | 0; + while (1) { + var $rsize_0_i; + var $v_0_i; + var $t_0_i; + var $176 = HEAP32[($t_0_i + 16 | 0) >> 2]; + if (($176 | 0) == 0) { + var $180 = HEAP32[($t_0_i + 20 | 0) >> 2]; + if (($180 | 0) == 0) { + break; + } + var $182 = $180; + } else { + var $182 = $176; + } + var $182; + var $186 = (HEAP32[($182 + 4 | 0) >> 2] & -8) - $8 | 0; + var $187 = $186 >>> 0 < $rsize_0_i >>> 0; + var $t_0_i = $182; + var $v_0_i = $187 ? $182 : $v_0_i; + var $rsize_0_i = $187 ? $186 : $rsize_0_i; + } + var $189 = $v_0_i; + var $190 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + do { + if (!($189 >>> 0 < $190 >>> 0)) { + var $193 = $189 + $8 | 0; + var $194 = $193; + if (!($189 >>> 0 < $193 >>> 0)) { + break; + } + var $198 = HEAPU32[($v_0_i + 24 | 0) >> 2]; + var $200 = HEAPU32[($v_0_i + 12 | 0) >> 2]; + do { + if (($200 | 0) == ($v_0_i | 0)) { + var $212 = $v_0_i + 20 | 0; + var $213 = HEAP32[$212 >> 2]; + if (($213 | 0) == 0) { + var $216 = $v_0_i + 16 | 0; + var $217 = HEAP32[$216 >> 2]; + if (($217 | 0) == 0) { + var $R_1_i = 0; + break; + } + var $RP_0_i = $216; + var $R_0_i = $217; + } else { + var $RP_0_i = $212; + var $R_0_i = $213; + __label__ = 39; + } + while (1) { + var $R_0_i; + var $RP_0_i; + var $219 = $R_0_i + 20 | 0; + var $220 = HEAP32[$219 >> 2]; + if (!(($220 | 0) == 0)) { + var $RP_0_i = $219; + var $R_0_i = $220; + continue; + } + var $223 = $R_0_i + 16 | 0; + var $224 = HEAPU32[$223 >> 2]; + if (($224 | 0) == 0) { + break; + } + var $RP_0_i = $223; + var $R_0_i = $224; + } + if ($RP_0_i >>> 0 < $190 >>> 0) { + _abort(); + } else { + HEAP32[$RP_0_i >> 2] = 0; + var $R_1_i = $R_0_i; + } + } else { + var $204 = HEAPU32[($v_0_i + 8 | 0) >> 2]; + if ($204 >>> 0 < $190 >>> 0) { + _abort(); + } else { + HEAP32[($204 + 12 | 0) >> 2] = $200; + HEAP32[($200 + 8 | 0) >> 2] = $204; + var $R_1_i = $200; + } } - if (!(($11 | 0) == 0)) { - var $54 = 2 << $9; - var $57 = $11 << $9 & ($54 | (-$54 | 0)); - var $60 = ($57 & (-$57 | 0)) - 1 | 0; - var $62 = $60 >>> 12 & 16; - var $63 = $60 >>> ($62 >>> 0); - var $65 = $63 >>> 5 & 8; - var $66 = $63 >>> ($65 >>> 0); - var $68 = $66 >>> 2 & 4; - var $69 = $66 >>> ($68 >>> 0); - var $71 = $69 >>> 1 & 2; - var $72 = $69 >>> ($71 >>> 0); - var $74 = $72 >>> 1 & 1; - var $80 = ($65 | $62 | $68 | $71 | $74) + ($72 >>> ($74 >>> 0)) | 0; - var $81 = $80 << 1; - var $83 = __gm_ + 40 + ($81 << 2) | 0; - var $84 = __gm_ + 40 + (($81 + 2 | 0) << 2) | 0; - var $85 = HEAPU32[$84 >> 2]; - var $86 = $85 + 8 | 0; - var $87 = HEAPU32[$86 >> 2]; - if (($83 | 0) == ($87 | 0)) { - HEAP32[(__gm_ | 0) >> 2] = $10 & (1 << $80 ^ -1); + } while (0); + var $R_1_i; + $_$62 : do { + if (!(($198 | 0) == 0)) { + var $234 = $v_0_i + 28 | 0; + var $236 = __gm_ + 304 + (HEAP32[$234 >> 2] << 2) | 0; + do { + if (($v_0_i | 0) == (HEAP32[$236 >> 2] | 0)) { + HEAP32[$236 >> 2] = $R_1_i; + if (!(($R_1_i | 0) == 0)) { + break; + } + HEAP32[(__gm_ + 4 | 0) >> 2] = HEAP32[(__gm_ + 4 | 0) >> 2] & (1 << HEAP32[$234 >> 2] ^ -1); + break $_$62; + } + if ($198 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { + _abort(); } else { - if ($87 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { - _abort(); - } else { - HEAP32[$84 >> 2] = $87; - HEAP32[($87 + 12 | 0) >> 2] = $83; - } + var $250 = $198 + 16 | 0; + if ((HEAP32[$250 >> 2] | 0) == ($v_0_i | 0)) { + HEAP32[$250 >> 2] = $R_1_i; + } else { + HEAP32[($198 + 20 | 0) >> 2] = $R_1_i; + } + if (($R_1_i | 0) == 0) { + break $_$62; + } } - var $101 = $80 << 3; - var $102 = $101 - $8 | 0; - HEAP32[($85 + 4 | 0) >> 2] = $8 | 3; - var $105 = $85; - var $107 = $105 + $8 | 0; - HEAP32[($105 + ($8 | 4) | 0) >> 2] = $102 | 1; - HEAP32[($105 + $101 | 0) >> 2] = $102; - var $113 = HEAPU32[(__gm_ + 8 | 0) >> 2]; - if (!(($113 | 0) == 0)) { - var $116 = HEAP32[(__gm_ + 20 | 0) >> 2]; - var $119 = $113 >>> 2 & 1073741822; - var $121 = __gm_ + 40 + ($119 << 2) | 0; - var $122 = HEAPU32[(__gm_ | 0) >> 2]; - var $123 = 1 << ($113 >>> 3); - do { - if (($122 & $123 | 0) == 0) { - HEAP32[(__gm_ | 0) >> 2] = $122 | $123; - var $F4_0 = $121; - var $_pre_phi = __gm_ + 40 + (($119 + 2 | 0) << 2) | 0; - } else { - var $129 = __gm_ + 40 + (($119 + 2 | 0) << 2) | 0; - var $130 = HEAPU32[$129 >> 2]; - if (!($130 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0)) { - var $F4_0 = $130; - var $_pre_phi = $129; - break; - } - _abort(); - } - } while (0); - var $_pre_phi; - var $F4_0; - HEAP32[$_pre_phi >> 2] = $116; - HEAP32[($F4_0 + 12 | 0) >> 2] = $116; - HEAP32[($116 + 8 | 0) >> 2] = $F4_0; - HEAP32[($116 + 12 | 0) >> 2] = $121; + } while (0); + if ($R_1_i >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { + _abort(); + } else { + HEAP32[($R_1_i + 24 | 0) >> 2] = $198; + var $266 = HEAPU32[($v_0_i + 16 | 0) >> 2]; + if (!(($266 | 0) == 0)) { + if ($266 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { + _abort(); + } else { + HEAP32[($R_1_i + 16 | 0) >> 2] = $266; + HEAP32[($266 + 24 | 0) >> 2] = $R_1_i; + } } - HEAP32[(__gm_ + 8 | 0) >> 2] = $102; - HEAP32[(__gm_ + 20 | 0) >> 2] = $107; - var $mem_0 = $86; - __label__ = 331; - break; + var $278 = HEAPU32[($v_0_i + 20 | 0) >> 2]; + if (($278 | 0) == 0) { + break; + } + if ($278 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { + _abort(); + } else { + HEAP32[($R_1_i + 20 | 0) >> 2] = $278; + HEAP32[($278 + 24 | 0) >> 2] = $R_1_i; + } + } } - var $142 = HEAP32[(__gm_ + 4 | 0) >> 2]; - if (($142 | 0) == 0) { - var $nb_0 = $8; - __label__ = 155; - break; + } while (0); + if ($rsize_0_i >>> 0 < 16) { + var $292 = $rsize_0_i + $8 | 0; + HEAP32[($v_0_i + 4 | 0) >> 2] = $292 | 3; + var $296 = $189 + ($292 + 4 | 0) | 0; + HEAP32[$296 >> 2] = HEAP32[$296 >> 2] | 1; + } else { + HEAP32[($v_0_i + 4 | 0) >> 2] = $8 | 3; + HEAP32[($189 + ($8 | 4) | 0) >> 2] = $rsize_0_i | 1; + HEAP32[($189 + ($rsize_0_i + $8 | 0) | 0) >> 2] = $rsize_0_i; + var $307 = HEAPU32[(__gm_ + 8 | 0) >> 2]; + if (!(($307 | 0) == 0)) { + var $310 = HEAPU32[(__gm_ + 20 | 0) >> 2]; + var $313 = $307 >>> 2 & 1073741822; + var $315 = __gm_ + 40 + ($313 << 2) | 0; + var $316 = HEAPU32[(__gm_ | 0) >> 2]; + var $317 = 1 << ($307 >>> 3); + do { + if (($316 & $317 | 0) == 0) { + HEAP32[(__gm_ | 0) >> 2] = $316 | $317; + var $F1_0_i = $315; + var $_pre_phi_i = __gm_ + 40 + (($313 + 2 | 0) << 2) | 0; + } else { + var $323 = __gm_ + 40 + (($313 + 2 | 0) << 2) | 0; + var $324 = HEAPU32[$323 >> 2]; + if (!($324 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0)) { + var $F1_0_i = $324; + var $_pre_phi_i = $323; + break; + } + _abort(); + } + } while (0); + var $_pre_phi_i; + var $F1_0_i; + HEAP32[$_pre_phi_i >> 2] = $310; + HEAP32[($F1_0_i + 12 | 0) >> 2] = $310; + HEAP32[($310 + 8 | 0) >> 2] = $F1_0_i; + HEAP32[($310 + 12 | 0) >> 2] = $315; } - var $147 = ($142 & (-$142 | 0)) - 1 | 0; - var $149 = $147 >>> 12 & 16; - var $150 = $147 >>> ($149 >>> 0); - var $152 = $150 >>> 5 & 8; - var $153 = $150 >>> ($152 >>> 0); - var $155 = $153 >>> 2 & 4; - var $156 = $153 >>> ($155 >>> 0); - var $158 = $156 >>> 1 & 2; - var $159 = $156 >>> ($158 >>> 0); - var $161 = $159 >>> 1 & 1; - var $169 = HEAPU32[(__gm_ + 304 + ((($152 | $149 | $155 | $158 | $161) + ($159 >>> ($161 >>> 0)) | 0) << 2) | 0) >> 2]; - var $t_0_i = $169; - var $v_0_i = $169; - var $rsize_0_i = (HEAP32[($169 + 4 | 0) >> 2] & -8) - $8 | 0; - while (1) { - var $rsize_0_i; - var $v_0_i; - var $t_0_i; - var $176 = HEAP32[($t_0_i + 16 | 0) >> 2]; - if (($176 | 0) == 0) { - var $180 = HEAP32[($t_0_i + 20 | 0) >> 2]; - if (($180 | 0) == 0) { - break; - } - var $182 = $180; + HEAP32[(__gm_ + 8 | 0) >> 2] = $rsize_0_i; + HEAP32[(__gm_ + 20 | 0) >> 2] = $194; + } + var $335 = $v_0_i + 8 | 0; + if (($335 | 0) == 0) { + var $nb_0 = $8; + __label__ = 155; + break $_$2; + } + var $mem_0 = $335; + __label__ = 331; + break $_$2; + } + } while (0); + _abort(); + } else { + if ($bytes >>> 0 > 4294967231) { + var $nb_0 = -1; + __label__ = 155; + break; + } + var $341 = $bytes + 11 | 0; + var $342 = $341 & -8; + var $343 = HEAPU32[(__gm_ + 4 | 0) >> 2]; + if (($343 | 0) == 0) { + var $nb_0 = $342; + __label__ = 155; + break; + } + var $346 = -$342 | 0; + var $347 = $341 >>> 8; + do { + if (($347 | 0) == 0) { + var $idx_0_i = 0; + } else { + if ($342 >>> 0 > 16777215) { + var $idx_0_i = 31; + break; + } + var $354 = ($347 + 1048320 | 0) >>> 16 & 8; + var $355 = $347 << $354; + var $358 = ($355 + 520192 | 0) >>> 16 & 4; + var $359 = $355 << $358; + var $362 = ($359 + 245760 | 0) >>> 16 & 2; + var $368 = (14 - ($358 | $354 | $362) | 0) + ($359 << $362 >>> 15) | 0; + var $idx_0_i = $342 >>> (($368 + 7 | 0) >>> 0) & 1 | $368 << 1; + } + } while (0); + var $idx_0_i; + var $376 = HEAPU32[(__gm_ + 304 + ($idx_0_i << 2) | 0) >> 2]; + $_$110 : do { + if (($376 | 0) == 0) { + var $v_2_i = 0; + var $rsize_2_i = $346; + var $t_1_i = 0; + } else { + if (($idx_0_i | 0) == 31) { + var $384 = 0; + } else { + var $384 = 25 - ($idx_0_i >>> 1) | 0; + } + var $384; + var $v_0_i15 = 0; + var $rsize_0_i14 = $346; + var $t_0_i13 = $376; + var $sizebits_0_i = $342 << $384; + var $rst_0_i = 0; + while (1) { + var $rst_0_i; + var $sizebits_0_i; + var $t_0_i13; + var $rsize_0_i14; + var $v_0_i15; + var $389 = HEAP32[($t_0_i13 + 4 | 0) >> 2] & -8; + var $390 = $389 - $342 | 0; + if ($390 >>> 0 < $rsize_0_i14 >>> 0) { + if (($389 | 0) == ($342 | 0)) { + var $v_2_i = $t_0_i13; + var $rsize_2_i = $390; + var $t_1_i = $t_0_i13; + break $_$110; + } + var $v_1_i = $t_0_i13; + var $rsize_1_i = $390; + } else { + var $v_1_i = $v_0_i15; + var $rsize_1_i = $rsize_0_i14; + } + var $rsize_1_i; + var $v_1_i; + var $396 = HEAPU32[($t_0_i13 + 20 | 0) >> 2]; + var $399 = HEAPU32[($t_0_i13 + 16 + ($sizebits_0_i >>> 31 << 2) | 0) >> 2]; + var $rst_1_i = ($396 | 0) == 0 | ($396 | 0) == ($399 | 0) ? $rst_0_i : $396; + if (($399 | 0) == 0) { + var $v_2_i = $v_1_i; + var $rsize_2_i = $rsize_1_i; + var $t_1_i = $rst_1_i; + break $_$110; + } + var $v_0_i15 = $v_1_i; + var $rsize_0_i14 = $rsize_1_i; + var $t_0_i13 = $399; + var $sizebits_0_i = $sizebits_0_i << 1; + var $rst_0_i = $rst_1_i; + } + } + } while (0); + var $t_1_i; + var $rsize_2_i; + var $v_2_i; + if (($t_1_i | 0) == 0 & ($v_2_i | 0) == 0) { + var $407 = 2 << $idx_0_i; + var $410 = $343 & ($407 | (-$407 | 0)); + if (($410 | 0) == 0) { + var $nb_0 = $342; + __label__ = 155; + break; + } + var $415 = ($410 & (-$410 | 0)) - 1 | 0; + var $417 = $415 >>> 12 & 16; + var $418 = $415 >>> ($417 >>> 0); + var $420 = $418 >>> 5 & 8; + var $421 = $418 >>> ($420 >>> 0); + var $423 = $421 >>> 2 & 4; + var $424 = $421 >>> ($423 >>> 0); + var $426 = $424 >>> 1 & 2; + var $427 = $424 >>> ($426 >>> 0); + var $429 = $427 >>> 1 & 1; + var $t_2_ph_i = HEAP32[(__gm_ + 304 + ((($420 | $417 | $423 | $426 | $429) + ($427 >>> ($429 >>> 0)) | 0) << 2) | 0) >> 2]; + } else { + var $t_2_ph_i = $t_1_i; + } + var $t_2_ph_i; + $_$125 : do { + if (($t_2_ph_i | 0) == 0) { + var $rsize_3_lcssa_i = $rsize_2_i; + var $v_3_lcssa_i = $v_2_i; + } else { + var $t_224_i = $t_2_ph_i; + var $rsize_325_i = $rsize_2_i; + var $v_326_i = $v_2_i; + while (1) { + var $v_326_i; + var $rsize_325_i; + var $t_224_i; + var $442 = (HEAP32[($t_224_i + 4 | 0) >> 2] & -8) - $342 | 0; + var $443 = $442 >>> 0 < $rsize_325_i >>> 0; + var $_rsize_3_i = $443 ? $442 : $rsize_325_i; + var $t_2_v_3_i = $443 ? $t_224_i : $v_326_i; + var $445 = HEAPU32[($t_224_i + 16 | 0) >> 2]; + if (!(($445 | 0) == 0)) { + var $t_224_i = $445; + var $rsize_325_i = $_rsize_3_i; + var $v_326_i = $t_2_v_3_i; + continue; + } + var $448 = HEAPU32[($t_224_i + 20 | 0) >> 2]; + if (($448 | 0) == 0) { + var $rsize_3_lcssa_i = $_rsize_3_i; + var $v_3_lcssa_i = $t_2_v_3_i; + break $_$125; + } + var $t_224_i = $448; + var $rsize_325_i = $_rsize_3_i; + var $v_326_i = $t_2_v_3_i; + } + } + } while (0); + var $v_3_lcssa_i; + var $rsize_3_lcssa_i; + if (($v_3_lcssa_i | 0) == 0) { + var $nb_0 = $342; + __label__ = 155; + break; + } + if (!($rsize_3_lcssa_i >>> 0 < (HEAP32[(__gm_ + 8 | 0) >> 2] - $342 | 0) >>> 0)) { + var $nb_0 = $342; + __label__ = 155; + break; + } + var $456 = $v_3_lcssa_i; + var $457 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + do { + if (!($456 >>> 0 < $457 >>> 0)) { + var $460 = $456 + $342 | 0; + var $461 = $460; + if (!($456 >>> 0 < $460 >>> 0)) { + break; + } + var $465 = HEAPU32[($v_3_lcssa_i + 24 | 0) >> 2]; + var $467 = HEAPU32[($v_3_lcssa_i + 12 | 0) >> 2]; + do { + if (($467 | 0) == ($v_3_lcssa_i | 0)) { + var $479 = $v_3_lcssa_i + 20 | 0; + var $480 = HEAP32[$479 >> 2]; + if (($480 | 0) == 0) { + var $483 = $v_3_lcssa_i + 16 | 0; + var $484 = HEAP32[$483 >> 2]; + if (($484 | 0) == 0) { + var $R_1_i19 = 0; + break; + } + var $RP_0_i17 = $483; + var $R_0_i16 = $484; + } else { + var $RP_0_i17 = $479; + var $R_0_i16 = $480; + __label__ = 103; + } + while (1) { + var $R_0_i16; + var $RP_0_i17; + var $486 = $R_0_i16 + 20 | 0; + var $487 = HEAP32[$486 >> 2]; + if (!(($487 | 0) == 0)) { + var $RP_0_i17 = $486; + var $R_0_i16 = $487; + continue; + } + var $490 = $R_0_i16 + 16 | 0; + var $491 = HEAPU32[$490 >> 2]; + if (($491 | 0) == 0) { + break; + } + var $RP_0_i17 = $490; + var $R_0_i16 = $491; + } + if ($RP_0_i17 >>> 0 < $457 >>> 0) { + _abort(); + } else { + HEAP32[$RP_0_i17 >> 2] = 0; + var $R_1_i19 = $R_0_i16; + } + } else { + var $471 = HEAPU32[($v_3_lcssa_i + 8 | 0) >> 2]; + if ($471 >>> 0 < $457 >>> 0) { + _abort(); + } else { + HEAP32[($471 + 12 | 0) >> 2] = $467; + HEAP32[($467 + 8 | 0) >> 2] = $471; + var $R_1_i19 = $467; + } + } + } while (0); + var $R_1_i19; + $_$151 : do { + if (!(($465 | 0) == 0)) { + var $501 = $v_3_lcssa_i + 28 | 0; + var $503 = __gm_ + 304 + (HEAP32[$501 >> 2] << 2) | 0; + do { + if (($v_3_lcssa_i | 0) == (HEAP32[$503 >> 2] | 0)) { + HEAP32[$503 >> 2] = $R_1_i19; + if (!(($R_1_i19 | 0) == 0)) { + break; + } + HEAP32[(__gm_ + 4 | 0) >> 2] = HEAP32[(__gm_ + 4 | 0) >> 2] & (1 << HEAP32[$501 >> 2] ^ -1); + break $_$151; + } + if ($465 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { + _abort(); } else { - var $182 = $176; + var $517 = $465 + 16 | 0; + if ((HEAP32[$517 >> 2] | 0) == ($v_3_lcssa_i | 0)) { + HEAP32[$517 >> 2] = $R_1_i19; + } else { + HEAP32[($465 + 20 | 0) >> 2] = $R_1_i19; + } + if (($R_1_i19 | 0) == 0) { + break $_$151; + } } - var $182; - var $186 = (HEAP32[($182 + 4 | 0) >> 2] & -8) - $8 | 0; - var $187 = $186 >>> 0 < $rsize_0_i >>> 0; - var $t_0_i = $182; - var $v_0_i = $187 ? $182 : $v_0_i; - var $rsize_0_i = $187 ? $186 : $rsize_0_i; + } while (0); + if ($R_1_i19 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { + _abort(); + } else { + HEAP32[($R_1_i19 + 24 | 0) >> 2] = $465; + var $533 = HEAPU32[($v_3_lcssa_i + 16 | 0) >> 2]; + if (!(($533 | 0) == 0)) { + if ($533 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { + _abort(); + } else { + HEAP32[($R_1_i19 + 16 | 0) >> 2] = $533; + HEAP32[($533 + 24 | 0) >> 2] = $R_1_i19; + } + } + var $545 = HEAPU32[($v_3_lcssa_i + 20 | 0) >> 2]; + if (($545 | 0) == 0) { + break; + } + if ($545 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { + _abort(); + } else { + HEAP32[($R_1_i19 + 20 | 0) >> 2] = $545; + HEAP32[($545 + 24 | 0) >> 2] = $R_1_i19; + } + } } - var $189 = $v_0_i; - var $190 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - do { - if (!($189 >>> 0 < $190 >>> 0)) { - var $193 = $189 + $8 | 0; - var $194 = $193; - if (!($189 >>> 0 < $193 >>> 0)) { - break; + } while (0); + $_$179 : do { + if ($rsize_3_lcssa_i >>> 0 < 16) { + var $559 = $rsize_3_lcssa_i + $342 | 0; + HEAP32[($v_3_lcssa_i + 4 | 0) >> 2] = $559 | 3; + var $563 = $456 + ($559 + 4 | 0) | 0; + HEAP32[$563 >> 2] = HEAP32[$563 >> 2] | 1; + } else { + HEAP32[($v_3_lcssa_i + 4 | 0) >> 2] = $342 | 3; + HEAP32[($456 + ($342 | 4) | 0) >> 2] = $rsize_3_lcssa_i | 1; + HEAP32[($456 + ($rsize_3_lcssa_i + $342 | 0) | 0) >> 2] = $rsize_3_lcssa_i; + if ($rsize_3_lcssa_i >>> 0 < 256) { + var $578 = $rsize_3_lcssa_i >>> 2 & 1073741822; + var $580 = __gm_ + 40 + ($578 << 2) | 0; + var $581 = HEAPU32[(__gm_ | 0) >> 2]; + var $582 = 1 << ($rsize_3_lcssa_i >>> 3); + do { + if (($581 & $582 | 0) == 0) { + HEAP32[(__gm_ | 0) >> 2] = $581 | $582; + var $F5_0_i = $580; + var $_pre_phi_i25 = __gm_ + 40 + (($578 + 2 | 0) << 2) | 0; + } else { + var $588 = __gm_ + 40 + (($578 + 2 | 0) << 2) | 0; + var $589 = HEAPU32[$588 >> 2]; + if (!($589 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0)) { + var $F5_0_i = $589; + var $_pre_phi_i25 = $588; + break; } - var $198 = HEAPU32[($v_0_i + 24 | 0) >> 2]; - var $200 = HEAPU32[($v_0_i + 12 | 0) >> 2]; - do { - if (($200 | 0) == ($v_0_i | 0)) { - var $212 = $v_0_i + 20 | 0; - var $213 = HEAP32[$212 >> 2]; - if (($213 | 0) == 0) { - var $216 = $v_0_i + 16 | 0; - var $217 = HEAP32[$216 >> 2]; - if (($217 | 0) == 0) { - var $R_1_i = 0; - break; - } - var $RP_0_i = $216; - var $R_0_i = $217; - } else { - var $RP_0_i = $212; - var $R_0_i = $213; - __label__ = 39; - } - while (1) { - var $R_0_i; - var $RP_0_i; - var $219 = $R_0_i + 20 | 0; - var $220 = HEAP32[$219 >> 2]; - if (!(($220 | 0) == 0)) { - var $RP_0_i = $219; - var $R_0_i = $220; - continue; - } - var $223 = $R_0_i + 16 | 0; - var $224 = HEAPU32[$223 >> 2]; - if (($224 | 0) == 0) { - break; - } - var $RP_0_i = $223; - var $R_0_i = $224; - } - if ($RP_0_i >>> 0 < $190 >>> 0) { - _abort(); - } else { - HEAP32[$RP_0_i >> 2] = 0; - var $R_1_i = $R_0_i; - } - } else { - var $204 = HEAPU32[($v_0_i + 8 | 0) >> 2]; - if ($204 >>> 0 < $190 >>> 0) { - _abort(); - } else { - HEAP32[($204 + 12 | 0) >> 2] = $200; - HEAP32[($200 + 8 | 0) >> 2] = $204; - var $R_1_i = $200; - } - } - } while (0); - var $R_1_i; - $_$62 : do { - if (!(($198 | 0) == 0)) { - var $234 = $v_0_i + 28 | 0; - var $236 = __gm_ + 304 + (HEAP32[$234 >> 2] << 2) | 0; - do { - if (($v_0_i | 0) == (HEAP32[$236 >> 2] | 0)) { - HEAP32[$236 >> 2] = $R_1_i; - if (!(($R_1_i | 0) == 0)) { - break; - } - HEAP32[(__gm_ + 4 | 0) >> 2] = HEAP32[(__gm_ + 4 | 0) >> 2] & (1 << HEAP32[$234 >> 2] ^ -1); - break $_$62; - } - if ($198 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { - _abort(); - } else { - var $250 = $198 + 16 | 0; - if ((HEAP32[$250 >> 2] | 0) == ($v_0_i | 0)) { - HEAP32[$250 >> 2] = $R_1_i; - } else { - HEAP32[($198 + 20 | 0) >> 2] = $R_1_i; - } - if (($R_1_i | 0) == 0) { - break $_$62; - } - } - } while (0); - if ($R_1_i >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { - _abort(); - } else { - HEAP32[($R_1_i + 24 | 0) >> 2] = $198; - var $266 = HEAPU32[($v_0_i + 16 | 0) >> 2]; - if (!(($266 | 0) == 0)) { - if ($266 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { - _abort(); - } else { - HEAP32[($R_1_i + 16 | 0) >> 2] = $266; - HEAP32[($266 + 24 | 0) >> 2] = $R_1_i; - } - } - var $278 = HEAPU32[($v_0_i + 20 | 0) >> 2]; - if (($278 | 0) == 0) { - break; - } - if ($278 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { - _abort(); - } else { - HEAP32[($R_1_i + 20 | 0) >> 2] = $278; - HEAP32[($278 + 24 | 0) >> 2] = $R_1_i; - } - } + _abort(); + } + } while (0); + var $_pre_phi_i25; + var $F5_0_i; + HEAP32[$_pre_phi_i25 >> 2] = $461; + HEAP32[($F5_0_i + 12 | 0) >> 2] = $461; + HEAP32[($456 + ($342 + 8 | 0) | 0) >> 2] = $F5_0_i; + HEAP32[($456 + ($342 + 12 | 0) | 0) >> 2] = $580; + } else { + var $601 = $460; + var $602 = $rsize_3_lcssa_i >>> 8; + do { + if (($602 | 0) == 0) { + var $I7_0_i = 0; + } else { + if ($rsize_3_lcssa_i >>> 0 > 16777215) { + var $I7_0_i = 31; + break; + } + var $609 = ($602 + 1048320 | 0) >>> 16 & 8; + var $610 = $602 << $609; + var $613 = ($610 + 520192 | 0) >>> 16 & 4; + var $614 = $610 << $613; + var $617 = ($614 + 245760 | 0) >>> 16 & 2; + var $623 = (14 - ($613 | $609 | $617) | 0) + ($614 << $617 >>> 15) | 0; + var $I7_0_i = $rsize_3_lcssa_i >>> (($623 + 7 | 0) >>> 0) & 1 | $623 << 1; + } + } while (0); + var $I7_0_i; + var $630 = __gm_ + 304 + ($I7_0_i << 2) | 0; + HEAP32[($456 + ($342 + 28 | 0) | 0) >> 2] = $I7_0_i; + HEAP32[($456 + ($342 + 20 | 0) | 0) >> 2] = 0; + HEAP32[($456 + ($342 + 16 | 0) | 0) >> 2] = 0; + var $637 = HEAP32[(__gm_ + 4 | 0) >> 2]; + var $638 = 1 << $I7_0_i; + if (($637 & $638 | 0) == 0) { + HEAP32[(__gm_ + 4 | 0) >> 2] = $637 | $638; + HEAP32[$630 >> 2] = $601; + HEAP32[($456 + ($342 + 24 | 0) | 0) >> 2] = $630; + HEAP32[($456 + ($342 + 12 | 0) | 0) >> 2] = $601; + HEAP32[($456 + ($342 + 8 | 0) | 0) >> 2] = $601; + } else { + if (($I7_0_i | 0) == 31) { + var $657 = 0; + } else { + var $657 = 25 - ($I7_0_i >>> 1) | 0; + } + var $657; + var $K12_0_i = $rsize_3_lcssa_i << $657; + var $T_0_i = HEAP32[$630 >> 2]; + while (1) { + var $T_0_i; + var $K12_0_i; + if ((HEAP32[($T_0_i + 4 | 0) >> 2] & -8 | 0) == ($rsize_3_lcssa_i | 0)) { + var $683 = $T_0_i + 8 | 0; + var $684 = HEAPU32[$683 >> 2]; + var $686 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + do { + if (!($T_0_i >>> 0 < $686 >>> 0)) { + if ($684 >>> 0 < $686 >>> 0) { + break; + } + HEAP32[($684 + 12 | 0) >> 2] = $601; + HEAP32[$683 >> 2] = $601; + HEAP32[($456 + ($342 + 8 | 0) | 0) >> 2] = $684; + HEAP32[($456 + ($342 + 12 | 0) | 0) >> 2] = $T_0_i; + HEAP32[($456 + ($342 + 24 | 0) | 0) >> 2] = 0; + break $_$179; } - } while (0); - if ($rsize_0_i >>> 0 < 16) { - var $292 = $rsize_0_i + $8 | 0; - HEAP32[($v_0_i + 4 | 0) >> 2] = $292 | 3; - var $296 = $189 + ($292 + 4 | 0) | 0; - HEAP32[$296 >> 2] = HEAP32[$296 >> 2] | 1; + } while (0); + _abort(); } else { - HEAP32[($v_0_i + 4 | 0) >> 2] = $8 | 3; - HEAP32[($189 + ($8 | 4) | 0) >> 2] = $rsize_0_i | 1; - HEAP32[($189 + ($rsize_0_i + $8 | 0) | 0) >> 2] = $rsize_0_i; - var $307 = HEAPU32[(__gm_ + 8 | 0) >> 2]; - if (!(($307 | 0) == 0)) { - var $310 = HEAPU32[(__gm_ + 20 | 0) >> 2]; - var $313 = $307 >>> 2 & 1073741822; - var $315 = __gm_ + 40 + ($313 << 2) | 0; - var $316 = HEAPU32[(__gm_ | 0) >> 2]; - var $317 = 1 << ($307 >>> 3); - do { - if (($316 & $317 | 0) == 0) { - HEAP32[(__gm_ | 0) >> 2] = $316 | $317; - var $F1_0_i = $315; - var $_pre_phi_i = __gm_ + 40 + (($313 + 2 | 0) << 2) | 0; - } else { - var $323 = __gm_ + 40 + (($313 + 2 | 0) << 2) | 0; - var $324 = HEAPU32[$323 >> 2]; - if (!($324 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0)) { - var $F1_0_i = $324; - var $_pre_phi_i = $323; - break; - } - _abort(); - } - } while (0); - var $_pre_phi_i; - var $F1_0_i; - HEAP32[$_pre_phi_i >> 2] = $310; - HEAP32[($F1_0_i + 12 | 0) >> 2] = $310; - HEAP32[($310 + 8 | 0) >> 2] = $F1_0_i; - HEAP32[($310 + 12 | 0) >> 2] = $315; - } - HEAP32[(__gm_ + 8 | 0) >> 2] = $rsize_0_i; - HEAP32[(__gm_ + 20 | 0) >> 2] = $194; - } - var $335 = $v_0_i + 8 | 0; - if (($335 | 0) == 0) { - var $nb_0 = $8; - __label__ = 155; - break $_$2; + var $666 = $T_0_i + 16 + ($K12_0_i >>> 31 << 2) | 0; + var $667 = HEAPU32[$666 >> 2]; + if (!(($667 | 0) == 0)) { + var $K12_0_i = $K12_0_i << 1; + var $T_0_i = $667; + continue; + } + if (!($666 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0)) { + HEAP32[$666 >> 2] = $601; + HEAP32[($456 + ($342 + 24 | 0) | 0) >> 2] = $T_0_i; + HEAP32[($456 + ($342 + 12 | 0) | 0) >> 2] = $601; + HEAP32[($456 + ($342 + 8 | 0) | 0) >> 2] = $601; + break $_$179; + } + _abort(); } - var $mem_0 = $335; - __label__ = 331; - break $_$2; + } } - } while (0); - _abort(); - } else { - if ($bytes >>> 0 > 4294967231) { - var $nb_0 = -1; - __label__ = 155; - break; + } } - var $341 = $bytes + 11 | 0; - var $342 = $341 & -8; - var $343 = HEAPU32[(__gm_ + 4 | 0) >> 2]; - if (($343 | 0) == 0) { - var $nb_0 = $342; - __label__ = 155; + } while (0); + var $700 = $v_3_lcssa_i + 8 | 0; + if (($700 | 0) == 0) { + var $nb_0 = $342; + __label__ = 155; + break $_$2; + } + var $mem_0 = $700; + __label__ = 331; + break $_$2; + } + } while (0); + _abort(); + } + } while (0); + $_$215 : do { + if (__label__ == 155) { + var $nb_0; + var $703 = HEAPU32[(__gm_ + 8 | 0) >> 2]; + if ($nb_0 >>> 0 > $703 >>> 0) { + var $732 = HEAPU32[(__gm_ + 12 | 0) >> 2]; + if ($nb_0 >>> 0 < $732 >>> 0) { + var $735 = $732 - $nb_0 | 0; + HEAP32[(__gm_ + 12 | 0) >> 2] = $735; + var $736 = HEAPU32[(__gm_ + 24 | 0) >> 2]; + var $737 = $736; + HEAP32[(__gm_ + 24 | 0) >> 2] = $737 + $nb_0 | 0; + HEAP32[($737 + ($nb_0 + 4 | 0) | 0) >> 2] = $735 | 1; + HEAP32[($736 + 4 | 0) >> 2] = $nb_0 | 3; + var $mem_0 = $736 + 8 | 0; + } else { + do { + if ((HEAP32[(_mparams | 0) >> 2] | 0) == 0) { + if (!((HEAP32[(_mparams | 0) >> 2] | 0) == 0)) { break; + } + var $754 = _sysconf(8); + if ((($754 - 1 | 0) & $754 | 0) == 0) { + HEAP32[(_mparams + 8 | 0) >> 2] = $754; + HEAP32[(_mparams + 4 | 0) >> 2] = $754; + HEAP32[(_mparams + 12 | 0) >> 2] = -1; + HEAP32[(_mparams + 16 | 0) >> 2] = 2097152; + HEAP32[(_mparams + 20 | 0) >> 2] = 0; + HEAP32[(__gm_ + 440 | 0) >> 2] = 0; + var $762 = _time(0) & -16 ^ 1431655768; + HEAP32[(_mparams | 0) >> 2] = $762; + } else { + _abort(); + } } - var $346 = -$342 | 0; - var $347 = $341 >>> 8; - do { - if (($347 | 0) == 0) { - var $idx_0_i = 0; - } else { - if ($342 >>> 0 > 16777215) { - var $idx_0_i = 31; + } while (0); + $_$234 : do { + if ((HEAP32[(__gm_ + 440 | 0) >> 2] & 4 | 0) == 0) { + var $767 = HEAP32[(__gm_ + 24 | 0) >> 2]; + $_$236 : do { + if (!(($767 | 0) == 0)) { + var $770 = $767; + var $sp_0_i_i = __gm_ + 444 | 0; + while (1) { + var $sp_0_i_i; + var $772 = $sp_0_i_i | 0; + var $773 = HEAPU32[$772 >> 2]; + if (!($773 >>> 0 > $770 >>> 0)) { + var $776 = $sp_0_i_i + 4 | 0; + if (($773 + HEAP32[$776 >> 2] | 0) >>> 0 > $770 >>> 0) { break; + } } - var $354 = ($347 + 1048320 | 0) >>> 16 & 8; - var $355 = $347 << $354; - var $358 = ($355 + 520192 | 0) >>> 16 & 4; - var $359 = $355 << $358; - var $362 = ($359 + 245760 | 0) >>> 16 & 2; - var $368 = (14 - ($358 | $354 | $362) | 0) + ($359 << $362 >>> 15) | 0; - var $idx_0_i = $342 >>> (($368 + 7 | 0) >>> 0) & 1 | $368 << 1; - } - } while (0); - var $idx_0_i; - var $376 = HEAPU32[(__gm_ + 304 + ($idx_0_i << 2) | 0) >> 2]; - $_$110 : do { - if (($376 | 0) == 0) { - var $v_2_i = 0; - var $rsize_2_i = $346; - var $t_1_i = 0; - } else { - if (($idx_0_i | 0) == 31) { - var $384 = 0; - } else { - var $384 = 25 - ($idx_0_i >>> 1) | 0; - } - var $384; - var $v_0_i15 = 0; - var $rsize_0_i14 = $346; - var $t_0_i13 = $376; - var $sizebits_0_i = $342 << $384; - var $rst_0_i = 0; - while (1) { - var $rst_0_i; - var $sizebits_0_i; - var $t_0_i13; - var $rsize_0_i14; - var $v_0_i15; - var $389 = HEAP32[($t_0_i13 + 4 | 0) >> 2] & -8; - var $390 = $389 - $342 | 0; - if ($390 >>> 0 < $rsize_0_i14 >>> 0) { - if (($389 | 0) == ($342 | 0)) { - var $v_2_i = $t_0_i13; - var $rsize_2_i = $390; - var $t_1_i = $t_0_i13; - break $_$110; - } - var $v_1_i = $t_0_i13; - var $rsize_1_i = $390; - } else { - var $v_1_i = $v_0_i15; - var $rsize_1_i = $rsize_0_i14; - } - var $rsize_1_i; - var $v_1_i; - var $396 = HEAPU32[($t_0_i13 + 20 | 0) >> 2]; - var $399 = HEAPU32[($t_0_i13 + 16 + ($sizebits_0_i >>> 31 << 2) | 0) >> 2]; - var $rst_1_i = ($396 | 0) == 0 | ($396 | 0) == ($399 | 0) ? $rst_0_i : $396; - if (($399 | 0) == 0) { - var $v_2_i = $v_1_i; - var $rsize_2_i = $rsize_1_i; - var $t_1_i = $rst_1_i; - break $_$110; - } - var $v_0_i15 = $v_1_i; - var $rsize_0_i14 = $rsize_1_i; - var $t_0_i13 = $399; - var $sizebits_0_i = $sizebits_0_i << 1; - var $rst_0_i = $rst_1_i; + var $782 = HEAPU32[($sp_0_i_i + 8 | 0) >> 2]; + if (($782 | 0) == 0) { + __label__ = 174; + break $_$236; } - } - } while (0); - var $t_1_i; - var $rsize_2_i; - var $v_2_i; - if (($t_1_i | 0) == 0 & ($v_2_i | 0) == 0) { - var $407 = 2 << $idx_0_i; - var $410 = $343 & ($407 | (-$407 | 0)); - if (($410 | 0) == 0) { - var $nb_0 = $342; - __label__ = 155; + var $sp_0_i_i = $782; + } + if (($sp_0_i_i | 0) == 0) { + __label__ = 174; break; - } - var $415 = ($410 & (-$410 | 0)) - 1 | 0; - var $417 = $415 >>> 12 & 16; - var $418 = $415 >>> ($417 >>> 0); - var $420 = $418 >>> 5 & 8; - var $421 = $418 >>> ($420 >>> 0); - var $423 = $421 >>> 2 & 4; - var $424 = $421 >>> ($423 >>> 0); - var $426 = $424 >>> 1 & 2; - var $427 = $424 >>> ($426 >>> 0); - var $429 = $427 >>> 1 & 1; - var $t_2_ph_i = HEAP32[(__gm_ + 304 + ((($420 | $417 | $423 | $426 | $429) + ($427 >>> ($429 >>> 0)) | 0) << 2) | 0) >> 2]; - } else { - var $t_2_ph_i = $t_1_i; - } - var $t_2_ph_i; - $_$125 : do { - if (($t_2_ph_i | 0) == 0) { - var $rsize_3_lcssa_i = $rsize_2_i; - var $v_3_lcssa_i = $v_2_i; - } else { - var $t_224_i = $t_2_ph_i; - var $rsize_325_i = $rsize_2_i; - var $v_326_i = $v_2_i; - while (1) { - var $v_326_i; - var $rsize_325_i; - var $t_224_i; - var $442 = (HEAP32[($t_224_i + 4 | 0) >> 2] & -8) - $342 | 0; - var $443 = $442 >>> 0 < $rsize_325_i >>> 0; - var $_rsize_3_i = $443 ? $442 : $rsize_325_i; - var $t_2_v_3_i = $443 ? $t_224_i : $v_326_i; - var $445 = HEAPU32[($t_224_i + 16 | 0) >> 2]; - if (!(($445 | 0) == 0)) { - var $t_224_i = $445; - var $rsize_325_i = $_rsize_3_i; - var $v_326_i = $t_2_v_3_i; - continue; - } - var $448 = HEAPU32[($t_224_i + 20 | 0) >> 2]; - if (($448 | 0) == 0) { - var $rsize_3_lcssa_i = $_rsize_3_i; - var $v_3_lcssa_i = $t_2_v_3_i; - break $_$125; - } - var $t_224_i = $448; - var $rsize_325_i = $_rsize_3_i; - var $v_326_i = $t_2_v_3_i; + } + var $811 = HEAP32[(_mparams + 8 | 0) >> 2]; + var $816 = ((($nb_0 + 47 | 0) - HEAP32[(__gm_ + 12 | 0) >> 2] | 0) + $811 | 0) & (-$811 | 0); + if (!($816 >>> 0 < 2147483647)) { + var $tsize_0242932_ph_i = 0; + __label__ = 189; + break; + } + var $819 = _sbrk($816); + var $823 = ($819 | 0) == (HEAP32[$772 >> 2] + HEAP32[$776 >> 2] | 0 | 0); + var $tbase_0_i = $823 ? $819 : -1; + var $tsize_0_i = $823 ? $816 : 0; + var $asize_1_i = $816; + var $br_0_i = $819; + __label__ = 181; + break; + } + __label__ = 174; + } while (0); + do { + if (__label__ == 174) { + var $785 = _sbrk(0); + if (($785 | 0) == -1) { + var $tsize_0242932_ph_i = 0; + __label__ = 189; + break; + } + var $788 = HEAP32[(_mparams + 8 | 0) >> 2]; + var $792 = (($nb_0 + 47 | 0) + $788 | 0) & (-$788 | 0); + var $793 = $785; + var $794 = HEAP32[(_mparams + 4 | 0) >> 2]; + var $795 = $794 - 1 | 0; + if (($795 & $793 | 0) == 0) { + var $asize_0_i = $792; + } else { + var $asize_0_i = ($792 - $793 | 0) + (($795 + $793 | 0) & (-$794 | 0)) | 0; + } + var $asize_0_i; + if (!($asize_0_i >>> 0 < 2147483647)) { + var $tsize_0242932_ph_i = 0; + __label__ = 189; + break; + } + var $807 = _sbrk($asize_0_i); + var $808 = ($807 | 0) == ($785 | 0); + var $tbase_0_i = $808 ? $785 : -1; + var $tsize_0_i = $808 ? $asize_0_i : 0; + var $asize_1_i = $asize_0_i; + var $br_0_i = $807; + __label__ = 181; + break; + } + } while (0); + $_$253 : do { + if (__label__ == 181) { + var $br_0_i; + var $asize_1_i; + var $tsize_0_i; + var $tbase_0_i; + var $825 = -$asize_1_i | 0; + if (!(($tbase_0_i | 0) == -1)) { + var $tsize_242_i = $tsize_0_i; + var $tbase_243_i = $tbase_0_i; + __label__ = 194; + break $_$234; + } + do { + if (($br_0_i | 0) != -1 & $asize_1_i >>> 0 < 2147483647) { + if (!($asize_1_i >>> 0 < ($nb_0 + 48 | 0) >>> 0)) { + var $asize_2_i = $asize_1_i; + break; + } + var $834 = HEAP32[(_mparams + 8 | 0) >> 2]; + var $839 = ((($nb_0 + 47 | 0) - $asize_1_i | 0) + $834 | 0) & (-$834 | 0); + if (!($839 >>> 0 < 2147483647)) { + var $asize_2_i = $asize_1_i; + break; + } + if ((_sbrk($839) | 0) == -1) { + _sbrk($825); + var $tsize_0242932_ph_i = $tsize_0_i; + break $_$253; + } + var $asize_2_i = $839 + $asize_1_i | 0; + } else { + var $asize_2_i = $asize_1_i; } + } while (0); + var $asize_2_i; + if (!(($br_0_i | 0) == -1)) { + var $tsize_242_i = $asize_2_i; + var $tbase_243_i = $br_0_i; + __label__ = 194; + break $_$234; + } + HEAP32[(__gm_ + 440 | 0) >> 2] = HEAP32[(__gm_ + 440 | 0) >> 2] | 4; + var $tsize_137_i = $tsize_0_i; + __label__ = 191; + break $_$234; } - } while (0); - var $v_3_lcssa_i; - var $rsize_3_lcssa_i; - if (($v_3_lcssa_i | 0) == 0) { - var $nb_0 = $342; - __label__ = 155; - break; + } while (0); + var $tsize_0242932_ph_i; + HEAP32[(__gm_ + 440 | 0) >> 2] = HEAP32[(__gm_ + 440 | 0) >> 2] | 4; + var $tsize_137_i = $tsize_0242932_ph_i; + __label__ = 191; + break; } - if (!($rsize_3_lcssa_i >>> 0 < (HEAP32[(__gm_ + 8 | 0) >> 2] - $342 | 0) >>> 0)) { - var $nb_0 = $342; - __label__ = 155; + var $tsize_137_i = 0; + __label__ = 191; + } while (0); + do { + if (__label__ == 191) { + var $tsize_137_i; + var $854 = HEAP32[(_mparams + 8 | 0) >> 2]; + var $858 = (($nb_0 + 47 | 0) + $854 | 0) & (-$854 | 0); + if (!($858 >>> 0 < 2147483647)) { + __label__ = 330; + break; + } + var $861 = _sbrk($858); + var $862 = _sbrk(0); + if (!(($862 | 0) != -1 & ($861 | 0) != -1 & $861 >>> 0 < $862 >>> 0)) { + __label__ = 330; break; + } + var $866 = $862 - $861 | 0; + var $868 = $866 >>> 0 > ($nb_0 + 40 | 0) >>> 0; + var $_tbase_1_i = $868 ? $861 : -1; + if (($_tbase_1_i | 0) == -1) { + __label__ = 330; + break; + } + var $tsize_242_i = $868 ? $866 : $tsize_137_i; + var $tbase_243_i = $_tbase_1_i; + __label__ = 194; + break; } - var $456 = $v_3_lcssa_i; - var $457 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - do { - if (!($456 >>> 0 < $457 >>> 0)) { - var $460 = $456 + $342 | 0; - var $461 = $460; - if (!($456 >>> 0 < $460 >>> 0)) { + } while (0); + do { + if (__label__ == 194) { + var $tbase_243_i; + var $tsize_242_i; + var $871 = HEAP32[(__gm_ + 432 | 0) >> 2] + $tsize_242_i | 0; + HEAP32[(__gm_ + 432 | 0) >> 2] = $871; + if ($871 >>> 0 > HEAPU32[(__gm_ + 436 | 0) >> 2] >>> 0) { + HEAP32[(__gm_ + 436 | 0) >> 2] = $871; + } + var $876 = HEAPU32[(__gm_ + 24 | 0) >> 2]; + $_$275 : do { + if (($876 | 0) == 0) { + var $879 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + if (($879 | 0) == 0 | $tbase_243_i >>> 0 < $879 >>> 0) { + HEAP32[(__gm_ + 16 | 0) >> 2] = $tbase_243_i; + } + HEAP32[(__gm_ + 444 | 0) >> 2] = $tbase_243_i; + HEAP32[(__gm_ + 448 | 0) >> 2] = $tsize_242_i; + HEAP32[(__gm_ + 456 | 0) >> 2] = 0; + HEAP32[(__gm_ + 36 | 0) >> 2] = HEAP32[(_mparams | 0) >> 2]; + HEAP32[(__gm_ + 32 | 0) >> 2] = -1; + var $i_02_i_i = 0; + while (1) { + var $i_02_i_i; + var $886 = $i_02_i_i << 1; + var $888 = __gm_ + 40 + ($886 << 2) | 0; + HEAP32[(__gm_ + 40 + (($886 + 3 | 0) << 2) | 0) >> 2] = $888; + HEAP32[(__gm_ + 40 + (($886 + 2 | 0) << 2) | 0) >> 2] = $888; + var $891 = $i_02_i_i + 1 | 0; + if (($891 | 0) == 32) { + break; + } + var $i_02_i_i = $891; + } + var $893 = $tbase_243_i + 8 | 0; + if (($893 & 7 | 0) == 0) { + var $899 = 0; + } else { + var $899 = (-$893 | 0) & 7; + } + var $899; + var $903 = ($tsize_242_i - 40 | 0) - $899 | 0; + HEAP32[(__gm_ + 24 | 0) >> 2] = $tbase_243_i + $899 | 0; + HEAP32[(__gm_ + 12 | 0) >> 2] = $903; + HEAP32[($tbase_243_i + ($899 + 4 | 0) | 0) >> 2] = $903 | 1; + HEAP32[($tbase_243_i + ($tsize_242_i - 36 | 0) | 0) >> 2] = 40; + HEAP32[(__gm_ + 28 | 0) >> 2] = HEAP32[(_mparams + 16 | 0) >> 2]; + } else { + var $sp_0_i = __gm_ + 444 | 0; + while (1) { + var $sp_0_i; + if (($sp_0_i | 0) == 0) { + break; + } + var $913 = HEAPU32[($sp_0_i | 0) >> 2]; + var $914 = $sp_0_i + 4 | 0; + var $915 = HEAPU32[$914 >> 2]; + if (($tbase_243_i | 0) == ($913 + $915 | 0 | 0)) { + if (!((HEAP32[($sp_0_i + 12 | 0) >> 2] & 8 | 0) == 0)) { + break; + } + var $926 = $876; + if (!($926 >>> 0 >= $913 >>> 0 & $926 >>> 0 < $tbase_243_i >>> 0)) { break; + } + HEAP32[$914 >> 2] = $915 + $tsize_242_i | 0; + var $931 = HEAP32[(__gm_ + 24 | 0) >> 2]; + var $933 = HEAP32[(__gm_ + 12 | 0) >> 2] + $tsize_242_i | 0; + var $934 = $931; + var $936 = $931 + 8 | 0; + if (($936 & 7 | 0) == 0) { + var $942 = 0; + } else { + var $942 = (-$936 | 0) & 7; + } + var $942; + var $945 = $933 - $942 | 0; + HEAP32[(__gm_ + 24 | 0) >> 2] = $934 + $942 | 0; + HEAP32[(__gm_ + 12 | 0) >> 2] = $945; + HEAP32[($934 + ($942 + 4 | 0) | 0) >> 2] = $945 | 1; + HEAP32[($934 + ($933 + 4 | 0) | 0) >> 2] = 40; + HEAP32[(__gm_ + 28 | 0) >> 2] = HEAP32[(_mparams + 16 | 0) >> 2]; + break $_$275; } - var $465 = HEAPU32[($v_3_lcssa_i + 24 | 0) >> 2]; - var $467 = HEAPU32[($v_3_lcssa_i + 12 | 0) >> 2]; - do { - if (($467 | 0) == ($v_3_lcssa_i | 0)) { - var $479 = $v_3_lcssa_i + 20 | 0; - var $480 = HEAP32[$479 >> 2]; - if (($480 | 0) == 0) { - var $483 = $v_3_lcssa_i + 16 | 0; - var $484 = HEAP32[$483 >> 2]; - if (($484 | 0) == 0) { - var $R_1_i19 = 0; - break; - } - var $RP_0_i17 = $483; - var $R_0_i16 = $484; - } else { - var $RP_0_i17 = $479; - var $R_0_i16 = $480; - __label__ = 103; - } - while (1) { - var $R_0_i16; - var $RP_0_i17; - var $486 = $R_0_i16 + 20 | 0; - var $487 = HEAP32[$486 >> 2]; - if (!(($487 | 0) == 0)) { - var $RP_0_i17 = $486; - var $R_0_i16 = $487; - continue; - } - var $490 = $R_0_i16 + 16 | 0; - var $491 = HEAPU32[$490 >> 2]; - if (($491 | 0) == 0) { - break; - } - var $RP_0_i17 = $490; - var $R_0_i16 = $491; - } - if ($RP_0_i17 >>> 0 < $457 >>> 0) { - _abort(); - } else { - HEAP32[$RP_0_i17 >> 2] = 0; - var $R_1_i19 = $R_0_i16; - } + var $sp_0_i = HEAP32[($sp_0_i + 8 | 0) >> 2]; + } + if ($tbase_243_i >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { + HEAP32[(__gm_ + 16 | 0) >> 2] = $tbase_243_i; + } + var $955 = $tbase_243_i + $tsize_242_i | 0; + var $sp_1_i = __gm_ + 444 | 0; + while (1) { + var $sp_1_i; + if (($sp_1_i | 0) == 0) { + __label__ = 293; + break; + } + var $959 = $sp_1_i | 0; + if ((HEAP32[$959 >> 2] | 0) == ($955 | 0)) { + __label__ = 218; + break; + } + var $sp_1_i = HEAP32[($sp_1_i + 8 | 0) >> 2]; + } + do { + if (__label__ == 218) { + if (!((HEAP32[($sp_1_i + 12 | 0) >> 2] & 8 | 0) == 0)) { + break; + } + HEAP32[$959 >> 2] = $tbase_243_i; + var $970 = $sp_1_i + 4 | 0; + HEAP32[$970 >> 2] = HEAP32[$970 >> 2] + $tsize_242_i | 0; + var $974 = $tbase_243_i + 8 | 0; + if (($974 & 7 | 0) == 0) { + var $981 = 0; + } else { + var $981 = (-$974 | 0) & 7; + } + var $981; + var $984 = $tbase_243_i + ($tsize_242_i + 8 | 0) | 0; + if (($984 & 7 | 0) == 0) { + var $991 = 0; + } else { + var $991 = (-$984 | 0) & 7; + } + var $991; + var $992 = $tbase_243_i + ($991 + $tsize_242_i | 0) | 0; + var $993 = $992; + var $_sum_i16_i = $981 + $nb_0 | 0; + var $997 = $tbase_243_i + $_sum_i16_i | 0; + var $998 = $997; + var $999 = ($992 - ($tbase_243_i + $981 | 0) | 0) - $nb_0 | 0; + HEAP32[($tbase_243_i + ($981 + 4 | 0) | 0) >> 2] = $nb_0 | 3; + $_$314 : do { + if (($993 | 0) == (HEAP32[(__gm_ + 24 | 0) >> 2] | 0)) { + var $1007 = HEAP32[(__gm_ + 12 | 0) >> 2] + $999 | 0; + HEAP32[(__gm_ + 12 | 0) >> 2] = $1007; + HEAP32[(__gm_ + 24 | 0) >> 2] = $998; + HEAP32[($tbase_243_i + ($_sum_i16_i + 4 | 0) | 0) >> 2] = $1007 | 1; } else { - var $471 = HEAPU32[($v_3_lcssa_i + 8 | 0) >> 2]; - if ($471 >>> 0 < $457 >>> 0) { - _abort(); - } else { - HEAP32[($471 + 12 | 0) >> 2] = $467; - HEAP32[($467 + 8 | 0) >> 2] = $471; - var $R_1_i19 = $467; - } - } - } while (0); - var $R_1_i19; - $_$151 : do { - if (!(($465 | 0) == 0)) { - var $501 = $v_3_lcssa_i + 28 | 0; - var $503 = __gm_ + 304 + (HEAP32[$501 >> 2] << 2) | 0; - do { - if (($v_3_lcssa_i | 0) == (HEAP32[$503 >> 2] | 0)) { - HEAP32[$503 >> 2] = $R_1_i19; - if (!(($R_1_i19 | 0) == 0)) { + if (($993 | 0) == (HEAP32[(__gm_ + 20 | 0) >> 2] | 0)) { + var $1016 = HEAP32[(__gm_ + 8 | 0) >> 2] + $999 | 0; + HEAP32[(__gm_ + 8 | 0) >> 2] = $1016; + HEAP32[(__gm_ + 20 | 0) >> 2] = $998; + HEAP32[($tbase_243_i + ($_sum_i16_i + 4 | 0) | 0) >> 2] = $1016 | 1; + HEAP32[($tbase_243_i + ($1016 + $_sum_i16_i | 0) | 0) >> 2] = $1016; + } else { + var $_sum2_i18_i = $tsize_242_i + 4 | 0; + var $1025 = HEAPU32[($tbase_243_i + ($_sum2_i18_i + $991 | 0) | 0) >> 2]; + if (($1025 & 3 | 0) == 1) { + var $1029 = $1025 & -8; + var $1030 = $1025 >>> 3; + $_$322 : do { + if ($1025 >>> 0 < 256) { + var $1035 = HEAPU32[($tbase_243_i + (($991 | 8) + $tsize_242_i | 0) | 0) >> 2]; + var $1038 = HEAPU32[($tbase_243_i + (($tsize_242_i + 12 | 0) + $991 | 0) | 0) >> 2]; + if (($1035 | 0) == ($1038 | 0)) { + HEAP32[(__gm_ | 0) >> 2] = HEAP32[(__gm_ | 0) >> 2] & (1 << $1030 ^ -1); + } else { + var $1049 = __gm_ + 40 + (($1025 >>> 2 & 1073741822) << 2) | 0; + do { + if (($1035 | 0) == ($1049 | 0)) { + __label__ = 233; + } else { + if ($1035 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { + __label__ = 236; + break; + } + __label__ = 233; break; - } - HEAP32[(__gm_ + 4 | 0) >> 2] = HEAP32[(__gm_ + 4 | 0) >> 2] & (1 << HEAP32[$501 >> 2] ^ -1); - break $_$151; - } - if ($465 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { + } + } while (0); + do { + if (__label__ == 233) { + if (!(($1038 | 0) == ($1049 | 0))) { + if ($1038 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { + break; + } + } + HEAP32[($1035 + 12 | 0) >> 2] = $1038; + HEAP32[($1038 + 8 | 0) >> 2] = $1035; + break $_$322; + } + } while (0); _abort(); + } } else { - var $517 = $465 + 16 | 0; - if ((HEAP32[$517 >> 2] | 0) == ($v_3_lcssa_i | 0)) { - HEAP32[$517 >> 2] = $R_1_i19; + var $1064 = $992; + var $1067 = HEAPU32[($tbase_243_i + (($991 | 24) + $tsize_242_i | 0) | 0) >> 2]; + var $1070 = HEAPU32[($tbase_243_i + (($tsize_242_i + 12 | 0) + $991 | 0) | 0) >> 2]; + do { + if (($1070 | 0) == ($1064 | 0)) { + var $_sum67_i_i = $991 | 16; + var $1085 = $tbase_243_i + ($_sum2_i18_i + $_sum67_i_i | 0) | 0; + var $1086 = HEAP32[$1085 >> 2]; + if (($1086 | 0) == 0) { + var $1090 = $tbase_243_i + ($_sum67_i_i + $tsize_242_i | 0) | 0; + var $1091 = HEAP32[$1090 >> 2]; + if (($1091 | 0) == 0) { + var $R_1_i_i = 0; + break; + } + var $RP_0_i_i = $1090; + var $R_0_i_i = $1091; + } else { + var $RP_0_i_i = $1085; + var $R_0_i_i = $1086; + __label__ = 243; + } + while (1) { + var $R_0_i_i; + var $RP_0_i_i; + var $1093 = $R_0_i_i + 20 | 0; + var $1094 = HEAP32[$1093 >> 2]; + if (!(($1094 | 0) == 0)) { + var $RP_0_i_i = $1093; + var $R_0_i_i = $1094; + continue; + } + var $1097 = $R_0_i_i + 16 | 0; + var $1098 = HEAPU32[$1097 >> 2]; + if (($1098 | 0) == 0) { + break; + } + var $RP_0_i_i = $1097; + var $R_0_i_i = $1098; + } + if ($RP_0_i_i >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { + _abort(); + } else { + HEAP32[$RP_0_i_i >> 2] = 0; + var $R_1_i_i = $R_0_i_i; + } } else { - HEAP32[($465 + 20 | 0) >> 2] = $R_1_i19; + var $1075 = HEAPU32[($tbase_243_i + (($991 | 8) + $tsize_242_i | 0) | 0) >> 2]; + if ($1075 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { + _abort(); + } else { + HEAP32[($1075 + 12 | 0) >> 2] = $1070; + HEAP32[($1070 + 8 | 0) >> 2] = $1075; + var $R_1_i_i = $1070; + } } - if (($R_1_i19 | 0) == 0) { - break $_$151; + } while (0); + var $R_1_i_i; + if (($1067 | 0) == 0) { + break; + } + var $1110 = $tbase_243_i + (($tsize_242_i + 28 | 0) + $991 | 0) | 0; + var $1112 = __gm_ + 304 + (HEAP32[$1110 >> 2] << 2) | 0; + do { + if (($1064 | 0) == (HEAP32[$1112 >> 2] | 0)) { + HEAP32[$1112 >> 2] = $R_1_i_i; + if (!(($R_1_i_i | 0) == 0)) { + break; + } + HEAP32[(__gm_ + 4 | 0) >> 2] = HEAP32[(__gm_ + 4 | 0) >> 2] & (1 << HEAP32[$1110 >> 2] ^ -1); + break $_$322; } - } - } while (0); - if ($R_1_i19 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { - _abort(); - } else { - HEAP32[($R_1_i19 + 24 | 0) >> 2] = $465; - var $533 = HEAPU32[($v_3_lcssa_i + 16 | 0) >> 2]; - if (!(($533 | 0) == 0)) { - if ($533 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { - _abort(); + if ($1067 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { + _abort(); } else { - HEAP32[($R_1_i19 + 16 | 0) >> 2] = $533; - HEAP32[($533 + 24 | 0) >> 2] = $R_1_i19; + var $1126 = $1067 + 16 | 0; + if ((HEAP32[$1126 >> 2] | 0) == ($1064 | 0)) { + HEAP32[$1126 >> 2] = $R_1_i_i; + } else { + HEAP32[($1067 + 20 | 0) >> 2] = $R_1_i_i; + } + if (($R_1_i_i | 0) == 0) { + break $_$322; + } } - } - var $545 = HEAPU32[($v_3_lcssa_i + 20 | 0) >> 2]; - if (($545 | 0) == 0) { - break; - } - if ($545 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { + } while (0); + if ($R_1_i_i >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { _abort(); - } else { - HEAP32[($R_1_i19 + 20 | 0) >> 2] = $545; - HEAP32[($545 + 24 | 0) >> 2] = $R_1_i19; - } - } - } - } while (0); - $_$179 : do { - if ($rsize_3_lcssa_i >>> 0 < 16) { - var $559 = $rsize_3_lcssa_i + $342 | 0; - HEAP32[($v_3_lcssa_i + 4 | 0) >> 2] = $559 | 3; - var $563 = $456 + ($559 + 4 | 0) | 0; - HEAP32[$563 >> 2] = HEAP32[$563 >> 2] | 1; - } else { - HEAP32[($v_3_lcssa_i + 4 | 0) >> 2] = $342 | 3; - HEAP32[($456 + ($342 | 4) | 0) >> 2] = $rsize_3_lcssa_i | 1; - HEAP32[($456 + ($rsize_3_lcssa_i + $342 | 0) | 0) >> 2] = $rsize_3_lcssa_i; - if ($rsize_3_lcssa_i >>> 0 < 256) { - var $578 = $rsize_3_lcssa_i >>> 2 & 1073741822; - var $580 = __gm_ + 40 + ($578 << 2) | 0; - var $581 = HEAPU32[(__gm_ | 0) >> 2]; - var $582 = 1 << ($rsize_3_lcssa_i >>> 3); - do { - if (($581 & $582 | 0) == 0) { - HEAP32[(__gm_ | 0) >> 2] = $581 | $582; - var $F5_0_i = $580; - var $_pre_phi_i25 = __gm_ + 40 + (($578 + 2 | 0) << 2) | 0; - } else { - var $588 = __gm_ + 40 + (($578 + 2 | 0) << 2) | 0; - var $589 = HEAPU32[$588 >> 2]; - if (!($589 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0)) { - var $F5_0_i = $589; - var $_pre_phi_i25 = $588; - break; - } + } else { + HEAP32[($R_1_i_i + 24 | 0) >> 2] = $1067; + var $_sum3132_i_i = $991 | 16; + var $1143 = HEAPU32[($tbase_243_i + ($_sum3132_i_i + $tsize_242_i | 0) | 0) >> 2]; + if (!(($1143 | 0) == 0)) { + if ($1143 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { _abort(); + } else { + HEAP32[($R_1_i_i + 16 | 0) >> 2] = $1143; + HEAP32[($1143 + 24 | 0) >> 2] = $R_1_i_i; + } } - } while (0); - var $_pre_phi_i25; - var $F5_0_i; - HEAP32[$_pre_phi_i25 >> 2] = $461; - HEAP32[($F5_0_i + 12 | 0) >> 2] = $461; - HEAP32[($456 + ($342 + 8 | 0) | 0) >> 2] = $F5_0_i; - HEAP32[($456 + ($342 + 12 | 0) | 0) >> 2] = $580; - } else { - var $601 = $460; - var $602 = $rsize_3_lcssa_i >>> 8; - do { - if (($602 | 0) == 0) { - var $I7_0_i = 0; - } else { - if ($rsize_3_lcssa_i >>> 0 > 16777215) { - var $I7_0_i = 31; - break; - } - var $609 = ($602 + 1048320 | 0) >>> 16 & 8; - var $610 = $602 << $609; - var $613 = ($610 + 520192 | 0) >>> 16 & 4; - var $614 = $610 << $613; - var $617 = ($614 + 245760 | 0) >>> 16 & 2; - var $623 = (14 - ($613 | $609 | $617) | 0) + ($614 << $617 >>> 15) | 0; - var $I7_0_i = $rsize_3_lcssa_i >>> (($623 + 7 | 0) >>> 0) & 1 | $623 << 1; + var $1156 = HEAPU32[($tbase_243_i + ($_sum2_i18_i + $_sum3132_i_i | 0) | 0) >> 2]; + if (($1156 | 0) == 0) { + break; } - } while (0); - var $I7_0_i; - var $630 = __gm_ + 304 + ($I7_0_i << 2) | 0; - HEAP32[($456 + ($342 + 28 | 0) | 0) >> 2] = $I7_0_i; - HEAP32[($456 + ($342 + 20 | 0) | 0) >> 2] = 0; - HEAP32[($456 + ($342 + 16 | 0) | 0) >> 2] = 0; - var $637 = HEAP32[(__gm_ + 4 | 0) >> 2]; - var $638 = 1 << $I7_0_i; - if (($637 & $638 | 0) == 0) { - HEAP32[(__gm_ + 4 | 0) >> 2] = $637 | $638; - HEAP32[$630 >> 2] = $601; - HEAP32[($456 + ($342 + 24 | 0) | 0) >> 2] = $630; - HEAP32[($456 + ($342 + 12 | 0) | 0) >> 2] = $601; - HEAP32[($456 + ($342 + 8 | 0) | 0) >> 2] = $601; - } else { - if (($I7_0_i | 0) == 31) { - var $657 = 0; + if ($1156 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { + _abort(); } else { - var $657 = 25 - ($I7_0_i >>> 1) | 0; - } - var $657; - var $K12_0_i = $rsize_3_lcssa_i << $657; - var $T_0_i = HEAP32[$630 >> 2]; - while (1) { - var $T_0_i; - var $K12_0_i; - if ((HEAP32[($T_0_i + 4 | 0) >> 2] & -8 | 0) == ($rsize_3_lcssa_i | 0)) { - var $683 = $T_0_i + 8 | 0; - var $684 = HEAPU32[$683 >> 2]; - var $686 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - do { - if (!($T_0_i >>> 0 < $686 >>> 0)) { - if ($684 >>> 0 < $686 >>> 0) { - break; - } - HEAP32[($684 + 12 | 0) >> 2] = $601; - HEAP32[$683 >> 2] = $601; - HEAP32[($456 + ($342 + 8 | 0) | 0) >> 2] = $684; - HEAP32[($456 + ($342 + 12 | 0) | 0) >> 2] = $T_0_i; - HEAP32[($456 + ($342 + 24 | 0) | 0) >> 2] = 0; - break $_$179; - } - } while (0); - _abort(); - } else { - var $666 = $T_0_i + 16 + ($K12_0_i >>> 31 << 2) | 0; - var $667 = HEAPU32[$666 >> 2]; - if (!(($667 | 0) == 0)) { - var $K12_0_i = $K12_0_i << 1; - var $T_0_i = $667; - continue; - } - if (!($666 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0)) { - HEAP32[$666 >> 2] = $601; - HEAP32[($456 + ($342 + 24 | 0) | 0) >> 2] = $T_0_i; - HEAP32[($456 + ($342 + 12 | 0) | 0) >> 2] = $601; - HEAP32[($456 + ($342 + 8 | 0) | 0) >> 2] = $601; - break $_$179; - } - _abort(); - } + HEAP32[($R_1_i_i + 20 | 0) >> 2] = $1156; + HEAP32[($1156 + 24 | 0) >> 2] = $R_1_i_i; } + } } - } - } - } while (0); - var $700 = $v_3_lcssa_i + 8 | 0; - if (($700 | 0) == 0) { - var $nb_0 = $342; - __label__ = 155; - break $_$2; - } - var $mem_0 = $700; - __label__ = 331; - break $_$2; - } - } while (0); - _abort(); - } - } while (0); - $_$215 : do { - if (__label__ == 155) { - var $nb_0; - var $703 = HEAPU32[(__gm_ + 8 | 0) >> 2]; - if ($nb_0 >>> 0 > $703 >>> 0) { - var $732 = HEAPU32[(__gm_ + 12 | 0) >> 2]; - if ($nb_0 >>> 0 < $732 >>> 0) { - var $735 = $732 - $nb_0 | 0; - HEAP32[(__gm_ + 12 | 0) >> 2] = $735; - var $736 = HEAPU32[(__gm_ + 24 | 0) >> 2]; - var $737 = $736; - HEAP32[(__gm_ + 24 | 0) >> 2] = $737 + $nb_0 | 0; - HEAP32[($737 + ($nb_0 + 4 | 0) | 0) >> 2] = $735 | 1; - HEAP32[($736 + 4 | 0) >> 2] = $nb_0 | 3; - var $mem_0 = $736 + 8 | 0; - } else { - do { - if ((HEAP32[(_mparams | 0) >> 2] | 0) == 0) { - if (!((HEAP32[(_mparams | 0) >> 2] | 0) == 0)) { - break; - } - var $754 = _sysconf(8); - if ((($754 - 1 | 0) & $754 | 0) == 0) { - HEAP32[(_mparams + 8 | 0) >> 2] = $754; - HEAP32[(_mparams + 4 | 0) >> 2] = $754; - HEAP32[(_mparams + 12 | 0) >> 2] = -1; - HEAP32[(_mparams + 16 | 0) >> 2] = 2097152; - HEAP32[(_mparams + 20 | 0) >> 2] = 0; - HEAP32[(__gm_ + 440 | 0) >> 2] = 0; - var $762 = _time(0) & -16 ^ 1431655768; - HEAP32[(_mparams | 0) >> 2] = $762; + } while (0); + var $oldfirst_0_i_i = $tbase_243_i + (($1029 | $991) + $tsize_242_i | 0) | 0; + var $qsize_0_i_i = $1029 + $999 | 0; } else { - _abort(); + var $oldfirst_0_i_i = $993; + var $qsize_0_i_i = $999; } - } - } while (0); - $_$234 : do { - if ((HEAP32[(__gm_ + 440 | 0) >> 2] & 4 | 0) == 0) { - var $767 = HEAP32[(__gm_ + 24 | 0) >> 2]; - $_$236 : do { - if (!(($767 | 0) == 0)) { - var $770 = $767; - var $sp_0_i_i = __gm_ + 444 | 0; - while (1) { - var $sp_0_i_i; - var $772 = $sp_0_i_i | 0; - var $773 = HEAPU32[$772 >> 2]; - if (!($773 >>> 0 > $770 >>> 0)) { - var $776 = $sp_0_i_i + 4 | 0; - if (($773 + HEAP32[$776 >> 2] | 0) >>> 0 > $770 >>> 0) { - break; - } - } - var $782 = HEAPU32[($sp_0_i_i + 8 | 0) >> 2]; - if (($782 | 0) == 0) { - __label__ = 174; - break $_$236; - } - var $sp_0_i_i = $782; - } - if (($sp_0_i_i | 0) == 0) { - __label__ = 174; - break; - } - var $811 = HEAP32[(_mparams + 8 | 0) >> 2]; - var $816 = ((($nb_0 + 47 | 0) - HEAP32[(__gm_ + 12 | 0) >> 2] | 0) + $811 | 0) & (-$811 | 0); - if (!($816 >>> 0 < 2147483647)) { - var $tsize_0242932_ph_i = 0; - __label__ = 189; - break; - } - var $819 = _sbrk($816); - var $823 = ($819 | 0) == (HEAP32[$772 >> 2] + HEAP32[$776 >> 2] | 0 | 0); - var $tbase_0_i = $823 ? $819 : -1; - var $tsize_0_i = $823 ? $816 : 0; - var $asize_1_i = $816; - var $br_0_i = $819; - __label__ = 181; + var $qsize_0_i_i; + var $oldfirst_0_i_i; + var $1172 = $oldfirst_0_i_i + 4 | 0; + HEAP32[$1172 >> 2] = HEAP32[$1172 >> 2] & -2; + HEAP32[($tbase_243_i + ($_sum_i16_i + 4 | 0) | 0) >> 2] = $qsize_0_i_i | 1; + HEAP32[($tbase_243_i + ($qsize_0_i_i + $_sum_i16_i | 0) | 0) >> 2] = $qsize_0_i_i; + if ($qsize_0_i_i >>> 0 < 256) { + var $1184 = $qsize_0_i_i >>> 2 & 1073741822; + var $1186 = __gm_ + 40 + ($1184 << 2) | 0; + var $1187 = HEAPU32[(__gm_ | 0) >> 2]; + var $1188 = 1 << ($qsize_0_i_i >>> 3); + do { + if (($1187 & $1188 | 0) == 0) { + HEAP32[(__gm_ | 0) >> 2] = $1187 | $1188; + var $F4_0_i_i = $1186; + var $_pre_phi_i20_i = __gm_ + 40 + (($1184 + 2 | 0) << 2) | 0; + } else { + var $1194 = __gm_ + 40 + (($1184 + 2 | 0) << 2) | 0; + var $1195 = HEAPU32[$1194 >> 2]; + if (!($1195 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0)) { + var $F4_0_i_i = $1195; + var $_pre_phi_i20_i = $1194; break; + } + _abort(); } - __label__ = 174; - } while (0); - do { - if (__label__ == 174) { - var $785 = _sbrk(0); - if (($785 | 0) == -1) { - var $tsize_0242932_ph_i = 0; - __label__ = 189; - break; - } - var $788 = HEAP32[(_mparams + 8 | 0) >> 2]; - var $792 = (($nb_0 + 47 | 0) + $788 | 0) & (-$788 | 0); - var $793 = $785; - var $794 = HEAP32[(_mparams + 4 | 0) >> 2]; - var $795 = $794 - 1 | 0; - if (($795 & $793 | 0) == 0) { - var $asize_0_i = $792; - } else { - var $asize_0_i = ($792 - $793 | 0) + (($795 + $793 | 0) & (-$794 | 0)) | 0; - } - var $asize_0_i; - if (!($asize_0_i >>> 0 < 2147483647)) { - var $tsize_0242932_ph_i = 0; - __label__ = 189; - break; - } - var $807 = _sbrk($asize_0_i); - var $808 = ($807 | 0) == ($785 | 0); - var $tbase_0_i = $808 ? $785 : -1; - var $tsize_0_i = $808 ? $asize_0_i : 0; - var $asize_1_i = $asize_0_i; - var $br_0_i = $807; - __label__ = 181; + } while (0); + var $_pre_phi_i20_i; + var $F4_0_i_i; + HEAP32[$_pre_phi_i20_i >> 2] = $998; + HEAP32[($F4_0_i_i + 12 | 0) >> 2] = $998; + HEAP32[($tbase_243_i + ($_sum_i16_i + 8 | 0) | 0) >> 2] = $F4_0_i_i; + HEAP32[($tbase_243_i + ($_sum_i16_i + 12 | 0) | 0) >> 2] = $1186; + } else { + var $1207 = $997; + var $1208 = $qsize_0_i_i >>> 8; + do { + if (($1208 | 0) == 0) { + var $I7_0_i_i = 0; + } else { + if ($qsize_0_i_i >>> 0 > 16777215) { + var $I7_0_i_i = 31; break; + } + var $1215 = ($1208 + 1048320 | 0) >>> 16 & 8; + var $1216 = $1208 << $1215; + var $1219 = ($1216 + 520192 | 0) >>> 16 & 4; + var $1220 = $1216 << $1219; + var $1223 = ($1220 + 245760 | 0) >>> 16 & 2; + var $1229 = (14 - ($1219 | $1215 | $1223) | 0) + ($1220 << $1223 >>> 15) | 0; + var $I7_0_i_i = $qsize_0_i_i >>> (($1229 + 7 | 0) >>> 0) & 1 | $1229 << 1; } - } while (0); - $_$253 : do { - if (__label__ == 181) { - var $br_0_i; - var $asize_1_i; - var $tsize_0_i; - var $tbase_0_i; - var $825 = -$asize_1_i | 0; - if (!(($tbase_0_i | 0) == -1)) { - var $tsize_242_i = $tsize_0_i; - var $tbase_243_i = $tbase_0_i; - __label__ = 194; - break $_$234; - } + } while (0); + var $I7_0_i_i; + var $1236 = __gm_ + 304 + ($I7_0_i_i << 2) | 0; + HEAP32[($tbase_243_i + ($_sum_i16_i + 28 | 0) | 0) >> 2] = $I7_0_i_i; + HEAP32[($tbase_243_i + ($_sum_i16_i + 20 | 0) | 0) >> 2] = 0; + HEAP32[($tbase_243_i + ($_sum_i16_i + 16 | 0) | 0) >> 2] = 0; + var $1243 = HEAP32[(__gm_ + 4 | 0) >> 2]; + var $1244 = 1 << $I7_0_i_i; + if (($1243 & $1244 | 0) == 0) { + HEAP32[(__gm_ + 4 | 0) >> 2] = $1243 | $1244; + HEAP32[$1236 >> 2] = $1207; + HEAP32[($tbase_243_i + ($_sum_i16_i + 24 | 0) | 0) >> 2] = $1236; + HEAP32[($tbase_243_i + ($_sum_i16_i + 12 | 0) | 0) >> 2] = $1207; + HEAP32[($tbase_243_i + ($_sum_i16_i + 8 | 0) | 0) >> 2] = $1207; + } else { + if (($I7_0_i_i | 0) == 31) { + var $1263 = 0; + } else { + var $1263 = 25 - ($I7_0_i_i >>> 1) | 0; + } + var $1263; + var $K8_0_i_i = $qsize_0_i_i << $1263; + var $T_0_i21_i = HEAP32[$1236 >> 2]; + while (1) { + var $T_0_i21_i; + var $K8_0_i_i; + if ((HEAP32[($T_0_i21_i + 4 | 0) >> 2] & -8 | 0) == ($qsize_0_i_i | 0)) { + var $1289 = $T_0_i21_i + 8 | 0; + var $1290 = HEAPU32[$1289 >> 2]; + var $1292 = HEAPU32[(__gm_ + 16 | 0) >> 2]; do { - if (($br_0_i | 0) != -1 & $asize_1_i >>> 0 < 2147483647) { - if (!($asize_1_i >>> 0 < ($nb_0 + 48 | 0) >>> 0)) { - var $asize_2_i = $asize_1_i; - break; - } - var $834 = HEAP32[(_mparams + 8 | 0) >> 2]; - var $839 = ((($nb_0 + 47 | 0) - $asize_1_i | 0) + $834 | 0) & (-$834 | 0); - if (!($839 >>> 0 < 2147483647)) { - var $asize_2_i = $asize_1_i; - break; - } - if ((_sbrk($839) | 0) == -1) { - _sbrk($825); - var $tsize_0242932_ph_i = $tsize_0_i; - break $_$253; - } - var $asize_2_i = $839 + $asize_1_i | 0; - } else { - var $asize_2_i = $asize_1_i; + if (!($T_0_i21_i >>> 0 < $1292 >>> 0)) { + if ($1290 >>> 0 < $1292 >>> 0) { + break; } + HEAP32[($1290 + 12 | 0) >> 2] = $1207; + HEAP32[$1289 >> 2] = $1207; + HEAP32[($tbase_243_i + ($_sum_i16_i + 8 | 0) | 0) >> 2] = $1290; + HEAP32[($tbase_243_i + ($_sum_i16_i + 12 | 0) | 0) >> 2] = $T_0_i21_i; + HEAP32[($tbase_243_i + ($_sum_i16_i + 24 | 0) | 0) >> 2] = 0; + break $_$314; + } } while (0); - var $asize_2_i; - if (!(($br_0_i | 0) == -1)) { - var $tsize_242_i = $asize_2_i; - var $tbase_243_i = $br_0_i; - __label__ = 194; - break $_$234; + _abort(); + } else { + var $1272 = $T_0_i21_i + 16 + ($K8_0_i_i >>> 31 << 2) | 0; + var $1273 = HEAPU32[$1272 >> 2]; + if (!(($1273 | 0) == 0)) { + var $K8_0_i_i = $K8_0_i_i << 1; + var $T_0_i21_i = $1273; + continue; + } + if (!($1272 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0)) { + HEAP32[$1272 >> 2] = $1207; + HEAP32[($tbase_243_i + ($_sum_i16_i + 24 | 0) | 0) >> 2] = $T_0_i21_i; + HEAP32[($tbase_243_i + ($_sum_i16_i + 12 | 0) | 0) >> 2] = $1207; + HEAP32[($tbase_243_i + ($_sum_i16_i + 8 | 0) | 0) >> 2] = $1207; + break $_$314; } - HEAP32[(__gm_ + 440 | 0) >> 2] = HEAP32[(__gm_ + 440 | 0) >> 2] | 4; - var $tsize_137_i = $tsize_0_i; - __label__ = 191; - break $_$234; + _abort(); + } } - } while (0); - var $tsize_0242932_ph_i; - HEAP32[(__gm_ + 440 | 0) >> 2] = HEAP32[(__gm_ + 440 | 0) >> 2] | 4; - var $tsize_137_i = $tsize_0242932_ph_i; - __label__ = 191; - break; + } + } + } } - var $tsize_137_i = 0; - __label__ = 191; - } while (0); + } while (0); + var $mem_0 = $tbase_243_i + ($981 | 8) | 0; + break $_$215; + } + } while (0); + var $1306 = $876; + var $sp_0_i_i_i = __gm_ + 444 | 0; + while (1) { + var $sp_0_i_i_i; + var $1309 = HEAPU32[($sp_0_i_i_i | 0) >> 2]; + if (!($1309 >>> 0 > $1306 >>> 0)) { + var $1313 = HEAPU32[($sp_0_i_i_i + 4 | 0) >> 2]; + if (($1309 + $1313 | 0) >>> 0 > $1306 >>> 0) { + var $1321 = $1309; + var $1320 = $1313; + break; + } + } + var $1318 = HEAPU32[($sp_0_i_i_i + 8 | 0) >> 2]; + if (!(($1318 | 0) == 0)) { + var $sp_0_i_i_i = $1318; + continue; + } + var $1321 = 0; + var $1320 = 4; + break; + } + var $1320; + var $1321; + var $1322 = $1321 + $1320 | 0; + var $1324 = $1321 + ($1320 - 39 | 0) | 0; + if (($1324 & 7 | 0) == 0) { + var $1331 = 0; + } else { + var $1331 = (-$1324 | 0) & 7; + } + var $1331; + var $1332 = $1321 + (($1320 - 47 | 0) + $1331 | 0) | 0; + var $1336 = $1332 >>> 0 < ($876 + 16 | 0) >>> 0 ? $1306 : $1332; + var $1337 = $1336 + 8 | 0; + var $1340 = $tbase_243_i + 8 | 0; + if (($1340 & 7 | 0) == 0) { + var $1346 = 0; + } else { + var $1346 = (-$1340 | 0) & 7; + } + var $1346; + var $1350 = ($tsize_242_i - 40 | 0) - $1346 | 0; + HEAP32[(__gm_ + 24 | 0) >> 2] = $tbase_243_i + $1346 | 0; + HEAP32[(__gm_ + 12 | 0) >> 2] = $1350; + HEAP32[($tbase_243_i + ($1346 + 4 | 0) | 0) >> 2] = $1350 | 1; + HEAP32[($tbase_243_i + ($tsize_242_i - 36 | 0) | 0) >> 2] = 40; + HEAP32[(__gm_ + 28 | 0) >> 2] = HEAP32[(_mparams + 16 | 0) >> 2]; + HEAP32[($1336 + 4 | 0) >> 2] = 27; + HEAP32[$1337 >> 2] = HEAP32[(__gm_ + 444 | 0) >> 2]; + HEAP32[$1337 + 4 >> 2] = HEAP32[(__gm_ + 444 | 0) + 4 >> 2]; + HEAP32[$1337 + 8 >> 2] = HEAP32[(__gm_ + 444 | 0) + 8 >> 2]; + HEAP32[$1337 + 12 >> 2] = HEAP32[(__gm_ + 444 | 0) + 12 >> 2]; + HEAP32[(__gm_ + 444 | 0) >> 2] = $tbase_243_i; + HEAP32[(__gm_ + 448 | 0) >> 2] = $tsize_242_i; + HEAP32[(__gm_ + 456 | 0) >> 2] = 0; + HEAP32[(__gm_ + 452 | 0) >> 2] = $1337; + var $1360 = $1336 + 28 | 0; + HEAP32[$1360 >> 2] = 7; + $_$426 : do { + if (($1336 + 32 | 0) >>> 0 < $1322 >>> 0) { + var $1363 = $1360; + while (1) { + var $1363; + var $1364 = $1363 + 4 | 0; + HEAP32[$1364 >> 2] = 7; + if (!(($1363 + 8 | 0) >>> 0 < $1322 >>> 0)) { + break $_$426; + } + var $1363 = $1364; + } + } + } while (0); + if (($1336 | 0) == ($1306 | 0)) { + break; + } + var $1372 = $1336 - $876 | 0; + var $1375 = $1306 + ($1372 + 4 | 0) | 0; + HEAP32[$1375 >> 2] = HEAP32[$1375 >> 2] & -2; + HEAP32[($876 + 4 | 0) >> 2] = $1372 | 1; + HEAP32[($1306 + $1372 | 0) >> 2] = $1372; + if ($1372 >>> 0 < 256) { + var $1385 = $1372 >>> 2 & 1073741822; + var $1387 = __gm_ + 40 + ($1385 << 2) | 0; + var $1388 = HEAPU32[(__gm_ | 0) >> 2]; + var $1389 = 1 << ($1372 >>> 3); do { - if (__label__ == 191) { - var $tsize_137_i; - var $854 = HEAP32[(_mparams + 8 | 0) >> 2]; - var $858 = (($nb_0 + 47 | 0) + $854 | 0) & (-$854 | 0); - if (!($858 >>> 0 < 2147483647)) { - __label__ = 330; - break; - } - var $861 = _sbrk($858); - var $862 = _sbrk(0); - if (!(($862 | 0) != -1 & ($861 | 0) != -1 & $861 >>> 0 < $862 >>> 0)) { - __label__ = 330; - break; - } - var $866 = $862 - $861 | 0; - var $868 = $866 >>> 0 > ($nb_0 + 40 | 0) >>> 0; - var $_tbase_1_i = $868 ? $861 : -1; - if (($_tbase_1_i | 0) == -1) { - __label__ = 330; - break; - } - var $tsize_242_i = $868 ? $866 : $tsize_137_i; - var $tbase_243_i = $_tbase_1_i; - __label__ = 194; - break; + if (($1388 & $1389 | 0) == 0) { + HEAP32[(__gm_ | 0) >> 2] = $1388 | $1389; + var $F_0_i_i = $1387; + var $_pre_phi_i_i = __gm_ + 40 + (($1385 + 2 | 0) << 2) | 0; + } else { + var $1395 = __gm_ + 40 + (($1385 + 2 | 0) << 2) | 0; + var $1396 = HEAPU32[$1395 >> 2]; + if (!($1396 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0)) { + var $F_0_i_i = $1396; + var $_pre_phi_i_i = $1395; + break; } + _abort(); + } } while (0); + var $_pre_phi_i_i; + var $F_0_i_i; + HEAP32[$_pre_phi_i_i >> 2] = $876; + HEAP32[($F_0_i_i + 12 | 0) >> 2] = $876; + HEAP32[($876 + 8 | 0) >> 2] = $F_0_i_i; + HEAP32[($876 + 12 | 0) >> 2] = $1387; + } else { + var $1406 = $876; + var $1407 = $1372 >>> 8; do { - if (__label__ == 194) { - var $tbase_243_i; - var $tsize_242_i; - var $871 = HEAP32[(__gm_ + 432 | 0) >> 2] + $tsize_242_i | 0; - HEAP32[(__gm_ + 432 | 0) >> 2] = $871; - if ($871 >>> 0 > HEAPU32[(__gm_ + 436 | 0) >> 2] >>> 0) { - HEAP32[(__gm_ + 436 | 0) >> 2] = $871; - } - var $876 = HEAPU32[(__gm_ + 24 | 0) >> 2]; - $_$275 : do { - if (($876 | 0) == 0) { - var $879 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - if (($879 | 0) == 0 | $tbase_243_i >>> 0 < $879 >>> 0) { - HEAP32[(__gm_ + 16 | 0) >> 2] = $tbase_243_i; - } - HEAP32[(__gm_ + 444 | 0) >> 2] = $tbase_243_i; - HEAP32[(__gm_ + 448 | 0) >> 2] = $tsize_242_i; - HEAP32[(__gm_ + 456 | 0) >> 2] = 0; - HEAP32[(__gm_ + 36 | 0) >> 2] = HEAP32[(_mparams | 0) >> 2]; - HEAP32[(__gm_ + 32 | 0) >> 2] = -1; - var $i_02_i_i = 0; - while (1) { - var $i_02_i_i; - var $886 = $i_02_i_i << 1; - var $888 = __gm_ + 40 + ($886 << 2) | 0; - HEAP32[(__gm_ + 40 + (($886 + 3 | 0) << 2) | 0) >> 2] = $888; - HEAP32[(__gm_ + 40 + (($886 + 2 | 0) << 2) | 0) >> 2] = $888; - var $891 = $i_02_i_i + 1 | 0; - if (($891 | 0) == 32) { - break; - } - var $i_02_i_i = $891; - } - var $893 = $tbase_243_i + 8 | 0; - if (($893 & 7 | 0) == 0) { - var $899 = 0; - } else { - var $899 = (-$893 | 0) & 7; - } - var $899; - var $903 = ($tsize_242_i - 40 | 0) - $899 | 0; - HEAP32[(__gm_ + 24 | 0) >> 2] = $tbase_243_i + $899 | 0; - HEAP32[(__gm_ + 12 | 0) >> 2] = $903; - HEAP32[($tbase_243_i + ($899 + 4 | 0) | 0) >> 2] = $903 | 1; - HEAP32[($tbase_243_i + ($tsize_242_i - 36 | 0) | 0) >> 2] = 40; - HEAP32[(__gm_ + 28 | 0) >> 2] = HEAP32[(_mparams + 16 | 0) >> 2]; - } else { - var $sp_0_i = __gm_ + 444 | 0; - while (1) { - var $sp_0_i; - if (($sp_0_i | 0) == 0) { - break; - } - var $913 = HEAPU32[($sp_0_i | 0) >> 2]; - var $914 = $sp_0_i + 4 | 0; - var $915 = HEAPU32[$914 >> 2]; - if (($tbase_243_i | 0) == ($913 + $915 | 0 | 0)) { - if (!((HEAP32[($sp_0_i + 12 | 0) >> 2] & 8 | 0) == 0)) { - break; - } - var $926 = $876; - if (!($926 >>> 0 >= $913 >>> 0 & $926 >>> 0 < $tbase_243_i >>> 0)) { - break; - } - HEAP32[$914 >> 2] = $915 + $tsize_242_i | 0; - var $931 = HEAP32[(__gm_ + 24 | 0) >> 2]; - var $933 = HEAP32[(__gm_ + 12 | 0) >> 2] + $tsize_242_i | 0; - var $934 = $931; - var $936 = $931 + 8 | 0; - if (($936 & 7 | 0) == 0) { - var $942 = 0; - } else { - var $942 = (-$936 | 0) & 7; - } - var $942; - var $945 = $933 - $942 | 0; - HEAP32[(__gm_ + 24 | 0) >> 2] = $934 + $942 | 0; - HEAP32[(__gm_ + 12 | 0) >> 2] = $945; - HEAP32[($934 + ($942 + 4 | 0) | 0) >> 2] = $945 | 1; - HEAP32[($934 + ($933 + 4 | 0) | 0) >> 2] = 40; - HEAP32[(__gm_ + 28 | 0) >> 2] = HEAP32[(_mparams + 16 | 0) >> 2]; - break $_$275; - } - var $sp_0_i = HEAP32[($sp_0_i + 8 | 0) >> 2]; - } - if ($tbase_243_i >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { - HEAP32[(__gm_ + 16 | 0) >> 2] = $tbase_243_i; - } - var $955 = $tbase_243_i + $tsize_242_i | 0; - var $sp_1_i = __gm_ + 444 | 0; - while (1) { - var $sp_1_i; - if (($sp_1_i | 0) == 0) { - __label__ = 293; - break; - } - var $959 = $sp_1_i | 0; - if ((HEAP32[$959 >> 2] | 0) == ($955 | 0)) { - __label__ = 218; - break; - } - var $sp_1_i = HEAP32[($sp_1_i + 8 | 0) >> 2]; - } - do { - if (__label__ == 218) { - if (!((HEAP32[($sp_1_i + 12 | 0) >> 2] & 8 | 0) == 0)) { - break; - } - HEAP32[$959 >> 2] = $tbase_243_i; - var $970 = $sp_1_i + 4 | 0; - HEAP32[$970 >> 2] = HEAP32[$970 >> 2] + $tsize_242_i | 0; - var $974 = $tbase_243_i + 8 | 0; - if (($974 & 7 | 0) == 0) { - var $981 = 0; - } else { - var $981 = (-$974 | 0) & 7; - } - var $981; - var $984 = $tbase_243_i + ($tsize_242_i + 8 | 0) | 0; - if (($984 & 7 | 0) == 0) { - var $991 = 0; - } else { - var $991 = (-$984 | 0) & 7; - } - var $991; - var $992 = $tbase_243_i + ($991 + $tsize_242_i | 0) | 0; - var $993 = $992; - var $_sum_i16_i = $981 + $nb_0 | 0; - var $997 = $tbase_243_i + $_sum_i16_i | 0; - var $998 = $997; - var $999 = ($992 - ($tbase_243_i + $981 | 0) | 0) - $nb_0 | 0; - HEAP32[($tbase_243_i + ($981 + 4 | 0) | 0) >> 2] = $nb_0 | 3; - $_$314 : do { - if (($993 | 0) == (HEAP32[(__gm_ + 24 | 0) >> 2] | 0)) { - var $1007 = HEAP32[(__gm_ + 12 | 0) >> 2] + $999 | 0; - HEAP32[(__gm_ + 12 | 0) >> 2] = $1007; - HEAP32[(__gm_ + 24 | 0) >> 2] = $998; - HEAP32[($tbase_243_i + ($_sum_i16_i + 4 | 0) | 0) >> 2] = $1007 | 1; - } else { - if (($993 | 0) == (HEAP32[(__gm_ + 20 | 0) >> 2] | 0)) { - var $1016 = HEAP32[(__gm_ + 8 | 0) >> 2] + $999 | 0; - HEAP32[(__gm_ + 8 | 0) >> 2] = $1016; - HEAP32[(__gm_ + 20 | 0) >> 2] = $998; - HEAP32[($tbase_243_i + ($_sum_i16_i + 4 | 0) | 0) >> 2] = $1016 | 1; - HEAP32[($tbase_243_i + ($1016 + $_sum_i16_i | 0) | 0) >> 2] = $1016; - } else { - var $_sum2_i18_i = $tsize_242_i + 4 | 0; - var $1025 = HEAPU32[($tbase_243_i + ($_sum2_i18_i + $991 | 0) | 0) >> 2]; - if (($1025 & 3 | 0) == 1) { - var $1029 = $1025 & -8; - var $1030 = $1025 >>> 3; - $_$322 : do { - if ($1025 >>> 0 < 256) { - var $1035 = HEAPU32[($tbase_243_i + (($991 | 8) + $tsize_242_i | 0) | 0) >> 2]; - var $1038 = HEAPU32[($tbase_243_i + (($tsize_242_i + 12 | 0) + $991 | 0) | 0) >> 2]; - if (($1035 | 0) == ($1038 | 0)) { - HEAP32[(__gm_ | 0) >> 2] = HEAP32[(__gm_ | 0) >> 2] & (1 << $1030 ^ -1); - } else { - var $1049 = __gm_ + 40 + (($1025 >>> 2 & 1073741822) << 2) | 0; - do { - if (($1035 | 0) == ($1049 | 0)) { - __label__ = 233; - } else { - if ($1035 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { - __label__ = 236; - break; - } - __label__ = 233; - break; - } - } while (0); - do { - if (__label__ == 233) { - if (!(($1038 | 0) == ($1049 | 0))) { - if ($1038 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { - break; - } - } - HEAP32[($1035 + 12 | 0) >> 2] = $1038; - HEAP32[($1038 + 8 | 0) >> 2] = $1035; - break $_$322; - } - } while (0); - _abort(); - } - } else { - var $1064 = $992; - var $1067 = HEAPU32[($tbase_243_i + (($991 | 24) + $tsize_242_i | 0) | 0) >> 2]; - var $1070 = HEAPU32[($tbase_243_i + (($tsize_242_i + 12 | 0) + $991 | 0) | 0) >> 2]; - do { - if (($1070 | 0) == ($1064 | 0)) { - var $_sum67_i_i = $991 | 16; - var $1085 = $tbase_243_i + ($_sum2_i18_i + $_sum67_i_i | 0) | 0; - var $1086 = HEAP32[$1085 >> 2]; - if (($1086 | 0) == 0) { - var $1090 = $tbase_243_i + ($_sum67_i_i + $tsize_242_i | 0) | 0; - var $1091 = HEAP32[$1090 >> 2]; - if (($1091 | 0) == 0) { - var $R_1_i_i = 0; - break; - } - var $RP_0_i_i = $1090; - var $R_0_i_i = $1091; - } else { - var $RP_0_i_i = $1085; - var $R_0_i_i = $1086; - __label__ = 243; - } - while (1) { - var $R_0_i_i; - var $RP_0_i_i; - var $1093 = $R_0_i_i + 20 | 0; - var $1094 = HEAP32[$1093 >> 2]; - if (!(($1094 | 0) == 0)) { - var $RP_0_i_i = $1093; - var $R_0_i_i = $1094; - continue; - } - var $1097 = $R_0_i_i + 16 | 0; - var $1098 = HEAPU32[$1097 >> 2]; - if (($1098 | 0) == 0) { - break; - } - var $RP_0_i_i = $1097; - var $R_0_i_i = $1098; - } - if ($RP_0_i_i >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { - _abort(); - } else { - HEAP32[$RP_0_i_i >> 2] = 0; - var $R_1_i_i = $R_0_i_i; - } - } else { - var $1075 = HEAPU32[($tbase_243_i + (($991 | 8) + $tsize_242_i | 0) | 0) >> 2]; - if ($1075 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { - _abort(); - } else { - HEAP32[($1075 + 12 | 0) >> 2] = $1070; - HEAP32[($1070 + 8 | 0) >> 2] = $1075; - var $R_1_i_i = $1070; - } - } - } while (0); - var $R_1_i_i; - if (($1067 | 0) == 0) { - break; - } - var $1110 = $tbase_243_i + (($tsize_242_i + 28 | 0) + $991 | 0) | 0; - var $1112 = __gm_ + 304 + (HEAP32[$1110 >> 2] << 2) | 0; - do { - if (($1064 | 0) == (HEAP32[$1112 >> 2] | 0)) { - HEAP32[$1112 >> 2] = $R_1_i_i; - if (!(($R_1_i_i | 0) == 0)) { - break; - } - HEAP32[(__gm_ + 4 | 0) >> 2] = HEAP32[(__gm_ + 4 | 0) >> 2] & (1 << HEAP32[$1110 >> 2] ^ -1); - break $_$322; - } - if ($1067 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { - _abort(); - } else { - var $1126 = $1067 + 16 | 0; - if ((HEAP32[$1126 >> 2] | 0) == ($1064 | 0)) { - HEAP32[$1126 >> 2] = $R_1_i_i; - } else { - HEAP32[($1067 + 20 | 0) >> 2] = $R_1_i_i; - } - if (($R_1_i_i | 0) == 0) { - break $_$322; - } - } - } while (0); - if ($R_1_i_i >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { - _abort(); - } else { - HEAP32[($R_1_i_i + 24 | 0) >> 2] = $1067; - var $_sum3132_i_i = $991 | 16; - var $1143 = HEAPU32[($tbase_243_i + ($_sum3132_i_i + $tsize_242_i | 0) | 0) >> 2]; - if (!(($1143 | 0) == 0)) { - if ($1143 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { - _abort(); - } else { - HEAP32[($R_1_i_i + 16 | 0) >> 2] = $1143; - HEAP32[($1143 + 24 | 0) >> 2] = $R_1_i_i; - } - } - var $1156 = HEAPU32[($tbase_243_i + ($_sum2_i18_i + $_sum3132_i_i | 0) | 0) >> 2]; - if (($1156 | 0) == 0) { - break; - } - if ($1156 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0) { - _abort(); - } else { - HEAP32[($R_1_i_i + 20 | 0) >> 2] = $1156; - HEAP32[($1156 + 24 | 0) >> 2] = $R_1_i_i; - } - } - } - } while (0); - var $oldfirst_0_i_i = $tbase_243_i + (($1029 | $991) + $tsize_242_i | 0) | 0; - var $qsize_0_i_i = $1029 + $999 | 0; - } else { - var $oldfirst_0_i_i = $993; - var $qsize_0_i_i = $999; - } - var $qsize_0_i_i; - var $oldfirst_0_i_i; - var $1172 = $oldfirst_0_i_i + 4 | 0; - HEAP32[$1172 >> 2] = HEAP32[$1172 >> 2] & -2; - HEAP32[($tbase_243_i + ($_sum_i16_i + 4 | 0) | 0) >> 2] = $qsize_0_i_i | 1; - HEAP32[($tbase_243_i + ($qsize_0_i_i + $_sum_i16_i | 0) | 0) >> 2] = $qsize_0_i_i; - if ($qsize_0_i_i >>> 0 < 256) { - var $1184 = $qsize_0_i_i >>> 2 & 1073741822; - var $1186 = __gm_ + 40 + ($1184 << 2) | 0; - var $1187 = HEAPU32[(__gm_ | 0) >> 2]; - var $1188 = 1 << ($qsize_0_i_i >>> 3); - do { - if (($1187 & $1188 | 0) == 0) { - HEAP32[(__gm_ | 0) >> 2] = $1187 | $1188; - var $F4_0_i_i = $1186; - var $_pre_phi_i20_i = __gm_ + 40 + (($1184 + 2 | 0) << 2) | 0; - } else { - var $1194 = __gm_ + 40 + (($1184 + 2 | 0) << 2) | 0; - var $1195 = HEAPU32[$1194 >> 2]; - if (!($1195 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0)) { - var $F4_0_i_i = $1195; - var $_pre_phi_i20_i = $1194; - break; - } - _abort(); - } - } while (0); - var $_pre_phi_i20_i; - var $F4_0_i_i; - HEAP32[$_pre_phi_i20_i >> 2] = $998; - HEAP32[($F4_0_i_i + 12 | 0) >> 2] = $998; - HEAP32[($tbase_243_i + ($_sum_i16_i + 8 | 0) | 0) >> 2] = $F4_0_i_i; - HEAP32[($tbase_243_i + ($_sum_i16_i + 12 | 0) | 0) >> 2] = $1186; - } else { - var $1207 = $997; - var $1208 = $qsize_0_i_i >>> 8; - do { - if (($1208 | 0) == 0) { - var $I7_0_i_i = 0; - } else { - if ($qsize_0_i_i >>> 0 > 16777215) { - var $I7_0_i_i = 31; - break; - } - var $1215 = ($1208 + 1048320 | 0) >>> 16 & 8; - var $1216 = $1208 << $1215; - var $1219 = ($1216 + 520192 | 0) >>> 16 & 4; - var $1220 = $1216 << $1219; - var $1223 = ($1220 + 245760 | 0) >>> 16 & 2; - var $1229 = (14 - ($1219 | $1215 | $1223) | 0) + ($1220 << $1223 >>> 15) | 0; - var $I7_0_i_i = $qsize_0_i_i >>> (($1229 + 7 | 0) >>> 0) & 1 | $1229 << 1; - } - } while (0); - var $I7_0_i_i; - var $1236 = __gm_ + 304 + ($I7_0_i_i << 2) | 0; - HEAP32[($tbase_243_i + ($_sum_i16_i + 28 | 0) | 0) >> 2] = $I7_0_i_i; - HEAP32[($tbase_243_i + ($_sum_i16_i + 20 | 0) | 0) >> 2] = 0; - HEAP32[($tbase_243_i + ($_sum_i16_i + 16 | 0) | 0) >> 2] = 0; - var $1243 = HEAP32[(__gm_ + 4 | 0) >> 2]; - var $1244 = 1 << $I7_0_i_i; - if (($1243 & $1244 | 0) == 0) { - HEAP32[(__gm_ + 4 | 0) >> 2] = $1243 | $1244; - HEAP32[$1236 >> 2] = $1207; - HEAP32[($tbase_243_i + ($_sum_i16_i + 24 | 0) | 0) >> 2] = $1236; - HEAP32[($tbase_243_i + ($_sum_i16_i + 12 | 0) | 0) >> 2] = $1207; - HEAP32[($tbase_243_i + ($_sum_i16_i + 8 | 0) | 0) >> 2] = $1207; - } else { - if (($I7_0_i_i | 0) == 31) { - var $1263 = 0; - } else { - var $1263 = 25 - ($I7_0_i_i >>> 1) | 0; - } - var $1263; - var $K8_0_i_i = $qsize_0_i_i << $1263; - var $T_0_i21_i = HEAP32[$1236 >> 2]; - while (1) { - var $T_0_i21_i; - var $K8_0_i_i; - if ((HEAP32[($T_0_i21_i + 4 | 0) >> 2] & -8 | 0) == ($qsize_0_i_i | 0)) { - var $1289 = $T_0_i21_i + 8 | 0; - var $1290 = HEAPU32[$1289 >> 2]; - var $1292 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - do { - if (!($T_0_i21_i >>> 0 < $1292 >>> 0)) { - if ($1290 >>> 0 < $1292 >>> 0) { - break; - } - HEAP32[($1290 + 12 | 0) >> 2] = $1207; - HEAP32[$1289 >> 2] = $1207; - HEAP32[($tbase_243_i + ($_sum_i16_i + 8 | 0) | 0) >> 2] = $1290; - HEAP32[($tbase_243_i + ($_sum_i16_i + 12 | 0) | 0) >> 2] = $T_0_i21_i; - HEAP32[($tbase_243_i + ($_sum_i16_i + 24 | 0) | 0) >> 2] = 0; - break $_$314; - } - } while (0); - _abort(); - } else { - var $1272 = $T_0_i21_i + 16 + ($K8_0_i_i >>> 31 << 2) | 0; - var $1273 = HEAPU32[$1272 >> 2]; - if (!(($1273 | 0) == 0)) { - var $K8_0_i_i = $K8_0_i_i << 1; - var $T_0_i21_i = $1273; - continue; - } - if (!($1272 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0)) { - HEAP32[$1272 >> 2] = $1207; - HEAP32[($tbase_243_i + ($_sum_i16_i + 24 | 0) | 0) >> 2] = $T_0_i21_i; - HEAP32[($tbase_243_i + ($_sum_i16_i + 12 | 0) | 0) >> 2] = $1207; - HEAP32[($tbase_243_i + ($_sum_i16_i + 8 | 0) | 0) >> 2] = $1207; - break $_$314; - } - _abort(); - } - } - } - } - } - } - } while (0); - var $mem_0 = $tbase_243_i + ($981 | 8) | 0; - break $_$215; - } - } while (0); - var $1306 = $876; - var $sp_0_i_i_i = __gm_ + 444 | 0; - while (1) { - var $sp_0_i_i_i; - var $1309 = HEAPU32[($sp_0_i_i_i | 0) >> 2]; - if (!($1309 >>> 0 > $1306 >>> 0)) { - var $1313 = HEAPU32[($sp_0_i_i_i + 4 | 0) >> 2]; - if (($1309 + $1313 | 0) >>> 0 > $1306 >>> 0) { - var $1321 = $1309; - var $1320 = $1313; - break; - } - } - var $1318 = HEAPU32[($sp_0_i_i_i + 8 | 0) >> 2]; - if (!(($1318 | 0) == 0)) { - var $sp_0_i_i_i = $1318; - continue; - } - var $1321 = 0; - var $1320 = 4; - break; - } - var $1320; - var $1321; - var $1322 = $1321 + $1320 | 0; - var $1324 = $1321 + ($1320 - 39 | 0) | 0; - if (($1324 & 7 | 0) == 0) { - var $1331 = 0; - } else { - var $1331 = (-$1324 | 0) & 7; - } - var $1331; - var $1332 = $1321 + (($1320 - 47 | 0) + $1331 | 0) | 0; - var $1336 = $1332 >>> 0 < ($876 + 16 | 0) >>> 0 ? $1306 : $1332; - var $1337 = $1336 + 8 | 0; - var $1340 = $tbase_243_i + 8 | 0; - if (($1340 & 7 | 0) == 0) { - var $1346 = 0; - } else { - var $1346 = (-$1340 | 0) & 7; - } - var $1346; - var $1350 = ($tsize_242_i - 40 | 0) - $1346 | 0; - HEAP32[(__gm_ + 24 | 0) >> 2] = $tbase_243_i + $1346 | 0; - HEAP32[(__gm_ + 12 | 0) >> 2] = $1350; - HEAP32[($tbase_243_i + ($1346 + 4 | 0) | 0) >> 2] = $1350 | 1; - HEAP32[($tbase_243_i + ($tsize_242_i - 36 | 0) | 0) >> 2] = 40; - HEAP32[(__gm_ + 28 | 0) >> 2] = HEAP32[(_mparams + 16 | 0) >> 2]; - HEAP32[($1336 + 4 | 0) >> 2] = 27; - HEAP32[$1337 >> 2] = HEAP32[(__gm_ + 444 | 0) >> 2]; - HEAP32[$1337 + 4 >> 2] = HEAP32[(__gm_ + 444 | 0) + 4 >> 2]; - HEAP32[$1337 + 8 >> 2] = HEAP32[(__gm_ + 444 | 0) + 8 >> 2]; - HEAP32[$1337 + 12 >> 2] = HEAP32[(__gm_ + 444 | 0) + 12 >> 2]; - HEAP32[(__gm_ + 444 | 0) >> 2] = $tbase_243_i; - HEAP32[(__gm_ + 448 | 0) >> 2] = $tsize_242_i; - HEAP32[(__gm_ + 456 | 0) >> 2] = 0; - HEAP32[(__gm_ + 452 | 0) >> 2] = $1337; - var $1360 = $1336 + 28 | 0; - HEAP32[$1360 >> 2] = 7; - $_$426 : do { - if (($1336 + 32 | 0) >>> 0 < $1322 >>> 0) { - var $1363 = $1360; - while (1) { - var $1363; - var $1364 = $1363 + 4 | 0; - HEAP32[$1364 >> 2] = 7; - if (!(($1363 + 8 | 0) >>> 0 < $1322 >>> 0)) { - break $_$426; - } - var $1363 = $1364; - } - } - } while (0); - if (($1336 | 0) == ($1306 | 0)) { - break; - } - var $1372 = $1336 - $876 | 0; - var $1375 = $1306 + ($1372 + 4 | 0) | 0; - HEAP32[$1375 >> 2] = HEAP32[$1375 >> 2] & -2; - HEAP32[($876 + 4 | 0) >> 2] = $1372 | 1; - HEAP32[($1306 + $1372 | 0) >> 2] = $1372; - if ($1372 >>> 0 < 256) { - var $1385 = $1372 >>> 2 & 1073741822; - var $1387 = __gm_ + 40 + ($1385 << 2) | 0; - var $1388 = HEAPU32[(__gm_ | 0) >> 2]; - var $1389 = 1 << ($1372 >>> 3); - do { - if (($1388 & $1389 | 0) == 0) { - HEAP32[(__gm_ | 0) >> 2] = $1388 | $1389; - var $F_0_i_i = $1387; - var $_pre_phi_i_i = __gm_ + 40 + (($1385 + 2 | 0) << 2) | 0; - } else { - var $1395 = __gm_ + 40 + (($1385 + 2 | 0) << 2) | 0; - var $1396 = HEAPU32[$1395 >> 2]; - if (!($1396 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0)) { - var $F_0_i_i = $1396; - var $_pre_phi_i_i = $1395; - break; - } - _abort(); - } - } while (0); - var $_pre_phi_i_i; - var $F_0_i_i; - HEAP32[$_pre_phi_i_i >> 2] = $876; - HEAP32[($F_0_i_i + 12 | 0) >> 2] = $876; - HEAP32[($876 + 8 | 0) >> 2] = $F_0_i_i; - HEAP32[($876 + 12 | 0) >> 2] = $1387; - } else { - var $1406 = $876; - var $1407 = $1372 >>> 8; - do { - if (($1407 | 0) == 0) { - var $I1_0_i_i = 0; - } else { - if ($1372 >>> 0 > 16777215) { - var $I1_0_i_i = 31; - break; - } - var $1414 = ($1407 + 1048320 | 0) >>> 16 & 8; - var $1415 = $1407 << $1414; - var $1418 = ($1415 + 520192 | 0) >>> 16 & 4; - var $1419 = $1415 << $1418; - var $1422 = ($1419 + 245760 | 0) >>> 16 & 2; - var $1428 = (14 - ($1418 | $1414 | $1422) | 0) + ($1419 << $1422 >>> 15) | 0; - var $I1_0_i_i = $1372 >>> (($1428 + 7 | 0) >>> 0) & 1 | $1428 << 1; - } - } while (0); - var $I1_0_i_i; - var $1435 = __gm_ + 304 + ($I1_0_i_i << 2) | 0; - HEAP32[($876 + 28 | 0) >> 2] = $I1_0_i_i; - HEAP32[($876 + 20 | 0) >> 2] = 0; - HEAP32[($876 + 16 | 0) >> 2] = 0; - var $1439 = HEAP32[(__gm_ + 4 | 0) >> 2]; - var $1440 = 1 << $I1_0_i_i; - if (($1439 & $1440 | 0) == 0) { - HEAP32[(__gm_ + 4 | 0) >> 2] = $1439 | $1440; - HEAP32[$1435 >> 2] = $1406; - HEAP32[($876 + 24 | 0) >> 2] = $1435; - HEAP32[($876 + 12 | 0) >> 2] = $876; - HEAP32[($876 + 8 | 0) >> 2] = $876; - } else { - if (($I1_0_i_i | 0) == 31) { - var $1455 = 0; - } else { - var $1455 = 25 - ($I1_0_i_i >>> 1) | 0; - } - var $1455; - var $K2_0_i_i = $1372 << $1455; - var $T_0_i_i = HEAP32[$1435 >> 2]; - while (1) { - var $T_0_i_i; - var $K2_0_i_i; - if ((HEAP32[($T_0_i_i + 4 | 0) >> 2] & -8 | 0) == ($1372 | 0)) { - var $1478 = $T_0_i_i + 8 | 0; - var $1479 = HEAPU32[$1478 >> 2]; - var $1481 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - do { - if (!($T_0_i_i >>> 0 < $1481 >>> 0)) { - if ($1479 >>> 0 < $1481 >>> 0) { - break; - } - HEAP32[($1479 + 12 | 0) >> 2] = $1406; - HEAP32[$1478 >> 2] = $1406; - HEAP32[($876 + 8 | 0) >> 2] = $1479; - HEAP32[($876 + 12 | 0) >> 2] = $T_0_i_i; - HEAP32[($876 + 24 | 0) >> 2] = 0; - break $_$275; - } - } while (0); - _abort(); - } else { - var $1464 = $T_0_i_i + 16 + ($K2_0_i_i >>> 31 << 2) | 0; - var $1465 = HEAPU32[$1464 >> 2]; - if (!(($1465 | 0) == 0)) { - var $K2_0_i_i = $K2_0_i_i << 1; - var $T_0_i_i = $1465; - continue; - } - if (!($1464 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0)) { - HEAP32[$1464 >> 2] = $1406; - HEAP32[($876 + 24 | 0) >> 2] = $T_0_i_i; - HEAP32[($876 + 12 | 0) >> 2] = $876; - HEAP32[($876 + 8 | 0) >> 2] = $876; - break $_$275; - } - _abort(); - } - } - } - } - } - } while (0); - var $1491 = HEAPU32[(__gm_ + 12 | 0) >> 2]; - if (!($1491 >>> 0 > $nb_0 >>> 0)) { + if (($1407 | 0) == 0) { + var $I1_0_i_i = 0; + } else { + if ($1372 >>> 0 > 16777215) { + var $I1_0_i_i = 31; + break; + } + var $1414 = ($1407 + 1048320 | 0) >>> 16 & 8; + var $1415 = $1407 << $1414; + var $1418 = ($1415 + 520192 | 0) >>> 16 & 4; + var $1419 = $1415 << $1418; + var $1422 = ($1419 + 245760 | 0) >>> 16 & 2; + var $1428 = (14 - ($1418 | $1414 | $1422) | 0) + ($1419 << $1422 >>> 15) | 0; + var $I1_0_i_i = $1372 >>> (($1428 + 7 | 0) >>> 0) & 1 | $1428 << 1; + } + } while (0); + var $I1_0_i_i; + var $1435 = __gm_ + 304 + ($I1_0_i_i << 2) | 0; + HEAP32[($876 + 28 | 0) >> 2] = $I1_0_i_i; + HEAP32[($876 + 20 | 0) >> 2] = 0; + HEAP32[($876 + 16 | 0) >> 2] = 0; + var $1439 = HEAP32[(__gm_ + 4 | 0) >> 2]; + var $1440 = 1 << $I1_0_i_i; + if (($1439 & $1440 | 0) == 0) { + HEAP32[(__gm_ + 4 | 0) >> 2] = $1439 | $1440; + HEAP32[$1435 >> 2] = $1406; + HEAP32[($876 + 24 | 0) >> 2] = $1435; + HEAP32[($876 + 12 | 0) >> 2] = $876; + HEAP32[($876 + 8 | 0) >> 2] = $876; + } else { + if (($I1_0_i_i | 0) == 31) { + var $1455 = 0; + } else { + var $1455 = 25 - ($I1_0_i_i >>> 1) | 0; + } + var $1455; + var $K2_0_i_i = $1372 << $1455; + var $T_0_i_i = HEAP32[$1435 >> 2]; + while (1) { + var $T_0_i_i; + var $K2_0_i_i; + if ((HEAP32[($T_0_i_i + 4 | 0) >> 2] & -8 | 0) == ($1372 | 0)) { + var $1478 = $T_0_i_i + 8 | 0; + var $1479 = HEAPU32[$1478 >> 2]; + var $1481 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + do { + if (!($T_0_i_i >>> 0 < $1481 >>> 0)) { + if ($1479 >>> 0 < $1481 >>> 0) { break; + } + HEAP32[($1479 + 12 | 0) >> 2] = $1406; + HEAP32[$1478 >> 2] = $1406; + HEAP32[($876 + 8 | 0) >> 2] = $1479; + HEAP32[($876 + 12 | 0) >> 2] = $T_0_i_i; + HEAP32[($876 + 24 | 0) >> 2] = 0; + break $_$275; } - var $1494 = $1491 - $nb_0 | 0; - HEAP32[(__gm_ + 12 | 0) >> 2] = $1494; - var $1495 = HEAPU32[(__gm_ + 24 | 0) >> 2]; - var $1496 = $1495; - HEAP32[(__gm_ + 24 | 0) >> 2] = $1496 + $nb_0 | 0; - HEAP32[($1496 + ($nb_0 + 4 | 0) | 0) >> 2] = $1494 | 1; - HEAP32[($1495 + 4 | 0) >> 2] = $nb_0 | 3; - var $mem_0 = $1495 + 8 | 0; - break $_$215; + } while (0); + _abort(); + } else { + var $1464 = $T_0_i_i + 16 + ($K2_0_i_i >>> 31 << 2) | 0; + var $1465 = HEAPU32[$1464 >> 2]; + if (!(($1465 | 0) == 0)) { + var $K2_0_i_i = $K2_0_i_i << 1; + var $T_0_i_i = $1465; + continue; + } + if (!($1464 >>> 0 < HEAPU32[(__gm_ + 16 | 0) >> 2] >>> 0)) { + HEAP32[$1464 >> 2] = $1406; + HEAP32[($876 + 24 | 0) >> 2] = $T_0_i_i; + HEAP32[($876 + 12 | 0) >> 2] = $876; + HEAP32[($876 + 8 | 0) >> 2] = $876; + break $_$275; + } + _abort(); } - } while (0); - HEAP32[___errno() >> 2] = 12; - var $mem_0 = 0; - } - } else { - var $706 = $703 - $nb_0 | 0; - var $707 = HEAPU32[(__gm_ + 20 | 0) >> 2]; - if ($706 >>> 0 > 15) { - var $710 = $707; - HEAP32[(__gm_ + 20 | 0) >> 2] = $710 + $nb_0 | 0; - HEAP32[(__gm_ + 8 | 0) >> 2] = $706; - HEAP32[($710 + ($nb_0 + 4 | 0) | 0) >> 2] = $706 | 1; - HEAP32[($710 + $703 | 0) >> 2] = $706; - HEAP32[($707 + 4 | 0) >> 2] = $nb_0 | 3; - } else { - HEAP32[(__gm_ + 8 | 0) >> 2] = 0; - HEAP32[(__gm_ + 20 | 0) >> 2] = 0; - HEAP32[($707 + 4 | 0) >> 2] = $703 | 3; - var $725 = $707 + ($703 + 4 | 0) | 0; - HEAP32[$725 >> 2] = HEAP32[$725 >> 2] | 1; + } + } + } } - var $mem_0 = $707 + 8 | 0; + } while (0); + var $1491 = HEAPU32[(__gm_ + 12 | 0) >> 2]; + if (!($1491 >>> 0 > $nb_0 >>> 0)) { + break; + } + var $1494 = $1491 - $nb_0 | 0; + HEAP32[(__gm_ + 12 | 0) >> 2] = $1494; + var $1495 = HEAPU32[(__gm_ + 24 | 0) >> 2]; + var $1496 = $1495; + HEAP32[(__gm_ + 24 | 0) >> 2] = $1496 + $nb_0 | 0; + HEAP32[($1496 + ($nb_0 + 4 | 0) | 0) >> 2] = $1494 | 1; + HEAP32[($1495 + 4 | 0) >> 2] = $nb_0 | 3; + var $mem_0 = $1495 + 8 | 0; + break $_$215; } + } while (0); + HEAP32[___errno() >> 2] = 12; + var $mem_0 = 0; } - } while (0); - var $mem_0; - return $mem_0; - return null; + } else { + var $706 = $703 - $nb_0 | 0; + var $707 = HEAPU32[(__gm_ + 20 | 0) >> 2]; + if ($706 >>> 0 > 15) { + var $710 = $707; + HEAP32[(__gm_ + 20 | 0) >> 2] = $710 + $nb_0 | 0; + HEAP32[(__gm_ + 8 | 0) >> 2] = $706; + HEAP32[($710 + ($nb_0 + 4 | 0) | 0) >> 2] = $706 | 1; + HEAP32[($710 + $703 | 0) >> 2] = $706; + HEAP32[($707 + 4 | 0) >> 2] = $nb_0 | 3; + } else { + HEAP32[(__gm_ + 8 | 0) >> 2] = 0; + HEAP32[(__gm_ + 20 | 0) >> 2] = 0; + HEAP32[($707 + 4 | 0) >> 2] = $703 | 3; + var $725 = $707 + ($703 + 4 | 0) | 0; + HEAP32[$725 >> 2] = HEAP32[$725 >> 2] | 1; + } + var $mem_0 = $707 + 8 | 0; + } + } + } while (0); + var $mem_0; + return $mem_0; + return null; } function _mallocNoU($bytes) { - var __label__; - $_$2 : do { - if ($bytes >>> 0 < 245) { - if ($bytes >>> 0 < 11) { - var $8 = 16; + var __label__; + $_$2 : do { + if ($bytes >>> 0 < 245) { + if ($bytes >>> 0 < 11) { + var $8 = 16; + } else { + var $8 = ($bytes + 11 | 0) & -8; + } + var $8; + var $9 = $8 >>> 3; + var $10 = HEAP32[(__gm_ | 0) >> 2]; + var $11 = $10 >>> ($9 >>> 0); + if (!(($11 & 3 | 0) == 0)) { + var $17 = ($11 & 1 ^ 1) + $9 | 0; + var $18 = $17 << 1; + var $20 = __gm_ + 40 + ($18 << 2) | 0; + var $21 = __gm_ + 40 + (($18 + 2 | 0) << 2) | 0; + var $22 = HEAP32[$21 >> 2]; + var $23 = $22 + 8 | 0; + var $24 = HEAP32[$23 >> 2]; + if (($20 | 0) == ($24 | 0)) { + HEAP32[(__gm_ | 0) >> 2] = $10 & (1 << $17 ^ -1); + } else { + if ($24 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { + _abort(); + } else { + HEAP32[$21 >> 2] = $24; + HEAP32[($24 + 12 | 0) >> 2] = $20; + } + } + var $38 = $17 << 3; + HEAP32[($22 + 4 | 0) >> 2] = $38 | 3; + var $43 = $22 + ($38 | 4) | 0; + HEAP32[$43 >> 2] = HEAP32[$43 >> 2] | 1; + var $mem_0 = $23; + __label__ = 331; + break; + } + if (!($8 >>> 0 > HEAP32[(__gm_ + 8 | 0) >> 2] >>> 0)) { + var $nb_0 = $8; + __label__ = 155; + break; + } + if (!(($11 | 0) == 0)) { + var $54 = 2 << $9; + var $57 = $11 << $9 & ($54 | (-$54 | 0)); + var $60 = ($57 & (-$57 | 0)) - 1 | 0; + var $62 = $60 >>> 12 & 16; + var $63 = $60 >>> ($62 >>> 0); + var $65 = $63 >>> 5 & 8; + var $66 = $63 >>> ($65 >>> 0); + var $68 = $66 >>> 2 & 4; + var $69 = $66 >>> ($68 >>> 0); + var $71 = $69 >>> 1 & 2; + var $72 = $69 >>> ($71 >>> 0); + var $74 = $72 >>> 1 & 1; + var $80 = ($65 | $62 | $68 | $71 | $74) + ($72 >>> ($74 >>> 0)) | 0; + var $81 = $80 << 1; + var $83 = __gm_ + 40 + ($81 << 2) | 0; + var $84 = __gm_ + 40 + (($81 + 2 | 0) << 2) | 0; + var $85 = HEAP32[$84 >> 2]; + var $86 = $85 + 8 | 0; + var $87 = HEAP32[$86 >> 2]; + if (($83 | 0) == ($87 | 0)) { + HEAP32[(__gm_ | 0) >> 2] = $10 & (1 << $80 ^ -1); + } else { + if ($87 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { + _abort(); + } else { + HEAP32[$84 >> 2] = $87; + HEAP32[($87 + 12 | 0) >> 2] = $83; + } + } + var $101 = $80 << 3; + var $102 = $101 - $8 | 0; + HEAP32[($85 + 4 | 0) >> 2] = $8 | 3; + var $105 = $85; + var $107 = $105 + $8 | 0; + HEAP32[($105 + ($8 | 4) | 0) >> 2] = $102 | 1; + HEAP32[($105 + $101 | 0) >> 2] = $102; + var $113 = HEAP32[(__gm_ + 8 | 0) >> 2]; + if (!(($113 | 0) == 0)) { + var $116 = HEAP32[(__gm_ + 20 | 0) >> 2]; + var $119 = $113 >>> 2 & 1073741822; + var $121 = __gm_ + 40 + ($119 << 2) | 0; + var $122 = HEAP32[(__gm_ | 0) >> 2]; + var $123 = 1 << ($113 >>> 3); + do { + if (($122 & $123 | 0) == 0) { + HEAP32[(__gm_ | 0) >> 2] = $122 | $123; + var $F4_0 = $121; + var $_pre_phi = __gm_ + 40 + (($119 + 2 | 0) << 2) | 0; } else { - var $8 = ($bytes + 11 | 0) & -8; - } - var $8; - var $9 = $8 >>> 3; - var $10 = HEAP32[(__gm_ | 0) >> 2]; - var $11 = $10 >>> ($9 >>> 0); - if (!(($11 & 3 | 0) == 0)) { - var $17 = ($11 & 1 ^ 1) + $9 | 0; - var $18 = $17 << 1; - var $20 = __gm_ + 40 + ($18 << 2) | 0; - var $21 = __gm_ + 40 + (($18 + 2 | 0) << 2) | 0; - var $22 = HEAP32[$21 >> 2]; - var $23 = $22 + 8 | 0; - var $24 = HEAP32[$23 >> 2]; - if (($20 | 0) == ($24 | 0)) { - HEAP32[(__gm_ | 0) >> 2] = $10 & (1 << $17 ^ -1); - } else { - if ($24 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { - _abort(); - } else { - HEAP32[$21 >> 2] = $24; - HEAP32[($24 + 12 | 0) >> 2] = $20; - } - } - var $38 = $17 << 3; - HEAP32[($22 + 4 | 0) >> 2] = $38 | 3; - var $43 = $22 + ($38 | 4) | 0; - HEAP32[$43 >> 2] = HEAP32[$43 >> 2] | 1; - var $mem_0 = $23; - __label__ = 331; + var $129 = __gm_ + 40 + (($119 + 2 | 0) << 2) | 0; + var $130 = HEAP32[$129 >> 2]; + if (!($130 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0)) { + var $F4_0 = $130; + var $_pre_phi = $129; break; + } + _abort(); } - if (!($8 >>> 0 > HEAP32[(__gm_ + 8 | 0) >> 2] >>> 0)) { - var $nb_0 = $8; - __label__ = 155; - break; + } while (0); + var $_pre_phi; + var $F4_0; + HEAP32[$_pre_phi >> 2] = $116; + HEAP32[($F4_0 + 12 | 0) >> 2] = $116; + HEAP32[($116 + 8 | 0) >> 2] = $F4_0; + HEAP32[($116 + 12 | 0) >> 2] = $121; + } + HEAP32[(__gm_ + 8 | 0) >> 2] = $102; + HEAP32[(__gm_ + 20 | 0) >> 2] = $107; + var $mem_0 = $86; + __label__ = 331; + break; + } + var $142 = HEAP32[(__gm_ + 4 | 0) >> 2]; + if (($142 | 0) == 0) { + var $nb_0 = $8; + __label__ = 155; + break; + } + var $147 = ($142 & (-$142 | 0)) - 1 | 0; + var $149 = $147 >>> 12 & 16; + var $150 = $147 >>> ($149 >>> 0); + var $152 = $150 >>> 5 & 8; + var $153 = $150 >>> ($152 >>> 0); + var $155 = $153 >>> 2 & 4; + var $156 = $153 >>> ($155 >>> 0); + var $158 = $156 >>> 1 & 2; + var $159 = $156 >>> ($158 >>> 0); + var $161 = $159 >>> 1 & 1; + var $169 = HEAP32[(__gm_ + 304 + ((($152 | $149 | $155 | $158 | $161) + ($159 >>> ($161 >>> 0)) | 0) << 2) | 0) >> 2]; + var $t_0_i = $169; + var $v_0_i = $169; + var $rsize_0_i = (HEAP32[($169 + 4 | 0) >> 2] & -8) - $8 | 0; + while (1) { + var $rsize_0_i; + var $v_0_i; + var $t_0_i; + var $176 = HEAP32[($t_0_i + 16 | 0) >> 2]; + if (($176 | 0) == 0) { + var $180 = HEAP32[($t_0_i + 20 | 0) >> 2]; + if (($180 | 0) == 0) { + break; + } + var $182 = $180; + } else { + var $182 = $176; + } + var $182; + var $186 = (HEAP32[($182 + 4 | 0) >> 2] & -8) - $8 | 0; + var $187 = $186 >>> 0 < $rsize_0_i >>> 0; + var $t_0_i = $182; + var $v_0_i = $187 ? $182 : $v_0_i; + var $rsize_0_i = $187 ? $186 : $rsize_0_i; + } + var $189 = $v_0_i; + var $190 = HEAP32[(__gm_ + 16 | 0) >> 2]; + do { + if (!($189 >>> 0 < $190 >>> 0)) { + var $193 = $189 + $8 | 0; + var $194 = $193; + if (!($189 >>> 0 < $193 >>> 0)) { + break; + } + var $198 = HEAP32[($v_0_i + 24 | 0) >> 2]; + var $200 = HEAP32[($v_0_i + 12 | 0) >> 2]; + do { + if (($200 | 0) == ($v_0_i | 0)) { + var $212 = $v_0_i + 20 | 0; + var $213 = HEAP32[$212 >> 2]; + if (($213 | 0) == 0) { + var $216 = $v_0_i + 16 | 0; + var $217 = HEAP32[$216 >> 2]; + if (($217 | 0) == 0) { + var $R_1_i = 0; + break; + } + var $RP_0_i = $216; + var $R_0_i = $217; + } else { + var $RP_0_i = $212; + var $R_0_i = $213; + __label__ = 39; + } + while (1) { + var $R_0_i; + var $RP_0_i; + var $219 = $R_0_i + 20 | 0; + var $220 = HEAP32[$219 >> 2]; + if (!(($220 | 0) == 0)) { + var $RP_0_i = $219; + var $R_0_i = $220; + continue; + } + var $223 = $R_0_i + 16 | 0; + var $224 = HEAP32[$223 >> 2]; + if (($224 | 0) == 0) { + break; + } + var $RP_0_i = $223; + var $R_0_i = $224; + } + if ($RP_0_i >>> 0 < $190 >>> 0) { + _abort(); + } else { + HEAP32[$RP_0_i >> 2] = 0; + var $R_1_i = $R_0_i; + } + } else { + var $204 = HEAP32[($v_0_i + 8 | 0) >> 2]; + if ($204 >>> 0 < $190 >>> 0) { + _abort(); + } else { + HEAP32[($204 + 12 | 0) >> 2] = $200; + HEAP32[($200 + 8 | 0) >> 2] = $204; + var $R_1_i = $200; + } } - if (!(($11 | 0) == 0)) { - var $54 = 2 << $9; - var $57 = $11 << $9 & ($54 | (-$54 | 0)); - var $60 = ($57 & (-$57 | 0)) - 1 | 0; - var $62 = $60 >>> 12 & 16; - var $63 = $60 >>> ($62 >>> 0); - var $65 = $63 >>> 5 & 8; - var $66 = $63 >>> ($65 >>> 0); - var $68 = $66 >>> 2 & 4; - var $69 = $66 >>> ($68 >>> 0); - var $71 = $69 >>> 1 & 2; - var $72 = $69 >>> ($71 >>> 0); - var $74 = $72 >>> 1 & 1; - var $80 = ($65 | $62 | $68 | $71 | $74) + ($72 >>> ($74 >>> 0)) | 0; - var $81 = $80 << 1; - var $83 = __gm_ + 40 + ($81 << 2) | 0; - var $84 = __gm_ + 40 + (($81 + 2 | 0) << 2) | 0; - var $85 = HEAP32[$84 >> 2]; - var $86 = $85 + 8 | 0; - var $87 = HEAP32[$86 >> 2]; - if (($83 | 0) == ($87 | 0)) { - HEAP32[(__gm_ | 0) >> 2] = $10 & (1 << $80 ^ -1); + } while (0); + var $R_1_i; + $_$62 : do { + if (!(($198 | 0) == 0)) { + var $234 = $v_0_i + 28 | 0; + var $236 = __gm_ + 304 + (HEAP32[$234 >> 2] << 2) | 0; + do { + if (($v_0_i | 0) == (HEAP32[$236 >> 2] | 0)) { + HEAP32[$236 >> 2] = $R_1_i; + if (!(($R_1_i | 0) == 0)) { + break; + } + HEAP32[(__gm_ + 4 | 0) >> 2] = HEAP32[(__gm_ + 4 | 0) >> 2] & (1 << HEAP32[$234 >> 2] ^ -1); + break $_$62; + } + if ($198 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { + _abort(); } else { - if ($87 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { - _abort(); - } else { - HEAP32[$84 >> 2] = $87; - HEAP32[($87 + 12 | 0) >> 2] = $83; - } + var $250 = $198 + 16 | 0; + if ((HEAP32[$250 >> 2] | 0) == ($v_0_i | 0)) { + HEAP32[$250 >> 2] = $R_1_i; + } else { + HEAP32[($198 + 20 | 0) >> 2] = $R_1_i; + } + if (($R_1_i | 0) == 0) { + break $_$62; + } } - var $101 = $80 << 3; - var $102 = $101 - $8 | 0; - HEAP32[($85 + 4 | 0) >> 2] = $8 | 3; - var $105 = $85; - var $107 = $105 + $8 | 0; - HEAP32[($105 + ($8 | 4) | 0) >> 2] = $102 | 1; - HEAP32[($105 + $101 | 0) >> 2] = $102; - var $113 = HEAP32[(__gm_ + 8 | 0) >> 2]; - if (!(($113 | 0) == 0)) { - var $116 = HEAP32[(__gm_ + 20 | 0) >> 2]; - var $119 = $113 >>> 2 & 1073741822; - var $121 = __gm_ + 40 + ($119 << 2) | 0; - var $122 = HEAP32[(__gm_ | 0) >> 2]; - var $123 = 1 << ($113 >>> 3); - do { - if (($122 & $123 | 0) == 0) { - HEAP32[(__gm_ | 0) >> 2] = $122 | $123; - var $F4_0 = $121; - var $_pre_phi = __gm_ + 40 + (($119 + 2 | 0) << 2) | 0; - } else { - var $129 = __gm_ + 40 + (($119 + 2 | 0) << 2) | 0; - var $130 = HEAP32[$129 >> 2]; - if (!($130 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0)) { - var $F4_0 = $130; - var $_pre_phi = $129; - break; - } - _abort(); - } - } while (0); - var $_pre_phi; - var $F4_0; - HEAP32[$_pre_phi >> 2] = $116; - HEAP32[($F4_0 + 12 | 0) >> 2] = $116; - HEAP32[($116 + 8 | 0) >> 2] = $F4_0; - HEAP32[($116 + 12 | 0) >> 2] = $121; + } while (0); + if ($R_1_i >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { + _abort(); + } else { + HEAP32[($R_1_i + 24 | 0) >> 2] = $198; + var $266 = HEAP32[($v_0_i + 16 | 0) >> 2]; + if (!(($266 | 0) == 0)) { + if ($266 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { + _abort(); + } else { + HEAP32[($R_1_i + 16 | 0) >> 2] = $266; + HEAP32[($266 + 24 | 0) >> 2] = $R_1_i; + } } - HEAP32[(__gm_ + 8 | 0) >> 2] = $102; - HEAP32[(__gm_ + 20 | 0) >> 2] = $107; - var $mem_0 = $86; - __label__ = 331; - break; + var $278 = HEAP32[($v_0_i + 20 | 0) >> 2]; + if (($278 | 0) == 0) { + break; + } + if ($278 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { + _abort(); + } else { + HEAP32[($R_1_i + 20 | 0) >> 2] = $278; + HEAP32[($278 + 24 | 0) >> 2] = $R_1_i; + } + } } - var $142 = HEAP32[(__gm_ + 4 | 0) >> 2]; - if (($142 | 0) == 0) { - var $nb_0 = $8; - __label__ = 155; - break; + } while (0); + if ($rsize_0_i >>> 0 < 16) { + var $292 = $rsize_0_i + $8 | 0; + HEAP32[($v_0_i + 4 | 0) >> 2] = $292 | 3; + var $296 = $189 + ($292 + 4 | 0) | 0; + HEAP32[$296 >> 2] = HEAP32[$296 >> 2] | 1; + } else { + HEAP32[($v_0_i + 4 | 0) >> 2] = $8 | 3; + HEAP32[($189 + ($8 | 4) | 0) >> 2] = $rsize_0_i | 1; + HEAP32[($189 + ($rsize_0_i + $8 | 0) | 0) >> 2] = $rsize_0_i; + var $307 = HEAP32[(__gm_ + 8 | 0) >> 2]; + if (!(($307 | 0) == 0)) { + var $310 = HEAP32[(__gm_ + 20 | 0) >> 2]; + var $313 = $307 >>> 2 & 1073741822; + var $315 = __gm_ + 40 + ($313 << 2) | 0; + var $316 = HEAP32[(__gm_ | 0) >> 2]; + var $317 = 1 << ($307 >>> 3); + do { + if (($316 & $317 | 0) == 0) { + HEAP32[(__gm_ | 0) >> 2] = $316 | $317; + var $F1_0_i = $315; + var $_pre_phi_i = __gm_ + 40 + (($313 + 2 | 0) << 2) | 0; + } else { + var $323 = __gm_ + 40 + (($313 + 2 | 0) << 2) | 0; + var $324 = HEAP32[$323 >> 2]; + if (!($324 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0)) { + var $F1_0_i = $324; + var $_pre_phi_i = $323; + break; + } + _abort(); + } + } while (0); + var $_pre_phi_i; + var $F1_0_i; + HEAP32[$_pre_phi_i >> 2] = $310; + HEAP32[($F1_0_i + 12 | 0) >> 2] = $310; + HEAP32[($310 + 8 | 0) >> 2] = $F1_0_i; + HEAP32[($310 + 12 | 0) >> 2] = $315; } - var $147 = ($142 & (-$142 | 0)) - 1 | 0; - var $149 = $147 >>> 12 & 16; - var $150 = $147 >>> ($149 >>> 0); - var $152 = $150 >>> 5 & 8; - var $153 = $150 >>> ($152 >>> 0); - var $155 = $153 >>> 2 & 4; - var $156 = $153 >>> ($155 >>> 0); - var $158 = $156 >>> 1 & 2; - var $159 = $156 >>> ($158 >>> 0); - var $161 = $159 >>> 1 & 1; - var $169 = HEAP32[(__gm_ + 304 + ((($152 | $149 | $155 | $158 | $161) + ($159 >>> ($161 >>> 0)) | 0) << 2) | 0) >> 2]; - var $t_0_i = $169; - var $v_0_i = $169; - var $rsize_0_i = (HEAP32[($169 + 4 | 0) >> 2] & -8) - $8 | 0; - while (1) { - var $rsize_0_i; - var $v_0_i; - var $t_0_i; - var $176 = HEAP32[($t_0_i + 16 | 0) >> 2]; - if (($176 | 0) == 0) { - var $180 = HEAP32[($t_0_i + 20 | 0) >> 2]; - if (($180 | 0) == 0) { - break; - } - var $182 = $180; + HEAP32[(__gm_ + 8 | 0) >> 2] = $rsize_0_i; + HEAP32[(__gm_ + 20 | 0) >> 2] = $194; + } + var $335 = $v_0_i + 8 | 0; + if (($335 | 0) == 0) { + var $nb_0 = $8; + __label__ = 155; + break $_$2; + } + var $mem_0 = $335; + __label__ = 331; + break $_$2; + } + } while (0); + _abort(); + } else { + if ($bytes >>> 0 > 4294967231) { + var $nb_0 = -1; + __label__ = 155; + break; + } + var $341 = $bytes + 11 | 0; + var $342 = $341 & -8; + var $343 = HEAP32[(__gm_ + 4 | 0) >> 2]; + if (($343 | 0) == 0) { + var $nb_0 = $342; + __label__ = 155; + break; + } + var $346 = -$342 | 0; + var $347 = $341 >>> 8; + do { + if (($347 | 0) == 0) { + var $idx_0_i = 0; + } else { + if ($342 >>> 0 > 16777215) { + var $idx_0_i = 31; + break; + } + var $354 = ($347 + 1048320 | 0) >>> 16 & 8; + var $355 = $347 << $354; + var $358 = ($355 + 520192 | 0) >>> 16 & 4; + var $359 = $355 << $358; + var $362 = ($359 + 245760 | 0) >>> 16 & 2; + var $368 = (14 - ($358 | $354 | $362) | 0) + ($359 << $362 >>> 15) | 0; + var $idx_0_i = $342 >>> (($368 + 7 | 0) >>> 0) & 1 | $368 << 1; + } + } while (0); + var $idx_0_i; + var $376 = HEAP32[(__gm_ + 304 + ($idx_0_i << 2) | 0) >> 2]; + $_$110 : do { + if (($376 | 0) == 0) { + var $v_2_i = 0; + var $rsize_2_i = $346; + var $t_1_i = 0; + } else { + if (($idx_0_i | 0) == 31) { + var $384 = 0; + } else { + var $384 = 25 - ($idx_0_i >>> 1) | 0; + } + var $384; + var $v_0_i15 = 0; + var $rsize_0_i14 = $346; + var $t_0_i13 = $376; + var $sizebits_0_i = $342 << $384; + var $rst_0_i = 0; + while (1) { + var $rst_0_i; + var $sizebits_0_i; + var $t_0_i13; + var $rsize_0_i14; + var $v_0_i15; + var $389 = HEAP32[($t_0_i13 + 4 | 0) >> 2] & -8; + var $390 = $389 - $342 | 0; + if ($390 >>> 0 < $rsize_0_i14 >>> 0) { + if (($389 | 0) == ($342 | 0)) { + var $v_2_i = $t_0_i13; + var $rsize_2_i = $390; + var $t_1_i = $t_0_i13; + break $_$110; + } + var $v_1_i = $t_0_i13; + var $rsize_1_i = $390; + } else { + var $v_1_i = $v_0_i15; + var $rsize_1_i = $rsize_0_i14; + } + var $rsize_1_i; + var $v_1_i; + var $396 = HEAP32[($t_0_i13 + 20 | 0) >> 2]; + var $399 = HEAP32[($t_0_i13 + 16 + ($sizebits_0_i >>> 31 << 2) | 0) >> 2]; + var $rst_1_i = ($396 | 0) == 0 | ($396 | 0) == ($399 | 0) ? $rst_0_i : $396; + if (($399 | 0) == 0) { + var $v_2_i = $v_1_i; + var $rsize_2_i = $rsize_1_i; + var $t_1_i = $rst_1_i; + break $_$110; + } + var $v_0_i15 = $v_1_i; + var $rsize_0_i14 = $rsize_1_i; + var $t_0_i13 = $399; + var $sizebits_0_i = $sizebits_0_i << 1; + var $rst_0_i = $rst_1_i; + } + } + } while (0); + var $t_1_i; + var $rsize_2_i; + var $v_2_i; + if (($t_1_i | 0) == 0 & ($v_2_i | 0) == 0) { + var $407 = 2 << $idx_0_i; + var $410 = $343 & ($407 | (-$407 | 0)); + if (($410 | 0) == 0) { + var $nb_0 = $342; + __label__ = 155; + break; + } + var $415 = ($410 & (-$410 | 0)) - 1 | 0; + var $417 = $415 >>> 12 & 16; + var $418 = $415 >>> ($417 >>> 0); + var $420 = $418 >>> 5 & 8; + var $421 = $418 >>> ($420 >>> 0); + var $423 = $421 >>> 2 & 4; + var $424 = $421 >>> ($423 >>> 0); + var $426 = $424 >>> 1 & 2; + var $427 = $424 >>> ($426 >>> 0); + var $429 = $427 >>> 1 & 1; + var $t_2_ph_i = HEAP32[(__gm_ + 304 + ((($420 | $417 | $423 | $426 | $429) + ($427 >>> ($429 >>> 0)) | 0) << 2) | 0) >> 2]; + } else { + var $t_2_ph_i = $t_1_i; + } + var $t_2_ph_i; + $_$125 : do { + if (($t_2_ph_i | 0) == 0) { + var $rsize_3_lcssa_i = $rsize_2_i; + var $v_3_lcssa_i = $v_2_i; + } else { + var $t_224_i = $t_2_ph_i; + var $rsize_325_i = $rsize_2_i; + var $v_326_i = $v_2_i; + while (1) { + var $v_326_i; + var $rsize_325_i; + var $t_224_i; + var $442 = (HEAP32[($t_224_i + 4 | 0) >> 2] & -8) - $342 | 0; + var $443 = $442 >>> 0 < $rsize_325_i >>> 0; + var $_rsize_3_i = $443 ? $442 : $rsize_325_i; + var $t_2_v_3_i = $443 ? $t_224_i : $v_326_i; + var $445 = HEAP32[($t_224_i + 16 | 0) >> 2]; + if (!(($445 | 0) == 0)) { + var $t_224_i = $445; + var $rsize_325_i = $_rsize_3_i; + var $v_326_i = $t_2_v_3_i; + continue; + } + var $448 = HEAP32[($t_224_i + 20 | 0) >> 2]; + if (($448 | 0) == 0) { + var $rsize_3_lcssa_i = $_rsize_3_i; + var $v_3_lcssa_i = $t_2_v_3_i; + break $_$125; + } + var $t_224_i = $448; + var $rsize_325_i = $_rsize_3_i; + var $v_326_i = $t_2_v_3_i; + } + } + } while (0); + var $v_3_lcssa_i; + var $rsize_3_lcssa_i; + if (($v_3_lcssa_i | 0) == 0) { + var $nb_0 = $342; + __label__ = 155; + break; + } + if (!($rsize_3_lcssa_i >>> 0 < (HEAP32[(__gm_ + 8 | 0) >> 2] - $342 | 0) >>> 0)) { + var $nb_0 = $342; + __label__ = 155; + break; + } + var $456 = $v_3_lcssa_i; + var $457 = HEAP32[(__gm_ + 16 | 0) >> 2]; + do { + if (!($456 >>> 0 < $457 >>> 0)) { + var $460 = $456 + $342 | 0; + var $461 = $460; + if (!($456 >>> 0 < $460 >>> 0)) { + break; + } + var $465 = HEAP32[($v_3_lcssa_i + 24 | 0) >> 2]; + var $467 = HEAP32[($v_3_lcssa_i + 12 | 0) >> 2]; + do { + if (($467 | 0) == ($v_3_lcssa_i | 0)) { + var $479 = $v_3_lcssa_i + 20 | 0; + var $480 = HEAP32[$479 >> 2]; + if (($480 | 0) == 0) { + var $483 = $v_3_lcssa_i + 16 | 0; + var $484 = HEAP32[$483 >> 2]; + if (($484 | 0) == 0) { + var $R_1_i19 = 0; + break; + } + var $RP_0_i17 = $483; + var $R_0_i16 = $484; + } else { + var $RP_0_i17 = $479; + var $R_0_i16 = $480; + __label__ = 103; + } + while (1) { + var $R_0_i16; + var $RP_0_i17; + var $486 = $R_0_i16 + 20 | 0; + var $487 = HEAP32[$486 >> 2]; + if (!(($487 | 0) == 0)) { + var $RP_0_i17 = $486; + var $R_0_i16 = $487; + continue; + } + var $490 = $R_0_i16 + 16 | 0; + var $491 = HEAP32[$490 >> 2]; + if (($491 | 0) == 0) { + break; + } + var $RP_0_i17 = $490; + var $R_0_i16 = $491; + } + if ($RP_0_i17 >>> 0 < $457 >>> 0) { + _abort(); + } else { + HEAP32[$RP_0_i17 >> 2] = 0; + var $R_1_i19 = $R_0_i16; + } + } else { + var $471 = HEAP32[($v_3_lcssa_i + 8 | 0) >> 2]; + if ($471 >>> 0 < $457 >>> 0) { + _abort(); + } else { + HEAP32[($471 + 12 | 0) >> 2] = $467; + HEAP32[($467 + 8 | 0) >> 2] = $471; + var $R_1_i19 = $467; + } + } + } while (0); + var $R_1_i19; + $_$151 : do { + if (!(($465 | 0) == 0)) { + var $501 = $v_3_lcssa_i + 28 | 0; + var $503 = __gm_ + 304 + (HEAP32[$501 >> 2] << 2) | 0; + do { + if (($v_3_lcssa_i | 0) == (HEAP32[$503 >> 2] | 0)) { + HEAP32[$503 >> 2] = $R_1_i19; + if (!(($R_1_i19 | 0) == 0)) { + break; + } + HEAP32[(__gm_ + 4 | 0) >> 2] = HEAP32[(__gm_ + 4 | 0) >> 2] & (1 << HEAP32[$501 >> 2] ^ -1); + break $_$151; + } + if ($465 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { + _abort(); + } else { + var $517 = $465 + 16 | 0; + if ((HEAP32[$517 >> 2] | 0) == ($v_3_lcssa_i | 0)) { + HEAP32[$517 >> 2] = $R_1_i19; + } else { + HEAP32[($465 + 20 | 0) >> 2] = $R_1_i19; + } + if (($R_1_i19 | 0) == 0) { + break $_$151; + } + } + } while (0); + if ($R_1_i19 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { + _abort(); + } else { + HEAP32[($R_1_i19 + 24 | 0) >> 2] = $465; + var $533 = HEAP32[($v_3_lcssa_i + 16 | 0) >> 2]; + if (!(($533 | 0) == 0)) { + if ($533 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { + _abort(); + } else { + HEAP32[($R_1_i19 + 16 | 0) >> 2] = $533; + HEAP32[($533 + 24 | 0) >> 2] = $R_1_i19; + } + } + var $545 = HEAP32[($v_3_lcssa_i + 20 | 0) >> 2]; + if (($545 | 0) == 0) { + break; + } + if ($545 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { + _abort(); } else { - var $182 = $176; + HEAP32[($R_1_i19 + 20 | 0) >> 2] = $545; + HEAP32[($545 + 24 | 0) >> 2] = $R_1_i19; } - var $182; - var $186 = (HEAP32[($182 + 4 | 0) >> 2] & -8) - $8 | 0; - var $187 = $186 >>> 0 < $rsize_0_i >>> 0; - var $t_0_i = $182; - var $v_0_i = $187 ? $182 : $v_0_i; - var $rsize_0_i = $187 ? $186 : $rsize_0_i; + } } - var $189 = $v_0_i; - var $190 = HEAP32[(__gm_ + 16 | 0) >> 2]; - do { - if (!($189 >>> 0 < $190 >>> 0)) { - var $193 = $189 + $8 | 0; - var $194 = $193; - if (!($189 >>> 0 < $193 >>> 0)) { - break; + } while (0); + $_$179 : do { + if ($rsize_3_lcssa_i >>> 0 < 16) { + var $559 = $rsize_3_lcssa_i + $342 | 0; + HEAP32[($v_3_lcssa_i + 4 | 0) >> 2] = $559 | 3; + var $563 = $456 + ($559 + 4 | 0) | 0; + HEAP32[$563 >> 2] = HEAP32[$563 >> 2] | 1; + } else { + HEAP32[($v_3_lcssa_i + 4 | 0) >> 2] = $342 | 3; + HEAP32[($456 + ($342 | 4) | 0) >> 2] = $rsize_3_lcssa_i | 1; + HEAP32[($456 + ($rsize_3_lcssa_i + $342 | 0) | 0) >> 2] = $rsize_3_lcssa_i; + if ($rsize_3_lcssa_i >>> 0 < 256) { + var $578 = $rsize_3_lcssa_i >>> 2 & 1073741822; + var $580 = __gm_ + 40 + ($578 << 2) | 0; + var $581 = HEAP32[(__gm_ | 0) >> 2]; + var $582 = 1 << ($rsize_3_lcssa_i >>> 3); + do { + if (($581 & $582 | 0) == 0) { + HEAP32[(__gm_ | 0) >> 2] = $581 | $582; + var $F5_0_i = $580; + var $_pre_phi_i25 = __gm_ + 40 + (($578 + 2 | 0) << 2) | 0; + } else { + var $588 = __gm_ + 40 + (($578 + 2 | 0) << 2) | 0; + var $589 = HEAP32[$588 >> 2]; + if (!($589 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0)) { + var $F5_0_i = $589; + var $_pre_phi_i25 = $588; + break; + } + _abort(); + } + } while (0); + var $_pre_phi_i25; + var $F5_0_i; + HEAP32[$_pre_phi_i25 >> 2] = $461; + HEAP32[($F5_0_i + 12 | 0) >> 2] = $461; + HEAP32[($456 + ($342 + 8 | 0) | 0) >> 2] = $F5_0_i; + HEAP32[($456 + ($342 + 12 | 0) | 0) >> 2] = $580; + } else { + var $601 = $460; + var $602 = $rsize_3_lcssa_i >>> 8; + do { + if (($602 | 0) == 0) { + var $I7_0_i = 0; + } else { + if ($rsize_3_lcssa_i >>> 0 > 16777215) { + var $I7_0_i = 31; + break; } - var $198 = HEAP32[($v_0_i + 24 | 0) >> 2]; - var $200 = HEAP32[($v_0_i + 12 | 0) >> 2]; - do { - if (($200 | 0) == ($v_0_i | 0)) { - var $212 = $v_0_i + 20 | 0; - var $213 = HEAP32[$212 >> 2]; - if (($213 | 0) == 0) { - var $216 = $v_0_i + 16 | 0; - var $217 = HEAP32[$216 >> 2]; - if (($217 | 0) == 0) { - var $R_1_i = 0; - break; - } - var $RP_0_i = $216; - var $R_0_i = $217; - } else { - var $RP_0_i = $212; - var $R_0_i = $213; - __label__ = 39; - } - while (1) { - var $R_0_i; - var $RP_0_i; - var $219 = $R_0_i + 20 | 0; - var $220 = HEAP32[$219 >> 2]; - if (!(($220 | 0) == 0)) { - var $RP_0_i = $219; - var $R_0_i = $220; - continue; - } - var $223 = $R_0_i + 16 | 0; - var $224 = HEAP32[$223 >> 2]; - if (($224 | 0) == 0) { - break; - } - var $RP_0_i = $223; - var $R_0_i = $224; - } - if ($RP_0_i >>> 0 < $190 >>> 0) { - _abort(); - } else { - HEAP32[$RP_0_i >> 2] = 0; - var $R_1_i = $R_0_i; - } - } else { - var $204 = HEAP32[($v_0_i + 8 | 0) >> 2]; - if ($204 >>> 0 < $190 >>> 0) { - _abort(); - } else { - HEAP32[($204 + 12 | 0) >> 2] = $200; - HEAP32[($200 + 8 | 0) >> 2] = $204; - var $R_1_i = $200; - } - } - } while (0); - var $R_1_i; - $_$62 : do { - if (!(($198 | 0) == 0)) { - var $234 = $v_0_i + 28 | 0; - var $236 = __gm_ + 304 + (HEAP32[$234 >> 2] << 2) | 0; - do { - if (($v_0_i | 0) == (HEAP32[$236 >> 2] | 0)) { - HEAP32[$236 >> 2] = $R_1_i; - if (!(($R_1_i | 0) == 0)) { - break; - } - HEAP32[(__gm_ + 4 | 0) >> 2] = HEAP32[(__gm_ + 4 | 0) >> 2] & (1 << HEAP32[$234 >> 2] ^ -1); - break $_$62; - } - if ($198 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { - _abort(); - } else { - var $250 = $198 + 16 | 0; - if ((HEAP32[$250 >> 2] | 0) == ($v_0_i | 0)) { - HEAP32[$250 >> 2] = $R_1_i; - } else { - HEAP32[($198 + 20 | 0) >> 2] = $R_1_i; - } - if (($R_1_i | 0) == 0) { - break $_$62; - } - } - } while (0); - if ($R_1_i >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { - _abort(); - } else { - HEAP32[($R_1_i + 24 | 0) >> 2] = $198; - var $266 = HEAP32[($v_0_i + 16 | 0) >> 2]; - if (!(($266 | 0) == 0)) { - if ($266 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { - _abort(); - } else { - HEAP32[($R_1_i + 16 | 0) >> 2] = $266; - HEAP32[($266 + 24 | 0) >> 2] = $R_1_i; - } - } - var $278 = HEAP32[($v_0_i + 20 | 0) >> 2]; - if (($278 | 0) == 0) { - break; - } - if ($278 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { - _abort(); - } else { - HEAP32[($R_1_i + 20 | 0) >> 2] = $278; - HEAP32[($278 + 24 | 0) >> 2] = $R_1_i; - } - } + var $609 = ($602 + 1048320 | 0) >>> 16 & 8; + var $610 = $602 << $609; + var $613 = ($610 + 520192 | 0) >>> 16 & 4; + var $614 = $610 << $613; + var $617 = ($614 + 245760 | 0) >>> 16 & 2; + var $623 = (14 - ($613 | $609 | $617) | 0) + ($614 << $617 >>> 15) | 0; + var $I7_0_i = $rsize_3_lcssa_i >>> (($623 + 7 | 0) >>> 0) & 1 | $623 << 1; + } + } while (0); + var $I7_0_i; + var $630 = __gm_ + 304 + ($I7_0_i << 2) | 0; + HEAP32[($456 + ($342 + 28 | 0) | 0) >> 2] = $I7_0_i; + HEAP32[($456 + ($342 + 20 | 0) | 0) >> 2] = 0; + HEAP32[($456 + ($342 + 16 | 0) | 0) >> 2] = 0; + var $637 = HEAP32[(__gm_ + 4 | 0) >> 2]; + var $638 = 1 << $I7_0_i; + if (($637 & $638 | 0) == 0) { + HEAP32[(__gm_ + 4 | 0) >> 2] = $637 | $638; + HEAP32[$630 >> 2] = $601; + HEAP32[($456 + ($342 + 24 | 0) | 0) >> 2] = $630; + HEAP32[($456 + ($342 + 12 | 0) | 0) >> 2] = $601; + HEAP32[($456 + ($342 + 8 | 0) | 0) >> 2] = $601; + } else { + if (($I7_0_i | 0) == 31) { + var $657 = 0; + } else { + var $657 = 25 - ($I7_0_i >>> 1) | 0; + } + var $657; + var $K12_0_i = $rsize_3_lcssa_i << $657; + var $T_0_i = HEAP32[$630 >> 2]; + while (1) { + var $T_0_i; + var $K12_0_i; + if ((HEAP32[($T_0_i + 4 | 0) >> 2] & -8 | 0) == ($rsize_3_lcssa_i | 0)) { + var $683 = $T_0_i + 8 | 0; + var $684 = HEAP32[$683 >> 2]; + var $686 = HEAP32[(__gm_ + 16 | 0) >> 2]; + do { + if (!($T_0_i >>> 0 < $686 >>> 0)) { + if ($684 >>> 0 < $686 >>> 0) { + break; + } + HEAP32[($684 + 12 | 0) >> 2] = $601; + HEAP32[$683 >> 2] = $601; + HEAP32[($456 + ($342 + 8 | 0) | 0) >> 2] = $684; + HEAP32[($456 + ($342 + 12 | 0) | 0) >> 2] = $T_0_i; + HEAP32[($456 + ($342 + 24 | 0) | 0) >> 2] = 0; + break $_$179; } - } while (0); - if ($rsize_0_i >>> 0 < 16) { - var $292 = $rsize_0_i + $8 | 0; - HEAP32[($v_0_i + 4 | 0) >> 2] = $292 | 3; - var $296 = $189 + ($292 + 4 | 0) | 0; - HEAP32[$296 >> 2] = HEAP32[$296 >> 2] | 1; + } while (0); + _abort(); } else { - HEAP32[($v_0_i + 4 | 0) >> 2] = $8 | 3; - HEAP32[($189 + ($8 | 4) | 0) >> 2] = $rsize_0_i | 1; - HEAP32[($189 + ($rsize_0_i + $8 | 0) | 0) >> 2] = $rsize_0_i; - var $307 = HEAP32[(__gm_ + 8 | 0) >> 2]; - if (!(($307 | 0) == 0)) { - var $310 = HEAP32[(__gm_ + 20 | 0) >> 2]; - var $313 = $307 >>> 2 & 1073741822; - var $315 = __gm_ + 40 + ($313 << 2) | 0; - var $316 = HEAP32[(__gm_ | 0) >> 2]; - var $317 = 1 << ($307 >>> 3); - do { - if (($316 & $317 | 0) == 0) { - HEAP32[(__gm_ | 0) >> 2] = $316 | $317; - var $F1_0_i = $315; - var $_pre_phi_i = __gm_ + 40 + (($313 + 2 | 0) << 2) | 0; - } else { - var $323 = __gm_ + 40 + (($313 + 2 | 0) << 2) | 0; - var $324 = HEAP32[$323 >> 2]; - if (!($324 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0)) { - var $F1_0_i = $324; - var $_pre_phi_i = $323; - break; - } - _abort(); - } - } while (0); - var $_pre_phi_i; - var $F1_0_i; - HEAP32[$_pre_phi_i >> 2] = $310; - HEAP32[($F1_0_i + 12 | 0) >> 2] = $310; - HEAP32[($310 + 8 | 0) >> 2] = $F1_0_i; - HEAP32[($310 + 12 | 0) >> 2] = $315; - } - HEAP32[(__gm_ + 8 | 0) >> 2] = $rsize_0_i; - HEAP32[(__gm_ + 20 | 0) >> 2] = $194; - } - var $335 = $v_0_i + 8 | 0; - if (($335 | 0) == 0) { - var $nb_0 = $8; - __label__ = 155; - break $_$2; + var $666 = $T_0_i + 16 + ($K12_0_i >>> 31 << 2) | 0; + var $667 = HEAP32[$666 >> 2]; + if (!(($667 | 0) == 0)) { + var $K12_0_i = $K12_0_i << 1; + var $T_0_i = $667; + continue; + } + if (!($666 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0)) { + HEAP32[$666 >> 2] = $601; + HEAP32[($456 + ($342 + 24 | 0) | 0) >> 2] = $T_0_i; + HEAP32[($456 + ($342 + 12 | 0) | 0) >> 2] = $601; + HEAP32[($456 + ($342 + 8 | 0) | 0) >> 2] = $601; + break $_$179; + } + _abort(); } - var $mem_0 = $335; - __label__ = 331; - break $_$2; + } } - } while (0); - _abort(); - } else { - if ($bytes >>> 0 > 4294967231) { - var $nb_0 = -1; - __label__ = 155; - break; + } } - var $341 = $bytes + 11 | 0; - var $342 = $341 & -8; - var $343 = HEAP32[(__gm_ + 4 | 0) >> 2]; - if (($343 | 0) == 0) { - var $nb_0 = $342; - __label__ = 155; + } while (0); + var $700 = $v_3_lcssa_i + 8 | 0; + if (($700 | 0) == 0) { + var $nb_0 = $342; + __label__ = 155; + break $_$2; + } + var $mem_0 = $700; + __label__ = 331; + break $_$2; + } + } while (0); + _abort(); + } + } while (0); + $_$215 : do { + if (__label__ == 155) { + var $nb_0; + var $703 = HEAP32[(__gm_ + 8 | 0) >> 2]; + if ($nb_0 >>> 0 > $703 >>> 0) { + var $732 = HEAP32[(__gm_ + 12 | 0) >> 2]; + if ($nb_0 >>> 0 < $732 >>> 0) { + var $735 = $732 - $nb_0 | 0; + HEAP32[(__gm_ + 12 | 0) >> 2] = $735; + var $736 = HEAP32[(__gm_ + 24 | 0) >> 2]; + var $737 = $736; + HEAP32[(__gm_ + 24 | 0) >> 2] = $737 + $nb_0 | 0; + HEAP32[($737 + ($nb_0 + 4 | 0) | 0) >> 2] = $735 | 1; + HEAP32[($736 + 4 | 0) >> 2] = $nb_0 | 3; + var $mem_0 = $736 + 8 | 0; + } else { + do { + if ((HEAP32[(_mparams | 0) >> 2] | 0) == 0) { + if (!((HEAP32[(_mparams | 0) >> 2] | 0) == 0)) { break; + } + var $754 = _sysconf(8); + if ((($754 - 1 | 0) & $754 | 0) == 0) { + HEAP32[(_mparams + 8 | 0) >> 2] = $754; + HEAP32[(_mparams + 4 | 0) >> 2] = $754; + HEAP32[(_mparams + 12 | 0) >> 2] = -1; + HEAP32[(_mparams + 16 | 0) >> 2] = 2097152; + HEAP32[(_mparams + 20 | 0) >> 2] = 0; + HEAP32[(__gm_ + 440 | 0) >> 2] = 0; + var $762 = _time(0) & -16 ^ 1431655768; + HEAP32[(_mparams | 0) >> 2] = $762; + } else { + _abort(); + } } - var $346 = -$342 | 0; - var $347 = $341 >>> 8; - do { - if (($347 | 0) == 0) { - var $idx_0_i = 0; - } else { - if ($342 >>> 0 > 16777215) { - var $idx_0_i = 31; + } while (0); + $_$234 : do { + if ((HEAP32[(__gm_ + 440 | 0) >> 2] & 4 | 0) == 0) { + var $767 = HEAP32[(__gm_ + 24 | 0) >> 2]; + $_$236 : do { + if (!(($767 | 0) == 0)) { + var $770 = $767; + var $sp_0_i_i = __gm_ + 444 | 0; + while (1) { + var $sp_0_i_i; + var $772 = $sp_0_i_i | 0; + var $773 = HEAP32[$772 >> 2]; + if (!($773 >>> 0 > $770 >>> 0)) { + var $776 = $sp_0_i_i + 4 | 0; + if (($773 + HEAP32[$776 >> 2] | 0) >>> 0 > $770 >>> 0) { break; + } } - var $354 = ($347 + 1048320 | 0) >>> 16 & 8; - var $355 = $347 << $354; - var $358 = ($355 + 520192 | 0) >>> 16 & 4; - var $359 = $355 << $358; - var $362 = ($359 + 245760 | 0) >>> 16 & 2; - var $368 = (14 - ($358 | $354 | $362) | 0) + ($359 << $362 >>> 15) | 0; - var $idx_0_i = $342 >>> (($368 + 7 | 0) >>> 0) & 1 | $368 << 1; - } - } while (0); - var $idx_0_i; - var $376 = HEAP32[(__gm_ + 304 + ($idx_0_i << 2) | 0) >> 2]; - $_$110 : do { - if (($376 | 0) == 0) { - var $v_2_i = 0; - var $rsize_2_i = $346; - var $t_1_i = 0; - } else { - if (($idx_0_i | 0) == 31) { - var $384 = 0; - } else { - var $384 = 25 - ($idx_0_i >>> 1) | 0; - } - var $384; - var $v_0_i15 = 0; - var $rsize_0_i14 = $346; - var $t_0_i13 = $376; - var $sizebits_0_i = $342 << $384; - var $rst_0_i = 0; - while (1) { - var $rst_0_i; - var $sizebits_0_i; - var $t_0_i13; - var $rsize_0_i14; - var $v_0_i15; - var $389 = HEAP32[($t_0_i13 + 4 | 0) >> 2] & -8; - var $390 = $389 - $342 | 0; - if ($390 >>> 0 < $rsize_0_i14 >>> 0) { - if (($389 | 0) == ($342 | 0)) { - var $v_2_i = $t_0_i13; - var $rsize_2_i = $390; - var $t_1_i = $t_0_i13; - break $_$110; - } - var $v_1_i = $t_0_i13; - var $rsize_1_i = $390; - } else { - var $v_1_i = $v_0_i15; - var $rsize_1_i = $rsize_0_i14; - } - var $rsize_1_i; - var $v_1_i; - var $396 = HEAP32[($t_0_i13 + 20 | 0) >> 2]; - var $399 = HEAP32[($t_0_i13 + 16 + ($sizebits_0_i >>> 31 << 2) | 0) >> 2]; - var $rst_1_i = ($396 | 0) == 0 | ($396 | 0) == ($399 | 0) ? $rst_0_i : $396; - if (($399 | 0) == 0) { - var $v_2_i = $v_1_i; - var $rsize_2_i = $rsize_1_i; - var $t_1_i = $rst_1_i; - break $_$110; - } - var $v_0_i15 = $v_1_i; - var $rsize_0_i14 = $rsize_1_i; - var $t_0_i13 = $399; - var $sizebits_0_i = $sizebits_0_i << 1; - var $rst_0_i = $rst_1_i; + var $782 = HEAP32[($sp_0_i_i + 8 | 0) >> 2]; + if (($782 | 0) == 0) { + __label__ = 174; + break $_$236; } + var $sp_0_i_i = $782; + } + if (($sp_0_i_i | 0) == 0) { + __label__ = 174; + break; + } + var $811 = HEAP32[(_mparams + 8 | 0) >> 2]; + var $816 = ((($nb_0 + 47 | 0) - HEAP32[(__gm_ + 12 | 0) >> 2] | 0) + $811 | 0) & (-$811 | 0); + if (!($816 >>> 0 < 2147483647)) { + var $tsize_0242932_ph_i = 0; + __label__ = 189; + break; + } + var $819 = _sbrk($816); + var $823 = ($819 | 0) == (HEAP32[$772 >> 2] + HEAP32[$776 >> 2] | 0 | 0); + var $tbase_0_i = $823 ? $819 : -1; + var $tsize_0_i = $823 ? $816 : 0; + var $asize_1_i = $816; + var $br_0_i = $819; + __label__ = 181; + break; } - } while (0); - var $t_1_i; - var $rsize_2_i; - var $v_2_i; - if (($t_1_i | 0) == 0 & ($v_2_i | 0) == 0) { - var $407 = 2 << $idx_0_i; - var $410 = $343 & ($407 | (-$407 | 0)); - if (($410 | 0) == 0) { - var $nb_0 = $342; - __label__ = 155; + __label__ = 174; + } while (0); + do { + if (__label__ == 174) { + var $785 = _sbrk(0); + if (($785 | 0) == -1) { + var $tsize_0242932_ph_i = 0; + __label__ = 189; break; + } + var $788 = HEAP32[(_mparams + 8 | 0) >> 2]; + var $792 = (($nb_0 + 47 | 0) + $788 | 0) & (-$788 | 0); + var $793 = $785; + var $794 = HEAP32[(_mparams + 4 | 0) >> 2]; + var $795 = $794 - 1 | 0; + if (($795 & $793 | 0) == 0) { + var $asize_0_i = $792; + } else { + var $asize_0_i = ($792 - $793 | 0) + (($795 + $793 | 0) & (-$794 | 0)) | 0; + } + var $asize_0_i; + if (!($asize_0_i >>> 0 < 2147483647)) { + var $tsize_0242932_ph_i = 0; + __label__ = 189; + break; + } + var $807 = _sbrk($asize_0_i); + var $808 = ($807 | 0) == ($785 | 0); + var $tbase_0_i = $808 ? $785 : -1; + var $tsize_0_i = $808 ? $asize_0_i : 0; + var $asize_1_i = $asize_0_i; + var $br_0_i = $807; + __label__ = 181; + break; } - var $415 = ($410 & (-$410 | 0)) - 1 | 0; - var $417 = $415 >>> 12 & 16; - var $418 = $415 >>> ($417 >>> 0); - var $420 = $418 >>> 5 & 8; - var $421 = $418 >>> ($420 >>> 0); - var $423 = $421 >>> 2 & 4; - var $424 = $421 >>> ($423 >>> 0); - var $426 = $424 >>> 1 & 2; - var $427 = $424 >>> ($426 >>> 0); - var $429 = $427 >>> 1 & 1; - var $t_2_ph_i = HEAP32[(__gm_ + 304 + ((($420 | $417 | $423 | $426 | $429) + ($427 >>> ($429 >>> 0)) | 0) << 2) | 0) >> 2]; - } else { - var $t_2_ph_i = $t_1_i; - } - var $t_2_ph_i; - $_$125 : do { - if (($t_2_ph_i | 0) == 0) { - var $rsize_3_lcssa_i = $rsize_2_i; - var $v_3_lcssa_i = $v_2_i; - } else { - var $t_224_i = $t_2_ph_i; - var $rsize_325_i = $rsize_2_i; - var $v_326_i = $v_2_i; - while (1) { - var $v_326_i; - var $rsize_325_i; - var $t_224_i; - var $442 = (HEAP32[($t_224_i + 4 | 0) >> 2] & -8) - $342 | 0; - var $443 = $442 >>> 0 < $rsize_325_i >>> 0; - var $_rsize_3_i = $443 ? $442 : $rsize_325_i; - var $t_2_v_3_i = $443 ? $t_224_i : $v_326_i; - var $445 = HEAP32[($t_224_i + 16 | 0) >> 2]; - if (!(($445 | 0) == 0)) { - var $t_224_i = $445; - var $rsize_325_i = $_rsize_3_i; - var $v_326_i = $t_2_v_3_i; - continue; - } - var $448 = HEAP32[($t_224_i + 20 | 0) >> 2]; - if (($448 | 0) == 0) { - var $rsize_3_lcssa_i = $_rsize_3_i; - var $v_3_lcssa_i = $t_2_v_3_i; - break $_$125; - } - var $t_224_i = $448; - var $rsize_325_i = $_rsize_3_i; - var $v_326_i = $t_2_v_3_i; + } while (0); + $_$253 : do { + if (__label__ == 181) { + var $br_0_i; + var $asize_1_i; + var $tsize_0_i; + var $tbase_0_i; + var $825 = -$asize_1_i | 0; + if (!(($tbase_0_i | 0) == -1)) { + var $tsize_242_i = $tsize_0_i; + var $tbase_243_i = $tbase_0_i; + __label__ = 194; + break $_$234; + } + do { + if (($br_0_i | 0) != -1 & $asize_1_i >>> 0 < 2147483647) { + if (!($asize_1_i >>> 0 < ($nb_0 + 48 | 0) >>> 0)) { + var $asize_2_i = $asize_1_i; + break; + } + var $834 = HEAP32[(_mparams + 8 | 0) >> 2]; + var $839 = ((($nb_0 + 47 | 0) - $asize_1_i | 0) + $834 | 0) & (-$834 | 0); + if (!($839 >>> 0 < 2147483647)) { + var $asize_2_i = $asize_1_i; + break; + } + if ((_sbrk($839) | 0) == -1) { + _sbrk($825); + var $tsize_0242932_ph_i = $tsize_0_i; + break $_$253; + } + var $asize_2_i = $839 + $asize_1_i | 0; + } else { + var $asize_2_i = $asize_1_i; } + } while (0); + var $asize_2_i; + if (!(($br_0_i | 0) == -1)) { + var $tsize_242_i = $asize_2_i; + var $tbase_243_i = $br_0_i; + __label__ = 194; + break $_$234; + } + HEAP32[(__gm_ + 440 | 0) >> 2] = HEAP32[(__gm_ + 440 | 0) >> 2] | 4; + var $tsize_137_i = $tsize_0_i; + __label__ = 191; + break $_$234; } - } while (0); - var $v_3_lcssa_i; - var $rsize_3_lcssa_i; - if (($v_3_lcssa_i | 0) == 0) { - var $nb_0 = $342; - __label__ = 155; - break; + } while (0); + var $tsize_0242932_ph_i; + HEAP32[(__gm_ + 440 | 0) >> 2] = HEAP32[(__gm_ + 440 | 0) >> 2] | 4; + var $tsize_137_i = $tsize_0242932_ph_i; + __label__ = 191; + break; } - if (!($rsize_3_lcssa_i >>> 0 < (HEAP32[(__gm_ + 8 | 0) >> 2] - $342 | 0) >>> 0)) { - var $nb_0 = $342; - __label__ = 155; + var $tsize_137_i = 0; + __label__ = 191; + } while (0); + do { + if (__label__ == 191) { + var $tsize_137_i; + var $854 = HEAP32[(_mparams + 8 | 0) >> 2]; + var $858 = (($nb_0 + 47 | 0) + $854 | 0) & (-$854 | 0); + if (!($858 >>> 0 < 2147483647)) { + __label__ = 330; + break; + } + var $861 = _sbrk($858); + var $862 = _sbrk(0); + if (!(($862 | 0) != -1 & ($861 | 0) != -1 & $861 >>> 0 < $862 >>> 0)) { + __label__ = 330; break; + } + var $866 = $862 - $861 | 0; + var $868 = $866 >>> 0 > ($nb_0 + 40 | 0) >>> 0; + var $_tbase_1_i = $868 ? $861 : -1; + if (($_tbase_1_i | 0) == -1) { + __label__ = 330; + break; + } + var $tsize_242_i = $868 ? $866 : $tsize_137_i; + var $tbase_243_i = $_tbase_1_i; + __label__ = 194; + break; } - var $456 = $v_3_lcssa_i; - var $457 = HEAP32[(__gm_ + 16 | 0) >> 2]; - do { - if (!($456 >>> 0 < $457 >>> 0)) { - var $460 = $456 + $342 | 0; - var $461 = $460; - if (!($456 >>> 0 < $460 >>> 0)) { + } while (0); + do { + if (__label__ == 194) { + var $tbase_243_i; + var $tsize_242_i; + var $871 = HEAP32[(__gm_ + 432 | 0) >> 2] + $tsize_242_i | 0; + HEAP32[(__gm_ + 432 | 0) >> 2] = $871; + if ($871 >>> 0 > HEAP32[(__gm_ + 436 | 0) >> 2] >>> 0) { + HEAP32[(__gm_ + 436 | 0) >> 2] = $871; + } + var $876 = HEAP32[(__gm_ + 24 | 0) >> 2]; + $_$275 : do { + if (($876 | 0) == 0) { + var $879 = HEAP32[(__gm_ + 16 | 0) >> 2]; + if (($879 | 0) == 0 | $tbase_243_i >>> 0 < $879 >>> 0) { + HEAP32[(__gm_ + 16 | 0) >> 2] = $tbase_243_i; + } + HEAP32[(__gm_ + 444 | 0) >> 2] = $tbase_243_i; + HEAP32[(__gm_ + 448 | 0) >> 2] = $tsize_242_i; + HEAP32[(__gm_ + 456 | 0) >> 2] = 0; + HEAP32[(__gm_ + 36 | 0) >> 2] = HEAP32[(_mparams | 0) >> 2]; + HEAP32[(__gm_ + 32 | 0) >> 2] = -1; + var $i_02_i_i = 0; + while (1) { + var $i_02_i_i; + var $886 = $i_02_i_i << 1; + var $888 = __gm_ + 40 + ($886 << 2) | 0; + HEAP32[(__gm_ + 40 + (($886 + 3 | 0) << 2) | 0) >> 2] = $888; + HEAP32[(__gm_ + 40 + (($886 + 2 | 0) << 2) | 0) >> 2] = $888; + var $891 = $i_02_i_i + 1 | 0; + if (($891 | 0) == 32) { + break; + } + var $i_02_i_i = $891; + } + var $893 = $tbase_243_i + 8 | 0; + if (($893 & 7 | 0) == 0) { + var $899 = 0; + } else { + var $899 = (-$893 | 0) & 7; + } + var $899; + var $903 = ($tsize_242_i - 40 | 0) - $899 | 0; + HEAP32[(__gm_ + 24 | 0) >> 2] = $tbase_243_i + $899 | 0; + HEAP32[(__gm_ + 12 | 0) >> 2] = $903; + HEAP32[($tbase_243_i + ($899 + 4 | 0) | 0) >> 2] = $903 | 1; + HEAP32[($tbase_243_i + ($tsize_242_i - 36 | 0) | 0) >> 2] = 40; + HEAP32[(__gm_ + 28 | 0) >> 2] = HEAP32[(_mparams + 16 | 0) >> 2]; + } else { + var $sp_0_i = __gm_ + 444 | 0; + while (1) { + var $sp_0_i; + if (($sp_0_i | 0) == 0) { + break; + } + var $913 = HEAP32[($sp_0_i | 0) >> 2]; + var $914 = $sp_0_i + 4 | 0; + var $915 = HEAP32[$914 >> 2]; + if (($tbase_243_i | 0) == ($913 + $915 | 0 | 0)) { + if (!((HEAP32[($sp_0_i + 12 | 0) >> 2] & 8 | 0) == 0)) { + break; + } + var $926 = $876; + if (!($926 >>> 0 >= $913 >>> 0 & $926 >>> 0 < $tbase_243_i >>> 0)) { break; + } + HEAP32[$914 >> 2] = $915 + $tsize_242_i | 0; + var $931 = HEAP32[(__gm_ + 24 | 0) >> 2]; + var $933 = HEAP32[(__gm_ + 12 | 0) >> 2] + $tsize_242_i | 0; + var $934 = $931; + var $936 = $931 + 8 | 0; + if (($936 & 7 | 0) == 0) { + var $942 = 0; + } else { + var $942 = (-$936 | 0) & 7; + } + var $942; + var $945 = $933 - $942 | 0; + HEAP32[(__gm_ + 24 | 0) >> 2] = $934 + $942 | 0; + HEAP32[(__gm_ + 12 | 0) >> 2] = $945; + HEAP32[($934 + ($942 + 4 | 0) | 0) >> 2] = $945 | 1; + HEAP32[($934 + ($933 + 4 | 0) | 0) >> 2] = 40; + HEAP32[(__gm_ + 28 | 0) >> 2] = HEAP32[(_mparams + 16 | 0) >> 2]; + break $_$275; } - var $465 = HEAP32[($v_3_lcssa_i + 24 | 0) >> 2]; - var $467 = HEAP32[($v_3_lcssa_i + 12 | 0) >> 2]; - do { - if (($467 | 0) == ($v_3_lcssa_i | 0)) { - var $479 = $v_3_lcssa_i + 20 | 0; - var $480 = HEAP32[$479 >> 2]; - if (($480 | 0) == 0) { - var $483 = $v_3_lcssa_i + 16 | 0; - var $484 = HEAP32[$483 >> 2]; - if (($484 | 0) == 0) { - var $R_1_i19 = 0; - break; - } - var $RP_0_i17 = $483; - var $R_0_i16 = $484; - } else { - var $RP_0_i17 = $479; - var $R_0_i16 = $480; - __label__ = 103; - } - while (1) { - var $R_0_i16; - var $RP_0_i17; - var $486 = $R_0_i16 + 20 | 0; - var $487 = HEAP32[$486 >> 2]; - if (!(($487 | 0) == 0)) { - var $RP_0_i17 = $486; - var $R_0_i16 = $487; - continue; - } - var $490 = $R_0_i16 + 16 | 0; - var $491 = HEAP32[$490 >> 2]; - if (($491 | 0) == 0) { - break; - } - var $RP_0_i17 = $490; - var $R_0_i16 = $491; - } - if ($RP_0_i17 >>> 0 < $457 >>> 0) { - _abort(); - } else { - HEAP32[$RP_0_i17 >> 2] = 0; - var $R_1_i19 = $R_0_i16; - } + var $sp_0_i = HEAP32[($sp_0_i + 8 | 0) >> 2]; + } + if ($tbase_243_i >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { + HEAP32[(__gm_ + 16 | 0) >> 2] = $tbase_243_i; + } + var $955 = $tbase_243_i + $tsize_242_i | 0; + var $sp_1_i = __gm_ + 444 | 0; + while (1) { + var $sp_1_i; + if (($sp_1_i | 0) == 0) { + __label__ = 293; + break; + } + var $959 = $sp_1_i | 0; + if ((HEAP32[$959 >> 2] | 0) == ($955 | 0)) { + __label__ = 218; + break; + } + var $sp_1_i = HEAP32[($sp_1_i + 8 | 0) >> 2]; + } + do { + if (__label__ == 218) { + if (!((HEAP32[($sp_1_i + 12 | 0) >> 2] & 8 | 0) == 0)) { + break; + } + HEAP32[$959 >> 2] = $tbase_243_i; + var $970 = $sp_1_i + 4 | 0; + HEAP32[$970 >> 2] = HEAP32[$970 >> 2] + $tsize_242_i | 0; + var $974 = $tbase_243_i + 8 | 0; + if (($974 & 7 | 0) == 0) { + var $981 = 0; + } else { + var $981 = (-$974 | 0) & 7; + } + var $981; + var $984 = $tbase_243_i + ($tsize_242_i + 8 | 0) | 0; + if (($984 & 7 | 0) == 0) { + var $991 = 0; + } else { + var $991 = (-$984 | 0) & 7; + } + var $991; + var $992 = $tbase_243_i + ($991 + $tsize_242_i | 0) | 0; + var $993 = $992; + var $_sum_i16_i = $981 + $nb_0 | 0; + var $997 = $tbase_243_i + $_sum_i16_i | 0; + var $998 = $997; + var $999 = ($992 - ($tbase_243_i + $981 | 0) | 0) - $nb_0 | 0; + HEAP32[($tbase_243_i + ($981 + 4 | 0) | 0) >> 2] = $nb_0 | 3; + $_$314 : do { + if (($993 | 0) == (HEAP32[(__gm_ + 24 | 0) >> 2] | 0)) { + var $1007 = HEAP32[(__gm_ + 12 | 0) >> 2] + $999 | 0; + HEAP32[(__gm_ + 12 | 0) >> 2] = $1007; + HEAP32[(__gm_ + 24 | 0) >> 2] = $998; + HEAP32[($tbase_243_i + ($_sum_i16_i + 4 | 0) | 0) >> 2] = $1007 | 1; } else { - var $471 = HEAP32[($v_3_lcssa_i + 8 | 0) >> 2]; - if ($471 >>> 0 < $457 >>> 0) { - _abort(); - } else { - HEAP32[($471 + 12 | 0) >> 2] = $467; - HEAP32[($467 + 8 | 0) >> 2] = $471; - var $R_1_i19 = $467; - } - } - } while (0); - var $R_1_i19; - $_$151 : do { - if (!(($465 | 0) == 0)) { - var $501 = $v_3_lcssa_i + 28 | 0; - var $503 = __gm_ + 304 + (HEAP32[$501 >> 2] << 2) | 0; - do { - if (($v_3_lcssa_i | 0) == (HEAP32[$503 >> 2] | 0)) { - HEAP32[$503 >> 2] = $R_1_i19; - if (!(($R_1_i19 | 0) == 0)) { + if (($993 | 0) == (HEAP32[(__gm_ + 20 | 0) >> 2] | 0)) { + var $1016 = HEAP32[(__gm_ + 8 | 0) >> 2] + $999 | 0; + HEAP32[(__gm_ + 8 | 0) >> 2] = $1016; + HEAP32[(__gm_ + 20 | 0) >> 2] = $998; + HEAP32[($tbase_243_i + ($_sum_i16_i + 4 | 0) | 0) >> 2] = $1016 | 1; + HEAP32[($tbase_243_i + ($1016 + $_sum_i16_i | 0) | 0) >> 2] = $1016; + } else { + var $_sum2_i18_i = $tsize_242_i + 4 | 0; + var $1025 = HEAP32[($tbase_243_i + ($_sum2_i18_i + $991 | 0) | 0) >> 2]; + if (($1025 & 3 | 0) == 1) { + var $1029 = $1025 & -8; + var $1030 = $1025 >>> 3; + $_$322 : do { + if ($1025 >>> 0 < 256) { + var $1035 = HEAP32[($tbase_243_i + (($991 | 8) + $tsize_242_i | 0) | 0) >> 2]; + var $1038 = HEAP32[($tbase_243_i + (($tsize_242_i + 12 | 0) + $991 | 0) | 0) >> 2]; + if (($1035 | 0) == ($1038 | 0)) { + HEAP32[(__gm_ | 0) >> 2] = HEAP32[(__gm_ | 0) >> 2] & (1 << $1030 ^ -1); + } else { + var $1049 = __gm_ + 40 + (($1025 >>> 2 & 1073741822) << 2) | 0; + do { + if (($1035 | 0) == ($1049 | 0)) { + __label__ = 233; + } else { + if ($1035 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { + __label__ = 236; + break; + } + __label__ = 233; break; - } - HEAP32[(__gm_ + 4 | 0) >> 2] = HEAP32[(__gm_ + 4 | 0) >> 2] & (1 << HEAP32[$501 >> 2] ^ -1); - break $_$151; - } - if ($465 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { + } + } while (0); + do { + if (__label__ == 233) { + if (!(($1038 | 0) == ($1049 | 0))) { + if ($1038 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { + break; + } + } + HEAP32[($1035 + 12 | 0) >> 2] = $1038; + HEAP32[($1038 + 8 | 0) >> 2] = $1035; + break $_$322; + } + } while (0); _abort(); + } } else { - var $517 = $465 + 16 | 0; - if ((HEAP32[$517 >> 2] | 0) == ($v_3_lcssa_i | 0)) { - HEAP32[$517 >> 2] = $R_1_i19; + var $1064 = $992; + var $1067 = HEAP32[($tbase_243_i + (($991 | 24) + $tsize_242_i | 0) | 0) >> 2]; + var $1070 = HEAP32[($tbase_243_i + (($tsize_242_i + 12 | 0) + $991 | 0) | 0) >> 2]; + do { + if (($1070 | 0) == ($1064 | 0)) { + var $_sum67_i_i = $991 | 16; + var $1085 = $tbase_243_i + ($_sum2_i18_i + $_sum67_i_i | 0) | 0; + var $1086 = HEAP32[$1085 >> 2]; + if (($1086 | 0) == 0) { + var $1090 = $tbase_243_i + ($_sum67_i_i + $tsize_242_i | 0) | 0; + var $1091 = HEAP32[$1090 >> 2]; + if (($1091 | 0) == 0) { + var $R_1_i_i = 0; + break; + } + var $RP_0_i_i = $1090; + var $R_0_i_i = $1091; + } else { + var $RP_0_i_i = $1085; + var $R_0_i_i = $1086; + __label__ = 243; + } + while (1) { + var $R_0_i_i; + var $RP_0_i_i; + var $1093 = $R_0_i_i + 20 | 0; + var $1094 = HEAP32[$1093 >> 2]; + if (!(($1094 | 0) == 0)) { + var $RP_0_i_i = $1093; + var $R_0_i_i = $1094; + continue; + } + var $1097 = $R_0_i_i + 16 | 0; + var $1098 = HEAP32[$1097 >> 2]; + if (($1098 | 0) == 0) { + break; + } + var $RP_0_i_i = $1097; + var $R_0_i_i = $1098; + } + if ($RP_0_i_i >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { + _abort(); + } else { + HEAP32[$RP_0_i_i >> 2] = 0; + var $R_1_i_i = $R_0_i_i; + } } else { - HEAP32[($465 + 20 | 0) >> 2] = $R_1_i19; + var $1075 = HEAP32[($tbase_243_i + (($991 | 8) + $tsize_242_i | 0) | 0) >> 2]; + if ($1075 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { + _abort(); + } else { + HEAP32[($1075 + 12 | 0) >> 2] = $1070; + HEAP32[($1070 + 8 | 0) >> 2] = $1075; + var $R_1_i_i = $1070; + } } - if (($R_1_i19 | 0) == 0) { - break $_$151; + } while (0); + var $R_1_i_i; + if (($1067 | 0) == 0) { + break; + } + var $1110 = $tbase_243_i + (($tsize_242_i + 28 | 0) + $991 | 0) | 0; + var $1112 = __gm_ + 304 + (HEAP32[$1110 >> 2] << 2) | 0; + do { + if (($1064 | 0) == (HEAP32[$1112 >> 2] | 0)) { + HEAP32[$1112 >> 2] = $R_1_i_i; + if (!(($R_1_i_i | 0) == 0)) { + break; + } + HEAP32[(__gm_ + 4 | 0) >> 2] = HEAP32[(__gm_ + 4 | 0) >> 2] & (1 << HEAP32[$1110 >> 2] ^ -1); + break $_$322; } - } - } while (0); - if ($R_1_i19 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { - _abort(); - } else { - HEAP32[($R_1_i19 + 24 | 0) >> 2] = $465; - var $533 = HEAP32[($v_3_lcssa_i + 16 | 0) >> 2]; - if (!(($533 | 0) == 0)) { - if ($533 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { - _abort(); + if ($1067 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { + _abort(); } else { - HEAP32[($R_1_i19 + 16 | 0) >> 2] = $533; - HEAP32[($533 + 24 | 0) >> 2] = $R_1_i19; + var $1126 = $1067 + 16 | 0; + if ((HEAP32[$1126 >> 2] | 0) == ($1064 | 0)) { + HEAP32[$1126 >> 2] = $R_1_i_i; + } else { + HEAP32[($1067 + 20 | 0) >> 2] = $R_1_i_i; + } + if (($R_1_i_i | 0) == 0) { + break $_$322; + } } - } - var $545 = HEAP32[($v_3_lcssa_i + 20 | 0) >> 2]; - if (($545 | 0) == 0) { - break; - } - if ($545 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { + } while (0); + if ($R_1_i_i >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { _abort(); - } else { - HEAP32[($R_1_i19 + 20 | 0) >> 2] = $545; - HEAP32[($545 + 24 | 0) >> 2] = $R_1_i19; - } - } - } - } while (0); - $_$179 : do { - if ($rsize_3_lcssa_i >>> 0 < 16) { - var $559 = $rsize_3_lcssa_i + $342 | 0; - HEAP32[($v_3_lcssa_i + 4 | 0) >> 2] = $559 | 3; - var $563 = $456 + ($559 + 4 | 0) | 0; - HEAP32[$563 >> 2] = HEAP32[$563 >> 2] | 1; - } else { - HEAP32[($v_3_lcssa_i + 4 | 0) >> 2] = $342 | 3; - HEAP32[($456 + ($342 | 4) | 0) >> 2] = $rsize_3_lcssa_i | 1; - HEAP32[($456 + ($rsize_3_lcssa_i + $342 | 0) | 0) >> 2] = $rsize_3_lcssa_i; - if ($rsize_3_lcssa_i >>> 0 < 256) { - var $578 = $rsize_3_lcssa_i >>> 2 & 1073741822; - var $580 = __gm_ + 40 + ($578 << 2) | 0; - var $581 = HEAP32[(__gm_ | 0) >> 2]; - var $582 = 1 << ($rsize_3_lcssa_i >>> 3); - do { - if (($581 & $582 | 0) == 0) { - HEAP32[(__gm_ | 0) >> 2] = $581 | $582; - var $F5_0_i = $580; - var $_pre_phi_i25 = __gm_ + 40 + (($578 + 2 | 0) << 2) | 0; - } else { - var $588 = __gm_ + 40 + (($578 + 2 | 0) << 2) | 0; - var $589 = HEAP32[$588 >> 2]; - if (!($589 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0)) { - var $F5_0_i = $589; - var $_pre_phi_i25 = $588; - break; - } + } else { + HEAP32[($R_1_i_i + 24 | 0) >> 2] = $1067; + var $_sum3132_i_i = $991 | 16; + var $1143 = HEAP32[($tbase_243_i + ($_sum3132_i_i + $tsize_242_i | 0) | 0) >> 2]; + if (!(($1143 | 0) == 0)) { + if ($1143 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { _abort(); + } else { + HEAP32[($R_1_i_i + 16 | 0) >> 2] = $1143; + HEAP32[($1143 + 24 | 0) >> 2] = $R_1_i_i; + } } - } while (0); - var $_pre_phi_i25; - var $F5_0_i; - HEAP32[$_pre_phi_i25 >> 2] = $461; - HEAP32[($F5_0_i + 12 | 0) >> 2] = $461; - HEAP32[($456 + ($342 + 8 | 0) | 0) >> 2] = $F5_0_i; - HEAP32[($456 + ($342 + 12 | 0) | 0) >> 2] = $580; - } else { - var $601 = $460; - var $602 = $rsize_3_lcssa_i >>> 8; - do { - if (($602 | 0) == 0) { - var $I7_0_i = 0; - } else { - if ($rsize_3_lcssa_i >>> 0 > 16777215) { - var $I7_0_i = 31; - break; - } - var $609 = ($602 + 1048320 | 0) >>> 16 & 8; - var $610 = $602 << $609; - var $613 = ($610 + 520192 | 0) >>> 16 & 4; - var $614 = $610 << $613; - var $617 = ($614 + 245760 | 0) >>> 16 & 2; - var $623 = (14 - ($613 | $609 | $617) | 0) + ($614 << $617 >>> 15) | 0; - var $I7_0_i = $rsize_3_lcssa_i >>> (($623 + 7 | 0) >>> 0) & 1 | $623 << 1; + var $1156 = HEAP32[($tbase_243_i + ($_sum2_i18_i + $_sum3132_i_i | 0) | 0) >> 2]; + if (($1156 | 0) == 0) { + break; } - } while (0); - var $I7_0_i; - var $630 = __gm_ + 304 + ($I7_0_i << 2) | 0; - HEAP32[($456 + ($342 + 28 | 0) | 0) >> 2] = $I7_0_i; - HEAP32[($456 + ($342 + 20 | 0) | 0) >> 2] = 0; - HEAP32[($456 + ($342 + 16 | 0) | 0) >> 2] = 0; - var $637 = HEAP32[(__gm_ + 4 | 0) >> 2]; - var $638 = 1 << $I7_0_i; - if (($637 & $638 | 0) == 0) { - HEAP32[(__gm_ + 4 | 0) >> 2] = $637 | $638; - HEAP32[$630 >> 2] = $601; - HEAP32[($456 + ($342 + 24 | 0) | 0) >> 2] = $630; - HEAP32[($456 + ($342 + 12 | 0) | 0) >> 2] = $601; - HEAP32[($456 + ($342 + 8 | 0) | 0) >> 2] = $601; - } else { - if (($I7_0_i | 0) == 31) { - var $657 = 0; + if ($1156 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { + _abort(); } else { - var $657 = 25 - ($I7_0_i >>> 1) | 0; - } - var $657; - var $K12_0_i = $rsize_3_lcssa_i << $657; - var $T_0_i = HEAP32[$630 >> 2]; - while (1) { - var $T_0_i; - var $K12_0_i; - if ((HEAP32[($T_0_i + 4 | 0) >> 2] & -8 | 0) == ($rsize_3_lcssa_i | 0)) { - var $683 = $T_0_i + 8 | 0; - var $684 = HEAP32[$683 >> 2]; - var $686 = HEAP32[(__gm_ + 16 | 0) >> 2]; - do { - if (!($T_0_i >>> 0 < $686 >>> 0)) { - if ($684 >>> 0 < $686 >>> 0) { - break; - } - HEAP32[($684 + 12 | 0) >> 2] = $601; - HEAP32[$683 >> 2] = $601; - HEAP32[($456 + ($342 + 8 | 0) | 0) >> 2] = $684; - HEAP32[($456 + ($342 + 12 | 0) | 0) >> 2] = $T_0_i; - HEAP32[($456 + ($342 + 24 | 0) | 0) >> 2] = 0; - break $_$179; - } - } while (0); - _abort(); - } else { - var $666 = $T_0_i + 16 + ($K12_0_i >>> 31 << 2) | 0; - var $667 = HEAP32[$666 >> 2]; - if (!(($667 | 0) == 0)) { - var $K12_0_i = $K12_0_i << 1; - var $T_0_i = $667; - continue; - } - if (!($666 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0)) { - HEAP32[$666 >> 2] = $601; - HEAP32[($456 + ($342 + 24 | 0) | 0) >> 2] = $T_0_i; - HEAP32[($456 + ($342 + 12 | 0) | 0) >> 2] = $601; - HEAP32[($456 + ($342 + 8 | 0) | 0) >> 2] = $601; - break $_$179; - } - _abort(); - } + HEAP32[($R_1_i_i + 20 | 0) >> 2] = $1156; + HEAP32[($1156 + 24 | 0) >> 2] = $R_1_i_i; } + } } - } - } - } while (0); - var $700 = $v_3_lcssa_i + 8 | 0; - if (($700 | 0) == 0) { - var $nb_0 = $342; - __label__ = 155; - break $_$2; - } - var $mem_0 = $700; - __label__ = 331; - break $_$2; - } - } while (0); - _abort(); - } - } while (0); - $_$215 : do { - if (__label__ == 155) { - var $nb_0; - var $703 = HEAP32[(__gm_ + 8 | 0) >> 2]; - if ($nb_0 >>> 0 > $703 >>> 0) { - var $732 = HEAP32[(__gm_ + 12 | 0) >> 2]; - if ($nb_0 >>> 0 < $732 >>> 0) { - var $735 = $732 - $nb_0 | 0; - HEAP32[(__gm_ + 12 | 0) >> 2] = $735; - var $736 = HEAP32[(__gm_ + 24 | 0) >> 2]; - var $737 = $736; - HEAP32[(__gm_ + 24 | 0) >> 2] = $737 + $nb_0 | 0; - HEAP32[($737 + ($nb_0 + 4 | 0) | 0) >> 2] = $735 | 1; - HEAP32[($736 + 4 | 0) >> 2] = $nb_0 | 3; - var $mem_0 = $736 + 8 | 0; - } else { - do { - if ((HEAP32[(_mparams | 0) >> 2] | 0) == 0) { - if (!((HEAP32[(_mparams | 0) >> 2] | 0) == 0)) { - break; - } - var $754 = _sysconf(8); - if ((($754 - 1 | 0) & $754 | 0) == 0) { - HEAP32[(_mparams + 8 | 0) >> 2] = $754; - HEAP32[(_mparams + 4 | 0) >> 2] = $754; - HEAP32[(_mparams + 12 | 0) >> 2] = -1; - HEAP32[(_mparams + 16 | 0) >> 2] = 2097152; - HEAP32[(_mparams + 20 | 0) >> 2] = 0; - HEAP32[(__gm_ + 440 | 0) >> 2] = 0; - var $762 = _time(0) & -16 ^ 1431655768; - HEAP32[(_mparams | 0) >> 2] = $762; + } while (0); + var $oldfirst_0_i_i = $tbase_243_i + (($1029 | $991) + $tsize_242_i | 0) | 0; + var $qsize_0_i_i = $1029 + $999 | 0; } else { - _abort(); + var $oldfirst_0_i_i = $993; + var $qsize_0_i_i = $999; } - } - } while (0); - $_$234 : do { - if ((HEAP32[(__gm_ + 440 | 0) >> 2] & 4 | 0) == 0) { - var $767 = HEAP32[(__gm_ + 24 | 0) >> 2]; - $_$236 : do { - if (!(($767 | 0) == 0)) { - var $770 = $767; - var $sp_0_i_i = __gm_ + 444 | 0; - while (1) { - var $sp_0_i_i; - var $772 = $sp_0_i_i | 0; - var $773 = HEAP32[$772 >> 2]; - if (!($773 >>> 0 > $770 >>> 0)) { - var $776 = $sp_0_i_i + 4 | 0; - if (($773 + HEAP32[$776 >> 2] | 0) >>> 0 > $770 >>> 0) { - break; - } - } - var $782 = HEAP32[($sp_0_i_i + 8 | 0) >> 2]; - if (($782 | 0) == 0) { - __label__ = 174; - break $_$236; - } - var $sp_0_i_i = $782; - } - if (($sp_0_i_i | 0) == 0) { - __label__ = 174; - break; - } - var $811 = HEAP32[(_mparams + 8 | 0) >> 2]; - var $816 = ((($nb_0 + 47 | 0) - HEAP32[(__gm_ + 12 | 0) >> 2] | 0) + $811 | 0) & (-$811 | 0); - if (!($816 >>> 0 < 2147483647)) { - var $tsize_0242932_ph_i = 0; - __label__ = 189; - break; - } - var $819 = _sbrk($816); - var $823 = ($819 | 0) == (HEAP32[$772 >> 2] + HEAP32[$776 >> 2] | 0 | 0); - var $tbase_0_i = $823 ? $819 : -1; - var $tsize_0_i = $823 ? $816 : 0; - var $asize_1_i = $816; - var $br_0_i = $819; - __label__ = 181; + var $qsize_0_i_i; + var $oldfirst_0_i_i; + var $1172 = $oldfirst_0_i_i + 4 | 0; + HEAP32[$1172 >> 2] = HEAP32[$1172 >> 2] & -2; + HEAP32[($tbase_243_i + ($_sum_i16_i + 4 | 0) | 0) >> 2] = $qsize_0_i_i | 1; + HEAP32[($tbase_243_i + ($qsize_0_i_i + $_sum_i16_i | 0) | 0) >> 2] = $qsize_0_i_i; + if ($qsize_0_i_i >>> 0 < 256) { + var $1184 = $qsize_0_i_i >>> 2 & 1073741822; + var $1186 = __gm_ + 40 + ($1184 << 2) | 0; + var $1187 = HEAP32[(__gm_ | 0) >> 2]; + var $1188 = 1 << ($qsize_0_i_i >>> 3); + do { + if (($1187 & $1188 | 0) == 0) { + HEAP32[(__gm_ | 0) >> 2] = $1187 | $1188; + var $F4_0_i_i = $1186; + var $_pre_phi_i20_i = __gm_ + 40 + (($1184 + 2 | 0) << 2) | 0; + } else { + var $1194 = __gm_ + 40 + (($1184 + 2 | 0) << 2) | 0; + var $1195 = HEAP32[$1194 >> 2]; + if (!($1195 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0)) { + var $F4_0_i_i = $1195; + var $_pre_phi_i20_i = $1194; break; + } + _abort(); } - __label__ = 174; - } while (0); - do { - if (__label__ == 174) { - var $785 = _sbrk(0); - if (($785 | 0) == -1) { - var $tsize_0242932_ph_i = 0; - __label__ = 189; - break; - } - var $788 = HEAP32[(_mparams + 8 | 0) >> 2]; - var $792 = (($nb_0 + 47 | 0) + $788 | 0) & (-$788 | 0); - var $793 = $785; - var $794 = HEAP32[(_mparams + 4 | 0) >> 2]; - var $795 = $794 - 1 | 0; - if (($795 & $793 | 0) == 0) { - var $asize_0_i = $792; - } else { - var $asize_0_i = ($792 - $793 | 0) + (($795 + $793 | 0) & (-$794 | 0)) | 0; - } - var $asize_0_i; - if (!($asize_0_i >>> 0 < 2147483647)) { - var $tsize_0242932_ph_i = 0; - __label__ = 189; - break; - } - var $807 = _sbrk($asize_0_i); - var $808 = ($807 | 0) == ($785 | 0); - var $tbase_0_i = $808 ? $785 : -1; - var $tsize_0_i = $808 ? $asize_0_i : 0; - var $asize_1_i = $asize_0_i; - var $br_0_i = $807; - __label__ = 181; + } while (0); + var $_pre_phi_i20_i; + var $F4_0_i_i; + HEAP32[$_pre_phi_i20_i >> 2] = $998; + HEAP32[($F4_0_i_i + 12 | 0) >> 2] = $998; + HEAP32[($tbase_243_i + ($_sum_i16_i + 8 | 0) | 0) >> 2] = $F4_0_i_i; + HEAP32[($tbase_243_i + ($_sum_i16_i + 12 | 0) | 0) >> 2] = $1186; + } else { + var $1207 = $997; + var $1208 = $qsize_0_i_i >>> 8; + do { + if (($1208 | 0) == 0) { + var $I7_0_i_i = 0; + } else { + if ($qsize_0_i_i >>> 0 > 16777215) { + var $I7_0_i_i = 31; break; + } + var $1215 = ($1208 + 1048320 | 0) >>> 16 & 8; + var $1216 = $1208 << $1215; + var $1219 = ($1216 + 520192 | 0) >>> 16 & 4; + var $1220 = $1216 << $1219; + var $1223 = ($1220 + 245760 | 0) >>> 16 & 2; + var $1229 = (14 - ($1219 | $1215 | $1223) | 0) + ($1220 << $1223 >>> 15) | 0; + var $I7_0_i_i = $qsize_0_i_i >>> (($1229 + 7 | 0) >>> 0) & 1 | $1229 << 1; } - } while (0); - $_$253 : do { - if (__label__ == 181) { - var $br_0_i; - var $asize_1_i; - var $tsize_0_i; - var $tbase_0_i; - var $825 = -$asize_1_i | 0; - if (!(($tbase_0_i | 0) == -1)) { - var $tsize_242_i = $tsize_0_i; - var $tbase_243_i = $tbase_0_i; - __label__ = 194; - break $_$234; - } + } while (0); + var $I7_0_i_i; + var $1236 = __gm_ + 304 + ($I7_0_i_i << 2) | 0; + HEAP32[($tbase_243_i + ($_sum_i16_i + 28 | 0) | 0) >> 2] = $I7_0_i_i; + HEAP32[($tbase_243_i + ($_sum_i16_i + 20 | 0) | 0) >> 2] = 0; + HEAP32[($tbase_243_i + ($_sum_i16_i + 16 | 0) | 0) >> 2] = 0; + var $1243 = HEAP32[(__gm_ + 4 | 0) >> 2]; + var $1244 = 1 << $I7_0_i_i; + if (($1243 & $1244 | 0) == 0) { + HEAP32[(__gm_ + 4 | 0) >> 2] = $1243 | $1244; + HEAP32[$1236 >> 2] = $1207; + HEAP32[($tbase_243_i + ($_sum_i16_i + 24 | 0) | 0) >> 2] = $1236; + HEAP32[($tbase_243_i + ($_sum_i16_i + 12 | 0) | 0) >> 2] = $1207; + HEAP32[($tbase_243_i + ($_sum_i16_i + 8 | 0) | 0) >> 2] = $1207; + } else { + if (($I7_0_i_i | 0) == 31) { + var $1263 = 0; + } else { + var $1263 = 25 - ($I7_0_i_i >>> 1) | 0; + } + var $1263; + var $K8_0_i_i = $qsize_0_i_i << $1263; + var $T_0_i21_i = HEAP32[$1236 >> 2]; + while (1) { + var $T_0_i21_i; + var $K8_0_i_i; + if ((HEAP32[($T_0_i21_i + 4 | 0) >> 2] & -8 | 0) == ($qsize_0_i_i | 0)) { + var $1289 = $T_0_i21_i + 8 | 0; + var $1290 = HEAP32[$1289 >> 2]; + var $1292 = HEAP32[(__gm_ + 16 | 0) >> 2]; do { - if (($br_0_i | 0) != -1 & $asize_1_i >>> 0 < 2147483647) { - if (!($asize_1_i >>> 0 < ($nb_0 + 48 | 0) >>> 0)) { - var $asize_2_i = $asize_1_i; - break; - } - var $834 = HEAP32[(_mparams + 8 | 0) >> 2]; - var $839 = ((($nb_0 + 47 | 0) - $asize_1_i | 0) + $834 | 0) & (-$834 | 0); - if (!($839 >>> 0 < 2147483647)) { - var $asize_2_i = $asize_1_i; - break; - } - if ((_sbrk($839) | 0) == -1) { - _sbrk($825); - var $tsize_0242932_ph_i = $tsize_0_i; - break $_$253; - } - var $asize_2_i = $839 + $asize_1_i | 0; - } else { - var $asize_2_i = $asize_1_i; + if (!($T_0_i21_i >>> 0 < $1292 >>> 0)) { + if ($1290 >>> 0 < $1292 >>> 0) { + break; } + HEAP32[($1290 + 12 | 0) >> 2] = $1207; + HEAP32[$1289 >> 2] = $1207; + HEAP32[($tbase_243_i + ($_sum_i16_i + 8 | 0) | 0) >> 2] = $1290; + HEAP32[($tbase_243_i + ($_sum_i16_i + 12 | 0) | 0) >> 2] = $T_0_i21_i; + HEAP32[($tbase_243_i + ($_sum_i16_i + 24 | 0) | 0) >> 2] = 0; + break $_$314; + } } while (0); - var $asize_2_i; - if (!(($br_0_i | 0) == -1)) { - var $tsize_242_i = $asize_2_i; - var $tbase_243_i = $br_0_i; - __label__ = 194; - break $_$234; + _abort(); + } else { + var $1272 = $T_0_i21_i + 16 + ($K8_0_i_i >>> 31 << 2) | 0; + var $1273 = HEAP32[$1272 >> 2]; + if (!(($1273 | 0) == 0)) { + var $K8_0_i_i = $K8_0_i_i << 1; + var $T_0_i21_i = $1273; + continue; + } + if (!($1272 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0)) { + HEAP32[$1272 >> 2] = $1207; + HEAP32[($tbase_243_i + ($_sum_i16_i + 24 | 0) | 0) >> 2] = $T_0_i21_i; + HEAP32[($tbase_243_i + ($_sum_i16_i + 12 | 0) | 0) >> 2] = $1207; + HEAP32[($tbase_243_i + ($_sum_i16_i + 8 | 0) | 0) >> 2] = $1207; + break $_$314; } - HEAP32[(__gm_ + 440 | 0) >> 2] = HEAP32[(__gm_ + 440 | 0) >> 2] | 4; - var $tsize_137_i = $tsize_0_i; - __label__ = 191; - break $_$234; + _abort(); + } } - } while (0); - var $tsize_0242932_ph_i; - HEAP32[(__gm_ + 440 | 0) >> 2] = HEAP32[(__gm_ + 440 | 0) >> 2] | 4; - var $tsize_137_i = $tsize_0242932_ph_i; - __label__ = 191; - break; + } + } + } } - var $tsize_137_i = 0; - __label__ = 191; - } while (0); + } while (0); + var $mem_0 = $tbase_243_i + ($981 | 8) | 0; + break $_$215; + } + } while (0); + var $1306 = $876; + var $sp_0_i_i_i = __gm_ + 444 | 0; + while (1) { + var $sp_0_i_i_i; + var $1309 = HEAP32[($sp_0_i_i_i | 0) >> 2]; + if (!($1309 >>> 0 > $1306 >>> 0)) { + var $1313 = HEAP32[($sp_0_i_i_i + 4 | 0) >> 2]; + if (($1309 + $1313 | 0) >>> 0 > $1306 >>> 0) { + var $1321 = $1309; + var $1320 = $1313; + break; + } + } + var $1318 = HEAP32[($sp_0_i_i_i + 8 | 0) >> 2]; + if (!(($1318 | 0) == 0)) { + var $sp_0_i_i_i = $1318; + continue; + } + var $1321 = 0; + var $1320 = 4; + break; + } + var $1320; + var $1321; + var $1322 = $1321 + $1320 | 0; + var $1324 = $1321 + ($1320 - 39 | 0) | 0; + if (($1324 & 7 | 0) == 0) { + var $1331 = 0; + } else { + var $1331 = (-$1324 | 0) & 7; + } + var $1331; + var $1332 = $1321 + (($1320 - 47 | 0) + $1331 | 0) | 0; + var $1336 = $1332 >>> 0 < ($876 + 16 | 0) >>> 0 ? $1306 : $1332; + var $1337 = $1336 + 8 | 0; + var $1340 = $tbase_243_i + 8 | 0; + if (($1340 & 7 | 0) == 0) { + var $1346 = 0; + } else { + var $1346 = (-$1340 | 0) & 7; + } + var $1346; + var $1350 = ($tsize_242_i - 40 | 0) - $1346 | 0; + HEAP32[(__gm_ + 24 | 0) >> 2] = $tbase_243_i + $1346 | 0; + HEAP32[(__gm_ + 12 | 0) >> 2] = $1350; + HEAP32[($tbase_243_i + ($1346 + 4 | 0) | 0) >> 2] = $1350 | 1; + HEAP32[($tbase_243_i + ($tsize_242_i - 36 | 0) | 0) >> 2] = 40; + HEAP32[(__gm_ + 28 | 0) >> 2] = HEAP32[(_mparams + 16 | 0) >> 2]; + HEAP32[($1336 + 4 | 0) >> 2] = 27; + HEAP32[$1337 >> 2] = HEAP32[(__gm_ + 444 | 0) >> 2]; + HEAP32[$1337 + 4 >> 2] = HEAP32[(__gm_ + 444 | 0) + 4 >> 2]; + HEAP32[$1337 + 8 >> 2] = HEAP32[(__gm_ + 444 | 0) + 8 >> 2]; + HEAP32[$1337 + 12 >> 2] = HEAP32[(__gm_ + 444 | 0) + 12 >> 2]; + HEAP32[(__gm_ + 444 | 0) >> 2] = $tbase_243_i; + HEAP32[(__gm_ + 448 | 0) >> 2] = $tsize_242_i; + HEAP32[(__gm_ + 456 | 0) >> 2] = 0; + HEAP32[(__gm_ + 452 | 0) >> 2] = $1337; + var $1360 = $1336 + 28 | 0; + HEAP32[$1360 >> 2] = 7; + $_$426 : do { + if (($1336 + 32 | 0) >>> 0 < $1322 >>> 0) { + var $1363 = $1360; + while (1) { + var $1363; + var $1364 = $1363 + 4 | 0; + HEAP32[$1364 >> 2] = 7; + if (!(($1363 + 8 | 0) >>> 0 < $1322 >>> 0)) { + break $_$426; + } + var $1363 = $1364; + } + } + } while (0); + if (($1336 | 0) == ($1306 | 0)) { + break; + } + var $1372 = $1336 - $876 | 0; + var $1375 = $1306 + ($1372 + 4 | 0) | 0; + HEAP32[$1375 >> 2] = HEAP32[$1375 >> 2] & -2; + HEAP32[($876 + 4 | 0) >> 2] = $1372 | 1; + HEAP32[($1306 + $1372 | 0) >> 2] = $1372; + if ($1372 >>> 0 < 256) { + var $1385 = $1372 >>> 2 & 1073741822; + var $1387 = __gm_ + 40 + ($1385 << 2) | 0; + var $1388 = HEAP32[(__gm_ | 0) >> 2]; + var $1389 = 1 << ($1372 >>> 3); do { - if (__label__ == 191) { - var $tsize_137_i; - var $854 = HEAP32[(_mparams + 8 | 0) >> 2]; - var $858 = (($nb_0 + 47 | 0) + $854 | 0) & (-$854 | 0); - if (!($858 >>> 0 < 2147483647)) { - __label__ = 330; - break; - } - var $861 = _sbrk($858); - var $862 = _sbrk(0); - if (!(($862 | 0) != -1 & ($861 | 0) != -1 & $861 >>> 0 < $862 >>> 0)) { - __label__ = 330; - break; - } - var $866 = $862 - $861 | 0; - var $868 = $866 >>> 0 > ($nb_0 + 40 | 0) >>> 0; - var $_tbase_1_i = $868 ? $861 : -1; - if (($_tbase_1_i | 0) == -1) { - __label__ = 330; - break; - } - var $tsize_242_i = $868 ? $866 : $tsize_137_i; - var $tbase_243_i = $_tbase_1_i; - __label__ = 194; - break; + if (($1388 & $1389 | 0) == 0) { + HEAP32[(__gm_ | 0) >> 2] = $1388 | $1389; + var $F_0_i_i = $1387; + var $_pre_phi_i_i = __gm_ + 40 + (($1385 + 2 | 0) << 2) | 0; + } else { + var $1395 = __gm_ + 40 + (($1385 + 2 | 0) << 2) | 0; + var $1396 = HEAP32[$1395 >> 2]; + if (!($1396 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0)) { + var $F_0_i_i = $1396; + var $_pre_phi_i_i = $1395; + break; } + _abort(); + } } while (0); + var $_pre_phi_i_i; + var $F_0_i_i; + HEAP32[$_pre_phi_i_i >> 2] = $876; + HEAP32[($F_0_i_i + 12 | 0) >> 2] = $876; + HEAP32[($876 + 8 | 0) >> 2] = $F_0_i_i; + HEAP32[($876 + 12 | 0) >> 2] = $1387; + } else { + var $1406 = $876; + var $1407 = $1372 >>> 8; do { - if (__label__ == 194) { - var $tbase_243_i; - var $tsize_242_i; - var $871 = HEAP32[(__gm_ + 432 | 0) >> 2] + $tsize_242_i | 0; - HEAP32[(__gm_ + 432 | 0) >> 2] = $871; - if ($871 >>> 0 > HEAP32[(__gm_ + 436 | 0) >> 2] >>> 0) { - HEAP32[(__gm_ + 436 | 0) >> 2] = $871; - } - var $876 = HEAP32[(__gm_ + 24 | 0) >> 2]; - $_$275 : do { - if (($876 | 0) == 0) { - var $879 = HEAP32[(__gm_ + 16 | 0) >> 2]; - if (($879 | 0) == 0 | $tbase_243_i >>> 0 < $879 >>> 0) { - HEAP32[(__gm_ + 16 | 0) >> 2] = $tbase_243_i; - } - HEAP32[(__gm_ + 444 | 0) >> 2] = $tbase_243_i; - HEAP32[(__gm_ + 448 | 0) >> 2] = $tsize_242_i; - HEAP32[(__gm_ + 456 | 0) >> 2] = 0; - HEAP32[(__gm_ + 36 | 0) >> 2] = HEAP32[(_mparams | 0) >> 2]; - HEAP32[(__gm_ + 32 | 0) >> 2] = -1; - var $i_02_i_i = 0; - while (1) { - var $i_02_i_i; - var $886 = $i_02_i_i << 1; - var $888 = __gm_ + 40 + ($886 << 2) | 0; - HEAP32[(__gm_ + 40 + (($886 + 3 | 0) << 2) | 0) >> 2] = $888; - HEAP32[(__gm_ + 40 + (($886 + 2 | 0) << 2) | 0) >> 2] = $888; - var $891 = $i_02_i_i + 1 | 0; - if (($891 | 0) == 32) { - break; - } - var $i_02_i_i = $891; - } - var $893 = $tbase_243_i + 8 | 0; - if (($893 & 7 | 0) == 0) { - var $899 = 0; - } else { - var $899 = (-$893 | 0) & 7; - } - var $899; - var $903 = ($tsize_242_i - 40 | 0) - $899 | 0; - HEAP32[(__gm_ + 24 | 0) >> 2] = $tbase_243_i + $899 | 0; - HEAP32[(__gm_ + 12 | 0) >> 2] = $903; - HEAP32[($tbase_243_i + ($899 + 4 | 0) | 0) >> 2] = $903 | 1; - HEAP32[($tbase_243_i + ($tsize_242_i - 36 | 0) | 0) >> 2] = 40; - HEAP32[(__gm_ + 28 | 0) >> 2] = HEAP32[(_mparams + 16 | 0) >> 2]; - } else { - var $sp_0_i = __gm_ + 444 | 0; - while (1) { - var $sp_0_i; - if (($sp_0_i | 0) == 0) { - break; - } - var $913 = HEAP32[($sp_0_i | 0) >> 2]; - var $914 = $sp_0_i + 4 | 0; - var $915 = HEAP32[$914 >> 2]; - if (($tbase_243_i | 0) == ($913 + $915 | 0 | 0)) { - if (!((HEAP32[($sp_0_i + 12 | 0) >> 2] & 8 | 0) == 0)) { - break; - } - var $926 = $876; - if (!($926 >>> 0 >= $913 >>> 0 & $926 >>> 0 < $tbase_243_i >>> 0)) { - break; - } - HEAP32[$914 >> 2] = $915 + $tsize_242_i | 0; - var $931 = HEAP32[(__gm_ + 24 | 0) >> 2]; - var $933 = HEAP32[(__gm_ + 12 | 0) >> 2] + $tsize_242_i | 0; - var $934 = $931; - var $936 = $931 + 8 | 0; - if (($936 & 7 | 0) == 0) { - var $942 = 0; - } else { - var $942 = (-$936 | 0) & 7; - } - var $942; - var $945 = $933 - $942 | 0; - HEAP32[(__gm_ + 24 | 0) >> 2] = $934 + $942 | 0; - HEAP32[(__gm_ + 12 | 0) >> 2] = $945; - HEAP32[($934 + ($942 + 4 | 0) | 0) >> 2] = $945 | 1; - HEAP32[($934 + ($933 + 4 | 0) | 0) >> 2] = 40; - HEAP32[(__gm_ + 28 | 0) >> 2] = HEAP32[(_mparams + 16 | 0) >> 2]; - break $_$275; - } - var $sp_0_i = HEAP32[($sp_0_i + 8 | 0) >> 2]; - } - if ($tbase_243_i >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { - HEAP32[(__gm_ + 16 | 0) >> 2] = $tbase_243_i; - } - var $955 = $tbase_243_i + $tsize_242_i | 0; - var $sp_1_i = __gm_ + 444 | 0; - while (1) { - var $sp_1_i; - if (($sp_1_i | 0) == 0) { - __label__ = 293; - break; - } - var $959 = $sp_1_i | 0; - if ((HEAP32[$959 >> 2] | 0) == ($955 | 0)) { - __label__ = 218; - break; - } - var $sp_1_i = HEAP32[($sp_1_i + 8 | 0) >> 2]; - } - do { - if (__label__ == 218) { - if (!((HEAP32[($sp_1_i + 12 | 0) >> 2] & 8 | 0) == 0)) { - break; - } - HEAP32[$959 >> 2] = $tbase_243_i; - var $970 = $sp_1_i + 4 | 0; - HEAP32[$970 >> 2] = HEAP32[$970 >> 2] + $tsize_242_i | 0; - var $974 = $tbase_243_i + 8 | 0; - if (($974 & 7 | 0) == 0) { - var $981 = 0; - } else { - var $981 = (-$974 | 0) & 7; - } - var $981; - var $984 = $tbase_243_i + ($tsize_242_i + 8 | 0) | 0; - if (($984 & 7 | 0) == 0) { - var $991 = 0; - } else { - var $991 = (-$984 | 0) & 7; - } - var $991; - var $992 = $tbase_243_i + ($991 + $tsize_242_i | 0) | 0; - var $993 = $992; - var $_sum_i16_i = $981 + $nb_0 | 0; - var $997 = $tbase_243_i + $_sum_i16_i | 0; - var $998 = $997; - var $999 = ($992 - ($tbase_243_i + $981 | 0) | 0) - $nb_0 | 0; - HEAP32[($tbase_243_i + ($981 + 4 | 0) | 0) >> 2] = $nb_0 | 3; - $_$314 : do { - if (($993 | 0) == (HEAP32[(__gm_ + 24 | 0) >> 2] | 0)) { - var $1007 = HEAP32[(__gm_ + 12 | 0) >> 2] + $999 | 0; - HEAP32[(__gm_ + 12 | 0) >> 2] = $1007; - HEAP32[(__gm_ + 24 | 0) >> 2] = $998; - HEAP32[($tbase_243_i + ($_sum_i16_i + 4 | 0) | 0) >> 2] = $1007 | 1; - } else { - if (($993 | 0) == (HEAP32[(__gm_ + 20 | 0) >> 2] | 0)) { - var $1016 = HEAP32[(__gm_ + 8 | 0) >> 2] + $999 | 0; - HEAP32[(__gm_ + 8 | 0) >> 2] = $1016; - HEAP32[(__gm_ + 20 | 0) >> 2] = $998; - HEAP32[($tbase_243_i + ($_sum_i16_i + 4 | 0) | 0) >> 2] = $1016 | 1; - HEAP32[($tbase_243_i + ($1016 + $_sum_i16_i | 0) | 0) >> 2] = $1016; - } else { - var $_sum2_i18_i = $tsize_242_i + 4 | 0; - var $1025 = HEAP32[($tbase_243_i + ($_sum2_i18_i + $991 | 0) | 0) >> 2]; - if (($1025 & 3 | 0) == 1) { - var $1029 = $1025 & -8; - var $1030 = $1025 >>> 3; - $_$322 : do { - if ($1025 >>> 0 < 256) { - var $1035 = HEAP32[($tbase_243_i + (($991 | 8) + $tsize_242_i | 0) | 0) >> 2]; - var $1038 = HEAP32[($tbase_243_i + (($tsize_242_i + 12 | 0) + $991 | 0) | 0) >> 2]; - if (($1035 | 0) == ($1038 | 0)) { - HEAP32[(__gm_ | 0) >> 2] = HEAP32[(__gm_ | 0) >> 2] & (1 << $1030 ^ -1); - } else { - var $1049 = __gm_ + 40 + (($1025 >>> 2 & 1073741822) << 2) | 0; - do { - if (($1035 | 0) == ($1049 | 0)) { - __label__ = 233; - } else { - if ($1035 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { - __label__ = 236; - break; - } - __label__ = 233; - break; - } - } while (0); - do { - if (__label__ == 233) { - if (!(($1038 | 0) == ($1049 | 0))) { - if ($1038 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { - break; - } - } - HEAP32[($1035 + 12 | 0) >> 2] = $1038; - HEAP32[($1038 + 8 | 0) >> 2] = $1035; - break $_$322; - } - } while (0); - _abort(); - } - } else { - var $1064 = $992; - var $1067 = HEAP32[($tbase_243_i + (($991 | 24) + $tsize_242_i | 0) | 0) >> 2]; - var $1070 = HEAP32[($tbase_243_i + (($tsize_242_i + 12 | 0) + $991 | 0) | 0) >> 2]; - do { - if (($1070 | 0) == ($1064 | 0)) { - var $_sum67_i_i = $991 | 16; - var $1085 = $tbase_243_i + ($_sum2_i18_i + $_sum67_i_i | 0) | 0; - var $1086 = HEAP32[$1085 >> 2]; - if (($1086 | 0) == 0) { - var $1090 = $tbase_243_i + ($_sum67_i_i + $tsize_242_i | 0) | 0; - var $1091 = HEAP32[$1090 >> 2]; - if (($1091 | 0) == 0) { - var $R_1_i_i = 0; - break; - } - var $RP_0_i_i = $1090; - var $R_0_i_i = $1091; - } else { - var $RP_0_i_i = $1085; - var $R_0_i_i = $1086; - __label__ = 243; - } - while (1) { - var $R_0_i_i; - var $RP_0_i_i; - var $1093 = $R_0_i_i + 20 | 0; - var $1094 = HEAP32[$1093 >> 2]; - if (!(($1094 | 0) == 0)) { - var $RP_0_i_i = $1093; - var $R_0_i_i = $1094; - continue; - } - var $1097 = $R_0_i_i + 16 | 0; - var $1098 = HEAP32[$1097 >> 2]; - if (($1098 | 0) == 0) { - break; - } - var $RP_0_i_i = $1097; - var $R_0_i_i = $1098; - } - if ($RP_0_i_i >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { - _abort(); - } else { - HEAP32[$RP_0_i_i >> 2] = 0; - var $R_1_i_i = $R_0_i_i; - } - } else { - var $1075 = HEAP32[($tbase_243_i + (($991 | 8) + $tsize_242_i | 0) | 0) >> 2]; - if ($1075 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { - _abort(); - } else { - HEAP32[($1075 + 12 | 0) >> 2] = $1070; - HEAP32[($1070 + 8 | 0) >> 2] = $1075; - var $R_1_i_i = $1070; - } - } - } while (0); - var $R_1_i_i; - if (($1067 | 0) == 0) { - break; - } - var $1110 = $tbase_243_i + (($tsize_242_i + 28 | 0) + $991 | 0) | 0; - var $1112 = __gm_ + 304 + (HEAP32[$1110 >> 2] << 2) | 0; - do { - if (($1064 | 0) == (HEAP32[$1112 >> 2] | 0)) { - HEAP32[$1112 >> 2] = $R_1_i_i; - if (!(($R_1_i_i | 0) == 0)) { - break; - } - HEAP32[(__gm_ + 4 | 0) >> 2] = HEAP32[(__gm_ + 4 | 0) >> 2] & (1 << HEAP32[$1110 >> 2] ^ -1); - break $_$322; - } - if ($1067 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { - _abort(); - } else { - var $1126 = $1067 + 16 | 0; - if ((HEAP32[$1126 >> 2] | 0) == ($1064 | 0)) { - HEAP32[$1126 >> 2] = $R_1_i_i; - } else { - HEAP32[($1067 + 20 | 0) >> 2] = $R_1_i_i; - } - if (($R_1_i_i | 0) == 0) { - break $_$322; - } - } - } while (0); - if ($R_1_i_i >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { - _abort(); - } else { - HEAP32[($R_1_i_i + 24 | 0) >> 2] = $1067; - var $_sum3132_i_i = $991 | 16; - var $1143 = HEAP32[($tbase_243_i + ($_sum3132_i_i + $tsize_242_i | 0) | 0) >> 2]; - if (!(($1143 | 0) == 0)) { - if ($1143 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { - _abort(); - } else { - HEAP32[($R_1_i_i + 16 | 0) >> 2] = $1143; - HEAP32[($1143 + 24 | 0) >> 2] = $R_1_i_i; - } - } - var $1156 = HEAP32[($tbase_243_i + ($_sum2_i18_i + $_sum3132_i_i | 0) | 0) >> 2]; - if (($1156 | 0) == 0) { - break; - } - if ($1156 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0) { - _abort(); - } else { - HEAP32[($R_1_i_i + 20 | 0) >> 2] = $1156; - HEAP32[($1156 + 24 | 0) >> 2] = $R_1_i_i; - } - } - } - } while (0); - var $oldfirst_0_i_i = $tbase_243_i + (($1029 | $991) + $tsize_242_i | 0) | 0; - var $qsize_0_i_i = $1029 + $999 | 0; - } else { - var $oldfirst_0_i_i = $993; - var $qsize_0_i_i = $999; - } - var $qsize_0_i_i; - var $oldfirst_0_i_i; - var $1172 = $oldfirst_0_i_i + 4 | 0; - HEAP32[$1172 >> 2] = HEAP32[$1172 >> 2] & -2; - HEAP32[($tbase_243_i + ($_sum_i16_i + 4 | 0) | 0) >> 2] = $qsize_0_i_i | 1; - HEAP32[($tbase_243_i + ($qsize_0_i_i + $_sum_i16_i | 0) | 0) >> 2] = $qsize_0_i_i; - if ($qsize_0_i_i >>> 0 < 256) { - var $1184 = $qsize_0_i_i >>> 2 & 1073741822; - var $1186 = __gm_ + 40 + ($1184 << 2) | 0; - var $1187 = HEAP32[(__gm_ | 0) >> 2]; - var $1188 = 1 << ($qsize_0_i_i >>> 3); - do { - if (($1187 & $1188 | 0) == 0) { - HEAP32[(__gm_ | 0) >> 2] = $1187 | $1188; - var $F4_0_i_i = $1186; - var $_pre_phi_i20_i = __gm_ + 40 + (($1184 + 2 | 0) << 2) | 0; - } else { - var $1194 = __gm_ + 40 + (($1184 + 2 | 0) << 2) | 0; - var $1195 = HEAP32[$1194 >> 2]; - if (!($1195 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0)) { - var $F4_0_i_i = $1195; - var $_pre_phi_i20_i = $1194; - break; - } - _abort(); - } - } while (0); - var $_pre_phi_i20_i; - var $F4_0_i_i; - HEAP32[$_pre_phi_i20_i >> 2] = $998; - HEAP32[($F4_0_i_i + 12 | 0) >> 2] = $998; - HEAP32[($tbase_243_i + ($_sum_i16_i + 8 | 0) | 0) >> 2] = $F4_0_i_i; - HEAP32[($tbase_243_i + ($_sum_i16_i + 12 | 0) | 0) >> 2] = $1186; - } else { - var $1207 = $997; - var $1208 = $qsize_0_i_i >>> 8; - do { - if (($1208 | 0) == 0) { - var $I7_0_i_i = 0; - } else { - if ($qsize_0_i_i >>> 0 > 16777215) { - var $I7_0_i_i = 31; - break; - } - var $1215 = ($1208 + 1048320 | 0) >>> 16 & 8; - var $1216 = $1208 << $1215; - var $1219 = ($1216 + 520192 | 0) >>> 16 & 4; - var $1220 = $1216 << $1219; - var $1223 = ($1220 + 245760 | 0) >>> 16 & 2; - var $1229 = (14 - ($1219 | $1215 | $1223) | 0) + ($1220 << $1223 >>> 15) | 0; - var $I7_0_i_i = $qsize_0_i_i >>> (($1229 + 7 | 0) >>> 0) & 1 | $1229 << 1; - } - } while (0); - var $I7_0_i_i; - var $1236 = __gm_ + 304 + ($I7_0_i_i << 2) | 0; - HEAP32[($tbase_243_i + ($_sum_i16_i + 28 | 0) | 0) >> 2] = $I7_0_i_i; - HEAP32[($tbase_243_i + ($_sum_i16_i + 20 | 0) | 0) >> 2] = 0; - HEAP32[($tbase_243_i + ($_sum_i16_i + 16 | 0) | 0) >> 2] = 0; - var $1243 = HEAP32[(__gm_ + 4 | 0) >> 2]; - var $1244 = 1 << $I7_0_i_i; - if (($1243 & $1244 | 0) == 0) { - HEAP32[(__gm_ + 4 | 0) >> 2] = $1243 | $1244; - HEAP32[$1236 >> 2] = $1207; - HEAP32[($tbase_243_i + ($_sum_i16_i + 24 | 0) | 0) >> 2] = $1236; - HEAP32[($tbase_243_i + ($_sum_i16_i + 12 | 0) | 0) >> 2] = $1207; - HEAP32[($tbase_243_i + ($_sum_i16_i + 8 | 0) | 0) >> 2] = $1207; - } else { - if (($I7_0_i_i | 0) == 31) { - var $1263 = 0; - } else { - var $1263 = 25 - ($I7_0_i_i >>> 1) | 0; - } - var $1263; - var $K8_0_i_i = $qsize_0_i_i << $1263; - var $T_0_i21_i = HEAP32[$1236 >> 2]; - while (1) { - var $T_0_i21_i; - var $K8_0_i_i; - if ((HEAP32[($T_0_i21_i + 4 | 0) >> 2] & -8 | 0) == ($qsize_0_i_i | 0)) { - var $1289 = $T_0_i21_i + 8 | 0; - var $1290 = HEAP32[$1289 >> 2]; - var $1292 = HEAP32[(__gm_ + 16 | 0) >> 2]; - do { - if (!($T_0_i21_i >>> 0 < $1292 >>> 0)) { - if ($1290 >>> 0 < $1292 >>> 0) { - break; - } - HEAP32[($1290 + 12 | 0) >> 2] = $1207; - HEAP32[$1289 >> 2] = $1207; - HEAP32[($tbase_243_i + ($_sum_i16_i + 8 | 0) | 0) >> 2] = $1290; - HEAP32[($tbase_243_i + ($_sum_i16_i + 12 | 0) | 0) >> 2] = $T_0_i21_i; - HEAP32[($tbase_243_i + ($_sum_i16_i + 24 | 0) | 0) >> 2] = 0; - break $_$314; - } - } while (0); - _abort(); - } else { - var $1272 = $T_0_i21_i + 16 + ($K8_0_i_i >>> 31 << 2) | 0; - var $1273 = HEAP32[$1272 >> 2]; - if (!(($1273 | 0) == 0)) { - var $K8_0_i_i = $K8_0_i_i << 1; - var $T_0_i21_i = $1273; - continue; - } - if (!($1272 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0)) { - HEAP32[$1272 >> 2] = $1207; - HEAP32[($tbase_243_i + ($_sum_i16_i + 24 | 0) | 0) >> 2] = $T_0_i21_i; - HEAP32[($tbase_243_i + ($_sum_i16_i + 12 | 0) | 0) >> 2] = $1207; - HEAP32[($tbase_243_i + ($_sum_i16_i + 8 | 0) | 0) >> 2] = $1207; - break $_$314; - } - _abort(); - } - } - } - } - } - } - } while (0); - var $mem_0 = $tbase_243_i + ($981 | 8) | 0; - break $_$215; - } - } while (0); - var $1306 = $876; - var $sp_0_i_i_i = __gm_ + 444 | 0; - while (1) { - var $sp_0_i_i_i; - var $1309 = HEAP32[($sp_0_i_i_i | 0) >> 2]; - if (!($1309 >>> 0 > $1306 >>> 0)) { - var $1313 = HEAP32[($sp_0_i_i_i + 4 | 0) >> 2]; - if (($1309 + $1313 | 0) >>> 0 > $1306 >>> 0) { - var $1321 = $1309; - var $1320 = $1313; - break; - } - } - var $1318 = HEAP32[($sp_0_i_i_i + 8 | 0) >> 2]; - if (!(($1318 | 0) == 0)) { - var $sp_0_i_i_i = $1318; - continue; - } - var $1321 = 0; - var $1320 = 4; - break; - } - var $1320; - var $1321; - var $1322 = $1321 + $1320 | 0; - var $1324 = $1321 + ($1320 - 39 | 0) | 0; - if (($1324 & 7 | 0) == 0) { - var $1331 = 0; - } else { - var $1331 = (-$1324 | 0) & 7; - } - var $1331; - var $1332 = $1321 + (($1320 - 47 | 0) + $1331 | 0) | 0; - var $1336 = $1332 >>> 0 < ($876 + 16 | 0) >>> 0 ? $1306 : $1332; - var $1337 = $1336 + 8 | 0; - var $1340 = $tbase_243_i + 8 | 0; - if (($1340 & 7 | 0) == 0) { - var $1346 = 0; - } else { - var $1346 = (-$1340 | 0) & 7; - } - var $1346; - var $1350 = ($tsize_242_i - 40 | 0) - $1346 | 0; - HEAP32[(__gm_ + 24 | 0) >> 2] = $tbase_243_i + $1346 | 0; - HEAP32[(__gm_ + 12 | 0) >> 2] = $1350; - HEAP32[($tbase_243_i + ($1346 + 4 | 0) | 0) >> 2] = $1350 | 1; - HEAP32[($tbase_243_i + ($tsize_242_i - 36 | 0) | 0) >> 2] = 40; - HEAP32[(__gm_ + 28 | 0) >> 2] = HEAP32[(_mparams + 16 | 0) >> 2]; - HEAP32[($1336 + 4 | 0) >> 2] = 27; - HEAP32[$1337 >> 2] = HEAP32[(__gm_ + 444 | 0) >> 2]; - HEAP32[$1337 + 4 >> 2] = HEAP32[(__gm_ + 444 | 0) + 4 >> 2]; - HEAP32[$1337 + 8 >> 2] = HEAP32[(__gm_ + 444 | 0) + 8 >> 2]; - HEAP32[$1337 + 12 >> 2] = HEAP32[(__gm_ + 444 | 0) + 12 >> 2]; - HEAP32[(__gm_ + 444 | 0) >> 2] = $tbase_243_i; - HEAP32[(__gm_ + 448 | 0) >> 2] = $tsize_242_i; - HEAP32[(__gm_ + 456 | 0) >> 2] = 0; - HEAP32[(__gm_ + 452 | 0) >> 2] = $1337; - var $1360 = $1336 + 28 | 0; - HEAP32[$1360 >> 2] = 7; - $_$426 : do { - if (($1336 + 32 | 0) >>> 0 < $1322 >>> 0) { - var $1363 = $1360; - while (1) { - var $1363; - var $1364 = $1363 + 4 | 0; - HEAP32[$1364 >> 2] = 7; - if (!(($1363 + 8 | 0) >>> 0 < $1322 >>> 0)) { - break $_$426; - } - var $1363 = $1364; - } - } - } while (0); - if (($1336 | 0) == ($1306 | 0)) { - break; - } - var $1372 = $1336 - $876 | 0; - var $1375 = $1306 + ($1372 + 4 | 0) | 0; - HEAP32[$1375 >> 2] = HEAP32[$1375 >> 2] & -2; - HEAP32[($876 + 4 | 0) >> 2] = $1372 | 1; - HEAP32[($1306 + $1372 | 0) >> 2] = $1372; - if ($1372 >>> 0 < 256) { - var $1385 = $1372 >>> 2 & 1073741822; - var $1387 = __gm_ + 40 + ($1385 << 2) | 0; - var $1388 = HEAP32[(__gm_ | 0) >> 2]; - var $1389 = 1 << ($1372 >>> 3); - do { - if (($1388 & $1389 | 0) == 0) { - HEAP32[(__gm_ | 0) >> 2] = $1388 | $1389; - var $F_0_i_i = $1387; - var $_pre_phi_i_i = __gm_ + 40 + (($1385 + 2 | 0) << 2) | 0; - } else { - var $1395 = __gm_ + 40 + (($1385 + 2 | 0) << 2) | 0; - var $1396 = HEAP32[$1395 >> 2]; - if (!($1396 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0)) { - var $F_0_i_i = $1396; - var $_pre_phi_i_i = $1395; - break; - } - _abort(); - } - } while (0); - var $_pre_phi_i_i; - var $F_0_i_i; - HEAP32[$_pre_phi_i_i >> 2] = $876; - HEAP32[($F_0_i_i + 12 | 0) >> 2] = $876; - HEAP32[($876 + 8 | 0) >> 2] = $F_0_i_i; - HEAP32[($876 + 12 | 0) >> 2] = $1387; - } else { - var $1406 = $876; - var $1407 = $1372 >>> 8; - do { - if (($1407 | 0) == 0) { - var $I1_0_i_i = 0; - } else { - if ($1372 >>> 0 > 16777215) { - var $I1_0_i_i = 31; - break; - } - var $1414 = ($1407 + 1048320 | 0) >>> 16 & 8; - var $1415 = $1407 << $1414; - var $1418 = ($1415 + 520192 | 0) >>> 16 & 4; - var $1419 = $1415 << $1418; - var $1422 = ($1419 + 245760 | 0) >>> 16 & 2; - var $1428 = (14 - ($1418 | $1414 | $1422) | 0) + ($1419 << $1422 >>> 15) | 0; - var $I1_0_i_i = $1372 >>> (($1428 + 7 | 0) >>> 0) & 1 | $1428 << 1; - } - } while (0); - var $I1_0_i_i; - var $1435 = __gm_ + 304 + ($I1_0_i_i << 2) | 0; - HEAP32[($876 + 28 | 0) >> 2] = $I1_0_i_i; - HEAP32[($876 + 20 | 0) >> 2] = 0; - HEAP32[($876 + 16 | 0) >> 2] = 0; - var $1439 = HEAP32[(__gm_ + 4 | 0) >> 2]; - var $1440 = 1 << $I1_0_i_i; - if (($1439 & $1440 | 0) == 0) { - HEAP32[(__gm_ + 4 | 0) >> 2] = $1439 | $1440; - HEAP32[$1435 >> 2] = $1406; - HEAP32[($876 + 24 | 0) >> 2] = $1435; - HEAP32[($876 + 12 | 0) >> 2] = $876; - HEAP32[($876 + 8 | 0) >> 2] = $876; - } else { - if (($I1_0_i_i | 0) == 31) { - var $1455 = 0; - } else { - var $1455 = 25 - ($I1_0_i_i >>> 1) | 0; - } - var $1455; - var $K2_0_i_i = $1372 << $1455; - var $T_0_i_i = HEAP32[$1435 >> 2]; - while (1) { - var $T_0_i_i; - var $K2_0_i_i; - if ((HEAP32[($T_0_i_i + 4 | 0) >> 2] & -8 | 0) == ($1372 | 0)) { - var $1478 = $T_0_i_i + 8 | 0; - var $1479 = HEAP32[$1478 >> 2]; - var $1481 = HEAP32[(__gm_ + 16 | 0) >> 2]; - do { - if (!($T_0_i_i >>> 0 < $1481 >>> 0)) { - if ($1479 >>> 0 < $1481 >>> 0) { - break; - } - HEAP32[($1479 + 12 | 0) >> 2] = $1406; - HEAP32[$1478 >> 2] = $1406; - HEAP32[($876 + 8 | 0) >> 2] = $1479; - HEAP32[($876 + 12 | 0) >> 2] = $T_0_i_i; - HEAP32[($876 + 24 | 0) >> 2] = 0; - break $_$275; - } - } while (0); - _abort(); - } else { - var $1464 = $T_0_i_i + 16 + ($K2_0_i_i >>> 31 << 2) | 0; - var $1465 = HEAP32[$1464 >> 2]; - if (!(($1465 | 0) == 0)) { - var $K2_0_i_i = $K2_0_i_i << 1; - var $T_0_i_i = $1465; - continue; - } - if (!($1464 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0)) { - HEAP32[$1464 >> 2] = $1406; - HEAP32[($876 + 24 | 0) >> 2] = $T_0_i_i; - HEAP32[($876 + 12 | 0) >> 2] = $876; - HEAP32[($876 + 8 | 0) >> 2] = $876; - break $_$275; - } - _abort(); - } - } - } - } - } - } while (0); - var $1491 = HEAP32[(__gm_ + 12 | 0) >> 2]; - if (!($1491 >>> 0 > $nb_0 >>> 0)) { + if (($1407 | 0) == 0) { + var $I1_0_i_i = 0; + } else { + if ($1372 >>> 0 > 16777215) { + var $I1_0_i_i = 31; + break; + } + var $1414 = ($1407 + 1048320 | 0) >>> 16 & 8; + var $1415 = $1407 << $1414; + var $1418 = ($1415 + 520192 | 0) >>> 16 & 4; + var $1419 = $1415 << $1418; + var $1422 = ($1419 + 245760 | 0) >>> 16 & 2; + var $1428 = (14 - ($1418 | $1414 | $1422) | 0) + ($1419 << $1422 >>> 15) | 0; + var $I1_0_i_i = $1372 >>> (($1428 + 7 | 0) >>> 0) & 1 | $1428 << 1; + } + } while (0); + var $I1_0_i_i; + var $1435 = __gm_ + 304 + ($I1_0_i_i << 2) | 0; + HEAP32[($876 + 28 | 0) >> 2] = $I1_0_i_i; + HEAP32[($876 + 20 | 0) >> 2] = 0; + HEAP32[($876 + 16 | 0) >> 2] = 0; + var $1439 = HEAP32[(__gm_ + 4 | 0) >> 2]; + var $1440 = 1 << $I1_0_i_i; + if (($1439 & $1440 | 0) == 0) { + HEAP32[(__gm_ + 4 | 0) >> 2] = $1439 | $1440; + HEAP32[$1435 >> 2] = $1406; + HEAP32[($876 + 24 | 0) >> 2] = $1435; + HEAP32[($876 + 12 | 0) >> 2] = $876; + HEAP32[($876 + 8 | 0) >> 2] = $876; + } else { + if (($I1_0_i_i | 0) == 31) { + var $1455 = 0; + } else { + var $1455 = 25 - ($I1_0_i_i >>> 1) | 0; + } + var $1455; + var $K2_0_i_i = $1372 << $1455; + var $T_0_i_i = HEAP32[$1435 >> 2]; + while (1) { + var $T_0_i_i; + var $K2_0_i_i; + if ((HEAP32[($T_0_i_i + 4 | 0) >> 2] & -8 | 0) == ($1372 | 0)) { + var $1478 = $T_0_i_i + 8 | 0; + var $1479 = HEAP32[$1478 >> 2]; + var $1481 = HEAP32[(__gm_ + 16 | 0) >> 2]; + do { + if (!($T_0_i_i >>> 0 < $1481 >>> 0)) { + if ($1479 >>> 0 < $1481 >>> 0) { break; + } + HEAP32[($1479 + 12 | 0) >> 2] = $1406; + HEAP32[$1478 >> 2] = $1406; + HEAP32[($876 + 8 | 0) >> 2] = $1479; + HEAP32[($876 + 12 | 0) >> 2] = $T_0_i_i; + HEAP32[($876 + 24 | 0) >> 2] = 0; + break $_$275; } - var $1494 = $1491 - $nb_0 | 0; - HEAP32[(__gm_ + 12 | 0) >> 2] = $1494; - var $1495 = HEAP32[(__gm_ + 24 | 0) >> 2]; - var $1496 = $1495; - HEAP32[(__gm_ + 24 | 0) >> 2] = $1496 + $nb_0 | 0; - HEAP32[($1496 + ($nb_0 + 4 | 0) | 0) >> 2] = $1494 | 1; - HEAP32[($1495 + 4 | 0) >> 2] = $nb_0 | 3; - var $mem_0 = $1495 + 8 | 0; - break $_$215; + } while (0); + _abort(); + } else { + var $1464 = $T_0_i_i + 16 + ($K2_0_i_i >>> 31 << 2) | 0; + var $1465 = HEAP32[$1464 >> 2]; + if (!(($1465 | 0) == 0)) { + var $K2_0_i_i = $K2_0_i_i << 1; + var $T_0_i_i = $1465; + continue; + } + if (!($1464 >>> 0 < HEAP32[(__gm_ + 16 | 0) >> 2] >>> 0)) { + HEAP32[$1464 >> 2] = $1406; + HEAP32[($876 + 24 | 0) >> 2] = $T_0_i_i; + HEAP32[($876 + 12 | 0) >> 2] = $876; + HEAP32[($876 + 8 | 0) >> 2] = $876; + break $_$275; + } + _abort(); } - } while (0); - HEAP32[___errno() >> 2] = 12; - var $mem_0 = 0; - } - } else { - var $706 = $703 - $nb_0 | 0; - var $707 = HEAP32[(__gm_ + 20 | 0) >> 2]; - if ($706 >>> 0 > 15) { - var $710 = $707; - HEAP32[(__gm_ + 20 | 0) >> 2] = $710 + $nb_0 | 0; - HEAP32[(__gm_ + 8 | 0) >> 2] = $706; - HEAP32[($710 + ($nb_0 + 4 | 0) | 0) >> 2] = $706 | 1; - HEAP32[($710 + $703 | 0) >> 2] = $706; - HEAP32[($707 + 4 | 0) >> 2] = $nb_0 | 3; - } else { - HEAP32[(__gm_ + 8 | 0) >> 2] = 0; - HEAP32[(__gm_ + 20 | 0) >> 2] = 0; - HEAP32[($707 + 4 | 0) >> 2] = $703 | 3; - var $725 = $707 + ($703 + 4 | 0) | 0; - HEAP32[$725 >> 2] = HEAP32[$725 >> 2] | 1; + } + } + } } - var $mem_0 = $707 + 8 | 0; + } while (0); + var $1491 = HEAP32[(__gm_ + 12 | 0) >> 2]; + if (!($1491 >>> 0 > $nb_0 >>> 0)) { + break; + } + var $1494 = $1491 - $nb_0 | 0; + HEAP32[(__gm_ + 12 | 0) >> 2] = $1494; + var $1495 = HEAP32[(__gm_ + 24 | 0) >> 2]; + var $1496 = $1495; + HEAP32[(__gm_ + 24 | 0) >> 2] = $1496 + $nb_0 | 0; + HEAP32[($1496 + ($nb_0 + 4 | 0) | 0) >> 2] = $1494 | 1; + HEAP32[($1495 + 4 | 0) >> 2] = $nb_0 | 3; + var $mem_0 = $1495 + 8 | 0; + break $_$215; } + } while (0); + HEAP32[___errno() >> 2] = 12; + var $mem_0 = 0; + } + } else { + var $706 = $703 - $nb_0 | 0; + var $707 = HEAP32[(__gm_ + 20 | 0) >> 2]; + if ($706 >>> 0 > 15) { + var $710 = $707; + HEAP32[(__gm_ + 20 | 0) >> 2] = $710 + $nb_0 | 0; + HEAP32[(__gm_ + 8 | 0) >> 2] = $706; + HEAP32[($710 + ($nb_0 + 4 | 0) | 0) >> 2] = $706 | 1; + HEAP32[($710 + $703 | 0) >> 2] = $706; + HEAP32[($707 + 4 | 0) >> 2] = $nb_0 | 3; + } else { + HEAP32[(__gm_ + 8 | 0) >> 2] = 0; + HEAP32[(__gm_ + 20 | 0) >> 2] = 0; + HEAP32[($707 + 4 | 0) >> 2] = $703 | 3; + var $725 = $707 + ($703 + 4 | 0) | 0; + HEAP32[$725 >> 2] = HEAP32[$725 >> 2] | 1; } - } while (0); - var $mem_0; - return $mem_0; - return null; + var $mem_0 = $707 + 8 | 0; + } + } + } while (0); + var $mem_0; + return $mem_0; + return null; } function asm(x, y) { - x = +x; - y = y | 0; - var a = 0, b = +0; - a = cheez(y + ~~x | 0) | 0; - b = a * a; - fleefl(b | 0, a | 0); + x = +x; + y = y | 0; + var a = 0, b = +0; + a = cheez(y + ~~x | 0) | 0; + b = a * a; + fleefl(b | 0, a | 0); } function phi() { - if (wat()) { - var $10 = 1; - } else { - var $10 = (_init_mparams() | 0) != 0; - } - var $10; + if (wat()) { + var $10 = 1; + } else { + var $10 = (_init_mparams() | 0) != 0; + } + var $10; } function intoCond() { - var $115 = 22; - var $NumWords = __ZN4llvm15BitstreamCursor4ReadEj($117, 32); - if (($115 | 0) != 0) { - HEAP32[$115 >> 2] = $NumWords; - } + var $115 = 22; + var $NumWords = __ZN4llvm15BitstreamCursor4ReadEj($117, 32); + if (($115 | 0) != 0) { + HEAP32[$115 >> 2] = $NumWords; + } } diff --git a/tools/eliminator/eliminator-test.js b/tools/eliminator/eliminator-test.js index 3edd61ac90ae1..ffad69ea5f06e 100644 --- a/tools/eliminator/eliminator-test.js +++ b/tools/eliminator/eliminator-test.js @@ -1,8856 +1,8856 @@ function a($directory) { - var $1 = _strlen($directory); - var $p_0 = $directory + $1 | 0; - chak($p_0); - var $210 = HEAP32[100]; // heaps alias each other! so this cannot be eliminated - HEAP32[1e3] = HEAP32[5]; - HEAP32[90] = $210; - chak(); - var $210a = HEAP32[100]; // function calls can also modify memory - something(); - HEAP32[90] = $210a; - chak(); - var $a = $hack; // no mem use (just a global), so ok to eliminate - HEAP32[1e3] = HEAP32[5]; - HEAP32[90] = $a; - chak(); - var $bb = HEAP32[11]; // ok to eliminate - var $b = ($bb+7)|0; // ok to eliminate by itself, but not with inlined $bb which is mem-using! - HEAP32[1e3] = HEAP32[5]; - HEAP32[90] = $b; - chak(); - var $bb2 = HEAP32[11]; - HEAP32[111] = 321; - var $b2 = ($bb2+7)|0; - HEAP32[1e3] = HEAP32[5]; - HEAP32[90] = $b2; - chak(); - var $d = HEAP32[100]; // alias on next line, but that is where we are consumed - so ok. - HEAP32[1e3] = $d; - chak(); - var $e = func(); - HEAP32[1e3] = $e; - chak(); - var $e2 = func(); - tor($e2); - chak(); - var $e3 = HEAP[9]; - tor($e3); - barrier(); // same stuff, but with a var on top and assigns as the first and only def - var $$210, $$210a, $$a, $$bb, $$b, $$bb2, $$b2, $$d, $$e, $$e2, $$e3; - $$210 = HEAP32[100]; // heaps alias each other! so this cannot be eliminated - HEAP32[1e3] = HEAP32[5]; - HEAP32[90] = $$210; - chak(); - $$210a = HEAP32[100]; // function calls can also modify memory - something(); - HEAP32[90] = $$210a; - chak(); - $$a = $$hack; // no mem use, so ok to eliminate - HEAP32[1e3] = HEAP32[5]; - HEAP32[90] = $$a; - chak(); - $$bb = HEAP32[11]; // ok to eliminate - $$b = ($$bb+7)|0; // ok to eliminate by itself, but not with inlined $$bb which is mem-using! - HEAP32[1e3] = HEAP32[5]; - HEAP32[90] = $$b; - chak(); - $$bb2 = HEAP32[11]; - HEAP32[111] = 321; - $$b2 = ($$bb2+7)|0; - HEAP32[1e3] = HEAP32[5]; - HEAP32[90] = $$b2; - chak(); - $$d = HEAP32[100]; // alias on next line, but that is where we are consumed - so ok. - HEAP32[1e3] = $$d; - chak(); - $$e = func(); - HEAP32[1e3] = $$e; - chak(); - $$e2 = func(); - tor($$e2); - chak(); - $$e3 = HEAP[9]; - tor($$e3); - barrier(); - var $65, $image, $51$s2, $71; - var $66 = HEAP32[$65 >> 2]; - var $71 = $66 - _int_ceildiv(HEAP32[$image >> 2], HEAP32[$51$s2]) | 0; - HEAP32[$65 >> 2] = _int_ceildivpow2($71, HEAP32[$51$s2 + 10]); - barr(); - var ONCE = sheep(); - while (ONCE) { - work(); - } - var ONCEb = 75; - while (ONCEb) { - work(); - } - var $26 = __ZL3minIiET_S0_S0_12(4096, 4096 - $16 | 0); // cannot eliminate this because the call might modify FUNCTION_TABLE - var $27 = FUNCTION_TABLE[$22]($18, $this + ($16 + 27) | 0, $26); - print($27); - chak(); - var zzz = 10; - do { - print(zzz); - } while (0); - var zzz1 = 10; - do { - print(zzz1); - } while (1); // cannot eliminate a do-while that is not one-time + var $1 = _strlen($directory); + var $p_0 = $directory + $1 | 0; + chak($p_0); + var $210 = HEAP32[100]; // heaps alias each other! so this cannot be eliminated + HEAP32[1e3] = HEAP32[5]; + HEAP32[90] = $210; + chak(); + var $210a = HEAP32[100]; // function calls can also modify memory + something(); + HEAP32[90] = $210a; + chak(); + var $a = $hack; // no mem use (just a global), so ok to eliminate + HEAP32[1e3] = HEAP32[5]; + HEAP32[90] = $a; + chak(); + var $bb = HEAP32[11]; // ok to eliminate + var $b = ($bb+7)|0; // ok to eliminate by itself, but not with inlined $bb which is mem-using! + HEAP32[1e3] = HEAP32[5]; + HEAP32[90] = $b; + chak(); + var $bb2 = HEAP32[11]; + HEAP32[111] = 321; + var $b2 = ($bb2+7)|0; + HEAP32[1e3] = HEAP32[5]; + HEAP32[90] = $b2; + chak(); + var $d = HEAP32[100]; // alias on next line, but that is where we are consumed - so ok. + HEAP32[1e3] = $d; + chak(); + var $e = func(); + HEAP32[1e3] = $e; + chak(); + var $e2 = func(); + tor($e2); + chak(); + var $e3 = HEAP[9]; + tor($e3); + barrier(); // same stuff, but with a var on top and assigns as the first and only def + var $$210, $$210a, $$a, $$bb, $$b, $$bb2, $$b2, $$d, $$e, $$e2, $$e3; + $$210 = HEAP32[100]; // heaps alias each other! so this cannot be eliminated + HEAP32[1e3] = HEAP32[5]; + HEAP32[90] = $$210; + chak(); + $$210a = HEAP32[100]; // function calls can also modify memory + something(); + HEAP32[90] = $$210a; + chak(); + $$a = $$hack; // no mem use, so ok to eliminate + HEAP32[1e3] = HEAP32[5]; + HEAP32[90] = $$a; + chak(); + $$bb = HEAP32[11]; // ok to eliminate + $$b = ($$bb+7)|0; // ok to eliminate by itself, but not with inlined $$bb which is mem-using! + HEAP32[1e3] = HEAP32[5]; + HEAP32[90] = $$b; + chak(); + $$bb2 = HEAP32[11]; + HEAP32[111] = 321; + $$b2 = ($$bb2+7)|0; + HEAP32[1e3] = HEAP32[5]; + HEAP32[90] = $$b2; + chak(); + $$d = HEAP32[100]; // alias on next line, but that is where we are consumed - so ok. + HEAP32[1e3] = $$d; + chak(); + $$e = func(); + HEAP32[1e3] = $$e; + chak(); + $$e2 = func(); + tor($$e2); + chak(); + $$e3 = HEAP[9]; + tor($$e3); + barrier(); + var $65, $image, $51$s2, $71; + var $66 = HEAP32[$65 >> 2]; + var $71 = $66 - _int_ceildiv(HEAP32[$image >> 2], HEAP32[$51$s2]) | 0; + HEAP32[$65 >> 2] = _int_ceildivpow2($71, HEAP32[$51$s2 + 10]); + barr(); + var ONCE = sheep(); + while (ONCE) { + work(); + } + var ONCEb = 75; + while (ONCEb) { + work(); + } + var $26 = __ZL3minIiET_S0_S0_12(4096, 4096 - $16 | 0); // cannot eliminate this because the call might modify FUNCTION_TABLE + var $27 = FUNCTION_TABLE[$22]($18, $this + ($16 + 27) | 0, $26); + print($27); + chak(); + var zzz = 10; + do { + print(zzz); + } while (0); + var zzz1 = 10; + do { + print(zzz1); + } while (1); // cannot eliminate a do-while that is not one-time } function b() { - var $148 = _sqlite3Strlen30($147); - var $150 = HEAP32[$pExpr + 16 >> 2]; - if (($150 | 0) == 0) { - var $156 = 0; - } else { - var $156 = HEAP32[$150 >> 2]; - } - var $156; - HEAP32[$139 + ($136 << 4) + 4 >> 2] = _sqlite3FindFunction($145, $147, $148, $156, $135, 0); - farr(); - var $a = f1(); - var $b = f2() + $a; // this could be reordered to facilitate optimization - f3($b); - farr(); - var finality = cheez(); - return finality; + var $148 = _sqlite3Strlen30($147); + var $150 = HEAP32[$pExpr + 16 >> 2]; + if (($150 | 0) == 0) { + var $156 = 0; + } else { + var $156 = HEAP32[$150 >> 2]; + } + var $156; + HEAP32[$139 + ($136 << 4) + 4 >> 2] = _sqlite3FindFunction($145, $147, $148, $156, $135, 0); + farr(); + var $a = f1(); + var $b = f2() + $a; // this could be reordered to facilitate optimization + f3($b); + farr(); + var finality = cheez(); + return finality; } function c() { - var x = MEM[100], y = callMe(5), z = glob; // do not eliminate vars with multiple variables, if there is a call! - var w = x*2; - zoom(z); - hail(w); - sunk(y); - barrier(); - var x2 = MEM[100], y2 = $callMe2, z2 = glob; // no call, so ok - var w2 = x2*2; - zoom(z2); - hail(w2); - sunk(y2); - var fly = you(fools); - var one, two = three(); // more than one var here, so cannot eliminate |two=|, oh well - var noneed; - noneed = fools(you); - var noneed2; - noneed2 += fools(you2); - return; + var x = MEM[100], y = callMe(5), z = glob; // do not eliminate vars with multiple variables, if there is a call! + var w = x*2; + zoom(z); + hail(w); + sunk(y); + barrier(); + var x2 = MEM[100], y2 = $callMe2, z2 = glob; // no call, so ok + var w2 = x2*2; + zoom(z2); + hail(w2); + sunk(y2); + var fly = you(fools); + var one, two = three(); // more than one var here, so cannot eliminate |two=|, oh well + var noneed; + noneed = fools(you); + var noneed2; + noneed2 += fools(you2); + return; } function f() { - var unused; - var x = GLOB[1]; - var y = x + 1; - var z = y / 2; - HEAP[123] = z; + var unused; + var x = GLOB[1]; + var y = x + 1; + var z = y / 2; + HEAP[123] = z; } function g(a1, a2) { - var a = 1; - var b = a * 2; - var c = b - 1; - var qqq = "qwe"; - a = c; - foo(c); - var ww = 1, www, zzz = 2; - foo(zzz); - for (var i = 0; i < 5; i++) { - var q = { - a: 1 - } + [ 2, 3 ]; - } - for (var iterator in SOME_GLOBAL) { - quux(iterator); - } - var $0 = HEAP[5]; - MAYBE_HEAP[myglobal] = 123; - var $1 = $0 < 0; - if ($1) { - __label__ = 1; - } else { - __label__ = 2; - } - var sadijn = new asd; - sadijn2 = "qwe%sert"; - this.Module || (this.Module = {}); - var obj = { - 'quoted': 1, - "doublequoted": 2, - unquoted: 3, - 4: 5 - }; + var a = 1; + var b = a * 2; + var c = b - 1; + var qqq = "qwe"; + a = c; + foo(c); + var ww = 1, www, zzz = 2; + foo(zzz); + for (var i = 0; i < 5; i++) { + var q = { + a: 1 + } + [ 2, 3 ]; + } + for (var iterator in SOME_GLOBAL) { + quux(iterator); + } + var $0 = HEAP[5]; + MAYBE_HEAP[myglobal] = 123; + var $1 = $0 < 0; + if ($1) { + __label__ = 1; + } else { + __label__ = 2; + } + var sadijn = new asd; + sadijn2 = "qwe%sert"; + this.Module || (this.Module = {}); + var obj = { + 'quoted': 1, + "doublequoted": 2, + unquoted: 3, + 4: 5 + }; } function h() { - var out; - bar(hello); - var hello = 5; - if (0) { - var sb1 = 21; - } - out = sb1; - if (0) { - var sb2 = 23; - } else { - out = sb2; - } - if (0) { - out = sb3; - } else { - var sb3 = 23; - } - for (var it = 0; it < 5; it++) { - x = y ? x + 1 : 7; - var x = -5; - } - var oneUse = glob; // for now, cannot eliminate into body or else of if - if (1) { - otherGlob = oneUse; - breakMe(); - } - var oneUse2 = glob2; - while (1) { - otherGlob2 = oneUse2; - breakMe(); - } - return out; + var out; + bar(hello); + var hello = 5; + if (0) { + var sb1 = 21; + } + out = sb1; + if (0) { + var sb2 = 23; + } else { + out = sb2; + } + if (0) { + out = sb3; + } else { + var sb3 = 23; + } + for (var it = 0; it < 5; it++) { + x = y ? x + 1 : 7; + var x = -5; + } + var oneUse = glob; // for now, cannot eliminate into body or else of if + if (1) { + otherGlob = oneUse; + breakMe(); + } + var oneUse2 = glob2; + while (1) { + otherGlob2 = oneUse2; + breakMe(); + } + return out; } function strtok_part(b, j, f) { - var a; - for (;;) { - h = a == 13 ? h : 0; - a = HEAP[d + h]; - if (a == g != 0) break; - var h = h + 1; - if (a != 0) a = 13; - } + var a; + for (;;) { + h = a == 13 ? h : 0; + a = HEAP[d + h]; + if (a == g != 0) break; + var h = h + 1; + if (a != 0) a = 13; + } } function py() { - var $4 = HEAP[__PyThreadState_Current]; - var $5 = $4 + 12; - var $7 = HEAP[$5] + 1; - var $8 = $7 + 12; - HEAP[$8] = 99; + var $4 = HEAP[__PyThreadState_Current]; + var $5 = $4 + 12; + var $7 = HEAP[$5] + 1; + var $8 = $7 + 12; + HEAP[$8] = 99; } var anon = function(x) { - var $4 = HEAP[__PyThreadState_Current]; - var $5 = $4 + 12; - var $7 = HEAP[$5] + 1; - var $8 = $4 + 12; - HEAP[$8] = $7; + var $4 = HEAP[__PyThreadState_Current]; + var $5 = $4 + 12; + var $7 = HEAP[$5] + 1; + var $8 = $4 + 12; + HEAP[$8] = $7; } function r($0) { - HEAP[$0 + 5 + 2] = 99+5+2+1; + HEAP[$0 + 5 + 2] = 99+5+2+1; } function t() { - var $cmp2=($10) < ($11); - if ($cmp2) { __label__ = 3; } - var $cmp3=($12) < ($13); - if (!($cmp3)) { __label__ = 4; } + var $cmp2=($10) < ($11); + if ($cmp2) { __label__ = 3; } + var $cmp3=($12) < ($13); + if (!($cmp3)) { __label__ = 4; } } function f2() { - var $arrayidx64_phi_trans_insert = $vla + ($storemerge312 << 2) | 0; - var $_pre = HEAPU32[$arrayidx64_phi_trans_insert >> 2]; - var $phitmp = $storemerge312 + 1 | 0; - var $storemerge312 = $phitmp; - var $8 = $_pre; - c($8); + var $arrayidx64_phi_trans_insert = $vla + ($storemerge312 << 2) | 0; + var $_pre = HEAPU32[$arrayidx64_phi_trans_insert >> 2]; + var $phitmp = $storemerge312 + 1 | 0; + var $storemerge312 = $phitmp; + var $8 = $_pre; + c($8); } function f3($s, $tree, $k) { - // HEAP vars alias each other, and the loop can confuse us - var $0 = HEAPU32[($s + 2908 + ($k << 2) | 0) >> 2]; - while (1) { - HEAP32[($s + 2908 + ($storemerge_in << 2) | 0) >> 2] = $9; - } - HEAP32[($s + 2908 + ($storemerge_in << 2) | 0) >> 2] = $0; + // HEAP vars alias each other, and the loop can confuse us + var $0 = HEAPU32[($s + 2908 + ($k << 2) | 0) >> 2]; + while (1) { + HEAP32[($s + 2908 + ($storemerge_in << 2) | 0) >> 2] = $9; + } + HEAP32[($s + 2908 + ($storemerge_in << 2) | 0) >> 2] = $0; } function llvm3_1() { - while (check()) { - var $inc = $aj_0 + 1; - if ($curri_01 % $zj_0 == 0) { - break; - } - var $j_0 = $inc; - run($j_0 / 2); + while (check()) { + var $inc = $aj_0 + 1; + if ($curri_01 % $zj_0 == 0) { + break; } + var $j_0 = $inc; + run($j_0 / 2); + } } function _inflate($strm, $flush) { - var __stackBase__ = STACKTOP; - STACKTOP += 4; - var __label__; - var $hbuf = __stackBase__; - var $cmp = ($strm | 0) == 0; - $_$2 : do { - if ($cmp) { + var __stackBase__ = STACKTOP; + STACKTOP += 4; + var __label__; + var $hbuf = __stackBase__; + var $cmp = ($strm | 0) == 0; + $_$2 : do { + if ($cmp) { + var $retval_0 = -2; + } else { + var $state1 = $strm + 28 | 0; + var $0 = HEAPU32[$state1 >> 2]; + var $cmp2 = ($0 | 0) == 0; + if ($cmp2) { + var $retval_0 = -2; + break; + } + var $next_out = $strm + 12 | 0; + var $1 = HEAP32[$next_out >> 2]; + var $cmp4 = ($1 | 0) == 0; + if ($cmp4) { + var $retval_0 = -2; + break; + } + var $next_in = $strm | 0; + var $2 = HEAP32[$next_in >> 2]; + var $cmp6 = ($2 | 0) == 0; + if ($cmp6) { + var $avail_in = $strm + 4 | 0; + var $3 = HEAP32[$avail_in >> 2]; + var $cmp7 = ($3 | 0) == 0; + if (!$cmp7) { + var $retval_0 = -2; + break; + } + } + var $4 = $0; + var $mode = $0 | 0; + var $5 = HEAP32[$mode >> 2]; + var $cmp9 = ($5 | 0) == 11; + if ($cmp9) { + HEAP32[$mode >> 2] = 12; + var $_pre = HEAP32[$next_out >> 2]; + var $_pre882 = HEAP32[$next_in >> 2]; + var $8 = $_pre; + var $7 = $_pre882; + var $6 = 12; + } else { + var $8 = $1; + var $7 = $2; + var $6 = $5; + } + var $6; + var $7; + var $8; + var $avail_out = $strm + 16 | 0; + var $9 = HEAP32[$avail_out >> 2]; + var $avail_in15 = $strm + 4 | 0; + var $10 = HEAPU32[$avail_in15 >> 2]; + var $11 = $0 + 56 | 0; + var $12 = HEAP32[$11 >> 2]; + var $13 = $0 + 60 | 0; + var $14 = HEAP32[$13 >> 2]; + var $15 = $0 + 8 | 0; + var $16 = $0 + 24 | 0; + var $arrayidx = $hbuf | 0; + var $arrayidx40 = $hbuf + 1 | 0; + var $17 = $0 + 16 | 0; + var $head = $0 + 32 | 0; + var $18 = $head; + var $msg = $strm + 24 | 0; + var $19 = $0 + 36 | 0; + var $20 = $0 + 20 | 0; + var $adler = $strm + 48 | 0; + var $21 = $0 + 64 | 0; + var $22 = $0 + 12 | 0; + var $flush_off = $flush - 5 | 0; + var $23 = $flush_off >>> 0 < 2; + var $24 = $0 + 4 | 0; + var $cmp660 = ($flush | 0) == 6; + var $25 = $0 + 7108 | 0; + var $26 = $0 + 84 | 0; + var $lencode1215 = $0 + 76 | 0; + var $27 = $lencode1215; + var $28 = $0 + 72 | 0; + var $29 = $0 + 7112 | 0; + var $30 = $0 + 68 | 0; + var $31 = $0 + 44 | 0; + var $32 = $0 + 7104 | 0; + var $33 = $0 + 48 | 0; + var $window = $0 + 52 | 0; + var $34 = $window; + var $35 = $0 + 40 | 0; + var $total_out = $strm + 20 | 0; + var $36 = $0 + 28 | 0; + var $arrayidx199 = $hbuf + 2 | 0; + var $arrayidx202 = $hbuf + 3 | 0; + var $37 = $0 + 96 | 0; + var $38 = $0 + 100 | 0; + var $39 = $0 + 92 | 0; + var $40 = $0 + 104 | 0; + var $lens = $0 + 112 | 0; + var $41 = $lens; + var $codes = $0 + 1328 | 0; + var $next861 = $0 + 108 | 0; + var $42 = $next861; + var $43 = $next861 | 0; + var $arraydecay860_c = $codes; + var $44 = $0 + 76 | 0; + var $arraydecay864 = $lens; + var $work = $0 + 752 | 0; + var $arraydecay867 = $work; + var $arrayidx1128 = $0 + 624 | 0; + var $45 = $arrayidx1128; + var $46 = $0 + 80 | 0; + var $47 = $0 + 88 | 0; + var $distcode1395 = $0 + 80 | 0; + var $48 = $distcode1395; + var $ret_0 = 0; + var $next_0 = $7; + var $put_0 = $8; + var $have_0 = $10; + var $left_0 = $9; + var $hold_0 = $12; + var $bits_0 = $14; + var $out_0 = $9; + var $49 = $6; + $_$12 : while (1) { + var $49; + var $out_0; + var $bits_0; + var $hold_0; + var $left_0; + var $have_0; + var $put_0; + var $next_0; + var $ret_0; + $_$14 : do { + if (($49 | 0) == 0) { + var $50 = HEAPU32[$15 >> 2]; + var $cmp19 = ($50 | 0) == 0; + if ($cmp19) { + HEAP32[$mode >> 2] = 12; + var $ret_0_be = $ret_0; + var $next_0_be = $next_0; + var $put_0_be = $put_0; + var $have_0_be = $have_0; + var $left_0_be = $left_0; + var $hold_0_be = $hold_0; + var $bits_0_be = $bits_0; + var $out_0_be = $out_0; + __label__ = 268; + break; + } + var $next_1 = $next_0; + var $have_1 = $have_0; + var $hold_1 = $hold_0; + var $bits_1 = $bits_0; + while (1) { + var $bits_1; + var $hold_1; + var $have_1; + var $next_1; + var $cmp24 = $bits_1 >>> 0 < 16; + if (!$cmp24) { + break; + } + var $cmp26 = ($have_1 | 0) == 0; + if ($cmp26) { + var $ret_8 = $ret_0; + var $next_58 = $next_1; + var $have_58 = 0; + var $hold_54 = $hold_1; + var $bits_54 = $bits_1; + var $out_4 = $out_0; + break $_$12; + } + // XXX first chunk with a difference (no impact) + var $dec = $have_1 - 1 | 0; + var $incdec_ptr = $next_1 + 1 | 0; + var $51 = HEAPU8[$next_1]; + var $conv = $51 & 255; + var $shl = $conv << $bits_1; + var $add = $shl + $hold_1 | 0; + var $add29 = $bits_1 + 8 | 0; + var $next_1 = $incdec_ptr; + var $have_1 = $dec; + var $hold_1 = $add; + var $bits_1 = $add29; + } + var $and = $50 & 2; + var $tobool = ($and | 0) != 0; + var $cmp34 = ($hold_1 | 0) == 35615; + var $or_cond = $tobool & $cmp34; + if ($or_cond) { + var $call = _crc32(0, 0, 0); + HEAP32[$16 >> 2] = $call; + HEAP8[$arrayidx] = 31; + HEAP8[$arrayidx40] = -117; + var $52 = HEAP32[$16 >> 2]; + var $call42 = _crc32($52, $arrayidx, 2); + HEAP32[$16 >> 2] = $call42; + HEAP32[$mode >> 2] = 1; + var $ret_0_be = $ret_0; + var $next_0_be = $next_1; + var $put_0_be = $put_0; + var $have_0_be = $have_1; + var $left_0_be = $left_0; + var $hold_0_be = 0; + var $bits_0_be = 0; + var $out_0_be = $out_0; + __label__ = 268; + break; + } + HEAP32[$17 >> 2] = 0; + var $53 = HEAP32[$18 >> 2]; + var $cmp49 = ($53 | 0) == 0; + if ($cmp49) { + var $54 = $50; + } else { + var $done = $53 + 48 | 0; + HEAP32[$done >> 2] = -1; + var $_pre884 = HEAP32[$15 >> 2]; + var $54 = $_pre884; + } + var $54; + var $and55 = $54 & 1; + var $tobool56 = ($and55 | 0) == 0; + do { + if (!$tobool56) { + var $and58 = $hold_1 << 8; + var $shl59 = $and58 & 65280; + var $shr60 = $hold_1 >>> 8; + var $add61 = $shl59 + $shr60 | 0; + var $rem = ($add61 >>> 0) % 31; + var $tobool62 = ($rem | 0) == 0; + if (!$tobool62) { + break; + } + var $and66 = $hold_1 & 15; + var $cmp67 = ($and66 | 0) == 8; + if ($cmp67) { + var $shr74 = $hold_1 >>> 4; + var $sub = $bits_1 - 4 | 0; + var $and76 = $shr74 & 15; + var $add77 = $and76 + 8 | 0; + var $55 = HEAPU32[$19 >> 2]; + var $cmp78 = ($55 | 0) == 0; + do { + if (!$cmp78) { + var $cmp83 = $add77 >>> 0 > $55 >>> 0; + if (!$cmp83) { + break; + } + HEAP32[$msg >> 2] = STRING_TABLE.__str3100 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $ret_0; + var $next_0_be = $next_1; + var $put_0_be = $put_0; + var $have_0_be = $have_1; + var $left_0_be = $left_0; + var $hold_0_be = $shr74; + var $bits_0_be = $sub; + var $out_0_be = $out_0; + __label__ = 268; + break $_$14; + } + HEAP32[$19 >> 2] = $add77; + } while (0); + var $shl90 = 1 << $add77; + HEAP32[$20 >> 2] = $shl90; + var $call91 = _adler32(0, 0, 0); + HEAP32[$16 >> 2] = $call91; + HEAP32[$adler >> 2] = $call91; + var $and93 = $hold_1 >>> 12; + var $56 = $and93 & 2; + var $57 = $56 ^ 11; + HEAP32[$mode >> 2] = $57; + var $ret_0_be = $ret_0; + var $next_0_be = $next_1; + var $put_0_be = $put_0; + var $have_0_be = $have_1; + var $left_0_be = $left_0; + var $hold_0_be = 0; + var $bits_0_be = 0; + var $out_0_be = $out_0; + __label__ = 268; + break $_$14; + } + HEAP32[$msg >> 2] = STRING_TABLE.__str299 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $ret_0; + var $next_0_be = $next_1; + var $put_0_be = $put_0; + var $have_0_be = $have_1; + var $left_0_be = $left_0; + var $hold_0_be = $hold_1; + var $bits_0_be = $bits_1; + var $out_0_be = $out_0; + __label__ = 268; + break $_$14; + } + } while (0); + HEAP32[$msg >> 2] = STRING_TABLE.__str198 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $ret_0; + var $next_0_be = $next_1; + var $put_0_be = $put_0; + var $have_0_be = $have_1; + var $left_0_be = $left_0; + var $hold_0_be = $hold_1; + var $bits_0_be = $bits_1; + var $out_0_be = $out_0; + __label__ = 268; + break; + } else if (($49 | 0) == 1) { + var $next_2 = $next_0; + var $have_2 = $have_0; + var $hold_2 = $hold_0; + var $bits_2 = $bits_0; + while (1) { + var $bits_2; + var $hold_2; + var $have_2; + var $next_2; + var $cmp101 = $bits_2 >>> 0 < 16; + if (!$cmp101) { + break; + } + var $cmp105 = ($have_2 | 0) == 0; + if ($cmp105) { + var $ret_8 = $ret_0; + var $next_58 = $next_2; + var $have_58 = 0; + var $hold_54 = $hold_2; + var $bits_54 = $bits_2; + var $out_4 = $out_0; + break $_$12; + } + var $dec109 = $have_2 - 1 | 0; + var $incdec_ptr110 = $next_2 + 1 | 0; + var $58 = HEAPU8[$next_2]; + var $conv111 = $58 & 255; + var $shl112 = $conv111 << $bits_2; + var $add113 = $shl112 + $hold_2 | 0; + var $add114 = $bits_2 + 8 | 0; + var $next_2 = $incdec_ptr110; + var $have_2 = $dec109; + var $hold_2 = $add113; + var $bits_2 = $add114; + } + HEAP32[$17 >> 2] = $hold_2; + var $and120 = $hold_2 & 255; + var $cmp121 = ($and120 | 0) == 8; + if (!$cmp121) { + HEAP32[$msg >> 2] = STRING_TABLE.__str299 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $ret_0; + var $next_0_be = $next_2; + var $put_0_be = $put_0; + var $have_0_be = $have_2; + var $left_0_be = $left_0; + var $hold_0_be = $hold_2; + var $bits_0_be = $bits_2; + var $out_0_be = $out_0; + __label__ = 268; + break; + } + var $and128 = $hold_2 & 57344; + var $tobool129 = ($and128 | 0) == 0; + if ($tobool129) { + var $59 = HEAPU32[$18 >> 2]; + var $cmp135 = ($59 | 0) == 0; + if ($cmp135) { + var $60 = $hold_2; + } else { + var $shr138 = $hold_2 >>> 8; + var $and139 = $shr138 & 1; + var $text = $59 | 0; + HEAP32[$text >> 2] = $and139; + var $_pre887 = HEAP32[$17 >> 2]; + var $60 = $_pre887; + } + var $60; + var $and143 = $60 & 512; + var $tobool144 = ($and143 | 0) == 0; + if (!$tobool144) { + var $conv147 = $hold_2 & 255; + HEAP8[$arrayidx] = $conv147; + var $shr149 = $hold_2 >>> 8; + var $conv150 = $shr149 & 255; + HEAP8[$arrayidx40] = $conv150; + var $61 = HEAP32[$16 >> 2]; + var $call154 = _crc32($61, $arrayidx, 2); + HEAP32[$16 >> 2] = $call154; + } + HEAP32[$mode >> 2] = 2; + var $next_3 = $next_2; + var $have_3 = $have_2; + var $hold_3 = 0; + var $bits_3 = 0; + __label__ = 44; + break; + } + HEAP32[$msg >> 2] = STRING_TABLE.__str4101 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $ret_0; + var $next_0_be = $next_2; + var $put_0_be = $put_0; + var $have_0_be = $have_2; + var $left_0_be = $left_0; + var $hold_0_be = $hold_2; + var $bits_0_be = $bits_2; + var $out_0_be = $out_0; + __label__ = 268; + break; + } else if (($49 | 0) == 2) { + var $next_3 = $next_0; + var $have_3 = $have_0; + var $hold_3 = $hold_0; + var $bits_3 = $bits_0; + __label__ = 44; + } else if (($49 | 0) == 3) { + var $next_4 = $next_0; + var $have_4 = $have_0; + var $hold_4 = $hold_0; + var $bits_4 = $bits_0; + __label__ = 52; + } else if (($49 | 0) == 4) { + var $next_5 = $next_0; + var $have_5 = $have_0; + var $hold_5 = $hold_0; + var $bits_5 = $bits_0; + __label__ = 60; + } else if (($49 | 0) == 5) { + var $next_8 = $next_0; + var $have_8 = $have_0; + var $hold_8 = $hold_0; + var $bits_8 = $bits_0; + __label__ = 71; + } else if (($49 | 0) == 6) { + var $_pre888 = HEAP32[$17 >> 2]; + var $next_11 = $next_0; + var $have_11 = $have_0; + var $hold_9 = $hold_0; + var $bits_9 = $bits_0; + var $89 = $_pre888; + __label__ = 81; + break; + } else if (($49 | 0) == 7) { + var $next_13 = $next_0; + var $have_13 = $have_0; + var $hold_10 = $hold_0; + var $bits_10 = $bits_0; + __label__ = 94; + } else if (($49 | 0) == 8) { + var $next_15 = $next_0; + var $have_15 = $have_0; + var $hold_11 = $hold_0; + var $bits_11 = $bits_0; + __label__ = 107; + } else if (($49 | 0) == 9) { + var $next_18 = $next_0; + var $have_18 = $have_0; + var $hold_14 = $hold_0; + var $bits_14 = $bits_0; + while (1) { + var $bits_14; + var $hold_14; + var $have_18; + var $next_18; + var $cmp552 = $bits_14 >>> 0 < 32; + if (!$cmp552) { + break; + } + var $cmp556 = ($have_18 | 0) == 0; + if ($cmp556) { + var $ret_8 = $ret_0; + var $next_58 = $next_18; + var $have_58 = 0; + var $hold_54 = $hold_14; + var $bits_54 = $bits_14; + var $out_4 = $out_0; + break $_$12; + } + var $dec560 = $have_18 - 1 | 0; + var $incdec_ptr561 = $next_18 + 1 | 0; + var $114 = HEAPU8[$next_18]; + var $conv562 = $114 & 255; + var $shl563 = $conv562 << $bits_14; + var $add564 = $shl563 + $hold_14 | 0; + var $add565 = $bits_14 + 8 | 0; + var $next_18 = $incdec_ptr561; + var $have_18 = $dec560; + var $hold_14 = $add564; + var $bits_14 = $add565; + } + var $add581 = _llvm_bswap_i32($hold_14); + HEAP32[$16 >> 2] = $add581; + HEAP32[$adler >> 2] = $add581; + HEAP32[$mode >> 2] = 10; + var $next_19 = $next_18; + var $have_19 = $have_18; + var $hold_15 = 0; + var $bits_15 = 0; + __label__ = 120; + break; + } else if (($49 | 0) == 10) { + var $next_19 = $next_0; + var $have_19 = $have_0; + var $hold_15 = $hold_0; + var $bits_15 = $bits_0; + __label__ = 120; + } else if (($49 | 0) == 11) { + var $next_20 = $next_0; + var $have_20 = $have_0; + var $hold_16 = $hold_0; + var $bits_16 = $bits_0; + __label__ = 123; + } else if (($49 | 0) == 12) { + var $next_21 = $next_0; + var $have_21 = $have_0; + var $hold_17 = $hold_0; + var $bits_17 = $bits_0; + __label__ = 124; + } else if (($49 | 0) == 13) { + var $and681 = $bits_0 & 7; + var $shr682 = $hold_0 >>> ($and681 >>> 0); + var $sub684 = $bits_0 - $and681 | 0; + var $next_23 = $next_0; + var $have_23 = $have_0; + var $hold_19 = $shr682; + var $bits_19 = $sub684; + while (1) { + var $bits_19; + var $hold_19; + var $have_23; + var $next_23; + var $cmp689 = $bits_19 >>> 0 < 32; + if (!$cmp689) { + break; + } + var $cmp693 = ($have_23 | 0) == 0; + if ($cmp693) { + var $ret_8 = $ret_0; + var $next_58 = $next_23; + var $have_58 = 0; + var $hold_54 = $hold_19; + var $bits_54 = $bits_19; + var $out_4 = $out_0; + break $_$12; + } + var $dec697 = $have_23 - 1 | 0; + var $incdec_ptr698 = $next_23 + 1 | 0; + var $118 = HEAPU8[$next_23]; + var $conv699 = $118 & 255; + var $shl700 = $conv699 << $bits_19; + var $add701 = $shl700 + $hold_19 | 0; + var $add702 = $bits_19 + 8 | 0; + var $next_23 = $incdec_ptr698; + var $have_23 = $dec697; + var $hold_19 = $add701; + var $bits_19 = $add702; + } + var $and708 = $hold_19 & 65535; + var $shr709 = $hold_19 >>> 16; + var $xor = $shr709 ^ 65535; + var $cmp710 = ($and708 | 0) == ($xor | 0); + if (!$cmp710) { + HEAP32[$msg >> 2] = STRING_TABLE.__str7104 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $ret_0; + var $next_0_be = $next_23; + var $put_0_be = $put_0; + var $have_0_be = $have_23; + var $left_0_be = $left_0; + var $hold_0_be = $hold_19; + var $bits_0_be = $bits_19; + var $out_0_be = $out_0; + __label__ = 268; + break; + } + HEAP32[$21 >> 2] = $and708; + HEAP32[$mode >> 2] = 14; + if ($cmp660) { + var $ret_8 = $ret_0; + var $next_58 = $next_23; + var $have_58 = $have_23; + var $hold_54 = 0; + var $bits_54 = 0; + var $out_4 = $out_0; + break $_$12; + } + var $next_24 = $next_23; + var $have_24 = $have_23; + var $hold_20 = 0; + var $bits_20 = 0; + __label__ = 143; + break; + } else if (($49 | 0) == 14) { + var $next_24 = $next_0; + var $have_24 = $have_0; + var $hold_20 = $hold_0; + var $bits_20 = $bits_0; + __label__ = 143; + } else if (($49 | 0) == 15) { + var $next_25 = $next_0; + var $have_25 = $have_0; + var $hold_21 = $hold_0; + var $bits_21 = $bits_0; + __label__ = 144; + } else if (($49 | 0) == 16) { + var $next_26 = $next_0; + var $have_26 = $have_0; + var $hold_22 = $hold_0; + var $bits_22 = $bits_0; + while (1) { + var $bits_22; + var $hold_22; + var $have_26; + var $next_26; + var $cmp755 = $bits_22 >>> 0 < 14; + if (!$cmp755) { + break; + } + var $cmp759 = ($have_26 | 0) == 0; + if ($cmp759) { + var $ret_8 = $ret_0; + var $next_58 = $next_26; + var $have_58 = 0; + var $hold_54 = $hold_22; + var $bits_54 = $bits_22; + var $out_4 = $out_0; + break $_$12; + } + var $dec763 = $have_26 - 1 | 0; + var $incdec_ptr764 = $next_26 + 1 | 0; + var $121 = HEAPU8[$next_26]; + var $conv765 = $121 & 255; + var $shl766 = $conv765 << $bits_22; + var $add767 = $shl766 + $hold_22 | 0; + var $add768 = $bits_22 + 8 | 0; + var $next_26 = $incdec_ptr764; + var $have_26 = $dec763; + var $hold_22 = $add767; + var $bits_22 = $add768; + } + var $and774 = $hold_22 & 31; + var $add775 = $and774 + 257 | 0; + HEAP32[$37 >> 2] = $add775; + var $shr777 = $hold_22 >>> 5; + var $and781 = $shr777 & 31; + var $add782 = $and781 + 1 | 0; + HEAP32[$38 >> 2] = $add782; + var $shr784 = $hold_22 >>> 10; + var $and788 = $shr784 & 15; + var $add789 = $and788 + 4 | 0; + HEAP32[$39 >> 2] = $add789; + var $shr791 = $hold_22 >>> 14; + var $sub792 = $bits_22 - 14 | 0; + var $cmp796 = $add775 >>> 0 > 286; + var $cmp800 = $add782 >>> 0 > 30; + var $or_cond894 = $cmp796 | $cmp800; + if ($or_cond894) { + HEAP32[$msg >> 2] = STRING_TABLE.__str8105 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $ret_0; + var $next_0_be = $next_26; + var $put_0_be = $put_0; + var $have_0_be = $have_26; + var $left_0_be = $left_0; + var $hold_0_be = $shr791; + var $bits_0_be = $sub792; + var $out_0_be = $out_0; + __label__ = 268; + break; + } + HEAP32[$40 >> 2] = 0; + HEAP32[$mode >> 2] = 17; + var $next_27 = $next_26; + var $have_27 = $have_26; + var $hold_23 = $shr791; + var $bits_23 = $sub792; + __label__ = 154; + break; + } else if (($49 | 0) == 17) { + var $next_27 = $next_0; + var $have_27 = $have_0; + var $hold_23 = $hold_0; + var $bits_23 = $bits_0; + __label__ = 154; + } else if (($49 | 0) == 18) { + var $ret_1_ph = $ret_0; + var $next_29_ph = $next_0; + var $have_29_ph = $have_0; + var $hold_25_ph = $hold_0; + var $bits_25_ph = $bits_0; + __label__ = 164; + } else if (($49 | 0) == 19) { + var $ret_2 = $ret_0; + var $next_37 = $next_0; + var $have_37 = $have_0; + var $hold_33 = $hold_0; + var $bits_33 = $bits_0; + __label__ = 205; + } else if (($49 | 0) == 20) { + var $ret_3 = $ret_0; + var $next_38 = $next_0; + var $have_38 = $have_0; + var $hold_34 = $hold_0; + var $bits_34 = $bits_0; + __label__ = 206; + } else if (($49 | 0) == 21) { + var $_pre889 = HEAP32[$28 >> 2]; + var $ret_4 = $ret_0; + var $next_42 = $next_0; + var $have_42 = $have_0; + var $hold_38 = $hold_0; + var $bits_38 = $bits_0; + var $156 = $_pre889; + __label__ = 227; + break; + } else if (($49 | 0) == 22) { + var $ret_5_ph = $ret_0; + var $next_45_ph = $next_0; + var $have_45_ph = $have_0; + var $hold_41_ph = $hold_0; + var $bits_41_ph = $bits_0; + __label__ = 234; + } else if (($49 | 0) == 23) { + var $_pre891 = HEAP32[$28 >> 2]; + var $ret_6 = $ret_0; + var $next_48 = $next_0; + var $have_48 = $have_0; + var $hold_44 = $hold_0; + var $bits_44 = $bits_0; + var $167 = $_pre891; + __label__ = 248; + break; + } else if (($49 | 0) == 24) { + var $ret_7 = $ret_0; + var $next_51 = $next_0; + var $have_51 = $have_0; + var $hold_47 = $hold_0; + var $bits_47 = $bits_0; + __label__ = 254; + } else if (($49 | 0) == 25) { + var $cmp1615 = ($left_0 | 0) == 0; + if ($cmp1615) { + var $ret_8 = $ret_0; + var $next_58 = $next_0; + var $have_58 = $have_0; + var $hold_54 = $hold_0; + var $bits_54 = $bits_0; + var $out_4 = $out_0; + break $_$12; + } + var $186 = HEAP32[$21 >> 2]; + var $conv1620 = $186 & 255; + var $incdec_ptr1621 = $put_0 + 1 | 0; + HEAP8[$put_0] = $conv1620; + var $dec1622 = $left_0 - 1 | 0; + HEAP32[$mode >> 2] = 20; + var $ret_0_be = $ret_0; + var $next_0_be = $next_0; + var $put_0_be = $incdec_ptr1621; + var $have_0_be = $have_0; + var $left_0_be = $dec1622; + var $hold_0_be = $hold_0; + var $bits_0_be = $bits_0; + var $out_0_be = $out_0; + __label__ = 268; + break; + } else if (($49 | 0) == 26) { + var $187 = HEAP32[$15 >> 2]; + var $tobool1626 = ($187 | 0) == 0; + do { + if (!$tobool1626) { + var $next_52 = $next_0; + var $have_52 = $have_0; + var $hold_48 = $hold_0; + var $bits_48 = $bits_0; + while (1) { + var $bits_48; + var $hold_48; + var $have_52; + var $next_52; + var $cmp1630 = $bits_48 >>> 0 < 32; + if (!$cmp1630) { + break; + } + var $cmp1634 = ($have_52 | 0) == 0; + if ($cmp1634) { + var $ret_8 = $ret_0; + var $next_58 = $next_52; + var $have_58 = 0; + var $hold_54 = $hold_48; + var $bits_54 = $bits_48; + var $out_4 = $out_0; + break $_$12; + } + var $dec1638 = $have_52 - 1 | 0; + var $incdec_ptr1639 = $next_52 + 1 | 0; + var $188 = HEAPU8[$next_52]; + var $conv1640 = $188 & 255; + var $shl1641 = $conv1640 << $bits_48; + var $add1642 = $shl1641 + $hold_48 | 0; + var $add1643 = $bits_48 + 8 | 0; + var $next_52 = $incdec_ptr1639; + var $have_52 = $dec1638; + var $hold_48 = $add1642; + var $bits_48 = $add1643; + } + var $sub1649 = $out_0 - $left_0 | 0; + var $189 = HEAP32[$total_out >> 2]; + var $add1650 = $189 + $sub1649 | 0; + HEAP32[$total_out >> 2] = $add1650; + var $190 = HEAP32[$36 >> 2]; + var $add1651 = $190 + $sub1649 | 0; + HEAP32[$36 >> 2] = $add1651; + var $tobool1652 = ($out_0 | 0) == ($left_0 | 0); + if (!$tobool1652) { + var $191 = HEAP32[$17 >> 2]; + var $tobool1655 = ($191 | 0) == 0; + var $192 = HEAP32[$16 >> 2]; + var $idx_neg1658 = -$sub1649 | 0; + var $add_ptr1659 = $put_0 + $idx_neg1658 | 0; + if ($tobool1655) { + var $call1665 = _adler32($192, $add_ptr1659, $sub1649); + var $cond1667 = $call1665; + } else { + var $call1660 = _crc32($192, $add_ptr1659, $sub1649); + var $cond1667 = $call1660; + } + var $cond1667; + HEAP32[$16 >> 2] = $cond1667; + HEAP32[$adler >> 2] = $cond1667; + } + var $193 = HEAP32[$17 >> 2]; + var $tobool1672 = ($193 | 0) == 0; + if ($tobool1672) { + var $add1685 = _llvm_bswap_i32($hold_48); + var $cond1687 = $add1685; + } else { + var $cond1687 = $hold_48; + } + var $cond1687; + var $194 = HEAP32[$16 >> 2]; + var $cmp1689 = ($cond1687 | 0) == ($194 | 0); + if ($cmp1689) { + var $next_53 = $next_52; + var $have_53 = $have_52; + var $hold_49 = 0; + var $bits_49 = 0; + var $out_1 = $left_0; + break; + } + HEAP32[$msg >> 2] = STRING_TABLE.__str17114 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $ret_0; + var $next_0_be = $next_52; + var $put_0_be = $put_0; + var $have_0_be = $have_52; + var $left_0_be = $left_0; + var $hold_0_be = $hold_48; + var $bits_0_be = $bits_48; + var $out_0_be = $left_0; + __label__ = 268; + break $_$14; + } + var $next_53 = $next_0; + var $have_53 = $have_0; + var $hold_49 = $hold_0; + var $bits_49 = $bits_0; + var $out_1 = $out_0; + } while (0); + var $out_1; + var $bits_49; + var $hold_49; + var $have_53; + var $next_53; + HEAP32[$mode >> 2] = 27; + var $next_54 = $next_53; + var $have_54 = $have_53; + var $hold_50 = $hold_49; + var $bits_50 = $bits_49; + var $out_2 = $out_1; + __label__ = 286; + break; + } else if (($49 | 0) == 27) { + var $next_54 = $next_0; + var $have_54 = $have_0; + var $hold_50 = $hold_0; + var $bits_50 = $bits_0; + var $out_2 = $out_0; + __label__ = 286; + } else if (($49 | 0) == 28) { + var $ret_8 = 1; + var $next_58 = $next_0; + var $have_58 = $have_0; + var $hold_54 = $hold_0; + var $bits_54 = $bits_0; + var $out_4 = $out_0; + break $_$12; + } else if (($49 | 0) == 29) { + var $ret_8 = -3; + var $next_58 = $next_0; + var $have_58 = $have_0; + var $hold_54 = $hold_0; + var $bits_54 = $bits_0; + var $out_4 = $out_0; + break $_$12; + } else if (($49 | 0) == 30) { + var $retval_0 = -4; + break $_$2; + } else { var $retval_0 = -2; - } else { - var $state1 = $strm + 28 | 0; - var $0 = HEAPU32[$state1 >> 2]; - var $cmp2 = ($0 | 0) == 0; - if ($cmp2) { - var $retval_0 = -2; + break $_$2; + } + } while (0); + $_$106 : do { + if (__label__ == 44) { + while (1) { + var $bits_3; + var $hold_3; + var $have_3; + var $next_3; + var $cmp164 = $bits_3 >>> 0 < 32; + if (!$cmp164) { break; + } + var $cmp168 = ($have_3 | 0) == 0; + if ($cmp168) { + var $ret_8 = $ret_0; + var $next_58 = $next_3; + var $have_58 = 0; + var $hold_54 = $hold_3; + var $bits_54 = $bits_3; + var $out_4 = $out_0; + break $_$12; + } + var $dec172 = $have_3 - 1 | 0; + var $incdec_ptr173 = $next_3 + 1 | 0; + var $62 = HEAPU8[$next_3]; + var $conv174 = $62 & 255; + var $shl175 = $conv174 << $bits_3; + var $add176 = $shl175 + $hold_3 | 0; + var $add177 = $bits_3 + 8 | 0; + var $next_3 = $incdec_ptr173; + var $have_3 = $dec172; + var $hold_3 = $add176; + var $bits_3 = $add177; + } + var $63 = HEAP32[$18 >> 2]; + var $cmp182 = ($63 | 0) == 0; + if (!$cmp182) { + var $time = $63 + 4 | 0; + HEAP32[$time >> 2] = $hold_3; + } + var $64 = HEAP32[$17 >> 2]; + var $and188 = $64 & 512; + var $tobool189 = ($and188 | 0) == 0; + if (!$tobool189) { + var $conv192 = $hold_3 & 255; + HEAP8[$arrayidx] = $conv192; + var $shr194 = $hold_3 >>> 8; + var $conv195 = $shr194 & 255; + HEAP8[$arrayidx40] = $conv195; + var $shr197 = $hold_3 >>> 16; + var $conv198 = $shr197 & 255; + HEAP8[$arrayidx199] = $conv198; + var $shr200 = $hold_3 >>> 24; + var $conv201 = $shr200 & 255; + HEAP8[$arrayidx202] = $conv201; + var $65 = HEAP32[$16 >> 2]; + var $call205 = _crc32($65, $arrayidx, 4); + HEAP32[$16 >> 2] = $call205; } - var $next_out = $strm + 12 | 0; - var $1 = HEAP32[$next_out >> 2]; - var $cmp4 = ($1 | 0) == 0; - if ($cmp4) { - var $retval_0 = -2; + HEAP32[$mode >> 2] = 3; + var $next_4 = $next_3; + var $have_4 = $have_3; + var $hold_4 = 0; + var $bits_4 = 0; + __label__ = 52; + break; + } else if (__label__ == 120) { + var $bits_15; + var $hold_15; + var $have_19; + var $next_19; + var $115 = HEAP32[$22 >> 2]; + var $cmp589 = ($115 | 0) == 0; + if ($cmp589) { + HEAP32[$next_out >> 2] = $put_0; + HEAP32[$avail_out >> 2] = $left_0; + HEAP32[$next_in >> 2] = $next_19; + HEAP32[$avail_in15 >> 2] = $have_19; + HEAP32[$11 >> 2] = $hold_15; + HEAP32[$13 >> 2] = $bits_15; + var $retval_0 = 2; + break $_$2; + } + var $call602 = _adler32(0, 0, 0); + HEAP32[$16 >> 2] = $call602; + HEAP32[$adler >> 2] = $call602; + HEAP32[$mode >> 2] = 11; + var $next_20 = $next_19; + var $have_20 = $have_19; + var $hold_16 = $hold_15; + var $bits_16 = $bits_15; + __label__ = 123; + break; + } else if (__label__ == 143) { + var $bits_20; + var $hold_20; + var $have_24; + var $next_24; + HEAP32[$mode >> 2] = 15; + var $next_25 = $next_24; + var $have_25 = $have_24; + var $hold_21 = $hold_20; + var $bits_21 = $bits_20; + __label__ = 144; + break; + } else if (__label__ == 154) { + while (1) { + var $bits_23; + var $hold_23; + var $have_27; + var $next_27; + var $122 = HEAPU32[$40 >> 2]; + var $123 = HEAPU32[$39 >> 2]; + var $cmp812 = $122 >>> 0 < $123 >>> 0; + if (!$cmp812) { break; + } + var $next_28 = $next_27; + var $have_28 = $have_27; + var $hold_24 = $hold_23; + var $bits_24 = $bits_23; + while (1) { + var $bits_24; + var $hold_24; + var $have_28; + var $next_28; + var $cmp817 = $bits_24 >>> 0 < 3; + if (!$cmp817) { + break; + } + var $cmp821 = ($have_28 | 0) == 0; + if ($cmp821) { + var $ret_8 = $ret_0; + var $next_58 = $next_28; + var $have_58 = 0; + var $hold_54 = $hold_24; + var $bits_54 = $bits_24; + var $out_4 = $out_0; + break $_$12; + } + var $dec825 = $have_28 - 1 | 0; + var $incdec_ptr826 = $next_28 + 1 | 0; + var $124 = HEAPU8[$next_28]; + var $conv827 = $124 & 255; + var $shl828 = $conv827 << $bits_24; + var $add829 = $shl828 + $hold_24 | 0; + var $add830 = $bits_24 + 8 | 0; + var $next_28 = $incdec_ptr826; + var $have_28 = $dec825; + var $hold_24 = $add829; + var $bits_24 = $add830; + } + var $hold_24_tr = $hold_24 & 65535; + var $conv837 = $hold_24_tr & 7; + var $inc839 = $122 + 1 | 0; + HEAP32[$40 >> 2] = $inc839; + var $arrayidx840 = _inflate_order + ($122 << 1) | 0; + var $125 = HEAPU16[$arrayidx840 >> 1]; + var $idxprom = $125 & 65535; + var $arrayidx841 = $41 + ($idxprom << 1) | 0; + HEAP16[$arrayidx841 >> 1] = $conv837; + var $shr843 = $hold_24 >>> 3; + var $sub844 = $bits_24 - 3 | 0; + var $next_27 = $next_28; + var $have_27 = $have_28; + var $hold_23 = $shr843; + var $bits_23 = $sub844; + } + var $cmp850111 = $122 >>> 0 < 19; + $_$131 : do { + if ($cmp850111) { + var $126 = $122; + while (1) { + var $126; + var $inc854 = $126 + 1 | 0; + HEAP32[$40 >> 2] = $inc854; + var $arrayidx855 = _inflate_order + ($126 << 1) | 0; + var $127 = HEAPU16[$arrayidx855 >> 1]; + var $idxprom856 = $127 & 65535; + var $arrayidx858 = $41 + ($idxprom856 << 1) | 0; + HEAP16[$arrayidx858 >> 1] = 0; + var $_pr = HEAPU32[$40 >> 2]; + var $cmp850 = $_pr >>> 0 < 19; + if (!$cmp850) { + break $_$131; + } + var $126 = $_pr; + } + } + } while (0); + HEAP32[$43 >> 2] = $arraydecay860_c; + HEAP32[$44 >> 2] = $arraydecay860_c; + HEAP32[$26 >> 2] = 7; + var $call868 = _inflate_table(0, $arraydecay864, 19, $42, $26, $arraydecay867); + var $tobool869 = ($call868 | 0) == 0; + if ($tobool869) { + HEAP32[$40 >> 2] = 0; + HEAP32[$mode >> 2] = 18; + var $ret_1_ph = 0; + var $next_29_ph = $next_27; + var $have_29_ph = $have_27; + var $hold_25_ph = $hold_23; + var $bits_25_ph = $bits_23; + __label__ = 164; + break; } - var $next_in = $strm | 0; - var $2 = HEAP32[$next_in >> 2]; - var $cmp6 = ($2 | 0) == 0; - if ($cmp6) { - var $avail_in = $strm + 4 | 0; - var $3 = HEAP32[$avail_in >> 2]; - var $cmp7 = ($3 | 0) == 0; - if (!$cmp7) { - var $retval_0 = -2; + HEAP32[$msg >> 2] = STRING_TABLE.__str9106 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $call868; + var $next_0_be = $next_27; + var $put_0_be = $put_0; + var $have_0_be = $have_27; + var $left_0_be = $left_0; + var $hold_0_be = $hold_23; + var $bits_0_be = $bits_23; + var $out_0_be = $out_0; + __label__ = 268; + break; + } else if (__label__ == 286) { + var $out_2; + var $bits_50; + var $hold_50; + var $have_54; + var $next_54; + var $195 = HEAP32[$15 >> 2]; + var $tobool1702 = ($195 | 0) == 0; + do { + if (!$tobool1702) { + var $196 = HEAP32[$17 >> 2]; + var $tobool1705 = ($196 | 0) == 0; + if ($tobool1705) { + var $next_56 = $next_54; + var $have_56 = $have_54; + var $hold_52 = $hold_50; + var $bits_52 = $bits_50; + break; + } + var $next_55 = $next_54; + var $have_55 = $have_54; + var $hold_51 = $hold_50; + var $bits_51 = $bits_50; + while (1) { + var $bits_51; + var $hold_51; + var $have_55; + var $next_55; + var $cmp1709 = $bits_51 >>> 0 < 32; + if (!$cmp1709) { break; + } + var $cmp1713 = ($have_55 | 0) == 0; + if ($cmp1713) { + var $ret_8 = $ret_0; + var $next_58 = $next_55; + var $have_58 = 0; + var $hold_54 = $hold_51; + var $bits_54 = $bits_51; + var $out_4 = $out_2; + break $_$12; + } + var $dec1717 = $have_55 - 1 | 0; + var $incdec_ptr1718 = $next_55 + 1 | 0; + var $197 = HEAPU8[$next_55]; + var $conv1719 = $197 & 255; + var $shl1720 = $conv1719 << $bits_51; + var $add1721 = $shl1720 + $hold_51 | 0; + var $add1722 = $bits_51 + 8 | 0; + var $next_55 = $incdec_ptr1718; + var $have_55 = $dec1717; + var $hold_51 = $add1721; + var $bits_51 = $add1722; + } + var $198 = HEAP32[$36 >> 2]; + var $cmp1729 = ($hold_51 | 0) == ($198 | 0); + if ($cmp1729) { + var $next_56 = $next_55; + var $have_56 = $have_55; + var $hold_52 = 0; + var $bits_52 = 0; + break; } + HEAP32[$msg >> 2] = STRING_TABLE.__str18115 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $ret_0; + var $next_0_be = $next_55; + var $put_0_be = $put_0; + var $have_0_be = $have_55; + var $left_0_be = $left_0; + var $hold_0_be = $hold_51; + var $bits_0_be = $bits_51; + var $out_0_be = $out_2; + __label__ = 268; + break $_$106; + } + var $next_56 = $next_54; + var $have_56 = $have_54; + var $hold_52 = $hold_50; + var $bits_52 = $bits_50; + } while (0); + var $bits_52; + var $hold_52; + var $have_56; + var $next_56; + HEAP32[$mode >> 2] = 28; + var $ret_8 = 1; + var $next_58 = $next_56; + var $have_58 = $have_56; + var $hold_54 = $hold_52; + var $bits_54 = $bits_52; + var $out_4 = $out_2; + break $_$12; + } + } while (0); + $_$148 : do { + if (__label__ == 52) { + while (1) { + var $bits_4; + var $hold_4; + var $have_4; + var $next_4; + var $cmp215 = $bits_4 >>> 0 < 16; + if (!$cmp215) { + break; + } + var $cmp219 = ($have_4 | 0) == 0; + if ($cmp219) { + var $ret_8 = $ret_0; + var $next_58 = $next_4; + var $have_58 = 0; + var $hold_54 = $hold_4; + var $bits_54 = $bits_4; + var $out_4 = $out_0; + break $_$12; + } + var $dec223 = $have_4 - 1 | 0; + var $incdec_ptr224 = $next_4 + 1 | 0; + var $66 = HEAPU8[$next_4]; + var $conv225 = $66 & 255; + var $shl226 = $conv225 << $bits_4; + var $add227 = $shl226 + $hold_4 | 0; + var $add228 = $bits_4 + 8 | 0; + var $next_4 = $incdec_ptr224; + var $have_4 = $dec223; + var $hold_4 = $add227; + var $bits_4 = $add228; } - var $4 = $0; - var $mode = $0 | 0; - var $5 = HEAP32[$mode >> 2]; - var $cmp9 = ($5 | 0) == 11; - if ($cmp9) { - HEAP32[$mode >> 2] = 12; - var $_pre = HEAP32[$next_out >> 2]; - var $_pre882 = HEAP32[$next_in >> 2]; - var $8 = $_pre; - var $7 = $_pre882; - var $6 = 12; - } else { - var $8 = $1; - var $7 = $2; - var $6 = $5; + var $67 = HEAP32[$18 >> 2]; + var $cmp233 = ($67 | 0) == 0; + if (!$cmp233) { + var $and236 = $hold_4 & 255; + var $xflags = $67 + 8 | 0; + HEAP32[$xflags >> 2] = $and236; + var $shr238 = $hold_4 >>> 8; + var $68 = HEAP32[$18 >> 2]; + var $os = $68 + 12 | 0; + HEAP32[$os >> 2] = $shr238; } - var $6; - var $7; - var $8; - var $avail_out = $strm + 16 | 0; - var $9 = HEAP32[$avail_out >> 2]; - var $avail_in15 = $strm + 4 | 0; - var $10 = HEAPU32[$avail_in15 >> 2]; - var $11 = $0 + 56 | 0; - var $12 = HEAP32[$11 >> 2]; - var $13 = $0 + 60 | 0; - var $14 = HEAP32[$13 >> 2]; - var $15 = $0 + 8 | 0; - var $16 = $0 + 24 | 0; - var $arrayidx = $hbuf | 0; - var $arrayidx40 = $hbuf + 1 | 0; - var $17 = $0 + 16 | 0; - var $head = $0 + 32 | 0; - var $18 = $head; - var $msg = $strm + 24 | 0; - var $19 = $0 + 36 | 0; - var $20 = $0 + 20 | 0; - var $adler = $strm + 48 | 0; - var $21 = $0 + 64 | 0; - var $22 = $0 + 12 | 0; - var $flush_off = $flush - 5 | 0; - var $23 = $flush_off >>> 0 < 2; - var $24 = $0 + 4 | 0; - var $cmp660 = ($flush | 0) == 6; - var $25 = $0 + 7108 | 0; - var $26 = $0 + 84 | 0; - var $lencode1215 = $0 + 76 | 0; - var $27 = $lencode1215; - var $28 = $0 + 72 | 0; - var $29 = $0 + 7112 | 0; - var $30 = $0 + 68 | 0; - var $31 = $0 + 44 | 0; - var $32 = $0 + 7104 | 0; - var $33 = $0 + 48 | 0; - var $window = $0 + 52 | 0; - var $34 = $window; - var $35 = $0 + 40 | 0; - var $total_out = $strm + 20 | 0; - var $36 = $0 + 28 | 0; - var $arrayidx199 = $hbuf + 2 | 0; - var $arrayidx202 = $hbuf + 3 | 0; - var $37 = $0 + 96 | 0; - var $38 = $0 + 100 | 0; - var $39 = $0 + 92 | 0; - var $40 = $0 + 104 | 0; - var $lens = $0 + 112 | 0; - var $41 = $lens; - var $codes = $0 + 1328 | 0; - var $next861 = $0 + 108 | 0; - var $42 = $next861; - var $43 = $next861 | 0; - var $arraydecay860_c = $codes; - var $44 = $0 + 76 | 0; - var $arraydecay864 = $lens; - var $work = $0 + 752 | 0; - var $arraydecay867 = $work; - var $arrayidx1128 = $0 + 624 | 0; - var $45 = $arrayidx1128; - var $46 = $0 + 80 | 0; - var $47 = $0 + 88 | 0; - var $distcode1395 = $0 + 80 | 0; - var $48 = $distcode1395; - var $ret_0 = 0; - var $next_0 = $7; - var $put_0 = $8; - var $have_0 = $10; - var $left_0 = $9; - var $hold_0 = $12; - var $bits_0 = $14; - var $out_0 = $9; - var $49 = $6; - $_$12 : while (1) { - var $49; - var $out_0; - var $bits_0; - var $hold_0; - var $left_0; - var $have_0; - var $put_0; - var $next_0; - var $ret_0; - $_$14 : do { - if (($49 | 0) == 0) { - var $50 = HEAPU32[$15 >> 2]; - var $cmp19 = ($50 | 0) == 0; - if ($cmp19) { - HEAP32[$mode >> 2] = 12; - var $ret_0_be = $ret_0; - var $next_0_be = $next_0; - var $put_0_be = $put_0; - var $have_0_be = $have_0; - var $left_0_be = $left_0; - var $hold_0_be = $hold_0; - var $bits_0_be = $bits_0; - var $out_0_be = $out_0; - __label__ = 268; - break; - } - var $next_1 = $next_0; - var $have_1 = $have_0; - var $hold_1 = $hold_0; - var $bits_1 = $bits_0; - while (1) { - var $bits_1; - var $hold_1; - var $have_1; - var $next_1; - var $cmp24 = $bits_1 >>> 0 < 16; - if (!$cmp24) { - break; - } - var $cmp26 = ($have_1 | 0) == 0; - if ($cmp26) { - var $ret_8 = $ret_0; - var $next_58 = $next_1; - var $have_58 = 0; - var $hold_54 = $hold_1; - var $bits_54 = $bits_1; - var $out_4 = $out_0; - break $_$12; - } - // XXX first chunk with a difference (no impact) - var $dec = $have_1 - 1 | 0; - var $incdec_ptr = $next_1 + 1 | 0; - var $51 = HEAPU8[$next_1]; - var $conv = $51 & 255; - var $shl = $conv << $bits_1; - var $add = $shl + $hold_1 | 0; - var $add29 = $bits_1 + 8 | 0; - var $next_1 = $incdec_ptr; - var $have_1 = $dec; - var $hold_1 = $add; - var $bits_1 = $add29; - } - var $and = $50 & 2; - var $tobool = ($and | 0) != 0; - var $cmp34 = ($hold_1 | 0) == 35615; - var $or_cond = $tobool & $cmp34; - if ($or_cond) { - var $call = _crc32(0, 0, 0); - HEAP32[$16 >> 2] = $call; - HEAP8[$arrayidx] = 31; - HEAP8[$arrayidx40] = -117; - var $52 = HEAP32[$16 >> 2]; - var $call42 = _crc32($52, $arrayidx, 2); - HEAP32[$16 >> 2] = $call42; - HEAP32[$mode >> 2] = 1; - var $ret_0_be = $ret_0; - var $next_0_be = $next_1; - var $put_0_be = $put_0; - var $have_0_be = $have_1; - var $left_0_be = $left_0; - var $hold_0_be = 0; - var $bits_0_be = 0; - var $out_0_be = $out_0; - __label__ = 268; - break; - } - HEAP32[$17 >> 2] = 0; - var $53 = HEAP32[$18 >> 2]; - var $cmp49 = ($53 | 0) == 0; - if ($cmp49) { - var $54 = $50; - } else { - var $done = $53 + 48 | 0; - HEAP32[$done >> 2] = -1; - var $_pre884 = HEAP32[$15 >> 2]; - var $54 = $_pre884; - } - var $54; - var $and55 = $54 & 1; - var $tobool56 = ($and55 | 0) == 0; - do { - if (!$tobool56) { - var $and58 = $hold_1 << 8; - var $shl59 = $and58 & 65280; - var $shr60 = $hold_1 >>> 8; - var $add61 = $shl59 + $shr60 | 0; - var $rem = ($add61 >>> 0) % 31; - var $tobool62 = ($rem | 0) == 0; - if (!$tobool62) { - break; - } - var $and66 = $hold_1 & 15; - var $cmp67 = ($and66 | 0) == 8; - if ($cmp67) { - var $shr74 = $hold_1 >>> 4; - var $sub = $bits_1 - 4 | 0; - var $and76 = $shr74 & 15; - var $add77 = $and76 + 8 | 0; - var $55 = HEAPU32[$19 >> 2]; - var $cmp78 = ($55 | 0) == 0; - do { - if (!$cmp78) { - var $cmp83 = $add77 >>> 0 > $55 >>> 0; - if (!$cmp83) { - break; - } - HEAP32[$msg >> 2] = STRING_TABLE.__str3100 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $ret_0; - var $next_0_be = $next_1; - var $put_0_be = $put_0; - var $have_0_be = $have_1; - var $left_0_be = $left_0; - var $hold_0_be = $shr74; - var $bits_0_be = $sub; - var $out_0_be = $out_0; - __label__ = 268; - break $_$14; - } - HEAP32[$19 >> 2] = $add77; - } while (0); - var $shl90 = 1 << $add77; - HEAP32[$20 >> 2] = $shl90; - var $call91 = _adler32(0, 0, 0); - HEAP32[$16 >> 2] = $call91; - HEAP32[$adler >> 2] = $call91; - var $and93 = $hold_1 >>> 12; - var $56 = $and93 & 2; - var $57 = $56 ^ 11; - HEAP32[$mode >> 2] = $57; - var $ret_0_be = $ret_0; - var $next_0_be = $next_1; - var $put_0_be = $put_0; - var $have_0_be = $have_1; - var $left_0_be = $left_0; - var $hold_0_be = 0; - var $bits_0_be = 0; - var $out_0_be = $out_0; - __label__ = 268; - break $_$14; - } - HEAP32[$msg >> 2] = STRING_TABLE.__str299 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $ret_0; - var $next_0_be = $next_1; - var $put_0_be = $put_0; - var $have_0_be = $have_1; - var $left_0_be = $left_0; - var $hold_0_be = $hold_1; - var $bits_0_be = $bits_1; - var $out_0_be = $out_0; - __label__ = 268; - break $_$14; - } - } while (0); - HEAP32[$msg >> 2] = STRING_TABLE.__str198 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $ret_0; - var $next_0_be = $next_1; - var $put_0_be = $put_0; - var $have_0_be = $have_1; - var $left_0_be = $left_0; - var $hold_0_be = $hold_1; - var $bits_0_be = $bits_1; - var $out_0_be = $out_0; - __label__ = 268; - break; - } else if (($49 | 0) == 1) { - var $next_2 = $next_0; - var $have_2 = $have_0; - var $hold_2 = $hold_0; - var $bits_2 = $bits_0; - while (1) { - var $bits_2; - var $hold_2; - var $have_2; - var $next_2; - var $cmp101 = $bits_2 >>> 0 < 16; - if (!$cmp101) { - break; - } - var $cmp105 = ($have_2 | 0) == 0; - if ($cmp105) { - var $ret_8 = $ret_0; - var $next_58 = $next_2; - var $have_58 = 0; - var $hold_54 = $hold_2; - var $bits_54 = $bits_2; - var $out_4 = $out_0; - break $_$12; - } - var $dec109 = $have_2 - 1 | 0; - var $incdec_ptr110 = $next_2 + 1 | 0; - var $58 = HEAPU8[$next_2]; - var $conv111 = $58 & 255; - var $shl112 = $conv111 << $bits_2; - var $add113 = $shl112 + $hold_2 | 0; - var $add114 = $bits_2 + 8 | 0; - var $next_2 = $incdec_ptr110; - var $have_2 = $dec109; - var $hold_2 = $add113; - var $bits_2 = $add114; - } - HEAP32[$17 >> 2] = $hold_2; - var $and120 = $hold_2 & 255; - var $cmp121 = ($and120 | 0) == 8; - if (!$cmp121) { - HEAP32[$msg >> 2] = STRING_TABLE.__str299 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $ret_0; - var $next_0_be = $next_2; - var $put_0_be = $put_0; - var $have_0_be = $have_2; - var $left_0_be = $left_0; - var $hold_0_be = $hold_2; - var $bits_0_be = $bits_2; - var $out_0_be = $out_0; - __label__ = 268; - break; - } - var $and128 = $hold_2 & 57344; - var $tobool129 = ($and128 | 0) == 0; - if ($tobool129) { - var $59 = HEAPU32[$18 >> 2]; - var $cmp135 = ($59 | 0) == 0; - if ($cmp135) { - var $60 = $hold_2; - } else { - var $shr138 = $hold_2 >>> 8; - var $and139 = $shr138 & 1; - var $text = $59 | 0; - HEAP32[$text >> 2] = $and139; - var $_pre887 = HEAP32[$17 >> 2]; - var $60 = $_pre887; - } - var $60; - var $and143 = $60 & 512; - var $tobool144 = ($and143 | 0) == 0; - if (!$tobool144) { - var $conv147 = $hold_2 & 255; - HEAP8[$arrayidx] = $conv147; - var $shr149 = $hold_2 >>> 8; - var $conv150 = $shr149 & 255; - HEAP8[$arrayidx40] = $conv150; - var $61 = HEAP32[$16 >> 2]; - var $call154 = _crc32($61, $arrayidx, 2); - HEAP32[$16 >> 2] = $call154; - } - HEAP32[$mode >> 2] = 2; - var $next_3 = $next_2; - var $have_3 = $have_2; - var $hold_3 = 0; - var $bits_3 = 0; - __label__ = 44; - break; - } - HEAP32[$msg >> 2] = STRING_TABLE.__str4101 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $ret_0; - var $next_0_be = $next_2; - var $put_0_be = $put_0; - var $have_0_be = $have_2; - var $left_0_be = $left_0; - var $hold_0_be = $hold_2; - var $bits_0_be = $bits_2; - var $out_0_be = $out_0; - __label__ = 268; - break; - } else if (($49 | 0) == 2) { - var $next_3 = $next_0; - var $have_3 = $have_0; - var $hold_3 = $hold_0; - var $bits_3 = $bits_0; - __label__ = 44; - } else if (($49 | 0) == 3) { - var $next_4 = $next_0; - var $have_4 = $have_0; - var $hold_4 = $hold_0; - var $bits_4 = $bits_0; - __label__ = 52; - } else if (($49 | 0) == 4) { - var $next_5 = $next_0; - var $have_5 = $have_0; - var $hold_5 = $hold_0; - var $bits_5 = $bits_0; - __label__ = 60; - } else if (($49 | 0) == 5) { - var $next_8 = $next_0; - var $have_8 = $have_0; - var $hold_8 = $hold_0; - var $bits_8 = $bits_0; - __label__ = 71; - } else if (($49 | 0) == 6) { - var $_pre888 = HEAP32[$17 >> 2]; - var $next_11 = $next_0; - var $have_11 = $have_0; - var $hold_9 = $hold_0; - var $bits_9 = $bits_0; - var $89 = $_pre888; - __label__ = 81; - break; - } else if (($49 | 0) == 7) { - var $next_13 = $next_0; - var $have_13 = $have_0; - var $hold_10 = $hold_0; - var $bits_10 = $bits_0; - __label__ = 94; - } else if (($49 | 0) == 8) { - var $next_15 = $next_0; - var $have_15 = $have_0; - var $hold_11 = $hold_0; - var $bits_11 = $bits_0; - __label__ = 107; - } else if (($49 | 0) == 9) { - var $next_18 = $next_0; - var $have_18 = $have_0; - var $hold_14 = $hold_0; - var $bits_14 = $bits_0; - while (1) { - var $bits_14; - var $hold_14; - var $have_18; - var $next_18; - var $cmp552 = $bits_14 >>> 0 < 32; - if (!$cmp552) { - break; - } - var $cmp556 = ($have_18 | 0) == 0; - if ($cmp556) { - var $ret_8 = $ret_0; - var $next_58 = $next_18; - var $have_58 = 0; - var $hold_54 = $hold_14; - var $bits_54 = $bits_14; - var $out_4 = $out_0; - break $_$12; - } - var $dec560 = $have_18 - 1 | 0; - var $incdec_ptr561 = $next_18 + 1 | 0; - var $114 = HEAPU8[$next_18]; - var $conv562 = $114 & 255; - var $shl563 = $conv562 << $bits_14; - var $add564 = $shl563 + $hold_14 | 0; - var $add565 = $bits_14 + 8 | 0; - var $next_18 = $incdec_ptr561; - var $have_18 = $dec560; - var $hold_14 = $add564; - var $bits_14 = $add565; - } - var $add581 = _llvm_bswap_i32($hold_14); - HEAP32[$16 >> 2] = $add581; - HEAP32[$adler >> 2] = $add581; - HEAP32[$mode >> 2] = 10; - var $next_19 = $next_18; - var $have_19 = $have_18; - var $hold_15 = 0; - var $bits_15 = 0; - __label__ = 120; - break; - } else if (($49 | 0) == 10) { - var $next_19 = $next_0; - var $have_19 = $have_0; - var $hold_15 = $hold_0; - var $bits_15 = $bits_0; - __label__ = 120; - } else if (($49 | 0) == 11) { - var $next_20 = $next_0; - var $have_20 = $have_0; - var $hold_16 = $hold_0; - var $bits_16 = $bits_0; - __label__ = 123; - } else if (($49 | 0) == 12) { - var $next_21 = $next_0; - var $have_21 = $have_0; - var $hold_17 = $hold_0; - var $bits_17 = $bits_0; - __label__ = 124; - } else if (($49 | 0) == 13) { - var $and681 = $bits_0 & 7; - var $shr682 = $hold_0 >>> ($and681 >>> 0); - var $sub684 = $bits_0 - $and681 | 0; - var $next_23 = $next_0; - var $have_23 = $have_0; - var $hold_19 = $shr682; - var $bits_19 = $sub684; - while (1) { - var $bits_19; - var $hold_19; - var $have_23; - var $next_23; - var $cmp689 = $bits_19 >>> 0 < 32; - if (!$cmp689) { - break; - } - var $cmp693 = ($have_23 | 0) == 0; - if ($cmp693) { - var $ret_8 = $ret_0; - var $next_58 = $next_23; - var $have_58 = 0; - var $hold_54 = $hold_19; - var $bits_54 = $bits_19; - var $out_4 = $out_0; - break $_$12; - } - var $dec697 = $have_23 - 1 | 0; - var $incdec_ptr698 = $next_23 + 1 | 0; - var $118 = HEAPU8[$next_23]; - var $conv699 = $118 & 255; - var $shl700 = $conv699 << $bits_19; - var $add701 = $shl700 + $hold_19 | 0; - var $add702 = $bits_19 + 8 | 0; - var $next_23 = $incdec_ptr698; - var $have_23 = $dec697; - var $hold_19 = $add701; - var $bits_19 = $add702; - } - var $and708 = $hold_19 & 65535; - var $shr709 = $hold_19 >>> 16; - var $xor = $shr709 ^ 65535; - var $cmp710 = ($and708 | 0) == ($xor | 0); - if (!$cmp710) { - HEAP32[$msg >> 2] = STRING_TABLE.__str7104 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $ret_0; - var $next_0_be = $next_23; - var $put_0_be = $put_0; - var $have_0_be = $have_23; - var $left_0_be = $left_0; - var $hold_0_be = $hold_19; - var $bits_0_be = $bits_19; - var $out_0_be = $out_0; - __label__ = 268; - break; - } - HEAP32[$21 >> 2] = $and708; - HEAP32[$mode >> 2] = 14; - if ($cmp660) { - var $ret_8 = $ret_0; - var $next_58 = $next_23; - var $have_58 = $have_23; - var $hold_54 = 0; - var $bits_54 = 0; - var $out_4 = $out_0; - break $_$12; - } - var $next_24 = $next_23; - var $have_24 = $have_23; - var $hold_20 = 0; - var $bits_20 = 0; - __label__ = 143; - break; - } else if (($49 | 0) == 14) { - var $next_24 = $next_0; - var $have_24 = $have_0; - var $hold_20 = $hold_0; - var $bits_20 = $bits_0; - __label__ = 143; - } else if (($49 | 0) == 15) { - var $next_25 = $next_0; - var $have_25 = $have_0; - var $hold_21 = $hold_0; - var $bits_21 = $bits_0; - __label__ = 144; - } else if (($49 | 0) == 16) { - var $next_26 = $next_0; - var $have_26 = $have_0; - var $hold_22 = $hold_0; - var $bits_22 = $bits_0; - while (1) { - var $bits_22; - var $hold_22; - var $have_26; - var $next_26; - var $cmp755 = $bits_22 >>> 0 < 14; - if (!$cmp755) { - break; - } - var $cmp759 = ($have_26 | 0) == 0; - if ($cmp759) { - var $ret_8 = $ret_0; - var $next_58 = $next_26; - var $have_58 = 0; - var $hold_54 = $hold_22; - var $bits_54 = $bits_22; - var $out_4 = $out_0; - break $_$12; - } - var $dec763 = $have_26 - 1 | 0; - var $incdec_ptr764 = $next_26 + 1 | 0; - var $121 = HEAPU8[$next_26]; - var $conv765 = $121 & 255; - var $shl766 = $conv765 << $bits_22; - var $add767 = $shl766 + $hold_22 | 0; - var $add768 = $bits_22 + 8 | 0; - var $next_26 = $incdec_ptr764; - var $have_26 = $dec763; - var $hold_22 = $add767; - var $bits_22 = $add768; - } - var $and774 = $hold_22 & 31; - var $add775 = $and774 + 257 | 0; - HEAP32[$37 >> 2] = $add775; - var $shr777 = $hold_22 >>> 5; - var $and781 = $shr777 & 31; - var $add782 = $and781 + 1 | 0; - HEAP32[$38 >> 2] = $add782; - var $shr784 = $hold_22 >>> 10; - var $and788 = $shr784 & 15; - var $add789 = $and788 + 4 | 0; - HEAP32[$39 >> 2] = $add789; - var $shr791 = $hold_22 >>> 14; - var $sub792 = $bits_22 - 14 | 0; - var $cmp796 = $add775 >>> 0 > 286; - var $cmp800 = $add782 >>> 0 > 30; - var $or_cond894 = $cmp796 | $cmp800; - if ($or_cond894) { - HEAP32[$msg >> 2] = STRING_TABLE.__str8105 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $ret_0; - var $next_0_be = $next_26; - var $put_0_be = $put_0; - var $have_0_be = $have_26; - var $left_0_be = $left_0; - var $hold_0_be = $shr791; - var $bits_0_be = $sub792; - var $out_0_be = $out_0; - __label__ = 268; - break; - } - HEAP32[$40 >> 2] = 0; - HEAP32[$mode >> 2] = 17; - var $next_27 = $next_26; - var $have_27 = $have_26; - var $hold_23 = $shr791; - var $bits_23 = $sub792; - __label__ = 154; - break; - } else if (($49 | 0) == 17) { - var $next_27 = $next_0; - var $have_27 = $have_0; - var $hold_23 = $hold_0; - var $bits_23 = $bits_0; - __label__ = 154; - } else if (($49 | 0) == 18) { - var $ret_1_ph = $ret_0; - var $next_29_ph = $next_0; - var $have_29_ph = $have_0; - var $hold_25_ph = $hold_0; - var $bits_25_ph = $bits_0; - __label__ = 164; - } else if (($49 | 0) == 19) { - var $ret_2 = $ret_0; - var $next_37 = $next_0; - var $have_37 = $have_0; - var $hold_33 = $hold_0; - var $bits_33 = $bits_0; - __label__ = 205; - } else if (($49 | 0) == 20) { - var $ret_3 = $ret_0; - var $next_38 = $next_0; - var $have_38 = $have_0; - var $hold_34 = $hold_0; - var $bits_34 = $bits_0; - __label__ = 206; - } else if (($49 | 0) == 21) { - var $_pre889 = HEAP32[$28 >> 2]; - var $ret_4 = $ret_0; - var $next_42 = $next_0; - var $have_42 = $have_0; - var $hold_38 = $hold_0; - var $bits_38 = $bits_0; - var $156 = $_pre889; - __label__ = 227; - break; - } else if (($49 | 0) == 22) { - var $ret_5_ph = $ret_0; - var $next_45_ph = $next_0; - var $have_45_ph = $have_0; - var $hold_41_ph = $hold_0; - var $bits_41_ph = $bits_0; - __label__ = 234; - } else if (($49 | 0) == 23) { - var $_pre891 = HEAP32[$28 >> 2]; - var $ret_6 = $ret_0; - var $next_48 = $next_0; - var $have_48 = $have_0; - var $hold_44 = $hold_0; - var $bits_44 = $bits_0; - var $167 = $_pre891; - __label__ = 248; - break; - } else if (($49 | 0) == 24) { - var $ret_7 = $ret_0; - var $next_51 = $next_0; - var $have_51 = $have_0; - var $hold_47 = $hold_0; - var $bits_47 = $bits_0; - __label__ = 254; - } else if (($49 | 0) == 25) { - var $cmp1615 = ($left_0 | 0) == 0; - if ($cmp1615) { - var $ret_8 = $ret_0; - var $next_58 = $next_0; - var $have_58 = $have_0; - var $hold_54 = $hold_0; - var $bits_54 = $bits_0; - var $out_4 = $out_0; - break $_$12; - } - var $186 = HEAP32[$21 >> 2]; - var $conv1620 = $186 & 255; - var $incdec_ptr1621 = $put_0 + 1 | 0; - HEAP8[$put_0] = $conv1620; - var $dec1622 = $left_0 - 1 | 0; - HEAP32[$mode >> 2] = 20; - var $ret_0_be = $ret_0; - var $next_0_be = $next_0; - var $put_0_be = $incdec_ptr1621; - var $have_0_be = $have_0; - var $left_0_be = $dec1622; - var $hold_0_be = $hold_0; - var $bits_0_be = $bits_0; - var $out_0_be = $out_0; - __label__ = 268; + var $69 = HEAP32[$17 >> 2]; + var $and242 = $69 & 512; + var $tobool243 = ($and242 | 0) == 0; + if (!$tobool243) { + var $conv246 = $hold_4 & 255; + HEAP8[$arrayidx] = $conv246; + var $shr248 = $hold_4 >>> 8; + var $conv249 = $shr248 & 255; + HEAP8[$arrayidx40] = $conv249; + var $70 = HEAP32[$16 >> 2]; + var $call253 = _crc32($70, $arrayidx, 2); + HEAP32[$16 >> 2] = $call253; + } + HEAP32[$mode >> 2] = 4; + var $next_5 = $next_4; + var $have_5 = $have_4; + var $hold_5 = 0; + var $bits_5 = 0; + __label__ = 60; + break; + } else if (__label__ == 123) { + var $bits_16; + var $hold_16; + var $have_20; + var $next_20; + if ($23) { + var $ret_8 = $ret_0; + var $next_58 = $next_20; + var $have_58 = $have_20; + var $hold_54 = $hold_16; + var $bits_54 = $bits_16; + var $out_4 = $out_0; + break $_$12; + } + var $next_21 = $next_20; + var $have_21 = $have_20; + var $hold_17 = $hold_16; + var $bits_17 = $bits_16; + __label__ = 124; + break; + } else if (__label__ == 144) { + var $bits_21; + var $hold_21; + var $have_25; + var $next_25; + var $119 = HEAPU32[$21 >> 2]; + var $tobool730 = ($119 | 0) == 0; + if ($tobool730) { + HEAP32[$mode >> 2] = 11; + var $ret_0_be = $ret_0; + var $next_0_be = $next_25; + var $put_0_be = $put_0; + var $have_0_be = $have_25; + var $left_0_be = $left_0; + var $hold_0_be = $hold_21; + var $bits_0_be = $bits_21; + var $out_0_be = $out_0; + __label__ = 268; + break; + } + var $cmp732 = $119 >>> 0 > $have_25 >>> 0; + var $copy_3 = $cmp732 ? $have_25 : $119; + var $cmp736 = $copy_3 >>> 0 > $left_0 >>> 0; + var $copy_4 = $cmp736 ? $left_0 : $copy_3; + var $cmp740 = ($copy_4 | 0) == 0; + if ($cmp740) { + var $ret_8 = $ret_0; + var $next_58 = $next_25; + var $have_58 = $have_25; + var $hold_54 = $hold_21; + var $bits_54 = $bits_21; + var $out_4 = $out_0; + break $_$12; + } + _memcpy($put_0, $next_25, $copy_4, 1); + var $sub744 = $have_25 - $copy_4 | 0; + var $add_ptr745 = $next_25 + $copy_4 | 0; + var $sub746 = $left_0 - $copy_4 | 0; + var $add_ptr747 = $put_0 + $copy_4 | 0; + var $120 = HEAP32[$21 >> 2]; + var $sub749 = $120 - $copy_4 | 0; + HEAP32[$21 >> 2] = $sub749; + var $ret_0_be = $ret_0; + var $next_0_be = $add_ptr745; + var $put_0_be = $add_ptr747; + var $have_0_be = $sub744; + var $left_0_be = $sub746; + var $hold_0_be = $hold_21; + var $bits_0_be = $bits_21; + var $out_0_be = $out_0; + __label__ = 268; + break; + } else if (__label__ == 164) { + var $bits_25_ph; + var $hold_25_ph; + var $have_29_ph; + var $next_29_ph; + var $ret_1_ph; + var $next_29 = $next_29_ph; + var $have_29 = $have_29_ph; + var $hold_25 = $hold_25_ph; + var $bits_25 = $bits_25_ph; + $_$167 : while (1) { + var $bits_25; + var $hold_25; + var $have_29; + var $next_29; + var $128 = HEAPU32[$40 >> 2]; + var $129 = HEAPU32[$37 >> 2]; + var $130 = HEAP32[$38 >> 2]; + var $add881 = $130 + $129 | 0; + var $cmp882 = $128 >>> 0 < $add881 >>> 0; + if ($cmp882) { + var $131 = HEAP32[$26 >> 2]; + var $shl887 = 1 << $131; + var $sub888 = $shl887 - 1 | 0; + var $132 = HEAPU32[$27 >> 2]; + var $next_30 = $next_29; + var $have_30 = $have_29; + var $hold_26 = $hold_25; + var $bits_26 = $bits_25; + while (1) { + var $bits_26; + var $hold_26; + var $have_30; + var $next_30; + var $and889 = $sub888 & $hold_26; + var $arrayidx891_1 = $132 + ($and889 << 2) + 1 | 0; + var $tmp25 = HEAPU8[$arrayidx891_1]; + var $conv893 = $tmp25 & 255; + var $cmp894 = $conv893 >>> 0 > $bits_26 >>> 0; + if (!$cmp894) { + break; + } + var $cmp899 = ($have_30 | 0) == 0; + if ($cmp899) { + var $ret_8 = $ret_1_ph; + var $next_58 = $next_30; + var $have_58 = 0; + var $hold_54 = $hold_26; + var $bits_54 = $bits_26; + var $out_4 = $out_0; + break $_$12; + } + var $dec903 = $have_30 - 1 | 0; + var $incdec_ptr904 = $next_30 + 1 | 0; + var $133 = HEAPU8[$next_30]; + var $conv905 = $133 & 255; + var $shl906 = $conv905 << $bits_26; + var $add907 = $shl906 + $hold_26 | 0; + var $add908 = $bits_26 + 8 | 0; + var $next_30 = $incdec_ptr904; + var $have_30 = $dec903; + var $hold_26 = $add907; + var $bits_26 = $add908; + } + var $arrayidx891_2 = $132 + ($and889 << 2) + 2 | 0; + var $tmp26 = HEAPU16[$arrayidx891_2 >> 1]; + var $cmp912 = ($tmp26 & 65535) < 16; + if ($cmp912) { + var $next_31 = $next_30; + var $have_31 = $have_30; + var $hold_27 = $hold_26; + var $bits_27 = $bits_26; + while (1) { + var $bits_27; + var $hold_27; + var $have_31; + var $next_31; + var $cmp919 = $bits_27 >>> 0 < $conv893 >>> 0; + if (!$cmp919) { + break; + } + var $cmp923 = ($have_31 | 0) == 0; + if ($cmp923) { + var $ret_8 = $ret_1_ph; + var $next_58 = $next_31; + var $have_58 = 0; + var $hold_54 = $hold_27; + var $bits_54 = $bits_27; + var $out_4 = $out_0; + break $_$12; + } + var $dec927 = $have_31 - 1 | 0; + var $incdec_ptr928 = $next_31 + 1 | 0; + var $134 = HEAPU8[$next_31]; + var $conv929 = $134 & 255; + var $shl930 = $conv929 << $bits_27; + var $add931 = $shl930 + $hold_27 | 0; + var $add932 = $bits_27 + 8 | 0; + var $next_31 = $incdec_ptr928; + var $have_31 = $dec927; + var $hold_27 = $add931; + var $bits_27 = $add932; + } + var $shr941 = $hold_27 >>> ($conv893 >>> 0); + var $sub944 = $bits_27 - $conv893 | 0; + var $inc949 = $128 + 1 | 0; + HEAP32[$40 >> 2] = $inc949; + var $arrayidx951 = $41 + ($128 << 1) | 0; + HEAP16[$arrayidx951 >> 1] = $tmp26; + var $next_29 = $next_31; + var $have_29 = $have_31; + var $hold_25 = $shr941; + var $bits_25 = $sub944; + } else { + if ($tmp26 << 16 >> 16 == 16) { + var $add962 = $conv893 + 2 | 0; + var $next_32 = $next_30; + var $have_32 = $have_30; + var $hold_28 = $hold_26; + var $bits_28 = $bits_26; + while (1) { + var $bits_28; + var $hold_28; + var $have_32; + var $next_32; + var $cmp963 = $bits_28 >>> 0 < $add962 >>> 0; + if (!$cmp963) { break; - } else if (($49 | 0) == 26) { - var $187 = HEAP32[$15 >> 2]; - var $tobool1626 = ($187 | 0) == 0; - do { - if (!$tobool1626) { - var $next_52 = $next_0; - var $have_52 = $have_0; - var $hold_48 = $hold_0; - var $bits_48 = $bits_0; - while (1) { - var $bits_48; - var $hold_48; - var $have_52; - var $next_52; - var $cmp1630 = $bits_48 >>> 0 < 32; - if (!$cmp1630) { - break; - } - var $cmp1634 = ($have_52 | 0) == 0; - if ($cmp1634) { - var $ret_8 = $ret_0; - var $next_58 = $next_52; - var $have_58 = 0; - var $hold_54 = $hold_48; - var $bits_54 = $bits_48; - var $out_4 = $out_0; - break $_$12; - } - var $dec1638 = $have_52 - 1 | 0; - var $incdec_ptr1639 = $next_52 + 1 | 0; - var $188 = HEAPU8[$next_52]; - var $conv1640 = $188 & 255; - var $shl1641 = $conv1640 << $bits_48; - var $add1642 = $shl1641 + $hold_48 | 0; - var $add1643 = $bits_48 + 8 | 0; - var $next_52 = $incdec_ptr1639; - var $have_52 = $dec1638; - var $hold_48 = $add1642; - var $bits_48 = $add1643; - } - var $sub1649 = $out_0 - $left_0 | 0; - var $189 = HEAP32[$total_out >> 2]; - var $add1650 = $189 + $sub1649 | 0; - HEAP32[$total_out >> 2] = $add1650; - var $190 = HEAP32[$36 >> 2]; - var $add1651 = $190 + $sub1649 | 0; - HEAP32[$36 >> 2] = $add1651; - var $tobool1652 = ($out_0 | 0) == ($left_0 | 0); - if (!$tobool1652) { - var $191 = HEAP32[$17 >> 2]; - var $tobool1655 = ($191 | 0) == 0; - var $192 = HEAP32[$16 >> 2]; - var $idx_neg1658 = -$sub1649 | 0; - var $add_ptr1659 = $put_0 + $idx_neg1658 | 0; - if ($tobool1655) { - var $call1665 = _adler32($192, $add_ptr1659, $sub1649); - var $cond1667 = $call1665; - } else { - var $call1660 = _crc32($192, $add_ptr1659, $sub1649); - var $cond1667 = $call1660; - } - var $cond1667; - HEAP32[$16 >> 2] = $cond1667; - HEAP32[$adler >> 2] = $cond1667; - } - var $193 = HEAP32[$17 >> 2]; - var $tobool1672 = ($193 | 0) == 0; - if ($tobool1672) { - var $add1685 = _llvm_bswap_i32($hold_48); - var $cond1687 = $add1685; - } else { - var $cond1687 = $hold_48; - } - var $cond1687; - var $194 = HEAP32[$16 >> 2]; - var $cmp1689 = ($cond1687 | 0) == ($194 | 0); - if ($cmp1689) { - var $next_53 = $next_52; - var $have_53 = $have_52; - var $hold_49 = 0; - var $bits_49 = 0; - var $out_1 = $left_0; - break; - } - HEAP32[$msg >> 2] = STRING_TABLE.__str17114 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $ret_0; - var $next_0_be = $next_52; - var $put_0_be = $put_0; - var $have_0_be = $have_52; - var $left_0_be = $left_0; - var $hold_0_be = $hold_48; - var $bits_0_be = $bits_48; - var $out_0_be = $left_0; - __label__ = 268; - break $_$14; - } - var $next_53 = $next_0; - var $have_53 = $have_0; - var $hold_49 = $hold_0; - var $bits_49 = $bits_0; - var $out_1 = $out_0; - } while (0); - var $out_1; - var $bits_49; - var $hold_49; - var $have_53; - var $next_53; - HEAP32[$mode >> 2] = 27; - var $next_54 = $next_53; - var $have_54 = $have_53; - var $hold_50 = $hold_49; - var $bits_50 = $bits_49; - var $out_2 = $out_1; - __label__ = 286; + } + var $cmp967 = ($have_32 | 0) == 0; + if ($cmp967) { + var $ret_8 = $ret_1_ph; + var $next_58 = $next_32; + var $have_58 = 0; + var $hold_54 = $hold_28; + var $bits_54 = $bits_28; + var $out_4 = $out_0; + break $_$12; + } + var $dec971 = $have_32 - 1 | 0; + var $incdec_ptr972 = $next_32 + 1 | 0; + var $135 = HEAPU8[$next_32]; + var $conv973 = $135 & 255; + var $shl974 = $conv973 << $bits_28; + var $add975 = $shl974 + $hold_28 | 0; + var $add976 = $bits_28 + 8 | 0; + var $next_32 = $incdec_ptr972; + var $have_32 = $dec971; + var $hold_28 = $add975; + var $bits_28 = $add976; + } + var $shr985 = $hold_28 >>> ($conv893 >>> 0); + var $sub988 = $bits_28 - $conv893 | 0; + var $cmp992 = ($128 | 0) == 0; + if ($cmp992) { + HEAP32[$msg >> 2] = STRING_TABLE.__str10107 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $ret_1_ph; + var $next_0_be = $next_32; + var $put_0_be = $put_0; + var $have_0_be = $have_32; + var $left_0_be = $left_0; + var $hold_0_be = $shr985; + var $bits_0_be = $sub988; + var $out_0_be = $out_0; + __label__ = 268; + break $_$148; + } + var $sub999 = $128 - 1 | 0; + var $arrayidx1001 = $41 + ($sub999 << 1) | 0; + var $136 = HEAP16[$arrayidx1001 >> 1]; + var $and1003 = $shr985 & 3; + var $add1004 = $and1003 + 3 | 0; + var $shr1006 = $shr985 >>> 2; + var $sub1007 = $sub988 - 2 | 0; + var $len_0 = $136; + var $next_35 = $next_32; + var $have_35 = $have_32; + var $hold_31 = $shr1006; + var $bits_31 = $sub1007; + var $copy_5 = $add1004; + } else if ($tmp26 << 16 >> 16 == 17) { + var $add1020 = $conv893 + 3 | 0; + var $next_33 = $next_30; + var $have_33 = $have_30; + var $hold_29 = $hold_26; + var $bits_29 = $bits_26; + while (1) { + var $bits_29; + var $hold_29; + var $have_33; + var $next_33; + var $cmp1021 = $bits_29 >>> 0 < $add1020 >>> 0; + if (!$cmp1021) { break; - } else if (($49 | 0) == 27) { - var $next_54 = $next_0; - var $have_54 = $have_0; - var $hold_50 = $hold_0; - var $bits_50 = $bits_0; - var $out_2 = $out_0; - __label__ = 286; - } else if (($49 | 0) == 28) { - var $ret_8 = 1; - var $next_58 = $next_0; - var $have_58 = $have_0; - var $hold_54 = $hold_0; - var $bits_54 = $bits_0; + } + var $cmp1025 = ($have_33 | 0) == 0; + if ($cmp1025) { + var $ret_8 = $ret_1_ph; + var $next_58 = $next_33; + var $have_58 = 0; + var $hold_54 = $hold_29; + var $bits_54 = $bits_29; var $out_4 = $out_0; break $_$12; - } else if (($49 | 0) == 29) { - var $ret_8 = -3; - var $next_58 = $next_0; - var $have_58 = $have_0; - var $hold_54 = $hold_0; - var $bits_54 = $bits_0; + } + var $dec1029 = $have_33 - 1 | 0; + var $incdec_ptr1030 = $next_33 + 1 | 0; + var $137 = HEAPU8[$next_33]; + var $conv1031 = $137 & 255; + var $shl1032 = $conv1031 << $bits_29; + var $add1033 = $shl1032 + $hold_29 | 0; + var $add1034 = $bits_29 + 8 | 0; + var $next_33 = $incdec_ptr1030; + var $have_33 = $dec1029; + var $hold_29 = $add1033; + var $bits_29 = $add1034; + } + var $shr1043 = $hold_29 >>> ($conv893 >>> 0); + var $and1049 = $shr1043 & 7; + var $add1050 = $and1049 + 3 | 0; + var $shr1052 = $shr1043 >>> 3; + var $sub1046 = -3 - $conv893 | 0; + var $sub1053 = $sub1046 + $bits_29 | 0; + var $len_0 = 0; + var $next_35 = $next_33; + var $have_35 = $have_33; + var $hold_31 = $shr1052; + var $bits_31 = $sub1053; + var $copy_5 = $add1050; + } else { + var $add1061 = $conv893 + 7 | 0; + var $next_34 = $next_30; + var $have_34 = $have_30; + var $hold_30 = $hold_26; + var $bits_30 = $bits_26; + while (1) { + var $bits_30; + var $hold_30; + var $have_34; + var $next_34; + var $cmp1062 = $bits_30 >>> 0 < $add1061 >>> 0; + if (!$cmp1062) { + break; + } + var $cmp1066 = ($have_34 | 0) == 0; + if ($cmp1066) { + var $ret_8 = $ret_1_ph; + var $next_58 = $next_34; + var $have_58 = 0; + var $hold_54 = $hold_30; + var $bits_54 = $bits_30; var $out_4 = $out_0; break $_$12; - } else if (($49 | 0) == 30) { - var $retval_0 = -4; - break $_$2; - } else { - var $retval_0 = -2; - break $_$2; + } + var $dec1070 = $have_34 - 1 | 0; + var $incdec_ptr1071 = $next_34 + 1 | 0; + var $138 = HEAPU8[$next_34]; + var $conv1072 = $138 & 255; + var $shl1073 = $conv1072 << $bits_30; + var $add1074 = $shl1073 + $hold_30 | 0; + var $add1075 = $bits_30 + 8 | 0; + var $next_34 = $incdec_ptr1071; + var $have_34 = $dec1070; + var $hold_30 = $add1074; + var $bits_30 = $add1075; + } + var $shr1084 = $hold_30 >>> ($conv893 >>> 0); + var $and1090 = $shr1084 & 127; + var $add1091 = $and1090 + 11 | 0; + var $shr1093 = $shr1084 >>> 7; + var $sub1087 = -7 - $conv893 | 0; + var $sub1094 = $sub1087 + $bits_30 | 0; + var $len_0 = 0; + var $next_35 = $next_34; + var $have_35 = $have_34; + var $hold_31 = $shr1093; + var $bits_31 = $sub1094; + var $copy_5 = $add1091; + } + var $copy_5; + var $bits_31; + var $hold_31; + var $have_35; + var $next_35; + var $len_0; + var $add1100 = $128 + $copy_5 | 0; + var $cmp1104 = $add1100 >>> 0 > $add881 >>> 0; + if ($cmp1104) { + HEAP32[$msg >> 2] = STRING_TABLE.__str10107 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $ret_1_ph; + var $next_0_be = $next_35; + var $put_0_be = $put_0; + var $have_0_be = $have_35; + var $left_0_be = $left_0; + var $hold_0_be = $hold_31; + var $bits_0_be = $bits_31; + var $out_0_be = $out_0; + __label__ = 268; + break $_$148; + } + var $copy_6127 = $copy_5; + var $139 = $128; + while (1) { + var $139; + var $copy_6127; + var $dec1111 = $copy_6127 - 1 | 0; + var $inc1116 = $139 + 1 | 0; + HEAP32[$40 >> 2] = $inc1116; + var $arrayidx1118 = $41 + ($139 << 1) | 0; + HEAP16[$arrayidx1118 >> 1] = $len_0; + var $tobool1112 = ($dec1111 | 0) == 0; + if ($tobool1112) { + var $next_29 = $next_35; + var $have_29 = $have_35; + var $hold_25 = $hold_31; + var $bits_25 = $bits_31; + continue $_$167; + } + var $_pre892 = HEAP32[$40 >> 2]; + var $copy_6127 = $dec1111; + var $139 = $_pre892; + } + } + } else { + var $_pr38 = HEAP32[$mode >> 2]; + var $cmp1123 = ($_pr38 | 0) == 29; + if ($cmp1123) { + var $ret_0_be = $ret_1_ph; + var $next_0_be = $next_29; + var $put_0_be = $put_0; + var $have_0_be = $have_29; + var $left_0_be = $left_0; + var $hold_0_be = $hold_25; + var $bits_0_be = $bits_25; + var $out_0_be = $out_0; + __label__ = 268; + break $_$148; + } + var $140 = HEAP16[$45 >> 1]; + var $cmp1130 = $140 << 16 >> 16 == 0; + if ($cmp1130) { + HEAP32[$msg >> 2] = STRING_TABLE.__str11108 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $ret_1_ph; + var $next_0_be = $next_29; + var $put_0_be = $put_0; + var $have_0_be = $have_29; + var $left_0_be = $left_0; + var $hold_0_be = $hold_25; + var $bits_0_be = $bits_25; + var $out_0_be = $out_0; + __label__ = 268; + break $_$148; + } + HEAP32[$43 >> 2] = $arraydecay860_c; + HEAP32[$44 >> 2] = $arraydecay860_c; + HEAP32[$26 >> 2] = 9; + var $call1149 = _inflate_table(1, $arraydecay864, $129, $42, $26, $arraydecay867); + var $tobool1150 = ($call1149 | 0) == 0; + if (!$tobool1150) { + HEAP32[$msg >> 2] = STRING_TABLE.__str12109 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $call1149; + var $next_0_be = $next_29; + var $put_0_be = $put_0; + var $have_0_be = $have_29; + var $left_0_be = $left_0; + var $hold_0_be = $hold_25; + var $bits_0_be = $bits_25; + var $out_0_be = $out_0; + __label__ = 268; + break $_$148; + } + var $141 = HEAP32[$42 >> 2]; + var $_c = $141; + HEAP32[$46 >> 2] = $_c; + HEAP32[$47 >> 2] = 6; + var $142 = HEAP32[$37 >> 2]; + var $add_ptr1159 = $arraydecay864 + ($142 << 1) | 0; + var $143 = HEAP32[$38 >> 2]; + var $call1165 = _inflate_table(2, $add_ptr1159, $143, $42, $47, $arraydecay867); + var $tobool1166 = ($call1165 | 0) == 0; + if (!$tobool1166) { + HEAP32[$msg >> 2] = STRING_TABLE.__str13110 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $call1165; + var $next_0_be = $next_29; + var $put_0_be = $put_0; + var $have_0_be = $have_29; + var $left_0_be = $left_0; + var $hold_0_be = $hold_25; + var $bits_0_be = $bits_25; + var $out_0_be = $out_0; + __label__ = 268; + break $_$148; + } + HEAP32[$mode >> 2] = 19; + if ($cmp660) { + var $ret_8 = 0; + var $next_58 = $next_29; + var $have_58 = $have_29; + var $hold_54 = $hold_25; + var $bits_54 = $bits_25; + var $out_4 = $out_0; + break $_$12; + } + var $ret_2 = 0; + var $next_37 = $next_29; + var $have_37 = $have_29; + var $hold_33 = $hold_25; + var $bits_33 = $bits_25; + __label__ = 205; + break $_$148; + } + } + } + } while (0); + do { + if (__label__ == 60) { + var $bits_5; + var $hold_5; + var $have_5; + var $next_5; + var $71 = HEAPU32[$17 >> 2]; + var $and262 = $71 & 1024; + var $tobool263 = ($and262 | 0) == 0; + do { + if ($tobool263) { + var $76 = HEAP32[$18 >> 2]; + var $cmp310 = ($76 | 0) == 0; + if ($cmp310) { + var $next_7 = $next_5; + var $have_7 = $have_5; + var $hold_7 = $hold_5; + var $bits_7 = $bits_5; + break; + } + var $extra = $76 + 16 | 0; + HEAP32[$extra >> 2] = 0; + var $next_7 = $next_5; + var $have_7 = $have_5; + var $hold_7 = $hold_5; + var $bits_7 = $bits_5; + } else { + var $next_6 = $next_5; + var $have_6 = $have_5; + var $hold_6 = $hold_5; + var $bits_6 = $bits_5; + while (1) { + var $bits_6; + var $hold_6; + var $have_6; + var $next_6; + var $cmp267 = $bits_6 >>> 0 < 16; + if (!$cmp267) { + break; + } + var $cmp271 = ($have_6 | 0) == 0; + if ($cmp271) { + var $ret_8 = $ret_0; + var $next_58 = $next_6; + var $have_58 = 0; + var $hold_54 = $hold_6; + var $bits_54 = $bits_6; + var $out_4 = $out_0; + break $_$12; + } + var $dec275 = $have_6 - 1 | 0; + var $incdec_ptr276 = $next_6 + 1 | 0; + var $72 = HEAPU8[$next_6]; + var $conv277 = $72 & 255; + var $shl278 = $conv277 << $bits_6; + var $add279 = $shl278 + $hold_6 | 0; + var $add280 = $bits_6 + 8 | 0; + var $next_6 = $incdec_ptr276; + var $have_6 = $dec275; + var $hold_6 = $add279; + var $bits_6 = $add280; + } + HEAP32[$21 >> 2] = $hold_6; + var $73 = HEAP32[$18 >> 2]; + var $cmp285 = ($73 | 0) == 0; + if ($cmp285) { + var $74 = $71; + } else { + var $extra_len = $73 + 20 | 0; + HEAP32[$extra_len >> 2] = $hold_6; + var $_pre885 = HEAP32[$17 >> 2]; + var $74 = $_pre885; + } + var $74; + var $and291 = $74 & 512; + var $tobool292 = ($and291 | 0) == 0; + if ($tobool292) { + var $next_7 = $next_6; + var $have_7 = $have_6; + var $hold_7 = 0; + var $bits_7 = 0; + break; + } + var $conv295 = $hold_6 & 255; + HEAP8[$arrayidx] = $conv295; + var $shr297 = $hold_6 >>> 8; + var $conv298 = $shr297 & 255; + HEAP8[$arrayidx40] = $conv298; + var $75 = HEAP32[$16 >> 2]; + var $call302 = _crc32($75, $arrayidx, 2); + HEAP32[$16 >> 2] = $call302; + var $next_7 = $next_6; + var $have_7 = $have_6; + var $hold_7 = 0; + var $bits_7 = 0; + } + } while (0); + var $bits_7; + var $hold_7; + var $have_7; + var $next_7; + HEAP32[$mode >> 2] = 5; + var $next_8 = $next_7; + var $have_8 = $have_7; + var $hold_8 = $hold_7; + var $bits_8 = $bits_7; + __label__ = 71; + break; + } else if (__label__ == 124) { + var $bits_17; + var $hold_17; + var $have_21; + var $next_21; + var $116 = HEAP32[$24 >> 2]; + var $tobool616 = ($116 | 0) == 0; + if ($tobool616) { + var $next_22 = $next_21; + var $have_22 = $have_21; + var $hold_18 = $hold_17; + var $bits_18 = $bits_17; + while (1) { + var $bits_18; + var $hold_18; + var $have_22; + var $next_22; + var $cmp629 = $bits_18 >>> 0 < 3; + if (!$cmp629) { + break; + } + var $cmp633 = ($have_22 | 0) == 0; + if ($cmp633) { + var $ret_8 = $ret_0; + var $next_58 = $next_22; + var $have_58 = 0; + var $hold_54 = $hold_18; + var $bits_54 = $bits_18; + var $out_4 = $out_0; + break $_$12; + } + var $dec637 = $have_22 - 1 | 0; + var $incdec_ptr638 = $next_22 + 1 | 0; + var $117 = HEAPU8[$next_22]; + var $conv639 = $117 & 255; + var $shl640 = $conv639 << $bits_18; + var $add641 = $shl640 + $hold_18 | 0; + var $add642 = $bits_18 + 8 | 0; + var $next_22 = $incdec_ptr638; + var $have_22 = $dec637; + var $hold_18 = $add641; + var $bits_18 = $add642; + } + var $and648 = $hold_18 & 1; + HEAP32[$24 >> 2] = $and648; + var $shr651 = $hold_18 >>> 1; + var $and655 = $shr651 & 3; + do { + if (($and655 | 0) == 0) { + HEAP32[$mode >> 2] = 13; + } else if (($and655 | 0) == 1) { + _fixedtables($4); + HEAP32[$mode >> 2] = 19; + if (!$cmp660) { + break; + } + var $shr664 = $hold_18 >>> 3; + var $sub665 = $bits_18 - 3 | 0; + var $ret_8 = $ret_0; + var $next_58 = $next_22; + var $have_58 = $have_22; + var $hold_54 = $shr664; + var $bits_54 = $sub665; + var $out_4 = $out_0; + break $_$12; + } else if (($and655 | 0) == 2) { + HEAP32[$mode >> 2] = 16; + } else if (($and655 | 0) == 3) { + HEAP32[$msg >> 2] = STRING_TABLE.__str6103 | 0; + HEAP32[$mode >> 2] = 29; + } + } while (0); + var $shr675 = $hold_18 >>> 3; + var $sub676 = $bits_18 - 3 | 0; + var $ret_0_be = $ret_0; + var $next_0_be = $next_22; + var $put_0_be = $put_0; + var $have_0_be = $have_22; + var $left_0_be = $left_0; + var $hold_0_be = $shr675; + var $bits_0_be = $sub676; + var $out_0_be = $out_0; + __label__ = 268; + break; + } + var $and619 = $bits_17 & 7; + var $shr620 = $hold_17 >>> ($and619 >>> 0); + var $sub622 = $bits_17 - $and619 | 0; + HEAP32[$mode >> 2] = 26; + var $ret_0_be = $ret_0; + var $next_0_be = $next_21; + var $put_0_be = $put_0; + var $have_0_be = $have_21; + var $left_0_be = $left_0; + var $hold_0_be = $shr620; + var $bits_0_be = $sub622; + var $out_0_be = $out_0; + __label__ = 268; + break; + } else if (__label__ == 205) { + var $bits_33; + var $hold_33; + var $have_37; + var $next_37; + var $ret_2; + HEAP32[$mode >> 2] = 20; + var $ret_3 = $ret_2; + var $next_38 = $next_37; + var $have_38 = $have_37; + var $hold_34 = $hold_33; + var $bits_34 = $bits_33; + __label__ = 206; + break; + } + } while (0); + do { + if (__label__ == 71) { + var $bits_8; + var $hold_8; + var $have_8; + var $next_8; + var $77 = HEAPU32[$17 >> 2]; + var $and319 = $77 & 1024; + var $tobool320 = ($and319 | 0) == 0; + if ($tobool320) { + var $next_10 = $next_8; + var $have_10 = $have_8; + var $88 = $77; + } else { + var $78 = HEAPU32[$21 >> 2]; + var $cmp323 = $78 >>> 0 > $have_8 >>> 0; + var $copy_0 = $cmp323 ? $have_8 : $78; + var $tobool327 = ($copy_0 | 0) == 0; + if ($tobool327) { + var $next_9 = $next_8; + var $have_9 = $have_8; + var $87 = $78; + var $86 = $77; + } else { + var $79 = HEAPU32[$18 >> 2]; + var $cmp330 = ($79 | 0) == 0; + do { + if ($cmp330) { + var $83 = $77; + } else { + var $extra334 = $79 + 16 | 0; + var $80 = HEAP32[$extra334 >> 2]; + var $cmp335 = ($80 | 0) == 0; + if ($cmp335) { + var $83 = $77; + break; } + var $extra_len339 = $79 + 20 | 0; + var $81 = HEAP32[$extra_len339 >> 2]; + var $sub341 = $81 - $78 | 0; + var $add_ptr = $80 + $sub341 | 0; + var $add344 = $sub341 + $copy_0 | 0; + var $extra_max = $79 + 24 | 0; + var $82 = HEAPU32[$extra_max >> 2]; + var $cmp346 = $add344 >>> 0 > $82 >>> 0; + var $sub350 = $82 - $sub341 | 0; + var $cond351 = $cmp346 ? $sub350 : $copy_0; + _memcpy($add_ptr, $next_8, $cond351, 1); + var $_pre886 = HEAP32[$17 >> 2]; + var $83 = $_pre886; + } } while (0); - $_$106 : do { - if (__label__ == 44) { - while (1) { - var $bits_3; - var $hold_3; - var $have_3; - var $next_3; - var $cmp164 = $bits_3 >>> 0 < 32; - if (!$cmp164) { - break; - } - var $cmp168 = ($have_3 | 0) == 0; - if ($cmp168) { - var $ret_8 = $ret_0; - var $next_58 = $next_3; - var $have_58 = 0; - var $hold_54 = $hold_3; - var $bits_54 = $bits_3; - var $out_4 = $out_0; - break $_$12; - } - var $dec172 = $have_3 - 1 | 0; - var $incdec_ptr173 = $next_3 + 1 | 0; - var $62 = HEAPU8[$next_3]; - var $conv174 = $62 & 255; - var $shl175 = $conv174 << $bits_3; - var $add176 = $shl175 + $hold_3 | 0; - var $add177 = $bits_3 + 8 | 0; - var $next_3 = $incdec_ptr173; - var $have_3 = $dec172; - var $hold_3 = $add176; - var $bits_3 = $add177; - } - var $63 = HEAP32[$18 >> 2]; - var $cmp182 = ($63 | 0) == 0; - if (!$cmp182) { - var $time = $63 + 4 | 0; - HEAP32[$time >> 2] = $hold_3; - } - var $64 = HEAP32[$17 >> 2]; - var $and188 = $64 & 512; - var $tobool189 = ($and188 | 0) == 0; - if (!$tobool189) { - var $conv192 = $hold_3 & 255; - HEAP8[$arrayidx] = $conv192; - var $shr194 = $hold_3 >>> 8; - var $conv195 = $shr194 & 255; - HEAP8[$arrayidx40] = $conv195; - var $shr197 = $hold_3 >>> 16; - var $conv198 = $shr197 & 255; - HEAP8[$arrayidx199] = $conv198; - var $shr200 = $hold_3 >>> 24; - var $conv201 = $shr200 & 255; - HEAP8[$arrayidx202] = $conv201; - var $65 = HEAP32[$16 >> 2]; - var $call205 = _crc32($65, $arrayidx, 4); - HEAP32[$16 >> 2] = $call205; - } - HEAP32[$mode >> 2] = 3; - var $next_4 = $next_3; - var $have_4 = $have_3; - var $hold_4 = 0; - var $bits_4 = 0; - __label__ = 52; + var $83; + var $and354 = $83 & 512; + var $tobool355 = ($and354 | 0) == 0; + if (!$tobool355) { + var $84 = HEAP32[$16 >> 2]; + var $call358 = _crc32($84, $next_8, $copy_0); + HEAP32[$16 >> 2] = $call358; + } + var $sub361 = $have_8 - $copy_0 | 0; + var $add_ptr362 = $next_8 + $copy_0 | 0; + var $85 = HEAP32[$21 >> 2]; + var $sub364 = $85 - $copy_0 | 0; + HEAP32[$21 >> 2] = $sub364; + var $next_9 = $add_ptr362; + var $have_9 = $sub361; + var $87 = $sub364; + var $86 = $83; + } + var $86; + var $87; + var $have_9; + var $next_9; + var $tobool367 = ($87 | 0) == 0; + if (!$tobool367) { + var $ret_8 = $ret_0; + var $next_58 = $next_9; + var $have_58 = $have_9; + var $hold_54 = $hold_8; + var $bits_54 = $bits_8; + var $out_4 = $out_0; + break $_$12; + } + var $next_10 = $next_9; + var $have_10 = $have_9; + var $88 = $86; + } + var $88; + var $have_10; + var $next_10; + HEAP32[$21 >> 2] = 0; + HEAP32[$mode >> 2] = 6; + var $next_11 = $next_10; + var $have_11 = $have_10; + var $hold_9 = $hold_8; + var $bits_9 = $bits_8; + var $89 = $88; + __label__ = 81; + break; + } else if (__label__ == 206) { + var $bits_34; + var $hold_34; + var $have_38; + var $next_38; + var $ret_3; + var $cmp1179 = $have_38 >>> 0 > 5; + var $cmp1182 = $left_0 >>> 0 > 257; + var $or_cond33 = $cmp1179 & $cmp1182; + if ($or_cond33) { + HEAP32[$next_out >> 2] = $put_0; + HEAP32[$avail_out >> 2] = $left_0; + HEAP32[$next_in >> 2] = $next_38; + HEAP32[$avail_in15 >> 2] = $have_38; + HEAP32[$11 >> 2] = $hold_34; + HEAP32[$13 >> 2] = $bits_34; + _inflate_fast($strm, $out_0); + var $144 = HEAP32[$next_out >> 2]; + var $145 = HEAP32[$avail_out >> 2]; + var $146 = HEAP32[$next_in >> 2]; + var $147 = HEAP32[$avail_in15 >> 2]; + var $148 = HEAP32[$11 >> 2]; + var $149 = HEAP32[$13 >> 2]; + var $150 = HEAP32[$mode >> 2]; + var $cmp1204 = ($150 | 0) == 11; + if (!$cmp1204) { + var $ret_0_be = $ret_3; + var $next_0_be = $146; + var $put_0_be = $144; + var $have_0_be = $147; + var $left_0_be = $145; + var $hold_0_be = $148; + var $bits_0_be = $149; + var $out_0_be = $out_0; + __label__ = 268; + break; + } + HEAP32[$25 >> 2] = -1; + var $ret_0_be = $ret_3; + var $next_0_be = $146; + var $put_0_be = $144; + var $have_0_be = $147; + var $left_0_be = $145; + var $hold_0_be = $148; + var $bits_0_be = $149; + var $out_0_be = $out_0; + __label__ = 268; + break; + } + HEAP32[$25 >> 2] = 0; + var $151 = HEAP32[$26 >> 2]; + var $shl1212 = 1 << $151; + var $sub1213 = $shl1212 - 1 | 0; + var $152 = HEAPU32[$27 >> 2]; + var $next_39 = $next_38; + var $have_39 = $have_38; + var $hold_35 = $hold_34; + var $bits_35 = $bits_34; + while (1) { + var $bits_35; + var $hold_35; + var $have_39; + var $next_39; + var $and1214 = $sub1213 & $hold_35; + var $arrayidx1216_1 = $152 + ($and1214 << 2) + 1 | 0; + var $tmp22 = HEAPU8[$arrayidx1216_1]; + var $conv1218 = $tmp22 & 255; + var $cmp1219 = $conv1218 >>> 0 > $bits_35 >>> 0; + if (!$cmp1219) { + break; + } + var $cmp1224 = ($have_39 | 0) == 0; + if ($cmp1224) { + var $ret_8 = $ret_3; + var $next_58 = $next_39; + var $have_58 = 0; + var $hold_54 = $hold_35; + var $bits_54 = $bits_35; + var $out_4 = $out_0; + break $_$12; + } + var $dec1228 = $have_39 - 1 | 0; + var $incdec_ptr1229 = $next_39 + 1 | 0; + var $153 = HEAPU8[$next_39]; + var $conv1230 = $153 & 255; + var $shl1231 = $conv1230 << $bits_35; + var $add1232 = $shl1231 + $hold_35 | 0; + var $add1233 = $bits_35 + 8 | 0; + var $next_39 = $incdec_ptr1229; + var $have_39 = $dec1228; + var $hold_35 = $add1232; + var $bits_35 = $add1233; + } + var $arrayidx1216_0 = $152 + ($and1214 << 2) | 0; + var $tmp21 = HEAPU8[$arrayidx1216_0]; + var $arrayidx1216_2 = $152 + ($and1214 << 2) + 2 | 0; + var $tmp23 = HEAPU16[$arrayidx1216_2 >> 1]; + var $conv1237 = $tmp21 & 255; + var $tobool1238 = $tmp21 << 24 >> 24 == 0; + do { + if ($tobool1238) { + var $next_41 = $next_39; + var $have_41 = $have_39; + var $hold_37 = $hold_35; + var $bits_37 = $bits_35; + var $here_09_0 = 0; + var $here_110_0 = $tmp22; + var $here_211_0 = $tmp23; + var $155 = 0; + } else { + var $and1242 = $conv1237 & 240; + var $cmp1243 = ($and1242 | 0) == 0; + if (!$cmp1243) { + var $next_41 = $next_39; + var $have_41 = $have_39; + var $hold_37 = $hold_35; + var $bits_37 = $bits_35; + var $here_09_0 = $tmp21; + var $here_110_0 = $tmp22; + var $here_211_0 = $tmp23; + var $155 = 0; + break; + } + var $conv1248 = $tmp23 & 65535; + var $add1253 = $conv1218 + $conv1237 | 0; + var $shl1254 = 1 << $add1253; + var $sub1255 = $shl1254 - 1 | 0; + var $next_40 = $next_39; + var $have_40 = $have_39; + var $hold_36 = $hold_35; + var $bits_36 = $bits_35; + while (1) { + var $bits_36; + var $hold_36; + var $have_40; + var $next_40; + var $and1256 = $hold_36 & $sub1255; + var $shr1259 = $and1256 >>> ($conv1218 >>> 0); + var $add1260 = $shr1259 + $conv1248 | 0; + var $arrayidx1262_1 = $152 + ($add1260 << 2) + 1 | 0; + var $tmp19 = HEAPU8[$arrayidx1262_1]; + var $conv1266 = $tmp19 & 255; + var $add1267 = $conv1266 + $conv1218 | 0; + var $cmp1268 = $add1267 >>> 0 > $bits_36 >>> 0; + if (!$cmp1268) { + break; + } + var $cmp1273 = ($have_40 | 0) == 0; + if ($cmp1273) { + var $ret_8 = $ret_3; + var $next_58 = $next_40; + var $have_58 = 0; + var $hold_54 = $hold_36; + var $bits_54 = $bits_36; + var $out_4 = $out_0; + break $_$12; + } + var $dec1277 = $have_40 - 1 | 0; + var $incdec_ptr1278 = $next_40 + 1 | 0; + var $154 = HEAPU8[$next_40]; + var $conv1279 = $154 & 255; + var $shl1280 = $conv1279 << $bits_36; + var $add1281 = $shl1280 + $hold_36 | 0; + var $add1282 = $bits_36 + 8 | 0; + var $next_40 = $incdec_ptr1278; + var $have_40 = $dec1277; + var $hold_36 = $add1281; + var $bits_36 = $add1282; + } + var $arrayidx1262_2 = $152 + ($add1260 << 2) + 2 | 0; + var $arrayidx1262_0 = $152 + ($add1260 << 2) | 0; + var $tmp20 = HEAP16[$arrayidx1262_2 >> 1]; + var $tmp18 = HEAP8[$arrayidx1262_0]; + var $shr1289 = $hold_36 >>> ($conv1218 >>> 0); + var $sub1292 = $bits_36 - $conv1218 | 0; + HEAP32[$25 >> 2] = $conv1218; + var $next_41 = $next_40; + var $have_41 = $have_40; + var $hold_37 = $shr1289; + var $bits_37 = $sub1292; + var $here_09_0 = $tmp18; + var $here_110_0 = $tmp19; + var $here_211_0 = $tmp20; + var $155 = $conv1218; + } + } while (0); + var $155; + var $here_211_0; + var $here_110_0; + var $here_09_0; + var $bits_37; + var $hold_37; + var $have_41; + var $next_41; + var $conv1302 = $here_110_0 & 255; + var $shr1303 = $hold_37 >>> ($conv1302 >>> 0); + var $sub1306 = $bits_37 - $conv1302 | 0; + var $add1312 = $155 + $conv1302 | 0; + HEAP32[$25 >> 2] = $add1312; + var $conv1314 = $here_211_0 & 65535; + HEAP32[$21 >> 2] = $conv1314; + var $conv1317 = $here_09_0 & 255; + var $cmp1318 = $here_09_0 << 24 >> 24 == 0; + if ($cmp1318) { + HEAP32[$mode >> 2] = 25; + var $ret_0_be = $ret_3; + var $next_0_be = $next_41; + var $put_0_be = $put_0; + var $have_0_be = $have_41; + var $left_0_be = $left_0; + var $hold_0_be = $shr1303; + var $bits_0_be = $sub1306; + var $out_0_be = $out_0; + __label__ = 268; + break; + } + var $and1325 = $conv1317 & 32; + var $tobool1326 = ($and1325 | 0) == 0; + if (!$tobool1326) { + HEAP32[$25 >> 2] = -1; + HEAP32[$mode >> 2] = 11; + var $ret_0_be = $ret_3; + var $next_0_be = $next_41; + var $put_0_be = $put_0; + var $have_0_be = $have_41; + var $left_0_be = $left_0; + var $hold_0_be = $shr1303; + var $bits_0_be = $sub1306; + var $out_0_be = $out_0; + __label__ = 268; + break; + } + var $and1333 = $conv1317 & 64; + var $tobool1334 = ($and1333 | 0) == 0; + if ($tobool1334) { + var $and1341 = $conv1317 & 15; + HEAP32[$28 >> 2] = $and1341; + HEAP32[$mode >> 2] = 21; + var $ret_4 = $ret_3; + var $next_42 = $next_41; + var $have_42 = $have_41; + var $hold_38 = $shr1303; + var $bits_38 = $sub1306; + var $156 = $and1341; + __label__ = 227; + break; + } + HEAP32[$msg >> 2] = STRING_TABLE.__str2171 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $ret_3; + var $next_0_be = $next_41; + var $put_0_be = $put_0; + var $have_0_be = $have_41; + var $left_0_be = $left_0; + var $hold_0_be = $shr1303; + var $bits_0_be = $sub1306; + var $out_0_be = $out_0; + __label__ = 268; + break; + } + } while (0); + do { + if (__label__ == 81) { + var $89; + var $bits_9; + var $hold_9; + var $have_11; + var $next_11; + var $and375 = $89 & 2048; + var $tobool376 = ($and375 | 0) == 0; + do { + if ($tobool376) { + var $98 = HEAP32[$18 >> 2]; + var $cmp424 = ($98 | 0) == 0; + if ($cmp424) { + var $next_12 = $next_11; + var $have_12 = $have_11; + break; + } + var $name428 = $98 + 28 | 0; + HEAP32[$name428 >> 2] = 0; + var $next_12 = $next_11; + var $have_12 = $have_11; + } else { + var $cmp378 = ($have_11 | 0) == 0; + if ($cmp378) { + var $ret_8 = $ret_0; + var $next_58 = $next_11; + var $have_58 = 0; + var $hold_54 = $hold_9; + var $bits_54 = $bits_9; + var $out_4 = $out_0; + break $_$12; + } + var $copy_1 = 0; + while (1) { + var $copy_1; + var $inc = $copy_1 + 1 | 0; + var $arrayidx383 = $next_11 + $copy_1 | 0; + var $90 = HEAP8[$arrayidx383]; + var $91 = HEAP32[$18 >> 2]; + var $cmp386 = ($91 | 0) == 0; + do { + if (!$cmp386) { + var $name = $91 + 28 | 0; + var $92 = HEAP32[$name >> 2]; + var $cmp390 = ($92 | 0) == 0; + if ($cmp390) { break; - } else if (__label__ == 120) { - var $bits_15; - var $hold_15; - var $have_19; - var $next_19; - var $115 = HEAP32[$22 >> 2]; - var $cmp589 = ($115 | 0) == 0; - if ($cmp589) { - HEAP32[$next_out >> 2] = $put_0; - HEAP32[$avail_out >> 2] = $left_0; - HEAP32[$next_in >> 2] = $next_19; - HEAP32[$avail_in15 >> 2] = $have_19; - HEAP32[$11 >> 2] = $hold_15; - HEAP32[$13 >> 2] = $bits_15; - var $retval_0 = 2; - break $_$2; - } - var $call602 = _adler32(0, 0, 0); - HEAP32[$16 >> 2] = $call602; - HEAP32[$adler >> 2] = $call602; - HEAP32[$mode >> 2] = 11; - var $next_20 = $next_19; - var $have_20 = $have_19; - var $hold_16 = $hold_15; - var $bits_16 = $bits_15; - __label__ = 123; + } + var $93 = HEAPU32[$21 >> 2]; + var $name_max = $91 + 32 | 0; + var $94 = HEAPU32[$name_max >> 2]; + var $cmp395 = $93 >>> 0 < $94 >>> 0; + if (!$cmp395) { break; - } else if (__label__ == 143) { - var $bits_20; - var $hold_20; - var $have_24; - var $next_24; - HEAP32[$mode >> 2] = 15; - var $next_25 = $next_24; - var $have_25 = $have_24; - var $hold_21 = $hold_20; - var $bits_21 = $bits_20; - __label__ = 144; + } + var $inc400 = $93 + 1 | 0; + HEAP32[$21 >> 2] = $inc400; + var $95 = HEAP32[$name >> 2]; + var $arrayidx403 = $95 + $93 | 0; + HEAP8[$arrayidx403] = $90; + } + } while (0); + var $tobool405 = $90 << 24 >> 24 != 0; + var $cmp406 = $inc >>> 0 < $have_11 >>> 0; + var $or_cond31 = $tobool405 & $cmp406; + if (!$or_cond31) { + break; + } + var $copy_1 = $inc; + } + var $96 = HEAP32[$17 >> 2]; + var $and410 = $96 & 512; + var $tobool411 = ($and410 | 0) == 0; + if (!$tobool411) { + var $97 = HEAP32[$16 >> 2]; + var $call414 = _crc32($97, $next_11, $inc); + HEAP32[$16 >> 2] = $call414; + } + var $sub417 = $have_11 - $inc | 0; + var $add_ptr418 = $next_11 + $inc | 0; + if ($tobool405) { + var $ret_8 = $ret_0; + var $next_58 = $add_ptr418; + var $have_58 = $sub417; + var $hold_54 = $hold_9; + var $bits_54 = $bits_9; + var $out_4 = $out_0; + break $_$12; + } + var $next_12 = $add_ptr418; + var $have_12 = $sub417; + } + } while (0); + var $have_12; + var $next_12; + HEAP32[$21 >> 2] = 0; + HEAP32[$mode >> 2] = 7; + var $next_13 = $next_12; + var $have_13 = $have_12; + var $hold_10 = $hold_9; + var $bits_10 = $bits_9; + __label__ = 94; + break; + } else if (__label__ == 227) { + var $156; + var $bits_38; + var $hold_38; + var $have_42; + var $next_42; + var $ret_4; + var $tobool1346 = ($156 | 0) == 0; + if ($tobool1346) { + var $_pre890 = HEAP32[$21 >> 2]; + var $next_44 = $next_42; + var $have_44 = $have_42; + var $hold_40 = $hold_38; + var $bits_40 = $bits_38; + var $160 = $_pre890; + } else { + var $next_43 = $next_42; + var $have_43 = $have_42; + var $hold_39 = $hold_38; + var $bits_39 = $bits_38; + while (1) { + var $bits_39; + var $hold_39; + var $have_43; + var $next_43; + var $cmp1351 = $bits_39 >>> 0 < $156 >>> 0; + if (!$cmp1351) { + break; + } + var $cmp1355 = ($have_43 | 0) == 0; + if ($cmp1355) { + var $ret_8 = $ret_4; + var $next_58 = $next_43; + var $have_58 = 0; + var $hold_54 = $hold_39; + var $bits_54 = $bits_39; + var $out_4 = $out_0; + break $_$12; + } + var $dec1359 = $have_43 - 1 | 0; + var $incdec_ptr1360 = $next_43 + 1 | 0; + var $157 = HEAPU8[$next_43]; + var $conv1361 = $157 & 255; + var $shl1362 = $conv1361 << $bits_39; + var $add1363 = $shl1362 + $hold_39 | 0; + var $add1364 = $bits_39 + 8 | 0; + var $next_43 = $incdec_ptr1360; + var $have_43 = $dec1359; + var $hold_39 = $add1363; + var $bits_39 = $add1364; + } + var $shl1371 = 1 << $156; + var $sub1372 = $shl1371 - 1 | 0; + var $and1373 = $sub1372 & $hold_39; + var $158 = HEAP32[$21 >> 2]; + var $add1375 = $158 + $and1373 | 0; + HEAP32[$21 >> 2] = $add1375; + var $shr1378 = $hold_39 >>> ($156 >>> 0); + var $sub1380 = $bits_39 - $156 | 0; + var $159 = HEAP32[$25 >> 2]; + var $add1385 = $159 + $156 | 0; + HEAP32[$25 >> 2] = $add1385; + var $next_44 = $next_43; + var $have_44 = $have_43; + var $hold_40 = $shr1378; + var $bits_40 = $sub1380; + var $160 = $add1375; + } + var $160; + var $bits_40; + var $hold_40; + var $have_44; + var $next_44; + HEAP32[$29 >> 2] = $160; + HEAP32[$mode >> 2] = 22; + var $ret_5_ph = $ret_4; + var $next_45_ph = $next_44; + var $have_45_ph = $have_44; + var $hold_41_ph = $hold_40; + var $bits_41_ph = $bits_40; + __label__ = 234; + break; + } + } while (0); + do { + if (__label__ == 94) { + var $bits_10; + var $hold_10; + var $have_13; + var $next_13; + var $99 = HEAP32[$17 >> 2]; + var $and435 = $99 & 4096; + var $tobool436 = ($and435 | 0) == 0; + do { + if ($tobool436) { + var $108 = HEAP32[$18 >> 2]; + var $cmp488 = ($108 | 0) == 0; + if ($cmp488) { + var $next_14 = $next_13; + var $have_14 = $have_13; + break; + } + var $comment492 = $108 + 36 | 0; + HEAP32[$comment492 >> 2] = 0; + var $next_14 = $next_13; + var $have_14 = $have_13; + } else { + var $cmp438 = ($have_13 | 0) == 0; + if ($cmp438) { + var $ret_8 = $ret_0; + var $next_58 = $next_13; + var $have_58 = 0; + var $hold_54 = $hold_10; + var $bits_54 = $bits_10; + var $out_4 = $out_0; + break $_$12; + } + var $copy_2 = 0; + while (1) { + var $copy_2; + var $inc443 = $copy_2 + 1 | 0; + var $arrayidx444 = $next_13 + $copy_2 | 0; + var $100 = HEAP8[$arrayidx444]; + var $101 = HEAP32[$18 >> 2]; + var $cmp447 = ($101 | 0) == 0; + do { + if (!$cmp447) { + var $comment = $101 + 36 | 0; + var $102 = HEAP32[$comment >> 2]; + var $cmp451 = ($102 | 0) == 0; + if ($cmp451) { break; - } else if (__label__ == 154) { - while (1) { - var $bits_23; - var $hold_23; - var $have_27; - var $next_27; - var $122 = HEAPU32[$40 >> 2]; - var $123 = HEAPU32[$39 >> 2]; - var $cmp812 = $122 >>> 0 < $123 >>> 0; - if (!$cmp812) { - break; - } - var $next_28 = $next_27; - var $have_28 = $have_27; - var $hold_24 = $hold_23; - var $bits_24 = $bits_23; - while (1) { - var $bits_24; - var $hold_24; - var $have_28; - var $next_28; - var $cmp817 = $bits_24 >>> 0 < 3; - if (!$cmp817) { - break; - } - var $cmp821 = ($have_28 | 0) == 0; - if ($cmp821) { - var $ret_8 = $ret_0; - var $next_58 = $next_28; - var $have_58 = 0; - var $hold_54 = $hold_24; - var $bits_54 = $bits_24; - var $out_4 = $out_0; - break $_$12; - } - var $dec825 = $have_28 - 1 | 0; - var $incdec_ptr826 = $next_28 + 1 | 0; - var $124 = HEAPU8[$next_28]; - var $conv827 = $124 & 255; - var $shl828 = $conv827 << $bits_24; - var $add829 = $shl828 + $hold_24 | 0; - var $add830 = $bits_24 + 8 | 0; - var $next_28 = $incdec_ptr826; - var $have_28 = $dec825; - var $hold_24 = $add829; - var $bits_24 = $add830; - } - var $hold_24_tr = $hold_24 & 65535; - var $conv837 = $hold_24_tr & 7; - var $inc839 = $122 + 1 | 0; - HEAP32[$40 >> 2] = $inc839; - var $arrayidx840 = _inflate_order + ($122 << 1) | 0; - var $125 = HEAPU16[$arrayidx840 >> 1]; - var $idxprom = $125 & 65535; - var $arrayidx841 = $41 + ($idxprom << 1) | 0; - HEAP16[$arrayidx841 >> 1] = $conv837; - var $shr843 = $hold_24 >>> 3; - var $sub844 = $bits_24 - 3 | 0; - var $next_27 = $next_28; - var $have_27 = $have_28; - var $hold_23 = $shr843; - var $bits_23 = $sub844; - } - var $cmp850111 = $122 >>> 0 < 19; - $_$131 : do { - if ($cmp850111) { - var $126 = $122; - while (1) { - var $126; - var $inc854 = $126 + 1 | 0; - HEAP32[$40 >> 2] = $inc854; - var $arrayidx855 = _inflate_order + ($126 << 1) | 0; - var $127 = HEAPU16[$arrayidx855 >> 1]; - var $idxprom856 = $127 & 65535; - var $arrayidx858 = $41 + ($idxprom856 << 1) | 0; - HEAP16[$arrayidx858 >> 1] = 0; - var $_pr = HEAPU32[$40 >> 2]; - var $cmp850 = $_pr >>> 0 < 19; - if (!$cmp850) { - break $_$131; - } - var $126 = $_pr; - } - } - } while (0); - HEAP32[$43 >> 2] = $arraydecay860_c; - HEAP32[$44 >> 2] = $arraydecay860_c; - HEAP32[$26 >> 2] = 7; - var $call868 = _inflate_table(0, $arraydecay864, 19, $42, $26, $arraydecay867); - var $tobool869 = ($call868 | 0) == 0; - if ($tobool869) { - HEAP32[$40 >> 2] = 0; - HEAP32[$mode >> 2] = 18; - var $ret_1_ph = 0; - var $next_29_ph = $next_27; - var $have_29_ph = $have_27; - var $hold_25_ph = $hold_23; - var $bits_25_ph = $bits_23; - __label__ = 164; - break; - } - HEAP32[$msg >> 2] = STRING_TABLE.__str9106 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $call868; - var $next_0_be = $next_27; - var $put_0_be = $put_0; - var $have_0_be = $have_27; - var $left_0_be = $left_0; - var $hold_0_be = $hold_23; - var $bits_0_be = $bits_23; - var $out_0_be = $out_0; - __label__ = 268; - break; - } else if (__label__ == 286) { - var $out_2; - var $bits_50; - var $hold_50; - var $have_54; - var $next_54; - var $195 = HEAP32[$15 >> 2]; - var $tobool1702 = ($195 | 0) == 0; - do { - if (!$tobool1702) { - var $196 = HEAP32[$17 >> 2]; - var $tobool1705 = ($196 | 0) == 0; - if ($tobool1705) { - var $next_56 = $next_54; - var $have_56 = $have_54; - var $hold_52 = $hold_50; - var $bits_52 = $bits_50; - break; - } - var $next_55 = $next_54; - var $have_55 = $have_54; - var $hold_51 = $hold_50; - var $bits_51 = $bits_50; - while (1) { - var $bits_51; - var $hold_51; - var $have_55; - var $next_55; - var $cmp1709 = $bits_51 >>> 0 < 32; - if (!$cmp1709) { - break; - } - var $cmp1713 = ($have_55 | 0) == 0; - if ($cmp1713) { - var $ret_8 = $ret_0; - var $next_58 = $next_55; - var $have_58 = 0; - var $hold_54 = $hold_51; - var $bits_54 = $bits_51; - var $out_4 = $out_2; - break $_$12; - } - var $dec1717 = $have_55 - 1 | 0; - var $incdec_ptr1718 = $next_55 + 1 | 0; - var $197 = HEAPU8[$next_55]; - var $conv1719 = $197 & 255; - var $shl1720 = $conv1719 << $bits_51; - var $add1721 = $shl1720 + $hold_51 | 0; - var $add1722 = $bits_51 + 8 | 0; - var $next_55 = $incdec_ptr1718; - var $have_55 = $dec1717; - var $hold_51 = $add1721; - var $bits_51 = $add1722; - } - var $198 = HEAP32[$36 >> 2]; - var $cmp1729 = ($hold_51 | 0) == ($198 | 0); - if ($cmp1729) { - var $next_56 = $next_55; - var $have_56 = $have_55; - var $hold_52 = 0; - var $bits_52 = 0; - break; - } - HEAP32[$msg >> 2] = STRING_TABLE.__str18115 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $ret_0; - var $next_0_be = $next_55; - var $put_0_be = $put_0; - var $have_0_be = $have_55; - var $left_0_be = $left_0; - var $hold_0_be = $hold_51; - var $bits_0_be = $bits_51; - var $out_0_be = $out_2; - __label__ = 268; - break $_$106; - } - var $next_56 = $next_54; - var $have_56 = $have_54; - var $hold_52 = $hold_50; - var $bits_52 = $bits_50; - } while (0); - var $bits_52; - var $hold_52; - var $have_56; - var $next_56; - HEAP32[$mode >> 2] = 28; - var $ret_8 = 1; - var $next_58 = $next_56; - var $have_58 = $have_56; - var $hold_54 = $hold_52; - var $bits_54 = $bits_52; - var $out_4 = $out_2; - break $_$12; - } - } while (0); - $_$148 : do { - if (__label__ == 52) { - while (1) { - var $bits_4; - var $hold_4; - var $have_4; - var $next_4; - var $cmp215 = $bits_4 >>> 0 < 16; - if (!$cmp215) { - break; - } - var $cmp219 = ($have_4 | 0) == 0; - if ($cmp219) { - var $ret_8 = $ret_0; - var $next_58 = $next_4; - var $have_58 = 0; - var $hold_54 = $hold_4; - var $bits_54 = $bits_4; - var $out_4 = $out_0; - break $_$12; - } - var $dec223 = $have_4 - 1 | 0; - var $incdec_ptr224 = $next_4 + 1 | 0; - var $66 = HEAPU8[$next_4]; - var $conv225 = $66 & 255; - var $shl226 = $conv225 << $bits_4; - var $add227 = $shl226 + $hold_4 | 0; - var $add228 = $bits_4 + 8 | 0; - var $next_4 = $incdec_ptr224; - var $have_4 = $dec223; - var $hold_4 = $add227; - var $bits_4 = $add228; - } - var $67 = HEAP32[$18 >> 2]; - var $cmp233 = ($67 | 0) == 0; - if (!$cmp233) { - var $and236 = $hold_4 & 255; - var $xflags = $67 + 8 | 0; - HEAP32[$xflags >> 2] = $and236; - var $shr238 = $hold_4 >>> 8; - var $68 = HEAP32[$18 >> 2]; - var $os = $68 + 12 | 0; - HEAP32[$os >> 2] = $shr238; - } - var $69 = HEAP32[$17 >> 2]; - var $and242 = $69 & 512; - var $tobool243 = ($and242 | 0) == 0; - if (!$tobool243) { - var $conv246 = $hold_4 & 255; - HEAP8[$arrayidx] = $conv246; - var $shr248 = $hold_4 >>> 8; - var $conv249 = $shr248 & 255; - HEAP8[$arrayidx40] = $conv249; - var $70 = HEAP32[$16 >> 2]; - var $call253 = _crc32($70, $arrayidx, 2); - HEAP32[$16 >> 2] = $call253; - } - HEAP32[$mode >> 2] = 4; - var $next_5 = $next_4; - var $have_5 = $have_4; - var $hold_5 = 0; - var $bits_5 = 0; - __label__ = 60; - break; - } else if (__label__ == 123) { - var $bits_16; - var $hold_16; - var $have_20; - var $next_20; - if ($23) { - var $ret_8 = $ret_0; - var $next_58 = $next_20; - var $have_58 = $have_20; - var $hold_54 = $hold_16; - var $bits_54 = $bits_16; - var $out_4 = $out_0; - break $_$12; - } - var $next_21 = $next_20; - var $have_21 = $have_20; - var $hold_17 = $hold_16; - var $bits_17 = $bits_16; - __label__ = 124; - break; - } else if (__label__ == 144) { - var $bits_21; - var $hold_21; - var $have_25; - var $next_25; - var $119 = HEAPU32[$21 >> 2]; - var $tobool730 = ($119 | 0) == 0; - if ($tobool730) { - HEAP32[$mode >> 2] = 11; - var $ret_0_be = $ret_0; - var $next_0_be = $next_25; - var $put_0_be = $put_0; - var $have_0_be = $have_25; - var $left_0_be = $left_0; - var $hold_0_be = $hold_21; - var $bits_0_be = $bits_21; - var $out_0_be = $out_0; - __label__ = 268; - break; - } - var $cmp732 = $119 >>> 0 > $have_25 >>> 0; - var $copy_3 = $cmp732 ? $have_25 : $119; - var $cmp736 = $copy_3 >>> 0 > $left_0 >>> 0; - var $copy_4 = $cmp736 ? $left_0 : $copy_3; - var $cmp740 = ($copy_4 | 0) == 0; - if ($cmp740) { - var $ret_8 = $ret_0; - var $next_58 = $next_25; - var $have_58 = $have_25; - var $hold_54 = $hold_21; - var $bits_54 = $bits_21; - var $out_4 = $out_0; - break $_$12; - } - _memcpy($put_0, $next_25, $copy_4, 1); - var $sub744 = $have_25 - $copy_4 | 0; - var $add_ptr745 = $next_25 + $copy_4 | 0; - var $sub746 = $left_0 - $copy_4 | 0; - var $add_ptr747 = $put_0 + $copy_4 | 0; - var $120 = HEAP32[$21 >> 2]; - var $sub749 = $120 - $copy_4 | 0; - HEAP32[$21 >> 2] = $sub749; - var $ret_0_be = $ret_0; - var $next_0_be = $add_ptr745; - var $put_0_be = $add_ptr747; - var $have_0_be = $sub744; - var $left_0_be = $sub746; - var $hold_0_be = $hold_21; - var $bits_0_be = $bits_21; - var $out_0_be = $out_0; - __label__ = 268; - break; - } else if (__label__ == 164) { - var $bits_25_ph; - var $hold_25_ph; - var $have_29_ph; - var $next_29_ph; - var $ret_1_ph; - var $next_29 = $next_29_ph; - var $have_29 = $have_29_ph; - var $hold_25 = $hold_25_ph; - var $bits_25 = $bits_25_ph; - $_$167 : while (1) { - var $bits_25; - var $hold_25; - var $have_29; - var $next_29; - var $128 = HEAPU32[$40 >> 2]; - var $129 = HEAPU32[$37 >> 2]; - var $130 = HEAP32[$38 >> 2]; - var $add881 = $130 + $129 | 0; - var $cmp882 = $128 >>> 0 < $add881 >>> 0; - if ($cmp882) { - var $131 = HEAP32[$26 >> 2]; - var $shl887 = 1 << $131; - var $sub888 = $shl887 - 1 | 0; - var $132 = HEAPU32[$27 >> 2]; - var $next_30 = $next_29; - var $have_30 = $have_29; - var $hold_26 = $hold_25; - var $bits_26 = $bits_25; - while (1) { - var $bits_26; - var $hold_26; - var $have_30; - var $next_30; - var $and889 = $sub888 & $hold_26; - var $arrayidx891_1 = $132 + ($and889 << 2) + 1 | 0; - var $tmp25 = HEAPU8[$arrayidx891_1]; - var $conv893 = $tmp25 & 255; - var $cmp894 = $conv893 >>> 0 > $bits_26 >>> 0; - if (!$cmp894) { - break; - } - var $cmp899 = ($have_30 | 0) == 0; - if ($cmp899) { - var $ret_8 = $ret_1_ph; - var $next_58 = $next_30; - var $have_58 = 0; - var $hold_54 = $hold_26; - var $bits_54 = $bits_26; - var $out_4 = $out_0; - break $_$12; - } - var $dec903 = $have_30 - 1 | 0; - var $incdec_ptr904 = $next_30 + 1 | 0; - var $133 = HEAPU8[$next_30]; - var $conv905 = $133 & 255; - var $shl906 = $conv905 << $bits_26; - var $add907 = $shl906 + $hold_26 | 0; - var $add908 = $bits_26 + 8 | 0; - var $next_30 = $incdec_ptr904; - var $have_30 = $dec903; - var $hold_26 = $add907; - var $bits_26 = $add908; - } - var $arrayidx891_2 = $132 + ($and889 << 2) + 2 | 0; - var $tmp26 = HEAPU16[$arrayidx891_2 >> 1]; - var $cmp912 = ($tmp26 & 65535) < 16; - if ($cmp912) { - var $next_31 = $next_30; - var $have_31 = $have_30; - var $hold_27 = $hold_26; - var $bits_27 = $bits_26; - while (1) { - var $bits_27; - var $hold_27; - var $have_31; - var $next_31; - var $cmp919 = $bits_27 >>> 0 < $conv893 >>> 0; - if (!$cmp919) { - break; - } - var $cmp923 = ($have_31 | 0) == 0; - if ($cmp923) { - var $ret_8 = $ret_1_ph; - var $next_58 = $next_31; - var $have_58 = 0; - var $hold_54 = $hold_27; - var $bits_54 = $bits_27; - var $out_4 = $out_0; - break $_$12; - } - var $dec927 = $have_31 - 1 | 0; - var $incdec_ptr928 = $next_31 + 1 | 0; - var $134 = HEAPU8[$next_31]; - var $conv929 = $134 & 255; - var $shl930 = $conv929 << $bits_27; - var $add931 = $shl930 + $hold_27 | 0; - var $add932 = $bits_27 + 8 | 0; - var $next_31 = $incdec_ptr928; - var $have_31 = $dec927; - var $hold_27 = $add931; - var $bits_27 = $add932; - } - var $shr941 = $hold_27 >>> ($conv893 >>> 0); - var $sub944 = $bits_27 - $conv893 | 0; - var $inc949 = $128 + 1 | 0; - HEAP32[$40 >> 2] = $inc949; - var $arrayidx951 = $41 + ($128 << 1) | 0; - HEAP16[$arrayidx951 >> 1] = $tmp26; - var $next_29 = $next_31; - var $have_29 = $have_31; - var $hold_25 = $shr941; - var $bits_25 = $sub944; - } else { - if ($tmp26 << 16 >> 16 == 16) { - var $add962 = $conv893 + 2 | 0; - var $next_32 = $next_30; - var $have_32 = $have_30; - var $hold_28 = $hold_26; - var $bits_28 = $bits_26; - while (1) { - var $bits_28; - var $hold_28; - var $have_32; - var $next_32; - var $cmp963 = $bits_28 >>> 0 < $add962 >>> 0; - if (!$cmp963) { - break; - } - var $cmp967 = ($have_32 | 0) == 0; - if ($cmp967) { - var $ret_8 = $ret_1_ph; - var $next_58 = $next_32; - var $have_58 = 0; - var $hold_54 = $hold_28; - var $bits_54 = $bits_28; - var $out_4 = $out_0; - break $_$12; - } - var $dec971 = $have_32 - 1 | 0; - var $incdec_ptr972 = $next_32 + 1 | 0; - var $135 = HEAPU8[$next_32]; - var $conv973 = $135 & 255; - var $shl974 = $conv973 << $bits_28; - var $add975 = $shl974 + $hold_28 | 0; - var $add976 = $bits_28 + 8 | 0; - var $next_32 = $incdec_ptr972; - var $have_32 = $dec971; - var $hold_28 = $add975; - var $bits_28 = $add976; - } - var $shr985 = $hold_28 >>> ($conv893 >>> 0); - var $sub988 = $bits_28 - $conv893 | 0; - var $cmp992 = ($128 | 0) == 0; - if ($cmp992) { - HEAP32[$msg >> 2] = STRING_TABLE.__str10107 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $ret_1_ph; - var $next_0_be = $next_32; - var $put_0_be = $put_0; - var $have_0_be = $have_32; - var $left_0_be = $left_0; - var $hold_0_be = $shr985; - var $bits_0_be = $sub988; - var $out_0_be = $out_0; - __label__ = 268; - break $_$148; - } - var $sub999 = $128 - 1 | 0; - var $arrayidx1001 = $41 + ($sub999 << 1) | 0; - var $136 = HEAP16[$arrayidx1001 >> 1]; - var $and1003 = $shr985 & 3; - var $add1004 = $and1003 + 3 | 0; - var $shr1006 = $shr985 >>> 2; - var $sub1007 = $sub988 - 2 | 0; - var $len_0 = $136; - var $next_35 = $next_32; - var $have_35 = $have_32; - var $hold_31 = $shr1006; - var $bits_31 = $sub1007; - var $copy_5 = $add1004; - } else if ($tmp26 << 16 >> 16 == 17) { - var $add1020 = $conv893 + 3 | 0; - var $next_33 = $next_30; - var $have_33 = $have_30; - var $hold_29 = $hold_26; - var $bits_29 = $bits_26; - while (1) { - var $bits_29; - var $hold_29; - var $have_33; - var $next_33; - var $cmp1021 = $bits_29 >>> 0 < $add1020 >>> 0; - if (!$cmp1021) { - break; - } - var $cmp1025 = ($have_33 | 0) == 0; - if ($cmp1025) { - var $ret_8 = $ret_1_ph; - var $next_58 = $next_33; - var $have_58 = 0; - var $hold_54 = $hold_29; - var $bits_54 = $bits_29; - var $out_4 = $out_0; - break $_$12; - } - var $dec1029 = $have_33 - 1 | 0; - var $incdec_ptr1030 = $next_33 + 1 | 0; - var $137 = HEAPU8[$next_33]; - var $conv1031 = $137 & 255; - var $shl1032 = $conv1031 << $bits_29; - var $add1033 = $shl1032 + $hold_29 | 0; - var $add1034 = $bits_29 + 8 | 0; - var $next_33 = $incdec_ptr1030; - var $have_33 = $dec1029; - var $hold_29 = $add1033; - var $bits_29 = $add1034; - } - var $shr1043 = $hold_29 >>> ($conv893 >>> 0); - var $and1049 = $shr1043 & 7; - var $add1050 = $and1049 + 3 | 0; - var $shr1052 = $shr1043 >>> 3; - var $sub1046 = -3 - $conv893 | 0; - var $sub1053 = $sub1046 + $bits_29 | 0; - var $len_0 = 0; - var $next_35 = $next_33; - var $have_35 = $have_33; - var $hold_31 = $shr1052; - var $bits_31 = $sub1053; - var $copy_5 = $add1050; - } else { - var $add1061 = $conv893 + 7 | 0; - var $next_34 = $next_30; - var $have_34 = $have_30; - var $hold_30 = $hold_26; - var $bits_30 = $bits_26; - while (1) { - var $bits_30; - var $hold_30; - var $have_34; - var $next_34; - var $cmp1062 = $bits_30 >>> 0 < $add1061 >>> 0; - if (!$cmp1062) { - break; - } - var $cmp1066 = ($have_34 | 0) == 0; - if ($cmp1066) { - var $ret_8 = $ret_1_ph; - var $next_58 = $next_34; - var $have_58 = 0; - var $hold_54 = $hold_30; - var $bits_54 = $bits_30; - var $out_4 = $out_0; - break $_$12; - } - var $dec1070 = $have_34 - 1 | 0; - var $incdec_ptr1071 = $next_34 + 1 | 0; - var $138 = HEAPU8[$next_34]; - var $conv1072 = $138 & 255; - var $shl1073 = $conv1072 << $bits_30; - var $add1074 = $shl1073 + $hold_30 | 0; - var $add1075 = $bits_30 + 8 | 0; - var $next_34 = $incdec_ptr1071; - var $have_34 = $dec1070; - var $hold_30 = $add1074; - var $bits_30 = $add1075; - } - var $shr1084 = $hold_30 >>> ($conv893 >>> 0); - var $and1090 = $shr1084 & 127; - var $add1091 = $and1090 + 11 | 0; - var $shr1093 = $shr1084 >>> 7; - var $sub1087 = -7 - $conv893 | 0; - var $sub1094 = $sub1087 + $bits_30 | 0; - var $len_0 = 0; - var $next_35 = $next_34; - var $have_35 = $have_34; - var $hold_31 = $shr1093; - var $bits_31 = $sub1094; - var $copy_5 = $add1091; - } - var $copy_5; - var $bits_31; - var $hold_31; - var $have_35; - var $next_35; - var $len_0; - var $add1100 = $128 + $copy_5 | 0; - var $cmp1104 = $add1100 >>> 0 > $add881 >>> 0; - if ($cmp1104) { - HEAP32[$msg >> 2] = STRING_TABLE.__str10107 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $ret_1_ph; - var $next_0_be = $next_35; - var $put_0_be = $put_0; - var $have_0_be = $have_35; - var $left_0_be = $left_0; - var $hold_0_be = $hold_31; - var $bits_0_be = $bits_31; - var $out_0_be = $out_0; - __label__ = 268; - break $_$148; - } - var $copy_6127 = $copy_5; - var $139 = $128; - while (1) { - var $139; - var $copy_6127; - var $dec1111 = $copy_6127 - 1 | 0; - var $inc1116 = $139 + 1 | 0; - HEAP32[$40 >> 2] = $inc1116; - var $arrayidx1118 = $41 + ($139 << 1) | 0; - HEAP16[$arrayidx1118 >> 1] = $len_0; - var $tobool1112 = ($dec1111 | 0) == 0; - if ($tobool1112) { - var $next_29 = $next_35; - var $have_29 = $have_35; - var $hold_25 = $hold_31; - var $bits_25 = $bits_31; - continue $_$167; - } - var $_pre892 = HEAP32[$40 >> 2]; - var $copy_6127 = $dec1111; - var $139 = $_pre892; - } - } - } else { - var $_pr38 = HEAP32[$mode >> 2]; - var $cmp1123 = ($_pr38 | 0) == 29; - if ($cmp1123) { - var $ret_0_be = $ret_1_ph; - var $next_0_be = $next_29; - var $put_0_be = $put_0; - var $have_0_be = $have_29; - var $left_0_be = $left_0; - var $hold_0_be = $hold_25; - var $bits_0_be = $bits_25; - var $out_0_be = $out_0; - __label__ = 268; - break $_$148; - } - var $140 = HEAP16[$45 >> 1]; - var $cmp1130 = $140 << 16 >> 16 == 0; - if ($cmp1130) { - HEAP32[$msg >> 2] = STRING_TABLE.__str11108 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $ret_1_ph; - var $next_0_be = $next_29; - var $put_0_be = $put_0; - var $have_0_be = $have_29; - var $left_0_be = $left_0; - var $hold_0_be = $hold_25; - var $bits_0_be = $bits_25; - var $out_0_be = $out_0; - __label__ = 268; - break $_$148; - } - HEAP32[$43 >> 2] = $arraydecay860_c; - HEAP32[$44 >> 2] = $arraydecay860_c; - HEAP32[$26 >> 2] = 9; - var $call1149 = _inflate_table(1, $arraydecay864, $129, $42, $26, $arraydecay867); - var $tobool1150 = ($call1149 | 0) == 0; - if (!$tobool1150) { - HEAP32[$msg >> 2] = STRING_TABLE.__str12109 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $call1149; - var $next_0_be = $next_29; - var $put_0_be = $put_0; - var $have_0_be = $have_29; - var $left_0_be = $left_0; - var $hold_0_be = $hold_25; - var $bits_0_be = $bits_25; - var $out_0_be = $out_0; - __label__ = 268; - break $_$148; - } - var $141 = HEAP32[$42 >> 2]; - var $_c = $141; - HEAP32[$46 >> 2] = $_c; - HEAP32[$47 >> 2] = 6; - var $142 = HEAP32[$37 >> 2]; - var $add_ptr1159 = $arraydecay864 + ($142 << 1) | 0; - var $143 = HEAP32[$38 >> 2]; - var $call1165 = _inflate_table(2, $add_ptr1159, $143, $42, $47, $arraydecay867); - var $tobool1166 = ($call1165 | 0) == 0; - if (!$tobool1166) { - HEAP32[$msg >> 2] = STRING_TABLE.__str13110 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $call1165; - var $next_0_be = $next_29; - var $put_0_be = $put_0; - var $have_0_be = $have_29; - var $left_0_be = $left_0; - var $hold_0_be = $hold_25; - var $bits_0_be = $bits_25; - var $out_0_be = $out_0; - __label__ = 268; - break $_$148; - } - HEAP32[$mode >> 2] = 19; - if ($cmp660) { - var $ret_8 = 0; - var $next_58 = $next_29; - var $have_58 = $have_29; - var $hold_54 = $hold_25; - var $bits_54 = $bits_25; - var $out_4 = $out_0; - break $_$12; - } - var $ret_2 = 0; - var $next_37 = $next_29; - var $have_37 = $have_29; - var $hold_33 = $hold_25; - var $bits_33 = $bits_25; - __label__ = 205; - break $_$148; - } - } - } - } while (0); - do { - if (__label__ == 60) { - var $bits_5; - var $hold_5; - var $have_5; - var $next_5; - var $71 = HEAPU32[$17 >> 2]; - var $and262 = $71 & 1024; - var $tobool263 = ($and262 | 0) == 0; - do { - if ($tobool263) { - var $76 = HEAP32[$18 >> 2]; - var $cmp310 = ($76 | 0) == 0; - if ($cmp310) { - var $next_7 = $next_5; - var $have_7 = $have_5; - var $hold_7 = $hold_5; - var $bits_7 = $bits_5; - break; - } - var $extra = $76 + 16 | 0; - HEAP32[$extra >> 2] = 0; - var $next_7 = $next_5; - var $have_7 = $have_5; - var $hold_7 = $hold_5; - var $bits_7 = $bits_5; - } else { - var $next_6 = $next_5; - var $have_6 = $have_5; - var $hold_6 = $hold_5; - var $bits_6 = $bits_5; - while (1) { - var $bits_6; - var $hold_6; - var $have_6; - var $next_6; - var $cmp267 = $bits_6 >>> 0 < 16; - if (!$cmp267) { - break; - } - var $cmp271 = ($have_6 | 0) == 0; - if ($cmp271) { - var $ret_8 = $ret_0; - var $next_58 = $next_6; - var $have_58 = 0; - var $hold_54 = $hold_6; - var $bits_54 = $bits_6; - var $out_4 = $out_0; - break $_$12; - } - var $dec275 = $have_6 - 1 | 0; - var $incdec_ptr276 = $next_6 + 1 | 0; - var $72 = HEAPU8[$next_6]; - var $conv277 = $72 & 255; - var $shl278 = $conv277 << $bits_6; - var $add279 = $shl278 + $hold_6 | 0; - var $add280 = $bits_6 + 8 | 0; - var $next_6 = $incdec_ptr276; - var $have_6 = $dec275; - var $hold_6 = $add279; - var $bits_6 = $add280; - } - HEAP32[$21 >> 2] = $hold_6; - var $73 = HEAP32[$18 >> 2]; - var $cmp285 = ($73 | 0) == 0; - if ($cmp285) { - var $74 = $71; - } else { - var $extra_len = $73 + 20 | 0; - HEAP32[$extra_len >> 2] = $hold_6; - var $_pre885 = HEAP32[$17 >> 2]; - var $74 = $_pre885; - } - var $74; - var $and291 = $74 & 512; - var $tobool292 = ($and291 | 0) == 0; - if ($tobool292) { - var $next_7 = $next_6; - var $have_7 = $have_6; - var $hold_7 = 0; - var $bits_7 = 0; - break; - } - var $conv295 = $hold_6 & 255; - HEAP8[$arrayidx] = $conv295; - var $shr297 = $hold_6 >>> 8; - var $conv298 = $shr297 & 255; - HEAP8[$arrayidx40] = $conv298; - var $75 = HEAP32[$16 >> 2]; - var $call302 = _crc32($75, $arrayidx, 2); - HEAP32[$16 >> 2] = $call302; - var $next_7 = $next_6; - var $have_7 = $have_6; - var $hold_7 = 0; - var $bits_7 = 0; - } - } while (0); - var $bits_7; - var $hold_7; - var $have_7; - var $next_7; - HEAP32[$mode >> 2] = 5; - var $next_8 = $next_7; - var $have_8 = $have_7; - var $hold_8 = $hold_7; - var $bits_8 = $bits_7; - __label__ = 71; - break; - } else if (__label__ == 124) { - var $bits_17; - var $hold_17; - var $have_21; - var $next_21; - var $116 = HEAP32[$24 >> 2]; - var $tobool616 = ($116 | 0) == 0; - if ($tobool616) { - var $next_22 = $next_21; - var $have_22 = $have_21; - var $hold_18 = $hold_17; - var $bits_18 = $bits_17; - while (1) { - var $bits_18; - var $hold_18; - var $have_22; - var $next_22; - var $cmp629 = $bits_18 >>> 0 < 3; - if (!$cmp629) { - break; - } - var $cmp633 = ($have_22 | 0) == 0; - if ($cmp633) { - var $ret_8 = $ret_0; - var $next_58 = $next_22; - var $have_58 = 0; - var $hold_54 = $hold_18; - var $bits_54 = $bits_18; - var $out_4 = $out_0; - break $_$12; - } - var $dec637 = $have_22 - 1 | 0; - var $incdec_ptr638 = $next_22 + 1 | 0; - var $117 = HEAPU8[$next_22]; - var $conv639 = $117 & 255; - var $shl640 = $conv639 << $bits_18; - var $add641 = $shl640 + $hold_18 | 0; - var $add642 = $bits_18 + 8 | 0; - var $next_22 = $incdec_ptr638; - var $have_22 = $dec637; - var $hold_18 = $add641; - var $bits_18 = $add642; - } - var $and648 = $hold_18 & 1; - HEAP32[$24 >> 2] = $and648; - var $shr651 = $hold_18 >>> 1; - var $and655 = $shr651 & 3; - do { - if (($and655 | 0) == 0) { - HEAP32[$mode >> 2] = 13; - } else if (($and655 | 0) == 1) { - _fixedtables($4); - HEAP32[$mode >> 2] = 19; - if (!$cmp660) { - break; - } - var $shr664 = $hold_18 >>> 3; - var $sub665 = $bits_18 - 3 | 0; - var $ret_8 = $ret_0; - var $next_58 = $next_22; - var $have_58 = $have_22; - var $hold_54 = $shr664; - var $bits_54 = $sub665; - var $out_4 = $out_0; - break $_$12; - } else if (($and655 | 0) == 2) { - HEAP32[$mode >> 2] = 16; - } else if (($and655 | 0) == 3) { - HEAP32[$msg >> 2] = STRING_TABLE.__str6103 | 0; - HEAP32[$mode >> 2] = 29; - } - } while (0); - var $shr675 = $hold_18 >>> 3; - var $sub676 = $bits_18 - 3 | 0; - var $ret_0_be = $ret_0; - var $next_0_be = $next_22; - var $put_0_be = $put_0; - var $have_0_be = $have_22; - var $left_0_be = $left_0; - var $hold_0_be = $shr675; - var $bits_0_be = $sub676; - var $out_0_be = $out_0; - __label__ = 268; - break; - } - var $and619 = $bits_17 & 7; - var $shr620 = $hold_17 >>> ($and619 >>> 0); - var $sub622 = $bits_17 - $and619 | 0; - HEAP32[$mode >> 2] = 26; - var $ret_0_be = $ret_0; - var $next_0_be = $next_21; - var $put_0_be = $put_0; - var $have_0_be = $have_21; - var $left_0_be = $left_0; - var $hold_0_be = $shr620; - var $bits_0_be = $sub622; - var $out_0_be = $out_0; - __label__ = 268; - break; - } else if (__label__ == 205) { - var $bits_33; - var $hold_33; - var $have_37; - var $next_37; - var $ret_2; - HEAP32[$mode >> 2] = 20; - var $ret_3 = $ret_2; - var $next_38 = $next_37; - var $have_38 = $have_37; - var $hold_34 = $hold_33; - var $bits_34 = $bits_33; - __label__ = 206; - break; - } - } while (0); - do { - if (__label__ == 71) { - var $bits_8; - var $hold_8; - var $have_8; - var $next_8; - var $77 = HEAPU32[$17 >> 2]; - var $and319 = $77 & 1024; - var $tobool320 = ($and319 | 0) == 0; - if ($tobool320) { - var $next_10 = $next_8; - var $have_10 = $have_8; - var $88 = $77; - } else { - var $78 = HEAPU32[$21 >> 2]; - var $cmp323 = $78 >>> 0 > $have_8 >>> 0; - var $copy_0 = $cmp323 ? $have_8 : $78; - var $tobool327 = ($copy_0 | 0) == 0; - if ($tobool327) { - var $next_9 = $next_8; - var $have_9 = $have_8; - var $87 = $78; - var $86 = $77; - } else { - var $79 = HEAPU32[$18 >> 2]; - var $cmp330 = ($79 | 0) == 0; - do { - if ($cmp330) { - var $83 = $77; - } else { - var $extra334 = $79 + 16 | 0; - var $80 = HEAP32[$extra334 >> 2]; - var $cmp335 = ($80 | 0) == 0; - if ($cmp335) { - var $83 = $77; - break; - } - var $extra_len339 = $79 + 20 | 0; - var $81 = HEAP32[$extra_len339 >> 2]; - var $sub341 = $81 - $78 | 0; - var $add_ptr = $80 + $sub341 | 0; - var $add344 = $sub341 + $copy_0 | 0; - var $extra_max = $79 + 24 | 0; - var $82 = HEAPU32[$extra_max >> 2]; - var $cmp346 = $add344 >>> 0 > $82 >>> 0; - var $sub350 = $82 - $sub341 | 0; - var $cond351 = $cmp346 ? $sub350 : $copy_0; - _memcpy($add_ptr, $next_8, $cond351, 1); - var $_pre886 = HEAP32[$17 >> 2]; - var $83 = $_pre886; - } - } while (0); - var $83; - var $and354 = $83 & 512; - var $tobool355 = ($and354 | 0) == 0; - if (!$tobool355) { - var $84 = HEAP32[$16 >> 2]; - var $call358 = _crc32($84, $next_8, $copy_0); - HEAP32[$16 >> 2] = $call358; - } - var $sub361 = $have_8 - $copy_0 | 0; - var $add_ptr362 = $next_8 + $copy_0 | 0; - var $85 = HEAP32[$21 >> 2]; - var $sub364 = $85 - $copy_0 | 0; - HEAP32[$21 >> 2] = $sub364; - var $next_9 = $add_ptr362; - var $have_9 = $sub361; - var $87 = $sub364; - var $86 = $83; - } - var $86; - var $87; - var $have_9; - var $next_9; - var $tobool367 = ($87 | 0) == 0; - if (!$tobool367) { - var $ret_8 = $ret_0; - var $next_58 = $next_9; - var $have_58 = $have_9; - var $hold_54 = $hold_8; - var $bits_54 = $bits_8; - var $out_4 = $out_0; - break $_$12; - } - var $next_10 = $next_9; - var $have_10 = $have_9; - var $88 = $86; - } - var $88; - var $have_10; - var $next_10; - HEAP32[$21 >> 2] = 0; - HEAP32[$mode >> 2] = 6; - var $next_11 = $next_10; - var $have_11 = $have_10; - var $hold_9 = $hold_8; - var $bits_9 = $bits_8; - var $89 = $88; - __label__ = 81; - break; - } else if (__label__ == 206) { - var $bits_34; - var $hold_34; - var $have_38; - var $next_38; - var $ret_3; - var $cmp1179 = $have_38 >>> 0 > 5; - var $cmp1182 = $left_0 >>> 0 > 257; - var $or_cond33 = $cmp1179 & $cmp1182; - if ($or_cond33) { - HEAP32[$next_out >> 2] = $put_0; - HEAP32[$avail_out >> 2] = $left_0; - HEAP32[$next_in >> 2] = $next_38; - HEAP32[$avail_in15 >> 2] = $have_38; - HEAP32[$11 >> 2] = $hold_34; - HEAP32[$13 >> 2] = $bits_34; - _inflate_fast($strm, $out_0); - var $144 = HEAP32[$next_out >> 2]; - var $145 = HEAP32[$avail_out >> 2]; - var $146 = HEAP32[$next_in >> 2]; - var $147 = HEAP32[$avail_in15 >> 2]; - var $148 = HEAP32[$11 >> 2]; - var $149 = HEAP32[$13 >> 2]; - var $150 = HEAP32[$mode >> 2]; - var $cmp1204 = ($150 | 0) == 11; - if (!$cmp1204) { - var $ret_0_be = $ret_3; - var $next_0_be = $146; - var $put_0_be = $144; - var $have_0_be = $147; - var $left_0_be = $145; - var $hold_0_be = $148; - var $bits_0_be = $149; - var $out_0_be = $out_0; - __label__ = 268; - break; - } - HEAP32[$25 >> 2] = -1; - var $ret_0_be = $ret_3; - var $next_0_be = $146; - var $put_0_be = $144; - var $have_0_be = $147; - var $left_0_be = $145; - var $hold_0_be = $148; - var $bits_0_be = $149; - var $out_0_be = $out_0; - __label__ = 268; - break; - } - HEAP32[$25 >> 2] = 0; - var $151 = HEAP32[$26 >> 2]; - var $shl1212 = 1 << $151; - var $sub1213 = $shl1212 - 1 | 0; - var $152 = HEAPU32[$27 >> 2]; - var $next_39 = $next_38; - var $have_39 = $have_38; - var $hold_35 = $hold_34; - var $bits_35 = $bits_34; - while (1) { - var $bits_35; - var $hold_35; - var $have_39; - var $next_39; - var $and1214 = $sub1213 & $hold_35; - var $arrayidx1216_1 = $152 + ($and1214 << 2) + 1 | 0; - var $tmp22 = HEAPU8[$arrayidx1216_1]; - var $conv1218 = $tmp22 & 255; - var $cmp1219 = $conv1218 >>> 0 > $bits_35 >>> 0; - if (!$cmp1219) { - break; - } - var $cmp1224 = ($have_39 | 0) == 0; - if ($cmp1224) { - var $ret_8 = $ret_3; - var $next_58 = $next_39; - var $have_58 = 0; - var $hold_54 = $hold_35; - var $bits_54 = $bits_35; - var $out_4 = $out_0; - break $_$12; - } - var $dec1228 = $have_39 - 1 | 0; - var $incdec_ptr1229 = $next_39 + 1 | 0; - var $153 = HEAPU8[$next_39]; - var $conv1230 = $153 & 255; - var $shl1231 = $conv1230 << $bits_35; - var $add1232 = $shl1231 + $hold_35 | 0; - var $add1233 = $bits_35 + 8 | 0; - var $next_39 = $incdec_ptr1229; - var $have_39 = $dec1228; - var $hold_35 = $add1232; - var $bits_35 = $add1233; - } - var $arrayidx1216_0 = $152 + ($and1214 << 2) | 0; - var $tmp21 = HEAPU8[$arrayidx1216_0]; - var $arrayidx1216_2 = $152 + ($and1214 << 2) + 2 | 0; - var $tmp23 = HEAPU16[$arrayidx1216_2 >> 1]; - var $conv1237 = $tmp21 & 255; - var $tobool1238 = $tmp21 << 24 >> 24 == 0; - do { - if ($tobool1238) { - var $next_41 = $next_39; - var $have_41 = $have_39; - var $hold_37 = $hold_35; - var $bits_37 = $bits_35; - var $here_09_0 = 0; - var $here_110_0 = $tmp22; - var $here_211_0 = $tmp23; - var $155 = 0; - } else { - var $and1242 = $conv1237 & 240; - var $cmp1243 = ($and1242 | 0) == 0; - if (!$cmp1243) { - var $next_41 = $next_39; - var $have_41 = $have_39; - var $hold_37 = $hold_35; - var $bits_37 = $bits_35; - var $here_09_0 = $tmp21; - var $here_110_0 = $tmp22; - var $here_211_0 = $tmp23; - var $155 = 0; - break; - } - var $conv1248 = $tmp23 & 65535; - var $add1253 = $conv1218 + $conv1237 | 0; - var $shl1254 = 1 << $add1253; - var $sub1255 = $shl1254 - 1 | 0; - var $next_40 = $next_39; - var $have_40 = $have_39; - var $hold_36 = $hold_35; - var $bits_36 = $bits_35; - while (1) { - var $bits_36; - var $hold_36; - var $have_40; - var $next_40; - var $and1256 = $hold_36 & $sub1255; - var $shr1259 = $and1256 >>> ($conv1218 >>> 0); - var $add1260 = $shr1259 + $conv1248 | 0; - var $arrayidx1262_1 = $152 + ($add1260 << 2) + 1 | 0; - var $tmp19 = HEAPU8[$arrayidx1262_1]; - var $conv1266 = $tmp19 & 255; - var $add1267 = $conv1266 + $conv1218 | 0; - var $cmp1268 = $add1267 >>> 0 > $bits_36 >>> 0; - if (!$cmp1268) { - break; - } - var $cmp1273 = ($have_40 | 0) == 0; - if ($cmp1273) { - var $ret_8 = $ret_3; - var $next_58 = $next_40; - var $have_58 = 0; - var $hold_54 = $hold_36; - var $bits_54 = $bits_36; - var $out_4 = $out_0; - break $_$12; - } - var $dec1277 = $have_40 - 1 | 0; - var $incdec_ptr1278 = $next_40 + 1 | 0; - var $154 = HEAPU8[$next_40]; - var $conv1279 = $154 & 255; - var $shl1280 = $conv1279 << $bits_36; - var $add1281 = $shl1280 + $hold_36 | 0; - var $add1282 = $bits_36 + 8 | 0; - var $next_40 = $incdec_ptr1278; - var $have_40 = $dec1277; - var $hold_36 = $add1281; - var $bits_36 = $add1282; - } - var $arrayidx1262_2 = $152 + ($add1260 << 2) + 2 | 0; - var $arrayidx1262_0 = $152 + ($add1260 << 2) | 0; - var $tmp20 = HEAP16[$arrayidx1262_2 >> 1]; - var $tmp18 = HEAP8[$arrayidx1262_0]; - var $shr1289 = $hold_36 >>> ($conv1218 >>> 0); - var $sub1292 = $bits_36 - $conv1218 | 0; - HEAP32[$25 >> 2] = $conv1218; - var $next_41 = $next_40; - var $have_41 = $have_40; - var $hold_37 = $shr1289; - var $bits_37 = $sub1292; - var $here_09_0 = $tmp18; - var $here_110_0 = $tmp19; - var $here_211_0 = $tmp20; - var $155 = $conv1218; - } - } while (0); - var $155; - var $here_211_0; - var $here_110_0; - var $here_09_0; - var $bits_37; - var $hold_37; - var $have_41; - var $next_41; - var $conv1302 = $here_110_0 & 255; - var $shr1303 = $hold_37 >>> ($conv1302 >>> 0); - var $sub1306 = $bits_37 - $conv1302 | 0; - var $add1312 = $155 + $conv1302 | 0; - HEAP32[$25 >> 2] = $add1312; - var $conv1314 = $here_211_0 & 65535; - HEAP32[$21 >> 2] = $conv1314; - var $conv1317 = $here_09_0 & 255; - var $cmp1318 = $here_09_0 << 24 >> 24 == 0; - if ($cmp1318) { - HEAP32[$mode >> 2] = 25; - var $ret_0_be = $ret_3; - var $next_0_be = $next_41; - var $put_0_be = $put_0; - var $have_0_be = $have_41; - var $left_0_be = $left_0; - var $hold_0_be = $shr1303; - var $bits_0_be = $sub1306; - var $out_0_be = $out_0; - __label__ = 268; - break; - } - var $and1325 = $conv1317 & 32; - var $tobool1326 = ($and1325 | 0) == 0; - if (!$tobool1326) { - HEAP32[$25 >> 2] = -1; - HEAP32[$mode >> 2] = 11; - var $ret_0_be = $ret_3; - var $next_0_be = $next_41; - var $put_0_be = $put_0; - var $have_0_be = $have_41; - var $left_0_be = $left_0; - var $hold_0_be = $shr1303; - var $bits_0_be = $sub1306; - var $out_0_be = $out_0; - __label__ = 268; - break; - } - var $and1333 = $conv1317 & 64; - var $tobool1334 = ($and1333 | 0) == 0; - if ($tobool1334) { - var $and1341 = $conv1317 & 15; - HEAP32[$28 >> 2] = $and1341; - HEAP32[$mode >> 2] = 21; - var $ret_4 = $ret_3; - var $next_42 = $next_41; - var $have_42 = $have_41; - var $hold_38 = $shr1303; - var $bits_38 = $sub1306; - var $156 = $and1341; - __label__ = 227; - break; - } - HEAP32[$msg >> 2] = STRING_TABLE.__str2171 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $ret_3; - var $next_0_be = $next_41; - var $put_0_be = $put_0; - var $have_0_be = $have_41; - var $left_0_be = $left_0; - var $hold_0_be = $shr1303; - var $bits_0_be = $sub1306; - var $out_0_be = $out_0; - __label__ = 268; - break; - } - } while (0); - do { - if (__label__ == 81) { - var $89; - var $bits_9; - var $hold_9; - var $have_11; - var $next_11; - var $and375 = $89 & 2048; - var $tobool376 = ($and375 | 0) == 0; - do { - if ($tobool376) { - var $98 = HEAP32[$18 >> 2]; - var $cmp424 = ($98 | 0) == 0; - if ($cmp424) { - var $next_12 = $next_11; - var $have_12 = $have_11; - break; - } - var $name428 = $98 + 28 | 0; - HEAP32[$name428 >> 2] = 0; - var $next_12 = $next_11; - var $have_12 = $have_11; - } else { - var $cmp378 = ($have_11 | 0) == 0; - if ($cmp378) { - var $ret_8 = $ret_0; - var $next_58 = $next_11; - var $have_58 = 0; - var $hold_54 = $hold_9; - var $bits_54 = $bits_9; - var $out_4 = $out_0; - break $_$12; - } - var $copy_1 = 0; - while (1) { - var $copy_1; - var $inc = $copy_1 + 1 | 0; - var $arrayidx383 = $next_11 + $copy_1 | 0; - var $90 = HEAP8[$arrayidx383]; - var $91 = HEAP32[$18 >> 2]; - var $cmp386 = ($91 | 0) == 0; - do { - if (!$cmp386) { - var $name = $91 + 28 | 0; - var $92 = HEAP32[$name >> 2]; - var $cmp390 = ($92 | 0) == 0; - if ($cmp390) { - break; - } - var $93 = HEAPU32[$21 >> 2]; - var $name_max = $91 + 32 | 0; - var $94 = HEAPU32[$name_max >> 2]; - var $cmp395 = $93 >>> 0 < $94 >>> 0; - if (!$cmp395) { - break; - } - var $inc400 = $93 + 1 | 0; - HEAP32[$21 >> 2] = $inc400; - var $95 = HEAP32[$name >> 2]; - var $arrayidx403 = $95 + $93 | 0; - HEAP8[$arrayidx403] = $90; - } - } while (0); - var $tobool405 = $90 << 24 >> 24 != 0; - var $cmp406 = $inc >>> 0 < $have_11 >>> 0; - var $or_cond31 = $tobool405 & $cmp406; - if (!$or_cond31) { - break; - } - var $copy_1 = $inc; - } - var $96 = HEAP32[$17 >> 2]; - var $and410 = $96 & 512; - var $tobool411 = ($and410 | 0) == 0; - if (!$tobool411) { - var $97 = HEAP32[$16 >> 2]; - var $call414 = _crc32($97, $next_11, $inc); - HEAP32[$16 >> 2] = $call414; - } - var $sub417 = $have_11 - $inc | 0; - var $add_ptr418 = $next_11 + $inc | 0; - if ($tobool405) { - var $ret_8 = $ret_0; - var $next_58 = $add_ptr418; - var $have_58 = $sub417; - var $hold_54 = $hold_9; - var $bits_54 = $bits_9; - var $out_4 = $out_0; - break $_$12; - } - var $next_12 = $add_ptr418; - var $have_12 = $sub417; - } - } while (0); - var $have_12; - var $next_12; - HEAP32[$21 >> 2] = 0; - HEAP32[$mode >> 2] = 7; - var $next_13 = $next_12; - var $have_13 = $have_12; - var $hold_10 = $hold_9; - var $bits_10 = $bits_9; - __label__ = 94; - break; - } else if (__label__ == 227) { - var $156; - var $bits_38; - var $hold_38; - var $have_42; - var $next_42; - var $ret_4; - var $tobool1346 = ($156 | 0) == 0; - if ($tobool1346) { - var $_pre890 = HEAP32[$21 >> 2]; - var $next_44 = $next_42; - var $have_44 = $have_42; - var $hold_40 = $hold_38; - var $bits_40 = $bits_38; - var $160 = $_pre890; - } else { - var $next_43 = $next_42; - var $have_43 = $have_42; - var $hold_39 = $hold_38; - var $bits_39 = $bits_38; - while (1) { - var $bits_39; - var $hold_39; - var $have_43; - var $next_43; - var $cmp1351 = $bits_39 >>> 0 < $156 >>> 0; - if (!$cmp1351) { - break; - } - var $cmp1355 = ($have_43 | 0) == 0; - if ($cmp1355) { - var $ret_8 = $ret_4; - var $next_58 = $next_43; - var $have_58 = 0; - var $hold_54 = $hold_39; - var $bits_54 = $bits_39; - var $out_4 = $out_0; - break $_$12; - } - var $dec1359 = $have_43 - 1 | 0; - var $incdec_ptr1360 = $next_43 + 1 | 0; - var $157 = HEAPU8[$next_43]; - var $conv1361 = $157 & 255; - var $shl1362 = $conv1361 << $bits_39; - var $add1363 = $shl1362 + $hold_39 | 0; - var $add1364 = $bits_39 + 8 | 0; - var $next_43 = $incdec_ptr1360; - var $have_43 = $dec1359; - var $hold_39 = $add1363; - var $bits_39 = $add1364; - } - var $shl1371 = 1 << $156; - var $sub1372 = $shl1371 - 1 | 0; - var $and1373 = $sub1372 & $hold_39; - var $158 = HEAP32[$21 >> 2]; - var $add1375 = $158 + $and1373 | 0; - HEAP32[$21 >> 2] = $add1375; - var $shr1378 = $hold_39 >>> ($156 >>> 0); - var $sub1380 = $bits_39 - $156 | 0; - var $159 = HEAP32[$25 >> 2]; - var $add1385 = $159 + $156 | 0; - HEAP32[$25 >> 2] = $add1385; - var $next_44 = $next_43; - var $have_44 = $have_43; - var $hold_40 = $shr1378; - var $bits_40 = $sub1380; - var $160 = $add1375; - } - var $160; - var $bits_40; - var $hold_40; - var $have_44; - var $next_44; - HEAP32[$29 >> 2] = $160; - HEAP32[$mode >> 2] = 22; - var $ret_5_ph = $ret_4; - var $next_45_ph = $next_44; - var $have_45_ph = $have_44; - var $hold_41_ph = $hold_40; - var $bits_41_ph = $bits_40; - __label__ = 234; - break; - } - } while (0); - do { - if (__label__ == 94) { - var $bits_10; - var $hold_10; - var $have_13; - var $next_13; - var $99 = HEAP32[$17 >> 2]; - var $and435 = $99 & 4096; - var $tobool436 = ($and435 | 0) == 0; - do { - if ($tobool436) { - var $108 = HEAP32[$18 >> 2]; - var $cmp488 = ($108 | 0) == 0; - if ($cmp488) { - var $next_14 = $next_13; - var $have_14 = $have_13; - break; - } - var $comment492 = $108 + 36 | 0; - HEAP32[$comment492 >> 2] = 0; - var $next_14 = $next_13; - var $have_14 = $have_13; - } else { - var $cmp438 = ($have_13 | 0) == 0; - if ($cmp438) { - var $ret_8 = $ret_0; - var $next_58 = $next_13; - var $have_58 = 0; - var $hold_54 = $hold_10; - var $bits_54 = $bits_10; - var $out_4 = $out_0; - break $_$12; - } - var $copy_2 = 0; - while (1) { - var $copy_2; - var $inc443 = $copy_2 + 1 | 0; - var $arrayidx444 = $next_13 + $copy_2 | 0; - var $100 = HEAP8[$arrayidx444]; - var $101 = HEAP32[$18 >> 2]; - var $cmp447 = ($101 | 0) == 0; - do { - if (!$cmp447) { - var $comment = $101 + 36 | 0; - var $102 = HEAP32[$comment >> 2]; - var $cmp451 = ($102 | 0) == 0; - if ($cmp451) { - break; - } - var $103 = HEAPU32[$21 >> 2]; - var $comm_max = $101 + 40 | 0; - var $104 = HEAPU32[$comm_max >> 2]; - var $cmp456 = $103 >>> 0 < $104 >>> 0; - if (!$cmp456) { - break; - } - var $inc461 = $103 + 1 | 0; - HEAP32[$21 >> 2] = $inc461; - var $105 = HEAP32[$comment >> 2]; - var $arrayidx464 = $105 + $103 | 0; - HEAP8[$arrayidx464] = $100; - } - } while (0); - var $tobool467 = $100 << 24 >> 24 != 0; - var $cmp469 = $inc443 >>> 0 < $have_13 >>> 0; - var $or_cond32 = $tobool467 & $cmp469; - if (!$or_cond32) { - break; - } - var $copy_2 = $inc443; - } - var $106 = HEAP32[$17 >> 2]; - var $and474 = $106 & 512; - var $tobool475 = ($and474 | 0) == 0; - if (!$tobool475) { - var $107 = HEAP32[$16 >> 2]; - var $call478 = _crc32($107, $next_13, $inc443); - HEAP32[$16 >> 2] = $call478; - } - var $sub481 = $have_13 - $inc443 | 0; - var $add_ptr482 = $next_13 + $inc443 | 0; - if ($tobool467) { - var $ret_8 = $ret_0; - var $next_58 = $add_ptr482; - var $have_58 = $sub481; - var $hold_54 = $hold_10; - var $bits_54 = $bits_10; - var $out_4 = $out_0; - break $_$12; - } - var $next_14 = $add_ptr482; - var $have_14 = $sub481; - } - } while (0); - var $have_14; - var $next_14; - HEAP32[$mode >> 2] = 8; - var $next_15 = $next_14; - var $have_15 = $have_14; - var $hold_11 = $hold_10; - var $bits_11 = $bits_10; - __label__ = 107; - break; - } else if (__label__ == 234) { - var $bits_41_ph; - var $hold_41_ph; - var $have_45_ph; - var $next_45_ph; - var $ret_5_ph; - var $161 = HEAP32[$47 >> 2]; - var $shl1392 = 1 << $161; - var $sub1393 = $shl1392 - 1 | 0; - var $162 = HEAPU32[$48 >> 2]; - var $next_45 = $next_45_ph; - var $have_45 = $have_45_ph; - var $hold_41 = $hold_41_ph; - var $bits_41 = $bits_41_ph; - while (1) { - var $bits_41; - var $hold_41; - var $have_45; - var $next_45; - var $and1394 = $sub1393 & $hold_41; - var $arrayidx1396_1 = $162 + ($and1394 << 2) + 1 | 0; - var $tmp16 = HEAPU8[$arrayidx1396_1]; - var $conv1398 = $tmp16 & 255; - var $cmp1399 = $conv1398 >>> 0 > $bits_41 >>> 0; - if (!$cmp1399) { - break; - } - var $cmp1404 = ($have_45 | 0) == 0; - if ($cmp1404) { - var $ret_8 = $ret_5_ph; - var $next_58 = $next_45; - var $have_58 = 0; - var $hold_54 = $hold_41; - var $bits_54 = $bits_41; - var $out_4 = $out_0; - break $_$12; - } - var $dec1408 = $have_45 - 1 | 0; - var $incdec_ptr1409 = $next_45 + 1 | 0; - var $163 = HEAPU8[$next_45]; - var $conv1410 = $163 & 255; - var $shl1411 = $conv1410 << $bits_41; - var $add1412 = $shl1411 + $hold_41 | 0; - var $add1413 = $bits_41 + 8 | 0; - var $next_45 = $incdec_ptr1409; - var $have_45 = $dec1408; - var $hold_41 = $add1412; - var $bits_41 = $add1413; - } - var $arrayidx1396_0 = $162 + ($and1394 << 2) | 0; - var $tmp15 = HEAPU8[$arrayidx1396_0]; - var $arrayidx1396_2 = $162 + ($and1394 << 2) + 2 | 0; - var $tmp17 = HEAPU16[$arrayidx1396_2 >> 1]; - var $conv1418 = $tmp15 & 255; - var $and1419 = $conv1418 & 240; - var $cmp1420 = ($and1419 | 0) == 0; - if ($cmp1420) { - var $conv1425 = $tmp17 & 65535; - var $add1430 = $conv1398 + $conv1418 | 0; - var $shl1431 = 1 << $add1430; - var $sub1432 = $shl1431 - 1 | 0; - var $next_46 = $next_45; - var $have_46 = $have_45; - var $hold_42 = $hold_41; - var $bits_42 = $bits_41; - while (1) { - var $bits_42; - var $hold_42; - var $have_46; - var $next_46; - var $and1433 = $hold_42 & $sub1432; - var $shr1436 = $and1433 >>> ($conv1398 >>> 0); - var $add1437 = $shr1436 + $conv1425 | 0; - var $arrayidx1439_1 = $162 + ($add1437 << 2) + 1 | 0; - var $tmp13 = HEAPU8[$arrayidx1439_1]; - var $conv1443 = $tmp13 & 255; - var $add1444 = $conv1443 + $conv1398 | 0; - var $cmp1445 = $add1444 >>> 0 > $bits_42 >>> 0; - if (!$cmp1445) { - break; - } - var $cmp1450 = ($have_46 | 0) == 0; - if ($cmp1450) { - var $ret_8 = $ret_5_ph; - var $next_58 = $next_46; - var $have_58 = 0; - var $hold_54 = $hold_42; - var $bits_54 = $bits_42; - var $out_4 = $out_0; - break $_$12; - } - var $dec1454 = $have_46 - 1 | 0; - var $incdec_ptr1455 = $next_46 + 1 | 0; - var $164 = HEAPU8[$next_46]; - var $conv1456 = $164 & 255; - var $shl1457 = $conv1456 << $bits_42; - var $add1458 = $shl1457 + $hold_42 | 0; - var $add1459 = $bits_42 + 8 | 0; - var $next_46 = $incdec_ptr1455; - var $have_46 = $dec1454; - var $hold_42 = $add1458; - var $bits_42 = $add1459; - } - var $arrayidx1439_2 = $162 + ($add1437 << 2) + 2 | 0; - var $arrayidx1439_0 = $162 + ($add1437 << 2) | 0; - var $tmp14 = HEAP16[$arrayidx1439_2 >> 1]; - var $tmp12 = HEAP8[$arrayidx1439_0]; - var $shr1466 = $hold_42 >>> ($conv1398 >>> 0); - var $sub1469 = $bits_42 - $conv1398 | 0; - var $165 = HEAP32[$25 >> 2]; - var $add1475 = $165 + $conv1398 | 0; - HEAP32[$25 >> 2] = $add1475; - var $next_47 = $next_46; - var $have_47 = $have_46; - var $hold_43 = $shr1466; - var $bits_43 = $sub1469; - var $here_09_1 = $tmp12; - var $here_110_1 = $tmp13; - var $here_211_1 = $tmp14; - var $166 = $add1475; - } else { - var $_pre893 = HEAP32[$25 >> 2]; - var $next_47 = $next_45; - var $have_47 = $have_45; - var $hold_43 = $hold_41; - var $bits_43 = $bits_41; - var $here_09_1 = $tmp15; - var $here_110_1 = $tmp16; - var $here_211_1 = $tmp17; - var $166 = $_pre893; - } - var $166; - var $here_211_1; - var $here_110_1; - var $here_09_1; - var $bits_43; - var $hold_43; - var $have_47; - var $next_47; - var $conv1479 = $here_110_1 & 255; - var $shr1480 = $hold_43 >>> ($conv1479 >>> 0); - var $sub1483 = $bits_43 - $conv1479 | 0; - var $add1489 = $166 + $conv1479 | 0; - HEAP32[$25 >> 2] = $add1489; - var $conv1491 = $here_09_1 & 255; - var $and1492 = $conv1491 & 64; - var $tobool1493 = ($and1492 | 0) == 0; - if ($tobool1493) { - var $conv1499 = $here_211_1 & 65535; - HEAP32[$30 >> 2] = $conv1499; - var $and1502 = $conv1491 & 15; - HEAP32[$28 >> 2] = $and1502; - HEAP32[$mode >> 2] = 23; - var $ret_6 = $ret_5_ph; - var $next_48 = $next_47; - var $have_48 = $have_47; - var $hold_44 = $shr1480; - var $bits_44 = $sub1483; - var $167 = $and1502; - __label__ = 248; - break; - } - HEAP32[$msg >> 2] = STRING_TABLE.__str1170 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $ret_5_ph; - var $next_0_be = $next_47; - var $put_0_be = $put_0; - var $have_0_be = $have_47; - var $left_0_be = $left_0; - var $hold_0_be = $shr1480; - var $bits_0_be = $sub1483; - var $out_0_be = $out_0; - __label__ = 268; + } + var $103 = HEAPU32[$21 >> 2]; + var $comm_max = $101 + 40 | 0; + var $104 = HEAPU32[$comm_max >> 2]; + var $cmp456 = $103 >>> 0 < $104 >>> 0; + if (!$cmp456) { break; + } + var $inc461 = $103 + 1 | 0; + HEAP32[$21 >> 2] = $inc461; + var $105 = HEAP32[$comment >> 2]; + var $arrayidx464 = $105 + $103 | 0; + HEAP8[$arrayidx464] = $100; } - } while (0); - $_$359 : do { - if (__label__ == 107) { - var $bits_11; - var $hold_11; - var $have_15; - var $next_15; - var $109 = HEAPU32[$17 >> 2]; - var $and498 = $109 & 512; - var $tobool499 = ($and498 | 0) == 0; - do { - if (!$tobool499) { - var $next_16 = $next_15; - var $have_16 = $have_15; - var $hold_12 = $hold_11; - var $bits_12 = $bits_11; - while (1) { - var $bits_12; - var $hold_12; - var $have_16; - var $next_16; - var $cmp503 = $bits_12 >>> 0 < 16; - if (!$cmp503) { - break; - } - var $cmp507 = ($have_16 | 0) == 0; - if ($cmp507) { - var $ret_8 = $ret_0; - var $next_58 = $next_16; - var $have_58 = 0; - var $hold_54 = $hold_12; - var $bits_54 = $bits_12; - var $out_4 = $out_0; - break $_$12; - } - var $dec511 = $have_16 - 1 | 0; - var $incdec_ptr512 = $next_16 + 1 | 0; - var $110 = HEAPU8[$next_16]; - var $conv513 = $110 & 255; - var $shl514 = $conv513 << $bits_12; - var $add515 = $shl514 + $hold_12 | 0; - var $add516 = $bits_12 + 8 | 0; - var $next_16 = $incdec_ptr512; - var $have_16 = $dec511; - var $hold_12 = $add515; - var $bits_12 = $add516; - } - var $111 = HEAP32[$16 >> 2]; - var $and523 = $111 & 65535; - var $cmp524 = ($hold_12 | 0) == ($and523 | 0); - if ($cmp524) { - var $next_17 = $next_16; - var $have_17 = $have_16; - var $hold_13 = 0; - var $bits_13 = 0; - break; - } - HEAP32[$msg >> 2] = STRING_TABLE.__str5102 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $ret_0; - var $next_0_be = $next_16; - var $put_0_be = $put_0; - var $have_0_be = $have_16; - var $left_0_be = $left_0; - var $hold_0_be = $hold_12; - var $bits_0_be = $bits_12; - var $out_0_be = $out_0; - __label__ = 268; - break $_$359; - } - var $next_17 = $next_15; - var $have_17 = $have_15; - var $hold_13 = $hold_11; - var $bits_13 = $bits_11; - } while (0); - var $bits_13; - var $hold_13; - var $have_17; - var $next_17; - var $112 = HEAPU32[$18 >> 2]; - var $cmp535 = ($112 | 0) == 0; - if (!$cmp535) { - var $shr53930 = $109 >>> 9; - var $and540 = $shr53930 & 1; - var $hcrc = $112 + 44 | 0; - HEAP32[$hcrc >> 2] = $and540; - var $113 = HEAP32[$18 >> 2]; - var $done543 = $113 + 48 | 0; - HEAP32[$done543 >> 2] = 1; - } - var $call545 = _crc32(0, 0, 0); - HEAP32[$16 >> 2] = $call545; - HEAP32[$adler >> 2] = $call545; - HEAP32[$mode >> 2] = 11; - var $ret_0_be = $ret_0; - var $next_0_be = $next_17; - var $put_0_be = $put_0; - var $have_0_be = $have_17; - var $left_0_be = $left_0; - var $hold_0_be = $hold_13; - var $bits_0_be = $bits_13; - var $out_0_be = $out_0; - __label__ = 268; - break; - } else if (__label__ == 248) { - var $167; - var $bits_44; - var $hold_44; - var $have_48; - var $next_48; - var $ret_6; - var $tobool1507 = ($167 | 0) == 0; - if ($tobool1507) { - var $next_50 = $next_48; - var $have_50 = $have_48; - var $hold_46 = $hold_44; - var $bits_46 = $bits_44; - } else { - var $next_49 = $next_48; - var $have_49 = $have_48; - var $hold_45 = $hold_44; - var $bits_45 = $bits_44; - while (1) { - var $bits_45; - var $hold_45; - var $have_49; - var $next_49; - var $cmp1512 = $bits_45 >>> 0 < $167 >>> 0; - if (!$cmp1512) { - break; - } - var $cmp1516 = ($have_49 | 0) == 0; - if ($cmp1516) { - var $ret_8 = $ret_6; - var $next_58 = $next_49; - var $have_58 = 0; - var $hold_54 = $hold_45; - var $bits_54 = $bits_45; - var $out_4 = $out_0; - break $_$12; - } - // XXX first chunk with a bug-causing difference - var $dec1520 = $have_49 - 1 | 0; - var $incdec_ptr1521 = $next_49 + 1 | 0; - var $168 = HEAPU8[$next_49]; - var $conv1522 = $168 & 255; - var $shl1523 = $conv1522 << $bits_45; - var $add1524 = $shl1523 + $hold_45 | 0; - var $add1525 = $bits_45 + 8 | 0; - var $next_49 = $incdec_ptr1521; - var $have_49 = $dec1520; - var $hold_45 = $add1524; - var $bits_45 = $add1525; - } - var $shl1532 = 1 << $167; - var $sub1533 = $shl1532 - 1 | 0; - var $and1534 = $sub1533 & $hold_45; - var $169 = HEAP32[$30 >> 2]; - var $add1536 = $169 + $and1534 | 0; - HEAP32[$30 >> 2] = $add1536; - var $shr1539 = $hold_45 >>> ($167 >>> 0); - var $sub1541 = $bits_45 - $167 | 0; - var $170 = HEAP32[$25 >> 2]; - var $add1546 = $170 + $167 | 0; - HEAP32[$25 >> 2] = $add1546; - var $next_50 = $next_49; - var $have_50 = $have_49; - var $hold_46 = $shr1539; - var $bits_46 = $sub1541; - } - var $bits_46; - var $hold_46; - var $have_50; - var $next_50; - HEAP32[$mode >> 2] = 24; - var $ret_7 = $ret_6; - var $next_51 = $next_50; - var $have_51 = $have_50; - var $hold_47 = $hold_46; - var $bits_47 = $bits_46; - __label__ = 254; - break; - } - } while (0); - $_$380 : do { - if (__label__ == 254) { - var $bits_47; - var $hold_47; - var $have_51; - var $next_51; - var $ret_7; - var $cmp1550 = ($left_0 | 0) == 0; - if ($cmp1550) { - var $ret_8 = $ret_7; - var $next_58 = $next_51; - var $have_58 = $have_51; - var $hold_54 = $hold_47; - var $bits_54 = $bits_47; - var $out_4 = $out_0; - break $_$12; - } - var $sub1554 = $out_0 - $left_0 | 0; - var $171 = HEAPU32[$30 >> 2]; - var $cmp1556 = $171 >>> 0 > $sub1554 >>> 0; - do { - if ($cmp1556) { - var $sub1560 = $171 - $sub1554 | 0; - var $172 = HEAPU32[$31 >> 2]; - var $cmp1561 = $sub1560 >>> 0 > $172 >>> 0; - do { - if ($cmp1561) { - var $173 = HEAP32[$32 >> 2]; - var $tobool1564 = ($173 | 0) == 0; - if ($tobool1564) { - break; - } - HEAP32[$msg >> 2] = STRING_TABLE.__str169 | 0; - HEAP32[$mode >> 2] = 29; - var $ret_0_be = $ret_7; - var $next_0_be = $next_51; - var $put_0_be = $put_0; - var $have_0_be = $have_51; - var $left_0_be = $left_0; - var $hold_0_be = $hold_47; - var $bits_0_be = $bits_47; - var $out_0_be = $out_0; - break $_$380; - } - } while (0); - var $174 = HEAPU32[$33 >> 2]; - var $cmp1570 = $sub1560 >>> 0 > $174 >>> 0; - if ($cmp1570) { - var $sub1574 = $sub1560 - $174 | 0; - var $175 = HEAP32[$34 >> 2]; - var $176 = HEAP32[$35 >> 2]; - var $sub1575 = $176 - $sub1574 | 0; - var $add_ptr1576 = $175 + $sub1575 | 0; - var $from_0 = $add_ptr1576; - var $copy_7 = $sub1574; - } else { - var $177 = HEAP32[$34 >> 2]; - var $sub1580 = $174 - $sub1560 | 0; - var $add_ptr1581 = $177 + $sub1580 | 0; - var $from_0 = $add_ptr1581; - var $copy_7 = $sub1560; - } - var $copy_7; - var $from_0; - var $178 = HEAPU32[$21 >> 2]; - var $cmp1584 = $copy_7 >>> 0 > $178 >>> 0; - if (!$cmp1584) { - var $from_1 = $from_0; - var $copy_8 = $copy_7; - var $180 = $178; - break; - } - var $from_1 = $from_0; - var $copy_8 = $178; - var $180 = $178; - } else { - var $idx_neg = -$171 | 0; - var $add_ptr1591 = $put_0 + $idx_neg | 0; - var $179 = HEAP32[$21 >> 2]; - var $from_1 = $add_ptr1591; - var $copy_8 = $179; - var $180 = $179; - } - } while (0); - var $180; - var $copy_8; - var $from_1; - var $cmp1594 = $copy_8 >>> 0 > $left_0 >>> 0; - var $copy_9 = $cmp1594 ? $left_0 : $copy_8; - var $sub1600 = $180 - $copy_9 | 0; - HEAP32[$21 >> 2] = $sub1600; - var $181 = $copy_8 ^ -1; - var $182 = $left_0 ^ -1; - var $183 = $181 >>> 0 > $182 >>> 0; - var $umax = $183 ? $181 : $182; - var $from_2 = $from_1; - var $put_1 = $put_0; - var $copy_10 = $copy_9; - while (1) { - var $copy_10; - var $put_1; - var $from_2; - var $incdec_ptr1602 = $from_2 + 1 | 0; - var $184 = HEAP8[$from_2]; - var $incdec_ptr1603 = $put_1 + 1 | 0; - HEAP8[$put_1] = $184; - var $dec1605 = $copy_10 - 1 | 0; - var $tobool1606 = ($dec1605 | 0) == 0; - if ($tobool1606) { - break; - } - var $from_2 = $incdec_ptr1602; - var $put_1 = $incdec_ptr1603; - var $copy_10 = $dec1605; - } - var $sub1598 = $left_0 - $copy_9 | 0; - var $scevgep_sum = $umax ^ -1; - var $scevgep632 = $put_0 + $scevgep_sum | 0; - var $185 = HEAP32[$21 >> 2]; - var $cmp1609 = ($185 | 0) == 0; - if (!$cmp1609) { - var $ret_0_be = $ret_7; - var $next_0_be = $next_51; - var $put_0_be = $scevgep632; - var $have_0_be = $have_51; - var $left_0_be = $sub1598; - var $hold_0_be = $hold_47; - var $bits_0_be = $bits_47; - var $out_0_be = $out_0; - break; - } - HEAP32[$mode >> 2] = 20; - var $ret_0_be = $ret_7; - var $next_0_be = $next_51; - var $put_0_be = $scevgep632; - var $have_0_be = $have_51; - var $left_0_be = $sub1598; - var $hold_0_be = $hold_47; - var $bits_0_be = $bits_47; - var $out_0_be = $out_0; - } - } while (0); - var $out_0_be; - var $bits_0_be; - var $hold_0_be; - var $left_0_be; - var $have_0_be; - var $put_0_be; - var $next_0_be; - var $ret_0_be; - var $_pre883 = HEAP32[$mode >> 2]; - var $ret_0 = $ret_0_be; - var $next_0 = $next_0_be; - var $put_0 = $put_0_be; - var $have_0 = $have_0_be; - var $left_0 = $left_0_be; - var $hold_0 = $hold_0_be; - var $bits_0 = $bits_0_be; - var $out_0 = $out_0_be; - var $49 = $_pre883; + } while (0); + var $tobool467 = $100 << 24 >> 24 != 0; + var $cmp469 = $inc443 >>> 0 < $have_13 >>> 0; + var $or_cond32 = $tobool467 & $cmp469; + if (!$or_cond32) { + break; + } + var $copy_2 = $inc443; + } + var $106 = HEAP32[$17 >> 2]; + var $and474 = $106 & 512; + var $tobool475 = ($and474 | 0) == 0; + if (!$tobool475) { + var $107 = HEAP32[$16 >> 2]; + var $call478 = _crc32($107, $next_13, $inc443); + HEAP32[$16 >> 2] = $call478; + } + var $sub481 = $have_13 - $inc443 | 0; + var $add_ptr482 = $next_13 + $inc443 | 0; + if ($tobool467) { + var $ret_8 = $ret_0; + var $next_58 = $add_ptr482; + var $have_58 = $sub481; + var $hold_54 = $hold_10; + var $bits_54 = $bits_10; + var $out_4 = $out_0; + break $_$12; + } + var $next_14 = $add_ptr482; + var $have_14 = $sub481; + } + } while (0); + var $have_14; + var $next_14; + HEAP32[$mode >> 2] = 8; + var $next_15 = $next_14; + var $have_15 = $have_14; + var $hold_11 = $hold_10; + var $bits_11 = $bits_10; + __label__ = 107; + break; + } else if (__label__ == 234) { + var $bits_41_ph; + var $hold_41_ph; + var $have_45_ph; + var $next_45_ph; + var $ret_5_ph; + var $161 = HEAP32[$47 >> 2]; + var $shl1392 = 1 << $161; + var $sub1393 = $shl1392 - 1 | 0; + var $162 = HEAPU32[$48 >> 2]; + var $next_45 = $next_45_ph; + var $have_45 = $have_45_ph; + var $hold_41 = $hold_41_ph; + var $bits_41 = $bits_41_ph; + while (1) { + var $bits_41; + var $hold_41; + var $have_45; + var $next_45; + var $and1394 = $sub1393 & $hold_41; + var $arrayidx1396_1 = $162 + ($and1394 << 2) + 1 | 0; + var $tmp16 = HEAPU8[$arrayidx1396_1]; + var $conv1398 = $tmp16 & 255; + var $cmp1399 = $conv1398 >>> 0 > $bits_41 >>> 0; + if (!$cmp1399) { + break; + } + var $cmp1404 = ($have_45 | 0) == 0; + if ($cmp1404) { + var $ret_8 = $ret_5_ph; + var $next_58 = $next_45; + var $have_58 = 0; + var $hold_54 = $hold_41; + var $bits_54 = $bits_41; + var $out_4 = $out_0; + break $_$12; + } + var $dec1408 = $have_45 - 1 | 0; + var $incdec_ptr1409 = $next_45 + 1 | 0; + var $163 = HEAPU8[$next_45]; + var $conv1410 = $163 & 255; + var $shl1411 = $conv1410 << $bits_41; + var $add1412 = $shl1411 + $hold_41 | 0; + var $add1413 = $bits_41 + 8 | 0; + var $next_45 = $incdec_ptr1409; + var $have_45 = $dec1408; + var $hold_41 = $add1412; + var $bits_41 = $add1413; } - var $out_4; - var $bits_54; - var $hold_54; - var $have_58; - var $next_58; - var $ret_8; - HEAP32[$next_out >> 2] = $put_0; - HEAP32[$avail_out >> 2] = $left_0; - HEAP32[$next_in >> 2] = $next_58; - HEAP32[$avail_in15 >> 2] = $have_58; - HEAP32[$11 >> 2] = $hold_54; - HEAP32[$13 >> 2] = $bits_54; - var $199 = HEAP32[$35 >> 2]; - var $tobool1755 = ($199 | 0) == 0; + var $arrayidx1396_0 = $162 + ($and1394 << 2) | 0; + var $tmp15 = HEAPU8[$arrayidx1396_0]; + var $arrayidx1396_2 = $162 + ($and1394 << 2) + 2 | 0; + var $tmp17 = HEAPU16[$arrayidx1396_2 >> 1]; + var $conv1418 = $tmp15 & 255; + var $and1419 = $conv1418 & 240; + var $cmp1420 = ($and1419 | 0) == 0; + if ($cmp1420) { + var $conv1425 = $tmp17 & 65535; + var $add1430 = $conv1398 + $conv1418 | 0; + var $shl1431 = 1 << $add1430; + var $sub1432 = $shl1431 - 1 | 0; + var $next_46 = $next_45; + var $have_46 = $have_45; + var $hold_42 = $hold_41; + var $bits_42 = $bits_41; + while (1) { + var $bits_42; + var $hold_42; + var $have_46; + var $next_46; + var $and1433 = $hold_42 & $sub1432; + var $shr1436 = $and1433 >>> ($conv1398 >>> 0); + var $add1437 = $shr1436 + $conv1425 | 0; + var $arrayidx1439_1 = $162 + ($add1437 << 2) + 1 | 0; + var $tmp13 = HEAPU8[$arrayidx1439_1]; + var $conv1443 = $tmp13 & 255; + var $add1444 = $conv1443 + $conv1398 | 0; + var $cmp1445 = $add1444 >>> 0 > $bits_42 >>> 0; + if (!$cmp1445) { + break; + } + var $cmp1450 = ($have_46 | 0) == 0; + if ($cmp1450) { + var $ret_8 = $ret_5_ph; + var $next_58 = $next_46; + var $have_58 = 0; + var $hold_54 = $hold_42; + var $bits_54 = $bits_42; + var $out_4 = $out_0; + break $_$12; + } + var $dec1454 = $have_46 - 1 | 0; + var $incdec_ptr1455 = $next_46 + 1 | 0; + var $164 = HEAPU8[$next_46]; + var $conv1456 = $164 & 255; + var $shl1457 = $conv1456 << $bits_42; + var $add1458 = $shl1457 + $hold_42 | 0; + var $add1459 = $bits_42 + 8 | 0; + var $next_46 = $incdec_ptr1455; + var $have_46 = $dec1454; + var $hold_42 = $add1458; + var $bits_42 = $add1459; + } + var $arrayidx1439_2 = $162 + ($add1437 << 2) + 2 | 0; + var $arrayidx1439_0 = $162 + ($add1437 << 2) | 0; + var $tmp14 = HEAP16[$arrayidx1439_2 >> 1]; + var $tmp12 = HEAP8[$arrayidx1439_0]; + var $shr1466 = $hold_42 >>> ($conv1398 >>> 0); + var $sub1469 = $bits_42 - $conv1398 | 0; + var $165 = HEAP32[$25 >> 2]; + var $add1475 = $165 + $conv1398 | 0; + HEAP32[$25 >> 2] = $add1475; + var $next_47 = $next_46; + var $have_47 = $have_46; + var $hold_43 = $shr1466; + var $bits_43 = $sub1469; + var $here_09_1 = $tmp12; + var $here_110_1 = $tmp13; + var $here_211_1 = $tmp14; + var $166 = $add1475; + } else { + var $_pre893 = HEAP32[$25 >> 2]; + var $next_47 = $next_45; + var $have_47 = $have_45; + var $hold_43 = $hold_41; + var $bits_43 = $bits_41; + var $here_09_1 = $tmp15; + var $here_110_1 = $tmp16; + var $here_211_1 = $tmp17; + var $166 = $_pre893; + } + var $166; + var $here_211_1; + var $here_110_1; + var $here_09_1; + var $bits_43; + var $hold_43; + var $have_47; + var $next_47; + var $conv1479 = $here_110_1 & 255; + var $shr1480 = $hold_43 >>> ($conv1479 >>> 0); + var $sub1483 = $bits_43 - $conv1479 | 0; + var $add1489 = $166 + $conv1479 | 0; + HEAP32[$25 >> 2] = $add1489; + var $conv1491 = $here_09_1 & 255; + var $and1492 = $conv1491 & 64; + var $tobool1493 = ($and1492 | 0) == 0; + if ($tobool1493) { + var $conv1499 = $here_211_1 & 65535; + HEAP32[$30 >> 2] = $conv1499; + var $and1502 = $conv1491 & 15; + HEAP32[$28 >> 2] = $and1502; + HEAP32[$mode >> 2] = 23; + var $ret_6 = $ret_5_ph; + var $next_48 = $next_47; + var $have_48 = $have_47; + var $hold_44 = $shr1480; + var $bits_44 = $sub1483; + var $167 = $and1502; + __label__ = 248; + break; + } + HEAP32[$msg >> 2] = STRING_TABLE.__str1170 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $ret_5_ph; + var $next_0_be = $next_47; + var $put_0_be = $put_0; + var $have_0_be = $have_47; + var $left_0_be = $left_0; + var $hold_0_be = $shr1480; + var $bits_0_be = $sub1483; + var $out_0_be = $out_0; + __label__ = 268; + break; + } + } while (0); + $_$359 : do { + if (__label__ == 107) { + var $bits_11; + var $hold_11; + var $have_15; + var $next_15; + var $109 = HEAPU32[$17 >> 2]; + var $and498 = $109 & 512; + var $tobool499 = ($and498 | 0) == 0; do { - if ($tobool1755) { - var $200 = HEAPU32[$mode >> 2]; - var $cmp1758 = $200 >>> 0 < 26; - if (!$cmp1758) { - __label__ = 300; - break; - } - var $201 = HEAP32[$avail_out >> 2]; - var $cmp1762 = ($out_4 | 0) == ($201 | 0); - if ($cmp1762) { - __label__ = 300; - break; - } - __label__ = 298; + if (!$tobool499) { + var $next_16 = $next_15; + var $have_16 = $have_15; + var $hold_12 = $hold_11; + var $bits_12 = $bits_11; + while (1) { + var $bits_12; + var $hold_12; + var $have_16; + var $next_16; + var $cmp503 = $bits_12 >>> 0 < 16; + if (!$cmp503) { break; - } else { - __label__ = 298; + } + var $cmp507 = ($have_16 | 0) == 0; + if ($cmp507) { + var $ret_8 = $ret_0; + var $next_58 = $next_16; + var $have_58 = 0; + var $hold_54 = $hold_12; + var $bits_54 = $bits_12; + var $out_4 = $out_0; + break $_$12; + } + var $dec511 = $have_16 - 1 | 0; + var $incdec_ptr512 = $next_16 + 1 | 0; + var $110 = HEAPU8[$next_16]; + var $conv513 = $110 & 255; + var $shl514 = $conv513 << $bits_12; + var $add515 = $shl514 + $hold_12 | 0; + var $add516 = $bits_12 + 8 | 0; + var $next_16 = $incdec_ptr512; + var $have_16 = $dec511; + var $hold_12 = $add515; + var $bits_12 = $add516; } + var $111 = HEAP32[$16 >> 2]; + var $and523 = $111 & 65535; + var $cmp524 = ($hold_12 | 0) == ($and523 | 0); + if ($cmp524) { + var $next_17 = $next_16; + var $have_17 = $have_16; + var $hold_13 = 0; + var $bits_13 = 0; + break; + } + HEAP32[$msg >> 2] = STRING_TABLE.__str5102 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $ret_0; + var $next_0_be = $next_16; + var $put_0_be = $put_0; + var $have_0_be = $have_16; + var $left_0_be = $left_0; + var $hold_0_be = $hold_12; + var $bits_0_be = $bits_12; + var $out_0_be = $out_0; + __label__ = 268; + break $_$359; + } + var $next_17 = $next_15; + var $have_17 = $have_15; + var $hold_13 = $hold_11; + var $bits_13 = $bits_11; } while (0); + var $bits_13; + var $hold_13; + var $have_17; + var $next_17; + var $112 = HEAPU32[$18 >> 2]; + var $cmp535 = ($112 | 0) == 0; + if (!$cmp535) { + var $shr53930 = $109 >>> 9; + var $and540 = $shr53930 & 1; + var $hcrc = $112 + 44 | 0; + HEAP32[$hcrc >> 2] = $and540; + var $113 = HEAP32[$18 >> 2]; + var $done543 = $113 + 48 | 0; + HEAP32[$done543 >> 2] = 1; + } + var $call545 = _crc32(0, 0, 0); + HEAP32[$16 >> 2] = $call545; + HEAP32[$adler >> 2] = $call545; + HEAP32[$mode >> 2] = 11; + var $ret_0_be = $ret_0; + var $next_0_be = $next_17; + var $put_0_be = $put_0; + var $have_0_be = $have_17; + var $left_0_be = $left_0; + var $hold_0_be = $hold_13; + var $bits_0_be = $bits_13; + var $out_0_be = $out_0; + __label__ = 268; + break; + } else if (__label__ == 248) { + var $167; + var $bits_44; + var $hold_44; + var $have_48; + var $next_48; + var $ret_6; + var $tobool1507 = ($167 | 0) == 0; + if ($tobool1507) { + var $next_50 = $next_48; + var $have_50 = $have_48; + var $hold_46 = $hold_44; + var $bits_46 = $bits_44; + } else { + var $next_49 = $next_48; + var $have_49 = $have_48; + var $hold_45 = $hold_44; + var $bits_45 = $bits_44; + while (1) { + var $bits_45; + var $hold_45; + var $have_49; + var $next_49; + var $cmp1512 = $bits_45 >>> 0 < $167 >>> 0; + if (!$cmp1512) { + break; + } + var $cmp1516 = ($have_49 | 0) == 0; + if ($cmp1516) { + var $ret_8 = $ret_6; + var $next_58 = $next_49; + var $have_58 = 0; + var $hold_54 = $hold_45; + var $bits_54 = $bits_45; + var $out_4 = $out_0; + break $_$12; + } + // XXX first chunk with a bug-causing difference + var $dec1520 = $have_49 - 1 | 0; + var $incdec_ptr1521 = $next_49 + 1 | 0; + var $168 = HEAPU8[$next_49]; + var $conv1522 = $168 & 255; + var $shl1523 = $conv1522 << $bits_45; + var $add1524 = $shl1523 + $hold_45 | 0; + var $add1525 = $bits_45 + 8 | 0; + var $next_49 = $incdec_ptr1521; + var $have_49 = $dec1520; + var $hold_45 = $add1524; + var $bits_45 = $add1525; + } + var $shl1532 = 1 << $167; + var $sub1533 = $shl1532 - 1 | 0; + var $and1534 = $sub1533 & $hold_45; + var $169 = HEAP32[$30 >> 2]; + var $add1536 = $169 + $and1534 | 0; + HEAP32[$30 >> 2] = $add1536; + var $shr1539 = $hold_45 >>> ($167 >>> 0); + var $sub1541 = $bits_45 - $167 | 0; + var $170 = HEAP32[$25 >> 2]; + var $add1546 = $170 + $167 | 0; + HEAP32[$25 >> 2] = $add1546; + var $next_50 = $next_49; + var $have_50 = $have_49; + var $hold_46 = $shr1539; + var $bits_46 = $sub1541; + } + var $bits_46; + var $hold_46; + var $have_50; + var $next_50; + HEAP32[$mode >> 2] = 24; + var $ret_7 = $ret_6; + var $next_51 = $next_50; + var $have_51 = $have_50; + var $hold_47 = $hold_46; + var $bits_47 = $bits_46; + __label__ = 254; + break; + } + } while (0); + $_$380 : do { + if (__label__ == 254) { + var $bits_47; + var $hold_47; + var $have_51; + var $next_51; + var $ret_7; + var $cmp1550 = ($left_0 | 0) == 0; + if ($cmp1550) { + var $ret_8 = $ret_7; + var $next_58 = $next_51; + var $have_58 = $have_51; + var $hold_54 = $hold_47; + var $bits_54 = $bits_47; + var $out_4 = $out_0; + break $_$12; + } + var $sub1554 = $out_0 - $left_0 | 0; + var $171 = HEAPU32[$30 >> 2]; + var $cmp1556 = $171 >>> 0 > $sub1554 >>> 0; do { - if (__label__ == 298) { - var $call1765 = _updatewindow($strm, $out_4); - var $tobool1766 = ($call1765 | 0) == 0; - if ($tobool1766) { - break; + if ($cmp1556) { + var $sub1560 = $171 - $sub1554 | 0; + var $172 = HEAPU32[$31 >> 2]; + var $cmp1561 = $sub1560 >>> 0 > $172 >>> 0; + do { + if ($cmp1561) { + var $173 = HEAP32[$32 >> 2]; + var $tobool1564 = ($173 | 0) == 0; + if ($tobool1564) { + break; } - HEAP32[$mode >> 2] = 30; - var $retval_0 = -4; - break $_$2; - } - } while (0); - var $202 = HEAPU32[$avail_in15 >> 2]; - var $203 = HEAPU32[$avail_out >> 2]; - var $sub1774 = $out_4 - $203 | 0; - var $total_in = $strm + 8 | 0; - var $204 = HEAP32[$total_in >> 2]; - var $sub1772 = $10 - $202 | 0; - var $add1775 = $sub1772 + $204 | 0; - HEAP32[$total_in >> 2] = $add1775; - var $205 = HEAP32[$total_out >> 2]; - var $add1777 = $205 + $sub1774 | 0; - HEAP32[$total_out >> 2] = $add1777; - var $206 = HEAP32[$36 >> 2]; - var $add1779 = $206 + $sub1774 | 0; - HEAP32[$36 >> 2] = $add1779; - var $207 = HEAP32[$15 >> 2]; - var $tobool1781 = ($207 | 0) == 0; - var $tobool1783 = ($out_4 | 0) == ($203 | 0); - var $or_cond34 = $tobool1781 | $tobool1783; - if (!$or_cond34) { - var $208 = HEAP32[$17 >> 2]; - var $tobool1786 = ($208 | 0) == 0; - var $209 = HEAP32[$16 >> 2]; - var $210 = HEAP32[$next_out >> 2]; - var $idx_neg1790 = -$sub1774 | 0; - var $add_ptr1791 = $210 + $idx_neg1790 | 0; - if ($tobool1786) { - var $call1798 = _adler32($209, $add_ptr1791, $sub1774); - var $cond1800 = $call1798; + HEAP32[$msg >> 2] = STRING_TABLE.__str169 | 0; + HEAP32[$mode >> 2] = 29; + var $ret_0_be = $ret_7; + var $next_0_be = $next_51; + var $put_0_be = $put_0; + var $have_0_be = $have_51; + var $left_0_be = $left_0; + var $hold_0_be = $hold_47; + var $bits_0_be = $bits_47; + var $out_0_be = $out_0; + break $_$380; + } + } while (0); + var $174 = HEAPU32[$33 >> 2]; + var $cmp1570 = $sub1560 >>> 0 > $174 >>> 0; + if ($cmp1570) { + var $sub1574 = $sub1560 - $174 | 0; + var $175 = HEAP32[$34 >> 2]; + var $176 = HEAP32[$35 >> 2]; + var $sub1575 = $176 - $sub1574 | 0; + var $add_ptr1576 = $175 + $sub1575 | 0; + var $from_0 = $add_ptr1576; + var $copy_7 = $sub1574; } else { - var $call1792 = _crc32($209, $add_ptr1791, $sub1774); - var $cond1800 = $call1792; + var $177 = HEAP32[$34 >> 2]; + var $sub1580 = $174 - $sub1560 | 0; + var $add_ptr1581 = $177 + $sub1580 | 0; + var $from_0 = $add_ptr1581; + var $copy_7 = $sub1560; + } + var $copy_7; + var $from_0; + var $178 = HEAPU32[$21 >> 2]; + var $cmp1584 = $copy_7 >>> 0 > $178 >>> 0; + if (!$cmp1584) { + var $from_1 = $from_0; + var $copy_8 = $copy_7; + var $180 = $178; + break; } - var $cond1800; - HEAP32[$16 >> 2] = $cond1800; - HEAP32[$adler >> 2] = $cond1800; + var $from_1 = $from_0; + var $copy_8 = $178; + var $180 = $178; + } else { + var $idx_neg = -$171 | 0; + var $add_ptr1591 = $put_0 + $idx_neg | 0; + var $179 = HEAP32[$21 >> 2]; + var $from_1 = $add_ptr1591; + var $copy_8 = $179; + var $180 = $179; + } + } while (0); + var $180; + var $copy_8; + var $from_1; + var $cmp1594 = $copy_8 >>> 0 > $left_0 >>> 0; + var $copy_9 = $cmp1594 ? $left_0 : $copy_8; + var $sub1600 = $180 - $copy_9 | 0; + HEAP32[$21 >> 2] = $sub1600; + var $181 = $copy_8 ^ -1; + var $182 = $left_0 ^ -1; + var $183 = $181 >>> 0 > $182 >>> 0; + var $umax = $183 ? $181 : $182; + var $from_2 = $from_1; + var $put_1 = $put_0; + var $copy_10 = $copy_9; + while (1) { + var $copy_10; + var $put_1; + var $from_2; + var $incdec_ptr1602 = $from_2 + 1 | 0; + var $184 = HEAP8[$from_2]; + var $incdec_ptr1603 = $put_1 + 1 | 0; + HEAP8[$put_1] = $184; + var $dec1605 = $copy_10 - 1 | 0; + var $tobool1606 = ($dec1605 | 0) == 0; + if ($tobool1606) { + break; + } + var $from_2 = $incdec_ptr1602; + var $put_1 = $incdec_ptr1603; + var $copy_10 = $dec1605; } - var $211 = HEAP32[$13 >> 2]; - var $212 = HEAP32[$24 >> 2]; - var $tobool1806 = ($212 | 0) != 0; - var $cond1807 = $tobool1806 ? 64 : 0; - var $213 = HEAP32[$mode >> 2]; - var $cmp1810 = ($213 | 0) == 11; - var $cond1812 = $cmp1810 ? 128 : 0; - var $cmp1815 = ($213 | 0) == 19; - if ($cmp1815) { - var $214 = 256; - } else { - var $cmp1818 = ($213 | 0) == 14; - var $phitmp = $cmp1818 ? 256 : 0; - var $214 = $phitmp; + var $sub1598 = $left_0 - $copy_9 | 0; + var $scevgep_sum = $umax ^ -1; + var $scevgep632 = $put_0 + $scevgep_sum | 0; + var $185 = HEAP32[$21 >> 2]; + var $cmp1609 = ($185 | 0) == 0; + if (!$cmp1609) { + var $ret_0_be = $ret_7; + var $next_0_be = $next_51; + var $put_0_be = $scevgep632; + var $have_0_be = $have_51; + var $left_0_be = $sub1598; + var $hold_0_be = $hold_47; + var $bits_0_be = $bits_47; + var $out_0_be = $out_0; + break; } - var $214; - var $add1808 = $cond1807 + $211 | 0; - var $add1813 = $add1808 + $cond1812 | 0; - var $add1821 = $add1813 + $214 | 0; - var $data_type = $strm + 44 | 0; - HEAP32[$data_type >> 2] = $add1821; - var $cmp1822 = ($10 | 0) == ($202 | 0); - var $or_cond35 = $cmp1822 & $tobool1783; - var $cmp1828 = ($flush | 0) == 4; - var $or_cond36 = $or_cond35 | $cmp1828; - var $cmp1831 = ($ret_8 | 0) == 0; - var $or_cond37 = $or_cond36 & $cmp1831; - var $ret_9 = $or_cond37 ? -5 : $ret_8; - var $retval_0 = $ret_9; + HEAP32[$mode >> 2] = 20; + var $ret_0_be = $ret_7; + var $next_0_be = $next_51; + var $put_0_be = $scevgep632; + var $have_0_be = $have_51; + var $left_0_be = $sub1598; + var $hold_0_be = $hold_47; + var $bits_0_be = $bits_47; + var $out_0_be = $out_0; + } + } while (0); + var $out_0_be; + var $bits_0_be; + var $hold_0_be; + var $left_0_be; + var $have_0_be; + var $put_0_be; + var $next_0_be; + var $ret_0_be; + var $_pre883 = HEAP32[$mode >> 2]; + var $ret_0 = $ret_0_be; + var $next_0 = $next_0_be; + var $put_0 = $put_0_be; + var $have_0 = $have_0_be; + var $left_0 = $left_0_be; + var $hold_0 = $hold_0_be; + var $bits_0 = $bits_0_be; + var $out_0 = $out_0_be; + var $49 = $_pre883; + } + var $out_4; + var $bits_54; + var $hold_54; + var $have_58; + var $next_58; + var $ret_8; + HEAP32[$next_out >> 2] = $put_0; + HEAP32[$avail_out >> 2] = $left_0; + HEAP32[$next_in >> 2] = $next_58; + HEAP32[$avail_in15 >> 2] = $have_58; + HEAP32[$11 >> 2] = $hold_54; + HEAP32[$13 >> 2] = $bits_54; + var $199 = HEAP32[$35 >> 2]; + var $tobool1755 = ($199 | 0) == 0; + do { + if ($tobool1755) { + var $200 = HEAPU32[$mode >> 2]; + var $cmp1758 = $200 >>> 0 < 26; + if (!$cmp1758) { + __label__ = 300; + break; + } + var $201 = HEAP32[$avail_out >> 2]; + var $cmp1762 = ($out_4 | 0) == ($201 | 0); + if ($cmp1762) { + __label__ = 300; + break; + } + __label__ = 298; + break; + } else { + __label__ = 298; + } + } while (0); + do { + if (__label__ == 298) { + var $call1765 = _updatewindow($strm, $out_4); + var $tobool1766 = ($call1765 | 0) == 0; + if ($tobool1766) { + break; + } + HEAP32[$mode >> 2] = 30; + var $retval_0 = -4; + break $_$2; } - } while (0); - var $retval_0; - STACKTOP = __stackBase__; - return $retval_0; - return null; + } while (0); + var $202 = HEAPU32[$avail_in15 >> 2]; + var $203 = HEAPU32[$avail_out >> 2]; + var $sub1774 = $out_4 - $203 | 0; + var $total_in = $strm + 8 | 0; + var $204 = HEAP32[$total_in >> 2]; + var $sub1772 = $10 - $202 | 0; + var $add1775 = $sub1772 + $204 | 0; + HEAP32[$total_in >> 2] = $add1775; + var $205 = HEAP32[$total_out >> 2]; + var $add1777 = $205 + $sub1774 | 0; + HEAP32[$total_out >> 2] = $add1777; + var $206 = HEAP32[$36 >> 2]; + var $add1779 = $206 + $sub1774 | 0; + HEAP32[$36 >> 2] = $add1779; + var $207 = HEAP32[$15 >> 2]; + var $tobool1781 = ($207 | 0) == 0; + var $tobool1783 = ($out_4 | 0) == ($203 | 0); + var $or_cond34 = $tobool1781 | $tobool1783; + if (!$or_cond34) { + var $208 = HEAP32[$17 >> 2]; + var $tobool1786 = ($208 | 0) == 0; + var $209 = HEAP32[$16 >> 2]; + var $210 = HEAP32[$next_out >> 2]; + var $idx_neg1790 = -$sub1774 | 0; + var $add_ptr1791 = $210 + $idx_neg1790 | 0; + if ($tobool1786) { + var $call1798 = _adler32($209, $add_ptr1791, $sub1774); + var $cond1800 = $call1798; + } else { + var $call1792 = _crc32($209, $add_ptr1791, $sub1774); + var $cond1800 = $call1792; + } + var $cond1800; + HEAP32[$16 >> 2] = $cond1800; + HEAP32[$adler >> 2] = $cond1800; + } + var $211 = HEAP32[$13 >> 2]; + var $212 = HEAP32[$24 >> 2]; + var $tobool1806 = ($212 | 0) != 0; + var $cond1807 = $tobool1806 ? 64 : 0; + var $213 = HEAP32[$mode >> 2]; + var $cmp1810 = ($213 | 0) == 11; + var $cond1812 = $cmp1810 ? 128 : 0; + var $cmp1815 = ($213 | 0) == 19; + if ($cmp1815) { + var $214 = 256; + } else { + var $cmp1818 = ($213 | 0) == 14; + var $phitmp = $cmp1818 ? 256 : 0; + var $214 = $phitmp; + } + var $214; + var $add1808 = $cond1807 + $211 | 0; + var $add1813 = $add1808 + $cond1812 | 0; + var $add1821 = $add1813 + $214 | 0; + var $data_type = $strm + 44 | 0; + HEAP32[$data_type >> 2] = $add1821; + var $cmp1822 = ($10 | 0) == ($202 | 0); + var $or_cond35 = $cmp1822 & $tobool1783; + var $cmp1828 = ($flush | 0) == 4; + var $or_cond36 = $or_cond35 | $cmp1828; + var $cmp1831 = ($ret_8 | 0) == 0; + var $or_cond37 = $or_cond36 & $cmp1831; + var $ret_9 = $or_cond37 ? -5 : $ret_8; + var $retval_0 = $ret_9; + } + } while (0); + var $retval_0; + STACKTOP = __stackBase__; + return $retval_0; + return null; } function _malloc($bytes) { - var __label__; - var $1 = $bytes >>> 0 < 245; - $_$2 : do { - if ($1) { - var $3 = $bytes >>> 0 < 11; - if ($3) { - var $8 = 16; + var __label__; + var $1 = $bytes >>> 0 < 245; + $_$2 : do { + if ($1) { + var $3 = $bytes >>> 0 < 11; + if ($3) { + var $8 = 16; + } else { + var $5 = $bytes + 11 | 0; + var $6 = $5 & -8; + var $8 = $6; + } + var $8; + var $9 = $8 >>> 3; + var $10 = HEAPU32[(__gm_ | 0) >> 2]; + var $11 = $10 >>> ($9 >>> 0); + var $12 = $11 & 3; + var $13 = ($12 | 0) == 0; + if (!$13) { + var $15 = $11 & 1; + var $16 = $15 ^ 1; + var $17 = $16 + $9 | 0; + var $18 = $17 << 1; + var $19 = __gm_ + 40 + ($18 << 2) | 0; + var $20 = $19; + var $_sum10 = $18 + 2 | 0; + var $21 = __gm_ + 40 + ($_sum10 << 2) | 0; + var $22 = HEAPU32[$21 >> 2]; + var $23 = $22 + 8 | 0; + var $24 = HEAPU32[$23 >> 2]; + var $25 = ($20 | 0) == ($24 | 0); + if ($25) { + var $27 = 1 << $17; + var $28 = $27 ^ -1; + var $29 = $10 & $28; + HEAP32[(__gm_ | 0) >> 2] = $29; + } else { + var $31 = $24; + var $32 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + var $33 = $31 >>> 0 < $32 >>> 0; + if ($33) { + _abort(); + } else { + HEAP32[$21 >> 2] = $24; + var $35 = $24 + 12 | 0; + HEAP32[$35 >> 2] = $20; + } + } + var $38 = $17 << 3; + var $39 = $38 | 3; + var $40 = $22 + 4 | 0; + HEAP32[$40 >> 2] = $39; + var $41 = $22; + var $_sum1112 = $38 | 4; + var $42 = $41 + $_sum1112 | 0; + var $43 = $42; + var $44 = HEAP32[$43 >> 2]; + var $45 = $44 | 1; + HEAP32[$43 >> 2] = $45; + var $46 = $23; + var $mem_0 = $46; + __label__ = 331; + break; + } + var $48 = HEAPU32[(__gm_ + 8 | 0) >> 2]; + var $49 = $8 >>> 0 > $48 >>> 0; + if (!$49) { + var $nb_0 = $8; + __label__ = 155; + break; + } + var $51 = ($11 | 0) == 0; + if (!$51) { + var $53 = $11 << $9; + var $54 = 2 << $9; + var $55 = -$54 | 0; + var $56 = $54 | $55; + var $57 = $53 & $56; + var $58 = -$57 | 0; + var $59 = $57 & $58; + var $60 = $59 - 1 | 0; + var $61 = $60 >>> 12; + var $62 = $61 & 16; + var $63 = $60 >>> ($62 >>> 0); + var $64 = $63 >>> 5; + var $65 = $64 & 8; + var $66 = $63 >>> ($65 >>> 0); + var $67 = $66 >>> 2; + var $68 = $67 & 4; + var $69 = $66 >>> ($68 >>> 0); + var $70 = $69 >>> 1; + var $71 = $70 & 2; + var $72 = $69 >>> ($71 >>> 0); + var $73 = $72 >>> 1; + var $74 = $73 & 1; + var $75 = $65 | $62; + var $76 = $75 | $68; + var $77 = $76 | $71; + var $78 = $77 | $74; + var $79 = $72 >>> ($74 >>> 0); + var $80 = $78 + $79 | 0; + var $81 = $80 << 1; + var $82 = __gm_ + 40 + ($81 << 2) | 0; + var $83 = $82; + var $_sum4 = $81 + 2 | 0; + var $84 = __gm_ + 40 + ($_sum4 << 2) | 0; + var $85 = HEAPU32[$84 >> 2]; + var $86 = $85 + 8 | 0; + var $87 = HEAPU32[$86 >> 2]; + var $88 = ($83 | 0) == ($87 | 0); + if ($88) { + var $90 = 1 << $80; + var $91 = $90 ^ -1; + var $92 = $10 & $91; + HEAP32[(__gm_ | 0) >> 2] = $92; + } else { + var $94 = $87; + var $95 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + var $96 = $94 >>> 0 < $95 >>> 0; + if ($96) { + _abort(); + } else { + HEAP32[$84 >> 2] = $87; + var $98 = $87 + 12 | 0; + HEAP32[$98 >> 2] = $83; + } + } + var $101 = $80 << 3; + var $102 = $101 - $8 | 0; + var $103 = $8 | 3; + var $104 = $85 + 4 | 0; + HEAP32[$104 >> 2] = $103; + var $105 = $85; + var $106 = $105 + $8 | 0; + var $107 = $106; + var $108 = $102 | 1; + var $_sum56 = $8 | 4; + var $109 = $105 + $_sum56 | 0; + var $110 = $109; + HEAP32[$110 >> 2] = $108; + var $111 = $105 + $101 | 0; + var $112 = $111; + HEAP32[$112 >> 2] = $102; + var $113 = HEAPU32[(__gm_ + 8 | 0) >> 2]; + var $114 = ($113 | 0) == 0; + if (!$114) { + var $116 = HEAP32[(__gm_ + 20 | 0) >> 2]; + var $117 = $113 >>> 3; + var $118 = $113 >>> 2; + var $119 = $118 & 1073741822; + var $120 = __gm_ + 40 + ($119 << 2) | 0; + var $121 = $120; + var $122 = HEAPU32[(__gm_ | 0) >> 2]; + var $123 = 1 << $117; + var $124 = $122 & $123; + var $125 = ($124 | 0) == 0; + do { + if ($125) { + var $127 = $122 | $123; + HEAP32[(__gm_ | 0) >> 2] = $127; + var $_sum8_pre = $119 + 2 | 0; + var $_pre = __gm_ + 40 + ($_sum8_pre << 2) | 0; + var $F4_0 = $121; + var $_pre_phi = $_pre; } else { - var $5 = $bytes + 11 | 0; - var $6 = $5 & -8; - var $8 = $6; - } - var $8; - var $9 = $8 >>> 3; - var $10 = HEAPU32[(__gm_ | 0) >> 2]; - var $11 = $10 >>> ($9 >>> 0); - var $12 = $11 & 3; - var $13 = ($12 | 0) == 0; - if (!$13) { - var $15 = $11 & 1; - var $16 = $15 ^ 1; - var $17 = $16 + $9 | 0; - var $18 = $17 << 1; - var $19 = __gm_ + 40 + ($18 << 2) | 0; - var $20 = $19; - var $_sum10 = $18 + 2 | 0; - var $21 = __gm_ + 40 + ($_sum10 << 2) | 0; - var $22 = HEAPU32[$21 >> 2]; - var $23 = $22 + 8 | 0; - var $24 = HEAPU32[$23 >> 2]; - var $25 = ($20 | 0) == ($24 | 0); - if ($25) { - var $27 = 1 << $17; - var $28 = $27 ^ -1; - var $29 = $10 & $28; - HEAP32[(__gm_ | 0) >> 2] = $29; - } else { - var $31 = $24; - var $32 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - var $33 = $31 >>> 0 < $32 >>> 0; - if ($33) { - _abort(); - } else { - HEAP32[$21 >> 2] = $24; - var $35 = $24 + 12 | 0; - HEAP32[$35 >> 2] = $20; - } - } - var $38 = $17 << 3; - var $39 = $38 | 3; - var $40 = $22 + 4 | 0; - HEAP32[$40 >> 2] = $39; - var $41 = $22; - var $_sum1112 = $38 | 4; - var $42 = $41 + $_sum1112 | 0; - var $43 = $42; - var $44 = HEAP32[$43 >> 2]; - var $45 = $44 | 1; - HEAP32[$43 >> 2] = $45; - var $46 = $23; - var $mem_0 = $46; - __label__ = 331; + var $_sum9 = $119 + 2 | 0; + var $129 = __gm_ + 40 + ($_sum9 << 2) | 0; + var $130 = HEAPU32[$129 >> 2]; + var $131 = $130; + var $132 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + var $133 = $131 >>> 0 < $132 >>> 0; + if (!$133) { + var $F4_0 = $130; + var $_pre_phi = $129; break; + } + _abort(); } - var $48 = HEAPU32[(__gm_ + 8 | 0) >> 2]; - var $49 = $8 >>> 0 > $48 >>> 0; - if (!$49) { - var $nb_0 = $8; - __label__ = 155; - break; + } while (0); + var $_pre_phi; + var $F4_0; + HEAP32[$_pre_phi >> 2] = $116; + var $136 = $F4_0 + 12 | 0; + HEAP32[$136 >> 2] = $116; + var $137 = $116 + 8 | 0; + HEAP32[$137 >> 2] = $F4_0; + var $138 = $116 + 12 | 0; + HEAP32[$138 >> 2] = $121; + } + HEAP32[(__gm_ + 8 | 0) >> 2] = $102; + HEAP32[(__gm_ + 20 | 0) >> 2] = $107; + var $140 = $86; + var $mem_0 = $140; + __label__ = 331; + break; + } + var $142 = HEAP32[(__gm_ + 4 | 0) >> 2]; + var $143 = ($142 | 0) == 0; + if ($143) { + var $nb_0 = $8; + __label__ = 155; + break; + } + var $145 = -$142 | 0; + var $146 = $142 & $145; + var $147 = $146 - 1 | 0; + var $148 = $147 >>> 12; + var $149 = $148 & 16; + var $150 = $147 >>> ($149 >>> 0); + var $151 = $150 >>> 5; + var $152 = $151 & 8; + var $153 = $150 >>> ($152 >>> 0); + var $154 = $153 >>> 2; + var $155 = $154 & 4; + var $156 = $153 >>> ($155 >>> 0); + var $157 = $156 >>> 1; + var $158 = $157 & 2; + var $159 = $156 >>> ($158 >>> 0); + var $160 = $159 >>> 1; + var $161 = $160 & 1; + var $162 = $152 | $149; + var $163 = $162 | $155; + var $164 = $163 | $158; + var $165 = $164 | $161; + var $166 = $159 >>> ($161 >>> 0); + var $167 = $165 + $166 | 0; + var $168 = __gm_ + 304 + ($167 << 2) | 0; + var $169 = HEAPU32[$168 >> 2]; + var $170 = $169 + 4 | 0; + var $171 = HEAP32[$170 >> 2]; + var $172 = $171 & -8; + var $173 = $172 - $8 | 0; + var $t_0_i = $169; + var $v_0_i = $169; + var $rsize_0_i = $173; + while (1) { + var $rsize_0_i; + var $v_0_i; + var $t_0_i; + var $175 = $t_0_i + 16 | 0; + var $176 = HEAP32[$175 >> 2]; + var $177 = ($176 | 0) == 0; + if ($177) { + var $179 = $t_0_i + 20 | 0; + var $180 = HEAP32[$179 >> 2]; + var $181 = ($180 | 0) == 0; + if ($181) { + break; + } + var $182 = $180; + } else { + var $182 = $176; + } + var $182; + var $183 = $182 + 4 | 0; + var $184 = HEAP32[$183 >> 2]; + var $185 = $184 & -8; + var $186 = $185 - $8 | 0; + var $187 = $186 >>> 0 < $rsize_0_i >>> 0; + var $_rsize_0_i = $187 ? $186 : $rsize_0_i; + var $_v_0_i = $187 ? $182 : $v_0_i; + var $t_0_i = $182; + var $v_0_i = $_v_0_i; + var $rsize_0_i = $_rsize_0_i; + } + var $189 = $v_0_i; + var $190 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + var $191 = $189 >>> 0 < $190 >>> 0; + do { + if (!$191) { + var $193 = $189 + $8 | 0; + var $194 = $193; + var $195 = $189 >>> 0 < $193 >>> 0; + if (!$195) { + break; + } + var $197 = $v_0_i + 24 | 0; + var $198 = HEAPU32[$197 >> 2]; + var $199 = $v_0_i + 12 | 0; + var $200 = HEAPU32[$199 >> 2]; + var $201 = ($200 | 0) == ($v_0_i | 0); + do { + if ($201) { + var $212 = $v_0_i + 20 | 0; + var $213 = HEAP32[$212 >> 2]; + var $214 = ($213 | 0) == 0; + if ($214) { + var $216 = $v_0_i + 16 | 0; + var $217 = HEAP32[$216 >> 2]; + var $218 = ($217 | 0) == 0; + if ($218) { + var $R_1_i = 0; + break; + } + var $RP_0_i = $216; + var $R_0_i = $217; + } else { + var $RP_0_i = $212; + var $R_0_i = $213; + __label__ = 39; + } + while (1) { + var $R_0_i; + var $RP_0_i; + var $219 = $R_0_i + 20 | 0; + var $220 = HEAP32[$219 >> 2]; + var $221 = ($220 | 0) == 0; + if (!$221) { + var $RP_0_i = $219; + var $R_0_i = $220; + continue; + } + var $223 = $R_0_i + 16 | 0; + var $224 = HEAPU32[$223 >> 2]; + var $225 = ($224 | 0) == 0; + if ($225) { + break; + } + var $RP_0_i = $223; + var $R_0_i = $224; + } + var $227 = $RP_0_i; + var $228 = $227 >>> 0 < $190 >>> 0; + if ($228) { + _abort(); + } else { + HEAP32[$RP_0_i >> 2] = 0; + var $R_1_i = $R_0_i; + } + } else { + var $203 = $v_0_i + 8 | 0; + var $204 = HEAPU32[$203 >> 2]; + var $205 = $204; + var $206 = $205 >>> 0 < $190 >>> 0; + if ($206) { + _abort(); + } else { + var $208 = $204 + 12 | 0; + HEAP32[$208 >> 2] = $200; + var $209 = $200 + 8 | 0; + HEAP32[$209 >> 2] = $204; + var $R_1_i = $200; + } } - var $51 = ($11 | 0) == 0; - if (!$51) { - var $53 = $11 << $9; - var $54 = 2 << $9; - var $55 = -$54 | 0; - var $56 = $54 | $55; - var $57 = $53 & $56; - var $58 = -$57 | 0; - var $59 = $57 & $58; - var $60 = $59 - 1 | 0; - var $61 = $60 >>> 12; - var $62 = $61 & 16; - var $63 = $60 >>> ($62 >>> 0); - var $64 = $63 >>> 5; - var $65 = $64 & 8; - var $66 = $63 >>> ($65 >>> 0); - var $67 = $66 >>> 2; - var $68 = $67 & 4; - var $69 = $66 >>> ($68 >>> 0); - var $70 = $69 >>> 1; - var $71 = $70 & 2; - var $72 = $69 >>> ($71 >>> 0); - var $73 = $72 >>> 1; - var $74 = $73 & 1; - var $75 = $65 | $62; - var $76 = $75 | $68; - var $77 = $76 | $71; - var $78 = $77 | $74; - var $79 = $72 >>> ($74 >>> 0); - var $80 = $78 + $79 | 0; - var $81 = $80 << 1; - var $82 = __gm_ + 40 + ($81 << 2) | 0; - var $83 = $82; - var $_sum4 = $81 + 2 | 0; - var $84 = __gm_ + 40 + ($_sum4 << 2) | 0; - var $85 = HEAPU32[$84 >> 2]; - var $86 = $85 + 8 | 0; - var $87 = HEAPU32[$86 >> 2]; - var $88 = ($83 | 0) == ($87 | 0); - if ($88) { - var $90 = 1 << $80; - var $91 = $90 ^ -1; - var $92 = $10 & $91; - HEAP32[(__gm_ | 0) >> 2] = $92; + } while (0); + var $R_1_i; + var $232 = ($198 | 0) == 0; + $_$62 : do { + if (!$232) { + var $234 = $v_0_i + 28 | 0; + var $235 = HEAP32[$234 >> 2]; + var $236 = __gm_ + 304 + ($235 << 2) | 0; + var $237 = HEAP32[$236 >> 2]; + var $238 = ($v_0_i | 0) == ($237 | 0); + do { + if ($238) { + HEAP32[$236 >> 2] = $R_1_i; + var $cond_i = ($R_1_i | 0) == 0; + if (!$cond_i) { + break; + } + var $240 = HEAP32[$234 >> 2]; + var $241 = 1 << $240; + var $242 = $241 ^ -1; + var $243 = HEAP32[(__gm_ + 4 | 0) >> 2]; + var $244 = $243 & $242; + HEAP32[(__gm_ + 4 | 0) >> 2] = $244; + break $_$62; + } + var $246 = $198; + var $247 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + var $248 = $246 >>> 0 < $247 >>> 0; + if ($248) { + _abort(); } else { - var $94 = $87; - var $95 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - var $96 = $94 >>> 0 < $95 >>> 0; - if ($96) { - _abort(); - } else { - HEAP32[$84 >> 2] = $87; - var $98 = $87 + 12 | 0; - HEAP32[$98 >> 2] = $83; - } + var $250 = $198 + 16 | 0; + var $251 = HEAP32[$250 >> 2]; + var $252 = ($251 | 0) == ($v_0_i | 0); + if ($252) { + HEAP32[$250 >> 2] = $R_1_i; + } else { + var $255 = $198 + 20 | 0; + HEAP32[$255 >> 2] = $R_1_i; + } + var $258 = ($R_1_i | 0) == 0; + if ($258) { + break $_$62; + } } - var $101 = $80 << 3; - var $102 = $101 - $8 | 0; - var $103 = $8 | 3; - var $104 = $85 + 4 | 0; - HEAP32[$104 >> 2] = $103; - var $105 = $85; - var $106 = $105 + $8 | 0; - var $107 = $106; - var $108 = $102 | 1; - var $_sum56 = $8 | 4; - var $109 = $105 + $_sum56 | 0; - var $110 = $109; - HEAP32[$110 >> 2] = $108; - var $111 = $105 + $101 | 0; - var $112 = $111; - HEAP32[$112 >> 2] = $102; - var $113 = HEAPU32[(__gm_ + 8 | 0) >> 2]; - var $114 = ($113 | 0) == 0; - if (!$114) { - var $116 = HEAP32[(__gm_ + 20 | 0) >> 2]; - var $117 = $113 >>> 3; - var $118 = $113 >>> 2; - var $119 = $118 & 1073741822; - var $120 = __gm_ + 40 + ($119 << 2) | 0; - var $121 = $120; - var $122 = HEAPU32[(__gm_ | 0) >> 2]; - var $123 = 1 << $117; - var $124 = $122 & $123; - var $125 = ($124 | 0) == 0; - do { - if ($125) { - var $127 = $122 | $123; - HEAP32[(__gm_ | 0) >> 2] = $127; - var $_sum8_pre = $119 + 2 | 0; - var $_pre = __gm_ + 40 + ($_sum8_pre << 2) | 0; - var $F4_0 = $121; - var $_pre_phi = $_pre; - } else { - var $_sum9 = $119 + 2 | 0; - var $129 = __gm_ + 40 + ($_sum9 << 2) | 0; - var $130 = HEAPU32[$129 >> 2]; - var $131 = $130; - var $132 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - var $133 = $131 >>> 0 < $132 >>> 0; - if (!$133) { - var $F4_0 = $130; - var $_pre_phi = $129; - break; - } - _abort(); - } - } while (0); - var $_pre_phi; - var $F4_0; - HEAP32[$_pre_phi >> 2] = $116; - var $136 = $F4_0 + 12 | 0; - HEAP32[$136 >> 2] = $116; - var $137 = $116 + 8 | 0; - HEAP32[$137 >> 2] = $F4_0; - var $138 = $116 + 12 | 0; - HEAP32[$138 >> 2] = $121; + } while (0); + var $260 = $R_1_i; + var $261 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + var $262 = $260 >>> 0 < $261 >>> 0; + if ($262) { + _abort(); + } else { + var $264 = $R_1_i + 24 | 0; + HEAP32[$264 >> 2] = $198; + var $265 = $v_0_i + 16 | 0; + var $266 = HEAPU32[$265 >> 2]; + var $267 = ($266 | 0) == 0; + if (!$267) { + var $269 = $266; + var $270 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + var $271 = $269 >>> 0 < $270 >>> 0; + if ($271) { + _abort(); + } else { + var $273 = $R_1_i + 16 | 0; + HEAP32[$273 >> 2] = $266; + var $274 = $266 + 24 | 0; + HEAP32[$274 >> 2] = $R_1_i; + } } - HEAP32[(__gm_ + 8 | 0) >> 2] = $102; - HEAP32[(__gm_ + 20 | 0) >> 2] = $107; - var $140 = $86; - var $mem_0 = $140; - __label__ = 331; - break; + var $277 = $v_0_i + 20 | 0; + var $278 = HEAPU32[$277 >> 2]; + var $279 = ($278 | 0) == 0; + if ($279) { + break; + } + var $281 = $278; + var $282 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + var $283 = $281 >>> 0 < $282 >>> 0; + if ($283) { + _abort(); + } else { + var $285 = $R_1_i + 20 | 0; + HEAP32[$285 >> 2] = $278; + var $286 = $278 + 24 | 0; + HEAP32[$286 >> 2] = $R_1_i; + } + } } - var $142 = HEAP32[(__gm_ + 4 | 0) >> 2]; - var $143 = ($142 | 0) == 0; - if ($143) { - var $nb_0 = $8; - __label__ = 155; - break; + } while (0); + var $290 = $rsize_0_i >>> 0 < 16; + if ($290) { + var $292 = $rsize_0_i + $8 | 0; + var $293 = $292 | 3; + var $294 = $v_0_i + 4 | 0; + HEAP32[$294 >> 2] = $293; + var $_sum4_i = $292 + 4 | 0; + var $295 = $189 + $_sum4_i | 0; + var $296 = $295; + var $297 = HEAP32[$296 >> 2]; + var $298 = $297 | 1; + HEAP32[$296 >> 2] = $298; + } else { + var $300 = $8 | 3; + var $301 = $v_0_i + 4 | 0; + HEAP32[$301 >> 2] = $300; + var $302 = $rsize_0_i | 1; + var $_sum_i33 = $8 | 4; + var $303 = $189 + $_sum_i33 | 0; + var $304 = $303; + HEAP32[$304 >> 2] = $302; + var $_sum1_i = $rsize_0_i + $8 | 0; + var $305 = $189 + $_sum1_i | 0; + var $306 = $305; + HEAP32[$306 >> 2] = $rsize_0_i; + var $307 = HEAPU32[(__gm_ + 8 | 0) >> 2]; + var $308 = ($307 | 0) == 0; + if (!$308) { + var $310 = HEAPU32[(__gm_ + 20 | 0) >> 2]; + var $311 = $307 >>> 3; + var $312 = $307 >>> 2; + var $313 = $312 & 1073741822; + var $314 = __gm_ + 40 + ($313 << 2) | 0; + var $315 = $314; + var $316 = HEAPU32[(__gm_ | 0) >> 2]; + var $317 = 1 << $311; + var $318 = $316 & $317; + var $319 = ($318 | 0) == 0; + do { + if ($319) { + var $321 = $316 | $317; + HEAP32[(__gm_ | 0) >> 2] = $321; + var $_sum2_pre_i = $313 + 2 | 0; + var $_pre_i = __gm_ + 40 + ($_sum2_pre_i << 2) | 0; + var $F1_0_i = $315; + var $_pre_phi_i = $_pre_i; + } else { + var $_sum3_i = $313 + 2 | 0; + var $323 = __gm_ + 40 + ($_sum3_i << 2) | 0; + var $324 = HEAPU32[$323 >> 2]; + var $325 = $324; + var $326 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + var $327 = $325 >>> 0 < $326 >>> 0; + if (!$327) { + var $F1_0_i = $324; + var $_pre_phi_i = $323; + break; + } + _abort(); + } + } while (0); + var $_pre_phi_i; + var $F1_0_i; + HEAP32[$_pre_phi_i >> 2] = $310; + var $330 = $F1_0_i + 12 | 0; + HEAP32[$330 >> 2] = $310; + var $331 = $310 + 8 | 0; + HEAP32[$331 >> 2] = $F1_0_i; + var $332 = $310 + 12 | 0; + HEAP32[$332 >> 2] = $315; } - var $145 = -$142 | 0; - var $146 = $142 & $145; - var $147 = $146 - 1 | 0; - var $148 = $147 >>> 12; - var $149 = $148 & 16; - var $150 = $147 >>> ($149 >>> 0); - var $151 = $150 >>> 5; - var $152 = $151 & 8; - var $153 = $150 >>> ($152 >>> 0); - var $154 = $153 >>> 2; - var $155 = $154 & 4; - var $156 = $153 >>> ($155 >>> 0); - var $157 = $156 >>> 1; - var $158 = $157 & 2; - var $159 = $156 >>> ($158 >>> 0); - var $160 = $159 >>> 1; - var $161 = $160 & 1; - var $162 = $152 | $149; - var $163 = $162 | $155; - var $164 = $163 | $158; - var $165 = $164 | $161; - var $166 = $159 >>> ($161 >>> 0); - var $167 = $165 + $166 | 0; - var $168 = __gm_ + 304 + ($167 << 2) | 0; - var $169 = HEAPU32[$168 >> 2]; - var $170 = $169 + 4 | 0; - var $171 = HEAP32[$170 >> 2]; - var $172 = $171 & -8; - var $173 = $172 - $8 | 0; - var $t_0_i = $169; - var $v_0_i = $169; - var $rsize_0_i = $173; - while (1) { - var $rsize_0_i; - var $v_0_i; - var $t_0_i; - var $175 = $t_0_i + 16 | 0; - var $176 = HEAP32[$175 >> 2]; - var $177 = ($176 | 0) == 0; - if ($177) { - var $179 = $t_0_i + 20 | 0; - var $180 = HEAP32[$179 >> 2]; - var $181 = ($180 | 0) == 0; - if ($181) { - break; - } - var $182 = $180; + HEAP32[(__gm_ + 8 | 0) >> 2] = $rsize_0_i; + HEAP32[(__gm_ + 20 | 0) >> 2] = $194; + } + var $335 = $v_0_i + 8 | 0; + var $336 = $335; + var $337 = ($335 | 0) == 0; + if ($337) { + var $nb_0 = $8; + __label__ = 155; + break $_$2; + } + var $mem_0 = $336; + __label__ = 331; + break $_$2; + } + } while (0); + _abort(); + } else { + var $339 = $bytes >>> 0 > 4294967231; + if ($339) { + var $nb_0 = -1; + __label__ = 155; + break; + } + var $341 = $bytes + 11 | 0; + var $342 = $341 & -8; + var $343 = HEAPU32[(__gm_ + 4 | 0) >> 2]; + var $344 = ($343 | 0) == 0; + if ($344) { + var $nb_0 = $342; + __label__ = 155; + break; + } + var $346 = -$342 | 0; + var $347 = $341 >>> 8; + var $348 = ($347 | 0) == 0; + do { + if ($348) { + var $idx_0_i = 0; + } else { + var $350 = $342 >>> 0 > 16777215; + if ($350) { + var $idx_0_i = 31; + break; + } + var $352 = $347 + 1048320 | 0; + var $353 = $352 >>> 16; + var $354 = $353 & 8; + var $355 = $347 << $354; + var $356 = $355 + 520192 | 0; + var $357 = $356 >>> 16; + var $358 = $357 & 4; + var $359 = $355 << $358; + var $360 = $359 + 245760 | 0; + var $361 = $360 >>> 16; + var $362 = $361 & 2; + var $363 = $358 | $354; + var $364 = $363 | $362; + var $365 = 14 - $364 | 0; + var $366 = $359 << $362; + var $367 = $366 >>> 15; + var $368 = $365 + $367 | 0; + var $369 = $368 << 1; + var $370 = $368 + 7 | 0; + var $371 = $342 >>> ($370 >>> 0); + var $372 = $371 & 1; + var $373 = $372 | $369; + var $idx_0_i = $373; + } + } while (0); + var $idx_0_i; + var $375 = __gm_ + 304 + ($idx_0_i << 2) | 0; + var $376 = HEAPU32[$375 >> 2]; + var $377 = ($376 | 0) == 0; + $_$110 : do { + if ($377) { + var $v_2_i = 0; + var $rsize_2_i = $346; + var $t_1_i = 0; + } else { + var $379 = ($idx_0_i | 0) == 31; + if ($379) { + var $384 = 0; + } else { + var $381 = $idx_0_i >>> 1; + var $382 = 25 - $381 | 0; + var $384 = $382; + } + var $384; + var $385 = $342 << $384; + var $v_0_i15 = 0; + var $rsize_0_i14 = $346; + var $t_0_i13 = $376; + var $sizebits_0_i = $385; + var $rst_0_i = 0; + while (1) { + var $rst_0_i; + var $sizebits_0_i; + var $t_0_i13; + var $rsize_0_i14; + var $v_0_i15; + var $387 = $t_0_i13 + 4 | 0; + var $388 = HEAP32[$387 >> 2]; + var $389 = $388 & -8; + var $390 = $389 - $342 | 0; + var $391 = $390 >>> 0 < $rsize_0_i14 >>> 0; + if ($391) { + var $393 = ($389 | 0) == ($342 | 0); + if ($393) { + var $v_2_i = $t_0_i13; + var $rsize_2_i = $390; + var $t_1_i = $t_0_i13; + break $_$110; + } + var $v_1_i = $t_0_i13; + var $rsize_1_i = $390; + } else { + var $v_1_i = $v_0_i15; + var $rsize_1_i = $rsize_0_i14; + } + var $rsize_1_i; + var $v_1_i; + var $395 = $t_0_i13 + 20 | 0; + var $396 = HEAPU32[$395 >> 2]; + var $397 = $sizebits_0_i >>> 31; + var $398 = $t_0_i13 + 16 + ($397 << 2) | 0; + var $399 = HEAPU32[$398 >> 2]; + var $400 = ($396 | 0) == 0; + var $401 = ($396 | 0) == ($399 | 0); + var $or_cond_i = $400 | $401; + var $rst_1_i = $or_cond_i ? $rst_0_i : $396; + var $402 = ($399 | 0) == 0; + var $403 = $sizebits_0_i << 1; + if ($402) { + var $v_2_i = $v_1_i; + var $rsize_2_i = $rsize_1_i; + var $t_1_i = $rst_1_i; + break $_$110; + } + var $v_0_i15 = $v_1_i; + var $rsize_0_i14 = $rsize_1_i; + var $t_0_i13 = $399; + var $sizebits_0_i = $403; + var $rst_0_i = $rst_1_i; + } + } + } while (0); + var $t_1_i; + var $rsize_2_i; + var $v_2_i; + var $404 = ($t_1_i | 0) == 0; + var $405 = ($v_2_i | 0) == 0; + var $or_cond19_i = $404 & $405; + if ($or_cond19_i) { + var $407 = 2 << $idx_0_i; + var $408 = -$407 | 0; + var $409 = $407 | $408; + var $410 = $343 & $409; + var $411 = ($410 | 0) == 0; + if ($411) { + var $nb_0 = $342; + __label__ = 155; + break; + } + var $413 = -$410 | 0; + var $414 = $410 & $413; + var $415 = $414 - 1 | 0; + var $416 = $415 >>> 12; + var $417 = $416 & 16; + var $418 = $415 >>> ($417 >>> 0); + var $419 = $418 >>> 5; + var $420 = $419 & 8; + var $421 = $418 >>> ($420 >>> 0); + var $422 = $421 >>> 2; + var $423 = $422 & 4; + var $424 = $421 >>> ($423 >>> 0); + var $425 = $424 >>> 1; + var $426 = $425 & 2; + var $427 = $424 >>> ($426 >>> 0); + var $428 = $427 >>> 1; + var $429 = $428 & 1; + var $430 = $420 | $417; + var $431 = $430 | $423; + var $432 = $431 | $426; + var $433 = $432 | $429; + var $434 = $427 >>> ($429 >>> 0); + var $435 = $433 + $434 | 0; + var $436 = __gm_ + 304 + ($435 << 2) | 0; + var $437 = HEAP32[$436 >> 2]; + var $t_2_ph_i = $437; + } else { + var $t_2_ph_i = $t_1_i; + } + var $t_2_ph_i; + var $438 = ($t_2_ph_i | 0) == 0; + $_$125 : do { + if ($438) { + var $rsize_3_lcssa_i = $rsize_2_i; + var $v_3_lcssa_i = $v_2_i; + } else { + var $t_224_i = $t_2_ph_i; + var $rsize_325_i = $rsize_2_i; + var $v_326_i = $v_2_i; + while (1) { + var $v_326_i; + var $rsize_325_i; + var $t_224_i; + var $439 = $t_224_i + 4 | 0; + var $440 = HEAP32[$439 >> 2]; + var $441 = $440 & -8; + var $442 = $441 - $342 | 0; + var $443 = $442 >>> 0 < $rsize_325_i >>> 0; + var $_rsize_3_i = $443 ? $442 : $rsize_325_i; + var $t_2_v_3_i = $443 ? $t_224_i : $v_326_i; + var $444 = $t_224_i + 16 | 0; + var $445 = HEAPU32[$444 >> 2]; + var $446 = ($445 | 0) == 0; + if (!$446) { + var $t_224_i = $445; + var $rsize_325_i = $_rsize_3_i; + var $v_326_i = $t_2_v_3_i; + continue; + } + var $447 = $t_224_i + 20 | 0; + var $448 = HEAPU32[$447 >> 2]; + var $449 = ($448 | 0) == 0; + if ($449) { + var $rsize_3_lcssa_i = $_rsize_3_i; + var $v_3_lcssa_i = $t_2_v_3_i; + break $_$125; + } + var $t_224_i = $448; + var $rsize_325_i = $_rsize_3_i; + var $v_326_i = $t_2_v_3_i; + } + } + } while (0); + var $v_3_lcssa_i; + var $rsize_3_lcssa_i; + var $450 = ($v_3_lcssa_i | 0) == 0; + if ($450) { + var $nb_0 = $342; + __label__ = 155; + break; + } + var $452 = HEAP32[(__gm_ + 8 | 0) >> 2]; + var $453 = $452 - $342 | 0; + var $454 = $rsize_3_lcssa_i >>> 0 < $453 >>> 0; + if (!$454) { + var $nb_0 = $342; + __label__ = 155; + break; + } + var $456 = $v_3_lcssa_i; + var $457 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + var $458 = $456 >>> 0 < $457 >>> 0; + do { + if (!$458) { + var $460 = $456 + $342 | 0; + var $461 = $460; + var $462 = $456 >>> 0 < $460 >>> 0; + if (!$462) { + break; + } + var $464 = $v_3_lcssa_i + 24 | 0; + var $465 = HEAPU32[$464 >> 2]; + var $466 = $v_3_lcssa_i + 12 | 0; + var $467 = HEAPU32[$466 >> 2]; + var $468 = ($467 | 0) == ($v_3_lcssa_i | 0); + do { + if ($468) { + var $479 = $v_3_lcssa_i + 20 | 0; + var $480 = HEAP32[$479 >> 2]; + var $481 = ($480 | 0) == 0; + if ($481) { + var $483 = $v_3_lcssa_i + 16 | 0; + var $484 = HEAP32[$483 >> 2]; + var $485 = ($484 | 0) == 0; + if ($485) { + var $R_1_i19 = 0; + break; + } + var $RP_0_i17 = $483; + var $R_0_i16 = $484; + } else { + var $RP_0_i17 = $479; + var $R_0_i16 = $480; + __label__ = 103; + } + while (1) { + var $R_0_i16; + var $RP_0_i17; + var $486 = $R_0_i16 + 20 | 0; + var $487 = HEAP32[$486 >> 2]; + var $488 = ($487 | 0) == 0; + if (!$488) { + var $RP_0_i17 = $486; + var $R_0_i16 = $487; + continue; + } + var $490 = $R_0_i16 + 16 | 0; + var $491 = HEAPU32[$490 >> 2]; + var $492 = ($491 | 0) == 0; + if ($492) { + break; + } + var $RP_0_i17 = $490; + var $R_0_i16 = $491; + } + var $494 = $RP_0_i17; + var $495 = $494 >>> 0 < $457 >>> 0; + if ($495) { + _abort(); + } else { + HEAP32[$RP_0_i17 >> 2] = 0; + var $R_1_i19 = $R_0_i16; + } + } else { + var $470 = $v_3_lcssa_i + 8 | 0; + var $471 = HEAPU32[$470 >> 2]; + var $472 = $471; + var $473 = $472 >>> 0 < $457 >>> 0; + if ($473) { + _abort(); + } else { + var $475 = $471 + 12 | 0; + HEAP32[$475 >> 2] = $467; + var $476 = $467 + 8 | 0; + HEAP32[$476 >> 2] = $471; + var $R_1_i19 = $467; + } + } + } while (0); + var $R_1_i19; + var $499 = ($465 | 0) == 0; + $_$151 : do { + if (!$499) { + var $501 = $v_3_lcssa_i + 28 | 0; + var $502 = HEAP32[$501 >> 2]; + var $503 = __gm_ + 304 + ($502 << 2) | 0; + var $504 = HEAP32[$503 >> 2]; + var $505 = ($v_3_lcssa_i | 0) == ($504 | 0); + do { + if ($505) { + HEAP32[$503 >> 2] = $R_1_i19; + var $cond_i20 = ($R_1_i19 | 0) == 0; + if (!$cond_i20) { + break; + } + var $507 = HEAP32[$501 >> 2]; + var $508 = 1 << $507; + var $509 = $508 ^ -1; + var $510 = HEAP32[(__gm_ + 4 | 0) >> 2]; + var $511 = $510 & $509; + HEAP32[(__gm_ + 4 | 0) >> 2] = $511; + break $_$151; + } + var $513 = $465; + var $514 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + var $515 = $513 >>> 0 < $514 >>> 0; + if ($515) { + _abort(); } else { - var $182 = $176; + var $517 = $465 + 16 | 0; + var $518 = HEAP32[$517 >> 2]; + var $519 = ($518 | 0) == ($v_3_lcssa_i | 0); + if ($519) { + HEAP32[$517 >> 2] = $R_1_i19; + } else { + var $522 = $465 + 20 | 0; + HEAP32[$522 >> 2] = $R_1_i19; + } + var $525 = ($R_1_i19 | 0) == 0; + if ($525) { + break $_$151; + } } - var $182; - var $183 = $182 + 4 | 0; - var $184 = HEAP32[$183 >> 2]; - var $185 = $184 & -8; - var $186 = $185 - $8 | 0; - var $187 = $186 >>> 0 < $rsize_0_i >>> 0; - var $_rsize_0_i = $187 ? $186 : $rsize_0_i; - var $_v_0_i = $187 ? $182 : $v_0_i; - var $t_0_i = $182; - var $v_0_i = $_v_0_i; - var $rsize_0_i = $_rsize_0_i; + } while (0); + var $527 = $R_1_i19; + var $528 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + var $529 = $527 >>> 0 < $528 >>> 0; + if ($529) { + _abort(); + } else { + var $531 = $R_1_i19 + 24 | 0; + HEAP32[$531 >> 2] = $465; + var $532 = $v_3_lcssa_i + 16 | 0; + var $533 = HEAPU32[$532 >> 2]; + var $534 = ($533 | 0) == 0; + if (!$534) { + var $536 = $533; + var $537 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + var $538 = $536 >>> 0 < $537 >>> 0; + if ($538) { + _abort(); + } else { + var $540 = $R_1_i19 + 16 | 0; + HEAP32[$540 >> 2] = $533; + var $541 = $533 + 24 | 0; + HEAP32[$541 >> 2] = $R_1_i19; + } + } + var $544 = $v_3_lcssa_i + 20 | 0; + var $545 = HEAPU32[$544 >> 2]; + var $546 = ($545 | 0) == 0; + if ($546) { + break; + } + var $548 = $545; + var $549 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + var $550 = $548 >>> 0 < $549 >>> 0; + if ($550) { + _abort(); + } else { + var $552 = $R_1_i19 + 20 | 0; + HEAP32[$552 >> 2] = $545; + var $553 = $545 + 24 | 0; + HEAP32[$553 >> 2] = $R_1_i19; + } + } } - var $189 = $v_0_i; - var $190 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - var $191 = $189 >>> 0 < $190 >>> 0; - do { - if (!$191) { - var $193 = $189 + $8 | 0; - var $194 = $193; - var $195 = $189 >>> 0 < $193 >>> 0; - if (!$195) { - break; + } while (0); + var $557 = $rsize_3_lcssa_i >>> 0 < 16; + $_$179 : do { + if ($557) { + var $559 = $rsize_3_lcssa_i + $342 | 0; + var $560 = $559 | 3; + var $561 = $v_3_lcssa_i + 4 | 0; + HEAP32[$561 >> 2] = $560; + var $_sum18_i = $559 + 4 | 0; + var $562 = $456 + $_sum18_i | 0; + var $563 = $562; + var $564 = HEAP32[$563 >> 2]; + var $565 = $564 | 1; + HEAP32[$563 >> 2] = $565; + } else { + var $567 = $342 | 3; + var $568 = $v_3_lcssa_i + 4 | 0; + HEAP32[$568 >> 2] = $567; + var $569 = $rsize_3_lcssa_i | 1; + var $_sum_i2232 = $342 | 4; + var $570 = $456 + $_sum_i2232 | 0; + var $571 = $570; + HEAP32[$571 >> 2] = $569; + var $_sum1_i23 = $rsize_3_lcssa_i + $342 | 0; + var $572 = $456 + $_sum1_i23 | 0; + var $573 = $572; + HEAP32[$573 >> 2] = $rsize_3_lcssa_i; + var $574 = $rsize_3_lcssa_i >>> 0 < 256; + if ($574) { + var $576 = $rsize_3_lcssa_i >>> 3; + var $577 = $rsize_3_lcssa_i >>> 2; + var $578 = $577 & 1073741822; + var $579 = __gm_ + 40 + ($578 << 2) | 0; + var $580 = $579; + var $581 = HEAPU32[(__gm_ | 0) >> 2]; + var $582 = 1 << $576; + var $583 = $581 & $582; + var $584 = ($583 | 0) == 0; + do { + if ($584) { + var $586 = $581 | $582; + HEAP32[(__gm_ | 0) >> 2] = $586; + var $_sum14_pre_i = $578 + 2 | 0; + var $_pre_i24 = __gm_ + 40 + ($_sum14_pre_i << 2) | 0; + var $F5_0_i = $580; + var $_pre_phi_i25 = $_pre_i24; + } else { + var $_sum17_i = $578 + 2 | 0; + var $588 = __gm_ + 40 + ($_sum17_i << 2) | 0; + var $589 = HEAPU32[$588 >> 2]; + var $590 = $589; + var $591 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + var $592 = $590 >>> 0 < $591 >>> 0; + if (!$592) { + var $F5_0_i = $589; + var $_pre_phi_i25 = $588; + break; } - var $197 = $v_0_i + 24 | 0; - var $198 = HEAPU32[$197 >> 2]; - var $199 = $v_0_i + 12 | 0; - var $200 = HEAPU32[$199 >> 2]; - var $201 = ($200 | 0) == ($v_0_i | 0); - do { - if ($201) { - var $212 = $v_0_i + 20 | 0; - var $213 = HEAP32[$212 >> 2]; - var $214 = ($213 | 0) == 0; - if ($214) { - var $216 = $v_0_i + 16 | 0; - var $217 = HEAP32[$216 >> 2]; - var $218 = ($217 | 0) == 0; - if ($218) { - var $R_1_i = 0; - break; - } - var $RP_0_i = $216; - var $R_0_i = $217; - } else { - var $RP_0_i = $212; - var $R_0_i = $213; - __label__ = 39; - } - while (1) { - var $R_0_i; - var $RP_0_i; - var $219 = $R_0_i + 20 | 0; - var $220 = HEAP32[$219 >> 2]; - var $221 = ($220 | 0) == 0; - if (!$221) { - var $RP_0_i = $219; - var $R_0_i = $220; - continue; - } - var $223 = $R_0_i + 16 | 0; - var $224 = HEAPU32[$223 >> 2]; - var $225 = ($224 | 0) == 0; - if ($225) { - break; - } - var $RP_0_i = $223; - var $R_0_i = $224; - } - var $227 = $RP_0_i; - var $228 = $227 >>> 0 < $190 >>> 0; - if ($228) { - _abort(); - } else { - HEAP32[$RP_0_i >> 2] = 0; - var $R_1_i = $R_0_i; - } - } else { - var $203 = $v_0_i + 8 | 0; - var $204 = HEAPU32[$203 >> 2]; - var $205 = $204; - var $206 = $205 >>> 0 < $190 >>> 0; - if ($206) { - _abort(); - } else { - var $208 = $204 + 12 | 0; - HEAP32[$208 >> 2] = $200; - var $209 = $200 + 8 | 0; - HEAP32[$209 >> 2] = $204; - var $R_1_i = $200; - } - } - } while (0); - var $R_1_i; - var $232 = ($198 | 0) == 0; - $_$62 : do { - if (!$232) { - var $234 = $v_0_i + 28 | 0; - var $235 = HEAP32[$234 >> 2]; - var $236 = __gm_ + 304 + ($235 << 2) | 0; - var $237 = HEAP32[$236 >> 2]; - var $238 = ($v_0_i | 0) == ($237 | 0); - do { - if ($238) { - HEAP32[$236 >> 2] = $R_1_i; - var $cond_i = ($R_1_i | 0) == 0; - if (!$cond_i) { - break; - } - var $240 = HEAP32[$234 >> 2]; - var $241 = 1 << $240; - var $242 = $241 ^ -1; - var $243 = HEAP32[(__gm_ + 4 | 0) >> 2]; - var $244 = $243 & $242; - HEAP32[(__gm_ + 4 | 0) >> 2] = $244; - break $_$62; - } - var $246 = $198; - var $247 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - var $248 = $246 >>> 0 < $247 >>> 0; - if ($248) { - _abort(); - } else { - var $250 = $198 + 16 | 0; - var $251 = HEAP32[$250 >> 2]; - var $252 = ($251 | 0) == ($v_0_i | 0); - if ($252) { - HEAP32[$250 >> 2] = $R_1_i; - } else { - var $255 = $198 + 20 | 0; - HEAP32[$255 >> 2] = $R_1_i; - } - var $258 = ($R_1_i | 0) == 0; - if ($258) { - break $_$62; - } - } - } while (0); - var $260 = $R_1_i; - var $261 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - var $262 = $260 >>> 0 < $261 >>> 0; - if ($262) { - _abort(); - } else { - var $264 = $R_1_i + 24 | 0; - HEAP32[$264 >> 2] = $198; - var $265 = $v_0_i + 16 | 0; - var $266 = HEAPU32[$265 >> 2]; - var $267 = ($266 | 0) == 0; - if (!$267) { - var $269 = $266; - var $270 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - var $271 = $269 >>> 0 < $270 >>> 0; - if ($271) { - _abort(); - } else { - var $273 = $R_1_i + 16 | 0; - HEAP32[$273 >> 2] = $266; - var $274 = $266 + 24 | 0; - HEAP32[$274 >> 2] = $R_1_i; - } - } - var $277 = $v_0_i + 20 | 0; - var $278 = HEAPU32[$277 >> 2]; - var $279 = ($278 | 0) == 0; - if ($279) { - break; - } - var $281 = $278; - var $282 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - var $283 = $281 >>> 0 < $282 >>> 0; - if ($283) { - _abort(); - } else { - var $285 = $R_1_i + 20 | 0; - HEAP32[$285 >> 2] = $278; - var $286 = $278 + 24 | 0; - HEAP32[$286 >> 2] = $R_1_i; - } - } + _abort(); + } + } while (0); + var $_pre_phi_i25; + var $F5_0_i; + HEAP32[$_pre_phi_i25 >> 2] = $461; + var $595 = $F5_0_i + 12 | 0; + HEAP32[$595 >> 2] = $461; + var $_sum15_i = $342 + 8 | 0; + var $596 = $456 + $_sum15_i | 0; + var $597 = $596; + HEAP32[$597 >> 2] = $F5_0_i; + var $_sum16_i = $342 + 12 | 0; + var $598 = $456 + $_sum16_i | 0; + var $599 = $598; + HEAP32[$599 >> 2] = $580; + } else { + var $601 = $460; + var $602 = $rsize_3_lcssa_i >>> 8; + var $603 = ($602 | 0) == 0; + do { + if ($603) { + var $I7_0_i = 0; + } else { + var $605 = $rsize_3_lcssa_i >>> 0 > 16777215; + if ($605) { + var $I7_0_i = 31; + break; + } + var $607 = $602 + 1048320 | 0; + var $608 = $607 >>> 16; + var $609 = $608 & 8; + var $610 = $602 << $609; + var $611 = $610 + 520192 | 0; + var $612 = $611 >>> 16; + var $613 = $612 & 4; + var $614 = $610 << $613; + var $615 = $614 + 245760 | 0; + var $616 = $615 >>> 16; + var $617 = $616 & 2; + var $618 = $613 | $609; + var $619 = $618 | $617; + var $620 = 14 - $619 | 0; + var $621 = $614 << $617; + var $622 = $621 >>> 15; + var $623 = $620 + $622 | 0; + var $624 = $623 << 1; + var $625 = $623 + 7 | 0; + var $626 = $rsize_3_lcssa_i >>> ($625 >>> 0); + var $627 = $626 & 1; + var $628 = $627 | $624; + var $I7_0_i = $628; + } + } while (0); + var $I7_0_i; + var $630 = __gm_ + 304 + ($I7_0_i << 2) | 0; + var $_sum2_i = $342 + 28 | 0; + var $631 = $456 + $_sum2_i | 0; + var $632 = $631; + HEAP32[$632 >> 2] = $I7_0_i; + var $_sum3_i26 = $342 + 16 | 0; + var $633 = $456 + $_sum3_i26 | 0; + var $_sum4_i27 = $342 + 20 | 0; + var $634 = $456 + $_sum4_i27 | 0; + var $635 = $634; + HEAP32[$635 >> 2] = 0; + var $636 = $633; + HEAP32[$636 >> 2] = 0; + var $637 = HEAP32[(__gm_ + 4 | 0) >> 2]; + var $638 = 1 << $I7_0_i; + var $639 = $637 & $638; + var $640 = ($639 | 0) == 0; + if ($640) { + var $642 = $637 | $638; + HEAP32[(__gm_ + 4 | 0) >> 2] = $642; + HEAP32[$630 >> 2] = $601; + var $643 = $630; + var $_sum5_i = $342 + 24 | 0; + var $644 = $456 + $_sum5_i | 0; + var $645 = $644; + HEAP32[$645 >> 2] = $643; + var $_sum6_i = $342 + 12 | 0; + var $646 = $456 + $_sum6_i | 0; + var $647 = $646; + HEAP32[$647 >> 2] = $601; + var $_sum7_i = $342 + 8 | 0; + var $648 = $456 + $_sum7_i | 0; + var $649 = $648; + HEAP32[$649 >> 2] = $601; + } else { + var $651 = HEAP32[$630 >> 2]; + var $652 = ($I7_0_i | 0) == 31; + if ($652) { + var $657 = 0; + } else { + var $654 = $I7_0_i >>> 1; + var $655 = 25 - $654 | 0; + var $657 = $655; + } + var $657; + var $658 = $rsize_3_lcssa_i << $657; + var $K12_0_i = $658; + var $T_0_i = $651; + while (1) { + var $T_0_i; + var $K12_0_i; + var $660 = $T_0_i + 4 | 0; + var $661 = HEAP32[$660 >> 2]; + var $662 = $661 & -8; + var $663 = ($662 | 0) == ($rsize_3_lcssa_i | 0); + if ($663) { + var $683 = $T_0_i + 8 | 0; + var $684 = HEAPU32[$683 >> 2]; + var $685 = $T_0_i; + var $686 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + var $687 = $685 >>> 0 < $686 >>> 0; + do { + if (!$687) { + var $689 = $684; + var $690 = $689 >>> 0 < $686 >>> 0; + if ($690) { + break; + } + var $692 = $684 + 12 | 0; + HEAP32[$692 >> 2] = $601; + HEAP32[$683 >> 2] = $601; + var $_sum8_i = $342 + 8 | 0; + var $693 = $456 + $_sum8_i | 0; + var $694 = $693; + HEAP32[$694 >> 2] = $684; + var $_sum9_i = $342 + 12 | 0; + var $695 = $456 + $_sum9_i | 0; + var $696 = $695; + HEAP32[$696 >> 2] = $T_0_i; + var $_sum10_i = $342 + 24 | 0; + var $697 = $456 + $_sum10_i | 0; + var $698 = $697; + HEAP32[$698 >> 2] = 0; + break $_$179; } - } while (0); - var $290 = $rsize_0_i >>> 0 < 16; - if ($290) { - var $292 = $rsize_0_i + $8 | 0; - var $293 = $292 | 3; - var $294 = $v_0_i + 4 | 0; - HEAP32[$294 >> 2] = $293; - var $_sum4_i = $292 + 4 | 0; - var $295 = $189 + $_sum4_i | 0; - var $296 = $295; - var $297 = HEAP32[$296 >> 2]; - var $298 = $297 | 1; - HEAP32[$296 >> 2] = $298; + } while (0); + _abort(); } else { - var $300 = $8 | 3; - var $301 = $v_0_i + 4 | 0; - HEAP32[$301 >> 2] = $300; - var $302 = $rsize_0_i | 1; - var $_sum_i33 = $8 | 4; - var $303 = $189 + $_sum_i33 | 0; - var $304 = $303; - HEAP32[$304 >> 2] = $302; - var $_sum1_i = $rsize_0_i + $8 | 0; - var $305 = $189 + $_sum1_i | 0; - var $306 = $305; - HEAP32[$306 >> 2] = $rsize_0_i; - var $307 = HEAPU32[(__gm_ + 8 | 0) >> 2]; - var $308 = ($307 | 0) == 0; - if (!$308) { - var $310 = HEAPU32[(__gm_ + 20 | 0) >> 2]; - var $311 = $307 >>> 3; - var $312 = $307 >>> 2; - var $313 = $312 & 1073741822; - var $314 = __gm_ + 40 + ($313 << 2) | 0; - var $315 = $314; - var $316 = HEAPU32[(__gm_ | 0) >> 2]; - var $317 = 1 << $311; - var $318 = $316 & $317; - var $319 = ($318 | 0) == 0; - do { - if ($319) { - var $321 = $316 | $317; - HEAP32[(__gm_ | 0) >> 2] = $321; - var $_sum2_pre_i = $313 + 2 | 0; - var $_pre_i = __gm_ + 40 + ($_sum2_pre_i << 2) | 0; - var $F1_0_i = $315; - var $_pre_phi_i = $_pre_i; - } else { - var $_sum3_i = $313 + 2 | 0; - var $323 = __gm_ + 40 + ($_sum3_i << 2) | 0; - var $324 = HEAPU32[$323 >> 2]; - var $325 = $324; - var $326 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - var $327 = $325 >>> 0 < $326 >>> 0; - if (!$327) { - var $F1_0_i = $324; - var $_pre_phi_i = $323; - break; - } - _abort(); - } - } while (0); - var $_pre_phi_i; - var $F1_0_i; - HEAP32[$_pre_phi_i >> 2] = $310; - var $330 = $F1_0_i + 12 | 0; - HEAP32[$330 >> 2] = $310; - var $331 = $310 + 8 | 0; - HEAP32[$331 >> 2] = $F1_0_i; - var $332 = $310 + 12 | 0; - HEAP32[$332 >> 2] = $315; - } - HEAP32[(__gm_ + 8 | 0) >> 2] = $rsize_0_i; - HEAP32[(__gm_ + 20 | 0) >> 2] = $194; - } - var $335 = $v_0_i + 8 | 0; - var $336 = $335; - var $337 = ($335 | 0) == 0; - if ($337) { - var $nb_0 = $8; - __label__ = 155; - break $_$2; + var $665 = $K12_0_i >>> 31; + var $666 = $T_0_i + 16 + ($665 << 2) | 0; + var $667 = HEAPU32[$666 >> 2]; + var $668 = ($667 | 0) == 0; + var $669 = $K12_0_i << 1; + if (!$668) { + var $K12_0_i = $669; + var $T_0_i = $667; + continue; + } + var $671 = $666; + var $672 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + var $673 = $671 >>> 0 < $672 >>> 0; + if (!$673) { + HEAP32[$666 >> 2] = $601; + var $_sum11_i = $342 + 24 | 0; + var $675 = $456 + $_sum11_i | 0; + var $676 = $675; + HEAP32[$676 >> 2] = $T_0_i; + var $_sum12_i = $342 + 12 | 0; + var $677 = $456 + $_sum12_i | 0; + var $678 = $677; + HEAP32[$678 >> 2] = $601; + var $_sum13_i = $342 + 8 | 0; + var $679 = $456 + $_sum13_i | 0; + var $680 = $679; + HEAP32[$680 >> 2] = $601; + break $_$179; + } + _abort(); } - var $mem_0 = $336; - __label__ = 331; - break $_$2; + } } - } while (0); - _abort(); - } else { - var $339 = $bytes >>> 0 > 4294967231; - if ($339) { - var $nb_0 = -1; - __label__ = 155; - break; + } } - var $341 = $bytes + 11 | 0; - var $342 = $341 & -8; - var $343 = HEAPU32[(__gm_ + 4 | 0) >> 2]; - var $344 = ($343 | 0) == 0; - if ($344) { - var $nb_0 = $342; - __label__ = 155; + } while (0); + var $700 = $v_3_lcssa_i + 8 | 0; + var $701 = $700; + var $702 = ($700 | 0) == 0; + if ($702) { + var $nb_0 = $342; + __label__ = 155; + break $_$2; + } + var $mem_0 = $701; + __label__ = 331; + break $_$2; + } + } while (0); + _abort(); + } + } while (0); + $_$215 : do { + if (__label__ == 155) { + var $nb_0; + var $703 = HEAPU32[(__gm_ + 8 | 0) >> 2]; + var $704 = $nb_0 >>> 0 > $703 >>> 0; + if ($704) { + var $732 = HEAPU32[(__gm_ + 12 | 0) >> 2]; + var $733 = $nb_0 >>> 0 < $732 >>> 0; + if ($733) { + var $735 = $732 - $nb_0 | 0; + HEAP32[(__gm_ + 12 | 0) >> 2] = $735; + var $736 = HEAPU32[(__gm_ + 24 | 0) >> 2]; + var $737 = $736; + var $738 = $737 + $nb_0 | 0; + var $739 = $738; + HEAP32[(__gm_ + 24 | 0) >> 2] = $739; + var $740 = $735 | 1; + var $_sum = $nb_0 + 4 | 0; + var $741 = $737 + $_sum | 0; + var $742 = $741; + HEAP32[$742 >> 2] = $740; + var $743 = $nb_0 | 3; + var $744 = $736 + 4 | 0; + HEAP32[$744 >> 2] = $743; + var $745 = $736 + 8 | 0; + var $746 = $745; + var $mem_0 = $746; + } else { + var $748 = HEAP32[(_mparams | 0) >> 2]; + var $749 = ($748 | 0) == 0; + do { + if ($749) { + var $751 = HEAP32[(_mparams | 0) >> 2]; + var $752 = ($751 | 0) == 0; + if (!$752) { break; + } + var $754 = _sysconf(8); + var $755 = $754 - 1 | 0; + var $756 = $755 & $754; + var $757 = ($756 | 0) == 0; + if ($757) { + HEAP32[(_mparams + 8 | 0) >> 2] = $754; + HEAP32[(_mparams + 4 | 0) >> 2] = $754; + HEAP32[(_mparams + 12 | 0) >> 2] = -1; + HEAP32[(_mparams + 16 | 0) >> 2] = 2097152; + HEAP32[(_mparams + 20 | 0) >> 2] = 0; + HEAP32[(__gm_ + 440 | 0) >> 2] = 0; + var $760 = _time(0); + var $761 = $760 & -16; + var $762 = $761 ^ 1431655768; + HEAP32[(_mparams | 0) >> 2] = $762; + } else { + _abort(); + } } - var $346 = -$342 | 0; - var $347 = $341 >>> 8; - var $348 = ($347 | 0) == 0; - do { - if ($348) { - var $idx_0_i = 0; - } else { - var $350 = $342 >>> 0 > 16777215; - if ($350) { - var $idx_0_i = 31; + } while (0); + var $763 = HEAP32[(__gm_ + 440 | 0) >> 2]; + var $764 = $763 & 4; + var $765 = ($764 | 0) == 0; + $_$234 : do { + if ($765) { + var $767 = HEAP32[(__gm_ + 24 | 0) >> 2]; + var $768 = ($767 | 0) == 0; + $_$236 : do { + if (!$768) { + var $770 = $767; + var $sp_0_i_i = __gm_ + 444 | 0; + while (1) { + var $sp_0_i_i; + var $772 = $sp_0_i_i | 0; + var $773 = HEAPU32[$772 >> 2]; + var $774 = $773 >>> 0 > $770 >>> 0; + if (!$774) { + var $776 = $sp_0_i_i + 4 | 0; + var $777 = HEAP32[$776 >> 2]; + var $778 = $773 + $777 | 0; + var $779 = $778 >>> 0 > $770 >>> 0; + if ($779) { break; + } } - var $352 = $347 + 1048320 | 0; - var $353 = $352 >>> 16; - var $354 = $353 & 8; - var $355 = $347 << $354; - var $356 = $355 + 520192 | 0; - var $357 = $356 >>> 16; - var $358 = $357 & 4; - var $359 = $355 << $358; - var $360 = $359 + 245760 | 0; - var $361 = $360 >>> 16; - var $362 = $361 & 2; - var $363 = $358 | $354; - var $364 = $363 | $362; - var $365 = 14 - $364 | 0; - var $366 = $359 << $362; - var $367 = $366 >>> 15; - var $368 = $365 + $367 | 0; - var $369 = $368 << 1; - var $370 = $368 + 7 | 0; - var $371 = $342 >>> ($370 >>> 0); - var $372 = $371 & 1; - var $373 = $372 | $369; - var $idx_0_i = $373; - } - } while (0); - var $idx_0_i; - var $375 = __gm_ + 304 + ($idx_0_i << 2) | 0; - var $376 = HEAPU32[$375 >> 2]; - var $377 = ($376 | 0) == 0; - $_$110 : do { - if ($377) { - var $v_2_i = 0; - var $rsize_2_i = $346; - var $t_1_i = 0; - } else { - var $379 = ($idx_0_i | 0) == 31; - if ($379) { - var $384 = 0; - } else { - var $381 = $idx_0_i >>> 1; - var $382 = 25 - $381 | 0; - var $384 = $382; - } - var $384; - var $385 = $342 << $384; - var $v_0_i15 = 0; - var $rsize_0_i14 = $346; - var $t_0_i13 = $376; - var $sizebits_0_i = $385; - var $rst_0_i = 0; - while (1) { - var $rst_0_i; - var $sizebits_0_i; - var $t_0_i13; - var $rsize_0_i14; - var $v_0_i15; - var $387 = $t_0_i13 + 4 | 0; - var $388 = HEAP32[$387 >> 2]; - var $389 = $388 & -8; - var $390 = $389 - $342 | 0; - var $391 = $390 >>> 0 < $rsize_0_i14 >>> 0; - if ($391) { - var $393 = ($389 | 0) == ($342 | 0); - if ($393) { - var $v_2_i = $t_0_i13; - var $rsize_2_i = $390; - var $t_1_i = $t_0_i13; - break $_$110; - } - var $v_1_i = $t_0_i13; - var $rsize_1_i = $390; - } else { - var $v_1_i = $v_0_i15; - var $rsize_1_i = $rsize_0_i14; - } - var $rsize_1_i; - var $v_1_i; - var $395 = $t_0_i13 + 20 | 0; - var $396 = HEAPU32[$395 >> 2]; - var $397 = $sizebits_0_i >>> 31; - var $398 = $t_0_i13 + 16 + ($397 << 2) | 0; - var $399 = HEAPU32[$398 >> 2]; - var $400 = ($396 | 0) == 0; - var $401 = ($396 | 0) == ($399 | 0); - var $or_cond_i = $400 | $401; - var $rst_1_i = $or_cond_i ? $rst_0_i : $396; - var $402 = ($399 | 0) == 0; - var $403 = $sizebits_0_i << 1; - if ($402) { - var $v_2_i = $v_1_i; - var $rsize_2_i = $rsize_1_i; - var $t_1_i = $rst_1_i; - break $_$110; - } - var $v_0_i15 = $v_1_i; - var $rsize_0_i14 = $rsize_1_i; - var $t_0_i13 = $399; - var $sizebits_0_i = $403; - var $rst_0_i = $rst_1_i; + var $781 = $sp_0_i_i + 8 | 0; + var $782 = HEAPU32[$781 >> 2]; + var $783 = ($782 | 0) == 0; + if ($783) { + __label__ = 174; + break $_$236; } - } - } while (0); - var $t_1_i; - var $rsize_2_i; - var $v_2_i; - var $404 = ($t_1_i | 0) == 0; - var $405 = ($v_2_i | 0) == 0; - var $or_cond19_i = $404 & $405; - if ($or_cond19_i) { - var $407 = 2 << $idx_0_i; - var $408 = -$407 | 0; - var $409 = $407 | $408; - var $410 = $343 & $409; - var $411 = ($410 | 0) == 0; - if ($411) { - var $nb_0 = $342; - __label__ = 155; + var $sp_0_i_i = $782; + } + var $784 = ($sp_0_i_i | 0) == 0; + if ($784) { + __label__ = 174; + break; + } + var $810 = HEAP32[(__gm_ + 12 | 0) >> 2]; + var $811 = HEAP32[(_mparams + 8 | 0) >> 2]; + var $812 = $nb_0 + 47 | 0; + var $813 = $812 - $810 | 0; + var $814 = $813 + $811 | 0; + var $815 = -$811 | 0; + var $816 = $814 & $815; + var $817 = $816 >>> 0 < 2147483647; + if (!$817) { + var $tsize_0242932_ph_i = 0; + __label__ = 189; break; + } + var $819 = _sbrk($816); + var $820 = HEAP32[$772 >> 2]; + var $821 = HEAP32[$776 >> 2]; + var $822 = $820 + $821 | 0; + var $823 = ($819 | 0) == ($822 | 0); + var $_1_i = $823 ? $816 : 0; + var $_2_i = $823 ? $819 : -1; + var $tbase_0_i = $_2_i; + var $tsize_0_i = $_1_i; + var $asize_1_i = $816; + var $br_0_i = $819; + __label__ = 181; + break; } - var $413 = -$410 | 0; - var $414 = $410 & $413; - var $415 = $414 - 1 | 0; - var $416 = $415 >>> 12; - var $417 = $416 & 16; - var $418 = $415 >>> ($417 >>> 0); - var $419 = $418 >>> 5; - var $420 = $419 & 8; - var $421 = $418 >>> ($420 >>> 0); - var $422 = $421 >>> 2; - var $423 = $422 & 4; - var $424 = $421 >>> ($423 >>> 0); - var $425 = $424 >>> 1; - var $426 = $425 & 2; - var $427 = $424 >>> ($426 >>> 0); - var $428 = $427 >>> 1; - var $429 = $428 & 1; - var $430 = $420 | $417; - var $431 = $430 | $423; - var $432 = $431 | $426; - var $433 = $432 | $429; - var $434 = $427 >>> ($429 >>> 0); - var $435 = $433 + $434 | 0; - var $436 = __gm_ + 304 + ($435 << 2) | 0; - var $437 = HEAP32[$436 >> 2]; - var $t_2_ph_i = $437; - } else { - var $t_2_ph_i = $t_1_i; - } - var $t_2_ph_i; - var $438 = ($t_2_ph_i | 0) == 0; - $_$125 : do { - if ($438) { - var $rsize_3_lcssa_i = $rsize_2_i; - var $v_3_lcssa_i = $v_2_i; - } else { - var $t_224_i = $t_2_ph_i; - var $rsize_325_i = $rsize_2_i; - var $v_326_i = $v_2_i; - while (1) { - var $v_326_i; - var $rsize_325_i; - var $t_224_i; - var $439 = $t_224_i + 4 | 0; - var $440 = HEAP32[$439 >> 2]; - var $441 = $440 & -8; - var $442 = $441 - $342 | 0; - var $443 = $442 >>> 0 < $rsize_325_i >>> 0; - var $_rsize_3_i = $443 ? $442 : $rsize_325_i; - var $t_2_v_3_i = $443 ? $t_224_i : $v_326_i; - var $444 = $t_224_i + 16 | 0; - var $445 = HEAPU32[$444 >> 2]; - var $446 = ($445 | 0) == 0; - if (!$446) { - var $t_224_i = $445; - var $rsize_325_i = $_rsize_3_i; - var $v_326_i = $t_2_v_3_i; - continue; - } - var $447 = $t_224_i + 20 | 0; - var $448 = HEAPU32[$447 >> 2]; - var $449 = ($448 | 0) == 0; - if ($449) { - var $rsize_3_lcssa_i = $_rsize_3_i; - var $v_3_lcssa_i = $t_2_v_3_i; - break $_$125; - } - var $t_224_i = $448; - var $rsize_325_i = $_rsize_3_i; - var $v_326_i = $t_2_v_3_i; + __label__ = 174; + } while (0); + do { + if (__label__ == 174) { + var $785 = _sbrk(0); + var $786 = ($785 | 0) == -1; + if ($786) { + var $tsize_0242932_ph_i = 0; + __label__ = 189; + break; + } + var $788 = HEAP32[(_mparams + 8 | 0) >> 2]; + var $789 = $nb_0 + 47 | 0; + var $790 = $789 + $788 | 0; + var $791 = -$788 | 0; + var $792 = $790 & $791; + var $793 = $785; + var $794 = HEAP32[(_mparams + 4 | 0) >> 2]; + var $795 = $794 - 1 | 0; + var $796 = $795 & $793; + var $797 = ($796 | 0) == 0; + if ($797) { + var $asize_0_i = $792; + } else { + var $799 = $795 + $793 | 0; + var $800 = -$794 | 0; + var $801 = $799 & $800; + var $802 = $792 - $793 | 0; + var $803 = $802 + $801 | 0; + var $asize_0_i = $803; + } + var $asize_0_i; + var $805 = $asize_0_i >>> 0 < 2147483647; + if (!$805) { + var $tsize_0242932_ph_i = 0; + __label__ = 189; + break; + } + var $807 = _sbrk($asize_0_i); + var $808 = ($807 | 0) == ($785 | 0); + var $asize_0__i = $808 ? $asize_0_i : 0; + var $__i = $808 ? $785 : -1; + var $tbase_0_i = $__i; + var $tsize_0_i = $asize_0__i; + var $asize_1_i = $asize_0_i; + var $br_0_i = $807; + __label__ = 181; + break; + } + } while (0); + $_$253 : do { + if (__label__ == 181) { + var $br_0_i; + var $asize_1_i; + var $tsize_0_i; + var $tbase_0_i; + var $825 = -$asize_1_i | 0; + var $826 = ($tbase_0_i | 0) == -1; + if (!$826) { + var $tsize_242_i = $tsize_0_i; + var $tbase_243_i = $tbase_0_i; + __label__ = 194; + break $_$234; + } + var $828 = ($br_0_i | 0) != -1; + var $829 = $asize_1_i >>> 0 < 2147483647; + var $or_cond_i28 = $828 & $829; + do { + if ($or_cond_i28) { + var $831 = $nb_0 + 48 | 0; + var $832 = $asize_1_i >>> 0 < $831 >>> 0; + if (!$832) { + var $asize_2_i = $asize_1_i; + break; + } + var $834 = HEAP32[(_mparams + 8 | 0) >> 2]; + var $835 = $nb_0 + 47 | 0; + var $836 = $835 - $asize_1_i | 0; + var $837 = $836 + $834 | 0; + var $838 = -$834 | 0; + var $839 = $837 & $838; + var $840 = $839 >>> 0 < 2147483647; + if (!$840) { + var $asize_2_i = $asize_1_i; + break; + } + var $842 = _sbrk($839); + var $843 = ($842 | 0) == -1; + if ($843) { + var $847 = _sbrk($825); + var $tsize_0242932_ph_i = $tsize_0_i; + break $_$253; + } + var $845 = $839 + $asize_1_i | 0; + var $asize_2_i = $845; + } else { + var $asize_2_i = $asize_1_i; } + } while (0); + var $asize_2_i; + var $849 = ($br_0_i | 0) == -1; + if (!$849) { + var $tsize_242_i = $asize_2_i; + var $tbase_243_i = $br_0_i; + __label__ = 194; + break $_$234; + } + var $852 = HEAP32[(__gm_ + 440 | 0) >> 2]; + var $853 = $852 | 4; + HEAP32[(__gm_ + 440 | 0) >> 2] = $853; + var $tsize_137_i = $tsize_0_i; + __label__ = 191; + break $_$234; } - } while (0); - var $v_3_lcssa_i; - var $rsize_3_lcssa_i; - var $450 = ($v_3_lcssa_i | 0) == 0; - if ($450) { - var $nb_0 = $342; - __label__ = 155; - break; + } while (0); + var $tsize_0242932_ph_i; + var $850 = HEAP32[(__gm_ + 440 | 0) >> 2]; + var $851 = $850 | 4; + HEAP32[(__gm_ + 440 | 0) >> 2] = $851; + var $tsize_137_i = $tsize_0242932_ph_i; + __label__ = 191; + break; } - var $452 = HEAP32[(__gm_ + 8 | 0) >> 2]; - var $453 = $452 - $342 | 0; - var $454 = $rsize_3_lcssa_i >>> 0 < $453 >>> 0; - if (!$454) { - var $nb_0 = $342; - __label__ = 155; + var $tsize_137_i = 0; + __label__ = 191; + } while (0); + do { + if (__label__ == 191) { + var $tsize_137_i; + var $854 = HEAP32[(_mparams + 8 | 0) >> 2]; + var $855 = $nb_0 + 47 | 0; + var $856 = $855 + $854 | 0; + var $857 = -$854 | 0; + var $858 = $856 & $857; + var $859 = $858 >>> 0 < 2147483647; + if (!$859) { + __label__ = 330; break; + } + var $861 = _sbrk($858); + var $862 = _sbrk(0); + var $notlhs_i = ($861 | 0) != -1; + var $notrhs_i = ($862 | 0) != -1; + var $or_cond3_not_i = $notrhs_i & $notlhs_i; + var $863 = $861 >>> 0 < $862 >>> 0; + var $or_cond4_i = $or_cond3_not_i & $863; + if (!$or_cond4_i) { + __label__ = 330; + break; + } + var $864 = $862; + var $865 = $861; + var $866 = $864 - $865 | 0; + var $867 = $nb_0 + 40 | 0; + var $868 = $866 >>> 0 > $867 >>> 0; + var $_tsize_1_i = $868 ? $866 : $tsize_137_i; + var $_tbase_1_i = $868 ? $861 : -1; + var $869 = ($_tbase_1_i | 0) == -1; + if ($869) { + __label__ = 330; + break; + } + var $tsize_242_i = $_tsize_1_i; + var $tbase_243_i = $_tbase_1_i; + __label__ = 194; + break; } - var $456 = $v_3_lcssa_i; - var $457 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - var $458 = $456 >>> 0 < $457 >>> 0; - do { - if (!$458) { - var $460 = $456 + $342 | 0; - var $461 = $460; - var $462 = $456 >>> 0 < $460 >>> 0; - if (!$462) { + } while (0); + do { + if (__label__ == 194) { + var $tbase_243_i; + var $tsize_242_i; + var $870 = HEAP32[(__gm_ + 432 | 0) >> 2]; + var $871 = $870 + $tsize_242_i | 0; + HEAP32[(__gm_ + 432 | 0) >> 2] = $871; + var $872 = HEAPU32[(__gm_ + 436 | 0) >> 2]; + var $873 = $871 >>> 0 > $872 >>> 0; + if ($873) { + HEAP32[(__gm_ + 436 | 0) >> 2] = $871; + } + var $876 = HEAPU32[(__gm_ + 24 | 0) >> 2]; + var $877 = ($876 | 0) == 0; + $_$275 : do { + if ($877) { + var $879 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + var $880 = ($879 | 0) == 0; + var $881 = $tbase_243_i >>> 0 < $879 >>> 0; + var $or_cond5_i = $880 | $881; + if ($or_cond5_i) { + HEAP32[(__gm_ + 16 | 0) >> 2] = $tbase_243_i; + } + HEAP32[(__gm_ + 444 | 0) >> 2] = $tbase_243_i; + HEAP32[(__gm_ + 448 | 0) >> 2] = $tsize_242_i; + HEAP32[(__gm_ + 456 | 0) >> 2] = 0; + var $884 = HEAP32[(_mparams | 0) >> 2]; + HEAP32[(__gm_ + 36 | 0) >> 2] = $884; + HEAP32[(__gm_ + 32 | 0) >> 2] = -1; + var $i_02_i_i = 0; + while (1) { + var $i_02_i_i; + var $886 = $i_02_i_i << 1; + var $887 = __gm_ + 40 + ($886 << 2) | 0; + var $888 = $887; + var $_sum_i_i = $886 + 3 | 0; + var $889 = __gm_ + 40 + ($_sum_i_i << 2) | 0; + HEAP32[$889 >> 2] = $888; + var $_sum1_i_i = $886 + 2 | 0; + var $890 = __gm_ + 40 + ($_sum1_i_i << 2) | 0; + HEAP32[$890 >> 2] = $888; + var $891 = $i_02_i_i + 1 | 0; + var $exitcond_i_i = ($891 | 0) == 32; + if ($exitcond_i_i) { + break; + } + var $i_02_i_i = $891; + } + var $892 = $tbase_243_i + 8 | 0; + var $893 = $892; + var $894 = $893 & 7; + var $895 = ($894 | 0) == 0; + if ($895) { + var $899 = 0; + } else { + var $897 = -$893 | 0; + var $898 = $897 & 7; + var $899 = $898; + } + var $899; + var $900 = $tbase_243_i + $899 | 0; + var $901 = $900; + var $902 = $tsize_242_i - 40 | 0; + var $903 = $902 - $899 | 0; + HEAP32[(__gm_ + 24 | 0) >> 2] = $901; + HEAP32[(__gm_ + 12 | 0) >> 2] = $903; + var $904 = $903 | 1; + var $_sum_i9_i = $899 + 4 | 0; + var $905 = $tbase_243_i + $_sum_i9_i | 0; + var $906 = $905; + HEAP32[$906 >> 2] = $904; + var $_sum2_i_i = $tsize_242_i - 36 | 0; + var $907 = $tbase_243_i + $_sum2_i_i | 0; + var $908 = $907; + HEAP32[$908 >> 2] = 40; + var $909 = HEAP32[(_mparams + 16 | 0) >> 2]; + HEAP32[(__gm_ + 28 | 0) >> 2] = $909; + } else { + var $sp_0_i = __gm_ + 444 | 0; + while (1) { + var $sp_0_i; + var $910 = ($sp_0_i | 0) == 0; + if ($910) { + break; + } + var $912 = $sp_0_i | 0; + var $913 = HEAPU32[$912 >> 2]; + var $914 = $sp_0_i + 4 | 0; + var $915 = HEAPU32[$914 >> 2]; + var $916 = $913 + $915 | 0; + var $917 = ($tbase_243_i | 0) == ($916 | 0); + if ($917) { + var $921 = $sp_0_i + 12 | 0; + var $922 = HEAP32[$921 >> 2]; + var $923 = $922 & 8; + var $924 = ($923 | 0) == 0; + if (!$924) { break; + } + var $926 = $876; + var $927 = $926 >>> 0 >= $913 >>> 0; + var $928 = $926 >>> 0 < $tbase_243_i >>> 0; + var $or_cond44_i = $927 & $928; + if (!$or_cond44_i) { + break; + } + var $930 = $915 + $tsize_242_i | 0; + HEAP32[$914 >> 2] = $930; + var $931 = HEAP32[(__gm_ + 24 | 0) >> 2]; + var $932 = HEAP32[(__gm_ + 12 | 0) >> 2]; + var $933 = $932 + $tsize_242_i | 0; + var $934 = $931; + var $935 = $931 + 8 | 0; + var $936 = $935; + var $937 = $936 & 7; + var $938 = ($937 | 0) == 0; + if ($938) { + var $942 = 0; + } else { + var $940 = -$936 | 0; + var $941 = $940 & 7; + var $942 = $941; + } + var $942; + var $943 = $934 + $942 | 0; + var $944 = $943; + var $945 = $933 - $942 | 0; + HEAP32[(__gm_ + 24 | 0) >> 2] = $944; + HEAP32[(__gm_ + 12 | 0) >> 2] = $945; + var $946 = $945 | 1; + var $_sum_i13_i = $942 + 4 | 0; + var $947 = $934 + $_sum_i13_i | 0; + var $948 = $947; + HEAP32[$948 >> 2] = $946; + var $_sum2_i14_i = $933 + 4 | 0; + var $949 = $934 + $_sum2_i14_i | 0; + var $950 = $949; + HEAP32[$950 >> 2] = 40; + var $951 = HEAP32[(_mparams + 16 | 0) >> 2]; + HEAP32[(__gm_ + 28 | 0) >> 2] = $951; + break $_$275; } - var $464 = $v_3_lcssa_i + 24 | 0; - var $465 = HEAPU32[$464 >> 2]; - var $466 = $v_3_lcssa_i + 12 | 0; - var $467 = HEAPU32[$466 >> 2]; - var $468 = ($467 | 0) == ($v_3_lcssa_i | 0); - do { - if ($468) { - var $479 = $v_3_lcssa_i + 20 | 0; - var $480 = HEAP32[$479 >> 2]; - var $481 = ($480 | 0) == 0; - if ($481) { - var $483 = $v_3_lcssa_i + 16 | 0; - var $484 = HEAP32[$483 >> 2]; - var $485 = ($484 | 0) == 0; - if ($485) { - var $R_1_i19 = 0; - break; - } - var $RP_0_i17 = $483; - var $R_0_i16 = $484; - } else { - var $RP_0_i17 = $479; - var $R_0_i16 = $480; - __label__ = 103; - } - while (1) { - var $R_0_i16; - var $RP_0_i17; - var $486 = $R_0_i16 + 20 | 0; - var $487 = HEAP32[$486 >> 2]; - var $488 = ($487 | 0) == 0; - if (!$488) { - var $RP_0_i17 = $486; - var $R_0_i16 = $487; - continue; - } - var $490 = $R_0_i16 + 16 | 0; - var $491 = HEAPU32[$490 >> 2]; - var $492 = ($491 | 0) == 0; - if ($492) { - break; - } - var $RP_0_i17 = $490; - var $R_0_i16 = $491; - } - var $494 = $RP_0_i17; - var $495 = $494 >>> 0 < $457 >>> 0; - if ($495) { - _abort(); - } else { - HEAP32[$RP_0_i17 >> 2] = 0; - var $R_1_i19 = $R_0_i16; - } + var $919 = $sp_0_i + 8 | 0; + var $920 = HEAP32[$919 >> 2]; + var $sp_0_i = $920; + } + var $952 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + var $953 = $tbase_243_i >>> 0 < $952 >>> 0; + if ($953) { + HEAP32[(__gm_ + 16 | 0) >> 2] = $tbase_243_i; + } + var $955 = $tbase_243_i + $tsize_242_i | 0; + var $sp_1_i = __gm_ + 444 | 0; + while (1) { + var $sp_1_i; + var $957 = ($sp_1_i | 0) == 0; + if ($957) { + __label__ = 293; + break; + } + var $959 = $sp_1_i | 0; + var $960 = HEAP32[$959 >> 2]; + var $961 = ($960 | 0) == ($955 | 0); + if ($961) { + __label__ = 218; + break; + } + var $963 = $sp_1_i + 8 | 0; + var $964 = HEAP32[$963 >> 2]; + var $sp_1_i = $964; + } + do { + if (__label__ == 218) { + var $965 = $sp_1_i + 12 | 0; + var $966 = HEAP32[$965 >> 2]; + var $967 = $966 & 8; + var $968 = ($967 | 0) == 0; + if (!$968) { + break; + } + HEAP32[$959 >> 2] = $tbase_243_i; + var $970 = $sp_1_i + 4 | 0; + var $971 = HEAP32[$970 >> 2]; + var $972 = $971 + $tsize_242_i | 0; + HEAP32[$970 >> 2] = $972; + var $973 = $tbase_243_i + 8 | 0; + var $974 = $973; + var $975 = $974 & 7; + var $976 = ($975 | 0) == 0; + if ($976) { + var $981 = 0; + } else { + var $978 = -$974 | 0; + var $979 = $978 & 7; + var $981 = $979; + } + var $981; + var $982 = $tbase_243_i + $981 | 0; + var $_sum79_i = $tsize_242_i + 8 | 0; + var $983 = $tbase_243_i + $_sum79_i | 0; + var $984 = $983; + var $985 = $984 & 7; + var $986 = ($985 | 0) == 0; + if ($986) { + var $991 = 0; + } else { + var $988 = -$984 | 0; + var $989 = $988 & 7; + var $991 = $989; + } + var $991; + var $_sum80_i = $991 + $tsize_242_i | 0; + var $992 = $tbase_243_i + $_sum80_i | 0; + var $993 = $992; + var $994 = $992; + var $995 = $982; + var $996 = $994 - $995 | 0; + var $_sum_i16_i = $981 + $nb_0 | 0; + var $997 = $tbase_243_i + $_sum_i16_i | 0; + var $998 = $997; + var $999 = $996 - $nb_0 | 0; + var $1000 = $nb_0 | 3; + var $_sum1_i17_i = $981 + 4 | 0; + var $1001 = $tbase_243_i + $_sum1_i17_i | 0; + var $1002 = $1001; + HEAP32[$1002 >> 2] = $1000; + var $1003 = HEAP32[(__gm_ + 24 | 0) >> 2]; + var $1004 = ($993 | 0) == ($1003 | 0); + $_$314 : do { + if ($1004) { + var $1006 = HEAP32[(__gm_ + 12 | 0) >> 2]; + var $1007 = $1006 + $999 | 0; + HEAP32[(__gm_ + 12 | 0) >> 2] = $1007; + HEAP32[(__gm_ + 24 | 0) >> 2] = $998; + var $1008 = $1007 | 1; + var $_sum42_i_i = $_sum_i16_i + 4 | 0; + var $1009 = $tbase_243_i + $_sum42_i_i | 0; + var $1010 = $1009; + HEAP32[$1010 >> 2] = $1008; } else { - var $470 = $v_3_lcssa_i + 8 | 0; - var $471 = HEAPU32[$470 >> 2]; - var $472 = $471; - var $473 = $472 >>> 0 < $457 >>> 0; - if ($473) { - _abort(); - } else { - var $475 = $471 + 12 | 0; - HEAP32[$475 >> 2] = $467; - var $476 = $467 + 8 | 0; - HEAP32[$476 >> 2] = $471; - var $R_1_i19 = $467; - } - } - } while (0); - var $R_1_i19; - var $499 = ($465 | 0) == 0; - $_$151 : do { - if (!$499) { - var $501 = $v_3_lcssa_i + 28 | 0; - var $502 = HEAP32[$501 >> 2]; - var $503 = __gm_ + 304 + ($502 << 2) | 0; - var $504 = HEAP32[$503 >> 2]; - var $505 = ($v_3_lcssa_i | 0) == ($504 | 0); - do { - if ($505) { - HEAP32[$503 >> 2] = $R_1_i19; - var $cond_i20 = ($R_1_i19 | 0) == 0; - if (!$cond_i20) { + var $1012 = HEAP32[(__gm_ + 20 | 0) >> 2]; + var $1013 = ($993 | 0) == ($1012 | 0); + if ($1013) { + var $1015 = HEAP32[(__gm_ + 8 | 0) >> 2]; + var $1016 = $1015 + $999 | 0; + HEAP32[(__gm_ + 8 | 0) >> 2] = $1016; + HEAP32[(__gm_ + 20 | 0) >> 2] = $998; + var $1017 = $1016 | 1; + var $_sum40_i_i = $_sum_i16_i + 4 | 0; + var $1018 = $tbase_243_i + $_sum40_i_i | 0; + var $1019 = $1018; + HEAP32[$1019 >> 2] = $1017; + var $_sum41_i_i = $1016 + $_sum_i16_i | 0; + var $1020 = $tbase_243_i + $_sum41_i_i | 0; + var $1021 = $1020; + HEAP32[$1021 >> 2] = $1016; + } else { + var $_sum2_i18_i = $tsize_242_i + 4 | 0; + var $_sum81_i = $_sum2_i18_i + $991 | 0; + var $1023 = $tbase_243_i + $_sum81_i | 0; + var $1024 = $1023; + var $1025 = HEAPU32[$1024 >> 2]; + var $1026 = $1025 & 3; + var $1027 = ($1026 | 0) == 1; + if ($1027) { + var $1029 = $1025 & -8; + var $1030 = $1025 >>> 3; + var $1031 = $1025 >>> 0 < 256; + $_$322 : do { + if ($1031) { + var $_sum3738_i_i = $991 | 8; + var $_sum91_i = $_sum3738_i_i + $tsize_242_i | 0; + var $1033 = $tbase_243_i + $_sum91_i | 0; + var $1034 = $1033; + var $1035 = HEAPU32[$1034 >> 2]; + var $_sum39_i_i = $tsize_242_i + 12 | 0; + var $_sum92_i = $_sum39_i_i + $991 | 0; + var $1036 = $tbase_243_i + $_sum92_i | 0; + var $1037 = $1036; + var $1038 = HEAPU32[$1037 >> 2]; + var $1039 = ($1035 | 0) == ($1038 | 0); + if ($1039) { + var $1041 = 1 << $1030; + var $1042 = $1041 ^ -1; + var $1043 = HEAP32[(__gm_ | 0) >> 2]; + var $1044 = $1043 & $1042; + HEAP32[(__gm_ | 0) >> 2] = $1044; + } else { + var $1046 = $1025 >>> 2; + var $1047 = $1046 & 1073741822; + var $1048 = __gm_ + 40 + ($1047 << 2) | 0; + var $1049 = $1048; + var $1050 = ($1035 | 0) == ($1049 | 0); + do { + if ($1050) { + __label__ = 233; + } else { + var $1052 = $1035; + var $1053 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + var $1054 = $1052 >>> 0 < $1053 >>> 0; + if ($1054) { + __label__ = 236; + break; + } + __label__ = 233; break; - } - var $507 = HEAP32[$501 >> 2]; - var $508 = 1 << $507; - var $509 = $508 ^ -1; - var $510 = HEAP32[(__gm_ + 4 | 0) >> 2]; - var $511 = $510 & $509; - HEAP32[(__gm_ + 4 | 0) >> 2] = $511; - break $_$151; - } - var $513 = $465; - var $514 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - var $515 = $513 >>> 0 < $514 >>> 0; - if ($515) { + } + } while (0); + do { + if (__label__ == 233) { + var $1056 = ($1038 | 0) == ($1049 | 0); + if (!$1056) { + var $1058 = $1038; + var $1059 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + var $1060 = $1058 >>> 0 < $1059 >>> 0; + if ($1060) { + break; + } + } + var $1061 = $1035 + 12 | 0; + HEAP32[$1061 >> 2] = $1038; + var $1062 = $1038 + 8 | 0; + HEAP32[$1062 >> 2] = $1035; + break $_$322; + } + } while (0); _abort(); + } } else { - var $517 = $465 + 16 | 0; - var $518 = HEAP32[$517 >> 2]; - var $519 = ($518 | 0) == ($v_3_lcssa_i | 0); - if ($519) { - HEAP32[$517 >> 2] = $R_1_i19; + var $1064 = $992; + var $_sum34_i_i = $991 | 24; + var $_sum82_i = $_sum34_i_i + $tsize_242_i | 0; + var $1065 = $tbase_243_i + $_sum82_i | 0; + var $1066 = $1065; + var $1067 = HEAPU32[$1066 >> 2]; + var $_sum5_i_i = $tsize_242_i + 12 | 0; + var $_sum83_i = $_sum5_i_i + $991 | 0; + var $1068 = $tbase_243_i + $_sum83_i | 0; + var $1069 = $1068; + var $1070 = HEAPU32[$1069 >> 2]; + var $1071 = ($1070 | 0) == ($1064 | 0); + do { + if ($1071) { + var $_sum67_i_i = $991 | 16; + var $_sum89_i = $_sum2_i18_i + $_sum67_i_i | 0; + var $1084 = $tbase_243_i + $_sum89_i | 0; + var $1085 = $1084; + var $1086 = HEAP32[$1085 >> 2]; + var $1087 = ($1086 | 0) == 0; + if ($1087) { + var $_sum90_i = $_sum67_i_i + $tsize_242_i | 0; + var $1089 = $tbase_243_i + $_sum90_i | 0; + var $1090 = $1089; + var $1091 = HEAP32[$1090 >> 2]; + var $1092 = ($1091 | 0) == 0; + if ($1092) { + var $R_1_i_i = 0; + break; + } + var $RP_0_i_i = $1090; + var $R_0_i_i = $1091; + } else { + var $RP_0_i_i = $1085; + var $R_0_i_i = $1086; + __label__ = 243; + } + while (1) { + var $R_0_i_i; + var $RP_0_i_i; + var $1093 = $R_0_i_i + 20 | 0; + var $1094 = HEAP32[$1093 >> 2]; + var $1095 = ($1094 | 0) == 0; + if (!$1095) { + var $RP_0_i_i = $1093; + var $R_0_i_i = $1094; + continue; + } + var $1097 = $R_0_i_i + 16 | 0; + var $1098 = HEAPU32[$1097 >> 2]; + var $1099 = ($1098 | 0) == 0; + if ($1099) { + break; + } + var $RP_0_i_i = $1097; + var $R_0_i_i = $1098; + } + var $1101 = $RP_0_i_i; + var $1102 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + var $1103 = $1101 >>> 0 < $1102 >>> 0; + if ($1103) { + _abort(); + } else { + HEAP32[$RP_0_i_i >> 2] = 0; + var $R_1_i_i = $R_0_i_i; + } } else { - var $522 = $465 + 20 | 0; - HEAP32[$522 >> 2] = $R_1_i19; + var $_sum3536_i_i = $991 | 8; + var $_sum84_i = $_sum3536_i_i + $tsize_242_i | 0; + var $1073 = $tbase_243_i + $_sum84_i | 0; + var $1074 = $1073; + var $1075 = HEAPU32[$1074 >> 2]; + var $1076 = $1075; + var $1077 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + var $1078 = $1076 >>> 0 < $1077 >>> 0; + if ($1078) { + _abort(); + } else { + var $1080 = $1075 + 12 | 0; + HEAP32[$1080 >> 2] = $1070; + var $1081 = $1070 + 8 | 0; + HEAP32[$1081 >> 2] = $1075; + var $R_1_i_i = $1070; + } } - var $525 = ($R_1_i19 | 0) == 0; - if ($525) { - break $_$151; + } while (0); + var $R_1_i_i; + var $1107 = ($1067 | 0) == 0; + if ($1107) { + break; + } + var $_sum30_i_i = $tsize_242_i + 28 | 0; + var $_sum85_i = $_sum30_i_i + $991 | 0; + var $1109 = $tbase_243_i + $_sum85_i | 0; + var $1110 = $1109; + var $1111 = HEAP32[$1110 >> 2]; + var $1112 = __gm_ + 304 + ($1111 << 2) | 0; + var $1113 = HEAP32[$1112 >> 2]; + var $1114 = ($1064 | 0) == ($1113 | 0); + do { + if ($1114) { + HEAP32[$1112 >> 2] = $R_1_i_i; + var $cond_i_i = ($R_1_i_i | 0) == 0; + if (!$cond_i_i) { + break; + } + var $1116 = HEAP32[$1110 >> 2]; + var $1117 = 1 << $1116; + var $1118 = $1117 ^ -1; + var $1119 = HEAP32[(__gm_ + 4 | 0) >> 2]; + var $1120 = $1119 & $1118; + HEAP32[(__gm_ + 4 | 0) >> 2] = $1120; + break $_$322; } - } - } while (0); - var $527 = $R_1_i19; - var $528 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - var $529 = $527 >>> 0 < $528 >>> 0; - if ($529) { - _abort(); - } else { - var $531 = $R_1_i19 + 24 | 0; - HEAP32[$531 >> 2] = $465; - var $532 = $v_3_lcssa_i + 16 | 0; - var $533 = HEAPU32[$532 >> 2]; - var $534 = ($533 | 0) == 0; - if (!$534) { - var $536 = $533; - var $537 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - var $538 = $536 >>> 0 < $537 >>> 0; - if ($538) { - _abort(); + var $1122 = $1067; + var $1123 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + var $1124 = $1122 >>> 0 < $1123 >>> 0; + if ($1124) { + _abort(); } else { - var $540 = $R_1_i19 + 16 | 0; - HEAP32[$540 >> 2] = $533; - var $541 = $533 + 24 | 0; - HEAP32[$541 >> 2] = $R_1_i19; + var $1126 = $1067 + 16 | 0; + var $1127 = HEAP32[$1126 >> 2]; + var $1128 = ($1127 | 0) == ($1064 | 0); + if ($1128) { + HEAP32[$1126 >> 2] = $R_1_i_i; + } else { + var $1131 = $1067 + 20 | 0; + HEAP32[$1131 >> 2] = $R_1_i_i; + } + var $1134 = ($R_1_i_i | 0) == 0; + if ($1134) { + break $_$322; + } } - } - var $544 = $v_3_lcssa_i + 20 | 0; - var $545 = HEAPU32[$544 >> 2]; - var $546 = ($545 | 0) == 0; - if ($546) { - break; - } - var $548 = $545; - var $549 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - var $550 = $548 >>> 0 < $549 >>> 0; - if ($550) { + } while (0); + var $1136 = $R_1_i_i; + var $1137 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + var $1138 = $1136 >>> 0 < $1137 >>> 0; + if ($1138) { _abort(); - } else { - var $552 = $R_1_i19 + 20 | 0; - HEAP32[$552 >> 2] = $545; - var $553 = $545 + 24 | 0; - HEAP32[$553 >> 2] = $R_1_i19; - } - } - } - } while (0); - var $557 = $rsize_3_lcssa_i >>> 0 < 16; - $_$179 : do { - if ($557) { - var $559 = $rsize_3_lcssa_i + $342 | 0; - var $560 = $559 | 3; - var $561 = $v_3_lcssa_i + 4 | 0; - HEAP32[$561 >> 2] = $560; - var $_sum18_i = $559 + 4 | 0; - var $562 = $456 + $_sum18_i | 0; - var $563 = $562; - var $564 = HEAP32[$563 >> 2]; - var $565 = $564 | 1; - HEAP32[$563 >> 2] = $565; - } else { - var $567 = $342 | 3; - var $568 = $v_3_lcssa_i + 4 | 0; - HEAP32[$568 >> 2] = $567; - var $569 = $rsize_3_lcssa_i | 1; - var $_sum_i2232 = $342 | 4; - var $570 = $456 + $_sum_i2232 | 0; - var $571 = $570; - HEAP32[$571 >> 2] = $569; - var $_sum1_i23 = $rsize_3_lcssa_i + $342 | 0; - var $572 = $456 + $_sum1_i23 | 0; - var $573 = $572; - HEAP32[$573 >> 2] = $rsize_3_lcssa_i; - var $574 = $rsize_3_lcssa_i >>> 0 < 256; - if ($574) { - var $576 = $rsize_3_lcssa_i >>> 3; - var $577 = $rsize_3_lcssa_i >>> 2; - var $578 = $577 & 1073741822; - var $579 = __gm_ + 40 + ($578 << 2) | 0; - var $580 = $579; - var $581 = HEAPU32[(__gm_ | 0) >> 2]; - var $582 = 1 << $576; - var $583 = $581 & $582; - var $584 = ($583 | 0) == 0; - do { - if ($584) { - var $586 = $581 | $582; - HEAP32[(__gm_ | 0) >> 2] = $586; - var $_sum14_pre_i = $578 + 2 | 0; - var $_pre_i24 = __gm_ + 40 + ($_sum14_pre_i << 2) | 0; - var $F5_0_i = $580; - var $_pre_phi_i25 = $_pre_i24; - } else { - var $_sum17_i = $578 + 2 | 0; - var $588 = __gm_ + 40 + ($_sum17_i << 2) | 0; - var $589 = HEAPU32[$588 >> 2]; - var $590 = $589; - var $591 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - var $592 = $590 >>> 0 < $591 >>> 0; - if (!$592) { - var $F5_0_i = $589; - var $_pre_phi_i25 = $588; - break; - } + } else { + var $1140 = $R_1_i_i + 24 | 0; + HEAP32[$1140 >> 2] = $1067; + var $_sum3132_i_i = $991 | 16; + var $_sum86_i = $_sum3132_i_i + $tsize_242_i | 0; + var $1141 = $tbase_243_i + $_sum86_i | 0; + var $1142 = $1141; + var $1143 = HEAPU32[$1142 >> 2]; + var $1144 = ($1143 | 0) == 0; + if (!$1144) { + var $1146 = $1143; + var $1147 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + var $1148 = $1146 >>> 0 < $1147 >>> 0; + if ($1148) { _abort(); + } else { + var $1150 = $R_1_i_i + 16 | 0; + HEAP32[$1150 >> 2] = $1143; + var $1151 = $1143 + 24 | 0; + HEAP32[$1151 >> 2] = $R_1_i_i; + } } - } while (0); - var $_pre_phi_i25; - var $F5_0_i; - HEAP32[$_pre_phi_i25 >> 2] = $461; - var $595 = $F5_0_i + 12 | 0; - HEAP32[$595 >> 2] = $461; - var $_sum15_i = $342 + 8 | 0; - var $596 = $456 + $_sum15_i | 0; - var $597 = $596; - HEAP32[$597 >> 2] = $F5_0_i; - var $_sum16_i = $342 + 12 | 0; - var $598 = $456 + $_sum16_i | 0; - var $599 = $598; - HEAP32[$599 >> 2] = $580; - } else { - var $601 = $460; - var $602 = $rsize_3_lcssa_i >>> 8; - var $603 = ($602 | 0) == 0; - do { - if ($603) { - var $I7_0_i = 0; - } else { - var $605 = $rsize_3_lcssa_i >>> 0 > 16777215; - if ($605) { - var $I7_0_i = 31; - break; - } - var $607 = $602 + 1048320 | 0; - var $608 = $607 >>> 16; - var $609 = $608 & 8; - var $610 = $602 << $609; - var $611 = $610 + 520192 | 0; - var $612 = $611 >>> 16; - var $613 = $612 & 4; - var $614 = $610 << $613; - var $615 = $614 + 245760 | 0; - var $616 = $615 >>> 16; - var $617 = $616 & 2; - var $618 = $613 | $609; - var $619 = $618 | $617; - var $620 = 14 - $619 | 0; - var $621 = $614 << $617; - var $622 = $621 >>> 15; - var $623 = $620 + $622 | 0; - var $624 = $623 << 1; - var $625 = $623 + 7 | 0; - var $626 = $rsize_3_lcssa_i >>> ($625 >>> 0); - var $627 = $626 & 1; - var $628 = $627 | $624; - var $I7_0_i = $628; + var $_sum87_i = $_sum2_i18_i + $_sum3132_i_i | 0; + var $1154 = $tbase_243_i + $_sum87_i | 0; + var $1155 = $1154; + var $1156 = HEAPU32[$1155 >> 2]; + var $1157 = ($1156 | 0) == 0; + if ($1157) { + break; } - } while (0); - var $I7_0_i; - var $630 = __gm_ + 304 + ($I7_0_i << 2) | 0; - var $_sum2_i = $342 + 28 | 0; - var $631 = $456 + $_sum2_i | 0; - var $632 = $631; - HEAP32[$632 >> 2] = $I7_0_i; - var $_sum3_i26 = $342 + 16 | 0; - var $633 = $456 + $_sum3_i26 | 0; - var $_sum4_i27 = $342 + 20 | 0; - var $634 = $456 + $_sum4_i27 | 0; - var $635 = $634; - HEAP32[$635 >> 2] = 0; - var $636 = $633; - HEAP32[$636 >> 2] = 0; - var $637 = HEAP32[(__gm_ + 4 | 0) >> 2]; - var $638 = 1 << $I7_0_i; - var $639 = $637 & $638; - var $640 = ($639 | 0) == 0; - if ($640) { - var $642 = $637 | $638; - HEAP32[(__gm_ + 4 | 0) >> 2] = $642; - HEAP32[$630 >> 2] = $601; - var $643 = $630; - var $_sum5_i = $342 + 24 | 0; - var $644 = $456 + $_sum5_i | 0; - var $645 = $644; - HEAP32[$645 >> 2] = $643; - var $_sum6_i = $342 + 12 | 0; - var $646 = $456 + $_sum6_i | 0; - var $647 = $646; - HEAP32[$647 >> 2] = $601; - var $_sum7_i = $342 + 8 | 0; - var $648 = $456 + $_sum7_i | 0; - var $649 = $648; - HEAP32[$649 >> 2] = $601; - } else { - var $651 = HEAP32[$630 >> 2]; - var $652 = ($I7_0_i | 0) == 31; - if ($652) { - var $657 = 0; + var $1159 = $1156; + var $1160 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + var $1161 = $1159 >>> 0 < $1160 >>> 0; + if ($1161) { + _abort(); } else { - var $654 = $I7_0_i >>> 1; - var $655 = 25 - $654 | 0; - var $657 = $655; - } - var $657; - var $658 = $rsize_3_lcssa_i << $657; - var $K12_0_i = $658; - var $T_0_i = $651; - while (1) { - var $T_0_i; - var $K12_0_i; - var $660 = $T_0_i + 4 | 0; - var $661 = HEAP32[$660 >> 2]; - var $662 = $661 & -8; - var $663 = ($662 | 0) == ($rsize_3_lcssa_i | 0); - if ($663) { - var $683 = $T_0_i + 8 | 0; - var $684 = HEAPU32[$683 >> 2]; - var $685 = $T_0_i; - var $686 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - var $687 = $685 >>> 0 < $686 >>> 0; - do { - if (!$687) { - var $689 = $684; - var $690 = $689 >>> 0 < $686 >>> 0; - if ($690) { - break; - } - var $692 = $684 + 12 | 0; - HEAP32[$692 >> 2] = $601; - HEAP32[$683 >> 2] = $601; - var $_sum8_i = $342 + 8 | 0; - var $693 = $456 + $_sum8_i | 0; - var $694 = $693; - HEAP32[$694 >> 2] = $684; - var $_sum9_i = $342 + 12 | 0; - var $695 = $456 + $_sum9_i | 0; - var $696 = $695; - HEAP32[$696 >> 2] = $T_0_i; - var $_sum10_i = $342 + 24 | 0; - var $697 = $456 + $_sum10_i | 0; - var $698 = $697; - HEAP32[$698 >> 2] = 0; - break $_$179; - } - } while (0); - _abort(); - } else { - var $665 = $K12_0_i >>> 31; - var $666 = $T_0_i + 16 + ($665 << 2) | 0; - var $667 = HEAPU32[$666 >> 2]; - var $668 = ($667 | 0) == 0; - var $669 = $K12_0_i << 1; - if (!$668) { - var $K12_0_i = $669; - var $T_0_i = $667; - continue; - } - var $671 = $666; - var $672 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - var $673 = $671 >>> 0 < $672 >>> 0; - if (!$673) { - HEAP32[$666 >> 2] = $601; - var $_sum11_i = $342 + 24 | 0; - var $675 = $456 + $_sum11_i | 0; - var $676 = $675; - HEAP32[$676 >> 2] = $T_0_i; - var $_sum12_i = $342 + 12 | 0; - var $677 = $456 + $_sum12_i | 0; - var $678 = $677; - HEAP32[$678 >> 2] = $601; - var $_sum13_i = $342 + 8 | 0; - var $679 = $456 + $_sum13_i | 0; - var $680 = $679; - HEAP32[$680 >> 2] = $601; - break $_$179; - } - _abort(); - } + var $1163 = $R_1_i_i + 20 | 0; + HEAP32[$1163 >> 2] = $1156; + var $1164 = $1156 + 24 | 0; + HEAP32[$1164 >> 2] = $R_1_i_i; } + } } - } - } - } while (0); - var $700 = $v_3_lcssa_i + 8 | 0; - var $701 = $700; - var $702 = ($700 | 0) == 0; - if ($702) { - var $nb_0 = $342; - __label__ = 155; - break $_$2; - } - var $mem_0 = $701; - __label__ = 331; - break $_$2; - } - } while (0); - _abort(); - } - } while (0); - $_$215 : do { - if (__label__ == 155) { - var $nb_0; - var $703 = HEAPU32[(__gm_ + 8 | 0) >> 2]; - var $704 = $nb_0 >>> 0 > $703 >>> 0; - if ($704) { - var $732 = HEAPU32[(__gm_ + 12 | 0) >> 2]; - var $733 = $nb_0 >>> 0 < $732 >>> 0; - if ($733) { - var $735 = $732 - $nb_0 | 0; - HEAP32[(__gm_ + 12 | 0) >> 2] = $735; - var $736 = HEAPU32[(__gm_ + 24 | 0) >> 2]; - var $737 = $736; - var $738 = $737 + $nb_0 | 0; - var $739 = $738; - HEAP32[(__gm_ + 24 | 0) >> 2] = $739; - var $740 = $735 | 1; - var $_sum = $nb_0 + 4 | 0; - var $741 = $737 + $_sum | 0; - var $742 = $741; - HEAP32[$742 >> 2] = $740; - var $743 = $nb_0 | 3; - var $744 = $736 + 4 | 0; - HEAP32[$744 >> 2] = $743; - var $745 = $736 + 8 | 0; - var $746 = $745; - var $mem_0 = $746; - } else { - var $748 = HEAP32[(_mparams | 0) >> 2]; - var $749 = ($748 | 0) == 0; - do { - if ($749) { - var $751 = HEAP32[(_mparams | 0) >> 2]; - var $752 = ($751 | 0) == 0; - if (!$752) { - break; - } - var $754 = _sysconf(8); - var $755 = $754 - 1 | 0; - var $756 = $755 & $754; - var $757 = ($756 | 0) == 0; - if ($757) { - HEAP32[(_mparams + 8 | 0) >> 2] = $754; - HEAP32[(_mparams + 4 | 0) >> 2] = $754; - HEAP32[(_mparams + 12 | 0) >> 2] = -1; - HEAP32[(_mparams + 16 | 0) >> 2] = 2097152; - HEAP32[(_mparams + 20 | 0) >> 2] = 0; - HEAP32[(__gm_ + 440 | 0) >> 2] = 0; - var $760 = _time(0); - var $761 = $760 & -16; - var $762 = $761 ^ 1431655768; - HEAP32[(_mparams | 0) >> 2] = $762; + } while (0); + var $_sum9_i_i = $1029 | $991; + var $_sum88_i = $_sum9_i_i + $tsize_242_i | 0; + var $1168 = $tbase_243_i + $_sum88_i | 0; + var $1169 = $1168; + var $1170 = $1029 + $999 | 0; + var $oldfirst_0_i_i = $1169; + var $qsize_0_i_i = $1170; } else { - _abort(); + var $oldfirst_0_i_i = $993; + var $qsize_0_i_i = $999; } - } - } while (0); - var $763 = HEAP32[(__gm_ + 440 | 0) >> 2]; - var $764 = $763 & 4; - var $765 = ($764 | 0) == 0; - $_$234 : do { - if ($765) { - var $767 = HEAP32[(__gm_ + 24 | 0) >> 2]; - var $768 = ($767 | 0) == 0; - $_$236 : do { - if (!$768) { - var $770 = $767; - var $sp_0_i_i = __gm_ + 444 | 0; - while (1) { - var $sp_0_i_i; - var $772 = $sp_0_i_i | 0; - var $773 = HEAPU32[$772 >> 2]; - var $774 = $773 >>> 0 > $770 >>> 0; - if (!$774) { - var $776 = $sp_0_i_i + 4 | 0; - var $777 = HEAP32[$776 >> 2]; - var $778 = $773 + $777 | 0; - var $779 = $778 >>> 0 > $770 >>> 0; - if ($779) { - break; - } - } - var $781 = $sp_0_i_i + 8 | 0; - var $782 = HEAPU32[$781 >> 2]; - var $783 = ($782 | 0) == 0; - if ($783) { - __label__ = 174; - break $_$236; - } - var $sp_0_i_i = $782; - } - var $784 = ($sp_0_i_i | 0) == 0; - if ($784) { - __label__ = 174; - break; - } - var $810 = HEAP32[(__gm_ + 12 | 0) >> 2]; - var $811 = HEAP32[(_mparams + 8 | 0) >> 2]; - var $812 = $nb_0 + 47 | 0; - var $813 = $812 - $810 | 0; - var $814 = $813 + $811 | 0; - var $815 = -$811 | 0; - var $816 = $814 & $815; - var $817 = $816 >>> 0 < 2147483647; - if (!$817) { - var $tsize_0242932_ph_i = 0; - __label__ = 189; - break; - } - var $819 = _sbrk($816); - var $820 = HEAP32[$772 >> 2]; - var $821 = HEAP32[$776 >> 2]; - var $822 = $820 + $821 | 0; - var $823 = ($819 | 0) == ($822 | 0); - var $_1_i = $823 ? $816 : 0; - var $_2_i = $823 ? $819 : -1; - var $tbase_0_i = $_2_i; - var $tsize_0_i = $_1_i; - var $asize_1_i = $816; - var $br_0_i = $819; - __label__ = 181; + var $qsize_0_i_i; + var $oldfirst_0_i_i; + var $1172 = $oldfirst_0_i_i + 4 | 0; + var $1173 = HEAP32[$1172 >> 2]; + var $1174 = $1173 & -2; + HEAP32[$1172 >> 2] = $1174; + var $1175 = $qsize_0_i_i | 1; + var $_sum10_i_i = $_sum_i16_i + 4 | 0; + var $1176 = $tbase_243_i + $_sum10_i_i | 0; + var $1177 = $1176; + HEAP32[$1177 >> 2] = $1175; + var $_sum11_i19_i = $qsize_0_i_i + $_sum_i16_i | 0; + var $1178 = $tbase_243_i + $_sum11_i19_i | 0; + var $1179 = $1178; + HEAP32[$1179 >> 2] = $qsize_0_i_i; + var $1180 = $qsize_0_i_i >>> 0 < 256; + if ($1180) { + var $1182 = $qsize_0_i_i >>> 3; + var $1183 = $qsize_0_i_i >>> 2; + var $1184 = $1183 & 1073741822; + var $1185 = __gm_ + 40 + ($1184 << 2) | 0; + var $1186 = $1185; + var $1187 = HEAPU32[(__gm_ | 0) >> 2]; + var $1188 = 1 << $1182; + var $1189 = $1187 & $1188; + var $1190 = ($1189 | 0) == 0; + do { + if ($1190) { + var $1192 = $1187 | $1188; + HEAP32[(__gm_ | 0) >> 2] = $1192; + var $_sum26_pre_i_i = $1184 + 2 | 0; + var $_pre_i_i = __gm_ + 40 + ($_sum26_pre_i_i << 2) | 0; + var $F4_0_i_i = $1186; + var $_pre_phi_i20_i = $_pre_i_i; + } else { + var $_sum29_i_i = $1184 + 2 | 0; + var $1194 = __gm_ + 40 + ($_sum29_i_i << 2) | 0; + var $1195 = HEAPU32[$1194 >> 2]; + var $1196 = $1195; + var $1197 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + var $1198 = $1196 >>> 0 < $1197 >>> 0; + if (!$1198) { + var $F4_0_i_i = $1195; + var $_pre_phi_i20_i = $1194; break; + } + _abort(); } - __label__ = 174; - } while (0); - do { - if (__label__ == 174) { - var $785 = _sbrk(0); - var $786 = ($785 | 0) == -1; - if ($786) { - var $tsize_0242932_ph_i = 0; - __label__ = 189; - break; - } - var $788 = HEAP32[(_mparams + 8 | 0) >> 2]; - var $789 = $nb_0 + 47 | 0; - var $790 = $789 + $788 | 0; - var $791 = -$788 | 0; - var $792 = $790 & $791; - var $793 = $785; - var $794 = HEAP32[(_mparams + 4 | 0) >> 2]; - var $795 = $794 - 1 | 0; - var $796 = $795 & $793; - var $797 = ($796 | 0) == 0; - if ($797) { - var $asize_0_i = $792; - } else { - var $799 = $795 + $793 | 0; - var $800 = -$794 | 0; - var $801 = $799 & $800; - var $802 = $792 - $793 | 0; - var $803 = $802 + $801 | 0; - var $asize_0_i = $803; - } - var $asize_0_i; - var $805 = $asize_0_i >>> 0 < 2147483647; - if (!$805) { - var $tsize_0242932_ph_i = 0; - __label__ = 189; - break; - } - var $807 = _sbrk($asize_0_i); - var $808 = ($807 | 0) == ($785 | 0); - var $asize_0__i = $808 ? $asize_0_i : 0; - var $__i = $808 ? $785 : -1; - var $tbase_0_i = $__i; - var $tsize_0_i = $asize_0__i; - var $asize_1_i = $asize_0_i; - var $br_0_i = $807; - __label__ = 181; + } while (0); + var $_pre_phi_i20_i; + var $F4_0_i_i; + HEAP32[$_pre_phi_i20_i >> 2] = $998; + var $1201 = $F4_0_i_i + 12 | 0; + HEAP32[$1201 >> 2] = $998; + var $_sum27_i_i = $_sum_i16_i + 8 | 0; + var $1202 = $tbase_243_i + $_sum27_i_i | 0; + var $1203 = $1202; + HEAP32[$1203 >> 2] = $F4_0_i_i; + var $_sum28_i_i = $_sum_i16_i + 12 | 0; + var $1204 = $tbase_243_i + $_sum28_i_i | 0; + var $1205 = $1204; + HEAP32[$1205 >> 2] = $1186; + } else { + var $1207 = $997; + var $1208 = $qsize_0_i_i >>> 8; + var $1209 = ($1208 | 0) == 0; + do { + if ($1209) { + var $I7_0_i_i = 0; + } else { + var $1211 = $qsize_0_i_i >>> 0 > 16777215; + if ($1211) { + var $I7_0_i_i = 31; break; + } + var $1213 = $1208 + 1048320 | 0; + var $1214 = $1213 >>> 16; + var $1215 = $1214 & 8; + var $1216 = $1208 << $1215; + var $1217 = $1216 + 520192 | 0; + var $1218 = $1217 >>> 16; + var $1219 = $1218 & 4; + var $1220 = $1216 << $1219; + var $1221 = $1220 + 245760 | 0; + var $1222 = $1221 >>> 16; + var $1223 = $1222 & 2; + var $1224 = $1219 | $1215; + var $1225 = $1224 | $1223; + var $1226 = 14 - $1225 | 0; + var $1227 = $1220 << $1223; + var $1228 = $1227 >>> 15; + var $1229 = $1226 + $1228 | 0; + var $1230 = $1229 << 1; + var $1231 = $1229 + 7 | 0; + var $1232 = $qsize_0_i_i >>> ($1231 >>> 0); + var $1233 = $1232 & 1; + var $1234 = $1233 | $1230; + var $I7_0_i_i = $1234; } - } while (0); - $_$253 : do { - if (__label__ == 181) { - var $br_0_i; - var $asize_1_i; - var $tsize_0_i; - var $tbase_0_i; - var $825 = -$asize_1_i | 0; - var $826 = ($tbase_0_i | 0) == -1; - if (!$826) { - var $tsize_242_i = $tsize_0_i; - var $tbase_243_i = $tbase_0_i; - __label__ = 194; - break $_$234; - } - var $828 = ($br_0_i | 0) != -1; - var $829 = $asize_1_i >>> 0 < 2147483647; - var $or_cond_i28 = $828 & $829; + } while (0); + var $I7_0_i_i; + var $1236 = __gm_ + 304 + ($I7_0_i_i << 2) | 0; + var $_sum12_i_i = $_sum_i16_i + 28 | 0; + var $1237 = $tbase_243_i + $_sum12_i_i | 0; + var $1238 = $1237; + HEAP32[$1238 >> 2] = $I7_0_i_i; + var $_sum13_i_i = $_sum_i16_i + 16 | 0; + var $1239 = $tbase_243_i + $_sum13_i_i | 0; + var $_sum14_i_i = $_sum_i16_i + 20 | 0; + var $1240 = $tbase_243_i + $_sum14_i_i | 0; + var $1241 = $1240; + HEAP32[$1241 >> 2] = 0; + var $1242 = $1239; + HEAP32[$1242 >> 2] = 0; + var $1243 = HEAP32[(__gm_ + 4 | 0) >> 2]; + var $1244 = 1 << $I7_0_i_i; + var $1245 = $1243 & $1244; + var $1246 = ($1245 | 0) == 0; + if ($1246) { + var $1248 = $1243 | $1244; + HEAP32[(__gm_ + 4 | 0) >> 2] = $1248; + HEAP32[$1236 >> 2] = $1207; + var $1249 = $1236; + var $_sum15_i_i = $_sum_i16_i + 24 | 0; + var $1250 = $tbase_243_i + $_sum15_i_i | 0; + var $1251 = $1250; + HEAP32[$1251 >> 2] = $1249; + var $_sum16_i_i = $_sum_i16_i + 12 | 0; + var $1252 = $tbase_243_i + $_sum16_i_i | 0; + var $1253 = $1252; + HEAP32[$1253 >> 2] = $1207; + var $_sum17_i_i = $_sum_i16_i + 8 | 0; + var $1254 = $tbase_243_i + $_sum17_i_i | 0; + var $1255 = $1254; + HEAP32[$1255 >> 2] = $1207; + } else { + var $1257 = HEAP32[$1236 >> 2]; + var $1258 = ($I7_0_i_i | 0) == 31; + if ($1258) { + var $1263 = 0; + } else { + var $1260 = $I7_0_i_i >>> 1; + var $1261 = 25 - $1260 | 0; + var $1263 = $1261; + } + var $1263; + var $1264 = $qsize_0_i_i << $1263; + var $K8_0_i_i = $1264; + var $T_0_i21_i = $1257; + while (1) { + var $T_0_i21_i; + var $K8_0_i_i; + var $1266 = $T_0_i21_i + 4 | 0; + var $1267 = HEAP32[$1266 >> 2]; + var $1268 = $1267 & -8; + var $1269 = ($1268 | 0) == ($qsize_0_i_i | 0); + if ($1269) { + var $1289 = $T_0_i21_i + 8 | 0; + var $1290 = HEAPU32[$1289 >> 2]; + var $1291 = $T_0_i21_i; + var $1292 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + var $1293 = $1291 >>> 0 < $1292 >>> 0; do { - if ($or_cond_i28) { - var $831 = $nb_0 + 48 | 0; - var $832 = $asize_1_i >>> 0 < $831 >>> 0; - if (!$832) { - var $asize_2_i = $asize_1_i; - break; - } - var $834 = HEAP32[(_mparams + 8 | 0) >> 2]; - var $835 = $nb_0 + 47 | 0; - var $836 = $835 - $asize_1_i | 0; - var $837 = $836 + $834 | 0; - var $838 = -$834 | 0; - var $839 = $837 & $838; - var $840 = $839 >>> 0 < 2147483647; - if (!$840) { - var $asize_2_i = $asize_1_i; - break; - } - var $842 = _sbrk($839); - var $843 = ($842 | 0) == -1; - if ($843) { - var $847 = _sbrk($825); - var $tsize_0242932_ph_i = $tsize_0_i; - break $_$253; - } - var $845 = $839 + $asize_1_i | 0; - var $asize_2_i = $845; - } else { - var $asize_2_i = $asize_1_i; + if (!$1293) { + var $1295 = $1290; + var $1296 = $1295 >>> 0 < $1292 >>> 0; + if ($1296) { + break; } + var $1298 = $1290 + 12 | 0; + HEAP32[$1298 >> 2] = $1207; + HEAP32[$1289 >> 2] = $1207; + var $_sum20_i_i = $_sum_i16_i + 8 | 0; + var $1299 = $tbase_243_i + $_sum20_i_i | 0; + var $1300 = $1299; + HEAP32[$1300 >> 2] = $1290; + var $_sum21_i_i = $_sum_i16_i + 12 | 0; + var $1301 = $tbase_243_i + $_sum21_i_i | 0; + var $1302 = $1301; + HEAP32[$1302 >> 2] = $T_0_i21_i; + var $_sum22_i_i = $_sum_i16_i + 24 | 0; + var $1303 = $tbase_243_i + $_sum22_i_i | 0; + var $1304 = $1303; + HEAP32[$1304 >> 2] = 0; + break $_$314; + } } while (0); - var $asize_2_i; - var $849 = ($br_0_i | 0) == -1; - if (!$849) { - var $tsize_242_i = $asize_2_i; - var $tbase_243_i = $br_0_i; - __label__ = 194; - break $_$234; + _abort(); + } else { + var $1271 = $K8_0_i_i >>> 31; + var $1272 = $T_0_i21_i + 16 + ($1271 << 2) | 0; + var $1273 = HEAPU32[$1272 >> 2]; + var $1274 = ($1273 | 0) == 0; + var $1275 = $K8_0_i_i << 1; + if (!$1274) { + var $K8_0_i_i = $1275; + var $T_0_i21_i = $1273; + continue; } - var $852 = HEAP32[(__gm_ + 440 | 0) >> 2]; - var $853 = $852 | 4; - HEAP32[(__gm_ + 440 | 0) >> 2] = $853; - var $tsize_137_i = $tsize_0_i; - __label__ = 191; - break $_$234; + var $1277 = $1272; + var $1278 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + var $1279 = $1277 >>> 0 < $1278 >>> 0; + if (!$1279) { + HEAP32[$1272 >> 2] = $1207; + var $_sum23_i_i = $_sum_i16_i + 24 | 0; + var $1281 = $tbase_243_i + $_sum23_i_i | 0; + var $1282 = $1281; + HEAP32[$1282 >> 2] = $T_0_i21_i; + var $_sum24_i_i = $_sum_i16_i + 12 | 0; + var $1283 = $tbase_243_i + $_sum24_i_i | 0; + var $1284 = $1283; + HEAP32[$1284 >> 2] = $1207; + var $_sum25_i_i = $_sum_i16_i + 8 | 0; + var $1285 = $tbase_243_i + $_sum25_i_i | 0; + var $1286 = $1285; + HEAP32[$1286 >> 2] = $1207; + break $_$314; + } + _abort(); + } } - } while (0); - var $tsize_0242932_ph_i; - var $850 = HEAP32[(__gm_ + 440 | 0) >> 2]; - var $851 = $850 | 4; - HEAP32[(__gm_ + 440 | 0) >> 2] = $851; - var $tsize_137_i = $tsize_0242932_ph_i; - __label__ = 191; - break; + } + } + } } - var $tsize_137_i = 0; - __label__ = 191; - } while (0); + } while (0); + var $_sum1819_i_i = $981 | 8; + var $1305 = $tbase_243_i + $_sum1819_i_i | 0; + var $mem_0 = $1305; + break $_$215; + } + } while (0); + var $1306 = $876; + var $sp_0_i_i_i = __gm_ + 444 | 0; + while (1) { + var $sp_0_i_i_i; + var $1308 = $sp_0_i_i_i | 0; + var $1309 = HEAPU32[$1308 >> 2]; + var $1310 = $1309 >>> 0 > $1306 >>> 0; + if (!$1310) { + var $1312 = $sp_0_i_i_i + 4 | 0; + var $1313 = HEAPU32[$1312 >> 2]; + var $1314 = $1309 + $1313 | 0; + var $1315 = $1314 >>> 0 > $1306 >>> 0; + if ($1315) { + var $1321 = $1309; + var $1320 = $1313; + break; + } + } + var $1317 = $sp_0_i_i_i + 8 | 0; + var $1318 = HEAPU32[$1317 >> 2]; + var $1319 = ($1318 | 0) == 0; + if (!$1319) { + var $sp_0_i_i_i = $1318; + continue; + } + var $_pre14_i_i = 4; + var $1321 = 0; + var $1320 = $_pre14_i_i; + break; + } + var $1320; + var $1321; + var $1322 = $1321 + $1320 | 0; + var $_sum1_i10_i = $1320 - 39 | 0; + var $1323 = $1321 + $_sum1_i10_i | 0; + var $1324 = $1323; + var $1325 = $1324 & 7; + var $1326 = ($1325 | 0) == 0; + if ($1326) { + var $1331 = 0; + } else { + var $1328 = -$1324 | 0; + var $1329 = $1328 & 7; + var $1331 = $1329; + } + var $1331; + var $_sum_i11_i = $1320 - 47 | 0; + var $_sum2_i12_i = $_sum_i11_i + $1331 | 0; + var $1332 = $1321 + $_sum2_i12_i | 0; + var $1333 = $876 + 16 | 0; + var $1334 = $1333; + var $1335 = $1332 >>> 0 < $1334 >>> 0; + var $1336 = $1335 ? $1306 : $1332; + var $1337 = $1336 + 8 | 0; + var $1338 = $1337; + var $1339 = $tbase_243_i + 8 | 0; + var $1340 = $1339; + var $1341 = $1340 & 7; + var $1342 = ($1341 | 0) == 0; + if ($1342) { + var $1346 = 0; + } else { + var $1344 = -$1340 | 0; + var $1345 = $1344 & 7; + var $1346 = $1345; + } + var $1346; + var $1347 = $tbase_243_i + $1346 | 0; + var $1348 = $1347; + var $1349 = $tsize_242_i - 40 | 0; + var $1350 = $1349 - $1346 | 0; + HEAP32[(__gm_ + 24 | 0) >> 2] = $1348; + HEAP32[(__gm_ + 12 | 0) >> 2] = $1350; + var $1351 = $1350 | 1; + var $_sum_i_i_i = $1346 + 4 | 0; + var $1352 = $tbase_243_i + $_sum_i_i_i | 0; + var $1353 = $1352; + HEAP32[$1353 >> 2] = $1351; + var $_sum2_i_i_i = $tsize_242_i - 36 | 0; + var $1354 = $tbase_243_i + $_sum2_i_i_i | 0; + var $1355 = $1354; + HEAP32[$1355 >> 2] = 40; + var $1356 = HEAP32[(_mparams + 16 | 0) >> 2]; + HEAP32[(__gm_ + 28 | 0) >> 2] = $1356; + var $1357 = $1336 + 4 | 0; + var $1358 = $1357; + HEAP32[$1358 >> 2] = 27; + HEAP32[$1337 >> 2] = HEAP32[(__gm_ + 444 | 0) >> 2]; + HEAP32[$1337 + 4 >> 2] = HEAP32[(__gm_ + 444 | 0) + 4 >> 2]; + HEAP32[$1337 + 8 >> 2] = HEAP32[(__gm_ + 444 | 0) + 8 >> 2]; + HEAP32[$1337 + 12 >> 2] = HEAP32[(__gm_ + 444 | 0) + 12 >> 2]; + HEAP32[(__gm_ + 444 | 0) >> 2] = $tbase_243_i; + HEAP32[(__gm_ + 448 | 0) >> 2] = $tsize_242_i; + HEAP32[(__gm_ + 456 | 0) >> 2] = 0; + HEAP32[(__gm_ + 452 | 0) >> 2] = $1338; + var $1359 = $1336 + 28 | 0; + var $1360 = $1359; + HEAP32[$1360 >> 2] = 7; + var $1361 = $1336 + 32 | 0; + var $1362 = $1361 >>> 0 < $1322 >>> 0; + $_$426 : do { + if ($1362) { + var $1363 = $1360; + while (1) { + var $1363; + var $1364 = $1363 + 4 | 0; + HEAP32[$1364 >> 2] = 7; + var $1365 = $1363 + 8 | 0; + var $1366 = $1365; + var $1367 = $1366 >>> 0 < $1322 >>> 0; + if (!$1367) { + break $_$426; + } + var $1363 = $1364; + } + } + } while (0); + var $1368 = ($1336 | 0) == ($1306 | 0); + if ($1368) { + break; + } + var $1370 = $1336; + var $1371 = $876; + var $1372 = $1370 - $1371 | 0; + var $1373 = $1306 + $1372 | 0; + var $_sum3_i_i = $1372 + 4 | 0; + var $1374 = $1306 + $_sum3_i_i | 0; + var $1375 = $1374; + var $1376 = HEAP32[$1375 >> 2]; + var $1377 = $1376 & -2; + HEAP32[$1375 >> 2] = $1377; + var $1378 = $1372 | 1; + var $1379 = $876 + 4 | 0; + HEAP32[$1379 >> 2] = $1378; + var $1380 = $1373; + HEAP32[$1380 >> 2] = $1372; + var $1381 = $1372 >>> 0 < 256; + if ($1381) { + var $1383 = $1372 >>> 3; + var $1384 = $1372 >>> 2; + var $1385 = $1384 & 1073741822; + var $1386 = __gm_ + 40 + ($1385 << 2) | 0; + var $1387 = $1386; + var $1388 = HEAPU32[(__gm_ | 0) >> 2]; + var $1389 = 1 << $1383; + var $1390 = $1388 & $1389; + var $1391 = ($1390 | 0) == 0; do { - if (__label__ == 191) { - var $tsize_137_i; - var $854 = HEAP32[(_mparams + 8 | 0) >> 2]; - var $855 = $nb_0 + 47 | 0; - var $856 = $855 + $854 | 0; - var $857 = -$854 | 0; - var $858 = $856 & $857; - var $859 = $858 >>> 0 < 2147483647; - if (!$859) { - __label__ = 330; - break; - } - var $861 = _sbrk($858); - var $862 = _sbrk(0); - var $notlhs_i = ($861 | 0) != -1; - var $notrhs_i = ($862 | 0) != -1; - var $or_cond3_not_i = $notrhs_i & $notlhs_i; - var $863 = $861 >>> 0 < $862 >>> 0; - var $or_cond4_i = $or_cond3_not_i & $863; - if (!$or_cond4_i) { - __label__ = 330; - break; - } - var $864 = $862; - var $865 = $861; - var $866 = $864 - $865 | 0; - var $867 = $nb_0 + 40 | 0; - var $868 = $866 >>> 0 > $867 >>> 0; - var $_tsize_1_i = $868 ? $866 : $tsize_137_i; - var $_tbase_1_i = $868 ? $861 : -1; - var $869 = ($_tbase_1_i | 0) == -1; - if ($869) { - __label__ = 330; - break; - } - var $tsize_242_i = $_tsize_1_i; - var $tbase_243_i = $_tbase_1_i; - __label__ = 194; - break; + if ($1391) { + var $1393 = $1388 | $1389; + HEAP32[(__gm_ | 0) >> 2] = $1393; + var $_sum10_pre_i_i = $1385 + 2 | 0; + var $_pre15_i_i = __gm_ + 40 + ($_sum10_pre_i_i << 2) | 0; + var $F_0_i_i = $1387; + var $_pre_phi_i_i = $_pre15_i_i; + } else { + var $_sum11_i_i = $1385 + 2 | 0; + var $1395 = __gm_ + 40 + ($_sum11_i_i << 2) | 0; + var $1396 = HEAPU32[$1395 >> 2]; + var $1397 = $1396; + var $1398 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + var $1399 = $1397 >>> 0 < $1398 >>> 0; + if (!$1399) { + var $F_0_i_i = $1396; + var $_pre_phi_i_i = $1395; + break; } + _abort(); + } } while (0); + var $_pre_phi_i_i; + var $F_0_i_i; + HEAP32[$_pre_phi_i_i >> 2] = $876; + var $1402 = $F_0_i_i + 12 | 0; + HEAP32[$1402 >> 2] = $876; + var $1403 = $876 + 8 | 0; + HEAP32[$1403 >> 2] = $F_0_i_i; + var $1404 = $876 + 12 | 0; + HEAP32[$1404 >> 2] = $1387; + } else { + var $1406 = $876; + var $1407 = $1372 >>> 8; + var $1408 = ($1407 | 0) == 0; do { - if (__label__ == 194) { - var $tbase_243_i; - var $tsize_242_i; - var $870 = HEAP32[(__gm_ + 432 | 0) >> 2]; - var $871 = $870 + $tsize_242_i | 0; - HEAP32[(__gm_ + 432 | 0) >> 2] = $871; - var $872 = HEAPU32[(__gm_ + 436 | 0) >> 2]; - var $873 = $871 >>> 0 > $872 >>> 0; - if ($873) { - HEAP32[(__gm_ + 436 | 0) >> 2] = $871; - } - var $876 = HEAPU32[(__gm_ + 24 | 0) >> 2]; - var $877 = ($876 | 0) == 0; - $_$275 : do { - if ($877) { - var $879 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - var $880 = ($879 | 0) == 0; - var $881 = $tbase_243_i >>> 0 < $879 >>> 0; - var $or_cond5_i = $880 | $881; - if ($or_cond5_i) { - HEAP32[(__gm_ + 16 | 0) >> 2] = $tbase_243_i; - } - HEAP32[(__gm_ + 444 | 0) >> 2] = $tbase_243_i; - HEAP32[(__gm_ + 448 | 0) >> 2] = $tsize_242_i; - HEAP32[(__gm_ + 456 | 0) >> 2] = 0; - var $884 = HEAP32[(_mparams | 0) >> 2]; - HEAP32[(__gm_ + 36 | 0) >> 2] = $884; - HEAP32[(__gm_ + 32 | 0) >> 2] = -1; - var $i_02_i_i = 0; - while (1) { - var $i_02_i_i; - var $886 = $i_02_i_i << 1; - var $887 = __gm_ + 40 + ($886 << 2) | 0; - var $888 = $887; - var $_sum_i_i = $886 + 3 | 0; - var $889 = __gm_ + 40 + ($_sum_i_i << 2) | 0; - HEAP32[$889 >> 2] = $888; - var $_sum1_i_i = $886 + 2 | 0; - var $890 = __gm_ + 40 + ($_sum1_i_i << 2) | 0; - HEAP32[$890 >> 2] = $888; - var $891 = $i_02_i_i + 1 | 0; - var $exitcond_i_i = ($891 | 0) == 32; - if ($exitcond_i_i) { - break; - } - var $i_02_i_i = $891; - } - var $892 = $tbase_243_i + 8 | 0; - var $893 = $892; - var $894 = $893 & 7; - var $895 = ($894 | 0) == 0; - if ($895) { - var $899 = 0; - } else { - var $897 = -$893 | 0; - var $898 = $897 & 7; - var $899 = $898; - } - var $899; - var $900 = $tbase_243_i + $899 | 0; - var $901 = $900; - var $902 = $tsize_242_i - 40 | 0; - var $903 = $902 - $899 | 0; - HEAP32[(__gm_ + 24 | 0) >> 2] = $901; - HEAP32[(__gm_ + 12 | 0) >> 2] = $903; - var $904 = $903 | 1; - var $_sum_i9_i = $899 + 4 | 0; - var $905 = $tbase_243_i + $_sum_i9_i | 0; - var $906 = $905; - HEAP32[$906 >> 2] = $904; - var $_sum2_i_i = $tsize_242_i - 36 | 0; - var $907 = $tbase_243_i + $_sum2_i_i | 0; - var $908 = $907; - HEAP32[$908 >> 2] = 40; - var $909 = HEAP32[(_mparams + 16 | 0) >> 2]; - HEAP32[(__gm_ + 28 | 0) >> 2] = $909; - } else { - var $sp_0_i = __gm_ + 444 | 0; - while (1) { - var $sp_0_i; - var $910 = ($sp_0_i | 0) == 0; - if ($910) { - break; - } - var $912 = $sp_0_i | 0; - var $913 = HEAPU32[$912 >> 2]; - var $914 = $sp_0_i + 4 | 0; - var $915 = HEAPU32[$914 >> 2]; - var $916 = $913 + $915 | 0; - var $917 = ($tbase_243_i | 0) == ($916 | 0); - if ($917) { - var $921 = $sp_0_i + 12 | 0; - var $922 = HEAP32[$921 >> 2]; - var $923 = $922 & 8; - var $924 = ($923 | 0) == 0; - if (!$924) { - break; - } - var $926 = $876; - var $927 = $926 >>> 0 >= $913 >>> 0; - var $928 = $926 >>> 0 < $tbase_243_i >>> 0; - var $or_cond44_i = $927 & $928; - if (!$or_cond44_i) { - break; - } - var $930 = $915 + $tsize_242_i | 0; - HEAP32[$914 >> 2] = $930; - var $931 = HEAP32[(__gm_ + 24 | 0) >> 2]; - var $932 = HEAP32[(__gm_ + 12 | 0) >> 2]; - var $933 = $932 + $tsize_242_i | 0; - var $934 = $931; - var $935 = $931 + 8 | 0; - var $936 = $935; - var $937 = $936 & 7; - var $938 = ($937 | 0) == 0; - if ($938) { - var $942 = 0; - } else { - var $940 = -$936 | 0; - var $941 = $940 & 7; - var $942 = $941; - } - var $942; - var $943 = $934 + $942 | 0; - var $944 = $943; - var $945 = $933 - $942 | 0; - HEAP32[(__gm_ + 24 | 0) >> 2] = $944; - HEAP32[(__gm_ + 12 | 0) >> 2] = $945; - var $946 = $945 | 1; - var $_sum_i13_i = $942 + 4 | 0; - var $947 = $934 + $_sum_i13_i | 0; - var $948 = $947; - HEAP32[$948 >> 2] = $946; - var $_sum2_i14_i = $933 + 4 | 0; - var $949 = $934 + $_sum2_i14_i | 0; - var $950 = $949; - HEAP32[$950 >> 2] = 40; - var $951 = HEAP32[(_mparams + 16 | 0) >> 2]; - HEAP32[(__gm_ + 28 | 0) >> 2] = $951; - break $_$275; - } - var $919 = $sp_0_i + 8 | 0; - var $920 = HEAP32[$919 >> 2]; - var $sp_0_i = $920; - } - var $952 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - var $953 = $tbase_243_i >>> 0 < $952 >>> 0; - if ($953) { - HEAP32[(__gm_ + 16 | 0) >> 2] = $tbase_243_i; - } - var $955 = $tbase_243_i + $tsize_242_i | 0; - var $sp_1_i = __gm_ + 444 | 0; - while (1) { - var $sp_1_i; - var $957 = ($sp_1_i | 0) == 0; - if ($957) { - __label__ = 293; - break; - } - var $959 = $sp_1_i | 0; - var $960 = HEAP32[$959 >> 2]; - var $961 = ($960 | 0) == ($955 | 0); - if ($961) { - __label__ = 218; - break; - } - var $963 = $sp_1_i + 8 | 0; - var $964 = HEAP32[$963 >> 2]; - var $sp_1_i = $964; - } - do { - if (__label__ == 218) { - var $965 = $sp_1_i + 12 | 0; - var $966 = HEAP32[$965 >> 2]; - var $967 = $966 & 8; - var $968 = ($967 | 0) == 0; - if (!$968) { - break; - } - HEAP32[$959 >> 2] = $tbase_243_i; - var $970 = $sp_1_i + 4 | 0; - var $971 = HEAP32[$970 >> 2]; - var $972 = $971 + $tsize_242_i | 0; - HEAP32[$970 >> 2] = $972; - var $973 = $tbase_243_i + 8 | 0; - var $974 = $973; - var $975 = $974 & 7; - var $976 = ($975 | 0) == 0; - if ($976) { - var $981 = 0; - } else { - var $978 = -$974 | 0; - var $979 = $978 & 7; - var $981 = $979; - } - var $981; - var $982 = $tbase_243_i + $981 | 0; - var $_sum79_i = $tsize_242_i + 8 | 0; - var $983 = $tbase_243_i + $_sum79_i | 0; - var $984 = $983; - var $985 = $984 & 7; - var $986 = ($985 | 0) == 0; - if ($986) { - var $991 = 0; - } else { - var $988 = -$984 | 0; - var $989 = $988 & 7; - var $991 = $989; - } - var $991; - var $_sum80_i = $991 + $tsize_242_i | 0; - var $992 = $tbase_243_i + $_sum80_i | 0; - var $993 = $992; - var $994 = $992; - var $995 = $982; - var $996 = $994 - $995 | 0; - var $_sum_i16_i = $981 + $nb_0 | 0; - var $997 = $tbase_243_i + $_sum_i16_i | 0; - var $998 = $997; - var $999 = $996 - $nb_0 | 0; - var $1000 = $nb_0 | 3; - var $_sum1_i17_i = $981 + 4 | 0; - var $1001 = $tbase_243_i + $_sum1_i17_i | 0; - var $1002 = $1001; - HEAP32[$1002 >> 2] = $1000; - var $1003 = HEAP32[(__gm_ + 24 | 0) >> 2]; - var $1004 = ($993 | 0) == ($1003 | 0); - $_$314 : do { - if ($1004) { - var $1006 = HEAP32[(__gm_ + 12 | 0) >> 2]; - var $1007 = $1006 + $999 | 0; - HEAP32[(__gm_ + 12 | 0) >> 2] = $1007; - HEAP32[(__gm_ + 24 | 0) >> 2] = $998; - var $1008 = $1007 | 1; - var $_sum42_i_i = $_sum_i16_i + 4 | 0; - var $1009 = $tbase_243_i + $_sum42_i_i | 0; - var $1010 = $1009; - HEAP32[$1010 >> 2] = $1008; - } else { - var $1012 = HEAP32[(__gm_ + 20 | 0) >> 2]; - var $1013 = ($993 | 0) == ($1012 | 0); - if ($1013) { - var $1015 = HEAP32[(__gm_ + 8 | 0) >> 2]; - var $1016 = $1015 + $999 | 0; - HEAP32[(__gm_ + 8 | 0) >> 2] = $1016; - HEAP32[(__gm_ + 20 | 0) >> 2] = $998; - var $1017 = $1016 | 1; - var $_sum40_i_i = $_sum_i16_i + 4 | 0; - var $1018 = $tbase_243_i + $_sum40_i_i | 0; - var $1019 = $1018; - HEAP32[$1019 >> 2] = $1017; - var $_sum41_i_i = $1016 + $_sum_i16_i | 0; - var $1020 = $tbase_243_i + $_sum41_i_i | 0; - var $1021 = $1020; - HEAP32[$1021 >> 2] = $1016; - } else { - var $_sum2_i18_i = $tsize_242_i + 4 | 0; - var $_sum81_i = $_sum2_i18_i + $991 | 0; - var $1023 = $tbase_243_i + $_sum81_i | 0; - var $1024 = $1023; - var $1025 = HEAPU32[$1024 >> 2]; - var $1026 = $1025 & 3; - var $1027 = ($1026 | 0) == 1; - if ($1027) { - var $1029 = $1025 & -8; - var $1030 = $1025 >>> 3; - var $1031 = $1025 >>> 0 < 256; - $_$322 : do { - if ($1031) { - var $_sum3738_i_i = $991 | 8; - var $_sum91_i = $_sum3738_i_i + $tsize_242_i | 0; - var $1033 = $tbase_243_i + $_sum91_i | 0; - var $1034 = $1033; - var $1035 = HEAPU32[$1034 >> 2]; - var $_sum39_i_i = $tsize_242_i + 12 | 0; - var $_sum92_i = $_sum39_i_i + $991 | 0; - var $1036 = $tbase_243_i + $_sum92_i | 0; - var $1037 = $1036; - var $1038 = HEAPU32[$1037 >> 2]; - var $1039 = ($1035 | 0) == ($1038 | 0); - if ($1039) { - var $1041 = 1 << $1030; - var $1042 = $1041 ^ -1; - var $1043 = HEAP32[(__gm_ | 0) >> 2]; - var $1044 = $1043 & $1042; - HEAP32[(__gm_ | 0) >> 2] = $1044; - } else { - var $1046 = $1025 >>> 2; - var $1047 = $1046 & 1073741822; - var $1048 = __gm_ + 40 + ($1047 << 2) | 0; - var $1049 = $1048; - var $1050 = ($1035 | 0) == ($1049 | 0); - do { - if ($1050) { - __label__ = 233; - } else { - var $1052 = $1035; - var $1053 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - var $1054 = $1052 >>> 0 < $1053 >>> 0; - if ($1054) { - __label__ = 236; - break; - } - __label__ = 233; - break; - } - } while (0); - do { - if (__label__ == 233) { - var $1056 = ($1038 | 0) == ($1049 | 0); - if (!$1056) { - var $1058 = $1038; - var $1059 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - var $1060 = $1058 >>> 0 < $1059 >>> 0; - if ($1060) { - break; - } - } - var $1061 = $1035 + 12 | 0; - HEAP32[$1061 >> 2] = $1038; - var $1062 = $1038 + 8 | 0; - HEAP32[$1062 >> 2] = $1035; - break $_$322; - } - } while (0); - _abort(); - } - } else { - var $1064 = $992; - var $_sum34_i_i = $991 | 24; - var $_sum82_i = $_sum34_i_i + $tsize_242_i | 0; - var $1065 = $tbase_243_i + $_sum82_i | 0; - var $1066 = $1065; - var $1067 = HEAPU32[$1066 >> 2]; - var $_sum5_i_i = $tsize_242_i + 12 | 0; - var $_sum83_i = $_sum5_i_i + $991 | 0; - var $1068 = $tbase_243_i + $_sum83_i | 0; - var $1069 = $1068; - var $1070 = HEAPU32[$1069 >> 2]; - var $1071 = ($1070 | 0) == ($1064 | 0); - do { - if ($1071) { - var $_sum67_i_i = $991 | 16; - var $_sum89_i = $_sum2_i18_i + $_sum67_i_i | 0; - var $1084 = $tbase_243_i + $_sum89_i | 0; - var $1085 = $1084; - var $1086 = HEAP32[$1085 >> 2]; - var $1087 = ($1086 | 0) == 0; - if ($1087) { - var $_sum90_i = $_sum67_i_i + $tsize_242_i | 0; - var $1089 = $tbase_243_i + $_sum90_i | 0; - var $1090 = $1089; - var $1091 = HEAP32[$1090 >> 2]; - var $1092 = ($1091 | 0) == 0; - if ($1092) { - var $R_1_i_i = 0; - break; - } - var $RP_0_i_i = $1090; - var $R_0_i_i = $1091; - } else { - var $RP_0_i_i = $1085; - var $R_0_i_i = $1086; - __label__ = 243; - } - while (1) { - var $R_0_i_i; - var $RP_0_i_i; - var $1093 = $R_0_i_i + 20 | 0; - var $1094 = HEAP32[$1093 >> 2]; - var $1095 = ($1094 | 0) == 0; - if (!$1095) { - var $RP_0_i_i = $1093; - var $R_0_i_i = $1094; - continue; - } - var $1097 = $R_0_i_i + 16 | 0; - var $1098 = HEAPU32[$1097 >> 2]; - var $1099 = ($1098 | 0) == 0; - if ($1099) { - break; - } - var $RP_0_i_i = $1097; - var $R_0_i_i = $1098; - } - var $1101 = $RP_0_i_i; - var $1102 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - var $1103 = $1101 >>> 0 < $1102 >>> 0; - if ($1103) { - _abort(); - } else { - HEAP32[$RP_0_i_i >> 2] = 0; - var $R_1_i_i = $R_0_i_i; - } - } else { - var $_sum3536_i_i = $991 | 8; - var $_sum84_i = $_sum3536_i_i + $tsize_242_i | 0; - var $1073 = $tbase_243_i + $_sum84_i | 0; - var $1074 = $1073; - var $1075 = HEAPU32[$1074 >> 2]; - var $1076 = $1075; - var $1077 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - var $1078 = $1076 >>> 0 < $1077 >>> 0; - if ($1078) { - _abort(); - } else { - var $1080 = $1075 + 12 | 0; - HEAP32[$1080 >> 2] = $1070; - var $1081 = $1070 + 8 | 0; - HEAP32[$1081 >> 2] = $1075; - var $R_1_i_i = $1070; - } - } - } while (0); - var $R_1_i_i; - var $1107 = ($1067 | 0) == 0; - if ($1107) { - break; - } - var $_sum30_i_i = $tsize_242_i + 28 | 0; - var $_sum85_i = $_sum30_i_i + $991 | 0; - var $1109 = $tbase_243_i + $_sum85_i | 0; - var $1110 = $1109; - var $1111 = HEAP32[$1110 >> 2]; - var $1112 = __gm_ + 304 + ($1111 << 2) | 0; - var $1113 = HEAP32[$1112 >> 2]; - var $1114 = ($1064 | 0) == ($1113 | 0); - do { - if ($1114) { - HEAP32[$1112 >> 2] = $R_1_i_i; - var $cond_i_i = ($R_1_i_i | 0) == 0; - if (!$cond_i_i) { - break; - } - var $1116 = HEAP32[$1110 >> 2]; - var $1117 = 1 << $1116; - var $1118 = $1117 ^ -1; - var $1119 = HEAP32[(__gm_ + 4 | 0) >> 2]; - var $1120 = $1119 & $1118; - HEAP32[(__gm_ + 4 | 0) >> 2] = $1120; - break $_$322; - } - var $1122 = $1067; - var $1123 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - var $1124 = $1122 >>> 0 < $1123 >>> 0; - if ($1124) { - _abort(); - } else { - var $1126 = $1067 + 16 | 0; - var $1127 = HEAP32[$1126 >> 2]; - var $1128 = ($1127 | 0) == ($1064 | 0); - if ($1128) { - HEAP32[$1126 >> 2] = $R_1_i_i; - } else { - var $1131 = $1067 + 20 | 0; - HEAP32[$1131 >> 2] = $R_1_i_i; - } - var $1134 = ($R_1_i_i | 0) == 0; - if ($1134) { - break $_$322; - } - } - } while (0); - var $1136 = $R_1_i_i; - var $1137 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - var $1138 = $1136 >>> 0 < $1137 >>> 0; - if ($1138) { - _abort(); - } else { - var $1140 = $R_1_i_i + 24 | 0; - HEAP32[$1140 >> 2] = $1067; - var $_sum3132_i_i = $991 | 16; - var $_sum86_i = $_sum3132_i_i + $tsize_242_i | 0; - var $1141 = $tbase_243_i + $_sum86_i | 0; - var $1142 = $1141; - var $1143 = HEAPU32[$1142 >> 2]; - var $1144 = ($1143 | 0) == 0; - if (!$1144) { - var $1146 = $1143; - var $1147 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - var $1148 = $1146 >>> 0 < $1147 >>> 0; - if ($1148) { - _abort(); - } else { - var $1150 = $R_1_i_i + 16 | 0; - HEAP32[$1150 >> 2] = $1143; - var $1151 = $1143 + 24 | 0; - HEAP32[$1151 >> 2] = $R_1_i_i; - } - } - var $_sum87_i = $_sum2_i18_i + $_sum3132_i_i | 0; - var $1154 = $tbase_243_i + $_sum87_i | 0; - var $1155 = $1154; - var $1156 = HEAPU32[$1155 >> 2]; - var $1157 = ($1156 | 0) == 0; - if ($1157) { - break; - } - var $1159 = $1156; - var $1160 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - var $1161 = $1159 >>> 0 < $1160 >>> 0; - if ($1161) { - _abort(); - } else { - var $1163 = $R_1_i_i + 20 | 0; - HEAP32[$1163 >> 2] = $1156; - var $1164 = $1156 + 24 | 0; - HEAP32[$1164 >> 2] = $R_1_i_i; - } - } - } - } while (0); - var $_sum9_i_i = $1029 | $991; - var $_sum88_i = $_sum9_i_i + $tsize_242_i | 0; - var $1168 = $tbase_243_i + $_sum88_i | 0; - var $1169 = $1168; - var $1170 = $1029 + $999 | 0; - var $oldfirst_0_i_i = $1169; - var $qsize_0_i_i = $1170; - } else { - var $oldfirst_0_i_i = $993; - var $qsize_0_i_i = $999; - } - var $qsize_0_i_i; - var $oldfirst_0_i_i; - var $1172 = $oldfirst_0_i_i + 4 | 0; - var $1173 = HEAP32[$1172 >> 2]; - var $1174 = $1173 & -2; - HEAP32[$1172 >> 2] = $1174; - var $1175 = $qsize_0_i_i | 1; - var $_sum10_i_i = $_sum_i16_i + 4 | 0; - var $1176 = $tbase_243_i + $_sum10_i_i | 0; - var $1177 = $1176; - HEAP32[$1177 >> 2] = $1175; - var $_sum11_i19_i = $qsize_0_i_i + $_sum_i16_i | 0; - var $1178 = $tbase_243_i + $_sum11_i19_i | 0; - var $1179 = $1178; - HEAP32[$1179 >> 2] = $qsize_0_i_i; - var $1180 = $qsize_0_i_i >>> 0 < 256; - if ($1180) { - var $1182 = $qsize_0_i_i >>> 3; - var $1183 = $qsize_0_i_i >>> 2; - var $1184 = $1183 & 1073741822; - var $1185 = __gm_ + 40 + ($1184 << 2) | 0; - var $1186 = $1185; - var $1187 = HEAPU32[(__gm_ | 0) >> 2]; - var $1188 = 1 << $1182; - var $1189 = $1187 & $1188; - var $1190 = ($1189 | 0) == 0; - do { - if ($1190) { - var $1192 = $1187 | $1188; - HEAP32[(__gm_ | 0) >> 2] = $1192; - var $_sum26_pre_i_i = $1184 + 2 | 0; - var $_pre_i_i = __gm_ + 40 + ($_sum26_pre_i_i << 2) | 0; - var $F4_0_i_i = $1186; - var $_pre_phi_i20_i = $_pre_i_i; - } else { - var $_sum29_i_i = $1184 + 2 | 0; - var $1194 = __gm_ + 40 + ($_sum29_i_i << 2) | 0; - var $1195 = HEAPU32[$1194 >> 2]; - var $1196 = $1195; - var $1197 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - var $1198 = $1196 >>> 0 < $1197 >>> 0; - if (!$1198) { - var $F4_0_i_i = $1195; - var $_pre_phi_i20_i = $1194; - break; - } - _abort(); - } - } while (0); - var $_pre_phi_i20_i; - var $F4_0_i_i; - HEAP32[$_pre_phi_i20_i >> 2] = $998; - var $1201 = $F4_0_i_i + 12 | 0; - HEAP32[$1201 >> 2] = $998; - var $_sum27_i_i = $_sum_i16_i + 8 | 0; - var $1202 = $tbase_243_i + $_sum27_i_i | 0; - var $1203 = $1202; - HEAP32[$1203 >> 2] = $F4_0_i_i; - var $_sum28_i_i = $_sum_i16_i + 12 | 0; - var $1204 = $tbase_243_i + $_sum28_i_i | 0; - var $1205 = $1204; - HEAP32[$1205 >> 2] = $1186; - } else { - var $1207 = $997; - var $1208 = $qsize_0_i_i >>> 8; - var $1209 = ($1208 | 0) == 0; - do { - if ($1209) { - var $I7_0_i_i = 0; - } else { - var $1211 = $qsize_0_i_i >>> 0 > 16777215; - if ($1211) { - var $I7_0_i_i = 31; - break; - } - var $1213 = $1208 + 1048320 | 0; - var $1214 = $1213 >>> 16; - var $1215 = $1214 & 8; - var $1216 = $1208 << $1215; - var $1217 = $1216 + 520192 | 0; - var $1218 = $1217 >>> 16; - var $1219 = $1218 & 4; - var $1220 = $1216 << $1219; - var $1221 = $1220 + 245760 | 0; - var $1222 = $1221 >>> 16; - var $1223 = $1222 & 2; - var $1224 = $1219 | $1215; - var $1225 = $1224 | $1223; - var $1226 = 14 - $1225 | 0; - var $1227 = $1220 << $1223; - var $1228 = $1227 >>> 15; - var $1229 = $1226 + $1228 | 0; - var $1230 = $1229 << 1; - var $1231 = $1229 + 7 | 0; - var $1232 = $qsize_0_i_i >>> ($1231 >>> 0); - var $1233 = $1232 & 1; - var $1234 = $1233 | $1230; - var $I7_0_i_i = $1234; - } - } while (0); - var $I7_0_i_i; - var $1236 = __gm_ + 304 + ($I7_0_i_i << 2) | 0; - var $_sum12_i_i = $_sum_i16_i + 28 | 0; - var $1237 = $tbase_243_i + $_sum12_i_i | 0; - var $1238 = $1237; - HEAP32[$1238 >> 2] = $I7_0_i_i; - var $_sum13_i_i = $_sum_i16_i + 16 | 0; - var $1239 = $tbase_243_i + $_sum13_i_i | 0; - var $_sum14_i_i = $_sum_i16_i + 20 | 0; - var $1240 = $tbase_243_i + $_sum14_i_i | 0; - var $1241 = $1240; - HEAP32[$1241 >> 2] = 0; - var $1242 = $1239; - HEAP32[$1242 >> 2] = 0; - var $1243 = HEAP32[(__gm_ + 4 | 0) >> 2]; - var $1244 = 1 << $I7_0_i_i; - var $1245 = $1243 & $1244; - var $1246 = ($1245 | 0) == 0; - if ($1246) { - var $1248 = $1243 | $1244; - HEAP32[(__gm_ + 4 | 0) >> 2] = $1248; - HEAP32[$1236 >> 2] = $1207; - var $1249 = $1236; - var $_sum15_i_i = $_sum_i16_i + 24 | 0; - var $1250 = $tbase_243_i + $_sum15_i_i | 0; - var $1251 = $1250; - HEAP32[$1251 >> 2] = $1249; - var $_sum16_i_i = $_sum_i16_i + 12 | 0; - var $1252 = $tbase_243_i + $_sum16_i_i | 0; - var $1253 = $1252; - HEAP32[$1253 >> 2] = $1207; - var $_sum17_i_i = $_sum_i16_i + 8 | 0; - var $1254 = $tbase_243_i + $_sum17_i_i | 0; - var $1255 = $1254; - HEAP32[$1255 >> 2] = $1207; - } else { - var $1257 = HEAP32[$1236 >> 2]; - var $1258 = ($I7_0_i_i | 0) == 31; - if ($1258) { - var $1263 = 0; - } else { - var $1260 = $I7_0_i_i >>> 1; - var $1261 = 25 - $1260 | 0; - var $1263 = $1261; - } - var $1263; - var $1264 = $qsize_0_i_i << $1263; - var $K8_0_i_i = $1264; - var $T_0_i21_i = $1257; - while (1) { - var $T_0_i21_i; - var $K8_0_i_i; - var $1266 = $T_0_i21_i + 4 | 0; - var $1267 = HEAP32[$1266 >> 2]; - var $1268 = $1267 & -8; - var $1269 = ($1268 | 0) == ($qsize_0_i_i | 0); - if ($1269) { - var $1289 = $T_0_i21_i + 8 | 0; - var $1290 = HEAPU32[$1289 >> 2]; - var $1291 = $T_0_i21_i; - var $1292 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - var $1293 = $1291 >>> 0 < $1292 >>> 0; - do { - if (!$1293) { - var $1295 = $1290; - var $1296 = $1295 >>> 0 < $1292 >>> 0; - if ($1296) { - break; - } - var $1298 = $1290 + 12 | 0; - HEAP32[$1298 >> 2] = $1207; - HEAP32[$1289 >> 2] = $1207; - var $_sum20_i_i = $_sum_i16_i + 8 | 0; - var $1299 = $tbase_243_i + $_sum20_i_i | 0; - var $1300 = $1299; - HEAP32[$1300 >> 2] = $1290; - var $_sum21_i_i = $_sum_i16_i + 12 | 0; - var $1301 = $tbase_243_i + $_sum21_i_i | 0; - var $1302 = $1301; - HEAP32[$1302 >> 2] = $T_0_i21_i; - var $_sum22_i_i = $_sum_i16_i + 24 | 0; - var $1303 = $tbase_243_i + $_sum22_i_i | 0; - var $1304 = $1303; - HEAP32[$1304 >> 2] = 0; - break $_$314; - } - } while (0); - _abort(); - } else { - var $1271 = $K8_0_i_i >>> 31; - var $1272 = $T_0_i21_i + 16 + ($1271 << 2) | 0; - var $1273 = HEAPU32[$1272 >> 2]; - var $1274 = ($1273 | 0) == 0; - var $1275 = $K8_0_i_i << 1; - if (!$1274) { - var $K8_0_i_i = $1275; - var $T_0_i21_i = $1273; - continue; - } - var $1277 = $1272; - var $1278 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - var $1279 = $1277 >>> 0 < $1278 >>> 0; - if (!$1279) { - HEAP32[$1272 >> 2] = $1207; - var $_sum23_i_i = $_sum_i16_i + 24 | 0; - var $1281 = $tbase_243_i + $_sum23_i_i | 0; - var $1282 = $1281; - HEAP32[$1282 >> 2] = $T_0_i21_i; - var $_sum24_i_i = $_sum_i16_i + 12 | 0; - var $1283 = $tbase_243_i + $_sum24_i_i | 0; - var $1284 = $1283; - HEAP32[$1284 >> 2] = $1207; - var $_sum25_i_i = $_sum_i16_i + 8 | 0; - var $1285 = $tbase_243_i + $_sum25_i_i | 0; - var $1286 = $1285; - HEAP32[$1286 >> 2] = $1207; - break $_$314; - } - _abort(); - } - } - } - } - } - } - } while (0); - var $_sum1819_i_i = $981 | 8; - var $1305 = $tbase_243_i + $_sum1819_i_i | 0; - var $mem_0 = $1305; - break $_$215; - } - } while (0); - var $1306 = $876; - var $sp_0_i_i_i = __gm_ + 444 | 0; - while (1) { - var $sp_0_i_i_i; - var $1308 = $sp_0_i_i_i | 0; - var $1309 = HEAPU32[$1308 >> 2]; - var $1310 = $1309 >>> 0 > $1306 >>> 0; - if (!$1310) { - var $1312 = $sp_0_i_i_i + 4 | 0; - var $1313 = HEAPU32[$1312 >> 2]; - var $1314 = $1309 + $1313 | 0; - var $1315 = $1314 >>> 0 > $1306 >>> 0; - if ($1315) { - var $1321 = $1309; - var $1320 = $1313; - break; - } - } - var $1317 = $sp_0_i_i_i + 8 | 0; - var $1318 = HEAPU32[$1317 >> 2]; - var $1319 = ($1318 | 0) == 0; - if (!$1319) { - var $sp_0_i_i_i = $1318; - continue; - } - var $_pre14_i_i = 4; - var $1321 = 0; - var $1320 = $_pre14_i_i; - break; - } - var $1320; - var $1321; - var $1322 = $1321 + $1320 | 0; - var $_sum1_i10_i = $1320 - 39 | 0; - var $1323 = $1321 + $_sum1_i10_i | 0; - var $1324 = $1323; - var $1325 = $1324 & 7; - var $1326 = ($1325 | 0) == 0; - if ($1326) { - var $1331 = 0; - } else { - var $1328 = -$1324 | 0; - var $1329 = $1328 & 7; - var $1331 = $1329; - } - var $1331; - var $_sum_i11_i = $1320 - 47 | 0; - var $_sum2_i12_i = $_sum_i11_i + $1331 | 0; - var $1332 = $1321 + $_sum2_i12_i | 0; - var $1333 = $876 + 16 | 0; - var $1334 = $1333; - var $1335 = $1332 >>> 0 < $1334 >>> 0; - var $1336 = $1335 ? $1306 : $1332; - var $1337 = $1336 + 8 | 0; - var $1338 = $1337; - var $1339 = $tbase_243_i + 8 | 0; - var $1340 = $1339; - var $1341 = $1340 & 7; - var $1342 = ($1341 | 0) == 0; - if ($1342) { - var $1346 = 0; - } else { - var $1344 = -$1340 | 0; - var $1345 = $1344 & 7; - var $1346 = $1345; - } - var $1346; - var $1347 = $tbase_243_i + $1346 | 0; - var $1348 = $1347; - var $1349 = $tsize_242_i - 40 | 0; - var $1350 = $1349 - $1346 | 0; - HEAP32[(__gm_ + 24 | 0) >> 2] = $1348; - HEAP32[(__gm_ + 12 | 0) >> 2] = $1350; - var $1351 = $1350 | 1; - var $_sum_i_i_i = $1346 + 4 | 0; - var $1352 = $tbase_243_i + $_sum_i_i_i | 0; - var $1353 = $1352; - HEAP32[$1353 >> 2] = $1351; - var $_sum2_i_i_i = $tsize_242_i - 36 | 0; - var $1354 = $tbase_243_i + $_sum2_i_i_i | 0; - var $1355 = $1354; - HEAP32[$1355 >> 2] = 40; - var $1356 = HEAP32[(_mparams + 16 | 0) >> 2]; - HEAP32[(__gm_ + 28 | 0) >> 2] = $1356; - var $1357 = $1336 + 4 | 0; - var $1358 = $1357; - HEAP32[$1358 >> 2] = 27; - HEAP32[$1337 >> 2] = HEAP32[(__gm_ + 444 | 0) >> 2]; - HEAP32[$1337 + 4 >> 2] = HEAP32[(__gm_ + 444 | 0) + 4 >> 2]; - HEAP32[$1337 + 8 >> 2] = HEAP32[(__gm_ + 444 | 0) + 8 >> 2]; - HEAP32[$1337 + 12 >> 2] = HEAP32[(__gm_ + 444 | 0) + 12 >> 2]; - HEAP32[(__gm_ + 444 | 0) >> 2] = $tbase_243_i; - HEAP32[(__gm_ + 448 | 0) >> 2] = $tsize_242_i; - HEAP32[(__gm_ + 456 | 0) >> 2] = 0; - HEAP32[(__gm_ + 452 | 0) >> 2] = $1338; - var $1359 = $1336 + 28 | 0; - var $1360 = $1359; - HEAP32[$1360 >> 2] = 7; - var $1361 = $1336 + 32 | 0; - var $1362 = $1361 >>> 0 < $1322 >>> 0; - $_$426 : do { - if ($1362) { - var $1363 = $1360; - while (1) { - var $1363; - var $1364 = $1363 + 4 | 0; - HEAP32[$1364 >> 2] = 7; - var $1365 = $1363 + 8 | 0; - var $1366 = $1365; - var $1367 = $1366 >>> 0 < $1322 >>> 0; - if (!$1367) { - break $_$426; - } - var $1363 = $1364; - } - } - } while (0); - var $1368 = ($1336 | 0) == ($1306 | 0); - if ($1368) { - break; - } - var $1370 = $1336; - var $1371 = $876; - var $1372 = $1370 - $1371 | 0; - var $1373 = $1306 + $1372 | 0; - var $_sum3_i_i = $1372 + 4 | 0; - var $1374 = $1306 + $_sum3_i_i | 0; - var $1375 = $1374; - var $1376 = HEAP32[$1375 >> 2]; - var $1377 = $1376 & -2; - HEAP32[$1375 >> 2] = $1377; - var $1378 = $1372 | 1; - var $1379 = $876 + 4 | 0; - HEAP32[$1379 >> 2] = $1378; - var $1380 = $1373; - HEAP32[$1380 >> 2] = $1372; - var $1381 = $1372 >>> 0 < 256; - if ($1381) { - var $1383 = $1372 >>> 3; - var $1384 = $1372 >>> 2; - var $1385 = $1384 & 1073741822; - var $1386 = __gm_ + 40 + ($1385 << 2) | 0; - var $1387 = $1386; - var $1388 = HEAPU32[(__gm_ | 0) >> 2]; - var $1389 = 1 << $1383; - var $1390 = $1388 & $1389; - var $1391 = ($1390 | 0) == 0; - do { - if ($1391) { - var $1393 = $1388 | $1389; - HEAP32[(__gm_ | 0) >> 2] = $1393; - var $_sum10_pre_i_i = $1385 + 2 | 0; - var $_pre15_i_i = __gm_ + 40 + ($_sum10_pre_i_i << 2) | 0; - var $F_0_i_i = $1387; - var $_pre_phi_i_i = $_pre15_i_i; - } else { - var $_sum11_i_i = $1385 + 2 | 0; - var $1395 = __gm_ + 40 + ($_sum11_i_i << 2) | 0; - var $1396 = HEAPU32[$1395 >> 2]; - var $1397 = $1396; - var $1398 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - var $1399 = $1397 >>> 0 < $1398 >>> 0; - if (!$1399) { - var $F_0_i_i = $1396; - var $_pre_phi_i_i = $1395; - break; - } - _abort(); - } - } while (0); - var $_pre_phi_i_i; - var $F_0_i_i; - HEAP32[$_pre_phi_i_i >> 2] = $876; - var $1402 = $F_0_i_i + 12 | 0; - HEAP32[$1402 >> 2] = $876; - var $1403 = $876 + 8 | 0; - HEAP32[$1403 >> 2] = $F_0_i_i; - var $1404 = $876 + 12 | 0; - HEAP32[$1404 >> 2] = $1387; - } else { - var $1406 = $876; - var $1407 = $1372 >>> 8; - var $1408 = ($1407 | 0) == 0; - do { - if ($1408) { - var $I1_0_i_i = 0; - } else { - var $1410 = $1372 >>> 0 > 16777215; - if ($1410) { - var $I1_0_i_i = 31; - break; - } - var $1412 = $1407 + 1048320 | 0; - var $1413 = $1412 >>> 16; - var $1414 = $1413 & 8; - var $1415 = $1407 << $1414; - var $1416 = $1415 + 520192 | 0; - var $1417 = $1416 >>> 16; - var $1418 = $1417 & 4; - var $1419 = $1415 << $1418; - var $1420 = $1419 + 245760 | 0; - var $1421 = $1420 >>> 16; - var $1422 = $1421 & 2; - var $1423 = $1418 | $1414; - var $1424 = $1423 | $1422; - var $1425 = 14 - $1424 | 0; - var $1426 = $1419 << $1422; - var $1427 = $1426 >>> 15; - var $1428 = $1425 + $1427 | 0; - var $1429 = $1428 << 1; - var $1430 = $1428 + 7 | 0; - var $1431 = $1372 >>> ($1430 >>> 0); - var $1432 = $1431 & 1; - var $1433 = $1432 | $1429; - var $I1_0_i_i = $1433; - } - } while (0); - var $I1_0_i_i; - var $1435 = __gm_ + 304 + ($I1_0_i_i << 2) | 0; - var $1436 = $876 + 28 | 0; - var $I1_0_c_i_i = $I1_0_i_i; - HEAP32[$1436 >> 2] = $I1_0_c_i_i; - var $1437 = $876 + 20 | 0; - HEAP32[$1437 >> 2] = 0; - var $1438 = $876 + 16 | 0; - HEAP32[$1438 >> 2] = 0; - var $1439 = HEAP32[(__gm_ + 4 | 0) >> 2]; - var $1440 = 1 << $I1_0_i_i; - var $1441 = $1439 & $1440; - var $1442 = ($1441 | 0) == 0; - if ($1442) { - var $1444 = $1439 | $1440; - HEAP32[(__gm_ + 4 | 0) >> 2] = $1444; - HEAP32[$1435 >> 2] = $1406; - var $1445 = $876 + 24 | 0; - var $_c_i_i = $1435; - HEAP32[$1445 >> 2] = $_c_i_i; - var $1446 = $876 + 12 | 0; - HEAP32[$1446 >> 2] = $876; - var $1447 = $876 + 8 | 0; - HEAP32[$1447 >> 2] = $876; - } else { - var $1449 = HEAP32[$1435 >> 2]; - var $1450 = ($I1_0_i_i | 0) == 31; - if ($1450) { - var $1455 = 0; - } else { - var $1452 = $I1_0_i_i >>> 1; - var $1453 = 25 - $1452 | 0; - var $1455 = $1453; - } - var $1455; - var $1456 = $1372 << $1455; - var $K2_0_i_i = $1456; - var $T_0_i_i = $1449; - while (1) { - var $T_0_i_i; - var $K2_0_i_i; - var $1458 = $T_0_i_i + 4 | 0; - var $1459 = HEAP32[$1458 >> 2]; - var $1460 = $1459 & -8; - var $1461 = ($1460 | 0) == ($1372 | 0); - if ($1461) { - var $1478 = $T_0_i_i + 8 | 0; - var $1479 = HEAPU32[$1478 >> 2]; - var $1480 = $T_0_i_i; - var $1481 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - var $1482 = $1480 >>> 0 < $1481 >>> 0; - do { - if (!$1482) { - var $1484 = $1479; - var $1485 = $1484 >>> 0 < $1481 >>> 0; - if ($1485) { - break; - } - var $1487 = $1479 + 12 | 0; - HEAP32[$1487 >> 2] = $1406; - HEAP32[$1478 >> 2] = $1406; - var $1488 = $876 + 8 | 0; - var $_c6_i_i = $1479; - HEAP32[$1488 >> 2] = $_c6_i_i; - var $1489 = $876 + 12 | 0; - var $T_0_c_i_i = $T_0_i_i; - HEAP32[$1489 >> 2] = $T_0_c_i_i; - var $1490 = $876 + 24 | 0; - HEAP32[$1490 >> 2] = 0; - break $_$275; - } - } while (0); - _abort(); - } else { - var $1463 = $K2_0_i_i >>> 31; - var $1464 = $T_0_i_i + 16 + ($1463 << 2) | 0; - var $1465 = HEAPU32[$1464 >> 2]; - var $1466 = ($1465 | 0) == 0; - var $1467 = $K2_0_i_i << 1; - if (!$1466) { - var $K2_0_i_i = $1467; - var $T_0_i_i = $1465; - continue; - } - var $1469 = $1464; - var $1470 = HEAPU32[(__gm_ + 16 | 0) >> 2]; - var $1471 = $1469 >>> 0 < $1470 >>> 0; - if (!$1471) { - HEAP32[$1464 >> 2] = $1406; - var $1473 = $876 + 24 | 0; - var $T_0_c7_i_i = $T_0_i_i; - HEAP32[$1473 >> 2] = $T_0_c7_i_i; - var $1474 = $876 + 12 | 0; - HEAP32[$1474 >> 2] = $876; - var $1475 = $876 + 8 | 0; - HEAP32[$1475 >> 2] = $876; - break $_$275; - } - _abort(); - } - } - } - } - } - } while (0); - var $1491 = HEAPU32[(__gm_ + 12 | 0) >> 2]; - var $1492 = $1491 >>> 0 > $nb_0 >>> 0; - if (!$1492) { + if ($1408) { + var $I1_0_i_i = 0; + } else { + var $1410 = $1372 >>> 0 > 16777215; + if ($1410) { + var $I1_0_i_i = 31; + break; + } + var $1412 = $1407 + 1048320 | 0; + var $1413 = $1412 >>> 16; + var $1414 = $1413 & 8; + var $1415 = $1407 << $1414; + var $1416 = $1415 + 520192 | 0; + var $1417 = $1416 >>> 16; + var $1418 = $1417 & 4; + var $1419 = $1415 << $1418; + var $1420 = $1419 + 245760 | 0; + var $1421 = $1420 >>> 16; + var $1422 = $1421 & 2; + var $1423 = $1418 | $1414; + var $1424 = $1423 | $1422; + var $1425 = 14 - $1424 | 0; + var $1426 = $1419 << $1422; + var $1427 = $1426 >>> 15; + var $1428 = $1425 + $1427 | 0; + var $1429 = $1428 << 1; + var $1430 = $1428 + 7 | 0; + var $1431 = $1372 >>> ($1430 >>> 0); + var $1432 = $1431 & 1; + var $1433 = $1432 | $1429; + var $I1_0_i_i = $1433; + } + } while (0); + var $I1_0_i_i; + var $1435 = __gm_ + 304 + ($I1_0_i_i << 2) | 0; + var $1436 = $876 + 28 | 0; + var $I1_0_c_i_i = $I1_0_i_i; + HEAP32[$1436 >> 2] = $I1_0_c_i_i; + var $1437 = $876 + 20 | 0; + HEAP32[$1437 >> 2] = 0; + var $1438 = $876 + 16 | 0; + HEAP32[$1438 >> 2] = 0; + var $1439 = HEAP32[(__gm_ + 4 | 0) >> 2]; + var $1440 = 1 << $I1_0_i_i; + var $1441 = $1439 & $1440; + var $1442 = ($1441 | 0) == 0; + if ($1442) { + var $1444 = $1439 | $1440; + HEAP32[(__gm_ + 4 | 0) >> 2] = $1444; + HEAP32[$1435 >> 2] = $1406; + var $1445 = $876 + 24 | 0; + var $_c_i_i = $1435; + HEAP32[$1445 >> 2] = $_c_i_i; + var $1446 = $876 + 12 | 0; + HEAP32[$1446 >> 2] = $876; + var $1447 = $876 + 8 | 0; + HEAP32[$1447 >> 2] = $876; + } else { + var $1449 = HEAP32[$1435 >> 2]; + var $1450 = ($I1_0_i_i | 0) == 31; + if ($1450) { + var $1455 = 0; + } else { + var $1452 = $I1_0_i_i >>> 1; + var $1453 = 25 - $1452 | 0; + var $1455 = $1453; + } + var $1455; + var $1456 = $1372 << $1455; + var $K2_0_i_i = $1456; + var $T_0_i_i = $1449; + while (1) { + var $T_0_i_i; + var $K2_0_i_i; + var $1458 = $T_0_i_i + 4 | 0; + var $1459 = HEAP32[$1458 >> 2]; + var $1460 = $1459 & -8; + var $1461 = ($1460 | 0) == ($1372 | 0); + if ($1461) { + var $1478 = $T_0_i_i + 8 | 0; + var $1479 = HEAPU32[$1478 >> 2]; + var $1480 = $T_0_i_i; + var $1481 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + var $1482 = $1480 >>> 0 < $1481 >>> 0; + do { + if (!$1482) { + var $1484 = $1479; + var $1485 = $1484 >>> 0 < $1481 >>> 0; + if ($1485) { break; + } + var $1487 = $1479 + 12 | 0; + HEAP32[$1487 >> 2] = $1406; + HEAP32[$1478 >> 2] = $1406; + var $1488 = $876 + 8 | 0; + var $_c6_i_i = $1479; + HEAP32[$1488 >> 2] = $_c6_i_i; + var $1489 = $876 + 12 | 0; + var $T_0_c_i_i = $T_0_i_i; + HEAP32[$1489 >> 2] = $T_0_c_i_i; + var $1490 = $876 + 24 | 0; + HEAP32[$1490 >> 2] = 0; + break $_$275; } - var $1494 = $1491 - $nb_0 | 0; - HEAP32[(__gm_ + 12 | 0) >> 2] = $1494; - var $1495 = HEAPU32[(__gm_ + 24 | 0) >> 2]; - var $1496 = $1495; - var $1497 = $1496 + $nb_0 | 0; - var $1498 = $1497; - HEAP32[(__gm_ + 24 | 0) >> 2] = $1498; - var $1499 = $1494 | 1; - var $_sum_i30 = $nb_0 + 4 | 0; - var $1500 = $1496 + $_sum_i30 | 0; - var $1501 = $1500; - HEAP32[$1501 >> 2] = $1499; - var $1502 = $nb_0 | 3; - var $1503 = $1495 + 4 | 0; - HEAP32[$1503 >> 2] = $1502; - var $1504 = $1495 + 8 | 0; - var $1505 = $1504; - var $mem_0 = $1505; - break $_$215; + } while (0); + _abort(); + } else { + var $1463 = $K2_0_i_i >>> 31; + var $1464 = $T_0_i_i + 16 + ($1463 << 2) | 0; + var $1465 = HEAPU32[$1464 >> 2]; + var $1466 = ($1465 | 0) == 0; + var $1467 = $K2_0_i_i << 1; + if (!$1466) { + var $K2_0_i_i = $1467; + var $T_0_i_i = $1465; + continue; + } + var $1469 = $1464; + var $1470 = HEAPU32[(__gm_ + 16 | 0) >> 2]; + var $1471 = $1469 >>> 0 < $1470 >>> 0; + if (!$1471) { + HEAP32[$1464 >> 2] = $1406; + var $1473 = $876 + 24 | 0; + var $T_0_c7_i_i = $T_0_i_i; + HEAP32[$1473 >> 2] = $T_0_c7_i_i; + var $1474 = $876 + 12 | 0; + HEAP32[$1474 >> 2] = $876; + var $1475 = $876 + 8 | 0; + HEAP32[$1475 >> 2] = $876; + break $_$275; + } + _abort(); } - } while (0); - var $1506 = ___errno(); - HEAP32[$1506 >> 2] = 12; - var $mem_0 = 0; - } - } else { - var $706 = $703 - $nb_0 | 0; - var $707 = HEAPU32[(__gm_ + 20 | 0) >> 2]; - var $708 = $706 >>> 0 > 15; - if ($708) { - var $710 = $707; - var $711 = $710 + $nb_0 | 0; - var $712 = $711; - HEAP32[(__gm_ + 20 | 0) >> 2] = $712; - HEAP32[(__gm_ + 8 | 0) >> 2] = $706; - var $713 = $706 | 1; - var $_sum2 = $nb_0 + 4 | 0; - var $714 = $710 + $_sum2 | 0; - var $715 = $714; - HEAP32[$715 >> 2] = $713; - var $716 = $710 + $703 | 0; - var $717 = $716; - HEAP32[$717 >> 2] = $706; - var $718 = $nb_0 | 3; - var $719 = $707 + 4 | 0; - HEAP32[$719 >> 2] = $718; - } else { - HEAP32[(__gm_ + 8 | 0) >> 2] = 0; - HEAP32[(__gm_ + 20 | 0) >> 2] = 0; - var $721 = $703 | 3; - var $722 = $707 + 4 | 0; - HEAP32[$722 >> 2] = $721; - var $723 = $707; - var $_sum1 = $703 + 4 | 0; - var $724 = $723 + $_sum1 | 0; - var $725 = $724; - var $726 = HEAP32[$725 >> 2]; - var $727 = $726 | 1; - HEAP32[$725 >> 2] = $727; + } + } + } } - var $729 = $707 + 8 | 0; - var $730 = $729; - var $mem_0 = $730; + } while (0); + var $1491 = HEAPU32[(__gm_ + 12 | 0) >> 2]; + var $1492 = $1491 >>> 0 > $nb_0 >>> 0; + if (!$1492) { + break; + } + var $1494 = $1491 - $nb_0 | 0; + HEAP32[(__gm_ + 12 | 0) >> 2] = $1494; + var $1495 = HEAPU32[(__gm_ + 24 | 0) >> 2]; + var $1496 = $1495; + var $1497 = $1496 + $nb_0 | 0; + var $1498 = $1497; + HEAP32[(__gm_ + 24 | 0) >> 2] = $1498; + var $1499 = $1494 | 1; + var $_sum_i30 = $nb_0 + 4 | 0; + var $1500 = $1496 + $_sum_i30 | 0; + var $1501 = $1500; + HEAP32[$1501 >> 2] = $1499; + var $1502 = $nb_0 | 3; + var $1503 = $1495 + 4 | 0; + HEAP32[$1503 >> 2] = $1502; + var $1504 = $1495 + 8 | 0; + var $1505 = $1504; + var $mem_0 = $1505; + break $_$215; } + } while (0); + var $1506 = ___errno(); + HEAP32[$1506 >> 2] = 12; + var $mem_0 = 0; + } + } else { + var $706 = $703 - $nb_0 | 0; + var $707 = HEAPU32[(__gm_ + 20 | 0) >> 2]; + var $708 = $706 >>> 0 > 15; + if ($708) { + var $710 = $707; + var $711 = $710 + $nb_0 | 0; + var $712 = $711; + HEAP32[(__gm_ + 20 | 0) >> 2] = $712; + HEAP32[(__gm_ + 8 | 0) >> 2] = $706; + var $713 = $706 | 1; + var $_sum2 = $nb_0 + 4 | 0; + var $714 = $710 + $_sum2 | 0; + var $715 = $714; + HEAP32[$715 >> 2] = $713; + var $716 = $710 + $703 | 0; + var $717 = $716; + HEAP32[$717 >> 2] = $706; + var $718 = $nb_0 | 3; + var $719 = $707 + 4 | 0; + HEAP32[$719 >> 2] = $718; + } else { + HEAP32[(__gm_ + 8 | 0) >> 2] = 0; + HEAP32[(__gm_ + 20 | 0) >> 2] = 0; + var $721 = $703 | 3; + var $722 = $707 + 4 | 0; + HEAP32[$722 >> 2] = $721; + var $723 = $707; + var $_sum1 = $703 + 4 | 0; + var $724 = $723 + $_sum1 | 0; + var $725 = $724; + var $726 = HEAP32[$725 >> 2]; + var $727 = $726 | 1; + HEAP32[$725 >> 2] = $727; } - } while (0); - var $mem_0; - return $mem_0; - return null; + var $729 = $707 + 8 | 0; + var $730 = $729; + var $mem_0 = $730; + } + } + } while (0); + var $mem_0; + return $mem_0; + return null; } function _mallocNoU($bytes) { - var __label__; - var $1 = $bytes >>> 0 < 245; - $_$2 : do { - if ($1) { - var $3 = $bytes >>> 0 < 11; - if ($3) { - var $8 = 16; + var __label__; + var $1 = $bytes >>> 0 < 245; + $_$2 : do { + if ($1) { + var $3 = $bytes >>> 0 < 11; + if ($3) { + var $8 = 16; + } else { + var $5 = $bytes + 11 | 0; + var $6 = $5 & -8; + var $8 = $6; + } + var $8; + var $9 = $8 >>> 3; + var $10 = HEAP32[(__gm_ | 0) >> 2]; + var $11 = $10 >>> ($9 >>> 0); + var $12 = $11 & 3; + var $13 = ($12 | 0) == 0; + if (!$13) { + var $15 = $11 & 1; + var $16 = $15 ^ 1; + var $17 = $16 + $9 | 0; + var $18 = $17 << 1; + var $19 = __gm_ + 40 + ($18 << 2) | 0; + var $20 = $19; + var $_sum10 = $18 + 2 | 0; + var $21 = __gm_ + 40 + ($_sum10 << 2) | 0; + var $22 = HEAP32[$21 >> 2]; + var $23 = $22 + 8 | 0; + var $24 = HEAP32[$23 >> 2]; + var $25 = ($20 | 0) == ($24 | 0); + if ($25) { + var $27 = 1 << $17; + var $28 = $27 ^ -1; + var $29 = $10 & $28; + HEAP32[(__gm_ | 0) >> 2] = $29; + } else { + var $31 = $24; + var $32 = HEAP32[(__gm_ + 16 | 0) >> 2]; + var $33 = $31 >>> 0 < $32 >>> 0; + if ($33) { + _abort(); + } else { + HEAP32[$21 >> 2] = $24; + var $35 = $24 + 12 | 0; + HEAP32[$35 >> 2] = $20; + } + } + var $38 = $17 << 3; + var $39 = $38 | 3; + var $40 = $22 + 4 | 0; + HEAP32[$40 >> 2] = $39; + var $41 = $22; + var $_sum1112 = $38 | 4; + var $42 = $41 + $_sum1112 | 0; + var $43 = $42; + var $44 = HEAP32[$43 >> 2]; + var $45 = $44 | 1; + HEAP32[$43 >> 2] = $45; + var $46 = $23; + var $mem_0 = $46; + __label__ = 331; + break; + } + var $48 = HEAP32[(__gm_ + 8 | 0) >> 2]; + var $49 = $8 >>> 0 > $48 >>> 0; + if (!$49) { + var $nb_0 = $8; + __label__ = 155; + break; + } + var $51 = ($11 | 0) == 0; + if (!$51) { + var $53 = $11 << $9; + var $54 = 2 << $9; + var $55 = -$54 | 0; + var $56 = $54 | $55; + var $57 = $53 & $56; + var $58 = -$57 | 0; + var $59 = $57 & $58; + var $60 = $59 - 1 | 0; + var $61 = $60 >>> 12; + var $62 = $61 & 16; + var $63 = $60 >>> ($62 >>> 0); + var $64 = $63 >>> 5; + var $65 = $64 & 8; + var $66 = $63 >>> ($65 >>> 0); + var $67 = $66 >>> 2; + var $68 = $67 & 4; + var $69 = $66 >>> ($68 >>> 0); + var $70 = $69 >>> 1; + var $71 = $70 & 2; + var $72 = $69 >>> ($71 >>> 0); + var $73 = $72 >>> 1; + var $74 = $73 & 1; + var $75 = $65 | $62; + var $76 = $75 | $68; + var $77 = $76 | $71; + var $78 = $77 | $74; + var $79 = $72 >>> ($74 >>> 0); + var $80 = $78 + $79 | 0; + var $81 = $80 << 1; + var $82 = __gm_ + 40 + ($81 << 2) | 0; + var $83 = $82; + var $_sum4 = $81 + 2 | 0; + var $84 = __gm_ + 40 + ($_sum4 << 2) | 0; + var $85 = HEAP32[$84 >> 2]; + var $86 = $85 + 8 | 0; + var $87 = HEAP32[$86 >> 2]; + var $88 = ($83 | 0) == ($87 | 0); + if ($88) { + var $90 = 1 << $80; + var $91 = $90 ^ -1; + var $92 = $10 & $91; + HEAP32[(__gm_ | 0) >> 2] = $92; + } else { + var $94 = $87; + var $95 = HEAP32[(__gm_ + 16 | 0) >> 2]; + var $96 = $94 >>> 0 < $95 >>> 0; + if ($96) { + _abort(); + } else { + HEAP32[$84 >> 2] = $87; + var $98 = $87 + 12 | 0; + HEAP32[$98 >> 2] = $83; + } + } + var $101 = $80 << 3; + var $102 = $101 - $8 | 0; + var $103 = $8 | 3; + var $104 = $85 + 4 | 0; + HEAP32[$104 >> 2] = $103; + var $105 = $85; + var $106 = $105 + $8 | 0; + var $107 = $106; + var $108 = $102 | 1; + var $_sum56 = $8 | 4; + var $109 = $105 + $_sum56 | 0; + var $110 = $109; + HEAP32[$110 >> 2] = $108; + var $111 = $105 + $101 | 0; + var $112 = $111; + HEAP32[$112 >> 2] = $102; + var $113 = HEAP32[(__gm_ + 8 | 0) >> 2]; + var $114 = ($113 | 0) == 0; + if (!$114) { + var $116 = HEAP32[(__gm_ + 20 | 0) >> 2]; + var $117 = $113 >>> 3; + var $118 = $113 >>> 2; + var $119 = $118 & 1073741822; + var $120 = __gm_ + 40 + ($119 << 2) | 0; + var $121 = $120; + var $122 = HEAP32[(__gm_ | 0) >> 2]; + var $123 = 1 << $117; + var $124 = $122 & $123; + var $125 = ($124 | 0) == 0; + do { + if ($125) { + var $127 = $122 | $123; + HEAP32[(__gm_ | 0) >> 2] = $127; + var $_sum8_pre = $119 + 2 | 0; + var $_pre = __gm_ + 40 + ($_sum8_pre << 2) | 0; + var $F4_0 = $121; + var $_pre_phi = $_pre; } else { - var $5 = $bytes + 11 | 0; - var $6 = $5 & -8; - var $8 = $6; - } - var $8; - var $9 = $8 >>> 3; - var $10 = HEAP32[(__gm_ | 0) >> 2]; - var $11 = $10 >>> ($9 >>> 0); - var $12 = $11 & 3; - var $13 = ($12 | 0) == 0; - if (!$13) { - var $15 = $11 & 1; - var $16 = $15 ^ 1; - var $17 = $16 + $9 | 0; - var $18 = $17 << 1; - var $19 = __gm_ + 40 + ($18 << 2) | 0; - var $20 = $19; - var $_sum10 = $18 + 2 | 0; - var $21 = __gm_ + 40 + ($_sum10 << 2) | 0; - var $22 = HEAP32[$21 >> 2]; - var $23 = $22 + 8 | 0; - var $24 = HEAP32[$23 >> 2]; - var $25 = ($20 | 0) == ($24 | 0); - if ($25) { - var $27 = 1 << $17; - var $28 = $27 ^ -1; - var $29 = $10 & $28; - HEAP32[(__gm_ | 0) >> 2] = $29; - } else { - var $31 = $24; - var $32 = HEAP32[(__gm_ + 16 | 0) >> 2]; - var $33 = $31 >>> 0 < $32 >>> 0; - if ($33) { - _abort(); - } else { - HEAP32[$21 >> 2] = $24; - var $35 = $24 + 12 | 0; - HEAP32[$35 >> 2] = $20; - } - } - var $38 = $17 << 3; - var $39 = $38 | 3; - var $40 = $22 + 4 | 0; - HEAP32[$40 >> 2] = $39; - var $41 = $22; - var $_sum1112 = $38 | 4; - var $42 = $41 + $_sum1112 | 0; - var $43 = $42; - var $44 = HEAP32[$43 >> 2]; - var $45 = $44 | 1; - HEAP32[$43 >> 2] = $45; - var $46 = $23; - var $mem_0 = $46; - __label__ = 331; + var $_sum9 = $119 + 2 | 0; + var $129 = __gm_ + 40 + ($_sum9 << 2) | 0; + var $130 = HEAP32[$129 >> 2]; + var $131 = $130; + var $132 = HEAP32[(__gm_ + 16 | 0) >> 2]; + var $133 = $131 >>> 0 < $132 >>> 0; + if (!$133) { + var $F4_0 = $130; + var $_pre_phi = $129; break; + } + _abort(); } - var $48 = HEAP32[(__gm_ + 8 | 0) >> 2]; - var $49 = $8 >>> 0 > $48 >>> 0; - if (!$49) { - var $nb_0 = $8; - __label__ = 155; - break; + } while (0); + var $_pre_phi; + var $F4_0; + HEAP32[$_pre_phi >> 2] = $116; + var $136 = $F4_0 + 12 | 0; + HEAP32[$136 >> 2] = $116; + var $137 = $116 + 8 | 0; + HEAP32[$137 >> 2] = $F4_0; + var $138 = $116 + 12 | 0; + HEAP32[$138 >> 2] = $121; + } + HEAP32[(__gm_ + 8 | 0) >> 2] = $102; + HEAP32[(__gm_ + 20 | 0) >> 2] = $107; + var $140 = $86; + var $mem_0 = $140; + __label__ = 331; + break; + } + var $142 = HEAP32[(__gm_ + 4 | 0) >> 2]; + var $143 = ($142 | 0) == 0; + if ($143) { + var $nb_0 = $8; + __label__ = 155; + break; + } + var $145 = -$142 | 0; + var $146 = $142 & $145; + var $147 = $146 - 1 | 0; + var $148 = $147 >>> 12; + var $149 = $148 & 16; + var $150 = $147 >>> ($149 >>> 0); + var $151 = $150 >>> 5; + var $152 = $151 & 8; + var $153 = $150 >>> ($152 >>> 0); + var $154 = $153 >>> 2; + var $155 = $154 & 4; + var $156 = $153 >>> ($155 >>> 0); + var $157 = $156 >>> 1; + var $158 = $157 & 2; + var $159 = $156 >>> ($158 >>> 0); + var $160 = $159 >>> 1; + var $161 = $160 & 1; + var $162 = $152 | $149; + var $163 = $162 | $155; + var $164 = $163 | $158; + var $165 = $164 | $161; + var $166 = $159 >>> ($161 >>> 0); + var $167 = $165 + $166 | 0; + var $168 = __gm_ + 304 + ($167 << 2) | 0; + var $169 = HEAP32[$168 >> 2]; + var $170 = $169 + 4 | 0; + var $171 = HEAP32[$170 >> 2]; + var $172 = $171 & -8; + var $173 = $172 - $8 | 0; + var $t_0_i = $169; + var $v_0_i = $169; + var $rsize_0_i = $173; + while (1) { + var $rsize_0_i; + var $v_0_i; + var $t_0_i; + var $175 = $t_0_i + 16 | 0; + var $176 = HEAP32[$175 >> 2]; + var $177 = ($176 | 0) == 0; + if ($177) { + var $179 = $t_0_i + 20 | 0; + var $180 = HEAP32[$179 >> 2]; + var $181 = ($180 | 0) == 0; + if ($181) { + break; + } + var $182 = $180; + } else { + var $182 = $176; + } + var $182; + var $183 = $182 + 4 | 0; + var $184 = HEAP32[$183 >> 2]; + var $185 = $184 & -8; + var $186 = $185 - $8 | 0; + var $187 = $186 >>> 0 < $rsize_0_i >>> 0; + var $_rsize_0_i = $187 ? $186 : $rsize_0_i; + var $_v_0_i = $187 ? $182 : $v_0_i; + var $t_0_i = $182; + var $v_0_i = $_v_0_i; + var $rsize_0_i = $_rsize_0_i; + } + var $189 = $v_0_i; + var $190 = HEAP32[(__gm_ + 16 | 0) >> 2]; + var $191 = $189 >>> 0 < $190 >>> 0; + do { + if (!$191) { + var $193 = $189 + $8 | 0; + var $194 = $193; + var $195 = $189 >>> 0 < $193 >>> 0; + if (!$195) { + break; + } + var $197 = $v_0_i + 24 | 0; + var $198 = HEAP32[$197 >> 2]; + var $199 = $v_0_i + 12 | 0; + var $200 = HEAP32[$199 >> 2]; + var $201 = ($200 | 0) == ($v_0_i | 0); + do { + if ($201) { + var $212 = $v_0_i + 20 | 0; + var $213 = HEAP32[$212 >> 2]; + var $214 = ($213 | 0) == 0; + if ($214) { + var $216 = $v_0_i + 16 | 0; + var $217 = HEAP32[$216 >> 2]; + var $218 = ($217 | 0) == 0; + if ($218) { + var $R_1_i = 0; + break; + } + var $RP_0_i = $216; + var $R_0_i = $217; + } else { + var $RP_0_i = $212; + var $R_0_i = $213; + __label__ = 39; + } + while (1) { + var $R_0_i; + var $RP_0_i; + var $219 = $R_0_i + 20 | 0; + var $220 = HEAP32[$219 >> 2]; + var $221 = ($220 | 0) == 0; + if (!$221) { + var $RP_0_i = $219; + var $R_0_i = $220; + continue; + } + var $223 = $R_0_i + 16 | 0; + var $224 = HEAP32[$223 >> 2]; + var $225 = ($224 | 0) == 0; + if ($225) { + break; + } + var $RP_0_i = $223; + var $R_0_i = $224; + } + var $227 = $RP_0_i; + var $228 = $227 >>> 0 < $190 >>> 0; + if ($228) { + _abort(); + } else { + HEAP32[$RP_0_i >> 2] = 0; + var $R_1_i = $R_0_i; + } + } else { + var $203 = $v_0_i + 8 | 0; + var $204 = HEAP32[$203 >> 2]; + var $205 = $204; + var $206 = $205 >>> 0 < $190 >>> 0; + if ($206) { + _abort(); + } else { + var $208 = $204 + 12 | 0; + HEAP32[$208 >> 2] = $200; + var $209 = $200 + 8 | 0; + HEAP32[$209 >> 2] = $204; + var $R_1_i = $200; + } } - var $51 = ($11 | 0) == 0; - if (!$51) { - var $53 = $11 << $9; - var $54 = 2 << $9; - var $55 = -$54 | 0; - var $56 = $54 | $55; - var $57 = $53 & $56; - var $58 = -$57 | 0; - var $59 = $57 & $58; - var $60 = $59 - 1 | 0; - var $61 = $60 >>> 12; - var $62 = $61 & 16; - var $63 = $60 >>> ($62 >>> 0); - var $64 = $63 >>> 5; - var $65 = $64 & 8; - var $66 = $63 >>> ($65 >>> 0); - var $67 = $66 >>> 2; - var $68 = $67 & 4; - var $69 = $66 >>> ($68 >>> 0); - var $70 = $69 >>> 1; - var $71 = $70 & 2; - var $72 = $69 >>> ($71 >>> 0); - var $73 = $72 >>> 1; - var $74 = $73 & 1; - var $75 = $65 | $62; - var $76 = $75 | $68; - var $77 = $76 | $71; - var $78 = $77 | $74; - var $79 = $72 >>> ($74 >>> 0); - var $80 = $78 + $79 | 0; - var $81 = $80 << 1; - var $82 = __gm_ + 40 + ($81 << 2) | 0; - var $83 = $82; - var $_sum4 = $81 + 2 | 0; - var $84 = __gm_ + 40 + ($_sum4 << 2) | 0; - var $85 = HEAP32[$84 >> 2]; - var $86 = $85 + 8 | 0; - var $87 = HEAP32[$86 >> 2]; - var $88 = ($83 | 0) == ($87 | 0); - if ($88) { - var $90 = 1 << $80; - var $91 = $90 ^ -1; - var $92 = $10 & $91; - HEAP32[(__gm_ | 0) >> 2] = $92; + } while (0); + var $R_1_i; + var $232 = ($198 | 0) == 0; + $_$62 : do { + if (!$232) { + var $234 = $v_0_i + 28 | 0; + var $235 = HEAP32[$234 >> 2]; + var $236 = __gm_ + 304 + ($235 << 2) | 0; + var $237 = HEAP32[$236 >> 2]; + var $238 = ($v_0_i | 0) == ($237 | 0); + do { + if ($238) { + HEAP32[$236 >> 2] = $R_1_i; + var $cond_i = ($R_1_i | 0) == 0; + if (!$cond_i) { + break; + } + var $240 = HEAP32[$234 >> 2]; + var $241 = 1 << $240; + var $242 = $241 ^ -1; + var $243 = HEAP32[(__gm_ + 4 | 0) >> 2]; + var $244 = $243 & $242; + HEAP32[(__gm_ + 4 | 0) >> 2] = $244; + break $_$62; + } + var $246 = $198; + var $247 = HEAP32[(__gm_ + 16 | 0) >> 2]; + var $248 = $246 >>> 0 < $247 >>> 0; + if ($248) { + _abort(); } else { - var $94 = $87; - var $95 = HEAP32[(__gm_ + 16 | 0) >> 2]; - var $96 = $94 >>> 0 < $95 >>> 0; - if ($96) { - _abort(); - } else { - HEAP32[$84 >> 2] = $87; - var $98 = $87 + 12 | 0; - HEAP32[$98 >> 2] = $83; - } + var $250 = $198 + 16 | 0; + var $251 = HEAP32[$250 >> 2]; + var $252 = ($251 | 0) == ($v_0_i | 0); + if ($252) { + HEAP32[$250 >> 2] = $R_1_i; + } else { + var $255 = $198 + 20 | 0; + HEAP32[$255 >> 2] = $R_1_i; + } + var $258 = ($R_1_i | 0) == 0; + if ($258) { + break $_$62; + } } - var $101 = $80 << 3; - var $102 = $101 - $8 | 0; - var $103 = $8 | 3; - var $104 = $85 + 4 | 0; - HEAP32[$104 >> 2] = $103; - var $105 = $85; - var $106 = $105 + $8 | 0; - var $107 = $106; - var $108 = $102 | 1; - var $_sum56 = $8 | 4; - var $109 = $105 + $_sum56 | 0; - var $110 = $109; - HEAP32[$110 >> 2] = $108; - var $111 = $105 + $101 | 0; - var $112 = $111; - HEAP32[$112 >> 2] = $102; - var $113 = HEAP32[(__gm_ + 8 | 0) >> 2]; - var $114 = ($113 | 0) == 0; - if (!$114) { - var $116 = HEAP32[(__gm_ + 20 | 0) >> 2]; - var $117 = $113 >>> 3; - var $118 = $113 >>> 2; - var $119 = $118 & 1073741822; - var $120 = __gm_ + 40 + ($119 << 2) | 0; - var $121 = $120; - var $122 = HEAP32[(__gm_ | 0) >> 2]; - var $123 = 1 << $117; - var $124 = $122 & $123; - var $125 = ($124 | 0) == 0; - do { - if ($125) { - var $127 = $122 | $123; - HEAP32[(__gm_ | 0) >> 2] = $127; - var $_sum8_pre = $119 + 2 | 0; - var $_pre = __gm_ + 40 + ($_sum8_pre << 2) | 0; - var $F4_0 = $121; - var $_pre_phi = $_pre; - } else { - var $_sum9 = $119 + 2 | 0; - var $129 = __gm_ + 40 + ($_sum9 << 2) | 0; - var $130 = HEAP32[$129 >> 2]; - var $131 = $130; - var $132 = HEAP32[(__gm_ + 16 | 0) >> 2]; - var $133 = $131 >>> 0 < $132 >>> 0; - if (!$133) { - var $F4_0 = $130; - var $_pre_phi = $129; - break; - } - _abort(); - } - } while (0); - var $_pre_phi; - var $F4_0; - HEAP32[$_pre_phi >> 2] = $116; - var $136 = $F4_0 + 12 | 0; - HEAP32[$136 >> 2] = $116; - var $137 = $116 + 8 | 0; - HEAP32[$137 >> 2] = $F4_0; - var $138 = $116 + 12 | 0; - HEAP32[$138 >> 2] = $121; + } while (0); + var $260 = $R_1_i; + var $261 = HEAP32[(__gm_ + 16 | 0) >> 2]; + var $262 = $260 >>> 0 < $261 >>> 0; + if ($262) { + _abort(); + } else { + var $264 = $R_1_i + 24 | 0; + HEAP32[$264 >> 2] = $198; + var $265 = $v_0_i + 16 | 0; + var $266 = HEAP32[$265 >> 2]; + var $267 = ($266 | 0) == 0; + if (!$267) { + var $269 = $266; + var $270 = HEAP32[(__gm_ + 16 | 0) >> 2]; + var $271 = $269 >>> 0 < $270 >>> 0; + if ($271) { + _abort(); + } else { + var $273 = $R_1_i + 16 | 0; + HEAP32[$273 >> 2] = $266; + var $274 = $266 + 24 | 0; + HEAP32[$274 >> 2] = $R_1_i; + } } - HEAP32[(__gm_ + 8 | 0) >> 2] = $102; - HEAP32[(__gm_ + 20 | 0) >> 2] = $107; - var $140 = $86; - var $mem_0 = $140; - __label__ = 331; - break; + var $277 = $v_0_i + 20 | 0; + var $278 = HEAP32[$277 >> 2]; + var $279 = ($278 | 0) == 0; + if ($279) { + break; + } + var $281 = $278; + var $282 = HEAP32[(__gm_ + 16 | 0) >> 2]; + var $283 = $281 >>> 0 < $282 >>> 0; + if ($283) { + _abort(); + } else { + var $285 = $R_1_i + 20 | 0; + HEAP32[$285 >> 2] = $278; + var $286 = $278 + 24 | 0; + HEAP32[$286 >> 2] = $R_1_i; + } + } } - var $142 = HEAP32[(__gm_ + 4 | 0) >> 2]; - var $143 = ($142 | 0) == 0; - if ($143) { - var $nb_0 = $8; - __label__ = 155; - break; + } while (0); + var $290 = $rsize_0_i >>> 0 < 16; + if ($290) { + var $292 = $rsize_0_i + $8 | 0; + var $293 = $292 | 3; + var $294 = $v_0_i + 4 | 0; + HEAP32[$294 >> 2] = $293; + var $_sum4_i = $292 + 4 | 0; + var $295 = $189 + $_sum4_i | 0; + var $296 = $295; + var $297 = HEAP32[$296 >> 2]; + var $298 = $297 | 1; + HEAP32[$296 >> 2] = $298; + } else { + var $300 = $8 | 3; + var $301 = $v_0_i + 4 | 0; + HEAP32[$301 >> 2] = $300; + var $302 = $rsize_0_i | 1; + var $_sum_i33 = $8 | 4; + var $303 = $189 + $_sum_i33 | 0; + var $304 = $303; + HEAP32[$304 >> 2] = $302; + var $_sum1_i = $rsize_0_i + $8 | 0; + var $305 = $189 + $_sum1_i | 0; + var $306 = $305; + HEAP32[$306 >> 2] = $rsize_0_i; + var $307 = HEAP32[(__gm_ + 8 | 0) >> 2]; + var $308 = ($307 | 0) == 0; + if (!$308) { + var $310 = HEAP32[(__gm_ + 20 | 0) >> 2]; + var $311 = $307 >>> 3; + var $312 = $307 >>> 2; + var $313 = $312 & 1073741822; + var $314 = __gm_ + 40 + ($313 << 2) | 0; + var $315 = $314; + var $316 = HEAP32[(__gm_ | 0) >> 2]; + var $317 = 1 << $311; + var $318 = $316 & $317; + var $319 = ($318 | 0) == 0; + do { + if ($319) { + var $321 = $316 | $317; + HEAP32[(__gm_ | 0) >> 2] = $321; + var $_sum2_pre_i = $313 + 2 | 0; + var $_pre_i = __gm_ + 40 + ($_sum2_pre_i << 2) | 0; + var $F1_0_i = $315; + var $_pre_phi_i = $_pre_i; + } else { + var $_sum3_i = $313 + 2 | 0; + var $323 = __gm_ + 40 + ($_sum3_i << 2) | 0; + var $324 = HEAP32[$323 >> 2]; + var $325 = $324; + var $326 = HEAP32[(__gm_ + 16 | 0) >> 2]; + var $327 = $325 >>> 0 < $326 >>> 0; + if (!$327) { + var $F1_0_i = $324; + var $_pre_phi_i = $323; + break; + } + _abort(); + } + } while (0); + var $_pre_phi_i; + var $F1_0_i; + HEAP32[$_pre_phi_i >> 2] = $310; + var $330 = $F1_0_i + 12 | 0; + HEAP32[$330 >> 2] = $310; + var $331 = $310 + 8 | 0; + HEAP32[$331 >> 2] = $F1_0_i; + var $332 = $310 + 12 | 0; + HEAP32[$332 >> 2] = $315; } - var $145 = -$142 | 0; - var $146 = $142 & $145; - var $147 = $146 - 1 | 0; - var $148 = $147 >>> 12; - var $149 = $148 & 16; - var $150 = $147 >>> ($149 >>> 0); - var $151 = $150 >>> 5; - var $152 = $151 & 8; - var $153 = $150 >>> ($152 >>> 0); - var $154 = $153 >>> 2; - var $155 = $154 & 4; - var $156 = $153 >>> ($155 >>> 0); - var $157 = $156 >>> 1; - var $158 = $157 & 2; - var $159 = $156 >>> ($158 >>> 0); - var $160 = $159 >>> 1; - var $161 = $160 & 1; - var $162 = $152 | $149; - var $163 = $162 | $155; - var $164 = $163 | $158; - var $165 = $164 | $161; - var $166 = $159 >>> ($161 >>> 0); - var $167 = $165 + $166 | 0; - var $168 = __gm_ + 304 + ($167 << 2) | 0; - var $169 = HEAP32[$168 >> 2]; - var $170 = $169 + 4 | 0; - var $171 = HEAP32[$170 >> 2]; - var $172 = $171 & -8; - var $173 = $172 - $8 | 0; - var $t_0_i = $169; - var $v_0_i = $169; - var $rsize_0_i = $173; - while (1) { - var $rsize_0_i; - var $v_0_i; - var $t_0_i; - var $175 = $t_0_i + 16 | 0; - var $176 = HEAP32[$175 >> 2]; - var $177 = ($176 | 0) == 0; - if ($177) { - var $179 = $t_0_i + 20 | 0; - var $180 = HEAP32[$179 >> 2]; - var $181 = ($180 | 0) == 0; - if ($181) { - break; - } - var $182 = $180; + HEAP32[(__gm_ + 8 | 0) >> 2] = $rsize_0_i; + HEAP32[(__gm_ + 20 | 0) >> 2] = $194; + } + var $335 = $v_0_i + 8 | 0; + var $336 = $335; + var $337 = ($335 | 0) == 0; + if ($337) { + var $nb_0 = $8; + __label__ = 155; + break $_$2; + } + var $mem_0 = $336; + __label__ = 331; + break $_$2; + } + } while (0); + _abort(); + } else { + var $339 = $bytes >>> 0 > 4294967231; + if ($339) { + var $nb_0 = -1; + __label__ = 155; + break; + } + var $341 = $bytes + 11 | 0; + var $342 = $341 & -8; + var $343 = HEAP32[(__gm_ + 4 | 0) >> 2]; + var $344 = ($343 | 0) == 0; + if ($344) { + var $nb_0 = $342; + __label__ = 155; + break; + } + var $346 = -$342 | 0; + var $347 = $341 >>> 8; + var $348 = ($347 | 0) == 0; + do { + if ($348) { + var $idx_0_i = 0; + } else { + var $350 = $342 >>> 0 > 16777215; + if ($350) { + var $idx_0_i = 31; + break; + } + var $352 = $347 + 1048320 | 0; + var $353 = $352 >>> 16; + var $354 = $353 & 8; + var $355 = $347 << $354; + var $356 = $355 + 520192 | 0; + var $357 = $356 >>> 16; + var $358 = $357 & 4; + var $359 = $355 << $358; + var $360 = $359 + 245760 | 0; + var $361 = $360 >>> 16; + var $362 = $361 & 2; + var $363 = $358 | $354; + var $364 = $363 | $362; + var $365 = 14 - $364 | 0; + var $366 = $359 << $362; + var $367 = $366 >>> 15; + var $368 = $365 + $367 | 0; + var $369 = $368 << 1; + var $370 = $368 + 7 | 0; + var $371 = $342 >>> ($370 >>> 0); + var $372 = $371 & 1; + var $373 = $372 | $369; + var $idx_0_i = $373; + } + } while (0); + var $idx_0_i; + var $375 = __gm_ + 304 + ($idx_0_i << 2) | 0; + var $376 = HEAP32[$375 >> 2]; + var $377 = ($376 | 0) == 0; + $_$110 : do { + if ($377) { + var $v_2_i = 0; + var $rsize_2_i = $346; + var $t_1_i = 0; + } else { + var $379 = ($idx_0_i | 0) == 31; + if ($379) { + var $384 = 0; + } else { + var $381 = $idx_0_i >>> 1; + var $382 = 25 - $381 | 0; + var $384 = $382; + } + var $384; + var $385 = $342 << $384; + var $v_0_i15 = 0; + var $rsize_0_i14 = $346; + var $t_0_i13 = $376; + var $sizebits_0_i = $385; + var $rst_0_i = 0; + while (1) { + var $rst_0_i; + var $sizebits_0_i; + var $t_0_i13; + var $rsize_0_i14; + var $v_0_i15; + var $387 = $t_0_i13 + 4 | 0; + var $388 = HEAP32[$387 >> 2]; + var $389 = $388 & -8; + var $390 = $389 - $342 | 0; + var $391 = $390 >>> 0 < $rsize_0_i14 >>> 0; + if ($391) { + var $393 = ($389 | 0) == ($342 | 0); + if ($393) { + var $v_2_i = $t_0_i13; + var $rsize_2_i = $390; + var $t_1_i = $t_0_i13; + break $_$110; + } + var $v_1_i = $t_0_i13; + var $rsize_1_i = $390; + } else { + var $v_1_i = $v_0_i15; + var $rsize_1_i = $rsize_0_i14; + } + var $rsize_1_i; + var $v_1_i; + var $395 = $t_0_i13 + 20 | 0; + var $396 = HEAP32[$395 >> 2]; + var $397 = $sizebits_0_i >>> 31; + var $398 = $t_0_i13 + 16 + ($397 << 2) | 0; + var $399 = HEAP32[$398 >> 2]; + var $400 = ($396 | 0) == 0; + var $401 = ($396 | 0) == ($399 | 0); + var $or_cond_i = $400 | $401; + var $rst_1_i = $or_cond_i ? $rst_0_i : $396; + var $402 = ($399 | 0) == 0; + var $403 = $sizebits_0_i << 1; + if ($402) { + var $v_2_i = $v_1_i; + var $rsize_2_i = $rsize_1_i; + var $t_1_i = $rst_1_i; + break $_$110; + } + var $v_0_i15 = $v_1_i; + var $rsize_0_i14 = $rsize_1_i; + var $t_0_i13 = $399; + var $sizebits_0_i = $403; + var $rst_0_i = $rst_1_i; + } + } + } while (0); + var $t_1_i; + var $rsize_2_i; + var $v_2_i; + var $404 = ($t_1_i | 0) == 0; + var $405 = ($v_2_i | 0) == 0; + var $or_cond19_i = $404 & $405; + if ($or_cond19_i) { + var $407 = 2 << $idx_0_i; + var $408 = -$407 | 0; + var $409 = $407 | $408; + var $410 = $343 & $409; + var $411 = ($410 | 0) == 0; + if ($411) { + var $nb_0 = $342; + __label__ = 155; + break; + } + var $413 = -$410 | 0; + var $414 = $410 & $413; + var $415 = $414 - 1 | 0; + var $416 = $415 >>> 12; + var $417 = $416 & 16; + var $418 = $415 >>> ($417 >>> 0); + var $419 = $418 >>> 5; + var $420 = $419 & 8; + var $421 = $418 >>> ($420 >>> 0); + var $422 = $421 >>> 2; + var $423 = $422 & 4; + var $424 = $421 >>> ($423 >>> 0); + var $425 = $424 >>> 1; + var $426 = $425 & 2; + var $427 = $424 >>> ($426 >>> 0); + var $428 = $427 >>> 1; + var $429 = $428 & 1; + var $430 = $420 | $417; + var $431 = $430 | $423; + var $432 = $431 | $426; + var $433 = $432 | $429; + var $434 = $427 >>> ($429 >>> 0); + var $435 = $433 + $434 | 0; + var $436 = __gm_ + 304 + ($435 << 2) | 0; + var $437 = HEAP32[$436 >> 2]; + var $t_2_ph_i = $437; + } else { + var $t_2_ph_i = $t_1_i; + } + var $t_2_ph_i; + var $438 = ($t_2_ph_i | 0) == 0; + $_$125 : do { + if ($438) { + var $rsize_3_lcssa_i = $rsize_2_i; + var $v_3_lcssa_i = $v_2_i; + } else { + var $t_224_i = $t_2_ph_i; + var $rsize_325_i = $rsize_2_i; + var $v_326_i = $v_2_i; + while (1) { + var $v_326_i; + var $rsize_325_i; + var $t_224_i; + var $439 = $t_224_i + 4 | 0; + var $440 = HEAP32[$439 >> 2]; + var $441 = $440 & -8; + var $442 = $441 - $342 | 0; + var $443 = $442 >>> 0 < $rsize_325_i >>> 0; + var $_rsize_3_i = $443 ? $442 : $rsize_325_i; + var $t_2_v_3_i = $443 ? $t_224_i : $v_326_i; + var $444 = $t_224_i + 16 | 0; + var $445 = HEAP32[$444 >> 2]; + var $446 = ($445 | 0) == 0; + if (!$446) { + var $t_224_i = $445; + var $rsize_325_i = $_rsize_3_i; + var $v_326_i = $t_2_v_3_i; + continue; + } + var $447 = $t_224_i + 20 | 0; + var $448 = HEAP32[$447 >> 2]; + var $449 = ($448 | 0) == 0; + if ($449) { + var $rsize_3_lcssa_i = $_rsize_3_i; + var $v_3_lcssa_i = $t_2_v_3_i; + break $_$125; + } + var $t_224_i = $448; + var $rsize_325_i = $_rsize_3_i; + var $v_326_i = $t_2_v_3_i; + } + } + } while (0); + var $v_3_lcssa_i; + var $rsize_3_lcssa_i; + var $450 = ($v_3_lcssa_i | 0) == 0; + if ($450) { + var $nb_0 = $342; + __label__ = 155; + break; + } + var $452 = HEAP32[(__gm_ + 8 | 0) >> 2]; + var $453 = $452 - $342 | 0; + var $454 = $rsize_3_lcssa_i >>> 0 < $453 >>> 0; + if (!$454) { + var $nb_0 = $342; + __label__ = 155; + break; + } + var $456 = $v_3_lcssa_i; + var $457 = HEAP32[(__gm_ + 16 | 0) >> 2]; + var $458 = $456 >>> 0 < $457 >>> 0; + do { + if (!$458) { + var $460 = $456 + $342 | 0; + var $461 = $460; + var $462 = $456 >>> 0 < $460 >>> 0; + if (!$462) { + break; + } + var $464 = $v_3_lcssa_i + 24 | 0; + var $465 = HEAP32[$464 >> 2]; + var $466 = $v_3_lcssa_i + 12 | 0; + var $467 = HEAP32[$466 >> 2]; + var $468 = ($467 | 0) == ($v_3_lcssa_i | 0); + do { + if ($468) { + var $479 = $v_3_lcssa_i + 20 | 0; + var $480 = HEAP32[$479 >> 2]; + var $481 = ($480 | 0) == 0; + if ($481) { + var $483 = $v_3_lcssa_i + 16 | 0; + var $484 = HEAP32[$483 >> 2]; + var $485 = ($484 | 0) == 0; + if ($485) { + var $R_1_i19 = 0; + break; + } + var $RP_0_i17 = $483; + var $R_0_i16 = $484; + } else { + var $RP_0_i17 = $479; + var $R_0_i16 = $480; + __label__ = 103; + } + while (1) { + var $R_0_i16; + var $RP_0_i17; + var $486 = $R_0_i16 + 20 | 0; + var $487 = HEAP32[$486 >> 2]; + var $488 = ($487 | 0) == 0; + if (!$488) { + var $RP_0_i17 = $486; + var $R_0_i16 = $487; + continue; + } + var $490 = $R_0_i16 + 16 | 0; + var $491 = HEAP32[$490 >> 2]; + var $492 = ($491 | 0) == 0; + if ($492) { + break; + } + var $RP_0_i17 = $490; + var $R_0_i16 = $491; + } + var $494 = $RP_0_i17; + var $495 = $494 >>> 0 < $457 >>> 0; + if ($495) { + _abort(); + } else { + HEAP32[$RP_0_i17 >> 2] = 0; + var $R_1_i19 = $R_0_i16; + } + } else { + var $470 = $v_3_lcssa_i + 8 | 0; + var $471 = HEAP32[$470 >> 2]; + var $472 = $471; + var $473 = $472 >>> 0 < $457 >>> 0; + if ($473) { + _abort(); + } else { + var $475 = $471 + 12 | 0; + HEAP32[$475 >> 2] = $467; + var $476 = $467 + 8 | 0; + HEAP32[$476 >> 2] = $471; + var $R_1_i19 = $467; + } + } + } while (0); + var $R_1_i19; + var $499 = ($465 | 0) == 0; + $_$151 : do { + if (!$499) { + var $501 = $v_3_lcssa_i + 28 | 0; + var $502 = HEAP32[$501 >> 2]; + var $503 = __gm_ + 304 + ($502 << 2) | 0; + var $504 = HEAP32[$503 >> 2]; + var $505 = ($v_3_lcssa_i | 0) == ($504 | 0); + do { + if ($505) { + HEAP32[$503 >> 2] = $R_1_i19; + var $cond_i20 = ($R_1_i19 | 0) == 0; + if (!$cond_i20) { + break; + } + var $507 = HEAP32[$501 >> 2]; + var $508 = 1 << $507; + var $509 = $508 ^ -1; + var $510 = HEAP32[(__gm_ + 4 | 0) >> 2]; + var $511 = $510 & $509; + HEAP32[(__gm_ + 4 | 0) >> 2] = $511; + break $_$151; + } + var $513 = $465; + var $514 = HEAP32[(__gm_ + 16 | 0) >> 2]; + var $515 = $513 >>> 0 < $514 >>> 0; + if ($515) { + _abort(); + } else { + var $517 = $465 + 16 | 0; + var $518 = HEAP32[$517 >> 2]; + var $519 = ($518 | 0) == ($v_3_lcssa_i | 0); + if ($519) { + HEAP32[$517 >> 2] = $R_1_i19; + } else { + var $522 = $465 + 20 | 0; + HEAP32[$522 >> 2] = $R_1_i19; + } + var $525 = ($R_1_i19 | 0) == 0; + if ($525) { + break $_$151; + } + } + } while (0); + var $527 = $R_1_i19; + var $528 = HEAP32[(__gm_ + 16 | 0) >> 2]; + var $529 = $527 >>> 0 < $528 >>> 0; + if ($529) { + _abort(); + } else { + var $531 = $R_1_i19 + 24 | 0; + HEAP32[$531 >> 2] = $465; + var $532 = $v_3_lcssa_i + 16 | 0; + var $533 = HEAP32[$532 >> 2]; + var $534 = ($533 | 0) == 0; + if (!$534) { + var $536 = $533; + var $537 = HEAP32[(__gm_ + 16 | 0) >> 2]; + var $538 = $536 >>> 0 < $537 >>> 0; + if ($538) { + _abort(); + } else { + var $540 = $R_1_i19 + 16 | 0; + HEAP32[$540 >> 2] = $533; + var $541 = $533 + 24 | 0; + HEAP32[$541 >> 2] = $R_1_i19; + } + } + var $544 = $v_3_lcssa_i + 20 | 0; + var $545 = HEAP32[$544 >> 2]; + var $546 = ($545 | 0) == 0; + if ($546) { + break; + } + var $548 = $545; + var $549 = HEAP32[(__gm_ + 16 | 0) >> 2]; + var $550 = $548 >>> 0 < $549 >>> 0; + if ($550) { + _abort(); } else { - var $182 = $176; + var $552 = $R_1_i19 + 20 | 0; + HEAP32[$552 >> 2] = $545; + var $553 = $545 + 24 | 0; + HEAP32[$553 >> 2] = $R_1_i19; } - var $182; - var $183 = $182 + 4 | 0; - var $184 = HEAP32[$183 >> 2]; - var $185 = $184 & -8; - var $186 = $185 - $8 | 0; - var $187 = $186 >>> 0 < $rsize_0_i >>> 0; - var $_rsize_0_i = $187 ? $186 : $rsize_0_i; - var $_v_0_i = $187 ? $182 : $v_0_i; - var $t_0_i = $182; - var $v_0_i = $_v_0_i; - var $rsize_0_i = $_rsize_0_i; + } } - var $189 = $v_0_i; - var $190 = HEAP32[(__gm_ + 16 | 0) >> 2]; - var $191 = $189 >>> 0 < $190 >>> 0; - do { - if (!$191) { - var $193 = $189 + $8 | 0; - var $194 = $193; - var $195 = $189 >>> 0 < $193 >>> 0; - if (!$195) { - break; + } while (0); + var $557 = $rsize_3_lcssa_i >>> 0 < 16; + $_$179 : do { + if ($557) { + var $559 = $rsize_3_lcssa_i + $342 | 0; + var $560 = $559 | 3; + var $561 = $v_3_lcssa_i + 4 | 0; + HEAP32[$561 >> 2] = $560; + var $_sum18_i = $559 + 4 | 0; + var $562 = $456 + $_sum18_i | 0; + var $563 = $562; + var $564 = HEAP32[$563 >> 2]; + var $565 = $564 | 1; + HEAP32[$563 >> 2] = $565; + } else { + var $567 = $342 | 3; + var $568 = $v_3_lcssa_i + 4 | 0; + HEAP32[$568 >> 2] = $567; + var $569 = $rsize_3_lcssa_i | 1; + var $_sum_i2232 = $342 | 4; + var $570 = $456 + $_sum_i2232 | 0; + var $571 = $570; + HEAP32[$571 >> 2] = $569; + var $_sum1_i23 = $rsize_3_lcssa_i + $342 | 0; + var $572 = $456 + $_sum1_i23 | 0; + var $573 = $572; + HEAP32[$573 >> 2] = $rsize_3_lcssa_i; + var $574 = $rsize_3_lcssa_i >>> 0 < 256; + if ($574) { + var $576 = $rsize_3_lcssa_i >>> 3; + var $577 = $rsize_3_lcssa_i >>> 2; + var $578 = $577 & 1073741822; + var $579 = __gm_ + 40 + ($578 << 2) | 0; + var $580 = $579; + var $581 = HEAP32[(__gm_ | 0) >> 2]; + var $582 = 1 << $576; + var $583 = $581 & $582; + var $584 = ($583 | 0) == 0; + do { + if ($584) { + var $586 = $581 | $582; + HEAP32[(__gm_ | 0) >> 2] = $586; + var $_sum14_pre_i = $578 + 2 | 0; + var $_pre_i24 = __gm_ + 40 + ($_sum14_pre_i << 2) | 0; + var $F5_0_i = $580; + var $_pre_phi_i25 = $_pre_i24; + } else { + var $_sum17_i = $578 + 2 | 0; + var $588 = __gm_ + 40 + ($_sum17_i << 2) | 0; + var $589 = HEAP32[$588 >> 2]; + var $590 = $589; + var $591 = HEAP32[(__gm_ + 16 | 0) >> 2]; + var $592 = $590 >>> 0 < $591 >>> 0; + if (!$592) { + var $F5_0_i = $589; + var $_pre_phi_i25 = $588; + break; + } + _abort(); + } + } while (0); + var $_pre_phi_i25; + var $F5_0_i; + HEAP32[$_pre_phi_i25 >> 2] = $461; + var $595 = $F5_0_i + 12 | 0; + HEAP32[$595 >> 2] = $461; + var $_sum15_i = $342 + 8 | 0; + var $596 = $456 + $_sum15_i | 0; + var $597 = $596; + HEAP32[$597 >> 2] = $F5_0_i; + var $_sum16_i = $342 + 12 | 0; + var $598 = $456 + $_sum16_i | 0; + var $599 = $598; + HEAP32[$599 >> 2] = $580; + } else { + var $601 = $460; + var $602 = $rsize_3_lcssa_i >>> 8; + var $603 = ($602 | 0) == 0; + do { + if ($603) { + var $I7_0_i = 0; + } else { + var $605 = $rsize_3_lcssa_i >>> 0 > 16777215; + if ($605) { + var $I7_0_i = 31; + break; } - var $197 = $v_0_i + 24 | 0; - var $198 = HEAP32[$197 >> 2]; - var $199 = $v_0_i + 12 | 0; - var $200 = HEAP32[$199 >> 2]; - var $201 = ($200 | 0) == ($v_0_i | 0); - do { - if ($201) { - var $212 = $v_0_i + 20 | 0; - var $213 = HEAP32[$212 >> 2]; - var $214 = ($213 | 0) == 0; - if ($214) { - var $216 = $v_0_i + 16 | 0; - var $217 = HEAP32[$216 >> 2]; - var $218 = ($217 | 0) == 0; - if ($218) { - var $R_1_i = 0; - break; - } - var $RP_0_i = $216; - var $R_0_i = $217; - } else { - var $RP_0_i = $212; - var $R_0_i = $213; - __label__ = 39; - } - while (1) { - var $R_0_i; - var $RP_0_i; - var $219 = $R_0_i + 20 | 0; - var $220 = HEAP32[$219 >> 2]; - var $221 = ($220 | 0) == 0; - if (!$221) { - var $RP_0_i = $219; - var $R_0_i = $220; - continue; - } - var $223 = $R_0_i + 16 | 0; - var $224 = HEAP32[$223 >> 2]; - var $225 = ($224 | 0) == 0; - if ($225) { - break; - } - var $RP_0_i = $223; - var $R_0_i = $224; - } - var $227 = $RP_0_i; - var $228 = $227 >>> 0 < $190 >>> 0; - if ($228) { - _abort(); - } else { - HEAP32[$RP_0_i >> 2] = 0; - var $R_1_i = $R_0_i; - } - } else { - var $203 = $v_0_i + 8 | 0; - var $204 = HEAP32[$203 >> 2]; - var $205 = $204; - var $206 = $205 >>> 0 < $190 >>> 0; - if ($206) { - _abort(); - } else { - var $208 = $204 + 12 | 0; - HEAP32[$208 >> 2] = $200; - var $209 = $200 + 8 | 0; - HEAP32[$209 >> 2] = $204; - var $R_1_i = $200; - } - } - } while (0); - var $R_1_i; - var $232 = ($198 | 0) == 0; - $_$62 : do { - if (!$232) { - var $234 = $v_0_i + 28 | 0; - var $235 = HEAP32[$234 >> 2]; - var $236 = __gm_ + 304 + ($235 << 2) | 0; - var $237 = HEAP32[$236 >> 2]; - var $238 = ($v_0_i | 0) == ($237 | 0); - do { - if ($238) { - HEAP32[$236 >> 2] = $R_1_i; - var $cond_i = ($R_1_i | 0) == 0; - if (!$cond_i) { - break; - } - var $240 = HEAP32[$234 >> 2]; - var $241 = 1 << $240; - var $242 = $241 ^ -1; - var $243 = HEAP32[(__gm_ + 4 | 0) >> 2]; - var $244 = $243 & $242; - HEAP32[(__gm_ + 4 | 0) >> 2] = $244; - break $_$62; - } - var $246 = $198; - var $247 = HEAP32[(__gm_ + 16 | 0) >> 2]; - var $248 = $246 >>> 0 < $247 >>> 0; - if ($248) { - _abort(); - } else { - var $250 = $198 + 16 | 0; - var $251 = HEAP32[$250 >> 2]; - var $252 = ($251 | 0) == ($v_0_i | 0); - if ($252) { - HEAP32[$250 >> 2] = $R_1_i; - } else { - var $255 = $198 + 20 | 0; - HEAP32[$255 >> 2] = $R_1_i; - } - var $258 = ($R_1_i | 0) == 0; - if ($258) { - break $_$62; - } - } - } while (0); - var $260 = $R_1_i; - var $261 = HEAP32[(__gm_ + 16 | 0) >> 2]; - var $262 = $260 >>> 0 < $261 >>> 0; - if ($262) { - _abort(); - } else { - var $264 = $R_1_i + 24 | 0; - HEAP32[$264 >> 2] = $198; - var $265 = $v_0_i + 16 | 0; - var $266 = HEAP32[$265 >> 2]; - var $267 = ($266 | 0) == 0; - if (!$267) { - var $269 = $266; - var $270 = HEAP32[(__gm_ + 16 | 0) >> 2]; - var $271 = $269 >>> 0 < $270 >>> 0; - if ($271) { - _abort(); - } else { - var $273 = $R_1_i + 16 | 0; - HEAP32[$273 >> 2] = $266; - var $274 = $266 + 24 | 0; - HEAP32[$274 >> 2] = $R_1_i; - } - } - var $277 = $v_0_i + 20 | 0; - var $278 = HEAP32[$277 >> 2]; - var $279 = ($278 | 0) == 0; - if ($279) { - break; - } - var $281 = $278; - var $282 = HEAP32[(__gm_ + 16 | 0) >> 2]; - var $283 = $281 >>> 0 < $282 >>> 0; - if ($283) { - _abort(); - } else { - var $285 = $R_1_i + 20 | 0; - HEAP32[$285 >> 2] = $278; - var $286 = $278 + 24 | 0; - HEAP32[$286 >> 2] = $R_1_i; - } - } + var $607 = $602 + 1048320 | 0; + var $608 = $607 >>> 16; + var $609 = $608 & 8; + var $610 = $602 << $609; + var $611 = $610 + 520192 | 0; + var $612 = $611 >>> 16; + var $613 = $612 & 4; + var $614 = $610 << $613; + var $615 = $614 + 245760 | 0; + var $616 = $615 >>> 16; + var $617 = $616 & 2; + var $618 = $613 | $609; + var $619 = $618 | $617; + var $620 = 14 - $619 | 0; + var $621 = $614 << $617; + var $622 = $621 >>> 15; + var $623 = $620 + $622 | 0; + var $624 = $623 << 1; + var $625 = $623 + 7 | 0; + var $626 = $rsize_3_lcssa_i >>> ($625 >>> 0); + var $627 = $626 & 1; + var $628 = $627 | $624; + var $I7_0_i = $628; + } + } while (0); + var $I7_0_i; + var $630 = __gm_ + 304 + ($I7_0_i << 2) | 0; + var $_sum2_i = $342 + 28 | 0; + var $631 = $456 + $_sum2_i | 0; + var $632 = $631; + HEAP32[$632 >> 2] = $I7_0_i; + var $_sum3_i26 = $342 + 16 | 0; + var $633 = $456 + $_sum3_i26 | 0; + var $_sum4_i27 = $342 + 20 | 0; + var $634 = $456 + $_sum4_i27 | 0; + var $635 = $634; + HEAP32[$635 >> 2] = 0; + var $636 = $633; + HEAP32[$636 >> 2] = 0; + var $637 = HEAP32[(__gm_ + 4 | 0) >> 2]; + var $638 = 1 << $I7_0_i; + var $639 = $637 & $638; + var $640 = ($639 | 0) == 0; + if ($640) { + var $642 = $637 | $638; + HEAP32[(__gm_ + 4 | 0) >> 2] = $642; + HEAP32[$630 >> 2] = $601; + var $643 = $630; + var $_sum5_i = $342 + 24 | 0; + var $644 = $456 + $_sum5_i | 0; + var $645 = $644; + HEAP32[$645 >> 2] = $643; + var $_sum6_i = $342 + 12 | 0; + var $646 = $456 + $_sum6_i | 0; + var $647 = $646; + HEAP32[$647 >> 2] = $601; + var $_sum7_i = $342 + 8 | 0; + var $648 = $456 + $_sum7_i | 0; + var $649 = $648; + HEAP32[$649 >> 2] = $601; + } else { + var $651 = HEAP32[$630 >> 2]; + var $652 = ($I7_0_i | 0) == 31; + if ($652) { + var $657 = 0; + } else { + var $654 = $I7_0_i >>> 1; + var $655 = 25 - $654 | 0; + var $657 = $655; + } + var $657; + var $658 = $rsize_3_lcssa_i << $657; + var $K12_0_i = $658; + var $T_0_i = $651; + while (1) { + var $T_0_i; + var $K12_0_i; + var $660 = $T_0_i + 4 | 0; + var $661 = HEAP32[$660 >> 2]; + var $662 = $661 & -8; + var $663 = ($662 | 0) == ($rsize_3_lcssa_i | 0); + if ($663) { + var $683 = $T_0_i + 8 | 0; + var $684 = HEAP32[$683 >> 2]; + var $685 = $T_0_i; + var $686 = HEAP32[(__gm_ + 16 | 0) >> 2]; + var $687 = $685 >>> 0 < $686 >>> 0; + do { + if (!$687) { + var $689 = $684; + var $690 = $689 >>> 0 < $686 >>> 0; + if ($690) { + break; + } + var $692 = $684 + 12 | 0; + HEAP32[$692 >> 2] = $601; + HEAP32[$683 >> 2] = $601; + var $_sum8_i = $342 + 8 | 0; + var $693 = $456 + $_sum8_i | 0; + var $694 = $693; + HEAP32[$694 >> 2] = $684; + var $_sum9_i = $342 + 12 | 0; + var $695 = $456 + $_sum9_i | 0; + var $696 = $695; + HEAP32[$696 >> 2] = $T_0_i; + var $_sum10_i = $342 + 24 | 0; + var $697 = $456 + $_sum10_i | 0; + var $698 = $697; + HEAP32[$698 >> 2] = 0; + break $_$179; } - } while (0); - var $290 = $rsize_0_i >>> 0 < 16; - if ($290) { - var $292 = $rsize_0_i + $8 | 0; - var $293 = $292 | 3; - var $294 = $v_0_i + 4 | 0; - HEAP32[$294 >> 2] = $293; - var $_sum4_i = $292 + 4 | 0; - var $295 = $189 + $_sum4_i | 0; - var $296 = $295; - var $297 = HEAP32[$296 >> 2]; - var $298 = $297 | 1; - HEAP32[$296 >> 2] = $298; + } while (0); + _abort(); } else { - var $300 = $8 | 3; - var $301 = $v_0_i + 4 | 0; - HEAP32[$301 >> 2] = $300; - var $302 = $rsize_0_i | 1; - var $_sum_i33 = $8 | 4; - var $303 = $189 + $_sum_i33 | 0; - var $304 = $303; - HEAP32[$304 >> 2] = $302; - var $_sum1_i = $rsize_0_i + $8 | 0; - var $305 = $189 + $_sum1_i | 0; - var $306 = $305; - HEAP32[$306 >> 2] = $rsize_0_i; - var $307 = HEAP32[(__gm_ + 8 | 0) >> 2]; - var $308 = ($307 | 0) == 0; - if (!$308) { - var $310 = HEAP32[(__gm_ + 20 | 0) >> 2]; - var $311 = $307 >>> 3; - var $312 = $307 >>> 2; - var $313 = $312 & 1073741822; - var $314 = __gm_ + 40 + ($313 << 2) | 0; - var $315 = $314; - var $316 = HEAP32[(__gm_ | 0) >> 2]; - var $317 = 1 << $311; - var $318 = $316 & $317; - var $319 = ($318 | 0) == 0; - do { - if ($319) { - var $321 = $316 | $317; - HEAP32[(__gm_ | 0) >> 2] = $321; - var $_sum2_pre_i = $313 + 2 | 0; - var $_pre_i = __gm_ + 40 + ($_sum2_pre_i << 2) | 0; - var $F1_0_i = $315; - var $_pre_phi_i = $_pre_i; - } else { - var $_sum3_i = $313 + 2 | 0; - var $323 = __gm_ + 40 + ($_sum3_i << 2) | 0; - var $324 = HEAP32[$323 >> 2]; - var $325 = $324; - var $326 = HEAP32[(__gm_ + 16 | 0) >> 2]; - var $327 = $325 >>> 0 < $326 >>> 0; - if (!$327) { - var $F1_0_i = $324; - var $_pre_phi_i = $323; - break; - } - _abort(); - } - } while (0); - var $_pre_phi_i; - var $F1_0_i; - HEAP32[$_pre_phi_i >> 2] = $310; - var $330 = $F1_0_i + 12 | 0; - HEAP32[$330 >> 2] = $310; - var $331 = $310 + 8 | 0; - HEAP32[$331 >> 2] = $F1_0_i; - var $332 = $310 + 12 | 0; - HEAP32[$332 >> 2] = $315; - } - HEAP32[(__gm_ + 8 | 0) >> 2] = $rsize_0_i; - HEAP32[(__gm_ + 20 | 0) >> 2] = $194; - } - var $335 = $v_0_i + 8 | 0; - var $336 = $335; - var $337 = ($335 | 0) == 0; - if ($337) { - var $nb_0 = $8; - __label__ = 155; - break $_$2; + var $665 = $K12_0_i >>> 31; + var $666 = $T_0_i + 16 + ($665 << 2) | 0; + var $667 = HEAP32[$666 >> 2]; + var $668 = ($667 | 0) == 0; + var $669 = $K12_0_i << 1; + if (!$668) { + var $K12_0_i = $669; + var $T_0_i = $667; + continue; + } + var $671 = $666; + var $672 = HEAP32[(__gm_ + 16 | 0) >> 2]; + var $673 = $671 >>> 0 < $672 >>> 0; + if (!$673) { + HEAP32[$666 >> 2] = $601; + var $_sum11_i = $342 + 24 | 0; + var $675 = $456 + $_sum11_i | 0; + var $676 = $675; + HEAP32[$676 >> 2] = $T_0_i; + var $_sum12_i = $342 + 12 | 0; + var $677 = $456 + $_sum12_i | 0; + var $678 = $677; + HEAP32[$678 >> 2] = $601; + var $_sum13_i = $342 + 8 | 0; + var $679 = $456 + $_sum13_i | 0; + var $680 = $679; + HEAP32[$680 >> 2] = $601; + break $_$179; + } + _abort(); } - var $mem_0 = $336; - __label__ = 331; - break $_$2; + } } - } while (0); - _abort(); - } else { - var $339 = $bytes >>> 0 > 4294967231; - if ($339) { - var $nb_0 = -1; - __label__ = 155; - break; + } } - var $341 = $bytes + 11 | 0; - var $342 = $341 & -8; - var $343 = HEAP32[(__gm_ + 4 | 0) >> 2]; - var $344 = ($343 | 0) == 0; - if ($344) { - var $nb_0 = $342; - __label__ = 155; + } while (0); + var $700 = $v_3_lcssa_i + 8 | 0; + var $701 = $700; + var $702 = ($700 | 0) == 0; + if ($702) { + var $nb_0 = $342; + __label__ = 155; + break $_$2; + } + var $mem_0 = $701; + __label__ = 331; + break $_$2; + } + } while (0); + _abort(); + } + } while (0); + $_$215 : do { + if (__label__ == 155) { + var $nb_0; + var $703 = HEAP32[(__gm_ + 8 | 0) >> 2]; + var $704 = $nb_0 >>> 0 > $703 >>> 0; + if ($704) { + var $732 = HEAP32[(__gm_ + 12 | 0) >> 2]; + var $733 = $nb_0 >>> 0 < $732 >>> 0; + if ($733) { + var $735 = $732 - $nb_0 | 0; + HEAP32[(__gm_ + 12 | 0) >> 2] = $735; + var $736 = HEAP32[(__gm_ + 24 | 0) >> 2]; + var $737 = $736; + var $738 = $737 + $nb_0 | 0; + var $739 = $738; + HEAP32[(__gm_ + 24 | 0) >> 2] = $739; + var $740 = $735 | 1; + var $_sum = $nb_0 + 4 | 0; + var $741 = $737 + $_sum | 0; + var $742 = $741; + HEAP32[$742 >> 2] = $740; + var $743 = $nb_0 | 3; + var $744 = $736 + 4 | 0; + HEAP32[$744 >> 2] = $743; + var $745 = $736 + 8 | 0; + var $746 = $745; + var $mem_0 = $746; + } else { + var $748 = HEAP32[(_mparams | 0) >> 2]; + var $749 = ($748 | 0) == 0; + do { + if ($749) { + var $751 = HEAP32[(_mparams | 0) >> 2]; + var $752 = ($751 | 0) == 0; + if (!$752) { break; + } + var $754 = _sysconf(8); + var $755 = $754 - 1 | 0; + var $756 = $755 & $754; + var $757 = ($756 | 0) == 0; + if ($757) { + HEAP32[(_mparams + 8 | 0) >> 2] = $754; + HEAP32[(_mparams + 4 | 0) >> 2] = $754; + HEAP32[(_mparams + 12 | 0) >> 2] = -1; + HEAP32[(_mparams + 16 | 0) >> 2] = 2097152; + HEAP32[(_mparams + 20 | 0) >> 2] = 0; + HEAP32[(__gm_ + 440 | 0) >> 2] = 0; + var $760 = _time(0); + var $761 = $760 & -16; + var $762 = $761 ^ 1431655768; + HEAP32[(_mparams | 0) >> 2] = $762; + } else { + _abort(); + } } - var $346 = -$342 | 0; - var $347 = $341 >>> 8; - var $348 = ($347 | 0) == 0; - do { - if ($348) { - var $idx_0_i = 0; - } else { - var $350 = $342 >>> 0 > 16777215; - if ($350) { - var $idx_0_i = 31; + } while (0); + var $763 = HEAP32[(__gm_ + 440 | 0) >> 2]; + var $764 = $763 & 4; + var $765 = ($764 | 0) == 0; + $_$234 : do { + if ($765) { + var $767 = HEAP32[(__gm_ + 24 | 0) >> 2]; + var $768 = ($767 | 0) == 0; + $_$236 : do { + if (!$768) { + var $770 = $767; + var $sp_0_i_i = __gm_ + 444 | 0; + while (1) { + var $sp_0_i_i; + var $772 = $sp_0_i_i | 0; + var $773 = HEAP32[$772 >> 2]; + var $774 = $773 >>> 0 > $770 >>> 0; + if (!$774) { + var $776 = $sp_0_i_i + 4 | 0; + var $777 = HEAP32[$776 >> 2]; + var $778 = $773 + $777 | 0; + var $779 = $778 >>> 0 > $770 >>> 0; + if ($779) { break; + } } - var $352 = $347 + 1048320 | 0; - var $353 = $352 >>> 16; - var $354 = $353 & 8; - var $355 = $347 << $354; - var $356 = $355 + 520192 | 0; - var $357 = $356 >>> 16; - var $358 = $357 & 4; - var $359 = $355 << $358; - var $360 = $359 + 245760 | 0; - var $361 = $360 >>> 16; - var $362 = $361 & 2; - var $363 = $358 | $354; - var $364 = $363 | $362; - var $365 = 14 - $364 | 0; - var $366 = $359 << $362; - var $367 = $366 >>> 15; - var $368 = $365 + $367 | 0; - var $369 = $368 << 1; - var $370 = $368 + 7 | 0; - var $371 = $342 >>> ($370 >>> 0); - var $372 = $371 & 1; - var $373 = $372 | $369; - var $idx_0_i = $373; - } - } while (0); - var $idx_0_i; - var $375 = __gm_ + 304 + ($idx_0_i << 2) | 0; - var $376 = HEAP32[$375 >> 2]; - var $377 = ($376 | 0) == 0; - $_$110 : do { - if ($377) { - var $v_2_i = 0; - var $rsize_2_i = $346; - var $t_1_i = 0; - } else { - var $379 = ($idx_0_i | 0) == 31; - if ($379) { - var $384 = 0; - } else { - var $381 = $idx_0_i >>> 1; - var $382 = 25 - $381 | 0; - var $384 = $382; - } - var $384; - var $385 = $342 << $384; - var $v_0_i15 = 0; - var $rsize_0_i14 = $346; - var $t_0_i13 = $376; - var $sizebits_0_i = $385; - var $rst_0_i = 0; - while (1) { - var $rst_0_i; - var $sizebits_0_i; - var $t_0_i13; - var $rsize_0_i14; - var $v_0_i15; - var $387 = $t_0_i13 + 4 | 0; - var $388 = HEAP32[$387 >> 2]; - var $389 = $388 & -8; - var $390 = $389 - $342 | 0; - var $391 = $390 >>> 0 < $rsize_0_i14 >>> 0; - if ($391) { - var $393 = ($389 | 0) == ($342 | 0); - if ($393) { - var $v_2_i = $t_0_i13; - var $rsize_2_i = $390; - var $t_1_i = $t_0_i13; - break $_$110; - } - var $v_1_i = $t_0_i13; - var $rsize_1_i = $390; - } else { - var $v_1_i = $v_0_i15; - var $rsize_1_i = $rsize_0_i14; - } - var $rsize_1_i; - var $v_1_i; - var $395 = $t_0_i13 + 20 | 0; - var $396 = HEAP32[$395 >> 2]; - var $397 = $sizebits_0_i >>> 31; - var $398 = $t_0_i13 + 16 + ($397 << 2) | 0; - var $399 = HEAP32[$398 >> 2]; - var $400 = ($396 | 0) == 0; - var $401 = ($396 | 0) == ($399 | 0); - var $or_cond_i = $400 | $401; - var $rst_1_i = $or_cond_i ? $rst_0_i : $396; - var $402 = ($399 | 0) == 0; - var $403 = $sizebits_0_i << 1; - if ($402) { - var $v_2_i = $v_1_i; - var $rsize_2_i = $rsize_1_i; - var $t_1_i = $rst_1_i; - break $_$110; - } - var $v_0_i15 = $v_1_i; - var $rsize_0_i14 = $rsize_1_i; - var $t_0_i13 = $399; - var $sizebits_0_i = $403; - var $rst_0_i = $rst_1_i; + var $781 = $sp_0_i_i + 8 | 0; + var $782 = HEAP32[$781 >> 2]; + var $783 = ($782 | 0) == 0; + if ($783) { + __label__ = 174; + break $_$236; } + var $sp_0_i_i = $782; + } + var $784 = ($sp_0_i_i | 0) == 0; + if ($784) { + __label__ = 174; + break; + } + var $810 = HEAP32[(__gm_ + 12 | 0) >> 2]; + var $811 = HEAP32[(_mparams + 8 | 0) >> 2]; + var $812 = $nb_0 + 47 | 0; + var $813 = $812 - $810 | 0; + var $814 = $813 + $811 | 0; + var $815 = -$811 | 0; + var $816 = $814 & $815; + var $817 = $816 >>> 0 < 2147483647; + if (!$817) { + var $tsize_0242932_ph_i = 0; + __label__ = 189; + break; + } + var $819 = _sbrk($816); + var $820 = HEAP32[$772 >> 2]; + var $821 = HEAP32[$776 >> 2]; + var $822 = $820 + $821 | 0; + var $823 = ($819 | 0) == ($822 | 0); + var $_1_i = $823 ? $816 : 0; + var $_2_i = $823 ? $819 : -1; + var $tbase_0_i = $_2_i; + var $tsize_0_i = $_1_i; + var $asize_1_i = $816; + var $br_0_i = $819; + __label__ = 181; + break; } - } while (0); - var $t_1_i; - var $rsize_2_i; - var $v_2_i; - var $404 = ($t_1_i | 0) == 0; - var $405 = ($v_2_i | 0) == 0; - var $or_cond19_i = $404 & $405; - if ($or_cond19_i) { - var $407 = 2 << $idx_0_i; - var $408 = -$407 | 0; - var $409 = $407 | $408; - var $410 = $343 & $409; - var $411 = ($410 | 0) == 0; - if ($411) { - var $nb_0 = $342; - __label__ = 155; + __label__ = 174; + } while (0); + do { + if (__label__ == 174) { + var $785 = _sbrk(0); + var $786 = ($785 | 0) == -1; + if ($786) { + var $tsize_0242932_ph_i = 0; + __label__ = 189; break; + } + var $788 = HEAP32[(_mparams + 8 | 0) >> 2]; + var $789 = $nb_0 + 47 | 0; + var $790 = $789 + $788 | 0; + var $791 = -$788 | 0; + var $792 = $790 & $791; + var $793 = $785; + var $794 = HEAP32[(_mparams + 4 | 0) >> 2]; + var $795 = $794 - 1 | 0; + var $796 = $795 & $793; + var $797 = ($796 | 0) == 0; + if ($797) { + var $asize_0_i = $792; + } else { + var $799 = $795 + $793 | 0; + var $800 = -$794 | 0; + var $801 = $799 & $800; + var $802 = $792 - $793 | 0; + var $803 = $802 + $801 | 0; + var $asize_0_i = $803; + } + var $asize_0_i; + var $805 = $asize_0_i >>> 0 < 2147483647; + if (!$805) { + var $tsize_0242932_ph_i = 0; + __label__ = 189; + break; + } + var $807 = _sbrk($asize_0_i); + var $808 = ($807 | 0) == ($785 | 0); + var $asize_0__i = $808 ? $asize_0_i : 0; + var $__i = $808 ? $785 : -1; + var $tbase_0_i = $__i; + var $tsize_0_i = $asize_0__i; + var $asize_1_i = $asize_0_i; + var $br_0_i = $807; + __label__ = 181; + break; } - var $413 = -$410 | 0; - var $414 = $410 & $413; - var $415 = $414 - 1 | 0; - var $416 = $415 >>> 12; - var $417 = $416 & 16; - var $418 = $415 >>> ($417 >>> 0); - var $419 = $418 >>> 5; - var $420 = $419 & 8; - var $421 = $418 >>> ($420 >>> 0); - var $422 = $421 >>> 2; - var $423 = $422 & 4; - var $424 = $421 >>> ($423 >>> 0); - var $425 = $424 >>> 1; - var $426 = $425 & 2; - var $427 = $424 >>> ($426 >>> 0); - var $428 = $427 >>> 1; - var $429 = $428 & 1; - var $430 = $420 | $417; - var $431 = $430 | $423; - var $432 = $431 | $426; - var $433 = $432 | $429; - var $434 = $427 >>> ($429 >>> 0); - var $435 = $433 + $434 | 0; - var $436 = __gm_ + 304 + ($435 << 2) | 0; - var $437 = HEAP32[$436 >> 2]; - var $t_2_ph_i = $437; - } else { - var $t_2_ph_i = $t_1_i; - } - var $t_2_ph_i; - var $438 = ($t_2_ph_i | 0) == 0; - $_$125 : do { - if ($438) { - var $rsize_3_lcssa_i = $rsize_2_i; - var $v_3_lcssa_i = $v_2_i; - } else { - var $t_224_i = $t_2_ph_i; - var $rsize_325_i = $rsize_2_i; - var $v_326_i = $v_2_i; - while (1) { - var $v_326_i; - var $rsize_325_i; - var $t_224_i; - var $439 = $t_224_i + 4 | 0; - var $440 = HEAP32[$439 >> 2]; - var $441 = $440 & -8; - var $442 = $441 - $342 | 0; - var $443 = $442 >>> 0 < $rsize_325_i >>> 0; - var $_rsize_3_i = $443 ? $442 : $rsize_325_i; - var $t_2_v_3_i = $443 ? $t_224_i : $v_326_i; - var $444 = $t_224_i + 16 | 0; - var $445 = HEAP32[$444 >> 2]; - var $446 = ($445 | 0) == 0; - if (!$446) { - var $t_224_i = $445; - var $rsize_325_i = $_rsize_3_i; - var $v_326_i = $t_2_v_3_i; - continue; - } - var $447 = $t_224_i + 20 | 0; - var $448 = HEAP32[$447 >> 2]; - var $449 = ($448 | 0) == 0; - if ($449) { - var $rsize_3_lcssa_i = $_rsize_3_i; - var $v_3_lcssa_i = $t_2_v_3_i; - break $_$125; - } - var $t_224_i = $448; - var $rsize_325_i = $_rsize_3_i; - var $v_326_i = $t_2_v_3_i; + } while (0); + $_$253 : do { + if (__label__ == 181) { + var $br_0_i; + var $asize_1_i; + var $tsize_0_i; + var $tbase_0_i; + var $825 = -$asize_1_i | 0; + var $826 = ($tbase_0_i | 0) == -1; + if (!$826) { + var $tsize_242_i = $tsize_0_i; + var $tbase_243_i = $tbase_0_i; + __label__ = 194; + break $_$234; + } + var $828 = ($br_0_i | 0) != -1; + var $829 = $asize_1_i >>> 0 < 2147483647; + var $or_cond_i28 = $828 & $829; + do { + if ($or_cond_i28) { + var $831 = $nb_0 + 48 | 0; + var $832 = $asize_1_i >>> 0 < $831 >>> 0; + if (!$832) { + var $asize_2_i = $asize_1_i; + break; + } + var $834 = HEAP32[(_mparams + 8 | 0) >> 2]; + var $835 = $nb_0 + 47 | 0; + var $836 = $835 - $asize_1_i | 0; + var $837 = $836 + $834 | 0; + var $838 = -$834 | 0; + var $839 = $837 & $838; + var $840 = $839 >>> 0 < 2147483647; + if (!$840) { + var $asize_2_i = $asize_1_i; + break; + } + var $842 = _sbrk($839); + var $843 = ($842 | 0) == -1; + if ($843) { + var $847 = _sbrk($825); + var $tsize_0242932_ph_i = $tsize_0_i; + break $_$253; + } + var $845 = $839 + $asize_1_i | 0; + var $asize_2_i = $845; + } else { + var $asize_2_i = $asize_1_i; } + } while (0); + var $asize_2_i; + var $849 = ($br_0_i | 0) == -1; + if (!$849) { + var $tsize_242_i = $asize_2_i; + var $tbase_243_i = $br_0_i; + __label__ = 194; + break $_$234; + } + var $852 = HEAP32[(__gm_ + 440 | 0) >> 2]; + var $853 = $852 | 4; + HEAP32[(__gm_ + 440 | 0) >> 2] = $853; + var $tsize_137_i = $tsize_0_i; + __label__ = 191; + break $_$234; } - } while (0); - var $v_3_lcssa_i; - var $rsize_3_lcssa_i; - var $450 = ($v_3_lcssa_i | 0) == 0; - if ($450) { - var $nb_0 = $342; - __label__ = 155; - break; + } while (0); + var $tsize_0242932_ph_i; + var $850 = HEAP32[(__gm_ + 440 | 0) >> 2]; + var $851 = $850 | 4; + HEAP32[(__gm_ + 440 | 0) >> 2] = $851; + var $tsize_137_i = $tsize_0242932_ph_i; + __label__ = 191; + break; } - var $452 = HEAP32[(__gm_ + 8 | 0) >> 2]; - var $453 = $452 - $342 | 0; - var $454 = $rsize_3_lcssa_i >>> 0 < $453 >>> 0; - if (!$454) { - var $nb_0 = $342; - __label__ = 155; + var $tsize_137_i = 0; + __label__ = 191; + } while (0); + do { + if (__label__ == 191) { + var $tsize_137_i; + var $854 = HEAP32[(_mparams + 8 | 0) >> 2]; + var $855 = $nb_0 + 47 | 0; + var $856 = $855 + $854 | 0; + var $857 = -$854 | 0; + var $858 = $856 & $857; + var $859 = $858 >>> 0 < 2147483647; + if (!$859) { + __label__ = 330; + break; + } + var $861 = _sbrk($858); + var $862 = _sbrk(0); + var $notlhs_i = ($861 | 0) != -1; + var $notrhs_i = ($862 | 0) != -1; + var $or_cond3_not_i = $notrhs_i & $notlhs_i; + var $863 = $861 >>> 0 < $862 >>> 0; + var $or_cond4_i = $or_cond3_not_i & $863; + if (!$or_cond4_i) { + __label__ = 330; break; + } + var $864 = $862; + var $865 = $861; + var $866 = $864 - $865 | 0; + var $867 = $nb_0 + 40 | 0; + var $868 = $866 >>> 0 > $867 >>> 0; + var $_tsize_1_i = $868 ? $866 : $tsize_137_i; + var $_tbase_1_i = $868 ? $861 : -1; + var $869 = ($_tbase_1_i | 0) == -1; + if ($869) { + __label__ = 330; + break; + } + var $tsize_242_i = $_tsize_1_i; + var $tbase_243_i = $_tbase_1_i; + __label__ = 194; + break; } - var $456 = $v_3_lcssa_i; - var $457 = HEAP32[(__gm_ + 16 | 0) >> 2]; - var $458 = $456 >>> 0 < $457 >>> 0; - do { - if (!$458) { - var $460 = $456 + $342 | 0; - var $461 = $460; - var $462 = $456 >>> 0 < $460 >>> 0; - if (!$462) { + } while (0); + do { + if (__label__ == 194) { + var $tbase_243_i; + var $tsize_242_i; + var $870 = HEAP32[(__gm_ + 432 | 0) >> 2]; + var $871 = $870 + $tsize_242_i | 0; + HEAP32[(__gm_ + 432 | 0) >> 2] = $871; + var $872 = HEAP32[(__gm_ + 436 | 0) >> 2]; + var $873 = $871 >>> 0 > $872 >>> 0; + if ($873) { + HEAP32[(__gm_ + 436 | 0) >> 2] = $871; + } + var $876 = HEAP32[(__gm_ + 24 | 0) >> 2]; + var $877 = ($876 | 0) == 0; + $_$275 : do { + if ($877) { + var $879 = HEAP32[(__gm_ + 16 | 0) >> 2]; + var $880 = ($879 | 0) == 0; + var $881 = $tbase_243_i >>> 0 < $879 >>> 0; + var $or_cond5_i = $880 | $881; + if ($or_cond5_i) { + HEAP32[(__gm_ + 16 | 0) >> 2] = $tbase_243_i; + } + HEAP32[(__gm_ + 444 | 0) >> 2] = $tbase_243_i; + HEAP32[(__gm_ + 448 | 0) >> 2] = $tsize_242_i; + HEAP32[(__gm_ + 456 | 0) >> 2] = 0; + var $884 = HEAP32[(_mparams | 0) >> 2]; + HEAP32[(__gm_ + 36 | 0) >> 2] = $884; + HEAP32[(__gm_ + 32 | 0) >> 2] = -1; + var $i_02_i_i = 0; + while (1) { + var $i_02_i_i; + var $886 = $i_02_i_i << 1; + var $887 = __gm_ + 40 + ($886 << 2) | 0; + var $888 = $887; + var $_sum_i_i = $886 + 3 | 0; + var $889 = __gm_ + 40 + ($_sum_i_i << 2) | 0; + HEAP32[$889 >> 2] = $888; + var $_sum1_i_i = $886 + 2 | 0; + var $890 = __gm_ + 40 + ($_sum1_i_i << 2) | 0; + HEAP32[$890 >> 2] = $888; + var $891 = $i_02_i_i + 1 | 0; + var $exitcond_i_i = ($891 | 0) == 32; + if ($exitcond_i_i) { + break; + } + var $i_02_i_i = $891; + } + var $892 = $tbase_243_i + 8 | 0; + var $893 = $892; + var $894 = $893 & 7; + var $895 = ($894 | 0) == 0; + if ($895) { + var $899 = 0; + } else { + var $897 = -$893 | 0; + var $898 = $897 & 7; + var $899 = $898; + } + var $899; + var $900 = $tbase_243_i + $899 | 0; + var $901 = $900; + var $902 = $tsize_242_i - 40 | 0; + var $903 = $902 - $899 | 0; + HEAP32[(__gm_ + 24 | 0) >> 2] = $901; + HEAP32[(__gm_ + 12 | 0) >> 2] = $903; + var $904 = $903 | 1; + var $_sum_i9_i = $899 + 4 | 0; + var $905 = $tbase_243_i + $_sum_i9_i | 0; + var $906 = $905; + HEAP32[$906 >> 2] = $904; + var $_sum2_i_i = $tsize_242_i - 36 | 0; + var $907 = $tbase_243_i + $_sum2_i_i | 0; + var $908 = $907; + HEAP32[$908 >> 2] = 40; + var $909 = HEAP32[(_mparams + 16 | 0) >> 2]; + HEAP32[(__gm_ + 28 | 0) >> 2] = $909; + } else { + var $sp_0_i = __gm_ + 444 | 0; + while (1) { + var $sp_0_i; + var $910 = ($sp_0_i | 0) == 0; + if ($910) { + break; + } + var $912 = $sp_0_i | 0; + var $913 = HEAP32[$912 >> 2]; + var $914 = $sp_0_i + 4 | 0; + var $915 = HEAP32[$914 >> 2]; + var $916 = $913 + $915 | 0; + var $917 = ($tbase_243_i | 0) == ($916 | 0); + if ($917) { + var $921 = $sp_0_i + 12 | 0; + var $922 = HEAP32[$921 >> 2]; + var $923 = $922 & 8; + var $924 = ($923 | 0) == 0; + if (!$924) { + break; + } + var $926 = $876; + var $927 = $926 >>> 0 >= $913 >>> 0; + var $928 = $926 >>> 0 < $tbase_243_i >>> 0; + var $or_cond44_i = $927 & $928; + if (!$or_cond44_i) { break; + } + var $930 = $915 + $tsize_242_i | 0; + HEAP32[$914 >> 2] = $930; + var $931 = HEAP32[(__gm_ + 24 | 0) >> 2]; + var $932 = HEAP32[(__gm_ + 12 | 0) >> 2]; + var $933 = $932 + $tsize_242_i | 0; + var $934 = $931; + var $935 = $931 + 8 | 0; + var $936 = $935; + var $937 = $936 & 7; + var $938 = ($937 | 0) == 0; + if ($938) { + var $942 = 0; + } else { + var $940 = -$936 | 0; + var $941 = $940 & 7; + var $942 = $941; + } + var $942; + var $943 = $934 + $942 | 0; + var $944 = $943; + var $945 = $933 - $942 | 0; + HEAP32[(__gm_ + 24 | 0) >> 2] = $944; + HEAP32[(__gm_ + 12 | 0) >> 2] = $945; + var $946 = $945 | 1; + var $_sum_i13_i = $942 + 4 | 0; + var $947 = $934 + $_sum_i13_i | 0; + var $948 = $947; + HEAP32[$948 >> 2] = $946; + var $_sum2_i14_i = $933 + 4 | 0; + var $949 = $934 + $_sum2_i14_i | 0; + var $950 = $949; + HEAP32[$950 >> 2] = 40; + var $951 = HEAP32[(_mparams + 16 | 0) >> 2]; + HEAP32[(__gm_ + 28 | 0) >> 2] = $951; + break $_$275; } - var $464 = $v_3_lcssa_i + 24 | 0; - var $465 = HEAP32[$464 >> 2]; - var $466 = $v_3_lcssa_i + 12 | 0; - var $467 = HEAP32[$466 >> 2]; - var $468 = ($467 | 0) == ($v_3_lcssa_i | 0); - do { - if ($468) { - var $479 = $v_3_lcssa_i + 20 | 0; - var $480 = HEAP32[$479 >> 2]; - var $481 = ($480 | 0) == 0; - if ($481) { - var $483 = $v_3_lcssa_i + 16 | 0; - var $484 = HEAP32[$483 >> 2]; - var $485 = ($484 | 0) == 0; - if ($485) { - var $R_1_i19 = 0; - break; - } - var $RP_0_i17 = $483; - var $R_0_i16 = $484; - } else { - var $RP_0_i17 = $479; - var $R_0_i16 = $480; - __label__ = 103; - } - while (1) { - var $R_0_i16; - var $RP_0_i17; - var $486 = $R_0_i16 + 20 | 0; - var $487 = HEAP32[$486 >> 2]; - var $488 = ($487 | 0) == 0; - if (!$488) { - var $RP_0_i17 = $486; - var $R_0_i16 = $487; - continue; - } - var $490 = $R_0_i16 + 16 | 0; - var $491 = HEAP32[$490 >> 2]; - var $492 = ($491 | 0) == 0; - if ($492) { - break; - } - var $RP_0_i17 = $490; - var $R_0_i16 = $491; - } - var $494 = $RP_0_i17; - var $495 = $494 >>> 0 < $457 >>> 0; - if ($495) { - _abort(); - } else { - HEAP32[$RP_0_i17 >> 2] = 0; - var $R_1_i19 = $R_0_i16; - } + var $919 = $sp_0_i + 8 | 0; + var $920 = HEAP32[$919 >> 2]; + var $sp_0_i = $920; + } + var $952 = HEAP32[(__gm_ + 16 | 0) >> 2]; + var $953 = $tbase_243_i >>> 0 < $952 >>> 0; + if ($953) { + HEAP32[(__gm_ + 16 | 0) >> 2] = $tbase_243_i; + } + var $955 = $tbase_243_i + $tsize_242_i | 0; + var $sp_1_i = __gm_ + 444 | 0; + while (1) { + var $sp_1_i; + var $957 = ($sp_1_i | 0) == 0; + if ($957) { + __label__ = 293; + break; + } + var $959 = $sp_1_i | 0; + var $960 = HEAP32[$959 >> 2]; + var $961 = ($960 | 0) == ($955 | 0); + if ($961) { + __label__ = 218; + break; + } + var $963 = $sp_1_i + 8 | 0; + var $964 = HEAP32[$963 >> 2]; + var $sp_1_i = $964; + } + do { + if (__label__ == 218) { + var $965 = $sp_1_i + 12 | 0; + var $966 = HEAP32[$965 >> 2]; + var $967 = $966 & 8; + var $968 = ($967 | 0) == 0; + if (!$968) { + break; + } + HEAP32[$959 >> 2] = $tbase_243_i; + var $970 = $sp_1_i + 4 | 0; + var $971 = HEAP32[$970 >> 2]; + var $972 = $971 + $tsize_242_i | 0; + HEAP32[$970 >> 2] = $972; + var $973 = $tbase_243_i + 8 | 0; + var $974 = $973; + var $975 = $974 & 7; + var $976 = ($975 | 0) == 0; + if ($976) { + var $981 = 0; + } else { + var $978 = -$974 | 0; + var $979 = $978 & 7; + var $981 = $979; + } + var $981; + var $982 = $tbase_243_i + $981 | 0; + var $_sum79_i = $tsize_242_i + 8 | 0; + var $983 = $tbase_243_i + $_sum79_i | 0; + var $984 = $983; + var $985 = $984 & 7; + var $986 = ($985 | 0) == 0; + if ($986) { + var $991 = 0; + } else { + var $988 = -$984 | 0; + var $989 = $988 & 7; + var $991 = $989; + } + var $991; + var $_sum80_i = $991 + $tsize_242_i | 0; + var $992 = $tbase_243_i + $_sum80_i | 0; + var $993 = $992; + var $994 = $992; + var $995 = $982; + var $996 = $994 - $995 | 0; + var $_sum_i16_i = $981 + $nb_0 | 0; + var $997 = $tbase_243_i + $_sum_i16_i | 0; + var $998 = $997; + var $999 = $996 - $nb_0 | 0; + var $1000 = $nb_0 | 3; + var $_sum1_i17_i = $981 + 4 | 0; + var $1001 = $tbase_243_i + $_sum1_i17_i | 0; + var $1002 = $1001; + HEAP32[$1002 >> 2] = $1000; + var $1003 = HEAP32[(__gm_ + 24 | 0) >> 2]; + var $1004 = ($993 | 0) == ($1003 | 0); + $_$314 : do { + if ($1004) { + var $1006 = HEAP32[(__gm_ + 12 | 0) >> 2]; + var $1007 = $1006 + $999 | 0; + HEAP32[(__gm_ + 12 | 0) >> 2] = $1007; + HEAP32[(__gm_ + 24 | 0) >> 2] = $998; + var $1008 = $1007 | 1; + var $_sum42_i_i = $_sum_i16_i + 4 | 0; + var $1009 = $tbase_243_i + $_sum42_i_i | 0; + var $1010 = $1009; + HEAP32[$1010 >> 2] = $1008; } else { - var $470 = $v_3_lcssa_i + 8 | 0; - var $471 = HEAP32[$470 >> 2]; - var $472 = $471; - var $473 = $472 >>> 0 < $457 >>> 0; - if ($473) { - _abort(); - } else { - var $475 = $471 + 12 | 0; - HEAP32[$475 >> 2] = $467; - var $476 = $467 + 8 | 0; - HEAP32[$476 >> 2] = $471; - var $R_1_i19 = $467; - } - } - } while (0); - var $R_1_i19; - var $499 = ($465 | 0) == 0; - $_$151 : do { - if (!$499) { - var $501 = $v_3_lcssa_i + 28 | 0; - var $502 = HEAP32[$501 >> 2]; - var $503 = __gm_ + 304 + ($502 << 2) | 0; - var $504 = HEAP32[$503 >> 2]; - var $505 = ($v_3_lcssa_i | 0) == ($504 | 0); - do { - if ($505) { - HEAP32[$503 >> 2] = $R_1_i19; - var $cond_i20 = ($R_1_i19 | 0) == 0; - if (!$cond_i20) { + var $1012 = HEAP32[(__gm_ + 20 | 0) >> 2]; + var $1013 = ($993 | 0) == ($1012 | 0); + if ($1013) { + var $1015 = HEAP32[(__gm_ + 8 | 0) >> 2]; + var $1016 = $1015 + $999 | 0; + HEAP32[(__gm_ + 8 | 0) >> 2] = $1016; + HEAP32[(__gm_ + 20 | 0) >> 2] = $998; + var $1017 = $1016 | 1; + var $_sum40_i_i = $_sum_i16_i + 4 | 0; + var $1018 = $tbase_243_i + $_sum40_i_i | 0; + var $1019 = $1018; + HEAP32[$1019 >> 2] = $1017; + var $_sum41_i_i = $1016 + $_sum_i16_i | 0; + var $1020 = $tbase_243_i + $_sum41_i_i | 0; + var $1021 = $1020; + HEAP32[$1021 >> 2] = $1016; + } else { + var $_sum2_i18_i = $tsize_242_i + 4 | 0; + var $_sum81_i = $_sum2_i18_i + $991 | 0; + var $1023 = $tbase_243_i + $_sum81_i | 0; + var $1024 = $1023; + var $1025 = HEAP32[$1024 >> 2]; + var $1026 = $1025 & 3; + var $1027 = ($1026 | 0) == 1; + if ($1027) { + var $1029 = $1025 & -8; + var $1030 = $1025 >>> 3; + var $1031 = $1025 >>> 0 < 256; + $_$322 : do { + if ($1031) { + var $_sum3738_i_i = $991 | 8; + var $_sum91_i = $_sum3738_i_i + $tsize_242_i | 0; + var $1033 = $tbase_243_i + $_sum91_i | 0; + var $1034 = $1033; + var $1035 = HEAP32[$1034 >> 2]; + var $_sum39_i_i = $tsize_242_i + 12 | 0; + var $_sum92_i = $_sum39_i_i + $991 | 0; + var $1036 = $tbase_243_i + $_sum92_i | 0; + var $1037 = $1036; + var $1038 = HEAP32[$1037 >> 2]; + var $1039 = ($1035 | 0) == ($1038 | 0); + if ($1039) { + var $1041 = 1 << $1030; + var $1042 = $1041 ^ -1; + var $1043 = HEAP32[(__gm_ | 0) >> 2]; + var $1044 = $1043 & $1042; + HEAP32[(__gm_ | 0) >> 2] = $1044; + } else { + var $1046 = $1025 >>> 2; + var $1047 = $1046 & 1073741822; + var $1048 = __gm_ + 40 + ($1047 << 2) | 0; + var $1049 = $1048; + var $1050 = ($1035 | 0) == ($1049 | 0); + do { + if ($1050) { + __label__ = 233; + } else { + var $1052 = $1035; + var $1053 = HEAP32[(__gm_ + 16 | 0) >> 2]; + var $1054 = $1052 >>> 0 < $1053 >>> 0; + if ($1054) { + __label__ = 236; + break; + } + __label__ = 233; break; - } - var $507 = HEAP32[$501 >> 2]; - var $508 = 1 << $507; - var $509 = $508 ^ -1; - var $510 = HEAP32[(__gm_ + 4 | 0) >> 2]; - var $511 = $510 & $509; - HEAP32[(__gm_ + 4 | 0) >> 2] = $511; - break $_$151; - } - var $513 = $465; - var $514 = HEAP32[(__gm_ + 16 | 0) >> 2]; - var $515 = $513 >>> 0 < $514 >>> 0; - if ($515) { + } + } while (0); + do { + if (__label__ == 233) { + var $1056 = ($1038 | 0) == ($1049 | 0); + if (!$1056) { + var $1058 = $1038; + var $1059 = HEAP32[(__gm_ + 16 | 0) >> 2]; + var $1060 = $1058 >>> 0 < $1059 >>> 0; + if ($1060) { + break; + } + } + var $1061 = $1035 + 12 | 0; + HEAP32[$1061 >> 2] = $1038; + var $1062 = $1038 + 8 | 0; + HEAP32[$1062 >> 2] = $1035; + break $_$322; + } + } while (0); _abort(); + } } else { - var $517 = $465 + 16 | 0; - var $518 = HEAP32[$517 >> 2]; - var $519 = ($518 | 0) == ($v_3_lcssa_i | 0); - if ($519) { - HEAP32[$517 >> 2] = $R_1_i19; + var $1064 = $992; + var $_sum34_i_i = $991 | 24; + var $_sum82_i = $_sum34_i_i + $tsize_242_i | 0; + var $1065 = $tbase_243_i + $_sum82_i | 0; + var $1066 = $1065; + var $1067 = HEAP32[$1066 >> 2]; + var $_sum5_i_i = $tsize_242_i + 12 | 0; + var $_sum83_i = $_sum5_i_i + $991 | 0; + var $1068 = $tbase_243_i + $_sum83_i | 0; + var $1069 = $1068; + var $1070 = HEAP32[$1069 >> 2]; + var $1071 = ($1070 | 0) == ($1064 | 0); + do { + if ($1071) { + var $_sum67_i_i = $991 | 16; + var $_sum89_i = $_sum2_i18_i + $_sum67_i_i | 0; + var $1084 = $tbase_243_i + $_sum89_i | 0; + var $1085 = $1084; + var $1086 = HEAP32[$1085 >> 2]; + var $1087 = ($1086 | 0) == 0; + if ($1087) { + var $_sum90_i = $_sum67_i_i + $tsize_242_i | 0; + var $1089 = $tbase_243_i + $_sum90_i | 0; + var $1090 = $1089; + var $1091 = HEAP32[$1090 >> 2]; + var $1092 = ($1091 | 0) == 0; + if ($1092) { + var $R_1_i_i = 0; + break; + } + var $RP_0_i_i = $1090; + var $R_0_i_i = $1091; + } else { + var $RP_0_i_i = $1085; + var $R_0_i_i = $1086; + __label__ = 243; + } + while (1) { + var $R_0_i_i; + var $RP_0_i_i; + var $1093 = $R_0_i_i + 20 | 0; + var $1094 = HEAP32[$1093 >> 2]; + var $1095 = ($1094 | 0) == 0; + if (!$1095) { + var $RP_0_i_i = $1093; + var $R_0_i_i = $1094; + continue; + } + var $1097 = $R_0_i_i + 16 | 0; + var $1098 = HEAP32[$1097 >> 2]; + var $1099 = ($1098 | 0) == 0; + if ($1099) { + break; + } + var $RP_0_i_i = $1097; + var $R_0_i_i = $1098; + } + var $1101 = $RP_0_i_i; + var $1102 = HEAP32[(__gm_ + 16 | 0) >> 2]; + var $1103 = $1101 >>> 0 < $1102 >>> 0; + if ($1103) { + _abort(); + } else { + HEAP32[$RP_0_i_i >> 2] = 0; + var $R_1_i_i = $R_0_i_i; + } } else { - var $522 = $465 + 20 | 0; - HEAP32[$522 >> 2] = $R_1_i19; + var $_sum3536_i_i = $991 | 8; + var $_sum84_i = $_sum3536_i_i + $tsize_242_i | 0; + var $1073 = $tbase_243_i + $_sum84_i | 0; + var $1074 = $1073; + var $1075 = HEAP32[$1074 >> 2]; + var $1076 = $1075; + var $1077 = HEAP32[(__gm_ + 16 | 0) >> 2]; + var $1078 = $1076 >>> 0 < $1077 >>> 0; + if ($1078) { + _abort(); + } else { + var $1080 = $1075 + 12 | 0; + HEAP32[$1080 >> 2] = $1070; + var $1081 = $1070 + 8 | 0; + HEAP32[$1081 >> 2] = $1075; + var $R_1_i_i = $1070; + } } - var $525 = ($R_1_i19 | 0) == 0; - if ($525) { - break $_$151; + } while (0); + var $R_1_i_i; + var $1107 = ($1067 | 0) == 0; + if ($1107) { + break; + } + var $_sum30_i_i = $tsize_242_i + 28 | 0; + var $_sum85_i = $_sum30_i_i + $991 | 0; + var $1109 = $tbase_243_i + $_sum85_i | 0; + var $1110 = $1109; + var $1111 = HEAP32[$1110 >> 2]; + var $1112 = __gm_ + 304 + ($1111 << 2) | 0; + var $1113 = HEAP32[$1112 >> 2]; + var $1114 = ($1064 | 0) == ($1113 | 0); + do { + if ($1114) { + HEAP32[$1112 >> 2] = $R_1_i_i; + var $cond_i_i = ($R_1_i_i | 0) == 0; + if (!$cond_i_i) { + break; + } + var $1116 = HEAP32[$1110 >> 2]; + var $1117 = 1 << $1116; + var $1118 = $1117 ^ -1; + var $1119 = HEAP32[(__gm_ + 4 | 0) >> 2]; + var $1120 = $1119 & $1118; + HEAP32[(__gm_ + 4 | 0) >> 2] = $1120; + break $_$322; } - } - } while (0); - var $527 = $R_1_i19; - var $528 = HEAP32[(__gm_ + 16 | 0) >> 2]; - var $529 = $527 >>> 0 < $528 >>> 0; - if ($529) { - _abort(); - } else { - var $531 = $R_1_i19 + 24 | 0; - HEAP32[$531 >> 2] = $465; - var $532 = $v_3_lcssa_i + 16 | 0; - var $533 = HEAP32[$532 >> 2]; - var $534 = ($533 | 0) == 0; - if (!$534) { - var $536 = $533; - var $537 = HEAP32[(__gm_ + 16 | 0) >> 2]; - var $538 = $536 >>> 0 < $537 >>> 0; - if ($538) { - _abort(); + var $1122 = $1067; + var $1123 = HEAP32[(__gm_ + 16 | 0) >> 2]; + var $1124 = $1122 >>> 0 < $1123 >>> 0; + if ($1124) { + _abort(); } else { - var $540 = $R_1_i19 + 16 | 0; - HEAP32[$540 >> 2] = $533; - var $541 = $533 + 24 | 0; - HEAP32[$541 >> 2] = $R_1_i19; + var $1126 = $1067 + 16 | 0; + var $1127 = HEAP32[$1126 >> 2]; + var $1128 = ($1127 | 0) == ($1064 | 0); + if ($1128) { + HEAP32[$1126 >> 2] = $R_1_i_i; + } else { + var $1131 = $1067 + 20 | 0; + HEAP32[$1131 >> 2] = $R_1_i_i; + } + var $1134 = ($R_1_i_i | 0) == 0; + if ($1134) { + break $_$322; + } } - } - var $544 = $v_3_lcssa_i + 20 | 0; - var $545 = HEAP32[$544 >> 2]; - var $546 = ($545 | 0) == 0; - if ($546) { - break; - } - var $548 = $545; - var $549 = HEAP32[(__gm_ + 16 | 0) >> 2]; - var $550 = $548 >>> 0 < $549 >>> 0; - if ($550) { + } while (0); + var $1136 = $R_1_i_i; + var $1137 = HEAP32[(__gm_ + 16 | 0) >> 2]; + var $1138 = $1136 >>> 0 < $1137 >>> 0; + if ($1138) { _abort(); - } else { - var $552 = $R_1_i19 + 20 | 0; - HEAP32[$552 >> 2] = $545; - var $553 = $545 + 24 | 0; - HEAP32[$553 >> 2] = $R_1_i19; - } - } - } - } while (0); - var $557 = $rsize_3_lcssa_i >>> 0 < 16; - $_$179 : do { - if ($557) { - var $559 = $rsize_3_lcssa_i + $342 | 0; - var $560 = $559 | 3; - var $561 = $v_3_lcssa_i + 4 | 0; - HEAP32[$561 >> 2] = $560; - var $_sum18_i = $559 + 4 | 0; - var $562 = $456 + $_sum18_i | 0; - var $563 = $562; - var $564 = HEAP32[$563 >> 2]; - var $565 = $564 | 1; - HEAP32[$563 >> 2] = $565; - } else { - var $567 = $342 | 3; - var $568 = $v_3_lcssa_i + 4 | 0; - HEAP32[$568 >> 2] = $567; - var $569 = $rsize_3_lcssa_i | 1; - var $_sum_i2232 = $342 | 4; - var $570 = $456 + $_sum_i2232 | 0; - var $571 = $570; - HEAP32[$571 >> 2] = $569; - var $_sum1_i23 = $rsize_3_lcssa_i + $342 | 0; - var $572 = $456 + $_sum1_i23 | 0; - var $573 = $572; - HEAP32[$573 >> 2] = $rsize_3_lcssa_i; - var $574 = $rsize_3_lcssa_i >>> 0 < 256; - if ($574) { - var $576 = $rsize_3_lcssa_i >>> 3; - var $577 = $rsize_3_lcssa_i >>> 2; - var $578 = $577 & 1073741822; - var $579 = __gm_ + 40 + ($578 << 2) | 0; - var $580 = $579; - var $581 = HEAP32[(__gm_ | 0) >> 2]; - var $582 = 1 << $576; - var $583 = $581 & $582; - var $584 = ($583 | 0) == 0; - do { - if ($584) { - var $586 = $581 | $582; - HEAP32[(__gm_ | 0) >> 2] = $586; - var $_sum14_pre_i = $578 + 2 | 0; - var $_pre_i24 = __gm_ + 40 + ($_sum14_pre_i << 2) | 0; - var $F5_0_i = $580; - var $_pre_phi_i25 = $_pre_i24; - } else { - var $_sum17_i = $578 + 2 | 0; - var $588 = __gm_ + 40 + ($_sum17_i << 2) | 0; - var $589 = HEAP32[$588 >> 2]; - var $590 = $589; - var $591 = HEAP32[(__gm_ + 16 | 0) >> 2]; - var $592 = $590 >>> 0 < $591 >>> 0; - if (!$592) { - var $F5_0_i = $589; - var $_pre_phi_i25 = $588; - break; - } + } else { + var $1140 = $R_1_i_i + 24 | 0; + HEAP32[$1140 >> 2] = $1067; + var $_sum3132_i_i = $991 | 16; + var $_sum86_i = $_sum3132_i_i + $tsize_242_i | 0; + var $1141 = $tbase_243_i + $_sum86_i | 0; + var $1142 = $1141; + var $1143 = HEAP32[$1142 >> 2]; + var $1144 = ($1143 | 0) == 0; + if (!$1144) { + var $1146 = $1143; + var $1147 = HEAP32[(__gm_ + 16 | 0) >> 2]; + var $1148 = $1146 >>> 0 < $1147 >>> 0; + if ($1148) { _abort(); + } else { + var $1150 = $R_1_i_i + 16 | 0; + HEAP32[$1150 >> 2] = $1143; + var $1151 = $1143 + 24 | 0; + HEAP32[$1151 >> 2] = $R_1_i_i; + } } - } while (0); - var $_pre_phi_i25; - var $F5_0_i; - HEAP32[$_pre_phi_i25 >> 2] = $461; - var $595 = $F5_0_i + 12 | 0; - HEAP32[$595 >> 2] = $461; - var $_sum15_i = $342 + 8 | 0; - var $596 = $456 + $_sum15_i | 0; - var $597 = $596; - HEAP32[$597 >> 2] = $F5_0_i; - var $_sum16_i = $342 + 12 | 0; - var $598 = $456 + $_sum16_i | 0; - var $599 = $598; - HEAP32[$599 >> 2] = $580; - } else { - var $601 = $460; - var $602 = $rsize_3_lcssa_i >>> 8; - var $603 = ($602 | 0) == 0; - do { - if ($603) { - var $I7_0_i = 0; - } else { - var $605 = $rsize_3_lcssa_i >>> 0 > 16777215; - if ($605) { - var $I7_0_i = 31; - break; - } - var $607 = $602 + 1048320 | 0; - var $608 = $607 >>> 16; - var $609 = $608 & 8; - var $610 = $602 << $609; - var $611 = $610 + 520192 | 0; - var $612 = $611 >>> 16; - var $613 = $612 & 4; - var $614 = $610 << $613; - var $615 = $614 + 245760 | 0; - var $616 = $615 >>> 16; - var $617 = $616 & 2; - var $618 = $613 | $609; - var $619 = $618 | $617; - var $620 = 14 - $619 | 0; - var $621 = $614 << $617; - var $622 = $621 >>> 15; - var $623 = $620 + $622 | 0; - var $624 = $623 << 1; - var $625 = $623 + 7 | 0; - var $626 = $rsize_3_lcssa_i >>> ($625 >>> 0); - var $627 = $626 & 1; - var $628 = $627 | $624; - var $I7_0_i = $628; + var $_sum87_i = $_sum2_i18_i + $_sum3132_i_i | 0; + var $1154 = $tbase_243_i + $_sum87_i | 0; + var $1155 = $1154; + var $1156 = HEAP32[$1155 >> 2]; + var $1157 = ($1156 | 0) == 0; + if ($1157) { + break; } - } while (0); - var $I7_0_i; - var $630 = __gm_ + 304 + ($I7_0_i << 2) | 0; - var $_sum2_i = $342 + 28 | 0; - var $631 = $456 + $_sum2_i | 0; - var $632 = $631; - HEAP32[$632 >> 2] = $I7_0_i; - var $_sum3_i26 = $342 + 16 | 0; - var $633 = $456 + $_sum3_i26 | 0; - var $_sum4_i27 = $342 + 20 | 0; - var $634 = $456 + $_sum4_i27 | 0; - var $635 = $634; - HEAP32[$635 >> 2] = 0; - var $636 = $633; - HEAP32[$636 >> 2] = 0; - var $637 = HEAP32[(__gm_ + 4 | 0) >> 2]; - var $638 = 1 << $I7_0_i; - var $639 = $637 & $638; - var $640 = ($639 | 0) == 0; - if ($640) { - var $642 = $637 | $638; - HEAP32[(__gm_ + 4 | 0) >> 2] = $642; - HEAP32[$630 >> 2] = $601; - var $643 = $630; - var $_sum5_i = $342 + 24 | 0; - var $644 = $456 + $_sum5_i | 0; - var $645 = $644; - HEAP32[$645 >> 2] = $643; - var $_sum6_i = $342 + 12 | 0; - var $646 = $456 + $_sum6_i | 0; - var $647 = $646; - HEAP32[$647 >> 2] = $601; - var $_sum7_i = $342 + 8 | 0; - var $648 = $456 + $_sum7_i | 0; - var $649 = $648; - HEAP32[$649 >> 2] = $601; - } else { - var $651 = HEAP32[$630 >> 2]; - var $652 = ($I7_0_i | 0) == 31; - if ($652) { - var $657 = 0; + var $1159 = $1156; + var $1160 = HEAP32[(__gm_ + 16 | 0) >> 2]; + var $1161 = $1159 >>> 0 < $1160 >>> 0; + if ($1161) { + _abort(); } else { - var $654 = $I7_0_i >>> 1; - var $655 = 25 - $654 | 0; - var $657 = $655; - } - var $657; - var $658 = $rsize_3_lcssa_i << $657; - var $K12_0_i = $658; - var $T_0_i = $651; - while (1) { - var $T_0_i; - var $K12_0_i; - var $660 = $T_0_i + 4 | 0; - var $661 = HEAP32[$660 >> 2]; - var $662 = $661 & -8; - var $663 = ($662 | 0) == ($rsize_3_lcssa_i | 0); - if ($663) { - var $683 = $T_0_i + 8 | 0; - var $684 = HEAP32[$683 >> 2]; - var $685 = $T_0_i; - var $686 = HEAP32[(__gm_ + 16 | 0) >> 2]; - var $687 = $685 >>> 0 < $686 >>> 0; - do { - if (!$687) { - var $689 = $684; - var $690 = $689 >>> 0 < $686 >>> 0; - if ($690) { - break; - } - var $692 = $684 + 12 | 0; - HEAP32[$692 >> 2] = $601; - HEAP32[$683 >> 2] = $601; - var $_sum8_i = $342 + 8 | 0; - var $693 = $456 + $_sum8_i | 0; - var $694 = $693; - HEAP32[$694 >> 2] = $684; - var $_sum9_i = $342 + 12 | 0; - var $695 = $456 + $_sum9_i | 0; - var $696 = $695; - HEAP32[$696 >> 2] = $T_0_i; - var $_sum10_i = $342 + 24 | 0; - var $697 = $456 + $_sum10_i | 0; - var $698 = $697; - HEAP32[$698 >> 2] = 0; - break $_$179; - } - } while (0); - _abort(); - } else { - var $665 = $K12_0_i >>> 31; - var $666 = $T_0_i + 16 + ($665 << 2) | 0; - var $667 = HEAP32[$666 >> 2]; - var $668 = ($667 | 0) == 0; - var $669 = $K12_0_i << 1; - if (!$668) { - var $K12_0_i = $669; - var $T_0_i = $667; - continue; - } - var $671 = $666; - var $672 = HEAP32[(__gm_ + 16 | 0) >> 2]; - var $673 = $671 >>> 0 < $672 >>> 0; - if (!$673) { - HEAP32[$666 >> 2] = $601; - var $_sum11_i = $342 + 24 | 0; - var $675 = $456 + $_sum11_i | 0; - var $676 = $675; - HEAP32[$676 >> 2] = $T_0_i; - var $_sum12_i = $342 + 12 | 0; - var $677 = $456 + $_sum12_i | 0; - var $678 = $677; - HEAP32[$678 >> 2] = $601; - var $_sum13_i = $342 + 8 | 0; - var $679 = $456 + $_sum13_i | 0; - var $680 = $679; - HEAP32[$680 >> 2] = $601; - break $_$179; - } - _abort(); - } + var $1163 = $R_1_i_i + 20 | 0; + HEAP32[$1163 >> 2] = $1156; + var $1164 = $1156 + 24 | 0; + HEAP32[$1164 >> 2] = $R_1_i_i; } + } } - } - } - } while (0); - var $700 = $v_3_lcssa_i + 8 | 0; - var $701 = $700; - var $702 = ($700 | 0) == 0; - if ($702) { - var $nb_0 = $342; - __label__ = 155; - break $_$2; - } - var $mem_0 = $701; - __label__ = 331; - break $_$2; - } - } while (0); - _abort(); - } - } while (0); - $_$215 : do { - if (__label__ == 155) { - var $nb_0; - var $703 = HEAP32[(__gm_ + 8 | 0) >> 2]; - var $704 = $nb_0 >>> 0 > $703 >>> 0; - if ($704) { - var $732 = HEAP32[(__gm_ + 12 | 0) >> 2]; - var $733 = $nb_0 >>> 0 < $732 >>> 0; - if ($733) { - var $735 = $732 - $nb_0 | 0; - HEAP32[(__gm_ + 12 | 0) >> 2] = $735; - var $736 = HEAP32[(__gm_ + 24 | 0) >> 2]; - var $737 = $736; - var $738 = $737 + $nb_0 | 0; - var $739 = $738; - HEAP32[(__gm_ + 24 | 0) >> 2] = $739; - var $740 = $735 | 1; - var $_sum = $nb_0 + 4 | 0; - var $741 = $737 + $_sum | 0; - var $742 = $741; - HEAP32[$742 >> 2] = $740; - var $743 = $nb_0 | 3; - var $744 = $736 + 4 | 0; - HEAP32[$744 >> 2] = $743; - var $745 = $736 + 8 | 0; - var $746 = $745; - var $mem_0 = $746; - } else { - var $748 = HEAP32[(_mparams | 0) >> 2]; - var $749 = ($748 | 0) == 0; - do { - if ($749) { - var $751 = HEAP32[(_mparams | 0) >> 2]; - var $752 = ($751 | 0) == 0; - if (!$752) { - break; - } - var $754 = _sysconf(8); - var $755 = $754 - 1 | 0; - var $756 = $755 & $754; - var $757 = ($756 | 0) == 0; - if ($757) { - HEAP32[(_mparams + 8 | 0) >> 2] = $754; - HEAP32[(_mparams + 4 | 0) >> 2] = $754; - HEAP32[(_mparams + 12 | 0) >> 2] = -1; - HEAP32[(_mparams + 16 | 0) >> 2] = 2097152; - HEAP32[(_mparams + 20 | 0) >> 2] = 0; - HEAP32[(__gm_ + 440 | 0) >> 2] = 0; - var $760 = _time(0); - var $761 = $760 & -16; - var $762 = $761 ^ 1431655768; - HEAP32[(_mparams | 0) >> 2] = $762; + } while (0); + var $_sum9_i_i = $1029 | $991; + var $_sum88_i = $_sum9_i_i + $tsize_242_i | 0; + var $1168 = $tbase_243_i + $_sum88_i | 0; + var $1169 = $1168; + var $1170 = $1029 + $999 | 0; + var $oldfirst_0_i_i = $1169; + var $qsize_0_i_i = $1170; } else { - _abort(); + var $oldfirst_0_i_i = $993; + var $qsize_0_i_i = $999; } - } - } while (0); - var $763 = HEAP32[(__gm_ + 440 | 0) >> 2]; - var $764 = $763 & 4; - var $765 = ($764 | 0) == 0; - $_$234 : do { - if ($765) { - var $767 = HEAP32[(__gm_ + 24 | 0) >> 2]; - var $768 = ($767 | 0) == 0; - $_$236 : do { - if (!$768) { - var $770 = $767; - var $sp_0_i_i = __gm_ + 444 | 0; - while (1) { - var $sp_0_i_i; - var $772 = $sp_0_i_i | 0; - var $773 = HEAP32[$772 >> 2]; - var $774 = $773 >>> 0 > $770 >>> 0; - if (!$774) { - var $776 = $sp_0_i_i + 4 | 0; - var $777 = HEAP32[$776 >> 2]; - var $778 = $773 + $777 | 0; - var $779 = $778 >>> 0 > $770 >>> 0; - if ($779) { - break; - } - } - var $781 = $sp_0_i_i + 8 | 0; - var $782 = HEAP32[$781 >> 2]; - var $783 = ($782 | 0) == 0; - if ($783) { - __label__ = 174; - break $_$236; - } - var $sp_0_i_i = $782; - } - var $784 = ($sp_0_i_i | 0) == 0; - if ($784) { - __label__ = 174; - break; - } - var $810 = HEAP32[(__gm_ + 12 | 0) >> 2]; - var $811 = HEAP32[(_mparams + 8 | 0) >> 2]; - var $812 = $nb_0 + 47 | 0; - var $813 = $812 - $810 | 0; - var $814 = $813 + $811 | 0; - var $815 = -$811 | 0; - var $816 = $814 & $815; - var $817 = $816 >>> 0 < 2147483647; - if (!$817) { - var $tsize_0242932_ph_i = 0; - __label__ = 189; - break; - } - var $819 = _sbrk($816); - var $820 = HEAP32[$772 >> 2]; - var $821 = HEAP32[$776 >> 2]; - var $822 = $820 + $821 | 0; - var $823 = ($819 | 0) == ($822 | 0); - var $_1_i = $823 ? $816 : 0; - var $_2_i = $823 ? $819 : -1; - var $tbase_0_i = $_2_i; - var $tsize_0_i = $_1_i; - var $asize_1_i = $816; - var $br_0_i = $819; - __label__ = 181; + var $qsize_0_i_i; + var $oldfirst_0_i_i; + var $1172 = $oldfirst_0_i_i + 4 | 0; + var $1173 = HEAP32[$1172 >> 2]; + var $1174 = $1173 & -2; + HEAP32[$1172 >> 2] = $1174; + var $1175 = $qsize_0_i_i | 1; + var $_sum10_i_i = $_sum_i16_i + 4 | 0; + var $1176 = $tbase_243_i + $_sum10_i_i | 0; + var $1177 = $1176; + HEAP32[$1177 >> 2] = $1175; + var $_sum11_i19_i = $qsize_0_i_i + $_sum_i16_i | 0; + var $1178 = $tbase_243_i + $_sum11_i19_i | 0; + var $1179 = $1178; + HEAP32[$1179 >> 2] = $qsize_0_i_i; + var $1180 = $qsize_0_i_i >>> 0 < 256; + if ($1180) { + var $1182 = $qsize_0_i_i >>> 3; + var $1183 = $qsize_0_i_i >>> 2; + var $1184 = $1183 & 1073741822; + var $1185 = __gm_ + 40 + ($1184 << 2) | 0; + var $1186 = $1185; + var $1187 = HEAP32[(__gm_ | 0) >> 2]; + var $1188 = 1 << $1182; + var $1189 = $1187 & $1188; + var $1190 = ($1189 | 0) == 0; + do { + if ($1190) { + var $1192 = $1187 | $1188; + HEAP32[(__gm_ | 0) >> 2] = $1192; + var $_sum26_pre_i_i = $1184 + 2 | 0; + var $_pre_i_i = __gm_ + 40 + ($_sum26_pre_i_i << 2) | 0; + var $F4_0_i_i = $1186; + var $_pre_phi_i20_i = $_pre_i_i; + } else { + var $_sum29_i_i = $1184 + 2 | 0; + var $1194 = __gm_ + 40 + ($_sum29_i_i << 2) | 0; + var $1195 = HEAP32[$1194 >> 2]; + var $1196 = $1195; + var $1197 = HEAP32[(__gm_ + 16 | 0) >> 2]; + var $1198 = $1196 >>> 0 < $1197 >>> 0; + if (!$1198) { + var $F4_0_i_i = $1195; + var $_pre_phi_i20_i = $1194; break; + } + _abort(); } - __label__ = 174; - } while (0); - do { - if (__label__ == 174) { - var $785 = _sbrk(0); - var $786 = ($785 | 0) == -1; - if ($786) { - var $tsize_0242932_ph_i = 0; - __label__ = 189; - break; - } - var $788 = HEAP32[(_mparams + 8 | 0) >> 2]; - var $789 = $nb_0 + 47 | 0; - var $790 = $789 + $788 | 0; - var $791 = -$788 | 0; - var $792 = $790 & $791; - var $793 = $785; - var $794 = HEAP32[(_mparams + 4 | 0) >> 2]; - var $795 = $794 - 1 | 0; - var $796 = $795 & $793; - var $797 = ($796 | 0) == 0; - if ($797) { - var $asize_0_i = $792; - } else { - var $799 = $795 + $793 | 0; - var $800 = -$794 | 0; - var $801 = $799 & $800; - var $802 = $792 - $793 | 0; - var $803 = $802 + $801 | 0; - var $asize_0_i = $803; - } - var $asize_0_i; - var $805 = $asize_0_i >>> 0 < 2147483647; - if (!$805) { - var $tsize_0242932_ph_i = 0; - __label__ = 189; - break; - } - var $807 = _sbrk($asize_0_i); - var $808 = ($807 | 0) == ($785 | 0); - var $asize_0__i = $808 ? $asize_0_i : 0; - var $__i = $808 ? $785 : -1; - var $tbase_0_i = $__i; - var $tsize_0_i = $asize_0__i; - var $asize_1_i = $asize_0_i; - var $br_0_i = $807; - __label__ = 181; + } while (0); + var $_pre_phi_i20_i; + var $F4_0_i_i; + HEAP32[$_pre_phi_i20_i >> 2] = $998; + var $1201 = $F4_0_i_i + 12 | 0; + HEAP32[$1201 >> 2] = $998; + var $_sum27_i_i = $_sum_i16_i + 8 | 0; + var $1202 = $tbase_243_i + $_sum27_i_i | 0; + var $1203 = $1202; + HEAP32[$1203 >> 2] = $F4_0_i_i; + var $_sum28_i_i = $_sum_i16_i + 12 | 0; + var $1204 = $tbase_243_i + $_sum28_i_i | 0; + var $1205 = $1204; + HEAP32[$1205 >> 2] = $1186; + } else { + var $1207 = $997; + var $1208 = $qsize_0_i_i >>> 8; + var $1209 = ($1208 | 0) == 0; + do { + if ($1209) { + var $I7_0_i_i = 0; + } else { + var $1211 = $qsize_0_i_i >>> 0 > 16777215; + if ($1211) { + var $I7_0_i_i = 31; break; + } + var $1213 = $1208 + 1048320 | 0; + var $1214 = $1213 >>> 16; + var $1215 = $1214 & 8; + var $1216 = $1208 << $1215; + var $1217 = $1216 + 520192 | 0; + var $1218 = $1217 >>> 16; + var $1219 = $1218 & 4; + var $1220 = $1216 << $1219; + var $1221 = $1220 + 245760 | 0; + var $1222 = $1221 >>> 16; + var $1223 = $1222 & 2; + var $1224 = $1219 | $1215; + var $1225 = $1224 | $1223; + var $1226 = 14 - $1225 | 0; + var $1227 = $1220 << $1223; + var $1228 = $1227 >>> 15; + var $1229 = $1226 + $1228 | 0; + var $1230 = $1229 << 1; + var $1231 = $1229 + 7 | 0; + var $1232 = $qsize_0_i_i >>> ($1231 >>> 0); + var $1233 = $1232 & 1; + var $1234 = $1233 | $1230; + var $I7_0_i_i = $1234; } - } while (0); - $_$253 : do { - if (__label__ == 181) { - var $br_0_i; - var $asize_1_i; - var $tsize_0_i; - var $tbase_0_i; - var $825 = -$asize_1_i | 0; - var $826 = ($tbase_0_i | 0) == -1; - if (!$826) { - var $tsize_242_i = $tsize_0_i; - var $tbase_243_i = $tbase_0_i; - __label__ = 194; - break $_$234; - } - var $828 = ($br_0_i | 0) != -1; - var $829 = $asize_1_i >>> 0 < 2147483647; - var $or_cond_i28 = $828 & $829; + } while (0); + var $I7_0_i_i; + var $1236 = __gm_ + 304 + ($I7_0_i_i << 2) | 0; + var $_sum12_i_i = $_sum_i16_i + 28 | 0; + var $1237 = $tbase_243_i + $_sum12_i_i | 0; + var $1238 = $1237; + HEAP32[$1238 >> 2] = $I7_0_i_i; + var $_sum13_i_i = $_sum_i16_i + 16 | 0; + var $1239 = $tbase_243_i + $_sum13_i_i | 0; + var $_sum14_i_i = $_sum_i16_i + 20 | 0; + var $1240 = $tbase_243_i + $_sum14_i_i | 0; + var $1241 = $1240; + HEAP32[$1241 >> 2] = 0; + var $1242 = $1239; + HEAP32[$1242 >> 2] = 0; + var $1243 = HEAP32[(__gm_ + 4 | 0) >> 2]; + var $1244 = 1 << $I7_0_i_i; + var $1245 = $1243 & $1244; + var $1246 = ($1245 | 0) == 0; + if ($1246) { + var $1248 = $1243 | $1244; + HEAP32[(__gm_ + 4 | 0) >> 2] = $1248; + HEAP32[$1236 >> 2] = $1207; + var $1249 = $1236; + var $_sum15_i_i = $_sum_i16_i + 24 | 0; + var $1250 = $tbase_243_i + $_sum15_i_i | 0; + var $1251 = $1250; + HEAP32[$1251 >> 2] = $1249; + var $_sum16_i_i = $_sum_i16_i + 12 | 0; + var $1252 = $tbase_243_i + $_sum16_i_i | 0; + var $1253 = $1252; + HEAP32[$1253 >> 2] = $1207; + var $_sum17_i_i = $_sum_i16_i + 8 | 0; + var $1254 = $tbase_243_i + $_sum17_i_i | 0; + var $1255 = $1254; + HEAP32[$1255 >> 2] = $1207; + } else { + var $1257 = HEAP32[$1236 >> 2]; + var $1258 = ($I7_0_i_i | 0) == 31; + if ($1258) { + var $1263 = 0; + } else { + var $1260 = $I7_0_i_i >>> 1; + var $1261 = 25 - $1260 | 0; + var $1263 = $1261; + } + var $1263; + var $1264 = $qsize_0_i_i << $1263; + var $K8_0_i_i = $1264; + var $T_0_i21_i = $1257; + while (1) { + var $T_0_i21_i; + var $K8_0_i_i; + var $1266 = $T_0_i21_i + 4 | 0; + var $1267 = HEAP32[$1266 >> 2]; + var $1268 = $1267 & -8; + var $1269 = ($1268 | 0) == ($qsize_0_i_i | 0); + if ($1269) { + var $1289 = $T_0_i21_i + 8 | 0; + var $1290 = HEAP32[$1289 >> 2]; + var $1291 = $T_0_i21_i; + var $1292 = HEAP32[(__gm_ + 16 | 0) >> 2]; + var $1293 = $1291 >>> 0 < $1292 >>> 0; do { - if ($or_cond_i28) { - var $831 = $nb_0 + 48 | 0; - var $832 = $asize_1_i >>> 0 < $831 >>> 0; - if (!$832) { - var $asize_2_i = $asize_1_i; - break; - } - var $834 = HEAP32[(_mparams + 8 | 0) >> 2]; - var $835 = $nb_0 + 47 | 0; - var $836 = $835 - $asize_1_i | 0; - var $837 = $836 + $834 | 0; - var $838 = -$834 | 0; - var $839 = $837 & $838; - var $840 = $839 >>> 0 < 2147483647; - if (!$840) { - var $asize_2_i = $asize_1_i; - break; - } - var $842 = _sbrk($839); - var $843 = ($842 | 0) == -1; - if ($843) { - var $847 = _sbrk($825); - var $tsize_0242932_ph_i = $tsize_0_i; - break $_$253; - } - var $845 = $839 + $asize_1_i | 0; - var $asize_2_i = $845; - } else { - var $asize_2_i = $asize_1_i; + if (!$1293) { + var $1295 = $1290; + var $1296 = $1295 >>> 0 < $1292 >>> 0; + if ($1296) { + break; } + var $1298 = $1290 + 12 | 0; + HEAP32[$1298 >> 2] = $1207; + HEAP32[$1289 >> 2] = $1207; + var $_sum20_i_i = $_sum_i16_i + 8 | 0; + var $1299 = $tbase_243_i + $_sum20_i_i | 0; + var $1300 = $1299; + HEAP32[$1300 >> 2] = $1290; + var $_sum21_i_i = $_sum_i16_i + 12 | 0; + var $1301 = $tbase_243_i + $_sum21_i_i | 0; + var $1302 = $1301; + HEAP32[$1302 >> 2] = $T_0_i21_i; + var $_sum22_i_i = $_sum_i16_i + 24 | 0; + var $1303 = $tbase_243_i + $_sum22_i_i | 0; + var $1304 = $1303; + HEAP32[$1304 >> 2] = 0; + break $_$314; + } } while (0); - var $asize_2_i; - var $849 = ($br_0_i | 0) == -1; - if (!$849) { - var $tsize_242_i = $asize_2_i; - var $tbase_243_i = $br_0_i; - __label__ = 194; - break $_$234; + _abort(); + } else { + var $1271 = $K8_0_i_i >>> 31; + var $1272 = $T_0_i21_i + 16 + ($1271 << 2) | 0; + var $1273 = HEAP32[$1272 >> 2]; + var $1274 = ($1273 | 0) == 0; + var $1275 = $K8_0_i_i << 1; + if (!$1274) { + var $K8_0_i_i = $1275; + var $T_0_i21_i = $1273; + continue; + } + var $1277 = $1272; + var $1278 = HEAP32[(__gm_ + 16 | 0) >> 2]; + var $1279 = $1277 >>> 0 < $1278 >>> 0; + if (!$1279) { + HEAP32[$1272 >> 2] = $1207; + var $_sum23_i_i = $_sum_i16_i + 24 | 0; + var $1281 = $tbase_243_i + $_sum23_i_i | 0; + var $1282 = $1281; + HEAP32[$1282 >> 2] = $T_0_i21_i; + var $_sum24_i_i = $_sum_i16_i + 12 | 0; + var $1283 = $tbase_243_i + $_sum24_i_i | 0; + var $1284 = $1283; + HEAP32[$1284 >> 2] = $1207; + var $_sum25_i_i = $_sum_i16_i + 8 | 0; + var $1285 = $tbase_243_i + $_sum25_i_i | 0; + var $1286 = $1285; + HEAP32[$1286 >> 2] = $1207; + break $_$314; } - var $852 = HEAP32[(__gm_ + 440 | 0) >> 2]; - var $853 = $852 | 4; - HEAP32[(__gm_ + 440 | 0) >> 2] = $853; - var $tsize_137_i = $tsize_0_i; - __label__ = 191; - break $_$234; + _abort(); + } } - } while (0); - var $tsize_0242932_ph_i; - var $850 = HEAP32[(__gm_ + 440 | 0) >> 2]; - var $851 = $850 | 4; - HEAP32[(__gm_ + 440 | 0) >> 2] = $851; - var $tsize_137_i = $tsize_0242932_ph_i; - __label__ = 191; - break; + } + } + } } - var $tsize_137_i = 0; - __label__ = 191; - } while (0); + } while (0); + var $_sum1819_i_i = $981 | 8; + var $1305 = $tbase_243_i + $_sum1819_i_i | 0; + var $mem_0 = $1305; + break $_$215; + } + } while (0); + var $1306 = $876; + var $sp_0_i_i_i = __gm_ + 444 | 0; + while (1) { + var $sp_0_i_i_i; + var $1308 = $sp_0_i_i_i | 0; + var $1309 = HEAP32[$1308 >> 2]; + var $1310 = $1309 >>> 0 > $1306 >>> 0; + if (!$1310) { + var $1312 = $sp_0_i_i_i + 4 | 0; + var $1313 = HEAP32[$1312 >> 2]; + var $1314 = $1309 + $1313 | 0; + var $1315 = $1314 >>> 0 > $1306 >>> 0; + if ($1315) { + var $1321 = $1309; + var $1320 = $1313; + break; + } + } + var $1317 = $sp_0_i_i_i + 8 | 0; + var $1318 = HEAP32[$1317 >> 2]; + var $1319 = ($1318 | 0) == 0; + if (!$1319) { + var $sp_0_i_i_i = $1318; + continue; + } + var $_pre14_i_i = 4; + var $1321 = 0; + var $1320 = $_pre14_i_i; + break; + } + var $1320; + var $1321; + var $1322 = $1321 + $1320 | 0; + var $_sum1_i10_i = $1320 - 39 | 0; + var $1323 = $1321 + $_sum1_i10_i | 0; + var $1324 = $1323; + var $1325 = $1324 & 7; + var $1326 = ($1325 | 0) == 0; + if ($1326) { + var $1331 = 0; + } else { + var $1328 = -$1324 | 0; + var $1329 = $1328 & 7; + var $1331 = $1329; + } + var $1331; + var $_sum_i11_i = $1320 - 47 | 0; + var $_sum2_i12_i = $_sum_i11_i + $1331 | 0; + var $1332 = $1321 + $_sum2_i12_i | 0; + var $1333 = $876 + 16 | 0; + var $1334 = $1333; + var $1335 = $1332 >>> 0 < $1334 >>> 0; + var $1336 = $1335 ? $1306 : $1332; + var $1337 = $1336 + 8 | 0; + var $1338 = $1337; + var $1339 = $tbase_243_i + 8 | 0; + var $1340 = $1339; + var $1341 = $1340 & 7; + var $1342 = ($1341 | 0) == 0; + if ($1342) { + var $1346 = 0; + } else { + var $1344 = -$1340 | 0; + var $1345 = $1344 & 7; + var $1346 = $1345; + } + var $1346; + var $1347 = $tbase_243_i + $1346 | 0; + var $1348 = $1347; + var $1349 = $tsize_242_i - 40 | 0; + var $1350 = $1349 - $1346 | 0; + HEAP32[(__gm_ + 24 | 0) >> 2] = $1348; + HEAP32[(__gm_ + 12 | 0) >> 2] = $1350; + var $1351 = $1350 | 1; + var $_sum_i_i_i = $1346 + 4 | 0; + var $1352 = $tbase_243_i + $_sum_i_i_i | 0; + var $1353 = $1352; + HEAP32[$1353 >> 2] = $1351; + var $_sum2_i_i_i = $tsize_242_i - 36 | 0; + var $1354 = $tbase_243_i + $_sum2_i_i_i | 0; + var $1355 = $1354; + HEAP32[$1355 >> 2] = 40; + var $1356 = HEAP32[(_mparams + 16 | 0) >> 2]; + HEAP32[(__gm_ + 28 | 0) >> 2] = $1356; + var $1357 = $1336 + 4 | 0; + var $1358 = $1357; + HEAP32[$1358 >> 2] = 27; + HEAP32[$1337 >> 2] = HEAP32[(__gm_ + 444 | 0) >> 2]; + HEAP32[$1337 + 4 >> 2] = HEAP32[(__gm_ + 444 | 0) + 4 >> 2]; + HEAP32[$1337 + 8 >> 2] = HEAP32[(__gm_ + 444 | 0) + 8 >> 2]; + HEAP32[$1337 + 12 >> 2] = HEAP32[(__gm_ + 444 | 0) + 12 >> 2]; + HEAP32[(__gm_ + 444 | 0) >> 2] = $tbase_243_i; + HEAP32[(__gm_ + 448 | 0) >> 2] = $tsize_242_i; + HEAP32[(__gm_ + 456 | 0) >> 2] = 0; + HEAP32[(__gm_ + 452 | 0) >> 2] = $1338; + var $1359 = $1336 + 28 | 0; + var $1360 = $1359; + HEAP32[$1360 >> 2] = 7; + var $1361 = $1336 + 32 | 0; + var $1362 = $1361 >>> 0 < $1322 >>> 0; + $_$426 : do { + if ($1362) { + var $1363 = $1360; + while (1) { + var $1363; + var $1364 = $1363 + 4 | 0; + HEAP32[$1364 >> 2] = 7; + var $1365 = $1363 + 8 | 0; + var $1366 = $1365; + var $1367 = $1366 >>> 0 < $1322 >>> 0; + if (!$1367) { + break $_$426; + } + var $1363 = $1364; + } + } + } while (0); + var $1368 = ($1336 | 0) == ($1306 | 0); + if ($1368) { + break; + } + var $1370 = $1336; + var $1371 = $876; + var $1372 = $1370 - $1371 | 0; + var $1373 = $1306 + $1372 | 0; + var $_sum3_i_i = $1372 + 4 | 0; + var $1374 = $1306 + $_sum3_i_i | 0; + var $1375 = $1374; + var $1376 = HEAP32[$1375 >> 2]; + var $1377 = $1376 & -2; + HEAP32[$1375 >> 2] = $1377; + var $1378 = $1372 | 1; + var $1379 = $876 + 4 | 0; + HEAP32[$1379 >> 2] = $1378; + var $1380 = $1373; + HEAP32[$1380 >> 2] = $1372; + var $1381 = $1372 >>> 0 < 256; + if ($1381) { + var $1383 = $1372 >>> 3; + var $1384 = $1372 >>> 2; + var $1385 = $1384 & 1073741822; + var $1386 = __gm_ + 40 + ($1385 << 2) | 0; + var $1387 = $1386; + var $1388 = HEAP32[(__gm_ | 0) >> 2]; + var $1389 = 1 << $1383; + var $1390 = $1388 & $1389; + var $1391 = ($1390 | 0) == 0; do { - if (__label__ == 191) { - var $tsize_137_i; - var $854 = HEAP32[(_mparams + 8 | 0) >> 2]; - var $855 = $nb_0 + 47 | 0; - var $856 = $855 + $854 | 0; - var $857 = -$854 | 0; - var $858 = $856 & $857; - var $859 = $858 >>> 0 < 2147483647; - if (!$859) { - __label__ = 330; - break; - } - var $861 = _sbrk($858); - var $862 = _sbrk(0); - var $notlhs_i = ($861 | 0) != -1; - var $notrhs_i = ($862 | 0) != -1; - var $or_cond3_not_i = $notrhs_i & $notlhs_i; - var $863 = $861 >>> 0 < $862 >>> 0; - var $or_cond4_i = $or_cond3_not_i & $863; - if (!$or_cond4_i) { - __label__ = 330; - break; - } - var $864 = $862; - var $865 = $861; - var $866 = $864 - $865 | 0; - var $867 = $nb_0 + 40 | 0; - var $868 = $866 >>> 0 > $867 >>> 0; - var $_tsize_1_i = $868 ? $866 : $tsize_137_i; - var $_tbase_1_i = $868 ? $861 : -1; - var $869 = ($_tbase_1_i | 0) == -1; - if ($869) { - __label__ = 330; - break; - } - var $tsize_242_i = $_tsize_1_i; - var $tbase_243_i = $_tbase_1_i; - __label__ = 194; - break; + if ($1391) { + var $1393 = $1388 | $1389; + HEAP32[(__gm_ | 0) >> 2] = $1393; + var $_sum10_pre_i_i = $1385 + 2 | 0; + var $_pre15_i_i = __gm_ + 40 + ($_sum10_pre_i_i << 2) | 0; + var $F_0_i_i = $1387; + var $_pre_phi_i_i = $_pre15_i_i; + } else { + var $_sum11_i_i = $1385 + 2 | 0; + var $1395 = __gm_ + 40 + ($_sum11_i_i << 2) | 0; + var $1396 = HEAP32[$1395 >> 2]; + var $1397 = $1396; + var $1398 = HEAP32[(__gm_ + 16 | 0) >> 2]; + var $1399 = $1397 >>> 0 < $1398 >>> 0; + if (!$1399) { + var $F_0_i_i = $1396; + var $_pre_phi_i_i = $1395; + break; } + _abort(); + } } while (0); + var $_pre_phi_i_i; + var $F_0_i_i; + HEAP32[$_pre_phi_i_i >> 2] = $876; + var $1402 = $F_0_i_i + 12 | 0; + HEAP32[$1402 >> 2] = $876; + var $1403 = $876 + 8 | 0; + HEAP32[$1403 >> 2] = $F_0_i_i; + var $1404 = $876 + 12 | 0; + HEAP32[$1404 >> 2] = $1387; + } else { + var $1406 = $876; + var $1407 = $1372 >>> 8; + var $1408 = ($1407 | 0) == 0; do { - if (__label__ == 194) { - var $tbase_243_i; - var $tsize_242_i; - var $870 = HEAP32[(__gm_ + 432 | 0) >> 2]; - var $871 = $870 + $tsize_242_i | 0; - HEAP32[(__gm_ + 432 | 0) >> 2] = $871; - var $872 = HEAP32[(__gm_ + 436 | 0) >> 2]; - var $873 = $871 >>> 0 > $872 >>> 0; - if ($873) { - HEAP32[(__gm_ + 436 | 0) >> 2] = $871; - } - var $876 = HEAP32[(__gm_ + 24 | 0) >> 2]; - var $877 = ($876 | 0) == 0; - $_$275 : do { - if ($877) { - var $879 = HEAP32[(__gm_ + 16 | 0) >> 2]; - var $880 = ($879 | 0) == 0; - var $881 = $tbase_243_i >>> 0 < $879 >>> 0; - var $or_cond5_i = $880 | $881; - if ($or_cond5_i) { - HEAP32[(__gm_ + 16 | 0) >> 2] = $tbase_243_i; - } - HEAP32[(__gm_ + 444 | 0) >> 2] = $tbase_243_i; - HEAP32[(__gm_ + 448 | 0) >> 2] = $tsize_242_i; - HEAP32[(__gm_ + 456 | 0) >> 2] = 0; - var $884 = HEAP32[(_mparams | 0) >> 2]; - HEAP32[(__gm_ + 36 | 0) >> 2] = $884; - HEAP32[(__gm_ + 32 | 0) >> 2] = -1; - var $i_02_i_i = 0; - while (1) { - var $i_02_i_i; - var $886 = $i_02_i_i << 1; - var $887 = __gm_ + 40 + ($886 << 2) | 0; - var $888 = $887; - var $_sum_i_i = $886 + 3 | 0; - var $889 = __gm_ + 40 + ($_sum_i_i << 2) | 0; - HEAP32[$889 >> 2] = $888; - var $_sum1_i_i = $886 + 2 | 0; - var $890 = __gm_ + 40 + ($_sum1_i_i << 2) | 0; - HEAP32[$890 >> 2] = $888; - var $891 = $i_02_i_i + 1 | 0; - var $exitcond_i_i = ($891 | 0) == 32; - if ($exitcond_i_i) { - break; - } - var $i_02_i_i = $891; - } - var $892 = $tbase_243_i + 8 | 0; - var $893 = $892; - var $894 = $893 & 7; - var $895 = ($894 | 0) == 0; - if ($895) { - var $899 = 0; - } else { - var $897 = -$893 | 0; - var $898 = $897 & 7; - var $899 = $898; - } - var $899; - var $900 = $tbase_243_i + $899 | 0; - var $901 = $900; - var $902 = $tsize_242_i - 40 | 0; - var $903 = $902 - $899 | 0; - HEAP32[(__gm_ + 24 | 0) >> 2] = $901; - HEAP32[(__gm_ + 12 | 0) >> 2] = $903; - var $904 = $903 | 1; - var $_sum_i9_i = $899 + 4 | 0; - var $905 = $tbase_243_i + $_sum_i9_i | 0; - var $906 = $905; - HEAP32[$906 >> 2] = $904; - var $_sum2_i_i = $tsize_242_i - 36 | 0; - var $907 = $tbase_243_i + $_sum2_i_i | 0; - var $908 = $907; - HEAP32[$908 >> 2] = 40; - var $909 = HEAP32[(_mparams + 16 | 0) >> 2]; - HEAP32[(__gm_ + 28 | 0) >> 2] = $909; - } else { - var $sp_0_i = __gm_ + 444 | 0; - while (1) { - var $sp_0_i; - var $910 = ($sp_0_i | 0) == 0; - if ($910) { - break; - } - var $912 = $sp_0_i | 0; - var $913 = HEAP32[$912 >> 2]; - var $914 = $sp_0_i + 4 | 0; - var $915 = HEAP32[$914 >> 2]; - var $916 = $913 + $915 | 0; - var $917 = ($tbase_243_i | 0) == ($916 | 0); - if ($917) { - var $921 = $sp_0_i + 12 | 0; - var $922 = HEAP32[$921 >> 2]; - var $923 = $922 & 8; - var $924 = ($923 | 0) == 0; - if (!$924) { - break; - } - var $926 = $876; - var $927 = $926 >>> 0 >= $913 >>> 0; - var $928 = $926 >>> 0 < $tbase_243_i >>> 0; - var $or_cond44_i = $927 & $928; - if (!$or_cond44_i) { - break; - } - var $930 = $915 + $tsize_242_i | 0; - HEAP32[$914 >> 2] = $930; - var $931 = HEAP32[(__gm_ + 24 | 0) >> 2]; - var $932 = HEAP32[(__gm_ + 12 | 0) >> 2]; - var $933 = $932 + $tsize_242_i | 0; - var $934 = $931; - var $935 = $931 + 8 | 0; - var $936 = $935; - var $937 = $936 & 7; - var $938 = ($937 | 0) == 0; - if ($938) { - var $942 = 0; - } else { - var $940 = -$936 | 0; - var $941 = $940 & 7; - var $942 = $941; - } - var $942; - var $943 = $934 + $942 | 0; - var $944 = $943; - var $945 = $933 - $942 | 0; - HEAP32[(__gm_ + 24 | 0) >> 2] = $944; - HEAP32[(__gm_ + 12 | 0) >> 2] = $945; - var $946 = $945 | 1; - var $_sum_i13_i = $942 + 4 | 0; - var $947 = $934 + $_sum_i13_i | 0; - var $948 = $947; - HEAP32[$948 >> 2] = $946; - var $_sum2_i14_i = $933 + 4 | 0; - var $949 = $934 + $_sum2_i14_i | 0; - var $950 = $949; - HEAP32[$950 >> 2] = 40; - var $951 = HEAP32[(_mparams + 16 | 0) >> 2]; - HEAP32[(__gm_ + 28 | 0) >> 2] = $951; - break $_$275; - } - var $919 = $sp_0_i + 8 | 0; - var $920 = HEAP32[$919 >> 2]; - var $sp_0_i = $920; - } - var $952 = HEAP32[(__gm_ + 16 | 0) >> 2]; - var $953 = $tbase_243_i >>> 0 < $952 >>> 0; - if ($953) { - HEAP32[(__gm_ + 16 | 0) >> 2] = $tbase_243_i; - } - var $955 = $tbase_243_i + $tsize_242_i | 0; - var $sp_1_i = __gm_ + 444 | 0; - while (1) { - var $sp_1_i; - var $957 = ($sp_1_i | 0) == 0; - if ($957) { - __label__ = 293; - break; - } - var $959 = $sp_1_i | 0; - var $960 = HEAP32[$959 >> 2]; - var $961 = ($960 | 0) == ($955 | 0); - if ($961) { - __label__ = 218; - break; - } - var $963 = $sp_1_i + 8 | 0; - var $964 = HEAP32[$963 >> 2]; - var $sp_1_i = $964; - } - do { - if (__label__ == 218) { - var $965 = $sp_1_i + 12 | 0; - var $966 = HEAP32[$965 >> 2]; - var $967 = $966 & 8; - var $968 = ($967 | 0) == 0; - if (!$968) { - break; - } - HEAP32[$959 >> 2] = $tbase_243_i; - var $970 = $sp_1_i + 4 | 0; - var $971 = HEAP32[$970 >> 2]; - var $972 = $971 + $tsize_242_i | 0; - HEAP32[$970 >> 2] = $972; - var $973 = $tbase_243_i + 8 | 0; - var $974 = $973; - var $975 = $974 & 7; - var $976 = ($975 | 0) == 0; - if ($976) { - var $981 = 0; - } else { - var $978 = -$974 | 0; - var $979 = $978 & 7; - var $981 = $979; - } - var $981; - var $982 = $tbase_243_i + $981 | 0; - var $_sum79_i = $tsize_242_i + 8 | 0; - var $983 = $tbase_243_i + $_sum79_i | 0; - var $984 = $983; - var $985 = $984 & 7; - var $986 = ($985 | 0) == 0; - if ($986) { - var $991 = 0; - } else { - var $988 = -$984 | 0; - var $989 = $988 & 7; - var $991 = $989; - } - var $991; - var $_sum80_i = $991 + $tsize_242_i | 0; - var $992 = $tbase_243_i + $_sum80_i | 0; - var $993 = $992; - var $994 = $992; - var $995 = $982; - var $996 = $994 - $995 | 0; - var $_sum_i16_i = $981 + $nb_0 | 0; - var $997 = $tbase_243_i + $_sum_i16_i | 0; - var $998 = $997; - var $999 = $996 - $nb_0 | 0; - var $1000 = $nb_0 | 3; - var $_sum1_i17_i = $981 + 4 | 0; - var $1001 = $tbase_243_i + $_sum1_i17_i | 0; - var $1002 = $1001; - HEAP32[$1002 >> 2] = $1000; - var $1003 = HEAP32[(__gm_ + 24 | 0) >> 2]; - var $1004 = ($993 | 0) == ($1003 | 0); - $_$314 : do { - if ($1004) { - var $1006 = HEAP32[(__gm_ + 12 | 0) >> 2]; - var $1007 = $1006 + $999 | 0; - HEAP32[(__gm_ + 12 | 0) >> 2] = $1007; - HEAP32[(__gm_ + 24 | 0) >> 2] = $998; - var $1008 = $1007 | 1; - var $_sum42_i_i = $_sum_i16_i + 4 | 0; - var $1009 = $tbase_243_i + $_sum42_i_i | 0; - var $1010 = $1009; - HEAP32[$1010 >> 2] = $1008; - } else { - var $1012 = HEAP32[(__gm_ + 20 | 0) >> 2]; - var $1013 = ($993 | 0) == ($1012 | 0); - if ($1013) { - var $1015 = HEAP32[(__gm_ + 8 | 0) >> 2]; - var $1016 = $1015 + $999 | 0; - HEAP32[(__gm_ + 8 | 0) >> 2] = $1016; - HEAP32[(__gm_ + 20 | 0) >> 2] = $998; - var $1017 = $1016 | 1; - var $_sum40_i_i = $_sum_i16_i + 4 | 0; - var $1018 = $tbase_243_i + $_sum40_i_i | 0; - var $1019 = $1018; - HEAP32[$1019 >> 2] = $1017; - var $_sum41_i_i = $1016 + $_sum_i16_i | 0; - var $1020 = $tbase_243_i + $_sum41_i_i | 0; - var $1021 = $1020; - HEAP32[$1021 >> 2] = $1016; - } else { - var $_sum2_i18_i = $tsize_242_i + 4 | 0; - var $_sum81_i = $_sum2_i18_i + $991 | 0; - var $1023 = $tbase_243_i + $_sum81_i | 0; - var $1024 = $1023; - var $1025 = HEAP32[$1024 >> 2]; - var $1026 = $1025 & 3; - var $1027 = ($1026 | 0) == 1; - if ($1027) { - var $1029 = $1025 & -8; - var $1030 = $1025 >>> 3; - var $1031 = $1025 >>> 0 < 256; - $_$322 : do { - if ($1031) { - var $_sum3738_i_i = $991 | 8; - var $_sum91_i = $_sum3738_i_i + $tsize_242_i | 0; - var $1033 = $tbase_243_i + $_sum91_i | 0; - var $1034 = $1033; - var $1035 = HEAP32[$1034 >> 2]; - var $_sum39_i_i = $tsize_242_i + 12 | 0; - var $_sum92_i = $_sum39_i_i + $991 | 0; - var $1036 = $tbase_243_i + $_sum92_i | 0; - var $1037 = $1036; - var $1038 = HEAP32[$1037 >> 2]; - var $1039 = ($1035 | 0) == ($1038 | 0); - if ($1039) { - var $1041 = 1 << $1030; - var $1042 = $1041 ^ -1; - var $1043 = HEAP32[(__gm_ | 0) >> 2]; - var $1044 = $1043 & $1042; - HEAP32[(__gm_ | 0) >> 2] = $1044; - } else { - var $1046 = $1025 >>> 2; - var $1047 = $1046 & 1073741822; - var $1048 = __gm_ + 40 + ($1047 << 2) | 0; - var $1049 = $1048; - var $1050 = ($1035 | 0) == ($1049 | 0); - do { - if ($1050) { - __label__ = 233; - } else { - var $1052 = $1035; - var $1053 = HEAP32[(__gm_ + 16 | 0) >> 2]; - var $1054 = $1052 >>> 0 < $1053 >>> 0; - if ($1054) { - __label__ = 236; - break; - } - __label__ = 233; - break; - } - } while (0); - do { - if (__label__ == 233) { - var $1056 = ($1038 | 0) == ($1049 | 0); - if (!$1056) { - var $1058 = $1038; - var $1059 = HEAP32[(__gm_ + 16 | 0) >> 2]; - var $1060 = $1058 >>> 0 < $1059 >>> 0; - if ($1060) { - break; - } - } - var $1061 = $1035 + 12 | 0; - HEAP32[$1061 >> 2] = $1038; - var $1062 = $1038 + 8 | 0; - HEAP32[$1062 >> 2] = $1035; - break $_$322; - } - } while (0); - _abort(); - } - } else { - var $1064 = $992; - var $_sum34_i_i = $991 | 24; - var $_sum82_i = $_sum34_i_i + $tsize_242_i | 0; - var $1065 = $tbase_243_i + $_sum82_i | 0; - var $1066 = $1065; - var $1067 = HEAP32[$1066 >> 2]; - var $_sum5_i_i = $tsize_242_i + 12 | 0; - var $_sum83_i = $_sum5_i_i + $991 | 0; - var $1068 = $tbase_243_i + $_sum83_i | 0; - var $1069 = $1068; - var $1070 = HEAP32[$1069 >> 2]; - var $1071 = ($1070 | 0) == ($1064 | 0); - do { - if ($1071) { - var $_sum67_i_i = $991 | 16; - var $_sum89_i = $_sum2_i18_i + $_sum67_i_i | 0; - var $1084 = $tbase_243_i + $_sum89_i | 0; - var $1085 = $1084; - var $1086 = HEAP32[$1085 >> 2]; - var $1087 = ($1086 | 0) == 0; - if ($1087) { - var $_sum90_i = $_sum67_i_i + $tsize_242_i | 0; - var $1089 = $tbase_243_i + $_sum90_i | 0; - var $1090 = $1089; - var $1091 = HEAP32[$1090 >> 2]; - var $1092 = ($1091 | 0) == 0; - if ($1092) { - var $R_1_i_i = 0; - break; - } - var $RP_0_i_i = $1090; - var $R_0_i_i = $1091; - } else { - var $RP_0_i_i = $1085; - var $R_0_i_i = $1086; - __label__ = 243; - } - while (1) { - var $R_0_i_i; - var $RP_0_i_i; - var $1093 = $R_0_i_i + 20 | 0; - var $1094 = HEAP32[$1093 >> 2]; - var $1095 = ($1094 | 0) == 0; - if (!$1095) { - var $RP_0_i_i = $1093; - var $R_0_i_i = $1094; - continue; - } - var $1097 = $R_0_i_i + 16 | 0; - var $1098 = HEAP32[$1097 >> 2]; - var $1099 = ($1098 | 0) == 0; - if ($1099) { - break; - } - var $RP_0_i_i = $1097; - var $R_0_i_i = $1098; - } - var $1101 = $RP_0_i_i; - var $1102 = HEAP32[(__gm_ + 16 | 0) >> 2]; - var $1103 = $1101 >>> 0 < $1102 >>> 0; - if ($1103) { - _abort(); - } else { - HEAP32[$RP_0_i_i >> 2] = 0; - var $R_1_i_i = $R_0_i_i; - } - } else { - var $_sum3536_i_i = $991 | 8; - var $_sum84_i = $_sum3536_i_i + $tsize_242_i | 0; - var $1073 = $tbase_243_i + $_sum84_i | 0; - var $1074 = $1073; - var $1075 = HEAP32[$1074 >> 2]; - var $1076 = $1075; - var $1077 = HEAP32[(__gm_ + 16 | 0) >> 2]; - var $1078 = $1076 >>> 0 < $1077 >>> 0; - if ($1078) { - _abort(); - } else { - var $1080 = $1075 + 12 | 0; - HEAP32[$1080 >> 2] = $1070; - var $1081 = $1070 + 8 | 0; - HEAP32[$1081 >> 2] = $1075; - var $R_1_i_i = $1070; - } - } - } while (0); - var $R_1_i_i; - var $1107 = ($1067 | 0) == 0; - if ($1107) { - break; - } - var $_sum30_i_i = $tsize_242_i + 28 | 0; - var $_sum85_i = $_sum30_i_i + $991 | 0; - var $1109 = $tbase_243_i + $_sum85_i | 0; - var $1110 = $1109; - var $1111 = HEAP32[$1110 >> 2]; - var $1112 = __gm_ + 304 + ($1111 << 2) | 0; - var $1113 = HEAP32[$1112 >> 2]; - var $1114 = ($1064 | 0) == ($1113 | 0); - do { - if ($1114) { - HEAP32[$1112 >> 2] = $R_1_i_i; - var $cond_i_i = ($R_1_i_i | 0) == 0; - if (!$cond_i_i) { - break; - } - var $1116 = HEAP32[$1110 >> 2]; - var $1117 = 1 << $1116; - var $1118 = $1117 ^ -1; - var $1119 = HEAP32[(__gm_ + 4 | 0) >> 2]; - var $1120 = $1119 & $1118; - HEAP32[(__gm_ + 4 | 0) >> 2] = $1120; - break $_$322; - } - var $1122 = $1067; - var $1123 = HEAP32[(__gm_ + 16 | 0) >> 2]; - var $1124 = $1122 >>> 0 < $1123 >>> 0; - if ($1124) { - _abort(); - } else { - var $1126 = $1067 + 16 | 0; - var $1127 = HEAP32[$1126 >> 2]; - var $1128 = ($1127 | 0) == ($1064 | 0); - if ($1128) { - HEAP32[$1126 >> 2] = $R_1_i_i; - } else { - var $1131 = $1067 + 20 | 0; - HEAP32[$1131 >> 2] = $R_1_i_i; - } - var $1134 = ($R_1_i_i | 0) == 0; - if ($1134) { - break $_$322; - } - } - } while (0); - var $1136 = $R_1_i_i; - var $1137 = HEAP32[(__gm_ + 16 | 0) >> 2]; - var $1138 = $1136 >>> 0 < $1137 >>> 0; - if ($1138) { - _abort(); - } else { - var $1140 = $R_1_i_i + 24 | 0; - HEAP32[$1140 >> 2] = $1067; - var $_sum3132_i_i = $991 | 16; - var $_sum86_i = $_sum3132_i_i + $tsize_242_i | 0; - var $1141 = $tbase_243_i + $_sum86_i | 0; - var $1142 = $1141; - var $1143 = HEAP32[$1142 >> 2]; - var $1144 = ($1143 | 0) == 0; - if (!$1144) { - var $1146 = $1143; - var $1147 = HEAP32[(__gm_ + 16 | 0) >> 2]; - var $1148 = $1146 >>> 0 < $1147 >>> 0; - if ($1148) { - _abort(); - } else { - var $1150 = $R_1_i_i + 16 | 0; - HEAP32[$1150 >> 2] = $1143; - var $1151 = $1143 + 24 | 0; - HEAP32[$1151 >> 2] = $R_1_i_i; - } - } - var $_sum87_i = $_sum2_i18_i + $_sum3132_i_i | 0; - var $1154 = $tbase_243_i + $_sum87_i | 0; - var $1155 = $1154; - var $1156 = HEAP32[$1155 >> 2]; - var $1157 = ($1156 | 0) == 0; - if ($1157) { - break; - } - var $1159 = $1156; - var $1160 = HEAP32[(__gm_ + 16 | 0) >> 2]; - var $1161 = $1159 >>> 0 < $1160 >>> 0; - if ($1161) { - _abort(); - } else { - var $1163 = $R_1_i_i + 20 | 0; - HEAP32[$1163 >> 2] = $1156; - var $1164 = $1156 + 24 | 0; - HEAP32[$1164 >> 2] = $R_1_i_i; - } - } - } - } while (0); - var $_sum9_i_i = $1029 | $991; - var $_sum88_i = $_sum9_i_i + $tsize_242_i | 0; - var $1168 = $tbase_243_i + $_sum88_i | 0; - var $1169 = $1168; - var $1170 = $1029 + $999 | 0; - var $oldfirst_0_i_i = $1169; - var $qsize_0_i_i = $1170; - } else { - var $oldfirst_0_i_i = $993; - var $qsize_0_i_i = $999; - } - var $qsize_0_i_i; - var $oldfirst_0_i_i; - var $1172 = $oldfirst_0_i_i + 4 | 0; - var $1173 = HEAP32[$1172 >> 2]; - var $1174 = $1173 & -2; - HEAP32[$1172 >> 2] = $1174; - var $1175 = $qsize_0_i_i | 1; - var $_sum10_i_i = $_sum_i16_i + 4 | 0; - var $1176 = $tbase_243_i + $_sum10_i_i | 0; - var $1177 = $1176; - HEAP32[$1177 >> 2] = $1175; - var $_sum11_i19_i = $qsize_0_i_i + $_sum_i16_i | 0; - var $1178 = $tbase_243_i + $_sum11_i19_i | 0; - var $1179 = $1178; - HEAP32[$1179 >> 2] = $qsize_0_i_i; - var $1180 = $qsize_0_i_i >>> 0 < 256; - if ($1180) { - var $1182 = $qsize_0_i_i >>> 3; - var $1183 = $qsize_0_i_i >>> 2; - var $1184 = $1183 & 1073741822; - var $1185 = __gm_ + 40 + ($1184 << 2) | 0; - var $1186 = $1185; - var $1187 = HEAP32[(__gm_ | 0) >> 2]; - var $1188 = 1 << $1182; - var $1189 = $1187 & $1188; - var $1190 = ($1189 | 0) == 0; - do { - if ($1190) { - var $1192 = $1187 | $1188; - HEAP32[(__gm_ | 0) >> 2] = $1192; - var $_sum26_pre_i_i = $1184 + 2 | 0; - var $_pre_i_i = __gm_ + 40 + ($_sum26_pre_i_i << 2) | 0; - var $F4_0_i_i = $1186; - var $_pre_phi_i20_i = $_pre_i_i; - } else { - var $_sum29_i_i = $1184 + 2 | 0; - var $1194 = __gm_ + 40 + ($_sum29_i_i << 2) | 0; - var $1195 = HEAP32[$1194 >> 2]; - var $1196 = $1195; - var $1197 = HEAP32[(__gm_ + 16 | 0) >> 2]; - var $1198 = $1196 >>> 0 < $1197 >>> 0; - if (!$1198) { - var $F4_0_i_i = $1195; - var $_pre_phi_i20_i = $1194; - break; - } - _abort(); - } - } while (0); - var $_pre_phi_i20_i; - var $F4_0_i_i; - HEAP32[$_pre_phi_i20_i >> 2] = $998; - var $1201 = $F4_0_i_i + 12 | 0; - HEAP32[$1201 >> 2] = $998; - var $_sum27_i_i = $_sum_i16_i + 8 | 0; - var $1202 = $tbase_243_i + $_sum27_i_i | 0; - var $1203 = $1202; - HEAP32[$1203 >> 2] = $F4_0_i_i; - var $_sum28_i_i = $_sum_i16_i + 12 | 0; - var $1204 = $tbase_243_i + $_sum28_i_i | 0; - var $1205 = $1204; - HEAP32[$1205 >> 2] = $1186; - } else { - var $1207 = $997; - var $1208 = $qsize_0_i_i >>> 8; - var $1209 = ($1208 | 0) == 0; - do { - if ($1209) { - var $I7_0_i_i = 0; - } else { - var $1211 = $qsize_0_i_i >>> 0 > 16777215; - if ($1211) { - var $I7_0_i_i = 31; - break; - } - var $1213 = $1208 + 1048320 | 0; - var $1214 = $1213 >>> 16; - var $1215 = $1214 & 8; - var $1216 = $1208 << $1215; - var $1217 = $1216 + 520192 | 0; - var $1218 = $1217 >>> 16; - var $1219 = $1218 & 4; - var $1220 = $1216 << $1219; - var $1221 = $1220 + 245760 | 0; - var $1222 = $1221 >>> 16; - var $1223 = $1222 & 2; - var $1224 = $1219 | $1215; - var $1225 = $1224 | $1223; - var $1226 = 14 - $1225 | 0; - var $1227 = $1220 << $1223; - var $1228 = $1227 >>> 15; - var $1229 = $1226 + $1228 | 0; - var $1230 = $1229 << 1; - var $1231 = $1229 + 7 | 0; - var $1232 = $qsize_0_i_i >>> ($1231 >>> 0); - var $1233 = $1232 & 1; - var $1234 = $1233 | $1230; - var $I7_0_i_i = $1234; - } - } while (0); - var $I7_0_i_i; - var $1236 = __gm_ + 304 + ($I7_0_i_i << 2) | 0; - var $_sum12_i_i = $_sum_i16_i + 28 | 0; - var $1237 = $tbase_243_i + $_sum12_i_i | 0; - var $1238 = $1237; - HEAP32[$1238 >> 2] = $I7_0_i_i; - var $_sum13_i_i = $_sum_i16_i + 16 | 0; - var $1239 = $tbase_243_i + $_sum13_i_i | 0; - var $_sum14_i_i = $_sum_i16_i + 20 | 0; - var $1240 = $tbase_243_i + $_sum14_i_i | 0; - var $1241 = $1240; - HEAP32[$1241 >> 2] = 0; - var $1242 = $1239; - HEAP32[$1242 >> 2] = 0; - var $1243 = HEAP32[(__gm_ + 4 | 0) >> 2]; - var $1244 = 1 << $I7_0_i_i; - var $1245 = $1243 & $1244; - var $1246 = ($1245 | 0) == 0; - if ($1246) { - var $1248 = $1243 | $1244; - HEAP32[(__gm_ + 4 | 0) >> 2] = $1248; - HEAP32[$1236 >> 2] = $1207; - var $1249 = $1236; - var $_sum15_i_i = $_sum_i16_i + 24 | 0; - var $1250 = $tbase_243_i + $_sum15_i_i | 0; - var $1251 = $1250; - HEAP32[$1251 >> 2] = $1249; - var $_sum16_i_i = $_sum_i16_i + 12 | 0; - var $1252 = $tbase_243_i + $_sum16_i_i | 0; - var $1253 = $1252; - HEAP32[$1253 >> 2] = $1207; - var $_sum17_i_i = $_sum_i16_i + 8 | 0; - var $1254 = $tbase_243_i + $_sum17_i_i | 0; - var $1255 = $1254; - HEAP32[$1255 >> 2] = $1207; - } else { - var $1257 = HEAP32[$1236 >> 2]; - var $1258 = ($I7_0_i_i | 0) == 31; - if ($1258) { - var $1263 = 0; - } else { - var $1260 = $I7_0_i_i >>> 1; - var $1261 = 25 - $1260 | 0; - var $1263 = $1261; - } - var $1263; - var $1264 = $qsize_0_i_i << $1263; - var $K8_0_i_i = $1264; - var $T_0_i21_i = $1257; - while (1) { - var $T_0_i21_i; - var $K8_0_i_i; - var $1266 = $T_0_i21_i + 4 | 0; - var $1267 = HEAP32[$1266 >> 2]; - var $1268 = $1267 & -8; - var $1269 = ($1268 | 0) == ($qsize_0_i_i | 0); - if ($1269) { - var $1289 = $T_0_i21_i + 8 | 0; - var $1290 = HEAP32[$1289 >> 2]; - var $1291 = $T_0_i21_i; - var $1292 = HEAP32[(__gm_ + 16 | 0) >> 2]; - var $1293 = $1291 >>> 0 < $1292 >>> 0; - do { - if (!$1293) { - var $1295 = $1290; - var $1296 = $1295 >>> 0 < $1292 >>> 0; - if ($1296) { - break; - } - var $1298 = $1290 + 12 | 0; - HEAP32[$1298 >> 2] = $1207; - HEAP32[$1289 >> 2] = $1207; - var $_sum20_i_i = $_sum_i16_i + 8 | 0; - var $1299 = $tbase_243_i + $_sum20_i_i | 0; - var $1300 = $1299; - HEAP32[$1300 >> 2] = $1290; - var $_sum21_i_i = $_sum_i16_i + 12 | 0; - var $1301 = $tbase_243_i + $_sum21_i_i | 0; - var $1302 = $1301; - HEAP32[$1302 >> 2] = $T_0_i21_i; - var $_sum22_i_i = $_sum_i16_i + 24 | 0; - var $1303 = $tbase_243_i + $_sum22_i_i | 0; - var $1304 = $1303; - HEAP32[$1304 >> 2] = 0; - break $_$314; - } - } while (0); - _abort(); - } else { - var $1271 = $K8_0_i_i >>> 31; - var $1272 = $T_0_i21_i + 16 + ($1271 << 2) | 0; - var $1273 = HEAP32[$1272 >> 2]; - var $1274 = ($1273 | 0) == 0; - var $1275 = $K8_0_i_i << 1; - if (!$1274) { - var $K8_0_i_i = $1275; - var $T_0_i21_i = $1273; - continue; - } - var $1277 = $1272; - var $1278 = HEAP32[(__gm_ + 16 | 0) >> 2]; - var $1279 = $1277 >>> 0 < $1278 >>> 0; - if (!$1279) { - HEAP32[$1272 >> 2] = $1207; - var $_sum23_i_i = $_sum_i16_i + 24 | 0; - var $1281 = $tbase_243_i + $_sum23_i_i | 0; - var $1282 = $1281; - HEAP32[$1282 >> 2] = $T_0_i21_i; - var $_sum24_i_i = $_sum_i16_i + 12 | 0; - var $1283 = $tbase_243_i + $_sum24_i_i | 0; - var $1284 = $1283; - HEAP32[$1284 >> 2] = $1207; - var $_sum25_i_i = $_sum_i16_i + 8 | 0; - var $1285 = $tbase_243_i + $_sum25_i_i | 0; - var $1286 = $1285; - HEAP32[$1286 >> 2] = $1207; - break $_$314; - } - _abort(); - } - } - } - } - } - } - } while (0); - var $_sum1819_i_i = $981 | 8; - var $1305 = $tbase_243_i + $_sum1819_i_i | 0; - var $mem_0 = $1305; - break $_$215; - } - } while (0); - var $1306 = $876; - var $sp_0_i_i_i = __gm_ + 444 | 0; - while (1) { - var $sp_0_i_i_i; - var $1308 = $sp_0_i_i_i | 0; - var $1309 = HEAP32[$1308 >> 2]; - var $1310 = $1309 >>> 0 > $1306 >>> 0; - if (!$1310) { - var $1312 = $sp_0_i_i_i + 4 | 0; - var $1313 = HEAP32[$1312 >> 2]; - var $1314 = $1309 + $1313 | 0; - var $1315 = $1314 >>> 0 > $1306 >>> 0; - if ($1315) { - var $1321 = $1309; - var $1320 = $1313; - break; - } - } - var $1317 = $sp_0_i_i_i + 8 | 0; - var $1318 = HEAP32[$1317 >> 2]; - var $1319 = ($1318 | 0) == 0; - if (!$1319) { - var $sp_0_i_i_i = $1318; - continue; - } - var $_pre14_i_i = 4; - var $1321 = 0; - var $1320 = $_pre14_i_i; - break; - } - var $1320; - var $1321; - var $1322 = $1321 + $1320 | 0; - var $_sum1_i10_i = $1320 - 39 | 0; - var $1323 = $1321 + $_sum1_i10_i | 0; - var $1324 = $1323; - var $1325 = $1324 & 7; - var $1326 = ($1325 | 0) == 0; - if ($1326) { - var $1331 = 0; - } else { - var $1328 = -$1324 | 0; - var $1329 = $1328 & 7; - var $1331 = $1329; - } - var $1331; - var $_sum_i11_i = $1320 - 47 | 0; - var $_sum2_i12_i = $_sum_i11_i + $1331 | 0; - var $1332 = $1321 + $_sum2_i12_i | 0; - var $1333 = $876 + 16 | 0; - var $1334 = $1333; - var $1335 = $1332 >>> 0 < $1334 >>> 0; - var $1336 = $1335 ? $1306 : $1332; - var $1337 = $1336 + 8 | 0; - var $1338 = $1337; - var $1339 = $tbase_243_i + 8 | 0; - var $1340 = $1339; - var $1341 = $1340 & 7; - var $1342 = ($1341 | 0) == 0; - if ($1342) { - var $1346 = 0; - } else { - var $1344 = -$1340 | 0; - var $1345 = $1344 & 7; - var $1346 = $1345; - } - var $1346; - var $1347 = $tbase_243_i + $1346 | 0; - var $1348 = $1347; - var $1349 = $tsize_242_i - 40 | 0; - var $1350 = $1349 - $1346 | 0; - HEAP32[(__gm_ + 24 | 0) >> 2] = $1348; - HEAP32[(__gm_ + 12 | 0) >> 2] = $1350; - var $1351 = $1350 | 1; - var $_sum_i_i_i = $1346 + 4 | 0; - var $1352 = $tbase_243_i + $_sum_i_i_i | 0; - var $1353 = $1352; - HEAP32[$1353 >> 2] = $1351; - var $_sum2_i_i_i = $tsize_242_i - 36 | 0; - var $1354 = $tbase_243_i + $_sum2_i_i_i | 0; - var $1355 = $1354; - HEAP32[$1355 >> 2] = 40; - var $1356 = HEAP32[(_mparams + 16 | 0) >> 2]; - HEAP32[(__gm_ + 28 | 0) >> 2] = $1356; - var $1357 = $1336 + 4 | 0; - var $1358 = $1357; - HEAP32[$1358 >> 2] = 27; - HEAP32[$1337 >> 2] = HEAP32[(__gm_ + 444 | 0) >> 2]; - HEAP32[$1337 + 4 >> 2] = HEAP32[(__gm_ + 444 | 0) + 4 >> 2]; - HEAP32[$1337 + 8 >> 2] = HEAP32[(__gm_ + 444 | 0) + 8 >> 2]; - HEAP32[$1337 + 12 >> 2] = HEAP32[(__gm_ + 444 | 0) + 12 >> 2]; - HEAP32[(__gm_ + 444 | 0) >> 2] = $tbase_243_i; - HEAP32[(__gm_ + 448 | 0) >> 2] = $tsize_242_i; - HEAP32[(__gm_ + 456 | 0) >> 2] = 0; - HEAP32[(__gm_ + 452 | 0) >> 2] = $1338; - var $1359 = $1336 + 28 | 0; - var $1360 = $1359; - HEAP32[$1360 >> 2] = 7; - var $1361 = $1336 + 32 | 0; - var $1362 = $1361 >>> 0 < $1322 >>> 0; - $_$426 : do { - if ($1362) { - var $1363 = $1360; - while (1) { - var $1363; - var $1364 = $1363 + 4 | 0; - HEAP32[$1364 >> 2] = 7; - var $1365 = $1363 + 8 | 0; - var $1366 = $1365; - var $1367 = $1366 >>> 0 < $1322 >>> 0; - if (!$1367) { - break $_$426; - } - var $1363 = $1364; - } - } - } while (0); - var $1368 = ($1336 | 0) == ($1306 | 0); - if ($1368) { - break; - } - var $1370 = $1336; - var $1371 = $876; - var $1372 = $1370 - $1371 | 0; - var $1373 = $1306 + $1372 | 0; - var $_sum3_i_i = $1372 + 4 | 0; - var $1374 = $1306 + $_sum3_i_i | 0; - var $1375 = $1374; - var $1376 = HEAP32[$1375 >> 2]; - var $1377 = $1376 & -2; - HEAP32[$1375 >> 2] = $1377; - var $1378 = $1372 | 1; - var $1379 = $876 + 4 | 0; - HEAP32[$1379 >> 2] = $1378; - var $1380 = $1373; - HEAP32[$1380 >> 2] = $1372; - var $1381 = $1372 >>> 0 < 256; - if ($1381) { - var $1383 = $1372 >>> 3; - var $1384 = $1372 >>> 2; - var $1385 = $1384 & 1073741822; - var $1386 = __gm_ + 40 + ($1385 << 2) | 0; - var $1387 = $1386; - var $1388 = HEAP32[(__gm_ | 0) >> 2]; - var $1389 = 1 << $1383; - var $1390 = $1388 & $1389; - var $1391 = ($1390 | 0) == 0; - do { - if ($1391) { - var $1393 = $1388 | $1389; - HEAP32[(__gm_ | 0) >> 2] = $1393; - var $_sum10_pre_i_i = $1385 + 2 | 0; - var $_pre15_i_i = __gm_ + 40 + ($_sum10_pre_i_i << 2) | 0; - var $F_0_i_i = $1387; - var $_pre_phi_i_i = $_pre15_i_i; - } else { - var $_sum11_i_i = $1385 + 2 | 0; - var $1395 = __gm_ + 40 + ($_sum11_i_i << 2) | 0; - var $1396 = HEAP32[$1395 >> 2]; - var $1397 = $1396; - var $1398 = HEAP32[(__gm_ + 16 | 0) >> 2]; - var $1399 = $1397 >>> 0 < $1398 >>> 0; - if (!$1399) { - var $F_0_i_i = $1396; - var $_pre_phi_i_i = $1395; - break; - } - _abort(); - } - } while (0); - var $_pre_phi_i_i; - var $F_0_i_i; - HEAP32[$_pre_phi_i_i >> 2] = $876; - var $1402 = $F_0_i_i + 12 | 0; - HEAP32[$1402 >> 2] = $876; - var $1403 = $876 + 8 | 0; - HEAP32[$1403 >> 2] = $F_0_i_i; - var $1404 = $876 + 12 | 0; - HEAP32[$1404 >> 2] = $1387; - } else { - var $1406 = $876; - var $1407 = $1372 >>> 8; - var $1408 = ($1407 | 0) == 0; - do { - if ($1408) { - var $I1_0_i_i = 0; - } else { - var $1410 = $1372 >>> 0 > 16777215; - if ($1410) { - var $I1_0_i_i = 31; - break; - } - var $1412 = $1407 + 1048320 | 0; - var $1413 = $1412 >>> 16; - var $1414 = $1413 & 8; - var $1415 = $1407 << $1414; - var $1416 = $1415 + 520192 | 0; - var $1417 = $1416 >>> 16; - var $1418 = $1417 & 4; - var $1419 = $1415 << $1418; - var $1420 = $1419 + 245760 | 0; - var $1421 = $1420 >>> 16; - var $1422 = $1421 & 2; - var $1423 = $1418 | $1414; - var $1424 = $1423 | $1422; - var $1425 = 14 - $1424 | 0; - var $1426 = $1419 << $1422; - var $1427 = $1426 >>> 15; - var $1428 = $1425 + $1427 | 0; - var $1429 = $1428 << 1; - var $1430 = $1428 + 7 | 0; - var $1431 = $1372 >>> ($1430 >>> 0); - var $1432 = $1431 & 1; - var $1433 = $1432 | $1429; - var $I1_0_i_i = $1433; - } - } while (0); - var $I1_0_i_i; - var $1435 = __gm_ + 304 + ($I1_0_i_i << 2) | 0; - var $1436 = $876 + 28 | 0; - var $I1_0_c_i_i = $I1_0_i_i; - HEAP32[$1436 >> 2] = $I1_0_c_i_i; - var $1437 = $876 + 20 | 0; - HEAP32[$1437 >> 2] = 0; - var $1438 = $876 + 16 | 0; - HEAP32[$1438 >> 2] = 0; - var $1439 = HEAP32[(__gm_ + 4 | 0) >> 2]; - var $1440 = 1 << $I1_0_i_i; - var $1441 = $1439 & $1440; - var $1442 = ($1441 | 0) == 0; - if ($1442) { - var $1444 = $1439 | $1440; - HEAP32[(__gm_ + 4 | 0) >> 2] = $1444; - HEAP32[$1435 >> 2] = $1406; - var $1445 = $876 + 24 | 0; - var $_c_i_i = $1435; - HEAP32[$1445 >> 2] = $_c_i_i; - var $1446 = $876 + 12 | 0; - HEAP32[$1446 >> 2] = $876; - var $1447 = $876 + 8 | 0; - HEAP32[$1447 >> 2] = $876; - } else { - var $1449 = HEAP32[$1435 >> 2]; - var $1450 = ($I1_0_i_i | 0) == 31; - if ($1450) { - var $1455 = 0; - } else { - var $1452 = $I1_0_i_i >>> 1; - var $1453 = 25 - $1452 | 0; - var $1455 = $1453; - } - var $1455; - var $1456 = $1372 << $1455; - var $K2_0_i_i = $1456; - var $T_0_i_i = $1449; - while (1) { - var $T_0_i_i; - var $K2_0_i_i; - var $1458 = $T_0_i_i + 4 | 0; - var $1459 = HEAP32[$1458 >> 2]; - var $1460 = $1459 & -8; - var $1461 = ($1460 | 0) == ($1372 | 0); - if ($1461) { - var $1478 = $T_0_i_i + 8 | 0; - var $1479 = HEAP32[$1478 >> 2]; - var $1480 = $T_0_i_i; - var $1481 = HEAP32[(__gm_ + 16 | 0) >> 2]; - var $1482 = $1480 >>> 0 < $1481 >>> 0; - do { - if (!$1482) { - var $1484 = $1479; - var $1485 = $1484 >>> 0 < $1481 >>> 0; - if ($1485) { - break; - } - var $1487 = $1479 + 12 | 0; - HEAP32[$1487 >> 2] = $1406; - HEAP32[$1478 >> 2] = $1406; - var $1488 = $876 + 8 | 0; - var $_c6_i_i = $1479; - HEAP32[$1488 >> 2] = $_c6_i_i; - var $1489 = $876 + 12 | 0; - var $T_0_c_i_i = $T_0_i_i; - HEAP32[$1489 >> 2] = $T_0_c_i_i; - var $1490 = $876 + 24 | 0; - HEAP32[$1490 >> 2] = 0; - break $_$275; - } - } while (0); - _abort(); - } else { - var $1463 = $K2_0_i_i >>> 31; - var $1464 = $T_0_i_i + 16 + ($1463 << 2) | 0; - var $1465 = HEAP32[$1464 >> 2]; - var $1466 = ($1465 | 0) == 0; - var $1467 = $K2_0_i_i << 1; - if (!$1466) { - var $K2_0_i_i = $1467; - var $T_0_i_i = $1465; - continue; - } - var $1469 = $1464; - var $1470 = HEAP32[(__gm_ + 16 | 0) >> 2]; - var $1471 = $1469 >>> 0 < $1470 >>> 0; - if (!$1471) { - HEAP32[$1464 >> 2] = $1406; - var $1473 = $876 + 24 | 0; - var $T_0_c7_i_i = $T_0_i_i; - HEAP32[$1473 >> 2] = $T_0_c7_i_i; - var $1474 = $876 + 12 | 0; - HEAP32[$1474 >> 2] = $876; - var $1475 = $876 + 8 | 0; - HEAP32[$1475 >> 2] = $876; - break $_$275; - } - _abort(); - } - } - } - } - } - } while (0); - var $1491 = HEAP32[(__gm_ + 12 | 0) >> 2]; - var $1492 = $1491 >>> 0 > $nb_0 >>> 0; - if (!$1492) { + if ($1408) { + var $I1_0_i_i = 0; + } else { + var $1410 = $1372 >>> 0 > 16777215; + if ($1410) { + var $I1_0_i_i = 31; + break; + } + var $1412 = $1407 + 1048320 | 0; + var $1413 = $1412 >>> 16; + var $1414 = $1413 & 8; + var $1415 = $1407 << $1414; + var $1416 = $1415 + 520192 | 0; + var $1417 = $1416 >>> 16; + var $1418 = $1417 & 4; + var $1419 = $1415 << $1418; + var $1420 = $1419 + 245760 | 0; + var $1421 = $1420 >>> 16; + var $1422 = $1421 & 2; + var $1423 = $1418 | $1414; + var $1424 = $1423 | $1422; + var $1425 = 14 - $1424 | 0; + var $1426 = $1419 << $1422; + var $1427 = $1426 >>> 15; + var $1428 = $1425 + $1427 | 0; + var $1429 = $1428 << 1; + var $1430 = $1428 + 7 | 0; + var $1431 = $1372 >>> ($1430 >>> 0); + var $1432 = $1431 & 1; + var $1433 = $1432 | $1429; + var $I1_0_i_i = $1433; + } + } while (0); + var $I1_0_i_i; + var $1435 = __gm_ + 304 + ($I1_0_i_i << 2) | 0; + var $1436 = $876 + 28 | 0; + var $I1_0_c_i_i = $I1_0_i_i; + HEAP32[$1436 >> 2] = $I1_0_c_i_i; + var $1437 = $876 + 20 | 0; + HEAP32[$1437 >> 2] = 0; + var $1438 = $876 + 16 | 0; + HEAP32[$1438 >> 2] = 0; + var $1439 = HEAP32[(__gm_ + 4 | 0) >> 2]; + var $1440 = 1 << $I1_0_i_i; + var $1441 = $1439 & $1440; + var $1442 = ($1441 | 0) == 0; + if ($1442) { + var $1444 = $1439 | $1440; + HEAP32[(__gm_ + 4 | 0) >> 2] = $1444; + HEAP32[$1435 >> 2] = $1406; + var $1445 = $876 + 24 | 0; + var $_c_i_i = $1435; + HEAP32[$1445 >> 2] = $_c_i_i; + var $1446 = $876 + 12 | 0; + HEAP32[$1446 >> 2] = $876; + var $1447 = $876 + 8 | 0; + HEAP32[$1447 >> 2] = $876; + } else { + var $1449 = HEAP32[$1435 >> 2]; + var $1450 = ($I1_0_i_i | 0) == 31; + if ($1450) { + var $1455 = 0; + } else { + var $1452 = $I1_0_i_i >>> 1; + var $1453 = 25 - $1452 | 0; + var $1455 = $1453; + } + var $1455; + var $1456 = $1372 << $1455; + var $K2_0_i_i = $1456; + var $T_0_i_i = $1449; + while (1) { + var $T_0_i_i; + var $K2_0_i_i; + var $1458 = $T_0_i_i + 4 | 0; + var $1459 = HEAP32[$1458 >> 2]; + var $1460 = $1459 & -8; + var $1461 = ($1460 | 0) == ($1372 | 0); + if ($1461) { + var $1478 = $T_0_i_i + 8 | 0; + var $1479 = HEAP32[$1478 >> 2]; + var $1480 = $T_0_i_i; + var $1481 = HEAP32[(__gm_ + 16 | 0) >> 2]; + var $1482 = $1480 >>> 0 < $1481 >>> 0; + do { + if (!$1482) { + var $1484 = $1479; + var $1485 = $1484 >>> 0 < $1481 >>> 0; + if ($1485) { break; + } + var $1487 = $1479 + 12 | 0; + HEAP32[$1487 >> 2] = $1406; + HEAP32[$1478 >> 2] = $1406; + var $1488 = $876 + 8 | 0; + var $_c6_i_i = $1479; + HEAP32[$1488 >> 2] = $_c6_i_i; + var $1489 = $876 + 12 | 0; + var $T_0_c_i_i = $T_0_i_i; + HEAP32[$1489 >> 2] = $T_0_c_i_i; + var $1490 = $876 + 24 | 0; + HEAP32[$1490 >> 2] = 0; + break $_$275; } - var $1494 = $1491 - $nb_0 | 0; - HEAP32[(__gm_ + 12 | 0) >> 2] = $1494; - var $1495 = HEAP32[(__gm_ + 24 | 0) >> 2]; - var $1496 = $1495; - var $1497 = $1496 + $nb_0 | 0; - var $1498 = $1497; - HEAP32[(__gm_ + 24 | 0) >> 2] = $1498; - var $1499 = $1494 | 1; - var $_sum_i30 = $nb_0 + 4 | 0; - var $1500 = $1496 + $_sum_i30 | 0; - var $1501 = $1500; - HEAP32[$1501 >> 2] = $1499; - var $1502 = $nb_0 | 3; - var $1503 = $1495 + 4 | 0; - HEAP32[$1503 >> 2] = $1502; - var $1504 = $1495 + 8 | 0; - var $1505 = $1504; - var $mem_0 = $1505; - break $_$215; + } while (0); + _abort(); + } else { + var $1463 = $K2_0_i_i >>> 31; + var $1464 = $T_0_i_i + 16 + ($1463 << 2) | 0; + var $1465 = HEAP32[$1464 >> 2]; + var $1466 = ($1465 | 0) == 0; + var $1467 = $K2_0_i_i << 1; + if (!$1466) { + var $K2_0_i_i = $1467; + var $T_0_i_i = $1465; + continue; + } + var $1469 = $1464; + var $1470 = HEAP32[(__gm_ + 16 | 0) >> 2]; + var $1471 = $1469 >>> 0 < $1470 >>> 0; + if (!$1471) { + HEAP32[$1464 >> 2] = $1406; + var $1473 = $876 + 24 | 0; + var $T_0_c7_i_i = $T_0_i_i; + HEAP32[$1473 >> 2] = $T_0_c7_i_i; + var $1474 = $876 + 12 | 0; + HEAP32[$1474 >> 2] = $876; + var $1475 = $876 + 8 | 0; + HEAP32[$1475 >> 2] = $876; + break $_$275; + } + _abort(); } - } while (0); - var $1506 = ___errno(); - HEAP32[$1506 >> 2] = 12; - var $mem_0 = 0; - } - } else { - var $706 = $703 - $nb_0 | 0; - var $707 = HEAP32[(__gm_ + 20 | 0) >> 2]; - var $708 = $706 >>> 0 > 15; - if ($708) { - var $710 = $707; - var $711 = $710 + $nb_0 | 0; - var $712 = $711; - HEAP32[(__gm_ + 20 | 0) >> 2] = $712; - HEAP32[(__gm_ + 8 | 0) >> 2] = $706; - var $713 = $706 | 1; - var $_sum2 = $nb_0 + 4 | 0; - var $714 = $710 + $_sum2 | 0; - var $715 = $714; - HEAP32[$715 >> 2] = $713; - var $716 = $710 + $703 | 0; - var $717 = $716; - HEAP32[$717 >> 2] = $706; - var $718 = $nb_0 | 3; - var $719 = $707 + 4 | 0; - HEAP32[$719 >> 2] = $718; - } else { - HEAP32[(__gm_ + 8 | 0) >> 2] = 0; - HEAP32[(__gm_ + 20 | 0) >> 2] = 0; - var $721 = $703 | 3; - var $722 = $707 + 4 | 0; - HEAP32[$722 >> 2] = $721; - var $723 = $707; - var $_sum1 = $703 + 4 | 0; - var $724 = $723 + $_sum1 | 0; - var $725 = $724; - var $726 = HEAP32[$725 >> 2]; - var $727 = $726 | 1; - HEAP32[$725 >> 2] = $727; + } + } + } } - var $729 = $707 + 8 | 0; - var $730 = $729; - var $mem_0 = $730; + } while (0); + var $1491 = HEAP32[(__gm_ + 12 | 0) >> 2]; + var $1492 = $1491 >>> 0 > $nb_0 >>> 0; + if (!$1492) { + break; + } + var $1494 = $1491 - $nb_0 | 0; + HEAP32[(__gm_ + 12 | 0) >> 2] = $1494; + var $1495 = HEAP32[(__gm_ + 24 | 0) >> 2]; + var $1496 = $1495; + var $1497 = $1496 + $nb_0 | 0; + var $1498 = $1497; + HEAP32[(__gm_ + 24 | 0) >> 2] = $1498; + var $1499 = $1494 | 1; + var $_sum_i30 = $nb_0 + 4 | 0; + var $1500 = $1496 + $_sum_i30 | 0; + var $1501 = $1500; + HEAP32[$1501 >> 2] = $1499; + var $1502 = $nb_0 | 3; + var $1503 = $1495 + 4 | 0; + HEAP32[$1503 >> 2] = $1502; + var $1504 = $1495 + 8 | 0; + var $1505 = $1504; + var $mem_0 = $1505; + break $_$215; } + } while (0); + var $1506 = ___errno(); + HEAP32[$1506 >> 2] = 12; + var $mem_0 = 0; + } + } else { + var $706 = $703 - $nb_0 | 0; + var $707 = HEAP32[(__gm_ + 20 | 0) >> 2]; + var $708 = $706 >>> 0 > 15; + if ($708) { + var $710 = $707; + var $711 = $710 + $nb_0 | 0; + var $712 = $711; + HEAP32[(__gm_ + 20 | 0) >> 2] = $712; + HEAP32[(__gm_ + 8 | 0) >> 2] = $706; + var $713 = $706 | 1; + var $_sum2 = $nb_0 + 4 | 0; + var $714 = $710 + $_sum2 | 0; + var $715 = $714; + HEAP32[$715 >> 2] = $713; + var $716 = $710 + $703 | 0; + var $717 = $716; + HEAP32[$717 >> 2] = $706; + var $718 = $nb_0 | 3; + var $719 = $707 + 4 | 0; + HEAP32[$719 >> 2] = $718; + } else { + HEAP32[(__gm_ + 8 | 0) >> 2] = 0; + HEAP32[(__gm_ + 20 | 0) >> 2] = 0; + var $721 = $703 | 3; + var $722 = $707 + 4 | 0; + HEAP32[$722 >> 2] = $721; + var $723 = $707; + var $_sum1 = $703 + 4 | 0; + var $724 = $723 + $_sum1 | 0; + var $725 = $724; + var $726 = HEAP32[$725 >> 2]; + var $727 = $726 | 1; + HEAP32[$725 >> 2] = $727; } - } while (0); - var $mem_0; - return $mem_0; - return null; + var $729 = $707 + 8 | 0; + var $730 = $729; + var $mem_0 = $730; + } + } + } while (0); + var $mem_0; + return $mem_0; + return null; } function asm(x, y) { // asm-style code, without special asm requested so will not be fully optimized - x = +x; - y = y|0; - var a = 0, b = +0, c = 0; - var label = 0; - a = cheez((y+~~x)|0)|0; - b = a*a; - fleefl(b|0, a|0); + x = +x; + y = y|0; + var a = 0, b = +0, c = 0; + var label = 0; + a = cheez((y+~~x)|0)|0; + b = a*a; + fleefl(b|0, a|0); } function phi() { - if (wat()) { - var $10 = 1; - } else { - var $7=_init_mparams(); - var $8=(($7)|0)!=0; - var $10 = $8; - } - var $10; + if (wat()) { + var $10 = 1; + } else { + var $7=_init_mparams(); + var $8=(($7)|0)!=0; + var $10 = $8; + } + var $10; } function intoCond() { - var $115 = 22; - var $499 = __ZN4llvm15BitstreamCursor4ReadEj($117, 32); - var $NumWords = $499; - var $500 = $115; - var $501 = ($500 | 0) != 0; - if ($501) { - var $503 = $NumWords; - var $504 = $115; - HEAP32[$504 >> 2] = $503; - } + var $115 = 22; + var $499 = __ZN4llvm15BitstreamCursor4ReadEj($117, 32); + var $NumWords = $499; + var $500 = $115; + var $501 = ($500 | 0) != 0; + if ($501) { + var $503 = $NumWords; + var $504 = $115; + HEAP32[$504 >> 2] = $503; + } } // EMSCRIPTEN_GENERATED_FUNCTIONS: ["a", "b", "c", "f", "g", "h", "py", "r", "t", "f2", "f3", "llvm3_1", "_inflate", "_malloc", "_mallocNoU", "asm", "phi", "intoCond"] diff --git a/tools/eliminator/safe-eliminator-test-output.js b/tools/eliminator/safe-eliminator-test-output.js index 57f0a74390f1e..36b0bb1f9ab48 100644 --- a/tools/eliminator/safe-eliminator-test-output.js +++ b/tools/eliminator/safe-eliminator-test-output.js @@ -1,85 +1,85 @@ function a($directory) { - chak($directory + _strlen($directory) | 0); - var $210 = HEAP32[100]; - HEAP32[1e3] = HEAP32[5]; - HEAP32[90] = $210; - chak(); - var $210a = HEAP32[100]; - something(); - HEAP32[90] = $210a; - chak(); - HEAP32[1e3] = HEAP32[5]; - HEAP32[90] = $hack; - chak(); - var $b = HEAP32[11] + 7 | 0; - HEAP32[1e3] = HEAP32[5]; - HEAP32[90] = $b; - chak(); - var $bb2 = HEAP32[11]; - HEAP32[111] = 321; - HEAP32[1e3] = HEAP32[5]; - HEAP32[90] = $bb2 + 7 | 0; - chak(); - HEAP32[1e3] = HEAP32[100]; - chak(); - var $e = func(); - HEAP32[1e3] = $e; - chak(); - tor(func()); - chak(); - tor(HEAP[9]); - barrier(); - var $$210, $$210a, $$b, $$bb2, $$e; - $$210 = HEAP32[100]; - HEAP32[1e3] = HEAP32[5]; - HEAP32[90] = $$210; - chak(); - $$210a = HEAP32[100]; - something(); - HEAP32[90] = $$210a; - chak(); - HEAP32[1e3] = HEAP32[5]; - HEAP32[90] = $$hack; - chak(); - $$b = HEAP32[11] + 7 | 0; - HEAP32[1e3] = HEAP32[5]; - HEAP32[90] = $$b; - chak(); - $$bb2 = HEAP32[11]; - HEAP32[111] = 321; - HEAP32[1e3] = HEAP32[5]; - HEAP32[90] = $$bb2 + 7 | 0; - chak(); - HEAP32[1e3] = HEAP32[100]; - chak(); - $$e = func(); - HEAP32[1e3] = $$e; - chak(); - tor(func()); - chak(); - tor(HEAP[9]); - barrier(); - var $65, $image, $51$s2, $71; - var $71 = HEAP32[$65 >> 2] - _int_ceildiv(HEAP32[$image >> 2], HEAP32[$51$s2]) | 0; - HEAP32[$65 >> 2] = _int_ceildivpow2($71, HEAP32[$51$s2 + 10]); - barr(); - var ONCE = sheep(); - while (ONCE) { - work(); - } - var ONCEb = 75; - while (ONCEb) { - work(); - } - var $26 = __ZL3minIiET_S0_S0_12(4096, 4096 - $16 | 0); - print(FUNCTION_TABLE[$22]($18, $16 + ($this + 27) | 0, $26)); - chak(); - do { - print(10); - } while (0); - var zzz1 = 10; - do { - print(zzz1); - } while (1); + chak($directory + _strlen($directory) | 0); + var $210 = HEAP32[100]; + HEAP32[1e3] = HEAP32[5]; + HEAP32[90] = $210; + chak(); + var $210a = HEAP32[100]; + something(); + HEAP32[90] = $210a; + chak(); + HEAP32[1e3] = HEAP32[5]; + HEAP32[90] = $hack; + chak(); + var $b = HEAP32[11] + 7 | 0; + HEAP32[1e3] = HEAP32[5]; + HEAP32[90] = $b; + chak(); + var $bb2 = HEAP32[11]; + HEAP32[111] = 321; + HEAP32[1e3] = HEAP32[5]; + HEAP32[90] = $bb2 + 7 | 0; + chak(); + HEAP32[1e3] = HEAP32[100]; + chak(); + var $e = func(); + HEAP32[1e3] = $e; + chak(); + tor(func()); + chak(); + tor(HEAP[9]); + barrier(); + var $$210, $$210a, $$b, $$bb2, $$e; + $$210 = HEAP32[100]; + HEAP32[1e3] = HEAP32[5]; + HEAP32[90] = $$210; + chak(); + $$210a = HEAP32[100]; + something(); + HEAP32[90] = $$210a; + chak(); + HEAP32[1e3] = HEAP32[5]; + HEAP32[90] = $$hack; + chak(); + $$b = HEAP32[11] + 7 | 0; + HEAP32[1e3] = HEAP32[5]; + HEAP32[90] = $$b; + chak(); + $$bb2 = HEAP32[11]; + HEAP32[111] = 321; + HEAP32[1e3] = HEAP32[5]; + HEAP32[90] = $$bb2 + 7 | 0; + chak(); + HEAP32[1e3] = HEAP32[100]; + chak(); + $$e = func(); + HEAP32[1e3] = $$e; + chak(); + tor(func()); + chak(); + tor(HEAP[9]); + barrier(); + var $65, $image, $51$s2, $71; + var $71 = HEAP32[$65 >> 2] - _int_ceildiv(HEAP32[$image >> 2], HEAP32[$51$s2]) | 0; + HEAP32[$65 >> 2] = _int_ceildivpow2($71, HEAP32[$51$s2 + 10]); + barr(); + var ONCE = sheep(); + while (ONCE) { + work(); + } + var ONCEb = 75; + while (ONCEb) { + work(); + } + var $26 = __ZL3minIiET_S0_S0_12(4096, 4096 - $16 | 0); + print(FUNCTION_TABLE[$22]($18, $16 + ($this + 27) | 0, $26)); + chak(); + do { + print(10); + } while (0); + var zzz1 = 10; + do { + print(zzz1); + } while (1); } diff --git a/tools/eliminator/safe-eliminator-test.js b/tools/eliminator/safe-eliminator-test.js index a181fb8abf007..d7bfdeccef021 100644 --- a/tools/eliminator/safe-eliminator-test.js +++ b/tools/eliminator/safe-eliminator-test.js @@ -1,103 +1,103 @@ function a($directory) { - var $1 = _strlen($directory); - var $p_0 = $directory + $1 | 0; - chak($p_0); - var $210 = HEAP32[100]; // heaps alias each other! so this cannot be eliminated - HEAP32[1e3] = HEAP32[5]; - HEAP32[90] = $210; - chak(); - var $210a = HEAP32[100]; // function calls can also modify memory - something(); - HEAP32[90] = $210a; - chak(); - var $a = $hack; // no mem use (just a global), so ok to eliminate - HEAP32[1e3] = HEAP32[5]; - HEAP32[90] = $a; - chak(); - var $bb = HEAP32[11]; // ok to eliminate - var $b = ($bb+7)|0; // ok to eliminate by itself, but not with inlined $bb which is mem-using! - HEAP32[1e3] = HEAP32[5]; - HEAP32[90] = $b; - chak(); - var $bb2 = HEAP32[11]; - HEAP32[111] = 321; - var $b2 = ($bb2+7)|0; - HEAP32[1e3] = HEAP32[5]; - HEAP32[90] = $b2; - chak(); - var $d = HEAP32[100]; // alias on next line, but that is where we are consumed - so ok. - HEAP32[1e3] = $d; - chak(); - var $e = func(); - HEAP32[1e3] = $e; - chak(); - var $e2 = func(); - tor($e2); - chak(); - var $e3 = HEAP[9]; - tor($e3); - barrier(); // same stuff, but with a var on top and assigns as the first and only def - var $$210, $$210a, $$a, $$bb, $$b, $$bb2, $$b2, $$d, $$e, $$e2, $$e3; - $$210 = HEAP32[100]; // heaps alias each other! so this cannot be eliminated - HEAP32[1e3] = HEAP32[5]; - HEAP32[90] = $$210; - chak(); - $$210a = HEAP32[100]; // function calls can also modify memory - something(); - HEAP32[90] = $$210a; - chak(); - $$a = $$hack; // no mem use, so ok to eliminate - HEAP32[1e3] = HEAP32[5]; - HEAP32[90] = $$a; - chak(); - $$bb = HEAP32[11]; // ok to eliminate - $$b = ($$bb+7)|0; // ok to eliminate by itself, but not with inlined $$bb which is mem-using! - HEAP32[1e3] = HEAP32[5]; - HEAP32[90] = $$b; - chak(); - $$bb2 = HEAP32[11]; - HEAP32[111] = 321; - $$b2 = ($$bb2+7)|0; - HEAP32[1e3] = HEAP32[5]; - HEAP32[90] = $$b2; - chak(); - $$d = HEAP32[100]; // alias on next line, but that is where we are consumed - so ok. - HEAP32[1e3] = $$d; - chak(); - $$e = func(); - HEAP32[1e3] = $$e; - chak(); - $$e2 = func(); - tor($$e2); - chak(); - $$e3 = HEAP[9]; - tor($$e3); - barrier(); - var $65, $image, $51$s2, $71; - var $66 = HEAP32[$65 >> 2]; - var $71 = $66 - _int_ceildiv(HEAP32[$image >> 2], HEAP32[$51$s2]) | 0; - HEAP32[$65 >> 2] = _int_ceildivpow2($71, HEAP32[$51$s2 + 10]); - barr(); - var ONCE = sheep(); - while (ONCE) { - work(); - } - var ONCEb = 75; - while (ONCEb) { - work(); - } - var $26 = __ZL3minIiET_S0_S0_12(4096, 4096 - $16 | 0); // cannot eliminate this because the call might modify FUNCTION_TABLE - var $27 = FUNCTION_TABLE[$22]($18, $this + ($16 + 27) | 0, $26); - print($27); - chak(); - var zzz = 10; - do { - print(zzz); - } while (0); - var zzz1 = 10; - do { - print(zzz1); - } while (1); // cannot eliminate a do-while that is not one-time + var $1 = _strlen($directory); + var $p_0 = $directory + $1 | 0; + chak($p_0); + var $210 = HEAP32[100]; // heaps alias each other! so this cannot be eliminated + HEAP32[1e3] = HEAP32[5]; + HEAP32[90] = $210; + chak(); + var $210a = HEAP32[100]; // function calls can also modify memory + something(); + HEAP32[90] = $210a; + chak(); + var $a = $hack; // no mem use (just a global), so ok to eliminate + HEAP32[1e3] = HEAP32[5]; + HEAP32[90] = $a; + chak(); + var $bb = HEAP32[11]; // ok to eliminate + var $b = ($bb+7)|0; // ok to eliminate by itself, but not with inlined $bb which is mem-using! + HEAP32[1e3] = HEAP32[5]; + HEAP32[90] = $b; + chak(); + var $bb2 = HEAP32[11]; + HEAP32[111] = 321; + var $b2 = ($bb2+7)|0; + HEAP32[1e3] = HEAP32[5]; + HEAP32[90] = $b2; + chak(); + var $d = HEAP32[100]; // alias on next line, but that is where we are consumed - so ok. + HEAP32[1e3] = $d; + chak(); + var $e = func(); + HEAP32[1e3] = $e; + chak(); + var $e2 = func(); + tor($e2); + chak(); + var $e3 = HEAP[9]; + tor($e3); + barrier(); // same stuff, but with a var on top and assigns as the first and only def + var $$210, $$210a, $$a, $$bb, $$b, $$bb2, $$b2, $$d, $$e, $$e2, $$e3; + $$210 = HEAP32[100]; // heaps alias each other! so this cannot be eliminated + HEAP32[1e3] = HEAP32[5]; + HEAP32[90] = $$210; + chak(); + $$210a = HEAP32[100]; // function calls can also modify memory + something(); + HEAP32[90] = $$210a; + chak(); + $$a = $$hack; // no mem use, so ok to eliminate + HEAP32[1e3] = HEAP32[5]; + HEAP32[90] = $$a; + chak(); + $$bb = HEAP32[11]; // ok to eliminate + $$b = ($$bb+7)|0; // ok to eliminate by itself, but not with inlined $$bb which is mem-using! + HEAP32[1e3] = HEAP32[5]; + HEAP32[90] = $$b; + chak(); + $$bb2 = HEAP32[11]; + HEAP32[111] = 321; + $$b2 = ($$bb2+7)|0; + HEAP32[1e3] = HEAP32[5]; + HEAP32[90] = $$b2; + chak(); + $$d = HEAP32[100]; // alias on next line, but that is where we are consumed - so ok. + HEAP32[1e3] = $$d; + chak(); + $$e = func(); + HEAP32[1e3] = $$e; + chak(); + $$e2 = func(); + tor($$e2); + chak(); + $$e3 = HEAP[9]; + tor($$e3); + barrier(); + var $65, $image, $51$s2, $71; + var $66 = HEAP32[$65 >> 2]; + var $71 = $66 - _int_ceildiv(HEAP32[$image >> 2], HEAP32[$51$s2]) | 0; + HEAP32[$65 >> 2] = _int_ceildivpow2($71, HEAP32[$51$s2 + 10]); + barr(); + var ONCE = sheep(); + while (ONCE) { + work(); + } + var ONCEb = 75; + while (ONCEb) { + work(); + } + var $26 = __ZL3minIiET_S0_S0_12(4096, 4096 - $16 | 0); // cannot eliminate this because the call might modify FUNCTION_TABLE + var $27 = FUNCTION_TABLE[$22]($18, $this + ($16 + 27) | 0, $26); + print($27); + chak(); + var zzz = 10; + do { + print(zzz); + } while (0); + var zzz1 = 10; + do { + print(zzz1); + } while (1); // cannot eliminate a do-while that is not one-time } // EMSCRIPTEN_GENERATED_FUNCTIONS: ["a"] diff --git a/tools/test-js-optimizer-asm-last-output.js b/tools/test-js-optimizer-asm-last-output.js index 1dacd0cd38618..cbc0a4d34842a 100644 --- a/tools/test-js-optimizer-asm-last-output.js +++ b/tools/test-js-optimizer-asm-last-output.js @@ -1,46 +1,46 @@ function finall(x) { - x = +x; - var a = 5.0; - a = +x; - a = 17; - a = 44.0; - a = 44.0; - a = 44.9; - a = 1278.0e3; - a = 12.0e10; - a = -x; - a = -17; - a = -44; - a = -44; - a = -44.9; - a = -1278e3; - a = -12e10; - a = +-x; - a = -17.0; - a = -44.0; - a = -44.0; - a = -44.9; - a = -1278.0e3; - a = -12.0e10; - a = 9223372036854776000.0; - a = -9223372036854776000.0; - a = -9223372036854776000.0; - a = -0x8000000000000000; - a = 999999984306749400.0; - a = -999999984306749400.0; - a = -999999984306749400.0; - a = -0xde0b6b000000000; - return 12.0e10; + x = +x; + var a = 5.0; + a = +x; + a = 17; + a = 44.0; + a = 44.0; + a = 44.9; + a = 1278.0e3; + a = 12.0e10; + a = -x; + a = -17; + a = -44; + a = -44; + a = -44.9; + a = -1278e3; + a = -12e10; + a = +-x; + a = -17.0; + a = -44.0; + a = -44.0; + a = -44.9; + a = -1278.0e3; + a = -12.0e10; + a = 9223372036854776000.0; + a = -9223372036854776000.0; + a = -9223372036854776000.0; + a = -0x8000000000000000; + a = 999999984306749400.0; + a = -999999984306749400.0; + a = -999999984306749400.0; + a = -0xde0b6b000000000; + return 12.0e10; } function looop() { - do { - do_it(); - } while (!condition()); - do { - do_it(); - } while (a <= b); - do { - do_it(); - } while (x()); + do { + do_it(); + } while (!condition()); + do { + do_it(); + } while (a <= b); + do { + do_it(); + } while (x()); } diff --git a/tools/test-js-optimizer-asm-last.js b/tools/test-js-optimizer-asm-last.js index e83822f82038f..6331879ea372a 100644 --- a/tools/test-js-optimizer-asm-last.js +++ b/tools/test-js-optimizer-asm-last.js @@ -1,56 +1,56 @@ function finall(x) { - x = +x; - var a = +5; - a = +x; - a = 17; - a = +44; - a = +44.0; - a = +44.9; - a = +12.78e5; - a = +12e10; - a = -x; - a = -17; - a = -44; - a = -44.0; - a = -44.9; - a = -12.78e5; - a = -12e10; - a = +-x; - a = +-17; - a = +-44; - a = +-44.0; - a = +-44.9; - a = +-12.78e5; - a = +-12e10; - a = +0x8000000000000000; - a = +-0x8000000000000000; - a = -+0x8000000000000000; - a = -0x8000000000000000; - a = +0xde0b6b000000000; - a = +-0xde0b6b000000000; - a = -+0xde0b6b000000000; - a = -0xde0b6b000000000; - return +12e10; + x = +x; + var a = +5; + a = +x; + a = 17; + a = +44; + a = +44.0; + a = +44.9; + a = +12.78e5; + a = +12e10; + a = -x; + a = -17; + a = -44; + a = -44.0; + a = -44.9; + a = -12.78e5; + a = -12e10; + a = +-x; + a = +-17; + a = +-44; + a = +-44.0; + a = +-44.9; + a = +-12.78e5; + a = +-12e10; + a = +0x8000000000000000; + a = +-0x8000000000000000; + a = -+0x8000000000000000; + a = -0x8000000000000000; + a = +0xde0b6b000000000; + a = +-0xde0b6b000000000; + a = -+0xde0b6b000000000; + a = -0xde0b6b000000000; + return +12e10; } function looop() { - while (1) { - do_it(); - if (condition()) { - break; - } + while (1) { + do_it(); + if (condition()) { + break; } - while (1) { - do_it(); - if (a > b) { - break; - } + } + while (1) { + do_it(); + if (a > b) { + break; } - while (1) { - do_it(); - if (!x()) { - break; - } + } + while (1) { + do_it(); + if (!x()) { + break; } + } } // EMSCRIPTEN_GENERATED_FUNCTIONS: ["finall", "looop"] diff --git a/tools/test-js-optimizer-asm-pre-output.js b/tools/test-js-optimizer-asm-pre-output.js index 0e95580fc67e2..2cd8d407bdc16 100644 --- a/tools/test-js-optimizer-asm-pre-output.js +++ b/tools/test-js-optimizer-asm-pre-output.js @@ -1,522 +1,522 @@ function a() { - f((HEAPU8[10202] | 0) + 5 | 0); - f(HEAPU8[10202] | 0); - f(347); - f(351); - f(8); - HEAP[1024] = 5; - HEAP[1024] = 5; - whee(12, 13) | 0; - +whee(12, 13); - f((g = t(), g + g | 0) | 0); - f() | 0; - f((h() | 0) + 5 | 0); - f(x + y + z | 0); - +f(); - f(+(+h() + 5)); - $140 = $p_3_i + (-$mantSize_0_i | 0) | 0; - f(g() | 0); - f(g() | 0 & -1); - f((g() | 0) >> 2); - $56 = _fcntl() | 0 | 1; + f((HEAPU8[10202] | 0) + 5 | 0); + f(HEAPU8[10202] | 0); + f(347); + f(351); + f(8); + HEAP[1024] = 5; + HEAP[1024] = 5; + whee(12, 13) | 0; + +whee(12, 13); + f((g = t(), g + g | 0) | 0); + f() | 0; + f((h() | 0) + 5 | 0); + f(x + y + z | 0); + +f(); + f(+(+h() + 5)); + $140 = $p_3_i + (-$mantSize_0_i | 0) | 0; + f(g() | 0); + f(g() | 0 & -1); + f((g() | 0) >> 2); + $56 = _fcntl() | 0 | 1; } function b($this, $__n) { - $this = $this | 0; - $__n = $__n | 0; - var $4 = 0, $5 = 0, $10 = 0, $13 = 0, $14 = 0, $15 = 0, $23 = 0, $30 = 0, $38 = 0, $40 = 0; - if (($__n | 0) == 0) { - return; - } - $4 = $this; - $5 = HEAP8[$4 & 16777215] | 0; - if (($5 & 1) == 0) { - $14 = 10; - $13 = $5; - } else { - $10 = HEAP32[($this & 16777215) >> 2] | 0; - $14 = ($10 & -2) - 1 | 0; - $13 = $10 & 255; - } - $15 = $13 & 255; - if (($15 & 1 | 0) == 0) { - $23 = $15 >>> 1; - } else { - $23 = HEAP32[($this + 4 & 16777215) >> 2] | 0; - } - if (($14 - $23 | 0) >>> 0 < $__n >>> 0) { - __ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9__grow_byEjjjjjj($this, $14, $__n - $14 + $23 | 0, $23, $23); - $30 = HEAP8[$4 & 16777215] | 0; - } else { - $30 = $13; - } - if (($30 & 1) == 0) { - $38 = $this + 1 | 0; - } else { - $38 = HEAP32[($this + 8 & 16777215) >> 2] | 0; - } - _memset($38 + $23 | 0, 0, $__n | 0, 1, 1213141516); - $40 = $23 + $__n | 0; - if ((HEAP8[$4 & 16777215] & 1) == 0) { - HEAP8[$4 & 16777215] = $40 << 1 & 255; - } else { - HEAP32[($this + 4 & 16777215) >> 2] = $40; - } - HEAP8[$38 + $40 & 16777215] = 0; + $this = $this | 0; + $__n = $__n | 0; + var $4 = 0, $5 = 0, $10 = 0, $13 = 0, $14 = 0, $15 = 0, $23 = 0, $30 = 0, $38 = 0, $40 = 0; + if (($__n | 0) == 0) { return; + } + $4 = $this; + $5 = HEAP8[$4 & 16777215] | 0; + if (($5 & 1) == 0) { + $14 = 10; + $13 = $5; + } else { + $10 = HEAP32[($this & 16777215) >> 2] | 0; + $14 = ($10 & -2) - 1 | 0; + $13 = $10 & 255; + } + $15 = $13 & 255; + if (($15 & 1 | 0) == 0) { + $23 = $15 >>> 1; + } else { + $23 = HEAP32[($this + 4 & 16777215) >> 2] | 0; + } + if (($14 - $23 | 0) >>> 0 < $__n >>> 0) { + __ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9__grow_byEjjjjjj($this, $14, $__n - $14 + $23 | 0, $23, $23); + $30 = HEAP8[$4 & 16777215] | 0; + } else { + $30 = $13; + } + if (($30 & 1) == 0) { + $38 = $this + 1 | 0; + } else { + $38 = HEAP32[($this + 8 & 16777215) >> 2] | 0; + } + _memset($38 + $23 | 0, 0, $__n | 0, 1, 1213141516); + $40 = $23 + $__n | 0; + if ((HEAP8[$4 & 16777215] & 1) == 0) { + HEAP8[$4 & 16777215] = $40 << 1 & 255; + } else { + HEAP32[($this + 4 & 16777215) >> 2] = $40; + } + HEAP8[$38 + $40 & 16777215] = 0; + return; } function rett() { - if (f()) { - g(); - return 5; - } - return 0; + if (f()) { + g(); + return 5; + } + return 0; } function ret2t() { - if (f()) { - g(); - return; - } + if (f()) { + g(); + return; + } } function retf() { - if (f()) { - g(); - return +h(); - } - return +0; + if (f()) { + g(); + return +h(); + } + return +0; } function i32_8() { - if ((HEAP8[$4 & 16777215] | 0) == 0) { - print(5); - } - if ((HEAP8[$5 & 16777215] | 0) == 0) { - print(5); - } - if ((HEAP8[$6 & 16777215] | 0) == 0) { - print(5); - } - if ((HEAP8[$7 & 16777215] | 0) == 0) { - print(5); - } - if (HEAPU8[$8 & 16777215] << 24 >> 16 == 0) { - print(5); - } - if (HEAPU8[$9 & 16777215] << 16 >> 16 == 0) { - print(5); - } + if ((HEAP8[$4 & 16777215] | 0) == 0) { + print(5); + } + if ((HEAP8[$5 & 16777215] | 0) == 0) { + print(5); + } + if ((HEAP8[$6 & 16777215] | 0) == 0) { + print(5); + } + if ((HEAP8[$7 & 16777215] | 0) == 0) { + print(5); + } + if (HEAPU8[$8 & 16777215] << 24 >> 16 == 0) { + print(5); + } + if (HEAPU8[$9 & 16777215] << 16 >> 16 == 0) { + print(5); + } } function sign_extension_simplification() { - if ((HEAP8[$4 & 16777215] & 127) == 0) { - print(5); - } - if ((HEAP8[$4 & 16777215] & 128) << 24 >> 24 == 0) { - print(5); - } - if ((HEAP32[$5 & 16777215] & 32767) == 0) { - print(5); - } - if ((HEAP32[$5 & 16777215] & 32768) << 16 >> 16 == 0) { - print(5); - } + if ((HEAP8[$4 & 16777215] & 127) == 0) { + print(5); + } + if ((HEAP8[$4 & 16777215] & 128) << 24 >> 24 == 0) { + print(5); + } + if ((HEAP32[$5 & 16777215] & 32767) == 0) { + print(5); + } + if ((HEAP32[$5 & 16777215] & 32768) << 16 >> 16 == 0) { + print(5); + } } function tempDoublePtr($45, $14, $28, $42) { - $45 = $45 | 0; - $14 = $14 | 0; - $28 = $28 | 0; - $42 = $42 | 0; - var unelim = +0, bad = 0, unelim2 = +0; - unelim = +(127.5 * +$14); - HEAPF32[$45 >> 2] = ($14 < $28 ? $14 : $28) - $42; - HEAP32[$world + 102916 >> 2] = _malloc(192) | 0; - f(+HEAPF32[$45 >> 2]); - g(HEAP32[$14 >> 2] | 0); - $42 = +HEAPF32[$42 >> 2]; - ch($42); - HEAPF32[$45 >> 2] = unelim; - moar(); - bad = (HEAPF32[tempDoublePtr >> 2] = 127.5 * +$14, HEAP32[tempDoublePtr >> 2] | 0); - func(); - HEAP32[4] = bad; - HEAP32[5] = bad + 1; - moar(); - unelim2 = 127 + $14 | 0; - func(); - HEAP32[4] = unelim2; + $45 = $45 | 0; + $14 = $14 | 0; + $28 = $28 | 0; + $42 = $42 | 0; + var unelim = +0, bad = 0, unelim2 = +0; + unelim = +(127.5 * +$14); + HEAPF32[$45 >> 2] = ($14 < $28 ? $14 : $28) - $42; + HEAP32[$world + 102916 >> 2] = _malloc(192) | 0; + f(+HEAPF32[$45 >> 2]); + g(HEAP32[$14 >> 2] | 0); + $42 = +HEAPF32[$42 >> 2]; + ch($42); + HEAPF32[$45 >> 2] = unelim; + moar(); + bad = (HEAPF32[tempDoublePtr >> 2] = 127.5 * +$14, HEAP32[tempDoublePtr >> 2] | 0); + func(); + HEAP32[4] = bad; + HEAP32[5] = bad + 1; + moar(); + unelim2 = 127 + $14 | 0; + func(); + HEAP32[4] = unelim2; } function boxx($this, $aabb, $xf, $childIndex) { - $this = $this | 0; - $aabb = $aabb | 0; - $xf = $xf | 0; - $childIndex = $childIndex | 0; - var $2 = +0, $4 = +0, $7 = +0, $9 = +0, $13 = +0, $14 = +0, $19 = +0, $20 = +0, $22 = +0, $25 = +0, $28 = +0, $32 = +0, $42 = +0, $45 = 0, $_sroa_06_0_insert_insert$1 = +0, $51 = 0, $_sroa_0_0_insert_insert$1 = +0; - $2 = +HEAPF32[$xf + 12 >> 2]; - $4 = +HEAPF32[$this + 12 >> 2]; - $7 = +HEAPF32[$xf + 8 >> 2]; - $9 = +HEAPF32[$this + 16 >> 2]; - $13 = +HEAPF32[$xf >> 2]; - $14 = $13 + ($2 * $4 - $7 * $9); - $19 = +HEAPF32[$xf + 4 >> 2]; - $20 = $4 * $7 + $2 * $9 + $19; - $22 = +HEAPF32[$this + 20 >> 2]; - $25 = +HEAPF32[$this + 24 >> 2]; - $28 = $13 + ($2 * $22 - $7 * $25); - $32 = $19 + ($7 * $22 + $2 * $25); - $42 = +HEAPF32[$this + 8 >> 2]; - $45 = $aabb; - $_sroa_06_0_insert_insert$1 = +(($20 < $32 ? $20 : $32) - $42); - HEAPF32[$45 >> 2] = ($14 < $28 ? $14 : $28) - $42; - HEAPF32[$45 + 4 >> 2] = $_sroa_06_0_insert_insert$1; - $51 = $aabb + 8 | 0; - $_sroa_0_0_insert_insert$1 = +($42 + ($20 > $32 ? $20 : $32)); - HEAPF32[$51 >> 2] = $42 + ($14 > $28 ? $14 : $28); - HEAPF32[$51 + 4 >> 2] = $_sroa_0_0_insert_insert$1; - return; + $this = $this | 0; + $aabb = $aabb | 0; + $xf = $xf | 0; + $childIndex = $childIndex | 0; + var $2 = +0, $4 = +0, $7 = +0, $9 = +0, $13 = +0, $14 = +0, $19 = +0, $20 = +0, $22 = +0, $25 = +0, $28 = +0, $32 = +0, $42 = +0, $45 = 0, $_sroa_06_0_insert_insert$1 = +0, $51 = 0, $_sroa_0_0_insert_insert$1 = +0; + $2 = +HEAPF32[$xf + 12 >> 2]; + $4 = +HEAPF32[$this + 12 >> 2]; + $7 = +HEAPF32[$xf + 8 >> 2]; + $9 = +HEAPF32[$this + 16 >> 2]; + $13 = +HEAPF32[$xf >> 2]; + $14 = $13 + ($2 * $4 - $7 * $9); + $19 = +HEAPF32[$xf + 4 >> 2]; + $20 = $4 * $7 + $2 * $9 + $19; + $22 = +HEAPF32[$this + 20 >> 2]; + $25 = +HEAPF32[$this + 24 >> 2]; + $28 = $13 + ($2 * $22 - $7 * $25); + $32 = $19 + ($7 * $22 + $2 * $25); + $42 = +HEAPF32[$this + 8 >> 2]; + $45 = $aabb; + $_sroa_06_0_insert_insert$1 = +(($20 < $32 ? $20 : $32) - $42); + HEAPF32[$45 >> 2] = ($14 < $28 ? $14 : $28) - $42; + HEAPF32[$45 + 4 >> 2] = $_sroa_06_0_insert_insert$1; + $51 = $aabb + 8 | 0; + $_sroa_0_0_insert_insert$1 = +($42 + ($20 > $32 ? $20 : $32)); + HEAPF32[$51 >> 2] = $42 + ($14 > $28 ? $14 : $28); + HEAPF32[$51 + 4 >> 2] = $_sroa_0_0_insert_insert$1; + return; } function _main($argc, $argv) { - $argc = $argc | 0; - $argv = $argv | 0; - var $def_i21 = 0, $def_i = 0, $world = 0, $bd = 0, $shape = 0, $shape1 = 0, $bd2 = 0, $result = 0, $6 = 0, $WARMUP_0 = 0, $14 = 0, $15 = 0, $17 = 0, $i_09_i_i = 0, $j_08_i_i = 0, $34 = 0, $j_1_i_i = 0, $38 = 0, $46 = 0, $48 = 0, $50 = 0, $54 = 0, $i_05_i_i_i = 0, $56 = 0, $62 = 0, $_lcssa_i_i_i = 0, $87 = 0, $96 = 0, $97 = 0, $98 = 0, $112 = 0, $115 = 0, $116 = 0, $118 = 0, $121 = 0, $126 = 0, $135 = 0, $137 = 0, $174 = 0, $176 = 0, $177 = 0, $178 = 0, $179 = 0, $180 = 0, $181 = 0, $182 = 0, $183 = 0, $185 = 0, $186 = 0, $188 = 0, $189 = 0, $190 = 0, $191 = 0, $192 = 0, $193 = 0, $194 = 0, $195 = 0, $196 = 0, $i_057 = 0, $x_sroa_0_0_load303656 = +0, $x_sroa_1_4_load313755 = +0, $j_052 = 0, $y_sroa_0_0_load283451 = +0, $y_sroa_1_4_load293550 = +0, $y_sroa_0_0_insert_insert$1 = +0, $205 = 0, $208 = 0, $209 = 0, $213 = 0, $223 = 0, $236 = 0, $i3_042 = 0, $241 = 0, $242 = 0, $243 = 0, $i4_038 = 0, $245 = 0, $260 = +0, $_0 = 0, label = 0, __stackBase__ = 0; - __stackBase__ = STACKTOP; - STACKTOP = STACKTOP + 103416 | 0; - $def_i21 = __stackBase__ | 0; - $def_i = __stackBase__ + 32 | 0; - $world = __stackBase__ + 64 | 0; - $bd = __stackBase__ + 103096 | 0; - $shape = __stackBase__ + 103152 | 0; - $shape1 = __stackBase__ + 103200 | 0; - $bd2 = __stackBase__ + 103352 | 0; - $result = __stackBase__ + 103408 | 0; - do { - if (($argc | 0) > 1) { - $6 = HEAP8[HEAP32[$argv + 4 >> 2] | 0] | 0; - if (($6 | 0) == 49) { - HEAP32[2414] = 35; - $WARMUP_0 = 5; - break; - } else if (($6 | 0) == 50) { - HEAP32[2414] = 161; - $WARMUP_0 = 32; - break; - } else if (($6 | 0) == 51) { - label = 43; - break; - } else if (($6 | 0) == 52) { - HEAP32[2414] = 2331; - $WARMUP_0 = 320; - break; - } else if (($6 | 0) == 53) { - HEAP32[2414] = 5661; - $WARMUP_0 = 640; - break; - } else if (($6 | 0) == 48) { - $_0 = 0; - STACKTOP = __stackBase__; - return $_0 | 0; - } else { - _printf(3512, (tempInt = STACKTOP, STACKTOP = STACKTOP + 8 | 0, HEAP32[tempInt >> 2] = $6 - 48, tempInt) | 0) | 0; - $_0 = -1; - STACKTOP = __stackBase__; - return $_0 | 0; - } - } else { - label = 43; - } - } while (0); - if ((label | 0) == 43) { - HEAP32[2414] = 333; - $WARMUP_0 = 64; - } - $14 = $world | 0; - $15 = $world + 8 | 0; - HEAP32[$15 >> 2] = 128; - HEAP32[$world + 4 >> 2] = 0; - $17 = _malloc(1024) | 0; - HEAP32[$world >> 2] = $17; - _memset($17 | 0, 0, HEAP32[$15 >> 2] << 3 | 0); - _memset($world + 12 | 0, 0, 56); - $j_08_i_i = 0; - $i_09_i_i = 1; - while (1) { - if (!(($j_08_i_i | 0) < 14)) { - label = 49; - break; - } - if (($i_09_i_i | 0) > (HEAP32[9600 + ($j_08_i_i << 2) >> 2] | 0)) { - $34 = $j_08_i_i + 1 | 0; - HEAP8[$i_09_i_i + 8952 | 0] = $34 & 255; - $j_1_i_i = $34; - } else { - HEAP8[$i_09_i_i + 8952 | 0] = $j_08_i_i & 255; - $j_1_i_i = $j_08_i_i; - } - $38 = $i_09_i_i + 1 | 0; - if (($38 | 0) < 641) { - $j_08_i_i = $j_1_i_i; - $i_09_i_i = $38; - } else { - break; - } + $argc = $argc | 0; + $argv = $argv | 0; + var $def_i21 = 0, $def_i = 0, $world = 0, $bd = 0, $shape = 0, $shape1 = 0, $bd2 = 0, $result = 0, $6 = 0, $WARMUP_0 = 0, $14 = 0, $15 = 0, $17 = 0, $i_09_i_i = 0, $j_08_i_i = 0, $34 = 0, $j_1_i_i = 0, $38 = 0, $46 = 0, $48 = 0, $50 = 0, $54 = 0, $i_05_i_i_i = 0, $56 = 0, $62 = 0, $_lcssa_i_i_i = 0, $87 = 0, $96 = 0, $97 = 0, $98 = 0, $112 = 0, $115 = 0, $116 = 0, $118 = 0, $121 = 0, $126 = 0, $135 = 0, $137 = 0, $174 = 0, $176 = 0, $177 = 0, $178 = 0, $179 = 0, $180 = 0, $181 = 0, $182 = 0, $183 = 0, $185 = 0, $186 = 0, $188 = 0, $189 = 0, $190 = 0, $191 = 0, $192 = 0, $193 = 0, $194 = 0, $195 = 0, $196 = 0, $i_057 = 0, $x_sroa_0_0_load303656 = +0, $x_sroa_1_4_load313755 = +0, $j_052 = 0, $y_sroa_0_0_load283451 = +0, $y_sroa_1_4_load293550 = +0, $y_sroa_0_0_insert_insert$1 = +0, $205 = 0, $208 = 0, $209 = 0, $213 = 0, $223 = 0, $236 = 0, $i3_042 = 0, $241 = 0, $242 = 0, $243 = 0, $i4_038 = 0, $245 = 0, $260 = +0, $_0 = 0, label = 0, __stackBase__ = 0; + __stackBase__ = STACKTOP; + STACKTOP = STACKTOP + 103416 | 0; + $def_i21 = __stackBase__ | 0; + $def_i = __stackBase__ + 32 | 0; + $world = __stackBase__ + 64 | 0; + $bd = __stackBase__ + 103096 | 0; + $shape = __stackBase__ + 103152 | 0; + $shape1 = __stackBase__ + 103200 | 0; + $bd2 = __stackBase__ + 103352 | 0; + $result = __stackBase__ + 103408 | 0; + do { + if (($argc | 0) > 1) { + $6 = HEAP8[HEAP32[$argv + 4 >> 2] | 0] | 0; + if (($6 | 0) == 49) { + HEAP32[2414] = 35; + $WARMUP_0 = 5; + break; + } else if (($6 | 0) == 50) { + HEAP32[2414] = 161; + $WARMUP_0 = 32; + break; + } else if (($6 | 0) == 51) { + label = 43; + break; + } else if (($6 | 0) == 52) { + HEAP32[2414] = 2331; + $WARMUP_0 = 320; + break; + } else if (($6 | 0) == 53) { + HEAP32[2414] = 5661; + $WARMUP_0 = 640; + break; + } else if (($6 | 0) == 48) { + $_0 = 0; + STACKTOP = __stackBase__; + return $_0 | 0; + } else { + _printf(3512, (tempInt = STACKTOP, STACKTOP = STACKTOP + 8 | 0, HEAP32[tempInt >> 2] = $6 - 48, tempInt) | 0) | 0; + $_0 = -1; + STACKTOP = __stackBase__; + return $_0 | 0; + } + } else { + label = 43; } - if ((label | 0) == 49) { - ___assert_func(3248, 73, 6448, 3360); - return 0; + } while (0); + if ((label | 0) == 43) { + HEAP32[2414] = 333; + $WARMUP_0 = 64; + } + $14 = $world | 0; + $15 = $world + 8 | 0; + HEAP32[$15 >> 2] = 128; + HEAP32[$world + 4 >> 2] = 0; + $17 = _malloc(1024) | 0; + HEAP32[$world >> 2] = $17; + _memset($17 | 0, 0, HEAP32[$15 >> 2] << 3 | 0); + _memset($world + 12 | 0, 0, 56); + $j_08_i_i = 0; + $i_09_i_i = 1; + while (1) { + if (!(($j_08_i_i | 0) < 14)) { + label = 49; + break; } - HEAP32[$world + 102468 >> 2] = 0; - HEAP32[$world + 102472 >> 2] = 0; - HEAP32[$world + 102476 >> 2] = 0; - HEAP32[$world + 102864 >> 2] = 0; - HEAP32[$world + 102872 >> 2] = -1; - $46 = $world + 102884 | 0; - HEAP32[$46 >> 2] = 16; - HEAP32[$world + 102880 >> 2] = 0; - $48 = _malloc(576) | 0; - $50 = $world + 102876 | 0; - HEAP32[$50 >> 2] = $48; - _memset($48 | 0, 0, (HEAP32[$46 >> 2] | 0) * 36 & -1 | 0); - $54 = (HEAP32[$46 >> 2] | 0) - 1 | 0; - if (($54 | 0) > 0) { - $i_05_i_i_i = 0; - while (1) { - $56 = $i_05_i_i_i + 1 | 0; - HEAP32[(HEAP32[$50 >> 2] | 0) + ($i_05_i_i_i * 36 & -1) + 20 >> 2] = $56; - HEAP32[(HEAP32[$50 >> 2] | 0) + ($i_05_i_i_i * 36 & -1) + 32 >> 2] = -1; - $62 = (HEAP32[$46 >> 2] | 0) - 1 | 0; - if (($56 | 0) < ($62 | 0)) { - $i_05_i_i_i = $56; - } else { - $_lcssa_i_i_i = $62; - break; - } - } + if (($i_09_i_i | 0) > (HEAP32[9600 + ($j_08_i_i << 2) >> 2] | 0)) { + $34 = $j_08_i_i + 1 | 0; + HEAP8[$i_09_i_i + 8952 | 0] = $34 & 255; + $j_1_i_i = $34; } else { - $_lcssa_i_i_i = $54; + HEAP8[$i_09_i_i + 8952 | 0] = $j_08_i_i & 255; + $j_1_i_i = $j_08_i_i; } - HEAP32[(HEAP32[$50 >> 2] | 0) + ($_lcssa_i_i_i * 36 & -1) + 20 >> 2] = -1; - HEAP32[(HEAP32[$50 >> 2] | 0) + (((HEAP32[$46 >> 2] | 0) - 1 | 0) * 36 & -1) + 32 >> 2] = -1; - _memset($world + 102888 | 0, 0, 16); - HEAP32[$world + 102920 >> 2] = 16; - HEAP32[$world + 102924 >> 2] = 0; - HEAP32[$world + 102916 >> 2] = _malloc(192) | 0; - HEAP32[$world + 102908 >> 2] = 16; - HEAP32[$world + 102912 >> 2] = 0; - HEAP32[$world + 102904 >> 2] = _malloc(64) | 0; - HEAP32[$world + 102932 >> 2] = 0; - HEAP32[$world + 102936 >> 2] = 0; - HEAP32[$world + 102940 >> 2] = 104; - HEAP32[$world + 102944 >> 2] = 96; - $87 = $world + 102948 | 0; - HEAP32[$world + 102980 >> 2] = 0; - HEAP32[$world + 102984 >> 2] = 0; - _memset($87 | 0, 0, 20); - HEAP8[$world + 102992 | 0] = 1; - HEAP8[$world + 102993 | 0] = 1; - HEAP8[$world + 102994 | 0] = 0; - HEAP8[$world + 102995 | 0] = 1; - $96 = $world + 102976 | 0; - HEAP8[$96] = 1; - $97 = $world + 102968 | 0; - HEAP32[$97 >> 2] = 0; - HEAP32[$97 + 4 >> 2] = -1054867456; - $98 = $world + 102868 | 0; - HEAP32[$98 >> 2] = 4; - HEAPF32[$world + 102988 >> 2] = +0; - HEAP32[$87 >> 2] = $14; - _memset($world + 102996 | 0, 0, 32); - HEAP8[$96] = 0; - HEAP32[$bd + 44 >> 2] = 0; - _memset($bd + 4 | 0, 0, 32); - HEAP8[$bd + 36 | 0] = 1; - HEAP8[$bd + 37 | 0] = 1; - HEAP8[$bd + 38 | 0] = 0; - HEAP8[$bd + 39 | 0] = 0; - HEAP32[$bd >> 2] = 0; - HEAP8[$bd + 40 | 0] = 1; - HEAPF32[$bd + 48 >> 2] = +1; - $112 = __ZN16b2BlockAllocator8AllocateEi($14, 152) | 0; - if (($112 | 0) == 0) { - $116 = 0; + $38 = $i_09_i_i + 1 | 0; + if (($38 | 0) < 641) { + $j_08_i_i = $j_1_i_i; + $i_09_i_i = $38; } else { - $115 = $112; - __ZN6b2BodyC2EPK9b2BodyDefP7b2World($115, $bd, $world); - $116 = $115; + break; } - HEAP32[$116 + 92 >> 2] = 0; - $118 = $world + 102952 | 0; - HEAP32[$116 + 96 >> 2] = HEAP32[$118 >> 2]; - $121 = HEAP32[$118 >> 2] | 0; - if (!(($121 | 0) == 0)) { - HEAP32[$121 + 92 >> 2] = $116; + } + if ((label | 0) == 49) { + ___assert_func(3248, 73, 6448, 3360); + return 0; + } + HEAP32[$world + 102468 >> 2] = 0; + HEAP32[$world + 102472 >> 2] = 0; + HEAP32[$world + 102476 >> 2] = 0; + HEAP32[$world + 102864 >> 2] = 0; + HEAP32[$world + 102872 >> 2] = -1; + $46 = $world + 102884 | 0; + HEAP32[$46 >> 2] = 16; + HEAP32[$world + 102880 >> 2] = 0; + $48 = _malloc(576) | 0; + $50 = $world + 102876 | 0; + HEAP32[$50 >> 2] = $48; + _memset($48 | 0, 0, (HEAP32[$46 >> 2] | 0) * 36 & -1 | 0); + $54 = (HEAP32[$46 >> 2] | 0) - 1 | 0; + if (($54 | 0) > 0) { + $i_05_i_i_i = 0; + while (1) { + $56 = $i_05_i_i_i + 1 | 0; + HEAP32[(HEAP32[$50 >> 2] | 0) + ($i_05_i_i_i * 36 & -1) + 20 >> 2] = $56; + HEAP32[(HEAP32[$50 >> 2] | 0) + ($i_05_i_i_i * 36 & -1) + 32 >> 2] = -1; + $62 = (HEAP32[$46 >> 2] | 0) - 1 | 0; + if (($56 | 0) < ($62 | 0)) { + $i_05_i_i_i = $56; + } else { + $_lcssa_i_i_i = $62; + break; + } } - HEAP32[$118 >> 2] = $116; - $126 = $world + 102960 | 0; - HEAP32[$126 >> 2] = (HEAP32[$126 >> 2] | 0) + 1; - HEAP32[$shape >> 2] = 8016; - HEAP32[$shape + 4 >> 2] = 1; - HEAPF32[$shape + 8 >> 2] = +.009999999776482582; - _memset($shape + 28 | 0, 0, 18); - $135 = $shape + 12 | 0; - HEAP32[$135 >> 2] = -1038090240; - HEAP32[$135 + 4 >> 2] = 0; - $137 = $shape + 20 | 0; - HEAP32[$137 >> 2] = 1109393408; - HEAP32[$137 + 4 >> 2] = 0; - HEAP8[$shape + 44 | 0] = 0; - HEAP8[$shape + 45 | 0] = 0; - HEAP16[$def_i + 22 >> 1] = 1; - HEAP16[$def_i + 24 >> 1] = -1; - HEAP16[$def_i + 26 >> 1] = 0; - HEAP32[$def_i + 4 >> 2] = 0; - HEAPF32[$def_i + 8 >> 2] = +.20000000298023224; - HEAPF32[$def_i + 12 >> 2] = +0; - HEAP8[$def_i + 20 | 0] = 0; - HEAP32[$def_i >> 2] = $shape; - HEAPF32[$def_i + 16 >> 2] = +0; - __ZN6b2Body13CreateFixtureEPK12b2FixtureDef($116, $def_i); - HEAP32[$shape1 >> 2] = 7968; - HEAP32[$shape1 + 4 >> 2] = 2; - HEAPF32[$shape1 + 8 >> 2] = +.009999999776482582; - HEAP32[$shape1 + 148 >> 2] = 4; - HEAPF32[$shape1 + 20 >> 2] = +-.5; - HEAPF32[$shape1 + 24 >> 2] = +-.5; - HEAPF32[$shape1 + 28 >> 2] = +.5; - HEAPF32[$shape1 + 32 >> 2] = +-.5; - HEAPF32[$shape1 + 36 >> 2] = +.5; - HEAPF32[$shape1 + 40 >> 2] = +.5; - HEAPF32[$shape1 + 44 >> 2] = +-.5; - HEAPF32[$shape1 + 48 >> 2] = +.5; - HEAPF32[$shape1 + 84 >> 2] = +0; - HEAPF32[$shape1 + 88 >> 2] = +-1; - HEAPF32[$shape1 + 92 >> 2] = +1; - HEAPF32[$shape1 + 96 >> 2] = +0; - HEAPF32[$shape1 + 100 >> 2] = +0; - HEAPF32[$shape1 + 104 >> 2] = +1; - HEAPF32[$shape1 + 108 >> 2] = +-1; - HEAPF32[$shape1 + 112 >> 2] = +0; - HEAPF32[$shape1 + 12 >> 2] = +0; - HEAPF32[$shape1 + 16 >> 2] = +0; - $174 = $bd2 + 44 | 0; - $176 = $bd2 + 36 | 0; - $177 = $bd2 + 4 | 0; - $178 = $bd2 + 37 | 0; - $179 = $bd2 + 38 | 0; - $180 = $bd2 + 39 | 0; - $181 = $bd2 | 0; - $182 = $bd2 + 40 | 0; - $183 = $bd2 + 48 | 0; - $185 = $bd2 + 4 | 0; - $186 = $shape1 | 0; - $188 = $def_i21 + 22 | 0; - $189 = $def_i21 + 24 | 0; - $190 = $def_i21 + 26 | 0; - $191 = $def_i21 | 0; - $192 = $def_i21 + 4 | 0; - $193 = $def_i21 + 8 | 0; - $194 = $def_i21 + 12 | 0; - $195 = $def_i21 + 16 | 0; - $196 = $def_i21 + 20 | 0; - $x_sroa_1_4_load313755 = +.75; - $x_sroa_0_0_load303656 = +-7; - $i_057 = 0; - L82 : while (1) { - $y_sroa_1_4_load293550 = $x_sroa_1_4_load313755; - $y_sroa_0_0_load283451 = $x_sroa_0_0_load303656; - $j_052 = $i_057; - while (1) { - HEAP32[$174 >> 2] = 0; - _memset($177 | 0, 0, 32); - HEAP8[$176] = 1; - HEAP8[$178] = 1; - HEAP8[$179] = 0; - HEAP8[$180] = 0; - HEAP8[$182] = 1; - HEAPF32[$183 >> 2] = +1; - HEAP32[$181 >> 2] = 2; - $y_sroa_0_0_insert_insert$1 = +$y_sroa_1_4_load293550; - HEAPF32[$185 >> 2] = $y_sroa_0_0_load283451; - HEAPF32[$185 + 4 >> 2] = $y_sroa_0_0_insert_insert$1; - if (!((HEAP32[$98 >> 2] & 2 | 0) == 0)) { - label = 65; - break L82; - } - $205 = __ZN16b2BlockAllocator8AllocateEi($14, 152) | 0; - if (($205 | 0) == 0) { - $209 = 0; - } else { - $208 = $205; - __ZN6b2BodyC2EPK9b2BodyDefP7b2World($208, $bd2, $world); - $209 = $208; - } - HEAP32[$209 + 92 >> 2] = 0; - HEAP32[$209 + 96 >> 2] = HEAP32[$118 >> 2]; - $213 = HEAP32[$118 >> 2] | 0; - if (!(($213 | 0) == 0)) { - HEAP32[$213 + 92 >> 2] = $209; - } - HEAP32[$118 >> 2] = $209; - HEAP32[$126 >> 2] = (HEAP32[$126 >> 2] | 0) + 1; - HEAP16[$188 >> 1] = 1; - HEAP16[$189 >> 1] = -1; - HEAP16[$190 >> 1] = 0; - HEAP32[$192 >> 2] = 0; - HEAPF32[$193 >> 2] = +.20000000298023224; - HEAPF32[$194 >> 2] = +0; - HEAP8[$196] = 0; - HEAP32[$191 >> 2] = $186; - HEAPF32[$195 >> 2] = +5; - __ZN6b2Body13CreateFixtureEPK12b2FixtureDef($209, $def_i21); - $223 = $j_052 + 1 | 0; - if (($223 | 0) < 40) { - $y_sroa_1_4_load293550 = $y_sroa_1_4_load293550 + +0; - $y_sroa_0_0_load283451 = $y_sroa_0_0_load283451 + 1.125; - $j_052 = $223; - } else { - break; - } - } - $236 = $i_057 + 1 | 0; - if (($236 | 0) < 40) { - $x_sroa_1_4_load313755 = $x_sroa_1_4_load313755 + +1; - $x_sroa_0_0_load303656 = $x_sroa_0_0_load303656 + +.5625; - $i_057 = $236; - } else { - $i3_042 = 0; - break; - } + } else { + $_lcssa_i_i_i = $54; + } + HEAP32[(HEAP32[$50 >> 2] | 0) + ($_lcssa_i_i_i * 36 & -1) + 20 >> 2] = -1; + HEAP32[(HEAP32[$50 >> 2] | 0) + (((HEAP32[$46 >> 2] | 0) - 1 | 0) * 36 & -1) + 32 >> 2] = -1; + _memset($world + 102888 | 0, 0, 16); + HEAP32[$world + 102920 >> 2] = 16; + HEAP32[$world + 102924 >> 2] = 0; + HEAP32[$world + 102916 >> 2] = _malloc(192) | 0; + HEAP32[$world + 102908 >> 2] = 16; + HEAP32[$world + 102912 >> 2] = 0; + HEAP32[$world + 102904 >> 2] = _malloc(64) | 0; + HEAP32[$world + 102932 >> 2] = 0; + HEAP32[$world + 102936 >> 2] = 0; + HEAP32[$world + 102940 >> 2] = 104; + HEAP32[$world + 102944 >> 2] = 96; + $87 = $world + 102948 | 0; + HEAP32[$world + 102980 >> 2] = 0; + HEAP32[$world + 102984 >> 2] = 0; + _memset($87 | 0, 0, 20); + HEAP8[$world + 102992 | 0] = 1; + HEAP8[$world + 102993 | 0] = 1; + HEAP8[$world + 102994 | 0] = 0; + HEAP8[$world + 102995 | 0] = 1; + $96 = $world + 102976 | 0; + HEAP8[$96] = 1; + $97 = $world + 102968 | 0; + HEAP32[$97 >> 2] = 0; + HEAP32[$97 + 4 >> 2] = -1054867456; + $98 = $world + 102868 | 0; + HEAP32[$98 >> 2] = 4; + HEAPF32[$world + 102988 >> 2] = +0; + HEAP32[$87 >> 2] = $14; + _memset($world + 102996 | 0, 0, 32); + HEAP8[$96] = 0; + HEAP32[$bd + 44 >> 2] = 0; + _memset($bd + 4 | 0, 0, 32); + HEAP8[$bd + 36 | 0] = 1; + HEAP8[$bd + 37 | 0] = 1; + HEAP8[$bd + 38 | 0] = 0; + HEAP8[$bd + 39 | 0] = 0; + HEAP32[$bd >> 2] = 0; + HEAP8[$bd + 40 | 0] = 1; + HEAPF32[$bd + 48 >> 2] = +1; + $112 = __ZN16b2BlockAllocator8AllocateEi($14, 152) | 0; + if (($112 | 0) == 0) { + $116 = 0; + } else { + $115 = $112; + __ZN6b2BodyC2EPK9b2BodyDefP7b2World($115, $bd, $world); + $116 = $115; + } + HEAP32[$116 + 92 >> 2] = 0; + $118 = $world + 102952 | 0; + HEAP32[$116 + 96 >> 2] = HEAP32[$118 >> 2]; + $121 = HEAP32[$118 >> 2] | 0; + if (!(($121 | 0) == 0)) { + HEAP32[$121 + 92 >> 2] = $116; + } + HEAP32[$118 >> 2] = $116; + $126 = $world + 102960 | 0; + HEAP32[$126 >> 2] = (HEAP32[$126 >> 2] | 0) + 1; + HEAP32[$shape >> 2] = 8016; + HEAP32[$shape + 4 >> 2] = 1; + HEAPF32[$shape + 8 >> 2] = +.009999999776482582; + _memset($shape + 28 | 0, 0, 18); + $135 = $shape + 12 | 0; + HEAP32[$135 >> 2] = -1038090240; + HEAP32[$135 + 4 >> 2] = 0; + $137 = $shape + 20 | 0; + HEAP32[$137 >> 2] = 1109393408; + HEAP32[$137 + 4 >> 2] = 0; + HEAP8[$shape + 44 | 0] = 0; + HEAP8[$shape + 45 | 0] = 0; + HEAP16[$def_i + 22 >> 1] = 1; + HEAP16[$def_i + 24 >> 1] = -1; + HEAP16[$def_i + 26 >> 1] = 0; + HEAP32[$def_i + 4 >> 2] = 0; + HEAPF32[$def_i + 8 >> 2] = +.20000000298023224; + HEAPF32[$def_i + 12 >> 2] = +0; + HEAP8[$def_i + 20 | 0] = 0; + HEAP32[$def_i >> 2] = $shape; + HEAPF32[$def_i + 16 >> 2] = +0; + __ZN6b2Body13CreateFixtureEPK12b2FixtureDef($116, $def_i); + HEAP32[$shape1 >> 2] = 7968; + HEAP32[$shape1 + 4 >> 2] = 2; + HEAPF32[$shape1 + 8 >> 2] = +.009999999776482582; + HEAP32[$shape1 + 148 >> 2] = 4; + HEAPF32[$shape1 + 20 >> 2] = +-.5; + HEAPF32[$shape1 + 24 >> 2] = +-.5; + HEAPF32[$shape1 + 28 >> 2] = +.5; + HEAPF32[$shape1 + 32 >> 2] = +-.5; + HEAPF32[$shape1 + 36 >> 2] = +.5; + HEAPF32[$shape1 + 40 >> 2] = +.5; + HEAPF32[$shape1 + 44 >> 2] = +-.5; + HEAPF32[$shape1 + 48 >> 2] = +.5; + HEAPF32[$shape1 + 84 >> 2] = +0; + HEAPF32[$shape1 + 88 >> 2] = +-1; + HEAPF32[$shape1 + 92 >> 2] = +1; + HEAPF32[$shape1 + 96 >> 2] = +0; + HEAPF32[$shape1 + 100 >> 2] = +0; + HEAPF32[$shape1 + 104 >> 2] = +1; + HEAPF32[$shape1 + 108 >> 2] = +-1; + HEAPF32[$shape1 + 112 >> 2] = +0; + HEAPF32[$shape1 + 12 >> 2] = +0; + HEAPF32[$shape1 + 16 >> 2] = +0; + $174 = $bd2 + 44 | 0; + $176 = $bd2 + 36 | 0; + $177 = $bd2 + 4 | 0; + $178 = $bd2 + 37 | 0; + $179 = $bd2 + 38 | 0; + $180 = $bd2 + 39 | 0; + $181 = $bd2 | 0; + $182 = $bd2 + 40 | 0; + $183 = $bd2 + 48 | 0; + $185 = $bd2 + 4 | 0; + $186 = $shape1 | 0; + $188 = $def_i21 + 22 | 0; + $189 = $def_i21 + 24 | 0; + $190 = $def_i21 + 26 | 0; + $191 = $def_i21 | 0; + $192 = $def_i21 + 4 | 0; + $193 = $def_i21 + 8 | 0; + $194 = $def_i21 + 12 | 0; + $195 = $def_i21 + 16 | 0; + $196 = $def_i21 + 20 | 0; + $x_sroa_1_4_load313755 = +.75; + $x_sroa_0_0_load303656 = +-7; + $i_057 = 0; + L82 : while (1) { + $y_sroa_1_4_load293550 = $x_sroa_1_4_load313755; + $y_sroa_0_0_load283451 = $x_sroa_0_0_load303656; + $j_052 = $i_057; + while (1) { + HEAP32[$174 >> 2] = 0; + _memset($177 | 0, 0, 32); + HEAP8[$176] = 1; + HEAP8[$178] = 1; + HEAP8[$179] = 0; + HEAP8[$180] = 0; + HEAP8[$182] = 1; + HEAPF32[$183 >> 2] = +1; + HEAP32[$181 >> 2] = 2; + $y_sroa_0_0_insert_insert$1 = +$y_sroa_1_4_load293550; + HEAPF32[$185 >> 2] = $y_sroa_0_0_load283451; + HEAPF32[$185 + 4 >> 2] = $y_sroa_0_0_insert_insert$1; + if (!((HEAP32[$98 >> 2] & 2 | 0) == 0)) { + label = 65; + break L82; + } + $205 = __ZN16b2BlockAllocator8AllocateEi($14, 152) | 0; + if (($205 | 0) == 0) { + $209 = 0; + } else { + $208 = $205; + __ZN6b2BodyC2EPK9b2BodyDefP7b2World($208, $bd2, $world); + $209 = $208; + } + HEAP32[$209 + 92 >> 2] = 0; + HEAP32[$209 + 96 >> 2] = HEAP32[$118 >> 2]; + $213 = HEAP32[$118 >> 2] | 0; + if (!(($213 | 0) == 0)) { + HEAP32[$213 + 92 >> 2] = $209; + } + HEAP32[$118 >> 2] = $209; + HEAP32[$126 >> 2] = (HEAP32[$126 >> 2] | 0) + 1; + HEAP16[$188 >> 1] = 1; + HEAP16[$189 >> 1] = -1; + HEAP16[$190 >> 1] = 0; + HEAP32[$192 >> 2] = 0; + HEAPF32[$193 >> 2] = +.20000000298023224; + HEAPF32[$194 >> 2] = +0; + HEAP8[$196] = 0; + HEAP32[$191 >> 2] = $186; + HEAPF32[$195 >> 2] = +5; + __ZN6b2Body13CreateFixtureEPK12b2FixtureDef($209, $def_i21); + $223 = $j_052 + 1 | 0; + if (($223 | 0) < 40) { + $y_sroa_1_4_load293550 = $y_sroa_1_4_load293550 + +0; + $y_sroa_0_0_load283451 = $y_sroa_0_0_load283451 + 1.125; + $j_052 = $223; + } else { + break; + } } - if ((label | 0) == 65) { - ___assert_func(112, 109, 5328, 2520); - return 0; + $236 = $i_057 + 1 | 0; + if (($236 | 0) < 40) { + $x_sroa_1_4_load313755 = $x_sroa_1_4_load313755 + +1; + $x_sroa_0_0_load303656 = $x_sroa_0_0_load303656 + +.5625; + $i_057 = $236; + } else { + $i3_042 = 0; + break; } - while (1) { - __ZN7b2World4StepEfii($world); - $i3_042 = $i3_042 + 1 | 0; - if (($i3_042 | 0) >= ($WARMUP_0 | 0)) { - break; - } + } + if ((label | 0) == 65) { + ___assert_func(112, 109, 5328, 2520); + return 0; + } + while (1) { + __ZN7b2World4StepEfii($world); + $i3_042 = $i3_042 + 1 | 0; + if (($i3_042 | 0) >= ($WARMUP_0 | 0)) { + break; } - $241 = HEAP32[2414] | 0; - $242 = _llvm_stacksave() | 0; - $243 = STACKTOP; - STACKTOP = STACKTOP + ($241 * 4 & -1) | 0; - STACKTOP = STACKTOP + 7 >> 3 << 3; - if (($241 | 0) > 0) { - $i4_038 = 0; - while (1) { - $245 = _clock() | 0; - __ZN7b2World4StepEfii($world); - HEAP32[$243 + ($i4_038 << 2) >> 2] = (_clock() | 0) - $245; - $i4_038 = $i4_038 + 1 | 0; - if (($i4_038 | 0) >= (HEAP32[2414] | 0)) { - break; - } - } + } + $241 = HEAP32[2414] | 0; + $242 = _llvm_stacksave() | 0; + $243 = STACKTOP; + STACKTOP = STACKTOP + ($241 * 4 & -1) | 0; + STACKTOP = STACKTOP + 7 >> 3 << 3; + if (($241 | 0) > 0) { + $i4_038 = 0; + while (1) { + $245 = _clock() | 0; + __ZN7b2World4StepEfii($world); + HEAP32[$243 + ($i4_038 << 2) >> 2] = (_clock() | 0) - $245; + $i4_038 = $i4_038 + 1 | 0; + if (($i4_038 | 0) >= (HEAP32[2414] | 0)) { + break; + } } - __Z7measurePm($result, $243); - $260 = +HEAPF32[$result + 4 >> 2]; - _printf(3480, (tempInt = STACKTOP, STACKTOP = STACKTOP + 16 | 0, HEAPF64[tempInt >> 3] = +HEAPF32[$result >> 2], HEAPF64[tempInt + 8 >> 3] = $260, tempInt) | 0) | 0; - _llvm_stackrestore($242 | 0); - __ZN7b2WorldD2Ev($world); - $_0 = 0; - STACKTOP = __stackBase__; - return $_0 | 0; + } + __Z7measurePm($result, $243); + $260 = +HEAPF32[$result + 4 >> 2]; + _printf(3480, (tempInt = STACKTOP, STACKTOP = STACKTOP + 16 | 0, HEAPF64[tempInt >> 3] = +HEAPF32[$result >> 2], HEAPF64[tempInt + 8 >> 3] = $260, tempInt) | 0) | 0; + _llvm_stackrestore($242 | 0); + __ZN7b2WorldD2Ev($world); + $_0 = 0; + STACKTOP = __stackBase__; + return $_0 | 0; } diff --git a/tools/test-js-optimizer-asm-pre.js b/tools/test-js-optimizer-asm-pre.js index 4f3ba7804dbbc..ca7d28946ed80 100644 --- a/tools/test-js-optimizer-asm-pre.js +++ b/tools/test-js-optimizer-asm-pre.js @@ -1,527 +1,527 @@ function a() { - f((HEAPU8[10202] | 0) + 5 | 0); - f((HEAPU8[10202] | 0) | 0); - f(347 | 0); - f(347 | 12); - f(347 & 12); - HEAP[4096 >> 2] = 5; - HEAP[(4096 & 8191) >> 2] = 5; - whee(12, 13) | 0; - +whee(12, 13); - f((g = t(), (g+g)|0)|0); - // always coerce function calls in asm - f() | 0; - f((h() | 0) + 5 | 0); - f(((x + y) | 0) + z | 0); - +f(); - f(+(+h() + 5)); - $140 = $p_3_i + (-$mantSize_0_i | 0) | 0; - f(g() | 0 | 0); - f(g() | 0 & -1); - f((g() | 0) >> 2); - $56 = (_fcntl() | 0) | 1; + f((HEAPU8[10202] | 0) + 5 | 0); + f((HEAPU8[10202] | 0) | 0); + f(347 | 0); + f(347 | 12); + f(347 & 12); + HEAP[4096 >> 2] = 5; + HEAP[(4096 & 8191) >> 2] = 5; + whee(12, 13) | 0; + +whee(12, 13); + f((g = t(), (g+g)|0)|0); + // always coerce function calls in asm + f() | 0; + f((h() | 0) + 5 | 0); + f(((x + y) | 0) + z | 0); + +f(); + f(+(+h() + 5)); + $140 = $p_3_i + (-$mantSize_0_i | 0) | 0; + f(g() | 0 | 0); + f(g() | 0 & -1); + f((g() | 0) >> 2); + $56 = (_fcntl() | 0) | 1; } function b($this, $__n) { - $this = $this | 0; - $__n = $__n | 0; - var $4 = 0, $5 = 0, $10 = 0, $13 = 0, $14 = 0, $15 = 0, $23 = 0, $30 = 0, $38 = 0, $40 = 0; - if (($__n | 0) == 0) { - return; - } - $4 = $this; - $5 = HEAP8[$4 & 16777215] | 0; - if (($5 & 1) << 24 >> 24 == 0) { - $14 = 10; - $13 = $5; - } else { - $10 = HEAP32[(($this | 0) & 16777215) >> 2] | 0; - $14 = ($10 & -2) - 1 | 0; - $13 = $10 & 255; - } - $15 = $13 & 255; - if (($15 & 1 | 0) == 0) { - $23 = $15 >>> 1; - } else { - $23 = HEAP32[(($this + 4 | 0) & 16777215) >> 2] | 0; - } - if (($14 - $23 | 0) >>> 0 < $__n >>> 0) { - __ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9__grow_byEjjjjjj($this, $14, ($__n - $14 | 0) + $23 | 0, $23, $23); - $30 = HEAP8[$4 & 16777215] | 0; - } else { - $30 = $13; - } - if (($30 & 1) << 24 >> 24 == 0) { - $38 = $this + 1 | 0; - } else { - $38 = HEAP32[(($this + 8 | 0) & 16777215) >> 2] | 0; - } - _memset($38 + $23 | 0 | 0 | 0, 0 | 0 | 0, $__n | 0 | 0, 1 | 0 | 0, 1213141516); - $40 = $23 + $__n | 0; - if (((HEAP8[$4 & 16777215] | 0) & 1) << 24 >> 24 == 0) { - HEAP8[$4 & 16777215] = $40 << 1 & 255; - } else { - HEAP32[(($this + 4 | 0) & 16777215) >> 2] = $40; - } - HEAP8[($38 + $40 | 0) & 16777215] = 0; + $this = $this | 0; + $__n = $__n | 0; + var $4 = 0, $5 = 0, $10 = 0, $13 = 0, $14 = 0, $15 = 0, $23 = 0, $30 = 0, $38 = 0, $40 = 0; + if (($__n | 0) == 0) { return; + } + $4 = $this; + $5 = HEAP8[$4 & 16777215] | 0; + if (($5 & 1) << 24 >> 24 == 0) { + $14 = 10; + $13 = $5; + } else { + $10 = HEAP32[(($this | 0) & 16777215) >> 2] | 0; + $14 = ($10 & -2) - 1 | 0; + $13 = $10 & 255; + } + $15 = $13 & 255; + if (($15 & 1 | 0) == 0) { + $23 = $15 >>> 1; + } else { + $23 = HEAP32[(($this + 4 | 0) & 16777215) >> 2] | 0; + } + if (($14 - $23 | 0) >>> 0 < $__n >>> 0) { + __ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9__grow_byEjjjjjj($this, $14, ($__n - $14 | 0) + $23 | 0, $23, $23); + $30 = HEAP8[$4 & 16777215] | 0; + } else { + $30 = $13; + } + if (($30 & 1) << 24 >> 24 == 0) { + $38 = $this + 1 | 0; + } else { + $38 = HEAP32[(($this + 8 | 0) & 16777215) >> 2] | 0; + } + _memset($38 + $23 | 0 | 0 | 0, 0 | 0 | 0, $__n | 0 | 0, 1 | 0 | 0, 1213141516); + $40 = $23 + $__n | 0; + if (((HEAP8[$4 & 16777215] | 0) & 1) << 24 >> 24 == 0) { + HEAP8[$4 & 16777215] = $40 << 1 & 255; + } else { + HEAP32[(($this + 4 | 0) & 16777215) >> 2] = $40; + } + HEAP8[($38 + $40 | 0) & 16777215] = 0; + return; } function rett() { - if (f()) { - g(); - return 5; - } - // missing final return, need to add it + if (f()) { + g(); + return 5; + } + // missing final return, need to add it } function ret2t() { - if (f()) { - g(); - return; - } - // missing final return, but no need + if (f()) { + g(); + return; + } + // missing final return, but no need } function retf() { - if (f()) { - g(); - return +h(); - } - // missing final return, need it as a float + if (f()) { + g(); + return +h(); + } + // missing final return, need it as a float } function i32_8() { - if (((HEAP8[$4 & 16777215] | 0) << 24 >> 24) == 0) { - print(5); - } - if ((HEAP8[$5 & 16777215] << 24 >> 24) == 0) { - print(5); - } - if (((HEAPU8[$6 & 16777215] | 0) << 24 >> 24) == 0) { - print(5); - } - if ((HEAPU8[$7 & 16777215] << 24 >> 24) == 0) { - print(5); - } - // non-valid - if ((HEAPU8[$8 & 16777215] << 24 >> 16) == 0) { - print(5); - } - if ((HEAPU8[$9 & 16777215] << 16 >> 16) == 0) { - print(5); - } + if (((HEAP8[$4 & 16777215] | 0) << 24 >> 24) == 0) { + print(5); + } + if ((HEAP8[$5 & 16777215] << 24 >> 24) == 0) { + print(5); + } + if (((HEAPU8[$6 & 16777215] | 0) << 24 >> 24) == 0) { + print(5); + } + if ((HEAPU8[$7 & 16777215] << 24 >> 24) == 0) { + print(5); + } + // non-valid + if ((HEAPU8[$8 & 16777215] << 24 >> 16) == 0) { + print(5); + } + if ((HEAPU8[$9 & 16777215] << 16 >> 16) == 0) { + print(5); + } } function sign_extension_simplification() { - if ((HEAP8[$4 & 16777215] & 127) << 24 >> 24 == 0) { - print(5); - } - if ((HEAP8[$4 & 16777215] & 128) << 24 >> 24 == 0) { - print(5); - } - if ((HEAP32[$5 & 16777215] & 32767) << 16 >> 16 == 0) { - print(5); - } - if ((HEAP32[$5 & 16777215] & 32768) << 16 >> 16 == 0) { - print(5); - } + if ((HEAP8[$4 & 16777215] & 127) << 24 >> 24 == 0) { + print(5); + } + if ((HEAP8[$4 & 16777215] & 128) << 24 >> 24 == 0) { + print(5); + } + if ((HEAP32[$5 & 16777215] & 32767) << 16 >> 16 == 0) { + print(5); + } + if ((HEAP32[$5 & 16777215] & 32768) << 16 >> 16 == 0) { + print(5); + } } function tempDoublePtr($45, $14, $28, $42) { - $45 = $45 | 0; - $14 = $14 | 0; - $28 = $28 | 0; - $42 = $42 | 0; - var unelim = 0; // only used as assign to int heap, so can avoid bitcast in definition - var bad = 0; - var unelim2 = 0; // opposite types - unelim = (HEAPF32[tempDoublePtr >> 2] = 127.5 * +$14, HEAP32[tempDoublePtr >> 2] | 0); - HEAP32[$45 >> 2] = 0 | (HEAPF32[tempDoublePtr >> 2] = ($14 < $28 ? $14 : $28) - $42, HEAP32[tempDoublePtr >> 2] | 0); - HEAP32[$world + 102916 >> 2] = _malloc(192) | 0; - f((HEAP32[tempDoublePtr >> 2] = HEAP32[$45 >> 2], +HEAPF32[tempDoublePtr >> 2])); - g((HEAPF32[tempDoublePtr >> 2] = HEAPF32[$14 >> 2], HEAP32[tempDoublePtr >> 2] | 0)); - $42 = (HEAP32[tempDoublePtr >> 2] = HEAP32[$42 >> 2] | 0, +HEAPF32[tempDoublePtr >> 2]); - ch($42); - HEAP32[$45 >> 2] = unelim; - moar(); - bad = (HEAPF32[tempDoublePtr >> 2] = 127.5 * +$14, HEAP32[tempDoublePtr >> 2] | 0); - func(); - HEAP32[4] = bad; - HEAP32[5] = (bad + 1) | 0; - moar(); - unelim2 = (HEAP32[tempDoublePtr >> 2] = 127 + $14, +HEAPF32[tempDoublePtr >> 2]); - func(); - HEAPF32[4] = unelim2; + $45 = $45 | 0; + $14 = $14 | 0; + $28 = $28 | 0; + $42 = $42 | 0; + var unelim = 0; // only used as assign to int heap, so can avoid bitcast in definition + var bad = 0; + var unelim2 = 0; // opposite types + unelim = (HEAPF32[tempDoublePtr >> 2] = 127.5 * +$14, HEAP32[tempDoublePtr >> 2] | 0); + HEAP32[$45 >> 2] = 0 | (HEAPF32[tempDoublePtr >> 2] = ($14 < $28 ? $14 : $28) - $42, HEAP32[tempDoublePtr >> 2] | 0); + HEAP32[$world + 102916 >> 2] = _malloc(192) | 0; + f((HEAP32[tempDoublePtr >> 2] = HEAP32[$45 >> 2], +HEAPF32[tempDoublePtr >> 2])); + g((HEAPF32[tempDoublePtr >> 2] = HEAPF32[$14 >> 2], HEAP32[tempDoublePtr >> 2] | 0)); + $42 = (HEAP32[tempDoublePtr >> 2] = HEAP32[$42 >> 2] | 0, +HEAPF32[tempDoublePtr >> 2]); + ch($42); + HEAP32[$45 >> 2] = unelim; + moar(); + bad = (HEAPF32[tempDoublePtr >> 2] = 127.5 * +$14, HEAP32[tempDoublePtr >> 2] | 0); + func(); + HEAP32[4] = bad; + HEAP32[5] = (bad + 1) | 0; + moar(); + unelim2 = (HEAP32[tempDoublePtr >> 2] = 127 + $14, +HEAPF32[tempDoublePtr >> 2]); + func(); + HEAPF32[4] = unelim2; } function boxx($this, $aabb, $xf, $childIndex) { - $this = $this | 0; - $aabb = $aabb | 0; - $xf = $xf | 0; - $childIndex = $childIndex | 0; - var $2 = +0, $4 = +0, $7 = +0, $9 = +0, $13 = +0, $14 = +0, $19 = +0, $20 = +0, $22 = +0, $25 = +0, $28 = +0, $32 = +0, $42 = +0, $45 = 0, $_sroa_06_0_insert_insert$1 = 0, $51 = 0, $_sroa_0_0_insert_insert$1 = 0; - $2 = +HEAPF32[$xf + 12 >> 2]; - $4 = +HEAPF32[$this + 12 >> 2]; - $7 = +HEAPF32[$xf + 8 >> 2]; - $9 = +HEAPF32[$this + 16 >> 2]; - $13 = +HEAPF32[$xf >> 2]; - $14 = $13 + ($2 * $4 - $7 * $9); - $19 = +HEAPF32[$xf + 4 >> 2]; - $20 = $4 * $7 + $2 * $9 + $19; - $22 = +HEAPF32[$this + 20 >> 2]; - $25 = +HEAPF32[$this + 24 >> 2]; - $28 = $13 + ($2 * $22 - $7 * $25); - $32 = $19 + ($7 * $22 + $2 * $25); - $42 = +HEAPF32[$this + 8 >> 2]; - $45 = $aabb; - $_sroa_06_0_insert_insert$1 = (HEAPF32[tempDoublePtr >> 2] = ($20 < $32 ? $20 : $32) - $42, HEAP32[tempDoublePtr >> 2] | 0) | 0; - HEAPF32[$45 >> 2] = ($14 < $28 ? $14 : $28) - $42; - HEAP32[$45 + 4 >> 2] = $_sroa_06_0_insert_insert$1; - $51 = $aabb + 8 | 0; - $_sroa_0_0_insert_insert$1 = (HEAPF32[tempDoublePtr >> 2] = $42 + ($20 > $32 ? $20 : $32), HEAP32[tempDoublePtr >> 2] | 0) | 0; - HEAPF32[$51 >> 2] = $42 + ($14 > $28 ? $14 : $28); - HEAP32[$51 + 4 >> 2] = $_sroa_0_0_insert_insert$1; - return; + $this = $this | 0; + $aabb = $aabb | 0; + $xf = $xf | 0; + $childIndex = $childIndex | 0; + var $2 = +0, $4 = +0, $7 = +0, $9 = +0, $13 = +0, $14 = +0, $19 = +0, $20 = +0, $22 = +0, $25 = +0, $28 = +0, $32 = +0, $42 = +0, $45 = 0, $_sroa_06_0_insert_insert$1 = 0, $51 = 0, $_sroa_0_0_insert_insert$1 = 0; + $2 = +HEAPF32[$xf + 12 >> 2]; + $4 = +HEAPF32[$this + 12 >> 2]; + $7 = +HEAPF32[$xf + 8 >> 2]; + $9 = +HEAPF32[$this + 16 >> 2]; + $13 = +HEAPF32[$xf >> 2]; + $14 = $13 + ($2 * $4 - $7 * $9); + $19 = +HEAPF32[$xf + 4 >> 2]; + $20 = $4 * $7 + $2 * $9 + $19; + $22 = +HEAPF32[$this + 20 >> 2]; + $25 = +HEAPF32[$this + 24 >> 2]; + $28 = $13 + ($2 * $22 - $7 * $25); + $32 = $19 + ($7 * $22 + $2 * $25); + $42 = +HEAPF32[$this + 8 >> 2]; + $45 = $aabb; + $_sroa_06_0_insert_insert$1 = (HEAPF32[tempDoublePtr >> 2] = ($20 < $32 ? $20 : $32) - $42, HEAP32[tempDoublePtr >> 2] | 0) | 0; + HEAPF32[$45 >> 2] = ($14 < $28 ? $14 : $28) - $42; + HEAP32[$45 + 4 >> 2] = $_sroa_06_0_insert_insert$1; + $51 = $aabb + 8 | 0; + $_sroa_0_0_insert_insert$1 = (HEAPF32[tempDoublePtr >> 2] = $42 + ($20 > $32 ? $20 : $32), HEAP32[tempDoublePtr >> 2] | 0) | 0; + HEAPF32[$51 >> 2] = $42 + ($14 > $28 ? $14 : $28); + HEAP32[$51 + 4 >> 2] = $_sroa_0_0_insert_insert$1; + return; } function _main($argc, $argv) { - $argc = $argc | 0; - $argv = $argv | 0; - var $def_i21 = 0, $def_i = 0, $world = 0, $bd = 0, $shape = 0, $shape1 = 0, $bd2 = 0, $result = 0, $6 = 0, $WARMUP_0 = 0, $14 = 0, $15 = 0, $17 = 0, $i_09_i_i = 0, $j_08_i_i = 0, $34 = 0, $j_1_i_i = 0, $38 = 0, $46 = 0, $48 = 0, $50 = 0, $54 = 0, $i_05_i_i_i = 0, $56 = 0, $62 = 0, $_lcssa_i_i_i = 0, $87 = 0, $96 = 0, $97 = 0, $98 = 0, $112 = 0, $115 = 0, $116 = 0, $118 = 0, $121 = 0, $126 = 0, $135 = 0, $137 = 0, $174 = 0, $176 = 0, $177 = 0, $178 = 0, $179 = 0, $180 = 0, $181 = 0, $182 = 0, $183 = 0, $185 = 0, $186 = 0, $188 = 0, $189 = 0, $190 = 0, $191 = 0, $192 = 0, $193 = 0, $194 = 0, $195 = 0, $196 = 0, $i_057 = 0, $x_sroa_0_0_load303656 = +0, $x_sroa_1_4_load313755 = +0, $j_052 = 0, $y_sroa_0_0_load283451 = +0, $y_sroa_1_4_load293550 = +0, $y_sroa_0_0_insert_insert$1 = 0, $205 = 0, $208 = 0, $209 = 0, $213 = 0, $223 = 0, $236 = 0, $i3_042 = 0, $241 = 0, $242 = 0, $243 = 0, $i4_038 = 0, $245 = 0, $260 = +0, $_0 = 0, label = 0, __stackBase__ = 0; - __stackBase__ = STACKTOP; - STACKTOP = STACKTOP + 103416 | 0; - $def_i21 = __stackBase__ | 0; - $def_i = __stackBase__ + 32 | 0; - $world = __stackBase__ + 64 | 0; - $bd = __stackBase__ + 103096 | 0; - $shape = __stackBase__ + 103152 | 0; - $shape1 = __stackBase__ + 103200 | 0; - $bd2 = __stackBase__ + 103352 | 0; - $result = __stackBase__ + 103408 | 0; - do { - if (($argc | 0) > 1) { - $6 = (HEAP8[HEAP32[($argv + 4 | 0) >> 2] | 0] | 0) << 24 >> 24; - if (($6 | 0 | 0) == (49 | 0)) { - HEAP32[9656 >> 2] = 35; - $WARMUP_0 = 5; - break; - } else if (($6 | 0 | 0) == (50 | 0)) { - HEAP32[9656 >> 2] = 161; - $WARMUP_0 = 32; - break; - } else if (($6 | 0 | 0) == (51 | 0)) { - label = 43; - break; - } else if (($6 | 0 | 0) == (52 | 0)) { - HEAP32[9656 >> 2] = 2331; - $WARMUP_0 = 320; - break; - } else if (($6 | 0 | 0) == (53 | 0)) { - HEAP32[9656 >> 2] = 5661; - $WARMUP_0 = 640; - break; - } else if (($6 | 0 | 0) == (48 | 0)) { - $_0 = 0; - STACKTOP = __stackBase__; - return $_0 | 0; - } else { - _printf(3512 | 0 | 0, (tempInt = STACKTOP, STACKTOP = STACKTOP + 8 | 0, HEAP32[tempInt >> 2] = $6 - 48 | 0, tempInt) | 0) | 0; - $_0 = -1; - STACKTOP = __stackBase__; - return $_0 | 0; - } - } else { - label = 43; - } - } while (0); - if ((label | 0) == 43) { - HEAP32[9656 >> 2] = 333; - $WARMUP_0 = 64; - } - $14 = $world | 0; - $15 = $world + 8 | 0; - HEAP32[$15 >> 2] = 128; - HEAP32[($world + 4 | 0) >> 2] = 0; - $17 = _malloc(1024) | 0; - HEAP32[($world | 0) >> 2] = $17; - _memset($17 | 0 | 0, 0 | 0 | 0, (HEAP32[$15 >> 2] | 0) << 3 | 0 | 0); - _memset($world + 12 | 0 | 0 | 0, 0 | 0 | 0, 56 | 0 | 0); - $j_08_i_i = 0; - $i_09_i_i = 1; - while (1) { - if (!(($j_08_i_i | 0) < 14)) { - label = 49; - break; - } - if (($i_09_i_i | 0) > (HEAP32[(9600 + ($j_08_i_i << 2) | 0) >> 2] | 0 | 0)) { - $34 = $j_08_i_i + 1 | 0; - HEAP8[$i_09_i_i + 8952 | 0] = $34 & 255; - $j_1_i_i = $34; - } else { - HEAP8[$i_09_i_i + 8952 | 0] = $j_08_i_i & 255; - $j_1_i_i = $j_08_i_i; - } - $38 = $i_09_i_i + 1 | 0; - if (($38 | 0) < 641) { - $j_08_i_i = $j_1_i_i; - $i_09_i_i = $38; - } else { - break; - } + $argc = $argc | 0; + $argv = $argv | 0; + var $def_i21 = 0, $def_i = 0, $world = 0, $bd = 0, $shape = 0, $shape1 = 0, $bd2 = 0, $result = 0, $6 = 0, $WARMUP_0 = 0, $14 = 0, $15 = 0, $17 = 0, $i_09_i_i = 0, $j_08_i_i = 0, $34 = 0, $j_1_i_i = 0, $38 = 0, $46 = 0, $48 = 0, $50 = 0, $54 = 0, $i_05_i_i_i = 0, $56 = 0, $62 = 0, $_lcssa_i_i_i = 0, $87 = 0, $96 = 0, $97 = 0, $98 = 0, $112 = 0, $115 = 0, $116 = 0, $118 = 0, $121 = 0, $126 = 0, $135 = 0, $137 = 0, $174 = 0, $176 = 0, $177 = 0, $178 = 0, $179 = 0, $180 = 0, $181 = 0, $182 = 0, $183 = 0, $185 = 0, $186 = 0, $188 = 0, $189 = 0, $190 = 0, $191 = 0, $192 = 0, $193 = 0, $194 = 0, $195 = 0, $196 = 0, $i_057 = 0, $x_sroa_0_0_load303656 = +0, $x_sroa_1_4_load313755 = +0, $j_052 = 0, $y_sroa_0_0_load283451 = +0, $y_sroa_1_4_load293550 = +0, $y_sroa_0_0_insert_insert$1 = 0, $205 = 0, $208 = 0, $209 = 0, $213 = 0, $223 = 0, $236 = 0, $i3_042 = 0, $241 = 0, $242 = 0, $243 = 0, $i4_038 = 0, $245 = 0, $260 = +0, $_0 = 0, label = 0, __stackBase__ = 0; + __stackBase__ = STACKTOP; + STACKTOP = STACKTOP + 103416 | 0; + $def_i21 = __stackBase__ | 0; + $def_i = __stackBase__ + 32 | 0; + $world = __stackBase__ + 64 | 0; + $bd = __stackBase__ + 103096 | 0; + $shape = __stackBase__ + 103152 | 0; + $shape1 = __stackBase__ + 103200 | 0; + $bd2 = __stackBase__ + 103352 | 0; + $result = __stackBase__ + 103408 | 0; + do { + if (($argc | 0) > 1) { + $6 = (HEAP8[HEAP32[($argv + 4 | 0) >> 2] | 0] | 0) << 24 >> 24; + if (($6 | 0 | 0) == (49 | 0)) { + HEAP32[9656 >> 2] = 35; + $WARMUP_0 = 5; + break; + } else if (($6 | 0 | 0) == (50 | 0)) { + HEAP32[9656 >> 2] = 161; + $WARMUP_0 = 32; + break; + } else if (($6 | 0 | 0) == (51 | 0)) { + label = 43; + break; + } else if (($6 | 0 | 0) == (52 | 0)) { + HEAP32[9656 >> 2] = 2331; + $WARMUP_0 = 320; + break; + } else if (($6 | 0 | 0) == (53 | 0)) { + HEAP32[9656 >> 2] = 5661; + $WARMUP_0 = 640; + break; + } else if (($6 | 0 | 0) == (48 | 0)) { + $_0 = 0; + STACKTOP = __stackBase__; + return $_0 | 0; + } else { + _printf(3512 | 0 | 0, (tempInt = STACKTOP, STACKTOP = STACKTOP + 8 | 0, HEAP32[tempInt >> 2] = $6 - 48 | 0, tempInt) | 0) | 0; + $_0 = -1; + STACKTOP = __stackBase__; + return $_0 | 0; + } + } else { + label = 43; } - if ((label | 0) == 49) { - ___assert_func(3248 | 0 | 0, 73 | 0, 6448 | 0 | 0, 3360 | 0 | 0); - return 0 | 0; + } while (0); + if ((label | 0) == 43) { + HEAP32[9656 >> 2] = 333; + $WARMUP_0 = 64; + } + $14 = $world | 0; + $15 = $world + 8 | 0; + HEAP32[$15 >> 2] = 128; + HEAP32[($world + 4 | 0) >> 2] = 0; + $17 = _malloc(1024) | 0; + HEAP32[($world | 0) >> 2] = $17; + _memset($17 | 0 | 0, 0 | 0 | 0, (HEAP32[$15 >> 2] | 0) << 3 | 0 | 0); + _memset($world + 12 | 0 | 0 | 0, 0 | 0 | 0, 56 | 0 | 0); + $j_08_i_i = 0; + $i_09_i_i = 1; + while (1) { + if (!(($j_08_i_i | 0) < 14)) { + label = 49; + break; } - HEAP32[($world + 102468 | 0) >> 2] = 0; - HEAP32[($world + 102472 | 0) >> 2] = 0; - HEAP32[($world + 102476 | 0) >> 2] = 0; - HEAP32[($world + 102864 | 0) >> 2] = 0; - HEAP32[($world + 102872 | 0) >> 2] = -1; - $46 = $world + 102884 | 0; - HEAP32[$46 >> 2] = 16; - HEAP32[($world + 102880 | 0) >> 2] = 0; - $48 = _malloc(576) | 0; - $50 = $world + 102876 | 0; - HEAP32[$50 >> 2] = $48; - _memset($48 | 0 | 0, 0 | 0 | 0, (HEAP32[$46 >> 2] | 0) * 36 & -1 | 0 | 0); - $54 = (HEAP32[$46 >> 2] | 0) - 1 | 0; - if (($54 | 0) > 0) { - $i_05_i_i_i = 0; - while (1) { - $56 = $i_05_i_i_i + 1 | 0; - HEAP32[((HEAP32[$50 >> 2] | 0) + ($i_05_i_i_i * 36 & -1) + 20 | 0) >> 2] = $56; - HEAP32[((HEAP32[$50 >> 2] | 0) + ($i_05_i_i_i * 36 & -1) + 32 | 0) >> 2] = -1; - $62 = (HEAP32[$46 >> 2] | 0) - 1 | 0; - if (($56 | 0) < ($62 | 0)) { - $i_05_i_i_i = $56; - } else { - $_lcssa_i_i_i = $62; - break; - } - } + if (($i_09_i_i | 0) > (HEAP32[(9600 + ($j_08_i_i << 2) | 0) >> 2] | 0 | 0)) { + $34 = $j_08_i_i + 1 | 0; + HEAP8[$i_09_i_i + 8952 | 0] = $34 & 255; + $j_1_i_i = $34; } else { - $_lcssa_i_i_i = $54; + HEAP8[$i_09_i_i + 8952 | 0] = $j_08_i_i & 255; + $j_1_i_i = $j_08_i_i; } - HEAP32[((HEAP32[$50 >> 2] | 0) + ($_lcssa_i_i_i * 36 & -1) + 20 | 0) >> 2] = -1; - HEAP32[((HEAP32[$50 >> 2] | 0) + (((HEAP32[$46 >> 2] | 0) - 1 | 0) * 36 & -1) + 32 | 0) >> 2] = -1; - _memset($world + 102888 | 0 | 0 | 0, 0 | 0 | 0, 16 | 0 | 0); - HEAP32[($world + 102920 | 0) >> 2] = 16; - HEAP32[($world + 102924 | 0) >> 2] = 0; - HEAP32[($world + 102916 | 0) >> 2] = _malloc(192) | 0; - HEAP32[($world + 102908 | 0) >> 2] = 16; - HEAP32[($world + 102912 | 0) >> 2] = 0; - HEAP32[($world + 102904 | 0) >> 2] = _malloc(64) | 0; - HEAP32[($world + 102932 | 0) >> 2] = 0; - HEAP32[($world + 102936 | 0) >> 2] = 0; - HEAP32[($world + 102940 | 0) >> 2] = 104; - HEAP32[($world + 102944 | 0) >> 2] = 96; - $87 = $world + 102948 | 0; - HEAP32[($world + 102980 | 0) >> 2] = 0; - HEAP32[($world + 102984 | 0) >> 2] = 0; - _memset($87 | 0 | 0, 0 | 0 | 0, 20 | 0 | 0); - HEAP8[$world + 102992 | 0] = 1; - HEAP8[$world + 102993 | 0] = 1; - HEAP8[$world + 102994 | 0] = 0; - HEAP8[$world + 102995 | 0] = 1; - $96 = $world + 102976 | 0; - HEAP8[$96] = 1; - $97 = $world + 102968 | 0; - HEAP32[($97 | 0) >> 2] = 0; - HEAP32[($97 + 4 | 0) >> 2] = -1054867456; - $98 = $world + 102868 | 0; - HEAP32[$98 >> 2] = 4; - HEAPF32[($world + 102988 | 0) >> 2] = +0; - HEAP32[$87 >> 2] = $14; - _memset($world + 102996 | 0 | 0 | 0, 0 | 0 | 0, 32 | 0 | 0); - HEAP8[$96] = 0; - HEAP32[($bd + 44 | 0) >> 2] = 0; - _memset($bd + 4 | 0 | 0 | 0, 0 | 0 | 0, 32 | 0 | 0); - HEAP8[$bd + 36 | 0] = 1; - HEAP8[$bd + 37 | 0] = 1; - HEAP8[$bd + 38 | 0] = 0; - HEAP8[$bd + 39 | 0] = 0; - HEAP32[($bd | 0) >> 2] = 0; - HEAP8[$bd + 40 | 0] = 1; - HEAPF32[($bd + 48 | 0) >> 2] = +1; - $112 = __ZN16b2BlockAllocator8AllocateEi($14, 152) | 0; - if (($112 | 0) == 0) { - $116 = 0; + $38 = $i_09_i_i + 1 | 0; + if (($38 | 0) < 641) { + $j_08_i_i = $j_1_i_i; + $i_09_i_i = $38; } else { - $115 = $112; - __ZN6b2BodyC2EPK9b2BodyDefP7b2World($115, $bd, $world); - $116 = $115; + break; + } + } + if ((label | 0) == 49) { + ___assert_func(3248 | 0 | 0, 73 | 0, 6448 | 0 | 0, 3360 | 0 | 0); + return 0 | 0; + } + HEAP32[($world + 102468 | 0) >> 2] = 0; + HEAP32[($world + 102472 | 0) >> 2] = 0; + HEAP32[($world + 102476 | 0) >> 2] = 0; + HEAP32[($world + 102864 | 0) >> 2] = 0; + HEAP32[($world + 102872 | 0) >> 2] = -1; + $46 = $world + 102884 | 0; + HEAP32[$46 >> 2] = 16; + HEAP32[($world + 102880 | 0) >> 2] = 0; + $48 = _malloc(576) | 0; + $50 = $world + 102876 | 0; + HEAP32[$50 >> 2] = $48; + _memset($48 | 0 | 0, 0 | 0 | 0, (HEAP32[$46 >> 2] | 0) * 36 & -1 | 0 | 0); + $54 = (HEAP32[$46 >> 2] | 0) - 1 | 0; + if (($54 | 0) > 0) { + $i_05_i_i_i = 0; + while (1) { + $56 = $i_05_i_i_i + 1 | 0; + HEAP32[((HEAP32[$50 >> 2] | 0) + ($i_05_i_i_i * 36 & -1) + 20 | 0) >> 2] = $56; + HEAP32[((HEAP32[$50 >> 2] | 0) + ($i_05_i_i_i * 36 & -1) + 32 | 0) >> 2] = -1; + $62 = (HEAP32[$46 >> 2] | 0) - 1 | 0; + if (($56 | 0) < ($62 | 0)) { + $i_05_i_i_i = $56; + } else { + $_lcssa_i_i_i = $62; + break; + } } - HEAP32[($116 + 92 | 0) >> 2] = 0; - $118 = $world + 102952 | 0; - HEAP32[($116 + 96 | 0) >> 2] = HEAP32[$118 >> 2] | 0; - $121 = HEAP32[$118 >> 2] | 0; - if (!(($121 | 0) == 0)) { - HEAP32[($121 + 92 | 0) >> 2] = $116; + } else { + $_lcssa_i_i_i = $54; + } + HEAP32[((HEAP32[$50 >> 2] | 0) + ($_lcssa_i_i_i * 36 & -1) + 20 | 0) >> 2] = -1; + HEAP32[((HEAP32[$50 >> 2] | 0) + (((HEAP32[$46 >> 2] | 0) - 1 | 0) * 36 & -1) + 32 | 0) >> 2] = -1; + _memset($world + 102888 | 0 | 0 | 0, 0 | 0 | 0, 16 | 0 | 0); + HEAP32[($world + 102920 | 0) >> 2] = 16; + HEAP32[($world + 102924 | 0) >> 2] = 0; + HEAP32[($world + 102916 | 0) >> 2] = _malloc(192) | 0; + HEAP32[($world + 102908 | 0) >> 2] = 16; + HEAP32[($world + 102912 | 0) >> 2] = 0; + HEAP32[($world + 102904 | 0) >> 2] = _malloc(64) | 0; + HEAP32[($world + 102932 | 0) >> 2] = 0; + HEAP32[($world + 102936 | 0) >> 2] = 0; + HEAP32[($world + 102940 | 0) >> 2] = 104; + HEAP32[($world + 102944 | 0) >> 2] = 96; + $87 = $world + 102948 | 0; + HEAP32[($world + 102980 | 0) >> 2] = 0; + HEAP32[($world + 102984 | 0) >> 2] = 0; + _memset($87 | 0 | 0, 0 | 0 | 0, 20 | 0 | 0); + HEAP8[$world + 102992 | 0] = 1; + HEAP8[$world + 102993 | 0] = 1; + HEAP8[$world + 102994 | 0] = 0; + HEAP8[$world + 102995 | 0] = 1; + $96 = $world + 102976 | 0; + HEAP8[$96] = 1; + $97 = $world + 102968 | 0; + HEAP32[($97 | 0) >> 2] = 0; + HEAP32[($97 + 4 | 0) >> 2] = -1054867456; + $98 = $world + 102868 | 0; + HEAP32[$98 >> 2] = 4; + HEAPF32[($world + 102988 | 0) >> 2] = +0; + HEAP32[$87 >> 2] = $14; + _memset($world + 102996 | 0 | 0 | 0, 0 | 0 | 0, 32 | 0 | 0); + HEAP8[$96] = 0; + HEAP32[($bd + 44 | 0) >> 2] = 0; + _memset($bd + 4 | 0 | 0 | 0, 0 | 0 | 0, 32 | 0 | 0); + HEAP8[$bd + 36 | 0] = 1; + HEAP8[$bd + 37 | 0] = 1; + HEAP8[$bd + 38 | 0] = 0; + HEAP8[$bd + 39 | 0] = 0; + HEAP32[($bd | 0) >> 2] = 0; + HEAP8[$bd + 40 | 0] = 1; + HEAPF32[($bd + 48 | 0) >> 2] = +1; + $112 = __ZN16b2BlockAllocator8AllocateEi($14, 152) | 0; + if (($112 | 0) == 0) { + $116 = 0; + } else { + $115 = $112; + __ZN6b2BodyC2EPK9b2BodyDefP7b2World($115, $bd, $world); + $116 = $115; + } + HEAP32[($116 + 92 | 0) >> 2] = 0; + $118 = $world + 102952 | 0; + HEAP32[($116 + 96 | 0) >> 2] = HEAP32[$118 >> 2] | 0; + $121 = HEAP32[$118 >> 2] | 0; + if (!(($121 | 0) == 0)) { + HEAP32[($121 + 92 | 0) >> 2] = $116; + } + HEAP32[$118 >> 2] = $116; + $126 = $world + 102960 | 0; + HEAP32[$126 >> 2] = (HEAP32[$126 >> 2] | 0) + 1 | 0; + HEAP32[($shape | 0) >> 2] = 8016 | 0; + HEAP32[($shape + 4 | 0) >> 2] = 1; + HEAPF32[($shape + 8 | 0) >> 2] = +.009999999776482582; + _memset($shape + 28 | 0 | 0 | 0, 0 | 0 | 0, 18 | 0 | 0); + $135 = $shape + 12 | 0; + HEAP32[($135 | 0) >> 2] = -1038090240; + HEAP32[($135 + 4 | 0) >> 2] = 0; + $137 = $shape + 20 | 0; + HEAP32[($137 | 0) >> 2] = 1109393408; + HEAP32[($137 + 4 | 0) >> 2] = 0; + HEAP8[$shape + 44 | 0] = 0; + HEAP8[$shape + 45 | 0] = 0; + HEAP16[($def_i + 22 | 0) >> 1] = 1; + HEAP16[($def_i + 24 | 0) >> 1] = -1; + HEAP16[($def_i + 26 | 0) >> 1] = 0; + HEAP32[($def_i + 4 | 0) >> 2] = 0; + HEAPF32[($def_i + 8 | 0) >> 2] = +.20000000298023224; + HEAPF32[($def_i + 12 | 0) >> 2] = +0; + HEAP8[$def_i + 20 | 0] = 0; + HEAP32[($def_i | 0) >> 2] = $shape | 0; + HEAPF32[($def_i + 16 | 0) >> 2] = +0; + __ZN6b2Body13CreateFixtureEPK12b2FixtureDef($116, $def_i); + HEAP32[($shape1 | 0) >> 2] = 7968 | 0; + HEAP32[($shape1 + 4 | 0) >> 2] = 2; + HEAPF32[($shape1 + 8 | 0) >> 2] = +.009999999776482582; + HEAP32[($shape1 + 148 | 0) >> 2] = 4; + HEAPF32[($shape1 + 20 | 0) >> 2] = +-.5; + HEAPF32[($shape1 + 24 | 0) >> 2] = +-.5; + HEAPF32[($shape1 + 28 | 0) >> 2] = +.5; + HEAPF32[($shape1 + 32 | 0) >> 2] = +-.5; + HEAPF32[($shape1 + 36 | 0) >> 2] = +.5; + HEAPF32[($shape1 + 40 | 0) >> 2] = +.5; + HEAPF32[($shape1 + 44 | 0) >> 2] = +-.5; + HEAPF32[($shape1 + 48 | 0) >> 2] = +.5; + HEAPF32[($shape1 + 84 | 0) >> 2] = +0; + HEAPF32[($shape1 + 88 | 0) >> 2] = +-1; + HEAPF32[($shape1 + 92 | 0) >> 2] = +1; + HEAPF32[($shape1 + 96 | 0) >> 2] = +0; + HEAPF32[($shape1 + 100 | 0) >> 2] = +0; + HEAPF32[($shape1 + 104 | 0) >> 2] = +1; + HEAPF32[($shape1 + 108 | 0) >> 2] = +-1; + HEAPF32[($shape1 + 112 | 0) >> 2] = +0; + HEAPF32[($shape1 + 12 | 0) >> 2] = +0; + HEAPF32[($shape1 + 16 | 0) >> 2] = +0; + $174 = $bd2 + 44 | 0; + $176 = $bd2 + 36 | 0; + $177 = $bd2 + 4 | 0; + $178 = $bd2 + 37 | 0; + $179 = $bd2 + 38 | 0; + $180 = $bd2 + 39 | 0; + $181 = $bd2 | 0; + $182 = $bd2 + 40 | 0; + $183 = $bd2 + 48 | 0; + $185 = $bd2 + 4 | 0; + $186 = $shape1 | 0; + $188 = $def_i21 + 22 | 0; + $189 = $def_i21 + 24 | 0; + $190 = $def_i21 + 26 | 0; + $191 = $def_i21 | 0; + $192 = $def_i21 + 4 | 0; + $193 = $def_i21 + 8 | 0; + $194 = $def_i21 + 12 | 0; + $195 = $def_i21 + 16 | 0; + $196 = $def_i21 + 20 | 0; + $x_sroa_1_4_load313755 = +.75; + $x_sroa_0_0_load303656 = +-7; + $i_057 = 0; + L82 : while (1) { + $y_sroa_1_4_load293550 = $x_sroa_1_4_load313755; + $y_sroa_0_0_load283451 = $x_sroa_0_0_load303656; + $j_052 = $i_057; + while (1) { + HEAP32[$174 >> 2] = 0; + _memset($177 | 0 | 0, 0 | 0 | 0, 32 | 0 | 0); + HEAP8[$176] = 1; + HEAP8[$178] = 1; + HEAP8[$179] = 0; + HEAP8[$180] = 0; + HEAP8[$182] = 1; + HEAPF32[$183 >> 2] = +1; + HEAP32[$181 >> 2] = 2; + $y_sroa_0_0_insert_insert$1 = (HEAPF32[tempDoublePtr >> 2] = $y_sroa_1_4_load293550, HEAP32[tempDoublePtr >> 2] | 0) | 0; + HEAP32[($185 | 0) >> 2] = 0 | (HEAPF32[tempDoublePtr >> 2] = $y_sroa_0_0_load283451, HEAP32[tempDoublePtr >> 2] | 0); + HEAP32[($185 + 4 | 0) >> 2] = $y_sroa_0_0_insert_insert$1; + if (!(((HEAP32[$98 >> 2] | 0) & 2 | 0) == 0)) { + label = 65; + break L82; + } + $205 = __ZN16b2BlockAllocator8AllocateEi($14, 152) | 0; + if (($205 | 0) == 0) { + $209 = 0; + } else { + $208 = $205; + __ZN6b2BodyC2EPK9b2BodyDefP7b2World($208, $bd2, $world); + $209 = $208; + } + HEAP32[($209 + 92 | 0) >> 2] = 0; + HEAP32[($209 + 96 | 0) >> 2] = HEAP32[$118 >> 2] | 0; + $213 = HEAP32[$118 >> 2] | 0; + if (!(($213 | 0) == 0)) { + HEAP32[($213 + 92 | 0) >> 2] = $209; + } + HEAP32[$118 >> 2] = $209; + HEAP32[$126 >> 2] = (HEAP32[$126 >> 2] | 0) + 1 | 0; + HEAP16[$188 >> 1] = 1; + HEAP16[$189 >> 1] = -1; + HEAP16[$190 >> 1] = 0; + HEAP32[$192 >> 2] = 0; + HEAPF32[$193 >> 2] = +.20000000298023224; + HEAPF32[$194 >> 2] = +0; + HEAP8[$196] = 0; + HEAP32[$191 >> 2] = $186; + HEAPF32[$195 >> 2] = +5; + __ZN6b2Body13CreateFixtureEPK12b2FixtureDef($209, $def_i21); + $223 = $j_052 + 1 | 0; + if (($223 | 0) < 40) { + $y_sroa_1_4_load293550 = $y_sroa_1_4_load293550 + +0; + $y_sroa_0_0_load283451 = $y_sroa_0_0_load283451 + 1.125; + $j_052 = $223; + } else { + break; + } } - HEAP32[$118 >> 2] = $116; - $126 = $world + 102960 | 0; - HEAP32[$126 >> 2] = (HEAP32[$126 >> 2] | 0) + 1 | 0; - HEAP32[($shape | 0) >> 2] = 8016 | 0; - HEAP32[($shape + 4 | 0) >> 2] = 1; - HEAPF32[($shape + 8 | 0) >> 2] = +.009999999776482582; - _memset($shape + 28 | 0 | 0 | 0, 0 | 0 | 0, 18 | 0 | 0); - $135 = $shape + 12 | 0; - HEAP32[($135 | 0) >> 2] = -1038090240; - HEAP32[($135 + 4 | 0) >> 2] = 0; - $137 = $shape + 20 | 0; - HEAP32[($137 | 0) >> 2] = 1109393408; - HEAP32[($137 + 4 | 0) >> 2] = 0; - HEAP8[$shape + 44 | 0] = 0; - HEAP8[$shape + 45 | 0] = 0; - HEAP16[($def_i + 22 | 0) >> 1] = 1; - HEAP16[($def_i + 24 | 0) >> 1] = -1; - HEAP16[($def_i + 26 | 0) >> 1] = 0; - HEAP32[($def_i + 4 | 0) >> 2] = 0; - HEAPF32[($def_i + 8 | 0) >> 2] = +.20000000298023224; - HEAPF32[($def_i + 12 | 0) >> 2] = +0; - HEAP8[$def_i + 20 | 0] = 0; - HEAP32[($def_i | 0) >> 2] = $shape | 0; - HEAPF32[($def_i + 16 | 0) >> 2] = +0; - __ZN6b2Body13CreateFixtureEPK12b2FixtureDef($116, $def_i); - HEAP32[($shape1 | 0) >> 2] = 7968 | 0; - HEAP32[($shape1 + 4 | 0) >> 2] = 2; - HEAPF32[($shape1 + 8 | 0) >> 2] = +.009999999776482582; - HEAP32[($shape1 + 148 | 0) >> 2] = 4; - HEAPF32[($shape1 + 20 | 0) >> 2] = +-.5; - HEAPF32[($shape1 + 24 | 0) >> 2] = +-.5; - HEAPF32[($shape1 + 28 | 0) >> 2] = +.5; - HEAPF32[($shape1 + 32 | 0) >> 2] = +-.5; - HEAPF32[($shape1 + 36 | 0) >> 2] = +.5; - HEAPF32[($shape1 + 40 | 0) >> 2] = +.5; - HEAPF32[($shape1 + 44 | 0) >> 2] = +-.5; - HEAPF32[($shape1 + 48 | 0) >> 2] = +.5; - HEAPF32[($shape1 + 84 | 0) >> 2] = +0; - HEAPF32[($shape1 + 88 | 0) >> 2] = +-1; - HEAPF32[($shape1 + 92 | 0) >> 2] = +1; - HEAPF32[($shape1 + 96 | 0) >> 2] = +0; - HEAPF32[($shape1 + 100 | 0) >> 2] = +0; - HEAPF32[($shape1 + 104 | 0) >> 2] = +1; - HEAPF32[($shape1 + 108 | 0) >> 2] = +-1; - HEAPF32[($shape1 + 112 | 0) >> 2] = +0; - HEAPF32[($shape1 + 12 | 0) >> 2] = +0; - HEAPF32[($shape1 + 16 | 0) >> 2] = +0; - $174 = $bd2 + 44 | 0; - $176 = $bd2 + 36 | 0; - $177 = $bd2 + 4 | 0; - $178 = $bd2 + 37 | 0; - $179 = $bd2 + 38 | 0; - $180 = $bd2 + 39 | 0; - $181 = $bd2 | 0; - $182 = $bd2 + 40 | 0; - $183 = $bd2 + 48 | 0; - $185 = $bd2 + 4 | 0; - $186 = $shape1 | 0; - $188 = $def_i21 + 22 | 0; - $189 = $def_i21 + 24 | 0; - $190 = $def_i21 + 26 | 0; - $191 = $def_i21 | 0; - $192 = $def_i21 + 4 | 0; - $193 = $def_i21 + 8 | 0; - $194 = $def_i21 + 12 | 0; - $195 = $def_i21 + 16 | 0; - $196 = $def_i21 + 20 | 0; - $x_sroa_1_4_load313755 = +.75; - $x_sroa_0_0_load303656 = +-7; - $i_057 = 0; - L82 : while (1) { - $y_sroa_1_4_load293550 = $x_sroa_1_4_load313755; - $y_sroa_0_0_load283451 = $x_sroa_0_0_load303656; - $j_052 = $i_057; - while (1) { - HEAP32[$174 >> 2] = 0; - _memset($177 | 0 | 0, 0 | 0 | 0, 32 | 0 | 0); - HEAP8[$176] = 1; - HEAP8[$178] = 1; - HEAP8[$179] = 0; - HEAP8[$180] = 0; - HEAP8[$182] = 1; - HEAPF32[$183 >> 2] = +1; - HEAP32[$181 >> 2] = 2; - $y_sroa_0_0_insert_insert$1 = (HEAPF32[tempDoublePtr >> 2] = $y_sroa_1_4_load293550, HEAP32[tempDoublePtr >> 2] | 0) | 0; - HEAP32[($185 | 0) >> 2] = 0 | (HEAPF32[tempDoublePtr >> 2] = $y_sroa_0_0_load283451, HEAP32[tempDoublePtr >> 2] | 0); - HEAP32[($185 + 4 | 0) >> 2] = $y_sroa_0_0_insert_insert$1; - if (!(((HEAP32[$98 >> 2] | 0) & 2 | 0) == 0)) { - label = 65; - break L82; - } - $205 = __ZN16b2BlockAllocator8AllocateEi($14, 152) | 0; - if (($205 | 0) == 0) { - $209 = 0; - } else { - $208 = $205; - __ZN6b2BodyC2EPK9b2BodyDefP7b2World($208, $bd2, $world); - $209 = $208; - } - HEAP32[($209 + 92 | 0) >> 2] = 0; - HEAP32[($209 + 96 | 0) >> 2] = HEAP32[$118 >> 2] | 0; - $213 = HEAP32[$118 >> 2] | 0; - if (!(($213 | 0) == 0)) { - HEAP32[($213 + 92 | 0) >> 2] = $209; - } - HEAP32[$118 >> 2] = $209; - HEAP32[$126 >> 2] = (HEAP32[$126 >> 2] | 0) + 1 | 0; - HEAP16[$188 >> 1] = 1; - HEAP16[$189 >> 1] = -1; - HEAP16[$190 >> 1] = 0; - HEAP32[$192 >> 2] = 0; - HEAPF32[$193 >> 2] = +.20000000298023224; - HEAPF32[$194 >> 2] = +0; - HEAP8[$196] = 0; - HEAP32[$191 >> 2] = $186; - HEAPF32[$195 >> 2] = +5; - __ZN6b2Body13CreateFixtureEPK12b2FixtureDef($209, $def_i21); - $223 = $j_052 + 1 | 0; - if (($223 | 0) < 40) { - $y_sroa_1_4_load293550 = $y_sroa_1_4_load293550 + +0; - $y_sroa_0_0_load283451 = $y_sroa_0_0_load283451 + 1.125; - $j_052 = $223; - } else { - break; - } - } - $236 = $i_057 + 1 | 0; - if (($236 | 0) < 40) { - $x_sroa_1_4_load313755 = $x_sroa_1_4_load313755 + +1; - $x_sroa_0_0_load303656 = $x_sroa_0_0_load303656 + +.5625; - $i_057 = $236; - } else { - $i3_042 = 0; - break; - } + $236 = $i_057 + 1 | 0; + if (($236 | 0) < 40) { + $x_sroa_1_4_load313755 = $x_sroa_1_4_load313755 + +1; + $x_sroa_0_0_load303656 = $x_sroa_0_0_load303656 + +.5625; + $i_057 = $236; + } else { + $i3_042 = 0; + break; } - if ((label | 0) == 65) { - ___assert_func(112 | 0 | 0, 109 | 0, 5328 | 0 | 0, 2520 | 0 | 0); - return 0 | 0; + } + if ((label | 0) == 65) { + ___assert_func(112 | 0 | 0, 109 | 0, 5328 | 0 | 0, 2520 | 0 | 0); + return 0 | 0; + } + while (1) { + __ZN7b2World4StepEfii($world); + $i3_042 = $i3_042 + 1 | 0; + if (($i3_042 | 0) >= ($WARMUP_0 | 0)) { + break; } + } + $241 = HEAP32[9656 >> 2] | 0; + $242 = _llvm_stacksave() | 0; + $243 = STACKTOP; + STACKTOP = STACKTOP + ($241 * 4 & -1) | 0; + STACKTOP = STACKTOP + 7 >> 3 << 3; + if (($241 | 0) > 0) { + $i4_038 = 0; while (1) { - __ZN7b2World4StepEfii($world); - $i3_042 = $i3_042 + 1 | 0; - if (($i3_042 | 0) >= ($WARMUP_0 | 0)) { - break; - } - } - $241 = HEAP32[9656 >> 2] | 0; - $242 = _llvm_stacksave() | 0; - $243 = STACKTOP; - STACKTOP = STACKTOP + ($241 * 4 & -1) | 0; - STACKTOP = STACKTOP + 7 >> 3 << 3; - if (($241 | 0) > 0) { - $i4_038 = 0; - while (1) { - $245 = _clock() | 0; - __ZN7b2World4StepEfii($world); - HEAP32[($243 + ($i4_038 << 2) | 0) >> 2] = (_clock() | 0) - $245 | 0; - $i4_038 = $i4_038 + 1 | 0; - if (($i4_038 | 0) >= (HEAP32[9656 >> 2] | 0 | 0)) { - break; - } - } + $245 = _clock() | 0; + __ZN7b2World4StepEfii($world); + HEAP32[($243 + ($i4_038 << 2) | 0) >> 2] = (_clock() | 0) - $245 | 0; + $i4_038 = $i4_038 + 1 | 0; + if (($i4_038 | 0) >= (HEAP32[9656 >> 2] | 0 | 0)) { + break; + } } - __Z7measurePm($result, $243); - $260 = +HEAPF32[($result + 4 | 0) >> 2]; - _printf(3480 | 0 | 0, (tempInt = STACKTOP, STACKTOP = STACKTOP + 16 | 0, HEAPF64[tempInt >> 3] = +HEAPF32[($result | 0) >> 2], HEAPF64[tempInt + 8 >> 3] = $260, tempInt) | 0) | 0; - _llvm_stackrestore($242 | 0); - __ZN7b2WorldD2Ev($world); - $_0 = 0; - STACKTOP = __stackBase__; - return $_0 | 0; + } + __Z7measurePm($result, $243); + $260 = +HEAPF32[($result + 4 | 0) >> 2]; + _printf(3480 | 0 | 0, (tempInt = STACKTOP, STACKTOP = STACKTOP + 16 | 0, HEAPF64[tempInt >> 3] = +HEAPF32[($result | 0) >> 2], HEAPF64[tempInt + 8 >> 3] = $260, tempInt) | 0) | 0; + _llvm_stackrestore($242 | 0); + __ZN7b2WorldD2Ev($world); + $_0 = 0; + STACKTOP = __stackBase__; + return $_0 | 0; } // EMSCRIPTEN_GENERATED_FUNCTIONS: ["a", "b", "rett", "ret2t", "retf", "i32_8", "tempDoublePtr", "boxx", "_main"] diff --git a/tools/test-js-optimizer-asm-regs-min-output.js b/tools/test-js-optimizer-asm-regs-min-output.js index b8088022b956a..3955e48a03a9b 100644 --- a/tools/test-js-optimizer-asm-regs-min-output.js +++ b/tools/test-js-optimizer-asm-regs-min-output.js @@ -1,36 +1,36 @@ function cl(b) { - b = b | 0; - var c = 0; - c = b * b; - a(c); - i1(b); + b = b | 0; + var c = 0; + c = b * b; + a(c); + i1(b); } function cl(b) { - b = b | 0; - var c = 0; - c = b * b; - a(c); - i1(b); + b = b | 0; + var c = 0; + c = b * b; + a(c); + i1(b); } function cl(b) { - b = b | 0; - var c = 0; - c = b * b; - a(c); - i1(b); + b = b | 0; + var c = 0; + c = b * b; + a(c); + i1(b); } function cl(b) { - b = b | 0; - var c = 0; - c = b * b; - a(c); - i1(b); + b = b | 0; + var c = 0; + c = b * b; + a(c); + i1(b); } function cl(b) { - b = b | 0; - var c = 0; - c = b * b; - a(c); - i1(b); + b = b | 0; + var c = 0; + c = b * b; + a(c); + i1(b); } diff --git a/tools/test-js-optimizer-asm-regs-min.js b/tools/test-js-optimizer-asm-regs-min.js index c126946de4db5..f47dbff340ddd 100644 --- a/tools/test-js-optimizer-asm-regs-min.js +++ b/tools/test-js-optimizer-asm-regs-min.js @@ -1,37 +1,37 @@ function collideLocal(x) { - x = x | 0; - var a = 0; - a = x*x; - aGlobal(a); // aGlobal needs to be minified into a, but a is used! - bGlobal(x); + x = x | 0; + var a = 0; + a = x*x; + aGlobal(a); // aGlobal needs to be minified into a, but a is used! + bGlobal(x); } function collideLocal(x) { - x = x | 0; - var i1 = 0; - i1 = x*x; - aGlobal(i1); - bGlobal(x); // bGlobal needs to be minified into i1, but i1 is used! + x = x | 0; + var i1 = 0; + i1 = x*x; + aGlobal(i1); + bGlobal(x); // bGlobal needs to be minified into i1, but i1 is used! } function collideLocal(a) { - a = a | 0; - var x = 0; - x = a*a; - aGlobal(x); // aGlobal needs to be minified into a, but a is used by a param! - bGlobal(a); + a = a | 0; + var x = 0; + x = a*a; + aGlobal(x); // aGlobal needs to be minified into a, but a is used by a param! + bGlobal(a); } function collideLocal(i1) { - i1 = i1 | 0; - var x = 0; - x = i1*i1; - aGlobal(x); - bGlobal(i1); // bGlobal needs to be minified into i1, but i1 is used by a param! + i1 = i1 | 0; + var x = 0; + x = i1*i1; + aGlobal(x); + bGlobal(i1); // bGlobal needs to be minified into i1, but i1 is used by a param! } function collideLocal(i1) { - i1 = i1 | 0; - var a = 0; - a = i1*i1; - aGlobal(a); // multiple collisions, a and i1 - bGlobal(i1); + i1 = i1 | 0; + var a = 0; + a = i1*i1; + aGlobal(a); // multiple collisions, a and i1 + bGlobal(i1); } // EMSCRIPTEN_GENERATED_FUNCTIONS // MINIFY_INFO: { "names": ["a", "b", "c", "d", "e", "f", "g", "h", "i", "i1", "cl"], "globals": { "aGlobal": "a", "bGlobal": "i1", "collideLocal": "cl" } } diff --git a/tools/test-js-optimizer-asm-regs-output.js b/tools/test-js-optimizer-asm-regs-output.js index c2efa506d055c..49e5032fc38ac 100644 --- a/tools/test-js-optimizer-asm-regs-output.js +++ b/tools/test-js-optimizer-asm-regs-output.js @@ -1,106 +1,106 @@ function asm(d1, i2) { - d1 = +d1; - i2 = i2 | 0; - var i3 = 0, d4 = +0; - i2 = d1 + d1 | 0; - d1 = d(Math_max(10, Math_min(5, f()))); - i3 = i2 + 2 | 0; - print(i3); - d4 = d1 * 5; - return d4; + d1 = +d1; + i2 = i2 | 0; + var i3 = 0, d4 = +0; + i2 = d1 + d1 | 0; + d1 = d(Math_max(10, Math_min(5, f()))); + i3 = i2 + 2 | 0; + print(i3); + d4 = d1 * 5; + return d4; } function _doit(i1, i2, i3) { - i1 = i1 | 0; - i2 = i2 | 0; - i3 = i3 | 0; - i1 = STACKTOP; - _printf(__str | 0, (tempInt = STACKTOP, STACKTOP = STACKTOP + 8 | 0, HEAP32[(tempInt & 16777215) >> 2] = i2, HEAP32[(tempInt + 4 & 16777215) >> 2] = i3, tempInt)); - STACKTOP = i1; - return 0 | 0; + i1 = i1 | 0; + i2 = i2 | 0; + i3 = i3 | 0; + i1 = STACKTOP; + _printf(__str | 0, (tempInt = STACKTOP, STACKTOP = STACKTOP + 8 | 0, HEAP32[(tempInt & 16777215) >> 2] = i2, HEAP32[(tempInt + 4 & 16777215) >> 2] = i3, tempInt)); + STACKTOP = i1; + return 0 | 0; } function stackRestore(i1) { - i1 = i1 | 0; - STACKTOP = i1; + i1 = i1 | 0; + STACKTOP = i1; } function switchey(d1, i2) { - d1 = +d1; - i2 = i2 | 0; - var i3 = 0, d4 = +0; - switch (d1 | 0) { - case 0: - i2 = d1 + d1 | 0; - d1 = d(Math_max(10, Math_min(5, f()))); - i3 = i2 + 2 | 0; - print(i3); - d4 = d1 * 5; - return d4; - case 1: - return 20; - } + d1 = +d1; + i2 = i2 | 0; + var i3 = 0, d4 = +0; + switch (d1 | 0) { + case 0: + i2 = d1 + d1 | 0; + d1 = d(Math_max(10, Math_min(5, f()))); + i3 = i2 + 2 | 0; + print(i3); + d4 = d1 * 5; + return d4; + case 1: + return 20; + } } function switchey2() { - var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, d6 = +0, d7 = +0, i8 = 0, i9 = 0; - i1 = STACKTOP; - STACKTOP = STACKTOP + 8 | 0; - i2 = 1; - while (1) switch (i2 | 0) { - case 1: - i3 = i1 | 0; - __ZN6RandomC1Ev(i3); - i4 = 0; - i5 = 0; - i2 = 2; - break; - case 2: - d6 = +__ZN6Random3getEf(8, +1); - d7 = +__ZN6Random3getEf(i3, +1); - _printf(24, (tempInt = STACKTOP, STACKTOP = STACKTOP + 16 | 0, HEAPF64[CHECK_ALIGN_8(tempInt | 0) >> 3] = d6, HEAPF64[CHECK_ALIGN_8(tempInt + 8 | 0) >> 3] = d7, tempInt) | 0); - i8 = (d6 != d7 & 1) + i5 | 0; - i9 = i4 + 1 | 0; - if ((i9 | 0) < 100) { - i4 = i9; - i5 = i8; - i2 = 2; - break; - } else { - i2 = 3; - break; - } - case 3: - _printf(16, (tempInt = STACKTOP, STACKTOP = STACKTOP + 8 | 0, HEAP32[CHECK_ALIGN_4(tempInt | 0) >> 2] = i8, tempInt) | 0); - STACKTOP = i1; - return 0; + var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, d6 = +0, d7 = +0, i8 = 0, i9 = 0; + i1 = STACKTOP; + STACKTOP = STACKTOP + 8 | 0; + i2 = 1; + while (1) switch (i2 | 0) { + case 1: + i3 = i1 | 0; + __ZN6RandomC1Ev(i3); + i4 = 0; + i5 = 0; + i2 = 2; + break; + case 2: + d6 = +__ZN6Random3getEf(8, +1); + d7 = +__ZN6Random3getEf(i3, +1); + _printf(24, (tempInt = STACKTOP, STACKTOP = STACKTOP + 16 | 0, HEAPF64[CHECK_ALIGN_8(tempInt | 0) >> 3] = d6, HEAPF64[CHECK_ALIGN_8(tempInt + 8 | 0) >> 3] = d7, tempInt) | 0); + i8 = (d6 != d7 & 1) + i5 | 0; + i9 = i4 + 1 | 0; + if ((i9 | 0) < 100) { + i4 = i9; + i5 = i8; + i2 = 2; + break; + } else { + i2 = 3; + break; } + case 3: + _printf(16, (tempInt = STACKTOP, STACKTOP = STACKTOP + 8 | 0, HEAP32[CHECK_ALIGN_4(tempInt | 0) >> 2] = i8, tempInt) | 0); + STACKTOP = i1; return 0; + } + return 0; } function iffey() { - var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, d6 = +0, d7 = +0, i8 = 0, i9 = 0; - i1 = STACKTOP; - STACKTOP = STACKTOP + 8 | 0; - i2 = 1; - while (1) { - if (i2 | 0) { - i3 = i1 | 0; - __ZN6RandomC1Ev(i3); - i4 = 0; - i5 = 0; - i2 = 2; - } else { - d6 = +__ZN6Random3getEf(8, +1); - d7 = +__ZN6Random3getEf(i3, +1); - _printf(24, (tempInt = STACKTOP, STACKTOP = STACKTOP + 16 | 0, HEAPF64[CHECK_ALIGN_8(tempInt | 0) >> 3] = d6, HEAPF64[CHECK_ALIGN_8(tempInt + 8 | 0) >> 3] = d7, tempInt) | 0); - i8 = (d6 != d7 & 1) + i5 | 0; - i9 = i4 + 1 | 0; - if ((i9 | 0) < 100) { - i4 = i9; - i5 = i8; - i2 = 2; - } else { - i2 = 3; - return 10; - } - } + var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, d6 = +0, d7 = +0, i8 = 0, i9 = 0; + i1 = STACKTOP; + STACKTOP = STACKTOP + 8 | 0; + i2 = 1; + while (1) { + if (i2 | 0) { + i3 = i1 | 0; + __ZN6RandomC1Ev(i3); + i4 = 0; + i5 = 0; + i2 = 2; + } else { + d6 = +__ZN6Random3getEf(8, +1); + d7 = +__ZN6Random3getEf(i3, +1); + _printf(24, (tempInt = STACKTOP, STACKTOP = STACKTOP + 16 | 0, HEAPF64[CHECK_ALIGN_8(tempInt | 0) >> 3] = d6, HEAPF64[CHECK_ALIGN_8(tempInt + 8 | 0) >> 3] = d7, tempInt) | 0); + i8 = (d6 != d7 & 1) + i5 | 0; + i9 = i4 + 1 | 0; + if ((i9 | 0) < 100) { + i4 = i9; + i5 = i8; + i2 = 2; + } else { + i2 = 3; + return 10; + } } - return 0; + } + return 0; } diff --git a/tools/test-js-optimizer-asm-regs.js b/tools/test-js-optimizer-asm-regs.js index 8c3a1c9880baf..cfa7732deb310 100644 --- a/tools/test-js-optimizer-asm-regs.js +++ b/tools/test-js-optimizer-asm-regs.js @@ -1,110 +1,110 @@ function asm(x, y) { - x = +x; - y = y | 0; - var int1 = 0, int2 = 0; // do not mix the types! - var double1 = +0, double2 = +0; - int1 = (x+x)|0; - double1 = d(Math.max(10, Math_min(5, f()))); - int2 = (int1+2)|0; - print(int2); - double2 = double1*5; - return double2; + x = +x; + y = y | 0; + var int1 = 0, int2 = 0; // do not mix the types! + var double1 = +0, double2 = +0; + int1 = (x+x)|0; + double1 = d(Math.max(10, Math_min(5, f()))); + int2 = (int1+2)|0; + print(int2); + double2 = double1*5; + return double2; } function _doit($x, $y$0, $y$1) { - $x = $x | 0; - $y$0 = $y$0 | 0; - $y$1 = $y$1 | 0; - var __stackBase__ = 0; - __stackBase__ = STACKTOP; - _printf(__str | 0, (tempInt = STACKTOP, STACKTOP = STACKTOP + 8 | 0, HEAP32[(tempInt & 16777215) >> 2] = $y$0, HEAP32[(tempInt + 4 & 16777215) >> 2] = $y$1, tempInt)); - STACKTOP = __stackBase__; - return 0 | 0; + $x = $x | 0; + $y$0 = $y$0 | 0; + $y$1 = $y$1 | 0; + var __stackBase__ = 0; + __stackBase__ = STACKTOP; + _printf(__str | 0, (tempInt = STACKTOP, STACKTOP = STACKTOP + 8 | 0, HEAP32[(tempInt & 16777215) >> 2] = $y$0, HEAP32[(tempInt + 4 & 16777215) >> 2] = $y$1, tempInt)); + STACKTOP = __stackBase__; + return 0 | 0; } function stackRestore(top) { - top = top|0; - STACKTOP = top; + top = top|0; + STACKTOP = top; } function switchey(x, y) { - x = +x; - y = y | 0; - var int1 = 0, int2 = 0; // do not mix the types! - var double1 = +0, double2 = +0; - switch(x|0) { - case 0: - int1 = (x+x)|0; - double1 = d(Math.max(10, Math_min(5, f()))); - int2 = (int1+2)|0; - print(int2); - double2 = double1*5; - return double2; - case 1: - return 20; - } + x = +x; + y = y | 0; + var int1 = 0, int2 = 0; // do not mix the types! + var double1 = +0, double2 = +0; + switch(x|0) { + case 0: + int1 = (x+x)|0; + double1 = d(Math.max(10, Math_min(5, f()))); + int2 = (int1+2)|0; + print(int2); + double2 = double1*5; + return double2; + case 1: + return 20; + } } function switchey2() { - var $rng2 = 0, $count_06 = 0, $i_05 = 0, $2 = +0, $3 = +0, $count_1 = 0, $9 = 0, label = 0, __stackBase__ = 0; - __stackBase__ = STACKTOP; - STACKTOP = STACKTOP + 8 | 0; - label = 1; - while (1) switch (label | 0) { - case 1: - $rng2 = __stackBase__ | 0; - __ZN6RandomC1Ev($rng2); - $i_05 = 0; - $count_06 = 0; - label = 2; - break; - case 2: - $2 = +__ZN6Random3getEf(8, +1); - $3 = +__ZN6Random3getEf($rng2, +1); - _printf(24, (tempInt = STACKTOP, STACKTOP = STACKTOP + 16 | 0, HEAPF64[CHECK_ALIGN_8(tempInt | 0) >> 3] = $2, HEAPF64[CHECK_ALIGN_8(tempInt + 8 | 0) >> 3] = $3, tempInt) | 0); - $count_1 = ($2 != $3 & 1) + $count_06 | 0; - $9 = $i_05 + 1 | 0; - if (($9 | 0) < 100) { - $i_05 = $9; - $count_06 = $count_1; - label = 2; - break; - } else { - label = 3; - break; - } - case 3: - _printf(16, (tempInt = STACKTOP, STACKTOP = STACKTOP + 8 | 0, HEAP32[CHECK_ALIGN_4(tempInt | 0) >> 2] = $count_1, tempInt) | 0); - STACKTOP = __stackBase__; - return 0; + var $rng2 = 0, $count_06 = 0, $i_05 = 0, $2 = +0, $3 = +0, $count_1 = 0, $9 = 0, label = 0, __stackBase__ = 0; + __stackBase__ = STACKTOP; + STACKTOP = STACKTOP + 8 | 0; + label = 1; + while (1) switch (label | 0) { + case 1: + $rng2 = __stackBase__ | 0; + __ZN6RandomC1Ev($rng2); + $i_05 = 0; + $count_06 = 0; + label = 2; + break; + case 2: + $2 = +__ZN6Random3getEf(8, +1); + $3 = +__ZN6Random3getEf($rng2, +1); + _printf(24, (tempInt = STACKTOP, STACKTOP = STACKTOP + 16 | 0, HEAPF64[CHECK_ALIGN_8(tempInt | 0) >> 3] = $2, HEAPF64[CHECK_ALIGN_8(tempInt + 8 | 0) >> 3] = $3, tempInt) | 0); + $count_1 = ($2 != $3 & 1) + $count_06 | 0; + $9 = $i_05 + 1 | 0; + if (($9 | 0) < 100) { + $i_05 = $9; + $count_06 = $count_1; + label = 2; + break; + } else { + label = 3; + break; } + case 3: + _printf(16, (tempInt = STACKTOP, STACKTOP = STACKTOP + 8 | 0, HEAP32[CHECK_ALIGN_4(tempInt | 0) >> 2] = $count_1, tempInt) | 0); + STACKTOP = __stackBase__; return 0; + } + return 0; } function iffey() { - var $rng2 = 0, $count_06 = 0, $i_05 = 0, $2 = +0, $3 = +0, $count_1 = 0, $9 = 0, label = 0, __stackBase__ = 0; - __stackBase__ = STACKTOP; - STACKTOP = STACKTOP + 8 | 0; - label = 1; - while (1) { - if (label | 0) { - $rng2 = __stackBase__ | 0; - __ZN6RandomC1Ev($rng2); - $i_05 = 0; - $count_06 = 0; - label = 2; - } else { - $2 = +__ZN6Random3getEf(8, +1); - $3 = +__ZN6Random3getEf($rng2, +1); - _printf(24, (tempInt = STACKTOP, STACKTOP = STACKTOP + 16 | 0, HEAPF64[CHECK_ALIGN_8(tempInt | 0) >> 3] = $2, HEAPF64[CHECK_ALIGN_8(tempInt + 8 | 0) >> 3] = $3, tempInt) | 0); - $count_1 = ($2 != $3 & 1) + $count_06 | 0; - $9 = $i_05 + 1 | 0; - if (($9 | 0) < 100) { - $i_05 = $9; - $count_06 = $count_1; - label = 2; - } else { - label = 3; - return 10; - } - } + var $rng2 = 0, $count_06 = 0, $i_05 = 0, $2 = +0, $3 = +0, $count_1 = 0, $9 = 0, label = 0, __stackBase__ = 0; + __stackBase__ = STACKTOP; + STACKTOP = STACKTOP + 8 | 0; + label = 1; + while (1) { + if (label | 0) { + $rng2 = __stackBase__ | 0; + __ZN6RandomC1Ev($rng2); + $i_05 = 0; + $count_06 = 0; + label = 2; + } else { + $2 = +__ZN6Random3getEf(8, +1); + $3 = +__ZN6Random3getEf($rng2, +1); + _printf(24, (tempInt = STACKTOP, STACKTOP = STACKTOP + 16 | 0, HEAPF64[CHECK_ALIGN_8(tempInt | 0) >> 3] = $2, HEAPF64[CHECK_ALIGN_8(tempInt + 8 | 0) >> 3] = $3, tempInt) | 0); + $count_1 = ($2 != $3 & 1) + $count_06 | 0; + $9 = $i_05 + 1 | 0; + if (($9 | 0) < 100) { + $i_05 = $9; + $count_06 = $count_1; + label = 2; + } else { + label = 3; + return 10; + } } - return 0; + } + return 0; } // EMSCRIPTEN_GENERATED_FUNCTIONS: ["asm", "_doit", "stackRestore", "switchey", "switchey2", "iffey"] diff --git a/tools/test-js-optimizer-output.js b/tools/test-js-optimizer-output.js index 13f927dee33fa..5e5ff29ae0254 100644 --- a/tools/test-js-optimizer-output.js +++ b/tools/test-js-optimizer-output.js @@ -1,291 +1,291 @@ function expr() { - if ($0 >= $1) print("hi"); + if ($0 >= $1) print("hi"); } function loopy() { - $while_body$2 : while (1) { - $ok = 1; - while (1) { - if ($ok) break; - var $inc = $ok + 1; - if ($inc == 9999) break $while_body$2; - } - continue; + $while_body$2 : while (1) { + $ok = 1; + while (1) { + if ($ok) break; + var $inc = $ok + 1; + if ($inc == 9999) break $while_body$2; } - next(); + continue; + } + next(); + while (1) { + $ok = 1; while (1) { - $ok = 1; - while (1) { - if ($ok) break; - var $inc = $ok + 1; - } - continue; + if ($ok) break; + var $inc = $ok + 1; + } + continue; + } + next(); + do { + if (!$ok) break; + something(); + } while (0); + next(); + b$once : do { + while (more()) { + if (!$ok) break b$once; } - next(); - do { - if (!$ok) break; - something(); - } while (0); - next(); - b$once : do { - while (more()) { - if (!$ok) break b$once; - } - something(); - } while (0); - next(); something(); + } while (0); + next(); + something(); } function bits() { - print(($s & 65535) + ((($f & 65535) << 16 >> 16) * (($f & 65535) << 16 >> 16) | 0) % 256 & 65535); - z(HEAP32[$id + 40 >> 2]); - z($f << 2); - z($f | 255); - z($f & 255); - z($f ^ 1); - z($f << 2); - z($f * 100 << 2); - z(($f | 0) % 2 | 255); - z(($f | 0) / 55 & 255); - z($f - 22 ^ 1); - z($f + 15 << 2); + print(($s & 65535) + ((($f & 65535) << 16 >> 16) * (($f & 65535) << 16 >> 16) | 0) % 256 & 65535); + z(HEAP32[$id + 40 >> 2]); + z($f << 2); + z($f | 255); + z($f & 255); + z($f ^ 1); + z($f << 2); + z($f * 100 << 2); + z(($f | 0) % 2 | 255); + z(($f | 0) / 55 & 255); + z($f - 22 ^ 1); + z($f + 15 << 2); } function maths() { - check(17); - check(95); - __ZN6b2Vec2C1Ev($this1 + 76 | 0); + check(17); + check(95); + __ZN6b2Vec2C1Ev($this1 + 76 | 0); } function hoisting() { + if ($i < $N) { + callOther(); + } + pause(1); + $for_body3$$for_end$5 : do { if ($i < $N) { - callOther(); + while (true) { + break $for_body3$$for_end$5; + } + callOther(); } - pause(1); - $for_body3$$for_end$5 : do { - if ($i < $N) { - while (true) { - break $for_body3$$for_end$5; - } - callOther(); - } - } while (0); - pause(2); - do { - if ($i < $N) { - if (callOther()) break; - } - } while (0); - pause(3); + } while (0); + pause(2); + do { if ($i < $N) { - callOther(); + if (callOther()) break; } - pause(4); - if ($i < $N) { - callOther(); - } else { - somethingElse(); + } while (0); + pause(3); + if ($i < $N) { + callOther(); + } + pause(4); + if ($i < $N) { + callOther(); + } else { + somethingElse(); + } + pause(5); + if ($i < $N) { + label = 2; + } else { + somethingElse(); + } + if (label == 55) { + callOther(); + } + pause(6); + if ($i >= $N) { + somethingElse(); + } + pause(7); + while (1) { + if ($i >= $N) { + label = 3; + break; } - pause(5); + somethingElse(); if ($i < $N) { - label = 2; - } else { - somethingElse(); + somethingElse(); } - if (label == 55) { - callOther(); + nothing(); + } + pause(8); + var $cmp95 = $69 == -1; + do { + if ($cmp95) { + if (!$cmp103) { + label = 38; + break; + } + if (!$cmp106) { + label = 38; + break; + } + label = 39; + break; } - pause(6); - if ($i >= $N) { - somethingElse(); + label = 38; + } while (0); + if (label == 38) { + var $79 = $_pr6; + } + pause(9); + var $cmp70 = ($call69 | 0) != 0; + pause(10); + while (check()) { + if ($i < $N) { + callOther(); + break; } - pause(7); - while (1) { - if ($i >= $N) { - label = 3; - break; - } - somethingElse(); - if ($i < $N) { - somethingElse(); - } - nothing(); + somethingElse(); + if ($i1 < $N) { + callOther(); + continue; } - pause(8); - var $cmp95 = $69 == -1; - do { - if ($cmp95) { - if (!$cmp103) { - label = 38; - break; - } - if (!$cmp106) { - label = 38; - break; - } - label = 39; - break; - } - label = 38; - } while (0); - if (label == 38) { - var $79 = $_pr6; + somethingElse(); + if ($i2 >= $N) { + somethingElse(); + break; } - pause(9); - var $cmp70 = ($call69 | 0) != 0; - pause(10); - while (check()) { - if ($i < $N) { - callOther(); - break; - } - somethingElse(); - if ($i1 < $N) { - callOther(); - continue; - } - somethingElse(); - if ($i2 >= $N) { - somethingElse(); - break; - } - callOther(); - if ($i3 >= $N) { - somethingElse(); - continue; - } - callOther(); - if ($i4 < $N) { - callOther(); - break; - } - somethingElse(); - continue; + callOther(); + if ($i3 >= $N) { + somethingElse(); + continue; + } + callOther(); + if ($i4 < $N) { + callOther(); + break; } + somethingElse(); + continue; + } } function innerShouldAlsoBeHoisted() { - function hoisting() { - if ($i < $N) { - callOther(); - } + function hoisting() { + if ($i < $N) { + callOther(); } + } } var FS = { - absolutePath: (function(relative, base) { - if (typeof relative !== "string") return null; - if (base === undefined) base = FS.currentPath; - if (relative && relative[0] == "/") base = ""; - var full = base + "/" + relative; - var parts = full.split("/").reverse(); - var absolute = [ "" ]; - while (parts.length) { - var part = parts.pop(); - if (part == "" || part == ".") {} else if (part == "..") { - if (absolute.length > 1) absolute.pop(); - } else { - absolute.push(part); - } - } - return absolute.length == 1 ? "/" : absolute.join("/"); - }) + absolutePath: (function(relative, base) { + if (typeof relative !== "string") return null; + if (base === undefined) base = FS.currentPath; + if (relative && relative[0] == "/") base = ""; + var full = base + "/" + relative; + var parts = full.split("/").reverse(); + var absolute = [ "" ]; + while (parts.length) { + var part = parts.pop(); + if (part == "" || part == ".") {} else if (part == "..") { + if (absolute.length > 1) absolute.pop(); + } else { + absolute.push(part); + } + } + return absolute.length == 1 ? "/" : absolute.join("/"); + }) }; function sleep() { - while (Date.now() - start < msec) {} - return 0; + while (Date.now() - start < msec) {} + return 0; } function demangle($cmp) { - do { - if (!$cmp) { - if (something()) { - label = 3; - break; - } - more(); - break; - } + do { + if (!$cmp) { + if (something()) { label = 3; - } while (0); - if (label == 3) { - final(); + break; + } + more(); + break; } + label = 3; + } while (0); + if (label == 3) { + final(); + } } function lua() { - while (1) { - do { - if (!$14) { - var $17 = $i; - var $18 = $3; - var $19 = $18 + ($17 << 2) | 0; - var $20 = HEAP32[$19 >> 2]; - var $21 = $20 + 1 | 0; - var $22 = HEAP8[$21]; - var $23 = $22 << 24 >> 24; - break; - } - } while (0); - } - pause(); - if ($1435 == 0) { - label = 176; - cheez(); - } else if ($1435 != 1) { - label = 180; - cheez(); - } - pause(); - if ($1435 == 0) { - label = 176; - cheez(); - } + while (1) { + do { + if (!$14) { + var $17 = $i; + var $18 = $3; + var $19 = $18 + ($17 << 2) | 0; + var $20 = HEAP32[$19 >> 2]; + var $21 = $20 + 1 | 0; + var $22 = HEAP8[$21]; + var $23 = $22 << 24 >> 24; + break; + } + } while (0); + } + pause(); + if ($1435 == 0) { + label = 176; + cheez(); + } else if ($1435 != 1) { + label = 180; + cheez(); + } + pause(); + if ($1435 == 0) { + label = 176; + cheez(); + } } function moreLabels() { - while (1) { - if (!$cmp) { - break; - } - if ($cmp1) { - break; - } - inc(); + while (1) { + if (!$cmp) { + break; } - pause(999); - $while_body$$while_end$31 : do { - if ($cmp3) { - var $6 = $5; - while (1) { - var $6; - $iter = $6 + 3; - if (FHEAP[$iter + 1] >= $pct_addr) { - var $_lcssa = $iter; - break $while_body$$while_end$31; - } - var $6 = $iter; - } - } else { - var $_lcssa = $5; + if ($cmp1) { + break; + } + inc(); + } + pause(999); + $while_body$$while_end$31 : do { + if ($cmp3) { + var $6 = $5; + while (1) { + var $6; + $iter = $6 + 3; + if (FHEAP[$iter + 1] >= $pct_addr) { + var $_lcssa = $iter; + break $while_body$$while_end$31; } - } while (0); - var $_lcssa; - cheez(); + var $6 = $iter; + } + } else { + var $_lcssa = $5; + } + } while (0); + var $_lcssa; + cheez(); } function notComps() { - if (HEAP32[$incdec_ptr71_i + 8 >> 2] != 0) { - shoo(); - } + if (HEAP32[$incdec_ptr71_i + 8 >> 2] != 0) { + shoo(); + } } function tricky() { - var $conv642 = $conv6374 - (($132 << 16 >> 16 | 0) / 2 & -1) & 65535; + var $conv642 = $conv6374 - (($132 << 16 >> 16 | 0) / 2 & -1) & 65535; } function asmy() { - f(HEAPU8[_buf + i6 & 16777215]); - f(HEAPU8[_buf + i6 & 16777215]); - f(HEAP8[_buf + i6 & 16777215] & 1); - f(HEAPU8[_buf + i6 & 16777215] & 1); - f(HEAP8[_buf + i6 & 16777215] & 1); - f(HEAPU8[_buf + i6 & 16777215] & 1); - f((HEAP8[_buf + i6 & 16777215] & 1) + i5 | 0); - f((HEAPU8[_buf + i6 & 16777215] & 1) + i5 | 0); - f((HEAP8[_buf + i6 & 16777215] & 1) + i5 | 0); - f((HEAPU8[_buf + i6 & 16777215] & 1) + i5 | 0); - if ((_sbrk($419 | 0) | 0) == -1) { - print("fleefl"); - } + f(HEAPU8[_buf + i6 & 16777215]); + f(HEAPU8[_buf + i6 & 16777215]); + f(HEAP8[_buf + i6 & 16777215] & 1); + f(HEAPU8[_buf + i6 & 16777215] & 1); + f(HEAP8[_buf + i6 & 16777215] & 1); + f(HEAPU8[_buf + i6 & 16777215] & 1); + f((HEAP8[_buf + i6 & 16777215] & 1) + i5 | 0); + f((HEAPU8[_buf + i6 & 16777215] & 1) + i5 | 0); + f((HEAP8[_buf + i6 & 16777215] & 1) + i5 | 0); + f((HEAPU8[_buf + i6 & 16777215] & 1) + i5 | 0); + if ((_sbrk($419 | 0) | 0) == -1) { + print("fleefl"); + } } diff --git a/tools/test-js-optimizer-regs-output.js b/tools/test-js-optimizer-regs-output.js index fe7de5fb836f7..149ca984acdd9 100644 --- a/tools/test-js-optimizer-regs-output.js +++ b/tools/test-js-optimizer-regs-output.js @@ -1,232 +1,232 @@ function test() { - var r1, r2; - r1 = 0; - f(r1); - r1 += 1; - r2 = r1 + 2; - g(r1, r2); - f(r1); - r1 = cheez(); - r2 = r1 + 2; - g(r2, r2); - r2 = 200; - r2 = 203; - r2 = 205; - r1 = 208; - c(r2); - while (f()) { - r2 = 5; - r1 = 12; - gg(r2, r1 * 2); - r1 = 100; - gg(r1, 20); - } - r1 = f(), r2 = 100, r2 = 1e3, r2 = 1e5; - f(r1()); + var r1, r2; + r1 = 0; + f(r1); + r1 += 1; + r2 = r1 + 2; + g(r1, r2); + f(r1); + r1 = cheez(); + r2 = r1 + 2; + g(r2, r2); + r2 = 200; + r2 = 203; + r2 = 205; + r1 = 208; + c(r2); + while (f()) { + r2 = 5; + r1 = 12; + gg(r2, r1 * 2); + r1 = 100; + gg(r1, 20); + } + r1 = f(), r2 = 100, r2 = 1e3, r2 = 1e5; + f(r1()); } function primes() { - var r1, r2, r3, r4, r5, r6, r7; - r1 = 2; - r2 = 0; - $_$2 : while (1) { - r3 = r1 | 0; - r4 = _sqrtf(r3); - r3 = 2; - $_$4 : while (1) { - r5 = r3 | 0; - r6 = r5 < r4; - if (!r6) { - r7 = 1; - break $_$4; - } - r6 = (r1 | 0) % (r3 | 0); - r5 = (r6 | 0) == 0; - if (r5) { - r7 = 0; - break $_$4; - } - r5 = r3 + 1 | 0; - r3 = r5; - } - r3 = r7 + r2 | 0; - r4 = r1 + 1 | 0; - r5 = (r3 | 0) < 1e5; - if (r5) { - r1 = r4; - r2 = r3; - } else { - break $_$2; - } + var r1, r2, r3, r4, r5, r6, r7; + r1 = 2; + r2 = 0; + $_$2 : while (1) { + r3 = r1 | 0; + r4 = _sqrtf(r3); + r3 = 2; + $_$4 : while (1) { + r5 = r3 | 0; + r6 = r5 < r4; + if (!r6) { + r7 = 1; + break $_$4; + } + r6 = (r1 | 0) % (r3 | 0); + r5 = (r6 | 0) == 0; + if (r5) { + r7 = 0; + break $_$4; + } + r5 = r3 + 1 | 0; + r3 = r5; + } + r3 = r7 + r2 | 0; + r4 = r1 + 1 | 0; + r5 = (r3 | 0) < 1e5; + if (r5) { + r1 = r4; + r2 = r3; + } else { + break $_$2; } - r2 = _printf(STRING_TABLE.__str | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = r1, tempInt)); - return 1; - return null; + } + r2 = _printf(STRING_TABLE.__str | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = r1, tempInt)); + return 1; + return null; } function atomic() { - var r1, r2, r3, r4; - r1 = STACKTOP; - STACKTOP += 4; - r2 = r1 >> 2; - HEAP32[r2] = 10; - r3 = (tempValue = HEAP32[r2], HEAP32[r2] == 10 && (HEAP32[r2] = 7), tempValue); - r4 = (r3 | 0) == 10 & 1; - r3 = HEAP32[r2]; - r2 = _printf(STRING_TABLE.__str | 0, (tempInt = STACKTOP, STACKTOP += 8, HEAP32[tempInt >> 2] = r3, HEAP32[tempInt + 4 >> 2] = r4, tempInt)); - STACKTOP = r1; - return 0; - return null; + var r1, r2, r3, r4; + r1 = STACKTOP; + STACKTOP += 4; + r2 = r1 >> 2; + HEAP32[r2] = 10; + r3 = (tempValue = HEAP32[r2], HEAP32[r2] == 10 && (HEAP32[r2] = 7), tempValue); + r4 = (r3 | 0) == 10 & 1; + r3 = HEAP32[r2]; + r2 = _printf(STRING_TABLE.__str | 0, (tempInt = STACKTOP, STACKTOP += 8, HEAP32[tempInt >> 2] = r3, HEAP32[tempInt + 4 >> 2] = r4, tempInt)); + STACKTOP = r1; + return 0; + return null; } function fcntl_open() { - var r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17; - r1 = STACKTOP; - STACKTOP += 84; - r2 = r1; - r3 = r1 + 72; - r4 = r3 | 0; - for (r5 = STRING_TABLE.__ZZ4mainE16nonexistent_name | 0, r6 = r4, r7 = r5 + 12; r5 < r7; r5++, r6++) { - HEAP8[r6] = HEAP8[r5]; - } - r5 = (r2 + 8 | 0) >> 2; - r8 = r2 >> 2; - r9 = r3 + 9 | 0; - r10 = r3 + 10 | 0; - r3 = 0; + var r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17; + r1 = STACKTOP; + STACKTOP += 84; + r2 = r1; + r3 = r1 + 72; + r4 = r3 | 0; + for (r5 = STRING_TABLE.__ZZ4mainE16nonexistent_name | 0, r6 = r4, r7 = r5 + 12; r5 < r7; r5++, r6++) { + HEAP8[r6] = HEAP8[r5]; + } + r5 = (r2 + 8 | 0) >> 2; + r8 = r2 >> 2; + r9 = r3 + 9 | 0; + r10 = r3 + 10 | 0; + r3 = 0; + while (1) { + r11 = HEAP32[__ZZ4mainE5modes + (r3 << 2) >> 2]; + r12 = r11 | 512; + r13 = r3 + 97 & 255; + r14 = 0; while (1) { - r11 = HEAP32[__ZZ4mainE5modes + (r3 << 2) >> 2]; - r12 = r11 | 512; - r13 = r3 + 97 & 255; - r14 = 0; - while (1) { - r15 = (r14 & 1 | 0) == 0 ? r11 : r12; - r16 = (r14 & 2 | 0) == 0 ? r15 : r15 | 2048; - r15 = (r14 & 4 | 0) == 0 ? r16 : r16 | 1024; - r16 = (r14 & 8 | 0) == 0 ? r15 : r15 | 8; - r15 = _printf(STRING_TABLE.__str | 0, (tempInt = STACKTOP, STACKTOP += 8, HEAP32[tempInt >> 2] = r3, HEAP32[tempInt + 4 >> 2] = r14, tempInt)); - r15 = _open(STRING_TABLE.__str2 | 0, r16, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = 511, tempInt)); - r17 = (r15 | 0) != -1 & 1; - r15 = _printf(STRING_TABLE.__str1 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = r17, tempInt)); - r17 = ___errno(); - r15 = HEAP32[r17 >> 2]; - r17 = _printf(STRING_TABLE.__str3 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = r15, tempInt)); - r15 = _stat(STRING_TABLE.__str2 | 0, r2); - r15 = HEAP32[r5] & -512; - r17 = _printf(STRING_TABLE.__str4 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = r15, tempInt)); - for (r6 = r8, r7 = r6 + 18; r6 < r7; r6++) { - HEAP32[r6] = 0; - } - r15 = _putchar(10); - r15 = ___errno(); - HEAP32[r15 >> 2] = 0; - r15 = _printf(STRING_TABLE.__str6 | 0, (tempInt = STACKTOP, STACKTOP += 8, HEAP32[tempInt >> 2] = r3, HEAP32[tempInt + 4 >> 2] = r14, tempInt)); - r15 = _open(STRING_TABLE.__str7 | 0, r16, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = 511, tempInt)); - r17 = (r15 | 0) != -1 & 1; - r15 = _printf(STRING_TABLE.__str1 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = r17, tempInt)); - r17 = ___errno(); - r15 = HEAP32[r17 >> 2]; - r17 = _printf(STRING_TABLE.__str3 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = r15, tempInt)); - r15 = _stat(STRING_TABLE.__str7 | 0, r2); - r15 = HEAP32[r5] & -512; - r17 = _printf(STRING_TABLE.__str4 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = r15, tempInt)); - for (r6 = r8, r7 = r6 + 18; r6 < r7; r6++) { - HEAP32[r6] = 0; - } - r15 = _putchar(10); - r15 = ___errno(); - HEAP32[r15 >> 2] = 0; - HEAP8[r9] = r13; - HEAP8[r10] = r14 + 97 & 255; - r15 = _printf(STRING_TABLE.__str8 | 0, (tempInt = STACKTOP, STACKTOP += 8, HEAP32[tempInt >> 2] = r3, HEAP32[tempInt + 4 >> 2] = r14, tempInt)); - r15 = _open(r4, r16, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = 511, tempInt)); - r17 = (r15 | 0) != -1 & 1; - r15 = _printf(STRING_TABLE.__str1 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = r17, tempInt)); - r17 = ___errno(); - r15 = HEAP32[r17 >> 2]; - r17 = _printf(STRING_TABLE.__str3 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = r15, tempInt)); - r15 = _stat(r4, r2); - r15 = HEAP32[r5] & -512; - r17 = _printf(STRING_TABLE.__str4 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = r15, tempInt)); - for (r6 = r8, r7 = r6 + 18; r6 < r7; r6++) { - HEAP32[r6] = 0; - } - r16 = _putchar(10); - r16 = ___errno(); - HEAP32[r16 >> 2] = 0; - r16 = r14 + 1 | 0; - if ((r16 | 0) == 16) { - break; - } - r14 = r16; - } - r14 = r3 + 1 | 0; - if ((r14 | 0) == 3) { - break; - } - r3 = r14; + r15 = (r14 & 1 | 0) == 0 ? r11 : r12; + r16 = (r14 & 2 | 0) == 0 ? r15 : r15 | 2048; + r15 = (r14 & 4 | 0) == 0 ? r16 : r16 | 1024; + r16 = (r14 & 8 | 0) == 0 ? r15 : r15 | 8; + r15 = _printf(STRING_TABLE.__str | 0, (tempInt = STACKTOP, STACKTOP += 8, HEAP32[tempInt >> 2] = r3, HEAP32[tempInt + 4 >> 2] = r14, tempInt)); + r15 = _open(STRING_TABLE.__str2 | 0, r16, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = 511, tempInt)); + r17 = (r15 | 0) != -1 & 1; + r15 = _printf(STRING_TABLE.__str1 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = r17, tempInt)); + r17 = ___errno(); + r15 = HEAP32[r17 >> 2]; + r17 = _printf(STRING_TABLE.__str3 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = r15, tempInt)); + r15 = _stat(STRING_TABLE.__str2 | 0, r2); + r15 = HEAP32[r5] & -512; + r17 = _printf(STRING_TABLE.__str4 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = r15, tempInt)); + for (r6 = r8, r7 = r6 + 18; r6 < r7; r6++) { + HEAP32[r6] = 0; + } + r15 = _putchar(10); + r15 = ___errno(); + HEAP32[r15 >> 2] = 0; + r15 = _printf(STRING_TABLE.__str6 | 0, (tempInt = STACKTOP, STACKTOP += 8, HEAP32[tempInt >> 2] = r3, HEAP32[tempInt + 4 >> 2] = r14, tempInt)); + r15 = _open(STRING_TABLE.__str7 | 0, r16, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = 511, tempInt)); + r17 = (r15 | 0) != -1 & 1; + r15 = _printf(STRING_TABLE.__str1 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = r17, tempInt)); + r17 = ___errno(); + r15 = HEAP32[r17 >> 2]; + r17 = _printf(STRING_TABLE.__str3 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = r15, tempInt)); + r15 = _stat(STRING_TABLE.__str7 | 0, r2); + r15 = HEAP32[r5] & -512; + r17 = _printf(STRING_TABLE.__str4 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = r15, tempInt)); + for (r6 = r8, r7 = r6 + 18; r6 < r7; r6++) { + HEAP32[r6] = 0; + } + r15 = _putchar(10); + r15 = ___errno(); + HEAP32[r15 >> 2] = 0; + HEAP8[r9] = r13; + HEAP8[r10] = r14 + 97 & 255; + r15 = _printf(STRING_TABLE.__str8 | 0, (tempInt = STACKTOP, STACKTOP += 8, HEAP32[tempInt >> 2] = r3, HEAP32[tempInt + 4 >> 2] = r14, tempInt)); + r15 = _open(r4, r16, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = 511, tempInt)); + r17 = (r15 | 0) != -1 & 1; + r15 = _printf(STRING_TABLE.__str1 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = r17, tempInt)); + r17 = ___errno(); + r15 = HEAP32[r17 >> 2]; + r17 = _printf(STRING_TABLE.__str3 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = r15, tempInt)); + r15 = _stat(r4, r2); + r15 = HEAP32[r5] & -512; + r17 = _printf(STRING_TABLE.__str4 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = r15, tempInt)); + for (r6 = r8, r7 = r6 + 18; r6 < r7; r6++) { + HEAP32[r6] = 0; + } + r16 = _putchar(10); + r16 = ___errno(); + HEAP32[r16 >> 2] = 0; + r16 = r14 + 1 | 0; + if ((r16 | 0) == 16) { + break; + } + r14 = r16; + } + r14 = r3 + 1 | 0; + if ((r14 | 0) == 3) { + break; } - r3 = _puts(STRING_TABLE._str | 0); - r3 = _creat(STRING_TABLE.__str10 | 0, 511); - r6 = (r3 | 0) != -1 & 1; - r3 = _printf(STRING_TABLE.__str1 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = r6, tempInt)); - r6 = ___errno(); - r3 = HEAP32[r6 >> 2]; - r6 = _printf(STRING_TABLE.__str3 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = r3, tempInt)); - STACKTOP = r1; - return 0; - return null; + r3 = r14; + } + r3 = _puts(STRING_TABLE._str | 0); + r3 = _creat(STRING_TABLE.__str10 | 0, 511); + r6 = (r3 | 0) != -1 & 1; + r3 = _printf(STRING_TABLE.__str1 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = r6, tempInt)); + r6 = ___errno(); + r3 = HEAP32[r6 >> 2]; + r6 = _printf(STRING_TABLE.__str3 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = r3, tempInt)); + STACKTOP = r1; + return 0; + return null; } function ex() { - var r1, r2; - r1 = STACKTOP; - STACKTOP += 4; - r2 = r1; - r1 = _puts(STRING_TABLE._str17 | 0); - r1 = r2 | 0; - r2 = 0; - while (1) { - r1 = _printf(STRING_TABLE.__str15 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = r2, tempInt)); - ((function() { - try { - __THREW__ = false; - return __Z5magici(r2); - } catch (e) { - if (typeof e != "number") throw e; - if (ABORT) throw e; - __THREW__ = true; - return null; - } - }))(); - } + var r1, r2; + r1 = STACKTOP; + STACKTOP += 4; + r2 = r1; + r1 = _puts(STRING_TABLE._str17 | 0); + r1 = r2 | 0; + r2 = 0; + while (1) { + r1 = _printf(STRING_TABLE.__str15 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = r2, tempInt)); + ((function() { + try { + __THREW__ = false; + return __Z5magici(r2); + } catch (e) { + if (typeof e != "number") throw e; + if (ABORT) throw e; + __THREW__ = true; + return null; + } + }))(); + } } function switchey(r1) { - var r2, r3, r4, r5, r6, r7, r8, r9; - r2 = 5; - while (1) { - switch (r1 = f(r1, r2)) { - case 1: - g(r2); - r3 = r1 + 1; - r1--; - break; - case 2: - g(r2 * 2); - r4 = r1 + 22; - r5 = r4 + 5; - r1 -= 20; - break; - default: - r6 = r1 + 22; - r7 = r4 + 5; - ch(r6, r7 * r4); - throw 99; - } + var r2, r3, r4, r5, r6, r7, r8, r9; + r2 = 5; + while (1) { + switch (r1 = f(r1, r2)) { + case 1: + g(r2); + r3 = r1 + 1; + r1--; + break; + case 2: + g(r2 * 2); + r4 = r1 + 22; + r5 = r4 + 5; + r1 -= 20; + break; + default: + r6 = r1 + 22; + r7 = r4 + 5; + ch(r6, r7 * r4); + throw 99; } - r8 = r1 + 1; - p(r2, r8); - r9 = r1 + 2; - pp(r9); + } + r8 = r1 + 1; + p(r2, r8); + r9 = r1 + 2; + pp(r9); } function __ZN14NetworkAddressC1EPKcti(r1) { - __ZN14NetworkAddressC2EPKcti(r1); - return; + __ZN14NetworkAddressC2EPKcti(r1); + return; } diff --git a/tools/test-js-optimizer-regs.js b/tools/test-js-optimizer-regs.js index 3013e518851a2..00303786de3fa 100644 --- a/tools/test-js-optimizer-regs.js +++ b/tools/test-js-optimizer-regs.js @@ -1,237 +1,237 @@ function test() { - var i = 0; - f(i); - i+=1; - var j = i + 2; - g(i, j); - f(i); - var i2 = cheez(); - var j2 = i2 + 2; - g(j2, j2); - var k1 = 200; - var k2 = 203; - var k3 = 205; - var k4 = 208; - c(k3); - while (f()) { - var apple = 5; - var orange = 12; - gg(apple, orange*2); - var tangerine = 100; - gg(tangerine, 20); - } - var ck = f(), ck2 = 100, ck3 = 1000, ck4 = 100000; - f(ck()); + var i = 0; + f(i); + i+=1; + var j = i + 2; + g(i, j); + f(i); + var i2 = cheez(); + var j2 = i2 + 2; + g(j2, j2); + var k1 = 200; + var k2 = 203; + var k3 = 205; + var k4 = 208; + c(k3); + while (f()) { + var apple = 5; + var orange = 12; + gg(apple, orange*2); + var tangerine = 100; + gg(tangerine, 20); + } + var ck = f(), ck2 = 100, ck3 = 1000, ck4 = 100000; + f(ck()); } function primes() { - var label; - var $curri_01 = 2; - var $primes_02 = 0; - $_$2 : while (1) { - var $primes_02; - var $curri_01; - var $conv1 = $curri_01 | 0; - var $call = _sqrtf($conv1); - var $j_0 = 2; - $_$4 : while (1) { - var $j_0; - var $conv = $j_0 | 0; - var $cmp2 = $conv < $call; - if (!$cmp2) { - var $ok_0 = 1; - break $_$4; - } - var $rem = ($curri_01 | 0) % ($j_0 | 0); - var $cmp3 = ($rem | 0) == 0; - if ($cmp3) { - var $ok_0 = 0; - break $_$4; - } - var $inc = $j_0 + 1 | 0; - var $j_0 = $inc; - } - var $ok_0; - var $inc5_primes_0 = $ok_0 + $primes_02 | 0; - var $inc7 = $curri_01 + 1 | 0; - var $cmp = ($inc5_primes_0 | 0) < 1e5; - if ($cmp) { - var $curri_01 = $inc7; - var $primes_02 = $inc5_primes_0; - } else { - break $_$2; - } + var label; + var $curri_01 = 2; + var $primes_02 = 0; + $_$2 : while (1) { + var $primes_02; + var $curri_01; + var $conv1 = $curri_01 | 0; + var $call = _sqrtf($conv1); + var $j_0 = 2; + $_$4 : while (1) { + var $j_0; + var $conv = $j_0 | 0; + var $cmp2 = $conv < $call; + if (!$cmp2) { + var $ok_0 = 1; + break $_$4; + } + var $rem = ($curri_01 | 0) % ($j_0 | 0); + var $cmp3 = ($rem | 0) == 0; + if ($cmp3) { + var $ok_0 = 0; + break $_$4; + } + var $inc = $j_0 + 1 | 0; + var $j_0 = $inc; + } + var $ok_0; + var $inc5_primes_0 = $ok_0 + $primes_02 | 0; + var $inc7 = $curri_01 + 1 | 0; + var $cmp = ($inc5_primes_0 | 0) < 1e5; + if ($cmp) { + var $curri_01 = $inc7; + var $primes_02 = $inc5_primes_0; + } else { + break $_$2; } - var $call8 = _printf(STRING_TABLE.__str | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = $curri_01, tempInt)); - return 1; - return null; + } + var $call8 = _printf(STRING_TABLE.__str | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = $curri_01, tempInt)); + return 1; + return null; } function atomic() { - var $x$s2; - var __stackBase__ = STACKTOP; - STACKTOP += 4; - var $x$s2 = __stackBase__ >> 2; - HEAP32[$x$s2] = 10; - var $0 = (tempValue = HEAP32[$x$s2], HEAP32[$x$s2] == 10 && (HEAP32[$x$s2] = 7), tempValue); - var $conv = ($0 | 0) == 10 & 1; - var $2 = HEAP32[$x$s2]; - var $call = _printf(STRING_TABLE.__str | 0, (tempInt = STACKTOP, STACKTOP += 8, HEAP32[tempInt >> 2] = $2, HEAP32[tempInt + 4 >> 2] = $conv, tempInt)); - STACKTOP = __stackBase__; - return 0; - return null; + var $x$s2; + var __stackBase__ = STACKTOP; + STACKTOP += 4; + var $x$s2 = __stackBase__ >> 2; + HEAP32[$x$s2] = 10; + var $0 = (tempValue = HEAP32[$x$s2], HEAP32[$x$s2] == 10 && (HEAP32[$x$s2] = 7), tempValue); + var $conv = ($0 | 0) == 10 & 1; + var $2 = HEAP32[$x$s2]; + var $call = _printf(STRING_TABLE.__str | 0, (tempInt = STACKTOP, STACKTOP += 8, HEAP32[tempInt >> 2] = $2, HEAP32[tempInt + 4 >> 2] = $conv, tempInt)); + STACKTOP = __stackBase__; + return 0; + return null; } function fcntl_open() { - var $1$s2; - var $st_mode$s2; - var __stackBase__ = STACKTOP; - STACKTOP += 84; - var $s = __stackBase__; - var $nonexistent_name = __stackBase__ + 72; - var $0 = $nonexistent_name | 0; - for (var $$src = STRING_TABLE.__ZZ4mainE16nonexistent_name | 0, $$dest = $0, $$stop = $$src + 12; $$src < $$stop; $$src++, $$dest++) { - HEAP8[$$dest] = HEAP8[$$src]; - } - var $st_mode$s2 = ($s + 8 | 0) >> 2; - var $1$s2 = $s >> 2; // critical variable, becomes r8 - var $arrayidx43 = $nonexistent_name + 9 | 0; - var $arrayidx46 = $nonexistent_name + 10 | 0; - var $i_04 = 0; + var $1$s2; + var $st_mode$s2; + var __stackBase__ = STACKTOP; + STACKTOP += 84; + var $s = __stackBase__; + var $nonexistent_name = __stackBase__ + 72; + var $0 = $nonexistent_name | 0; + for (var $$src = STRING_TABLE.__ZZ4mainE16nonexistent_name | 0, $$dest = $0, $$stop = $$src + 12; $$src < $$stop; $$src++, $$dest++) { + HEAP8[$$dest] = HEAP8[$$src]; + } + var $st_mode$s2 = ($s + 8 | 0) >> 2; + var $1$s2 = $s >> 2; // critical variable, becomes r8 + var $arrayidx43 = $nonexistent_name + 9 | 0; + var $arrayidx46 = $nonexistent_name + 10 | 0; + var $i_04 = 0; + while (1) { + var $i_04; + var $2 = HEAP32[__ZZ4mainE5modes + ($i_04 << 2) >> 2]; + var $or = $2 | 512; + var $conv42 = $i_04 + 97 & 255; + var $j_03 = 0; while (1) { - var $i_04; - var $2 = HEAP32[__ZZ4mainE5modes + ($i_04 << 2) >> 2]; - var $or = $2 | 512; - var $conv42 = $i_04 + 97 & 255; - var $j_03 = 0; - while (1) { - var $j_03; - var $flags_0 = ($j_03 & 1 | 0) == 0 ? $2 : $or; - var $flags_0_or7 = ($j_03 & 2 | 0) == 0 ? $flags_0 : $flags_0 | 2048; - var $flags_2 = ($j_03 & 4 | 0) == 0 ? $flags_0_or7 : $flags_0_or7 | 1024; - var $flags_2_or17 = ($j_03 & 8 | 0) == 0 ? $flags_2 : $flags_2 | 8; - var $call = _printf(STRING_TABLE.__str | 0, (tempInt = STACKTOP, STACKTOP += 8, HEAP32[tempInt >> 2] = $i_04, HEAP32[tempInt + 4 >> 2] = $j_03, tempInt)); - var $call19 = _open(STRING_TABLE.__str2 | 0, $flags_2_or17, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = 511, tempInt)); - var $conv = ($call19 | 0) != -1 & 1; - var $call21 = _printf(STRING_TABLE.__str1 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = $conv, tempInt)); - var $call22 = ___errno(); - var $3 = HEAP32[$call22 >> 2]; - var $call23 = _printf(STRING_TABLE.__str3 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = $3, tempInt)); - var $call24 = _stat(STRING_TABLE.__str2 | 0, $s); - var $and25 = HEAP32[$st_mode$s2] & -512; - var $call26 = _printf(STRING_TABLE.__str4 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = $and25, tempInt)); - for (var $$dest = $1$s2, $$stop = $$dest + 18; $$dest < $$stop; $$dest++) { - HEAP32[$$dest] = 0; - } - var $putchar = _putchar(10); - var $call28 = ___errno(); - HEAP32[$call28 >> 2] = 0; - var $call29 = _printf(STRING_TABLE.__str6 | 0, (tempInt = STACKTOP, STACKTOP += 8, HEAP32[tempInt >> 2] = $i_04, HEAP32[tempInt + 4 >> 2] = $j_03, tempInt)); - var $call30 = _open(STRING_TABLE.__str7 | 0, $flags_2_or17, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = 511, tempInt)); - var $conv32 = ($call30 | 0) != -1 & 1; - var $call33 = _printf(STRING_TABLE.__str1 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = $conv32, tempInt)); - var $call34 = ___errno(); - var $5 = HEAP32[$call34 >> 2]; - var $call35 = _printf(STRING_TABLE.__str3 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = $5, tempInt)); - var $call36 = _stat(STRING_TABLE.__str7 | 0, $s); - var $and38 = HEAP32[$st_mode$s2] & -512; - var $call39 = _printf(STRING_TABLE.__str4 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = $and38, tempInt)); - for (var $$dest = $1$s2, $$stop = $$dest + 18; $$dest < $$stop; $$dest++) { - HEAP32[$$dest] = 0; - } - var $putchar1 = _putchar(10); - var $call41 = ___errno(); - HEAP32[$call41 >> 2] = 0; - HEAP8[$arrayidx43] = $conv42; - HEAP8[$arrayidx46] = $j_03 + 97 & 255; - var $call47 = _printf(STRING_TABLE.__str8 | 0, (tempInt = STACKTOP, STACKTOP += 8, HEAP32[tempInt >> 2] = $i_04, HEAP32[tempInt + 4 >> 2] = $j_03, tempInt)); - var $call48 = _open($0, $flags_2_or17, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = 511, tempInt)); - var $conv50 = ($call48 | 0) != -1 & 1; - var $call51 = _printf(STRING_TABLE.__str1 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = $conv50, tempInt)); - var $call52 = ___errno(); - var $7 = HEAP32[$call52 >> 2]; - var $call53 = _printf(STRING_TABLE.__str3 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = $7, tempInt)); - var $call55 = _stat($0, $s); - var $and57 = HEAP32[$st_mode$s2] & -512; - var $call58 = _printf(STRING_TABLE.__str4 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = $and57, tempInt)); - for (var $$dest = $1$s2, $$stop = $$dest + 18; $$dest < $$stop; $$dest++) { - HEAP32[$$dest] = 0; - } - var $putchar2 = _putchar(10); - var $call60 = ___errno(); - HEAP32[$call60 >> 2] = 0; - var $inc = $j_03 + 1 | 0; - if (($inc | 0) == 16) { - break; - } - var $j_03 = $inc; - } - var $inc62 = $i_04 + 1 | 0; - if (($inc62 | 0) == 3) { - break; - } - var $i_04 = $inc62; + var $j_03; + var $flags_0 = ($j_03 & 1 | 0) == 0 ? $2 : $or; + var $flags_0_or7 = ($j_03 & 2 | 0) == 0 ? $flags_0 : $flags_0 | 2048; + var $flags_2 = ($j_03 & 4 | 0) == 0 ? $flags_0_or7 : $flags_0_or7 | 1024; + var $flags_2_or17 = ($j_03 & 8 | 0) == 0 ? $flags_2 : $flags_2 | 8; + var $call = _printf(STRING_TABLE.__str | 0, (tempInt = STACKTOP, STACKTOP += 8, HEAP32[tempInt >> 2] = $i_04, HEAP32[tempInt + 4 >> 2] = $j_03, tempInt)); + var $call19 = _open(STRING_TABLE.__str2 | 0, $flags_2_or17, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = 511, tempInt)); + var $conv = ($call19 | 0) != -1 & 1; + var $call21 = _printf(STRING_TABLE.__str1 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = $conv, tempInt)); + var $call22 = ___errno(); + var $3 = HEAP32[$call22 >> 2]; + var $call23 = _printf(STRING_TABLE.__str3 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = $3, tempInt)); + var $call24 = _stat(STRING_TABLE.__str2 | 0, $s); + var $and25 = HEAP32[$st_mode$s2] & -512; + var $call26 = _printf(STRING_TABLE.__str4 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = $and25, tempInt)); + for (var $$dest = $1$s2, $$stop = $$dest + 18; $$dest < $$stop; $$dest++) { + HEAP32[$$dest] = 0; + } + var $putchar = _putchar(10); + var $call28 = ___errno(); + HEAP32[$call28 >> 2] = 0; + var $call29 = _printf(STRING_TABLE.__str6 | 0, (tempInt = STACKTOP, STACKTOP += 8, HEAP32[tempInt >> 2] = $i_04, HEAP32[tempInt + 4 >> 2] = $j_03, tempInt)); + var $call30 = _open(STRING_TABLE.__str7 | 0, $flags_2_or17, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = 511, tempInt)); + var $conv32 = ($call30 | 0) != -1 & 1; + var $call33 = _printf(STRING_TABLE.__str1 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = $conv32, tempInt)); + var $call34 = ___errno(); + var $5 = HEAP32[$call34 >> 2]; + var $call35 = _printf(STRING_TABLE.__str3 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = $5, tempInt)); + var $call36 = _stat(STRING_TABLE.__str7 | 0, $s); + var $and38 = HEAP32[$st_mode$s2] & -512; + var $call39 = _printf(STRING_TABLE.__str4 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = $and38, tempInt)); + for (var $$dest = $1$s2, $$stop = $$dest + 18; $$dest < $$stop; $$dest++) { + HEAP32[$$dest] = 0; + } + var $putchar1 = _putchar(10); + var $call41 = ___errno(); + HEAP32[$call41 >> 2] = 0; + HEAP8[$arrayidx43] = $conv42; + HEAP8[$arrayidx46] = $j_03 + 97 & 255; + var $call47 = _printf(STRING_TABLE.__str8 | 0, (tempInt = STACKTOP, STACKTOP += 8, HEAP32[tempInt >> 2] = $i_04, HEAP32[tempInt + 4 >> 2] = $j_03, tempInt)); + var $call48 = _open($0, $flags_2_or17, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = 511, tempInt)); + var $conv50 = ($call48 | 0) != -1 & 1; + var $call51 = _printf(STRING_TABLE.__str1 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = $conv50, tempInt)); + var $call52 = ___errno(); + var $7 = HEAP32[$call52 >> 2]; + var $call53 = _printf(STRING_TABLE.__str3 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = $7, tempInt)); + var $call55 = _stat($0, $s); + var $and57 = HEAP32[$st_mode$s2] & -512; + var $call58 = _printf(STRING_TABLE.__str4 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = $and57, tempInt)); + for (var $$dest = $1$s2, $$stop = $$dest + 18; $$dest < $$stop; $$dest++) { + HEAP32[$$dest] = 0; + } + var $putchar2 = _putchar(10); + var $call60 = ___errno(); + HEAP32[$call60 >> 2] = 0; + var $inc = $j_03 + 1 | 0; + if (($inc | 0) == 16) { + break; + } + var $j_03 = $inc; + } + var $inc62 = $i_04 + 1 | 0; + if (($inc62 | 0) == 3) { + break; } - var $puts = _puts(STRING_TABLE._str | 0); - var $call65 = _creat(STRING_TABLE.__str10 | 0, 511); - var $conv67 = ($call65 | 0) != -1 & 1; - var $call68 = _printf(STRING_TABLE.__str1 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = $conv67, tempInt)); - var $call69 = ___errno(); - var $9 = HEAP32[$call69 >> 2]; - var $call70 = _printf(STRING_TABLE.__str3 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = $9, tempInt)); - STACKTOP = __stackBase__; - return 0; - return null; + var $i_04 = $inc62; + } + var $puts = _puts(STRING_TABLE._str | 0); + var $call65 = _creat(STRING_TABLE.__str10 | 0, 511); + var $conv67 = ($call65 | 0) != -1 & 1; + var $call68 = _printf(STRING_TABLE.__str1 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = $conv67, tempInt)); + var $call69 = ___errno(); + var $9 = HEAP32[$call69 >> 2]; + var $call70 = _printf(STRING_TABLE.__str3 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = $9, tempInt)); + STACKTOP = __stackBase__; + return 0; + return null; } function ex() { - var __stackBase__ = STACKTOP; - STACKTOP += 4; - var $e1 = __stackBase__; - var $puts = _puts(STRING_TABLE._str17 | 0); - var $x41 = $e1 | 0; - var $i_04 = 0; - while (1) { - var $i_04; - var $call1 = _printf(STRING_TABLE.__str15 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = $i_04, tempInt)); - ((function() { - try { - __THREW__ = false; - return __Z5magici($i_04); - } catch (e) { - if (typeof e != "number") throw e; - if (ABORT) throw e; - __THREW__ = true; - return null; - } - }))(); - } + var __stackBase__ = STACKTOP; + STACKTOP += 4; + var $e1 = __stackBase__; + var $puts = _puts(STRING_TABLE._str17 | 0); + var $x41 = $e1 | 0; + var $i_04 = 0; + while (1) { + var $i_04; + var $call1 = _printf(STRING_TABLE.__str15 | 0, (tempInt = STACKTOP, STACKTOP += 4, HEAP32[tempInt >> 2] = $i_04, tempInt)); + ((function() { + try { + __THREW__ = false; + return __Z5magici($i_04); + } catch (e) { + if (typeof e != "number") throw e; + if (ABORT) throw e; + __THREW__ = true; + return null; + } + }))(); + } } function switchey(x) { - var a = 5; - while (1) { - switch (x = f(x, a)) { - case 1: - g(a); - var b = x+1; - x--; - break; - case 2: - g(a*2); - var c = x+22; - var d = c+5; - x -= 20; - break; - default: - var c1 = x+22; - var d2 = c+5; - ch(c1, d2*c); - throw 99; - } + var a = 5; + while (1) { + switch (x = f(x, a)) { + case 1: + g(a); + var b = x+1; + x--; + break; + case 2: + g(a*2); + var c = x+22; + var d = c+5; + x -= 20; + break; + default: + var c1 = x+22; + var d2 = c+5; + ch(c1, d2*c); + throw 99; } - var aa = x+1; - p(a, aa); - var aaa = x+2; - pp(aaa); + } + var aa = x+1; + p(a, aa); + var aaa = x+2; + pp(aaa); } function __ZN14NetworkAddressC1EPKcti($this) { - __ZN14NetworkAddressC2EPKcti($this); - return; + __ZN14NetworkAddressC2EPKcti($this); + return; } // EMSCRIPTEN_GENERATED_FUNCTIONS: ["test", "primes", "atomic", "fcntl_open", "ex", "switchey", "__ZN14NetworkAddressC1EPKcti"] diff --git a/tools/test-js-optimizer-t2-output.js b/tools/test-js-optimizer-t2-output.js index 0ae66be513e9e..334d7999acbea 100644 --- a/tools/test-js-optimizer-t2-output.js +++ b/tools/test-js-optimizer-t2-output.js @@ -1,91 +1,91 @@ function shifty($id2) { - var $tp$s2; - var $parameters_addr$s2; - var $wavelet38$s2; - var _dwt_norms_real$s2; - var $a_addr$s2; - var _idents$s2; - var $id3$s3; - var $id2$s1 = $id2 >> 1; - q(HEAP32[$id >> 2]); - q(HEAP32[$id + 40 >> 2]); - q(HEAP32[$id + 80 >> 2]); - q(HEAP32[unknown1 + unknown2 + $id >> 2]); - q(HEAP32[unknown1 + $id + unknown2 >> 2]); - var localUnchanged1 = get(1), localUnchanged2 = get(1); - q(HEAP32[localUnchanged1 + $id + localUnchanged2 >> 2]); - q($id >> _something_); - $id = q(".."); - q($id << _somethingElse_); - pause(-1); - q(HEAP32[$id2$s1]); - q(HEAP32[$id2$s1]); - q(HEAP32[$id2$s1]); - q(HEAP32[$id2$s1]); - q(HEAP32[$id2$s1 + 20]); - q(HEAP32[$id2$s1 + 40]); - var $id3 = get(74), $id3$s3 = $id3 >> 3; - q(HEAP32[$id3$s3]); - q(HEAP32[$id3$s3 + 5]); - q(HEAP32[$id3$s3 + 10]); - q($id3); - pause(0); - var _idents = get("abc"), _idents$s2 = _idents >> 2; - q(HEAP32[HEAP32[_idents$s2] + 8 >> 2]); - q(HEAP32[HEAP32[_idents$s2] + 8 >> 2]); - q(HEAP32[HEAP32[_idents$s2] + 8 >> 2]); - pause(1); - var $sn_addr = get(12), $a_addr = get(999), $a_addr$s2 = $a_addr >> 2; - var $i = get(112233); - q(HEAP32[(($sn_addr - 1 << 1) + 1 << 2 >> 2) + $a_addr$s2]); - q(HEAP32[(($i - 1 << 1) + 1 << 2 >> 2) + $a_addr$s2]); - q(HEAP32[($i << 3 >> 2) + $a_addr$s2]); - q(HEAP32[($i << 2 >> 2) + $a_addr$s2]); - q($a_addr$s2, z($a_addr$s2)); - pause(2); - var $level = HEAP[get(322) >> 2]; - var _dwt_norms_real = get("a"), _dwt_norms_real$s2 = _dwt_norms_real >> 2, $orient = get("cheez"); - q(HEAP32[($level << 3 >> 2) + _dwt_norms_real$s2 + ($orient * 20 | 0)]); - q(HEAP32[(($level << 3) + 4 >> 2) + _dwt_norms_real$s2 + ($orient * 20 | 0)]); - q(HEAP32[(($level << 3) + 8 >> 2) + _dwt_norms_real$s2 + ($orient * 20 | 0)]); - pause(3); - var $wavelet38 = get(38), $wavelet38$s2 = $wavelet38 >> 2; - $k = $a_addr; - q(HEAPF32[HEAP32[$wavelet38$s2] + ($k << 4) + 8 >> 2]); - q(HEAPF32[HEAP32[$wavelet38$s2] + ($k << 4) + 12 >> 2]); - q(HEAPF32[HEAP32[$wavelet38$s2] + ($k << 4) + 400 >> 2]); - pause(4); - var $p = $k, $parameters_addr = get("burger"), $parameters_addr$s2 = $parameters_addr >> 2; - q(HEAP32[(($p << 2) + 5624 >> 2) + $parameters_addr$s2]); - q(HEAP32[(($p << 2) + 5644 >> 2) + $parameters_addr$s2]); - q(HEAP32[(($p << 2) + 5664 >> 2) + $parameters_addr$s2]); - pause(5); - var $res_spec242 = get($real), $cp = get("b"), $tileno = arguments[2]; - q(HEAP32[(($res_spec242 - 1 << 2) + 5624 >> 2) + $parameters_addr$s2]); - q(HEAP32[(HEAP32[$cp + 108 >> 2] + 420 >> 2) + ($tileno * 1397 | 0)]); - pause(6); - q($idx << 3); - q(1 << $idx << 1); - print(INDENT + "Entering: _main" + "hi"); - pause(7); - var $tp = get("tp"), $tp$s2 = $tp >> 2; - q($tp$s2); - q($tp$s2); - q($tp$s2); - HEAP32[$H400] = $tp; - HEAP32[$tp] = 5; - HEAP32[$tp$s2] = 5; - HEAP32[HEAP[$tp$s2]] = 5; - HEAP32[HEAP[$tp$s2] >> 2] = 5; - pause(7); - q(go() >> 1 << 1); - q(go() << 1 >> 1); - q(go() >> 2); - q(go() << 2); - q(go() >> 8 << 8); - q(go() << 8 >> 8); - q(go() >> 16); - q(go() << 16); - q(go() + 2 >> 2); + var $tp$s2; + var $parameters_addr$s2; + var $wavelet38$s2; + var _dwt_norms_real$s2; + var $a_addr$s2; + var _idents$s2; + var $id3$s3; + var $id2$s1 = $id2 >> 1; + q(HEAP32[$id >> 2]); + q(HEAP32[$id + 40 >> 2]); + q(HEAP32[$id + 80 >> 2]); + q(HEAP32[unknown1 + unknown2 + $id >> 2]); + q(HEAP32[unknown1 + $id + unknown2 >> 2]); + var localUnchanged1 = get(1), localUnchanged2 = get(1); + q(HEAP32[localUnchanged1 + $id + localUnchanged2 >> 2]); + q($id >> _something_); + $id = q(".."); + q($id << _somethingElse_); + pause(-1); + q(HEAP32[$id2$s1]); + q(HEAP32[$id2$s1]); + q(HEAP32[$id2$s1]); + q(HEAP32[$id2$s1]); + q(HEAP32[$id2$s1 + 20]); + q(HEAP32[$id2$s1 + 40]); + var $id3 = get(74), $id3$s3 = $id3 >> 3; + q(HEAP32[$id3$s3]); + q(HEAP32[$id3$s3 + 5]); + q(HEAP32[$id3$s3 + 10]); + q($id3); + pause(0); + var _idents = get("abc"), _idents$s2 = _idents >> 2; + q(HEAP32[HEAP32[_idents$s2] + 8 >> 2]); + q(HEAP32[HEAP32[_idents$s2] + 8 >> 2]); + q(HEAP32[HEAP32[_idents$s2] + 8 >> 2]); + pause(1); + var $sn_addr = get(12), $a_addr = get(999), $a_addr$s2 = $a_addr >> 2; + var $i = get(112233); + q(HEAP32[(($sn_addr - 1 << 1) + 1 << 2 >> 2) + $a_addr$s2]); + q(HEAP32[(($i - 1 << 1) + 1 << 2 >> 2) + $a_addr$s2]); + q(HEAP32[($i << 3 >> 2) + $a_addr$s2]); + q(HEAP32[($i << 2 >> 2) + $a_addr$s2]); + q($a_addr$s2, z($a_addr$s2)); + pause(2); + var $level = HEAP[get(322) >> 2]; + var _dwt_norms_real = get("a"), _dwt_norms_real$s2 = _dwt_norms_real >> 2, $orient = get("cheez"); + q(HEAP32[($level << 3 >> 2) + _dwt_norms_real$s2 + ($orient * 20 | 0)]); + q(HEAP32[(($level << 3) + 4 >> 2) + _dwt_norms_real$s2 + ($orient * 20 | 0)]); + q(HEAP32[(($level << 3) + 8 >> 2) + _dwt_norms_real$s2 + ($orient * 20 | 0)]); + pause(3); + var $wavelet38 = get(38), $wavelet38$s2 = $wavelet38 >> 2; + $k = $a_addr; + q(HEAPF32[HEAP32[$wavelet38$s2] + ($k << 4) + 8 >> 2]); + q(HEAPF32[HEAP32[$wavelet38$s2] + ($k << 4) + 12 >> 2]); + q(HEAPF32[HEAP32[$wavelet38$s2] + ($k << 4) + 400 >> 2]); + pause(4); + var $p = $k, $parameters_addr = get("burger"), $parameters_addr$s2 = $parameters_addr >> 2; + q(HEAP32[(($p << 2) + 5624 >> 2) + $parameters_addr$s2]); + q(HEAP32[(($p << 2) + 5644 >> 2) + $parameters_addr$s2]); + q(HEAP32[(($p << 2) + 5664 >> 2) + $parameters_addr$s2]); + pause(5); + var $res_spec242 = get($real), $cp = get("b"), $tileno = arguments[2]; + q(HEAP32[(($res_spec242 - 1 << 2) + 5624 >> 2) + $parameters_addr$s2]); + q(HEAP32[(HEAP32[$cp + 108 >> 2] + 420 >> 2) + ($tileno * 1397 | 0)]); + pause(6); + q($idx << 3); + q(1 << $idx << 1); + print(INDENT + "Entering: _main" + "hi"); + pause(7); + var $tp = get("tp"), $tp$s2 = $tp >> 2; + q($tp$s2); + q($tp$s2); + q($tp$s2); + HEAP32[$H400] = $tp; + HEAP32[$tp] = 5; + HEAP32[$tp$s2] = 5; + HEAP32[HEAP[$tp$s2]] = 5; + HEAP32[HEAP[$tp$s2] >> 2] = 5; + pause(7); + q(go() >> 1 << 1); + q(go() << 1 >> 1); + q(go() >> 2); + q(go() << 2); + q(go() >> 8 << 8); + q(go() << 8 >> 8); + q(go() >> 16); + q(go() << 16); + q(go() + 2 >> 2); } diff --git a/tools/test-js-optimizer-t2.js b/tools/test-js-optimizer-t2.js index 1582dce74392e..8dd82485e2711 100644 --- a/tools/test-js-optimizer-t2.js +++ b/tools/test-js-optimizer-t2.js @@ -1,92 +1,92 @@ // TODO also with >> 1 and >> 3 -// also HEAP*U*, and HEAP8, 16 +// also HEAP*U*, and HEAP8, 16 function shifty($id2) { - // $id is a non-ssa, $id2 is a param. both should be replaced with a shifted version - q(HEAP32[$id >> 2]); - q(HEAP32[($id + 40) >> 2]); - q(HEAP32[($id + 80 | 0) >> 2]); - q(HEAP32[(unknown1 + unknown2 + $id) >> 2]); - q(HEAP32[(unknown1 + $id + unknown2) >> 2]); // unknowns should be shifted together - var localUnchanged1 = get(1), localUnchanged2 = get(1); - q(HEAP32[(localUnchanged1 + $id + localUnchanged2) >> 2]); // unknowns should be shifted together - q($id >> _something_); // non-fixed shift - $id = q('..'); - q($id << _somethingElse_); // non-fixed shift - pause(-1); - q(HEAP32[$id2 >> 1]); - q(HEAP32[$id2 >> 1]); - q(HEAP32[$id2 >> 1]); - q(HEAP32[$id2 >> 1]); - q(HEAP32[($id2 + 40) >> 1]); - q(HEAP32[($id2 + 80 | 0) >> 1]); - var $id3 = get(74); - q(HEAP32[$id3 >> 3]); - q(HEAP32[($id3 + 40) >> 3]); - q(HEAP32[($id3 + 80 | 0) >> 3]); - q($id3); - pause(0); - // similar, but inside another HEAP - var _idents = get('abc'); - q(HEAP32[(HEAP32[_idents >> 2] + 8 | 0) >> 2]); - q(HEAP32[(HEAP32[_idents >> 2] + 8 | 0) >> 2]); - q(HEAP32[(HEAP32[_idents >> 2] + 8 | 0) >> 2]); - pause(1); - // $i's shifts should consolidate (the last should be 0..? - // since we may have had |0 in the middle!) - var $sn_addr = get(12), $a_addr = get(999); - var $i = get(112233); - q(HEAP32[($a_addr + ((($sn_addr - 1 << 1) + 1 | 0) << 2) | 0) >> 2]); - q(HEAP32[($a_addr + ((($i - 1 << 1) + 1 | 0) << 2) | 0) >> 2]); - q(HEAP32[($a_addr + (($i << 1 | 0) << 2) | 0) >> 2]); - q(HEAP32[($a_addr + ($i << 2)) >> 2]); - q($a_addr >> 2, z($a_addr >> 2)); - pause(2); - var $level = HEAP[get(322) >> 2]; // ignore this - var _dwt_norms_real = get('a'), $orient = get('cheez'); - q(HEAP32[(_dwt_norms_real + $orient * 80 + ($level << 3) | 0) >> 2]); - q(HEAP32[(_dwt_norms_real + $orient * 80 + ($level << 3) + 4 | 0) >> 2]); - q(HEAP32[(_dwt_norms_real + $orient * 80 + ($level << 3) + 8 | 0) >> 2]); - pause(3); - // reuse $a_addr here - var $wavelet38 = get(38); - $k = $a_addr; - q(HEAPF32[(HEAP32[$wavelet38 >> 2] + ($k << 4) + 8 | 0) >> 2]); - q(HEAPF32[(HEAP32[$wavelet38 >> 2] + ($k << 4) + 12 | 0) >> 2]); - q(HEAPF32[(HEAP32[$wavelet38 >> 2] + ($k << 4) + 400 | 0) >> 2]); - pause(4); - // reuse $k, which already reuses $a_addr - var $p = $k, $parameters_addr = get('burger') - q(HEAP32[($parameters_addr + 5624 + ($p << 2) | 0) >> 2]); - q(HEAP32[($parameters_addr + 5644 + ($p << 2) | 0) >> 2]); - q(HEAP32[($parameters_addr + 5664 + ($p << 2) | 0) >> 2]); - pause(5); - // loops count as more uses! - var $res_spec242 = get($real), $cp = get('b'), $tileno = arguments[2]; - q(HEAP32[($parameters_addr + 5624 + (($res_spec242 - 1 | 0) << 2) | 0) >> 2]); - q(HEAP32[(HEAP32[($cp + 108 | 0) >> 2] + $tileno * 5588 + 420 | 0) >> 2]); - pause(6); - q($idx << 1 << 2); - q(1 << $idx << 1); // Do not turn this into the slower 1 << $idx + 1 (which is identical though) - print(INDENT + "Entering: _main" + "hi"); // this order should not be modified - pause(7); - var $tp = get('tp'); - q($tp >> 2); - q($tp >> 2); - q($tp >> 2); - HEAP32[$H400] = $tp; - HEAP32[$tp] = 5; - HEAP32[$tp >> 2] = 5; - HEAP32[HEAP[$tp >> 2]] = 5; - HEAP32[HEAP[$tp >> 2] >> 2] = 5; - pause(7); - q(go() >> 1 << 1); - q(go() << 1 >> 1); - q(go() >> 1 >> 1); - q(go() << 1 << 1); - q(go() >> 8 << 8); - q(go() << 8 >> 8); - q(go() >> 8 >> 8); - q(go() << 8 << 8); - q((go() + 2) >> 2); // the 2 >> 2 can't be simplified + // $id is a non-ssa, $id2 is a param. both should be replaced with a shifted version + q(HEAP32[$id >> 2]); + q(HEAP32[($id + 40) >> 2]); + q(HEAP32[($id + 80 | 0) >> 2]); + q(HEAP32[(unknown1 + unknown2 + $id) >> 2]); + q(HEAP32[(unknown1 + $id + unknown2) >> 2]); // unknowns should be shifted together + var localUnchanged1 = get(1), localUnchanged2 = get(1); + q(HEAP32[(localUnchanged1 + $id + localUnchanged2) >> 2]); // unknowns should be shifted together + q($id >> _something_); // non-fixed shift + $id = q('..'); + q($id << _somethingElse_); // non-fixed shift + pause(-1); + q(HEAP32[$id2 >> 1]); + q(HEAP32[$id2 >> 1]); + q(HEAP32[$id2 >> 1]); + q(HEAP32[$id2 >> 1]); + q(HEAP32[($id2 + 40) >> 1]); + q(HEAP32[($id2 + 80 | 0) >> 1]); + var $id3 = get(74); + q(HEAP32[$id3 >> 3]); + q(HEAP32[($id3 + 40) >> 3]); + q(HEAP32[($id3 + 80 | 0) >> 3]); + q($id3); + pause(0); + // similar, but inside another HEAP + var _idents = get('abc'); + q(HEAP32[(HEAP32[_idents >> 2] + 8 | 0) >> 2]); + q(HEAP32[(HEAP32[_idents >> 2] + 8 | 0) >> 2]); + q(HEAP32[(HEAP32[_idents >> 2] + 8 | 0) >> 2]); + pause(1); + // $i's shifts should consolidate (the last should be 0..? + // since we may have had |0 in the middle!) + var $sn_addr = get(12), $a_addr = get(999); + var $i = get(112233); + q(HEAP32[($a_addr + ((($sn_addr - 1 << 1) + 1 | 0) << 2) | 0) >> 2]); + q(HEAP32[($a_addr + ((($i - 1 << 1) + 1 | 0) << 2) | 0) >> 2]); + q(HEAP32[($a_addr + (($i << 1 | 0) << 2) | 0) >> 2]); + q(HEAP32[($a_addr + ($i << 2)) >> 2]); + q($a_addr >> 2, z($a_addr >> 2)); + pause(2); + var $level = HEAP[get(322) >> 2]; // ignore this + var _dwt_norms_real = get('a'), $orient = get('cheez'); + q(HEAP32[(_dwt_norms_real + $orient * 80 + ($level << 3) | 0) >> 2]); + q(HEAP32[(_dwt_norms_real + $orient * 80 + ($level << 3) + 4 | 0) >> 2]); + q(HEAP32[(_dwt_norms_real + $orient * 80 + ($level << 3) + 8 | 0) >> 2]); + pause(3); + // reuse $a_addr here + var $wavelet38 = get(38); + $k = $a_addr; + q(HEAPF32[(HEAP32[$wavelet38 >> 2] + ($k << 4) + 8 | 0) >> 2]); + q(HEAPF32[(HEAP32[$wavelet38 >> 2] + ($k << 4) + 12 | 0) >> 2]); + q(HEAPF32[(HEAP32[$wavelet38 >> 2] + ($k << 4) + 400 | 0) >> 2]); + pause(4); + // reuse $k, which already reuses $a_addr + var $p = $k, $parameters_addr = get('burger') + q(HEAP32[($parameters_addr + 5624 + ($p << 2) | 0) >> 2]); + q(HEAP32[($parameters_addr + 5644 + ($p << 2) | 0) >> 2]); + q(HEAP32[($parameters_addr + 5664 + ($p << 2) | 0) >> 2]); + pause(5); + // loops count as more uses! + var $res_spec242 = get($real), $cp = get('b'), $tileno = arguments[2]; + q(HEAP32[($parameters_addr + 5624 + (($res_spec242 - 1 | 0) << 2) | 0) >> 2]); + q(HEAP32[(HEAP32[($cp + 108 | 0) >> 2] + $tileno * 5588 + 420 | 0) >> 2]); + pause(6); + q($idx << 1 << 2); + q(1 << $idx << 1); // Do not turn this into the slower 1 << $idx + 1 (which is identical though) + print(INDENT + "Entering: _main" + "hi"); // this order should not be modified + pause(7); + var $tp = get('tp'); + q($tp >> 2); + q($tp >> 2); + q($tp >> 2); + HEAP32[$H400] = $tp; + HEAP32[$tp] = 5; + HEAP32[$tp >> 2] = 5; + HEAP32[HEAP[$tp >> 2]] = 5; + HEAP32[HEAP[$tp >> 2] >> 2] = 5; + pause(7); + q(go() >> 1 << 1); + q(go() << 1 >> 1); + q(go() >> 1 >> 1); + q(go() << 1 << 1); + q(go() >> 8 << 8); + q(go() << 8 >> 8); + q(go() >> 8 >> 8); + q(go() << 8 << 8); + q((go() + 2) >> 2); // the 2 >> 2 can't be simplified } // EMSCRIPTEN_GENERATED_FUNCTIONS: ["shifty"] diff --git a/tools/test-js-optimizer-t2c-output.js b/tools/test-js-optimizer-t2c-output.js index 726112ecc7890..43cdf889b2f43 100644 --- a/tools/test-js-optimizer-t2c-output.js +++ b/tools/test-js-optimizer-t2c-output.js @@ -1,17 +1,17 @@ function shifty() { - $pPage = HEAP32[$pCur_addr + ($26 << 16 >> 16 << 2) + 116 >> 2]; - var $ead_192394 = HEAP32[$pCur_addr + ($26 << 16 >> 16 << 2) + 116 >> 2]; - $pPage2 = HEAP32[($26 << 16 >> 16 << 2) + $pCur_addr + 116]; - var $ead_192394b = HEAP32[($26 << 16 >> 16 << 2) + $pCur_addr + 116]; - $pPage2 = HEAP32[($26 << 16 >> 16) + $pCur_addr + 116]; - var $ead_192394b = HEAP32[($26 << 16 >> 16) + $pCur_addr + 116]; - q(4); - q($13 + 8 >> 2); - q($13 + 28 >> 2); - q($13 + 60 >> 2); - q($13 + $15 + 12 >> 2); - q(HEAPF32[$output + ($j37 << 4) + 4 >> 2]); - q($13 + 13 << 2); - q(h() >> 2 << 2); + $pPage = HEAP32[$pCur_addr + ($26 << 16 >> 16 << 2) + 116 >> 2]; + var $ead_192394 = HEAP32[$pCur_addr + ($26 << 16 >> 16 << 2) + 116 >> 2]; + $pPage2 = HEAP32[($26 << 16 >> 16 << 2) + $pCur_addr + 116]; + var $ead_192394b = HEAP32[($26 << 16 >> 16 << 2) + $pCur_addr + 116]; + $pPage2 = HEAP32[($26 << 16 >> 16) + $pCur_addr + 116]; + var $ead_192394b = HEAP32[($26 << 16 >> 16) + $pCur_addr + 116]; + q(4); + q($13 + 8 >> 2); + q($13 + 28 >> 2); + q($13 + 60 >> 2); + q($13 + $15 + 12 >> 2); + q(HEAPF32[$output + ($j37 << 4) + 4 >> 2]); + q($13 + 13 << 2); + q(h() >> 2 << 2); } diff --git a/tools/test-js-optimizer-t2c.js b/tools/test-js-optimizer-t2c.js index 52e9b4f9a5018..85292ba57ecb4 100644 --- a/tools/test-js-optimizer-t2c.js +++ b/tools/test-js-optimizer-t2c.js @@ -1,18 +1,18 @@ function shifty() { - $pPage = HEAP32[$pCur_addr + 116 + ($26 << 16 >> 16 << 2) >> 2]; - var $ead_192394 = HEAP32[$pCur_addr + 116 + ($26 << 16 >> 16 << 2) >> 2]; - $pPage2 = HEAP32[$pCur_addr + 116 + ($26 << 16 >> 16 << 2)]; - var $ead_192394b = HEAP32[$pCur_addr + 116 + ($26 << 16 >> 16 << 2)]; - $pPage2 = HEAP32[$pCur_addr + 116 + ($26 << 16 >> 16)]; - var $ead_192394b = HEAP32[$pCur_addr + 116 + ($26 << 16 >> 16)]; - // We prefer to do additions then shifts, so the shift happens last, because the shift output is known to be 32-bit. So these should not change - q(16 >> 2); - q($13 + 8 >> 2); - q(28 + $13 >> 2); - q(48 + $13 + 12 >> 2); - q($13 + $15 + 12 >> 2); - q(HEAPF32[$output + ($j37 << 4) + 4 >> 2]); - q(5 + $13 + 8 << 2); - q(((h() | 0) >> 2) << 2); // removing the shifts is dangerous + $pPage = HEAP32[$pCur_addr + 116 + ($26 << 16 >> 16 << 2) >> 2]; + var $ead_192394 = HEAP32[$pCur_addr + 116 + ($26 << 16 >> 16 << 2) >> 2]; + $pPage2 = HEAP32[$pCur_addr + 116 + ($26 << 16 >> 16 << 2)]; + var $ead_192394b = HEAP32[$pCur_addr + 116 + ($26 << 16 >> 16 << 2)]; + $pPage2 = HEAP32[$pCur_addr + 116 + ($26 << 16 >> 16)]; + var $ead_192394b = HEAP32[$pCur_addr + 116 + ($26 << 16 >> 16)]; + // We prefer to do additions then shifts, so the shift happens last, because the shift output is known to be 32-bit. So these should not change + q(16 >> 2); + q($13 + 8 >> 2); + q(28 + $13 >> 2); + q(48 + $13 + 12 >> 2); + q($13 + $15 + 12 >> 2); + q(HEAPF32[$output + ($j37 << 4) + 4 >> 2]); + q(5 + $13 + 8 << 2); + q(((h() | 0) >> 2) << 2); // removing the shifts is dangerous } // EMSCRIPTEN_GENERATED_FUNCTIONS: ["shifty"] diff --git a/tools/test-js-optimizer-t3-output.js b/tools/test-js-optimizer-t3-output.js index 924868fad1e2d..9a16c2accb96a 100644 --- a/tools/test-js-optimizer-t3-output.js +++ b/tools/test-js-optimizer-t3-output.js @@ -1,49 +1,49 @@ function _png_create_write_struct_2($user_png_ver, $error_ptr, $error_fn, $warn_fn, $mem_ptr, $malloc_fn, $free_fn) { - var $png_ptr$s2; - var label; - label = 2; - var setjmpTable = { - "2": (function(value) { - label = 5; - $call1 = value; - }), - dummy: 0 - }; - while (1) try { - switch (label) { - case 2: - var $png_ptr; - var $call = _png_create_struct(1); - $png_ptr = $call; - var $call1 = (HEAP32[$png_ptr >> 2] = label, 0); - label = 5; - break; - case 5: - var $2 = $png_ptr; - if (($call1 | 0) == 0) { - label = 4; - break; - } else { - label = 3; - break; - } - case 3: - var $4 = HEAP32[($png_ptr >> 2) + (148 >> 2)]; - _png_free($2, $4); - HEAP32[($png_ptr >> 2) + (148 >> 2)] = 0; - _png_destroy_struct($png_ptr); - var $retval_0 = 0; - label = 4; - break; - case 4: - var $retval_0; - return $retval_0; - default: - assert(0, "bad label: " + label); - } - } catch (e) { - if (!e.longjmp) throw e; - setjmpTable[e.label](e.value); + var $png_ptr$s2; + var label; + label = 2; + var setjmpTable = { + "2": (function(value) { + label = 5; + $call1 = value; + }), + dummy: 0 + }; + while (1) try { + switch (label) { + case 2: + var $png_ptr; + var $call = _png_create_struct(1); + $png_ptr = $call; + var $call1 = (HEAP32[$png_ptr >> 2] = label, 0); + label = 5; + break; + case 5: + var $2 = $png_ptr; + if (($call1 | 0) == 0) { + label = 4; + break; + } else { + label = 3; + break; + } + case 3: + var $4 = HEAP32[($png_ptr >> 2) + (148 >> 2)]; + _png_free($2, $4); + HEAP32[($png_ptr >> 2) + (148 >> 2)] = 0; + _png_destroy_struct($png_ptr); + var $retval_0 = 0; + label = 4; + break; + case 4: + var $retval_0; + return $retval_0; + default: + assert(0, "bad label: " + label); } + } catch (e) { + if (!e.longjmp) throw e; + setjmpTable[e.label](e.value); + } } diff --git a/tools/test-js-optimizer-t3.js b/tools/test-js-optimizer-t3.js index 5519189f10022..0e02f72bc36ed 100644 --- a/tools/test-js-optimizer-t3.js +++ b/tools/test-js-optimizer-t3.js @@ -1,50 +1,50 @@ function _png_create_write_struct_2($user_png_ver, $error_ptr, $error_fn, $warn_fn, $mem_ptr, $malloc_fn, $free_fn) { - var $png_ptr$s2; - var label; - label = 2; - var setjmpTable = { - "2": (function(value) { - label = 5; - $call1 = value; - }), - dummy: 0 - }; - while (1) try { - switch (label) { - case 2: - var $png_ptr; - var $call = _png_create_struct(1); - $png_ptr = $call; - var $call1 = (HEAP32[$png_ptr >> 2] = label, 0); - label = 5; - break; - case 5: - var $2 = $png_ptr; - if (($call1 | 0) == 0) { - label = 4; - break; - } else { - label = 3; - break; - } - case 3: - var $4 = HEAP32[($png_ptr >> 2) + (148 >> 2)]; - _png_free($2, $4); - HEAP32[($png_ptr >> 2) + (148 >> 2)] = 0; - _png_destroy_struct($png_ptr); - var $retval_0 = 0; - label = 4; - break; - case 4: - var $retval_0; - return $retval_0; - default: - assert(0, "bad label: " + label); - } - } catch (e) { - if (!e.longjmp) throw e; - setjmpTable[e.label](e.value); + var $png_ptr$s2; + var label; + label = 2; + var setjmpTable = { + "2": (function(value) { + label = 5; + $call1 = value; + }), + dummy: 0 + }; + while (1) try { + switch (label) { + case 2: + var $png_ptr; + var $call = _png_create_struct(1); + $png_ptr = $call; + var $call1 = (HEAP32[$png_ptr >> 2] = label, 0); + label = 5; + break; + case 5: + var $2 = $png_ptr; + if (($call1 | 0) == 0) { + label = 4; + break; + } else { + label = 3; + break; + } + case 3: + var $4 = HEAP32[($png_ptr >> 2) + (148 >> 2)]; + _png_free($2, $4); + HEAP32[($png_ptr >> 2) + (148 >> 2)] = 0; + _png_destroy_struct($png_ptr); + var $retval_0 = 0; + label = 4; + break; + case 4: + var $retval_0; + return $retval_0; + default: + assert(0, "bad label: " + label); } + } catch (e) { + if (!e.longjmp) throw e; + setjmpTable[e.label](e.value); + } } // EMSCRIPTEN_GENERATED_FUNCTIONS: ["_png_create_write_struct_2"] diff --git a/tools/test-js-optimizer.js b/tools/test-js-optimizer.js index bd3be2810410b..09c59df273abe 100644 --- a/tools/test-js-optimizer.js +++ b/tools/test-js-optimizer.js @@ -1,401 +1,401 @@ function expr() { - if (!($0 < $1)) print("hi"); + if (!($0 < $1)) print("hi"); } function loopy() { - $while_body$2: while(1) { - $ok=1; - $for_cond$4: while(1) { - if ($ok) break $for_cond$4; - var $inc=$ok+1; - if ($inc == 9999) break $while_body$2; // this forces a label to remain on the outer loop - } - continue $while_body$2; + $while_body$2: while(1) { + $ok=1; + $for_cond$4: while(1) { + if ($ok) break $for_cond$4; + var $inc=$ok+1; + if ($inc == 9999) break $while_body$2; // this forces a label to remain on the outer loop } - next(); - b$while_body$2: while(1) { - $ok=1; - b$for_cond$4: while(1) { - if ($ok) break b$for_cond$4; - var $inc=$ok+1; - } - continue b$while_body$2; + continue $while_body$2; + } + next(); + b$while_body$2: while(1) { + $ok=1; + b$for_cond$4: while(1) { + if ($ok) break b$for_cond$4; + var $inc=$ok+1; } - next(); - $once: do { - if (!$ok) break $once; // forces the entire one-time do to remain (but unlabelled) - something(); - } while(0); - next(); - b$once: do { - while (more()) { - if (!$ok) break b$once; // forces the entire one-time do to remain, with label - } - something(); - } while(0); - next(); - c$once: do { - something(); - } while(0); + continue b$while_body$2; + } + next(); + $once: do { + if (!$ok) break $once; // forces the entire one-time do to remain (but unlabelled) + something(); + } while(0); + next(); + b$once: do { + while (more()) { + if (!$ok) break b$once; // forces the entire one-time do to remain, with label + } + something(); + } while(0); + next(); + c$once: do { + something(); + } while(0); } function bits() { - print((($s & 65535) + ((($f & 65535) << 16 >> 16) * (($f & 65535) << 16 >> 16) | 0 | 0) % 256 | 0) & 65535); - z(HEAP32[($id + 40 | 0) >> 2]); - z(($f | 0) << 2); - z(($f | 0) | 255); - z(($f | 0) & 255); - z(($f | 0) ^ 1); - z(($f | 0) << 2); - z((($f | 0) * 100) << 2); - z((($f | 0) % 2) | 255); - z((($f | 0) / 55) & 255); - z((($f | 0) - 22) ^ 1); - z((($f | 0) + 15) << 2); + print((($s & 65535) + ((($f & 65535) << 16 >> 16) * (($f & 65535) << 16 >> 16) | 0 | 0) % 256 | 0) & 65535); + z(HEAP32[($id + 40 | 0) >> 2]); + z(($f | 0) << 2); + z(($f | 0) | 255); + z(($f | 0) & 255); + z(($f | 0) ^ 1); + z(($f | 0) << 2); + z((($f | 0) * 100) << 2); + z((($f | 0) % 2) | 255); + z((($f | 0) / 55) & 255); + z((($f | 0) - 22) ^ 1); + z((($f | 0) + 15) << 2); } function maths() { - check(5+12); - check(90+3+2); - __ZN6b2Vec2C1Ev(((((((($this1 + 20 | 0 | 0) + 8 | 0) + 8 | 0) + 8 | 0) + 8 | 0) + 8 | 0) + 8 | 0) + 8 | 0); + check(5+12); + check(90+3+2); + __ZN6b2Vec2C1Ev(((((((($this1 + 20 | 0 | 0) + 8 | 0) + 8 | 0) + 8 | 0) + 8 | 0) + 8 | 0) + 8 | 0) + 8 | 0); } function hoisting() { - if ($i < $N) { - label = 2; + if ($i < $N) { + label = 2; + } + if (label == 2) { + callOther(); + } + pause(1); + if ($i < $N) { + label = 2; + } else { + label = 3; + } + $for_body3$$for_end$5 : do { + if (label == 2) { + while(true) { break $for_body3$$for_end$5 } + callOther(); } + } while (0); + pause(2); + if ($i < $N) { + label = 2; + } else { + label = 3; + } + cheez: do { if (label == 2) { - callOther(); + if (callOther()) break cheez; } - pause(1); + } while (0); + pause(3); + if ($i < $N) { + label = 2; + } else { + label = 3; + } + if (label == 2) { + callOther(); + } + pause(4); + if ($i < $N) { + label = 2; + } else { + label = 3; + } + if (label == 2) { + callOther(); + } else if (label == 3) { + somethingElse(); + } + pause(5); + if ($i < $N) { + label = 2; + } else { + label = 3; + } + if (label == 55) { + callOther(); + } else if (label == 3) { + somethingElse(); + } + pause(6); + if ($i < $N) { + label = 2; + } else { + label = 3; + } + if (label == 3) { + somethingElse(); + } + pause(7); + free: while (1) { if ($i < $N) { - label = 2; + label = 2; } else { - label = 3; + label = 3; // this cannot be removed! + break; } - $for_body3$$for_end$5 : do { - if (label == 2) { - while(true) { break $for_body3$$for_end$5 } - callOther(); - } - } while (0); - pause(2); - if ($i < $N) { - label = 2; - } else { - label = 3; + if (label == 2) { + somethingElse(); } - cheez: do { - if (label == 2) { - if (callOther()) break cheez; - } - } while (0); - pause(3); if ($i < $N) { - label = 2; + label = 2; } else { - label = 3; + label = 3; // this can be removed! } if (label == 2) { - callOther(); + somethingElse(); + } + nothing(); + } + pause(8); + var $cmp95 = $69 == -1; + if ($cmp95) { + label = 35; + } else { + label = 38; + } + $if_then96$$if_end110thread_pre_split$48 : do { + if (label == 35) { + if (!$cmp103) { + label = 38; + break $if_then96$$if_end110thread_pre_split$48; + } + if (!$cmp106) { + label = 38; + break $if_then96$$if_end110thread_pre_split$48; + } + label = 39; + break $if_then96$$if_end110thread_pre_split$48; } - pause(4); + } while (0); + $if_end110$$if_end110thread_pre_split$52 : do { + if (label == 38) { + var $79 = $_pr6; + } + } while (0); + pause(9); + var $cmp70 = ($call69 | 0) != 0; + if ($cmp70) { + label = 40; + } else { + label = 41; + } + $if_then72$$if_end73$126 : do { + if (label == 40) {} else if (label == 41) {} + } while (0); + pause(10); + while(check()) { if ($i < $N) { - label = 2; + label = 2; } else { - label = 3; + label = 3; } if (label == 2) { - callOther(); + callOther(); + break; } else if (label == 3) { - somethingElse(); + somethingElse(); } - pause(5); - if ($i < $N) { - label = 2; + if ($i1 < $N) { + label = 2; } else { - label = 3; + label = 3; } - if (label == 55) { - callOther(); + if (label == 2) { + callOther(); + continue; } else if (label == 3) { - somethingElse(); + somethingElse(); } - pause(6); - if ($i < $N) { - label = 2; + if ($i2 < $N) { + label = 2; } else { - label = 3; - } - if (label == 3) { - somethingElse(); + label = 3; } - pause(7); - free: while (1) { - if ($i < $N) { - label = 2; - } else { - label = 3; // this cannot be removed! - break; - } - if (label == 2) { - somethingElse(); - } - if ($i < $N) { - label = 2; - } else { - label = 3; // this can be removed! - } - if (label == 2) { - somethingElse(); - } - nothing(); + if (label == 2) { + callOther(); + } else if (label == 3) { + somethingElse(); + break; } - pause(8); - var $cmp95 = $69 == -1; - if ($cmp95) { - label = 35; + if ($i3 < $N) { + label = 2; } else { - label = 38; + label = 3; } - $if_then96$$if_end110thread_pre_split$48 : do { - if (label == 35) { - if (!$cmp103) { - label = 38; - break $if_then96$$if_end110thread_pre_split$48; - } - if (!$cmp106) { - label = 38; - break $if_then96$$if_end110thread_pre_split$48; - } - label = 39; - break $if_then96$$if_end110thread_pre_split$48; - } - } while (0); - $if_end110$$if_end110thread_pre_split$52 : do { - if (label == 38) { - var $79 = $_pr6; - } - } while (0); - pause(9); - var $cmp70 = ($call69 | 0) != 0; - if ($cmp70) { - label = 40; + if (label == 2) { + callOther(); + } else if (label == 3) { + somethingElse(); + continue; + } + if ($i4 < $N) { + label = 2; } else { - label = 41; + label = 3; } - $if_then72$$if_end73$126 : do { - if (label == 40) {} else if (label == 41) {} - } while (0); - pause(10); - while(check()) { - if ($i < $N) { - label = 2; - } else { - label = 3; - } - if (label == 2) { - callOther(); - break; - } else if (label == 3) { - somethingElse(); - } - if ($i1 < $N) { - label = 2; - } else { - label = 3; - } - if (label == 2) { - callOther(); - continue; - } else if (label == 3) { - somethingElse(); - } - if ($i2 < $N) { - label = 2; - } else { - label = 3; - } - if (label == 2) { - callOther(); - } else if (label == 3) { - somethingElse(); - break; - } - if ($i3 < $N) { - label = 2; - } else { - label = 3; - } - if (label == 2) { - callOther(); - } else if (label == 3) { - somethingElse(); - continue; - } - if ($i4 < $N) { - label = 2; - } else { - label = 3; - } - if (label == 2) { - callOther(); - break; - } else if (label == 3) { - somethingElse(); - continue; - } + if (label == 2) { + callOther(); + break; + } else if (label == 3) { + somethingElse(); + continue; } + } } function innerShouldAlsoBeHoisted() { - function hoisting() { - if ($i < $N) { - label = 2; - } - if (label == 2) { - callOther(); - } + function hoisting() { + if ($i < $N) { + label = 2; } + if (label == 2) { + callOther(); + } + } } var FS = { - absolutePath: function(relative, base) { // Don't touch this! - if (typeof relative !== 'string') return null; - if (base === undefined) base = FS.currentPath; - if (relative && relative[0] == '/') base = ''; - var full = base + '/' + relative; - var parts = full.split('/').reverse(); - var absolute = ['']; - while (parts.length) { - var part = parts.pop(); - if (part == '' || part == '.') { - // Nothing. - } else if (part == '..') { - if (absolute.length > 1) absolute.pop(); - } else { - absolute.push(part); - } - } - return absolute.length == 1 ? '/' : absolute.join('/'); + absolutePath: function(relative, base) { // Don't touch this! + if (typeof relative !== 'string') return null; + if (base === undefined) base = FS.currentPath; + if (relative && relative[0] == '/') base = ''; + var full = base + '/' + relative; + var parts = full.split('/').reverse(); + var absolute = ['']; + while (parts.length) { + var part = parts.pop(); + if (part == '' || part == '.') { + // Nothing. + } else if (part == '..') { + if (absolute.length > 1) absolute.pop(); + } else { + absolute.push(part); + } } + return absolute.length == 1 ? '/' : absolute.join('/'); + } } function sleep() { - while (Date.now() - start < msec) { - // Do nothing. This empty block should remain untouched (c.f. _usleep) - } - return 0; + while (Date.now() - start < msec) { + // Do nothing. This empty block should remain untouched (c.f. _usleep) + } + return 0; } function demangle($cmp) { - if ($cmp) { + if ($cmp) { + label = 3; + } else { + label = 1; + } + $if_then$$lor_lhs_false$2 : do { + if (label == 1) { + if (something()) { label = 3; - } else { - label = 1; + break $if_then$$lor_lhs_false$2; + } + more(); + break $if_then$$lor_lhs_false$2; } - $if_then$$lor_lhs_false$2 : do { - if (label == 1) { - if (something()) { - label = 3; - break $if_then$$lor_lhs_false$2; - } - more(); - break $if_then$$lor_lhs_false$2; - } - } while (0); - $if_then$$return$6 : do { - if (label == 3) { - final(); - } - } while (0); + } while (0); + $if_then$$return$6 : do { + if (label == 3) { + final(); + } + } while (0); } function lua() { - $5$98 : while (1) { - if ($14) { - label = 3; - } else { - label = 4; - } - $15$$16$101 : do { - if (label == 3) {} else if (label == 4) { - var $17 = $i; - var $18 = $3; - var $19 = $18 + ($17 << 2) | 0; - var $20 = HEAP32[$19 >> 2]; - var $21 = $20 + 1 | 0; - var $22 = HEAP8[$21]; - var $23 = $22 << 24 >> 24; - break $15$$16$101; - } - } while(0); - } - pause(); - if ($1435 == 0) { - label = 176; - cheez(); - } else if ($1435 == 1) {} else { - label = 180; - cheez(); + $5$98 : while (1) { + if ($14) { + label = 3; + } else { + label = 4; } - pause(); - if ($1435 == 0) { - label = 176; - cheez(); - } else if ($1435 == 1) {} + $15$$16$101 : do { + if (label == 3) {} else if (label == 4) { + var $17 = $i; + var $18 = $3; + var $19 = $18 + ($17 << 2) | 0; + var $20 = HEAP32[$19 >> 2]; + var $21 = $20 + 1 | 0; + var $22 = HEAP8[$21]; + var $23 = $22 << 24 >> 24; + break $15$$16$101; + } + } while(0); + } + pause(); + if ($1435 == 0) { + label = 176; + cheez(); + } else if ($1435 == 1) {} else { + label = 180; + cheez(); + } + pause(); + if ($1435 == 0) { + label = 176; + cheez(); + } else if ($1435 == 1) {} } function moreLabels() { - $for_cond$2 : while (1) { // even this label should vanish - if (!$cmp) { - break $for_cond$2; - } - $if_then$$for_inc$5 : do { - if ($cmp1) { - break $for_cond$2; - } else { - inc(); - } - } while (0); - $if_then$$for_inc$5 : do {} while (0); + $for_cond$2 : while (1) { // even this label should vanish + if (!$cmp) { + break $for_cond$2; } - pause(999); - $while_body$$while_end$31 : do { - if ($cmp3) { - var $6 = $5; - { - while (1) { - var $6; - $iter = $6 + 3; - if (FHEAP[$iter + 1] < $pct_addr) { - var $6 = $iter; - } else { - var $_lcssa = $iter; - break $while_body$$while_end$31; - } - } - } - } else { - var $_lcssa = $5; - label = 2; - } + $if_then$$for_inc$5 : do { + if ($cmp1) { + break $for_cond$2; + } else { + inc(); + } } while (0); - var $_lcssa; - cheez(); + $if_then$$for_inc$5 : do {} while (0); + } + pause(999); + $while_body$$while_end$31 : do { + if ($cmp3) { + var $6 = $5; + { + while (1) { + var $6; + $iter = $6 + 3; + if (FHEAP[$iter + 1] < $pct_addr) { + var $6 = $iter; + } else { + var $_lcssa = $iter; + break $while_body$$while_end$31; + } + } + } + } else { + var $_lcssa = $5; + label = 2; + } + } while (0); + var $_lcssa; + cheez(); } function notComps() { - if (!(HEAP32[$incdec_ptr71_i + 8 >> 2] == 0)) { - shoo(); - } + if (!(HEAP32[$incdec_ptr71_i + 8 >> 2] == 0)) { + shoo(); + } } function tricky() { - // The &-1 is a rounding correction, and must not be removed - var $conv642 = ($conv6374 - (($132 << 16 >> 16 | 0) / 2 & -1) | 0) & 65535; + // The &-1 is a rounding correction, and must not be removed + var $conv642 = ($conv6374 - (($132 << 16 >> 16 | 0) / 2 & -1) | 0) & 65535; } function asmy() { - f(HEAP8[_buf + i6 & 16777215] & 255); - f(HEAPU8[_buf + i6 & 16777215] & 255); - f(HEAP8[_buf + i6 & 16777215] & 255 & 1); - f(HEAPU8[_buf + i6 & 16777215] & 255 & 1); - f(HEAP8[_buf + i6 & 16777215] & 1 & 255); - f(HEAPU8[_buf + i6 & 16777215] & 1 & 255); - f((HEAP8[_buf + i6 & 16777215] & 255 & 1) + i5 | 0); - f((HEAPU8[_buf + i6 & 16777215] & 255 & 1) + i5 | 0); - f((HEAP8[_buf + i6 & 16777215] & 1 & 255) + i5 | 0); - f((HEAPU8[_buf + i6 & 16777215] & 1 & 255) + i5 | 0); - if ((_sbrk($419 | 0) | 0 | 0) == -1) { - print('fleefl'); - } + f(HEAP8[_buf + i6 & 16777215] & 255); + f(HEAPU8[_buf + i6 & 16777215] & 255); + f(HEAP8[_buf + i6 & 16777215] & 255 & 1); + f(HEAPU8[_buf + i6 & 16777215] & 255 & 1); + f(HEAP8[_buf + i6 & 16777215] & 1 & 255); + f(HEAPU8[_buf + i6 & 16777215] & 1 & 255); + f((HEAP8[_buf + i6 & 16777215] & 255 & 1) + i5 | 0); + f((HEAPU8[_buf + i6 & 16777215] & 255 & 1) + i5 | 0); + f((HEAP8[_buf + i6 & 16777215] & 1 & 255) + i5 | 0); + f((HEAPU8[_buf + i6 & 16777215] & 1 & 255) + i5 | 0); + if ((_sbrk($419 | 0) | 0 | 0) == -1) { + print('fleefl'); + } } // EMSCRIPTEN_GENERATED_FUNCTIONS: ["abc", "xyz", "xyz2", "expr", "loopy", "bits", "maths", "hoisting", "demangle", "lua", "moreLabels", "notComps", "tricky", "asmy"] From b5fbaa0114212a9f9837958d6b9e62468b38b54f Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Fri, 21 Jun 2013 16:54:51 -0700 Subject: [PATCH 23/69] do not run addition optimization pass in asm; it just adds overhead, and minorly increases code size by changing addition order against the grain of operator precedence --- tools/js-optimizer.js | 74 ++++++++++++++++++++++--------------------- 1 file changed, 38 insertions(+), 36 deletions(-) diff --git a/tools/js-optimizer.js b/tools/js-optimizer.js index 8e9e229e73ffa..ae72437b69113 100644 --- a/tools/js-optimizer.js +++ b/tools/js-optimizer.js @@ -2626,48 +2626,50 @@ function eliminate(ast, memSafe) { } }); - // A class for optimizing expressions. We know that it is legitimate to collapse - // 5+7 in the generated code, as it will always be numerical, for example. XXX do we need this? here? - function ExpressionOptimizer(node) { - this.node = node; - - this.run = function() { - traverse(this.node, function(node, type) { - if (type === 'binary' && node[1] == '+') { - var names = []; - var num = 0; - var has_num = false; - var fail = false; - traverse(node, function(subNode, subType) { - if (subType === 'binary') { - if (subNode[1] != '+') { + if (!asm) { // TODO: deprecate in non-asm too + // A class for optimizing expressions. We know that it is legitimate to collapse + // 5+7 in the generated code, as it will always be numerical, for example. XXX do we need this? here? + function ExpressionOptimizer(node) { + this.node = node; + + this.run = function() { + traverse(this.node, function(node, type) { + if (type === 'binary' && node[1] == '+') { + var names = []; + var num = 0; + var has_num = false; + var fail = false; + traverse(node, function(subNode, subType) { + if (subType === 'binary') { + if (subNode[1] != '+') { + fail = true; + return false; + } + } else if (subType === 'name') { + names.push(subNode[1]); + return; + } else if (subType === 'num') { + num += subNode[1]; + has_num = true; + return; + } else { fail = true; return false; } - } else if (subType === 'name') { - names.push(subNode[1]); - return; - } else if (subType === 'num') { - num += subNode[1]; - has_num = true; - return; - } else { - fail = true; - return false; - } - }); - if (!fail && has_num) { - var ret = ['num', num]; - for (var i = 0; i < names.length; i++) { - ret = ['binary', '+', ['name', names[i]], ret]; + }); + if (!fail && has_num) { + var ret = ['num', num]; + for (var i = 0; i < names.length; i++) { + ret = ['binary', '+', ['name', names[i]], ret]; + } + return ret; } - return ret; } - } - }); - }; + }); + }; + } + new ExpressionOptimizer(ast).run(); } - new ExpressionOptimizer(ast).run(); } function eliminateMemSafe(ast) { From cfe4eb5b4f1dd020276a2bd7a4886e172e76b48b Mon Sep 17 00:00:00 2001 From: Jez Ng Date: Thu, 20 Jun 2013 14:39:42 -0700 Subject: [PATCH 24/69] Source maps should only be activated via the `--map` flag. --- emcc | 19 +++++++++++-------- tests/runner.py | 4 ++-- tools/js_optimizer.py | 18 ++++++++++-------- 3 files changed, 23 insertions(+), 18 deletions(-) diff --git a/emcc b/emcc index 2b2048e3fdf49..48ecd60410221 100755 --- a/emcc +++ b/emcc @@ -710,6 +710,7 @@ try: save_bc = False memory_init_file = False use_preload_cache = False + make_source_map = False if use_cxx: default_cxx_std = '-std=c++03' # Enforce a consistent C++ standard when compiling .cpp files, if user does not specify one on the cmdline. @@ -780,6 +781,9 @@ try: elif newargs[i] == '-g': keep_llvm_debug = True keep_js_debug = True + elif newargs[i] == '--map': + make_source_map = True + newargs[i] = '-g' # we'll need this to get LLVM debug info elif newargs[i] == '--bind': bind = True newargs[i] = '' @@ -869,6 +873,8 @@ try: if llvm_opts is None: llvm_opts = LLVM_OPT_LEVEL[opt_level] if llvm_lto is None: llvm_lto = opt_level >= 3 if opt_level <= 0: keep_llvm_debug = keep_js_debug = True # always keep debug in -O0 + if opt_level > 0: keep_llvm_debug = False # JS optimizer wipes out llvm debug info + if make_source_map: keep_llvm_debug = True; keep_js_debug = True if closure is None and opt_level == 3: closure = True if DEBUG: start_time = time.time() # done after parsing arguments, which might affect debug state @@ -1498,8 +1504,7 @@ try: if shared.Settings.ASM_JS: js_optimizer_queue = ['asm'] + js_optimizer_queue logging.debug('applying js optimization passes: %s', js_optimizer_queue) - final = shared.Building.js_optimizer(final, js_optimizer_queue, jcache, - keep_llvm_debug and keep_js_debug) + final = shared.Building.js_optimizer(final, js_optimizer_queue, jcache, make_source_map) js_transform_tempfiles.append(final) if DEBUG: save_intermediate('js_opts') else: @@ -1508,8 +1513,7 @@ try: if shared.Settings.ASM_JS: passes = ['asm'] + passes logging.debug('applying js optimization pass: %s', passes) - final = shared.Building.js_optimizer(final, passes, jcache, - keep_llvm_debug and keep_js_debug) + final = shared.Building.js_optimizer(final, passes, jcache, make_source_map) js_transform_tempfiles.append(final) save_intermediate(name) js_optimizer_queue = [] @@ -1519,8 +1523,7 @@ try: if DEBUG == '2': # Clean up the syntax a bit - final = shared.Building.js_optimizer(final, [], jcache, - keep_llvm_debug and keep_js_debug) + final = shared.Building.js_optimizer(final, [], jcache, make_source_map) if DEBUG: save_intermediate('pretty') def get_eliminate(): @@ -1608,7 +1611,7 @@ try: shell = open(shell_path).read() html = open(target, 'w') if not Compression.on: - if keep_llvm_debug and keep_js_debug: + if make_source_map: match = re.match('.*?]*>{{{ SCRIPT_CODE }}}', shell, re.DOTALL) if match is None: @@ -1684,7 +1687,7 @@ try: from tools.split import split_javascript_file split_javascript_file(final, unsuffixed(target), split_js_file) else: - if keep_llvm_debug and keep_js_debug: generate_source_map(target) + if make_source_map: generate_source_map(target) # copy final JS to output shutil.move(final, target) diff --git a/tests/runner.py b/tests/runner.py index 1697294d910dd..156e2bdaaa78e 100755 --- a/tests/runner.py +++ b/tests/runner.py @@ -9586,7 +9586,7 @@ def process(filename): def test_source_map(self): if Settings.USE_TYPED_ARRAYS != 2: return self.skip("doesn't pass without typed arrays") - if '-g' not in Building.COMPILER_TEST_OPTS: Building.COMPILER_TEST_OPTS.append('-g') + if '--map' not in Building.COMPILER_TEST_OPTS: Building.COMPILER_TEST_OPTS.append('--map') src = ''' #include @@ -11754,7 +11754,7 @@ def test_html_source_map(self): return 0; } ''') - Popen([PYTHON, EMCC, cpp_file, '-o', html_file, '-g']).communicate() + Popen([PYTHON, EMCC, cpp_file, '-o', html_file, '--map']).communicate() webbrowser.open_new('file://' + html_file) print ''' Set the debugger to pause on exceptions diff --git a/tools/js_optimizer.py b/tools/js_optimizer.py index e99c02bedf677..7a29bc8c3fed9 100644 --- a/tools/js_optimizer.py +++ b/tools/js_optimizer.py @@ -57,7 +57,7 @@ def __init__(self, js, js_engine): if curr not in INVALID_3: self.names.append(curr) #print >> sys.stderr, self.names - def minify_shell(self, shell, compress, debug=False): + def minify_shell(self, shell, compress, source_map=False): #print >> sys.stderr, "MINIFY SHELL 1111111111", shell, "\n222222222222222" # Run through js-optimizer.js to find and minify the global symbols # We send it the globals, which it parses at the proper time. JS decides how @@ -80,7 +80,7 @@ def minify_shell(self, shell, compress, debug=False): output = subprocess.Popen(self.js_engine + [JS_OPTIMIZER, temp_file, 'minifyGlobals', 'noPrintMetadata'] + (['compress'] if compress else []) + - (['--debug'] if debug else []), + (['--debug'] if source_map else []), stdout=subprocess.PIPE).communicate()[0] assert len(output) > 0 and not output.startswith('Assertion failed'), 'Error in js optimizer: ' + output #print >> sys.stderr, "minified SHELL 3333333333333333", output, "\n44444444444444444444" @@ -107,7 +107,7 @@ def run_on_chunk(command): if DEBUG and not shared.WINDOWS: print >> sys.stderr, '.' # Skip debug progress indicator on Windows, since it doesn't buffer well with multiple threads printing to console. return filename -def run_on_js(filename, passes, js_engine, jcache, debug=False): +def run_on_js(filename, passes, js_engine, jcache, source_map=False): if isinstance(jcache, bool) and jcache: jcache = shared.JCache if jcache: shared.JCache.ensure() @@ -175,7 +175,7 @@ def process(line): js = js[start_funcs + len(start_funcs_marker):end_funcs] minifier = Minifier(js, js_engine) - asm_shell_pre, asm_shell_post = minifier.minify_shell(asm_shell, 'compress' in passes, debug).split('EMSCRIPTEN_FUNCS();'); + asm_shell_pre, asm_shell_post = minifier.minify_shell(asm_shell, 'compress' in passes, source_map).split('EMSCRIPTEN_FUNCS();'); asm_shell_post = asm_shell_post.replace('});', '})'); pre += asm_shell_pre + '\n' + start_funcs_marker post = end_funcs_marker + asm_shell_post + post @@ -211,7 +211,9 @@ def process(line): total_size = len(js) js = None - cores = int(os.environ.get('EMCC_CORES') or multiprocessing.cpu_count()) + # if we are making source maps, we want our debug numbering to start from the + # top of the file, so avoid breaking the JS into chunks + cores = 1 if source_map else int(os.environ.get('EMCC_CORES') or multiprocessing.cpu_count()) intended_num_chunks = int(round(cores * NUM_CHUNKS_PER_CORE)) chunk_size = min(MAX_CHUNK_SIZE, max(MIN_CHUNK_SIZE, total_size / intended_num_chunks)) @@ -253,7 +255,7 @@ def write_chunk(chunk, i): # XXX Use '--nocrankshaft' to disable crankshaft to work around v8 bug 1895, needed for older v8/node (node 0.6.8+ should be ok) commands = map(lambda filename: js_engine + [JS_OPTIMIZER, filename, 'noPrintMetadata'] + - (['--debug'] if debug else []) + passes, filenames) + (['--debug'] if source_map else []) + passes, filenames) #print [' '.join(command) for command in commands] cores = min(cores, filenames) @@ -321,6 +323,6 @@ def write_chunk(chunk, i): return filename -def run(filename, passes, js_engine, jcache, debug=False): - return temp_files.run_and_clean(lambda: run_on_js(filename, passes, js_engine, jcache, debug)) +def run(filename, passes, js_engine, jcache, source_map=False): + return temp_files.run_and_clean(lambda: run_on_js(filename, passes, js_engine, jcache, source_map)) From 5459b3543fdc8eb01806e6fb03b05d19bd2815e9 Mon Sep 17 00:00:00 2001 From: Jez Ng Date: Thu, 20 Jun 2013 14:46:40 -0700 Subject: [PATCH 25/69] Fix line numbering for invoke instructions. Line numbering of exceptions now work (better) in optimized mode. --- src/jsifier.js | 4 ++- tests/runner.py | 34 +++++++++++++++++++ .../node_modules/uglify-js/lib/process.js | 14 +++++++- 3 files changed, 50 insertions(+), 2 deletions(-) diff --git a/src/jsifier.js b/src/jsifier.js index 88b9d9f6fc7f9..7264b0e9dae50 100644 --- a/src/jsifier.js +++ b/src/jsifier.js @@ -693,7 +693,9 @@ function JSify(data, functionsOnly, givenFunctions) { } } i++; - return JS + (Debugging.on ? Debugging.getComment(line.lineNum) : ''); + // invoke instructions span two lines, and the debug info is located + // on the second line, hence the +1 + return JS + (Debugging.on ? Debugging.getComment(line.lineNum + (line.intertype === 'invoke' ? 1 : 0)) : ''); }) .join('\n') .split('\n') // some lines include line breaks diff --git a/tests/runner.py b/tests/runner.py index 156e2bdaaa78e..479f4824de58a 100755 --- a/tests/runner.py +++ b/tests/runner.py @@ -9625,6 +9625,40 @@ def post(filename): self.build(src, dirname, src_filename, post_build=(None,post)) + def test_exception_source_map(self): + if Settings.USE_TYPED_ARRAYS != 2: return self.skip("doesn't pass without typed arrays") + if '--map' not in Building.COMPILER_TEST_OPTS: Building.COMPILER_TEST_OPTS.append('--map') + + src = ''' + #include + + __attribute__((noinline)) void foo(int i) { + if (i < 10) throw i; // line 5 + } + + int main() { + int i; + scanf("%d", &i); + foo(i); + return 0; + } + ''' + + def post(filename): + import json + map_filename = filename + '.map' + mappings = json.loads(jsrun.run_js( + path_from_root('tools', 'source-maps', 'sourcemap2json.js'), + tools.shared.NODE_JS, [map_filename])) + with open(filename) as f: lines = f.readlines() + for m in mappings: + if m['originalLine'] == 5 and '__cxa_throw' in lines[m['generatedLine']]: + return + assert False, 'Must label throw statements with line numbers' + + dirname = self.get_dir() + self.build(src, dirname, os.path.join(dirname, 'src.cpp'), post_build=(None, post)) + def test_linespecific(self): if Settings.ASM_JS: return self.skip('asm always has corrections on') diff --git a/tools/eliminator/node_modules/uglify-js/lib/process.js b/tools/eliminator/node_modules/uglify-js/lib/process.js index 39ccde37ac38d..88ce490f820f5 100644 --- a/tools/eliminator/node_modules/uglify-js/lib/process.js +++ b/tools/eliminator/node_modules/uglify-js/lib/process.js @@ -412,7 +412,19 @@ function gen_code(ast, options) { }; function add_commas(a) { - return a.join("," + space); + var str = a.join("," + space); + if (options.debug) { + // if a line contains more than one comma-separated segment, assign it the + // original line number of the first NodeWithLine segment + for (var i = 0, l = a.length; i < l; i ++) { + var v = a[i]; + if (v instanceof NodeWithLine) { + v.str = str; + return v + } + } + } + return str; }; function parenthesize(expr) { From 99fa57e08e92821e1f6f4dd230e80970ad366250 Mon Sep 17 00:00:00 2001 From: Jez Ng Date: Thu, 20 Jun 2013 16:36:42 -0700 Subject: [PATCH 26/69] Make test_debug actually fail when things go wrong. --- emcc | 2 +- tests/runner.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/emcc b/emcc index 48ecd60410221..650ba9e9f8e22 100755 --- a/emcc +++ b/emcc @@ -1490,7 +1490,7 @@ try: final += '.tr.js' posix = True if not shared.WINDOWS else False logging.debug('applying transform: %s' % js_transform) - execute(shlex.split(js_transform, posix=posix) + [os.path.abspath(final)]) + subprocess.check_call(shlex.split(js_transform, posix=posix) + [os.path.abspath(final)]) if DEBUG: save_intermediate('transformed') js_transform_tempfiles = [final] diff --git a/tests/runner.py b/tests/runner.py index 479f4824de58a..10478b6ad5dff 100755 --- a/tests/runner.py +++ b/tests/runner.py @@ -9582,7 +9582,7 @@ def process(filename): self.do_run(src, '*nothingatall*', post_build=post) except Exception, e: # This test *should* fail - assert 'Assertion failed' in str(e), str(e) + assert 'Assertion failed: x < 15' in str(e), str(e) def test_source_map(self): if Settings.USE_TYPED_ARRAYS != 2: return self.skip("doesn't pass without typed arrays") From 7212198353b83e2e8b638a8755708cc14d39aee6 Mon Sep 17 00:00:00 2001 From: Jez Ng Date: Fri, 21 Jun 2013 01:41:29 -0700 Subject: [PATCH 27/69] Make optimizer handle both strings and string-like type objects. NodeWithToken is a string-like type produced by the parser during 'embed tokens' mode, which allows us to track line numbers. --- .../node_modules/uglify-js/lib/parse-js.js | 25 +++++++++++++++++-- tools/js-optimizer.js | 21 +++++++++------- 2 files changed, 35 insertions(+), 11 deletions(-) diff --git a/tools/eliminator/node_modules/uglify-js/lib/parse-js.js b/tools/eliminator/node_modules/uglify-js/lib/parse-js.js index a89163c69ba86..2dc2ef70721d0 100644 --- a/tools/eliminator/node_modules/uglify-js/lib/parse-js.js +++ b/tools/eliminator/node_modules/uglify-js/lib/parse-js.js @@ -679,7 +679,28 @@ function NodeWithToken(str, start, end) { this.end = end; }; -NodeWithToken.prototype.toString = function() { return this.name; }; +NodeWithToken.prototype = { + get length() { + return this.name.length; + }, + set length(v) { + return this.name.length = v; + }, + replace: function() { return this.name.replace.apply(this.name, arguments); }, + concat: function() { return this.name.concat.apply(this.name, arguments); }, + indexOf: function() { return this.name.indexOf.apply(this.name, arguments); }, + lastIndexOf: function() { return this.name.lastIndexOf.apply(this.name, arguments); }, + lastIndexOf: function() { return this.name.lastIndexOf.apply(this.name, arguments); }, + match: function() { return this.name.match.apply(this.name, arguments); }, + search: function() { return this.name.search.apply(this.name, arguments); }, + slice: function() { return this.name.slice.apply(this.name, arguments); }, + split: function() { return this.name.split.apply(this.name, arguments); }, + substr: function() { return this.name.substr.apply(this.name, arguments); }, + substring: function() { return this.name.substring.apply(this.name, arguments); }, + toString: function() { return this.name; }, + toJSON: function() { return this.name; }, + valueOf: function() { return this.name; }, +}; function parse($TEXT, exigent_mode, embed_tokens) { @@ -1314,7 +1335,7 @@ function characters(str) { function member(name, array) { for (var i = array.length; --i >= 0;) - if (array[i] === name) + if (array[i] == name) return true; return false; }; diff --git a/tools/js-optimizer.js b/tools/js-optimizer.js index f86bb0d6e4604..0709251387d86 100644 --- a/tools/js-optimizer.js +++ b/tools/js-optimizer.js @@ -164,7 +164,8 @@ function astToSrc(ast, compress) { function traverseChildren(node, traverse, pre, post, stack) { for (var i = 0; i < node.length; i++) { var subnode = node[i]; - if (typeof subnode == 'object' && subnode && subnode.length) { + if (typeof subnode == 'object' && subnode && subnode.length && + typeof subnode.valueOf() !== 'string') { var subresult = traverse(subnode, pre, post, stack); if (subresult == true) return true; if (subresult !== null && typeof subresult == 'object') node[i] = subresult; @@ -188,7 +189,9 @@ function traverseChildren(node, traverse, pre, post, stack) { // was stopped, true. Otherwise undefined. function traverse(node, pre, post, stack) { var type = node[0], result, len; - var relevant = typeof type == 'string'; + // valueOf() ensures that NodeWithToken (produced by uglify's parser during + // 'embed tokens' mode) gets marked as 'relevant' + var relevant = type && typeof type.valueOf() == 'string'; if (relevant) { if (stack) len = stack.length; var result = pre(node, type, stack); @@ -2006,7 +2009,7 @@ function eliminate(ast, memSafe) { // examine body and note locals var hasSwitch = false; traverse(func, function(node, type) { - if (type === 'var') { + if (type == 'var') { var node1 = node[1]; for (var i = 0; i < node1.length; i++) { var node1i = node1[i]; @@ -2020,7 +2023,7 @@ function eliminate(ast, memSafe) { if (!uses[name]) uses[name] = 0; locals[name] = true; } - } else if (type === 'name') { + } else if (type == 'name') { var name = node[1]; if (!uses[name]) uses[name] = 0; uses[name]++; @@ -2477,7 +2480,7 @@ function eliminate(ast, memSafe) { // clean up vars, and loop variable elimination traverse(func, function(node, type) { // pre - if (type === 'var') { + if (type == 'var') { node[1] = node[1].filter(function(pair) { return !varsToRemove[pair[0]] }); if (node[1].length == 0) { // wipe out an empty |var;| @@ -2599,21 +2602,21 @@ function eliminate(ast, memSafe) { this.run = function() { traverse(this.node, function(node, type) { - if (type === 'binary' && node[1] == '+') { + if (type == 'binary' && node[1] == '+') { var names = []; var num = 0; var has_num = false; var fail = false; traverse(node, function(subNode, subType) { - if (subType === 'binary') { + if (subType == 'binary') { if (subNode[1] != '+') { fail = true; return false; } - } else if (subType === 'name') { + } else if (subType == 'name') { names.push(subNode[1]); return; - } else if (subType === 'num') { + } else if (subType == 'num') { num += subNode[1]; has_num = true; return; From 4eef4beff61d4efae4e372e7f4ee66090f9bcef5 Mon Sep 17 00:00:00 2001 From: Jez Ng Date: Fri, 21 Jun 2013 05:55:10 -0700 Subject: [PATCH 28/69] Put uglify back the way it was. Makes for an easier-to-review pull request. --- .../node_modules/uglify-js/lib/process.js | 2636 ++++++++++++----- 1 file changed, 1856 insertions(+), 780 deletions(-) diff --git a/tools/eliminator/node_modules/uglify-js/lib/process.js b/tools/eliminator/node_modules/uglify-js/lib/process.js index 88ce490f820f5..da38caa7363aa 100644 --- a/tools/eliminator/node_modules/uglify-js/lib/process.js +++ b/tools/eliminator/node_modules/uglify-js/lib/process.js @@ -1,6 +1,6 @@ /*********************************************************************** - A JavaScript tokenizer / parser / beautifier. + A JavaScript tokenizer / parser / beautifier / compressor. This version is suitable for Node.js. With minimal changes (the exports stuff) it should work on any JS platform. @@ -10,6 +10,12 @@ Exported functions: + - ast_mangle(ast, options) -- mangles the variable/function names + in the AST. Returns an AST. + + - ast_squeeze(ast) -- employs various optimizations to make the + final generated code even smaller. Returns an AST. + - gen_code(ast, options) -- generates JS code from the AST. Pass true (or an object, see the code for some options) as second argument to get "pretty" (indented) code. @@ -59,8 +65,8 @@ var jsp = require("./parse-js"), OPERATORS = jsp.OPERATORS; function NodeWithLine(str, line) { - this.str = str; - this.line = line; + this.str = str; + this.line = line; } NodeWithLine.prototype = new String(); @@ -74,809 +80,1871 @@ String.prototype.lineComment = function() { return ""; } /* -----[ helper for AST traversal ]----- */ function ast_walker() { - function _vardefs(defs) { - return [ this[0], MAP(defs, function(def){ - var a = [ def[0] ]; - if (def.length > 1) - a[1] = walk(def[1]); - return a; - }) ]; - }; - function _block(statements) { - var out = [ this[0] ]; - if (statements != null) - out.push(MAP(statements, walk)); - return out; - }; - var walkers = { - "string": function(str) { - return [ this[0], str ]; - }, - "num": function(num) { - return [ this[0], num ]; - }, - "name": function(name) { - return [ this[0], name ]; - }, - "toplevel": function(statements) { - return [ this[0], MAP(statements, walk) ]; - }, - "block": _block, - "splice": _block, - "var": _vardefs, - "const": _vardefs, - "try": function(t, c, f) { - return [ - this[0], - MAP(t, walk), - c != null ? [ c[0], MAP(c[1], walk) ] : null, - f != null ? MAP(f, walk) : null - ]; - }, - "throw": function(expr) { - return [ this[0], walk(expr) ]; - }, - "new": function(ctor, args) { - return [ this[0], walk(ctor), MAP(args, walk) ]; - }, - "switch": function(expr, body) { - return [ this[0], walk(expr), MAP(body, function(branch){ - return [ branch[0] ? walk(branch[0]) : null, - MAP(branch[1], walk) ]; - }) ]; - }, - "break": function(label) { - return [ this[0], label ]; - }, - "continue": function(label) { - return [ this[0], label ]; - }, - "conditional": function(cond, t, e) { - return [ this[0], walk(cond), walk(t), walk(e) ]; - }, - "assign": function(op, lvalue, rvalue) { - return [ this[0], op, walk(lvalue), walk(rvalue) ]; - }, - "dot": function(expr) { - return [ this[0], walk(expr) ].concat(slice(arguments, 1)); - }, - "call": function(expr, args) { - return [ this[0], walk(expr), MAP(args, walk) ]; - }, - "function": function(name, args, body) { - return [ this[0], name, args.slice(), MAP(body, walk) ]; - }, - "defun": function(name, args, body) { - return [ this[0], name, args.slice(), MAP(body, walk) ]; - }, - "if": function(conditional, t, e) { - return [ this[0], walk(conditional), walk(t), walk(e) ]; - }, - "for": function(init, cond, step, block) { - return [ this[0], walk(init), walk(cond), walk(step), walk(block) ]; - }, - "for-in": function(vvar, key, hash, block) { - return [ this[0], walk(vvar), walk(key), walk(hash), walk(block) ]; - }, - "while": function(cond, block) { - return [ this[0], walk(cond), walk(block) ]; - }, - "do": function(cond, block) { - return [ this[0], walk(cond), walk(block) ]; - }, - "return": function(expr) { - return [ this[0], walk(expr) ]; - }, - "binary": function(op, left, right) { - return [ this[0], op, walk(left), walk(right) ]; - }, - "unary-prefix": function(op, expr) { - return [ this[0], op, walk(expr) ]; - }, - "unary-postfix": function(op, expr) { - return [ this[0], op, walk(expr) ]; - }, - "sub": function(expr, subscript) { - return [ this[0], walk(expr), walk(subscript) ]; - }, - "object": function(props) { - return [ this[0], MAP(props, function(p){ - return p.length == 2 - ? [ p[0], walk(p[1]) ] - : [ p[0], walk(p[1]), p[2] ]; // get/set-ter - }) ]; - }, - "regexp": function(rx, mods) { - return [ this[0], rx, mods ]; - }, - "array": function(elements) { - return [ this[0], MAP(elements, walk) ]; - }, - "stat": function(stat) { - return [ this[0], walk(stat) ]; - }, - "seq": function() { - return [ this[0] ].concat(MAP(slice(arguments), walk)); - }, - "label": function(name, block) { - return [ this[0], name, walk(block) ]; - }, - "with": function(expr, block) { - return [ this[0], walk(expr), walk(block) ]; - }, - "atom": function(name) { - return [ this[0], name ]; - } - }; - - var user = {}; - var stack = []; - function walk(ast) { - if (ast == null) - return null; - try { - stack.push(ast); - var type = ast[0]; - var gen = user[type]; - if (gen) { - var ret = gen.apply(ast, ast.slice(1)); - if (ret != null) - return ret; - } - gen = walkers[type]; - return gen.apply(ast, ast.slice(1)); - } finally { - stack.pop(); - } - }; - - function with_walkers(walkers, cont){ - var save = {}, i; - for (i in walkers) if (HOP(walkers, i)) { - save[i] = user[i]; - user[i] = walkers[i]; - } - var ret = cont(); - for (i in save) if (HOP(save, i)) { - if (!save[i]) delete user[i]; - else user[i] = save[i]; - } - return ret; - }; - - return { - walk: walk, - with_walkers: with_walkers, - parent: function() { - return stack[stack.length - 2]; // last one is current node - }, - stack: function() { - return stack; - } - }; + function _vardefs(defs) { + return [ this[0], MAP(defs, function(def){ + var a = [ def[0] ]; + if (def.length > 1) + a[1] = walk(def[1]); + return a; + }) ]; + }; + function _block(statements) { + var out = [ this[0] ]; + if (statements != null) + out.push(MAP(statements, walk)); + return out; + }; + var walkers = { + "string": function(str) { + return [ this[0], str ]; + }, + "num": function(num) { + return [ this[0], num ]; + }, + "name": function(name) { + return [ this[0], name ]; + }, + "toplevel": function(statements) { + return [ this[0], MAP(statements, walk) ]; + }, + "block": _block, + "splice": _block, + "var": _vardefs, + "const": _vardefs, + "try": function(t, c, f) { + return [ + this[0], + MAP(t, walk), + c != null ? [ c[0], MAP(c[1], walk) ] : null, + f != null ? MAP(f, walk) : null + ]; + }, + "throw": function(expr) { + return [ this[0], walk(expr) ]; + }, + "new": function(ctor, args) { + return [ this[0], walk(ctor), MAP(args, walk) ]; + }, + "switch": function(expr, body) { + return [ this[0], walk(expr), MAP(body, function(branch){ + return [ branch[0] ? walk(branch[0]) : null, + MAP(branch[1], walk) ]; + }) ]; + }, + "break": function(label) { + return [ this[0], label ]; + }, + "continue": function(label) { + return [ this[0], label ]; + }, + "conditional": function(cond, t, e) { + return [ this[0], walk(cond), walk(t), walk(e) ]; + }, + "assign": function(op, lvalue, rvalue) { + return [ this[0], op, walk(lvalue), walk(rvalue) ]; + }, + "dot": function(expr) { + return [ this[0], walk(expr) ].concat(slice(arguments, 1)); + }, + "call": function(expr, args) { + return [ this[0], walk(expr), MAP(args, walk) ]; + }, + "function": function(name, args, body) { + return [ this[0], name, args.slice(), MAP(body, walk) ]; + }, + "defun": function(name, args, body) { + return [ this[0], name, args.slice(), MAP(body, walk) ]; + }, + "if": function(conditional, t, e) { + return [ this[0], walk(conditional), walk(t), walk(e) ]; + }, + "for": function(init, cond, step, block) { + return [ this[0], walk(init), walk(cond), walk(step), walk(block) ]; + }, + "for-in": function(vvar, key, hash, block) { + return [ this[0], walk(vvar), walk(key), walk(hash), walk(block) ]; + }, + "while": function(cond, block) { + return [ this[0], walk(cond), walk(block) ]; + }, + "do": function(cond, block) { + return [ this[0], walk(cond), walk(block) ]; + }, + "return": function(expr) { + return [ this[0], walk(expr) ]; + }, + "binary": function(op, left, right) { + return [ this[0], op, walk(left), walk(right) ]; + }, + "unary-prefix": function(op, expr) { + return [ this[0], op, walk(expr) ]; + }, + "unary-postfix": function(op, expr) { + return [ this[0], op, walk(expr) ]; + }, + "sub": function(expr, subscript) { + return [ this[0], walk(expr), walk(subscript) ]; + }, + "object": function(props) { + return [ this[0], MAP(props, function(p){ + return p.length == 2 + ? [ p[0], walk(p[1]) ] + : [ p[0], walk(p[1]), p[2] ]; // get/set-ter + }) ]; + }, + "regexp": function(rx, mods) { + return [ this[0], rx, mods ]; + }, + "array": function(elements) { + return [ this[0], MAP(elements, walk) ]; + }, + "stat": function(stat) { + return [ this[0], walk(stat) ]; + }, + "seq": function() { + return [ this[0] ].concat(MAP(slice(arguments), walk)); + }, + "label": function(name, block) { + return [ this[0], name, walk(block) ]; + }, + "with": function(expr, block) { + return [ this[0], walk(expr), walk(block) ]; + }, + "atom": function(name) { + return [ this[0], name ]; + } + }; + + var user = {}; + var stack = []; + function walk(ast) { + if (ast == null) + return null; + try { + stack.push(ast); + var type = ast[0]; + var gen = user[type]; + if (gen) { + var ret = gen.apply(ast, ast.slice(1)); + if (ret != null) + return ret; + } + gen = walkers[type]; + return gen.apply(ast, ast.slice(1)); + } finally { + stack.pop(); + } + }; + + function with_walkers(walkers, cont){ + var save = {}, i; + for (i in walkers) if (HOP(walkers, i)) { + save[i] = user[i]; + user[i] = walkers[i]; + } + var ret = cont(); + for (i in save) if (HOP(save, i)) { + if (!save[i]) delete user[i]; + else user[i] = save[i]; + } + return ret; + }; + + return { + walk: walk, + with_walkers: with_walkers, + parent: function() { + return stack[stack.length - 2]; // last one is current node + }, + stack: function() { + return stack; + } + }; +}; + +/* -----[ Scope and mangling ]----- */ + +function Scope(parent) { + this.names = {}; // names defined in this scope + this.mangled = {}; // mangled names (orig.name => mangled) + this.rev_mangled = {}; // reverse lookup (mangled => orig.name) + this.cname = -1; // current mangled name + this.refs = {}; // names referenced from this scope + this.uses_with = false; // will become TRUE if with() is detected in this or any subscopes + this.uses_eval = false; // will become TRUE if eval() is detected in this or any subscopes + this.parent = parent; // parent scope + this.children = []; // sub-scopes + if (parent) { + this.level = parent.level + 1; + parent.children.push(this); + } else { + this.level = 0; + } +}; + +var base54 = (function(){ + var DIGITS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_"; + return function(num) { + var ret = ""; + do { + ret = DIGITS.charAt(num % 54) + ret; + num = Math.floor(num / 54); + } while (num > 0); + return ret; + }; +})(); + +Scope.prototype = { + has: function(name) { + for (var s = this; s; s = s.parent) + if (HOP(s.names, name)) + return s; + }, + has_mangled: function(mname) { + for (var s = this; s; s = s.parent) + if (HOP(s.rev_mangled, mname)) + return s; + }, + toJSON: function() { + return { + names: this.names, + uses_eval: this.uses_eval, + uses_with: this.uses_with + }; + }, + + next_mangled: function() { + // we must be careful that the new mangled name: + // + // 1. doesn't shadow a mangled name from a parent + // scope, unless we don't reference the original + // name from this scope OR from any sub-scopes! + // This will get slow. + // + // 2. doesn't shadow an original name from a parent + // scope, in the event that the name is not mangled + // in the parent scope and we reference that name + // here OR IN ANY SUBSCOPES! + // + // 3. doesn't shadow a name that is referenced but not + // defined (possibly global defined elsewhere). + for (;;) { + var m = base54(++this.cname), prior; + + // case 1. + prior = this.has_mangled(m); + if (prior && this.refs[prior.rev_mangled[m]] === prior) + continue; + + // case 2. + prior = this.has(m); + if (prior && prior !== this && this.refs[m] === prior && !prior.has_mangled(m)) + continue; + + // case 3. + if (HOP(this.refs, m) && this.refs[m] == null) + continue; + + // I got "do" once. :-/ + if (!is_identifier(m)) + continue; + + return m; + } + }, + set_mangle: function(name, m) { + this.rev_mangled[m] = name; + return this.mangled[name] = m; + }, + get_mangled: function(name, newMangle) { + if (this.uses_eval || this.uses_with) return name; // no mangle if eval or with is in use + var s = this.has(name); + if (!s) return name; // not in visible scope, no mangle + if (HOP(s.mangled, name)) return s.mangled[name]; // already mangled in this scope + if (!newMangle) return name; // not found and no mangling requested + return s.set_mangle(name, s.next_mangled()); + }, + references: function(name) { + return name && !this.parent || this.uses_with || this.uses_eval || this.refs[name]; + }, + define: function(name, type) { + if (name != null) { + if (type == "var" || !HOP(this.names, name)) + this.names[name] = type || "var"; + return name; + } + } +}; + +function ast_add_scope(ast) { + + var current_scope = null; + var w = ast_walker(), walk = w.walk; + var having_eval = []; + + function with_new_scope(cont) { + current_scope = new Scope(current_scope); + var ret = current_scope.body = cont(); + ret.scope = current_scope; + current_scope = current_scope.parent; + return ret; + }; + + function define(name, type) { + return current_scope.define(name, type); + }; + + function reference(name) { + current_scope.refs[name] = true; + }; + + function _lambda(name, args, body) { + var is_defun = this[0] == "defun"; + return [ this[0], is_defun ? define(name, "defun") : name, args, with_new_scope(function(){ + if (!is_defun) define(name, "lambda"); + MAP(args, function(name){ define(name, "arg") }); + return MAP(body, walk); + })]; + }; + + function _vardefs(type) { + return function(defs) { + MAP(defs, function(d){ + define(d[0], type); + if (d[1]) reference(d[0]); + }); + }; + }; + + return with_new_scope(function(){ + // process AST + var ret = w.with_walkers({ + "function": _lambda, + "defun": _lambda, + "label": function(name, stat) { define(name, "label") }, + "break": function(label) { if (label) reference(label) }, + "continue": function(label) { if (label) reference(label) }, + "with": function(expr, block) { + for (var s = current_scope; s; s = s.parent) + s.uses_with = true; + }, + "var": _vardefs("var"), + "const": _vardefs("const"), + "try": function(t, c, f) { + if (c != null) return [ + this[0], + MAP(t, walk), + [ define(c[0], "catch"), MAP(c[1], walk) ], + f != null ? MAP(f, walk) : null + ]; + }, + "name": function(name) { + if (name == "eval") + having_eval.push(current_scope); + reference(name); + } + }, function(){ + return walk(ast); + }); + + // the reason why we need an additional pass here is + // that names can be used prior to their definition. + + // scopes where eval was detected and their parents + // are marked with uses_eval, unless they define the + // "eval" name. + MAP(having_eval, function(scope){ + if (!scope.has("eval")) while (scope) { + scope.uses_eval = true; + scope = scope.parent; + } + }); + + // for referenced names it might be useful to know + // their origin scope. current_scope here is the + // toplevel one. + function fixrefs(scope, i) { + // do children first; order shouldn't matter + for (i = scope.children.length; --i >= 0;) + fixrefs(scope.children[i]); + for (i in scope.refs) if (HOP(scope.refs, i)) { + // find origin scope and propagate the reference to origin + for (var origin = scope.has(i), s = scope; s; s = s.parent) { + s.refs[i] = origin; + if (s === origin) break; + } + } + }; + fixrefs(current_scope); + + return ret; + }); + +}; + +/* -----[ mangle names ]----- */ + +function ast_mangle(ast, options) { + var w = ast_walker(), walk = w.walk, scope; + options = options || {}; + + function get_mangled(name, newMangle) { + if (!options.toplevel && !scope.parent) return name; // don't mangle toplevel + if (options.except && member(name, options.except)) + return name; + return scope.get_mangled(name, newMangle); + }; + + function get_define(name) { + if (options.defines) { + // we always lookup a defined symbol for the current scope FIRST, so declared + // vars trump a DEFINE symbol, but if no such var is found, then match a DEFINE value + if (!scope.has(name)) { + if (HOP(options.defines, name)) { + return options.defines[name]; + } + } + return null; + } + }; + + function _lambda(name, args, body) { + var is_defun = this[0] == "defun", extra; + if (name) { + if (is_defun) name = get_mangled(name); + else { + extra = {}; + if (!(scope.uses_eval || scope.uses_with)) + name = extra[name] = scope.next_mangled(); + else + extra[name] = name; + } + } + body = with_scope(body.scope, function(){ + args = MAP(args, function(name){ return get_mangled(name) }); + return MAP(body, walk); + }, extra); + return [ this[0], name, args, body ]; + }; + + function with_scope(s, cont, extra) { + var _scope = scope; + scope = s; + if (extra) for (var i in extra) if (HOP(extra, i)) { + s.set_mangle(i, extra[i]); + } + for (var i in s.names) if (HOP(s.names, i)) { + get_mangled(i, true); + } + var ret = cont(); + ret.scope = s; + scope = _scope; + return ret; + }; + + function _vardefs(defs) { + return [ this[0], MAP(defs, function(d){ + return [ get_mangled(d[0]), walk(d[1]) ]; + }) ]; + }; + + return w.with_walkers({ + "function": _lambda, + "defun": function() { + // move function declarations to the top when + // they are not in some block. + var ast = _lambda.apply(this, arguments); + switch (w.parent()[0]) { + case "toplevel": + case "function": + case "defun": + return MAP.at_top(ast); + } + return ast; + }, + "label": function(label, stat) { return [ this[0], get_mangled(label), walk(stat) ] }, + "break": function(label) { if (label) return [ this[0], get_mangled(label) ] }, + "continue": function(label) { if (label) return [ this[0], get_mangled(label) ] }, + "var": _vardefs, + "const": _vardefs, + "name": function(name) { + return get_define(name) || [ this[0], get_mangled(name) ]; + }, + "try": function(t, c, f) { + return [ this[0], + MAP(t, walk), + c != null ? [ get_mangled(c[0]), MAP(c[1], walk) ] : null, + f != null ? MAP(f, walk) : null ]; + }, + "toplevel": function(body) { + var self = this; + return with_scope(self.scope, function(){ + return [ self[0], MAP(body, walk) ]; + }); + } + }, function() { + return walk(ast_add_scope(ast)); + }); }; +/* -----[ + - compress foo["bar"] into foo.bar, + - remove block brackets {} where possible + - join consecutive var declarations + - various optimizations for IFs: + - if (cond) foo(); else bar(); ==> cond?foo():bar(); + - if (cond) foo(); ==> cond&&foo(); + - if (foo) return bar(); else return baz(); ==> return foo?bar():baz(); // also for throw + - if (foo) return bar(); else something(); ==> {if(foo)return bar();something()} + ]----- */ + var warn = function(){}; function best_of(ast1, ast2) { - return gen_code(ast1).length > gen_code(ast2[0] == "stat" ? ast2[1] : ast2).length ? ast2 : ast1; + return gen_code(ast1).length > gen_code(ast2[0] == "stat" ? ast2[1] : ast2).length ? ast2 : ast1; }; function last_stat(b) { - if (b[0] == "block" && b[1] && b[1].length > 0) - return b[1][b[1].length - 1]; - return b; + if (b[0] == "block" && b[1] && b[1].length > 0) + return b[1][b[1].length - 1]; + return b; } function aborts(t) { - if (t) switch (last_stat(t)[0]) { - case "return": - case "break": - case "continue": - case "throw": - return true; - } + if (t) switch (last_stat(t)[0]) { + case "return": + case "break": + case "continue": + case "throw": + return true; + } }; function boolean_expr(expr) { - return ((expr[0] == "unary-prefix" - && member(expr[1], [ "!", "delete" ])) || + return ( (expr[0] == "unary-prefix" + && member(expr[1], [ "!", "delete" ])) || - (expr[0] == "binary" - && member(expr[1], [ "in", "instanceof", "==", "!=", "===", "!==", "<", "<=", ">=", ">" ])) || + (expr[0] == "binary" + && member(expr[1], [ "in", "instanceof", "==", "!=", "===", "!==", "<", "<=", ">=", ">" ])) || - (expr[0] == "binary" - && member(expr[1], [ "&&", "||" ]) - && boolean_expr(expr[2]) - && boolean_expr(expr[3])) || + (expr[0] == "binary" + && member(expr[1], [ "&&", "||" ]) + && boolean_expr(expr[2]) + && boolean_expr(expr[3])) || - (expr[0] == "conditional" - && boolean_expr(expr[2]) - && boolean_expr(expr[3])) || + (expr[0] == "conditional" + && boolean_expr(expr[2]) + && boolean_expr(expr[3])) || - (expr[0] == "assign" - && expr[1] === true - && boolean_expr(expr[3])) || + (expr[0] == "assign" + && expr[1] === true + && boolean_expr(expr[3])) || - (expr[0] == "seq" - && boolean_expr(expr[expr.length - 1]))); + (expr[0] == "seq" + && boolean_expr(expr[expr.length - 1])) + ); +}; + +function make_conditional(c, t, e) { + var make_real_conditional = function() { + if (c[0] == "unary-prefix" && c[1] == "!") { + return e ? [ "conditional", c[2], e, t ] : [ "binary", "||", c[2], t ]; + } else { + return e ? [ "conditional", c, t, e ] : [ "binary", "&&", c, t ]; + } + }; + // shortcut the conditional if the expression has a constant value + return when_constant(c, function(ast, val){ + warn_unreachable(val ? e : t); + return (val ? t : e); + }, make_real_conditional); }; function empty(b) { - return !b || (b[0] == "block" && (!b[1] || b[1].length == 0)); + return !b || (b[0] == "block" && (!b[1] || b[1].length == 0)); }; function is_string(node) { - return (node[0] == "string" || - node[0] == "unary-prefix" && node[1] == "typeof" || - node[0] == "binary" && node[1] == "+" && - (is_string(node[2]) || is_string(node[3]))); + return (node[0] == "string" || + node[0] == "unary-prefix" && node[1] == "typeof" || + node[0] == "binary" && node[1] == "+" && + (is_string(node[2]) || is_string(node[3]))); +}; + +var when_constant = (function(){ + + var $NOT_CONSTANT = {}; + + // this can only evaluate constant expressions. If it finds anything + // not constant, it throws $NOT_CONSTANT. + function evaluate(expr) { + switch (expr[0]) { + case "string": + case "num": + return expr[1]; + case "name": + case "atom": + switch (expr[1]) { + case "true": return true; + case "false": return false; + } + break; + case "unary-prefix": + switch (expr[1]) { + case "!": return !evaluate(expr[2]); + case "typeof": return typeof evaluate(expr[2]); + case "~": return ~evaluate(expr[2]); + case "-": return -evaluate(expr[2]); + case "+": return +evaluate(expr[2]); + } + break; + case "binary": + var left = expr[2], right = expr[3]; + switch (expr[1]) { + case "&&" : return evaluate(left) && evaluate(right); + case "||" : return evaluate(left) || evaluate(right); + case "|" : return evaluate(left) | evaluate(right); + case "&" : return evaluate(left) & evaluate(right); + case "^" : return evaluate(left) ^ evaluate(right); + case "+" : return evaluate(left) + evaluate(right); + case "*" : return evaluate(left) * evaluate(right); + case "/" : return evaluate(left) / evaluate(right); + case "-" : return evaluate(left) - evaluate(right); + case "<<" : return evaluate(left) << evaluate(right); + case ">>" : return evaluate(left) >> evaluate(right); + case ">>>" : return evaluate(left) >>> evaluate(right); + case "==" : return evaluate(left) == evaluate(right); + case "===" : return evaluate(left) === evaluate(right); + case "!=" : return evaluate(left) != evaluate(right); + case "!==" : return evaluate(left) !== evaluate(right); + case "<" : return evaluate(left) < evaluate(right); + case "<=" : return evaluate(left) <= evaluate(right); + case ">" : return evaluate(left) > evaluate(right); + case ">=" : return evaluate(left) >= evaluate(right); + case "in" : return evaluate(left) in evaluate(right); + case "instanceof" : return evaluate(left) instanceof evaluate(right); + } + } + throw $NOT_CONSTANT; + }; + + return function(expr, yes, no) { + try { + var val = evaluate(expr), ast; + switch (typeof val) { + case "string": ast = [ "string", val ]; break; + case "number": ast = [ "num", val ]; break; + case "boolean": ast = [ "name", String(val) ]; break; + default: throw new Error("Can't handle constant of type: " + (typeof val)); + } + return yes.call(expr, ast, val); + } catch(ex) { + if (ex === $NOT_CONSTANT) { + if (expr[0] == "binary" + && (expr[1] == "===" || expr[1] == "!==") + && ((is_string(expr[2]) && is_string(expr[3])) + || (boolean_expr(expr[2]) && boolean_expr(expr[3])))) { + expr[1] = expr[1].substr(0, 2); + } + else if (no && expr[0] == "binary" + && (expr[1] == "||" || expr[1] == "&&")) { + // the whole expression is not constant but the lval may be... + try { + var lval = evaluate(expr[2]); + expr = ((expr[1] == "&&" && (lval ? expr[3] : lval)) || + (expr[1] == "||" && (lval ? lval : expr[3])) || + expr); + } catch(ex2) { + // IGNORE... lval is not constant + } + } + return no ? no.call(expr, expr) : null; + } + else throw ex; + } + }; + +})(); + +function warn_unreachable(ast) { + if (!empty(ast)) + warn("Dropping unreachable code: " + gen_code(ast, true)); +}; + +function prepare_ifs(ast) { + var w = ast_walker(), walk = w.walk; + // In this first pass, we rewrite ifs which abort with no else with an + // if-else. For example: + // + // if (x) { + // blah(); + // return y; + // } + // foobar(); + // + // is rewritten into: + // + // if (x) { + // blah(); + // return y; + // } else { + // foobar(); + // } + function redo_if(statements) { + statements = MAP(statements, walk); + + for (var i = 0; i < statements.length; ++i) { + var fi = statements[i]; + if (fi[0] != "if") continue; + + if (fi[3] && walk(fi[3])) continue; + + var t = walk(fi[2]); + if (!aborts(t)) continue; + + var conditional = walk(fi[1]); + + var e_body = statements.slice(i + 1); + var e = e_body.length == 1 ? e_body[0] : [ "block", e_body ]; + + var ret = statements.slice(0, i).concat([ [ + fi[0], // "if" + conditional, // conditional + t, // then + e // else + ] ]); + + return redo_if(ret); + } + + return statements; + }; + + function redo_if_lambda(name, args, body) { + body = redo_if(body); + return [ this[0], name, args, body ]; + }; + + function redo_if_block(statements) { + return [ this[0], statements != null ? redo_if(statements) : null ]; + }; + + return w.with_walkers({ + "defun": redo_if_lambda, + "function": redo_if_lambda, + "block": redo_if_block, + "splice": redo_if_block, + "toplevel": function(statements) { + return [ this[0], redo_if(statements) ]; + }, + "try": function(t, c, f) { + return [ + this[0], + redo_if(t), + c != null ? [ c[0], redo_if(c[1]) ] : null, + f != null ? redo_if(f) : null + ]; + } + }, function() { + return walk(ast); + }); +}; + +function for_side_effects(ast, handler) { + var w = ast_walker(), walk = w.walk; + var $stop = {}, $restart = {}; + function stop() { throw $stop }; + function restart() { throw $restart }; + function found(){ return handler.call(this, this, w, stop, restart) }; + function unary(op) { + if (op == "++" || op == "--") + return found.apply(this, arguments); + }; + return w.with_walkers({ + "try": found, + "throw": found, + "return": found, + "new": found, + "switch": found, + "break": found, + "continue": found, + "assign": found, + "call": found, + "if": found, + "for": found, + "for-in": found, + "while": found, + "do": found, + "return": found, + "unary-prefix": unary, + "unary-postfix": unary, + "defun": found + }, function(){ + while (true) try { + walk(ast); + break; + } catch(ex) { + if (ex === $stop) break; + if (ex === $restart) continue; + throw ex; + } + }); +}; + +function ast_lift_variables(ast) { + var w = ast_walker(), walk = w.walk, scope; + function do_body(body, env) { + var _scope = scope; + scope = env; + body = MAP(body, walk); + var hash = {}, names = MAP(env.names, function(type, name){ + if (type != "var") return MAP.skip; + if (!env.references(name)) return MAP.skip; + hash[name] = true; + return [ name ]; + }); + if (names.length > 0) { + // looking for assignments to any of these variables. + // we can save considerable space by moving the definitions + // in the var declaration. + for_side_effects([ "block", body ], function(ast, walker, stop, restart) { + if (ast[0] == "assign" + && ast[1] === true + && ast[2][0] == "name" + && HOP(hash, ast[2][1])) { + // insert the definition into the var declaration + for (var i = names.length; --i >= 0;) { + if (names[i][0] == ast[2][1]) { + if (names[i][1]) // this name already defined, we must stop + stop(); + names[i][1] = ast[3]; // definition + names.push(names.splice(i, 1)[0]); + break; + } + } + // remove this assignment from the AST. + var p = walker.parent(); + if (p[0] == "seq") { + var a = p[2]; + a.unshift(0, p.length); + p.splice.apply(p, a); + } + else if (p[0] == "stat") { + p.splice(0, p.length, "block"); // empty statement + } + else { + stop(); + } + restart(); + } + stop(); + }); + body.unshift([ "var", names ]); + } + scope = _scope; + return body; + }; + function _vardefs(defs) { + var ret = null; + for (var i = defs.length; --i >= 0;) { + var d = defs[i]; + if (!d[1]) continue; + d = [ "assign", true, [ "name", d[0] ], d[1] ]; + if (ret == null) ret = d; + else ret = [ "seq", d, ret ]; + } + if (ret == null) { + if (w.parent()[0] == "for-in") + return [ "name", defs[0][0] ]; + return MAP.skip; + } + return [ "stat", ret ]; + }; + function _toplevel(body) { + return [ this[0], do_body(body, this.scope) ]; + }; + return w.with_walkers({ + "function": function(name, args, body){ + for (var i = args.length; --i >= 0 && !body.scope.references(args[i]);) + args.pop(); + if (!body.scope.references(name)) name = null; + return [ this[0], name, args, do_body(body, body.scope) ]; + }, + "defun": function(name, args, body){ + if (!scope.references(name)) return MAP.skip; + for (var i = args.length; --i >= 0 && !body.scope.references(args[i]);) + args.pop(); + return [ this[0], name, args, do_body(body, body.scope) ]; + }, + "var": _vardefs, + "toplevel": _toplevel + }, function(){ + return walk(ast_add_scope(ast)); + }); +}; + +function ast_squeeze(ast, options) { + options = defaults(options, { + make_seqs : true, + dead_code : true, + keep_comps : true, + no_warnings : false + }); + + var w = ast_walker(), walk = w.walk, scope; + + function negate(c) { + var not_c = [ "unary-prefix", "!", c ]; + switch (c[0]) { + case "unary-prefix": + return c[1] == "!" && boolean_expr(c[2]) ? c[2] : not_c; + case "seq": + c = slice(c); + c[c.length - 1] = negate(c[c.length - 1]); + return c; + case "conditional": + return best_of(not_c, [ "conditional", c[1], negate(c[2]), negate(c[3]) ]); + case "binary": + var op = c[1], left = c[2], right = c[3]; + if (!options.keep_comps) switch (op) { + case "<=" : return [ "binary", ">", left, right ]; + case "<" : return [ "binary", ">=", left, right ]; + case ">=" : return [ "binary", "<", left, right ]; + case ">" : return [ "binary", "<=", left, right ]; + } + switch (op) { + case "==" : return [ "binary", "!=", left, right ]; + case "!=" : return [ "binary", "==", left, right ]; + case "===" : return [ "binary", "!==", left, right ]; + case "!==" : return [ "binary", "===", left, right ]; + case "&&" : return best_of(not_c, [ "binary", "||", negate(left), negate(right) ]); + case "||" : return best_of(not_c, [ "binary", "&&", negate(left), negate(right) ]); + } + break; + } + return not_c; + }; + + function with_scope(s, cont) { + var _scope = scope; + scope = s; + var ret = cont(); + ret.scope = s; + scope = _scope; + return ret; + }; + + function rmblock(block) { + if (block != null && block[0] == "block" && block[1]) { + if (block[1].length == 1) + block = block[1][0]; + else if (block[1].length == 0) + block = [ "block" ]; + } + return block; + }; + + function _lambda(name, args, body) { + var is_defun = this[0] == "defun"; + body = with_scope(body.scope, function(){ + var ret = tighten(body, "lambda"); + if (!is_defun && name && !scope.references(name)) + name = null; + return ret; + }); + return [ this[0], name, args, body ]; + }; + + // this function does a few things: + // 1. discard useless blocks + // 2. join consecutive var declarations + // 3. remove obviously dead code + // 4. transform consecutive statements using the comma operator + // 5. if block_type == "lambda" and it detects constructs like if(foo) return ... - rewrite like if (!foo) { ... } + function tighten(statements, block_type) { + statements = MAP(statements, walk); + + statements = statements.reduce(function(a, stat){ + if (stat[0] == "block") { + if (stat[1]) { + a.push.apply(a, stat[1]); + } + } else { + a.push(stat); + } + return a; + }, []); + + statements = (function(a, prev){ + statements.forEach(function(cur){ + if (prev && ((cur[0] == "var" && prev[0] == "var") || + (cur[0] == "const" && prev[0] == "const"))) { + prev[1] = prev[1].concat(cur[1]); + } else { + a.push(cur); + prev = cur; + } + }); + return a; + })([]); + + if (options.dead_code) statements = (function(a, has_quit){ + statements.forEach(function(st){ + if (has_quit) { + if (st[0] == "function" || st[0] == "defun") { + a.push(st); + } + else if (st[0] == "var" || st[0] == "const") { + if (!options.no_warnings) + warn("Variables declared in unreachable code"); + st[1] = MAP(st[1], function(def){ + if (def[1] && !options.no_warnings) + warn_unreachable([ "assign", true, [ "name", def[0] ], def[1] ]); + return [ def[0] ]; + }); + a.push(st); + } + else if (!options.no_warnings) + warn_unreachable(st); + } + else { + a.push(st); + if (member(st[0], [ "return", "throw", "break", "continue" ])) + has_quit = true; + } + }); + return a; + })([]); + + if (options.make_seqs) statements = (function(a, prev) { + statements.forEach(function(cur){ + if (prev && prev[0] == "stat" && cur[0] == "stat") { + prev[1] = [ "seq", prev[1], cur[1] ]; + } else { + a.push(cur); + prev = cur; + } + }); + if (a.length >= 2 + && a[a.length-2][0] == "stat" + && (a[a.length-1][0] == "return" || a[a.length-1][0] == "throw") + && a[a.length-1][1]) + { + a.splice(a.length - 2, 2, + [ a[a.length-1][0], + [ "seq", a[a.length-2][1], a[a.length-1][1] ]]); + } + return a; + })([]); + + // this increases jQuery by 1K. Probably not such a good idea after all.. + // part of this is done in prepare_ifs anyway. + // if (block_type == "lambda") statements = (function(i, a, stat){ + // while (i < statements.length) { + // stat = statements[i++]; + // if (stat[0] == "if" && !stat[3]) { + // if (stat[2][0] == "return" && stat[2][1] == null) { + // a.push(make_if(negate(stat[1]), [ "block", statements.slice(i) ])); + // break; + // } + // var last = last_stat(stat[2]); + // if (last[0] == "return" && last[1] == null) { + // a.push(make_if(stat[1], [ "block", stat[2][1].slice(0, -1) ], [ "block", statements.slice(i) ])); + // break; + // } + // } + // a.push(stat); + // } + // return a; + // })(0, []); + + return statements; + }; + + function make_if(c, t, e) { + return when_constant(c, function(ast, val){ + if (val) { + warn_unreachable(e); + return t; + } else { + warn_unreachable(t); + return e; + } + }, function() { + return make_real_if(c, t, e); + }); + }; + + function make_real_if(c, t, e) { + c = walk(c); + t = walk(t); + e = walk(e); + + if (empty(t)) { + c = negate(c); + t = e; + e = null; + } else if (empty(e)) { + e = null; + } else { + // if we have both else and then, maybe it makes sense to switch them? + (function(){ + var a = gen_code(c); + var n = negate(c); + var b = gen_code(n); + if (b.length < a.length) { + var tmp = t; + t = e; + e = tmp; + c = n; + } + })(); + } + if (empty(e) && empty(t)) + return [ "stat", c ]; + var ret = [ "if", c, t, e ]; + if (t[0] == "if" && empty(t[3]) && empty(e)) { + ret = best_of(ret, walk([ "if", [ "binary", "&&", c, t[1] ], t[2] ])); + } + else if (t[0] == "stat") { + if (e) { + if (e[0] == "stat") { + ret = best_of(ret, [ "stat", make_conditional(c, t[1], e[1]) ]); + } + } + else { + ret = best_of(ret, [ "stat", make_conditional(c, t[1]) ]); + } + } + else if (e && t[0] == e[0] && (t[0] == "return" || t[0] == "throw") && t[1] && e[1]) { + ret = best_of(ret, [ t[0], make_conditional(c, t[1], e[1] ) ]); + } + else if (e && aborts(t)) { + ret = [ [ "if", c, t ] ]; + if (e[0] == "block") { + if (e[1]) ret = ret.concat(e[1]); + } + else { + ret.push(e); + } + ret = walk([ "block", ret ]); + } + else if (t && aborts(e)) { + ret = [ [ "if", negate(c), e ] ]; + if (t[0] == "block") { + if (t[1]) ret = ret.concat(t[1]); + } else { + ret.push(t); + } + ret = walk([ "block", ret ]); + } + return ret; + }; + + function _do_while(cond, body) { + return when_constant(cond, function(cond, val){ + if (!val) { + warn_unreachable(body); + return [ "block" ]; + } else { + return [ "for", null, null, null, walk(body) ]; + } + }); + }; + + return w.with_walkers({ + "sub": function(expr, subscript) { + if (subscript[0] == "string") { + var name = subscript[1]; + if (is_identifier(name)) + return [ "dot", walk(expr), name ]; + else if (/^[1-9][0-9]*$/.test(name) || name === "0") + return [ "sub", walk(expr), [ "num", parseInt(name, 10) ] ]; + } + }, + "if": make_if, + "toplevel": function(body) { + return [ "toplevel", with_scope(this.scope, function(){ + return tighten(body); + }) ]; + }, + "switch": function(expr, body) { + var last = body.length - 1; + return [ "switch", walk(expr), MAP(body, function(branch, i){ + var block = tighten(branch[1]); + if (i == last && block.length > 0) { + var node = block[block.length - 1]; + if (node[0] == "break" && !node[1]) + block.pop(); + } + return [ branch[0] ? walk(branch[0]) : null, block ]; + }) ]; + }, + "function": _lambda, + "defun": _lambda, + "block": function(body) { + if (body) return rmblock([ "block", tighten(body) ]); + }, + "binary": function(op, left, right) { + return when_constant([ "binary", op, walk(left), walk(right) ], function yes(c){ + return best_of(walk(c), this); + }, function no() { + return this; + }); + }, + "conditional": function(c, t, e) { + return make_conditional(walk(c), walk(t), walk(e)); + }, + "try": function(t, c, f) { + return [ + "try", + tighten(t), + c != null ? [ c[0], tighten(c[1]) ] : null, + f != null ? tighten(f) : null + ]; + }, + "unary-prefix": function(op, expr) { + expr = walk(expr); + var ret = [ "unary-prefix", op, expr ]; + if (op == "!") + ret = best_of(ret, negate(expr)); + return when_constant(ret, function(ast, val){ + return walk(ast); // it's either true or false, so minifies to !0 or !1 + }, function() { return ret }); + }, + "name": function(name) { + switch (name) { + case "true": return [ "unary-prefix", "!", [ "num", 0 ]]; + case "false": return [ "unary-prefix", "!", [ "num", 1 ]]; + } + }, + "while": _do_while + }, function() { + for (var i = 0; i < 2; ++i) { + ast = prepare_ifs(ast); + ast = ast_add_scope(ast); + ast = walk(ast); + } + return ast; + }); }; /* -----[ re-generate code from the AST ]----- */ var DOT_CALL_NO_PARENS = jsp.array_to_hash([ - "name", "array", "object", "string", "dot", "sub", "call", "regexp" ]); + "name", + "array", + "object", + "string", + "dot", + "sub", + "call", + "regexp" +]); function make_string(str, ascii_only) { - var dq = 0, sq = 0; - str = str.replace(/[\\\b\f\n\r\t\x22\x27\u2028\u2029]/g, function(s){ - switch (s) { - case "\\": return "\\\\"; - case "\b": return "\\b"; - case "\f": return "\\f"; - case "\n": return "\\n"; - case "\r": return "\\r"; - case "\t": return "\\t"; - case "\u2028": return "\\u2028"; - case "\u2029": return "\\u2029"; - case '"': ++dq; return '"'; - case "'": ++sq; return "'"; - } - return s; - }); - if (ascii_only) str = to_ascii(str); - if (dq > sq) return "'" + str.replace(/\x27/g, "\\'") + "'"; - else return '"' + str.replace(/\x22/g, '\\"') + '"'; + var dq = 0, sq = 0; + str = str.replace(/[\\\b\f\n\r\t\x22\x27\u2028\u2029]/g, function(s){ + switch (s) { + case "\\": return "\\\\"; + case "\b": return "\\b"; + case "\f": return "\\f"; + case "\n": return "\\n"; + case "\r": return "\\r"; + case "\t": return "\\t"; + case "\u2028": return "\\u2028"; + case "\u2029": return "\\u2029"; + case '"': ++dq; return '"'; + case "'": ++sq; return "'"; + } + return s; + }); + if (ascii_only) str = to_ascii(str); + if (dq > sq) return "'" + str.replace(/\x27/g, "\\'") + "'"; + else return '"' + str.replace(/\x22/g, '\\"') + '"'; }; function to_ascii(str) { - return str.replace(/[\u0080-\uffff]/g, function(ch) { - var code = ch.charCodeAt(0).toString(16); - while (code.length < 4) code = "0" + code; - return "\\u" + code; - }); + return str.replace(/[\u0080-\uffff]/g, function(ch) { + var code = ch.charCodeAt(0).toString(16); + while (code.length < 4) code = "0" + code; + return "\\u" + code; + }); }; var SPLICE_NEEDS_BRACKETS = jsp.array_to_hash([ "if", "while", "do", "for", "for-in", "with" ]); function gen_code(ast, options) { - options = defaults(options, { - debug: false, - indent_start : 0, - indent_level : 4, - quote_keys : false, - space_colon : false, - beautify : false, - ascii_only : false, - inline_script: false - }); - var beautify = !!options.beautify; - var indentation = 0, - newline = beautify ? "\n" : "", - space = beautify ? " " : ""; - - function encode_string(str) { - var ret = make_string(str, options.ascii_only); - if (options.inline_script) - ret = ret.replace(/<\x2fscript([>/\t\n\f\r ])/gi, "<\\/script$1"); - return ret; - }; - - function make_name(name) { - name = name.toString(); - if (options.ascii_only) - name = to_ascii(name); - return name; - }; - - function indent(line) { - if (line == null) - line = ""; - if (beautify) - line = repeat_string(" ", options.indent_start + indentation * options.indent_level) + line; - return line; - }; - - function with_indent(cont, incr) { - if (incr == null) incr = 1; - indentation += incr; - try { return cont.apply(null, slice(arguments, 1)); } - finally { indentation -= incr; } - }; - - function add_spaces(a) { - if (beautify) - return a.join(" "); - var b = []; - for (var i = 0; i < a.length; ++i) { - var next = a[i + 1]; - b.push(a[i]); - if (next && - ((/[a-z0-9_\x24]$/i.test(a[i].toString()) && /^[a-z0-9_\x24]/i.test(next.toString())) || - (/[\+\-]$/.test(a[i].toString()) && /^[\+\-]/.test(next.toString())))) { - b.push(" "); - } - } - return b.join(""); - }; - - function add_commas(a) { - var str = a.join("," + space); - if (options.debug) { - // if a line contains more than one comma-separated segment, assign it the - // original line number of the first NodeWithLine segment - for (var i = 0, l = a.length; i < l; i ++) { - var v = a[i]; - if (v instanceof NodeWithLine) { - v.str = str; - return v - } - } - } - return str; - }; - - function parenthesize(expr) { - var gen = make(expr); - for (var i = 1; i < arguments.length; ++i) { - var el = arguments[i]; - if ((el instanceof Function && el(expr)) || expr[0] == el) - return "(" + gen + ")"; - } - return gen; - }; - - function best_of(a) { - if (a.length == 1) { - return a[0]; - } - if (a.length == 2) { - var b = a[1]; - a = a[0]; - return a.length <= b.length ? a : b; - } - return best_of([ a[0], best_of(a.slice(1)) ]); - }; - - function needs_parens(expr) { - if (expr[0] == "function" || expr[0] == "object") { - // dot/call on a literal function requires the - // function literal itself to be parenthesized - // only if it's the first "thing" in a - // statement. This means that the parent is - // "stat", but it could also be a "seq" and - // we're the first in this "seq" and the - // parent is "stat", and so on. Messy stuff, - // but it worths the trouble. - var a = slice(w.stack()), self = a.pop(), p = a.pop(); - while (p) { - if (p[0] == "stat") return true; - if (((p[0] == "seq" || p[0] == "call" || p[0] == "dot" || p[0] == "sub" || p[0] == "conditional") && p[1] === self) || - ((p[0] == "binary" || p[0] == "assign" || p[0] == "unary-postfix") && p[2] === self)) { - self = p; - p = a.pop(); - } else { - return false; - } - } - } - return !HOP(DOT_CALL_NO_PARENS, expr[0]); - }; - - function make_num(num) { - var str = num.toString(10), a = [ str.replace(/^0\./, ".") ], m; - if (Math.floor(num) === num) { - a.push("0x" + num.toString(16).toLowerCase(), // probably pointless - "0" + num.toString(8)); // same. - if ((m = /^(.*?)(0+)$/.exec(num))) { - a.push(m[1] + "e" + m[2].length); - } - } else if ((m = /^0?\.(0+)(.*)$/.exec(num))) { - a.push(m[2] + "e-" + (m[1].length + m[2].length), - str.substr(str.indexOf("."))); - } - var best = best_of(a); - if (options.debug && this[0].start) - return new NodeWithLine(best, this[0].start.line); - return best; - }; - - var w = ast_walker(); - var make = w.walk; - return w.with_walkers({ - "string": encode_string, - "num": make_num, - "name": make_name, - "toplevel": function(statements) { - return make_block_statements(statements).join(newline + newline); - }, - "splice": function(statements) { - var parent = w.parent(); - if (HOP(SPLICE_NEEDS_BRACKETS, parent)) { - // we need block brackets in this case - return make_block.apply(this, arguments); - } else { - return MAP(make_block_statements(statements, true), function(line, i) { - // the first line is already indented - return i > 0 ? indent(line) : line; - }).join(newline); - } - }, - "block": make_block, - "var": function(defs) { - var s = "var " + add_commas(MAP(defs, make_1vardef)) + ";"; - if (options.debug) { - // hack: we don't support mapping one optimized line to more than one - // generated line, so in case of multiple comma-separated var definitions, - // just take the first - if (defs[0][1] && defs[0][1][0] && defs[0][1][0].start) { - return s + (new NodeWithLine(s, defs[0][1][0].start.line)).lineComment(); - } - } - return s; - }, - "const": function(defs) { - return "const " + add_commas(MAP(defs, make_1vardef)) + ";"; - }, - "try": function(tr, ca, fi) { - var out = [ "try", make_block(tr) ]; - if (ca) out.push("catch", "(" + ca[0] + ")", make_block(ca[1])); - if (fi) out.push("finally", make_block(fi)); - return add_spaces(out); - }, - "throw": function(expr) { - return add_spaces([ "throw", make(expr) ]) + ";"; - }, - "new": function(ctor, args) { - args = args.length > 0 ? "(" + add_commas(MAP(args, make)) + ")" : ""; - return add_spaces([ "new", parenthesize(ctor, "seq", "binary", "conditional", "assign", function(expr){ - var w = ast_walker(), has_call = {}; - try { - w.with_walkers({ - "call": function() { throw has_call }, - "function": function() { return this } - }, function(){ - w.walk(expr); - }); - } catch(ex) { - if (ex === has_call) - return true; - throw ex; - } - }) + args ]); - }, - "switch": function(expr, body) { - return add_spaces([ "switch", "(" + make(expr) + ")", make_switch_block(body) ]); - }, - "break": function(label) { - var out = "break"; - if (label != null) - out += " " + make_name(label); - return out + ";"; - }, - "continue": function(label) { - var out = "continue"; - if (label != null) - out += " " + make_name(label); - return out + ";"; - }, - "conditional": function(co, th, el) { - return add_spaces([ parenthesize(co, "assign", "seq", "conditional"), "?", - parenthesize(th, "seq"), ":", - parenthesize(el, "seq") ]); - }, - "assign": function(op, lvalue, rvalue) { - if (op && op !== true) op += "="; - else op = "="; - var s = add_spaces([ make(lvalue), op, parenthesize(rvalue, "seq") ]); - if (options.debug && this[0].start) - return new NodeWithLine(s, this[0].start.line); - return s; - }, - "dot": function(expr) { - var out = make(expr), i = 1; - if (expr[0] == "num") { - if (!/\./.test(expr[1])) - out += "."; - } else if (needs_parens(expr)) - out = "(" + out + ")"; - while (i < arguments.length) - out += "." + make_name(arguments[i++]); - return out; - }, - "call": function(func, args) { - var f = make(func); - if (needs_parens(func)) - f = "(" + f + ")"; - var str = f + "(" + add_commas(MAP(args, function(expr){ - return parenthesize(expr, "seq"); - })) + ")"; - if (options.debug && this[0].start) - return new NodeWithLine(str, this[0].start.line) - return str; - }, - "function": make_function, - "defun": make_function, - "if": function(co, th, el) { - var out = [ "if", "(" + make(co) + ")", el ? make_then(th) : make(th) ]; - if (el) { - out.push("else", make(el)); - } - return add_spaces(out); - }, - "for": function(init, cond, step, block) { - var out = [ "for" ]; - init = (init != null ? make(init) : "").replace(/;*\s*$/, ";" + space); - cond = (cond != null ? make(cond) : "").replace(/;*\s*$/, ";" + space); - step = (step != null ? make(step) : "").replace(/;*\s*$/, ""); - var args = init + cond + step; - if (args == "; ; ") args = ";;"; - out.push("(" + args + ")", make(block)); - return add_spaces(out); - }, - "for-in": function(vvar, key, hash, block) { - return add_spaces([ "for", "(" + - (vvar ? make(vvar).replace(/;+$/, "") : make(key)), - "in", - make(hash) + ")", make(block) ]); - }, - "while": function(condition, block) { - return add_spaces([ "while", "(" + make(condition) + ")", make(block) ]); - }, - "do": function(condition, block) { - return add_spaces([ "do", make(block), "while", "(" + make(condition) + ")" ]) + ";"; - }, - "return": function(expr) { - var out = [ "return" ]; - var str = make(expr); - if (expr != null) out.push(str); - return add_spaces(out) + ";" + (str ? str.lineComment() : ''); - }, - "binary": function(operator, lvalue, rvalue) { - var left = make(lvalue), right = make(rvalue); - // XXX: I'm pretty sure other cases will bite here. - // we need to be smarter. - // adding parens all the time is the safest bet. - if (member(lvalue[0], [ "assign", "conditional", "seq" ]) || - lvalue[0] == "binary" && PRECEDENCE[operator] > PRECEDENCE[lvalue[1]]) { - left = "(" + left + ")"; - } - if (member(rvalue[0], [ "assign", "conditional", "seq" ]) || - rvalue[0] == "binary" && PRECEDENCE[operator] >= PRECEDENCE[rvalue[1]] && - !(rvalue[1] == operator && member(operator, [ "&&", "||", "*" ]))) { - right = "(" + right + ")"; - } - else if (!beautify && options.inline_script && (operator == "<" || operator == "<<") - && rvalue[0] == "regexp" && /^script/i.test(rvalue[1])) { - right = " " + right; - } - var tok = this[0]; - var str = add_spaces([ left, operator, right ]); - if (options.debug && tok.start) - return new NodeWithLine(str, tok.start.line); - return str; - }, - "unary-prefix": function(operator, expr) { - var val = make(expr); - if (!(expr[0] == "num" || (expr[0] == "unary-prefix" && !HOP(OPERATORS, operator + expr[1])) || !needs_parens(expr))) - val = "(" + val + ")"; - return operator + (jsp.is_alphanumeric_char(operator.charAt(0)) ? " " : "") + val; - }, - "unary-postfix": function(operator, expr) { - var val = make(expr); - if (!(expr[0] == "num" || (expr[0] == "unary-postfix" && !HOP(OPERATORS, operator + expr[1])) || !needs_parens(expr))) - val = "(" + val + ")"; - return val + operator; - }, - "sub": function(expr, subscript) { - var hash = make(expr); - if (needs_parens(expr)) - hash = "(" + hash + ")"; - return hash + "[" + make(subscript) + "]"; - }, - "object": function(props) { - if (props.length == 0) - return "{}"; - return "{" + newline + with_indent(function(){ - return MAP(props, function(p){ - if (p.length == 3) { - // getter/setter. The name is in p[0], the arg.list in p[1][2], the - // body in p[1][3] and type ("get" / "set") in p[2]. - return indent(make_function(p[0], p[1][2], p[1][3], p[2])); - } - var key = p[0], val = parenthesize(p[1], "seq"); - if (options.quote_keys || p.quoted) { - key = encode_string(key); - } else if ((typeof key == "number" || !beautify && +key + "" == key) - && parseFloat(key) >= 0) { - key = make_num(+key); - } else if (!is_identifier(key)) { - key = encode_string(key); - } - return indent(add_spaces(beautify && options.space_colon - ? [ key, ":", val ] - : [ key + ":", val ])); - }).join("," + newline); - }) + newline + indent("}"); - }, - "regexp": function(rx, mods) { - return "/" + rx + "/" + mods; - }, - "array": function(elements) { - if (elements.length == 0) return "[]"; - return add_spaces([ "[", add_commas(MAP(elements, function(el){ - if (!beautify && el[0] == "atom" && el[1] == "undefined") return ""; - return parenthesize(el, "seq"); - })), "]" ]); - }, - "stat": function(stmt) { - var str = make(stmt); - return str.replace(/;*\s*$/, ";") + str.lineComment(); - }, - "seq": function() { - return add_commas(MAP(slice(arguments), make)); - }, - "label": function(name, block) { - return add_spaces([ make_name(name), ":", make(block) ]); - }, - "with": function(expr, block) { - return add_spaces([ "with", "(" + make(expr) + ")", make(block) ]); - }, - "atom": function(name) { - return make_name(name); - } - }, function(){ return make(ast) }); - - // The squeezer replaces "block"-s that contain only a single - // statement with the statement itself; technically, the AST - // is correct, but this can create problems when we output an - // IF having an ELSE clause where the THEN clause ends in an - // IF *without* an ELSE block (then the outer ELSE would refer - // to the inner IF). This function checks for this case and - // adds the block brackets if needed. - function make_then(th) { - if (th[0] == "do") { - // https://github.com/mishoo/UglifyJS/issues/#issue/57 - // IE croaks with "syntax error" on code like this: - // if (foo) do ... while(cond); else ... - // we need block brackets around do/while - return make_block([ th ]); - } - var b = th; - while (true) { - var type = b[0]; - if (type == "if") { - if (!b[3]) - // no else, we must add the block - return make([ "block", [ th ]]); - b = b[3]; - } - else if (type == "while" || type == "do") b = b[2]; - else if (type == "for" || type == "for-in") b = b[4]; - else break; - } - return make(th); - }; - - function make_function(name, args, body, keyword) { - var out = keyword || "function"; - if (name) { - out += " " + make_name(name); - } - out += "(" + add_commas(MAP(args, make_name)) + ")"; - var result = add_spaces([ out, make_block(body) ]) - if (!name) result = "(" + result + ")"; - return result; - }; - - function must_has_semicolon(node) { - switch (node[0]) { - case "with": - case "while": - return empty(node[2]); // `with' or `while' with empty body? - case "for": - case "for-in": - return empty(node[4]); // `for' with empty body? - case "if": - if (empty(node[2]) && !node[3]) return true; // `if' with empty `then' and no `else' - if (node[3]) { - if (empty(node[3])) return true; // `else' present but empty - return must_has_semicolon(node[3]); // dive into the `else' branch - } - return must_has_semicolon(node[2]); // dive into the `then' branch - } - }; - - function make_block_statements(statements, noindent) { - for (var a = [], last = statements.length - 1, i = 0; i <= last; ++i) { - var stat = statements[i]; - var code = make(stat); - if (code != ";") { - if (!beautify && i == last && !must_has_semicolon(stat)) { - code = code.replace(/;+\s*$/, ""); - } - a.push(code); - } - } - return noindent ? a : MAP(a, indent); - }; - - function make_switch_block(body) { - var n = body.length; - if (n == 0) return "{}"; - return "{" + newline + MAP(body, function(branch, i){ - var has_body = branch[1].length > 0, code = with_indent(function(){ - return indent(branch[0] - ? add_spaces([ "case", make(branch[0]) + ":" ]) - : "default:"); - }, 0.5) + (has_body ? newline + with_indent(function(){ - return make_block_statements(branch[1]).join(newline); - }) : ""); - if (!beautify && has_body && i < n - 1) - code += ";"; - return code; - }).join(newline) + newline + indent("}"); - }; - - function make_block(statements) { - if (!statements) return ";"; - if (statements.length == 0) return "{}"; - return "{" + newline + with_indent(function(){ - return make_block_statements(statements).join(newline); - }) + newline + indent("}"); - }; - - function make_1vardef(def) { - var name = def[0], val = def[1]; - if (val != null) - name = add_spaces([ make_name(name), "=", parenthesize(val, "seq") ]); - return name; - }; + options = defaults(options, { + debug: false, + indent_start : 0, + indent_level : 4, + quote_keys : false, + space_colon : false, + beautify : false, + ascii_only : false, + inline_script: false + }); + var beautify = !!options.beautify; + var indentation = 0, + newline = beautify ? "\n" : "", + space = beautify ? " " : ""; + + function encode_string(str) { + var ret = make_string(str, options.ascii_only); + if (options.inline_script) + ret = ret.replace(/<\x2fscript([>/\t\n\f\r ])/gi, "<\\/script$1"); + return ret; + }; + + function make_name(name) { + name = name.toString(); + if (options.ascii_only) + name = to_ascii(name); + return name; + }; + + function indent(line) { + if (line == null) + line = ""; + if (beautify) + line = repeat_string(" ", options.indent_start + indentation * options.indent_level) + line; + return line; + }; + + function with_indent(cont, incr) { + if (incr == null) incr = 1; + indentation += incr; + try { return cont.apply(null, slice(arguments, 1)); } + finally { indentation -= incr; } + }; + + function add_spaces(a) { + if (beautify) + return a.join(" "); + var b = []; + for (var i = 0; i < a.length; ++i) { + var next = a[i + 1]; + b.push(a[i]); + if (next && + ((/[a-z0-9_\x24]$/i.test(a[i].toString()) && /^[a-z0-9_\x24]/i.test(next.toString())) || + (/[\+\-]$/.test(a[i].toString()) && /^[\+\-]/.test(next.toString())))) { + b.push(" "); + } + } + return b.join(""); + }; + + function add_commas(a) { + var str = a.join("," + space); + if (options.debug) { + // if a line contains more than one comma-separated segment, assign it the + // original line number of the first NodeWithLine segment + for (var i = 0, l = a.length; i < l; i ++) { + var v = a[i]; + if (v instanceof NodeWithLine) { + v.str = str; + return v + } + } + } + return str; + }; + + function parenthesize(expr) { + var gen = make(expr); + for (var i = 1; i < arguments.length; ++i) { + var el = arguments[i]; + if ((el instanceof Function && el(expr)) || expr[0] == el) + return "(" + gen + ")"; + } + return gen; + }; + + function best_of(a) { + if (a.length == 1) { + return a[0]; + } + if (a.length == 2) { + var b = a[1]; + a = a[0]; + return a.length <= b.length ? a : b; + } + return best_of([ a[0], best_of(a.slice(1)) ]); + }; + + function needs_parens(expr) { + if (expr[0] == "function" || expr[0] == "object") { + // dot/call on a literal function requires the + // function literal itself to be parenthesized + // only if it's the first "thing" in a + // statement. This means that the parent is + // "stat", but it could also be a "seq" and + // we're the first in this "seq" and the + // parent is "stat", and so on. Messy stuff, + // but it worths the trouble. + var a = slice(w.stack()), self = a.pop(), p = a.pop(); + while (p) { + if (p[0] == "stat") return true; + if (((p[0] == "seq" || p[0] == "call" || p[0] == "dot" || p[0] == "sub" || p[0] == "conditional") && p[1] === self) || + ((p[0] == "binary" || p[0] == "assign" || p[0] == "unary-postfix") && p[2] === self)) { + self = p; + p = a.pop(); + } else { + return false; + } + } + } + return !HOP(DOT_CALL_NO_PARENS, expr[0]); + }; + + function make_num(num) { + var str = num.toString(10), a = [ str.replace(/^0\./, ".") ], m; + if (Math.floor(num) === num) { + a.push("0x" + num.toString(16).toLowerCase(), // probably pointless + "0" + num.toString(8)); // same. + if ((m = /^(.*?)(0+)$/.exec(num))) { + a.push(m[1] + "e" + m[2].length); + } + } else if ((m = /^0?\.(0+)(.*)$/.exec(num))) { + a.push(m[2] + "e-" + (m[1].length + m[2].length), + str.substr(str.indexOf("."))); + } + var best = best_of(a); + if (options.debug && this[0].start) + return new NodeWithLine(best, this[0].start.line); + return best; + }; + + var w = ast_walker(); + var make = w.walk; + return w.with_walkers({ + "string": encode_string, + "num": make_num, + "name": make_name, + "toplevel": function(statements) { + return make_block_statements(statements) + .join(newline + newline); + }, + "splice": function(statements) { + var parent = w.parent(); + if (HOP(SPLICE_NEEDS_BRACKETS, parent)) { + // we need block brackets in this case + return make_block.apply(this, arguments); + } else { + return MAP(make_block_statements(statements, true), + function(line, i) { + // the first line is already indented + return i > 0 ? indent(line) : line; + }).join(newline); + } + }, + "block": make_block, + "var": function(defs) { + var s = "var " + add_commas(MAP(defs, make_1vardef)) + ";"; + if (options.debug) { + // hack: we don't support mapping one optimized line to more than one + // generated line, so in case of multiple comma-separated var definitions, + // just take the first + if (defs[0][1] && defs[0][1][0] && defs[0][1][0].start) + return s + (new NodeWithLine(s, defs[0][1][0].start.line)).lineComment(); + } + return s; + }, + "const": function(defs) { + return "const " + add_commas(MAP(defs, make_1vardef)) + ";"; + }, + "try": function(tr, ca, fi) { + var out = [ "try", make_block(tr) ]; + if (ca) out.push("catch", "(" + ca[0] + ")", make_block(ca[1])); + if (fi) out.push("finally", make_block(fi)); + return add_spaces(out); + }, + "throw": function(expr) { + return add_spaces([ "throw", make(expr) ]) + ";"; + }, + "new": function(ctor, args) { + args = args.length > 0 ? "(" + add_commas(MAP(args, make)) + ")" : ""; + return add_spaces([ "new", parenthesize(ctor, "seq", "binary", "conditional", "assign", function(expr){ + var w = ast_walker(), has_call = {}; + try { + w.with_walkers({ + "call": function() { throw has_call }, + "function": function() { return this } + }, function(){ + w.walk(expr); + }); + } catch(ex) { + if (ex === has_call) + return true; + throw ex; + } + }) + args ]); + }, + "switch": function(expr, body) { + return add_spaces([ "switch", "(" + make(expr) + ")", make_switch_block(body) ]); + }, + "break": function(label) { + var out = "break"; + if (label != null) + out += " " + make_name(label); + return out + ";"; + }, + "continue": function(label) { + var out = "continue"; + if (label != null) + out += " " + make_name(label); + return out + ";"; + }, + "conditional": function(co, th, el) { + return add_spaces([ parenthesize(co, "assign", "seq", "conditional"), "?", + parenthesize(th, "seq"), ":", + parenthesize(el, "seq") ]); + }, + "assign": function(op, lvalue, rvalue) { + if (op && op !== true) op += "="; + else op = "="; + var s = add_spaces([ make(lvalue), op, parenthesize(rvalue, "seq") ]); + if (options.debug && this[0].start) + return new NodeWithLine(s, this[0].start.line); + return s; + }, + "dot": function(expr) { + var out = make(expr), i = 1; + if (expr[0] == "num") { + if (!/\./.test(expr[1])) + out += "."; + } else if (needs_parens(expr)) + out = "(" + out + ")"; + while (i < arguments.length) + out += "." + make_name(arguments[i++]); + return out; + }, + "call": function(func, args) { + var f = make(func); + if (needs_parens(func)) + f = "(" + f + ")"; + var str = f + "(" + add_commas(MAP(args, function(expr){ + return parenthesize(expr, "seq"); + })) + ")"; + if (options.debug && this[0].start) + return new NodeWithLine(str, this[0].start.line) + return str; + }, + "function": make_function, + "defun": make_function, + "if": function(co, th, el) { + var out = [ "if", "(" + make(co) + ")", el ? make_then(th) : make(th) ]; + if (el) { + out.push("else", make(el)); + } + return add_spaces(out); + }, + "for": function(init, cond, step, block) { + var out = [ "for" ]; + init = (init != null ? make(init) : "").replace(/;*\s*$/, ";" + space); + cond = (cond != null ? make(cond) : "").replace(/;*\s*$/, ";" + space); + step = (step != null ? make(step) : "").replace(/;*\s*$/, ""); + var args = init + cond + step; + if (args == "; ; ") args = ";;"; + out.push("(" + args + ")", make(block)); + return add_spaces(out); + }, + "for-in": function(vvar, key, hash, block) { + return add_spaces([ "for", "(" + + (vvar ? make(vvar).replace(/;+$/, "") : make(key)), + "in", + make(hash) + ")", make(block) ]); + }, + "while": function(condition, block) { + return add_spaces([ "while", "(" + make(condition) + ")", make(block) ]); + }, + "do": function(condition, block) { + return add_spaces([ "do", make(block), "while", "(" + make(condition) + ")" ]) + ";"; + }, + "return": function(expr) { + var out = [ "return" ]; + var str = make(expr); + if (expr != null) out.push(str); + return add_spaces(out) + ";" + (str ? str.lineComment() : ''); + }, + "binary": function(operator, lvalue, rvalue) { + var left = make(lvalue), right = make(rvalue); + // XXX: I'm pretty sure other cases will bite here. + // we need to be smarter. + // adding parens all the time is the safest bet. + if (member(lvalue[0], [ "assign", "conditional", "seq" ]) || + lvalue[0] == "binary" && PRECEDENCE[operator] > PRECEDENCE[lvalue[1]]) { + left = "(" + left + ")"; + } + if (member(rvalue[0], [ "assign", "conditional", "seq" ]) || + rvalue[0] == "binary" && PRECEDENCE[operator] >= PRECEDENCE[rvalue[1]] && + !(rvalue[1] == operator && member(operator, [ "&&", "||", "*" ]))) { + right = "(" + right + ")"; + } + else if (!beautify && options.inline_script && (operator == "<" || operator == "<<") + && rvalue[0] == "regexp" && /^script/i.test(rvalue[1])) { + right = " " + right; + } + var tok = this[0]; + var str = add_spaces([ left, operator, right ]); + if (options.debug && tok.start) + return new NodeWithLine(str, tok.start.line); + return str; + }, + "unary-prefix": function(operator, expr) { + var val = make(expr); + if (!(expr[0] == "num" || (expr[0] == "unary-prefix" && !HOP(OPERATORS, operator + expr[1])) || !needs_parens(expr))) + val = "(" + val + ")"; + return operator + (jsp.is_alphanumeric_char(operator.charAt(0)) ? " " : "") + val; + }, + "unary-postfix": function(operator, expr) { + var val = make(expr); + if (!(expr[0] == "num" || (expr[0] == "unary-postfix" && !HOP(OPERATORS, operator + expr[1])) || !needs_parens(expr))) + val = "(" + val + ")"; + return val + operator; + }, + "sub": function(expr, subscript) { + var hash = make(expr); + if (needs_parens(expr)) + hash = "(" + hash + ")"; + return hash + "[" + make(subscript) + "]"; + }, + "object": function(props) { + if (props.length == 0) + return "{}"; + return "{" + newline + with_indent(function(){ + return MAP(props, function(p){ + if (p.length == 3) { + // getter/setter. The name is in p[0], the arg.list in p[1][2], the + // body in p[1][3] and type ("get" / "set") in p[2]. + return indent(make_function(p[0], p[1][2], p[1][3], p[2])); + } + var key = p[0], val = parenthesize(p[1], "seq"); + if (options.quote_keys || p.quoted) { + key = encode_string(key); + } else if ((typeof key == "number" || !beautify && +key + "" == key) + && parseFloat(key) >= 0) { + key = make_num(+key); + } else if (!is_identifier(key)) { + key = encode_string(key); + } + return indent(add_spaces(beautify && options.space_colon + ? [ key, ":", val ] + : [ key + ":", val ])); + }).join("," + newline); + }) + newline + indent("}"); + }, + "regexp": function(rx, mods) { + return "/" + rx + "/" + mods; + }, + "array": function(elements) { + if (elements.length == 0) return "[]"; + return add_spaces([ "[", add_commas(MAP(elements, function(el){ + if (!beautify && el[0] == "atom" && el[1] == "undefined") return ""; + return parenthesize(el, "seq"); + })), "]" ]); + }, + "stat": function(stmt) { + var str = make(stmt); + return str.replace(/;*\s*$/, ";") + str.lineComment(); + }, + "seq": function() { + return add_commas(MAP(slice(arguments), make)); + }, + "label": function(name, block) { + return add_spaces([ make_name(name), ":", make(block) ]); + }, + "with": function(expr, block) { + return add_spaces([ "with", "(" + make(expr) + ")", make(block) ]); + }, + "atom": function(name) { + return make_name(name); + } + }, function(){ return make(ast) }); + + // The squeezer replaces "block"-s that contain only a single + // statement with the statement itself; technically, the AST + // is correct, but this can create problems when we output an + // IF having an ELSE clause where the THEN clause ends in an + // IF *without* an ELSE block (then the outer ELSE would refer + // to the inner IF). This function checks for this case and + // adds the block brackets if needed. + function make_then(th) { + if (th[0] == "do") { + // https://github.com/mishoo/UglifyJS/issues/#issue/57 + // IE croaks with "syntax error" on code like this: + // if (foo) do ... while(cond); else ... + // we need block brackets around do/while + return make_block([ th ]); + } + var b = th; + while (true) { + var type = b[0]; + if (type == "if") { + if (!b[3]) + // no else, we must add the block + return make([ "block", [ th ]]); + b = b[3]; + } + else if (type == "while" || type == "do") b = b[2]; + else if (type == "for" || type == "for-in") b = b[4]; + else break; + } + return make(th); + }; + + function make_function(name, args, body, keyword) { + var out = keyword || "function"; + if (name) { + out += " " + make_name(name); + } + out += "(" + add_commas(MAP(args, make_name)) + ")"; + var result = add_spaces([ out, make_block(body) ]) + if (!name) result = "(" + result + ")"; + return result; + }; + + function must_has_semicolon(node) { + switch (node[0]) { + case "with": + case "while": + return empty(node[2]); // `with' or `while' with empty body? + case "for": + case "for-in": + return empty(node[4]); // `for' with empty body? + case "if": + if (empty(node[2]) && !node[3]) return true; // `if' with empty `then' and no `else' + if (node[3]) { + if (empty(node[3])) return true; // `else' present but empty + return must_has_semicolon(node[3]); // dive into the `else' branch + } + return must_has_semicolon(node[2]); // dive into the `then' branch + } + }; + + function make_block_statements(statements, noindent) { + for (var a = [], last = statements.length - 1, i = 0; i <= last; ++i) { + var stat = statements[i]; + var code = make(stat); + if (code != ";") { + if (!beautify && i == last && !must_has_semicolon(stat)) { + code = code.replace(/;+\s*$/, ""); + } + a.push(code); + } + } + return noindent ? a : MAP(a, indent); + }; + + function make_switch_block(body) { + var n = body.length; + if (n == 0) return "{}"; + return "{" + newline + MAP(body, function(branch, i){ + var has_body = branch[1].length > 0, code = with_indent(function(){ + return indent(branch[0] + ? add_spaces([ "case", make(branch[0]) + ":" ]) + : "default:"); + }, 0.5) + (has_body ? newline + with_indent(function(){ + return make_block_statements(branch[1]).join(newline); + }) : ""); + if (!beautify && has_body && i < n - 1) + code += ";"; + return code; + }).join(newline) + newline + indent("}"); + }; + + function make_block(statements) { + if (!statements) return ";"; + if (statements.length == 0) return "{}"; + return "{" + newline + with_indent(function(){ + return make_block_statements(statements).join(newline); + }) + newline + indent("}"); + }; + + function make_1vardef(def) { + var name = def[0], val = def[1]; + if (val != null) + name = add_spaces([ make_name(name), "=", parenthesize(val, "seq") ]); + return name; + }; }; +function split_lines(code, max_line_length) { + var splits = [ 0 ]; + jsp.parse(function(){ + var next_token = jsp.tokenizer(code); + var last_split = 0; + var prev_token; + function current_length(tok) { + return tok.pos - last_split; + }; + function split_here(tok) { + last_split = tok.pos; + splits.push(last_split); + }; + function custom(){ + var tok = next_token.apply(this, arguments); + out: { + if (prev_token) { + if (prev_token.type == "keyword") break out; + } + if (current_length(tok) > max_line_length) { + switch (tok.type) { + case "keyword": + case "atom": + case "name": + case "punc": + split_here(tok); + break out; + } + } + } + prev_token = tok; + return tok; + }; + custom.context = function() { + return next_token.context.apply(this, arguments); + }; + return custom; + }()); + return splits.map(function(pos, i){ + return code.substring(pos, splits[i + 1] || code.length); + }).join("\n"); +}; + /* -----[ Utilities ]----- */ function repeat_string(str, i) { - if (i <= 0) return ""; - if (i == 1) return str; - var d = repeat_string(str, i >> 1); - d += d; - if (i & 1) d += str; - return d; + if (i <= 0) return ""; + if (i == 1) return str; + var d = repeat_string(str, i >> 1); + d += d; + if (i & 1) d += str; + return d; }; function defaults(args, defs) { - var ret = {}; - if (args === true) - args = {}; - for (var i in defs) if (HOP(defs, i)) { - ret[i] = (args && HOP(args, i)) ? args[i] : defs[i]; - } - return ret; + var ret = {}; + if (args === true) + args = {}; + for (var i in defs) if (HOP(defs, i)) { + ret[i] = (args && HOP(args, i)) ? args[i] : defs[i]; + } + return ret; }; function is_identifier(name) { - return /^[a-z_$][a-z0-9_$]*$/i.test(name) - && name != "this" - && !HOP(jsp.KEYWORDS_ATOM, name) - && !HOP(jsp.RESERVED_WORDS, name) - && !HOP(jsp.KEYWORDS, name); + return /^[a-z_$][a-z0-9_$]*$/i.test(name) + && name != "this" + && !HOP(jsp.KEYWORDS_ATOM, name) + && !HOP(jsp.RESERVED_WORDS, name) + && !HOP(jsp.KEYWORDS, name); }; function HOP(obj, prop) { - return Object.prototype.hasOwnProperty.call(obj, prop); + return Object.prototype.hasOwnProperty.call(obj, prop); }; // some utilities @@ -884,41 +1952,49 @@ function HOP(obj, prop) { var MAP; (function(){ - MAP = function(a, f, o) { - var ret = [], top = [], i; - function doit() { - var val = f.call(o, a[i], i); - if (val instanceof AtTop) { - val = val.v; - if (val instanceof Splice) { - top.push.apply(top, val.v); - } else { - top.push(val); - } - } - else if (val != skip) { - if (val instanceof Splice) { - ret.push.apply(ret, val.v); - } else { - ret.push(val); - } - } - }; - if (a instanceof Array) for (i = 0; i < a.length; ++i) doit(); - else for (i in a) if (HOP(a, i)) doit(); - return top.concat(ret); - }; - MAP.at_top = function(val) { return new AtTop(val) }; - MAP.splice = function(val) { return new Splice(val) }; - var skip = MAP.skip = {}; - function AtTop(val) { this.v = val }; - function Splice(val) { this.v = val }; + MAP = function(a, f, o) { + var ret = [], top = [], i; + function doit() { + var val = f.call(o, a[i], i); + if (val instanceof AtTop) { + val = val.v; + if (val instanceof Splice) { + top.push.apply(top, val.v); + } else { + top.push(val); + } + } + else if (val != skip) { + if (val instanceof Splice) { + ret.push.apply(ret, val.v); + } else { + ret.push(val); + } + } + }; + if (a instanceof Array) for (i = 0; i < a.length; ++i) doit(); + else for (i in a) if (HOP(a, i)) doit(); + return top.concat(ret); + }; + MAP.at_top = function(val) { return new AtTop(val) }; + MAP.splice = function(val) { return new Splice(val) }; + var skip = MAP.skip = {}; + function AtTop(val) { this.v = val }; + function Splice(val) { this.v = val }; })(); /* -----[ Exports ]----- */ exports.ast_walker = ast_walker; +exports.ast_mangle = ast_mangle; +exports.ast_squeeze = ast_squeeze; +exports.ast_lift_variables = ast_lift_variables; exports.gen_code = gen_code; +exports.ast_add_scope = ast_add_scope; exports.set_logger = function(logger) { warn = logger }; exports.make_string = make_string; +exports.split_lines = split_lines; exports.MAP = MAP; + +// keep this last! +exports.ast_squeeze_more = require("./squeeze-more").ast_squeeze_more; From d50e7b4f7de07df53f820051dac85e79f8aa6e84 Mon Sep 17 00:00:00 2001 From: Jez Ng Date: Fri, 21 Jun 2013 06:19:25 -0700 Subject: [PATCH 29/69] Improvements to test_html_source_map. * Now works on FF Nightly * Test does not run unless explicitly requested --- tests/runner.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/tests/runner.py b/tests/runner.py index 10478b6ad5dff..f13db825bdd2d 100755 --- a/tests/runner.py +++ b/tests/runner.py @@ -11766,6 +11766,8 @@ def test_html(self): message='You should see "hello, world!" and a colored cube.') def test_html_source_map(self): + if 'test_html_source_map' not in str(sys.argv): return self.skip('''This test + requires manual intervention; will not be run unless explicitly requested''') cpp_file = os.path.join(self.get_dir(), 'src.cpp') html_file = os.path.join(self.get_dir(), 'src.html') # browsers will try to 'guess' the corresponding original line if a @@ -11788,7 +11790,10 @@ def test_html_source_map(self): return 0; } ''') - Popen([PYTHON, EMCC, cpp_file, '-o', html_file, '--map']).communicate() + # use relative paths when calling emcc, because file:// URIs can only load + # sourceContent when the maps are relative paths + Popen([PYTHON, EMCC, 'src.cpp', '-o', 'src.html', '--map'], + cwd=self.get_dir()).communicate() webbrowser.open_new('file://' + html_file) print ''' Set the debugger to pause on exceptions From 88feddf045882bbddd29d9286eae4e6a9086e286 Mon Sep 17 00:00:00 2001 From: Jez Ng Date: Fri, 21 Jun 2013 16:01:38 -0700 Subject: [PATCH 30/69] Get test_source_map passing again. --- emcc | 1 + .../node_modules/uglify-js/lib/process.js | 13 +++++++++---- tools/js-optimizer.js | 4 +++- 3 files changed, 13 insertions(+), 5 deletions(-) diff --git a/emcc b/emcc index 650ba9e9f8e22..d40473190a6bf 100755 --- a/emcc +++ b/emcc @@ -1524,6 +1524,7 @@ try: if DEBUG == '2': # Clean up the syntax a bit final = shared.Building.js_optimizer(final, [], jcache, make_source_map) + js_transform_tempfiles.append(final) if DEBUG: save_intermediate('pretty') def get_eliminate(): diff --git a/tools/eliminator/node_modules/uglify-js/lib/process.js b/tools/eliminator/node_modules/uglify-js/lib/process.js index da38caa7363aa..3fd99b7952ae6 100644 --- a/tools/eliminator/node_modules/uglify-js/lib/process.js +++ b/tools/eliminator/node_modules/uglify-js/lib/process.js @@ -72,7 +72,7 @@ function NodeWithLine(str, line) { NodeWithLine.prototype = new String(); NodeWithLine.prototype.toString = function() { return this.str; } NodeWithLine.prototype.valueOf = function() { return this.str; } -NodeWithLine.prototype.lineComment = function() { return " // @line " + this.line; } +NodeWithLine.prototype.lineComment = function() { return " //@line " + this.line; } // XXX ugly hack String.prototype.lineComment = function() { return ""; } @@ -1686,10 +1686,15 @@ function gen_code(ast, options) { && rvalue[0] == "regexp" && /^script/i.test(rvalue[1])) { right = " " + right; } - var tok = this[0]; var str = add_spaces([ left, operator, right ]); - if (options.debug && tok.start) - return new NodeWithLine(str, tok.start.line); + if (options.debug) { + if (this[0].start) + return new NodeWithLine(str, this[0].start.line); + else if (lvalue[0].start) + return new NodeWithLine(str, lvalue[0].start.line); + else if (rvalue[0].start) + return new NodeWithLine(str, rvalue[0].start.line); + } return str; }, "unary-prefix": function(operator, expr) { diff --git a/tools/js-optimizer.js b/tools/js-optimizer.js index 0709251387d86..94c10ebca07c0 100644 --- a/tools/js-optimizer.js +++ b/tools/js-optimizer.js @@ -442,7 +442,9 @@ function simplifyExpressionsPre(ast) { traverse(ast, function process(node, type, stack) { if (type == 'binary' && node[1] == '|') { if (node[2][0] == 'num' && node[3][0] == 'num') { - return ['num', node[2][1] | node[3][1]]; + // pass node[2][0] instead of 'num' because it might be a token + // object with line numbers attached. + return [node[2][0], node[2][1] | node[3][1]]; } else if (jsonCompare(node[2], ZERO) || jsonCompare(node[3], ZERO)) { // We might be able to remove this correction for (var i = stack.length-1; i >= 0; i--) { From 9382556ed563b1e4c36b90b1cbe4acafffef930d Mon Sep 17 00:00:00 2001 From: Jez Ng Date: Fri, 21 Jun 2013 17:39:37 -0700 Subject: [PATCH 31/69] Test that source mapping works with EMCC_DEBUG=2. --- emcc | 4 +++- tests/runner.py | 23 +++++++++++++++++++---- 2 files changed, 22 insertions(+), 5 deletions(-) diff --git a/emcc b/emcc index d40473190a6bf..c68d9e6312d3c 100755 --- a/emcc +++ b/emcc @@ -1483,9 +1483,11 @@ try: open(final, 'w').write(src) if DEBUG: save_intermediate('bind') - # TODO: support source maps with js_transform # Apply a source code transformation, if requested if js_transform: + # TODO: support source maps with js_transform + logging.warning('disabling source maps because a js transform is being done') + make_source_map = False shutil.copyfile(final, final + '.tr.js') final += '.tr.js' posix = True if not shared.WINDOWS else False diff --git a/tests/runner.py b/tests/runner.py index f13db825bdd2d..be6ba6e00776a 100755 --- a/tests/runner.py +++ b/tests/runner.py @@ -9605,12 +9605,16 @@ def test_source_map(self): dirname = self.get_dir() src_filename = os.path.join(dirname, 'src.cpp') + with open(src_filename, 'w') as f: f.write(src) + out_filename = os.path.join(dirname, 'a.out.js') - def post(filename): + def build_and_check(): import json - map_filename = filename + '.map' + Building.emcc(src_filename, Settings.serialize() + self.emcc_args + + Building.COMPILER_TEST_OPTS, out_filename, stderr=PIPE) + map_filename = out_filename + '.map' data = json.load(open(map_filename, 'r')) - self.assertIdentical(filename, data['file']) + self.assertIdentical(out_filename, data['file']) self.assertIdentical(src_filename, data['sources'][0]) self.assertIdentical(src, data['sourcesContent'][0]) mappings = json.loads(jsrun.run_js( @@ -9623,7 +9627,18 @@ def post(filename): # ensure that all the 'meaningful' lines in the original code get mapped assert seen_lines.issuperset([6, 7, 11, 12]) - self.build(src, dirname, src_filename, post_build=(None,post)) + # EMCC_DEBUG=2 causes lots of intermediate files to be written, and so + # serves as a stress test for source maps because it needs to correlate + # line numbers across all those files. + old_emcc_debug = os.environ.get('EMCC_DEBUG', None) + os.environ.pop('EMCC_DEBUG', None) + build_and_check() + os.environ['EMCC_DEBUG'] = '2' + build_and_check() + if old_emcc_debug is not None: + os.environ['EMCC_DEBUG'] = old_emcc_debug + else: + del os.environ['EMCC_DEBUG'] def test_exception_source_map(self): if Settings.USE_TYPED_ARRAYS != 2: return self.skip("doesn't pass without typed arrays") From 610388440c46a5586dbe406e18fb73323b2aa9eb Mon Sep 17 00:00:00 2001 From: Jez Ng Date: Sat, 22 Jun 2013 00:55:34 -0700 Subject: [PATCH 32/69] Ensure JS output remains the same when making source maps. --- tests/runner.py | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/tests/runner.py b/tests/runner.py index be6ba6e00776a..cd0ca35754d0a 100755 --- a/tests/runner.py +++ b/tests/runner.py @@ -9586,7 +9586,7 @@ def process(filename): def test_source_map(self): if Settings.USE_TYPED_ARRAYS != 2: return self.skip("doesn't pass without typed arrays") - if '--map' not in Building.COMPILER_TEST_OPTS: Building.COMPILER_TEST_OPTS.append('--map') + if '-g' not in Building.COMPILER_TEST_OPTS: Building.COMPILER_TEST_OPTS.append('-g') src = ''' #include @@ -9605,13 +9605,27 @@ def test_source_map(self): dirname = self.get_dir() src_filename = os.path.join(dirname, 'src.cpp') + no_maps_filename = os.path.join(dirname, 'no-maps.out.js') with open(src_filename, 'w') as f: f.write(src) + assert '--map' not in Building.COMPILER_TEST_OPTS + Building.emcc(src_filename, Settings.serialize() + self.emcc_args + + Building.COMPILER_TEST_OPTS, no_maps_filename) + with open(no_maps_filename) as f: no_maps_file = f.read() out_filename = os.path.join(dirname, 'a.out.js') + Building.COMPILER_TEST_OPTS.append('--map') def build_and_check(): import json Building.emcc(src_filename, Settings.serialize() + self.emcc_args + Building.COMPILER_TEST_OPTS, out_filename, stderr=PIPE) + with open(out_filename) as f: out_file = f.read() + # after removing the @line and @sourceMappingURL comments, the build + # result should be identical to the non-source-mapped debug version. + # this is worth checking because the parser AST swaps strings for token + # objects when generating source maps, so we want to make sure the + # optimizer can deal with both types. + out_file = re.sub('//@.*$', '', out_file) + self.assertIdentical(no_maps_file, out_file) map_filename = out_filename + '.map' data = json.load(open(map_filename, 'r')) self.assertIdentical(out_filename, data['file']) From 3a84846dedd590b88fab84472d24f81ac56cf9ae Mon Sep 17 00:00:00 2001 From: Jez Ng Date: Sat, 22 Jun 2013 02:03:39 -0700 Subject: [PATCH 33/69] Centralize debug options in a -gX flag. --- emcc | 77 +++++++++++++++++++++++++++---------------------- tests/runner.py | 8 ++--- 2 files changed, 47 insertions(+), 38 deletions(-) diff --git a/emcc b/emcc index c68d9e6312d3c..33dbbb035817d 100755 --- a/emcc +++ b/emcc @@ -182,7 +182,7 @@ Options that are modified or new in %s include: ). Note that the path must be absolute, not relative. - -g Use debug info. Note that you need this during + -g or -g1 Use debug info. Note that you need this during the last compilation phase from bitcode to JavaScript, or else we will remove it by default in -O1 and above. @@ -193,6 +193,11 @@ Options that are modified or new in %s include: causes name mangling or minification (closure or the registerize pass). + -g2 Like -g1, but we generate source maps as well, + and we preserve comments even with -O1 and above. + Note that this may be considerably slower because + JS optimization is limited to a single core. + --typed-arrays 0: No typed arrays 1: Parallel typed arrays 2: Shared (C-like) typed arrays (default) @@ -689,6 +694,7 @@ try: newargs = sys.argv[1:] opt_level = 0 + debug_level = 0 llvm_opts = None llvm_lto = None closure = None @@ -703,14 +709,11 @@ try: ignore_dynamic_linking = False shell_path = shared.path_from_root('src', 'shell.html') js_libraries = [] - keep_llvm_debug = False - keep_js_debug = False bind = False jcache = False save_bc = False memory_init_file = False use_preload_cache = False - make_source_map = False if use_cxx: default_cxx_std = '-std=c++03' # Enforce a consistent C++ standard when compiling .cpp files, if user does not specify one on the cmdline. @@ -724,6 +727,14 @@ try: settings_changes = [] + def validate_arg_level(level_string, max_level): + try: + level = int(level_string) + assert 0 <= level <= max_level + except: + raise Exception('Invalid argument value: ' + newargs[i]) + return level + for i in range(len(newargs)): newargs[i] = newargs[i].strip() # On Windows Vista (and possibly others), excessive spaces in the command line leak into the items in this array, so trim e.g. 'foo.cpp ' -> 'foo.cpp' if newargs[i].startswith('-O'): @@ -732,11 +743,7 @@ try: if requested_level == 's': requested_level = 2 settings_changes.append('INLINING_LIMIT=50') - try: - opt_level = int(requested_level) - assert 0 <= opt_level <= 3 - except: - raise Exception('Invalid optimization level: ' + newargs[i]) + opt_level = validate_arg_level(requested_level, 3) newargs[i] = '' elif newargs[i].startswith('--llvm-opts'): check_bad_eq(newargs[i]) @@ -778,12 +785,11 @@ try: split_js_file = int(newargs[i+1]) newargs[i] = '' newargs[i+1] = '' - elif newargs[i] == '-g': - keep_llvm_debug = True - keep_js_debug = True - elif newargs[i] == '--map': - make_source_map = True - newargs[i] = '-g' # we'll need this to get LLVM debug info + elif newargs[i].startswith('-g'): + requested_level = newargs[i][2:] or '1' + debug_level = validate_arg_level(requested_level, 2) + if debug_level > 0: + newargs[i] = '-g' # we'll need this to get LLVM debug info elif newargs[i] == '--bind': bind = True newargs[i] = '' @@ -872,11 +878,14 @@ try: if llvm_opts is None: llvm_opts = LLVM_OPT_LEVEL[opt_level] if llvm_lto is None: llvm_lto = opt_level >= 3 - if opt_level <= 0: keep_llvm_debug = keep_js_debug = True # always keep debug in -O0 - if opt_level > 0: keep_llvm_debug = False # JS optimizer wipes out llvm debug info - if make_source_map: keep_llvm_debug = True; keep_js_debug = True + if opt_level <= 0: debug_level = max(debug_level, 1) # always keep debug in -O0 if closure is None and opt_level == 3: closure = True + # TODO: support source maps with js_transform + if js_transform and debug_level >= 2: + logging.warning('disabling source maps because a js transform is being done') + debug_level = 1 + if DEBUG: start_time = time.time() # done after parsing arguments, which might affect debug state if closure: @@ -1023,15 +1032,12 @@ try: if shared.Settings.ASSERTIONS and shared.Settings.ALIASING_FUNCTION_POINTERS: logging.warning('ALIASING_FUNCTION_POINTERS is on, function pointer comparisons may be invalid across types') - if shared.Settings.CORRECT_SIGNS >= 2 or shared.Settings.CORRECT_OVERFLOWS >= 2 or shared.Settings.CORRECT_ROUNDINGS >= 2: - keep_llvm_debug = True # must keep debug info to do line-by-line operations - - if (keep_llvm_debug or keep_js_debug) and closure: + if debug_level >= 1 and closure: logging.warning('disabling closure because debug info was requested') closure = False if minify_whitespace is None: - minify_whitespace = opt_level >= 2 and not keep_js_debug + minify_whitespace = opt_level >= 2 and debug_level == 0 assert shared.LLVM_TARGET in shared.COMPILER_OPTS if shared.LLVM_TARGET == 'i386-pc-linux-gnu': @@ -1401,7 +1407,13 @@ try: # Optimize, if asked to if not LEAVE_INPUTS_RAW: - link_opts = [] if keep_llvm_debug else ['-strip-debug'] # remove LLVM debug info in -O1+, since the optimizer removes it anyhow + + if opt_level == 0 or debug_level >= 2 or shared.Settings.CORRECT_SIGNS >= 2 or \ + shared.Settings.CORRECT_OVERFLOWS >= 2 or shared.Settings.CORRECT_ROUNDINGS >= 2: + link_opts = [] + else: + link_opts = ['-strip-debug'] # remove LLVM debug info in -O1+, since the optimizer removes it anyhow + if llvm_opts > 0: if not os.environ.get('EMCC_OPTIMIZE_NORMALLY'): shared.Building.llvm_opt(in_temp(target_basename + '.bc'), llvm_opts) @@ -1485,9 +1497,6 @@ try: # Apply a source code transformation, if requested if js_transform: - # TODO: support source maps with js_transform - logging.warning('disabling source maps because a js transform is being done') - make_source_map = False shutil.copyfile(final, final + '.tr.js') final += '.tr.js' posix = True if not shared.WINDOWS else False @@ -1506,7 +1515,7 @@ try: if shared.Settings.ASM_JS: js_optimizer_queue = ['asm'] + js_optimizer_queue logging.debug('applying js optimization passes: %s', js_optimizer_queue) - final = shared.Building.js_optimizer(final, js_optimizer_queue, jcache, make_source_map) + final = shared.Building.js_optimizer(final, js_optimizer_queue, jcache, debug_level >= 2) js_transform_tempfiles.append(final) if DEBUG: save_intermediate('js_opts') else: @@ -1515,7 +1524,7 @@ try: if shared.Settings.ASM_JS: passes = ['asm'] + passes logging.debug('applying js optimization pass: %s', passes) - final = shared.Building.js_optimizer(final, passes, jcache, make_source_map) + final = shared.Building.js_optimizer(final, passes, jcache, debug_level >= 2) js_transform_tempfiles.append(final) save_intermediate(name) js_optimizer_queue = [] @@ -1525,7 +1534,7 @@ try: if DEBUG == '2': # Clean up the syntax a bit - final = shared.Building.js_optimizer(final, [], jcache, make_source_map) + final = shared.Building.js_optimizer(final, [], jcache, debug_level >= 2) js_transform_tempfiles.append(final) if DEBUG: save_intermediate('pretty') @@ -1545,7 +1554,7 @@ try: logging.debug('running closure') # no need to add this to js_transform_tempfiles, because closure and - # keep_js_debug are never simultaneously true + # debug_level > 0 are never simultaneously true final = shared.Building.closure_compiler(final) if DEBUG: save_intermediate('closure') @@ -1553,7 +1562,7 @@ try: logging.debug('running post-closure post-opts') js_optimizer_queue += ['simplifyExpressionsPost'] - if (not closure or shared.Settings.ASM_JS) and shared.Settings.RELOOP and not keep_js_debug: + if (not closure or shared.Settings.ASM_JS) and shared.Settings.RELOOP and debug_level == 0: # do this if closure is not enabled (it gives similar speedups), and we do not need to keep debug info around js_optimizer_queue += ['registerize'] @@ -1614,7 +1623,7 @@ try: shell = open(shell_path).read() html = open(target, 'w') if not Compression.on: - if make_source_map: + if debug_level >= 2: match = re.match('.*?]*>{{{ SCRIPT_CODE }}}', shell, re.DOTALL) if match is None: @@ -1690,7 +1699,7 @@ try: from tools.split import split_javascript_file split_javascript_file(final, unsuffixed(target), split_js_file) else: - if make_source_map: generate_source_map(target) + if debug_level >= 2: generate_source_map(target) # copy final JS to output shutil.move(final, target) diff --git a/tests/runner.py b/tests/runner.py index cd0ca35754d0a..27e3d9b7ab73e 100755 --- a/tests/runner.py +++ b/tests/runner.py @@ -9607,12 +9607,12 @@ def test_source_map(self): src_filename = os.path.join(dirname, 'src.cpp') no_maps_filename = os.path.join(dirname, 'no-maps.out.js') with open(src_filename, 'w') as f: f.write(src) - assert '--map' not in Building.COMPILER_TEST_OPTS + assert '-g2' not in Building.COMPILER_TEST_OPTS Building.emcc(src_filename, Settings.serialize() + self.emcc_args + Building.COMPILER_TEST_OPTS, no_maps_filename) with open(no_maps_filename) as f: no_maps_file = f.read() out_filename = os.path.join(dirname, 'a.out.js') - Building.COMPILER_TEST_OPTS.append('--map') + Building.COMPILER_TEST_OPTS.append('-g2') def build_and_check(): import json @@ -9656,7 +9656,7 @@ def build_and_check(): def test_exception_source_map(self): if Settings.USE_TYPED_ARRAYS != 2: return self.skip("doesn't pass without typed arrays") - if '--map' not in Building.COMPILER_TEST_OPTS: Building.COMPILER_TEST_OPTS.append('--map') + if '-g2' not in Building.COMPILER_TEST_OPTS: Building.COMPILER_TEST_OPTS.append('-g2') src = ''' #include @@ -11821,7 +11821,7 @@ def test_html_source_map(self): ''') # use relative paths when calling emcc, because file:// URIs can only load # sourceContent when the maps are relative paths - Popen([PYTHON, EMCC, 'src.cpp', '-o', 'src.html', '--map'], + Popen([PYTHON, EMCC, 'src.cpp', '-o', 'src.html', '-g2'], cwd=self.get_dir()).communicate() webbrowser.open_new('file://' + html_file) print ''' From 2b54c4f9164df8e7aced49930926589f7524de42 Mon Sep 17 00:00:00 2001 From: Jez Ng Date: Sat, 22 Jun 2013 03:33:41 -0700 Subject: [PATCH 34/69] Fix up the source map JS output 'reftest'. Without re.MULTILINE, the regexp wasn't actually matching anything... --- tests/runner.py | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/tests/runner.py b/tests/runner.py index 27e3d9b7ab73e..473bd86eb27ec 100755 --- a/tests/runner.py +++ b/tests/runner.py @@ -9586,6 +9586,7 @@ def process(filename): def test_source_map(self): if Settings.USE_TYPED_ARRAYS != 2: return self.skip("doesn't pass without typed arrays") + if NODE_JS not in JS_ENGINES: return self.skip('sourcemapper requires Node to run') if '-g' not in Building.COMPILER_TEST_OPTS: Building.COMPILER_TEST_OPTS.append('-g') src = ''' @@ -9605,13 +9606,18 @@ def test_source_map(self): dirname = self.get_dir() src_filename = os.path.join(dirname, 'src.cpp') + out_filename = os.path.join(dirname, 'a.out.js') no_maps_filename = os.path.join(dirname, 'no-maps.out.js') + with open(src_filename, 'w') as f: f.write(src) assert '-g2' not in Building.COMPILER_TEST_OPTS Building.emcc(src_filename, Settings.serialize() + self.emcc_args + - Building.COMPILER_TEST_OPTS, no_maps_filename) + Building.COMPILER_TEST_OPTS, out_filename) + # the file name may find its way into the generated code, so make sure we + # can do an apples-to-apples comparison by compiling with the same file name + shutil.move(out_filename, no_maps_filename) with open(no_maps_filename) as f: no_maps_file = f.read() - out_filename = os.path.join(dirname, 'a.out.js') + no_maps_file = re.sub(' *//@.*$', '', no_maps_file, flags=re.MULTILINE) Building.COMPILER_TEST_OPTS.append('-g2') def build_and_check(): @@ -9624,7 +9630,7 @@ def build_and_check(): # this is worth checking because the parser AST swaps strings for token # objects when generating source maps, so we want to make sure the # optimizer can deal with both types. - out_file = re.sub('//@.*$', '', out_file) + out_file = re.sub(' *//@.*$', '', out_file, flags=re.MULTILINE) self.assertIdentical(no_maps_file, out_file) map_filename = out_filename + '.map' data = json.load(open(map_filename, 'r')) @@ -9657,6 +9663,7 @@ def build_and_check(): def test_exception_source_map(self): if Settings.USE_TYPED_ARRAYS != 2: return self.skip("doesn't pass without typed arrays") if '-g2' not in Building.COMPILER_TEST_OPTS: Building.COMPILER_TEST_OPTS.append('-g2') + if NODE_JS not in JS_ENGINES: return self.skip('sourcemapper requires Node to run') src = ''' #include From 8f1a7e5546f5b10263c176e507dba8d548161c86 Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Sat, 22 Jun 2013 09:42:37 -0700 Subject: [PATCH 35/69] show auto-linking decision process only in VERBOSE --- emcc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/emcc b/emcc index e76c987051a85..6c5b1f519772e 100755 --- a/emcc +++ b/emcc @@ -1354,7 +1354,7 @@ try: for haz in has: # remove symbols that are supplied by another of the inputs if haz in need: need.remove(haz) - logging.debug('considering %s: we need %s and have %s' % (name, str(need), str(has))) + if shared.Settings.VERBOSE: logging.debug('considering %s: we need %s and have %s' % (name, str(need), str(has))) if (force or len(need) > 0) and apply_(need): # We need to build and link the library in logging.debug('including %s' % name) From 2978204196fa7993490305a2e38598edfa868171 Mon Sep 17 00:00:00 2001 From: manny/MADE Date: Sat, 22 Jun 2013 21:04:28 +0200 Subject: [PATCH 36/69] IMPROVED: fixed codestyle to match java/js IMPROVED: handling mouse position when pointer is locked --- src/library_browser.js | 21 +++++++++------------ 1 file changed, 9 insertions(+), 12 deletions(-) diff --git a/src/library_browser.js b/src/library_browser.js index a5cec33788a93..04c8951dfb0ee 100644 --- a/src/library_browser.js +++ b/src/library_browser.js @@ -427,15 +427,14 @@ mergeInto(LibraryManager.library, { } // check if SDL is available - if (typeof SDL != "undefined") - { + if (typeof SDL != "undefined") { Browser.mouseX = SDL.mouseX + Browser.mouseMovementX; Browser.mouseY = SDL.mouseY + Browser.mouseMovementY; - } - else - { - Browser.mouseX = Browser.mouseMovementX; - Browser.mouseY = Browser.mouseMovementY; + } else { + // just add the mouse delta to the current absolut mouse position + // FIXME: ideally this should be clamped against the canvas size and zero + Browser.mouseX += Browser.mouseMovementX; + Browser.mouseY += Browser.mouseMovementY; } } else { // Otherwise, calculate the movement based on the changes @@ -512,10 +511,9 @@ mergeInto(LibraryManager.library, { this.windowedWidth = canvas.width; this.windowedHeight = canvas.height; canvas.width = screen.width; - canvas.height = screen.height; + canvas.height = screen.height; // check if SDL is available - if (typeof SDL != "undefined") - { + if (typeof SDL != "undefined") { var flags = {{{ makeGetValue('SDL.screen+Runtime.QUANTUM_SIZE*0', '0', 'i32', 0, 1) }}}; flags = flags | 0x00800000; // set SDL_FULLSCREEN flag {{{ makeSetValue('SDL.screen+Runtime.QUANTUM_SIZE*0', '0', 'flags', 'i32') }}} @@ -528,8 +526,7 @@ mergeInto(LibraryManager.library, { canvas.width = this.windowedWidth; canvas.height = this.windowedHeight; // check if SDL is available - if (typeof SDL != "undefined") - { + if (typeof SDL != "undefined") { var flags = {{{ makeGetValue('SDL.screen+Runtime.QUANTUM_SIZE*0', '0', 'i32', 0, 1) }}}; flags = flags & ~0x00800000; // clear SDL_FULLSCREEN flag {{{ makeSetValue('SDL.screen+Runtime.QUANTUM_SIZE*0', '0', 'flags', 'i32') }}} From 369167ebda362eb0c76081976ae0a48d2d3c1cbd Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Sat, 22 Jun 2013 13:21:54 -0700 Subject: [PATCH 37/69] -gLEVEL ; support varying degrees of debuggability --- emcc | 76 +++++++++++++++++++++++++++---------------------- tests/runner.py | 6 ++-- 2 files changed, 45 insertions(+), 37 deletions(-) diff --git a/emcc b/emcc index 6c5b1f519772e..12d2c1b339f88 100755 --- a/emcc +++ b/emcc @@ -182,16 +182,31 @@ Options that are modified or new in %s include: ). Note that the path must be absolute, not relative. - -g Use debug info. Note that you need this during - the last compilation phase from bitcode to - JavaScript, or else we will remove it by - default in -O1 and above. - In -O0, line numbers wil be shown in the - generated code. In -O1 and above, the optimizer - removes those comments. This flag does however - have the effect of disabling anything that - causes name mangling or minification (closure - or the registerize pass). + -g Use debug info. When compiling to bitcode, + this is the same as in clang and gcc, it + adds debug info to the object files. When + compiling from source to JS or bitcode to JS, + it is equivalent to -g3 (keep code as debuggable + as possible, except for discarding LLVM + debug info, so no C/C++ line numbers; use + -g4 to get line number debugging info in JS). + + -g When compiling from bitcode to JS, we can + keep the code debuggable to different + degrees. Each of these levels builds on the + previous: + + -g0 Make no effort to keep code debuggable. + Will discard LLVM debug info. (default + in -O1+) + -g1 Preserve (do not minify) whitespace + -g2 Preserve function names + -g3 Preserve variable names + -g4 Preserve LLVM debug info (if -g was + used when compiling the C/C++ sources) + and show line number debug comments. + This is the highest level of debuggability. + (default in -O0) --typed-arrays 0: No typed arrays 1: Parallel typed arrays @@ -303,12 +318,7 @@ Options that are modified or new in %s include: archive, which is given the same name as the output HTML but with suffix .data.compress - --minify 0: Do not minify the generated JavaScript's - whitespace (default in -O0, -O1, or if - -g is used) - 1: Minify the generated JavaScript's - whitespace (default in -O2+, assuming - -g is not used) + --minify 0 Identical to -g1 --split Splits the resulting javascript file into pieces to ease debugging. This option only works if @@ -689,13 +699,13 @@ try: newargs = sys.argv[1:] opt_level = 0 + debug_level = 0 llvm_opts = None llvm_lto = None closure = None js_transform = None pre_js = '' post_js = '' - minify_whitespace = None split_js_file = None preload_files = [] embed_files = [] @@ -703,8 +713,6 @@ try: ignore_dynamic_linking = False shell_path = shared.path_from_root('src', 'shell.html') js_libraries = [] - keep_llvm_debug = False - keep_js_debug = False bind = False jcache = False save_bc = False @@ -769,7 +777,7 @@ try: newargs[i+1] = '' elif newargs[i].startswith('--minify'): check_bad_eq(newargs[i]) - minify_whitespace = int(newargs[i+1]) + debug_level = max(1, debug_level) newargs[i] = '' newargs[i+1] = '' elif newargs[i].startswith('--split'): @@ -777,9 +785,14 @@ try: split_js_file = int(newargs[i+1]) newargs[i] = '' newargs[i+1] = '' - elif newargs[i] == '-g': - keep_llvm_debug = True - keep_js_debug = True + elif newargs[i].startswith('-g'): + requested_level = newargs[i][2:] or '3' + try: + debug_level = int(requested_level) + assert 0 <= debug_level <= 4 + except: + raise Exception('Invalid debug level: ' + newargs[i]) + newargs[i] = '-g' # discard level for clang args elif newargs[i] == '--bind': bind = True newargs[i] = '' @@ -868,8 +881,7 @@ try: if llvm_opts is None: llvm_opts = LLVM_OPT_LEVEL[opt_level] if llvm_lto is None: llvm_lto = opt_level >= 3 - if opt_level <= 0: keep_llvm_debug = keep_js_debug = True # always keep debug in -O0 - if opt_level > 0: keep_llvm_debug = False # JS optimizer wipes out llvm debug info from being visible + if opt_level == 0: debug_level = 4 if closure is None and opt_level == 3: closure = True if DEBUG: start_time = time.time() # done after parsing arguments, which might affect debug state @@ -1019,15 +1031,12 @@ try: logging.warning('ALIASING_FUNCTION_POINTERS is on, function pointer comparisons may be invalid across types') if shared.Settings.CORRECT_SIGNS >= 2 or shared.Settings.CORRECT_OVERFLOWS >= 2 or shared.Settings.CORRECT_ROUNDINGS >= 2: - keep_llvm_debug = True # must keep debug info to do line-by-line operations + debug_level = 4 # must keep debug info to do line-by-line operations - if (keep_llvm_debug or keep_js_debug) and closure: + if debug_level > 0 and closure: logging.warning('disabling closure because debug info was requested') closure = False - if minify_whitespace is None: - minify_whitespace = opt_level >= 2 and not keep_js_debug - assert shared.LLVM_TARGET in shared.COMPILER_OPTS if shared.LLVM_TARGET == 'i386-pc-linux-gnu': shared.Settings.TARGET_X86 = 1 @@ -1398,7 +1407,7 @@ try: # Optimize, if asked to if not LEAVE_INPUTS_RAW: - link_opts = [] if keep_llvm_debug else ['-strip-debug'] # remove LLVM debug info in -O1+, since the optimizer removes it anyhow + link_opts = [] if debug_level >= 4 else ['-strip-debug'] # remove LLVM debug if we are not asked for it if llvm_opts > 0: if not os.environ.get('EMCC_OPTIMIZE_NORMALLY'): shared.Building.llvm_opt(in_temp(target_basename + '.bc'), llvm_opts) @@ -1540,11 +1549,10 @@ try: logging.debug('running post-closure post-opts') js_optimizer_queue += ['simplifyExpressionsPost'] - if (not closure or shared.Settings.ASM_JS) and shared.Settings.RELOOP and not keep_js_debug: - # do this if closure is not enabled (it gives similar speedups), and we do not need to keep debug info around + if (not closure or shared.Settings.ASM_JS) and shared.Settings.RELOOP and debug_level < 3: js_optimizer_queue += ['registerize'] - if minify_whitespace: + if debug_level == 0 and opt_level > 0: js_optimizer_queue += ['compress'] if closure and shared.Settings.ASM_JS: diff --git a/tests/runner.py b/tests/runner.py index bcd8e84cf9aab..f8ca43431bc30 100755 --- a/tests/runner.py +++ b/tests/runner.py @@ -10160,8 +10160,8 @@ def test_emcc(self): assert 'SAFE_HEAP' not in generated, 'safe heap should not be used by default' assert ': while(' not in generated, 'when relooping we also js-optimize, so there should be no labelled whiles' if closure: - if opt_level <= 1: assert 'Module._main =' in generated, 'closure compiler should have been run' - elif opt_level >= 2: assert 'Module._main=' in generated, 'closure compiler should have been run (and output should be minified)' + if opt_level == 0: assert 'Module._main =' in generated, 'closure compiler should have been run' + elif opt_level >= 1: assert 'Module._main=' in generated, 'closure compiler should have been run (and output should be minified)' else: # closure has not been run, we can do some additional checks. TODO: figure out how to do these even with closure assert 'Module._main = ' not in generated, 'closure compiler should not have been run' @@ -10172,7 +10172,7 @@ def test_emcc(self): if opt_level >= 2 and '-g' in params: assert re.search('HEAP8\[\$?\w+ ?\+ ?\(+\$?\w+ ?', generated) or re.search('HEAP8\[HEAP32\[', generated), 'eliminator should create compound expressions, and fewer one-time vars' # also in -O1, but easier to test in -O2 assert ('_puts(' in generated) == (opt_level >= 1), 'with opt >= 1, llvm opts are run and they should optimize printf to puts' - if opt_level <= 1 or '-g' in params: assert 'function _main() {' in generated, 'Should be unminified, including whitespace' + if opt_level == 0 or '-g' in params: assert 'function _main() {' in generated, 'Should be unminified, including whitespace' elif opt_level >= 2: assert ('function _main(){' in generated or '"use asm";var a=' in generated), 'Should be whitespace-minified' # emcc -s RELOOP=1 src.cpp ==> should pass -s to emscripten.py. --typed-arrays is a convenient alias for -s USE_TYPED_ARRAYS From 202461abe30f260cf403d430e51d80f225950605 Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Sat, 22 Jun 2013 15:02:10 -0700 Subject: [PATCH 38/69] fix -g2 and add testing --- emcc | 5 +++-- tests/runner.py | 5 +++++ tools/js-optimizer.js | 10 +++++----- tools/js_optimizer.py | 18 ++++++++++-------- 4 files changed, 23 insertions(+), 15 deletions(-) diff --git a/emcc b/emcc index 12d2c1b339f88..19e30d579ccb8 100755 --- a/emcc +++ b/emcc @@ -1552,8 +1552,9 @@ try: if (not closure or shared.Settings.ASM_JS) and shared.Settings.RELOOP and debug_level < 3: js_optimizer_queue += ['registerize'] - if debug_level == 0 and opt_level > 0: - js_optimizer_queue += ['compress'] + if opt_level > 0: + if debug_level < 2 and shared.Settings.ASM_JS: js_optimizer_queue += ['minifyGlobals'] + if debug_level == 0: js_optimizer_queue += ['minifyWhitespace'] if closure and shared.Settings.ASM_JS: js_optimizer_queue += ['closure'] diff --git a/tests/runner.py b/tests/runner.py index f8ca43431bc30..3d98cf2c2461a 100755 --- a/tests/runner.py +++ b/tests/runner.py @@ -10182,6 +10182,11 @@ def test_emcc(self): (['-O2'], lambda generated: 'var b=0' in generated and not 'function _main' in generated, 'registerize/minify is run by default in -O2'), (['-O2', '--minify', '0'], lambda generated: 'var b = 0' in generated and not 'function _main' in generated, 'minify is cancelled, but not registerize'), (['-O2', '-g'], lambda generated: 'var b=0' not in generated and 'var b = 0' not in generated and 'function _main' in generated, 'registerize/minify is cancelled by -g'), + (['-O2', '-g0'], lambda generated: 'var b=0' in generated and not 'function _main' in generated, 'registerize/minify is run by default in -O2 -g0'), + (['-O2', '-g1'], lambda generated: 'var b = 0' in generated and not 'function _main' in generated, 'compress is cancelled by -g1'), + (['-O2', '-g2'], lambda generated: 'var b = 0' in generated and 'function _main' in generated, 'minify is cancelled by -g2'), + (['-O2', '-g3'], lambda generated: 'var b=0' not in generated and 'var b = 0' not in generated and 'function _main' in generated, 'registerize is cancelled by -g3'), + #(['-O2', '-g4'], lambda generated: 'var b=0' not in generated and 'var b = 0' not in generated and 'function _main' in generated, 'same as -g3 for now'), (['-s', 'INLINING_LIMIT=0'], lambda generated: 'function _dump' in generated, 'no inlining without opts'), (['-O3', '-s', 'INLINING_LIMIT=0', '--closure', '0'], lambda generated: 'function _dump' not in generated, 'lto/inlining'), (['-Os', '--llvm-lto', '1', '-s', 'ASM_JS=0'], lambda generated: 'function _dump' in generated, '-Os disables inlining'), diff --git a/tools/js-optimizer.js b/tools/js-optimizer.js index ae72437b69113..fba97a14c6175 100644 --- a/tools/js-optimizer.js +++ b/tools/js-optimizer.js @@ -149,10 +149,10 @@ function srcToAst(src) { return uglify.parser.parse(src); } -function astToSrc(ast, compress) { +function astToSrc(ast, minifyWhitespace) { return uglify.uglify.gen_code(ast, { ascii_only: true, - beautify: !compress, + beautify: !minifyWhitespace, indent_level: 1 }); } @@ -2759,7 +2759,7 @@ function asmLoopOptimizer(ast) { // Passes table -var compress = false, printMetadata = true, asm = false, last = false; +var minifyWhitespace = false, printMetadata = true, asm = false, last = false; var passes = { dumpAst: dumpAst, @@ -2777,7 +2777,7 @@ var passes = { eliminate: eliminate, eliminateMemSafe: eliminateMemSafe, minifyGlobals: minifyGlobals, - compress: function() { compress = true }, + minifyWhitespace: function() { minifyWhitespace = true }, noPrintMetadata: function() { printMetadata = false }, asm: function() { asm = true }, last: function() { last = true }, @@ -2803,7 +2803,7 @@ if (asm && last) { asmLoopOptimizer(ast); prepDotZero(ast); } -var js = astToSrc(ast, compress), old; +var js = astToSrc(ast, minifyWhitespace), old; if (asm && last) { js = fixDotZero(js); } diff --git a/tools/js_optimizer.py b/tools/js_optimizer.py index 0452a72595e26..f014c7d467517 100644 --- a/tools/js_optimizer.py +++ b/tools/js_optimizer.py @@ -57,7 +57,7 @@ def __init__(self, js, js_engine): if curr not in INVALID_3: self.names.append(curr) #print >> sys.stderr, self.names - def minify_shell(self, shell, compress): + def minify_shell(self, shell, minify_whitespace): #print >> sys.stderr, "MINIFY SHELL 1111111111", shell, "\n222222222222222" # Run through js-optimizer.js to find and minify the global symbols # We send it the globals, which it parses at the proper time. JS decides how @@ -77,7 +77,7 @@ def minify_shell(self, shell, compress): f.write('// MINIFY_INFO:' + self.serialize()) f.close() - output = subprocess.Popen(self.js_engine + [JS_OPTIMIZER, temp_file, 'minifyGlobals', 'noPrintMetadata'] + (['compress'] if compress else []), stdout=subprocess.PIPE).communicate()[0] + output = subprocess.Popen(self.js_engine + [JS_OPTIMIZER, temp_file, 'minifyGlobals', 'noPrintMetadata'] + (['minifyWhitespace'] if minify_whitespace else []), stdout=subprocess.PIPE).communicate()[0] assert len(output) > 0 and not output.startswith('Assertion failed'), 'Error in js optimizer: ' + output #print >> sys.stderr, "minified SHELL 3333333333333333", output, "\n44444444444444444444" code, metadata = output.split('// MINIFY_INFO:') @@ -130,8 +130,10 @@ def run_on_js(filename, passes, js_engine, jcache): start_funcs = js.find(start_funcs_marker) end_funcs = js.rfind(end_funcs_marker) #assert (start_funcs >= 0) == (end_funcs >= 0) == (not not suffix) - asm_registerize = 'asm' in passes and 'registerize' in passes - if asm_registerize: + + minify_globals = 'minifyGlobals' in passes + if minify_globals: + passes = filter(lambda p: p != 'minifyGlobals', passes) # we will run it manually start_asm_marker = '// EMSCRIPTEN_START_ASM\n' end_asm_marker = '// EMSCRIPTEN_END_ASM\n' start_asm = js.find(start_asm_marker) @@ -146,7 +148,7 @@ def run_on_js(filename, passes, js_engine, jcache): jcache = False if suffix: - if not asm_registerize: + if not minify_globals: pre = js[:start_funcs + len(start_funcs_marker)] post = js[end_funcs + len(end_funcs_marker):] js = js[start_funcs + len(start_funcs_marker):end_funcs] @@ -171,7 +173,7 @@ def process(line): js = js[start_funcs + len(start_funcs_marker):end_funcs] minifier = Minifier(js, js_engine) - asm_shell_pre, asm_shell_post = minifier.minify_shell(asm_shell, 'compress' in passes).split('EMSCRIPTEN_FUNCS();'); + asm_shell_pre, asm_shell_post = minifier.minify_shell(asm_shell, 'minifyWhitespace' in passes).split('EMSCRIPTEN_FUNCS();'); asm_shell_post = asm_shell_post.replace('});', '})'); pre += asm_shell_pre + '\n' + start_funcs_marker post = end_funcs_marker + asm_shell_post + post @@ -236,7 +238,7 @@ def write_chunk(chunk, i): f = open(temp_file, 'w') f.write(chunk) f.write(suffix_marker) - if asm_registerize: + if minify_globals: f.write('\n') f.write('// MINIFY_INFO:' + minify_info) f.close() @@ -279,7 +281,7 @@ def write_chunk(chunk, i): c.write(closure_sep) c.write(post_2) c.close() - closured = shared.Building.closure_compiler(closuree, pretty='compress' not in passes) + closured = shared.Building.closure_compiler(closuree, pretty='minifyWhitespace' not in passes) temp_files.note(closured) coutput = open(closured).read() coutput = coutput.replace('wakaUnknownBefore();', '') From 61b60b7f130858d352e1cfc6bc76c55dc11789b8 Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Sat, 22 Jun 2013 15:32:03 -0700 Subject: [PATCH 39/69] only minify globals when relooping --- emcc | 2 +- tools/js_optimizer.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/emcc b/emcc index 19e30d579ccb8..0b75fce40bc3c 100755 --- a/emcc +++ b/emcc @@ -1553,7 +1553,7 @@ try: js_optimizer_queue += ['registerize'] if opt_level > 0: - if debug_level < 2 and shared.Settings.ASM_JS: js_optimizer_queue += ['minifyGlobals'] + if debug_level < 2 and shared.Settings.ASM_JS and shared.Settings.RELOOP: js_optimizer_queue += ['minifyGlobals'] if debug_level == 0: js_optimizer_queue += ['minifyWhitespace'] if closure and shared.Settings.ASM_JS: diff --git a/tools/js_optimizer.py b/tools/js_optimizer.py index f014c7d467517..6788f196517d9 100644 --- a/tools/js_optimizer.py +++ b/tools/js_optimizer.py @@ -131,7 +131,7 @@ def run_on_js(filename, passes, js_engine, jcache): end_funcs = js.rfind(end_funcs_marker) #assert (start_funcs >= 0) == (end_funcs >= 0) == (not not suffix) - minify_globals = 'minifyGlobals' in passes + minify_globals = 'minifyGlobals' in passes and 'registerize' in passes and 'asm' in passes if minify_globals: passes = filter(lambda p: p != 'minifyGlobals', passes) # we will run it manually start_asm_marker = '// EMSCRIPTEN_START_ASM\n' From a86a9f898bdb7f3dbe91c6d64d72cb7ef693ce86 Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Sat, 22 Jun 2013 15:43:40 -0700 Subject: [PATCH 40/69] update test --- tests/runner.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/runner.py b/tests/runner.py index 3d98cf2c2461a..672ae456f8b86 100755 --- a/tests/runner.py +++ b/tests/runner.py @@ -10184,7 +10184,7 @@ def test_emcc(self): (['-O2', '-g'], lambda generated: 'var b=0' not in generated and 'var b = 0' not in generated and 'function _main' in generated, 'registerize/minify is cancelled by -g'), (['-O2', '-g0'], lambda generated: 'var b=0' in generated and not 'function _main' in generated, 'registerize/minify is run by default in -O2 -g0'), (['-O2', '-g1'], lambda generated: 'var b = 0' in generated and not 'function _main' in generated, 'compress is cancelled by -g1'), - (['-O2', '-g2'], lambda generated: 'var b = 0' in generated and 'function _main' in generated, 'minify is cancelled by -g2'), + (['-O2', '-g2'], lambda generated: ('var b = 0' in generated or 'var i1 = 0' in generated) and 'function _main' in generated, 'minify is cancelled by -g2'), (['-O2', '-g3'], lambda generated: 'var b=0' not in generated and 'var b = 0' not in generated and 'function _main' in generated, 'registerize is cancelled by -g3'), #(['-O2', '-g4'], lambda generated: 'var b=0' not in generated and 'var b = 0' not in generated and 'function _main' in generated, 'same as -g3 for now'), (['-s', 'INLINING_LIMIT=0'], lambda generated: 'function _dump' in generated, 'no inlining without opts'), From fa2481c976a0873690bf3f5f0b2b4b676c1a004b Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Sat, 22 Jun 2013 19:33:26 -0700 Subject: [PATCH 41/69] remove unneeded line --- tools/js_optimizer.py | 1 - 1 file changed, 1 deletion(-) diff --git a/tools/js_optimizer.py b/tools/js_optimizer.py index 6788f196517d9..923daa3ce2794 100644 --- a/tools/js_optimizer.py +++ b/tools/js_optimizer.py @@ -73,7 +73,6 @@ def minify_shell(self, shell, minify_whitespace): f = open(temp_file, 'w') f.write(shell) f.write('\n') - self f.write('// MINIFY_INFO:' + self.serialize()) f.close() From c001e260ef766875fba65ae1f9848cfe6add90c7 Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Sat, 22 Jun 2013 20:11:50 -0700 Subject: [PATCH 42/69] clean up closure calling --- tools/js-optimizer.js | 1 - tools/js_optimizer.py | 6 +++++- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/tools/js-optimizer.js b/tools/js-optimizer.js index fba97a14c6175..5d7704d756dbb 100644 --- a/tools/js-optimizer.js +++ b/tools/js-optimizer.js @@ -2781,7 +2781,6 @@ var passes = { noPrintMetadata: function() { printMetadata = false }, asm: function() { asm = true }, last: function() { last = true }, - closure: function(){} // handled in python }; // Main diff --git a/tools/js_optimizer.py b/tools/js_optimizer.py index 923daa3ce2794..b610206c31c66 100644 --- a/tools/js_optimizer.py +++ b/tools/js_optimizer.py @@ -139,6 +139,10 @@ def run_on_js(filename, passes, js_engine, jcache): end_asm = js.rfind(end_asm_marker) assert (start_asm >= 0) == (end_asm >= 0) + closure = 'closure' in passes + if closure: + passes = filter(lambda p: p != 'closure', passes) # we will do it manually + if not suffix and jcache: # JCache cannot be used without metadata, since it might reorder stuff, and that's dangerous since only generated can be reordered # This means jcache does not work after closure compiler runs, for example. But you won't get much benefit from jcache with closure @@ -266,7 +270,7 @@ def write_chunk(chunk, i): for filename in filenames: temp_files.note(filename) - if 'closure' in passes: + if closure: # run closure on the shell code, everything but what we js-optimize start_asm = '// EMSCRIPTEN_START_ASM\n' end_asm = '// EMSCRIPTEN_END_ASM\n' From 5eaa7ba8af13eca8bf14375acb23b462472a8f3c Mon Sep 17 00:00:00 2001 From: Jez Ng Date: Sat, 22 Jun 2013 23:47:26 -0700 Subject: [PATCH 43/69] Ensure original test environment is restored. --- tests/runner.py | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/tests/runner.py b/tests/runner.py index 77c32695bc693..564013984a7a1 100755 --- a/tests/runner.py +++ b/tests/runner.py @@ -9652,13 +9652,15 @@ def build_and_check(): # line numbers across all those files. old_emcc_debug = os.environ.get('EMCC_DEBUG', None) os.environ.pop('EMCC_DEBUG', None) - build_and_check() - os.environ['EMCC_DEBUG'] = '2' - build_and_check() - if old_emcc_debug is not None: - os.environ['EMCC_DEBUG'] = old_emcc_debug - else: - del os.environ['EMCC_DEBUG'] + try: + build_and_check() + os.environ['EMCC_DEBUG'] = '2' + build_and_check() + finally: + if old_emcc_debug is not None: + os.environ['EMCC_DEBUG'] = old_emcc_debug + else: + del os.environ['EMCC_DEBUG'] def test_exception_source_map(self): if Settings.USE_TYPED_ARRAYS != 2: return self.skip("doesn't pass without typed arrays") From 26f17cca734aca2b6717e16f0f22ead0e43571b8 Mon Sep 17 00:00:00 2001 From: manny/MADE Date: Mon, 24 Jun 2013 11:00:45 +0200 Subject: [PATCH 44/69] IMPROVED: ensured proper indentation for entire document --- src/library_glut.js | 40 +++++++++++++++++++--------------------- 1 file changed, 19 insertions(+), 21 deletions(-) diff --git a/src/library_glut.js b/src/library_glut.js index 6fc935743ee96..36d4778797527 100644 --- a/src/library_glut.js +++ b/src/library_glut.js @@ -117,9 +117,9 @@ var LibraryGLUT = { if (48 <= keycode && keycode <= 57) return keycode; // numeric TODO handle shift? if (65 <= keycode && keycode <= 90) - return event['shiftKey'] ? keycode : keycode + 32; + return event['shiftKey'] ? keycode : keycode + 32; if (106 <= keycode && keycode <= 111) - return keycode - 106 + 42; // *,+-./ TODO handle shift? + return keycode - 106 + 42; // *,+-./ TODO handle shift? switch (keycode) { case 27: // escape @@ -227,7 +227,7 @@ var LibraryGLUT = { } else { width = GLUT.windowWidth; height = GLUT.windowHeight; - // TODO set position + // TODO set position document.removeEventListener('fullscreenchange', GLUT.onFullScreenEventChange, true); document.removeEventListener('mozfullscreenchange', GLUT.onFullScreenEventChange, true); document.removeEventListener('webkitfullscreenchange', GLUT.onFullScreenEventChange, true); @@ -255,7 +255,7 @@ var LibraryGLUT = { document['cancelFullScreen'] || document['mozCancelFullScreen'] || document['webkitCancelFullScreen'] || - (function() {}); + (function() {}); CFS.apply(document, []); } }, @@ -273,11 +273,11 @@ var LibraryGLUT = { window.addEventListener("mousedown", GLUT.onMouseButtonDown, true); window.addEventListener("mouseup", GLUT.onMouseButtonUp, true); - Browser.resizeListeners.push(function(width, height) { - if (GLUT.reshapeFunc) { - Runtime.dynCall('vii', GLUT.reshapeFunc, [width, height]); - } - }); + Browser.resizeListeners.push(function(width, height) { + if (GLUT.reshapeFunc) { + Runtime.dynCall('vii', GLUT.reshapeFunc, [width, height]); + } + }); __ATEXIT__.push({ func: function() { window.removeEventListener("keydown", GLUT.onKeydown, true); @@ -301,25 +301,25 @@ var LibraryGLUT = { glutGet: function(type) { switch (type) { case 100: /* GLUT_WINDOW_X */ - return 0; /* TODO */ + return 0; /* TODO */ case 101: /* GLUT_WINDOW_Y */ - return 0; /* TODO */ + return 0; /* TODO */ case 102: /* GLUT_WINDOW_WIDTH */ - return Module['canvas'].width; + return Module['canvas'].width; case 103: /* GLUT_WINDOW_HEIGHT */ - return Module['canvas'].height; + return Module['canvas'].height; case 200: /* GLUT_SCREEN_WIDTH */ - return Module['canvas'].width; + return Module['canvas'].width; case 201: /* GLUT_SCREEN_HEIGHT */ - return Module['canvas'].height; + return Module['canvas'].height; case 500: /* GLUT_INIT_WINDOW_X */ - return 0; /* TODO */ + return 0; /* TODO */ case 501: /* GLUT_INIT_WINDOW_Y */ - return 0; /* TODO */ + return 0; /* TODO */ case 502: /* GLUT_INIT_WINDOW_WIDTH */ - return GLUT.initWindowWidth; + return GLUT.initWindowWidth; case 503: /* GLUT_INIT_WINDOW_HEIGHT */ - return GLUT.initWindowHeight; + return GLUT.initWindowHeight; case 700: /* GLUT_ELAPSED_TIME */ var now = Date.now(); return now - GLUT.initTime; @@ -397,10 +397,8 @@ var LibraryGLUT = { glutReshapeWindow__deps: ['$GLUT', 'glutPostRedisplay'], glutReshapeWindow: function(width, height) { GLUT.cancelFullScreen(); - // console.log("glutReshapeWindow: " + width + ", " + height); Browser.setCanvasSize(width, height); if (GLUT.reshapeFunc) { - // console.log("GLUT.reshapeFunc: " + width + ", " + height); Runtime.dynCall('vii', GLUT.reshapeFunc, [width, height]); } _glutPostRedisplay(); From 7eaba0c3322cd5e44200bedcd070e6d149f413cd Mon Sep 17 00:00:00 2001 From: "Michael J. Bishop" Date: Mon, 24 Jun 2013 10:21:13 -0400 Subject: [PATCH 45/69] Removed unnecessary "audio.paused = " statements. --- src/library_sdl.js | 5 ----- 1 file changed, 5 deletions(-) diff --git a/src/library_sdl.js b/src/library_sdl.js index 4e75f5948d2fa..176a2fae9b3cb 100644 --- a/src/library_sdl.js +++ b/src/library_sdl.js @@ -1463,7 +1463,6 @@ var LibrarySDL = { audio.play(); } audio.volume = channelInfo.volume; - audio.paused = false; return channel; }, Mix_PlayChannelTimed: 'Mix_PlayChannel', // XXX ignore Timing @@ -1521,7 +1520,6 @@ var LibrarySDL = { Module.printErr('Music is already playing. ' + SDL.music.source); } SDL.music.audio.pause(); - SDL.music.audio.paused = true; } SDL.music.audio = audio; return 0; @@ -1531,7 +1529,6 @@ var LibrarySDL = { var audio = SDL.music.audio; if (!audio) return 0; audio.pause(); - audio.paused = true; return 0; }, @@ -1539,7 +1536,6 @@ var LibrarySDL = { var audio = SDL.music.audio; if (!audio) return 0; audio.play(); - audio.paused = false; return 0; }, @@ -1590,7 +1586,6 @@ var LibrarySDL = { var info = SDL.channels[channel]; if (info && info.audio) { info.audio.pause(); - info.audio.paused = true; } else { Module.printErr('Mix_Pause: no sound found for channel: ' + channel); } From 637ad69e97761fde5ec5dee882b14f3bb49f561e Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Mon, 24 Jun 2013 10:56:08 -0700 Subject: [PATCH 46/69] add space in debug output --- emcc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/emcc b/emcc index 0b75fce40bc3c..d90d63ed3b53d 100755 --- a/emcc +++ b/emcc @@ -1063,7 +1063,7 @@ try: output_file = in_temp(unsuffixed(uniquename(input_file)) + '.o') temp_files.append(output_file) args = newargs + ['-emit-llvm', '-c', input_file, '-o', output_file] - logging.debug("running:" + call + ' '.join(args)) + logging.debug("running:" + call + ' ' + ' '.join(args)) execute([call] + args) # let compiler frontend print directly, so colors are saved (PIPE kills that) if not os.path.exists(output_file): logging.error('compiler frontend failed to generate LLVM bitcode, halting') From 9e0fc0e5cfc6c8601fb1dfcf73fb0e26fc5ae3af Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Mon, 24 Jun 2013 13:11:07 -0700 Subject: [PATCH 47/69] fix minifyGlobals in separate pass --- tools/js_optimizer.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/js_optimizer.py b/tools/js_optimizer.py index b610206c31c66..ca7f5364ff7a0 100644 --- a/tools/js_optimizer.py +++ b/tools/js_optimizer.py @@ -130,7 +130,7 @@ def run_on_js(filename, passes, js_engine, jcache): end_funcs = js.rfind(end_funcs_marker) #assert (start_funcs >= 0) == (end_funcs >= 0) == (not not suffix) - minify_globals = 'minifyGlobals' in passes and 'registerize' in passes and 'asm' in passes + minify_globals = 'minifyGlobals' in passes and 'asm' in passes if minify_globals: passes = filter(lambda p: p != 'minifyGlobals', passes) # we will run it manually start_asm_marker = '// EMSCRIPTEN_START_ASM\n' From bab35f453ae0730cd598c4bd18fe6495695522f8 Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Mon, 24 Jun 2013 13:24:30 -0700 Subject: [PATCH 48/69] unify registerize and minify passes, since they must run in conjunction --- emcc | 2 +- tools/js_optimizer.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/emcc b/emcc index d90d63ed3b53d..8368f3b1e4f0c 100755 --- a/emcc +++ b/emcc @@ -1553,7 +1553,7 @@ try: js_optimizer_queue += ['registerize'] if opt_level > 0: - if debug_level < 2 and shared.Settings.ASM_JS and shared.Settings.RELOOP: js_optimizer_queue += ['minifyGlobals'] + if debug_level < 2 and shared.Settings.ASM_JS: js_optimizer_queue = map(lambda p: p if p != 'registerize' else 'registerizeAndMinify', js_optimizer_queue) if debug_level == 0: js_optimizer_queue += ['minifyWhitespace'] if closure and shared.Settings.ASM_JS: diff --git a/tools/js_optimizer.py b/tools/js_optimizer.py index ca7f5364ff7a0..9dd3bff570422 100644 --- a/tools/js_optimizer.py +++ b/tools/js_optimizer.py @@ -130,9 +130,9 @@ def run_on_js(filename, passes, js_engine, jcache): end_funcs = js.rfind(end_funcs_marker) #assert (start_funcs >= 0) == (end_funcs >= 0) == (not not suffix) - minify_globals = 'minifyGlobals' in passes and 'asm' in passes + minify_globals = 'registerizeAndMinify' in passes and 'asm' in passes if minify_globals: - passes = filter(lambda p: p != 'minifyGlobals', passes) # we will run it manually + passes = map(lambda p: p if p != 'registerizeAndMinify' else 'registerize', passes) start_asm_marker = '// EMSCRIPTEN_START_ASM\n' end_asm_marker = '// EMSCRIPTEN_END_ASM\n' start_asm = js.find(start_asm_marker) From 6dd8e7a93724da0f97fc99e276a301ab564b65c5 Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Mon, 24 Jun 2013 13:28:50 -0700 Subject: [PATCH 49/69] rename MINIFY_INFO to EXTRA_INFO in preparation for further uses --- tools/js-optimizer.js | 38 +++++++++++++++++++------------------- tools/js_optimizer.py | 6 +++--- 2 files changed, 22 insertions(+), 22 deletions(-) diff --git a/tools/js-optimizer.js b/tools/js-optimizer.js index 5d7704d756dbb..7f0c97bae0f80 100644 --- a/tools/js-optimizer.js +++ b/tools/js-optimizer.js @@ -143,7 +143,7 @@ var FALSE_NODE = ['unary-prefix', '!', ['num', 1]]; var GENERATED_FUNCTIONS_MARKER = '// EMSCRIPTEN_GENERATED_FUNCTIONS'; var generatedFunctions = false; // whether we have received only generated functions -var minifierInfo = null; +var extraInfo = null; function srcToAst(src) { return uglify.parser.parse(src); @@ -1634,7 +1634,7 @@ function denormalizeAsm(func, data) { // Very simple 'registerization', coalescing of variables into a smaller number, // as part of minification. Globals-level minification began in a previous pass, -// we receive minifierInfo which tells us how to rename globals. (Only in asm.js.) +// we receive extraInfo which tells us how to rename globals. (Only in asm.js.) // // We do not optimize when there are switches, so this pass only makes sense with // relooping. @@ -1676,7 +1676,7 @@ function registerize(ast) { } }); vacuum(fun); - if (minifierInfo) { + if (extraInfo) { assert(asm); var usedGlobals = {}; var nextLocal = 0; @@ -1684,7 +1684,7 @@ function registerize(ast) { traverse(fun, function(node, type) { if (type == 'name') { var name = node[1]; - var minified = minifierInfo.globals[name]; + var minified = extraInfo.globals[name]; if (minified) { assert(!localVars[name], name); // locals must not shadow globals, or else we don't know which is which if (localVars[minified]) { @@ -1717,8 +1717,8 @@ function registerize(ast) { } } }); - assert(fun[1] in minifierInfo.globals, fun[1]); - fun[1] = minifierInfo.globals[fun[1]]; + assert(fun[1] in extraInfo.globals, fun[1]); + fun[1] = extraInfo.globals[fun[1]]; assert(fun[1]); var nextRegName = 0; } @@ -1726,14 +1726,14 @@ function registerize(ast) { function getNewRegName(num, name) { if (!asm) return 'r' + num; var type = asmData.vars[name]; - if (!minifierInfo) { + if (!extraInfo) { var ret = (type ? 'd' : 'i') + num; regTypes[ret] = type; return ret; } // find the next free minified name that is not used by a global that shows up in this function - while (nextRegName < minifierInfo.names.length) { - var ret = minifierInfo.names[nextRegName++]; + while (nextRegName < extraInfo.names.length) { + var ret = extraInfo.names[nextRegName++]; if (!usedGlobals[ret]) { regTypes[ret] = type; return ret; @@ -2690,16 +2690,16 @@ function minifyGlobals(ast) { var vars = node[1]; for (var i = 0; i < vars.length; i++) { var name = vars[i][0]; - assert(next < minifierInfo.names.length); - vars[i][0] = minified[name] = minifierInfo.names[next++]; + assert(next < extraInfo.names.length); + vars[i][0] = minified[name] = extraInfo.names[next++]; } } }); // add all globals in function chunks, i.e. not here but passed to us - for (var i = 0; i < minifierInfo.globals.length; i++) { - name = minifierInfo.globals[i]; - assert(next < minifierInfo.names.length); - minified[name] = minifierInfo.names[next++]; + for (var i = 0; i < extraInfo.globals.length; i++) { + name = extraInfo.globals[i]; + assert(next < extraInfo.names.length); + minified[name] = extraInfo.names[next++]; } // apply minification traverse(ast, function(node, type) { @@ -2710,7 +2710,7 @@ function minifyGlobals(ast) { } } }); - suffix = '// MINIFY_INFO:' + JSON.stringify(minified); + suffix = '// EXTRA_INFO:' + JSON.stringify(minified); } // Change +5 to DOT$ZERO(5). We then textually change 5 to 5.0 (uglify's ast cannot differentiate between 5 and 5.0 directly) @@ -2791,9 +2791,9 @@ var src = read(arguments_[0]); var ast = srcToAst(src); //printErr(JSON.stringify(ast)); throw 1; generatedFunctions = src.indexOf(GENERATED_FUNCTIONS_MARKER) >= 0; -var minifierInfoStart = src.indexOf('// MINIFY_INFO:') -if (minifierInfoStart > 0) minifierInfo = JSON.parse(src.substr(minifierInfoStart + 15)); -//printErr(JSON.stringify(minifierInfo)); +var extraInfoStart = src.indexOf('// EXTRA_INFO:') +if (extraInfoStart > 0) extraInfo = JSON.parse(src.substr(extraInfoStart + 14)); +//printErr(JSON.stringify(extraInfo)); arguments_.slice(1).forEach(function(arg) { passes[arg](ast); diff --git a/tools/js_optimizer.py b/tools/js_optimizer.py index 9dd3bff570422..16bc73c1af5b7 100644 --- a/tools/js_optimizer.py +++ b/tools/js_optimizer.py @@ -73,13 +73,13 @@ def minify_shell(self, shell, minify_whitespace): f = open(temp_file, 'w') f.write(shell) f.write('\n') - f.write('// MINIFY_INFO:' + self.serialize()) + f.write('// EXTRA_INFO:' + self.serialize()) f.close() output = subprocess.Popen(self.js_engine + [JS_OPTIMIZER, temp_file, 'minifyGlobals', 'noPrintMetadata'] + (['minifyWhitespace'] if minify_whitespace else []), stdout=subprocess.PIPE).communicate()[0] assert len(output) > 0 and not output.startswith('Assertion failed'), 'Error in js optimizer: ' + output #print >> sys.stderr, "minified SHELL 3333333333333333", output, "\n44444444444444444444" - code, metadata = output.split('// MINIFY_INFO:') + code, metadata = output.split('// EXTRA_INFO:') self.globs = json.loads(metadata) return code.replace('13371337', '0.0') @@ -243,7 +243,7 @@ def write_chunk(chunk, i): f.write(suffix_marker) if minify_globals: f.write('\n') - f.write('// MINIFY_INFO:' + minify_info) + f.write('// EXTRA_INFO:' + minify_info) f.close() return temp_file filenames = [write_chunk(chunks[i], i) for i in range(len(chunks))] From 454e20609b2526c2397cb67386fc759df872fd2f Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Mon, 24 Jun 2013 13:40:17 -0700 Subject: [PATCH 50/69] update test --- tools/test-js-optimizer-asm-regs-min.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/test-js-optimizer-asm-regs-min.js b/tools/test-js-optimizer-asm-regs-min.js index f47dbff340ddd..a5b9427e3ceb9 100644 --- a/tools/test-js-optimizer-asm-regs-min.js +++ b/tools/test-js-optimizer-asm-regs-min.js @@ -34,4 +34,4 @@ function collideLocal(i1) { bGlobal(i1); } // EMSCRIPTEN_GENERATED_FUNCTIONS -// MINIFY_INFO: { "names": ["a", "b", "c", "d", "e", "f", "g", "h", "i", "i1", "cl"], "globals": { "aGlobal": "a", "bGlobal": "i1", "collideLocal": "cl" } } +// EXTRA_INFO: { "names": ["a", "b", "c", "d", "e", "f", "g", "h", "i", "i1", "cl"], "globals": { "aGlobal": "a", "bGlobal": "i1", "collideLocal": "cl" } } From e94938b90603372d8dadfbbdc0ed4088ef68078b Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Mon, 24 Jun 2013 13:50:10 -0700 Subject: [PATCH 51/69] relocation pass for shared modules --- tests/runner.py | 2 + tools/js-optimizer.js | 56 +++++++++++++++++++ .../test-js-optimizer-asm-relocate-output.js | 9 +++ tools/test-js-optimizer-asm-relocate.js | 12 ++++ 4 files changed, 79 insertions(+) create mode 100644 tools/test-js-optimizer-asm-relocate-output.js create mode 100644 tools/test-js-optimizer-asm-relocate.js diff --git a/tests/runner.py b/tests/runner.py index 637d2e52af395..2c459f6fa52da 100755 --- a/tests/runner.py +++ b/tests/runner.py @@ -11235,6 +11235,8 @@ def test_js_optimizer(self): ['asm', 'simplifyExpressionsPre']), (path_from_root('tools', 'test-js-optimizer-asm-last.js'), open(path_from_root('tools', 'test-js-optimizer-asm-last-output.js')).read(), ['asm', 'last']), + (path_from_root('tools', 'test-js-optimizer-asm-relocate.js'), open(path_from_root('tools', 'test-js-optimizer-asm-relocate-output.js')).read(), + ['asm', 'relocate']), ]: print input output = Popen(listify(NODE_JS) + [path_from_root('tools', 'js-optimizer.js'), input] + passes, stdin=PIPE, stdout=PIPE).communicate()[0] diff --git a/tools/js-optimizer.js b/tools/js-optimizer.js index 7f0c97bae0f80..67cd8066a3840 100644 --- a/tools/js-optimizer.js +++ b/tools/js-optimizer.js @@ -2713,6 +2713,61 @@ function minifyGlobals(ast) { suffix = '// EXTRA_INFO:' + JSON.stringify(minified); } +// Relocation pass for a shared module (for the functions part of the module) +// +// 1. Replace function names with alternate names as defined (to avoid colliding with +// names in the main module we are being linked to) +// 2. Hardcode function table offsets from F_BASE+x to const+x if x is a variable, or +// the constant sum of the base + offset +// 3. Hardcode heap offsets from H_BASE as well +function relocate(ast) { + assert(asm); // we also assume we are normalized + + var replacements = extraInfo.replacements; + var fBase = extraInfo.fBase; + var hBase = extraInfo.hBase; + + traverse(ast, function(node, type) { + switch(type) { + case 'name': case 'defun': { + var rep = replacements[node[1]]; + if (rep) node[1] = rep; + break; + } + case 'binary': { + if (node[1] == '+' && node[2][0] == 'name') { + var base = null; + if (node[2][1] == 'F_BASE') { + base = fBase; + } else if (node[2][1] == 'H_BASE') { + base = hBase; + } + if (base) { + var other = node[3]; + if (other[0] == 'num') { + other[1] += base; + return other; + } else { + node[2] = ['num', base]; + } + } + } + break; + } + case 'var': { + var vars = node[1]; + for (var i = 0; i < vars.length; i++) { + var name = vars[i][0]; + assert(!(name in replacements)); // cannot shadow functions we are replacing TODO: fix that + } + break; + } + } + }); +} + +// Last pass utilities + // Change +5 to DOT$ZERO(5). We then textually change 5 to 5.0 (uglify's ast cannot differentiate between 5 and 5.0 directly) function prepDotZero(ast) { traverse(ast, function(node, type) { @@ -2777,6 +2832,7 @@ var passes = { eliminate: eliminate, eliminateMemSafe: eliminateMemSafe, minifyGlobals: minifyGlobals, + relocate: relocate, minifyWhitespace: function() { minifyWhitespace = true }, noPrintMetadata: function() { printMetadata = false }, asm: function() { asm = true }, diff --git a/tools/test-js-optimizer-asm-relocate-output.js b/tools/test-js-optimizer-asm-relocate-output.js new file mode 100644 index 0000000000000..6a197e81cc0fd --- /dev/null +++ b/tools/test-js-optimizer-asm-relocate-output.js @@ -0,0 +1,9 @@ +function leaveMeAlone(c) {} +function fixed(a, b) {} +function a(x, y) { + fixed(34, 12); + fixed(34 | 0, 12 | 0); + leaveMeAlone(10 + x, 33 + y); + leaveMeAlone(10 + x | 0, 33 + y | 0); +} + diff --git a/tools/test-js-optimizer-asm-relocate.js b/tools/test-js-optimizer-asm-relocate.js new file mode 100644 index 0000000000000..a45bc2f049989 --- /dev/null +++ b/tools/test-js-optimizer-asm-relocate.js @@ -0,0 +1,12 @@ +function leaveMeAlone(c) { +} +function replaceMe(a, b) { +} +function a(x, y) { + replaceMe(H_BASE + 1, F_BASE + 2); + replaceMe(H_BASE + 1 | 0, F_BASE + 2 | 0); + leaveMeAlone(F_BASE + x, H_BASE + y); + leaveMeAlone(F_BASE + x | 0, H_BASE + y | 0); +} +// EMSCRIPTEN_GENERATED_FUNCTIONS +// EXTRA_INFO: { "replacements": { "replaceMe": "fixed" }, "hBase": 33, "fBase": 10 } From 415a82bfa600aa976749e01431376b9a0a3c4e0a Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Mon, 24 Jun 2013 14:38:35 -0700 Subject: [PATCH 52/69] notice when a function call definitely does not have a return --- src/jsifier.js | 10 +++++----- tests/cases/returnfp.ll | 23 +++++++++++++++++++++++ 2 files changed, 28 insertions(+), 5 deletions(-) create mode 100644 tests/cases/returnfp.ll diff --git a/src/jsifier.js b/src/jsifier.js index 062bae6cc3aa1..ac6c259bdf9a6 100644 --- a/src/jsifier.js +++ b/src/jsifier.js @@ -1180,7 +1180,7 @@ function JSify(data, functionsOnly, givenFunctions) { // in an assignment var disabled = DISABLE_EXCEPTION_CATCHING == 2 && !(item.funcData.ident in EXCEPTION_CATCHING_WHITELIST); var phiSets = calcPhiSets(item); - var call_ = makeFunctionCall(item.ident, item.params, item.funcData, item.type, ASM_JS && !disabled); + var call_ = makeFunctionCall(item.ident, item.params, item.funcData, item.type, ASM_JS && !disabled, !!item.assignTo || !item.standalone); var ret; @@ -1337,7 +1337,7 @@ function JSify(data, functionsOnly, givenFunctions) { return ret; }); - function makeFunctionCall(ident, params, funcData, type, forceByPointer) { + function makeFunctionCall(ident, params, funcData, type, forceByPointer, hasReturn) { // We cannot compile assembly. See comment in intertyper.js:'Call' assert(ident != 'asm', 'Inline assembly cannot be compiled to JavaScript!'); @@ -1465,8 +1465,8 @@ function JSify(data, functionsOnly, givenFunctions) { } } - var returnType; - if (byPointer || ASM_JS) { + var returnType = 'void'; + if ((byPointer || ASM_JS) && hasReturn) { returnType = getReturnType(type); } @@ -1511,7 +1511,7 @@ function JSify(data, functionsOnly, givenFunctions) { makeFuncLineActor('getelementptr', function(item) { return finalizeLLVMFunctionCall(item) }); makeFuncLineActor('call', function(item) { if (item.standalone && LibraryManager.isStubFunction(item.ident)) return ';'; - return makeFunctionCall(item.ident, item.params, item.funcData, item.type) + (item.standalone ? ';' : ''); + return makeFunctionCall(item.ident, item.params, item.funcData, item.type, false, !!item.assignTo || !item.standalone) + (item.standalone ? ';' : ''); }); makeFuncLineActor('unreachable', function(item) { diff --git a/tests/cases/returnfp.ll b/tests/cases/returnfp.ll new file mode 100644 index 0000000000000..974459e5686ef --- /dev/null +++ b/tests/cases/returnfp.ll @@ -0,0 +1,23 @@ +; ModuleID = 'tests/hello_world.bc' +target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32-S128" +target triple = "i386-pc-linux-gnu" + +@.str = private unnamed_addr constant [15 x i8] c"hello, world!\0A\00", align 1 ; [#uses=1 type=[15 x i8]*] + +define internal void @__xmlRaiseError(void ()* %schannel) nounwind { + %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([15 x i8]* @.str, i32 0, i32 0)) ; [#uses=0 type=i32] + ret void +} + +; [#uses=0] +define i32 @main() { +entry: + %retval = alloca i32, align 4 ; [#uses=1 type=i32*] + store i32 0, i32* %retval + call void (void ()*)* @__xmlRaiseError(void ()* null) + ret i32 1 +} + +; [#uses=1] +declare i32 @printf(i8*, ...) + From 452b8715fbf467c1e61b141ebb4c56b1dc4d8ad6 Mon Sep 17 00:00:00 2001 From: Jez Ng Date: Mon, 24 Jun 2013 15:13:06 -0700 Subject: [PATCH 53/69] Optimize! --- tests/runner.py | 2 +- tools/js-optimizer.js | 54 +++++++++++++++++++++---------------------- 2 files changed, 28 insertions(+), 28 deletions(-) diff --git a/tests/runner.py b/tests/runner.py index 564013984a7a1..f0f77bc9b29a2 100755 --- a/tests/runner.py +++ b/tests/runner.py @@ -9660,7 +9660,7 @@ def build_and_check(): if old_emcc_debug is not None: os.environ['EMCC_DEBUG'] = old_emcc_debug else: - del os.environ['EMCC_DEBUG'] + os.environ.pop('EMCC_DEBUG', None) def test_exception_source_map(self): if Settings.USE_TYPED_ARRAYS != 2: return self.skip("doesn't pass without typed arrays") diff --git a/tools/js-optimizer.js b/tools/js-optimizer.js index 940719e9c658f..4b44247dddc33 100644 --- a/tools/js-optimizer.js +++ b/tools/js-optimizer.js @@ -164,11 +164,10 @@ function astToSrc(ast, minifyWhitespace) { function traverseChildren(node, traverse, pre, post, stack) { for (var i = 0; i < node.length; i++) { var subnode = node[i]; - if (typeof subnode == 'object' && subnode && subnode.length && - typeof subnode.valueOf() !== 'string') { + if (Array.isArray(subnode)) { var subresult = traverse(subnode, pre, post, stack); - if (subresult == true) return true; - if (subresult !== null && typeof subresult == 'object') node[i] = subresult; + if (subresult === true) return true; + if (subresult !== null && typeof subresult === 'object') node[i] = subresult; } } } @@ -191,16 +190,16 @@ function traverse(node, pre, post, stack) { var type = node[0], result, len; // valueOf() ensures that NodeWithToken (produced by uglify's parser during // 'embed tokens' mode) gets marked as 'relevant' - var relevant = type && typeof type.valueOf() == 'string'; + var relevant = !Array.isArray(node[0]); if (relevant) { if (stack) len = stack.length; var result = pre(node, type, stack); - if (result == true) return true; - if (result !== null && typeof result == 'object') node = result; // Continue processing on this node + if (result === true) return true; + if (Array.isArray(result)) node = result; // Continue processing on this node if (stack && len == stack.length) stack.push(0); } if (result !== null) { - if (traverseChildren(node, traverse, pre, post, stack) == true) return true; + if (traverseChildren(node, traverse, pre, post, stack) === true) return true; } if (relevant) { if (post) { @@ -451,9 +450,8 @@ function simplifyExpressionsPre(ast) { traverse(ast, function process(node, type, stack) { if (type == 'binary' && node[1] == '|') { if (node[2][0] == 'num' && node[3][0] == 'num') { - // pass node[2][0] instead of 'num' because it might be a token - // object with line numbers attached. - return [node[2][0], node[2][1] | node[3][1]]; + node[2][1] |= node[3][1]; + return node[2]; } var go = false; if (jsonCompare(node[2], ZERO)) { @@ -707,7 +705,7 @@ function simplifyExpressionsPre(ast) { while (rerun) { rerun = false; traverse(ast, function(node, type) { - if (type == 'binary' && node[1] == '+') { + if (type == 'binary' && node[1] === '+') { if (node[2][0] == 'num' && node[3][0] == 'num') { rerun = true; return ['num', node[2][1] + node[3][1]]; @@ -715,7 +713,7 @@ function simplifyExpressionsPre(ast) { for (var i = 2; i <= 3; i++) { var ii = 5-i; for (var j = 2; j <= 3; j++) { - if (node[i][0] == 'num' && node[ii][0] == 'binary' && node[ii][1] == '+' && node[ii][j][0] == 'num') { + if (node[i][0] == 'num' && node[ii][0] == 'binary' && node[ii][1] === '+' && node[ii][j][0] == 'num') { rerun = true; node[ii][j][1] += node[i][1]; return node[ii]; @@ -837,7 +835,7 @@ function optimizeShiftsInternal(ast, conservative) { if (shifts <= MAX_SHIFTS) { // Push the >> inside the value elements function addShift(subNode) { - if (subNode[0] == 'binary' && subNode[1] == '+') { + if (subNode[0] == 'binary' && subNode[1] === '+') { subNode[2] = addShift(subNode[2]); subNode[3] = addShift(subNode[3]); return subNode; @@ -1015,11 +1013,11 @@ function optimizeShiftsInternal(ast, conservative) { // Re-combine remaining shifts, to undo the breaking up we did before. may require reordering inside +'s traverse(fun, function(node, type, stack) { stack.push(node); - if (type == 'binary' && node[1] == '+' && (stack[stack.length-2][0] != 'binary' || stack[stack.length-2][1] != '+')) { + if (type == 'binary' && node[1] === '+' && (stack[stack.length-2][0] != 'binary' || stack[stack.length-2][1] !== '+')) { // 'Flatten' added items var addedItems = []; function flatten(node) { - if (node[0] == 'binary' && node[1] == '+') { + if (node[0] == 'binary' && node[1] === '+') { flatten(node[2]); flatten(node[3]); } else { @@ -1445,7 +1443,7 @@ function loopOptimizer(ast) { var more = false; // Remove unneeded labels traverseGenerated(ast, function(node, type) { - if (type == 'label' && node[1][0] == '+') { + if (type == 'label' && node[1][0] === '+') { more = true; var ident = node[1].substr(1); // Remove label from loop flow commands @@ -2038,7 +2036,8 @@ function eliminate(ast, memSafe) { // examine body and note locals var hasSwitch = false; traverse(func, function(node, type) { - if (type == 'var') { + if (debug && type) type = type.toString(); + if (type === 'var') { var node1 = node[1]; for (var i = 0; i < node1.length; i++) { var node1i = node1[i]; @@ -2052,11 +2051,11 @@ function eliminate(ast, memSafe) { if (!uses[name]) uses[name] = 0; locals[name] = true; } - } else if (type == 'name') { + } else if (type === 'name') { var name = node[1]; if (!uses[name]) uses[name] = 0; uses[name]++; - } else if (type == 'assign') { + } else if (type === 'assign') { var target = node[2]; if (target[0] == 'name') { var name = target[1]; @@ -2070,7 +2069,7 @@ function eliminate(ast, memSafe) { namings[name]++; // offset it here, this tracks the total times we are named } } - } else if (type == 'switch') { + } else if (type === 'switch') { hasSwitch = true; } }); @@ -2641,21 +2640,22 @@ function eliminate(ast, memSafe) { this.run = function() { traverse(this.node, function(node, type) { - if (type == 'binary' && node[1] == '+') { + if (type == 'binary' && node[1] === '+') { var names = []; var num = 0; var has_num = false; var fail = false; traverse(node, function(subNode, subType) { - if (subType == 'binary') { - if (subNode[1] != '+') { + if (debug && subType) subType = subType.toString(); + if (subType === 'binary') { + if (subNode[1] !== '+') { fail = true; return false; } - } else if (subType == 'name') { + } else if (subType === 'name') { names.push(subNode[1]); return; - } else if (subType == 'num') { + } else if (subType === 'num') { num += subNode[1]; has_num = true; return; @@ -2723,7 +2723,7 @@ function minifyGlobals(ast) { // Change +5 to DOT$ZERO(5). We then textually change 5 to 5.0 (uglify's ast cannot differentiate between 5 and 5.0 directly) function prepDotZero(ast) { traverse(ast, function(node, type) { - if (type == 'unary-prefix' && node[1] == '+') { + if (type == 'unary-prefix' && node[1] === '+') { if (node[2][0] == 'num' || (node[2][0] == 'unary-prefix' && node[2][1] == '-' && node[2][2][0] == 'num')) { return ['call', ['name', 'DOT$ZERO'], [node[2]]]; From 6768d77c41eb5a63ec40ce7d0448f2bd176a2577 Mon Sep 17 00:00:00 2001 From: Jez Ng Date: Mon, 24 Jun 2013 15:29:38 -0700 Subject: [PATCH 54/69] Clean up emcc flag parsing + help message. --- emcc | 19 +++++++++++-------- 1 file changed, 11 insertions(+), 8 deletions(-) diff --git a/emcc b/emcc index 053076a3953df..b09a27463a957 100755 --- a/emcc +++ b/emcc @@ -203,10 +203,13 @@ Options that are modified or new in %s include: -g2 Preserve function names -g3 Preserve variable names -g4 Preserve LLVM debug info (if -g was - used when compiling the C/C++ sources) - and show line number debug comments. - This is the highest level of debuggability. - (default in -O0) + used when compiling the C/C++ sources), + show line number debug comments, and + generate source maps. This is the highest + level of debuggability. Note that this + may make -O1 and above significantly + slower because JS optimization will be + limited to 1 core. (default in -O0) -g2 Like -g1, but we generate source maps as well, and we preserve comments even with -O1 and above. @@ -736,12 +739,12 @@ try: settings_changes = [] - def validate_arg_level(level_string, max_level): + def validate_arg_level(level_string, max_level, err_msg): try: level = int(level_string) assert 0 <= level <= max_level except: - raise Exception('Invalid argument value: ' + newargs[i]) + raise Exception(err_msg) return level for i in range(len(newargs)): @@ -752,7 +755,7 @@ try: if requested_level == 's': requested_level = 2 settings_changes.append('INLINING_LIMIT=50') - opt_level = validate_arg_level(requested_level, 3) + opt_level = validate_arg_level(requested_level, 3, 'Invalid optimization level: ' + newargs[i]) newargs[i] = '' elif newargs[i].startswith('--llvm-opts'): check_bad_eq(newargs[i]) @@ -796,7 +799,7 @@ try: newargs[i+1] = '' elif newargs[i].startswith('-g'): requested_level = newargs[i][2:] or '3' - debug_level = validate_arg_level(requested_level, 4) + debug_level = validate_arg_level(requested_level, 4, 'Invalid debug level: ' + newargs[i]) newargs[i] = '-g' # we'll need this to get LLVM debug info elif newargs[i] == '--bind': bind = True From 0c19e4051e497c9bd61459617768b9e3eaad5a44 Mon Sep 17 00:00:00 2001 From: Jez Ng Date: Mon, 24 Jun 2013 19:03:50 -0700 Subject: [PATCH 55/69] Get rid of stale comment. --- tools/js-optimizer.js | 2 -- 1 file changed, 2 deletions(-) diff --git a/tools/js-optimizer.js b/tools/js-optimizer.js index 4b44247dddc33..61d87c9535eb1 100644 --- a/tools/js-optimizer.js +++ b/tools/js-optimizer.js @@ -188,8 +188,6 @@ function traverseChildren(node, traverse, pre, post, stack) { // was stopped, true. Otherwise undefined. function traverse(node, pre, post, stack) { var type = node[0], result, len; - // valueOf() ensures that NodeWithToken (produced by uglify's parser during - // 'embed tokens' mode) gets marked as 'relevant' var relevant = !Array.isArray(node[0]); if (relevant) { if (stack) len = stack.length; From e7dfdb3a27887f555f2ec3216e8e458257674b25 Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Mon, 24 Jun 2013 21:27:18 -0700 Subject: [PATCH 56/69] make emcc -v update debug settings, so that it saves temp files --- emcc | 1 + tools/shared.py | 23 ++++++++++++++--------- 2 files changed, 15 insertions(+), 9 deletions(-) diff --git a/emcc b/emcc index 8368f3b1e4f0c..3bc35aa458e32 100755 --- a/emcc +++ b/emcc @@ -836,6 +836,7 @@ try: DEBUG = 1 shared.set_logging() logging.debug('invocation: ' + ' '.join(sys.argv)) + shared.apply_configuration() # reset config to pick up change newargs[i] = '' elif newargs[i].startswith('--shell-file'): check_bad_eq(newargs[i]) diff --git a/tools/shared.py b/tools/shared.py index db8f7a5687eb3..fdd577de0c8e0 100644 --- a/tools/shared.py +++ b/tools/shared.py @@ -420,7 +420,7 @@ def build_clang_tool_path(tool): # Temp dir. Create a random one, unless EMCC_DEBUG is set, in which case use TEMP_DIR/emscripten_temp class Configuration: - def __init__(self, environ): + def __init__(self, environ=os.environ): self.DEBUG = environ.get('EMCC_DEBUG') if self.DEBUG == "0": self.DEBUG = None @@ -448,11 +448,14 @@ def get_temp_files(self): tmp=self.TEMP_DIR if not self.DEBUG else self.EMSCRIPTEN_TEMP_DIR, save_debug_files=os.environ.get('EMCC_DEBUG_SAVE')) -configuration = Configuration(environ=os.environ) -DEBUG = configuration.DEBUG -EMSCRIPTEN_TEMP_DIR = configuration.EMSCRIPTEN_TEMP_DIR -DEBUG_CACHE = configuration.DEBUG_CACHE -CANONICAL_TEMP_DIR = configuration.CANONICAL_TEMP_DIR +def apply_configuration(): + configuration = Configuration() + global configuration, DEBUG, EMSCRIPTEN_TEMP_DIR, DEBUG_CACHE, CANONICAL_TEMP_DIR + DEBUG = configuration.DEBUG + EMSCRIPTEN_TEMP_DIR = configuration.EMSCRIPTEN_TEMP_DIR + DEBUG_CACHE = configuration.DEBUG_CACHE + CANONICAL_TEMP_DIR = configuration.CANONICAL_TEMP_DIR +apply_configuration() logging.basicConfig(format='%(levelname)-8s %(name)s: %(message)s') def set_logging(): @@ -462,9 +465,11 @@ def set_logging(): if not EMSCRIPTEN_TEMP_DIR: EMSCRIPTEN_TEMP_DIR = tempfile.mkdtemp(prefix='emscripten_temp_', dir=configuration.TEMP_DIR) - def clean_temp(): - try_delete(EMSCRIPTEN_TEMP_DIR) - atexit.register(clean_temp) + def prepare_to_clean_temp(d): + def clean_temp(): + try_delete(d) + atexit.register(clean_temp) + prepare_to_clean_temp(EMSCRIPTEN_TEMP_DIR) # this global var might change later # EM_CONFIG stuff From de688a4e5d5a57959d55626c4b0283e715dfebaa Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Tue, 25 Jun 2013 09:52:24 -0700 Subject: [PATCH 57/69] fix apply_configuration --- tools/shared.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/shared.py b/tools/shared.py index fdd577de0c8e0..0d575fd7d5ab9 100644 --- a/tools/shared.py +++ b/tools/shared.py @@ -449,8 +449,8 @@ def get_temp_files(self): save_debug_files=os.environ.get('EMCC_DEBUG_SAVE')) def apply_configuration(): - configuration = Configuration() global configuration, DEBUG, EMSCRIPTEN_TEMP_DIR, DEBUG_CACHE, CANONICAL_TEMP_DIR + configuration = Configuration() DEBUG = configuration.DEBUG EMSCRIPTEN_TEMP_DIR = configuration.EMSCRIPTEN_TEMP_DIR DEBUG_CACHE = configuration.DEBUG_CACHE From 6f3337677dbec6716d9a08f4414454d6472926ee Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Tue, 25 Jun 2013 10:52:54 -0700 Subject: [PATCH 58/69] fix crash in js optimizer loop variables pass on empty if blocks --- tools/eliminator/asm-eliminator-test-output.js | 5 +++++ tools/eliminator/asm-eliminator-test.js | 8 +++++++- tools/js-optimizer.js | 4 ++-- 3 files changed, 14 insertions(+), 3 deletions(-) diff --git a/tools/eliminator/asm-eliminator-test-output.js b/tools/eliminator/asm-eliminator-test-output.js index b28fbd4a425b7..5cc6238e3a0b4 100644 --- a/tools/eliminator/asm-eliminator-test-output.js +++ b/tools/eliminator/asm-eliminator-test-output.js @@ -5121,4 +5121,9 @@ function tempDouble2($46, $14, $28, $42, $20, $32, $45) { HEAP32[$45 + 4 >> 2] = $_sroa_06_0_insert_insert$1; HEAP32[$45 + 8 >> 2] = $_sroa_06_0_insert_insert$1; } +function watIf() { + while (1) { + if ($cmp38) {} else {} + } +} diff --git a/tools/eliminator/asm-eliminator-test.js b/tools/eliminator/asm-eliminator-test.js index f90c355773779..b33c60406f030 100644 --- a/tools/eliminator/asm-eliminator-test.js +++ b/tools/eliminator/asm-eliminator-test.js @@ -6851,5 +6851,11 @@ function tempDouble2($46, $14, $28, $42, $20, $32, $45) { HEAP32[$45 + 4 >> 2] = $_sroa_06_0_insert_insert$1; HEAP32[$45 + 8 >> 2] = $_sroa_06_0_insert_insert$1; } -// EMSCRIPTEN_GENERATED_FUNCTIONS: ["asm", "__Z11printResultPiS_j", "_segment_holding", "__ZN5identC2EiPKcPci", "_vec2Length", "exc", "label", "confuusion", "tempDouble", "_org_apache_harmony_luni_util_NumberConverter_freeFormat__", "__ZN23b2EdgeAndPolygonContact8EvaluateEP10b2ManifoldRK11b2TransformS4_", "_java_nio_charset_Charset_forNameInternal___java_lang_String", "looop2", "looop3", "looop4", "looop5", "looop6", "looop7", "looop8", "multiloop", "multiloop2", "tempDouble2"] +function watIf() { + while (1) { + if ($cmp38) {} else { + } + } +} +// EMSCRIPTEN_GENERATED_FUNCTIONS: ["asm", "__Z11printResultPiS_j", "_segment_holding", "__ZN5identC2EiPKcPci", "_vec2Length", "exc", "label", "confuusion", "tempDouble", "_org_apache_harmony_luni_util_NumberConverter_freeFormat__", "__ZN23b2EdgeAndPolygonContact8EvaluateEP10b2ManifoldRK11b2TransformS4_", "_java_nio_charset_Charset_forNameInternal___java_lang_String", "looop2", "looop3", "looop4", "looop5", "looop6", "looop7", "looop8", "multiloop", "multiloop2", "tempDouble2", "watIf"] diff --git a/tools/js-optimizer.js b/tools/js-optimizer.js index 67cd8066a3840..7561abc8f5923 100644 --- a/tools/js-optimizer.js +++ b/tools/js-optimizer.js @@ -2535,13 +2535,13 @@ function eliminate(ast, memSafe) { var ifTrue = last[2]; var ifFalse = last[3]; var flip = false; - if (ifFalse[1][0][0] == 'break') { // canonicalize break in the if + if (ifFalse[1][0] && ifFalse[1][0][0] == 'break') { // canonicalize break in the if var temp = ifFalse; ifFalse = ifTrue; ifTrue = temp; flip = true; } - if (ifTrue[1][0][0] == 'break') { + if (ifTrue[1][0] && ifTrue[1][0][0] == 'break') { var assigns = ifFalse[1]; var loopers = [], helpers = []; for (var i = 0; i < assigns.length; i++) { From 493d0dcf303d66726be5bb08c187f8183ee96a65 Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Tue, 25 Jun 2013 10:59:18 -0700 Subject: [PATCH 59/69] add 'let' to reserved keywords for minifier --- tools/js_optimizer.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/js_optimizer.py b/tools/js_optimizer.py index 16bc73c1af5b7..2ecf3cfb96d1e 100644 --- a/tools/js_optimizer.py +++ b/tools/js_optimizer.py @@ -36,7 +36,7 @@ def __init__(self, js, js_engine): MAX_NAMES = 80000 INVALID_2 = set(['do', 'if', 'in']) - INVALID_3 = set(['for', 'new', 'try', 'var', 'env']) + INVALID_3 = set(['for', 'new', 'try', 'var', 'env', 'let']) self.names = [] init_possibles = string.ascii_letters + '_$' From 566447048806a59eb6e102fc364191ce292d7045 Mon Sep 17 00:00:00 2001 From: Jez Ng Date: Wed, 26 Jun 2013 01:15:35 -0700 Subject: [PATCH 60/69] Move line numbers to the AST node itself. This allows us to use strict comparisons on the node type. --- .../node_modules/uglify-js/lib/parse-js.js | 7 ++--- .../node_modules/uglify-js/lib/process.js | 28 +++++++++---------- 2 files changed, 16 insertions(+), 19 deletions(-) diff --git a/tools/eliminator/node_modules/uglify-js/lib/parse-js.js b/tools/eliminator/node_modules/uglify-js/lib/parse-js.js index 2dc2ef70721d0..c7c2025f12efa 100644 --- a/tools/eliminator/node_modules/uglify-js/lib/parse-js.js +++ b/tools/eliminator/node_modules/uglify-js/lib/parse-js.js @@ -786,15 +786,12 @@ function parse($TEXT, exigent_mode, embed_tokens) { return ex; }; - function add_tokens(str, start, end) { - return str instanceof NodeWithToken ? str : new NodeWithToken(str, start, end); - }; - function maybe_embed_tokens(parser) { if (embed_tokens) return function() { var start = S.token; var ast = parser.apply(this, arguments); - ast[0] = add_tokens(ast[0], start, prev()); + ast.start = start; + ast.end = prev; return ast; }; else return parser; diff --git a/tools/eliminator/node_modules/uglify-js/lib/process.js b/tools/eliminator/node_modules/uglify-js/lib/process.js index 3fd99b7952ae6..e1d692b2cc00e 100644 --- a/tools/eliminator/node_modules/uglify-js/lib/process.js +++ b/tools/eliminator/node_modules/uglify-js/lib/process.js @@ -1511,8 +1511,8 @@ function gen_code(ast, options) { str.substr(str.indexOf("."))); } var best = best_of(a); - if (options.debug && this[0].start) - return new NodeWithLine(best, this[0].start.line); + if (options.debug && this.start) + return new NodeWithLine(best, this.start.line); return best; }; @@ -1546,8 +1546,8 @@ function gen_code(ast, options) { // hack: we don't support mapping one optimized line to more than one // generated line, so in case of multiple comma-separated var definitions, // just take the first - if (defs[0][1] && defs[0][1][0] && defs[0][1][0].start) - return s + (new NodeWithLine(s, defs[0][1][0].start.line)).lineComment(); + if (defs[0][1] && defs[0][1].start) + return s + (new NodeWithLine(s, defs[0][1].start.line)).lineComment(); } return s; }, @@ -1605,8 +1605,8 @@ function gen_code(ast, options) { if (op && op !== true) op += "="; else op = "="; var s = add_spaces([ make(lvalue), op, parenthesize(rvalue, "seq") ]); - if (options.debug && this[0].start) - return new NodeWithLine(s, this[0].start.line); + if (options.debug && this.start) + return new NodeWithLine(s, this.start.line); return s; }, "dot": function(expr) { @@ -1627,8 +1627,8 @@ function gen_code(ast, options) { var str = f + "(" + add_commas(MAP(args, function(expr){ return parenthesize(expr, "seq"); })) + ")"; - if (options.debug && this[0].start) - return new NodeWithLine(str, this[0].start.line) + if (options.debug && this.start) + return new NodeWithLine(str, this.start.line) return str; }, "function": make_function, @@ -1688,12 +1688,12 @@ function gen_code(ast, options) { } var str = add_spaces([ left, operator, right ]); if (options.debug) { - if (this[0].start) - return new NodeWithLine(str, this[0].start.line); - else if (lvalue[0].start) - return new NodeWithLine(str, lvalue[0].start.line); - else if (rvalue[0].start) - return new NodeWithLine(str, rvalue[0].start.line); + if (this.start) + return new NodeWithLine(str, this.start.line); + else if (lvalue.start) + return new NodeWithLine(str, lvalue.start.line); + else if (rvalue.start) + return new NodeWithLine(str, rvalue.start.line); } return str; }, From e3a37fccf8a1c62388e998c8e31309f3bb834c27 Mon Sep 17 00:00:00 2001 From: Jez Ng Date: Wed, 26 Jun 2013 01:25:13 -0700 Subject: [PATCH 61/69] Strict compare all the things! --- tools/js-optimizer.js | 518 +++++++++++++++++++++--------------------- 1 file changed, 259 insertions(+), 259 deletions(-) diff --git a/tools/js-optimizer.js b/tools/js-optimizer.js index 61d87c9535eb1..3943963adc649 100644 --- a/tools/js-optimizer.js +++ b/tools/js-optimizer.js @@ -103,7 +103,7 @@ function globalEval(x) { eval.call(null, x); } -if (typeof load == 'undefined' && typeof read != 'undefined') { +if (typeof load === 'undefined' && typeof read != 'undefined') { this['load'] = function(f) { globalEval(read(f)); }; @@ -194,7 +194,7 @@ function traverse(node, pre, post, stack) { var result = pre(node, type, stack); if (result === true) return true; if (Array.isArray(result)) node = result; // Continue processing on this node - if (stack && len == stack.length) stack.push(0); + if (stack && len === stack.length) stack.push(0); } if (result !== null) { if (traverseChildren(node, traverse, pre, post, stack) === true) return true; @@ -213,7 +213,7 @@ function traverse(node, pre, post, stack) { function traverseGenerated(ast, pre, post, stack) { assert(generatedFunctions); traverse(ast, function(node) { - if (node[0] == 'defun') { + if (node[0] === 'defun') { traverse(node, pre, post, stack); return null; } @@ -222,13 +222,13 @@ function traverseGenerated(ast, pre, post, stack) { function traverseGeneratedFunctions(ast, callback) { assert(generatedFunctions); - if (ast[0] == 'toplevel') { + if (ast[0] === 'toplevel') { var stats = ast[1]; for (var i = 0; i < stats.length; i++) { var curr = stats[i]; - if (curr[0] == 'defun') callback(curr); + if (curr[0] === 'defun') callback(curr); } - } else if (ast[0] == 'defun') { + } else if (ast[0] === 'defun') { callback(ast); } } @@ -238,7 +238,7 @@ function traverseWithVariables(ast, callback) { traverse(ast, function(node, type, stack) { if (type in FUNCTION) { stack.push({ type: 'function', vars: node[2] }); - } else if (type == 'var') { + } else if (type === 'var') { // Find our function, add our vars var func = stack[stack.length-1]; if (func) { @@ -246,12 +246,12 @@ function traverseWithVariables(ast, callback) { } } }, function(node, type, stack) { - if (type == 'toplevel' || type in FUNCTION) { + if (type === 'toplevel' || type in FUNCTION) { // We know all of the variables that are seen here, proceed to do relevant replacements var allVars = stack.map(function(item) { return item ? item.vars : [] }).reduce(concatenator, []); // FIXME dictionary for speed? traverse(node, function(node2, type2, stack2) { // Be careful not to look into our inner functions. They have already been processed. - if (sum(stack2) > 1 || (type == 'toplevel' && sum(stack2) == 1)) return; + if (sum(stack2) > 1 || (type === 'toplevel' && sum(stack2) === 1)) return; if (type2 in FUNCTION) stack2.push(1); return callback(node2, type2, allVars); }, null, []); @@ -264,7 +264,7 @@ function emptyNode() { // XXX do we need to create new nodes here? can't we reus } function isEmptyNode(node) { - return node.length == 2 && node[0] == 'toplevel' && node[1].length == 0; + return node.length === 2 && node[0] === 'toplevel' && node[1].length === 0; } // Passes @@ -286,7 +286,7 @@ function unGlobalize(ast) { throw 'this is deprecated!'; // and does not work with parallel compilation - assert(ast[0] == 'toplevel'); + assert(ast[0] === 'toplevel'); var values = {}; // Find global renamings of the relevant values ast[1].forEach(function(node, i) { @@ -307,7 +307,7 @@ function unGlobalize(ast) { ast[1][i][1][j] = emptyNode(); var assigned = false; traverseWithVariables(ast, function(node, type, allVars) { - if (type == 'assign' && node[2][0] == 'name' && node[2][1] == ident) assigned = true; + if (type === 'assign' && node[2][0] === 'name' && node[2][1] === ident) assigned = true; }); ast[1][i][1][j] = [ident, value]; if (!assigned) { @@ -317,12 +317,12 @@ function unGlobalize(ast) { return true; }); - if (node[1].length == 0) { + if (node[1].length === 0) { ast[1][i] = emptyNode(); } }); traverseWithVariables(ast, function(node, type, allVars) { - if (type == 'name') { + if (type === 'name') { var ident = node[1]; if (ident in values && allVars.indexOf(ident) < 0) { return copy(values[ident]); @@ -345,9 +345,9 @@ function unGlobalize(ast) { // is now explicit. function removeAssignsToUndefined(ast) { traverse(ast, function(node, type) { - if (type == 'assign' && jsonCompare(node[3], ['unary-prefix', 'void', ['num', 0]])) { + if (type === 'assign' && jsonCompare(node[3], ['unary-prefix', 'void', ['num', 0]])) { return emptyNode(); - } else if (type == 'var') { + } else if (type === 'var') { node[1] = node[1].map(function(varItem, j) { var ident = varItem[0]; var value = varItem[1]; @@ -361,10 +361,10 @@ function removeAssignsToUndefined(ast) { while (modified) { modified = false; traverse(ast, function(node, type) { - if (type == 'assign' && jsonCompare(node[3], emptyNode())) { + if (type === 'assign' && jsonCompare(node[3], emptyNode())) { modified = true; return emptyNode(); - } else if (type == 'var') { + } else if (type === 'var') { node[1] = node[1].map(function(varItem, j) { var ident = varItem[0]; var value = varItem[1]; @@ -382,19 +382,19 @@ function removeAssignsToUndefined(ast) { // are actually necessary. It's easy to clean those up now. function removeUnneededLabelSettings(ast) { traverse(ast, function(node, type) { - if (type == 'defun') { // all of our compiled code is in defun nodes + if (type === 'defun') { // all of our compiled code is in defun nodes // Find all checks var checked = {}; traverse(node, function(node, type) { - if (type == 'binary' && node[1] == '==' && node[2][0] == 'name' && node[2][1] == 'label') { - assert(node[3][0] == 'num'); + if (type === 'binary' && node[1] === '==' && node[2][0] === 'name' && node[2][1] === 'label') { + assert(node[3][0] === 'num'); checked[node[3][1]] = 1; } }); // Remove unneeded sets traverse(node, function(node, type) { - if (type == 'assign' && node[2][0] == 'name' && node[2][1] == 'label') { - assert(node[3][0] == 'num'); + if (type === 'assign' && node[2][0] === 'name' && node[2][1] === 'label') { + assert(node[3][0] === 'num'); if (!(node[3][1] in checked)) return emptyNode(); } }); @@ -410,13 +410,13 @@ function simplifyExpressionsPre(ast) { // Look for (x&A)<>B and replace it with X&A if possible. function simplifySignExtends(ast) { traverse(ast, function(node, type) { - if (type == 'binary' && node[1] == '>>' && node[3][0] == 'num' && - node[2][0] == 'binary' && node[2][1] == '<<' && node[2][3][0] == 'num' && node[3][1] == node[2][3][1]) { + if (type === 'binary' && node[1] === '>>' && node[3][0] === 'num' && + node[2][0] === 'binary' && node[2][1] === '<<' && node[2][3][0] === 'num' && node[3][1] === node[2][3][1]) { var innerNode = node[2][2]; var shifts = node[3][1]; - if (innerNode[0] == 'binary' && innerNode[1] == '&' && innerNode[3][0] == 'num') { + if (innerNode[0] === 'binary' && innerNode[1] === '&' && innerNode[3][0] === 'num') { var mask = innerNode[3][1]; - if (mask << shifts >> shifts == mask) { + if (mask << shifts >> shifts === mask) { return innerNode; } } @@ -446,8 +446,8 @@ function simplifyExpressionsPre(ast) { while (rerun) { rerun = false; traverse(ast, function process(node, type, stack) { - if (type == 'binary' && node[1] == '|') { - if (node[2][0] == 'num' && node[3][0] == 'num') { + if (type === 'binary' && node[1] === '|') { + if (node[2][0] === 'num' && node[3][0] === 'num') { node[2][1] |= node[3][1]; return node[2]; } @@ -469,9 +469,9 @@ function simplifyExpressionsPre(ast) { for (var i = stack.length-1; i >= 0; i--) { if (stack[i] >= 1) { if (asm) { - if (stack[stack.length-1] < 2 && node[2][0] == 'call') break; // we can only remove multiple |0s on these + if (stack[stack.length-1] < 2 && node[2][0] === 'call') break; // we can only remove multiple |0s on these if (stack[stack.length-1] < 1 && (node[2][0] in COERCION_REQUIRING_OPS || - (node[2][0] == 'binary' && node[2][1] in COERCION_REQUIRING_BINARIES))) break; // we can remove |0 or >>2 + (node[2][0] === 'binary' && node[2][1] in COERCION_REQUIRING_BINARIES))) break; // we can remove |0 or >>2 } // we will replace ourselves with the non-zero side. Recursively process that node. var result = jsonCompare(node[2], ZERO) ? node[3] : node[2], other; @@ -482,15 +482,15 @@ function simplifyExpressionsPre(ast) { } rerun = true; return process(result, result[0], stack); - } else if (stack[i] == -1) { + } else if (stack[i] === -1) { break; // Too bad, we can't } } stack.push(2); // From here on up, no need for this kind of correction, it's done at the top // (Add this at the end, so it is only added if we did not remove it) - } else if (type == 'binary' && node[1] in USEFUL_BINARY_OPS) { + } else if (type === 'binary' && node[1] in USEFUL_BINARY_OPS) { stack.push(1); - } else if ((type == 'binary' && node[1] in SAFE_BINARY_OPS) || type == 'num' || type == 'name') { + } else if ((type === 'binary' && node[1] in SAFE_BINARY_OPS) || type === 'num' || type === 'name') { stack.push(0); // This node is safe in that it does not interfere with this optimization } else { stack.push(-1); // This node is dangerous! Give up if you see this before you see '1' @@ -506,7 +506,7 @@ function simplifyExpressionsPre(ast) { var heapBits, heapUnsigned; function parseHeap(name) { if (name.substr(0, 4) != 'HEAP') return false; - heapUnsigned = name[4] == 'U'; + heapUnsigned = name[4] === 'U'; heapBits = parseInt(name.substr(heapUnsigned ? 5 : 4)); return true; } @@ -514,21 +514,21 @@ function simplifyExpressionsPre(ast) { var hasTempDoublePtr = false, rerunOrZeroPass = false; traverse(ast, function(node, type) { - if (type == 'name') { - if (node[1] == 'tempDoublePtr') hasTempDoublePtr = true; - } else if (type == 'binary' && node[1] == '&' && node[3][0] == 'num') { - if (node[2][0] == 'num') return ['num', node[2][1] & node[3][1]]; + if (type === 'name') { + if (node[1] === 'tempDoublePtr') hasTempDoublePtr = true; + } else if (type === 'binary' && node[1] === '&' && node[3][0] === 'num') { + if (node[2][0] === 'num') return ['num', node[2][1] & node[3][1]]; var input = node[2]; var amount = node[3][1]; - if (input[0] == 'binary' && input[1] == '&' && input[3][0] == 'num') { + if (input[0] === 'binary' && input[1] === '&' && input[3][0] === 'num') { // Collapse X & 255 & 1 node[3][1] = amount & input[3][1]; node[2] = input[2]; - } else if (input[0] == 'sub' && input[1][0] == 'name') { + } else if (input[0] === 'sub' && input[1][0] === 'name') { // HEAP8[..] & 255 => HEAPU8[..] var name = input[1][1]; if (parseHeap(name)) { - if (amount == Math.pow(2, heapBits)-1) { + if (amount === Math.pow(2, heapBits)-1) { if (!heapUnsigned) { input[1][1] = 'HEAPU' + heapBits; // make unsigned } @@ -542,14 +542,14 @@ function simplifyExpressionsPre(ast) { } } } - } else if (type == 'binary' && node[1] == '>>' && node[3][0] == 'num' && - node[2][0] == 'binary' && node[2][1] == '<<' && node[2][3][0] == 'num' && - node[2][2][0] == 'sub' && node[2][2][1][0] == 'name') { + } else if (type === 'binary' && node[1] === '>>' && node[3][0] === 'num' && + node[2][0] === 'binary' && node[2][1] === '<<' && node[2][3][0] === 'num' && + node[2][2][0] === 'sub' && node[2][2][1][0] === 'name') { // collapse HEAPU?8[..] << 24 >> 24 etc. into HEAP8[..] | 0 var amount = node[3][1]; var name = node[2][2][1][1]; - if (amount == node[2][3][1] && parseHeap(name)) { - if (heapBits == 32 - amount) { + if (amount === node[2][3][1] && parseHeap(name)) { + if (heapBits === 32 - amount) { node[2][2][1][1] = 'HEAP' + heapBits; node[1] = '|'; node[2] = node[2][2]; @@ -558,29 +558,29 @@ function simplifyExpressionsPre(ast) { return node; } } - } else if (type == 'assign') { + } else if (type === 'assign') { // optimizations for assigning into HEAP32 specifically - if (node[1] === true && node[2][0] == 'sub' && node[2][1][0] == 'name' && node[2][1][1] == 'HEAP32') { + if (node[1] === true && node[2][0] === 'sub' && node[2][1][0] === 'name' && node[2][1][1] === 'HEAP32') { // HEAP32[..] = x | 0 does not need the | 0 (unless it is a mandatory |0 of a call) - if (node[3][0] == 'binary' && node[3][1] == '|') { - if (node[3][2][0] == 'num' && node[3][2][1] == 0 && node[3][3][0] != 'call') { + if (node[3][0] === 'binary' && node[3][1] === '|') { + if (node[3][2][0] === 'num' && node[3][2][1] === 0 && node[3][3][0] != 'call') { node[3] = node[3][3]; - } else if (node[3][3][0] == 'num' && node[3][3][1] == 0 && node[3][2][0] != 'call') { + } else if (node[3][3][0] === 'num' && node[3][3][1] === 0 && node[3][2][0] != 'call') { node[3] = node[3][2]; } } } var value = node[3]; - if (value[0] == 'binary' && value[1] == '|') { + if (value[0] === 'binary' && value[1] === '|') { // canonicalize order of |0 to end - if (value[2][0] == 'num' && value[2][1] == 0) { + if (value[2][0] === 'num' && value[2][1] === 0) { var temp = value[2]; value[2] = value[3]; value[3] = temp; } // if a seq ends in an |0, remove an external |0 // note that it is only safe to do this in assigns, like we are doing here (return (x, y|0); is not valid) - if (value[2][0] == 'seq' && value[2][2][0] == 'binary' && value[2][2][1] in USEFUL_BINARY_OPS) { + if (value[2][0] === 'seq' && value[2][2][0] === 'binary' && value[2][2][1] in USEFUL_BINARY_OPS) { node[3] = value[2]; } } @@ -592,27 +592,27 @@ function simplifyExpressionsPre(ast) { if (asm) { if (hasTempDoublePtr) { traverse(ast, function(node, type) { - if (type == 'assign') { - if (node[1] === true && node[2][0] == 'sub' && node[2][1][0] == 'name' && node[2][1][1] == 'HEAP32') { + if (type === 'assign') { + if (node[1] === true && node[2][0] === 'sub' && node[2][1][0] === 'name' && node[2][1][1] === 'HEAP32') { // remove bitcasts that are now obviously pointless, e.g. // HEAP32[$45 >> 2] = HEAPF32[tempDoublePtr >> 2] = ($14 < $28 ? $14 : $28) - $42, HEAP32[tempDoublePtr >> 2] | 0; var value = node[3]; - if (value[0] == 'seq' && value[1][0] == 'assign' && value[1][2][0] == 'sub' && value[1][2][1][0] == 'name' && value[1][2][1][1] == 'HEAPF32' && - value[1][2][2][0] == 'binary' && value[1][2][2][2][0] == 'name' && value[1][2][2][2][1] == 'tempDoublePtr') { + if (value[0] === 'seq' && value[1][0] === 'assign' && value[1][2][0] === 'sub' && value[1][2][1][0] === 'name' && value[1][2][1][1] === 'HEAPF32' && + value[1][2][2][0] === 'binary' && value[1][2][2][2][0] === 'name' && value[1][2][2][2][1] === 'tempDoublePtr') { // transform to HEAPF32[$45 >> 2] = ($14 < $28 ? $14 : $28) - $42; node[2][1][1] = 'HEAPF32'; node[3] = value[1][3]; } } - } else if (type == 'seq') { + } else if (type === 'seq') { // (HEAP32[tempDoublePtr >> 2] = HEAP32[$37 >> 2], +HEAPF32[tempDoublePtr >> 2]) // ==> // +HEAPF32[$37 >> 2] - if (node[0] == 'seq' && node[1][0] == 'assign' && node[1][2][0] == 'sub' && node[1][2][1][0] == 'name' && - (node[1][2][1][1] == 'HEAP32' || node[1][2][1][1] == 'HEAPF32') && - node[1][2][2][0] == 'binary' && node[1][2][2][2][0] == 'name' && node[1][2][2][2][1] == 'tempDoublePtr' && - node[1][3][0] == 'sub' && node[1][3][1][0] == 'name' && (node[1][3][1][1] == 'HEAP32' || node[1][3][1][1] == 'HEAPF32')) { - if (node[1][2][1][1] == 'HEAP32') { + if (node[0] === 'seq' && node[1][0] === 'assign' && node[1][2][0] === 'sub' && node[1][2][1][0] === 'name' && + (node[1][2][1][1] === 'HEAP32' || node[1][2][1][1] === 'HEAPF32') && + node[1][2][2][0] === 'binary' && node[1][2][2][2][0] === 'name' && node[1][2][2][2][1] === 'tempDoublePtr' && + node[1][3][0] === 'sub' && node[1][3][1][0] === 'name' && (node[1][3][1][1] === 'HEAP32' || node[1][3][1][1] === 'HEAPF32')) { + if (node[1][2][1][1] === 'HEAP32') { node[1][3][1][1] = 'HEAPF32'; return ['unary-prefix', '+', node[1][3]]; } else { @@ -627,11 +627,11 @@ function simplifyExpressionsPre(ast) { // the other heap type, then eliminate the bitcast var bitcastVars = {}; traverse(ast, function(node, type) { - if (type == 'assign' && node[1] === true && node[2][0] == 'name') { + if (type === 'assign' && node[1] === true && node[2][0] === 'name') { var value = node[3]; - if (value[0] == 'seq' && value[1][0] == 'assign' && value[1][2][0] == 'sub' && value[1][2][1][0] == 'name' && - (value[1][2][1][1] == 'HEAP32' || value[1][2][1][1] == 'HEAPF32') && - value[1][2][2][0] == 'binary' && value[1][2][2][2][0] == 'name' && value[1][2][2][2][1] == 'tempDoublePtr') { + if (value[0] === 'seq' && value[1][0] === 'assign' && value[1][2][0] === 'sub' && value[1][2][1][0] === 'name' && + (value[1][2][1][1] === 'HEAP32' || value[1][2][1][1] === 'HEAPF32') && + value[1][2][2][0] === 'binary' && value[1][2][2][2][0] === 'name' && value[1][2][2][2][1] === 'tempDoublePtr') { var name = node[2][1]; if (!bitcastVars[name]) bitcastVars[name] = { define_HEAP32: 0, define_HEAPF32: 0, use_HEAP32: 0, use_HEAPF32: 0, bad: false, namings: 0, defines: [], uses: [] @@ -642,15 +642,15 @@ function simplifyExpressionsPre(ast) { } }); traverse(ast, function(node, type) { - if (type == 'name' && bitcastVars[node[1]]) { + if (type === 'name' && bitcastVars[node[1]]) { bitcastVars[node[1]].namings++; - } else if (type == 'assign' && node[1] === true) { + } else if (type === 'assign' && node[1] === true) { var value = node[3]; - if (value[0] == 'name') { + if (value[0] === 'name') { var name = value[1]; if (bitcastVars[name]) { var target = node[2]; - if (target[0] == 'sub' && target[1][0] == 'name' && (target[1][1] == 'HEAP32' || target[1][1] == 'HEAPF32')) { + if (target[0] === 'sub' && target[1][0] === 'name' && (target[1][1] === 'HEAP32' || target[1][1] === 'HEAPF32')) { bitcastVars[name]['use_' + target[1][1]]++; bitcastVars[name].uses.push(node); } @@ -662,14 +662,14 @@ function simplifyExpressionsPre(ast) { for (var v in bitcastVars) { var info = bitcastVars[v]; // good variables define only one type, use only one type, have definitions and uses, and define as a different type than they use - if (info.define_HEAP32*info.define_HEAPF32 == 0 && info.use_HEAP32*info.use_HEAPF32 == 0 && + if (info.define_HEAP32*info.define_HEAPF32 === 0 && info.use_HEAP32*info.use_HEAPF32 === 0 && info.define_HEAP32+info.define_HEAPF32 > 0 && info.use_HEAP32+info.use_HEAPF32 > 0 && - info.define_HEAP32*info.use_HEAP32 == 0 && info.define_HEAPF32*info.use_HEAPF32 == 0 && - v in asmData.vars && info.namings == info.define_HEAP32+info.define_HEAPF32+info.use_HEAP32+info.use_HEAPF32) { + info.define_HEAP32*info.use_HEAP32 === 0 && info.define_HEAPF32*info.use_HEAPF32 === 0 && + v in asmData.vars && info.namings === info.define_HEAP32+info.define_HEAPF32+info.use_HEAP32+info.use_HEAPF32) { var correct = info.use_HEAP32 ? 'HEAPF32' : 'HEAP32'; info.defines.forEach(function(define) { define[3] = define[3][1][3]; - if (correct == 'HEAP32') { + if (correct === 'HEAP32') { define[3] = ['binary', '|', define[3], ['num', 0]]; } else { define[3] = ['unary-prefix', '+', define[3]]; @@ -687,7 +687,7 @@ function simplifyExpressionsPre(ast) { // optimize num >> num, in asm we need this here since we do not run optimizeShifts traverse(ast, function(node, type) { - if (type == 'binary' && node[1] == '>>' && node[2][0] == 'num' && node[3][0] == 'num') { + if (type === 'binary' && node[1] === '>>' && node[2][0] === 'num' && node[3][0] === 'num') { node[0] = 'num'; node[1] = node[2][1] >> node[3][1]; node.length = 2; @@ -703,15 +703,15 @@ function simplifyExpressionsPre(ast) { while (rerun) { rerun = false; traverse(ast, function(node, type) { - if (type == 'binary' && node[1] === '+') { - if (node[2][0] == 'num' && node[3][0] == 'num') { + if (type === 'binary' && node[1] === '+') { + if (node[2][0] === 'num' && node[3][0] === 'num') { rerun = true; return ['num', node[2][1] + node[3][1]]; } for (var i = 2; i <= 3; i++) { var ii = 5-i; for (var j = 2; j <= 3; j++) { - if (node[i][0] == 'num' && node[ii][0] == 'binary' && node[ii][1] === '+' && node[ii][j][0] == 'num') { + if (node[i][0] === 'num' && node[ii][0] === 'binary' && node[ii][1] === '+' && node[ii][j][0] === 'num') { rerun = true; node[ii][j][1] += node[i][1]; return node[ii]; @@ -723,15 +723,15 @@ function simplifyExpressionsPre(ast) { } } - // if (x == 0) can be if (!x), etc. + // if (x === 0) can be if (!x), etc. function simplifyZeroComp(ast) { traverse(ast, function(node, type) { var binary; - if (type == 'if' && (binary = node[1])[0] == 'binary') { - if ((binary[1] == '!=' || binary[1] == '!==') && binary[3][0] == 'num' && binary[3][1] == 0) { + if (type === 'if' && (binary = node[1])[0] === 'binary') { + if ((binary[1] === '!=' || binary[1] === '!==') && binary[3][0] === 'num' && binary[3][1] === 0) { node[1] = binary[2]; return node; - } else if ((binary[1] == '==' || binary[1] == '===') && binary[3][0] == 'num' && binary[3][1] == 0) { + } else if ((binary[1] === '==' || binary[1] === '===') && binary[3][0] === 'num' && binary[3][1] === 0) { node[1] = ['unary-prefix', '!', binary[2]]; return node; } @@ -743,7 +743,7 @@ function simplifyExpressionsPre(ast) { // Add final returns when necessary var returnType = null; traverse(fun, function(node, type) { - if (type == 'return' && node[1]) { + if (type === 'return' && node[1]) { returnType = detectAsmCoercion(node[1]); } }); @@ -753,7 +753,7 @@ function simplifyExpressionsPre(ast) { var last = stats[stats.length-1]; if (last[0] != 'return') { var returnValue = ['num', 0]; - if (returnType == ASM_DOUBLE) returnValue = ['unary-prefix', '+', returnValue]; + if (returnType === ASM_DOUBLE) returnValue = ['unary-prefix', '+', returnValue]; stats.push(['return', returnValue]); } } @@ -803,11 +803,11 @@ function optimizeShiftsInternal(ast, conservative) { // vars // XXX if var has >>=, ignore it here? That means a previous pass already optimized it var hasSwitch = traverse(fun, function(node, type) { - if (type == 'var') { + if (type === 'var') { node[1].forEach(function(arg) { newVar(arg[0], false, arg[1]); }); - } else if (type == 'switch') { + } else if (type === 'switch') { // The relooper can't always optimize functions, and we currently don't work with // switch statements when optimizing shifts. Bail. return true; @@ -820,25 +820,25 @@ function optimizeShiftsInternal(ast, conservative) { // optimize for code size, not speed. traverse(fun, function(node, type, stack) { stack.push(node); - if (type == 'name' && vars[node[1]] && stack[stack.length-2][0] != 'assign') { + if (type === 'name' && vars[node[1]] && stack[stack.length-2][0] != 'assign') { vars[node[1]].uses++; - } else if (type == 'assign' && node[2][0] == 'name' && vars[node[2][1]]) { + } else if (type === 'assign' && node[2][0] === 'name' && vars[node[2][1]]) { vars[node[2][1]].defs++; } }, null, []); // First, break up elements inside a shift. This lets us see clearly what to do next. traverse(fun, function(node, type) { - if (type == 'binary' && node[1] == '>>' && node[3][0] == 'num') { + if (type === 'binary' && node[1] === '>>' && node[3][0] === 'num') { var shifts = node[3][1]; if (shifts <= MAX_SHIFTS) { // Push the >> inside the value elements function addShift(subNode) { - if (subNode[0] == 'binary' && subNode[1] === '+') { + if (subNode[0] === 'binary' && subNode[1] === '+') { subNode[2] = addShift(subNode[2]); subNode[3] = addShift(subNode[3]); return subNode; } - if (subNode[0] == 'name' && !subNode[2]) { // names are returned with a shift, but we also note their being shifted + if (subNode[0] === 'name' && !subNode[2]) { // names are returned with a shift, but we also note their being shifted var name = subNode[1]; if (vars[name]) { vars[name].timesShifted[shifts]++; @@ -852,7 +852,7 @@ function optimizeShiftsInternal(ast, conservative) { } }); traverse(fun, function(node, type) { - if (node[0] == 'name' && node[2]) { + if (node[0] === 'name' && node[2]) { return node.slice(0, 2); // clean up our notes } }); @@ -861,7 +861,7 @@ function optimizeShiftsInternal(ast, conservative) { for (var name in vars) { var data = vars[name]; var totalTimesShifted = sum(data.timesShifted); - if (totalTimesShifted == 0) { + if (totalTimesShifted === 0) { continue; } if (totalTimesShifted != Math.max.apply(null, data.timesShifted)) { @@ -871,7 +871,7 @@ function optimizeShiftsInternal(ast, conservative) { if (funFinished[name]) continue; // We have one shift size (and possible unshifted uses). Consider replacing this variable with a shifted clone. If // the estimated benefit is >0, we will do it - if (data.defs == 1) { + if (data.defs === 1) { data.benefit = totalTimesShifted - 2*(data.defs + (data.param ? 1 : 0)); } if (conservative) data.benefit = 0; @@ -887,7 +887,7 @@ function optimizeShiftsInternal(ast, conservative) { //printErr(JSON.stringify(vars)); function cleanNotes() { // We need to mark 'name' nodes as 'processed' in some passes here; this cleans the notes up traverse(fun, function(node, type) { - if (node[0] == 'name' && node[2]) { + if (node[0] === 'name' && node[2]) { return node.slice(0, 2); } }); @@ -909,7 +909,7 @@ function optimizeShiftsInternal(ast, conservative) { } traverse(fun, function(node, type, stack) { // add shift to assignments stack.push(node); - if (node[0] == 'assign' && node[1] === true && node[2][0] == 'name' && needsShift(node[2][1]) && !node[2][2]) { + if (node[0] === 'assign' && node[1] === true && node[2][0] === 'name' && needsShift(node[2][1]) && !node[2][2]) { var name = node[2][1]; var data = vars[name]; var parent = stack[stack.length-3]; @@ -917,7 +917,7 @@ function optimizeShiftsInternal(ast, conservative) { assert(statements, 'Invalid parent for assign-shift: ' + dump(parent)); var i = statements.indexOf(stack[stack.length-2]); statements.splice(i+1, 0, ['stat', ['assign', true, ['name', name + '$s' + data.primaryShift], ['binary', '>>', ['name', name, true], ['num', data.primaryShift]]]]); - } else if (node[0] == 'var') { + } else if (node[0] === 'var') { var args = node[1]; for (var i = 0; i < args.length; i++) { var arg = args[i]; @@ -933,14 +933,14 @@ function optimizeShiftsInternal(ast, conservative) { cleanNotes(); traverse(fun, function(node, type, stack) { // replace shifted name with new variable stack.push(node); - if (node[0] == 'binary' && node[1] == '>>' && node[2][0] == 'name' && needsShift(node[2][1]) && node[3][0] == 'num') { + if (node[0] === 'binary' && node[1] === '>>' && node[2][0] === 'name' && needsShift(node[2][1]) && node[3][0] === 'num') { var name = node[2][1]; var data = vars[name]; var parent = stack[stack.length-2]; // Don't modify in |x$sN = x >> 2|, in normal assigns and in var assigns - if (parent[0] == 'assign' && parent[2][0] == 'name' && parent[2][1] == name + '$s' + data.primaryShift) return; - if (parent[0] == name + '$s' + data.primaryShift) return; - if (node[3][1] == data.primaryShift) { + if (parent[0] === 'assign' && parent[2][0] === 'name' && parent[2][1] === name + '$s' + data.primaryShift) return; + if (parent[0] === name + '$s' + data.primaryShift) return; + if (node[3][1] === data.primaryShift) { return ['name', name + '$s' + data.primaryShift]; } } @@ -951,8 +951,8 @@ function optimizeShiftsInternal(ast, conservative) { while (more) { // combine shifts in the same direction as an optimization more = false; traverse(fun, function(node, type) { - if (node[0] == 'binary' && node[1] in SIMPLE_SHIFTS && node[2][0] == 'binary' && node[2][1] == node[1] && - node[3][0] == 'num' && node[2][3][0] == 'num') { // do not turn a << b << c into a << b + c; while logically identical, it is slower + if (node[0] === 'binary' && node[1] in SIMPLE_SHIFTS && node[2][0] === 'binary' && node[2][1] === node[1] && + node[3][0] === 'num' && node[2][3][0] === 'num') { // do not turn a << b << c into a << b + c; while logically identical, it is slower more = true; return ['binary', node[1], node[2][2], ['num', node[3][1] + node[2][3][1]]]; } @@ -961,32 +961,32 @@ function optimizeShiftsInternal(ast, conservative) { // Before recombining, do some additional optimizations traverse(fun, function(node, type) { // Apply constant shifts onto constants - if (type == 'binary' && node[1] == '>>' && node[2][0] == 'num' && node[3][0] == 'num' && node[3][1] <= MAX_SHIFTS) { + if (type === 'binary' && node[1] === '>>' && node[2][0] === 'num' && node[3][0] === 'num' && node[3][1] <= MAX_SHIFTS) { var subNode = node[2]; var shifts = node[3][1]; var result = subNode[1] / Math.pow(2, shifts); - if (result % 1 == 0) { + if (result % 1 === 0) { subNode[1] = result; return subNode; } } // Optimize the case of ($a*80)>>2 into ($a*20)|0 - if (type == 'binary' && node[1] in SIMPLE_SHIFTS && - node[2][0] == 'binary' && node[2][1] == '*') { + if (type === 'binary' && node[1] in SIMPLE_SHIFTS && + node[2][0] === 'binary' && node[2][1] === '*') { var mulNode = node[2]; - if (mulNode[2][0] == 'num') { + if (mulNode[2][0] === 'num') { var temp = mulNode[2]; mulNode[2] = mulNode[3]; mulNode[3] = temp; } - if (mulNode[3][0] == 'num') { - if (node[1] == '<<') { + if (mulNode[3][0] === 'num') { + if (node[1] === '<<') { mulNode[3][1] *= Math.pow(2, node[3][1]); node[1] = '|'; node[3][1] = 0; return node; } else { - if (mulNode[3][1] % Math.pow(2, node[3][1]) == 0) { + if (mulNode[3][1] % Math.pow(2, node[3][1]) === 0) { mulNode[3][1] /= Math.pow(2, node[3][1]); node[1] = '|'; node[3][1] = 0; @@ -997,8 +997,8 @@ function optimizeShiftsInternal(ast, conservative) { } /* XXX - theoretically useful optimization(s), but commented out as not helpful in practice // Transform (x << 2) >> 2 into x & mask or something even simpler - if (type == 'binary' && node[1] == '>>' && node[3][0] == 'num' && - node[2][0] == 'binary' && node[2][1] == '<<' && node[2][3][0] == 'num' && node[3][1] == node[2][3][1]) { + if (type === 'binary' && node[1] === '>>' && node[3][0] === 'num' && + node[2][0] === 'binary' && node[2][1] === '<<' && node[2][3][0] === 'num' && node[3][1] === node[2][3][1]) { var subNode = node[2]; var shifts = node[3][1]; var mask = ((0xffffffff << shifts) >>> shifts) | 0; @@ -1011,11 +1011,11 @@ function optimizeShiftsInternal(ast, conservative) { // Re-combine remaining shifts, to undo the breaking up we did before. may require reordering inside +'s traverse(fun, function(node, type, stack) { stack.push(node); - if (type == 'binary' && node[1] === '+' && (stack[stack.length-2][0] != 'binary' || stack[stack.length-2][1] !== '+')) { + if (type === 'binary' && node[1] === '+' && (stack[stack.length-2][0] != 'binary' || stack[stack.length-2][1] !== '+')) { // 'Flatten' added items var addedItems = []; function flatten(node) { - if (node[0] == 'binary' && node[1] === '+') { + if (node[0] === 'binary' && node[1] === '+') { flatten(node[2]); flatten(node[3]); } else { @@ -1028,15 +1028,15 @@ function optimizeShiftsInternal(ast, conservative) { function originalOrderKey(item) { return -originalOrder.indexOf(item); } - if (node[0] == 'binary' && node[1] in SIMPLE_SHIFTS) { - if (node[3][0] == 'num' && node[3][1] <= MAX_SHIFTS) return 2*node[3][1] + (node[1] == '>>' ? 100 : 0); // 0-106 - return (node[1] == '>>' ? 20000 : 10000) + originalOrderKey(node); + if (node[0] === 'binary' && node[1] in SIMPLE_SHIFTS) { + if (node[3][0] === 'num' && node[3][1] <= MAX_SHIFTS) return 2*node[3][1] + (node[1] === '>>' ? 100 : 0); // 0-106 + return (node[1] === '>>' ? 20000 : 10000) + originalOrderKey(node); } - if (node[0] == 'num') return -20000 + node[1]; + if (node[0] === 'num') return -20000 + node[1]; return -10000 + originalOrderKey(node); // Don't modify the original order if we don't modify anything } for (var i = 0; i < addedItems.length; i++) { - if (addedItems[i][0] == 'string') return; // this node is not relevant for us + if (addedItems[i][0] === 'string') return; // this node is not relevant for us } addedItems.sort(function(node1, node2) { return key(node1) - key(node2); @@ -1045,7 +1045,7 @@ function optimizeShiftsInternal(ast, conservative) { var i = 0; while (i < addedItems.length-1) { // re-combine inside addedItems var k = key(addedItems[i]), k1 = key(addedItems[i+1]); - if (k == k1 && k >= 0 && k1 <= 106) { + if (k === k1 && k >= 0 && k1 <= 106) { addedItems[i] = ['binary', addedItems[i][1], ['binary', '+', addedItems[i][2], addedItems[i+1][2]], addedItems[i][3]]; addedItems.splice(i+1, 1); } else { @@ -1054,7 +1054,7 @@ function optimizeShiftsInternal(ast, conservative) { } var num = 0; for (i = 0; i < addedItems.length; i++) { // combine all numbers into one - if (addedItems[i][0] == 'num') { + if (addedItems[i][0] === 'num') { num += addedItems[i][1]; addedItems.splice(i, 1); i--; @@ -1066,7 +1066,7 @@ function optimizeShiftsInternal(ast, conservative) { // so it might take more space, but normally at most one more digit). var added = false; for (i = 0; i < addedItems.length; i++) { - if (addedItems[i][0] == 'binary' && addedItems[i][1] == '>>' && addedItems[i][3][0] == 'num' && addedItems[i][3][1] <= MAX_SHIFTS) { + if (addedItems[i][0] === 'binary' && addedItems[i][1] === '>>' && addedItems[i][3][0] === 'num' && addedItems[i][3][1] <= MAX_SHIFTS) { addedItems[i] = ['binary', '>>', ['binary', '+', addedItems[i][2], ['num', num << addedItems[i][3][1]]], addedItems[i][3]]; added = true; } @@ -1103,8 +1103,8 @@ function optimizeShiftsAggressive(ast) { // if (!(x < 5)) // or such. Simplifying these saves space and time. function simplifyNotCompsDirect(node) { - if (node[0] == 'unary-prefix' && node[1] == '!') { - if (node[2][0] == 'binary') { + if (node[0] === 'unary-prefix' && node[1] === '!') { + if (node[2][0] === 'binary') { switch(node[2][1]) { case '<': return ['binary', '>=', node[2][2], node[2][3]]; case '>': return ['binary', '<=', node[2][2], node[2][3]]; @@ -1115,7 +1115,7 @@ function simplifyNotCompsDirect(node) { case '===': return ['binary', '!==', node[2][2], node[2][3]]; case '!==': return ['binary', '===', node[2][2], node[2][3]]; } - } else if (node[2][0] == 'unary-prefix' && node[2][1] == '!') { + } else if (node[2][0] === 'unary-prefix' && node[2][1] === '!') { return node[2][2]; } } @@ -1138,8 +1138,8 @@ var NO_SIDE_EFFECTS = set('num', 'name'); function hasSideEffects(node) { // this is 99% incomplete! if (node[0] in NO_SIDE_EFFECTS) return false; - if (node[0] == 'unary-prefix') return hasSideEffects(node[2]); - if (node[0] == 'binary') return hasSideEffects(node[2]) || hasSideEffects(node[3]); + if (node[0] === 'unary-prefix') return hasSideEffects(node[2]); + if (node[0] === 'binary') return hasSideEffects(node[2]) || hasSideEffects(node[3]); return true; } @@ -1148,8 +1148,8 @@ function hasSideEffects(node) { // this is 99% incomplete! function vacuum(ast) { function isEmpty(node) { if (!node) return true; - if (node[0] == 'toplevel' && (!node[1] || node[1].length == 0)) return true; - if (node[0] == 'block' && (!node[1] || (typeof node[1] != 'object') || node[1].length == 0 || (node[1].length == 1 && isEmpty(node[1])))) return true; + if (node[0] === 'toplevel' && (!node[1] || node[1].length === 0)) return true; + if (node[0] === 'block' && (!node[1] || (typeof node[1] != 'object') || node[1].length === 0 || (node[1].length === 1 && isEmpty(node[1])))) return true; return false; } function simplifyList(node, si) { @@ -1159,7 +1159,7 @@ function vacuum(ast) { var i = 0; while (i < statements.length) { var subNode = statements[i]; - if (subNode[0] == 'block') { + if (subNode[0] === 'block') { statements.splice.apply(statements, [i, 1].concat(subNode[1] || [])); changed = true; } else { @@ -1179,20 +1179,20 @@ function vacuum(ast) { var ret; switch(node[0]) { case 'block': { - if (node[1] && node[1].length == 1 && node[1][0][0] == 'block') { + if (node[1] && node[1].length === 1 && node[1][0][0] === 'block') { return node[1][0]; - } else if (typeof node[1] == 'object') { + } else if (typeof node[1] === 'object') { ret = simplifyList(node, 1); if (ret) return ret; } } break; case 'stat': { - if (node[1][0] == 'block') { + if (node[1][0] === 'block') { return node[1]; } } break; case 'defun': { - if (node[3].length == 1 && node[3][0][0] == 'block') { + if (node[3].length === 1 && node[3][0][0] === 'block') { node[3] = node[3][0][1]; return node; } else { @@ -1201,19 +1201,19 @@ function vacuum(ast) { } } break; case 'do': { - if (node[1][0] == 'num' && node[2][0] == 'toplevel' && (!node[2][1] || node[2][1].length == 0)) { + if (node[1][0] === 'num' && node[2][0] === 'toplevel' && (!node[2][1] || node[2][1].length === 0)) { return emptyNode(); } else if (isEmpty(node[2]) && !hasSideEffects(node[1])) { return emptyNode(); } } break; case 'label': { - if (node[2][0] == 'toplevel' && (!node[2][1] || node[2][1].length == 0)) { + if (node[2][0] === 'toplevel' && (!node[2][1] || node[2][1].length === 0)) { return emptyNode(); } } break; case 'if': { - var empty2 = isEmpty(node[2]), empty3 = isEmpty(node[3]), has3 = node.length == 4; + var empty2 = isEmpty(node[2]), empty3 = isEmpty(node[3]), has3 = node.length === 4; if (!empty2 && empty3 && has3) { // empty else clauses return node.slice(0, 3); } else if (empty2 && !empty3) { // empty if blocks @@ -1235,9 +1235,9 @@ function vacuum(ast) { } function getStatements(node) { - if (node[0] == 'defun') { + if (node[0] === 'defun') { return node[3]; - } else if (node[0] == 'block') { + } else if (node[0] === 'block') { return node[1]; } else { return null; @@ -1245,9 +1245,9 @@ function getStatements(node) { } // Multiple blocks from the relooper are, in general, implemented by -// if (label == x) { } else if .. +// if (label === x) { } else if .. // and branching into them by -// if (condition) { label == x } else .. +// if (condition) { label === x } else .. // We can hoist the multiple block into the condition, thus removing code and one 'if' check function hoistMultiples(ast) { traverseGeneratedFunctions(ast, function(node) { @@ -1264,10 +1264,10 @@ function hoistMultiples(ast) { var postInner = post; var shellLabel = false, shellDo = false; while (true) { - if (postInner[0] == 'label') { + if (postInner[0] === 'label') { shellLabel = postInner[1]; postInner = postInner[2]; - } else if (postInner[0] == 'do') { + } else if (postInner[0] === 'do') { shellDo = postInner[1]; postInner = postInner[2][1][0]; } else { @@ -1276,19 +1276,19 @@ function hoistMultiples(ast) { } if (postInner[0] != 'if') continue; // Look into this if, and its elseifs - while (postInner && postInner[0] == 'if') { + while (postInner && postInner[0] === 'if') { var cond = postInner[1]; - if (cond[0] == 'binary' && cond[1] == '==' && cond[2][0] == 'name' && cond[2][1] == 'label') { - assert(cond[3][0] == 'num'); + if (cond[0] === 'binary' && cond[1] === '==' && cond[2][0] === 'name' && cond[2][1] === 'label') { + assert(cond[3][0] === 'num'); // We have a valid Multiple check here. Try to hoist it, look for the source in |pre| and its else's var labelNum = cond[3][1]; var labelBlock = postInner[2]; - assert(labelBlock[0] == 'block'); + assert(labelBlock[0] === 'block'); var found = false; traverse(pre, function(preNode, preType) { - if (!found && preType == 'assign' && preNode[2][0] == 'name' && preNode[2][1] == 'label') { - assert(preNode[3][0] == 'num'); - if (preNode[3][1] == labelNum) { + if (!found && preType === 'assign' && preNode[2][0] === 'name' && preNode[2][1] === 'label') { + assert(preNode[3][0] === 'num'); + if (preNode[3][1] === labelNum) { // That's it! Hoist away. We can also throw away the label setting as its goal has already been achieved found = true; modifiedI = true; @@ -1318,16 +1318,16 @@ function hoistMultiples(ast) { // situation is if the code after us is a multiple, in which case we might be checking for // this label inside it (or in a later multiple, even) function tryEliminate(node) { - if (node[0] == 'if') { + if (node[0] === 'if') { var replaced; if (replaced = tryEliminate(node[2])) node[2] = replaced; if (node[3] && (replaced = tryEliminate(node[3]))) node[3] = replaced; } else { - if (node[0] == 'block' && node[1] && node[1].length > 0) { + if (node[0] === 'block' && node[1] && node[1].length > 0) { var subNode = node[1][node[1].length-1]; - if (subNode[0] == 'stat' && subNode[1][0] == 'assign' && subNode[1][2][0] == 'name' && - subNode[1][2][1] == 'label' && subNode[1][3][0] == 'num') { - if (node[1].length == 1) { + if (subNode[0] === 'stat' && subNode[1][0] === 'assign' && subNode[1][2][0] === 'name' && + subNode[1][2][1] === 'label' && subNode[1][3][0] === 'num') { + if (node[1].length === 1) { return emptyNode(); } else { node[1].splice(node[1].length-1, 1); @@ -1339,9 +1339,9 @@ function hoistMultiples(ast) { return false; } function getActualStatement(node) { // find the actual active statement, ignoring a label and one-time do loop - if (node[0] == 'label') node = node[2]; - if (node[0] == 'do') node = node[2]; - if (node[0] == 'block' && node[1].length == 1) node = node[1][0]; + if (node[0] === 'label') node = node[2]; + if (node[0] === 'do') node = node[2]; + if (node[0] === 'block' && node[1].length === 1) node = node[1][0]; return node; } vacuum(node); @@ -1351,7 +1351,7 @@ function hoistMultiples(ast) { for (var i = 0; i < statements.length-1; i++) { var curr = getActualStatement(statements[i]); var next = statements[i+1]; - if (curr[0] == 'if' && next[0] != 'if' && next[0] != 'label' && next[0] != 'do' && next[0] != 'while') { + if (curr[0] === 'if' && next[0] != 'if' && next[0] != 'label' && next[0] != 'do' && next[0] != 'while') { tryEliminate(curr); } } @@ -1369,7 +1369,7 @@ function hoistMultiples(ast) { if (!statements) return; for (var i = 0; i < statements.length; i++) { var node = statements[i]; - if (node[0] == 'if' && node[2][0] == 'block' && node[3] && node[3][0] == 'block') { + if (node[0] === 'if' && node[2][0] === 'block' && node[3] && node[3][0] === 'block') { var stat1 = node[2][1], stat2 = node[3][1]; // If break|continue in the latter and not the former, reverse them if (!(stat1[stat1.length-1][0] in LOOP_FLOW) && (stat2[stat2.length-1][0] in LOOP_FLOW)) { @@ -1397,7 +1397,7 @@ function loopOptimizer(ast) { var neededDos = []; // Find unneeded labels traverseGenerated(ast, function(node, type, stack) { - if (type == 'label' && node[2][0] in LOOP) { + if (type === 'label' && node[2][0] in LOOP) { // this is a labelled loop. we don't know if it's needed yet. Mark its label for removal for now now. stack.push(node); node[1] = '+' + node[1]; @@ -1413,12 +1413,12 @@ function loopOptimizer(ast) { assert(lastLoop, 'Cannot break/continue without a Label'); while (i >= 0 && !lastLabel) { if (stack[i][0] in LOOP) break; // another loop in the middle - no label for lastLoop - if (stack[i][0] == 'label') lastLabel = stack[i]; + if (stack[i][0] === 'label') lastLabel = stack[i]; i--; } var ident = node[1]; // there may not be a label ident if this is a simple break; or continue; var plus = '+' + ident; - if (lastLabel && ident && (ident == lastLabel[1] || plus == lastLabel[1])) { + if (lastLabel && ident && (ident === lastLabel[1] || plus === lastLabel[1])) { // If this is a 'do' loop, this break means we actually need it. neededDos.push(lastLoop); // We don't need the control flow command to have a label - it's referring to the current loop @@ -1431,7 +1431,7 @@ function loopOptimizer(ast) { // Find the label node that needs to stay alive stack.forEach(function(label) { if (!label) return; - if (label[1] == plus) label[1] = label[1].substr(1); // Remove '+', marking it as needed + if (label[1] === plus) label[1] = label[1].substr(1); // Remove '+', marking it as needed }); } } @@ -1441,12 +1441,12 @@ function loopOptimizer(ast) { var more = false; // Remove unneeded labels traverseGenerated(ast, function(node, type) { - if (type == 'label' && node[1][0] === '+') { + if (type === 'label' && node[1][0] === '+') { more = true; var ident = node[1].substr(1); // Remove label from loop flow commands traverse(node[2], function(node2, type) { - if (type in LOOP_FLOW && node2[1] == ident) { + if (type in LOOP_FLOW && node2[1] === ident) { return [node2[0]]; } }); @@ -1456,13 +1456,13 @@ function loopOptimizer(ast) { // Remove unneeded one-time loops. We need such loops if (1) they have a label, or (2) they have a direct break so they are in neededDos. // First, add all labeled loops of this nature to neededDos traverseGenerated(ast, function(node, type) { - if (type == 'label' && node[2][0] == 'do') { + if (type === 'label' && node[2][0] === 'do') { neededDos.push(node[2]); } }); // Remove unneeded dos, we know who they are now traverseGenerated(ast, function(node, type) { - if (type == 'do' && neededDos.indexOf(node) < 0) { + if (type === 'do' && neededDos.indexOf(node) < 0) { assert(jsonCompare(node[1], ['num', 0]), 'Trying to remove a one-time do loop that is not one of our generated ones.;'); more = true; return node[2]; @@ -1488,7 +1488,7 @@ function loopOptimizer(ast) { function unVarify(vars, ret) { // transform var x=1, y=2 etc. into (x=1, y=2), i.e., the same assigns, but without a var definition ret = ret || []; ret[0] = 'stat'; - if (vars.length == 1) { + if (vars.length === 1) { ret[1] = ['assign', true, ['name', vars[0][0]], vars[0][1]]; } else { ret[1] = []; @@ -1510,16 +1510,16 @@ var ASM_DOUBLE = 1; function detectAsmCoercion(node) { // for params, +x vs x|0, for vars, 0.0 vs 0 - if (node[0] == 'num' && node[1].toString().indexOf('.') >= 0) return ASM_DOUBLE; - return node[0] == 'unary-prefix' ? ASM_DOUBLE : ASM_INT; + if (node[0] === 'num' && node[1].toString().indexOf('.') >= 0) return ASM_DOUBLE; + return node[0] === 'unary-prefix' ? ASM_DOUBLE : ASM_INT; } function makeAsmParamCoercion(param, type) { - return type == ASM_INT ? ['binary', '|', ['name', param], ['num', 0]] : ['unary-prefix', '+', ['name', param]]; + return type === ASM_INT ? ['binary', '|', ['name', param], ['num', 0]] : ['unary-prefix', '+', ['name', param]]; } function makeAsmVarDef(v, type) { - return [v, type == ASM_INT ? ['num', 0] : ['unary-prefix', '+', ['num', 0]]]; + return [v, type === ASM_INT ? ['num', 0] : ['unary-prefix', '+', ['num', 0]]]; } function normalizeAsm(func) { @@ -1551,7 +1551,7 @@ function normalizeAsm(func) { var name = v[0]; var value = v[1]; if (!(name in data.vars)) { - assert(value[0] == 'num' || (value[0] == 'unary-prefix' && value[2][0] == 'num')); // must be valid coercion no-op + assert(value[0] === 'num' || (value[0] === 'unary-prefix' && value[2][0] === 'num')); // must be valid coercion no-op data.vars[name] = detectAsmCoercion(value); v.length = 1; // make an un-assigning var } else { @@ -1563,7 +1563,7 @@ function normalizeAsm(func) { // finally, look for other var definitions and collect them while (i < stats.length) { traverse(stats[i], function(node, type) { - if (type == 'var') { + if (type === 'var') { for (var j = 0; j < node[1].length; j++) { var v = node[1][j]; var name = v[0]; @@ -1578,8 +1578,8 @@ function normalizeAsm(func) { } } unVarify(node[1], node); - } else if (type == 'dot') { - if (node[1][0] == 'name' && node[1][1] == 'Math') { + } else if (type === 'dot') { + if (node[1][0] === 'name' && node[1][1] === 'Math') { // transform Math.max to Math_max; we forward in the latter version node[0] = 'name'; node[1] = 'Math_' + node[2]; @@ -1597,7 +1597,7 @@ function denormalizeAsm(func, data) { var stats = func[3]; // Remove var definitions, if any for (var i = 0; i < stats.length; i++) { - if (stats[i][0] == 'var') { + if (stats[i][0] === 'var') { stats[i] = emptyNode(); } else { if (!isEmptyNode(stats[i])) break; @@ -1666,7 +1666,7 @@ function registerize(ast) { var localVars = {}; var hasSwitch = false; // we cannot optimize variables if there is a switch, unless in asm mode traverse(fun, function(node, type) { - if (type == 'var') { + if (type === 'var') { node[1].forEach(function(defined) { localVars[defined[0]] = 1 }); var vars = node[1].filter(function(varr) { return varr[1] }); if (vars.length >= 1) { @@ -1674,7 +1674,7 @@ function registerize(ast) { } else { return emptyNode(); } - } else if (type == 'switch') { + } else if (type === 'switch') { hasSwitch = true; } }); @@ -1685,7 +1685,7 @@ function registerize(ast) { var nextLocal = 0; // Minify globals using the mapping we were given traverse(fun, function(node, type) { - if (type == 'name') { + if (type === 'name') { var name = node[1]; var minified = minifierInfo.globals[name]; if (minified) { @@ -1705,13 +1705,13 @@ function registerize(ast) { asmData.params[newName] = asmData.params[minified]; delete asmData.params[minified]; traverse(fun, function(node, type) { - if (type == 'name' && node[1] == minified) { + if (type === 'name' && node[1] === minified) { node[1] = newName; } }); if (fun[2]) { for (var i = 0; i < fun[2].length; i++) { - if (fun[2][i] == minified) fun[2][i] = newName; + if (fun[2][i] === minified) fun[2][i] = newName; } } } @@ -1764,15 +1764,15 @@ function registerize(ast) { level--; } traverse(fun, function possibilifier(node, type) { - if (type == 'name') { + if (type === 'name') { var name = node[1]; if (localVars[name]) { if (!varUses[name]) varUses[name] = 0; varUses[name]++; if (possibles[name] && !varLevels[name]) unoptimizables[name] = 1; // used outside of simple domination } - } else if (type == 'assign' && typeof node[1] != 'string') { - if (node[2] && node[2][0] == 'name') { + } else if (type === 'assign' && typeof node[1] != 'string') { + if (node[2] && node[2][0] === 'name') { var name = node[2][1]; // if local and not yet used, this might be optimizable if we dominate // all other uses @@ -1880,11 +1880,11 @@ function registerize(ast) { } varUses[name]--; assert(varUses[name] >= 0); - if (varUses[name] == 0) { + if (varUses[name] === 0) { if (optimizables[name]) delete activeOptimizables[name]; // If we are not in a loop, or we are optimizable and not bound to a loop // (we might have been in one but left it), we can free the register now. - if (loops == 0 || (optimizables[name] && !optimizableLoops[name])) { + if (loops === 0 || (optimizables[name] && !optimizableLoops[name])) { // free register freeRegs.push(reg); } else { @@ -1897,7 +1897,7 @@ function registerize(ast) { return true; } traverse(fun, function(node, type) { // XXX we rely on traversal order being the same as execution order here - if (type == 'name') { + if (type === 'name') { var name = node[1]; if (decUse(name)) { node[1] = fullNames[varRegs[name]]; @@ -2004,10 +2004,10 @@ var IGNORABLE_ELIMINATOR_SCAN_NODES = set('num', 'toplevel', 'string', 'break', var ABORTING_ELIMINATOR_SCAN_NODES = set('new', 'object', 'function', 'defun', 'for', 'while', 'array', 'throw'); // we could handle some of these, TODO, but nontrivial (e.g. for while, the condition is hit multiple times after the body) function isTempDoublePtrAccess(node) { // these are used in bitcasts; they are not really affecting memory, and should cause no invalidation - assert(node[0] == 'sub'); - return (node[2][0] == 'name' && node[2][1] == 'tempDoublePtr') || - (node[2][0] == 'binary' && ((node[2][2][0] == 'name' && node[2][2][1] == 'tempDoublePtr') || - (node[2][3][0] == 'name' && node[2][3][1] == 'tempDoublePtr'))); + assert(node[0] === 'sub'); + return (node[2][0] === 'name' && node[2][1] === 'tempDoublePtr') || + (node[2][0] === 'binary' && ((node[2][2][0] === 'name' && node[2][2][1] === 'tempDoublePtr') || + (node[2][3][0] === 'name' && node[2][3][1] === 'tempDoublePtr'))); } function eliminate(ast, memSafe) { @@ -2055,7 +2055,7 @@ function eliminate(ast, memSafe) { uses[name]++; } else if (type === 'assign') { var target = node[2]; - if (target[0] == 'name') { + if (target[0] === 'name') { var name = target[1]; if (!(name in definitions)) definitions[name] = 0; definitions[name]++; @@ -2089,9 +2089,9 @@ function eliminate(ast, memSafe) { if (name in varsToTryToRemove) delete varsToTryToRemove[name]; } function processVariable(name) { - if (definitions[name] == 1 && uses[name] == 1) { + if (definitions[name] === 1 && uses[name] === 1) { potentials[name] = 1; - } else if (uses[name] == 0 && (!definitions[name] || definitions[name] <= 1)) { // no uses, no def or 1 def (cannot operate on phis, and the llvm optimizer will remove unneeded phis anyhow) + } else if (uses[name] === 0 && (!definitions[name] || definitions[name] <= 1)) { // no uses, no def or 1 def (cannot operate on phis, and the llvm optimizer will remove unneeded phis anyhow) var hasSideEffects = false; var value = values[name]; if (value) { @@ -2099,8 +2099,8 @@ function eliminate(ast, memSafe) { // First, pattern-match // (HEAP32[((tempDoublePtr)>>2)]=((HEAP32[(($_sroa_0_0__idx1)>>2)])|0),HEAP32[(((tempDoublePtr)+(4))>>2)]=((HEAP32[((($_sroa_0_0__idx1)+(4))>>2)])|0),(+(HEAPF64[(tempDoublePtr)>>3]))) // which has no side effects and is the special form of converting double to i64. - if (!(value[0] == 'seq' && value[1][0] == 'assign' && value[1][2][0] == 'sub' && value[1][2][2][0] == 'binary' && value[1][2][2][1] == '>>' && - value[1][2][2][2][0] == 'name' && value[1][2][2][2][1] == 'tempDoublePtr')) { + if (!(value[0] === 'seq' && value[1][0] === 'assign' && value[1][2][0] === 'sub' && value[1][2][2][0] === 'binary' && value[1][2][2][1] === '>>' && + value[1][2][2][2][0] === 'name' && value[1][2][2][2][1] === 'tempDoublePtr')) { // If not that, then traverse and scan normally. traverse(value, function(node, type) { if (!(type in NODES_WITHOUT_ELIMINATION_SIDE_EFFECTS)) { @@ -2118,7 +2118,7 @@ function eliminate(ast, memSafe) { // appearing in it, and possibly eliminate again if (value) { traverse(value, function(node, type) { - if (type == 'name') { + if (type === 'name') { var name = node[1]; node[1] = ''; // we can remove this - it will never be shown, and should not be left to confuse us as we traverse if (name in locals) { @@ -2156,7 +2156,7 @@ function eliminate(ast, memSafe) { var usesGlobals = false, usesMemory = false, deps = {}, doesCall = false; var ignoreName = false; // one-time ignorings of names, as first op in sub and call traverse(value, function(node, type) { - if (type == 'name') { + if (type === 'name') { if (!ignoreName) { var name = node[1]; if (!(name in locals)) { @@ -2168,10 +2168,10 @@ function eliminate(ast, memSafe) { } else { ignoreName = false; } - } else if (type == 'sub') { + } else if (type === 'sub') { usesMemory = true; ignoreName = true; - } else if (type == 'call') { + } else if (type === 'call') { usesGlobals = true; usesMemory = true; doesCall = true; @@ -2259,10 +2259,10 @@ function eliminate(ast, memSafe) { //nesting++; // printErr-related //printErr(spaces(2*(nesting+1)) + 'trav: ' + JSON.stringify(node).substr(0, 50) + ' : ' + keys(tracked) + ' : ' + [allowTracking, ignoreSub, ignoreName]); var type = node[0]; - if (type == 'assign') { + if (type === 'assign') { var target = node[2]; var value = node[3]; - var nameTarget = target[0] == 'name'; + var nameTarget = target[0] === 'name'; traverseInOrder(target, true, nameTarget); // evaluate left traverseInOrder(value); // evaluate right // do the actual assignment @@ -2279,7 +2279,7 @@ function eliminate(ast, memSafe) { } // if we can track this name (that we assign into), and it has 0 uses and we want to remove its 'var' // definition - then remove it right now, there is no later chance - if (allowTracking && (name in varsToRemove) && uses[name] == 0) { + if (allowTracking && (name in varsToRemove) && uses[name] === 0) { track(name, node[3], node); doEliminate(name, node); } @@ -2294,13 +2294,13 @@ function eliminate(ast, memSafe) { } else { if (allowTracking) track(name, node[3], node); } - } else if (target[0] == 'sub') { + } else if (target[0] === 'sub') { if (!isTempDoublePtrAccess(target) && !memoryInvalidated) { invalidateMemory(); memoryInvalidated = true; } } - } else if (type == 'sub') { + } else if (type === 'sub') { traverseInOrder(node[1], false, !memSafe); // evaluate inner traverseInOrder(node[2]); // evaluate outer // ignoreSub means we are a write (happening later), not a read @@ -2311,7 +2311,7 @@ function eliminate(ast, memSafe) { callsInvalidated = true; } } - } else if (type == 'var') { + } else if (type === 'var') { var vars = node[1]; for (var i = 0; i < vars.length; i++) { var name = vars[i][0]; @@ -2323,7 +2323,7 @@ function eliminate(ast, memSafe) { } else { invalidateByDep(name); } - if (vars.length == 1 && name in varsToTryToRemove && value) { + if (vars.length === 1 && name in varsToTryToRemove && value) { // replace it in-place value = ['stat', value]; node.length = value.length; @@ -2334,7 +2334,7 @@ function eliminate(ast, memSafe) { } } } - } else if (type == 'binary') { + } else if (type === 'binary') { var flipped = false; if (node[1] in ASSOCIATIVE_BINARIES && !(node[2][0] in NAME_OR_NUM) && node[3][0] in NAME_OR_NUM) { // TODO recurse here? // associatives like + and * can be reordered in the simple case of one of the sides being a name, since we assume they are all just numbers @@ -2350,7 +2350,7 @@ function eliminate(ast, memSafe) { node[2] = node[3]; node[3] = temp; } - } else if (type == 'name') { + } else if (type === 'name') { if (!ignoreName) { // ignoreName means we are the name of something like a call or a sub - irrelevant for us var name = node[1]; if (name in tracked) { @@ -2360,10 +2360,10 @@ function eliminate(ast, memSafe) { callsInvalidated = true; } } - } else if (type == 'unary-prefix' || type == 'unary-postfix') { + } else if (type === 'unary-prefix' || type === 'unary-postfix') { traverseInOrder(node[2]); } else if (type in IGNORABLE_ELIMINATOR_SCAN_NODES) { - } else if (type == 'call') { + } else if (type === 'call') { traverseInOrder(node[1], false, true); var args = node[2]; for (var i = 0; i < args.length; i++) { @@ -2378,7 +2378,7 @@ function eliminate(ast, memSafe) { invalidateMemory(); memoryInvalidated = true; } - } else if (type == 'if') { + } else if (type === 'if') { if (allowTracking) { traverseInOrder(node[1]); // can eliminate into condition, but nowhere else if (!callsInvalidated) { // invalidate calls, since we cannot eliminate them into an if that may not execute! @@ -2394,38 +2394,38 @@ function eliminate(ast, memSafe) { } else { tracked = {}; } - } else if (type == 'block') { + } else if (type === 'block') { var stats = node[1]; if (stats) { for (var i = 0; i < stats.length; i++) { traverseInOrder(stats[i]); } } - } else if (type == 'stat') { + } else if (type === 'stat') { traverseInOrder(node[1]); - } else if (type == 'label') { + } else if (type === 'label') { traverseInOrder(node[2]); - } else if (type == 'seq') { + } else if (type === 'seq') { traverseInOrder(node[1]); traverseInOrder(node[2]); - } else if (type == 'do') { - if (node[1][0] == 'num' && node[1][1] == 0) { // one-time loop + } else if (type === 'do') { + if (node[1][0] === 'num' && node[1][1] === 0) { // one-time loop traverseInOrder(node[2]); } else { tracked = {}; } - } else if (type == 'return') { + } else if (type === 'return') { if (node[1]) traverseInOrder(node[1]); - } else if (type == 'conditional') { + } else if (type === 'conditional') { traverseInOrder(node[1]); traverseInOrder(node[2]); traverseInOrder(node[3]); - } else if (type == 'switch') { + } else if (type === 'switch') { traverseInOrder(node[1]); var cases = node[2]; for (var i = 0; i < cases.length; i++) { var c = cases[i]; - assert(c[0] === null || c[0][0] == 'num' || (c[0][0] == 'unary-prefix' && c[0][2][0] == 'num')); + assert(c[0] === null || c[0][0] === 'num' || (c[0][0] === 'unary-prefix' && c[0][2][0] === 'num')); var stats = c[1]; for (var j = 0; j < stats.length; j++) { traverseInOrder(stats[j]); @@ -2444,7 +2444,7 @@ function eliminate(ast, memSafe) { } //var eliminationLimit = 0; // used to debugging purposes function doEliminate(name, node) { - //if (eliminationLimit == 0) return; + //if (eliminationLimit === 0) return; //eliminationLimit--; //printErr('elim!!!!! ' + name); // yes, eliminate! @@ -2453,9 +2453,9 @@ function eliminate(ast, memSafe) { delete tracked[name]; var defNode = info.defNode; if (!sideEffectFree[name]) { - if (defNode[0] == 'var') { + if (defNode[0] === 'var') { defNode[1].forEach(function(pair) { - if (pair[0] == name) { + if (pair[0] === name) { value = pair[1]; } }); @@ -2481,7 +2481,7 @@ function eliminate(ast, memSafe) { } traverse(func, function(block) { // Look for statements, including while-switch pattern - var stats = getStatements(block) || (block[0] == 'while' && block[2][0] == 'switch' ? [block[2]] : stats); + var stats = getStatements(block) || (block[0] === 'while' && block[2][0] === 'switch' ? [block[2]] : stats); if (!stats) return; //printErr('Stats: ' + JSON.stringify(stats).substr(0,100)); tracked = {}; @@ -2490,7 +2490,7 @@ function eliminate(ast, memSafe) { var node = stats[i]; //printErr('StatBlock[' + i + '] => ' + JSON.stringify(node).substr(0,100)); var type = node[0]; - if (type == 'stat') { + if (type === 'stat') { node = node[1]; type = node[0]; } @@ -2509,9 +2509,9 @@ function eliminate(ast, memSafe) { // clean up vars, and loop variable elimination traverse(func, function(node, type) { // pre - if (type == 'var') { + if (type === 'var') { node[1] = node[1].filter(function(pair) { return !varsToRemove[pair[0]] }); - if (node[1].length == 0) { + if (node[1].length === 0) { // wipe out an empty |var;| node[0] = 'toplevel'; node[1] = []; @@ -2519,7 +2519,7 @@ function eliminate(ast, memSafe) { } }, function(node, type) { // post - if (type == 'name') { + if (type === 'name') { var name = node[1]; if (name in helperReplacements) { node[1] = helperReplacements[name]; @@ -2531,30 +2531,30 @@ function eliminate(ast, memSafe) { } else { seenUses[name]++; } - } else if (type == 'while') { + } else if (type === 'while') { // try to remove loop helper variables specifically var stats = node[2][1]; var last = stats[stats.length-1]; - if (last && last[0] == 'if' && last[2][0] == 'block' && last[3] && last[3][0] == 'block') { + if (last && last[0] === 'if' && last[2][0] === 'block' && last[3] && last[3][0] === 'block') { var ifTrue = last[2]; var ifFalse = last[3]; var flip = false; - if (ifFalse[1][0][0] == 'break') { // canonicalize break in the if + if (ifFalse[1][0][0] === 'break') { // canonicalize break in the if var temp = ifFalse; ifFalse = ifTrue; ifTrue = temp; flip = true; } - if (ifTrue[1][0][0] == 'break') { + if (ifTrue[1][0][0] === 'break') { var assigns = ifFalse[1]; var loopers = [], helpers = []; for (var i = 0; i < assigns.length; i++) { - if (assigns[i][0] == 'stat' && assigns[i][1][0] == 'assign') { + if (assigns[i][0] === 'stat' && assigns[i][1][0] === 'assign') { var assign = assigns[i][1]; - if (assign[1] === true && assign[2][0] == 'name' && assign[3][0] == 'name') { + if (assign[1] === true && assign[2][0] === 'name' && assign[3][0] === 'name') { var looper = assign[2][1]; var helper = assign[3][1]; - if (definitions[helper] == 1 && seenUses[looper] == namings[looper] && + if (definitions[helper] === 1 && seenUses[looper] === namings[looper] && !helperReplacements[helper] && !helperReplacements[looper]) { loopers.push(looper); helpers.push(helper); @@ -2570,11 +2570,11 @@ function eliminate(ast, memSafe) { var found = -1; for (var i = stats.length-2; i >= 0; i--) { var curr = stats[i]; - if (curr[0] == 'stat' && curr[1][0] == 'assign') { + if (curr[0] === 'stat' && curr[1][0] === 'assign') { var currAssign = curr[1]; - if (currAssign[1] === true && currAssign[2][0] == 'name') { + if (currAssign[1] === true && currAssign[2][0] === 'name') { var to = currAssign[2][1]; - if (to == helper) { + if (to === helper) { found = i; break; } @@ -2586,7 +2586,7 @@ function eliminate(ast, memSafe) { for (var i = found+1; i < stats.length && !looperUsed; i++) { var curr = i < stats.length-1 ? stats[i] : last[1]; // on the last line, just look in the condition traverse(curr, function(node, type) { - if (type == 'name' && node[1] == looper) { + if (type === 'name' && node[1] === looper) { looperUsed = true; return true; } @@ -2596,7 +2596,7 @@ function eliminate(ast, memSafe) { } for (var l = 0; l < helpers.length; l++) { for (var k = 0; k < helpers.length; k++) { - if (l != k && helpers[l] == helpers[k]) return; // it is complicated to handle a shared helper, abort + if (l != k && helpers[l] === helpers[k]) return; // it is complicated to handle a shared helper, abort } } // hurrah! this is safe to do @@ -2606,7 +2606,7 @@ function eliminate(ast, memSafe) { var helper = helpers[l]; varsToRemove[helper] = 2; traverse(node, function(node, type) { // replace all appearances of helper with looper - if (type == 'name' && node[1] == helper) node[1] = looper; + if (type === 'name' && node[1] === helper) node[1] = looper; }); helperReplacements[helper] = looper; // replace all future appearances of helper with looper helperReplacements[looper] = looper; // avoid any further attempts to optimize looper in this manner (seenUses is wrong anyhow, too) @@ -2624,7 +2624,7 @@ function eliminate(ast, memSafe) { if (asm) { for (var v in varsToRemove) { - if (varsToRemove[v] == 2) delete asmData.vars[v]; + if (varsToRemove[v] === 2) delete asmData.vars[v]; } denormalizeAsm(func, asmData); } @@ -2638,7 +2638,7 @@ function eliminate(ast, memSafe) { this.run = function() { traverse(this.node, function(node, type) { - if (type == 'binary' && node[1] === '+') { + if (type === 'binary' && node[1] === '+') { var names = []; var num = 0; var has_num = false; @@ -2687,7 +2687,7 @@ function minifyGlobals(ast) { var first = true; // do not minify initial 'var asm =' // find the globals traverse(ast, function(node, type) { - if (type == 'var') { + if (type === 'var') { if (first) { first = false; return; @@ -2708,7 +2708,7 @@ function minifyGlobals(ast) { } // apply minification traverse(ast, function(node, type) { - if (type == 'name') { + if (type === 'name') { var name = node[1]; if (name in minified) { node[1] = minified[name]; @@ -2721,9 +2721,9 @@ function minifyGlobals(ast) { // Change +5 to DOT$ZERO(5). We then textually change 5 to 5.0 (uglify's ast cannot differentiate between 5 and 5.0 directly) function prepDotZero(ast) { traverse(ast, function(node, type) { - if (type == 'unary-prefix' && node[1] === '+') { - if (node[2][0] == 'num' || - (node[2][0] == 'unary-prefix' && node[2][1] == '-' && node[2][2][0] == 'num')) { + if (type === 'unary-prefix' && node[1] === '+') { + if (node[2][0] === 'num' || + (node[2][0] === 'unary-prefix' && node[2][1] === '-' && node[2][2][0] === 'num')) { return ['call', ['name', 'DOT$ZERO'], [node[2]]]; } } @@ -2731,7 +2731,7 @@ function prepDotZero(ast) { } function fixDotZero(js) { return js.replace(/DOT\$ZERO\(([-+]?(0x)?[0-9a-f]*\.?[0-9]+([eE][-+]?[0-9]+)?)\)/g, function(m, num) { - if (num.substr(0, 2) == '0x' || num.substr(0, 3) == '-0x') { + if (num.substr(0, 2) === '0x' || num.substr(0, 3) === '-0x') { return eval(num) + '.0'; } if (num.indexOf('.') >= 0) return num; @@ -2746,11 +2746,11 @@ function asmLoopOptimizer(ast) { // This is at the end of the pipeline, we can assume all other optimizations are done, and we modify loops // into shapes that might confuse other passes traverse(fun, function(node, type) { - if (type == 'while' && node[1][0] == 'num' && node[1][1] == 1 && node[2][0] == 'block') { + if (type === 'while' && node[1][0] === 'num' && node[1][1] === 1 && node[2][0] === 'block') { // while (1) { .. if (..) { break } } ==> do { .. } while(..) var stats = node[2][1]; var last = stats[stats.length-1]; - if (last && last[0] == 'if' && !last[3] && last[2][0] == 'block' && last[2][1][0][0] == 'break' && !last[2][1][0][1]) { + if (last && last[0] === 'if' && !last[3] && last[2][0] === 'block' && last[2][1][0][0] === 'break' && !last[2][1][0][1]) { var conditionToBreak = last[1]; stats.pop(); node[0] = 'do'; From e08502da58c467e889d82fee33fffccd49190d05 Mon Sep 17 00:00:00 2001 From: Jez Ng Date: Wed, 26 Jun 2013 01:38:24 -0700 Subject: [PATCH 62/69] We can just compare for strings here. --- tools/js-optimizer.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/js-optimizer.js b/tools/js-optimizer.js index 3943963adc649..109f5b6de11dd 100644 --- a/tools/js-optimizer.js +++ b/tools/js-optimizer.js @@ -188,7 +188,7 @@ function traverseChildren(node, traverse, pre, post, stack) { // was stopped, true. Otherwise undefined. function traverse(node, pre, post, stack) { var type = node[0], result, len; - var relevant = !Array.isArray(node[0]); + var relevant = typeof node[0] === 'string'; if (relevant) { if (stack) len = stack.length; var result = pre(node, type, stack); From 5383aa8bf93e5c9fed3f67853b2675ab2be10493 Mon Sep 17 00:00:00 2001 From: Jez Ng Date: Wed, 26 Jun 2013 01:56:30 -0700 Subject: [PATCH 63/69] Reuse nodes where possible. This allows us to preserve more line numbers when debugging. --- tools/js-optimizer.js | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tools/js-optimizer.js b/tools/js-optimizer.js index 109f5b6de11dd..532dc7fc3f1f6 100644 --- a/tools/js-optimizer.js +++ b/tools/js-optimizer.js @@ -706,7 +706,8 @@ function simplifyExpressionsPre(ast) { if (type === 'binary' && node[1] === '+') { if (node[2][0] === 'num' && node[3][0] === 'num') { rerun = true; - return ['num', node[2][1] + node[3][1]]; + node[2][1] += node[3][1]; + return node[2]; } for (var i = 2; i <= 3; i++) { var ii = 5-i; From b54c74693af827f27dc490d8b1e7f46f82ac1167 Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Wed, 26 Jun 2013 11:08:13 -0700 Subject: [PATCH 64/69] fix crash in asmLoopOptimizer --- tools/js-optimizer.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/js-optimizer.js b/tools/js-optimizer.js index c772f667941bc..151e573a2750c 100644 --- a/tools/js-optimizer.js +++ b/tools/js-optimizer.js @@ -2806,7 +2806,7 @@ function asmLoopOptimizer(ast) { // while (1) { .. if (..) { break } } ==> do { .. } while(..) var stats = node[2][1]; var last = stats[stats.length-1]; - if (last && last[0] === 'if' && !last[3] && last[2][0] === 'block' && last[2][1][0][0] === 'break' && !last[2][1][0][1]) { + if (last && last[0] === 'if' && !last[3] && last[2][0] === 'block' && last[2][1][0] && last[2][1][0][0] === 'break' && !last[2][1][0][1]) { var conditionToBreak = last[1]; stats.pop(); node[0] = 'do'; From deacdfa1297cb3bbbb8aedb439f52aae11571630 Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Wed, 26 Jun 2013 11:47:20 -0700 Subject: [PATCH 65/69] remove incorrect comment --- emcc | 5 ----- 1 file changed, 5 deletions(-) diff --git a/emcc b/emcc index 0c1515759d063..fb73ef6be9530 100755 --- a/emcc +++ b/emcc @@ -211,11 +211,6 @@ Options that are modified or new in %s include: slower because JS optimization will be limited to 1 core. (default in -O0) - -g2 Like -g1, but we generate source maps as well, - and we preserve comments even with -O1 and above. - Note that this may be considerably slower because - JS optimization is limited to a single core. - --typed-arrays 0: No typed arrays 1: Parallel typed arrays 2: Shared (C-like) typed arrays (default) From 4d0be84d50307689f6b15f9f4502255736e522db Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Wed, 26 Jun 2013 11:51:32 -0700 Subject: [PATCH 66/69] fix test_debug --- tests/runner.py | 18 ++++++++---------- 1 file changed, 8 insertions(+), 10 deletions(-) diff --git a/tests/runner.py b/tests/runner.py index c55c96fd91353..46dc5e11f9895 100755 --- a/tests/runner.py +++ b/tests/runner.py @@ -9570,20 +9570,18 @@ def test_debug(self): } ''' try: - post = r''' -def process(filename): - lines = open(filename, 'r').readlines() - lines = filter(lambda line: '___assert_fail(' in line or '___assert_func(' in line, lines) - found_line_num = any(('//@line 7 "' in line) for line in lines) - found_filename = any(('src.cpp"\n' in line) for line in lines) - assert found_line_num, 'Must have debug info with the line number' - assert found_filename, 'Must have debug info with the filename' -''' - self.do_run(src, '*nothingatall*', post_build=post) + self.do_run(src, '*nothingatall*') except Exception, e: # This test *should* fail assert 'Assertion failed: x < 15' in str(e), str(e) + lines = open('src.cpp.o.js', 'r').readlines() + lines = filter(lambda line: '___assert_fail(' in line or '___assert_func(' in line, lines) + found_line_num = any(('//@line 7 "' in line) for line in lines) + found_filename = any(('src.cpp"\n' in line) for line in lines) + assert found_line_num, 'Must have debug info with the line number' + assert found_filename, 'Must have debug info with the filename' + def test_source_map(self): if Settings.USE_TYPED_ARRAYS != 2: return self.skip("doesn't pass without typed arrays") if NODE_JS not in JS_ENGINES: return self.skip('sourcemapper requires Node to run') From dc341c89d3521c27a41f0d65047096bc0f1f99d2 Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Wed, 26 Jun 2013 13:51:59 -0700 Subject: [PATCH 67/69] deprecate llvm opts in non-ta2 modes --- emcc | 4 ++++ src/settings.js | 4 ++-- tests/runner.py | 34 ++++++++++++++-------------------- 3 files changed, 20 insertions(+), 22 deletions(-) diff --git a/emcc b/emcc index fb73ef6be9530..bd4f6808b19f0 100755 --- a/emcc +++ b/emcc @@ -1058,6 +1058,10 @@ try: else: raise Exception('unknown llvm target: ' + str(shared.LLVM_TARGET)) + if shared.Settings.USE_TYPED_ARRAYS != 2 and llvm_opts > 0: + logging.warning('disabling LLVM optimizations, need typed arrays mode 2 for them') + llvm_opts = 0 + ## Compile source code to bitcode logging.debug('compiling to bitcode') diff --git a/src/settings.js b/src/settings.js index 3a91b4886fa78..3e530c52bbb82 100644 --- a/src/settings.js +++ b/src/settings.js @@ -67,9 +67,9 @@ var RELOOP = 0; // Recreate js native loops from llvm data var RELOOPER = 'relooper.js'; // Loads the relooper from this path relative to compiler.js var USE_TYPED_ARRAYS = 2; // Use typed arrays for the heap. See https://github.com/kripken/emscripten/wiki/Code-Generation-Modes/ - // 0 means no typed arrays are used. + // 0 means no typed arrays are used. This mode disallows LLVM optimizations // 1 has two heaps, IHEAP (int32) and FHEAP (double), - // and addresses there are a match for normal addresses. This is deprecated. + // and addresses there are a match for normal addresses. This mode disallows LLVM optimizations. // 2 is a single heap, accessible through views as int8, int32, etc. This is // the recommended mode both for performance and for compatibility. var USE_FHEAP = 1; // Relevant in USE_TYPED_ARRAYS == 1. If this is disabled, only IHEAP will be used, and FHEAP diff --git a/tests/runner.py b/tests/runner.py index 46dc5e11f9895..cc057c001d8eb 100755 --- a/tests/runner.py +++ b/tests/runner.py @@ -435,7 +435,7 @@ def setup_runtimelink_test(self): sys.argv = map(lambda arg: arg if not arg.startswith('test_') else 'default.' + arg, sys.argv) -test_modes = ['default', 'o1', 'o2', 'asm1', 'asm2', 'asm2g', 'asm2x86', 's_0_0', 's_0_1', 's_1_0', 's_1_1'] +test_modes = ['default', 'o1', 'o2', 'asm1', 'asm2', 'asm2g', 'asm2x86', 's_0_0', 's_0_1'] test_index = 0 @@ -10005,7 +10005,7 @@ def test_gc(self): ''') # Generate tests for everything - def make_run(fullname, name=-1, compiler=-1, llvm_opts=0, embetter=0, quantum_size=0, typed_arrays=0, emcc_args=None, env='{}'): + def make_run(fullname, name=-1, compiler=-1, embetter=0, quantum_size=0, typed_arrays=0, emcc_args=None, env='{}'): exec(''' class %s(T): run_name = '%s' @@ -10042,7 +10042,6 @@ def setUp(self): Building.COMPILER_TEST_OPTS = [] # remove -g in -O2 tests, for more coverage return - llvm_opts = %d # 1 is yes, 2 is yes and unsafe embetter = %d quantum_size = %d # TODO: Move much of these to a init() function in shared.py, and reuse that @@ -10052,14 +10051,13 @@ def setUp(self): Settings.MICRO_OPTS = embetter Settings.QUANTUM_SIZE = quantum_size Settings.ASSERTIONS = 1-embetter - Settings.SAFE_HEAP = 1-(embetter and llvm_opts) - Building.LLVM_OPTS = llvm_opts - Settings.CHECK_OVERFLOWS = 1-(embetter or llvm_opts) - Settings.CORRECT_OVERFLOWS = 1-(embetter and llvm_opts) + Settings.SAFE_HEAP = 1-embetter + Settings.CHECK_OVERFLOWS = 1-embetter + Settings.CORRECT_OVERFLOWS = 1-embetter Settings.CORRECT_SIGNS = 0 Settings.CORRECT_ROUNDINGS = 0 Settings.CORRECT_OVERFLOWS_LINES = CORRECT_SIGNS_LINES = CORRECT_ROUNDINGS_LINES = SAFE_HEAP_LINES = [] - Settings.CHECK_SIGNS = 0 #1-(embetter or llvm_opts) + Settings.CHECK_SIGNS = 0 #1-embetter Settings.RUNTIME_TYPE_INFO = 0 Settings.DISABLE_EXCEPTION_CATCHING = 0 Settings.INCLUDE_FULL_LIBRARY = 0 @@ -10068,12 +10066,10 @@ def setUp(self): Settings.EMULATE_UNALIGNED_ACCESSES = int(Settings.USE_TYPED_ARRAYS == 2 and Building.LLVM_OPTS == 2) Settings.DOUBLE_MODE = 1 if Settings.USE_TYPED_ARRAYS and Building.LLVM_OPTS == 0 else 0 Settings.PRECISE_I64_MATH = 0 - Settings.NAMED_GLOBALS = 0 if not (embetter and llvm_opts) else 1 - - Building.pick_llvm_opts(3) + Settings.NAMED_GLOBALS = 0 if not embetter else 1 TT = %s -''' % (fullname, fullname, env, fullname, fullname, compiler, str(emcc_args), llvm_opts, embetter, quantum_size, typed_arrays, fullname)) +''' % (fullname, fullname, env, fullname, fullname, compiler, str(emcc_args), embetter, quantum_size, typed_arrays, fullname)) return TT # Make one run with the defaults @@ -10092,16 +10088,14 @@ def setUp(self): exec('''asm2x86 = make_run("asm2x86", compiler=CLANG, emcc_args=["-O2", "-g", "-s", "CHECK_HEAP_ALIGN=1"], env='{"EMCC_LLVM_TARGET": "i386-pc-linux-gnu"}')''') # Make custom runs with various options - for compiler, quantum, embetter, typed_arrays, llvm_opts in [ - (CLANG, 4, 0, 0, 0), - (CLANG, 4, 0, 0, 1), - (CLANG, 4, 1, 1, 0), - (CLANG, 4, 1, 1, 1), + for compiler, quantum, embetter, typed_arrays in [ + (CLANG, 4, 0, 0), + (CLANG, 4, 1, 1), ]: - fullname = 's_%d_%d%s%s' % ( - llvm_opts, embetter, '' if quantum == 4 else '_q' + str(quantum), '' if typed_arrays in [0, 1] else '_t' + str(typed_arrays) + fullname = 's_0_%d%s%s' % ( + embetter, '' if quantum == 4 else '_q' + str(quantum), '' if typed_arrays in [0, 1] else '_t' + str(typed_arrays) ) - exec('%s = make_run(fullname, %r,%r,%d,%d,%d,%d)' % (fullname, fullname, compiler, llvm_opts, embetter, quantum, typed_arrays)) + exec('%s = make_run(fullname, %r,%r,%d,%d,%d)' % (fullname, fullname, compiler, embetter, quantum, typed_arrays)) del T # T is just a shape for the specific subclasses, we don't test it itself From 7e179d8c63f43ade6d6345e9bb118e1974a1c992 Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Wed, 26 Jun 2013 13:58:30 -0700 Subject: [PATCH 68/69] make EMCC_OPTIMIZE_NORMALLY the default --- emcc | 31 +++++++------------------- tests/runner.py | 58 ------------------------------------------------- tools/shared.py | 4 ---- 3 files changed, 8 insertions(+), 85 deletions(-) diff --git a/emcc b/emcc index bd4f6808b19f0..c2ede46aa836d 100755 --- a/emcc +++ b/emcc @@ -127,11 +127,6 @@ Options that are modified or new in %s include: (For details on the affects of different opt levels, see apply_opt_level() in tools/shared.py and also src/settings.js.) - Note: Optimizations are only done when - compiling to JavaScript, not to intermediate - bitcode, *unless* you build with - EMCC_OPTIMIZE_NORMALLY=1 (not recommended - unless you know what you are doing!) -O2 As -O1, plus the relooper (loop recreation), LLVM -O2 optimizations, and @@ -1103,18 +1098,15 @@ try: if not LEAVE_INPUTS_RAW: assert len(temp_files) == len(input_files) + # Optimize source files + if llvm_opts > 0: + for input_file in input_files: + if input_file.endswith(SOURCE_SUFFIXES): + logging.debug('optimizing %s with -O%d' % (input_file, llvm_opts)) + shared.Building.llvm_opt(in_temp(unsuffixed(uniquename(input_file)) + '.o'), llvm_opts) + # If we were just asked to generate bitcode, stop there if final_suffix not in JS_CONTAINING_SUFFIXES: - if llvm_opts > 0: - if not os.environ.get('EMCC_OPTIMIZE_NORMALLY'): - logging.warning('-Ox flags ignored, since not generating JavaScript') - else: - for input_file in input_files: - if input_file.endswith(SOURCE_SUFFIXES): - logging.debug('optimizing %s with -O%d since EMCC_OPTIMIZE_NORMALLY defined' % (input_file, llvm_opts)) - shared.Building.llvm_opt(in_temp(unsuffixed(uniquename(input_file)) + '.o'), llvm_opts) - else: - logging.debug('not optimizing %s despite EMCC_OPTIMIZE_NORMALLY since not source code' % (input_file)) if not specified_target: for input_file in input_files: shutil.move(in_temp(unsuffixed(uniquename(input_file)) + '.o'), unsuffixed_basename(input_file) + '.' + final_suffix) @@ -1154,7 +1146,7 @@ try: libcxx_symbols = read_symbols(shared.path_from_root('system', 'lib', 'libcxx', 'symbols'), exclude=libc_symbols) libcxxabi_symbols = read_symbols(shared.path_from_root('system', 'lib', 'libcxxabi', 'symbols'), exclude=libc_symbols) - # XXX we should disable EMCC_DEBUG (and EMCC_OPTIMIZE_NORMALLY?) when building libs, just like in the relooper + # XXX we should disable EMCC_DEBUG when building libs, just like in the relooper def build_libc(lib_filename, files): o_s = [] @@ -1422,13 +1414,6 @@ try: if not LEAVE_INPUTS_RAW: link_opts = [] if debug_level >= 4 else ['-strip-debug'] # remove LLVM debug if we are not asked for it - if llvm_opts > 0: - if not os.environ.get('EMCC_OPTIMIZE_NORMALLY'): - shared.Building.llvm_opt(in_temp(target_basename + '.bc'), llvm_opts) - if DEBUG: save_intermediate('opt', 'bc') - # Do LTO in a separate pass to work around LLVM bug XXX (see failure e.g. in cubescript) - else: - logging.debug('not running opt because EMCC_OPTIMIZE_NORMALLY was specified, opt should have been run before') if shared.Building.can_build_standalone(): # If we can LTO, do it before dce, since it opens up dce opportunities if llvm_lto and shared.Building.can_use_unsafe_opts(): diff --git a/tests/runner.py b/tests/runner.py index cc057c001d8eb..e6c7f958fabb1 100755 --- a/tests/runner.py +++ b/tests/runner.py @@ -11494,64 +11494,6 @@ def test_link_s(self): code = open('a.out.js').read() assert 'SAFE_HEAP' in code, 'valid -s option had an effect' - def test_optimize_normally(self): - assert not os.environ.get('EMCC_OPTIMIZE_NORMALLY') - assert not os.environ.get('EMCC_DEBUG') - - for optimize_normally in [0, 1]: - print optimize_normally - try: - if optimize_normally: os.environ['EMCC_OPTIMIZE_NORMALLY'] = '1' - os.environ['EMCC_DEBUG'] = '1' - - open(self.in_dir('main.cpp'), 'w').write(r''' - extern "C" { - void something(); - } - - int main() { - something(); - return 0; - } - ''') - open(self.in_dir('supp.cpp'), 'w').write(r''' - #include - - extern "C" { - void something() { - printf("yello\n"); - } - } - ''') - out, err = Popen([PYTHON, EMCC, self.in_dir('main.cpp'), '-O2', '-o', 'main.o'], stdout=PIPE, stderr=PIPE).communicate() - assert ("emcc: LLVM opts: ['-O3']" in err) == optimize_normally - assert (' with -O3 since EMCC_OPTIMIZE_NORMALLY defined' in err) == optimize_normally - - out, err = Popen([PYTHON, EMCC, self.in_dir('supp.cpp'), '-O2', '-o', 'supp.o'], stdout=PIPE, stderr=PIPE).communicate() - assert ("emcc: LLVM opts: ['-O3']" in err) == optimize_normally - assert (' with -O3 since EMCC_OPTIMIZE_NORMALLY defined' in err) == optimize_normally - - out, err = Popen([PYTHON, EMCC, self.in_dir('main.o'), self.in_dir('supp.o'), '-O2', '-o', 'both.o'], stdout=PIPE, stderr=PIPE).communicate() - assert "emcc: LLVM opts: ['-O3']" not in err - assert ' with -O3 since EMCC_OPTIMIZE_NORMALLY defined' not in err - assert ('despite EMCC_OPTIMIZE_NORMALLY since not source code' in err) == optimize_normally - - out, err = Popen([PYTHON, EMCC, self.in_dir('main.cpp'), self.in_dir('supp.cpp'), '-O2', '-o', 'both2.o'], stdout=PIPE, stderr=PIPE).communicate() - assert ("emcc: LLVM opts: ['-O3']" in err) == optimize_normally - assert (' with -O3 since EMCC_OPTIMIZE_NORMALLY defined' in err) == optimize_normally - - for last in ['both.o', 'both2.o']: - out, err = Popen([PYTHON, EMCC, self.in_dir('both.o'), '-O2', '-o', last + '.js', '--memory-init-file', '0'], stdout=PIPE, stderr=PIPE).communicate() - assert ("emcc: LLVM opts: ['-O3']" not in err) == optimize_normally - assert ' with -O3 since EMCC_OPTIMIZE_NORMALLY defined' not in err - output = run_js(last + '.js') - assert 'yello' in output, 'code works ' + err - assert open('both.o.js').read() == open('both2.o.js').read() - - finally: - if optimize_normally: del os.environ['EMCC_OPTIMIZE_NORMALLY'] - del os.environ['EMCC_DEBUG'] - def test_jcache_printf(self): open(self.in_dir('src.cpp'), 'w').write(r''' #include diff --git a/tools/shared.py b/tools/shared.py index 2a754d27c8464..1817f98d95b85 100644 --- a/tools/shared.py +++ b/tools/shared.py @@ -1293,9 +1293,6 @@ def ensure_relooper(relooper): emcc_debug = os.environ.get('EMCC_DEBUG') if emcc_debug: del os.environ['EMCC_DEBUG'] - emcc_optimize_normally = os.environ.get('EMCC_OPTIMIZE_NORMALLY') - if emcc_optimize_normally: del os.environ['EMCC_OPTIMIZE_NORMALLY'] - def make(opt_level): raw = relooper + '.raw.js' Building.emcc(os.path.join('relooper', 'Relooper.cpp'), ['-I' + os.path.join('relooper'), '--post-js', @@ -1326,7 +1323,6 @@ def make(opt_level): finally: os.chdir(curr) if emcc_debug: os.environ['EMCC_DEBUG'] = emcc_debug - if emcc_optimize_normally: os.environ['EMCC_OPTIMIZE_NORMALLY'] = emcc_optimize_normally if not ok: logging.error('bootstrapping relooper failed. You may need to manually create relooper.js by compiling it, see src/relooper/emscripten') 1/0 From ec84a66d78cee680d69c2dfafd233625b08a6fda Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Wed, 26 Jun 2013 15:30:00 -0700 Subject: [PATCH 69/69] 1.5.2 --- tools/shared.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/shared.py b/tools/shared.py index 1817f98d95b85..e857028650a1e 100644 --- a/tools/shared.py +++ b/tools/shared.py @@ -295,7 +295,7 @@ def check_node_version(): # we re-check sanity when the settings are changed) # We also re-check sanity and clear the cache when the version changes -EMSCRIPTEN_VERSION = '1.5.1' +EMSCRIPTEN_VERSION = '1.5.2' def generate_sanity(): return EMSCRIPTEN_VERSION + '|' + get_llvm_target()