music-assistant-server
1021.2 KB•JS
libflac.js
1021.2 KB • 34,569 lines • javascript
1
2
3// The Module object: Our interface to the outside world. We import
4// and export values on it. There are various ways Module can be used:
5// 1. Not defined. We create it here
6// 2. A function parameter, function(Module) { ..generated code.. }
7// 3. pre-run appended it, var Module = {}; ..generated code..
8// 4. External script tag defines var Module.
9// We need to check if Module already exists (e.g. case 3 above).
10// Substitution will be replaced with actual code on later stage of the build,
11// this way Closure Compiler will not mangle it (e.g. case 4. above).
12// Note that if you want to run closure, and also to use Module
13// after the generated code, you will need to define var Module = {};
14// before the code. Then that object will be used in the code, and you
15// can continue to use Module afterwards as well.
16var Module = typeof Module !== 'undefined' ? Module : {};
17
18
19
20// --pre-jses are emitted after the Module integration code, so that they can
21// refer to Module (if they choose; they can also define Module)
22// libflac.js - port of libflac to JavaScript using emscripten
23
24
25(function (root, factory) {
26
27 if (typeof define === 'function' && define.amd) {
28 // AMD. Register as an anonymous module.
29 define(['module', 'require'], factory.bind(null, root));
30 } else if (typeof module === 'object' && module.exports) {
31 // Node. Does not work with strict CommonJS, but
32 // only CommonJS-like environments that support module.exports,
33 // like Node.
34
35 // use process.env (if available) for reading Flac environment settings:
36 var env = typeof process !== 'undefined' && process && process.env? process.env : root;
37 factory(env, module, module.require);
38 } else {
39 // Browser globals
40 root.Flac = factory(root);
41 }
42
43}(typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : this, function (global, expLib, require) {
44'use strict';
45
46var Module = Module || {};
47var _flac_ready = false;
48//in case resources are loaded asynchronously (e.g. *.mem file for minified version): setup "ready" handling
49Module["onRuntimeInitialized"] = function(){
50 _flac_ready = true;
51 if(!_exported){
52 //if _exported is not yet set (may happen, in case initialization was strictly synchronously),
53 // do "pause" until sync initialization has run through
54 setTimeout(function(){do_fire_event('ready', [{type: 'ready', target: _exported}], true);}, 0);
55 } else {
56 do_fire_event('ready', [{type: 'ready', target: _exported}], true);
57 }
58};
59
60if(global && global.FLAC_SCRIPT_LOCATION){
61
62 Module["locateFile"] = function(fileName){
63 var path = global.FLAC_SCRIPT_LOCATION || '';
64 if(path[fileName]){
65 return path[fileName];
66 }
67 path += path && !/\/$/.test(path)? '/' : '';
68 return path + fileName;
69 };
70
71 //NOTE will be overwritten if emscripten has env specific implementation for this
72 var readBinary = function(filePath){
73
74 //for Node: use default implementation (copied from generated code):
75 if(ENVIRONMENT_IS_NODE){
76 var ret = read_(filePath, true);
77 if (!ret.buffer) {
78 ret = new Uint8Array(ret);
79 }
80 assert(ret.buffer);
81 return ret;
82 }
83
84 //otherwise: try "fallback" to AJAX
85 return new Promise(function(resolve, reject){
86 var xhr = new XMLHttpRequest();
87 xhr.responseType = "arraybuffer";
88 xhr.addEventListener("load", function(evt){
89 resolve(xhr.response);
90 });
91 xhr.addEventListener("error", function(err){
92 reject(err);
93 });
94 xhr.open("GET", filePath);
95 xhr.send();
96 });
97 };
98}
99
100//fallback for fetch && support file://-protocol: try read as binary if fetch fails
101if(global && typeof global.fetch === 'function'){
102 var _fetch = global.fetch;
103 global.fetch = function(url){
104 return _fetch.apply(null, arguments).catch(function(err){
105 try{
106 var result = readBinary(url);
107 if(result && result.catch){
108 result.catch(function(_err){throw err});
109 }
110 return result;
111 } catch(_err){
112 throw err;
113 }
114 });
115 };
116}
117
118
119
120// Sometimes an existing Module object exists with properties
121// meant to overwrite the default module functionality. Here
122// we collect those properties and reapply _after_ we configure
123// the current environment's defaults to avoid having to be so
124// defensive during initialization.
125var moduleOverrides = {};
126var key;
127for (key in Module) {
128 if (Module.hasOwnProperty(key)) {
129 moduleOverrides[key] = Module[key];
130 }
131}
132
133var arguments_ = [];
134var thisProgram = './this.program';
135var quit_ = function(status, toThrow) {
136 throw toThrow;
137};
138
139// Determine the runtime environment we are in. You can customize this by
140// setting the ENVIRONMENT setting at compile time (see settings.js).
141
142var ENVIRONMENT_IS_WEB = false;
143var ENVIRONMENT_IS_WORKER = false;
144var ENVIRONMENT_IS_NODE = false;
145var ENVIRONMENT_IS_SHELL = false;
146ENVIRONMENT_IS_WEB = typeof window === 'object';
147ENVIRONMENT_IS_WORKER = typeof importScripts === 'function';
148// N.b. Electron.js environment is simultaneously a NODE-environment, but
149// also a web environment.
150ENVIRONMENT_IS_NODE = typeof process === 'object' && typeof process.versions === 'object' && typeof process.versions.node === 'string';
151ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
152
153
154
155
156// `/` should be present at the end if `scriptDirectory` is not empty
157var scriptDirectory = '';
158function locateFile(path) {
159 if (Module['locateFile']) {
160 return Module['locateFile'](path, scriptDirectory);
161 }
162 return scriptDirectory + path;
163}
164
165// Hooks that are implemented differently in different runtime environments.
166var read_,
167 readAsync,
168 readBinary,
169 setWindowTitle;
170
171var nodeFS;
172var nodePath;
173
174if (ENVIRONMENT_IS_NODE) {
175 if (ENVIRONMENT_IS_WORKER) {
176 scriptDirectory = require('path').dirname(scriptDirectory) + '/';
177 } else {
178 scriptDirectory = __dirname + '/';
179 }
180
181
182
183
184 read_ = function shell_read(filename, binary) {
185 var ret = tryParseAsDataURI(filename);
186 if (ret) {
187 return binary ? ret : ret.toString();
188 }
189 if (!nodeFS) nodeFS = require('fs');
190 if (!nodePath) nodePath = require('path');
191 filename = nodePath['normalize'](filename);
192 return nodeFS['readFileSync'](filename, binary ? null : 'utf8');
193 };
194
195 readBinary = function readBinary(filename) {
196 var ret = read_(filename, true);
197 if (!ret.buffer) {
198 ret = new Uint8Array(ret);
199 }
200 assert(ret.buffer);
201 return ret;
202 };
203
204
205
206
207 if (process['argv'].length > 1) {
208 thisProgram = process['argv'][1].replace(/\\/g, '/');
209 }
210
211 arguments_ = process['argv'].slice(2);
212
213 if (typeof module !== 'undefined') {
214 module['exports'] = Module;
215 }
216
217
218
219 quit_ = function(status) {
220 process['exit'](status);
221 };
222
223 Module['inspect'] = function () { return '[Emscripten Module object]'; };
224
225
226
227} else
228if (ENVIRONMENT_IS_SHELL) {
229
230
231 if (typeof read != 'undefined') {
232 read_ = function shell_read(f) {
233 var data = tryParseAsDataURI(f);
234 if (data) {
235 return intArrayToString(data);
236 }
237 return read(f);
238 };
239 }
240
241 readBinary = function readBinary(f) {
242 var data;
243 data = tryParseAsDataURI(f);
244 if (data) {
245 return data;
246 }
247 if (typeof readbuffer === 'function') {
248 return new Uint8Array(readbuffer(f));
249 }
250 data = read(f, 'binary');
251 assert(typeof data === 'object');
252 return data;
253 };
254
255 if (typeof scriptArgs != 'undefined') {
256 arguments_ = scriptArgs;
257 } else if (typeof arguments != 'undefined') {
258 arguments_ = arguments;
259 }
260
261 if (typeof quit === 'function') {
262 quit_ = function(status) {
263 quit(status);
264 };
265 }
266
267 if (typeof print !== 'undefined') {
268 // Prefer to use print/printErr where they exist, as they usually work better.
269 if (typeof console === 'undefined') console = /** @type{!Console} */({});
270 console.log = /** @type{!function(this:Console, ...*): undefined} */ (print);
271 console.warn = console.error = /** @type{!function(this:Console, ...*): undefined} */ (typeof printErr !== 'undefined' ? printErr : print);
272 }
273
274
275} else
276
277// Note that this includes Node.js workers when relevant (pthreads is enabled).
278// Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and
279// ENVIRONMENT_IS_NODE.
280if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
281 if (ENVIRONMENT_IS_WORKER) { // Check worker, not web, since window could be polyfilled
282 scriptDirectory = self.location.href;
283 } else if (document.currentScript) { // web
284 scriptDirectory = document.currentScript.src;
285 }
286 // blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them.
287 // otherwise, slice off the final part of the url to find the script directory.
288 // if scriptDirectory does not contain a slash, lastIndexOf will return -1,
289 // and scriptDirectory will correctly be replaced with an empty string.
290 if (scriptDirectory.indexOf('blob:') !== 0) {
291 scriptDirectory = scriptDirectory.substr(0, scriptDirectory.lastIndexOf('/')+1);
292 } else {
293 scriptDirectory = '';
294 }
295
296
297 // Differentiate the Web Worker from the Node Worker case, as reading must
298 // be done differently.
299 {
300
301
302
303
304 read_ = function shell_read(url) {
305 try {
306 var xhr = new XMLHttpRequest();
307 xhr.open('GET', url, false);
308 xhr.send(null);
309 return xhr.responseText;
310 } catch (err) {
311 var data = tryParseAsDataURI(url);
312 if (data) {
313 return intArrayToString(data);
314 }
315 throw err;
316 }
317 };
318
319 if (ENVIRONMENT_IS_WORKER) {
320 readBinary = function readBinary(url) {
321 try {
322 var xhr = new XMLHttpRequest();
323 xhr.open('GET', url, false);
324 xhr.responseType = 'arraybuffer';
325 xhr.send(null);
326 return new Uint8Array(/** @type{!ArrayBuffer} */(xhr.response));
327 } catch (err) {
328 var data = tryParseAsDataURI(url);
329 if (data) {
330 return data;
331 }
332 throw err;
333 }
334 };
335 }
336
337 readAsync = function readAsync(url, onload, onerror) {
338 var xhr = new XMLHttpRequest();
339 xhr.open('GET', url, true);
340 xhr.responseType = 'arraybuffer';
341 xhr.onload = function xhr_onload() {
342 if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0
343 onload(xhr.response);
344 return;
345 }
346 var data = tryParseAsDataURI(url);
347 if (data) {
348 onload(data.buffer);
349 return;
350 }
351 onerror();
352 };
353 xhr.onerror = onerror;
354 xhr.send(null);
355 };
356
357
358
359
360 }
361
362 setWindowTitle = function(title) { document.title = title };
363} else
364{
365}
366
367
368// Set up the out() and err() hooks, which are how we can print to stdout or
369// stderr, respectively.
370var out = Module['print'] || console.log.bind(console);
371var err = Module['printErr'] || console.warn.bind(console);
372
373// Merge back in the overrides
374for (key in moduleOverrides) {
375 if (moduleOverrides.hasOwnProperty(key)) {
376 Module[key] = moduleOverrides[key];
377 }
378}
379// Free the object hierarchy contained in the overrides, this lets the GC
380// reclaim data used e.g. in memoryInitializerRequest, which is a large typed array.
381moduleOverrides = null;
382
383// Emit code to handle expected values on the Module object. This applies Module.x
384// to the proper local x. This has two benefits: first, we only emit it if it is
385// expected to arrive, and second, by using a local everywhere else that can be
386// minified.
387if (Module['arguments']) arguments_ = Module['arguments'];
388if (Module['thisProgram']) thisProgram = Module['thisProgram'];
389if (Module['quit']) quit_ = Module['quit'];
390
391// perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message
392
393
394
395
396
397// {{PREAMBLE_ADDITIONS}}
398
399var STACK_ALIGN = 16;
400
401function dynamicAlloc(size) {
402 var ret = HEAP32[DYNAMICTOP_PTR>>2];
403 var end = (ret + size + 15) & -16;
404 HEAP32[DYNAMICTOP_PTR>>2] = end;
405 return ret;
406}
407
408function alignMemory(size, factor) {
409 if (!factor) factor = STACK_ALIGN; // stack alignment (16-byte) by default
410 return Math.ceil(size / factor) * factor;
411}
412
413function getNativeTypeSize(type) {
414 switch (type) {
415 case 'i1': case 'i8': return 1;
416 case 'i16': return 2;
417 case 'i32': return 4;
418 case 'i64': return 8;
419 case 'float': return 4;
420 case 'double': return 8;
421 default: {
422 if (type[type.length-1] === '*') {
423 return 4; // A pointer
424 } else if (type[0] === 'i') {
425 var bits = Number(type.substr(1));
426 assert(bits % 8 === 0, 'getNativeTypeSize invalid bits ' + bits + ', type ' + type);
427 return bits / 8;
428 } else {
429 return 0;
430 }
431 }
432 }
433}
434
435function warnOnce(text) {
436 if (!warnOnce.shown) warnOnce.shown = {};
437 if (!warnOnce.shown[text]) {
438 warnOnce.shown[text] = 1;
439 err(text);
440 }
441}
442
443
444
445
446
447
448
449
450// Wraps a JS function as a wasm function with a given signature.
451function convertJsFunctionToWasm(func, sig) {
452 return func;
453}
454
455var freeTableIndexes = [];
456
457// Weak map of functions in the table to their indexes, created on first use.
458var functionsInTableMap;
459
460// Add a wasm function to the table.
461function addFunctionWasm(func, sig) {
462 var table = wasmTable;
463
464 // Check if the function is already in the table, to ensure each function
465 // gets a unique index. First, create the map if this is the first use.
466 if (!functionsInTableMap) {
467 functionsInTableMap = new WeakMap();
468 for (var i = 0; i < table.length; i++) {
469 var item = table.get(i);
470 // Ignore null values.
471 if (item) {
472 functionsInTableMap.set(item, i);
473 }
474 }
475 }
476 if (functionsInTableMap.has(func)) {
477 return functionsInTableMap.get(func);
478 }
479
480 // It's not in the table, add it now.
481
482
483 var ret;
484 // Reuse a free index if there is one, otherwise grow.
485 if (freeTableIndexes.length) {
486 ret = freeTableIndexes.pop();
487 } else {
488 ret = table.length;
489 // Grow the table
490 try {
491 table.grow(1);
492 } catch (err) {
493 if (!(err instanceof RangeError)) {
494 throw err;
495 }
496 throw 'Unable to grow wasm table. Set ALLOW_TABLE_GROWTH.';
497 }
498 }
499
500 // Set the new value.
501 try {
502 // Attempting to call this with JS function will cause of table.set() to fail
503 table.set(ret, func);
504 } catch (err) {
505 if (!(err instanceof TypeError)) {
506 throw err;
507 }
508 var wrapped = convertJsFunctionToWasm(func, sig);
509 table.set(ret, wrapped);
510 }
511
512 functionsInTableMap.set(func, ret);
513
514 return ret;
515}
516
517function removeFunctionWasm(index) {
518 functionsInTableMap.delete(wasmTable.get(index));
519 freeTableIndexes.push(index);
520}
521
522// 'sig' parameter is required for the llvm backend but only when func is not
523// already a WebAssembly function.
524function addFunction(func, sig) {
525
526 return addFunctionWasm(func, sig);
527}
528
529function removeFunction(index) {
530 removeFunctionWasm(index);
531}
532
533
534
535var funcWrappers = {};
536
537function getFuncWrapper(func, sig) {
538 if (!func) return; // on null pointer, return undefined
539 assert(sig);
540 if (!funcWrappers[sig]) {
541 funcWrappers[sig] = {};
542 }
543 var sigCache = funcWrappers[sig];
544 if (!sigCache[func]) {
545 // optimize away arguments usage in common cases
546 if (sig.length === 1) {
547 sigCache[func] = function dynCall_wrapper() {
548 return dynCall(sig, func);
549 };
550 } else if (sig.length === 2) {
551 sigCache[func] = function dynCall_wrapper(arg) {
552 return dynCall(sig, func, [arg]);
553 };
554 } else {
555 // general case
556 sigCache[func] = function dynCall_wrapper() {
557 return dynCall(sig, func, Array.prototype.slice.call(arguments));
558 };
559 }
560 }
561 return sigCache[func];
562}
563
564
565
566
567
568
569
570function makeBigInt(low, high, unsigned) {
571 return unsigned ? ((+((low>>>0)))+((+((high>>>0)))*4294967296.0)) : ((+((low>>>0)))+((+((high|0)))*4294967296.0));
572}
573
574/** @param {Array=} args */
575function dynCall(sig, ptr, args) {
576 if (args && args.length) {
577 return Module['dynCall_' + sig].apply(null, [ptr].concat(args));
578 } else {
579 return Module['dynCall_' + sig].call(null, ptr);
580 }
581}
582
583var tempRet0 = 0;
584
585var setTempRet0 = function(value) {
586 tempRet0 = value;
587};
588
589var getTempRet0 = function() {
590 return tempRet0;
591};
592
593
594// The address globals begin at. Very low in memory, for code size and optimization opportunities.
595// Above 0 is static memory, starting with globals.
596// Then the stack.
597// Then 'dynamic' memory for sbrk.
598var GLOBAL_BASE = 1024;
599
600
601
602
603
604// === Preamble library stuff ===
605
606// Documentation for the public APIs defined in this file must be updated in:
607// site/source/docs/api_reference/preamble.js.rst
608// A prebuilt local version of the documentation is available at:
609// site/build/text/docs/api_reference/preamble.js.txt
610// You can also build docs locally as HTML or other formats in site/
611// An online HTML version (which may be of a different version of Emscripten)
612// is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html
613
614
615var wasmBinary;if (Module['wasmBinary']) wasmBinary = Module['wasmBinary'];
616var noExitRuntime;if (Module['noExitRuntime']) noExitRuntime = Module['noExitRuntime'];
617
618
619
620
621// wasm2js.js - enough of a polyfill for the WebAssembly object so that we can load
622// wasm2js code that way.
623
624// Emit "var WebAssembly" if definitely using wasm2js. Otherwise, in MAYBE_WASM2JS
625// mode, we can't use a "var" since it would prevent normal wasm from working.
626/** @suppress{const} */
627var
628WebAssembly = {
629 // Note that we do not use closure quoting (this['buffer'], etc.) on these
630 // functions, as they are just meant for internal use. In other words, this is
631 // not a fully general polyfill.
632 Memory: function(opts) {
633 this.buffer = new ArrayBuffer(opts['initial'] * 65536);
634 this.grow = function(amount) {
635 var ret = __growWasmMemory(amount);
636 return ret;
637 };
638 },
639
640 // Table is not a normal constructor and instead returns the array object.
641 // That lets us use the length property automatically, which is simpler and
642 // smaller (but instanceof will not report that an instance of Table is an
643 // instance of this function).
644 Table: /** @constructor */ function(opts) {
645 var ret = new Array(opts['initial']);
646 ret.grow = function(by) {
647 if (ret.length >= 22 + 5) {
648 abort('Unable to grow wasm table. Use a higher value for RESERVED_FUNCTION_POINTERS or set ALLOW_TABLE_GROWTH.')
649 }
650 ret.push(null);
651 };
652 ret.set = function(i, func) {
653 ret[i] = func;
654 };
655 ret.get = function(i) {
656 return ret[i];
657 };
658 return ret;
659 },
660
661 Module: function(binary) {
662 // TODO: use the binary and info somehow - right now the wasm2js output is embedded in
663 // the main JS
664 },
665
666 Instance: function(module, info) {
667 // TODO: use the module and info somehow - right now the wasm2js output is embedded in
668 // the main JS
669 // This will be replaced by the actual wasm2js code.
670 this.exports = (
671function instantiate(asmLibraryArg, wasmMemory, wasmTable) {
672
673
674 var scratchBuffer = new ArrayBuffer(8);
675 var i32ScratchView = new Int32Array(scratchBuffer);
676 var f32ScratchView = new Float32Array(scratchBuffer);
677 var f64ScratchView = new Float64Array(scratchBuffer);
678
679 function wasm2js_scratch_load_i32(index) {
680 return i32ScratchView[index];
681 }
682
683 function wasm2js_scratch_store_i32(index, value) {
684 i32ScratchView[index] = value;
685 }
686
687 function wasm2js_scratch_load_f64() {
688 return f64ScratchView[0];
689 }
690
691 function wasm2js_scratch_store_f64(value) {
692 f64ScratchView[0] = value;
693 }
694
695 function wasm2js_scratch_store_f32(value) {
696 f32ScratchView[0] = value;
697 }
698
699function asmFunc(global, env, buffer) {
700 var memory = env.memory;
701 var FUNCTION_TABLE = wasmTable;
702 var HEAP8 = new global.Int8Array(buffer);
703 var HEAP16 = new global.Int16Array(buffer);
704 var HEAP32 = new global.Int32Array(buffer);
705 var HEAPU8 = new global.Uint8Array(buffer);
706 var HEAPU16 = new global.Uint16Array(buffer);
707 var HEAPU32 = new global.Uint32Array(buffer);
708 var HEAPF32 = new global.Float32Array(buffer);
709 var HEAPF64 = new global.Float64Array(buffer);
710 var Math_imul = global.Math.imul;
711 var Math_fround = global.Math.fround;
712 var Math_abs = global.Math.abs;
713 var Math_clz32 = global.Math.clz32;
714 var Math_min = global.Math.min;
715 var Math_max = global.Math.max;
716 var Math_floor = global.Math.floor;
717 var Math_ceil = global.Math.ceil;
718 var Math_sqrt = global.Math.sqrt;
719 var abort = env.abort;
720 var nan = global.NaN;
721 var infinity = global.Infinity;
722 var emscripten_resize_heap = env.emscripten_resize_heap;
723 var emscripten_memcpy_big = env.emscripten_memcpy_big;
724 var __wasi_fd_close = env.fd_close;
725 var __wasi_fd_read = env.fd_read;
726 var round = env.round;
727 var __wasi_fd_write = env.fd_write;
728 var setTempRet0 = env.setTempRet0;
729 var legalimport$__wasi_fd_seek = env.fd_seek;
730 var global$0 = 5257216;
731 var global$1 = 14168;
732 var __wasm_intrinsics_temp_i64 = 0;
733 var __wasm_intrinsics_temp_i64$hi = 0;
734 var i64toi32_i32$HIGH_BITS = 0;
735 // EMSCRIPTEN_START_FUNCS
736;
737 function __wasm_call_ctors() {
738
739 }
740
741 function __errno_location() {
742 return 11584;
743 }
744
745 function sbrk($0) {
746 var $1 = 0, $2 = 0;
747 $1 = HEAP32[3544];
748 $2 = $0 + 3 & -4;
749 $0 = $1 + $2 | 0;
750 label$1 : {
751 if ($0 >>> 0 <= $1 >>> 0 ? ($2 | 0) >= 1 : 0) {
752 break label$1
753 }
754 if ($0 >>> 0 > __wasm_memory_size() << 16 >>> 0) {
755 if (!emscripten_resize_heap($0 | 0)) {
756 break label$1
757 }
758 }
759 HEAP32[3544] = $0;
760 return $1;
761 }
762 HEAP32[2896] = 48;
763 return -1;
764 }
765
766 function memset($0, $1) {
767 var $2 = 0, $3 = 0;
768 label$1 : {
769 if (!$1) {
770 break label$1
771 }
772 $2 = $0 + $1 | 0;
773 HEAP8[$2 + -1 | 0] = 0;
774 HEAP8[$0 | 0] = 0;
775 if ($1 >>> 0 < 3) {
776 break label$1
777 }
778 HEAP8[$2 + -2 | 0] = 0;
779 HEAP8[$0 + 1 | 0] = 0;
780 HEAP8[$2 + -3 | 0] = 0;
781 HEAP8[$0 + 2 | 0] = 0;
782 if ($1 >>> 0 < 7) {
783 break label$1
784 }
785 HEAP8[$2 + -4 | 0] = 0;
786 HEAP8[$0 + 3 | 0] = 0;
787 if ($1 >>> 0 < 9) {
788 break label$1
789 }
790 $3 = 0 - $0 & 3;
791 $2 = $3 + $0 | 0;
792 HEAP32[$2 >> 2] = 0;
793 $3 = $1 - $3 & -4;
794 $1 = $3 + $2 | 0;
795 HEAP32[$1 + -4 >> 2] = 0;
796 if ($3 >>> 0 < 9) {
797 break label$1
798 }
799 HEAP32[$2 + 8 >> 2] = 0;
800 HEAP32[$2 + 4 >> 2] = 0;
801 HEAP32[$1 + -8 >> 2] = 0;
802 HEAP32[$1 + -12 >> 2] = 0;
803 if ($3 >>> 0 < 25) {
804 break label$1
805 }
806 HEAP32[$2 + 24 >> 2] = 0;
807 HEAP32[$2 + 20 >> 2] = 0;
808 HEAP32[$2 + 16 >> 2] = 0;
809 HEAP32[$2 + 12 >> 2] = 0;
810 HEAP32[$1 + -16 >> 2] = 0;
811 HEAP32[$1 + -20 >> 2] = 0;
812 HEAP32[$1 + -24 >> 2] = 0;
813 HEAP32[$1 + -28 >> 2] = 0;
814 $1 = $3;
815 $3 = $2 & 4 | 24;
816 $1 = $1 - $3 | 0;
817 if ($1 >>> 0 < 32) {
818 break label$1
819 }
820 $2 = $2 + $3 | 0;
821 while (1) {
822 HEAP32[$2 + 24 >> 2] = 0;
823 HEAP32[$2 + 28 >> 2] = 0;
824 HEAP32[$2 + 16 >> 2] = 0;
825 HEAP32[$2 + 20 >> 2] = 0;
826 HEAP32[$2 + 8 >> 2] = 0;
827 HEAP32[$2 + 12 >> 2] = 0;
828 HEAP32[$2 >> 2] = 0;
829 HEAP32[$2 + 4 >> 2] = 0;
830 $2 = $2 + 32 | 0;
831 $1 = $1 + -32 | 0;
832 if ($1 >>> 0 > 31) {
833 continue
834 }
835 break;
836 };
837 }
838 return $0;
839 }
840
841 function memcpy($0, $1, $2) {
842 var $3 = 0, $4 = 0, $5 = 0;
843 if ($2 >>> 0 >= 512) {
844 emscripten_memcpy_big($0 | 0, $1 | 0, $2 | 0) | 0;
845 return $0;
846 }
847 $4 = $0 + $2 | 0;
848 label$2 : {
849 if (!(($0 ^ $1) & 3)) {
850 label$4 : {
851 if (($2 | 0) < 1) {
852 $2 = $0;
853 break label$4;
854 }
855 if (!($0 & 3)) {
856 $2 = $0;
857 break label$4;
858 }
859 $2 = $0;
860 while (1) {
861 HEAP8[$2 | 0] = HEAPU8[$1 | 0];
862 $1 = $1 + 1 | 0;
863 $2 = $2 + 1 | 0;
864 if ($2 >>> 0 >= $4 >>> 0) {
865 break label$4
866 }
867 if ($2 & 3) {
868 continue
869 }
870 break;
871 };
872 }
873 $3 = $4 & -4;
874 label$8 : {
875 if ($3 >>> 0 < 64) {
876 break label$8
877 }
878 $5 = $3 + -64 | 0;
879 if ($2 >>> 0 > $5 >>> 0) {
880 break label$8
881 }
882 while (1) {
883 HEAP32[$2 >> 2] = HEAP32[$1 >> 2];
884 HEAP32[$2 + 4 >> 2] = HEAP32[$1 + 4 >> 2];
885 HEAP32[$2 + 8 >> 2] = HEAP32[$1 + 8 >> 2];
886 HEAP32[$2 + 12 >> 2] = HEAP32[$1 + 12 >> 2];
887 HEAP32[$2 + 16 >> 2] = HEAP32[$1 + 16 >> 2];
888 HEAP32[$2 + 20 >> 2] = HEAP32[$1 + 20 >> 2];
889 HEAP32[$2 + 24 >> 2] = HEAP32[$1 + 24 >> 2];
890 HEAP32[$2 + 28 >> 2] = HEAP32[$1 + 28 >> 2];
891 HEAP32[$2 + 32 >> 2] = HEAP32[$1 + 32 >> 2];
892 HEAP32[$2 + 36 >> 2] = HEAP32[$1 + 36 >> 2];
893 HEAP32[$2 + 40 >> 2] = HEAP32[$1 + 40 >> 2];
894 HEAP32[$2 + 44 >> 2] = HEAP32[$1 + 44 >> 2];
895 HEAP32[$2 + 48 >> 2] = HEAP32[$1 + 48 >> 2];
896 HEAP32[$2 + 52 >> 2] = HEAP32[$1 + 52 >> 2];
897 HEAP32[$2 + 56 >> 2] = HEAP32[$1 + 56 >> 2];
898 HEAP32[$2 + 60 >> 2] = HEAP32[$1 + 60 >> 2];
899 $1 = $1 - -64 | 0;
900 $2 = $2 - -64 | 0;
901 if ($2 >>> 0 <= $5 >>> 0) {
902 continue
903 }
904 break;
905 };
906 }
907 if ($2 >>> 0 >= $3 >>> 0) {
908 break label$2
909 }
910 while (1) {
911 HEAP32[$2 >> 2] = HEAP32[$1 >> 2];
912 $1 = $1 + 4 | 0;
913 $2 = $2 + 4 | 0;
914 if ($2 >>> 0 < $3 >>> 0) {
915 continue
916 }
917 break;
918 };
919 break label$2;
920 }
921 if ($4 >>> 0 < 4) {
922 $2 = $0;
923 break label$2;
924 }
925 $3 = $4 + -4 | 0;
926 if ($3 >>> 0 < $0 >>> 0) {
927 $2 = $0;
928 break label$2;
929 }
930 $2 = $0;
931 while (1) {
932 HEAP8[$2 | 0] = HEAPU8[$1 | 0];
933 HEAP8[$2 + 1 | 0] = HEAPU8[$1 + 1 | 0];
934 HEAP8[$2 + 2 | 0] = HEAPU8[$1 + 2 | 0];
935 HEAP8[$2 + 3 | 0] = HEAPU8[$1 + 3 | 0];
936 $1 = $1 + 4 | 0;
937 $2 = $2 + 4 | 0;
938 if ($2 >>> 0 <= $3 >>> 0) {
939 continue
940 }
941 break;
942 };
943 }
944 if ($2 >>> 0 < $4 >>> 0) {
945 while (1) {
946 HEAP8[$2 | 0] = HEAPU8[$1 | 0];
947 $1 = $1 + 1 | 0;
948 $2 = $2 + 1 | 0;
949 if (($4 | 0) != ($2 | 0)) {
950 continue
951 }
952 break;
953 }
954 }
955 return $0;
956 }
957
958 function dlmalloc($0) {
959 $0 = $0 | 0;
960 var $1 = 0, $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
961 $11 = global$0 - 16 | 0;
962 global$0 = $11;
963 label$1 : {
964 label$2 : {
965 label$3 : {
966 label$4 : {
967 label$5 : {
968 label$6 : {
969 label$7 : {
970 label$8 : {
971 label$9 : {
972 label$10 : {
973 label$11 : {
974 if ($0 >>> 0 <= 244) {
975 $6 = HEAP32[2897];
976 $5 = $0 >>> 0 < 11 ? 16 : $0 + 11 & -8;
977 $0 = $5 >>> 3 | 0;
978 $1 = $6 >>> $0 | 0;
979 if ($1 & 3) {
980 $2 = $0 + (($1 ^ -1) & 1) | 0;
981 $5 = $2 << 3;
982 $1 = HEAP32[$5 + 11636 >> 2];
983 $0 = $1 + 8 | 0;
984 $3 = HEAP32[$1 + 8 >> 2];
985 $5 = $5 + 11628 | 0;
986 label$14 : {
987 if (($3 | 0) == ($5 | 0)) {
988 (wasm2js_i32$0 = 11588, wasm2js_i32$1 = __wasm_rotl_i32(-2, $2) & $6), HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
989 break label$14;
990 }
991 HEAP32[$3 + 12 >> 2] = $5;
992 HEAP32[$5 + 8 >> 2] = $3;
993 }
994 $2 = $2 << 3;
995 HEAP32[$1 + 4 >> 2] = $2 | 3;
996 $1 = $1 + $2 | 0;
997 HEAP32[$1 + 4 >> 2] = HEAP32[$1 + 4 >> 2] | 1;
998 break label$1;
999 }
1000 $7 = HEAP32[2899];
1001 if ($5 >>> 0 <= $7 >>> 0) {
1002 break label$11
1003 }
1004 if ($1) {
1005 $2 = 2 << $0;
1006 $0 = (0 - $2 | $2) & $1 << $0;
1007 $0 = (0 - $0 & $0) + -1 | 0;
1008 $1 = $0 >>> 12 & 16;
1009 $2 = $1;
1010 $0 = $0 >>> $1 | 0;
1011 $1 = $0 >>> 5 & 8;
1012 $2 = $2 | $1;
1013 $0 = $0 >>> $1 | 0;
1014 $1 = $0 >>> 2 & 4;
1015 $2 = $2 | $1;
1016 $0 = $0 >>> $1 | 0;
1017 $1 = $0 >>> 1 & 2;
1018 $2 = $2 | $1;
1019 $0 = $0 >>> $1 | 0;
1020 $1 = $0 >>> 1 & 1;
1021 $2 = ($2 | $1) + ($0 >>> $1 | 0) | 0;
1022 $3 = $2 << 3;
1023 $1 = HEAP32[$3 + 11636 >> 2];
1024 $0 = HEAP32[$1 + 8 >> 2];
1025 $3 = $3 + 11628 | 0;
1026 label$17 : {
1027 if (($0 | 0) == ($3 | 0)) {
1028 $6 = __wasm_rotl_i32(-2, $2) & $6;
1029 HEAP32[2897] = $6;
1030 break label$17;
1031 }
1032 HEAP32[$0 + 12 >> 2] = $3;
1033 HEAP32[$3 + 8 >> 2] = $0;
1034 }
1035 $0 = $1 + 8 | 0;
1036 HEAP32[$1 + 4 >> 2] = $5 | 3;
1037 $4 = $1 + $5 | 0;
1038 $2 = $2 << 3;
1039 $3 = $2 - $5 | 0;
1040 HEAP32[$4 + 4 >> 2] = $3 | 1;
1041 HEAP32[$1 + $2 >> 2] = $3;
1042 if ($7) {
1043 $5 = $7 >>> 3 | 0;
1044 $1 = ($5 << 3) + 11628 | 0;
1045 $2 = HEAP32[2902];
1046 $5 = 1 << $5;
1047 label$20 : {
1048 if (!($5 & $6)) {
1049 HEAP32[2897] = $5 | $6;
1050 $5 = $1;
1051 break label$20;
1052 }
1053 $5 = HEAP32[$1 + 8 >> 2];
1054 }
1055 HEAP32[$1 + 8 >> 2] = $2;
1056 HEAP32[$5 + 12 >> 2] = $2;
1057 HEAP32[$2 + 12 >> 2] = $1;
1058 HEAP32[$2 + 8 >> 2] = $5;
1059 }
1060 HEAP32[2902] = $4;
1061 HEAP32[2899] = $3;
1062 break label$1;
1063 }
1064 $10 = HEAP32[2898];
1065 if (!$10) {
1066 break label$11
1067 }
1068 $0 = ($10 & 0 - $10) + -1 | 0;
1069 $1 = $0 >>> 12 & 16;
1070 $2 = $1;
1071 $0 = $0 >>> $1 | 0;
1072 $1 = $0 >>> 5 & 8;
1073 $2 = $2 | $1;
1074 $0 = $0 >>> $1 | 0;
1075 $1 = $0 >>> 2 & 4;
1076 $2 = $2 | $1;
1077 $0 = $0 >>> $1 | 0;
1078 $1 = $0 >>> 1 & 2;
1079 $2 = $2 | $1;
1080 $0 = $0 >>> $1 | 0;
1081 $1 = $0 >>> 1 & 1;
1082 $1 = HEAP32[(($2 | $1) + ($0 >>> $1 | 0) << 2) + 11892 >> 2];
1083 $3 = (HEAP32[$1 + 4 >> 2] & -8) - $5 | 0;
1084 $2 = $1;
1085 while (1) {
1086 label$23 : {
1087 $0 = HEAP32[$2 + 16 >> 2];
1088 if (!$0) {
1089 $0 = HEAP32[$2 + 20 >> 2];
1090 if (!$0) {
1091 break label$23
1092 }
1093 }
1094 $4 = (HEAP32[$0 + 4 >> 2] & -8) - $5 | 0;
1095 $2 = $4 >>> 0 < $3 >>> 0;
1096 $3 = $2 ? $4 : $3;
1097 $1 = $2 ? $0 : $1;
1098 $2 = $0;
1099 continue;
1100 }
1101 break;
1102 };
1103 $9 = HEAP32[$1 + 24 >> 2];
1104 $4 = HEAP32[$1 + 12 >> 2];
1105 if (($4 | 0) != ($1 | 0)) {
1106 $0 = HEAP32[$1 + 8 >> 2];
1107 HEAP32[$0 + 12 >> 2] = $4;
1108 HEAP32[$4 + 8 >> 2] = $0;
1109 break label$2;
1110 }
1111 $2 = $1 + 20 | 0;
1112 $0 = HEAP32[$2 >> 2];
1113 if (!$0) {
1114 $0 = HEAP32[$1 + 16 >> 2];
1115 if (!$0) {
1116 break label$10
1117 }
1118 $2 = $1 + 16 | 0;
1119 }
1120 while (1) {
1121 $8 = $2;
1122 $4 = $0;
1123 $2 = $0 + 20 | 0;
1124 $0 = HEAP32[$2 >> 2];
1125 if ($0) {
1126 continue
1127 }
1128 $2 = $4 + 16 | 0;
1129 $0 = HEAP32[$4 + 16 >> 2];
1130 if ($0) {
1131 continue
1132 }
1133 break;
1134 };
1135 HEAP32[$8 >> 2] = 0;
1136 break label$2;
1137 }
1138 $5 = -1;
1139 if ($0 >>> 0 > 4294967231) {
1140 break label$11
1141 }
1142 $0 = $0 + 11 | 0;
1143 $5 = $0 & -8;
1144 $8 = HEAP32[2898];
1145 if (!$8) {
1146 break label$11
1147 }
1148 $2 = 0 - $5 | 0;
1149 $0 = $0 >>> 8 | 0;
1150 $7 = 0;
1151 label$29 : {
1152 if (!$0) {
1153 break label$29
1154 }
1155 $7 = 31;
1156 if ($5 >>> 0 > 16777215) {
1157 break label$29
1158 }
1159 $3 = $0 + 1048320 >>> 16 & 8;
1160 $1 = $0 << $3;
1161 $0 = $1 + 520192 >>> 16 & 4;
1162 $6 = $1 << $0;
1163 $1 = $6 + 245760 >>> 16 & 2;
1164 $0 = ($6 << $1 >>> 15 | 0) - ($1 | ($0 | $3)) | 0;
1165 $7 = ($0 << 1 | $5 >>> $0 + 21 & 1) + 28 | 0;
1166 }
1167 $3 = HEAP32[($7 << 2) + 11892 >> 2];
1168 label$30 : {
1169 label$31 : {
1170 label$32 : {
1171 if (!$3) {
1172 $0 = 0;
1173 break label$32;
1174 }
1175 $1 = $5 << (($7 | 0) == 31 ? 0 : 25 - ($7 >>> 1 | 0) | 0);
1176 $0 = 0;
1177 while (1) {
1178 label$35 : {
1179 $6 = (HEAP32[$3 + 4 >> 2] & -8) - $5 | 0;
1180 if ($6 >>> 0 >= $2 >>> 0) {
1181 break label$35
1182 }
1183 $4 = $3;
1184 $2 = $6;
1185 if ($2) {
1186 break label$35
1187 }
1188 $2 = 0;
1189 $0 = $3;
1190 break label$31;
1191 }
1192 $6 = HEAP32[$3 + 20 >> 2];
1193 $3 = HEAP32[(($1 >>> 29 & 4) + $3 | 0) + 16 >> 2];
1194 $0 = $6 ? (($6 | 0) == ($3 | 0) ? $0 : $6) : $0;
1195 $1 = $1 << (($3 | 0) != 0);
1196 if ($3) {
1197 continue
1198 }
1199 break;
1200 };
1201 }
1202 if (!($0 | $4)) {
1203 $0 = 2 << $7;
1204 $0 = (0 - $0 | $0) & $8;
1205 if (!$0) {
1206 break label$11
1207 }
1208 $0 = ($0 & 0 - $0) + -1 | 0;
1209 $1 = $0 >>> 12 & 16;
1210 $3 = $1;
1211 $0 = $0 >>> $1 | 0;
1212 $1 = $0 >>> 5 & 8;
1213 $3 = $3 | $1;
1214 $0 = $0 >>> $1 | 0;
1215 $1 = $0 >>> 2 & 4;
1216 $3 = $3 | $1;
1217 $0 = $0 >>> $1 | 0;
1218 $1 = $0 >>> 1 & 2;
1219 $3 = $3 | $1;
1220 $0 = $0 >>> $1 | 0;
1221 $1 = $0 >>> 1 & 1;
1222 $0 = HEAP32[(($3 | $1) + ($0 >>> $1 | 0) << 2) + 11892 >> 2];
1223 }
1224 if (!$0) {
1225 break label$30
1226 }
1227 }
1228 while (1) {
1229 $3 = (HEAP32[$0 + 4 >> 2] & -8) - $5 | 0;
1230 $1 = $3 >>> 0 < $2 >>> 0;
1231 $2 = $1 ? $3 : $2;
1232 $4 = $1 ? $0 : $4;
1233 $1 = HEAP32[$0 + 16 >> 2];
1234 if ($1) {
1235 $0 = $1
1236 } else {
1237 $0 = HEAP32[$0 + 20 >> 2]
1238 }
1239 if ($0) {
1240 continue
1241 }
1242 break;
1243 };
1244 }
1245 if (!$4 | $2 >>> 0 >= HEAP32[2899] - $5 >>> 0) {
1246 break label$11
1247 }
1248 $7 = HEAP32[$4 + 24 >> 2];
1249 $1 = HEAP32[$4 + 12 >> 2];
1250 if (($4 | 0) != ($1 | 0)) {
1251 $0 = HEAP32[$4 + 8 >> 2];
1252 HEAP32[$0 + 12 >> 2] = $1;
1253 HEAP32[$1 + 8 >> 2] = $0;
1254 break label$3;
1255 }
1256 $3 = $4 + 20 | 0;
1257 $0 = HEAP32[$3 >> 2];
1258 if (!$0) {
1259 $0 = HEAP32[$4 + 16 >> 2];
1260 if (!$0) {
1261 break label$9
1262 }
1263 $3 = $4 + 16 | 0;
1264 }
1265 while (1) {
1266 $6 = $3;
1267 $1 = $0;
1268 $3 = $0 + 20 | 0;
1269 $0 = HEAP32[$3 >> 2];
1270 if ($0) {
1271 continue
1272 }
1273 $3 = $1 + 16 | 0;
1274 $0 = HEAP32[$1 + 16 >> 2];
1275 if ($0) {
1276 continue
1277 }
1278 break;
1279 };
1280 HEAP32[$6 >> 2] = 0;
1281 break label$3;
1282 }
1283 $1 = HEAP32[2899];
1284 if ($1 >>> 0 >= $5 >>> 0) {
1285 $0 = HEAP32[2902];
1286 $2 = $1 - $5 | 0;
1287 label$45 : {
1288 if ($2 >>> 0 >= 16) {
1289 HEAP32[2899] = $2;
1290 $3 = $0 + $5 | 0;
1291 HEAP32[2902] = $3;
1292 HEAP32[$3 + 4 >> 2] = $2 | 1;
1293 HEAP32[$0 + $1 >> 2] = $2;
1294 HEAP32[$0 + 4 >> 2] = $5 | 3;
1295 break label$45;
1296 }
1297 HEAP32[2902] = 0;
1298 HEAP32[2899] = 0;
1299 HEAP32[$0 + 4 >> 2] = $1 | 3;
1300 $1 = $0 + $1 | 0;
1301 HEAP32[$1 + 4 >> 2] = HEAP32[$1 + 4 >> 2] | 1;
1302 }
1303 $0 = $0 + 8 | 0;
1304 break label$1;
1305 }
1306 $1 = HEAP32[2900];
1307 if ($1 >>> 0 > $5 >>> 0) {
1308 $1 = $1 - $5 | 0;
1309 HEAP32[2900] = $1;
1310 $0 = HEAP32[2903];
1311 $2 = $0 + $5 | 0;
1312 HEAP32[2903] = $2;
1313 HEAP32[$2 + 4 >> 2] = $1 | 1;
1314 HEAP32[$0 + 4 >> 2] = $5 | 3;
1315 $0 = $0 + 8 | 0;
1316 break label$1;
1317 }
1318 $0 = 0;
1319 $4 = $5 + 47 | 0;
1320 $3 = $4;
1321 if (HEAP32[3015]) {
1322 $2 = HEAP32[3017]
1323 } else {
1324 HEAP32[3018] = -1;
1325 HEAP32[3019] = -1;
1326 HEAP32[3016] = 4096;
1327 HEAP32[3017] = 4096;
1328 HEAP32[3015] = $11 + 12 & -16 ^ 1431655768;
1329 HEAP32[3020] = 0;
1330 HEAP32[3008] = 0;
1331 $2 = 4096;
1332 }
1333 $6 = $3 + $2 | 0;
1334 $8 = 0 - $2 | 0;
1335 $2 = $6 & $8;
1336 if ($2 >>> 0 <= $5 >>> 0) {
1337 break label$1
1338 }
1339 $3 = HEAP32[3007];
1340 if ($3) {
1341 $7 = HEAP32[3005];
1342 $9 = $7 + $2 | 0;
1343 if ($9 >>> 0 <= $7 >>> 0 | $9 >>> 0 > $3 >>> 0) {
1344 break label$1
1345 }
1346 }
1347 if (HEAPU8[12032] & 4) {
1348 break label$6
1349 }
1350 label$51 : {
1351 label$52 : {
1352 $3 = HEAP32[2903];
1353 if ($3) {
1354 $0 = 12036;
1355 while (1) {
1356 $7 = HEAP32[$0 >> 2];
1357 if ($7 + HEAP32[$0 + 4 >> 2] >>> 0 > $3 >>> 0 ? $7 >>> 0 <= $3 >>> 0 : 0) {
1358 break label$52
1359 }
1360 $0 = HEAP32[$0 + 8 >> 2];
1361 if ($0) {
1362 continue
1363 }
1364 break;
1365 };
1366 }
1367 $1 = sbrk(0);
1368 if (($1 | 0) == -1) {
1369 break label$7
1370 }
1371 $6 = $2;
1372 $0 = HEAP32[3016];
1373 $3 = $0 + -1 | 0;
1374 if ($3 & $1) {
1375 $6 = ($2 - $1 | 0) + ($1 + $3 & 0 - $0) | 0
1376 }
1377 if ($6 >>> 0 <= $5 >>> 0 | $6 >>> 0 > 2147483646) {
1378 break label$7
1379 }
1380 $0 = HEAP32[3007];
1381 if ($0) {
1382 $3 = HEAP32[3005];
1383 $8 = $3 + $6 | 0;
1384 if ($8 >>> 0 <= $3 >>> 0 | $8 >>> 0 > $0 >>> 0) {
1385 break label$7
1386 }
1387 }
1388 $0 = sbrk($6);
1389 if (($1 | 0) != ($0 | 0)) {
1390 break label$51
1391 }
1392 break label$5;
1393 }
1394 $6 = $8 & $6 - $1;
1395 if ($6 >>> 0 > 2147483646) {
1396 break label$7
1397 }
1398 $1 = sbrk($6);
1399 if (($1 | 0) == (HEAP32[$0 >> 2] + HEAP32[$0 + 4 >> 2] | 0)) {
1400 break label$8
1401 }
1402 $0 = $1;
1403 }
1404 if (!(($0 | 0) == -1 | $5 + 48 >>> 0 <= $6 >>> 0)) {
1405 $1 = HEAP32[3017];
1406 $1 = $1 + ($4 - $6 | 0) & 0 - $1;
1407 if ($1 >>> 0 > 2147483646) {
1408 $1 = $0;
1409 break label$5;
1410 }
1411 if ((sbrk($1) | 0) != -1) {
1412 $6 = $1 + $6 | 0;
1413 $1 = $0;
1414 break label$5;
1415 }
1416 sbrk(0 - $6 | 0);
1417 break label$7;
1418 }
1419 $1 = $0;
1420 if (($0 | 0) != -1) {
1421 break label$5
1422 }
1423 break label$7;
1424 }
1425 $4 = 0;
1426 break label$2;
1427 }
1428 $1 = 0;
1429 break label$3;
1430 }
1431 if (($1 | 0) != -1) {
1432 break label$5
1433 }
1434 }
1435 HEAP32[3008] = HEAP32[3008] | 4;
1436 }
1437 if ($2 >>> 0 > 2147483646) {
1438 break label$4
1439 }
1440 $1 = sbrk($2);
1441 $0 = sbrk(0);
1442 if ($1 >>> 0 >= $0 >>> 0 | ($1 | 0) == -1 | ($0 | 0) == -1) {
1443 break label$4
1444 }
1445 $6 = $0 - $1 | 0;
1446 if ($6 >>> 0 <= $5 + 40 >>> 0) {
1447 break label$4
1448 }
1449 }
1450 $0 = HEAP32[3005] + $6 | 0;
1451 HEAP32[3005] = $0;
1452 if ($0 >>> 0 > HEAPU32[3006]) {
1453 HEAP32[3006] = $0
1454 }
1455 label$62 : {
1456 label$63 : {
1457 label$64 : {
1458 $3 = HEAP32[2903];
1459 if ($3) {
1460 $0 = 12036;
1461 while (1) {
1462 $2 = HEAP32[$0 >> 2];
1463 $4 = HEAP32[$0 + 4 >> 2];
1464 if (($2 + $4 | 0) == ($1 | 0)) {
1465 break label$64
1466 }
1467 $0 = HEAP32[$0 + 8 >> 2];
1468 if ($0) {
1469 continue
1470 }
1471 break;
1472 };
1473 break label$63;
1474 }
1475 $0 = HEAP32[2901];
1476 if (!($1 >>> 0 >= $0 >>> 0 ? $0 : 0)) {
1477 HEAP32[2901] = $1
1478 }
1479 $0 = 0;
1480 HEAP32[3010] = $6;
1481 HEAP32[3009] = $1;
1482 HEAP32[2905] = -1;
1483 HEAP32[2906] = HEAP32[3015];
1484 HEAP32[3012] = 0;
1485 while (1) {
1486 $2 = $0 << 3;
1487 $3 = $2 + 11628 | 0;
1488 HEAP32[$2 + 11636 >> 2] = $3;
1489 HEAP32[$2 + 11640 >> 2] = $3;
1490 $0 = $0 + 1 | 0;
1491 if (($0 | 0) != 32) {
1492 continue
1493 }
1494 break;
1495 };
1496 $0 = $6 + -40 | 0;
1497 $2 = $1 + 8 & 7 ? -8 - $1 & 7 : 0;
1498 $3 = $0 - $2 | 0;
1499 HEAP32[2900] = $3;
1500 $2 = $1 + $2 | 0;
1501 HEAP32[2903] = $2;
1502 HEAP32[$2 + 4 >> 2] = $3 | 1;
1503 HEAP32[($0 + $1 | 0) + 4 >> 2] = 40;
1504 HEAP32[2904] = HEAP32[3019];
1505 break label$62;
1506 }
1507 if (HEAPU8[$0 + 12 | 0] & 8 | $1 >>> 0 <= $3 >>> 0 | $2 >>> 0 > $3 >>> 0) {
1508 break label$63
1509 }
1510 HEAP32[$0 + 4 >> 2] = $4 + $6;
1511 $0 = $3 + 8 & 7 ? -8 - $3 & 7 : 0;
1512 $1 = $0 + $3 | 0;
1513 HEAP32[2903] = $1;
1514 $2 = HEAP32[2900] + $6 | 0;
1515 $0 = $2 - $0 | 0;
1516 HEAP32[2900] = $0;
1517 HEAP32[$1 + 4 >> 2] = $0 | 1;
1518 HEAP32[($2 + $3 | 0) + 4 >> 2] = 40;
1519 HEAP32[2904] = HEAP32[3019];
1520 break label$62;
1521 }
1522 $0 = HEAP32[2901];
1523 if ($1 >>> 0 < $0 >>> 0) {
1524 HEAP32[2901] = $1;
1525 $0 = 0;
1526 }
1527 $2 = $1 + $6 | 0;
1528 $0 = 12036;
1529 label$70 : {
1530 label$71 : {
1531 label$72 : {
1532 label$73 : {
1533 label$74 : {
1534 label$75 : {
1535 while (1) {
1536 if (($2 | 0) != HEAP32[$0 >> 2]) {
1537 $0 = HEAP32[$0 + 8 >> 2];
1538 if ($0) {
1539 continue
1540 }
1541 break label$75;
1542 }
1543 break;
1544 };
1545 if (!(HEAPU8[$0 + 12 | 0] & 8)) {
1546 break label$74
1547 }
1548 }
1549 $0 = 12036;
1550 while (1) {
1551 $2 = HEAP32[$0 >> 2];
1552 if ($2 >>> 0 <= $3 >>> 0) {
1553 $4 = $2 + HEAP32[$0 + 4 >> 2] | 0;
1554 if ($4 >>> 0 > $3 >>> 0) {
1555 break label$73
1556 }
1557 }
1558 $0 = HEAP32[$0 + 8 >> 2];
1559 continue;
1560 };
1561 }
1562 HEAP32[$0 >> 2] = $1;
1563 HEAP32[$0 + 4 >> 2] = HEAP32[$0 + 4 >> 2] + $6;
1564 $7 = ($1 + 8 & 7 ? -8 - $1 & 7 : 0) + $1 | 0;
1565 HEAP32[$7 + 4 >> 2] = $5 | 3;
1566 $1 = $2 + ($2 + 8 & 7 ? -8 - $2 & 7 : 0) | 0;
1567 $0 = ($1 - $7 | 0) - $5 | 0;
1568 $4 = $5 + $7 | 0;
1569 if (($1 | 0) == ($3 | 0)) {
1570 HEAP32[2903] = $4;
1571 $0 = HEAP32[2900] + $0 | 0;
1572 HEAP32[2900] = $0;
1573 HEAP32[$4 + 4 >> 2] = $0 | 1;
1574 break label$71;
1575 }
1576 if (HEAP32[2902] == ($1 | 0)) {
1577 HEAP32[2902] = $4;
1578 $0 = HEAP32[2899] + $0 | 0;
1579 HEAP32[2899] = $0;
1580 HEAP32[$4 + 4 >> 2] = $0 | 1;
1581 HEAP32[$0 + $4 >> 2] = $0;
1582 break label$71;
1583 }
1584 $2 = HEAP32[$1 + 4 >> 2];
1585 if (($2 & 3) == 1) {
1586 $9 = $2 & -8;
1587 label$83 : {
1588 if ($2 >>> 0 <= 255) {
1589 $3 = HEAP32[$1 + 8 >> 2];
1590 $5 = $2 >>> 3 | 0;
1591 $2 = HEAP32[$1 + 12 >> 2];
1592 if (($2 | 0) == ($3 | 0)) {
1593 (wasm2js_i32$0 = 11588, wasm2js_i32$1 = HEAP32[2897] & __wasm_rotl_i32(-2, $5)), HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
1594 break label$83;
1595 }
1596 HEAP32[$3 + 12 >> 2] = $2;
1597 HEAP32[$2 + 8 >> 2] = $3;
1598 break label$83;
1599 }
1600 $8 = HEAP32[$1 + 24 >> 2];
1601 $6 = HEAP32[$1 + 12 >> 2];
1602 label$86 : {
1603 if (($6 | 0) != ($1 | 0)) {
1604 $2 = HEAP32[$1 + 8 >> 2];
1605 HEAP32[$2 + 12 >> 2] = $6;
1606 HEAP32[$6 + 8 >> 2] = $2;
1607 break label$86;
1608 }
1609 label$89 : {
1610 $3 = $1 + 20 | 0;
1611 $5 = HEAP32[$3 >> 2];
1612 if ($5) {
1613 break label$89
1614 }
1615 $3 = $1 + 16 | 0;
1616 $5 = HEAP32[$3 >> 2];
1617 if ($5) {
1618 break label$89
1619 }
1620 $6 = 0;
1621 break label$86;
1622 }
1623 while (1) {
1624 $2 = $3;
1625 $6 = $5;
1626 $3 = $5 + 20 | 0;
1627 $5 = HEAP32[$3 >> 2];
1628 if ($5) {
1629 continue
1630 }
1631 $3 = $6 + 16 | 0;
1632 $5 = HEAP32[$6 + 16 >> 2];
1633 if ($5) {
1634 continue
1635 }
1636 break;
1637 };
1638 HEAP32[$2 >> 2] = 0;
1639 }
1640 if (!$8) {
1641 break label$83
1642 }
1643 $2 = HEAP32[$1 + 28 >> 2];
1644 $3 = ($2 << 2) + 11892 | 0;
1645 label$91 : {
1646 if (HEAP32[$3 >> 2] == ($1 | 0)) {
1647 HEAP32[$3 >> 2] = $6;
1648 if ($6) {
1649 break label$91
1650 }
1651 (wasm2js_i32$0 = 11592, wasm2js_i32$1 = HEAP32[2898] & __wasm_rotl_i32(-2, $2)), HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
1652 break label$83;
1653 }
1654 HEAP32[$8 + (HEAP32[$8 + 16 >> 2] == ($1 | 0) ? 16 : 20) >> 2] = $6;
1655 if (!$6) {
1656 break label$83
1657 }
1658 }
1659 HEAP32[$6 + 24 >> 2] = $8;
1660 $2 = HEAP32[$1 + 16 >> 2];
1661 if ($2) {
1662 HEAP32[$6 + 16 >> 2] = $2;
1663 HEAP32[$2 + 24 >> 2] = $6;
1664 }
1665 $2 = HEAP32[$1 + 20 >> 2];
1666 if (!$2) {
1667 break label$83
1668 }
1669 HEAP32[$6 + 20 >> 2] = $2;
1670 HEAP32[$2 + 24 >> 2] = $6;
1671 }
1672 $1 = $1 + $9 | 0;
1673 $0 = $0 + $9 | 0;
1674 }
1675 HEAP32[$1 + 4 >> 2] = HEAP32[$1 + 4 >> 2] & -2;
1676 HEAP32[$4 + 4 >> 2] = $0 | 1;
1677 HEAP32[$0 + $4 >> 2] = $0;
1678 if ($0 >>> 0 <= 255) {
1679 $1 = $0 >>> 3 | 0;
1680 $0 = ($1 << 3) + 11628 | 0;
1681 $2 = HEAP32[2897];
1682 $1 = 1 << $1;
1683 label$95 : {
1684 if (!($2 & $1)) {
1685 HEAP32[2897] = $1 | $2;
1686 $1 = $0;
1687 break label$95;
1688 }
1689 $1 = HEAP32[$0 + 8 >> 2];
1690 }
1691 HEAP32[$0 + 8 >> 2] = $4;
1692 HEAP32[$1 + 12 >> 2] = $4;
1693 HEAP32[$4 + 12 >> 2] = $0;
1694 HEAP32[$4 + 8 >> 2] = $1;
1695 break label$71;
1696 }
1697 $6 = $4;
1698 $1 = $0 >>> 8 | 0;
1699 $2 = 0;
1700 label$97 : {
1701 if (!$1) {
1702 break label$97
1703 }
1704 $2 = 31;
1705 if ($0 >>> 0 > 16777215) {
1706 break label$97
1707 }
1708 $3 = $1 + 1048320 >>> 16 & 8;
1709 $2 = $1 << $3;
1710 $1 = $2 + 520192 >>> 16 & 4;
1711 $5 = $2 << $1;
1712 $2 = $5 + 245760 >>> 16 & 2;
1713 $1 = ($5 << $2 >>> 15 | 0) - ($2 | ($1 | $3)) | 0;
1714 $2 = ($1 << 1 | $0 >>> $1 + 21 & 1) + 28 | 0;
1715 }
1716 $1 = $2;
1717 HEAP32[$6 + 28 >> 2] = $1;
1718 HEAP32[$4 + 16 >> 2] = 0;
1719 HEAP32[$4 + 20 >> 2] = 0;
1720 $2 = ($1 << 2) + 11892 | 0;
1721 $3 = HEAP32[2898];
1722 $5 = 1 << $1;
1723 label$98 : {
1724 if (!($3 & $5)) {
1725 HEAP32[2898] = $3 | $5;
1726 HEAP32[$2 >> 2] = $4;
1727 break label$98;
1728 }
1729 $3 = $0 << (($1 | 0) == 31 ? 0 : 25 - ($1 >>> 1 | 0) | 0);
1730 $1 = HEAP32[$2 >> 2];
1731 while (1) {
1732 $2 = $1;
1733 if ((HEAP32[$1 + 4 >> 2] & -8) == ($0 | 0)) {
1734 break label$72
1735 }
1736 $1 = $3 >>> 29 | 0;
1737 $3 = $3 << 1;
1738 $5 = ($2 + ($1 & 4) | 0) + 16 | 0;
1739 $1 = HEAP32[$5 >> 2];
1740 if ($1) {
1741 continue
1742 }
1743 break;
1744 };
1745 HEAP32[$5 >> 2] = $4;
1746 }
1747 HEAP32[$4 + 24 >> 2] = $2;
1748 HEAP32[$4 + 12 >> 2] = $4;
1749 HEAP32[$4 + 8 >> 2] = $4;
1750 break label$71;
1751 }
1752 $0 = $6 + -40 | 0;
1753 $2 = $1 + 8 & 7 ? -8 - $1 & 7 : 0;
1754 $8 = $0 - $2 | 0;
1755 HEAP32[2900] = $8;
1756 $2 = $1 + $2 | 0;
1757 HEAP32[2903] = $2;
1758 HEAP32[$2 + 4 >> 2] = $8 | 1;
1759 HEAP32[($0 + $1 | 0) + 4 >> 2] = 40;
1760 HEAP32[2904] = HEAP32[3019];
1761 $0 = ($4 + ($4 + -39 & 7 ? 39 - $4 & 7 : 0) | 0) + -47 | 0;
1762 $2 = $0 >>> 0 < $3 + 16 >>> 0 ? $3 : $0;
1763 HEAP32[$2 + 4 >> 2] = 27;
1764 $0 = HEAP32[3012];
1765 HEAP32[$2 + 16 >> 2] = HEAP32[3011];
1766 HEAP32[$2 + 20 >> 2] = $0;
1767 $0 = HEAP32[3010];
1768 HEAP32[$2 + 8 >> 2] = HEAP32[3009];
1769 HEAP32[$2 + 12 >> 2] = $0;
1770 HEAP32[3011] = $2 + 8;
1771 HEAP32[3010] = $6;
1772 HEAP32[3009] = $1;
1773 HEAP32[3012] = 0;
1774 $0 = $2 + 24 | 0;
1775 while (1) {
1776 HEAP32[$0 + 4 >> 2] = 7;
1777 $1 = $0 + 8 | 0;
1778 $0 = $0 + 4 | 0;
1779 if ($4 >>> 0 > $1 >>> 0) {
1780 continue
1781 }
1782 break;
1783 };
1784 if (($2 | 0) == ($3 | 0)) {
1785 break label$62
1786 }
1787 HEAP32[$2 + 4 >> 2] = HEAP32[$2 + 4 >> 2] & -2;
1788 $6 = $2 - $3 | 0;
1789 HEAP32[$3 + 4 >> 2] = $6 | 1;
1790 HEAP32[$2 >> 2] = $6;
1791 if ($6 >>> 0 <= 255) {
1792 $1 = $6 >>> 3 | 0;
1793 $0 = ($1 << 3) + 11628 | 0;
1794 $2 = HEAP32[2897];
1795 $1 = 1 << $1;
1796 label$103 : {
1797 if (!($2 & $1)) {
1798 HEAP32[2897] = $1 | $2;
1799 $1 = $0;
1800 break label$103;
1801 }
1802 $1 = HEAP32[$0 + 8 >> 2];
1803 }
1804 HEAP32[$0 + 8 >> 2] = $3;
1805 HEAP32[$1 + 12 >> 2] = $3;
1806 HEAP32[$3 + 12 >> 2] = $0;
1807 HEAP32[$3 + 8 >> 2] = $1;
1808 break label$62;
1809 }
1810 HEAP32[$3 + 16 >> 2] = 0;
1811 HEAP32[$3 + 20 >> 2] = 0;
1812 $7 = $3;
1813 $0 = $6 >>> 8 | 0;
1814 $1 = 0;
1815 label$105 : {
1816 if (!$0) {
1817 break label$105
1818 }
1819 $1 = 31;
1820 if ($6 >>> 0 > 16777215) {
1821 break label$105
1822 }
1823 $2 = $0 + 1048320 >>> 16 & 8;
1824 $1 = $0 << $2;
1825 $0 = $1 + 520192 >>> 16 & 4;
1826 $4 = $1 << $0;
1827 $1 = $4 + 245760 >>> 16 & 2;
1828 $0 = ($4 << $1 >>> 15 | 0) - ($1 | ($0 | $2)) | 0;
1829 $1 = ($0 << 1 | $6 >>> $0 + 21 & 1) + 28 | 0;
1830 }
1831 $0 = $1;
1832 HEAP32[$7 + 28 >> 2] = $0;
1833 $1 = ($0 << 2) + 11892 | 0;
1834 $2 = HEAP32[2898];
1835 $4 = 1 << $0;
1836 label$106 : {
1837 if (!($2 & $4)) {
1838 HEAP32[2898] = $2 | $4;
1839 HEAP32[$1 >> 2] = $3;
1840 HEAP32[$3 + 24 >> 2] = $1;
1841 break label$106;
1842 }
1843 $0 = $6 << (($0 | 0) == 31 ? 0 : 25 - ($0 >>> 1 | 0) | 0);
1844 $1 = HEAP32[$1 >> 2];
1845 while (1) {
1846 $2 = $1;
1847 if (($6 | 0) == (HEAP32[$1 + 4 >> 2] & -8)) {
1848 break label$70
1849 }
1850 $1 = $0 >>> 29 | 0;
1851 $0 = $0 << 1;
1852 $4 = ($2 + ($1 & 4) | 0) + 16 | 0;
1853 $1 = HEAP32[$4 >> 2];
1854 if ($1) {
1855 continue
1856 }
1857 break;
1858 };
1859 HEAP32[$4 >> 2] = $3;
1860 HEAP32[$3 + 24 >> 2] = $2;
1861 }
1862 HEAP32[$3 + 12 >> 2] = $3;
1863 HEAP32[$3 + 8 >> 2] = $3;
1864 break label$62;
1865 }
1866 $0 = HEAP32[$2 + 8 >> 2];
1867 HEAP32[$0 + 12 >> 2] = $4;
1868 HEAP32[$2 + 8 >> 2] = $4;
1869 HEAP32[$4 + 24 >> 2] = 0;
1870 HEAP32[$4 + 12 >> 2] = $2;
1871 HEAP32[$4 + 8 >> 2] = $0;
1872 }
1873 $0 = $7 + 8 | 0;
1874 break label$1;
1875 }
1876 $0 = HEAP32[$2 + 8 >> 2];
1877 HEAP32[$0 + 12 >> 2] = $3;
1878 HEAP32[$2 + 8 >> 2] = $3;
1879 HEAP32[$3 + 24 >> 2] = 0;
1880 HEAP32[$3 + 12 >> 2] = $2;
1881 HEAP32[$3 + 8 >> 2] = $0;
1882 }
1883 $0 = HEAP32[2900];
1884 if ($0 >>> 0 <= $5 >>> 0) {
1885 break label$4
1886 }
1887 $1 = $0 - $5 | 0;
1888 HEAP32[2900] = $1;
1889 $0 = HEAP32[2903];
1890 $2 = $0 + $5 | 0;
1891 HEAP32[2903] = $2;
1892 HEAP32[$2 + 4 >> 2] = $1 | 1;
1893 HEAP32[$0 + 4 >> 2] = $5 | 3;
1894 $0 = $0 + 8 | 0;
1895 break label$1;
1896 }
1897 HEAP32[2896] = 48;
1898 $0 = 0;
1899 break label$1;
1900 }
1901 label$109 : {
1902 if (!$7) {
1903 break label$109
1904 }
1905 $0 = HEAP32[$4 + 28 >> 2];
1906 $3 = ($0 << 2) + 11892 | 0;
1907 label$110 : {
1908 if (HEAP32[$3 >> 2] == ($4 | 0)) {
1909 HEAP32[$3 >> 2] = $1;
1910 if ($1) {
1911 break label$110
1912 }
1913 $8 = __wasm_rotl_i32(-2, $0) & $8;
1914 HEAP32[2898] = $8;
1915 break label$109;
1916 }
1917 HEAP32[$7 + (HEAP32[$7 + 16 >> 2] == ($4 | 0) ? 16 : 20) >> 2] = $1;
1918 if (!$1) {
1919 break label$109
1920 }
1921 }
1922 HEAP32[$1 + 24 >> 2] = $7;
1923 $0 = HEAP32[$4 + 16 >> 2];
1924 if ($0) {
1925 HEAP32[$1 + 16 >> 2] = $0;
1926 HEAP32[$0 + 24 >> 2] = $1;
1927 }
1928 $0 = HEAP32[$4 + 20 >> 2];
1929 if (!$0) {
1930 break label$109
1931 }
1932 HEAP32[$1 + 20 >> 2] = $0;
1933 HEAP32[$0 + 24 >> 2] = $1;
1934 }
1935 label$113 : {
1936 if ($2 >>> 0 <= 15) {
1937 $0 = $2 + $5 | 0;
1938 HEAP32[$4 + 4 >> 2] = $0 | 3;
1939 $0 = $0 + $4 | 0;
1940 HEAP32[$0 + 4 >> 2] = HEAP32[$0 + 4 >> 2] | 1;
1941 break label$113;
1942 }
1943 HEAP32[$4 + 4 >> 2] = $5 | 3;
1944 $1 = $4 + $5 | 0;
1945 HEAP32[$1 + 4 >> 2] = $2 | 1;
1946 HEAP32[$1 + $2 >> 2] = $2;
1947 if ($2 >>> 0 <= 255) {
1948 $2 = $2 >>> 3 | 0;
1949 $0 = ($2 << 3) + 11628 | 0;
1950 $3 = HEAP32[2897];
1951 $2 = 1 << $2;
1952 label$116 : {
1953 if (!($3 & $2)) {
1954 HEAP32[2897] = $2 | $3;
1955 $2 = $0;
1956 break label$116;
1957 }
1958 $2 = HEAP32[$0 + 8 >> 2];
1959 }
1960 HEAP32[$0 + 8 >> 2] = $1;
1961 HEAP32[$2 + 12 >> 2] = $1;
1962 HEAP32[$1 + 12 >> 2] = $0;
1963 HEAP32[$1 + 8 >> 2] = $2;
1964 break label$113;
1965 }
1966 $7 = $1;
1967 $0 = $2 >>> 8 | 0;
1968 $3 = 0;
1969 label$118 : {
1970 if (!$0) {
1971 break label$118
1972 }
1973 $3 = 31;
1974 if ($2 >>> 0 > 16777215) {
1975 break label$118
1976 }
1977 $5 = $0 + 1048320 >>> 16 & 8;
1978 $3 = $0 << $5;
1979 $0 = $3 + 520192 >>> 16 & 4;
1980 $6 = $3 << $0;
1981 $3 = $6 + 245760 >>> 16 & 2;
1982 $0 = ($6 << $3 >>> 15 | 0) - ($3 | ($0 | $5)) | 0;
1983 $3 = ($0 << 1 | $2 >>> $0 + 21 & 1) + 28 | 0;
1984 }
1985 $0 = $3;
1986 HEAP32[$7 + 28 >> 2] = $0;
1987 HEAP32[$1 + 16 >> 2] = 0;
1988 HEAP32[$1 + 20 >> 2] = 0;
1989 $3 = ($0 << 2) + 11892 | 0;
1990 label$119 : {
1991 $5 = 1 << $0;
1992 label$120 : {
1993 if (!($5 & $8)) {
1994 HEAP32[2898] = $5 | $8;
1995 HEAP32[$3 >> 2] = $1;
1996 break label$120;
1997 }
1998 $0 = $2 << (($0 | 0) == 31 ? 0 : 25 - ($0 >>> 1 | 0) | 0);
1999 $5 = HEAP32[$3 >> 2];
2000 while (1) {
2001 $3 = $5;
2002 if ((HEAP32[$3 + 4 >> 2] & -8) == ($2 | 0)) {
2003 break label$119
2004 }
2005 $5 = $0 >>> 29 | 0;
2006 $0 = $0 << 1;
2007 $6 = ($3 + ($5 & 4) | 0) + 16 | 0;
2008 $5 = HEAP32[$6 >> 2];
2009 if ($5) {
2010 continue
2011 }
2012 break;
2013 };
2014 HEAP32[$6 >> 2] = $1;
2015 }
2016 HEAP32[$1 + 24 >> 2] = $3;
2017 HEAP32[$1 + 12 >> 2] = $1;
2018 HEAP32[$1 + 8 >> 2] = $1;
2019 break label$113;
2020 }
2021 $0 = HEAP32[$3 + 8 >> 2];
2022 HEAP32[$0 + 12 >> 2] = $1;
2023 HEAP32[$3 + 8 >> 2] = $1;
2024 HEAP32[$1 + 24 >> 2] = 0;
2025 HEAP32[$1 + 12 >> 2] = $3;
2026 HEAP32[$1 + 8 >> 2] = $0;
2027 }
2028 $0 = $4 + 8 | 0;
2029 break label$1;
2030 }
2031 label$123 : {
2032 if (!$9) {
2033 break label$123
2034 }
2035 $0 = HEAP32[$1 + 28 >> 2];
2036 $2 = ($0 << 2) + 11892 | 0;
2037 label$124 : {
2038 if (HEAP32[$2 >> 2] == ($1 | 0)) {
2039 HEAP32[$2 >> 2] = $4;
2040 if ($4) {
2041 break label$124
2042 }
2043 (wasm2js_i32$0 = 11592, wasm2js_i32$1 = __wasm_rotl_i32(-2, $0) & $10), HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
2044 break label$123;
2045 }
2046 HEAP32[(HEAP32[$9 + 16 >> 2] == ($1 | 0) ? 16 : 20) + $9 >> 2] = $4;
2047 if (!$4) {
2048 break label$123
2049 }
2050 }
2051 HEAP32[$4 + 24 >> 2] = $9;
2052 $0 = HEAP32[$1 + 16 >> 2];
2053 if ($0) {
2054 HEAP32[$4 + 16 >> 2] = $0;
2055 HEAP32[$0 + 24 >> 2] = $4;
2056 }
2057 $0 = HEAP32[$1 + 20 >> 2];
2058 if (!$0) {
2059 break label$123
2060 }
2061 HEAP32[$4 + 20 >> 2] = $0;
2062 HEAP32[$0 + 24 >> 2] = $4;
2063 }
2064 label$127 : {
2065 if ($3 >>> 0 <= 15) {
2066 $0 = $3 + $5 | 0;
2067 HEAP32[$1 + 4 >> 2] = $0 | 3;
2068 $0 = $0 + $1 | 0;
2069 HEAP32[$0 + 4 >> 2] = HEAP32[$0 + 4 >> 2] | 1;
2070 break label$127;
2071 }
2072 HEAP32[$1 + 4 >> 2] = $5 | 3;
2073 $5 = $1 + $5 | 0;
2074 HEAP32[$5 + 4 >> 2] = $3 | 1;
2075 HEAP32[$3 + $5 >> 2] = $3;
2076 if ($7) {
2077 $4 = $7 >>> 3 | 0;
2078 $0 = ($4 << 3) + 11628 | 0;
2079 $2 = HEAP32[2902];
2080 $4 = 1 << $4;
2081 label$130 : {
2082 if (!($4 & $6)) {
2083 HEAP32[2897] = $4 | $6;
2084 $6 = $0;
2085 break label$130;
2086 }
2087 $6 = HEAP32[$0 + 8 >> 2];
2088 }
2089 HEAP32[$0 + 8 >> 2] = $2;
2090 HEAP32[$6 + 12 >> 2] = $2;
2091 HEAP32[$2 + 12 >> 2] = $0;
2092 HEAP32[$2 + 8 >> 2] = $6;
2093 }
2094 HEAP32[2902] = $5;
2095 HEAP32[2899] = $3;
2096 }
2097 $0 = $1 + 8 | 0;
2098 }
2099 global$0 = $11 + 16 | 0;
2100 return $0 | 0;
2101 }
2102
2103 function dlfree($0) {
2104 $0 = $0 | 0;
2105 var $1 = 0, $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
2106 label$1 : {
2107 if (!$0) {
2108 break label$1
2109 }
2110 $3 = $0 + -8 | 0;
2111 $2 = HEAP32[$0 + -4 >> 2];
2112 $0 = $2 & -8;
2113 $5 = $3 + $0 | 0;
2114 label$2 : {
2115 if ($2 & 1) {
2116 break label$2
2117 }
2118 if (!($2 & 3)) {
2119 break label$1
2120 }
2121 $2 = HEAP32[$3 >> 2];
2122 $3 = $3 - $2 | 0;
2123 if ($3 >>> 0 < HEAPU32[2901]) {
2124 break label$1
2125 }
2126 $0 = $0 + $2 | 0;
2127 if (HEAP32[2902] != ($3 | 0)) {
2128 if ($2 >>> 0 <= 255) {
2129 $4 = HEAP32[$3 + 8 >> 2];
2130 $2 = $2 >>> 3 | 0;
2131 $1 = HEAP32[$3 + 12 >> 2];
2132 if (($1 | 0) == ($4 | 0)) {
2133 (wasm2js_i32$0 = 11588, wasm2js_i32$1 = HEAP32[2897] & __wasm_rotl_i32(-2, $2)), HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
2134 break label$2;
2135 }
2136 HEAP32[$4 + 12 >> 2] = $1;
2137 HEAP32[$1 + 8 >> 2] = $4;
2138 break label$2;
2139 }
2140 $7 = HEAP32[$3 + 24 >> 2];
2141 $2 = HEAP32[$3 + 12 >> 2];
2142 label$6 : {
2143 if (($2 | 0) != ($3 | 0)) {
2144 $1 = HEAP32[$3 + 8 >> 2];
2145 HEAP32[$1 + 12 >> 2] = $2;
2146 HEAP32[$2 + 8 >> 2] = $1;
2147 break label$6;
2148 }
2149 label$9 : {
2150 $4 = $3 + 20 | 0;
2151 $1 = HEAP32[$4 >> 2];
2152 if ($1) {
2153 break label$9
2154 }
2155 $4 = $3 + 16 | 0;
2156 $1 = HEAP32[$4 >> 2];
2157 if ($1) {
2158 break label$9
2159 }
2160 $2 = 0;
2161 break label$6;
2162 }
2163 while (1) {
2164 $6 = $4;
2165 $2 = $1;
2166 $4 = $2 + 20 | 0;
2167 $1 = HEAP32[$4 >> 2];
2168 if ($1) {
2169 continue
2170 }
2171 $4 = $2 + 16 | 0;
2172 $1 = HEAP32[$2 + 16 >> 2];
2173 if ($1) {
2174 continue
2175 }
2176 break;
2177 };
2178 HEAP32[$6 >> 2] = 0;
2179 }
2180 if (!$7) {
2181 break label$2
2182 }
2183 $4 = HEAP32[$3 + 28 >> 2];
2184 $1 = ($4 << 2) + 11892 | 0;
2185 label$11 : {
2186 if (HEAP32[$1 >> 2] == ($3 | 0)) {
2187 HEAP32[$1 >> 2] = $2;
2188 if ($2) {
2189 break label$11
2190 }
2191 (wasm2js_i32$0 = 11592, wasm2js_i32$1 = HEAP32[2898] & __wasm_rotl_i32(-2, $4)), HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
2192 break label$2;
2193 }
2194 HEAP32[$7 + (HEAP32[$7 + 16 >> 2] == ($3 | 0) ? 16 : 20) >> 2] = $2;
2195 if (!$2) {
2196 break label$2
2197 }
2198 }
2199 HEAP32[$2 + 24 >> 2] = $7;
2200 $1 = HEAP32[$3 + 16 >> 2];
2201 if ($1) {
2202 HEAP32[$2 + 16 >> 2] = $1;
2203 HEAP32[$1 + 24 >> 2] = $2;
2204 }
2205 $1 = HEAP32[$3 + 20 >> 2];
2206 if (!$1) {
2207 break label$2
2208 }
2209 HEAP32[$2 + 20 >> 2] = $1;
2210 HEAP32[$1 + 24 >> 2] = $2;
2211 break label$2;
2212 }
2213 $2 = HEAP32[$5 + 4 >> 2];
2214 if (($2 & 3) != 3) {
2215 break label$2
2216 }
2217 HEAP32[2899] = $0;
2218 HEAP32[$5 + 4 >> 2] = $2 & -2;
2219 HEAP32[$3 + 4 >> 2] = $0 | 1;
2220 HEAP32[$0 + $3 >> 2] = $0;
2221 return;
2222 }
2223 if ($5 >>> 0 <= $3 >>> 0) {
2224 break label$1
2225 }
2226 $2 = HEAP32[$5 + 4 >> 2];
2227 if (!($2 & 1)) {
2228 break label$1
2229 }
2230 label$14 : {
2231 if (!($2 & 2)) {
2232 if (($5 | 0) == HEAP32[2903]) {
2233 HEAP32[2903] = $3;
2234 $0 = HEAP32[2900] + $0 | 0;
2235 HEAP32[2900] = $0;
2236 HEAP32[$3 + 4 >> 2] = $0 | 1;
2237 if (HEAP32[2902] != ($3 | 0)) {
2238 break label$1
2239 }
2240 HEAP32[2899] = 0;
2241 HEAP32[2902] = 0;
2242 return;
2243 }
2244 if (($5 | 0) == HEAP32[2902]) {
2245 HEAP32[2902] = $3;
2246 $0 = HEAP32[2899] + $0 | 0;
2247 HEAP32[2899] = $0;
2248 HEAP32[$3 + 4 >> 2] = $0 | 1;
2249 HEAP32[$0 + $3 >> 2] = $0;
2250 return;
2251 }
2252 $0 = ($2 & -8) + $0 | 0;
2253 label$18 : {
2254 if ($2 >>> 0 <= 255) {
2255 $1 = HEAP32[$5 + 8 >> 2];
2256 $2 = $2 >>> 3 | 0;
2257 $4 = HEAP32[$5 + 12 >> 2];
2258 if (($1 | 0) == ($4 | 0)) {
2259 (wasm2js_i32$0 = 11588, wasm2js_i32$1 = HEAP32[2897] & __wasm_rotl_i32(-2, $2)), HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
2260 break label$18;
2261 }
2262 HEAP32[$1 + 12 >> 2] = $4;
2263 HEAP32[$4 + 8 >> 2] = $1;
2264 break label$18;
2265 }
2266 $7 = HEAP32[$5 + 24 >> 2];
2267 $2 = HEAP32[$5 + 12 >> 2];
2268 label$23 : {
2269 if (($5 | 0) != ($2 | 0)) {
2270 $1 = HEAP32[$5 + 8 >> 2];
2271 HEAP32[$1 + 12 >> 2] = $2;
2272 HEAP32[$2 + 8 >> 2] = $1;
2273 break label$23;
2274 }
2275 label$26 : {
2276 $4 = $5 + 20 | 0;
2277 $1 = HEAP32[$4 >> 2];
2278 if ($1) {
2279 break label$26
2280 }
2281 $4 = $5 + 16 | 0;
2282 $1 = HEAP32[$4 >> 2];
2283 if ($1) {
2284 break label$26
2285 }
2286 $2 = 0;
2287 break label$23;
2288 }
2289 while (1) {
2290 $6 = $4;
2291 $2 = $1;
2292 $4 = $2 + 20 | 0;
2293 $1 = HEAP32[$4 >> 2];
2294 if ($1) {
2295 continue
2296 }
2297 $4 = $2 + 16 | 0;
2298 $1 = HEAP32[$2 + 16 >> 2];
2299 if ($1) {
2300 continue
2301 }
2302 break;
2303 };
2304 HEAP32[$6 >> 2] = 0;
2305 }
2306 if (!$7) {
2307 break label$18
2308 }
2309 $4 = HEAP32[$5 + 28 >> 2];
2310 $1 = ($4 << 2) + 11892 | 0;
2311 label$28 : {
2312 if (($5 | 0) == HEAP32[$1 >> 2]) {
2313 HEAP32[$1 >> 2] = $2;
2314 if ($2) {
2315 break label$28
2316 }
2317 (wasm2js_i32$0 = 11592, wasm2js_i32$1 = HEAP32[2898] & __wasm_rotl_i32(-2, $4)), HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
2318 break label$18;
2319 }
2320 HEAP32[$7 + (($5 | 0) == HEAP32[$7 + 16 >> 2] ? 16 : 20) >> 2] = $2;
2321 if (!$2) {
2322 break label$18
2323 }
2324 }
2325 HEAP32[$2 + 24 >> 2] = $7;
2326 $1 = HEAP32[$5 + 16 >> 2];
2327 if ($1) {
2328 HEAP32[$2 + 16 >> 2] = $1;
2329 HEAP32[$1 + 24 >> 2] = $2;
2330 }
2331 $1 = HEAP32[$5 + 20 >> 2];
2332 if (!$1) {
2333 break label$18
2334 }
2335 HEAP32[$2 + 20 >> 2] = $1;
2336 HEAP32[$1 + 24 >> 2] = $2;
2337 }
2338 HEAP32[$3 + 4 >> 2] = $0 | 1;
2339 HEAP32[$0 + $3 >> 2] = $0;
2340 if (HEAP32[2902] != ($3 | 0)) {
2341 break label$14
2342 }
2343 HEAP32[2899] = $0;
2344 return;
2345 }
2346 HEAP32[$5 + 4 >> 2] = $2 & -2;
2347 HEAP32[$3 + 4 >> 2] = $0 | 1;
2348 HEAP32[$0 + $3 >> 2] = $0;
2349 }
2350 if ($0 >>> 0 <= 255) {
2351 $0 = $0 >>> 3 | 0;
2352 $2 = ($0 << 3) + 11628 | 0;
2353 $1 = HEAP32[2897];
2354 $0 = 1 << $0;
2355 label$32 : {
2356 if (!($1 & $0)) {
2357 HEAP32[2897] = $0 | $1;
2358 $0 = $2;
2359 break label$32;
2360 }
2361 $0 = HEAP32[$2 + 8 >> 2];
2362 }
2363 HEAP32[$2 + 8 >> 2] = $3;
2364 HEAP32[$0 + 12 >> 2] = $3;
2365 HEAP32[$3 + 12 >> 2] = $2;
2366 HEAP32[$3 + 8 >> 2] = $0;
2367 return;
2368 }
2369 HEAP32[$3 + 16 >> 2] = 0;
2370 HEAP32[$3 + 20 >> 2] = 0;
2371 $5 = $3;
2372 $4 = $0 >>> 8 | 0;
2373 $1 = 0;
2374 label$34 : {
2375 if (!$4) {
2376 break label$34
2377 }
2378 $1 = 31;
2379 if ($0 >>> 0 > 16777215) {
2380 break label$34
2381 }
2382 $2 = $4;
2383 $4 = $4 + 1048320 >>> 16 & 8;
2384 $1 = $2 << $4;
2385 $7 = $1 + 520192 >>> 16 & 4;
2386 $1 = $1 << $7;
2387 $6 = $1 + 245760 >>> 16 & 2;
2388 $1 = ($1 << $6 >>> 15 | 0) - ($6 | ($4 | $7)) | 0;
2389 $1 = ($1 << 1 | $0 >>> $1 + 21 & 1) + 28 | 0;
2390 }
2391 HEAP32[$5 + 28 >> 2] = $1;
2392 $6 = ($1 << 2) + 11892 | 0;
2393 label$35 : {
2394 label$36 : {
2395 $4 = HEAP32[2898];
2396 $2 = 1 << $1;
2397 label$37 : {
2398 if (!($4 & $2)) {
2399 HEAP32[2898] = $2 | $4;
2400 HEAP32[$6 >> 2] = $3;
2401 HEAP32[$3 + 24 >> 2] = $6;
2402 break label$37;
2403 }
2404 $4 = $0 << (($1 | 0) == 31 ? 0 : 25 - ($1 >>> 1 | 0) | 0);
2405 $2 = HEAP32[$6 >> 2];
2406 while (1) {
2407 $1 = $2;
2408 if ((HEAP32[$2 + 4 >> 2] & -8) == ($0 | 0)) {
2409 break label$36
2410 }
2411 $2 = $4 >>> 29 | 0;
2412 $4 = $4 << 1;
2413 $6 = ($1 + ($2 & 4) | 0) + 16 | 0;
2414 $2 = HEAP32[$6 >> 2];
2415 if ($2) {
2416 continue
2417 }
2418 break;
2419 };
2420 HEAP32[$6 >> 2] = $3;
2421 HEAP32[$3 + 24 >> 2] = $1;
2422 }
2423 HEAP32[$3 + 12 >> 2] = $3;
2424 HEAP32[$3 + 8 >> 2] = $3;
2425 break label$35;
2426 }
2427 $0 = HEAP32[$1 + 8 >> 2];
2428 HEAP32[$0 + 12 >> 2] = $3;
2429 HEAP32[$1 + 8 >> 2] = $3;
2430 HEAP32[$3 + 24 >> 2] = 0;
2431 HEAP32[$3 + 12 >> 2] = $1;
2432 HEAP32[$3 + 8 >> 2] = $0;
2433 }
2434 $0 = HEAP32[2905] + -1 | 0;
2435 HEAP32[2905] = $0;
2436 if ($0) {
2437 break label$1
2438 }
2439 $3 = 12044;
2440 while (1) {
2441 $0 = HEAP32[$3 >> 2];
2442 $3 = $0 + 8 | 0;
2443 if ($0) {
2444 continue
2445 }
2446 break;
2447 };
2448 HEAP32[2905] = -1;
2449 }
2450 }
2451
2452 function dlcalloc($0, $1) {
2453 var $2 = 0, $3 = 0, $4 = 0;
2454 $2 = 0;
2455 label$2 : {
2456 if (!$0) {
2457 break label$2
2458 }
2459 $3 = __wasm_i64_mul($0, 0, $1, 0);
2460 $4 = i64toi32_i32$HIGH_BITS;
2461 $2 = $3;
2462 if (($0 | $1) >>> 0 < 65536) {
2463 break label$2
2464 }
2465 $2 = $4 ? -1 : $3;
2466 }
2467 $1 = $2;
2468 $0 = dlmalloc($1);
2469 if (!(!$0 | !(HEAPU8[$0 + -4 | 0] & 3))) {
2470 memset($0, $1)
2471 }
2472 return $0;
2473 }
2474
2475 function dlrealloc($0, $1) {
2476 var $2 = 0, $3 = 0;
2477 if (!$0) {
2478 return dlmalloc($1)
2479 }
2480 if ($1 >>> 0 >= 4294967232) {
2481 HEAP32[2896] = 48;
2482 return 0;
2483 }
2484 $2 = try_realloc_chunk($0 + -8 | 0, $1 >>> 0 < 11 ? 16 : $1 + 11 & -8);
2485 if ($2) {
2486 return $2 + 8 | 0
2487 }
2488 $2 = dlmalloc($1);
2489 if (!$2) {
2490 return 0
2491 }
2492 $3 = HEAP32[$0 + -4 >> 2];
2493 $3 = ($3 & 3 ? -4 : -8) + ($3 & -8) | 0;
2494 memcpy($2, $0, $3 >>> 0 < $1 >>> 0 ? $3 : $1);
2495 dlfree($0);
2496 return $2;
2497 }
2498
2499 function try_realloc_chunk($0, $1) {
2500 var $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
2501 $7 = HEAP32[$0 + 4 >> 2];
2502 $2 = $7 & 3;
2503 $3 = $7 & -8;
2504 $5 = $3 + $0 | 0;
2505 label$2 : {
2506 if (!$2) {
2507 $2 = 0;
2508 if ($1 >>> 0 < 256) {
2509 break label$2
2510 }
2511 if ($3 >>> 0 >= $1 + 4 >>> 0) {
2512 $2 = $0;
2513 if ($3 - $1 >>> 0 <= HEAP32[3017] << 1 >>> 0) {
2514 break label$2
2515 }
2516 }
2517 return 0;
2518 }
2519 label$5 : {
2520 if ($3 >>> 0 >= $1 >>> 0) {
2521 $2 = $3 - $1 | 0;
2522 if ($2 >>> 0 < 16) {
2523 break label$5
2524 }
2525 HEAP32[$0 + 4 >> 2] = $7 & 1 | $1 | 2;
2526 $1 = $0 + $1 | 0;
2527 HEAP32[$1 + 4 >> 2] = $2 | 3;
2528 HEAP32[$5 + 4 >> 2] = HEAP32[$5 + 4 >> 2] | 1;
2529 dispose_chunk($1, $2);
2530 break label$5;
2531 }
2532 $2 = 0;
2533 if (($5 | 0) == HEAP32[2903]) {
2534 $4 = $3 + HEAP32[2900] | 0;
2535 if ($4 >>> 0 <= $1 >>> 0) {
2536 break label$2
2537 }
2538 HEAP32[$0 + 4 >> 2] = $7 & 1 | $1 | 2;
2539 $2 = $0 + $1 | 0;
2540 $1 = $4 - $1 | 0;
2541 HEAP32[$2 + 4 >> 2] = $1 | 1;
2542 HEAP32[2900] = $1;
2543 HEAP32[2903] = $2;
2544 break label$5;
2545 }
2546 if (($5 | 0) == HEAP32[2902]) {
2547 $4 = $3 + HEAP32[2899] | 0;
2548 if ($4 >>> 0 < $1 >>> 0) {
2549 break label$2
2550 }
2551 $2 = $4 - $1 | 0;
2552 label$9 : {
2553 if ($2 >>> 0 >= 16) {
2554 HEAP32[$0 + 4 >> 2] = $7 & 1 | $1 | 2;
2555 $1 = $0 + $1 | 0;
2556 HEAP32[$1 + 4 >> 2] = $2 | 1;
2557 $4 = $0 + $4 | 0;
2558 HEAP32[$4 >> 2] = $2;
2559 HEAP32[$4 + 4 >> 2] = HEAP32[$4 + 4 >> 2] & -2;
2560 break label$9;
2561 }
2562 HEAP32[$0 + 4 >> 2] = $4 | $7 & 1 | 2;
2563 $1 = $0 + $4 | 0;
2564 HEAP32[$1 + 4 >> 2] = HEAP32[$1 + 4 >> 2] | 1;
2565 $2 = 0;
2566 $1 = 0;
2567 }
2568 HEAP32[2902] = $1;
2569 HEAP32[2899] = $2;
2570 break label$5;
2571 }
2572 $6 = HEAP32[$5 + 4 >> 2];
2573 if ($6 & 2) {
2574 break label$2
2575 }
2576 $8 = $3 + ($6 & -8) | 0;
2577 if ($8 >>> 0 < $1 >>> 0) {
2578 break label$2
2579 }
2580 $10 = $8 - $1 | 0;
2581 label$11 : {
2582 if ($6 >>> 0 <= 255) {
2583 $2 = $6 >>> 3 | 0;
2584 $6 = HEAP32[$5 + 8 >> 2];
2585 $4 = HEAP32[$5 + 12 >> 2];
2586 if (($6 | 0) == ($4 | 0)) {
2587 (wasm2js_i32$0 = 11588, wasm2js_i32$1 = HEAP32[2897] & __wasm_rotl_i32(-2, $2)), HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
2588 break label$11;
2589 }
2590 HEAP32[$6 + 12 >> 2] = $4;
2591 HEAP32[$4 + 8 >> 2] = $6;
2592 break label$11;
2593 }
2594 $9 = HEAP32[$5 + 24 >> 2];
2595 $3 = HEAP32[$5 + 12 >> 2];
2596 label$14 : {
2597 if (($5 | 0) != ($3 | 0)) {
2598 $2 = HEAP32[$5 + 8 >> 2];
2599 HEAP32[$2 + 12 >> 2] = $3;
2600 HEAP32[$3 + 8 >> 2] = $2;
2601 break label$14;
2602 }
2603 label$17 : {
2604 $2 = $5 + 20 | 0;
2605 $6 = HEAP32[$2 >> 2];
2606 if ($6) {
2607 break label$17
2608 }
2609 $2 = $5 + 16 | 0;
2610 $6 = HEAP32[$2 >> 2];
2611 if ($6) {
2612 break label$17
2613 }
2614 $3 = 0;
2615 break label$14;
2616 }
2617 while (1) {
2618 $4 = $2;
2619 $3 = $6;
2620 $2 = $3 + 20 | 0;
2621 $6 = HEAP32[$2 >> 2];
2622 if ($6) {
2623 continue
2624 }
2625 $2 = $3 + 16 | 0;
2626 $6 = HEAP32[$3 + 16 >> 2];
2627 if ($6) {
2628 continue
2629 }
2630 break;
2631 };
2632 HEAP32[$4 >> 2] = 0;
2633 }
2634 if (!$9) {
2635 break label$11
2636 }
2637 $4 = HEAP32[$5 + 28 >> 2];
2638 $2 = ($4 << 2) + 11892 | 0;
2639 label$19 : {
2640 if (($5 | 0) == HEAP32[$2 >> 2]) {
2641 HEAP32[$2 >> 2] = $3;
2642 if ($3) {
2643 break label$19
2644 }
2645 (wasm2js_i32$0 = 11592, wasm2js_i32$1 = HEAP32[2898] & __wasm_rotl_i32(-2, $4)), HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
2646 break label$11;
2647 }
2648 HEAP32[(($5 | 0) == HEAP32[$9 + 16 >> 2] ? 16 : 20) + $9 >> 2] = $3;
2649 if (!$3) {
2650 break label$11
2651 }
2652 }
2653 HEAP32[$3 + 24 >> 2] = $9;
2654 $2 = HEAP32[$5 + 16 >> 2];
2655 if ($2) {
2656 HEAP32[$3 + 16 >> 2] = $2;
2657 HEAP32[$2 + 24 >> 2] = $3;
2658 }
2659 $2 = HEAP32[$5 + 20 >> 2];
2660 if (!$2) {
2661 break label$11
2662 }
2663 HEAP32[$3 + 20 >> 2] = $2;
2664 HEAP32[$2 + 24 >> 2] = $3;
2665 }
2666 if ($10 >>> 0 <= 15) {
2667 HEAP32[$0 + 4 >> 2] = $7 & 1 | $8 | 2;
2668 $1 = $0 + $8 | 0;
2669 HEAP32[$1 + 4 >> 2] = HEAP32[$1 + 4 >> 2] | 1;
2670 break label$5;
2671 }
2672 HEAP32[$0 + 4 >> 2] = $7 & 1 | $1 | 2;
2673 $2 = $0 + $1 | 0;
2674 HEAP32[$2 + 4 >> 2] = $10 | 3;
2675 $1 = $0 + $8 | 0;
2676 HEAP32[$1 + 4 >> 2] = HEAP32[$1 + 4 >> 2] | 1;
2677 dispose_chunk($2, $10);
2678 }
2679 $2 = $0;
2680 }
2681 return $2;
2682 }
2683
2684 function dispose_chunk($0, $1) {
2685 var $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
2686 $5 = $0 + $1 | 0;
2687 label$1 : {
2688 label$2 : {
2689 $2 = HEAP32[$0 + 4 >> 2];
2690 if ($2 & 1) {
2691 break label$2
2692 }
2693 if (!($2 & 3)) {
2694 break label$1
2695 }
2696 $2 = HEAP32[$0 >> 2];
2697 $1 = $2 + $1 | 0;
2698 $0 = $0 - $2 | 0;
2699 if (($0 | 0) != HEAP32[2902]) {
2700 if ($2 >>> 0 <= 255) {
2701 $4 = $2 >>> 3 | 0;
2702 $2 = HEAP32[$0 + 8 >> 2];
2703 $3 = HEAP32[$0 + 12 >> 2];
2704 if (($3 | 0) == ($2 | 0)) {
2705 (wasm2js_i32$0 = 11588, wasm2js_i32$1 = HEAP32[2897] & __wasm_rotl_i32(-2, $4)), HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
2706 break label$2;
2707 }
2708 HEAP32[$2 + 12 >> 2] = $3;
2709 HEAP32[$3 + 8 >> 2] = $2;
2710 break label$2;
2711 }
2712 $7 = HEAP32[$0 + 24 >> 2];
2713 $2 = HEAP32[$0 + 12 >> 2];
2714 label$6 : {
2715 if (($2 | 0) != ($0 | 0)) {
2716 $3 = HEAP32[$0 + 8 >> 2];
2717 HEAP32[$3 + 12 >> 2] = $2;
2718 HEAP32[$2 + 8 >> 2] = $3;
2719 break label$6;
2720 }
2721 label$9 : {
2722 $3 = $0 + 20 | 0;
2723 $4 = HEAP32[$3 >> 2];
2724 if ($4) {
2725 break label$9
2726 }
2727 $3 = $0 + 16 | 0;
2728 $4 = HEAP32[$3 >> 2];
2729 if ($4) {
2730 break label$9
2731 }
2732 $2 = 0;
2733 break label$6;
2734 }
2735 while (1) {
2736 $6 = $3;
2737 $2 = $4;
2738 $3 = $2 + 20 | 0;
2739 $4 = HEAP32[$3 >> 2];
2740 if ($4) {
2741 continue
2742 }
2743 $3 = $2 + 16 | 0;
2744 $4 = HEAP32[$2 + 16 >> 2];
2745 if ($4) {
2746 continue
2747 }
2748 break;
2749 };
2750 HEAP32[$6 >> 2] = 0;
2751 }
2752 if (!$7) {
2753 break label$2
2754 }
2755 $3 = HEAP32[$0 + 28 >> 2];
2756 $4 = ($3 << 2) + 11892 | 0;
2757 label$11 : {
2758 if (HEAP32[$4 >> 2] == ($0 | 0)) {
2759 HEAP32[$4 >> 2] = $2;
2760 if ($2) {
2761 break label$11
2762 }
2763 (wasm2js_i32$0 = 11592, wasm2js_i32$1 = HEAP32[2898] & __wasm_rotl_i32(-2, $3)), HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
2764 break label$2;
2765 }
2766 HEAP32[$7 + (HEAP32[$7 + 16 >> 2] == ($0 | 0) ? 16 : 20) >> 2] = $2;
2767 if (!$2) {
2768 break label$2
2769 }
2770 }
2771 HEAP32[$2 + 24 >> 2] = $7;
2772 $3 = HEAP32[$0 + 16 >> 2];
2773 if ($3) {
2774 HEAP32[$2 + 16 >> 2] = $3;
2775 HEAP32[$3 + 24 >> 2] = $2;
2776 }
2777 $3 = HEAP32[$0 + 20 >> 2];
2778 if (!$3) {
2779 break label$2
2780 }
2781 HEAP32[$2 + 20 >> 2] = $3;
2782 HEAP32[$3 + 24 >> 2] = $2;
2783 break label$2;
2784 }
2785 $2 = HEAP32[$5 + 4 >> 2];
2786 if (($2 & 3) != 3) {
2787 break label$2
2788 }
2789 HEAP32[2899] = $1;
2790 HEAP32[$5 + 4 >> 2] = $2 & -2;
2791 HEAP32[$0 + 4 >> 2] = $1 | 1;
2792 HEAP32[$5 >> 2] = $1;
2793 return;
2794 }
2795 $2 = HEAP32[$5 + 4 >> 2];
2796 label$14 : {
2797 if (!($2 & 2)) {
2798 if (($5 | 0) == HEAP32[2903]) {
2799 HEAP32[2903] = $0;
2800 $1 = HEAP32[2900] + $1 | 0;
2801 HEAP32[2900] = $1;
2802 HEAP32[$0 + 4 >> 2] = $1 | 1;
2803 if (HEAP32[2902] != ($0 | 0)) {
2804 break label$1
2805 }
2806 HEAP32[2899] = 0;
2807 HEAP32[2902] = 0;
2808 return;
2809 }
2810 if (($5 | 0) == HEAP32[2902]) {
2811 HEAP32[2902] = $0;
2812 $1 = HEAP32[2899] + $1 | 0;
2813 HEAP32[2899] = $1;
2814 HEAP32[$0 + 4 >> 2] = $1 | 1;
2815 HEAP32[$0 + $1 >> 2] = $1;
2816 return;
2817 }
2818 $1 = ($2 & -8) + $1 | 0;
2819 label$18 : {
2820 if ($2 >>> 0 <= 255) {
2821 $4 = $2 >>> 3 | 0;
2822 $2 = HEAP32[$5 + 8 >> 2];
2823 $3 = HEAP32[$5 + 12 >> 2];
2824 if (($2 | 0) == ($3 | 0)) {
2825 (wasm2js_i32$0 = 11588, wasm2js_i32$1 = HEAP32[2897] & __wasm_rotl_i32(-2, $4)), HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
2826 break label$18;
2827 }
2828 HEAP32[$2 + 12 >> 2] = $3;
2829 HEAP32[$3 + 8 >> 2] = $2;
2830 break label$18;
2831 }
2832 $7 = HEAP32[$5 + 24 >> 2];
2833 $2 = HEAP32[$5 + 12 >> 2];
2834 label$21 : {
2835 if (($5 | 0) != ($2 | 0)) {
2836 $3 = HEAP32[$5 + 8 >> 2];
2837 HEAP32[$3 + 12 >> 2] = $2;
2838 HEAP32[$2 + 8 >> 2] = $3;
2839 break label$21;
2840 }
2841 label$24 : {
2842 $3 = $5 + 20 | 0;
2843 $4 = HEAP32[$3 >> 2];
2844 if ($4) {
2845 break label$24
2846 }
2847 $3 = $5 + 16 | 0;
2848 $4 = HEAP32[$3 >> 2];
2849 if ($4) {
2850 break label$24
2851 }
2852 $2 = 0;
2853 break label$21;
2854 }
2855 while (1) {
2856 $6 = $3;
2857 $2 = $4;
2858 $3 = $2 + 20 | 0;
2859 $4 = HEAP32[$3 >> 2];
2860 if ($4) {
2861 continue
2862 }
2863 $3 = $2 + 16 | 0;
2864 $4 = HEAP32[$2 + 16 >> 2];
2865 if ($4) {
2866 continue
2867 }
2868 break;
2869 };
2870 HEAP32[$6 >> 2] = 0;
2871 }
2872 if (!$7) {
2873 break label$18
2874 }
2875 $3 = HEAP32[$5 + 28 >> 2];
2876 $4 = ($3 << 2) + 11892 | 0;
2877 label$26 : {
2878 if (($5 | 0) == HEAP32[$4 >> 2]) {
2879 HEAP32[$4 >> 2] = $2;
2880 if ($2) {
2881 break label$26
2882 }
2883 (wasm2js_i32$0 = 11592, wasm2js_i32$1 = HEAP32[2898] & __wasm_rotl_i32(-2, $3)), HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
2884 break label$18;
2885 }
2886 HEAP32[$7 + (($5 | 0) == HEAP32[$7 + 16 >> 2] ? 16 : 20) >> 2] = $2;
2887 if (!$2) {
2888 break label$18
2889 }
2890 }
2891 HEAP32[$2 + 24 >> 2] = $7;
2892 $3 = HEAP32[$5 + 16 >> 2];
2893 if ($3) {
2894 HEAP32[$2 + 16 >> 2] = $3;
2895 HEAP32[$3 + 24 >> 2] = $2;
2896 }
2897 $3 = HEAP32[$5 + 20 >> 2];
2898 if (!$3) {
2899 break label$18
2900 }
2901 HEAP32[$2 + 20 >> 2] = $3;
2902 HEAP32[$3 + 24 >> 2] = $2;
2903 }
2904 HEAP32[$0 + 4 >> 2] = $1 | 1;
2905 HEAP32[$0 + $1 >> 2] = $1;
2906 if (HEAP32[2902] != ($0 | 0)) {
2907 break label$14
2908 }
2909 HEAP32[2899] = $1;
2910 return;
2911 }
2912 HEAP32[$5 + 4 >> 2] = $2 & -2;
2913 HEAP32[$0 + 4 >> 2] = $1 | 1;
2914 HEAP32[$0 + $1 >> 2] = $1;
2915 }
2916 if ($1 >>> 0 <= 255) {
2917 $2 = $1 >>> 3 | 0;
2918 $1 = ($2 << 3) + 11628 | 0;
2919 $3 = HEAP32[2897];
2920 $2 = 1 << $2;
2921 label$30 : {
2922 if (!($3 & $2)) {
2923 HEAP32[2897] = $2 | $3;
2924 $2 = $1;
2925 break label$30;
2926 }
2927 $2 = HEAP32[$1 + 8 >> 2];
2928 }
2929 HEAP32[$1 + 8 >> 2] = $0;
2930 HEAP32[$2 + 12 >> 2] = $0;
2931 HEAP32[$0 + 12 >> 2] = $1;
2932 HEAP32[$0 + 8 >> 2] = $2;
2933 return;
2934 }
2935 HEAP32[$0 + 16 >> 2] = 0;
2936 HEAP32[$0 + 20 >> 2] = 0;
2937 $3 = $0;
2938 $4 = $1 >>> 8 | 0;
2939 $2 = 0;
2940 label$32 : {
2941 if (!$4) {
2942 break label$32
2943 }
2944 $2 = 31;
2945 if ($1 >>> 0 > 16777215) {
2946 break label$32
2947 }
2948 $6 = $4 + 1048320 >>> 16 & 8;
2949 $4 = $4 << $6;
2950 $2 = $4 + 520192 >>> 16 & 4;
2951 $5 = $4 << $2;
2952 $4 = $5 + 245760 >>> 16 & 2;
2953 $2 = ($5 << $4 >>> 15 | 0) - ($4 | ($2 | $6)) | 0;
2954 $2 = ($2 << 1 | $1 >>> $2 + 21 & 1) + 28 | 0;
2955 }
2956 HEAP32[$3 + 28 >> 2] = $2;
2957 $4 = ($2 << 2) + 11892 | 0;
2958 label$33 : {
2959 $3 = HEAP32[2898];
2960 $6 = 1 << $2;
2961 label$34 : {
2962 if (!($3 & $6)) {
2963 HEAP32[2898] = $3 | $6;
2964 HEAP32[$4 >> 2] = $0;
2965 break label$34;
2966 }
2967 $3 = $1 << (($2 | 0) == 31 ? 0 : 25 - ($2 >>> 1 | 0) | 0);
2968 $2 = HEAP32[$4 >> 2];
2969 while (1) {
2970 $4 = $2;
2971 if ((HEAP32[$2 + 4 >> 2] & -8) == ($1 | 0)) {
2972 break label$33
2973 }
2974 $2 = $3 >>> 29 | 0;
2975 $3 = $3 << 1;
2976 $6 = ($4 + ($2 & 4) | 0) + 16 | 0;
2977 $2 = HEAP32[$6 >> 2];
2978 if ($2) {
2979 continue
2980 }
2981 break;
2982 };
2983 HEAP32[$6 >> 2] = $0;
2984 }
2985 HEAP32[$0 + 24 >> 2] = $4;
2986 HEAP32[$0 + 12 >> 2] = $0;
2987 HEAP32[$0 + 8 >> 2] = $0;
2988 return;
2989 }
2990 $1 = HEAP32[$4 + 8 >> 2];
2991 HEAP32[$1 + 12 >> 2] = $0;
2992 HEAP32[$4 + 8 >> 2] = $0;
2993 HEAP32[$0 + 24 >> 2] = 0;
2994 HEAP32[$0 + 12 >> 2] = $4;
2995 HEAP32[$0 + 8 >> 2] = $1;
2996 }
2997 }
2998
2999 function memchr($0, $1) {
3000 var $2 = 0;
3001 $2 = ($1 | 0) != 0;
3002 label$1 : {
3003 label$2 : {
3004 label$3 : {
3005 if (!$1 | !($0 & 3)) {
3006 break label$3
3007 }
3008 while (1) {
3009 if (HEAPU8[$0 | 0] == 79) {
3010 break label$2
3011 }
3012 $0 = $0 + 1 | 0;
3013 $1 = $1 + -1 | 0;
3014 $2 = ($1 | 0) != 0;
3015 if (!$1) {
3016 break label$3
3017 }
3018 if ($0 & 3) {
3019 continue
3020 }
3021 break;
3022 };
3023 }
3024 if (!$2) {
3025 break label$1
3026 }
3027 }
3028 label$5 : {
3029 if (HEAPU8[$0 | 0] == 79 | $1 >>> 0 < 4) {
3030 break label$5
3031 }
3032 while (1) {
3033 $2 = HEAP32[$0 >> 2] ^ 1330597711;
3034 if (($2 ^ -1) & $2 + -16843009 & -2139062144) {
3035 break label$5
3036 }
3037 $0 = $0 + 4 | 0;
3038 $1 = $1 + -4 | 0;
3039 if ($1 >>> 0 > 3) {
3040 continue
3041 }
3042 break;
3043 };
3044 }
3045 if (!$1) {
3046 break label$1
3047 }
3048 while (1) {
3049 if (HEAPU8[$0 | 0] == 79) {
3050 return $0
3051 }
3052 $0 = $0 + 1 | 0;
3053 $1 = $1 + -1 | 0;
3054 if ($1) {
3055 continue
3056 }
3057 break;
3058 };
3059 }
3060 return 0;
3061 }
3062
3063 function frexp($0, $1) {
3064 var $2 = 0, $3 = 0, $4 = 0;
3065 wasm2js_scratch_store_f64(+$0);
3066 $2 = wasm2js_scratch_load_i32(1) | 0;
3067 $3 = wasm2js_scratch_load_i32(0) | 0;
3068 $4 = $2;
3069 $2 = $2 >>> 20 & 2047;
3070 if (($2 | 0) != 2047) {
3071 if (!$2) {
3072 $2 = $1;
3073 if ($0 == 0.0) {
3074 $1 = 0
3075 } else {
3076 $0 = frexp($0 * 18446744073709551615.0, $1);
3077 $1 = HEAP32[$1 >> 2] + -64 | 0;
3078 }
3079 HEAP32[$2 >> 2] = $1;
3080 return $0;
3081 }
3082 HEAP32[$1 >> 2] = $2 + -1022;
3083 wasm2js_scratch_store_i32(0, $3 | 0);
3084 wasm2js_scratch_store_i32(1, $4 & -2146435073 | 1071644672);
3085 $0 = +wasm2js_scratch_load_f64();
3086 }
3087 return $0;
3088 }
3089
3090 function __ashlti3($0, $1, $2, $3, $4, $5) {
3091 var $6 = 0, $7 = 0, $8 = 0, $9 = 0;
3092 label$1 : {
3093 if ($5 & 64) {
3094 $3 = $1;
3095 $4 = $5 + -64 | 0;
3096 $1 = $4 & 31;
3097 if (32 <= ($4 & 63) >>> 0) {
3098 $4 = $3 << $1;
3099 $3 = 0;
3100 } else {
3101 $4 = (1 << $1) - 1 & $3 >>> 32 - $1 | $2 << $1;
3102 $3 = $3 << $1;
3103 }
3104 $1 = 0;
3105 $2 = 0;
3106 break label$1;
3107 }
3108 if (!$5) {
3109 break label$1
3110 }
3111 $6 = $3;
3112 $8 = $5;
3113 $3 = $5 & 31;
3114 if (32 <= ($5 & 63) >>> 0) {
3115 $7 = $6 << $3;
3116 $9 = 0;
3117 } else {
3118 $7 = (1 << $3) - 1 & $6 >>> 32 - $3 | $4 << $3;
3119 $9 = $6 << $3;
3120 }
3121 $3 = $2;
3122 $6 = $1;
3123 $5 = 64 - $5 | 0;
3124 $4 = $5 & 31;
3125 if (32 <= ($5 & 63) >>> 0) {
3126 $5 = 0;
3127 $3 = $3 >>> $4 | 0;
3128 } else {
3129 $5 = $3 >>> $4 | 0;
3130 $3 = ((1 << $4) - 1 & $3) << 32 - $4 | $6 >>> $4;
3131 }
3132 $3 = $9 | $3;
3133 $4 = $5 | $7;
3134 $5 = $1;
3135 $1 = $8 & 31;
3136 if (32 <= ($8 & 63) >>> 0) {
3137 $7 = $5 << $1;
3138 $1 = 0;
3139 } else {
3140 $7 = (1 << $1) - 1 & $5 >>> 32 - $1 | $2 << $1;
3141 $1 = $5 << $1;
3142 }
3143 $2 = $7;
3144 }
3145 HEAP32[$0 >> 2] = $1;
3146 HEAP32[$0 + 4 >> 2] = $2;
3147 HEAP32[$0 + 8 >> 2] = $3;
3148 HEAP32[$0 + 12 >> 2] = $4;
3149 }
3150
3151 function __lshrti3($0, $1, $2, $3, $4, $5) {
3152 var $6 = 0, $7 = 0, $8 = 0, $9 = 0;
3153 label$1 : {
3154 if ($5 & 64) {
3155 $2 = $5 + -64 | 0;
3156 $1 = $2 & 31;
3157 if (32 <= ($2 & 63) >>> 0) {
3158 $2 = 0;
3159 $1 = $4 >>> $1 | 0;
3160 } else {
3161 $2 = $4 >>> $1 | 0;
3162 $1 = ((1 << $1) - 1 & $4) << 32 - $1 | $3 >>> $1;
3163 }
3164 $3 = 0;
3165 $4 = 0;
3166 break label$1;
3167 }
3168 if (!$5) {
3169 break label$1
3170 }
3171 $7 = $4;
3172 $8 = $3;
3173 $9 = 64 - $5 | 0;
3174 $6 = $9 & 31;
3175 if (32 <= ($9 & 63) >>> 0) {
3176 $7 = $8 << $6;
3177 $9 = 0;
3178 } else {
3179 $7 = (1 << $6) - 1 & $8 >>> 32 - $6 | $7 << $6;
3180 $9 = $8 << $6;
3181 }
3182 $8 = $1;
3183 $6 = $5;
3184 $1 = $6 & 31;
3185 if (32 <= ($6 & 63) >>> 0) {
3186 $6 = 0;
3187 $1 = $2 >>> $1 | 0;
3188 } else {
3189 $6 = $2 >>> $1 | 0;
3190 $1 = ((1 << $1) - 1 & $2) << 32 - $1 | $8 >>> $1;
3191 }
3192 $1 = $9 | $1;
3193 $2 = $6 | $7;
3194 $6 = $3;
3195 $3 = $5 & 31;
3196 if (32 <= ($5 & 63) >>> 0) {
3197 $7 = 0;
3198 $3 = $4 >>> $3 | 0;
3199 } else {
3200 $7 = $4 >>> $3 | 0;
3201 $3 = ((1 << $3) - 1 & $4) << 32 - $3 | $6 >>> $3;
3202 }
3203 $4 = $7;
3204 }
3205 HEAP32[$0 >> 2] = $1;
3206 HEAP32[$0 + 4 >> 2] = $2;
3207 HEAP32[$0 + 8 >> 2] = $3;
3208 HEAP32[$0 + 12 >> 2] = $4;
3209 }
3210
3211 function __trunctfdf2($0, $1, $2, $3) {
3212 var $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0;
3213 $6 = global$0 - 32 | 0;
3214 global$0 = $6;
3215 $4 = $3 & 2147483647;
3216 $8 = $4;
3217 $4 = $4 + -1006698496 | 0;
3218 $7 = $2;
3219 $5 = $2;
3220 if ($2 >>> 0 < 0) {
3221 $4 = $4 + 1 | 0
3222 }
3223 $9 = $5;
3224 $5 = $4;
3225 $4 = $8 + -1140785152 | 0;
3226 $10 = $7;
3227 if ($7 >>> 0 < 0) {
3228 $4 = $4 + 1 | 0
3229 }
3230 label$1 : {
3231 if (($4 | 0) == ($5 | 0) & $9 >>> 0 < $10 >>> 0 | $5 >>> 0 < $4 >>> 0) {
3232 $4 = $3 << 4 | $2 >>> 28;
3233 $2 = $2 << 4 | $1 >>> 28;
3234 $1 = $1 & 268435455;
3235 $7 = $1;
3236 if (($1 | 0) == 134217728 & $0 >>> 0 >= 1 | $1 >>> 0 > 134217728) {
3237 $4 = $4 + 1073741824 | 0;
3238 $0 = $2 + 1 | 0;
3239 if ($0 >>> 0 < 1) {
3240 $4 = $4 + 1 | 0
3241 }
3242 $5 = $0;
3243 break label$1;
3244 }
3245 $5 = $2;
3246 $4 = $4 - (($2 >>> 0 < 0) + -1073741824 | 0) | 0;
3247 if ($0 | $7 ^ 134217728) {
3248 break label$1
3249 }
3250 $0 = $5 + ($5 & 1) | 0;
3251 if ($0 >>> 0 < $5 >>> 0) {
3252 $4 = $4 + 1 | 0
3253 }
3254 $5 = $0;
3255 break label$1;
3256 }
3257 if (!(!$7 & ($8 | 0) == 2147418112 ? !($0 | $1) : ($8 | 0) == 2147418112 & $7 >>> 0 < 0 | $8 >>> 0 < 2147418112)) {
3258 $4 = $3 << 4 | $2 >>> 28;
3259 $5 = $2 << 4 | $1 >>> 28;
3260 $4 = $4 & 524287 | 2146959360;
3261 break label$1;
3262 }
3263 $5 = 0;
3264 $4 = 2146435072;
3265 if ($8 >>> 0 > 1140785151) {
3266 break label$1
3267 }
3268 $4 = 0;
3269 $7 = $8 >>> 16 | 0;
3270 if ($7 >>> 0 < 15249) {
3271 break label$1
3272 }
3273 $4 = $3 & 65535 | 65536;
3274 __ashlti3($6 + 16 | 0, $0, $1, $2, $4, $7 + -15233 | 0);
3275 __lshrti3($6, $0, $1, $2, $4, 15361 - $7 | 0);
3276 $2 = HEAP32[$6 + 4 >> 2];
3277 $0 = HEAP32[$6 + 8 >> 2];
3278 $4 = HEAP32[$6 + 12 >> 2] << 4 | $0 >>> 28;
3279 $5 = $0 << 4 | $2 >>> 28;
3280 $0 = $2 & 268435455;
3281 $2 = $0;
3282 $1 = HEAP32[$6 >> 2] | ((HEAP32[$6 + 16 >> 2] | HEAP32[$6 + 24 >> 2]) != 0 | (HEAP32[$6 + 20 >> 2] | HEAP32[$6 + 28 >> 2]) != 0);
3283 if (($0 | 0) == 134217728 & $1 >>> 0 >= 1 | $0 >>> 0 > 134217728) {
3284 $0 = $5 + 1 | 0;
3285 if ($0 >>> 0 < 1) {
3286 $4 = $4 + 1 | 0
3287 }
3288 $5 = $0;
3289 break label$1;
3290 }
3291 if ($1 | $2 ^ 134217728) {
3292 break label$1
3293 }
3294 $0 = $5 + ($5 & 1) | 0;
3295 if ($0 >>> 0 < $5 >>> 0) {
3296 $4 = $4 + 1 | 0
3297 }
3298 $5 = $0;
3299 }
3300 global$0 = $6 + 32 | 0;
3301 wasm2js_scratch_store_i32(0, $5 | 0);
3302 wasm2js_scratch_store_i32(1, $3 & -2147483648 | $4);
3303 return +wasm2js_scratch_load_f64();
3304 }
3305
3306 function FLAC__crc8($0, $1) {
3307 var $2 = 0;
3308 if ($1) {
3309 while (1) {
3310 $2 = HEAPU8[(HEAPU8[$0 | 0] ^ $2) + 1024 | 0];
3311 $0 = $0 + 1 | 0;
3312 $1 = $1 + -1 | 0;
3313 if ($1) {
3314 continue
3315 }
3316 break;
3317 }
3318 }
3319 return $2;
3320 }
3321
3322 function FLAC__crc16($0, $1) {
3323 var $2 = 0, $3 = 0;
3324 if ($1 >>> 0 > 7) {
3325 while (1) {
3326 $3 = $2;
3327 $2 = HEAPU8[$0 | 0] | HEAPU8[$0 + 1 | 0] << 8;
3328 $2 = $3 ^ ($2 << 8 & 16711680 | $2 << 24) >>> 16;
3329 $2 = HEAPU16[(HEAPU8[$0 + 7 | 0] << 1) + 1280 >> 1] ^ (HEAPU16[((HEAPU8[$0 + 6 | 0] << 1) + 1280 | 0) + 512 >> 1] ^ (HEAPU16[(HEAPU8[$0 + 5 | 0] << 1) + 2304 >> 1] ^ (HEAPU16[(HEAPU8[$0 + 4 | 0] << 1) + 2816 >> 1] ^ (HEAPU16[(HEAPU8[$0 + 3 | 0] << 1) + 3328 >> 1] ^ (HEAPU16[(HEAPU8[$0 + 2 | 0] << 1) + 3840 >> 1] ^ (HEAPU16[(($2 & 255) << 1) + 4352 >> 1] ^ HEAPU16[($2 >>> 7 & 510) + 4864 >> 1]))))));
3330 $0 = $0 + 8 | 0;
3331 $1 = $1 + -8 | 0;
3332 if ($1 >>> 0 > 7) {
3333 continue
3334 }
3335 break;
3336 }
3337 }
3338 if ($1) {
3339 while (1) {
3340 $2 = HEAPU16[((HEAPU8[$0 | 0] ^ ($2 & 65280) >>> 8) << 1) + 1280 >> 1] ^ $2 << 8;
3341 $0 = $0 + 1 | 0;
3342 $1 = $1 + -1 | 0;
3343 if ($1) {
3344 continue
3345 }
3346 break;
3347 }
3348 }
3349 return $2 & 65535;
3350 }
3351
3352 function FLAC__crc16_update_words32($0, $1, $2) {
3353 var $3 = 0;
3354 if ($1 >>> 0 >= 2) {
3355 while (1) {
3356 $3 = $2;
3357 $2 = HEAP32[$0 >> 2];
3358 $3 = $3 ^ $2 >>> 16;
3359 $3 = HEAPU16[(($3 & 255) << 1) + 4352 >> 1] ^ HEAPU16[($3 >>> 7 & 510) + 4864 >> 1] ^ HEAPU16[($2 >>> 7 & 510) + 3840 >> 1] ^ HEAPU16[(($2 & 255) << 1) + 3328 >> 1];
3360 $2 = HEAP32[$0 + 4 >> 2];
3361 $2 = $3 ^ HEAPU16[($2 >>> 23 & 510) + 2816 >> 1] ^ HEAPU16[($2 >>> 15 & 510) + 2304 >> 1] ^ HEAPU16[(($2 >>> 7 & 510) + 1280 | 0) + 512 >> 1] ^ HEAPU16[(($2 & 255) << 1) + 1280 >> 1];
3362 $0 = $0 + 8 | 0;
3363 $1 = $1 + -2 | 0;
3364 if ($1 >>> 0 > 1) {
3365 continue
3366 }
3367 break;
3368 }
3369 }
3370 if ($1) {
3371 $0 = HEAP32[$0 >> 2];
3372 $1 = $0 >>> 16 ^ $2;
3373 $2 = HEAPU16[(($1 & 255) << 1) + 2304 >> 1] ^ HEAPU16[($1 >>> 7 & 510) + 2816 >> 1] ^ HEAPU16[(($0 >>> 7 & 510) + 1280 | 0) + 512 >> 1] ^ HEAPU16[(($0 & 255) << 1) + 1280 >> 1];
3374 }
3375 return $2 & 65535;
3376 }
3377
3378 function memmove($0, $1, $2) {
3379 var $3 = 0;
3380 label$1 : {
3381 if (($0 | 0) == ($1 | 0)) {
3382 break label$1
3383 }
3384 if (($1 - $0 | 0) - $2 >>> 0 <= 0 - ($2 << 1) >>> 0) {
3385 memcpy($0, $1, $2);
3386 return;
3387 }
3388 $3 = ($0 ^ $1) & 3;
3389 label$3 : {
3390 label$4 : {
3391 if ($0 >>> 0 < $1 >>> 0) {
3392 if ($3) {
3393 break label$3
3394 }
3395 if (!($0 & 3)) {
3396 break label$4
3397 }
3398 while (1) {
3399 if (!$2) {
3400 break label$1
3401 }
3402 HEAP8[$0 | 0] = HEAPU8[$1 | 0];
3403 $1 = $1 + 1 | 0;
3404 $2 = $2 + -1 | 0;
3405 $0 = $0 + 1 | 0;
3406 if ($0 & 3) {
3407 continue
3408 }
3409 break;
3410 };
3411 break label$4;
3412 }
3413 label$9 : {
3414 if ($3) {
3415 break label$9
3416 }
3417 if ($0 + $2 & 3) {
3418 while (1) {
3419 if (!$2) {
3420 break label$1
3421 }
3422 $2 = $2 + -1 | 0;
3423 $3 = $2 + $0 | 0;
3424 HEAP8[$3 | 0] = HEAPU8[$1 + $2 | 0];
3425 if ($3 & 3) {
3426 continue
3427 }
3428 break;
3429 }
3430 }
3431 if ($2 >>> 0 <= 3) {
3432 break label$9
3433 }
3434 while (1) {
3435 $2 = $2 + -4 | 0;
3436 HEAP32[$2 + $0 >> 2] = HEAP32[$1 + $2 >> 2];
3437 if ($2 >>> 0 > 3) {
3438 continue
3439 }
3440 break;
3441 };
3442 }
3443 if (!$2) {
3444 break label$1
3445 }
3446 while (1) {
3447 $2 = $2 + -1 | 0;
3448 HEAP8[$2 + $0 | 0] = HEAPU8[$1 + $2 | 0];
3449 if ($2) {
3450 continue
3451 }
3452 break;
3453 };
3454 break label$1;
3455 }
3456 if ($2 >>> 0 <= 3) {
3457 break label$3
3458 }
3459 while (1) {
3460 HEAP32[$0 >> 2] = HEAP32[$1 >> 2];
3461 $1 = $1 + 4 | 0;
3462 $0 = $0 + 4 | 0;
3463 $2 = $2 + -4 | 0;
3464 if ($2 >>> 0 > 3) {
3465 continue
3466 }
3467 break;
3468 };
3469 }
3470 if (!$2) {
3471 break label$1
3472 }
3473 while (1) {
3474 HEAP8[$0 | 0] = HEAPU8[$1 | 0];
3475 $0 = $0 + 1 | 0;
3476 $1 = $1 + 1 | 0;
3477 $2 = $2 + -1 | 0;
3478 if ($2) {
3479 continue
3480 }
3481 break;
3482 };
3483 }
3484 }
3485
3486 function FLAC__bitreader_delete($0) {
3487 var $1 = 0;
3488 $1 = HEAP32[$0 >> 2];
3489 if ($1) {
3490 dlfree($1)
3491 }
3492 dlfree($0);
3493 }
3494
3495 function FLAC__bitreader_free($0) {
3496 var $1 = 0;
3497 $1 = HEAP32[$0 >> 2];
3498 if ($1) {
3499 dlfree($1)
3500 }
3501 HEAP32[$0 + 36 >> 2] = 0;
3502 HEAP32[$0 + 40 >> 2] = 0;
3503 HEAP32[$0 >> 2] = 0;
3504 HEAP32[$0 + 4 >> 2] = 0;
3505 HEAP32[$0 + 8 >> 2] = 0;
3506 HEAP32[$0 + 12 >> 2] = 0;
3507 HEAP32[$0 + 16 >> 2] = 0;
3508 HEAP32[$0 + 20 >> 2] = 0;
3509 }
3510
3511 function FLAC__bitreader_init($0, $1) {
3512 var $2 = 0;
3513 HEAP32[$0 + 8 >> 2] = 0;
3514 HEAP32[$0 + 12 >> 2] = 0;
3515 HEAP32[$0 + 4 >> 2] = 2048;
3516 HEAP32[$0 + 16 >> 2] = 0;
3517 HEAP32[$0 + 20 >> 2] = 0;
3518 $2 = dlmalloc(8192);
3519 HEAP32[$0 >> 2] = $2;
3520 if (!$2) {
3521 return 0
3522 }
3523 HEAP32[$0 + 40 >> 2] = $1;
3524 HEAP32[$0 + 36 >> 2] = 7;
3525 return 1;
3526 }
3527
3528 function FLAC__bitreader_get_read_crc16($0) {
3529 var $1 = 0, $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0;
3530 $5 = HEAP32[$0 + 16 >> 2];
3531 $2 = HEAP32[$0 + 28 >> 2];
3532 label$1 : {
3533 if ($5 >>> 0 <= $2 >>> 0) {
3534 $4 = $2;
3535 break label$1;
3536 }
3537 $1 = HEAP32[$0 + 32 >> 2];
3538 if (!$1) {
3539 $4 = $2;
3540 break label$1;
3541 }
3542 $4 = $2 + 1 | 0;
3543 HEAP32[$0 + 28 >> 2] = $4;
3544 $3 = HEAP32[$0 + 24 >> 2];
3545 if ($1 >>> 0 <= 31) {
3546 $2 = HEAP32[HEAP32[$0 >> 2] + ($2 << 2) >> 2];
3547 while (1) {
3548 $3 = HEAPU16[(($2 >>> 24 - $1 & 255 ^ $3 >>> 8) << 1) + 1280 >> 1] ^ $3 << 8 & 65280;
3549 $7 = $1 >>> 0 < 24;
3550 $6 = $1 + 8 | 0;
3551 $1 = $6;
3552 if ($7) {
3553 continue
3554 }
3555 break;
3556 };
3557 HEAP32[$0 + 32 >> 2] = $6;
3558 }
3559 HEAP32[$0 + 32 >> 2] = 0;
3560 HEAP32[$0 + 24 >> 2] = $3;
3561 }
3562 $1 = FLAC__crc16_update_words32(HEAP32[$0 >> 2] + ($4 << 2) | 0, $5 - $4 | 0, HEAPU16[$0 + 24 >> 1]);
3563 HEAP32[$0 + 28 >> 2] = 0;
3564 HEAP32[$0 + 24 >> 2] = $1;
3565 $2 = HEAP32[$0 + 20 >> 2];
3566 label$6 : {
3567 if (!$2) {
3568 break label$6
3569 }
3570 $3 = HEAP32[$0 + 32 >> 2];
3571 if ($3 >>> 0 >= $2 >>> 0) {
3572 break label$6
3573 }
3574 $4 = HEAP32[HEAP32[$0 >> 2] + (HEAP32[$0 + 16 >> 2] << 2) >> 2];
3575 while (1) {
3576 $1 = HEAPU16[(($4 >>> 24 - $3 & 255 ^ $1 >>> 8) << 1) + 1280 >> 1] ^ $1 << 8 & 65280;
3577 $3 = $3 + 8 | 0;
3578 if ($3 >>> 0 < $2 >>> 0) {
3579 continue
3580 }
3581 break;
3582 };
3583 HEAP32[$0 + 32 >> 2] = $3;
3584 HEAP32[$0 + 24 >> 2] = $1;
3585 }
3586 return $1;
3587 }
3588
3589 function FLAC__bitreader_is_consumed_byte_aligned($0) {
3590 return !(HEAPU8[$0 + 20 | 0] & 7);
3591 }
3592
3593 function FLAC__bitreader_bits_left_for_byte_alignment($0) {
3594 return 8 - (HEAP32[$0 + 20 >> 2] & 7) | 0;
3595 }
3596
3597 function FLAC__bitreader_read_raw_uint32($0, $1, $2) {
3598 var $3 = 0, $4 = 0, $5 = 0;
3599 label$1 : {
3600 if ($2) {
3601 label$4 : {
3602 while (1) {
3603 $5 = HEAP32[$0 + 8 >> 2];
3604 $4 = HEAP32[$0 + 16 >> 2];
3605 $3 = HEAP32[$0 + 20 >> 2];
3606 if ((($5 - $4 << 5) + (HEAP32[$0 + 12 >> 2] << 3) | 0) - $3 >>> 0 >= $2 >>> 0) {
3607 break label$4
3608 }
3609 if (bitreader_read_from_client_($0)) {
3610 continue
3611 }
3612 break;
3613 };
3614 return 0;
3615 }
3616 if ($5 >>> 0 > $4 >>> 0) {
3617 if ($3) {
3618 $5 = HEAP32[$0 >> 2];
3619 $4 = HEAP32[$5 + ($4 << 2) >> 2] & -1 >>> $3;
3620 $3 = 32 - $3 | 0;
3621 if ($3 >>> 0 > $2 >>> 0) {
3622 HEAP32[$1 >> 2] = $4 >>> $3 - $2;
3623 HEAP32[$0 + 20 >> 2] = HEAP32[$0 + 20 >> 2] + $2;
3624 break label$1;
3625 }
3626 HEAP32[$1 >> 2] = $4;
3627 HEAP32[$0 + 20 >> 2] = 0;
3628 HEAP32[$0 + 16 >> 2] = HEAP32[$0 + 16 >> 2] + 1;
3629 $2 = $2 - $3 | 0;
3630 if (!$2) {
3631 break label$1
3632 }
3633 $3 = HEAP32[$1 >> 2] << $2;
3634 HEAP32[$1 >> 2] = $3;
3635 HEAP32[$1 >> 2] = $3 | HEAP32[(HEAP32[$0 + 16 >> 2] << 2) + $5 >> 2] >>> 32 - $2;
3636 HEAP32[$0 + 20 >> 2] = $2;
3637 return 1;
3638 }
3639 $3 = HEAP32[HEAP32[$0 >> 2] + ($4 << 2) >> 2];
3640 if ($2 >>> 0 <= 31) {
3641 HEAP32[$1 >> 2] = $3 >>> 32 - $2;
3642 HEAP32[$0 + 20 >> 2] = $2;
3643 break label$1;
3644 }
3645 HEAP32[$1 >> 2] = $3;
3646 HEAP32[$0 + 16 >> 2] = HEAP32[$0 + 16 >> 2] + 1;
3647 return 1;
3648 }
3649 $4 = HEAP32[HEAP32[$0 >> 2] + ($4 << 2) >> 2];
3650 if ($3) {
3651 HEAP32[$1 >> 2] = ($4 & -1 >>> $3) >>> 32 - ($2 + $3 | 0);
3652 HEAP32[$0 + 20 >> 2] = HEAP32[$0 + 20 >> 2] + $2;
3653 break label$1;
3654 }
3655 HEAP32[$1 >> 2] = $4 >>> 32 - $2;
3656 HEAP32[$0 + 20 >> 2] = HEAP32[$0 + 20 >> 2] + $2;
3657 break label$1;
3658 }
3659 HEAP32[$1 >> 2] = 0;
3660 }
3661 return 1;
3662 }
3663
3664 function bitreader_read_from_client_($0) {
3665 var $1 = 0, $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0;
3666 $6 = global$0 - 16 | 0;
3667 global$0 = $6;
3668 $5 = HEAP32[$0 + 16 >> 2];
3669 label$1 : {
3670 if (!$5) {
3671 $2 = HEAP32[$0 + 8 >> 2];
3672 break label$1;
3673 }
3674 $1 = HEAP32[$0 + 28 >> 2];
3675 label$3 : {
3676 if ($5 >>> 0 <= $1 >>> 0) {
3677 $3 = $1;
3678 break label$3;
3679 }
3680 $2 = HEAP32[$0 + 32 >> 2];
3681 if (!$2) {
3682 $3 = $1;
3683 break label$3;
3684 }
3685 $3 = $1 + 1 | 0;
3686 HEAP32[$0 + 28 >> 2] = $3;
3687 $4 = HEAP32[$0 + 24 >> 2];
3688 if ($2 >>> 0 <= 31) {
3689 $1 = HEAP32[HEAP32[$0 >> 2] + ($1 << 2) >> 2];
3690 while (1) {
3691 $4 = HEAPU16[(($1 >>> 24 - $2 & 255 ^ $4 >>> 8) << 1) + 1280 >> 1] ^ $4 << 8 & 65280;
3692 $7 = $2 >>> 0 < 24;
3693 $8 = $2 + 8 | 0;
3694 $2 = $8;
3695 if ($7) {
3696 continue
3697 }
3698 break;
3699 };
3700 HEAP32[$0 + 32 >> 2] = $8;
3701 }
3702 HEAP32[$0 + 32 >> 2] = 0;
3703 HEAP32[$0 + 24 >> 2] = $4;
3704 }
3705 $1 = FLAC__crc16_update_words32(HEAP32[$0 >> 2] + ($3 << 2) | 0, $5 - $3 | 0, HEAPU16[$0 + 24 >> 1]);
3706 HEAP32[$0 + 28 >> 2] = 0;
3707 HEAP32[$0 + 24 >> 2] = $1;
3708 $3 = HEAP32[$0 >> 2];
3709 $1 = HEAP32[$0 + 16 >> 2];
3710 memmove($3, $3 + ($1 << 2) | 0, (HEAP32[$0 + 8 >> 2] - $1 | 0) + (HEAP32[$0 + 12 >> 2] != 0) << 2);
3711 HEAP32[$0 + 16 >> 2] = 0;
3712 $2 = HEAP32[$0 + 8 >> 2] - $1 | 0;
3713 HEAP32[$0 + 8 >> 2] = $2;
3714 }
3715 $1 = HEAP32[$0 + 12 >> 2];
3716 $3 = (HEAP32[$0 + 4 >> 2] - $2 << 2) - $1 | 0;
3717 HEAP32[$6 + 12 >> 2] = $3;
3718 $4 = 0;
3719 label$8 : {
3720 if (!$3) {
3721 break label$8
3722 }
3723 $3 = HEAP32[$0 >> 2] + ($2 << 2) | 0;
3724 $2 = $3 + $1 | 0;
3725 if ($1) {
3726 $1 = HEAP32[$3 >> 2];
3727 HEAP32[$3 >> 2] = $1 << 24 | $1 << 8 & 16711680 | ($1 >>> 8 & 65280 | $1 >>> 24);
3728 }
3729 if (!FUNCTION_TABLE[HEAP32[$0 + 36 >> 2]]($2, $6 + 12 | 0, HEAP32[$0 + 40 >> 2])) {
3730 break label$8
3731 }
3732 $5 = HEAP32[$6 + 12 >> 2];
3733 $2 = HEAP32[$0 + 12 >> 2];
3734 $4 = HEAP32[$0 + 8 >> 2];
3735 $1 = $4 << 2;
3736 $3 = ($5 + ($2 + $1 | 0) | 0) + 3 >>> 2 | 0;
3737 $8 = $0;
3738 if ($4 >>> 0 < $3 >>> 0) {
3739 $2 = HEAP32[$0 >> 2];
3740 while (1) {
3741 $7 = $2 + ($4 << 2) | 0;
3742 $1 = HEAP32[$7 >> 2];
3743 HEAP32[$7 >> 2] = $1 << 8 & 16711680 | $1 << 24 | ($1 >>> 8 & 65280 | $1 >>> 24);
3744 $4 = $4 + 1 | 0;
3745 if (($3 | 0) != ($4 | 0)) {
3746 continue
3747 }
3748 break;
3749 };
3750 $2 = HEAP32[$0 + 12 >> 2];
3751 $1 = HEAP32[$0 + 8 >> 2] << 2;
3752 }
3753 $1 = $1 + ($2 + $5 | 0) | 0;
3754 HEAP32[$8 + 12 >> 2] = $1 & 3;
3755 HEAP32[$0 + 8 >> 2] = $1 >>> 2;
3756 $4 = 1;
3757 }
3758 global$0 = $6 + 16 | 0;
3759 return $4;
3760 }
3761
3762 function FLAC__bitreader_read_raw_int32($0, $1, $2) {
3763 var $3 = 0, $4 = 0;
3764 $3 = global$0 - 16 | 0;
3765 global$0 = $3;
3766 $4 = 0;
3767 label$1 : {
3768 if (!FLAC__bitreader_read_raw_uint32($0, $3 + 12 | 0, $2)) {
3769 break label$1
3770 }
3771 $0 = 1 << $2 + -1;
3772 HEAP32[$1 >> 2] = ($0 ^ HEAP32[$3 + 12 >> 2]) - $0;
3773 $4 = 1;
3774 }
3775 $0 = $4;
3776 global$0 = $3 + 16 | 0;
3777 return $0;
3778 }
3779
3780 function FLAC__bitreader_read_raw_uint64($0, $1, $2) {
3781 var $3 = 0, $4 = 0, $5 = 0, $6 = 0;
3782 $3 = global$0 - 16 | 0;
3783 global$0 = $3;
3784 $4 = $1;
3785 $5 = $1;
3786 label$1 : {
3787 label$2 : {
3788 if ($2 >>> 0 >= 33) {
3789 if (!FLAC__bitreader_read_raw_uint32($0, $3 + 12 | 0, $2 + -32 | 0)) {
3790 break label$1
3791 }
3792 if (!FLAC__bitreader_read_raw_uint32($0, $3 + 8 | 0, 32)) {
3793 break label$1
3794 }
3795 $0 = HEAP32[$3 + 12 >> 2];
3796 $2 = 0;
3797 HEAP32[$1 >> 2] = $2;
3798 HEAP32[$1 + 4 >> 2] = $0;
3799 $1 = HEAP32[$3 + 8 >> 2] | $2;
3800 break label$2;
3801 }
3802 if (!FLAC__bitreader_read_raw_uint32($0, $3 + 8 | 0, $2)) {
3803 break label$1
3804 }
3805 $0 = 0;
3806 $1 = HEAP32[$3 + 8 >> 2];
3807 }
3808 HEAP32[$5 >> 2] = $1;
3809 HEAP32[$4 + 4 >> 2] = $0;
3810 $6 = 1;
3811 }
3812 global$0 = $3 + 16 | 0;
3813 return $6;
3814 }
3815
3816 function FLAC__bitreader_read_uint32_little_endian($0, $1) {
3817 var $2 = 0, $3 = 0, $4 = 0;
3818 $2 = global$0 - 16 | 0;
3819 global$0 = $2;
3820 HEAP32[$2 + 8 >> 2] = 0;
3821 label$1 : {
3822 if (!FLAC__bitreader_read_raw_uint32($0, $2 + 8 | 0, 8)) {
3823 break label$1
3824 }
3825 if (!FLAC__bitreader_read_raw_uint32($0, $2 + 12 | 0, 8)) {
3826 break label$1
3827 }
3828 $3 = HEAP32[$2 + 8 >> 2] | HEAP32[$2 + 12 >> 2] << 8;
3829 HEAP32[$2 + 8 >> 2] = $3;
3830 if (!FLAC__bitreader_read_raw_uint32($0, $2 + 12 | 0, 8)) {
3831 break label$1
3832 }
3833 $3 = $3 | HEAP32[$2 + 12 >> 2] << 16;
3834 HEAP32[$2 + 8 >> 2] = $3;
3835 if (!FLAC__bitreader_read_raw_uint32($0, $2 + 12 | 0, 8)) {
3836 break label$1
3837 }
3838 $0 = $3 | HEAP32[$2 + 12 >> 2] << 24;
3839 HEAP32[$2 + 8 >> 2] = $0;
3840 HEAP32[$1 >> 2] = $0;
3841 $4 = 1;
3842 }
3843 global$0 = $2 + 16 | 0;
3844 return $4;
3845 }
3846
3847 function FLAC__bitreader_skip_bits_no_crc($0, $1) {
3848 var $2 = 0, $3 = 0, $4 = 0, $5 = 0;
3849 $3 = global$0 - 16 | 0;
3850 global$0 = $3;
3851 $4 = 1;
3852 label$1 : {
3853 if (!$1) {
3854 break label$1
3855 }
3856 $2 = HEAP32[$0 + 20 >> 2] & 7;
3857 label$2 : {
3858 if ($2) {
3859 $2 = 8 - $2 | 0;
3860 $2 = $2 >>> 0 < $1 >>> 0 ? $2 : $1;
3861 if (!FLAC__bitreader_read_raw_uint32($0, $3 + 8 | 0, $2)) {
3862 break label$2
3863 }
3864 $1 = $1 - $2 | 0;
3865 }
3866 $2 = $1 >>> 3 | 0;
3867 if ($2) {
3868 while (1) {
3869 label$7 : {
3870 if (!HEAP32[$0 + 20 >> 2]) {
3871 if ($2 >>> 0 > 3) {
3872 while (1) {
3873 $5 = HEAP32[$0 + 16 >> 2];
3874 label$11 : {
3875 if ($5 >>> 0 < HEAPU32[$0 + 8 >> 2]) {
3876 HEAP32[$0 + 16 >> 2] = $5 + 1;
3877 $2 = $2 + -4 | 0;
3878 break label$11;
3879 }
3880 if (!bitreader_read_from_client_($0)) {
3881 break label$2
3882 }
3883 }
3884 if ($2 >>> 0 > 3) {
3885 continue
3886 }
3887 break;
3888 };
3889 if (!$2) {
3890 break label$7
3891 }
3892 }
3893 while (1) {
3894 if (!FLAC__bitreader_read_raw_uint32($0, $3 + 12 | 0, 8)) {
3895 break label$2
3896 }
3897 $2 = $2 + -1 | 0;
3898 if ($2) {
3899 continue
3900 }
3901 break;
3902 };
3903 break label$7;
3904 }
3905 if (!FLAC__bitreader_read_raw_uint32($0, $3 + 12 | 0, 8)) {
3906 break label$2
3907 }
3908 $2 = $2 + -1 | 0;
3909 if ($2) {
3910 continue
3911 }
3912 }
3913 break;
3914 };
3915 $1 = $1 & 7;
3916 }
3917 if (!$1) {
3918 break label$1
3919 }
3920 if (FLAC__bitreader_read_raw_uint32($0, $3 + 8 | 0, $1)) {
3921 break label$1
3922 }
3923 }
3924 $4 = 0;
3925 }
3926 global$0 = $3 + 16 | 0;
3927 return $4;
3928 }
3929
3930 function FLAC__bitreader_skip_byte_block_aligned_no_crc($0, $1) {
3931 var $2 = 0, $3 = 0, $4 = 0;
3932 $2 = global$0 - 16 | 0;
3933 global$0 = $2;
3934 $3 = 1;
3935 label$1 : {
3936 if (!$1) {
3937 break label$1
3938 }
3939 while (1) {
3940 label$3 : {
3941 if (!HEAP32[$0 + 20 >> 2]) {
3942 label$5 : {
3943 if ($1 >>> 0 < 4) {
3944 break label$5
3945 }
3946 while (1) {
3947 $4 = HEAP32[$0 + 16 >> 2];
3948 label$7 : {
3949 if ($4 >>> 0 < HEAPU32[$0 + 8 >> 2]) {
3950 HEAP32[$0 + 16 >> 2] = $4 + 1;
3951 $1 = $1 + -4 | 0;
3952 break label$7;
3953 }
3954 if (!bitreader_read_from_client_($0)) {
3955 break label$3
3956 }
3957 }
3958 if ($1 >>> 0 > 3) {
3959 continue
3960 }
3961 break;
3962 };
3963 if ($1) {
3964 break label$5
3965 }
3966 break label$1;
3967 }
3968 while (1) {
3969 if (!FLAC__bitreader_read_raw_uint32($0, $2 + 12 | 0, 8)) {
3970 break label$3
3971 }
3972 $1 = $1 + -1 | 0;
3973 if ($1) {
3974 continue
3975 }
3976 break;
3977 };
3978 break label$1;
3979 }
3980 if (!FLAC__bitreader_read_raw_uint32($0, $2 + 12 | 0, 8)) {
3981 break label$3
3982 }
3983 $1 = $1 + -1 | 0;
3984 if ($1) {
3985 continue
3986 }
3987 break label$1;
3988 }
3989 break;
3990 };
3991 $3 = 0;
3992 }
3993 global$0 = $2 + 16 | 0;
3994 return $3;
3995 }
3996
3997 function FLAC__bitreader_read_byte_block_aligned_no_crc($0, $1, $2) {
3998 var $3 = 0, $4 = 0;
3999 $4 = global$0 - 16 | 0;
4000 global$0 = $4;
4001 label$1 : {
4002 if (!$2) {
4003 $3 = 1;
4004 break label$1;
4005 }
4006 while (1) {
4007 if (!HEAP32[$0 + 20 >> 2]) {
4008 label$5 : {
4009 if ($2 >>> 0 < 4) {
4010 break label$5
4011 }
4012 while (1) {
4013 label$7 : {
4014 $3 = HEAP32[$0 + 16 >> 2];
4015 if ($3 >>> 0 < HEAPU32[$0 + 8 >> 2]) {
4016 HEAP32[$0 + 16 >> 2] = $3 + 1;
4017 $3 = HEAP32[HEAP32[$0 >> 2] + ($3 << 2) >> 2];
4018 $3 = $3 << 24 | $3 << 8 & 16711680 | ($3 >>> 8 & 65280 | $3 >>> 24);
4019 HEAP8[$1 | 0] = $3;
4020 HEAP8[$1 + 1 | 0] = $3 >>> 8;
4021 HEAP8[$1 + 2 | 0] = $3 >>> 16;
4022 HEAP8[$1 + 3 | 0] = $3 >>> 24;
4023 $2 = $2 + -4 | 0;
4024 $1 = $1 + 4 | 0;
4025 break label$7;
4026 }
4027 if (bitreader_read_from_client_($0)) {
4028 break label$7
4029 }
4030 $3 = 0;
4031 break label$1;
4032 }
4033 if ($2 >>> 0 > 3) {
4034 continue
4035 }
4036 break;
4037 };
4038 if ($2) {
4039 break label$5
4040 }
4041 $3 = 1;
4042 break label$1;
4043 }
4044 while (1) {
4045 if (!FLAC__bitreader_read_raw_uint32($0, $4 + 12 | 0, 8)) {
4046 $3 = 0;
4047 break label$1;
4048 }
4049 HEAP8[$1 | 0] = HEAP32[$4 + 12 >> 2];
4050 $3 = 1;
4051 $1 = $1 + 1 | 0;
4052 $2 = $2 + -1 | 0;
4053 if ($2) {
4054 continue
4055 }
4056 break;
4057 };
4058 break label$1;
4059 }
4060 if (!FLAC__bitreader_read_raw_uint32($0, $4 + 12 | 0, 8)) {
4061 $3 = 0;
4062 break label$1;
4063 }
4064 HEAP8[$1 | 0] = HEAP32[$4 + 12 >> 2];
4065 $3 = 1;
4066 $1 = $1 + 1 | 0;
4067 $2 = $2 + -1 | 0;
4068 if ($2) {
4069 continue
4070 }
4071 break;
4072 };
4073 }
4074 global$0 = $4 + 16 | 0;
4075 return $3;
4076 }
4077
4078 function FLAC__bitreader_read_unary_unsigned($0, $1) {
4079 var $2 = 0, $3 = 0, $4 = 0;
4080 HEAP32[$1 >> 2] = 0;
4081 label$1 : {
4082 while (1) {
4083 $3 = HEAP32[$0 + 16 >> 2];
4084 label$3 : {
4085 if ($3 >>> 0 >= HEAPU32[$0 + 8 >> 2]) {
4086 $2 = HEAP32[$0 + 20 >> 2];
4087 break label$3;
4088 }
4089 $2 = HEAP32[$0 + 20 >> 2];
4090 $4 = HEAP32[$0 >> 2];
4091 while (1) {
4092 $3 = HEAP32[$4 + ($3 << 2) >> 2] << $2;
4093 if ($3) {
4094 $2 = $1;
4095 $4 = HEAP32[$1 >> 2];
4096 $1 = Math_clz32($3);
4097 HEAP32[$2 >> 2] = $4 + $1;
4098 $2 = ($1 + HEAP32[$0 + 20 >> 2] | 0) + 1 | 0;
4099 HEAP32[$0 + 20 >> 2] = $2;
4100 $1 = 1;
4101 if ($2 >>> 0 < 32) {
4102 break label$1
4103 }
4104 HEAP32[$0 + 20 >> 2] = 0;
4105 HEAP32[$0 + 16 >> 2] = HEAP32[$0 + 16 >> 2] + 1;
4106 return 1;
4107 }
4108 HEAP32[$1 >> 2] = (HEAP32[$1 >> 2] - $2 | 0) + 32;
4109 $2 = 0;
4110 HEAP32[$0 + 20 >> 2] = 0;
4111 $3 = HEAP32[$0 + 16 >> 2] + 1 | 0;
4112 HEAP32[$0 + 16 >> 2] = $3;
4113 if ($3 >>> 0 < HEAPU32[$0 + 8 >> 2]) {
4114 continue
4115 }
4116 break;
4117 };
4118 }
4119 $4 = HEAP32[$0 + 12 >> 2] << 3;
4120 if ($4 >>> 0 > $2 >>> 0) {
4121 $3 = (HEAP32[HEAP32[$0 >> 2] + ($3 << 2) >> 2] & -1 << 32 - $4) << $2;
4122 if ($3) {
4123 $2 = $1;
4124 $4 = HEAP32[$1 >> 2];
4125 $1 = Math_clz32($3);
4126 HEAP32[$2 >> 2] = $4 + $1;
4127 HEAP32[$0 + 20 >> 2] = ($1 + HEAP32[$0 + 20 >> 2] | 0) + 1;
4128 return 1;
4129 }
4130 HEAP32[$1 >> 2] = HEAP32[$1 >> 2] + ($4 - $2 | 0);
4131 HEAP32[$0 + 20 >> 2] = $4;
4132 }
4133 if (bitreader_read_from_client_($0)) {
4134 continue
4135 }
4136 break;
4137 };
4138 $1 = 0;
4139 }
4140 return $1;
4141 }
4142
4143 function FLAC__bitreader_read_rice_signed_block($0, $1, $2, $3) {
4144 var $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0;
4145 $6 = global$0 - 16 | 0;
4146 global$0 = $6;
4147 $12 = ($2 << 2) + $1 | 0;
4148 label$1 : {
4149 if (!$3) {
4150 $14 = 1;
4151 if (($2 | 0) < 1) {
4152 break label$1
4153 }
4154 while (1) {
4155 if (!FLAC__bitreader_read_unary_unsigned($0, $6 + 8 | 0)) {
4156 $14 = 0;
4157 break label$1;
4158 }
4159 $2 = HEAP32[$6 + 8 >> 2];
4160 HEAP32[$1 >> 2] = $2 >>> 1 ^ 0 - ($2 & 1);
4161 $1 = $1 + 4 | 0;
4162 if ($1 >>> 0 < $12 >>> 0) {
4163 continue
4164 }
4165 break;
4166 };
4167 break label$1;
4168 }
4169 label$5 : {
4170 label$6 : {
4171 $4 = HEAP32[$0 + 16 >> 2];
4172 $10 = HEAP32[$0 + 8 >> 2];
4173 if ($4 >>> 0 >= $10 >>> 0) {
4174 break label$6
4175 }
4176 $11 = HEAP32[$0 >> 2];
4177 $13 = HEAP32[$0 + 20 >> 2];
4178 $9 = HEAP32[$11 + ($4 << 2) >> 2] << $13;
4179 $2 = 0;
4180 break label$5;
4181 }
4182 $2 = 1;
4183 }
4184 while (1) {
4185 label$9 : {
4186 label$10 : {
4187 label$11 : {
4188 label$12 : {
4189 if (!$2) {
4190 $5 = 32 - $13 | 0;
4191 label$14 : {
4192 if ($1 >>> 0 < $12 >>> 0) {
4193 $15 = 32 - $3 | 0;
4194 while (1) {
4195 $2 = $4;
4196 $7 = $5;
4197 label$17 : {
4198 if ($9) {
4199 $7 = Math_clz32($9);
4200 $8 = $7;
4201 break label$17;
4202 }
4203 while (1) {
4204 $2 = $2 + 1 | 0;
4205 if ($2 >>> 0 >= $10 >>> 0) {
4206 break label$14
4207 }
4208 $9 = HEAP32[($2 << 2) + $11 >> 2];
4209 $8 = Math_clz32($9);
4210 $7 = $8 + $7 | 0;
4211 if (!$9) {
4212 continue
4213 }
4214 break;
4215 };
4216 }
4217 $4 = $9 << $8 << 1;
4218 $8 = $4 >>> $15 | 0;
4219 HEAP32[$6 + 8 >> 2] = $7;
4220 $5 = ($7 ^ -1) + $5 & 31;
4221 label$20 : {
4222 if ($5 >>> 0 >= $3 >>> 0) {
4223 $9 = $4 << $3;
4224 $5 = $5 - $3 | 0;
4225 $4 = $2;
4226 break label$20;
4227 }
4228 $4 = $2 + 1 | 0;
4229 if ($4 >>> 0 >= $10 >>> 0) {
4230 break label$12
4231 }
4232 $2 = HEAP32[($4 << 2) + $11 >> 2];
4233 $5 = $5 + $15 | 0;
4234 $9 = $2 << 32 - $5;
4235 $8 = $2 >>> $5 | $8;
4236 }
4237 HEAP32[$6 + 12 >> 2] = $8;
4238 $2 = $7 << $3 | $8;
4239 HEAP32[$1 >> 2] = $2 >>> 1 ^ 0 - ($2 & 1);
4240 $1 = $1 + 4 | 0;
4241 if ($1 >>> 0 < $12 >>> 0) {
4242 continue
4243 }
4244 break;
4245 };
4246 }
4247 $1 = $4 >>> 0 < $10 >>> 0;
4248 HEAP32[$0 + 16 >> 2] = ($1 & !$5) + $4;
4249 HEAP32[$0 + 20 >> 2] = 32 - ($5 ? $5 : $1 << 5);
4250 $14 = 1;
4251 break label$1;
4252 }
4253 HEAP32[$0 + 20 >> 2] = 0;
4254 $2 = $4 + 1 | 0;
4255 HEAP32[$0 + 16 >> 2] = $10 >>> 0 > $2 >>> 0 ? $10 : $2;
4256 break label$10;
4257 }
4258 if (!FLAC__bitreader_read_unary_unsigned($0, $6 + 8 | 0)) {
4259 break label$1
4260 }
4261 $7 = HEAP32[$6 + 8 >> 2] + $7 | 0;
4262 HEAP32[$6 + 8 >> 2] = $7;
4263 $8 = 0;
4264 $5 = 0;
4265 break label$11;
4266 }
4267 HEAP32[$0 + 16 >> 2] = $4;
4268 HEAP32[$0 + 20 >> 2] = 0;
4269 }
4270 if (!FLAC__bitreader_read_raw_uint32($0, $6 + 12 | 0, $3 - $5 | 0)) {
4271 break label$1
4272 }
4273 $2 = $7 << $3;
4274 $4 = HEAP32[$6 + 12 >> 2] | $8;
4275 HEAP32[$6 + 12 >> 2] = $4;
4276 $7 = 0;
4277 $2 = $2 | $4;
4278 HEAP32[$1 >> 2] = $2 >>> 1 ^ 0 - ($2 & 1);
4279 $11 = HEAP32[$0 >> 2];
4280 $4 = HEAP32[$0 + 16 >> 2];
4281 $13 = HEAP32[$0 + 20 >> 2];
4282 $9 = HEAP32[$11 + ($4 << 2) >> 2] << $13;
4283 $10 = HEAP32[$0 + 8 >> 2];
4284 $1 = $1 + 4 | 0;
4285 if ($4 >>> 0 < $10 >>> 0 | $1 >>> 0 >= $12 >>> 0) {
4286 break label$9
4287 }
4288 }
4289 $2 = 1;
4290 continue;
4291 }
4292 $2 = 0;
4293 continue;
4294 };
4295 }
4296 global$0 = $6 + 16 | 0;
4297 return $14;
4298 }
4299
4300 function FLAC__bitreader_read_utf8_uint32($0, $1, $2, $3) {
4301 var $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0;
4302 $7 = global$0 - 16 | 0;
4303 global$0 = $7;
4304 label$1 : {
4305 if (!FLAC__bitreader_read_raw_uint32($0, $7 + 12 | 0, 8)) {
4306 break label$1
4307 }
4308 $4 = HEAP32[$7 + 12 >> 2];
4309 if ($2) {
4310 $5 = HEAP32[$3 >> 2];
4311 HEAP32[$3 >> 2] = $5 + 1;
4312 HEAP8[$2 + $5 | 0] = $4;
4313 }
4314 label$3 : {
4315 label$4 : {
4316 label$5 : {
4317 label$6 : {
4318 if (!($4 & 128)) {
4319 break label$6
4320 }
4321 label$7 : {
4322 if (!(!($4 & 192) | $4 & 32)) {
4323 $6 = 31;
4324 $5 = 1;
4325 break label$7;
4326 }
4327 if (!(!($4 & 224) | $4 & 16)) {
4328 $6 = 15;
4329 $5 = 2;
4330 break label$7;
4331 }
4332 if (!(!($4 & 240) | $4 & 8)) {
4333 $6 = 7;
4334 $5 = 3;
4335 break label$7;
4336 }
4337 if ($4 & 248) {
4338 $6 = 3;
4339 $5 = 4;
4340 if (!($4 & 4)) {
4341 break label$7
4342 }
4343 }
4344 if (!($4 & 252) | $4 & 2) {
4345 break label$5
4346 }
4347 $6 = 1;
4348 $5 = 5;
4349 }
4350 $4 = $4 & $6;
4351 if (!$2) {
4352 while (1) {
4353 if (!FLAC__bitreader_read_raw_uint32($0, $7 + 12 | 0, 8)) {
4354 break label$1
4355 }
4356 $2 = HEAP32[$7 + 12 >> 2];
4357 if (($2 & 192) != 128) {
4358 break label$4
4359 }
4360 $4 = $2 & 63 | $4 << 6;
4361 $5 = $5 + -1 | 0;
4362 if ($5) {
4363 continue
4364 }
4365 break label$6;
4366 }
4367 }
4368 while (1) {
4369 if (!FLAC__bitreader_read_raw_uint32($0, $7 + 12 | 0, 8)) {
4370 break label$1
4371 }
4372 $6 = HEAP32[$7 + 12 >> 2];
4373 $8 = HEAP32[$3 >> 2];
4374 HEAP32[$3 >> 2] = $8 + 1;
4375 HEAP8[$2 + $8 | 0] = $6;
4376 if (($6 & 192) != 128) {
4377 break label$4
4378 }
4379 $4 = $6 & 63 | $4 << 6;
4380 $5 = $5 + -1 | 0;
4381 if ($5) {
4382 continue
4383 }
4384 break;
4385 };
4386 }
4387 HEAP32[$1 >> 2] = $4;
4388 break label$3;
4389 }
4390 HEAP32[$1 >> 2] = -1;
4391 break label$3;
4392 }
4393 HEAP32[$1 >> 2] = -1;
4394 }
4395 $9 = 1;
4396 }
4397 global$0 = $7 + 16 | 0;
4398 return $9;
4399 }
4400
4401 function FLAC__bitreader_read_utf8_uint64($0, $1, $2, $3) {
4402 var $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0;
4403 $7 = global$0 - 16 | 0;
4404 global$0 = $7;
4405 label$1 : {
4406 if (!FLAC__bitreader_read_raw_uint32($0, $7 + 12 | 0, 8)) {
4407 break label$1
4408 }
4409 $4 = HEAP32[$7 + 12 >> 2];
4410 if ($2) {
4411 $6 = HEAP32[$3 >> 2];
4412 HEAP32[$3 >> 2] = $6 + 1;
4413 HEAP8[$2 + $6 | 0] = $4;
4414 }
4415 label$4 : {
4416 label$5 : {
4417 label$6 : {
4418 label$7 : {
4419 if ($4 & 128) {
4420 if (!(!($4 & 192) | $4 & 32)) {
4421 $4 = $4 & 31;
4422 $5 = 1;
4423 break label$7;
4424 }
4425 if (!(!($4 & 224) | $4 & 16)) {
4426 $4 = $4 & 15;
4427 $5 = 2;
4428 break label$7;
4429 }
4430 if (!(!($4 & 240) | $4 & 8)) {
4431 $4 = $4 & 7;
4432 $5 = 3;
4433 break label$7;
4434 }
4435 if (!(!($4 & 248) | $4 & 4)) {
4436 $4 = $4 & 3;
4437 $5 = 4;
4438 break label$7;
4439 }
4440 if (!(!($4 & 252) | $4 & 2)) {
4441 $4 = $4 & 1;
4442 $5 = 5;
4443 break label$7;
4444 }
4445 $5 = 1;
4446 if (!(!($4 & 254) | $4 & 1)) {
4447 $5 = 6;
4448 $4 = 0;
4449 break label$7;
4450 }
4451 HEAP32[$1 >> 2] = -1;
4452 HEAP32[$1 + 4 >> 2] = -1;
4453 break label$1;
4454 }
4455 $6 = 0;
4456 break label$6;
4457 }
4458 $6 = 0;
4459 if (!$2) {
4460 while (1) {
4461 if (!FLAC__bitreader_read_raw_uint32($0, $7 + 12 | 0, 8)) {
4462 $5 = 0;
4463 break label$1;
4464 }
4465 $2 = HEAP32[$7 + 12 >> 2];
4466 if (($2 & 192) != 128) {
4467 break label$5
4468 }
4469 $2 = $2 & 63;
4470 $6 = $6 << 6 | $4 >>> 26;
4471 $4 = $2 | $4 << 6;
4472 $5 = $5 + -1 | 0;
4473 if ($5) {
4474 continue
4475 }
4476 break label$6;
4477 }
4478 }
4479 while (1) {
4480 if (!FLAC__bitreader_read_raw_uint32($0, $7 + 12 | 0, 8)) {
4481 $5 = 0;
4482 break label$1;
4483 }
4484 $8 = HEAP32[$7 + 12 >> 2];
4485 $9 = HEAP32[$3 >> 2];
4486 HEAP32[$3 >> 2] = $9 + 1;
4487 HEAP8[$2 + $9 | 0] = $8;
4488 if (($8 & 192) != 128) {
4489 break label$5
4490 }
4491 $6 = $6 << 6 | $4 >>> 26;
4492 $4 = $8 & 63 | $4 << 6;
4493 $5 = $5 + -1 | 0;
4494 if ($5) {
4495 continue
4496 }
4497 break;
4498 };
4499 }
4500 HEAP32[$1 >> 2] = $4;
4501 HEAP32[$1 + 4 >> 2] = $6;
4502 break label$4;
4503 }
4504 HEAP32[$1 >> 2] = -1;
4505 HEAP32[$1 + 4 >> 2] = -1;
4506 }
4507 $5 = 1;
4508 }
4509 global$0 = $7 + 16 | 0;
4510 return $5;
4511 }
4512
4513 function qsort($0, $1) {
4514 var $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0;
4515 $2 = global$0 - 208 | 0;
4516 global$0 = $2;
4517 HEAP32[$2 + 8 >> 2] = 1;
4518 HEAP32[$2 + 12 >> 2] = 0;
4519 label$1 : {
4520 $5 = Math_imul($1, 24);
4521 if (!$5) {
4522 break label$1
4523 }
4524 HEAP32[$2 + 16 >> 2] = 24;
4525 HEAP32[$2 + 20 >> 2] = 24;
4526 $1 = 24;
4527 $4 = $1;
4528 $3 = 2;
4529 while (1) {
4530 $6 = $4 + 24 | 0;
4531 $4 = $1;
4532 $1 = $1 + $6 | 0;
4533 HEAP32[($2 + 16 | 0) + ($3 << 2) >> 2] = $1;
4534 $3 = $3 + 1 | 0;
4535 if ($1 >>> 0 < $5 >>> 0) {
4536 continue
4537 }
4538 break;
4539 };
4540 $4 = ($0 + $5 | 0) + -24 | 0;
4541 label$3 : {
4542 if ($4 >>> 0 <= $0 >>> 0) {
4543 $3 = 1;
4544 $1 = 1;
4545 break label$3;
4546 }
4547 $3 = 1;
4548 $1 = 1;
4549 while (1) {
4550 label$6 : {
4551 if (($3 & 3) == 3) {
4552 sift($0, $1, $2 + 16 | 0);
4553 shr($2 + 8 | 0, 2);
4554 $1 = $1 + 2 | 0;
4555 break label$6;
4556 }
4557 $3 = $1 + -1 | 0;
4558 label$8 : {
4559 if (HEAPU32[($2 + 16 | 0) + ($3 << 2) >> 2] >= $4 - $0 >>> 0) {
4560 trinkle($0, $2 + 8 | 0, $1, 0, $2 + 16 | 0);
4561 break label$8;
4562 }
4563 sift($0, $1, $2 + 16 | 0);
4564 }
4565 if (($1 | 0) == 1) {
4566 shl($2 + 8 | 0, 1);
4567 $1 = 0;
4568 break label$6;
4569 }
4570 shl($2 + 8 | 0, $3);
4571 $1 = 1;
4572 }
4573 $3 = HEAP32[$2 + 8 >> 2] | 1;
4574 HEAP32[$2 + 8 >> 2] = $3;
4575 $0 = $0 + 24 | 0;
4576 if ($0 >>> 0 < $4 >>> 0) {
4577 continue
4578 }
4579 break;
4580 };
4581 }
4582 trinkle($0, $2 + 8 | 0, $1, 0, $2 + 16 | 0);
4583 while (1) {
4584 label$12 : {
4585 label$13 : {
4586 label$14 : {
4587 if (!(($1 | 0) != 1 | ($3 | 0) != 1)) {
4588 if (HEAP32[$2 + 12 >> 2]) {
4589 break label$14
4590 }
4591 break label$1;
4592 }
4593 if (($1 | 0) > 1) {
4594 break label$13
4595 }
4596 }
4597 $4 = pntz($2 + 8 | 0);
4598 shr($2 + 8 | 0, $4);
4599 $3 = HEAP32[$2 + 8 >> 2];
4600 $1 = $1 + $4 | 0;
4601 break label$12;
4602 }
4603 shl($2 + 8 | 0, 2);
4604 HEAP32[$2 + 8 >> 2] = HEAP32[$2 + 8 >> 2] ^ 7;
4605 shr($2 + 8 | 0, 1);
4606 $5 = $0 + -24 | 0;
4607 $4 = $1 + -2 | 0;
4608 trinkle($5 - HEAP32[($2 + 16 | 0) + ($4 << 2) >> 2] | 0, $2 + 8 | 0, $1 + -1 | 0, 1, $2 + 16 | 0);
4609 shl($2 + 8 | 0, 1);
4610 $3 = HEAP32[$2 + 8 >> 2] | 1;
4611 HEAP32[$2 + 8 >> 2] = $3;
4612 trinkle($5, $2 + 8 | 0, $4, 1, $2 + 16 | 0);
4613 $1 = $4;
4614 }
4615 $0 = $0 + -24 | 0;
4616 continue;
4617 };
4618 }
4619 global$0 = $2 + 208 | 0;
4620 }
4621
4622 function sift($0, $1, $2) {
4623 var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0;
4624 $3 = global$0 - 240 | 0;
4625 global$0 = $3;
4626 HEAP32[$3 >> 2] = $0;
4627 $6 = 1;
4628 label$1 : {
4629 if (($1 | 0) < 2) {
4630 break label$1
4631 }
4632 $4 = $0;
4633 while (1) {
4634 $5 = $4 + -24 | 0;
4635 $7 = $1 + -2 | 0;
4636 $4 = $5 - HEAP32[($7 << 2) + $2 >> 2] | 0;
4637 if ((FUNCTION_TABLE[1]($0, $4) | 0) >= 0) {
4638 if ((FUNCTION_TABLE[1]($0, $5) | 0) > -1) {
4639 break label$1
4640 }
4641 }
4642 $0 = ($6 << 2) + $3 | 0;
4643 label$4 : {
4644 if ((FUNCTION_TABLE[1]($4, $5) | 0) >= 0) {
4645 HEAP32[$0 >> 2] = $4;
4646 $7 = $1 + -1 | 0;
4647 break label$4;
4648 }
4649 HEAP32[$0 >> 2] = $5;
4650 $4 = $5;
4651 }
4652 $6 = $6 + 1 | 0;
4653 if (($7 | 0) < 2) {
4654 break label$1
4655 }
4656 $0 = HEAP32[$3 >> 2];
4657 $1 = $7;
4658 continue;
4659 };
4660 }
4661 cycle($3, $6);
4662 global$0 = $3 + 240 | 0;
4663 }
4664
4665 function shr($0, $1) {
4666 var $2 = 0, $3 = 0, $4 = 0;
4667 $4 = $0;
4668 label$1 : {
4669 if ($1 >>> 0 <= 31) {
4670 $2 = HEAP32[$0 >> 2];
4671 $3 = HEAP32[$0 + 4 >> 2];
4672 break label$1;
4673 }
4674 $2 = HEAP32[$0 + 4 >> 2];
4675 HEAP32[$0 + 4 >> 2] = 0;
4676 HEAP32[$0 >> 2] = $2;
4677 $1 = $1 + -32 | 0;
4678 $3 = 0;
4679 }
4680 HEAP32[$4 + 4 >> 2] = $3 >>> $1;
4681 HEAP32[$0 >> 2] = $3 << 32 - $1 | $2 >>> $1;
4682 }
4683
4684 function trinkle($0, $1, $2, $3, $4) {
4685 var $5 = 0, $6 = 0, $7 = 0, $8 = 0;
4686 $5 = global$0 - 240 | 0;
4687 global$0 = $5;
4688 $6 = HEAP32[$1 >> 2];
4689 HEAP32[$5 + 232 >> 2] = $6;
4690 $1 = HEAP32[$1 + 4 >> 2];
4691 HEAP32[$5 >> 2] = $0;
4692 HEAP32[$5 + 236 >> 2] = $1;
4693 $7 = 1;
4694 label$1 : {
4695 label$2 : {
4696 label$3 : {
4697 label$4 : {
4698 if ($1 ? 0 : ($6 | 0) == 1) {
4699 break label$4
4700 }
4701 $6 = $0 - HEAP32[($2 << 2) + $4 >> 2] | 0;
4702 if ((FUNCTION_TABLE[1]($6, $0) | 0) < 1) {
4703 break label$4
4704 }
4705 $8 = !$3;
4706 while (1) {
4707 label$6 : {
4708 $1 = $6;
4709 if (!(!$8 | ($2 | 0) < 2)) {
4710 $3 = HEAP32[(($2 << 2) + $4 | 0) + -8 >> 2];
4711 $6 = $0 + -24 | 0;
4712 if ((FUNCTION_TABLE[1]($6, $1) | 0) > -1) {
4713 break label$6
4714 }
4715 if ((FUNCTION_TABLE[1]($6 - $3 | 0, $1) | 0) > -1) {
4716 break label$6
4717 }
4718 }
4719 HEAP32[($7 << 2) + $5 >> 2] = $1;
4720 $0 = pntz($5 + 232 | 0);
4721 shr($5 + 232 | 0, $0);
4722 $7 = $7 + 1 | 0;
4723 $2 = $0 + $2 | 0;
4724 if (HEAP32[$5 + 236 >> 2] ? 0 : HEAP32[$5 + 232 >> 2] == 1) {
4725 break label$2
4726 }
4727 $3 = 0;
4728 $8 = 1;
4729 $0 = $1;
4730 $6 = $1 - HEAP32[($2 << 2) + $4 >> 2] | 0;
4731 if ((FUNCTION_TABLE[1]($6, HEAP32[$5 >> 2]) | 0) > 0) {
4732 continue
4733 }
4734 break label$3;
4735 }
4736 break;
4737 };
4738 $1 = $0;
4739 break label$2;
4740 }
4741 $1 = $0;
4742 }
4743 if ($3) {
4744 break label$1
4745 }
4746 }
4747 cycle($5, $7);
4748 sift($1, $2, $4);
4749 }
4750 global$0 = $5 + 240 | 0;
4751 }
4752
4753 function shl($0, $1) {
4754 var $2 = 0, $3 = 0, $4 = 0;
4755 $4 = $0;
4756 label$1 : {
4757 if ($1 >>> 0 <= 31) {
4758 $2 = HEAP32[$0 + 4 >> 2];
4759 $3 = HEAP32[$0 >> 2];
4760 break label$1;
4761 }
4762 $2 = HEAP32[$0 >> 2];
4763 HEAP32[$0 + 4 >> 2] = $2;
4764 HEAP32[$0 >> 2] = 0;
4765 $1 = $1 + -32 | 0;
4766 $3 = 0;
4767 }
4768 HEAP32[$4 >> 2] = $3 << $1;
4769 HEAP32[$0 + 4 >> 2] = $2 << $1 | $3 >>> 32 - $1;
4770 }
4771
4772 function pntz($0) {
4773 var $1 = 0;
4774 $1 = __wasm_ctz_i32(HEAP32[$0 >> 2] + -1 | 0);
4775 if (!$1) {
4776 $0 = __wasm_ctz_i32(HEAP32[$0 + 4 >> 2]);
4777 return $0 ? $0 + 32 | 0 : 0;
4778 }
4779 return $1;
4780 }
4781
4782 function cycle($0, $1) {
4783 var $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0;
4784 $3 = 24;
4785 $4 = global$0 - 256 | 0;
4786 global$0 = $4;
4787 label$1 : {
4788 if (($1 | 0) < 2) {
4789 break label$1
4790 }
4791 $7 = ($1 << 2) + $0 | 0;
4792 HEAP32[$7 >> 2] = $4;
4793 $2 = $4;
4794 while (1) {
4795 $5 = $3 >>> 0 < 256 ? $3 : 256;
4796 memcpy($2, HEAP32[$0 >> 2], $5);
4797 $2 = 0;
4798 while (1) {
4799 $6 = ($2 << 2) + $0 | 0;
4800 $2 = $2 + 1 | 0;
4801 memcpy(HEAP32[$6 >> 2], HEAP32[($2 << 2) + $0 >> 2], $5);
4802 HEAP32[$6 >> 2] = HEAP32[$6 >> 2] + $5;
4803 if (($1 | 0) != ($2 | 0)) {
4804 continue
4805 }
4806 break;
4807 };
4808 $3 = $3 - $5 | 0;
4809 if (!$3) {
4810 break label$1
4811 }
4812 $2 = HEAP32[$7 >> 2];
4813 continue;
4814 };
4815 }
4816 global$0 = $4 + 256 | 0;
4817 }
4818
4819 function FLAC__format_sample_rate_is_subset($0) {
4820 if ($0 + -1 >>> 0 <= 655349) {
4821 return !(($0 >>> 0) % 10) | (!(($0 >>> 0) % 1e3) | $0 >>> 0 < 65536)
4822 }
4823 return 0;
4824 }
4825
4826 function FLAC__format_seektable_is_legal($0) {
4827 var $1 = 0, $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0;
4828 $3 = HEAP32[$0 >> 2];
4829 if (!$3) {
4830 return 1
4831 }
4832 $6 = HEAP32[$0 + 4 >> 2];
4833 $0 = 0;
4834 $4 = 1;
4835 while (1) {
4836 $7 = $2;
4837 $5 = $1;
4838 $1 = Math_imul($0, 24) + $6 | 0;
4839 $2 = HEAP32[$1 >> 2];
4840 $1 = HEAP32[$1 + 4 >> 2];
4841 if (!(($2 | 0) == -1 & ($1 | 0) == -1 | $4 | (($1 | 0) == ($5 | 0) & $2 >>> 0 > $7 >>> 0 | $1 >>> 0 > $5 >>> 0))) {
4842 return 0
4843 }
4844 $4 = 0;
4845 $0 = $0 + 1 | 0;
4846 if ($0 >>> 0 < $3 >>> 0) {
4847 continue
4848 }
4849 break;
4850 };
4851 return 1;
4852 }
4853
4854 function FLAC__format_seektable_sort($0) {
4855 var $1 = 0, $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0;
4856 label$1 : {
4857 $2 = HEAP32[$0 >> 2];
4858 if (!$2) {
4859 break label$1
4860 }
4861 qsort(HEAP32[$0 + 4 >> 2], $2);
4862 if (!HEAP32[$0 >> 2]) {
4863 break label$1
4864 }
4865 $2 = 1;
4866 $1 = HEAP32[$0 >> 2];
4867 if ($1 >>> 0 > 1) {
4868 $6 = 1;
4869 while (1) {
4870 $4 = HEAP32[$0 + 4 >> 2];
4871 $3 = $4 + Math_imul($6, 24) | 0;
4872 $5 = HEAP32[$3 >> 2];
4873 $7 = HEAP32[$3 + 4 >> 2];
4874 $8 = $7;
4875 label$4 : {
4876 if (($5 | 0) != -1 | ($7 | 0) != -1) {
4877 $7 = $5;
4878 $5 = ($4 + Math_imul($2, 24) | 0) + -24 | 0;
4879 if (($7 | 0) == HEAP32[$5 >> 2] & HEAP32[$5 + 4 >> 2] == ($8 | 0)) {
4880 break label$4
4881 }
4882 }
4883 $5 = HEAP32[$3 + 4 >> 2];
4884 $1 = $4 + Math_imul($2, 24) | 0;
4885 HEAP32[$1 >> 2] = HEAP32[$3 >> 2];
4886 HEAP32[$1 + 4 >> 2] = $5;
4887 $4 = HEAP32[$3 + 20 >> 2];
4888 HEAP32[$1 + 16 >> 2] = HEAP32[$3 + 16 >> 2];
4889 HEAP32[$1 + 20 >> 2] = $4;
4890 $4 = HEAP32[$3 + 12 >> 2];
4891 HEAP32[$1 + 8 >> 2] = HEAP32[$3 + 8 >> 2];
4892 HEAP32[$1 + 12 >> 2] = $4;
4893 $2 = $2 + 1 | 0;
4894 $1 = HEAP32[$0 >> 2];
4895 }
4896 $6 = $6 + 1 | 0;
4897 if ($6 >>> 0 < $1 >>> 0) {
4898 continue
4899 }
4900 break;
4901 };
4902 }
4903 if ($2 >>> 0 >= $1 >>> 0) {
4904 break label$1
4905 }
4906 $3 = HEAP32[$0 + 4 >> 2];
4907 while (1) {
4908 $0 = $3 + Math_imul($2, 24) | 0;
4909 HEAP32[$0 + 16 >> 2] = 0;
4910 HEAP32[$0 + 8 >> 2] = 0;
4911 HEAP32[$0 + 12 >> 2] = 0;
4912 HEAP32[$0 >> 2] = -1;
4913 HEAP32[$0 + 4 >> 2] = -1;
4914 $2 = $2 + 1 | 0;
4915 if (($1 | 0) != ($2 | 0)) {
4916 continue
4917 }
4918 break;
4919 };
4920 }
4921 }
4922
4923 function seekpoint_compare_($0, $1) {
4924 $0 = $0 | 0;
4925 $1 = $1 | 0;
4926 var $2 = 0, $3 = 0;
4927 $2 = HEAP32[$0 + 4 >> 2];
4928 $3 = HEAP32[$1 + 4 >> 2];
4929 $0 = HEAP32[$0 >> 2];
4930 $1 = HEAP32[$1 >> 2];
4931 return (($0 | 0) == ($1 | 0) & ($2 | 0) == ($3 | 0) ? 0 : ($2 | 0) == ($3 | 0) & $0 >>> 0 < $1 >>> 0 | $2 >>> 0 < $3 >>> 0 ? -1 : 1) | 0;
4932 }
4933
4934 function utf8len_($0) {
4935 var $1 = 0, $2 = 0, $3 = 0, $4 = 0;
4936 $2 = 1;
4937 label$1 : {
4938 $1 = HEAPU8[$0 | 0];
4939 label$2 : {
4940 if (!($1 & 128)) {
4941 break label$2
4942 }
4943 if (!(($1 & 224) != 192 | (HEAPU8[$0 + 1 | 0] & 192) != 128)) {
4944 return (($1 & 254) != 192) << 1
4945 }
4946 label$4 : {
4947 if (($1 & 240) != 224) {
4948 break label$4
4949 }
4950 $3 = HEAPU8[$0 + 1 | 0];
4951 if (($3 & 192) != 128) {
4952 break label$4
4953 }
4954 $4 = HEAPU8[$0 + 2 | 0];
4955 if (($4 & 192) != 128) {
4956 break label$4
4957 }
4958 $2 = 0;
4959 if (($3 & 224) == 128 ? ($1 | 0) == 224 : 0) {
4960 break label$2
4961 }
4962 label$5 : {
4963 label$6 : {
4964 switch ($1 + -237 | 0) {
4965 case 0:
4966 if (($3 & 224) != 160) {
4967 break label$5
4968 }
4969 break label$2;
4970 case 2:
4971 break label$6;
4972 default:
4973 break label$5;
4974 };
4975 }
4976 if (($3 | 0) != 191) {
4977 break label$5
4978 }
4979 if (($4 & 254) == 190) {
4980 break label$2
4981 }
4982 }
4983 return 3;
4984 }
4985 label$8 : {
4986 if (($1 & 248) != 240) {
4987 break label$8
4988 }
4989 $2 = HEAPU8[$0 + 1 | 0];
4990 if (($2 & 192) != 128 | (HEAPU8[$0 + 2 | 0] & 192) != 128) {
4991 break label$8
4992 }
4993 if ((HEAPU8[$0 + 3 | 0] & 192) == 128) {
4994 break label$1
4995 }
4996 }
4997 label$9 : {
4998 if (($1 & 252) != 248) {
4999 break label$9
5000 }
5001 $2 = HEAPU8[$0 + 1 | 0];
5002 if (($2 & 192) != 128 | (HEAPU8[$0 + 2 | 0] & 192) != 128 | ((HEAPU8[$0 + 3 | 0] & 192) != 128 | (HEAPU8[$0 + 4 | 0] & 192) != 128)) {
5003 break label$9
5004 }
5005 return ($1 | 0) == 248 ? (($2 & 248) == 128 ? 0 : 5) : 5;
5006 }
5007 $2 = 0;
5008 if (($1 & 254) != 252) {
5009 break label$2
5010 }
5011 $3 = HEAPU8[$0 + 1 | 0];
5012 if (($3 & 192) != 128 | (HEAPU8[$0 + 2 | 0] & 192) != 128 | ((HEAPU8[$0 + 3 | 0] & 192) != 128 | (HEAPU8[$0 + 4 | 0] & 192) != 128)) {
5013 break label$2
5014 }
5015 if ((HEAPU8[$0 + 5 | 0] & 192) != 128) {
5016 break label$2
5017 }
5018 $2 = ($1 | 0) == 252 ? (($3 & 252) == 128 ? 0 : 6) : 6;
5019 }
5020 return $2;
5021 }
5022 return ($1 | 0) == 240 ? (($2 & 240) != 128) << 2 : 4;
5023 }
5024
5025 function FLAC__format_cuesheet_is_legal($0, $1) {
5026 var $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0;
5027 label$1 : {
5028 label$2 : {
5029 label$3 : {
5030 label$4 : {
5031 label$5 : {
5032 label$6 : {
5033 label$7 : {
5034 if ($1) {
5035 $1 = HEAP32[$0 + 140 >> 2];
5036 $3 = $1;
5037 $2 = HEAP32[$0 + 136 >> 2];
5038 if (!$1 & $2 >>> 0 <= 88199 | $1 >>> 0 < 0) {
5039 $0 = 0;
5040 break label$1;
5041 }
5042 if (__wasm_i64_urem($2, $3) | i64toi32_i32$HIGH_BITS) {
5043 $0 = 0;
5044 break label$1;
5045 }
5046 $3 = HEAP32[$0 + 148 >> 2];
5047 if (!$3) {
5048 break label$2
5049 }
5050 if (HEAPU8[(HEAP32[$0 + 152 >> 2] + ($3 << 5) | 0) + -24 | 0] == 170) {
5051 break label$7
5052 }
5053 $0 = 0;
5054 break label$1;
5055 }
5056 $2 = HEAP32[$0 + 148 >> 2];
5057 if (!$2) {
5058 break label$2
5059 }
5060 $4 = $2 + -1 | 0;
5061 $6 = HEAP32[$0 + 152 >> 2];
5062 $1 = 0;
5063 while (1) {
5064 $0 = $6 + ($1 << 5) | 0;
5065 if (!HEAPU8[$0 + 8 | 0]) {
5066 break label$3
5067 }
5068 $3 = HEAPU8[$0 + 23 | 0];
5069 label$12 : {
5070 label$13 : {
5071 if ($1 >>> 0 < $4 >>> 0) {
5072 if (!$3) {
5073 break label$4
5074 }
5075 if (HEAPU8[HEAP32[$0 + 24 >> 2] + 8 | 0] > 1) {
5076 break label$5
5077 }
5078 break label$13;
5079 }
5080 if (!$3) {
5081 break label$12
5082 }
5083 }
5084 $7 = $0 + 24 | 0;
5085 $0 = 0;
5086 while (1) {
5087 if ($0) {
5088 $5 = HEAP32[$7 >> 2] + ($0 << 4) | 0;
5089 if ((HEAPU8[$5 + -8 | 0] + 1 | 0) != HEAPU8[$5 + 8 | 0]) {
5090 break label$6
5091 }
5092 }
5093 $0 = $0 + 1 | 0;
5094 if ($0 >>> 0 < $3 >>> 0) {
5095 continue
5096 }
5097 break;
5098 };
5099 }
5100 $0 = 1;
5101 $1 = $1 + 1 | 0;
5102 if (($2 | 0) != ($1 | 0)) {
5103 continue
5104 }
5105 break;
5106 };
5107 break label$1;
5108 }
5109 $6 = $3 + -1 | 0;
5110 $7 = HEAP32[$0 + 152 >> 2];
5111 $1 = 0;
5112 while (1) {
5113 $0 = $7 + ($1 << 5) | 0;
5114 $2 = HEAPU8[$0 + 8 | 0];
5115 if (!$2) {
5116 break label$3
5117 }
5118 if (!(($2 | 0) == 170 | $2 >>> 0 < 100)) {
5119 $0 = 0;
5120 break label$1;
5121 }
5122 if (__wasm_i64_urem(HEAP32[$0 >> 2], HEAP32[$0 + 4 >> 2]) | i64toi32_i32$HIGH_BITS) {
5123 $0 = 0;
5124 break label$1;
5125 }
5126 $2 = HEAPU8[$0 + 23 | 0];
5127 label$21 : {
5128 label$22 : {
5129 if ($1 >>> 0 < $6 >>> 0) {
5130 if (!$2) {
5131 break label$4
5132 }
5133 if (HEAPU8[HEAP32[$0 + 24 >> 2] + 8 | 0] < 2) {
5134 break label$22
5135 }
5136 break label$5;
5137 }
5138 if (!$2) {
5139 break label$21
5140 }
5141 }
5142 $5 = HEAP32[$0 + 24 >> 2];
5143 $0 = 0;
5144 while (1) {
5145 $4 = $5 + ($0 << 4) | 0;
5146 if (__wasm_i64_urem(HEAP32[$4 >> 2], HEAP32[$4 + 4 >> 2]) | i64toi32_i32$HIGH_BITS) {
5147 $0 = 0;
5148 break label$1;
5149 }
5150 if (HEAPU8[$4 + 8 | 0] != (HEAPU8[$4 + -8 | 0] + 1 | 0) ? $0 : 0) {
5151 break label$6
5152 }
5153 $0 = $0 + 1 | 0;
5154 if ($0 >>> 0 < $2 >>> 0) {
5155 continue
5156 }
5157 break;
5158 };
5159 }
5160 $0 = 1;
5161 $1 = $1 + 1 | 0;
5162 if (($3 | 0) != ($1 | 0)) {
5163 continue
5164 }
5165 break;
5166 };
5167 break label$1;
5168 }
5169 $0 = 0;
5170 break label$1;
5171 }
5172 $0 = 0;
5173 break label$1;
5174 }
5175 $0 = 0;
5176 break label$1;
5177 }
5178 $0 = 0;
5179 break label$1;
5180 }
5181 $0 = 0;
5182 }
5183 return $0;
5184 }
5185
5186 function FLAC__format_picture_is_legal($0) {
5187 var $1 = 0, $2 = 0;
5188 label$1 : {
5189 label$2 : {
5190 $2 = HEAP32[$0 + 4 >> 2];
5191 $1 = HEAPU8[$2 | 0];
5192 if (!$1) {
5193 break label$2
5194 }
5195 while (1) {
5196 if (($1 + -32 & 255) >>> 0 < 95) {
5197 $2 = $2 + 1 | 0;
5198 $1 = HEAPU8[$2 | 0];
5199 if ($1) {
5200 continue
5201 }
5202 break label$2;
5203 }
5204 break;
5205 };
5206 $2 = 0;
5207 break label$1;
5208 }
5209 $2 = 1;
5210 $1 = HEAP32[$0 + 8 >> 2];
5211 if (!HEAPU8[$1 | 0]) {
5212 break label$1
5213 }
5214 while (1) {
5215 $0 = utf8len_($1);
5216 if (!$0) {
5217 $2 = 0;
5218 break label$1;
5219 }
5220 $1 = $0 + $1 | 0;
5221 if (HEAPU8[$1 | 0]) {
5222 continue
5223 }
5224 break;
5225 };
5226 }
5227 return $2;
5228 }
5229
5230 function FLAC__format_get_max_rice_partition_order_from_blocksize_limited_max_and_predictor_order($0, $1, $2) {
5231 var $3 = 0;
5232 while (1) {
5233 $3 = $0;
5234 if ($3) {
5235 $0 = $3 + -1 | 0;
5236 if ($1 >>> $3 >>> 0 <= $2 >>> 0) {
5237 continue
5238 }
5239 }
5240 break;
5241 };
5242 return $3;
5243 }
5244
5245 function FLAC__format_get_max_rice_partition_order_from_blocksize($0) {
5246 var $1 = 0, $2 = 0;
5247 label$1 : {
5248 if (!($0 & 1)) {
5249 while (1) {
5250 $1 = $1 + 1 | 0;
5251 $2 = $0 & 2;
5252 $0 = $0 >>> 1 | 0;
5253 if (!$2) {
5254 continue
5255 }
5256 break;
5257 };
5258 $0 = 15;
5259 if ($1 >>> 0 > 14) {
5260 break label$1
5261 }
5262 }
5263 $0 = $1;
5264 }
5265 return $0;
5266 }
5267
5268 function FLAC__format_entropy_coding_method_partitioned_rice_contents_init($0) {
5269 HEAP32[$0 + 8 >> 2] = 0;
5270 HEAP32[$0 >> 2] = 0;
5271 HEAP32[$0 + 4 >> 2] = 0;
5272 }
5273
5274 function FLAC__format_entropy_coding_method_partitioned_rice_contents_clear($0) {
5275 var $1 = 0;
5276 $1 = HEAP32[$0 >> 2];
5277 if ($1) {
5278 dlfree($1)
5279 }
5280 $1 = HEAP32[$0 + 4 >> 2];
5281 if ($1) {
5282 dlfree($1)
5283 }
5284 HEAP32[$0 + 8 >> 2] = 0;
5285 HEAP32[$0 >> 2] = 0;
5286 HEAP32[$0 + 4 >> 2] = 0;
5287 }
5288
5289 function FLAC__format_entropy_coding_method_partitioned_rice_contents_ensure_size($0, $1) {
5290 var $2 = 0, $3 = 0, $4 = 0, $5 = 0;
5291 $3 = 1;
5292 label$1 : {
5293 if (HEAPU32[$0 + 8 >> 2] >= $1 >>> 0) {
5294 break label$1
5295 }
5296 $3 = HEAP32[$0 >> 2];
5297 $4 = 4 << $1;
5298 $2 = dlrealloc($3, $4);
5299 if (!($2 | $1 >>> 0 > 29)) {
5300 dlfree($3)
5301 }
5302 HEAP32[$0 >> 2] = $2;
5303 $3 = 0;
5304 if (!$2) {
5305 break label$1
5306 }
5307 $5 = HEAP32[$0 + 4 >> 2];
5308 $2 = dlrealloc($5, $4);
5309 if (!($2 | $1 >>> 0 > 29)) {
5310 dlfree($5)
5311 }
5312 HEAP32[$0 + 4 >> 2] = $2;
5313 if (!$2) {
5314 break label$1
5315 }
5316 memset($2, $4);
5317 HEAP32[$0 + 8 >> 2] = $1;
5318 $3 = 1;
5319 }
5320 return $3;
5321 }
5322
5323 function ogg_page_serialno($0) {
5324 $0 = HEAP32[$0 >> 2];
5325 return HEAPU8[$0 + 14 | 0] | HEAPU8[$0 + 15 | 0] << 8 | (HEAPU8[$0 + 16 | 0] << 16 | HEAPU8[$0 + 17 | 0] << 24);
5326 }
5327
5328 function ogg_stream_init($0, $1) {
5329 var $2 = 0, $3 = 0, $4 = 0;
5330 if ($0) {
5331 memset($0 + 8 | 0, 352);
5332 HEAP32[$0 + 24 >> 2] = 1024;
5333 HEAP32[$0 + 4 >> 2] = 16384;
5334 $3 = dlmalloc(16384);
5335 HEAP32[$0 >> 2] = $3;
5336 $2 = dlmalloc(4096);
5337 HEAP32[$0 + 16 >> 2] = $2;
5338 $4 = dlmalloc(8192);
5339 HEAP32[$0 + 20 >> 2] = $4;
5340 label$2 : {
5341 if ($3) {
5342 if ($2 ? $4 : 0) {
5343 break label$2
5344 }
5345 dlfree($3);
5346 $2 = HEAP32[$0 + 16 >> 2];
5347 }
5348 if ($2) {
5349 dlfree($2)
5350 }
5351 $1 = HEAP32[$0 + 20 >> 2];
5352 if ($1) {
5353 dlfree($1)
5354 }
5355 memset($0, 360);
5356 return -1;
5357 }
5358 HEAP32[$0 + 336 >> 2] = $1;
5359 $0 = 0;
5360 } else {
5361 $0 = -1
5362 }
5363 return $0;
5364 }
5365
5366 function ogg_stream_clear($0) {
5367 var $1 = 0;
5368 if ($0) {
5369 $1 = HEAP32[$0 >> 2];
5370 if ($1) {
5371 dlfree($1)
5372 }
5373 $1 = HEAP32[$0 + 16 >> 2];
5374 if ($1) {
5375 dlfree($1)
5376 }
5377 $1 = HEAP32[$0 + 20 >> 2];
5378 if ($1) {
5379 dlfree($1)
5380 }
5381 memset($0, 360);
5382 }
5383 }
5384
5385 function ogg_page_checksum_set($0) {
5386 var $1 = 0, $2 = 0, $3 = 0, $4 = 0;
5387 if ($0) {
5388 HEAP8[HEAP32[$0 >> 2] + 22 | 0] = 0;
5389 HEAP8[HEAP32[$0 >> 2] + 23 | 0] = 0;
5390 HEAP8[HEAP32[$0 >> 2] + 24 | 0] = 0;
5391 HEAP8[HEAP32[$0 >> 2] + 25 | 0] = 0;
5392 $3 = HEAP32[$0 + 4 >> 2];
5393 if (($3 | 0) >= 1) {
5394 $4 = HEAP32[$0 >> 2];
5395 while (1) {
5396 $1 = HEAP32[((HEAPU8[$2 + $4 | 0] ^ $1 >>> 24) << 2) + 6512 >> 2] ^ $1 << 8;
5397 $2 = $2 + 1 | 0;
5398 if (($3 | 0) != ($2 | 0)) {
5399 continue
5400 }
5401 break;
5402 };
5403 }
5404 $3 = HEAP32[$0 + 12 >> 2];
5405 if (($3 | 0) >= 1) {
5406 $4 = HEAP32[$0 + 8 >> 2];
5407 $2 = 0;
5408 while (1) {
5409 $1 = HEAP32[((HEAPU8[$2 + $4 | 0] ^ $1 >>> 24) << 2) + 6512 >> 2] ^ $1 << 8;
5410 $2 = $2 + 1 | 0;
5411 if (($3 | 0) != ($2 | 0)) {
5412 continue
5413 }
5414 break;
5415 };
5416 }
5417 HEAP8[HEAP32[$0 >> 2] + 22 | 0] = $1;
5418 HEAP8[HEAP32[$0 >> 2] + 23 | 0] = $1 >>> 8;
5419 HEAP8[HEAP32[$0 >> 2] + 24 | 0] = $1 >>> 16;
5420 HEAP8[HEAP32[$0 >> 2] + 25 | 0] = $1 >>> 24;
5421 }
5422 }
5423
5424 function ogg_stream_iovecin($0, $1, $2, $3, $4) {
5425 var $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0;
5426 $6 = -1;
5427 folding_inner0 : {
5428 label$1 : {
5429 if (!$0) {
5430 break label$1
5431 }
5432 $8 = HEAP32[$0 >> 2];
5433 if (!$8) {
5434 break label$1
5435 }
5436 if (!$1) {
5437 return 0
5438 }
5439 while (1) {
5440 $7 = HEAP32[(($5 << 3) + $1 | 0) + 4 >> 2];
5441 if (($7 | 0) < 0 | ($9 | 0) > (2147483647 - $7 | 0)) {
5442 break label$1
5443 }
5444 $9 = $7 + $9 | 0;
5445 $5 = $5 + 1 | 0;
5446 if (($5 | 0) != 1) {
5447 continue
5448 }
5449 break;
5450 };
5451 $5 = HEAP32[$0 + 12 >> 2];
5452 if ($5) {
5453 $7 = HEAP32[$0 + 8 >> 2] - $5 | 0;
5454 HEAP32[$0 + 8 >> 2] = $7;
5455 if ($7) {
5456 memmove($8, $5 + $8 | 0, $7)
5457 }
5458 HEAP32[$0 + 12 >> 2] = 0;
5459 }
5460 $5 = HEAP32[$0 + 4 >> 2];
5461 if (($5 - $9 | 0) <= HEAP32[$0 + 8 >> 2]) {
5462 if (($5 | 0) > (2147483647 - $9 | 0)) {
5463 break folding_inner0
5464 }
5465 $5 = $5 + $9 | 0;
5466 $5 = ($5 | 0) < 2147482623 ? $5 + 1024 | 0 : $5;
5467 $8 = dlrealloc(HEAP32[$0 >> 2], $5);
5468 if (!$8) {
5469 break folding_inner0
5470 }
5471 HEAP32[$0 >> 2] = $8;
5472 HEAP32[$0 + 4 >> 2] = $5;
5473 }
5474 $8 = ($9 | 0) / 255 | 0;
5475 $11 = $8 + 1 | 0;
5476 if (_os_lacing_expand($0, $11)) {
5477 break label$1
5478 }
5479 $6 = HEAP32[$0 + 8 >> 2];
5480 $5 = 0;
5481 while (1) {
5482 $7 = HEAP32[$0 >> 2] + $6 | 0;
5483 $6 = ($5 << 3) + $1 | 0;
5484 memcpy($7, HEAP32[$6 >> 2], HEAP32[$6 + 4 >> 2]);
5485 $6 = HEAP32[$0 + 8 >> 2] + HEAP32[$6 + 4 >> 2] | 0;
5486 HEAP32[$0 + 8 >> 2] = $6;
5487 $5 = $5 + 1 | 0;
5488 if (($5 | 0) != 1) {
5489 continue
5490 }
5491 break;
5492 };
5493 $7 = HEAP32[$0 + 16 >> 2];
5494 $12 = $7;
5495 $1 = HEAP32[$0 + 28 >> 2];
5496 $13 = $1;
5497 label$19 : {
5498 if (($9 | 0) <= 254) {
5499 $6 = HEAP32[$0 + 20 >> 2];
5500 $5 = 0;
5501 break label$19;
5502 }
5503 $6 = HEAP32[$0 + 20 >> 2];
5504 $5 = 0;
5505 while (1) {
5506 $10 = $1 + $5 | 0;
5507 HEAP32[$7 + ($10 << 2) >> 2] = 255;
5508 $14 = HEAP32[$0 + 356 >> 2];
5509 $10 = ($10 << 3) + $6 | 0;
5510 HEAP32[$10 >> 2] = HEAP32[$0 + 352 >> 2];
5511 HEAP32[$10 + 4 >> 2] = $14;
5512 $5 = $5 + 1 | 0;
5513 if (($8 | 0) != ($5 | 0)) {
5514 continue
5515 }
5516 break;
5517 };
5518 $5 = $8;
5519 }
5520 $5 = $13 + $5 | 0;
5521 HEAP32[$12 + ($5 << 2) >> 2] = $9 - Math_imul($8, 255);
5522 $5 = ($5 << 3) + $6 | 0;
5523 HEAP32[$5 >> 2] = $3;
5524 HEAP32[$5 + 4 >> 2] = $4;
5525 HEAP32[$0 + 352 >> 2] = $3;
5526 HEAP32[$0 + 356 >> 2] = $4;
5527 $3 = $7 + ($1 << 2) | 0;
5528 HEAP32[$3 >> 2] = HEAP32[$3 >> 2] | 256;
5529 HEAP32[$0 + 28 >> 2] = $1 + $11;
5530 $1 = HEAP32[$0 + 348 >> 2];
5531 $3 = HEAP32[$0 + 344 >> 2] + 1 | 0;
5532 if ($3 >>> 0 < 1) {
5533 $1 = $1 + 1 | 0
5534 }
5535 HEAP32[$0 + 344 >> 2] = $3;
5536 HEAP32[$0 + 348 >> 2] = $1;
5537 $6 = 0;
5538 if (!$2) {
5539 break label$1
5540 }
5541 HEAP32[$0 + 328 >> 2] = 1;
5542 }
5543 return $6;
5544 }
5545 $1 = HEAP32[$0 >> 2];
5546 if ($1) {
5547 dlfree($1)
5548 }
5549 $1 = HEAP32[$0 + 16 >> 2];
5550 if ($1) {
5551 dlfree($1)
5552 }
5553 $1 = HEAP32[$0 + 20 >> 2];
5554 if ($1) {
5555 dlfree($1)
5556 }
5557 memset($0, 360);
5558 return -1;
5559 }
5560
5561 function _os_lacing_expand($0, $1) {
5562 var $2 = 0;
5563 folding_inner0 : {
5564 $2 = HEAP32[$0 + 24 >> 2];
5565 if (($2 - $1 | 0) <= HEAP32[$0 + 28 >> 2]) {
5566 if (($2 | 0) > (2147483647 - $1 | 0)) {
5567 break folding_inner0
5568 }
5569 $1 = $1 + $2 | 0;
5570 $1 = ($1 | 0) < 2147483615 ? $1 + 32 | 0 : $1;
5571 $2 = dlrealloc(HEAP32[$0 + 16 >> 2], $1 << 2);
5572 if (!$2) {
5573 break folding_inner0
5574 }
5575 HEAP32[$0 + 16 >> 2] = $2;
5576 $2 = dlrealloc(HEAP32[$0 + 20 >> 2], $1 << 3);
5577 if (!$2) {
5578 break folding_inner0
5579 }
5580 HEAP32[$0 + 24 >> 2] = $1;
5581 HEAP32[$0 + 20 >> 2] = $2;
5582 }
5583 return 0;
5584 }
5585 $1 = HEAP32[$0 >> 2];
5586 if ($1) {
5587 dlfree($1)
5588 }
5589 $1 = HEAP32[$0 + 16 >> 2];
5590 if ($1) {
5591 dlfree($1)
5592 }
5593 $1 = HEAP32[$0 + 20 >> 2];
5594 if ($1) {
5595 dlfree($1)
5596 }
5597 memset($0, 360);
5598 return -1;
5599 }
5600
5601 function ogg_stream_packetin($0, $1) {
5602 var $2 = 0;
5603 $2 = global$0 - 16 | 0;
5604 global$0 = $2;
5605 HEAP32[$2 + 8 >> 2] = HEAP32[$1 >> 2];
5606 HEAP32[$2 + 12 >> 2] = HEAP32[$1 + 4 >> 2];
5607 $0 = ogg_stream_iovecin($0, $2 + 8 | 0, HEAP32[$1 + 12 >> 2], HEAP32[$1 + 16 >> 2], HEAP32[$1 + 20 >> 2]);
5608 global$0 = $2 + 16 | 0;
5609 return $0;
5610 }
5611
5612 function ogg_stream_flush_i($0, $1, $2) {
5613 var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0;
5614 label$1 : {
5615 if (!$0) {
5616 break label$1
5617 }
5618 $8 = HEAP32[$0 + 28 >> 2];
5619 $4 = ($8 | 0) < 255 ? $8 : 255;
5620 if (!$4) {
5621 break label$1
5622 }
5623 $10 = HEAP32[$0 >> 2];
5624 if (!$10) {
5625 break label$1
5626 }
5627 label$2 : {
5628 label$3 : {
5629 label$4 : {
5630 $11 = HEAP32[$0 + 332 >> 2];
5631 if ($11) {
5632 if (($8 | 0) >= 1) {
5633 break label$4
5634 }
5635 $7 = -1;
5636 $5 = -1;
5637 break label$3;
5638 }
5639 $3 = ($4 | 0) > 0 ? $4 : 0;
5640 while (1) {
5641 if (($3 | 0) == ($6 | 0)) {
5642 break label$3
5643 }
5644 $9 = $6 << 2;
5645 $4 = $6 + 1 | 0;
5646 $6 = $4;
5647 if (HEAPU8[$9 + HEAP32[$0 + 16 >> 2] | 0] == 255) {
5648 continue
5649 }
5650 break;
5651 };
5652 $3 = $4;
5653 break label$3;
5654 }
5655 $4 = ($4 | 0) > 1 ? $4 : 1;
5656 $7 = -1;
5657 $5 = -1;
5658 label$7 : {
5659 while (1) {
5660 if (!(($6 | 0) <= 4096 | ($9 | 0) <= 3)) {
5661 $2 = 1;
5662 break label$7;
5663 }
5664 $9 = 0;
5665 $12 = HEAPU8[HEAP32[$0 + 16 >> 2] + ($3 << 2) | 0];
5666 if (($12 | 0) != 255) {
5667 $13 = $13 + 1 | 0;
5668 $9 = $13;
5669 $5 = HEAP32[$0 + 20 >> 2] + ($3 << 3) | 0;
5670 $7 = HEAP32[$5 >> 2];
5671 $5 = HEAP32[$5 + 4 >> 2];
5672 }
5673 $6 = $6 + $12 | 0;
5674 $3 = $3 + 1 | 0;
5675 if (($4 | 0) != ($3 | 0)) {
5676 continue
5677 }
5678 break;
5679 };
5680 $3 = $4;
5681 }
5682 $4 = 255;
5683 if (($3 | 0) == 255) {
5684 break label$2
5685 }
5686 }
5687 $4 = $3;
5688 if (!$2) {
5689 break label$1
5690 }
5691 }
5692 HEAP32[$0 + 40 >> 2] = 1399285583;
5693 HEAP16[$0 + 44 >> 1] = 0;
5694 $2 = HEAP32[$0 + 16 >> 2];
5695 $3 = (HEAPU8[$2 + 1 | 0] ^ -1) & 1;
5696 $3 = $11 ? $3 : $3 | 2;
5697 HEAP8[$0 + 45 | 0] = $3;
5698 if (!(!HEAP32[$0 + 328 >> 2] | ($4 | 0) != ($8 | 0))) {
5699 HEAP8[$0 + 45 | 0] = $3 | 4
5700 }
5701 HEAP32[$0 + 332 >> 2] = 1;
5702 HEAP8[$0 + 53 | 0] = $5 >>> 24;
5703 HEAP8[$0 + 52 | 0] = $5 >>> 16;
5704 HEAP8[$0 + 51 | 0] = $5 >>> 8;
5705 HEAP8[$0 + 50 | 0] = $5;
5706 HEAP8[$0 + 49 | 0] = ($5 & 16777215) << 8 | $7 >>> 24;
5707 HEAP8[$0 + 48 | 0] = ($5 & 65535) << 16 | $7 >>> 16;
5708 HEAP8[$0 + 47 | 0] = ($5 & 255) << 24 | $7 >>> 8;
5709 HEAP8[$0 + 46 | 0] = $7;
5710 $3 = HEAP32[$0 + 336 >> 2];
5711 HEAP8[$0 + 54 | 0] = $3;
5712 HEAP8[$0 + 55 | 0] = $3 >>> 8;
5713 HEAP8[$0 + 56 | 0] = $3 >>> 16;
5714 HEAP8[$0 + 57 | 0] = $3 >>> 24;
5715 $3 = HEAP32[$0 + 340 >> 2];
5716 if (($3 | 0) == -1) {
5717 HEAP32[$0 + 340 >> 2] = 0;
5718 $3 = 0;
5719 }
5720 HEAP8[$0 + 66 | 0] = $4;
5721 $6 = 0;
5722 HEAP16[$0 + 62 >> 1] = 0;
5723 HEAP16[$0 + 64 >> 1] = 0;
5724 HEAP8[$0 + 61 | 0] = $3 >>> 24;
5725 HEAP8[$0 + 60 | 0] = $3 >>> 16;
5726 HEAP8[$0 + 59 | 0] = $3 >>> 8;
5727 HEAP8[$0 + 58 | 0] = $3;
5728 $14 = 1;
5729 HEAP32[$0 + 340 >> 2] = $3 + 1;
5730 if (($4 | 0) >= 1) {
5731 $3 = 0;
5732 while (1) {
5733 $5 = HEAP32[$2 + ($3 << 2) >> 2];
5734 HEAP8[($0 + $3 | 0) + 67 | 0] = $5;
5735 $6 = ($5 & 255) + $6 | 0;
5736 $3 = $3 + 1 | 0;
5737 if (($4 | 0) != ($3 | 0)) {
5738 continue
5739 }
5740 break;
5741 };
5742 }
5743 HEAP32[$1 >> 2] = $0 + 40;
5744 $3 = $4 + 27 | 0;
5745 HEAP32[$0 + 324 >> 2] = $3;
5746 HEAP32[$1 + 4 >> 2] = $3;
5747 $3 = HEAP32[$0 + 12 >> 2];
5748 HEAP32[$1 + 12 >> 2] = $6;
5749 HEAP32[$1 + 8 >> 2] = $3 + $10;
5750 $3 = $8 - $4 | 0;
5751 HEAP32[$0 + 28 >> 2] = $3;
5752 memmove($2, $2 + ($4 << 2) | 0, $3 << 2);
5753 $2 = HEAP32[$0 + 20 >> 2];
5754 memmove($2, $2 + ($4 << 3) | 0, HEAP32[$0 + 28 >> 2] << 3);
5755 HEAP32[$0 + 12 >> 2] = HEAP32[$0 + 12 >> 2] + $6;
5756 if (!$1) {
5757 break label$1
5758 }
5759 $0 = 0;
5760 HEAP8[HEAP32[$1 >> 2] + 22 | 0] = 0;
5761 HEAP8[HEAP32[$1 >> 2] + 23 | 0] = 0;
5762 HEAP8[HEAP32[$1 >> 2] + 24 | 0] = 0;
5763 HEAP8[HEAP32[$1 >> 2] + 25 | 0] = 0;
5764 $2 = HEAP32[$1 + 4 >> 2];
5765 if (($2 | 0) >= 1) {
5766 $4 = HEAP32[$1 >> 2];
5767 $3 = 0;
5768 while (1) {
5769 $0 = HEAP32[((HEAPU8[$3 + $4 | 0] ^ $0 >>> 24) << 2) + 6512 >> 2] ^ $0 << 8;
5770 $3 = $3 + 1 | 0;
5771 if (($2 | 0) != ($3 | 0)) {
5772 continue
5773 }
5774 break;
5775 };
5776 }
5777 $2 = HEAP32[$1 + 12 >> 2];
5778 if (($2 | 0) >= 1) {
5779 $4 = HEAP32[$1 + 8 >> 2];
5780 $3 = 0;
5781 while (1) {
5782 $0 = HEAP32[((HEAPU8[$3 + $4 | 0] ^ $0 >>> 24) << 2) + 6512 >> 2] ^ $0 << 8;
5783 $3 = $3 + 1 | 0;
5784 if (($2 | 0) != ($3 | 0)) {
5785 continue
5786 }
5787 break;
5788 };
5789 }
5790 HEAP8[HEAP32[$1 >> 2] + 22 | 0] = $0;
5791 HEAP8[HEAP32[$1 >> 2] + 23 | 0] = $0 >>> 8;
5792 HEAP8[HEAP32[$1 >> 2] + 24 | 0] = $0 >>> 16;
5793 HEAP8[HEAP32[$1 >> 2] + 25 | 0] = $0 >>> 24;
5794 }
5795 return $14;
5796 }
5797
5798 function ogg_stream_pageout($0, $1) {
5799 var $2 = 0, $3 = 0, $4 = 0;
5800 if (!(!$0 | !HEAP32[$0 >> 2])) {
5801 $2 = HEAP32[$0 + 28 >> 2];
5802 $4 = $0;
5803 label$2 : {
5804 label$3 : {
5805 if (HEAP32[$0 + 328 >> 2]) {
5806 if ($2) {
5807 break label$3
5808 }
5809 $3 = 0;
5810 break label$2;
5811 }
5812 $3 = 0;
5813 if (HEAP32[$0 + 332 >> 2] | !$2) {
5814 break label$2
5815 }
5816 }
5817 $3 = 1;
5818 }
5819 $2 = ogg_stream_flush_i($4, $1, $3);
5820 }
5821 return $2;
5822 }
5823
5824 function ogg_sync_init($0) {
5825 if ($0) {
5826 HEAP32[$0 >> 2] = 0;
5827 HEAP32[$0 + 4 >> 2] = 0;
5828 HEAP32[$0 + 24 >> 2] = 0;
5829 HEAP32[$0 + 16 >> 2] = 0;
5830 HEAP32[$0 + 20 >> 2] = 0;
5831 HEAP32[$0 + 8 >> 2] = 0;
5832 HEAP32[$0 + 12 >> 2] = 0;
5833 }
5834 return 0;
5835 }
5836
5837 function ogg_sync_clear($0) {
5838 var $1 = 0;
5839 if ($0) {
5840 $1 = HEAP32[$0 >> 2];
5841 if ($1) {
5842 dlfree($1)
5843 }
5844 HEAP32[$0 >> 2] = 0;
5845 HEAP32[$0 + 4 >> 2] = 0;
5846 HEAP32[$0 + 24 >> 2] = 0;
5847 HEAP32[$0 + 16 >> 2] = 0;
5848 HEAP32[$0 + 20 >> 2] = 0;
5849 HEAP32[$0 + 8 >> 2] = 0;
5850 HEAP32[$0 + 12 >> 2] = 0;
5851 }
5852 }
5853
5854 function ogg_sync_buffer($0, $1) {
5855 var $2 = 0, $3 = 0, $4 = 0;
5856 $2 = HEAP32[$0 + 4 >> 2];
5857 if (($2 | 0) >= 0) {
5858 $4 = HEAP32[$0 + 12 >> 2];
5859 if ($4) {
5860 $3 = HEAP32[$0 + 8 >> 2] - $4 | 0;
5861 HEAP32[$0 + 8 >> 2] = $3;
5862 if (($3 | 0) >= 1) {
5863 $2 = HEAP32[$0 >> 2];
5864 memmove($2, $2 + $4 | 0, $3);
5865 $2 = HEAP32[$0 + 4 >> 2];
5866 }
5867 HEAP32[$0 + 12 >> 2] = 0;
5868 }
5869 $3 = $2;
5870 $2 = HEAP32[$0 + 8 >> 2];
5871 label$4 : {
5872 if (($3 - $2 | 0) >= ($1 | 0)) {
5873 $1 = HEAP32[$0 >> 2];
5874 break label$4;
5875 }
5876 $2 = ($1 + $2 | 0) + 4096 | 0;
5877 $1 = HEAP32[$0 >> 2];
5878 label$6 : {
5879 if ($1) {
5880 $1 = dlrealloc($1, $2);
5881 break label$6;
5882 }
5883 $1 = dlmalloc($2);
5884 }
5885 if (!$1) {
5886 $1 = HEAP32[$0 >> 2];
5887 if ($1) {
5888 dlfree($1)
5889 }
5890 HEAP32[$0 >> 2] = 0;
5891 HEAP32[$0 + 4 >> 2] = 0;
5892 HEAP32[$0 + 24 >> 2] = 0;
5893 HEAP32[$0 + 16 >> 2] = 0;
5894 HEAP32[$0 + 20 >> 2] = 0;
5895 HEAP32[$0 + 8 >> 2] = 0;
5896 HEAP32[$0 + 12 >> 2] = 0;
5897 return 0;
5898 }
5899 HEAP32[$0 + 4 >> 2] = $2;
5900 HEAP32[$0 >> 2] = $1;
5901 $2 = HEAP32[$0 + 8 >> 2];
5902 }
5903 $0 = $1 + $2 | 0;
5904 } else {
5905 $0 = 0
5906 }
5907 return $0;
5908 }
5909
5910 function ogg_sync_wrote($0, $1) {
5911 var $2 = 0, $3 = 0;
5912 $2 = -1;
5913 $3 = HEAP32[$0 + 4 >> 2];
5914 label$1 : {
5915 if (($3 | 0) < 0) {
5916 break label$1
5917 }
5918 $1 = HEAP32[$0 + 8 >> 2] + $1 | 0;
5919 if (($1 | 0) > ($3 | 0)) {
5920 break label$1
5921 }
5922 HEAP32[$0 + 8 >> 2] = $1;
5923 $2 = 0;
5924 }
5925 return $2;
5926 }
5927
5928 function ogg_sync_pageseek($0, $1) {
5929 var $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0;
5930 $9 = global$0 - 16 | 0;
5931 global$0 = $9;
5932 label$1 : {
5933 if (HEAP32[$0 + 4 >> 2] < 0) {
5934 break label$1
5935 }
5936 $4 = HEAP32[$0 + 12 >> 2];
5937 $10 = HEAP32[$0 + 8 >> 2] - $4 | 0;
5938 $2 = $4 + HEAP32[$0 >> 2] | 0;
5939 label$2 : {
5940 label$3 : {
5941 label$4 : {
5942 $5 = HEAP32[$0 + 20 >> 2];
5943 label$5 : {
5944 if (!$5) {
5945 if (($10 | 0) < 27) {
5946 break label$1
5947 }
5948 if ((HEAPU8[$2 | 0] | HEAPU8[$2 + 1 | 0] << 8 | (HEAPU8[$2 + 2 | 0] << 16 | HEAPU8[$2 + 3 | 0] << 24)) != 1399285583) {
5949 break label$5
5950 }
5951 $4 = HEAPU8[$2 + 26 | 0];
5952 $5 = $4 + 27 | 0;
5953 if (($10 | 0) < ($5 | 0)) {
5954 break label$1
5955 }
5956 if ($4) {
5957 $4 = HEAP32[$0 + 24 >> 2];
5958 while (1) {
5959 $4 = HEAPU8[($2 + $6 | 0) + 27 | 0] + $4 | 0;
5960 HEAP32[$0 + 24 >> 2] = $4;
5961 $6 = $6 + 1 | 0;
5962 if ($6 >>> 0 < HEAPU8[$2 + 26 | 0]) {
5963 continue
5964 }
5965 break;
5966 };
5967 }
5968 HEAP32[$0 + 20 >> 2] = $5;
5969 }
5970 if ((HEAP32[$0 + 24 >> 2] + $5 | 0) > ($10 | 0)) {
5971 break label$1
5972 }
5973 $7 = HEAPU8[$2 + 22 | 0] | HEAPU8[$2 + 23 | 0] << 8 | (HEAPU8[$2 + 24 | 0] << 16 | HEAPU8[$2 + 25 | 0] << 24);
5974 HEAP32[$9 + 12 >> 2] = $7;
5975 $6 = 0;
5976 HEAP8[$2 + 22 | 0] = 0;
5977 HEAP8[$2 + 23 | 0] = 0;
5978 HEAP8[$2 + 24 | 0] = 0;
5979 HEAP8[$2 + 25 | 0] = 0;
5980 $11 = HEAP32[$0 + 24 >> 2];
5981 $8 = HEAP32[$0 + 20 >> 2];
5982 HEAP8[$2 + 22 | 0] = 0;
5983 HEAP8[$2 + 23 | 0] = 0;
5984 HEAP8[$2 + 24 | 0] = 0;
5985 HEAP8[$2 + 25 | 0] = 0;
5986 if (($8 | 0) > 0) {
5987 $5 = 0;
5988 while (1) {
5989 $3 = HEAP32[((HEAPU8[$2 + $5 | 0] ^ $3 >>> 24) << 2) + 6512 >> 2] ^ $3 << 8;
5990 $5 = $5 + 1 | 0;
5991 if (($8 | 0) != ($5 | 0)) {
5992 continue
5993 }
5994 break;
5995 };
5996 }
5997 $4 = $2 + 22 | 0;
5998 if (($11 | 0) > 0) {
5999 $8 = $2 + $8 | 0;
6000 while (1) {
6001 $3 = HEAP32[((HEAPU8[$6 + $8 | 0] ^ $3 >>> 24) << 2) + 6512 >> 2] ^ $3 << 8;
6002 $6 = $6 + 1 | 0;
6003 if (($11 | 0) != ($6 | 0)) {
6004 continue
6005 }
6006 break;
6007 };
6008 }
6009 HEAP8[$2 + 22 | 0] = $3;
6010 HEAP8[$2 + 23 | 0] = $3 >>> 8;
6011 HEAP8[$2 + 24 | 0] = $3 >>> 16;
6012 HEAP8[$2 + 25 | 0] = $3 >>> 24;
6013 if (HEAP32[$9 + 12 >> 2] == (HEAPU8[$4 | 0] | HEAPU8[$4 + 1 | 0] << 8 | (HEAPU8[$4 + 2 | 0] << 16 | HEAPU8[$4 + 3 | 0] << 24))) {
6014 break label$4
6015 }
6016 HEAP8[$4 | 0] = $7;
6017 HEAP8[$4 + 1 | 0] = $7 >>> 8;
6018 HEAP8[$4 + 2 | 0] = $7 >>> 16;
6019 HEAP8[$4 + 3 | 0] = $7 >>> 24;
6020 }
6021 HEAP32[$0 + 20 >> 2] = 0;
6022 HEAP32[$0 + 24 >> 2] = 0;
6023 $3 = memchr($2 + 1 | 0, $10 + -1 | 0);
6024 if (!$3) {
6025 break label$3
6026 }
6027 $6 = HEAP32[$0 >> 2];
6028 break label$2;
6029 }
6030 $7 = HEAP32[$0 + 12 >> 2];
6031 label$13 : {
6032 if (!$1) {
6033 $5 = HEAP32[$0 + 24 >> 2];
6034 $3 = HEAP32[$0 + 20 >> 2];
6035 break label$13;
6036 }
6037 $4 = $7 + HEAP32[$0 >> 2] | 0;
6038 HEAP32[$1 >> 2] = $4;
6039 $3 = HEAP32[$0 + 20 >> 2];
6040 HEAP32[$1 + 4 >> 2] = $3;
6041 HEAP32[$1 + 8 >> 2] = $3 + $4;
6042 $5 = HEAP32[$0 + 24 >> 2];
6043 HEAP32[$1 + 12 >> 2] = $5;
6044 }
6045 HEAP32[$0 + 24 >> 2] = 0;
6046 HEAP32[$0 + 16 >> 2] = 0;
6047 HEAP32[$0 + 20 >> 2] = 0;
6048 $3 = $3 + $5 | 0;
6049 HEAP32[$0 + 12 >> 2] = $7 + $3;
6050 break label$1;
6051 }
6052 $6 = HEAP32[$0 >> 2];
6053 $3 = $6 + HEAP32[$0 + 8 >> 2] | 0;
6054 }
6055 HEAP32[$0 + 12 >> 2] = $3 - $6;
6056 $3 = $2 - $3 | 0;
6057 }
6058 global$0 = $9 + 16 | 0;
6059 return $3;
6060 }
6061
6062 function ogg_sync_pageout($0, $1) {
6063 var $2 = 0;
6064 if (HEAP32[$0 + 4 >> 2] >= 0) {
6065 while (1) {
6066 $2 = ogg_sync_pageseek($0, $1);
6067 if (($2 | 0) > 0) {
6068 return 1
6069 }
6070 if (!$2) {
6071 return 0
6072 }
6073 if (HEAP32[$0 + 16 >> 2]) {
6074 continue
6075 }
6076 break;
6077 };
6078 HEAP32[$0 + 16 >> 2] = 1;
6079 $0 = -1;
6080 } else {
6081 $0 = 0
6082 }
6083 return $0;
6084 }
6085
6086 function ogg_stream_pagein($0, $1) {
6087 var $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0;
6088 $4 = -1;
6089 folding_inner0 : {
6090 label$1 : {
6091 if (!$0) {
6092 break label$1
6093 }
6094 $6 = HEAP32[$0 >> 2];
6095 if (!$6) {
6096 break label$1
6097 }
6098 $3 = HEAP32[$1 >> 2];
6099 $10 = HEAPU8[$3 + 5 | 0];
6100 $5 = HEAP32[$1 + 12 >> 2];
6101 $11 = HEAP32[$1 + 8 >> 2];
6102 $8 = HEAPU8[$3 + 26 | 0];
6103 $13 = HEAPU8[$3 + 18 | 0] | HEAPU8[$3 + 19 | 0] << 8 | (HEAPU8[$3 + 20 | 0] << 16 | HEAPU8[$3 + 21 | 0] << 24);
6104 $9 = HEAPU8[$3 + 14 | 0] | HEAPU8[$3 + 15 | 0] << 8 | (HEAPU8[$3 + 16 | 0] << 16 | HEAPU8[$3 + 17 | 0] << 24);
6105 $14 = HEAPU8[$3 + 6 | 0] | HEAPU8[$3 + 7 | 0] << 8 | (HEAPU8[$3 + 8 | 0] << 16 | HEAPU8[$3 + 9 | 0] << 24);
6106 $15 = HEAPU8[$3 + 10 | 0] | HEAPU8[$3 + 11 | 0] << 8 | (HEAPU8[$3 + 12 | 0] << 16 | HEAPU8[$3 + 13 | 0] << 24);
6107 $12 = HEAPU8[$3 + 4 | 0];
6108 $2 = HEAP32[$0 + 36 >> 2];
6109 $1 = HEAP32[$0 + 12 >> 2];
6110 if ($1) {
6111 $7 = HEAP32[$0 + 8 >> 2] - $1 | 0;
6112 HEAP32[$0 + 8 >> 2] = $7;
6113 if ($7) {
6114 memmove($6, $1 + $6 | 0, $7)
6115 }
6116 HEAP32[$0 + 12 >> 2] = 0;
6117 }
6118 if ($2) {
6119 $1 = $0;
6120 $6 = HEAP32[$0 + 28 >> 2] - $2 | 0;
6121 if ($6) {
6122 $7 = HEAP32[$0 + 16 >> 2];
6123 memmove($7, $7 + ($2 << 2) | 0, $6 << 2);
6124 $6 = HEAP32[$0 + 20 >> 2];
6125 memmove($6, $6 + ($2 << 3) | 0, HEAP32[$0 + 28 >> 2] - $2 << 3);
6126 $7 = HEAP32[$0 + 28 >> 2] - $2 | 0;
6127 } else {
6128 $7 = 0
6129 }
6130 HEAP32[$1 + 28 >> 2] = $7;
6131 HEAP32[$0 + 36 >> 2] = 0;
6132 HEAP32[$0 + 32 >> 2] = HEAP32[$0 + 32 >> 2] - $2;
6133 }
6134 if (($9 | 0) != HEAP32[$0 + 336 >> 2] | $12) {
6135 break label$1
6136 }
6137 if (_os_lacing_expand($0, $8 + 1 | 0)) {
6138 break label$1
6139 }
6140 $7 = $10 & 1;
6141 $6 = HEAP32[$0 + 340 >> 2];
6142 label$7 : {
6143 if (($6 | 0) == ($13 | 0)) {
6144 break label$7
6145 }
6146 $2 = HEAP32[$0 + 32 >> 2];
6147 $9 = HEAP32[$0 + 28 >> 2];
6148 if (($2 | 0) < ($9 | 0)) {
6149 $4 = HEAP32[$0 + 8 >> 2];
6150 $12 = HEAP32[$0 + 16 >> 2];
6151 $1 = $2;
6152 while (1) {
6153 $4 = $4 - HEAPU8[$12 + ($1 << 2) | 0] | 0;
6154 $1 = $1 + 1 | 0;
6155 if (($1 | 0) < ($9 | 0)) {
6156 continue
6157 }
6158 break;
6159 };
6160 HEAP32[$0 + 8 >> 2] = $4;
6161 }
6162 HEAP32[$0 + 28 >> 2] = $2;
6163 if (($6 | 0) == -1) {
6164 break label$7
6165 }
6166 $1 = $2 + 1 | 0;
6167 HEAP32[$0 + 28 >> 2] = $1;
6168 HEAP32[HEAP32[$0 + 16 >> 2] + ($2 << 2) >> 2] = 1024;
6169 HEAP32[$0 + 32 >> 2] = $1;
6170 }
6171 $6 = $10 & 2;
6172 $4 = 0;
6173 label$10 : {
6174 if (!$7) {
6175 break label$10
6176 }
6177 $1 = HEAP32[$0 + 28 >> 2];
6178 if (HEAP32[(HEAP32[$0 + 16 >> 2] + ($1 << 2) | 0) + -4 >> 2] != 1024 ? ($1 | 0) >= 1 : 0) {
6179 break label$10
6180 }
6181 $6 = 0;
6182 if (!$8) {
6183 break label$10
6184 }
6185 $1 = 0;
6186 while (1) {
6187 $4 = $1 + 1 | 0;
6188 $1 = HEAPU8[($1 + $3 | 0) + 27 | 0];
6189 $5 = $5 - $1 | 0;
6190 $11 = $1 + $11 | 0;
6191 if (($1 | 0) != 255) {
6192 break label$10
6193 }
6194 $1 = $4;
6195 if (($8 | 0) != ($1 | 0)) {
6196 continue
6197 }
6198 break;
6199 };
6200 $4 = $8;
6201 }
6202 if ($5) {
6203 $2 = HEAP32[$0 + 4 >> 2];
6204 $1 = HEAP32[$0 + 8 >> 2];
6205 label$15 : {
6206 if (($2 - $5 | 0) > ($1 | 0)) {
6207 $2 = HEAP32[$0 >> 2];
6208 break label$15;
6209 }
6210 if (($2 | 0) > (2147483647 - $5 | 0)) {
6211 break folding_inner0
6212 }
6213 $1 = $2 + $5 | 0;
6214 $1 = ($1 | 0) < 2147482623 ? $1 + 1024 | 0 : $1;
6215 $2 = dlrealloc(HEAP32[$0 >> 2], $1);
6216 if (!$2) {
6217 break folding_inner0
6218 }
6219 HEAP32[$0 >> 2] = $2;
6220 HEAP32[$0 + 4 >> 2] = $1;
6221 $1 = HEAP32[$0 + 8 >> 2];
6222 }
6223 memcpy($1 + $2 | 0, $11, $5);
6224 HEAP32[$0 + 8 >> 2] = HEAP32[$0 + 8 >> 2] + $5;
6225 }
6226 $11 = $10 & 4;
6227 label$25 : {
6228 if (($4 | 0) >= ($8 | 0)) {
6229 break label$25
6230 }
6231 $10 = HEAP32[$0 + 20 >> 2];
6232 $7 = HEAP32[$0 + 16 >> 2];
6233 $2 = HEAP32[$0 + 28 >> 2];
6234 $1 = $7 + ($2 << 2) | 0;
6235 $5 = HEAPU8[($3 + $4 | 0) + 27 | 0];
6236 HEAP32[$1 >> 2] = $5;
6237 $9 = $10 + ($2 << 3) | 0;
6238 HEAP32[$9 >> 2] = -1;
6239 HEAP32[$9 + 4 >> 2] = -1;
6240 if ($6) {
6241 HEAP32[$1 >> 2] = $5 | 256
6242 }
6243 $1 = $2 + 1 | 0;
6244 HEAP32[$0 + 28 >> 2] = $1;
6245 $4 = $4 + 1 | 0;
6246 label$27 : {
6247 if (($5 | 0) == 255) {
6248 $2 = -1;
6249 break label$27;
6250 }
6251 HEAP32[$0 + 32 >> 2] = $1;
6252 }
6253 if (($4 | 0) != ($8 | 0)) {
6254 while (1) {
6255 $6 = HEAPU8[($3 + $4 | 0) + 27 | 0];
6256 HEAP32[$7 + ($1 << 2) >> 2] = $6;
6257 $5 = $10 + ($1 << 3) | 0;
6258 HEAP32[$5 >> 2] = -1;
6259 HEAP32[$5 + 4 >> 2] = -1;
6260 $5 = $1 + 1 | 0;
6261 HEAP32[$0 + 28 >> 2] = $5;
6262 $4 = $4 + 1 | 0;
6263 if (($6 | 0) != 255) {
6264 HEAP32[$0 + 32 >> 2] = $5;
6265 $2 = $1;
6266 }
6267 $1 = $5;
6268 if (($4 | 0) != ($8 | 0)) {
6269 continue
6270 }
6271 break;
6272 }
6273 }
6274 if (($2 | 0) == -1) {
6275 break label$25
6276 }
6277 $1 = HEAP32[$0 + 20 >> 2] + ($2 << 3) | 0;
6278 HEAP32[$1 >> 2] = $14;
6279 HEAP32[$1 + 4 >> 2] = $15;
6280 }
6281 label$32 : {
6282 if (!$11) {
6283 break label$32
6284 }
6285 HEAP32[$0 + 328 >> 2] = 1;
6286 $1 = HEAP32[$0 + 28 >> 2];
6287 if (($1 | 0) < 1) {
6288 break label$32
6289 }
6290 $1 = (HEAP32[$0 + 16 >> 2] + ($1 << 2) | 0) + -4 | 0;
6291 HEAP32[$1 >> 2] = HEAP32[$1 >> 2] | 512;
6292 }
6293 HEAP32[$0 + 340 >> 2] = $13 + 1;
6294 $4 = 0;
6295 }
6296 return $4;
6297 }
6298 $1 = HEAP32[$0 >> 2];
6299 if ($1) {
6300 dlfree($1)
6301 }
6302 $1 = HEAP32[$0 + 16 >> 2];
6303 if ($1) {
6304 dlfree($1)
6305 }
6306 $1 = HEAP32[$0 + 20 >> 2];
6307 if ($1) {
6308 dlfree($1)
6309 }
6310 memset($0, 360);
6311 return -1;
6312 }
6313
6314 function ogg_sync_reset($0) {
6315 if (HEAP32[$0 + 4 >> 2] < 0) {
6316 return
6317 }
6318 HEAP32[$0 + 8 >> 2] = 0;
6319 HEAP32[$0 + 12 >> 2] = 0;
6320 HEAP32[$0 + 24 >> 2] = 0;
6321 HEAP32[$0 + 16 >> 2] = 0;
6322 HEAP32[$0 + 20 >> 2] = 0;
6323 }
6324
6325 function ogg_stream_reset($0) {
6326 if (!$0 | !HEAP32[$0 >> 2]) {
6327 $0 = -1
6328 } else {
6329 HEAP32[$0 + 344 >> 2] = 0;
6330 HEAP32[$0 + 348 >> 2] = 0;
6331 HEAP32[$0 + 340 >> 2] = -1;
6332 HEAP32[$0 + 332 >> 2] = 0;
6333 HEAP32[$0 + 324 >> 2] = 0;
6334 HEAP32[$0 + 328 >> 2] = 0;
6335 HEAP32[$0 + 36 >> 2] = 0;
6336 HEAP32[$0 + 28 >> 2] = 0;
6337 HEAP32[$0 + 32 >> 2] = 0;
6338 HEAP32[$0 + 8 >> 2] = 0;
6339 HEAP32[$0 + 12 >> 2] = 0;
6340 HEAP32[$0 + 352 >> 2] = 0;
6341 HEAP32[$0 + 356 >> 2] = 0;
6342 $0 = 0;
6343 }
6344 }
6345
6346 function ogg_stream_packetout($0, $1) {
6347 var $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0;
6348 label$1 : {
6349 if (!$0) {
6350 break label$1
6351 }
6352 $8 = HEAP32[$0 >> 2];
6353 if (!$8) {
6354 break label$1
6355 }
6356 $5 = HEAP32[$0 + 36 >> 2];
6357 if (HEAP32[$0 + 32 >> 2] <= ($5 | 0)) {
6358 break label$1
6359 }
6360 $3 = HEAP32[$0 + 16 >> 2];
6361 $6 = HEAP32[$3 + ($5 << 2) >> 2];
6362 if ($6 & 1024) {
6363 HEAP32[$0 + 36 >> 2] = $5 + 1;
6364 $1 = $0;
6365 $3 = $0;
6366 $2 = HEAP32[$0 + 348 >> 2];
6367 $0 = HEAP32[$0 + 344 >> 2] + 1 | 0;
6368 if ($0 >>> 0 < 1) {
6369 $2 = $2 + 1 | 0
6370 }
6371 HEAP32[$3 + 344 >> 2] = $0;
6372 HEAP32[$1 + 348 >> 2] = $2;
6373 return -1;
6374 }
6375 $4 = $6 & 512;
6376 $7 = 255;
6377 $2 = $6 & 255;
6378 label$3 : {
6379 if (($2 | 0) != 255) {
6380 $7 = $2;
6381 break label$3;
6382 }
6383 while (1) {
6384 $5 = $5 + 1 | 0;
6385 $2 = HEAP32[($5 << 2) + $3 >> 2];
6386 $4 = $2 & 512 ? 512 : $4;
6387 $2 = $2 & 255;
6388 $7 = $2 + $7 | 0;
6389 if (($2 | 0) == 255) {
6390 continue
6391 }
6392 break;
6393 };
6394 }
6395 label$6 : {
6396 if (!$1) {
6397 $4 = HEAP32[$0 + 344 >> 2];
6398 $2 = HEAP32[$0 + 348 >> 2];
6399 $6 = HEAP32[$0 + 12 >> 2];
6400 break label$6;
6401 }
6402 HEAP32[$1 + 8 >> 2] = $6 & 256;
6403 HEAP32[$1 + 12 >> 2] = $4;
6404 $6 = HEAP32[$0 + 12 >> 2];
6405 HEAP32[$1 >> 2] = $8 + $6;
6406 $3 = HEAP32[$0 + 348 >> 2];
6407 $2 = $3;
6408 $4 = HEAP32[$0 + 344 >> 2];
6409 HEAP32[$1 + 24 >> 2] = $4;
6410 HEAP32[$1 + 28 >> 2] = $2;
6411 $3 = HEAP32[$0 + 20 >> 2] + ($5 << 3) | 0;
6412 $8 = HEAP32[$3 + 4 >> 2];
6413 $3 = HEAP32[$3 >> 2];
6414 HEAP32[$1 + 4 >> 2] = $7;
6415 HEAP32[$1 + 16 >> 2] = $3;
6416 HEAP32[$1 + 20 >> 2] = $8;
6417 }
6418 $3 = $4 + 1 | 0;
6419 if ($3 >>> 0 < 1) {
6420 $2 = $2 + 1 | 0
6421 }
6422 HEAP32[$0 + 344 >> 2] = $3;
6423 HEAP32[$0 + 348 >> 2] = $2;
6424 $4 = 1;
6425 HEAP32[$0 + 36 >> 2] = $5 + 1;
6426 HEAP32[$0 + 12 >> 2] = $6 + $7;
6427 }
6428 return $4;
6429 }
6430
6431 function FLAC__ogg_decoder_aspect_init($0) {
6432 var $1 = 0;
6433 label$1 : {
6434 if (ogg_stream_init($0 + 8 | 0, HEAP32[$0 + 4 >> 2])) {
6435 break label$1
6436 }
6437 if (ogg_sync_init($0 + 368 | 0)) {
6438 break label$1
6439 }
6440 HEAP32[$0 + 396 >> 2] = -1;
6441 HEAP32[$0 + 400 >> 2] = -1;
6442 HEAP32[$0 + 408 >> 2] = 0;
6443 HEAP32[$0 + 412 >> 2] = 0;
6444 HEAP32[$0 + 404 >> 2] = HEAP32[$0 >> 2];
6445 $1 = 1;
6446 }
6447 return $1;
6448 }
6449
6450 function FLAC__ogg_decoder_aspect_set_defaults($0) {
6451 HEAP32[$0 >> 2] = 1;
6452 }
6453
6454 function FLAC__ogg_decoder_aspect_reset($0) {
6455 ogg_stream_reset($0 + 8 | 0);
6456 ogg_sync_reset($0 + 368 | 0);
6457 HEAP32[$0 + 408 >> 2] = 0;
6458 HEAP32[$0 + 412 >> 2] = 0;
6459 if (HEAP32[$0 >> 2]) {
6460 HEAP32[$0 + 404 >> 2] = 1
6461 }
6462 }
6463
6464 function FLAC__ogg_decoder_aspect_read_callback_wrapper($0, $1, $2, $3, $4) {
6465 var $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0;
6466 $8 = global$0 - 16 | 0;
6467 global$0 = $8;
6468 $9 = HEAP32[$2 >> 2];
6469 HEAP32[$2 >> 2] = 0;
6470 label$1 : {
6471 label$2 : {
6472 label$3 : {
6473 if (!$9) {
6474 break label$3
6475 }
6476 $10 = $0 + 416 | 0;
6477 $11 = $0 + 368 | 0;
6478 $13 = $0 + 440 | 0;
6479 $14 = $0 + 8 | 0;
6480 $15 = HEAP32[2721];
6481 $16 = HEAPU8[7536];
6482 while (1) {
6483 if (HEAP32[$0 + 408 >> 2]) {
6484 break label$3
6485 }
6486 label$5 : {
6487 label$6 : {
6488 if (HEAP32[$0 + 412 >> 2]) {
6489 if (HEAP32[$0 + 432 >> 2]) {
6490 $7 = HEAP32[$0 + 440 >> 2];
6491 $6 = HEAP32[$0 + 444 >> 2];
6492 $5 = $9 - $5 | 0;
6493 if ($6 >>> 0 > $5 >>> 0) {
6494 break label$6
6495 }
6496 $1 = memcpy($1, $7, $6);
6497 HEAP32[$2 >> 2] = $6 + HEAP32[$2 >> 2];
6498 HEAP32[$0 + 432 >> 2] = 0;
6499 $1 = $1 + $6 | 0;
6500 break label$5;
6501 }
6502 $5 = ogg_stream_packetout($14, $13);
6503 if (($5 | 0) >= 1) {
6504 HEAP32[$0 + 432 >> 2] = 1;
6505 $12 = HEAP32[$0 + 444 >> 2];
6506 if (($12 | 0) < 1) {
6507 break label$5
6508 }
6509 $6 = HEAP32[$13 >> 2];
6510 if (HEAPU8[$6 | 0] != ($16 | 0)) {
6511 break label$5
6512 }
6513 $7 = 3;
6514 if (($12 | 0) < 9) {
6515 break label$1
6516 }
6517 $5 = $15;
6518 if ((HEAPU8[$6 + 1 | 0] | HEAPU8[$6 + 2 | 0] << 8 | (HEAPU8[$6 + 3 | 0] << 16 | HEAPU8[$6 + 4 | 0] << 24)) != (HEAPU8[$5 | 0] | HEAPU8[$5 + 1 | 0] << 8 | (HEAPU8[$5 + 2 | 0] << 16 | HEAPU8[$5 + 3 | 0] << 24))) {
6519 break label$1
6520 }
6521 $5 = HEAPU8[$6 + 5 | 0];
6522 HEAP32[$0 + 396 >> 2] = $5;
6523 HEAP32[$0 + 400 >> 2] = HEAPU8[$6 + 6 | 0];
6524 if (($5 | 0) != 1) {
6525 $7 = 4;
6526 break label$1;
6527 }
6528 HEAP32[$0 + 444 >> 2] = $12 + -9;
6529 HEAP32[$0 + 440 >> 2] = $6 + 9;
6530 break label$5;
6531 }
6532 if ($5) {
6533 $7 = 2;
6534 break label$1;
6535 }
6536 HEAP32[$0 + 412 >> 2] = 0;
6537 break label$5;
6538 }
6539 $5 = ogg_sync_pageout($11, $10);
6540 if (($5 | 0) >= 1) {
6541 if (HEAP32[$0 + 404 >> 2]) {
6542 $5 = ogg_page_serialno($10);
6543 HEAP32[$0 + 404 >> 2] = 0;
6544 HEAP32[$0 + 344 >> 2] = $5;
6545 HEAP32[$0 + 4 >> 2] = $5;
6546 }
6547 if (ogg_stream_pagein($14, $10)) {
6548 break label$5
6549 }
6550 HEAP32[$0 + 432 >> 2] = 0;
6551 HEAP32[$0 + 412 >> 2] = 1;
6552 break label$5;
6553 }
6554 if ($5) {
6555 $7 = 2;
6556 break label$1;
6557 }
6558 $5 = $9 - HEAP32[$2 >> 2] | 0;
6559 $5 = $5 >>> 0 > 8192 ? $5 : 8192;
6560 $6 = ogg_sync_buffer($11, $5);
6561 if (!$6) {
6562 $7 = 7;
6563 break label$1;
6564 }
6565 HEAP32[$8 + 12 >> 2] = $5;
6566 label$16 : {
6567 switch ((FUNCTION_TABLE[8]($3, $6, $8 + 12 | 0, $4) | 0) + -1 | 0) {
6568 case 0:
6569 HEAP32[$0 + 408 >> 2] = 1;
6570 break;
6571 case 4:
6572 break label$2;
6573 default:
6574 break label$16;
6575 };
6576 }
6577 if ((ogg_sync_wrote($11, HEAP32[$8 + 12 >> 2]) | 0) >= 0) {
6578 break label$5
6579 }
6580 $7 = 6;
6581 break label$1;
6582 }
6583 $1 = memcpy($1, $7, $5);
6584 HEAP32[$2 >> 2] = $5 + HEAP32[$2 >> 2];
6585 HEAP32[$0 + 440 >> 2] = $5 + HEAP32[$0 + 440 >> 2];
6586 HEAP32[$0 + 444 >> 2] = HEAP32[$0 + 444 >> 2] - $5;
6587 $1 = $1 + $5 | 0;
6588 }
6589 $5 = HEAP32[$2 >> 2];
6590 if ($9 >>> 0 > $5 >>> 0) {
6591 continue
6592 }
6593 break;
6594 };
6595 }
6596 global$0 = $8 + 16 | 0;
6597 return !$5 & HEAP32[$0 + 408 >> 2] != 0;
6598 }
6599 $7 = 5;
6600 }
6601 global$0 = $8 + 16 | 0;
6602 return $7;
6603 }
6604
6605 function FLAC__MD5Init($0) {
6606 HEAP32[$0 + 80 >> 2] = 0;
6607 HEAP32[$0 + 84 >> 2] = 0;
6608 HEAP32[$0 + 64 >> 2] = 1732584193;
6609 HEAP32[$0 + 68 >> 2] = -271733879;
6610 HEAP32[$0 + 72 >> 2] = -1732584194;
6611 HEAP32[$0 + 76 >> 2] = 271733878;
6612 HEAP32[$0 + 88 >> 2] = 0;
6613 HEAP32[$0 + 92 >> 2] = 0;
6614 }
6615
6616 function FLAC__MD5Final($0, $1) {
6617 var $2 = 0, $3 = 0, $4 = 0;
6618 $3 = HEAP32[$1 + 80 >> 2] & 63;
6619 $2 = $3 + $1 | 0;
6620 HEAP8[$2 | 0] = 128;
6621 $2 = $2 + 1 | 0;
6622 $4 = 56;
6623 label$1 : {
6624 if ($3 >>> 0 < 56) {
6625 $4 = 55 - $3 | 0;
6626 break label$1;
6627 }
6628 memset($2, $3 ^ 63);
6629 FLAC__MD5Transform($1 - -64 | 0, $1);
6630 $2 = $1;
6631 }
6632 memset($2, $4);
6633 $2 = HEAP32[$1 + 80 >> 2];
6634 HEAP32[$1 + 56 >> 2] = $2 << 3;
6635 HEAP32[$1 + 60 >> 2] = HEAP32[$1 + 84 >> 2] << 3 | $2 >>> 29;
6636 FLAC__MD5Transform($1 - -64 | 0, $1);
6637 $2 = HEAPU8[$1 + 76 | 0] | HEAPU8[$1 + 77 | 0] << 8 | (HEAPU8[$1 + 78 | 0] << 16 | HEAPU8[$1 + 79 | 0] << 24);
6638 $3 = HEAPU8[$1 + 72 | 0] | HEAPU8[$1 + 73 | 0] << 8 | (HEAPU8[$1 + 74 | 0] << 16 | HEAPU8[$1 + 75 | 0] << 24);
6639 HEAP8[$0 + 8 | 0] = $3;
6640 HEAP8[$0 + 9 | 0] = $3 >>> 8;
6641 HEAP8[$0 + 10 | 0] = $3 >>> 16;
6642 HEAP8[$0 + 11 | 0] = $3 >>> 24;
6643 HEAP8[$0 + 12 | 0] = $2;
6644 HEAP8[$0 + 13 | 0] = $2 >>> 8;
6645 HEAP8[$0 + 14 | 0] = $2 >>> 16;
6646 HEAP8[$0 + 15 | 0] = $2 >>> 24;
6647 $2 = HEAPU8[$1 + 68 | 0] | HEAPU8[$1 + 69 | 0] << 8 | (HEAPU8[$1 + 70 | 0] << 16 | HEAPU8[$1 + 71 | 0] << 24);
6648 $3 = HEAPU8[$1 + 64 | 0] | HEAPU8[$1 + 65 | 0] << 8 | (HEAPU8[$1 + 66 | 0] << 16 | HEAPU8[$1 + 67 | 0] << 24);
6649 HEAP8[$0 | 0] = $3;
6650 HEAP8[$0 + 1 | 0] = $3 >>> 8;
6651 HEAP8[$0 + 2 | 0] = $3 >>> 16;
6652 HEAP8[$0 + 3 | 0] = $3 >>> 24;
6653 HEAP8[$0 + 4 | 0] = $2;
6654 HEAP8[$0 + 5 | 0] = $2 >>> 8;
6655 HEAP8[$0 + 6 | 0] = $2 >>> 16;
6656 HEAP8[$0 + 7 | 0] = $2 >>> 24;
6657 $0 = HEAP32[$1 + 88 >> 2];
6658 if ($0) {
6659 dlfree($0);
6660 HEAP32[$1 + 88 >> 2] = 0;
6661 HEAP32[$1 + 92 >> 2] = 0;
6662 }
6663 memset($1, 96);
6664 }
6665
6666 function FLAC__MD5Transform($0, $1) {
6667 var $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0, $23 = 0, $24 = 0, $25 = 0, $26 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
6668 $11 = HEAP32[$1 + 16 >> 2];
6669 $8 = HEAP32[$1 + 32 >> 2];
6670 $12 = HEAP32[$1 + 48 >> 2];
6671 $13 = HEAP32[$1 + 36 >> 2];
6672 $14 = HEAP32[$1 + 52 >> 2];
6673 $15 = HEAP32[$1 + 4 >> 2];
6674 $6 = HEAP32[$1 + 20 >> 2];
6675 $7 = HEAP32[$0 + 4 >> 2];
6676 $9 = HEAP32[$1 >> 2];
6677 $25 = HEAP32[$0 >> 2];
6678 $16 = HEAP32[$0 + 12 >> 2];
6679 $10 = HEAP32[$0 + 8 >> 2];
6680 $3 = $7 + __wasm_rotl_i32((($9 + $25 | 0) + ($16 ^ ($16 ^ $10) & $7) | 0) + -680876936 | 0, 7) | 0;
6681 $17 = HEAP32[$1 + 12 >> 2];
6682 $18 = HEAP32[$1 + 8 >> 2];
6683 $4 = __wasm_rotl_i32((($15 + $16 | 0) + ($3 & ($7 ^ $10) ^ $10) | 0) + -389564586 | 0, 12) + $3 | 0;
6684 $2 = __wasm_rotl_i32((($18 + $10 | 0) + ($4 & ($3 ^ $7) ^ $7) | 0) + 606105819 | 0, 17) + $4 | 0;
6685 $5 = __wasm_rotl_i32((($7 + $17 | 0) + ($3 ^ $2 & ($3 ^ $4)) | 0) + -1044525330 | 0, 22) + $2 | 0;
6686 $3 = __wasm_rotl_i32((($3 + $11 | 0) + ($4 ^ $5 & ($2 ^ $4)) | 0) + -176418897 | 0, 7) + $5 | 0;
6687 $19 = HEAP32[$1 + 28 >> 2];
6688 $20 = HEAP32[$1 + 24 >> 2];
6689 $4 = __wasm_rotl_i32((($4 + $6 | 0) + ($2 ^ $3 & ($2 ^ $5)) | 0) + 1200080426 | 0, 12) + $3 | 0;
6690 $2 = __wasm_rotl_i32((($2 + $20 | 0) + ($5 ^ $4 & ($3 ^ $5)) | 0) + -1473231341 | 0, 17) + $4 | 0;
6691 $5 = __wasm_rotl_i32((($5 + $19 | 0) + ($3 ^ $2 & ($3 ^ $4)) | 0) + -45705983 | 0, 22) + $2 | 0;
6692 $3 = __wasm_rotl_i32((($3 + $8 | 0) + ($4 ^ $5 & ($2 ^ $4)) | 0) + 1770035416 | 0, 7) + $5 | 0;
6693 $21 = HEAP32[$1 + 44 >> 2];
6694 $22 = HEAP32[$1 + 40 >> 2];
6695 $4 = __wasm_rotl_i32((($4 + $13 | 0) + ($2 ^ $3 & ($2 ^ $5)) | 0) + -1958414417 | 0, 12) + $3 | 0;
6696 $2 = __wasm_rotl_i32((($2 + $22 | 0) + ($5 ^ $4 & ($3 ^ $5)) | 0) + -42063 | 0, 17) + $4 | 0;
6697 $5 = __wasm_rotl_i32((($5 + $21 | 0) + ($3 ^ $2 & ($3 ^ $4)) | 0) + -1990404162 | 0, 22) + $2 | 0;
6698 $3 = __wasm_rotl_i32((($3 + $12 | 0) + ($4 ^ $5 & ($2 ^ $4)) | 0) + 1804603682 | 0, 7) + $5 | 0;
6699 $23 = HEAP32[$1 + 56 >> 2];
6700 $24 = HEAP32[$1 + 60 >> 2];
6701 $4 = __wasm_rotl_i32((($4 + $14 | 0) + ($2 ^ $3 & ($2 ^ $5)) | 0) + -40341101 | 0, 12) + $3 | 0;
6702 $1 = $4 + __wasm_rotl_i32((($2 + $23 | 0) + ($5 ^ ($3 ^ $5) & $4) | 0) + -1502002290 | 0, 17) | 0;
6703 $26 = $1 + $21 | 0;
6704 $2 = $3 + $15 | 0;
6705 $3 = __wasm_rotl_i32((($5 + $24 | 0) + ($3 ^ $1 & ($3 ^ $4)) | 0) + 1236535329 | 0, 22) + $1 | 0;
6706 $2 = __wasm_rotl_i32(($2 + ($1 ^ ($3 ^ $1) & $4) | 0) + -165796510 | 0, 5) + $3 | 0;
6707 $1 = __wasm_rotl_i32((($4 + $20 | 0) + ($3 ^ $1 & ($3 ^ $2)) | 0) + -1069501632 | 0, 9) + $2 | 0;
6708 $4 = __wasm_rotl_i32(($26 + (($2 ^ $1) & $3 ^ $2) | 0) + 643717713 | 0, 14) + $1 | 0;
6709 $3 = __wasm_rotl_i32((($3 + $9 | 0) + ($1 ^ $2 & ($1 ^ $4)) | 0) + -373897302 | 0, 20) + $4 | 0;
6710 $2 = __wasm_rotl_i32((($2 + $6 | 0) + ($4 ^ $1 & ($3 ^ $4)) | 0) + -701558691 | 0, 5) + $3 | 0;
6711 $1 = __wasm_rotl_i32((($1 + $22 | 0) + ($3 ^ $4 & ($3 ^ $2)) | 0) + 38016083 | 0, 9) + $2 | 0;
6712 $4 = __wasm_rotl_i32((($24 + $4 | 0) + (($2 ^ $1) & $3 ^ $2) | 0) + -660478335 | 0, 14) + $1 | 0;
6713 $3 = __wasm_rotl_i32((($3 + $11 | 0) + ($1 ^ $2 & ($1 ^ $4)) | 0) + -405537848 | 0, 20) + $4 | 0;
6714 $2 = __wasm_rotl_i32((($2 + $13 | 0) + ($4 ^ $1 & ($3 ^ $4)) | 0) + 568446438 | 0, 5) + $3 | 0;
6715 $1 = __wasm_rotl_i32((($1 + $23 | 0) + ($3 ^ $4 & ($3 ^ $2)) | 0) + -1019803690 | 0, 9) + $2 | 0;
6716 $4 = __wasm_rotl_i32((($4 + $17 | 0) + (($2 ^ $1) & $3 ^ $2) | 0) + -187363961 | 0, 14) + $1 | 0;
6717 $3 = __wasm_rotl_i32((($3 + $8 | 0) + ($1 ^ $2 & ($1 ^ $4)) | 0) + 1163531501 | 0, 20) + $4 | 0;
6718 $2 = __wasm_rotl_i32((($2 + $14 | 0) + ($4 ^ $1 & ($3 ^ $4)) | 0) + -1444681467 | 0, 5) + $3 | 0;
6719 $1 = __wasm_rotl_i32((($1 + $18 | 0) + ($3 ^ $4 & ($3 ^ $2)) | 0) + -51403784 | 0, 9) + $2 | 0;
6720 $4 = __wasm_rotl_i32((($4 + $19 | 0) + (($2 ^ $1) & $3 ^ $2) | 0) + 1735328473 | 0, 14) + $1 | 0;
6721 $5 = $1 ^ $4;
6722 $3 = __wasm_rotl_i32((($3 + $12 | 0) + ($1 ^ $5 & $2) | 0) + -1926607734 | 0, 20) + $4 | 0;
6723 $2 = __wasm_rotl_i32((($2 + $6 | 0) + ($3 ^ $5) | 0) + -378558 | 0, 4) + $3 | 0;
6724 $1 = __wasm_rotl_i32((($1 + $8 | 0) + ($3 ^ $4 ^ $2) | 0) + -2022574463 | 0, 11) + $2 | 0;
6725 $4 = __wasm_rotl_i32((($4 + $21 | 0) + ($1 ^ ($3 ^ $2)) | 0) + 1839030562 | 0, 16) + $1 | 0;
6726 $3 = __wasm_rotl_i32((($3 + $23 | 0) + ($4 ^ ($1 ^ $2)) | 0) + -35309556 | 0, 23) + $4 | 0;
6727 $2 = __wasm_rotl_i32((($2 + $15 | 0) + ($3 ^ ($1 ^ $4)) | 0) + -1530992060 | 0, 4) + $3 | 0;
6728 $1 = __wasm_rotl_i32((($1 + $11 | 0) + ($2 ^ ($3 ^ $4)) | 0) + 1272893353 | 0, 11) + $2 | 0;
6729 $4 = __wasm_rotl_i32((($4 + $19 | 0) + ($1 ^ ($3 ^ $2)) | 0) + -155497632 | 0, 16) + $1 | 0;
6730 $3 = __wasm_rotl_i32((($3 + $22 | 0) + ($4 ^ ($1 ^ $2)) | 0) + -1094730640 | 0, 23) + $4 | 0;
6731 $2 = __wasm_rotl_i32((($2 + $14 | 0) + ($3 ^ ($1 ^ $4)) | 0) + 681279174 | 0, 4) + $3 | 0;
6732 $1 = __wasm_rotl_i32((($1 + $9 | 0) + ($2 ^ ($3 ^ $4)) | 0) + -358537222 | 0, 11) + $2 | 0;
6733 $4 = __wasm_rotl_i32((($4 + $17 | 0) + ($1 ^ ($3 ^ $2)) | 0) + -722521979 | 0, 16) + $1 | 0;
6734 $3 = __wasm_rotl_i32((($3 + $20 | 0) + ($4 ^ ($1 ^ $2)) | 0) + 76029189 | 0, 23) + $4 | 0;
6735 $2 = __wasm_rotl_i32((($2 + $13 | 0) + ($3 ^ ($1 ^ $4)) | 0) + -640364487 | 0, 4) + $3 | 0;
6736 $1 = __wasm_rotl_i32((($1 + $12 | 0) + ($2 ^ ($3 ^ $4)) | 0) + -421815835 | 0, 11) + $2 | 0;
6737 $5 = $2 + $9 | 0;
6738 $9 = $1 ^ $2;
6739 $2 = __wasm_rotl_i32((($4 + $24 | 0) + ($1 ^ ($3 ^ $2)) | 0) + 530742520 | 0, 16) + $1 | 0;
6740 $4 = __wasm_rotl_i32((($3 + $18 | 0) + ($9 ^ $2) | 0) + -995338651 | 0, 23) + $2 | 0;
6741 $3 = __wasm_rotl_i32(($5 + (($4 | $1 ^ -1) ^ $2) | 0) + -198630844 | 0, 6) + $4 | 0;
6742 $5 = $4 + $6 | 0;
6743 $6 = $2 + $23 | 0;
6744 $2 = __wasm_rotl_i32((($1 + $19 | 0) + ($4 ^ ($3 | $2 ^ -1)) | 0) + 1126891415 | 0, 10) + $3 | 0;
6745 $4 = __wasm_rotl_i32(($6 + ($3 ^ ($2 | $4 ^ -1)) | 0) + -1416354905 | 0, 15) + $2 | 0;
6746 $1 = __wasm_rotl_i32(($5 + (($4 | $3 ^ -1) ^ $2) | 0) + -57434055 | 0, 21) + $4 | 0;
6747 $5 = $4 + $22 | 0;
6748 $6 = $2 + $17 | 0;
6749 $2 = __wasm_rotl_i32((($3 + $12 | 0) + ($4 ^ ($1 | $2 ^ -1)) | 0) + 1700485571 | 0, 6) + $1 | 0;
6750 $4 = __wasm_rotl_i32(($6 + ($1 ^ ($2 | $4 ^ -1)) | 0) + -1894986606 | 0, 10) + $2 | 0;
6751 $3 = __wasm_rotl_i32(($5 + (($4 | $1 ^ -1) ^ $2) | 0) + -1051523 | 0, 15) + $4 | 0;
6752 $5 = $4 + $24 | 0;
6753 $8 = $2 + $8 | 0;
6754 $2 = __wasm_rotl_i32((($1 + $15 | 0) + ($4 ^ ($3 | $2 ^ -1)) | 0) + -2054922799 | 0, 21) + $3 | 0;
6755 $4 = __wasm_rotl_i32(($8 + ($3 ^ ($2 | $4 ^ -1)) | 0) + 1873313359 | 0, 6) + $2 | 0;
6756 $1 = __wasm_rotl_i32(($5 + (($4 | $3 ^ -1) ^ $2) | 0) + -30611744 | 0, 10) + $4 | 0;
6757 $3 = __wasm_rotl_i32((($3 + $20 | 0) + ($4 ^ ($1 | $2 ^ -1)) | 0) + -1560198380 | 0, 15) + $1 | 0;
6758 $2 = __wasm_rotl_i32((($2 + $14 | 0) + ($1 ^ ($3 | $4 ^ -1)) | 0) + 1309151649 | 0, 21) + $3 | 0;
6759 $4 = __wasm_rotl_i32((($4 + $11 | 0) + (($2 | $1 ^ -1) ^ $3) | 0) + -145523070 | 0, 6) + $2 | 0;
6760 HEAP32[$0 >> 2] = $4 + $25;
6761 $1 = __wasm_rotl_i32((($1 + $21 | 0) + ($2 ^ ($4 | $3 ^ -1)) | 0) + -1120210379 | 0, 10) + $4 | 0;
6762 HEAP32[$0 + 12 >> 2] = $1 + $16;
6763 $3 = __wasm_rotl_i32((($3 + $18 | 0) + ($4 ^ ($1 | $2 ^ -1)) | 0) + 718787259 | 0, 15) + $1 | 0;
6764 HEAP32[$0 + 8 >> 2] = $3 + $10;
6765 (wasm2js_i32$0 = $0, wasm2js_i32$1 = __wasm_rotl_i32((($2 + $13 | 0) + ($1 ^ ($3 | $4 ^ -1)) | 0) + -343485551 | 0, 21) + ($3 + $7 | 0) | 0), HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1;
6766 }
6767
6768 function FLAC__MD5Accumulate($0, $1, $2, $3, $4) {
6769 var $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0;
6770 __wasm_i64_mul($4, 0, $2, 0);
6771 label$1 : {
6772 if (i64toi32_i32$HIGH_BITS) {
6773 break label$1
6774 }
6775 $7 = Math_imul($2, $4);
6776 __wasm_i64_mul($3, 0, $7, 0);
6777 if (i64toi32_i32$HIGH_BITS) {
6778 break label$1
6779 }
6780 $6 = HEAP32[$0 + 88 >> 2];
6781 $11 = Math_imul($3, $7);
6782 label$2 : {
6783 if (HEAPU32[$0 + 92 >> 2] >= $11 >>> 0) {
6784 $5 = $6;
6785 break label$2;
6786 }
6787 $5 = dlrealloc($6, $11);
6788 label$4 : {
6789 if (!$5) {
6790 dlfree($6);
6791 $5 = dlmalloc($11);
6792 HEAP32[$0 + 88 >> 2] = $5;
6793 if ($5) {
6794 break label$4
6795 }
6796 HEAP32[$0 + 92 >> 2] = 0;
6797 return 0;
6798 }
6799 HEAP32[$0 + 88 >> 2] = $5;
6800 }
6801 HEAP32[$0 + 92 >> 2] = $11;
6802 }
6803 label$6 : {
6804 label$7 : {
6805 label$8 : {
6806 label$9 : {
6807 label$10 : {
6808 label$11 : {
6809 label$12 : {
6810 label$13 : {
6811 label$14 : {
6812 label$15 : {
6813 label$16 : {
6814 label$17 : {
6815 $6 = Math_imul($4, 100) + $2 | 0;
6816 if (($6 | 0) <= 300) {
6817 label$19 : {
6818 switch ($6 + -101 | 0) {
6819 case 3:
6820 break label$10;
6821 case 5:
6822 break label$11;
6823 case 7:
6824 break label$12;
6825 case 2:
6826 case 4:
6827 case 6:
6828 break label$7;
6829 case 0:
6830 break label$8;
6831 case 1:
6832 break label$9;
6833 default:
6834 break label$19;
6835 };
6836 }
6837 switch ($6 + -201 | 0) {
6838 case 0:
6839 break label$13;
6840 case 1:
6841 break label$14;
6842 case 3:
6843 break label$15;
6844 case 5:
6845 break label$16;
6846 case 7:
6847 break label$17;
6848 default:
6849 break label$7;
6850 };
6851 }
6852 label$20 : {
6853 label$21 : {
6854 label$22 : {
6855 switch ($6 + -401 | 0) {
6856 default:
6857 switch ($6 + -301 | 0) {
6858 case 0:
6859 break label$20;
6860 case 1:
6861 break label$21;
6862 default:
6863 break label$7;
6864 };
6865 case 7:
6866 if (!$3) {
6867 break label$6
6868 }
6869 $13 = HEAP32[$1 + 28 >> 2];
6870 $8 = HEAP32[$1 + 24 >> 2];
6871 $12 = HEAP32[$1 + 20 >> 2];
6872 $7 = HEAP32[$1 + 16 >> 2];
6873 $10 = HEAP32[$1 + 12 >> 2];
6874 $6 = HEAP32[$1 + 8 >> 2];
6875 $4 = HEAP32[$1 + 4 >> 2];
6876 $1 = HEAP32[$1 >> 2];
6877 $2 = 0;
6878 while (1) {
6879 $9 = $2 << 2;
6880 HEAP32[$5 >> 2] = HEAP32[$9 + $1 >> 2];
6881 HEAP32[$5 + 4 >> 2] = HEAP32[$4 + $9 >> 2];
6882 HEAP32[$5 + 8 >> 2] = HEAP32[$6 + $9 >> 2];
6883 HEAP32[$5 + 12 >> 2] = HEAP32[$10 + $9 >> 2];
6884 HEAP32[$5 + 16 >> 2] = HEAP32[$7 + $9 >> 2];
6885 HEAP32[$5 + 20 >> 2] = HEAP32[$9 + $12 >> 2];
6886 HEAP32[$5 + 24 >> 2] = HEAP32[$8 + $9 >> 2];
6887 HEAP32[$5 + 28 >> 2] = HEAP32[$9 + $13 >> 2];
6888 $5 = $5 + 32 | 0;
6889 $2 = $2 + 1 | 0;
6890 if (($3 | 0) != ($2 | 0)) {
6891 continue
6892 }
6893 break;
6894 };
6895 break label$6;
6896 case 5:
6897 if (!$3) {
6898 break label$6
6899 }
6900 $12 = HEAP32[$1 + 20 >> 2];
6901 $7 = HEAP32[$1 + 16 >> 2];
6902 $10 = HEAP32[$1 + 12 >> 2];
6903 $6 = HEAP32[$1 + 8 >> 2];
6904 $4 = HEAP32[$1 + 4 >> 2];
6905 $1 = HEAP32[$1 >> 2];
6906 $2 = 0;
6907 while (1) {
6908 $8 = $2 << 2;
6909 HEAP32[$5 >> 2] = HEAP32[$8 + $1 >> 2];
6910 HEAP32[$5 + 4 >> 2] = HEAP32[$4 + $8 >> 2];
6911 HEAP32[$5 + 8 >> 2] = HEAP32[$6 + $8 >> 2];
6912 HEAP32[$5 + 12 >> 2] = HEAP32[$8 + $10 >> 2];
6913 HEAP32[$5 + 16 >> 2] = HEAP32[$7 + $8 >> 2];
6914 HEAP32[$5 + 20 >> 2] = HEAP32[$8 + $12 >> 2];
6915 $5 = $5 + 24 | 0;
6916 $2 = $2 + 1 | 0;
6917 if (($3 | 0) != ($2 | 0)) {
6918 continue
6919 }
6920 break;
6921 };
6922 break label$6;
6923 case 3:
6924 if (!$3) {
6925 break label$6
6926 }
6927 $10 = HEAP32[$1 + 12 >> 2];
6928 $6 = HEAP32[$1 + 8 >> 2];
6929 $4 = HEAP32[$1 + 4 >> 2];
6930 $1 = HEAP32[$1 >> 2];
6931 $2 = 0;
6932 while (1) {
6933 $7 = $2 << 2;
6934 HEAP32[$5 >> 2] = HEAP32[$7 + $1 >> 2];
6935 HEAP32[$5 + 4 >> 2] = HEAP32[$4 + $7 >> 2];
6936 HEAP32[$5 + 8 >> 2] = HEAP32[$6 + $7 >> 2];
6937 HEAP32[$5 + 12 >> 2] = HEAP32[$7 + $10 >> 2];
6938 $5 = $5 + 16 | 0;
6939 $2 = $2 + 1 | 0;
6940 if (($3 | 0) != ($2 | 0)) {
6941 continue
6942 }
6943 break;
6944 };
6945 break label$6;
6946 case 1:
6947 if (!$3) {
6948 break label$6
6949 }
6950 $6 = HEAP32[$1 + 4 >> 2];
6951 $4 = HEAP32[$1 >> 2];
6952 $1 = 0;
6953 while (1) {
6954 $2 = $1 << 2;
6955 HEAP32[$5 >> 2] = HEAP32[$2 + $4 >> 2];
6956 HEAP32[$5 + 4 >> 2] = HEAP32[$2 + $6 >> 2];
6957 $5 = $5 + 8 | 0;
6958 $1 = $1 + 1 | 0;
6959 if (($3 | 0) != ($1 | 0)) {
6960 continue
6961 }
6962 break;
6963 };
6964 break label$6;
6965 case 0:
6966 break label$22;
6967 case 2:
6968 case 4:
6969 case 6:
6970 break label$7;
6971 };
6972 }
6973 if (!$3) {
6974 break label$6
6975 }
6976 $2 = HEAP32[$1 >> 2];
6977 $1 = 0;
6978 while (1) {
6979 HEAP32[$5 >> 2] = HEAP32[$2 + ($1 << 2) >> 2];
6980 $5 = $5 + 4 | 0;
6981 $1 = $1 + 1 | 0;
6982 if (($3 | 0) != ($1 | 0)) {
6983 continue
6984 }
6985 break;
6986 };
6987 break label$6;
6988 }
6989 if (!$3) {
6990 break label$6
6991 }
6992 $2 = 0;
6993 while (1) {
6994 $4 = $2 << 2;
6995 $6 = HEAP32[$4 + HEAP32[$1 >> 2] >> 2];
6996 HEAP8[$5 | 0] = $6;
6997 HEAP8[$5 + 2 | 0] = $6 >>> 16;
6998 HEAP8[$5 + 1 | 0] = $6 >>> 8;
6999 $4 = HEAP32[$4 + HEAP32[$1 + 4 >> 2] >> 2];
7000 HEAP8[$5 + 3 | 0] = $4;
7001 HEAP8[$5 + 5 | 0] = $4 >>> 16;
7002 HEAP8[$5 + 4 | 0] = $4 >>> 8;
7003 $5 = $5 + 6 | 0;
7004 $2 = $2 + 1 | 0;
7005 if (($3 | 0) != ($2 | 0)) {
7006 continue
7007 }
7008 break;
7009 };
7010 break label$6;
7011 }
7012 if (!$3) {
7013 break label$6
7014 }
7015 $2 = 0;
7016 while (1) {
7017 $4 = HEAP32[HEAP32[$1 >> 2] + ($2 << 2) >> 2];
7018 HEAP8[$5 | 0] = $4;
7019 HEAP8[$5 + 2 | 0] = $4 >>> 16;
7020 HEAP8[$5 + 1 | 0] = $4 >>> 8;
7021 $5 = $5 + 3 | 0;
7022 $2 = $2 + 1 | 0;
7023 if (($3 | 0) != ($2 | 0)) {
7024 continue
7025 }
7026 break;
7027 };
7028 break label$6;
7029 }
7030 if (!$3) {
7031 break label$6
7032 }
7033 $13 = HEAP32[$1 + 28 >> 2];
7034 $8 = HEAP32[$1 + 24 >> 2];
7035 $12 = HEAP32[$1 + 20 >> 2];
7036 $7 = HEAP32[$1 + 16 >> 2];
7037 $10 = HEAP32[$1 + 12 >> 2];
7038 $6 = HEAP32[$1 + 8 >> 2];
7039 $4 = HEAP32[$1 + 4 >> 2];
7040 $1 = HEAP32[$1 >> 2];
7041 $2 = 0;
7042 while (1) {
7043 $9 = $2 << 2;
7044 HEAP16[$5 >> 1] = HEAP32[$9 + $1 >> 2];
7045 HEAP16[$5 + 2 >> 1] = HEAP32[$4 + $9 >> 2];
7046 HEAP16[$5 + 4 >> 1] = HEAP32[$6 + $9 >> 2];
7047 HEAP16[$5 + 6 >> 1] = HEAP32[$10 + $9 >> 2];
7048 HEAP16[$5 + 8 >> 1] = HEAP32[$7 + $9 >> 2];
7049 HEAP16[$5 + 10 >> 1] = HEAP32[$9 + $12 >> 2];
7050 HEAP16[$5 + 12 >> 1] = HEAP32[$8 + $9 >> 2];
7051 HEAP16[$5 + 14 >> 1] = HEAP32[$9 + $13 >> 2];
7052 $5 = $5 + 16 | 0;
7053 $2 = $2 + 1 | 0;
7054 if (($3 | 0) != ($2 | 0)) {
7055 continue
7056 }
7057 break;
7058 };
7059 break label$6;
7060 }
7061 if (!$3) {
7062 break label$6
7063 }
7064 $12 = HEAP32[$1 + 20 >> 2];
7065 $7 = HEAP32[$1 + 16 >> 2];
7066 $10 = HEAP32[$1 + 12 >> 2];
7067 $6 = HEAP32[$1 + 8 >> 2];
7068 $4 = HEAP32[$1 + 4 >> 2];
7069 $1 = HEAP32[$1 >> 2];
7070 $2 = 0;
7071 while (1) {
7072 $8 = $2 << 2;
7073 HEAP16[$5 >> 1] = HEAP32[$8 + $1 >> 2];
7074 HEAP16[$5 + 2 >> 1] = HEAP32[$4 + $8 >> 2];
7075 HEAP16[$5 + 4 >> 1] = HEAP32[$6 + $8 >> 2];
7076 HEAP16[$5 + 6 >> 1] = HEAP32[$8 + $10 >> 2];
7077 HEAP16[$5 + 8 >> 1] = HEAP32[$7 + $8 >> 2];
7078 HEAP16[$5 + 10 >> 1] = HEAP32[$8 + $12 >> 2];
7079 $5 = $5 + 12 | 0;
7080 $2 = $2 + 1 | 0;
7081 if (($3 | 0) != ($2 | 0)) {
7082 continue
7083 }
7084 break;
7085 };
7086 break label$6;
7087 }
7088 if (!$3) {
7089 break label$6
7090 }
7091 $10 = HEAP32[$1 + 12 >> 2];
7092 $6 = HEAP32[$1 + 8 >> 2];
7093 $4 = HEAP32[$1 + 4 >> 2];
7094 $1 = HEAP32[$1 >> 2];
7095 $2 = 0;
7096 while (1) {
7097 $7 = $2 << 2;
7098 HEAP16[$5 >> 1] = HEAP32[$7 + $1 >> 2];
7099 HEAP16[$5 + 2 >> 1] = HEAP32[$4 + $7 >> 2];
7100 HEAP16[$5 + 4 >> 1] = HEAP32[$6 + $7 >> 2];
7101 HEAP16[$5 + 6 >> 1] = HEAP32[$7 + $10 >> 2];
7102 $5 = $5 + 8 | 0;
7103 $2 = $2 + 1 | 0;
7104 if (($3 | 0) != ($2 | 0)) {
7105 continue
7106 }
7107 break;
7108 };
7109 break label$6;
7110 }
7111 if (!$3) {
7112 break label$6
7113 }
7114 $6 = HEAP32[$1 + 4 >> 2];
7115 $4 = HEAP32[$1 >> 2];
7116 $1 = 0;
7117 while (1) {
7118 $2 = $1 << 2;
7119 HEAP16[$5 >> 1] = HEAP32[$2 + $4 >> 2];
7120 HEAP16[$5 + 2 >> 1] = HEAP32[$2 + $6 >> 2];
7121 $5 = $5 + 4 | 0;
7122 $1 = $1 + 1 | 0;
7123 if (($3 | 0) != ($1 | 0)) {
7124 continue
7125 }
7126 break;
7127 };
7128 break label$6;
7129 }
7130 if (!$3) {
7131 break label$6
7132 }
7133 $2 = HEAP32[$1 >> 2];
7134 $1 = 0;
7135 while (1) {
7136 HEAP16[$5 >> 1] = HEAP32[$2 + ($1 << 2) >> 2];
7137 $5 = $5 + 2 | 0;
7138 $1 = $1 + 1 | 0;
7139 if (($3 | 0) != ($1 | 0)) {
7140 continue
7141 }
7142 break;
7143 };
7144 break label$6;
7145 }
7146 if (!$3) {
7147 break label$6
7148 }
7149 $4 = 0;
7150 while (1) {
7151 $2 = $4 << 2;
7152 HEAP8[$5 | 0] = HEAP32[$2 + HEAP32[$1 >> 2] >> 2];
7153 HEAP8[$5 + 1 | 0] = HEAP32[$2 + HEAP32[$1 + 4 >> 2] >> 2];
7154 HEAP8[$5 + 2 | 0] = HEAP32[$2 + HEAP32[$1 + 8 >> 2] >> 2];
7155 HEAP8[$5 + 3 | 0] = HEAP32[$2 + HEAP32[$1 + 12 >> 2] >> 2];
7156 HEAP8[$5 + 4 | 0] = HEAP32[$2 + HEAP32[$1 + 16 >> 2] >> 2];
7157 HEAP8[$5 + 5 | 0] = HEAP32[$2 + HEAP32[$1 + 20 >> 2] >> 2];
7158 HEAP8[$5 + 6 | 0] = HEAP32[$2 + HEAP32[$1 + 24 >> 2] >> 2];
7159 HEAP8[$5 + 7 | 0] = HEAP32[$2 + HEAP32[$1 + 28 >> 2] >> 2];
7160 $5 = $5 + 8 | 0;
7161 $4 = $4 + 1 | 0;
7162 if (($4 | 0) != ($3 | 0)) {
7163 continue
7164 }
7165 break;
7166 };
7167 break label$6;
7168 }
7169 if (!$3) {
7170 break label$6
7171 }
7172 $4 = 0;
7173 while (1) {
7174 $2 = $4 << 2;
7175 HEAP8[$5 | 0] = HEAP32[$2 + HEAP32[$1 >> 2] >> 2];
7176 HEAP8[$5 + 1 | 0] = HEAP32[$2 + HEAP32[$1 + 4 >> 2] >> 2];
7177 HEAP8[$5 + 2 | 0] = HEAP32[$2 + HEAP32[$1 + 8 >> 2] >> 2];
7178 HEAP8[$5 + 3 | 0] = HEAP32[$2 + HEAP32[$1 + 12 >> 2] >> 2];
7179 HEAP8[$5 + 4 | 0] = HEAP32[$2 + HEAP32[$1 + 16 >> 2] >> 2];
7180 HEAP8[$5 + 5 | 0] = HEAP32[$2 + HEAP32[$1 + 20 >> 2] >> 2];
7181 $5 = $5 + 6 | 0;
7182 $4 = $4 + 1 | 0;
7183 if (($4 | 0) != ($3 | 0)) {
7184 continue
7185 }
7186 break;
7187 };
7188 break label$6;
7189 }
7190 if (!$3) {
7191 break label$6
7192 }
7193 $4 = 0;
7194 while (1) {
7195 $2 = $4 << 2;
7196 HEAP8[$5 | 0] = HEAP32[$2 + HEAP32[$1 >> 2] >> 2];
7197 HEAP8[$5 + 1 | 0] = HEAP32[$2 + HEAP32[$1 + 4 >> 2] >> 2];
7198 HEAP8[$5 + 2 | 0] = HEAP32[$2 + HEAP32[$1 + 8 >> 2] >> 2];
7199 HEAP8[$5 + 3 | 0] = HEAP32[$2 + HEAP32[$1 + 12 >> 2] >> 2];
7200 $5 = $5 + 4 | 0;
7201 $4 = $4 + 1 | 0;
7202 if (($4 | 0) != ($3 | 0)) {
7203 continue
7204 }
7205 break;
7206 };
7207 break label$6;
7208 }
7209 if (!$3) {
7210 break label$6
7211 }
7212 $2 = 0;
7213 while (1) {
7214 $4 = $2 << 2;
7215 HEAP8[$5 | 0] = HEAP32[$4 + HEAP32[$1 >> 2] >> 2];
7216 HEAP8[$5 + 1 | 0] = HEAP32[$4 + HEAP32[$1 + 4 >> 2] >> 2];
7217 $5 = $5 + 2 | 0;
7218 $2 = $2 + 1 | 0;
7219 if (($3 | 0) != ($2 | 0)) {
7220 continue
7221 }
7222 break;
7223 };
7224 break label$6;
7225 }
7226 if (!$3) {
7227 break label$6
7228 }
7229 $2 = 0;
7230 while (1) {
7231 HEAP8[$5 | 0] = HEAP32[HEAP32[$1 >> 2] + ($2 << 2) >> 2];
7232 $5 = $5 + 1 | 0;
7233 $2 = $2 + 1 | 0;
7234 if (($3 | 0) != ($2 | 0)) {
7235 continue
7236 }
7237 break;
7238 };
7239 break label$6;
7240 }
7241 label$45 : {
7242 switch ($4 + -1 | 0) {
7243 case 3:
7244 if (!$2 | !$3) {
7245 break label$6
7246 }
7247 $6 = 0;
7248 while (1) {
7249 $4 = 0;
7250 while (1) {
7251 HEAP32[$5 >> 2] = HEAP32[HEAP32[($4 << 2) + $1 >> 2] + ($6 << 2) >> 2];
7252 $5 = $5 + 4 | 0;
7253 $4 = $4 + 1 | 0;
7254 if (($4 | 0) != ($2 | 0)) {
7255 continue
7256 }
7257 break;
7258 };
7259 $6 = $6 + 1 | 0;
7260 if (($6 | 0) != ($3 | 0)) {
7261 continue
7262 }
7263 break;
7264 };
7265 break label$6;
7266 case 2:
7267 if (!$2 | !$3) {
7268 break label$6
7269 }
7270 while (1) {
7271 $4 = 0;
7272 while (1) {
7273 $6 = HEAP32[HEAP32[($4 << 2) + $1 >> 2] + ($10 << 2) >> 2];
7274 HEAP8[$5 | 0] = $6;
7275 HEAP8[$5 + 2 | 0] = $6 >>> 16;
7276 HEAP8[$5 + 1 | 0] = $6 >>> 8;
7277 $5 = $5 + 3 | 0;
7278 $4 = $4 + 1 | 0;
7279 if (($4 | 0) != ($2 | 0)) {
7280 continue
7281 }
7282 break;
7283 };
7284 $10 = $10 + 1 | 0;
7285 if (($10 | 0) != ($3 | 0)) {
7286 continue
7287 }
7288 break;
7289 };
7290 break label$6;
7291 case 1:
7292 if (!$2 | !$3) {
7293 break label$6
7294 }
7295 $6 = 0;
7296 while (1) {
7297 $4 = 0;
7298 while (1) {
7299 HEAP16[$5 >> 1] = HEAP32[HEAP32[($4 << 2) + $1 >> 2] + ($6 << 2) >> 2];
7300 $5 = $5 + 2 | 0;
7301 $4 = $4 + 1 | 0;
7302 if (($4 | 0) != ($2 | 0)) {
7303 continue
7304 }
7305 break;
7306 };
7307 $6 = $6 + 1 | 0;
7308 if (($6 | 0) != ($3 | 0)) {
7309 continue
7310 }
7311 break;
7312 };
7313 break label$6;
7314 case 0:
7315 break label$45;
7316 default:
7317 break label$6;
7318 };
7319 }
7320 if (!$2 | !$3) {
7321 break label$6
7322 }
7323 $6 = 0;
7324 while (1) {
7325 $4 = 0;
7326 while (1) {
7327 HEAP8[$5 | 0] = HEAP32[HEAP32[($4 << 2) + $1 >> 2] + ($6 << 2) >> 2];
7328 $5 = $5 + 1 | 0;
7329 $4 = $4 + 1 | 0;
7330 if (($4 | 0) != ($2 | 0)) {
7331 continue
7332 }
7333 break;
7334 };
7335 $6 = $6 + 1 | 0;
7336 if (($6 | 0) != ($3 | 0)) {
7337 continue
7338 }
7339 break;
7340 };
7341 }
7342 $2 = HEAP32[$0 + 80 >> 2];
7343 $1 = $2 + $11 | 0;
7344 HEAP32[$0 + 80 >> 2] = $1;
7345 $3 = HEAP32[$0 + 88 >> 2];
7346 if ($1 >>> 0 < $2 >>> 0) {
7347 $1 = $0 + 84 | 0;
7348 HEAP32[$1 >> 2] = HEAP32[$1 >> 2] + 1;
7349 }
7350 $4 = 64 - ($2 & 63) | 0;
7351 $1 = ($0 - $4 | 0) - -64 | 0;
7352 label$58 : {
7353 if ($11 >>> 0 < $4 >>> 0) {
7354 memcpy($1, $3, $11);
7355 break label$58;
7356 }
7357 memcpy($1, $3, $4);
7358 $2 = $0 - -64 | 0;
7359 FLAC__MD5Transform($2, $0);
7360 $5 = $3 + $4 | 0;
7361 $1 = $11 - $4 | 0;
7362 if ($1 >>> 0 >= 64) {
7363 while (1) {
7364 $4 = HEAPU8[$5 + 4 | 0] | HEAPU8[$5 + 5 | 0] << 8 | (HEAPU8[$5 + 6 | 0] << 16 | HEAPU8[$5 + 7 | 0] << 24);
7365 $3 = HEAPU8[$5 | 0] | HEAPU8[$5 + 1 | 0] << 8 | (HEAPU8[$5 + 2 | 0] << 16 | HEAPU8[$5 + 3 | 0] << 24);
7366 HEAP8[$0 | 0] = $3;
7367 HEAP8[$0 + 1 | 0] = $3 >>> 8;
7368 HEAP8[$0 + 2 | 0] = $3 >>> 16;
7369 HEAP8[$0 + 3 | 0] = $3 >>> 24;
7370 HEAP8[$0 + 4 | 0] = $4;
7371 HEAP8[$0 + 5 | 0] = $4 >>> 8;
7372 HEAP8[$0 + 6 | 0] = $4 >>> 16;
7373 HEAP8[$0 + 7 | 0] = $4 >>> 24;
7374 $4 = HEAPU8[$5 + 60 | 0] | HEAPU8[$5 + 61 | 0] << 8 | (HEAPU8[$5 + 62 | 0] << 16 | HEAPU8[$5 + 63 | 0] << 24);
7375 $3 = HEAPU8[$5 + 56 | 0] | HEAPU8[$5 + 57 | 0] << 8 | (HEAPU8[$5 + 58 | 0] << 16 | HEAPU8[$5 + 59 | 0] << 24);
7376 HEAP8[$0 + 56 | 0] = $3;
7377 HEAP8[$0 + 57 | 0] = $3 >>> 8;
7378 HEAP8[$0 + 58 | 0] = $3 >>> 16;
7379 HEAP8[$0 + 59 | 0] = $3 >>> 24;
7380 HEAP8[$0 + 60 | 0] = $4;
7381 HEAP8[$0 + 61 | 0] = $4 >>> 8;
7382 HEAP8[$0 + 62 | 0] = $4 >>> 16;
7383 HEAP8[$0 + 63 | 0] = $4 >>> 24;
7384 $4 = HEAPU8[$5 + 52 | 0] | HEAPU8[$5 + 53 | 0] << 8 | (HEAPU8[$5 + 54 | 0] << 16 | HEAPU8[$5 + 55 | 0] << 24);
7385 $3 = HEAPU8[$5 + 48 | 0] | HEAPU8[$5 + 49 | 0] << 8 | (HEAPU8[$5 + 50 | 0] << 16 | HEAPU8[$5 + 51 | 0] << 24);
7386 HEAP8[$0 + 48 | 0] = $3;
7387 HEAP8[$0 + 49 | 0] = $3 >>> 8;
7388 HEAP8[$0 + 50 | 0] = $3 >>> 16;
7389 HEAP8[$0 + 51 | 0] = $3 >>> 24;
7390 HEAP8[$0 + 52 | 0] = $4;
7391 HEAP8[$0 + 53 | 0] = $4 >>> 8;
7392 HEAP8[$0 + 54 | 0] = $4 >>> 16;
7393 HEAP8[$0 + 55 | 0] = $4 >>> 24;
7394 $4 = HEAPU8[$5 + 44 | 0] | HEAPU8[$5 + 45 | 0] << 8 | (HEAPU8[$5 + 46 | 0] << 16 | HEAPU8[$5 + 47 | 0] << 24);
7395 $3 = HEAPU8[$5 + 40 | 0] | HEAPU8[$5 + 41 | 0] << 8 | (HEAPU8[$5 + 42 | 0] << 16 | HEAPU8[$5 + 43 | 0] << 24);
7396 HEAP8[$0 + 40 | 0] = $3;
7397 HEAP8[$0 + 41 | 0] = $3 >>> 8;
7398 HEAP8[$0 + 42 | 0] = $3 >>> 16;
7399 HEAP8[$0 + 43 | 0] = $3 >>> 24;
7400 HEAP8[$0 + 44 | 0] = $4;
7401 HEAP8[$0 + 45 | 0] = $4 >>> 8;
7402 HEAP8[$0 + 46 | 0] = $4 >>> 16;
7403 HEAP8[$0 + 47 | 0] = $4 >>> 24;
7404 $4 = HEAPU8[$5 + 36 | 0] | HEAPU8[$5 + 37 | 0] << 8 | (HEAPU8[$5 + 38 | 0] << 16 | HEAPU8[$5 + 39 | 0] << 24);
7405 $3 = HEAPU8[$5 + 32 | 0] | HEAPU8[$5 + 33 | 0] << 8 | (HEAPU8[$5 + 34 | 0] << 16 | HEAPU8[$5 + 35 | 0] << 24);
7406 HEAP8[$0 + 32 | 0] = $3;
7407 HEAP8[$0 + 33 | 0] = $3 >>> 8;
7408 HEAP8[$0 + 34 | 0] = $3 >>> 16;
7409 HEAP8[$0 + 35 | 0] = $3 >>> 24;
7410 HEAP8[$0 + 36 | 0] = $4;
7411 HEAP8[$0 + 37 | 0] = $4 >>> 8;
7412 HEAP8[$0 + 38 | 0] = $4 >>> 16;
7413 HEAP8[$0 + 39 | 0] = $4 >>> 24;
7414 $4 = HEAPU8[$5 + 28 | 0] | HEAPU8[$5 + 29 | 0] << 8 | (HEAPU8[$5 + 30 | 0] << 16 | HEAPU8[$5 + 31 | 0] << 24);
7415 $3 = HEAPU8[$5 + 24 | 0] | HEAPU8[$5 + 25 | 0] << 8 | (HEAPU8[$5 + 26 | 0] << 16 | HEAPU8[$5 + 27 | 0] << 24);
7416 HEAP8[$0 + 24 | 0] = $3;
7417 HEAP8[$0 + 25 | 0] = $3 >>> 8;
7418 HEAP8[$0 + 26 | 0] = $3 >>> 16;
7419 HEAP8[$0 + 27 | 0] = $3 >>> 24;
7420 HEAP8[$0 + 28 | 0] = $4;
7421 HEAP8[$0 + 29 | 0] = $4 >>> 8;
7422 HEAP8[$0 + 30 | 0] = $4 >>> 16;
7423 HEAP8[$0 + 31 | 0] = $4 >>> 24;
7424 $4 = HEAPU8[$5 + 20 | 0] | HEAPU8[$5 + 21 | 0] << 8 | (HEAPU8[$5 + 22 | 0] << 16 | HEAPU8[$5 + 23 | 0] << 24);
7425 $3 = HEAPU8[$5 + 16 | 0] | HEAPU8[$5 + 17 | 0] << 8 | (HEAPU8[$5 + 18 | 0] << 16 | HEAPU8[$5 + 19 | 0] << 24);
7426 HEAP8[$0 + 16 | 0] = $3;
7427 HEAP8[$0 + 17 | 0] = $3 >>> 8;
7428 HEAP8[$0 + 18 | 0] = $3 >>> 16;
7429 HEAP8[$0 + 19 | 0] = $3 >>> 24;
7430 HEAP8[$0 + 20 | 0] = $4;
7431 HEAP8[$0 + 21 | 0] = $4 >>> 8;
7432 HEAP8[$0 + 22 | 0] = $4 >>> 16;
7433 HEAP8[$0 + 23 | 0] = $4 >>> 24;
7434 $4 = HEAPU8[$5 + 12 | 0] | HEAPU8[$5 + 13 | 0] << 8 | (HEAPU8[$5 + 14 | 0] << 16 | HEAPU8[$5 + 15 | 0] << 24);
7435 $3 = HEAPU8[$5 + 8 | 0] | HEAPU8[$5 + 9 | 0] << 8 | (HEAPU8[$5 + 10 | 0] << 16 | HEAPU8[$5 + 11 | 0] << 24);
7436 HEAP8[$0 + 8 | 0] = $3;
7437 HEAP8[$0 + 9 | 0] = $3 >>> 8;
7438 HEAP8[$0 + 10 | 0] = $3 >>> 16;
7439 HEAP8[$0 + 11 | 0] = $3 >>> 24;
7440 HEAP8[$0 + 12 | 0] = $4;
7441 HEAP8[$0 + 13 | 0] = $4 >>> 8;
7442 HEAP8[$0 + 14 | 0] = $4 >>> 16;
7443 HEAP8[$0 + 15 | 0] = $4 >>> 24;
7444 FLAC__MD5Transform($2, $0);
7445 $5 = $5 - -64 | 0;
7446 $1 = $1 + -64 | 0;
7447 if ($1 >>> 0 > 63) {
7448 continue
7449 }
7450 break;
7451 }
7452 }
7453 memcpy($0, $5, $1);
7454 }
7455 $5 = 1;
7456 }
7457 return $5;
7458 }
7459
7460 function __stdio_close($0) {
7461 $0 = $0 | 0;
7462 return __wasi_fd_close(HEAP32[$0 + 60 >> 2]) | 0;
7463 }
7464
7465 function __wasi_syscall_ret($0) {
7466 if (!$0) {
7467 return 0
7468 }
7469 HEAP32[2896] = $0;
7470 return -1;
7471 }
7472
7473 function __stdio_read($0, $1, $2) {
7474 $0 = $0 | 0;
7475 $1 = $1 | 0;
7476 $2 = $2 | 0;
7477 var $3 = 0, $4 = 0, $5 = 0, $6 = 0;
7478 $3 = global$0 - 32 | 0;
7479 global$0 = $3;
7480 HEAP32[$3 + 16 >> 2] = $1;
7481 $4 = HEAP32[$0 + 48 >> 2];
7482 HEAP32[$3 + 20 >> 2] = $2 - (($4 | 0) != 0);
7483 $5 = HEAP32[$0 + 44 >> 2];
7484 HEAP32[$3 + 28 >> 2] = $4;
7485 HEAP32[$3 + 24 >> 2] = $5;
7486 label$1 : {
7487 label$2 : {
7488 label$3 : {
7489 if (__wasi_syscall_ret(__wasi_fd_read(HEAP32[$0 + 60 >> 2], $3 + 16 | 0, 2, $3 + 12 | 0) | 0)) {
7490 HEAP32[$3 + 12 >> 2] = -1;
7491 $2 = -1;
7492 break label$3;
7493 }
7494 $4 = HEAP32[$3 + 12 >> 2];
7495 if (($4 | 0) > 0) {
7496 break label$2
7497 }
7498 $2 = $4;
7499 }
7500 HEAP32[$0 >> 2] = HEAP32[$0 >> 2] | $2 & 48 ^ 16;
7501 break label$1;
7502 }
7503 $6 = HEAP32[$3 + 20 >> 2];
7504 if ($4 >>> 0 <= $6 >>> 0) {
7505 $2 = $4;
7506 break label$1;
7507 }
7508 $5 = HEAP32[$0 + 44 >> 2];
7509 HEAP32[$0 + 4 >> 2] = $5;
7510 HEAP32[$0 + 8 >> 2] = $5 + ($4 - $6 | 0);
7511 if (!HEAP32[$0 + 48 >> 2]) {
7512 break label$1
7513 }
7514 HEAP32[$0 + 4 >> 2] = $5 + 1;
7515 HEAP8[($1 + $2 | 0) + -1 | 0] = HEAPU8[$5 | 0];
7516 }
7517 global$0 = $3 + 32 | 0;
7518 return $2 | 0;
7519 }
7520
7521 function __stdio_seek($0, $1, $2, $3) {
7522 $0 = $0 | 0;
7523 $1 = $1 | 0;
7524 $2 = $2 | 0;
7525 $3 = $3 | 0;
7526 var $4 = 0;
7527 $4 = global$0 - 16 | 0;
7528 global$0 = $4;
7529 label$1 : {
7530 if (!__wasi_syscall_ret(legalimport$__wasi_fd_seek(HEAP32[$0 + 60 >> 2], $1 | 0, $2 | 0, $3 & 255, $4 + 8 | 0) | 0)) {
7531 $1 = HEAP32[$4 + 12 >> 2];
7532 $0 = HEAP32[$4 + 8 >> 2];
7533 break label$1;
7534 }
7535 HEAP32[$4 + 8 >> 2] = -1;
7536 HEAP32[$4 + 12 >> 2] = -1;
7537 $1 = -1;
7538 $0 = -1;
7539 }
7540 global$0 = $4 + 16 | 0;
7541 i64toi32_i32$HIGH_BITS = $1;
7542 return $0 | 0;
7543 }
7544
7545 function fflush($0) {
7546 var $1 = 0;
7547 if ($0) {
7548 if (HEAP32[$0 + 76 >> 2] <= -1) {
7549 return __fflush_unlocked($0)
7550 }
7551 return __fflush_unlocked($0);
7552 }
7553 if (HEAP32[2794]) {
7554 $1 = fflush(HEAP32[2794])
7555 }
7556 $0 = HEAP32[3023];
7557 if ($0) {
7558 while (1) {
7559 if (HEAPU32[$0 + 20 >> 2] > HEAPU32[$0 + 28 >> 2]) {
7560 $1 = __fflush_unlocked($0) | $1
7561 }
7562 $0 = HEAP32[$0 + 56 >> 2];
7563 if ($0) {
7564 continue
7565 }
7566 break;
7567 }
7568 }
7569 return $1;
7570 }
7571
7572 function __fflush_unlocked($0) {
7573 var $1 = 0, $2 = 0;
7574 label$1 : {
7575 if (HEAPU32[$0 + 20 >> 2] <= HEAPU32[$0 + 28 >> 2]) {
7576 break label$1
7577 }
7578 FUNCTION_TABLE[HEAP32[$0 + 36 >> 2]]($0, 0, 0) | 0;
7579 if (HEAP32[$0 + 20 >> 2]) {
7580 break label$1
7581 }
7582 return -1;
7583 }
7584 $1 = HEAP32[$0 + 4 >> 2];
7585 $2 = HEAP32[$0 + 8 >> 2];
7586 if ($1 >>> 0 < $2 >>> 0) {
7587 $1 = $1 - $2 | 0;
7588 FUNCTION_TABLE[HEAP32[$0 + 40 >> 2]]($0, $1, $1 >> 31, 1) | 0;
7589 }
7590 HEAP32[$0 + 28 >> 2] = 0;
7591 HEAP32[$0 + 16 >> 2] = 0;
7592 HEAP32[$0 + 20 >> 2] = 0;
7593 HEAP32[$0 + 4 >> 2] = 0;
7594 HEAP32[$0 + 8 >> 2] = 0;
7595 return 0;
7596 }
7597
7598 function fclose($0) {
7599 var $1 = 0, $2 = 0, $3 = 0, $4 = 0;
7600 $4 = HEAP32[$0 + 76 >> 2] >= 0 ? 1 : 0;
7601 $3 = HEAP32[$0 >> 2] & 1;
7602 if (!$3) {
7603 $1 = HEAP32[$0 + 52 >> 2];
7604 if ($1) {
7605 HEAP32[$1 + 56 >> 2] = HEAP32[$0 + 56 >> 2]
7606 }
7607 $2 = HEAP32[$0 + 56 >> 2];
7608 if ($2) {
7609 HEAP32[$2 + 52 >> 2] = $1
7610 }
7611 if (HEAP32[3023] == ($0 | 0)) {
7612 HEAP32[3023] = $2
7613 }
7614 }
7615 fflush($0);
7616 FUNCTION_TABLE[HEAP32[$0 + 12 >> 2]]($0) | 0;
7617 $1 = HEAP32[$0 + 96 >> 2];
7618 if ($1) {
7619 dlfree($1)
7620 }
7621 label$7 : {
7622 if (!$3) {
7623 dlfree($0);
7624 break label$7;
7625 }
7626 if (!$4) {
7627 break label$7
7628 }
7629 }
7630 }
7631
7632 function memcmp($0, $1, $2) {
7633 var $3 = 0, $4 = 0, $5 = 0;
7634 label$1 : {
7635 if (!$2) {
7636 break label$1
7637 }
7638 while (1) {
7639 $3 = HEAPU8[$0 | 0];
7640 $4 = HEAPU8[$1 | 0];
7641 if (($3 | 0) == ($4 | 0)) {
7642 $1 = $1 + 1 | 0;
7643 $0 = $0 + 1 | 0;
7644 $2 = $2 + -1 | 0;
7645 if ($2) {
7646 continue
7647 }
7648 break label$1;
7649 }
7650 break;
7651 };
7652 $5 = $3 - $4 | 0;
7653 }
7654 return $5;
7655 }
7656
7657 function FLAC__cpu_info($0) {
7658 HEAP32[$0 + 8 >> 2] = 0;
7659 HEAP32[$0 + 12 >> 2] = 0;
7660 HEAP32[$0 >> 2] = 0;
7661 HEAP32[$0 + 4 >> 2] = 3;
7662 HEAP32[$0 + 56 >> 2] = 0;
7663 HEAP32[$0 + 60 >> 2] = 0;
7664 HEAP32[$0 + 48 >> 2] = 0;
7665 HEAP32[$0 + 52 >> 2] = 0;
7666 HEAP32[$0 + 40 >> 2] = 0;
7667 HEAP32[$0 + 44 >> 2] = 0;
7668 HEAP32[$0 + 32 >> 2] = 0;
7669 HEAP32[$0 + 36 >> 2] = 0;
7670 HEAP32[$0 + 24 >> 2] = 0;
7671 HEAP32[$0 + 28 >> 2] = 0;
7672 HEAP32[$0 + 16 >> 2] = 0;
7673 HEAP32[$0 + 20 >> 2] = 0;
7674 }
7675
7676 function lround($0) {
7677 $0 = +round(+$0);
7678 if (Math_abs($0) < 2147483648.0) {
7679 return ~~$0
7680 }
7681 return -2147483648;
7682 }
7683
7684 function log($0) {
7685 var $1 = 0, $2 = 0.0, $3 = 0, $4 = 0.0, $5 = 0, $6 = 0, $7 = 0.0, $8 = 0.0, $9 = 0.0, $10 = 0.0;
7686 label$1 : {
7687 label$2 : {
7688 label$3 : {
7689 label$4 : {
7690 wasm2js_scratch_store_f64(+$0);
7691 $1 = wasm2js_scratch_load_i32(1) | 0;
7692 $3 = wasm2js_scratch_load_i32(0) | 0;
7693 if (($1 | 0) > 0 ? 1 : ($1 | 0) >= 0 ? ($3 >>> 0 < 0 ? 0 : 1) : 0) {
7694 $5 = $1;
7695 if ($1 >>> 0 > 1048575) {
7696 break label$4
7697 }
7698 }
7699 if (!($1 & 2147483647 | $3)) {
7700 return -1.0 / ($0 * $0)
7701 }
7702 if (($1 | 0) > -1 ? 1 : 0) {
7703 break label$3
7704 }
7705 return ($0 - $0) / 0.0;
7706 }
7707 if ($5 >>> 0 > 2146435071) {
7708 break label$1
7709 }
7710 $1 = 1072693248;
7711 $6 = -1023;
7712 if (($5 | 0) != 1072693248) {
7713 $1 = $5;
7714 break label$2;
7715 }
7716 if ($3) {
7717 break label$2
7718 }
7719 return 0.0;
7720 }
7721 wasm2js_scratch_store_f64(+($0 * 18014398509481984.0));
7722 $1 = wasm2js_scratch_load_i32(1) | 0;
7723 $3 = wasm2js_scratch_load_i32(0) | 0;
7724 $6 = -1077;
7725 }
7726 $1 = $1 + 614242 | 0;
7727 $4 = +(($1 >>> 20 | 0) + $6 | 0);
7728 wasm2js_scratch_store_i32(0, $3 | 0);
7729 wasm2js_scratch_store_i32(1, ($1 & 1048575) + 1072079006 | 0);
7730 $0 = +wasm2js_scratch_load_f64() + -1.0;
7731 $2 = $0 / ($0 + 2.0);
7732 $7 = $4 * .6931471803691238;
7733 $8 = $0;
7734 $9 = $4 * 1.9082149292705877e-10;
7735 $10 = $2;
7736 $4 = $0 * ($0 * .5);
7737 $2 = $2 * $2;
7738 $0 = $2 * $2;
7739 $0 = $7 + ($8 + ($9 + $10 * ($4 + ($0 * ($0 * ($0 * .15313837699209373 + .22222198432149784) + .3999999999940942) + $2 * ($0 * ($0 * ($0 * .14798198605116586 + .1818357216161805) + .2857142874366239) + .6666666666666735))) - $4));
7740 }
7741 return $0;
7742 }
7743
7744 function FLAC__lpc_window_data($0, $1, $2, $3) {
7745 var $4 = 0, $5 = 0;
7746 if ($3) {
7747 while (1) {
7748 $5 = $4 << 2;
7749 HEAPF32[$5 + $2 >> 2] = HEAPF32[$1 + $5 >> 2] * Math_fround(HEAP32[$0 + $5 >> 2]);
7750 $4 = $4 + 1 | 0;
7751 if (($4 | 0) != ($3 | 0)) {
7752 continue
7753 }
7754 break;
7755 }
7756 }
7757 }
7758
7759 function FLAC__lpc_compute_autocorrelation($0, $1, $2, $3) {
7760 $0 = $0 | 0;
7761 $1 = $1 | 0;
7762 $2 = $2 | 0;
7763 $3 = $3 | 0;
7764 var $4 = 0, $5 = 0, $6 = 0, $7 = Math_fround(0), $8 = 0, $9 = 0;
7765 $6 = $1 - $2 | 0;
7766 label$1 : {
7767 if (!$2) {
7768 while (1) {
7769 $4 = $4 + 1 | 0;
7770 if ($4 >>> 0 <= $6 >>> 0) {
7771 continue
7772 }
7773 break;
7774 };
7775 break label$1;
7776 }
7777 $9 = memset($3, $2 << 2);
7778 while (1) {
7779 $7 = HEAPF32[($4 << 2) + $0 >> 2];
7780 $5 = 0;
7781 while (1) {
7782 $8 = ($5 << 2) + $9 | 0;
7783 HEAPF32[$8 >> 2] = HEAPF32[$8 >> 2] + Math_fround($7 * HEAPF32[($4 + $5 << 2) + $0 >> 2]);
7784 $5 = $5 + 1 | 0;
7785 if (($5 | 0) != ($2 | 0)) {
7786 continue
7787 }
7788 break;
7789 };
7790 $4 = $4 + 1 | 0;
7791 if ($4 >>> 0 <= $6 >>> 0) {
7792 continue
7793 }
7794 break;
7795 };
7796 }
7797 if ($4 >>> 0 < $1 >>> 0) {
7798 while (1) {
7799 $2 = $1 - $4 | 0;
7800 if ($2) {
7801 $7 = HEAPF32[($4 << 2) + $0 >> 2];
7802 $5 = 0;
7803 while (1) {
7804 $6 = ($5 << 2) + $3 | 0;
7805 HEAPF32[$6 >> 2] = HEAPF32[$6 >> 2] + Math_fround($7 * HEAPF32[($4 + $5 << 2) + $0 >> 2]);
7806 $5 = $5 + 1 | 0;
7807 if ($5 >>> 0 < $2 >>> 0) {
7808 continue
7809 }
7810 break;
7811 };
7812 }
7813 $4 = $4 + 1 | 0;
7814 if (($4 | 0) != ($1 | 0)) {
7815 continue
7816 }
7817 break;
7818 }
7819 }
7820 }
7821
7822 function FLAC__lpc_compute_lp_coefficients($0, $1, $2, $3) {
7823 var $4 = 0, $5 = 0, $6 = 0.0, $7 = 0, $8 = 0, $9 = 0.0, $10 = 0.0, $11 = 0, $12 = 0, $13 = 0, $14 = 0;
7824 $7 = global$0 - 256 | 0;
7825 global$0 = $7;
7826 $13 = HEAP32[$1 >> 2];
7827 $10 = +HEAPF32[$0 >> 2];
7828 label$1 : {
7829 while (1) {
7830 if (($5 | 0) == ($13 | 0)) {
7831 break label$1
7832 }
7833 $11 = $5 + 1 | 0;
7834 $6 = +Math_fround(-HEAPF32[($11 << 2) + $0 >> 2]);
7835 label$3 : {
7836 if ($5) {
7837 $12 = $5 >>> 1 | 0;
7838 $4 = 0;
7839 while (1) {
7840 $6 = $6 - HEAPF64[($4 << 3) + $7 >> 3] * +HEAPF32[($5 - $4 << 2) + $0 >> 2];
7841 $4 = $4 + 1 | 0;
7842 if (($5 | 0) != ($4 | 0)) {
7843 continue
7844 }
7845 break;
7846 };
7847 $6 = $6 / $10;
7848 HEAPF64[($5 << 3) + $7 >> 3] = $6;
7849 $4 = 0;
7850 if ($12) {
7851 while (1) {
7852 $8 = ($4 << 3) + $7 | 0;
7853 $9 = HEAPF64[$8 >> 3];
7854 $14 = $8;
7855 $8 = (($4 ^ -1) + $5 << 3) + $7 | 0;
7856 HEAPF64[$14 >> 3] = $9 + $6 * HEAPF64[$8 >> 3];
7857 HEAPF64[$8 >> 3] = $6 * $9 + HEAPF64[$8 >> 3];
7858 $4 = $4 + 1 | 0;
7859 if (($12 | 0) != ($4 | 0)) {
7860 continue
7861 }
7862 break;
7863 }
7864 }
7865 if (!($5 & 1)) {
7866 break label$3
7867 }
7868 $8 = ($12 << 3) + $7 | 0;
7869 $9 = HEAPF64[$8 >> 3];
7870 HEAPF64[$8 >> 3] = $9 + $6 * $9;
7871 break label$3;
7872 }
7873 $6 = $6 / $10;
7874 HEAPF64[($5 << 3) + $7 >> 3] = $6;
7875 }
7876 $9 = 1.0 - $6 * $6;
7877 $4 = 0;
7878 while (1) {
7879 HEAPF32[(($5 << 7) + $2 | 0) + ($4 << 2) >> 2] = -Math_fround(HEAPF64[($4 << 3) + $7 >> 3]);
7880 $4 = $4 + 1 | 0;
7881 if ($4 >>> 0 <= $5 >>> 0) {
7882 continue
7883 }
7884 break;
7885 };
7886 $10 = $10 * $9;
7887 HEAPF64[($5 << 3) + $3 >> 3] = $10;
7888 $5 = $11;
7889 if ($10 != 0.0) {
7890 continue
7891 }
7892 break;
7893 };
7894 HEAP32[$1 >> 2] = $11;
7895 }
7896 global$0 = $7 + 256 | 0;
7897 }
7898
7899 function FLAC__lpc_quantize_coefficients($0, $1, $2, $3, $4) {
7900 var $5 = 0, $6 = 0.0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0.0, $12 = 0, $13 = 0, $14 = Math_fround(0);
7901 $8 = global$0 - 16 | 0;
7902 global$0 = $8;
7903 label$1 : {
7904 if (!$1) {
7905 $7 = 2;
7906 break label$1;
7907 }
7908 $5 = $2 + -1 | 0;
7909 $2 = 0;
7910 while (1) {
7911 $11 = +Math_fround(Math_abs(HEAPF32[($2 << 2) + $0 >> 2]));
7912 $6 = $6 < $11 ? $11 : $6;
7913 $2 = $2 + 1 | 0;
7914 if (($2 | 0) != ($1 | 0)) {
7915 continue
7916 }
7917 break;
7918 };
7919 $7 = 2;
7920 if ($6 <= 0.0) {
7921 break label$1
7922 }
7923 $9 = 1 << $5;
7924 $12 = $9 + -1 | 0;
7925 $10 = 0 - $9 | 0;
7926 frexp($6, $8 + 12 | 0);
7927 $2 = HEAP32[$8 + 12 >> 2];
7928 HEAP32[$8 + 12 >> 2] = $2 + -1;
7929 $5 = $5 - $2 | 0;
7930 HEAP32[$4 >> 2] = $5;
7931 label$4 : {
7932 $7 = -1 << HEAP32[1413] + -1;
7933 $2 = $7 ^ -1;
7934 if (($5 | 0) > ($2 | 0)) {
7935 HEAP32[$4 >> 2] = $2;
7936 $5 = $2;
7937 break label$4;
7938 }
7939 if (($5 | 0) >= ($7 | 0)) {
7940 break label$4
7941 }
7942 $7 = 1;
7943 break label$1;
7944 }
7945 $7 = 0;
7946 if (($5 | 0) >= 0) {
7947 if (!$1) {
7948 break label$1
7949 }
7950 $6 = 0.0;
7951 $2 = 0;
7952 while (1) {
7953 $13 = $2 << 2;
7954 $6 = $6 + +Math_fround(HEAPF32[$13 + $0 >> 2] * Math_fround(1 << $5));
7955 $5 = lround($6);
7956 $5 = ($5 | 0) < ($9 | 0) ? (($5 | 0) < ($10 | 0) ? $10 : $5) : $12;
7957 HEAP32[$3 + $13 >> 2] = $5;
7958 $2 = $2 + 1 | 0;
7959 if (($2 | 0) == ($1 | 0)) {
7960 break label$1
7961 }
7962 $6 = $6 - +($5 | 0);
7963 $5 = HEAP32[$4 >> 2];
7964 continue;
7965 };
7966 }
7967 if ($1) {
7968 $2 = 0;
7969 $14 = Math_fround(1 << 0 - $5);
7970 $6 = 0.0;
7971 while (1) {
7972 $7 = $2 << 2;
7973 $6 = $6 + +Math_fround(HEAPF32[$7 + $0 >> 2] / $14);
7974 $5 = lround($6);
7975 $5 = ($5 | 0) < ($9 | 0) ? (($5 | 0) < ($10 | 0) ? $10 : $5) : $12;
7976 HEAP32[$3 + $7 >> 2] = $5;
7977 $6 = $6 - +($5 | 0);
7978 $2 = $2 + 1 | 0;
7979 if (($2 | 0) != ($1 | 0)) {
7980 continue
7981 }
7982 break;
7983 };
7984 }
7985 $7 = 0;
7986 HEAP32[$4 >> 2] = 0;
7987 }
7988 global$0 = $8 + 16 | 0;
7989 return $7;
7990 }
7991
7992 function FLAC__lpc_compute_residual_from_qlp_coefficients($0, $1, $2, $3, $4, $5) {
7993 $0 = $0 | 0;
7994 $1 = $1 | 0;
7995 $2 = $2 | 0;
7996 $3 = $3 | 0;
7997 $4 = $4 | 0;
7998 $5 = $5 | 0;
7999 var $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0, $23 = 0, $24 = 0, $25 = 0, $26 = 0, $27 = 0, $28 = 0, $29 = 0, $30 = 0;
8000 label$1 : {
8001 if ($3 >>> 0 >= 13) {
8002 if (($1 | 0) < 1) {
8003 break label$1
8004 }
8005 $25 = $3 + -13 | 0;
8006 while (1) {
8007 $17 = 0;
8008 $20 = 0;
8009 $19 = 0;
8010 $22 = 0;
8011 $21 = 0;
8012 $24 = 0;
8013 $23 = 0;
8014 $26 = 0;
8015 $18 = 0;
8016 $16 = 0;
8017 $15 = 0;
8018 $14 = 0;
8019 $13 = 0;
8020 $12 = 0;
8021 $11 = 0;
8022 $10 = 0;
8023 $9 = 0;
8024 $8 = 0;
8025 $7 = 0;
8026 $3 = 0;
8027 label$4 : {
8028 switch ($25 | 0) {
8029 case 19:
8030 $17 = Math_imul(HEAP32[(($6 << 2) + $0 | 0) + -128 >> 2], HEAP32[$2 + 124 >> 2]);
8031 case 18:
8032 $20 = Math_imul(HEAP32[(($6 << 2) + $0 | 0) + -124 >> 2], HEAP32[$2 + 120 >> 2]) + $17 | 0;
8033 case 17:
8034 $19 = Math_imul(HEAP32[(($6 << 2) + $0 | 0) + -120 >> 2], HEAP32[$2 + 116 >> 2]) + $20 | 0;
8035 case 16:
8036 $22 = Math_imul(HEAP32[(($6 << 2) + $0 | 0) + -116 >> 2], HEAP32[$2 + 112 >> 2]) + $19 | 0;
8037 case 15:
8038 $21 = Math_imul(HEAP32[(($6 << 2) + $0 | 0) + -112 >> 2], HEAP32[$2 + 108 >> 2]) + $22 | 0;
8039 case 14:
8040 $24 = Math_imul(HEAP32[(($6 << 2) + $0 | 0) + -108 >> 2], HEAP32[$2 + 104 >> 2]) + $21 | 0;
8041 case 13:
8042 $23 = Math_imul(HEAP32[(($6 << 2) + $0 | 0) + -104 >> 2], HEAP32[$2 + 100 >> 2]) + $24 | 0;
8043 case 12:
8044 $26 = Math_imul(HEAP32[(($6 << 2) + $0 | 0) + -100 >> 2], HEAP32[$2 + 96 >> 2]) + $23 | 0;
8045 case 11:
8046 $18 = Math_imul(HEAP32[(($6 << 2) + $0 | 0) + -96 >> 2], HEAP32[$2 + 92 >> 2]) + $26 | 0;
8047 case 10:
8048 $16 = Math_imul(HEAP32[(($6 << 2) + $0 | 0) + -92 >> 2], HEAP32[$2 + 88 >> 2]) + $18 | 0;
8049 case 9:
8050 $15 = Math_imul(HEAP32[(($6 << 2) + $0 | 0) + -88 >> 2], HEAP32[$2 + 84 >> 2]) + $16 | 0;
8051 case 8:
8052 $14 = Math_imul(HEAP32[(($6 << 2) + $0 | 0) + -84 >> 2], HEAP32[$2 + 80 >> 2]) + $15 | 0;
8053 case 7:
8054 $13 = Math_imul(HEAP32[(($6 << 2) + $0 | 0) + -80 >> 2], HEAP32[$2 + 76 >> 2]) + $14 | 0;
8055 case 6:
8056 $12 = Math_imul(HEAP32[(($6 << 2) + $0 | 0) + -76 >> 2], HEAP32[$2 + 72 >> 2]) + $13 | 0;
8057 case 5:
8058 $11 = Math_imul(HEAP32[(($6 << 2) + $0 | 0) + -72 >> 2], HEAP32[$2 + 68 >> 2]) + $12 | 0;
8059 case 4:
8060 $10 = Math_imul(HEAP32[(($6 << 2) + $0 | 0) + -68 >> 2], HEAP32[$2 + 64 >> 2]) + $11 | 0;
8061 case 3:
8062 $9 = Math_imul(HEAP32[(($6 << 2) + $0 | 0) + -64 >> 2], HEAP32[$2 + 60 >> 2]) + $10 | 0;
8063 case 2:
8064 $8 = Math_imul(HEAP32[(($6 << 2) + $0 | 0) + -60 >> 2], HEAP32[$2 + 56 >> 2]) + $9 | 0;
8065 case 1:
8066 $7 = Math_imul(HEAP32[(($6 << 2) + $0 | 0) + -56 >> 2], HEAP32[$2 + 52 >> 2]) + $8 | 0;
8067 case 0:
8068 $3 = ($6 << 2) + $0 | 0;
8069 $3 = ((((((((((((Math_imul(HEAP32[$3 + -52 >> 2], HEAP32[$2 + 48 >> 2]) + $7 | 0) + Math_imul(HEAP32[$3 + -48 >> 2], HEAP32[$2 + 44 >> 2]) | 0) + Math_imul(HEAP32[$3 + -44 >> 2], HEAP32[$2 + 40 >> 2]) | 0) + Math_imul(HEAP32[$3 + -40 >> 2], HEAP32[$2 + 36 >> 2]) | 0) + Math_imul(HEAP32[$3 + -36 >> 2], HEAP32[$2 + 32 >> 2]) | 0) + Math_imul(HEAP32[$3 + -32 >> 2], HEAP32[$2 + 28 >> 2]) | 0) + Math_imul(HEAP32[$3 + -28 >> 2], HEAP32[$2 + 24 >> 2]) | 0) + Math_imul(HEAP32[$3 + -24 >> 2], HEAP32[$2 + 20 >> 2]) | 0) + Math_imul(HEAP32[$3 + -20 >> 2], HEAP32[$2 + 16 >> 2]) | 0) + Math_imul(HEAP32[$3 + -16 >> 2], HEAP32[$2 + 12 >> 2]) | 0) + Math_imul(HEAP32[$3 + -12 >> 2], HEAP32[$2 + 8 >> 2]) | 0) + Math_imul(HEAP32[$3 + -8 >> 2], HEAP32[$2 + 4 >> 2]) | 0) + Math_imul(HEAP32[$3 + -4 >> 2], HEAP32[$2 >> 2]) | 0;
8070 break;
8071 default:
8072 break label$4;
8073 };
8074 }
8075 $7 = $6 << 2;
8076 HEAP32[$7 + $5 >> 2] = HEAP32[$0 + $7 >> 2] - ($3 >> $4);
8077 $6 = $6 + 1 | 0;
8078 if (($6 | 0) != ($1 | 0)) {
8079 continue
8080 }
8081 break;
8082 };
8083 break label$1;
8084 }
8085 if ($3 >>> 0 >= 9) {
8086 if ($3 >>> 0 >= 11) {
8087 if (($3 | 0) != 12) {
8088 if (($1 | 0) < 1) {
8089 break label$1
8090 }
8091 $15 = HEAP32[$0 + -4 >> 2];
8092 $6 = HEAP32[$0 + -8 >> 2];
8093 $3 = HEAP32[$0 + -12 >> 2];
8094 $7 = HEAP32[$0 + -16 >> 2];
8095 $8 = HEAP32[$0 + -20 >> 2];
8096 $9 = HEAP32[$0 + -24 >> 2];
8097 $10 = HEAP32[$0 + -28 >> 2];
8098 $11 = HEAP32[$0 + -32 >> 2];
8099 $12 = HEAP32[$0 + -36 >> 2];
8100 $13 = HEAP32[$0 + -40 >> 2];
8101 $16 = HEAP32[$0 + -44 >> 2];
8102 $18 = HEAP32[$2 >> 2];
8103 $17 = HEAP32[$2 + 4 >> 2];
8104 $20 = HEAP32[$2 + 8 >> 2];
8105 $19 = HEAP32[$2 + 12 >> 2];
8106 $22 = HEAP32[$2 + 16 >> 2];
8107 $21 = HEAP32[$2 + 20 >> 2];
8108 $24 = HEAP32[$2 + 24 >> 2];
8109 $23 = HEAP32[$2 + 28 >> 2];
8110 $26 = HEAP32[$2 + 32 >> 2];
8111 $25 = HEAP32[$2 + 36 >> 2];
8112 $28 = HEAP32[$2 + 40 >> 2];
8113 $2 = 0;
8114 while (1) {
8115 $14 = $13;
8116 $13 = $12;
8117 $12 = $11;
8118 $11 = $10;
8119 $10 = $9;
8120 $9 = $8;
8121 $8 = $7;
8122 $7 = $3;
8123 $3 = $6;
8124 $6 = $15;
8125 $27 = $2 << 2;
8126 $15 = HEAP32[$27 + $0 >> 2];
8127 HEAP32[$5 + $27 >> 2] = $15 - ((((((((((Math_imul($14, $25) + Math_imul($16, $28) | 0) + Math_imul($13, $26) | 0) + Math_imul($12, $23) | 0) + Math_imul($11, $24) | 0) + Math_imul($10, $21) | 0) + Math_imul($9, $22) | 0) + Math_imul($8, $19) | 0) + Math_imul($7, $20) | 0) + Math_imul($3, $17) | 0) + Math_imul($6, $18) >> $4);
8128 $16 = $14;
8129 $2 = $2 + 1 | 0;
8130 if (($2 | 0) != ($1 | 0)) {
8131 continue
8132 }
8133 break;
8134 };
8135 break label$1;
8136 }
8137 if (($1 | 0) < 1) {
8138 break label$1
8139 }
8140 $16 = HEAP32[$0 + -4 >> 2];
8141 $6 = HEAP32[$0 + -8 >> 2];
8142 $3 = HEAP32[$0 + -12 >> 2];
8143 $7 = HEAP32[$0 + -16 >> 2];
8144 $8 = HEAP32[$0 + -20 >> 2];
8145 $9 = HEAP32[$0 + -24 >> 2];
8146 $10 = HEAP32[$0 + -28 >> 2];
8147 $11 = HEAP32[$0 + -32 >> 2];
8148 $12 = HEAP32[$0 + -36 >> 2];
8149 $13 = HEAP32[$0 + -40 >> 2];
8150 $14 = HEAP32[$0 + -44 >> 2];
8151 $18 = HEAP32[$0 + -48 >> 2];
8152 $17 = HEAP32[$2 >> 2];
8153 $20 = HEAP32[$2 + 4 >> 2];
8154 $19 = HEAP32[$2 + 8 >> 2];
8155 $22 = HEAP32[$2 + 12 >> 2];
8156 $21 = HEAP32[$2 + 16 >> 2];
8157 $24 = HEAP32[$2 + 20 >> 2];
8158 $23 = HEAP32[$2 + 24 >> 2];
8159 $26 = HEAP32[$2 + 28 >> 2];
8160 $25 = HEAP32[$2 + 32 >> 2];
8161 $28 = HEAP32[$2 + 36 >> 2];
8162 $27 = HEAP32[$2 + 40 >> 2];
8163 $30 = HEAP32[$2 + 44 >> 2];
8164 $2 = 0;
8165 while (1) {
8166 $15 = $14;
8167 $14 = $13;
8168 $13 = $12;
8169 $12 = $11;
8170 $11 = $10;
8171 $10 = $9;
8172 $9 = $8;
8173 $8 = $7;
8174 $7 = $3;
8175 $3 = $6;
8176 $6 = $16;
8177 $29 = $2 << 2;
8178 $16 = HEAP32[$29 + $0 >> 2];
8179 HEAP32[$5 + $29 >> 2] = $16 - (((((((((((Math_imul($15, $27) + Math_imul($18, $30) | 0) + Math_imul($14, $28) | 0) + Math_imul($13, $25) | 0) + Math_imul($12, $26) | 0) + Math_imul($11, $23) | 0) + Math_imul($10, $24) | 0) + Math_imul($9, $21) | 0) + Math_imul($8, $22) | 0) + Math_imul($7, $19) | 0) + Math_imul($3, $20) | 0) + Math_imul($6, $17) >> $4);
8180 $18 = $15;
8181 $2 = $2 + 1 | 0;
8182 if (($2 | 0) != ($1 | 0)) {
8183 continue
8184 }
8185 break;
8186 };
8187 break label$1;
8188 }
8189 if (($3 | 0) != 10) {
8190 if (($1 | 0) < 1) {
8191 break label$1
8192 }
8193 $13 = HEAP32[$0 + -4 >> 2];
8194 $6 = HEAP32[$0 + -8 >> 2];
8195 $3 = HEAP32[$0 + -12 >> 2];
8196 $7 = HEAP32[$0 + -16 >> 2];
8197 $8 = HEAP32[$0 + -20 >> 2];
8198 $9 = HEAP32[$0 + -24 >> 2];
8199 $10 = HEAP32[$0 + -28 >> 2];
8200 $11 = HEAP32[$0 + -32 >> 2];
8201 $14 = HEAP32[$0 + -36 >> 2];
8202 $16 = HEAP32[$2 >> 2];
8203 $15 = HEAP32[$2 + 4 >> 2];
8204 $18 = HEAP32[$2 + 8 >> 2];
8205 $17 = HEAP32[$2 + 12 >> 2];
8206 $20 = HEAP32[$2 + 16 >> 2];
8207 $19 = HEAP32[$2 + 20 >> 2];
8208 $22 = HEAP32[$2 + 24 >> 2];
8209 $21 = HEAP32[$2 + 28 >> 2];
8210 $24 = HEAP32[$2 + 32 >> 2];
8211 $2 = 0;
8212 while (1) {
8213 $12 = $11;
8214 $11 = $10;
8215 $10 = $9;
8216 $9 = $8;
8217 $8 = $7;
8218 $7 = $3;
8219 $3 = $6;
8220 $6 = $13;
8221 $23 = $2 << 2;
8222 $13 = HEAP32[$23 + $0 >> 2];
8223 HEAP32[$5 + $23 >> 2] = $13 - ((((((((Math_imul($12, $21) + Math_imul($14, $24) | 0) + Math_imul($11, $22) | 0) + Math_imul($10, $19) | 0) + Math_imul($9, $20) | 0) + Math_imul($8, $17) | 0) + Math_imul($7, $18) | 0) + Math_imul($3, $15) | 0) + Math_imul($6, $16) >> $4);
8224 $14 = $12;
8225 $2 = $2 + 1 | 0;
8226 if (($2 | 0) != ($1 | 0)) {
8227 continue
8228 }
8229 break;
8230 };
8231 break label$1;
8232 }
8233 if (($1 | 0) < 1) {
8234 break label$1
8235 }
8236 $14 = HEAP32[$0 + -4 >> 2];
8237 $6 = HEAP32[$0 + -8 >> 2];
8238 $3 = HEAP32[$0 + -12 >> 2];
8239 $7 = HEAP32[$0 + -16 >> 2];
8240 $8 = HEAP32[$0 + -20 >> 2];
8241 $9 = HEAP32[$0 + -24 >> 2];
8242 $10 = HEAP32[$0 + -28 >> 2];
8243 $11 = HEAP32[$0 + -32 >> 2];
8244 $12 = HEAP32[$0 + -36 >> 2];
8245 $15 = HEAP32[$0 + -40 >> 2];
8246 $16 = HEAP32[$2 >> 2];
8247 $18 = HEAP32[$2 + 4 >> 2];
8248 $17 = HEAP32[$2 + 8 >> 2];
8249 $20 = HEAP32[$2 + 12 >> 2];
8250 $19 = HEAP32[$2 + 16 >> 2];
8251 $22 = HEAP32[$2 + 20 >> 2];
8252 $21 = HEAP32[$2 + 24 >> 2];
8253 $24 = HEAP32[$2 + 28 >> 2];
8254 $23 = HEAP32[$2 + 32 >> 2];
8255 $26 = HEAP32[$2 + 36 >> 2];
8256 $2 = 0;
8257 while (1) {
8258 $13 = $12;
8259 $12 = $11;
8260 $11 = $10;
8261 $10 = $9;
8262 $9 = $8;
8263 $8 = $7;
8264 $7 = $3;
8265 $3 = $6;
8266 $6 = $14;
8267 $25 = $2 << 2;
8268 $14 = HEAP32[$25 + $0 >> 2];
8269 HEAP32[$5 + $25 >> 2] = $14 - (((((((((Math_imul($13, $23) + Math_imul($15, $26) | 0) + Math_imul($12, $24) | 0) + Math_imul($11, $21) | 0) + Math_imul($10, $22) | 0) + Math_imul($9, $19) | 0) + Math_imul($8, $20) | 0) + Math_imul($7, $17) | 0) + Math_imul($3, $18) | 0) + Math_imul($6, $16) >> $4);
8270 $15 = $13;
8271 $2 = $2 + 1 | 0;
8272 if (($2 | 0) != ($1 | 0)) {
8273 continue
8274 }
8275 break;
8276 };
8277 break label$1;
8278 }
8279 if ($3 >>> 0 >= 5) {
8280 if ($3 >>> 0 >= 7) {
8281 if (($3 | 0) != 8) {
8282 if (($1 | 0) < 1) {
8283 break label$1
8284 }
8285 $11 = HEAP32[$0 + -4 >> 2];
8286 $6 = HEAP32[$0 + -8 >> 2];
8287 $3 = HEAP32[$0 + -12 >> 2];
8288 $7 = HEAP32[$0 + -16 >> 2];
8289 $8 = HEAP32[$0 + -20 >> 2];
8290 $9 = HEAP32[$0 + -24 >> 2];
8291 $12 = HEAP32[$0 + -28 >> 2];
8292 $13 = HEAP32[$2 >> 2];
8293 $14 = HEAP32[$2 + 4 >> 2];
8294 $16 = HEAP32[$2 + 8 >> 2];
8295 $15 = HEAP32[$2 + 12 >> 2];
8296 $18 = HEAP32[$2 + 16 >> 2];
8297 $17 = HEAP32[$2 + 20 >> 2];
8298 $20 = HEAP32[$2 + 24 >> 2];
8299 $2 = 0;
8300 while (1) {
8301 $10 = $9;
8302 $9 = $8;
8303 $8 = $7;
8304 $7 = $3;
8305 $3 = $6;
8306 $6 = $11;
8307 $19 = $2 << 2;
8308 $11 = HEAP32[$19 + $0 >> 2];
8309 HEAP32[$5 + $19 >> 2] = $11 - ((((((Math_imul($10, $17) + Math_imul($12, $20) | 0) + Math_imul($9, $18) | 0) + Math_imul($8, $15) | 0) + Math_imul($7, $16) | 0) + Math_imul($3, $14) | 0) + Math_imul($6, $13) >> $4);
8310 $12 = $10;
8311 $2 = $2 + 1 | 0;
8312 if (($2 | 0) != ($1 | 0)) {
8313 continue
8314 }
8315 break;
8316 };
8317 break label$1;
8318 }
8319 if (($1 | 0) < 1) {
8320 break label$1
8321 }
8322 $12 = HEAP32[$0 + -4 >> 2];
8323 $6 = HEAP32[$0 + -8 >> 2];
8324 $3 = HEAP32[$0 + -12 >> 2];
8325 $7 = HEAP32[$0 + -16 >> 2];
8326 $8 = HEAP32[$0 + -20 >> 2];
8327 $9 = HEAP32[$0 + -24 >> 2];
8328 $10 = HEAP32[$0 + -28 >> 2];
8329 $13 = HEAP32[$0 + -32 >> 2];
8330 $14 = HEAP32[$2 >> 2];
8331 $16 = HEAP32[$2 + 4 >> 2];
8332 $15 = HEAP32[$2 + 8 >> 2];
8333 $18 = HEAP32[$2 + 12 >> 2];
8334 $17 = HEAP32[$2 + 16 >> 2];
8335 $20 = HEAP32[$2 + 20 >> 2];
8336 $19 = HEAP32[$2 + 24 >> 2];
8337 $22 = HEAP32[$2 + 28 >> 2];
8338 $2 = 0;
8339 while (1) {
8340 $11 = $10;
8341 $10 = $9;
8342 $9 = $8;
8343 $8 = $7;
8344 $7 = $3;
8345 $3 = $6;
8346 $6 = $12;
8347 $21 = $2 << 2;
8348 $12 = HEAP32[$21 + $0 >> 2];
8349 HEAP32[$5 + $21 >> 2] = $12 - (((((((Math_imul($11, $19) + Math_imul($13, $22) | 0) + Math_imul($10, $20) | 0) + Math_imul($9, $17) | 0) + Math_imul($8, $18) | 0) + Math_imul($7, $15) | 0) + Math_imul($3, $16) | 0) + Math_imul($6, $14) >> $4);
8350 $13 = $11;
8351 $2 = $2 + 1 | 0;
8352 if (($2 | 0) != ($1 | 0)) {
8353 continue
8354 }
8355 break;
8356 };
8357 break label$1;
8358 }
8359 if (($3 | 0) != 6) {
8360 if (($1 | 0) < 1) {
8361 break label$1
8362 }
8363 $9 = HEAP32[$0 + -4 >> 2];
8364 $6 = HEAP32[$0 + -8 >> 2];
8365 $3 = HEAP32[$0 + -12 >> 2];
8366 $7 = HEAP32[$0 + -16 >> 2];
8367 $10 = HEAP32[$0 + -20 >> 2];
8368 $11 = HEAP32[$2 >> 2];
8369 $12 = HEAP32[$2 + 4 >> 2];
8370 $13 = HEAP32[$2 + 8 >> 2];
8371 $14 = HEAP32[$2 + 12 >> 2];
8372 $16 = HEAP32[$2 + 16 >> 2];
8373 $2 = 0;
8374 while (1) {
8375 $8 = $7;
8376 $7 = $3;
8377 $3 = $6;
8378 $6 = $9;
8379 $15 = $2 << 2;
8380 $9 = HEAP32[$15 + $0 >> 2];
8381 HEAP32[$5 + $15 >> 2] = $9 - ((((Math_imul($8, $14) + Math_imul($10, $16) | 0) + Math_imul($7, $13) | 0) + Math_imul($3, $12) | 0) + Math_imul($6, $11) >> $4);
8382 $10 = $8;
8383 $2 = $2 + 1 | 0;
8384 if (($2 | 0) != ($1 | 0)) {
8385 continue
8386 }
8387 break;
8388 };
8389 break label$1;
8390 }
8391 if (($1 | 0) < 1) {
8392 break label$1
8393 }
8394 $10 = HEAP32[$0 + -4 >> 2];
8395 $6 = HEAP32[$0 + -8 >> 2];
8396 $3 = HEAP32[$0 + -12 >> 2];
8397 $7 = HEAP32[$0 + -16 >> 2];
8398 $8 = HEAP32[$0 + -20 >> 2];
8399 $11 = HEAP32[$0 + -24 >> 2];
8400 $12 = HEAP32[$2 >> 2];
8401 $13 = HEAP32[$2 + 4 >> 2];
8402 $14 = HEAP32[$2 + 8 >> 2];
8403 $16 = HEAP32[$2 + 12 >> 2];
8404 $15 = HEAP32[$2 + 16 >> 2];
8405 $18 = HEAP32[$2 + 20 >> 2];
8406 $2 = 0;
8407 while (1) {
8408 $9 = $8;
8409 $8 = $7;
8410 $7 = $3;
8411 $3 = $6;
8412 $6 = $10;
8413 $17 = $2 << 2;
8414 $10 = HEAP32[$17 + $0 >> 2];
8415 HEAP32[$5 + $17 >> 2] = $10 - (((((Math_imul($9, $15) + Math_imul($11, $18) | 0) + Math_imul($8, $16) | 0) + Math_imul($7, $14) | 0) + Math_imul($3, $13) | 0) + Math_imul($6, $12) >> $4);
8416 $11 = $9;
8417 $2 = $2 + 1 | 0;
8418 if (($2 | 0) != ($1 | 0)) {
8419 continue
8420 }
8421 break;
8422 };
8423 break label$1;
8424 }
8425 if ($3 >>> 0 >= 3) {
8426 if (($3 | 0) != 4) {
8427 if (($1 | 0) < 1) {
8428 break label$1
8429 }
8430 $7 = HEAP32[$0 + -4 >> 2];
8431 $6 = HEAP32[$0 + -8 >> 2];
8432 $8 = HEAP32[$0 + -12 >> 2];
8433 $9 = HEAP32[$2 >> 2];
8434 $10 = HEAP32[$2 + 4 >> 2];
8435 $11 = HEAP32[$2 + 8 >> 2];
8436 $2 = 0;
8437 while (1) {
8438 $3 = $6;
8439 $6 = $7;
8440 $12 = $2 << 2;
8441 $7 = HEAP32[$12 + $0 >> 2];
8442 HEAP32[$5 + $12 >> 2] = $7 - ((Math_imul($3, $10) + Math_imul($8, $11) | 0) + Math_imul($6, $9) >> $4);
8443 $8 = $3;
8444 $2 = $2 + 1 | 0;
8445 if (($2 | 0) != ($1 | 0)) {
8446 continue
8447 }
8448 break;
8449 };
8450 break label$1;
8451 }
8452 if (($1 | 0) < 1) {
8453 break label$1
8454 }
8455 $8 = HEAP32[$0 + -4 >> 2];
8456 $6 = HEAP32[$0 + -8 >> 2];
8457 $3 = HEAP32[$0 + -12 >> 2];
8458 $9 = HEAP32[$0 + -16 >> 2];
8459 $10 = HEAP32[$2 >> 2];
8460 $11 = HEAP32[$2 + 4 >> 2];
8461 $12 = HEAP32[$2 + 8 >> 2];
8462 $13 = HEAP32[$2 + 12 >> 2];
8463 $2 = 0;
8464 while (1) {
8465 $7 = $3;
8466 $3 = $6;
8467 $6 = $8;
8468 $14 = $2 << 2;
8469 $8 = HEAP32[$14 + $0 >> 2];
8470 HEAP32[$5 + $14 >> 2] = $8 - (((Math_imul($7, $12) + Math_imul($9, $13) | 0) + Math_imul($3, $11) | 0) + Math_imul($6, $10) >> $4);
8471 $9 = $7;
8472 $2 = $2 + 1 | 0;
8473 if (($2 | 0) != ($1 | 0)) {
8474 continue
8475 }
8476 break;
8477 };
8478 break label$1;
8479 }
8480 if (($3 | 0) != 2) {
8481 if (($1 | 0) < 1) {
8482 break label$1
8483 }
8484 $6 = HEAP32[$0 + -4 >> 2];
8485 $3 = HEAP32[$2 >> 2];
8486 $2 = 0;
8487 while (1) {
8488 $7 = Math_imul($3, $6);
8489 $8 = $2 << 2;
8490 $6 = HEAP32[$8 + $0 >> 2];
8491 HEAP32[$5 + $8 >> 2] = $6 - ($7 >> $4);
8492 $2 = $2 + 1 | 0;
8493 if (($2 | 0) != ($1 | 0)) {
8494 continue
8495 }
8496 break;
8497 };
8498 break label$1;
8499 }
8500 if (($1 | 0) < 1) {
8501 break label$1
8502 }
8503 $3 = HEAP32[$0 + -4 >> 2];
8504 $7 = HEAP32[$0 + -8 >> 2];
8505 $8 = HEAP32[$2 >> 2];
8506 $9 = HEAP32[$2 + 4 >> 2];
8507 $2 = 0;
8508 while (1) {
8509 $6 = $3;
8510 $10 = $2 << 2;
8511 $3 = HEAP32[$10 + $0 >> 2];
8512 HEAP32[$5 + $10 >> 2] = $3 - (Math_imul($6, $8) + Math_imul($7, $9) >> $4);
8513 $7 = $6;
8514 $2 = $2 + 1 | 0;
8515 if (($2 | 0) != ($1 | 0)) {
8516 continue
8517 }
8518 break;
8519 };
8520 }
8521 }
8522
8523 function FLAC__lpc_compute_residual_from_qlp_coefficients_wide($0, $1, $2, $3, $4, $5) {
8524 $0 = $0 | 0;
8525 $1 = $1 | 0;
8526 $2 = $2 | 0;
8527 $3 = $3 | 0;
8528 $4 = $4 | 0;
8529 $5 = $5 | 0;
8530 var $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0, $23 = 0, $24 = 0, $25 = 0, $26 = 0, $27 = 0, $28 = 0, $29 = 0, $30 = 0, $31 = 0, $32 = 0, $33 = 0, $34 = 0, $35 = 0, $36 = 0, $37 = 0, $38 = 0, $39 = 0, $40 = 0, $41 = 0, $42 = 0, $43 = 0, $44 = 0, $45 = 0;
8531 label$1 : {
8532 if ($3 >>> 0 >= 13) {
8533 if (($1 | 0) < 1) {
8534 break label$1
8535 }
8536 $18 = $4;
8537 $12 = $3 + -13 | 0;
8538 while (1) {
8539 $4 = 0;
8540 $3 = 0;
8541 label$4 : {
8542 switch ($12 | 0) {
8543 case 19:
8544 $3 = HEAP32[(($15 << 2) + $0 | 0) + -128 >> 2];
8545 $4 = $3;
8546 $7 = $3 >> 31;
8547 $3 = HEAP32[$2 + 124 >> 2];
8548 $4 = __wasm_i64_mul($4, $7, $3, $3 >> 31);
8549 $3 = i64toi32_i32$HIGH_BITS;
8550 case 18:
8551 $7 = HEAP32[(($15 << 2) + $0 | 0) + -124 >> 2];
8552 $6 = $7;
8553 $8 = $7 >> 31;
8554 $7 = HEAP32[$2 + 120 >> 2];
8555 $7 = __wasm_i64_mul($6, $8, $7, $7 >> 31) + $4 | 0;
8556 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
8557 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
8558 $4 = $7;
8559 $3 = $6;
8560 case 17:
8561 $7 = HEAP32[(($15 << 2) + $0 | 0) + -120 >> 2];
8562 $6 = $7;
8563 $8 = $7 >> 31;
8564 $7 = HEAP32[$2 + 116 >> 2];
8565 $7 = __wasm_i64_mul($6, $8, $7, $7 >> 31) + $4 | 0;
8566 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
8567 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
8568 $4 = $7;
8569 $3 = $6;
8570 case 16:
8571 $7 = HEAP32[(($15 << 2) + $0 | 0) + -116 >> 2];
8572 $6 = $7;
8573 $8 = $7 >> 31;
8574 $7 = HEAP32[$2 + 112 >> 2];
8575 $7 = __wasm_i64_mul($6, $8, $7, $7 >> 31) + $4 | 0;
8576 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
8577 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
8578 $4 = $7;
8579 $3 = $6;
8580 case 15:
8581 $7 = HEAP32[(($15 << 2) + $0 | 0) + -112 >> 2];
8582 $6 = $7;
8583 $8 = $7 >> 31;
8584 $7 = HEAP32[$2 + 108 >> 2];
8585 $7 = __wasm_i64_mul($6, $8, $7, $7 >> 31) + $4 | 0;
8586 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
8587 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
8588 $4 = $7;
8589 $3 = $6;
8590 case 14:
8591 $7 = HEAP32[(($15 << 2) + $0 | 0) + -108 >> 2];
8592 $6 = $7;
8593 $8 = $7 >> 31;
8594 $7 = HEAP32[$2 + 104 >> 2];
8595 $7 = __wasm_i64_mul($6, $8, $7, $7 >> 31) + $4 | 0;
8596 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
8597 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
8598 $4 = $7;
8599 $3 = $6;
8600 case 13:
8601 $7 = HEAP32[(($15 << 2) + $0 | 0) + -104 >> 2];
8602 $6 = $7;
8603 $8 = $7 >> 31;
8604 $7 = HEAP32[$2 + 100 >> 2];
8605 $7 = __wasm_i64_mul($6, $8, $7, $7 >> 31) + $4 | 0;
8606 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
8607 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
8608 $4 = $7;
8609 $3 = $6;
8610 case 12:
8611 $7 = HEAP32[(($15 << 2) + $0 | 0) + -100 >> 2];
8612 $6 = $7;
8613 $8 = $7 >> 31;
8614 $7 = HEAP32[$2 + 96 >> 2];
8615 $7 = __wasm_i64_mul($6, $8, $7, $7 >> 31) + $4 | 0;
8616 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
8617 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
8618 $4 = $7;
8619 $3 = $6;
8620 case 11:
8621 $7 = HEAP32[(($15 << 2) + $0 | 0) + -96 >> 2];
8622 $6 = $7;
8623 $8 = $7 >> 31;
8624 $7 = HEAP32[$2 + 92 >> 2];
8625 $7 = __wasm_i64_mul($6, $8, $7, $7 >> 31) + $4 | 0;
8626 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
8627 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
8628 $4 = $7;
8629 $3 = $6;
8630 case 10:
8631 $7 = HEAP32[(($15 << 2) + $0 | 0) + -92 >> 2];
8632 $6 = $7;
8633 $8 = $7 >> 31;
8634 $7 = HEAP32[$2 + 88 >> 2];
8635 $7 = __wasm_i64_mul($6, $8, $7, $7 >> 31) + $4 | 0;
8636 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
8637 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
8638 $4 = $7;
8639 $3 = $6;
8640 case 9:
8641 $7 = HEAP32[(($15 << 2) + $0 | 0) + -88 >> 2];
8642 $6 = $7;
8643 $8 = $7 >> 31;
8644 $7 = HEAP32[$2 + 84 >> 2];
8645 $7 = __wasm_i64_mul($6, $8, $7, $7 >> 31) + $4 | 0;
8646 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
8647 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
8648 $4 = $7;
8649 $3 = $6;
8650 case 8:
8651 $7 = HEAP32[(($15 << 2) + $0 | 0) + -84 >> 2];
8652 $6 = $7;
8653 $8 = $7 >> 31;
8654 $7 = HEAP32[$2 + 80 >> 2];
8655 $7 = __wasm_i64_mul($6, $8, $7, $7 >> 31) + $4 | 0;
8656 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
8657 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
8658 $4 = $7;
8659 $3 = $6;
8660 case 7:
8661 $7 = HEAP32[(($15 << 2) + $0 | 0) + -80 >> 2];
8662 $6 = $7;
8663 $8 = $7 >> 31;
8664 $7 = HEAP32[$2 + 76 >> 2];
8665 $7 = __wasm_i64_mul($6, $8, $7, $7 >> 31) + $4 | 0;
8666 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
8667 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
8668 $4 = $7;
8669 $3 = $6;
8670 case 6:
8671 $7 = HEAP32[(($15 << 2) + $0 | 0) + -76 >> 2];
8672 $6 = $7;
8673 $8 = $7 >> 31;
8674 $7 = HEAP32[$2 + 72 >> 2];
8675 $7 = __wasm_i64_mul($6, $8, $7, $7 >> 31) + $4 | 0;
8676 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
8677 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
8678 $4 = $7;
8679 $3 = $6;
8680 case 5:
8681 $7 = HEAP32[(($15 << 2) + $0 | 0) + -72 >> 2];
8682 $6 = $7;
8683 $8 = $7 >> 31;
8684 $7 = HEAP32[$2 + 68 >> 2];
8685 $7 = __wasm_i64_mul($6, $8, $7, $7 >> 31) + $4 | 0;
8686 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
8687 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
8688 $4 = $7;
8689 $3 = $6;
8690 case 4:
8691 $7 = HEAP32[(($15 << 2) + $0 | 0) + -68 >> 2];
8692 $6 = $7;
8693 $8 = $7 >> 31;
8694 $7 = HEAP32[$2 + 64 >> 2];
8695 $7 = __wasm_i64_mul($6, $8, $7, $7 >> 31) + $4 | 0;
8696 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
8697 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
8698 $4 = $7;
8699 $3 = $6;
8700 case 3:
8701 $7 = HEAP32[(($15 << 2) + $0 | 0) + -64 >> 2];
8702 $6 = $7;
8703 $8 = $7 >> 31;
8704 $7 = HEAP32[$2 + 60 >> 2];
8705 $7 = __wasm_i64_mul($6, $8, $7, $7 >> 31) + $4 | 0;
8706 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
8707 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
8708 $4 = $7;
8709 $3 = $6;
8710 case 2:
8711 $7 = HEAP32[(($15 << 2) + $0 | 0) + -60 >> 2];
8712 $6 = $7;
8713 $8 = $7 >> 31;
8714 $7 = HEAP32[$2 + 56 >> 2];
8715 $7 = __wasm_i64_mul($6, $8, $7, $7 >> 31) + $4 | 0;
8716 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
8717 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
8718 $4 = $7;
8719 $3 = $6;
8720 case 1:
8721 $7 = HEAP32[(($15 << 2) + $0 | 0) + -56 >> 2];
8722 $6 = $7;
8723 $8 = $7 >> 31;
8724 $7 = HEAP32[$2 + 52 >> 2];
8725 $7 = __wasm_i64_mul($6, $8, $7, $7 >> 31) + $4 | 0;
8726 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
8727 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
8728 $4 = $7;
8729 $3 = $6;
8730 case 0:
8731 $8 = ($15 << 2) + $0 | 0;
8732 $7 = HEAP32[$8 + -52 >> 2];
8733 $6 = $7;
8734 $9 = $7 >> 31;
8735 $7 = HEAP32[$2 + 48 >> 2];
8736 $7 = __wasm_i64_mul($6, $9, $7, $7 >> 31) + $4 | 0;
8737 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
8738 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
8739 $3 = HEAP32[$8 + -48 >> 2];
8740 $4 = $3;
8741 $9 = $3 >> 31;
8742 $3 = HEAP32[$2 + 44 >> 2];
8743 $3 = __wasm_i64_mul($4, $9, $3, $3 >> 31);
8744 $4 = $3 + $7 | 0;
8745 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
8746 $6 = $4 >>> 0 < $3 >>> 0 ? $6 + 1 | 0 : $6;
8747 $3 = HEAP32[$8 + -44 >> 2];
8748 $7 = $3;
8749 $9 = $3 >> 31;
8750 $3 = HEAP32[$2 + 40 >> 2];
8751 $3 = __wasm_i64_mul($7, $9, $3, $3 >> 31);
8752 $4 = $3 + $4 | 0;
8753 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
8754 $6 = $4 >>> 0 < $3 >>> 0 ? $6 + 1 | 0 : $6;
8755 $3 = HEAP32[$8 + -40 >> 2];
8756 $7 = $3;
8757 $9 = $3 >> 31;
8758 $3 = HEAP32[$2 + 36 >> 2];
8759 $3 = __wasm_i64_mul($7, $9, $3, $3 >> 31);
8760 $4 = $3 + $4 | 0;
8761 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
8762 $6 = $4 >>> 0 < $3 >>> 0 ? $6 + 1 | 0 : $6;
8763 $3 = HEAP32[$8 + -36 >> 2];
8764 $7 = $3;
8765 $9 = $3 >> 31;
8766 $3 = HEAP32[$2 + 32 >> 2];
8767 $3 = __wasm_i64_mul($7, $9, $3, $3 >> 31);
8768 $4 = $3 + $4 | 0;
8769 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
8770 $6 = $4 >>> 0 < $3 >>> 0 ? $6 + 1 | 0 : $6;
8771 $3 = HEAP32[$8 + -32 >> 2];
8772 $7 = $3;
8773 $9 = $3 >> 31;
8774 $3 = HEAP32[$2 + 28 >> 2];
8775 $3 = __wasm_i64_mul($7, $9, $3, $3 >> 31);
8776 $4 = $3 + $4 | 0;
8777 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
8778 $6 = $4 >>> 0 < $3 >>> 0 ? $6 + 1 | 0 : $6;
8779 $3 = HEAP32[$8 + -28 >> 2];
8780 $7 = $3;
8781 $9 = $3 >> 31;
8782 $3 = HEAP32[$2 + 24 >> 2];
8783 $3 = __wasm_i64_mul($7, $9, $3, $3 >> 31);
8784 $4 = $3 + $4 | 0;
8785 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
8786 $6 = $4 >>> 0 < $3 >>> 0 ? $6 + 1 | 0 : $6;
8787 $3 = HEAP32[$8 + -24 >> 2];
8788 $7 = $3;
8789 $9 = $3 >> 31;
8790 $3 = HEAP32[$2 + 20 >> 2];
8791 $3 = __wasm_i64_mul($7, $9, $3, $3 >> 31);
8792 $4 = $3 + $4 | 0;
8793 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
8794 $6 = $4 >>> 0 < $3 >>> 0 ? $6 + 1 | 0 : $6;
8795 $3 = HEAP32[$8 + -20 >> 2];
8796 $7 = $3;
8797 $9 = $3 >> 31;
8798 $3 = HEAP32[$2 + 16 >> 2];
8799 $3 = __wasm_i64_mul($7, $9, $3, $3 >> 31);
8800 $4 = $3 + $4 | 0;
8801 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
8802 $6 = $4 >>> 0 < $3 >>> 0 ? $6 + 1 | 0 : $6;
8803 $3 = HEAP32[$8 + -16 >> 2];
8804 $7 = $3;
8805 $9 = $3 >> 31;
8806 $3 = HEAP32[$2 + 12 >> 2];
8807 $3 = __wasm_i64_mul($7, $9, $3, $3 >> 31);
8808 $4 = $3 + $4 | 0;
8809 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
8810 $6 = $4 >>> 0 < $3 >>> 0 ? $6 + 1 | 0 : $6;
8811 $3 = HEAP32[$8 + -12 >> 2];
8812 $7 = $3;
8813 $9 = $3 >> 31;
8814 $3 = HEAP32[$2 + 8 >> 2];
8815 $3 = __wasm_i64_mul($7, $9, $3, $3 >> 31);
8816 $4 = $3 + $4 | 0;
8817 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
8818 $6 = $4 >>> 0 < $3 >>> 0 ? $6 + 1 | 0 : $6;
8819 $3 = HEAP32[$8 + -8 >> 2];
8820 $7 = $3;
8821 $9 = $3 >> 31;
8822 $3 = HEAP32[$2 + 4 >> 2];
8823 $3 = __wasm_i64_mul($7, $9, $3, $3 >> 31);
8824 $4 = $3 + $4 | 0;
8825 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
8826 $6 = $4 >>> 0 < $3 >>> 0 ? $6 + 1 | 0 : $6;
8827 $3 = HEAP32[$8 + -4 >> 2];
8828 $7 = $3;
8829 $8 = $3 >> 31;
8830 $3 = HEAP32[$2 >> 2];
8831 $3 = __wasm_i64_mul($7, $8, $3, $3 >> 31);
8832 $4 = $3 + $4 | 0;
8833 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
8834 $6 = $4 >>> 0 < $3 >>> 0 ? $6 + 1 | 0 : $6;
8835 $3 = $6;
8836 break;
8837 default:
8838 break label$4;
8839 };
8840 }
8841 $7 = $15 << 2;
8842 $6 = $7 + $5 | 0;
8843 $9 = HEAP32[$0 + $7 >> 2];
8844 $7 = $3;
8845 $3 = $18;
8846 $8 = $3 & 31;
8847 HEAP32[$6 >> 2] = $9 - (32 <= ($3 & 63) >>> 0 ? $7 >> $8 : ((1 << $8) - 1 & $7) << 32 - $8 | $4 >>> $8);
8848 $15 = $15 + 1 | 0;
8849 if (($15 | 0) != ($1 | 0)) {
8850 continue
8851 }
8852 break;
8853 };
8854 break label$1;
8855 }
8856 if ($3 >>> 0 >= 9) {
8857 if ($3 >>> 0 >= 11) {
8858 if (($3 | 0) != 12) {
8859 if (($1 | 0) < 1) {
8860 break label$1
8861 }
8862 $10 = HEAP32[$0 + -4 >> 2];
8863 $15 = HEAP32[$0 + -8 >> 2];
8864 $3 = HEAP32[$0 + -12 >> 2];
8865 $18 = HEAP32[$0 + -16 >> 2];
8866 $7 = HEAP32[$0 + -20 >> 2];
8867 $12 = HEAP32[$0 + -24 >> 2];
8868 $8 = HEAP32[$0 + -28 >> 2];
8869 $9 = HEAP32[$0 + -32 >> 2];
8870 $11 = HEAP32[$0 + -36 >> 2];
8871 $17 = HEAP32[$0 + -40 >> 2];
8872 $13 = HEAP32[$0 + -44 >> 2];
8873 $6 = HEAP32[$2 >> 2];
8874 $40 = $6;
8875 $41 = $6 >> 31;
8876 $6 = HEAP32[$2 + 4 >> 2];
8877 $42 = $6;
8878 $37 = $6 >> 31;
8879 $6 = HEAP32[$2 + 8 >> 2];
8880 $38 = $6;
8881 $39 = $6 >> 31;
8882 $6 = HEAP32[$2 + 12 >> 2];
8883 $34 = $6;
8884 $35 = $6 >> 31;
8885 $6 = HEAP32[$2 + 16 >> 2];
8886 $36 = $6;
8887 $31 = $6 >> 31;
8888 $6 = HEAP32[$2 + 20 >> 2];
8889 $32 = $6;
8890 $33 = $6 >> 31;
8891 $6 = HEAP32[$2 + 24 >> 2];
8892 $29 = $6;
8893 $30 = $6 >> 31;
8894 $6 = HEAP32[$2 + 28 >> 2];
8895 $26 = $6;
8896 $27 = $6 >> 31;
8897 $6 = HEAP32[$2 + 32 >> 2];
8898 $28 = $6;
8899 $23 = $6 >> 31;
8900 $6 = HEAP32[$2 + 36 >> 2];
8901 $24 = $6;
8902 $25 = $6 >> 31;
8903 $2 = HEAP32[$2 + 40 >> 2];
8904 $21 = $2;
8905 $22 = $2 >> 31;
8906 $2 = 0;
8907 while (1) {
8908 $16 = $17;
8909 $17 = $11;
8910 $11 = $9;
8911 $9 = $8;
8912 $8 = $12;
8913 $12 = $7;
8914 $7 = $18;
8915 $18 = $3;
8916 $3 = $15;
8917 $15 = $10;
8918 $6 = $2 << 2;
8919 $20 = $6 + $5 | 0;
8920 $10 = HEAP32[$0 + $6 >> 2];
8921 $14 = __wasm_i64_mul($16, $16 >> 31, $24, $25);
8922 $6 = i64toi32_i32$HIGH_BITS;
8923 $13 = __wasm_i64_mul($13, $13 >> 31, $21, $22);
8924 $14 = $13 + $14 | 0;
8925 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
8926 $6 = $14 >>> 0 < $13 >>> 0 ? $6 + 1 | 0 : $6;
8927 $13 = __wasm_i64_mul($17, $17 >> 31, $28, $23);
8928 $14 = $13 + $14 | 0;
8929 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
8930 $6 = $14 >>> 0 < $13 >>> 0 ? $6 + 1 | 0 : $6;
8931 $13 = __wasm_i64_mul($11, $11 >> 31, $26, $27);
8932 $14 = $13 + $14 | 0;
8933 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
8934 $6 = $14 >>> 0 < $13 >>> 0 ? $6 + 1 | 0 : $6;
8935 $13 = __wasm_i64_mul($9, $9 >> 31, $29, $30);
8936 $14 = $13 + $14 | 0;
8937 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
8938 $6 = $14 >>> 0 < $13 >>> 0 ? $6 + 1 | 0 : $6;
8939 $13 = __wasm_i64_mul($8, $8 >> 31, $32, $33);
8940 $14 = $13 + $14 | 0;
8941 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
8942 $6 = $14 >>> 0 < $13 >>> 0 ? $6 + 1 | 0 : $6;
8943 $13 = __wasm_i64_mul($12, $12 >> 31, $36, $31);
8944 $14 = $13 + $14 | 0;
8945 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
8946 $6 = $14 >>> 0 < $13 >>> 0 ? $6 + 1 | 0 : $6;
8947 $13 = __wasm_i64_mul($7, $7 >> 31, $34, $35);
8948 $14 = $13 + $14 | 0;
8949 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
8950 $6 = $14 >>> 0 < $13 >>> 0 ? $6 + 1 | 0 : $6;
8951 $13 = __wasm_i64_mul($18, $18 >> 31, $38, $39);
8952 $14 = $13 + $14 | 0;
8953 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
8954 $6 = $14 >>> 0 < $13 >>> 0 ? $6 + 1 | 0 : $6;
8955 $13 = __wasm_i64_mul($3, $3 >> 31, $42, $37);
8956 $14 = $13 + $14 | 0;
8957 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
8958 $6 = $14 >>> 0 < $13 >>> 0 ? $6 + 1 | 0 : $6;
8959 $13 = __wasm_i64_mul($15, $15 >> 31, $40, $41);
8960 $14 = $13 + $14 | 0;
8961 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
8962 $6 = $14 >>> 0 < $13 >>> 0 ? $6 + 1 | 0 : $6;
8963 $13 = $6;
8964 $6 = $4;
8965 $19 = $6 & 31;
8966 HEAP32[$20 >> 2] = $10 - (32 <= ($6 & 63) >>> 0 ? $13 >> $19 : ((1 << $19) - 1 & $13) << 32 - $19 | $14 >>> $19);
8967 $13 = $16;
8968 $2 = $2 + 1 | 0;
8969 if (($2 | 0) != ($1 | 0)) {
8970 continue
8971 }
8972 break;
8973 };
8974 break label$1;
8975 }
8976 if (($1 | 0) < 1) {
8977 break label$1
8978 }
8979 $13 = HEAP32[$0 + -4 >> 2];
8980 $15 = HEAP32[$0 + -8 >> 2];
8981 $3 = HEAP32[$0 + -12 >> 2];
8982 $18 = HEAP32[$0 + -16 >> 2];
8983 $7 = HEAP32[$0 + -20 >> 2];
8984 $12 = HEAP32[$0 + -24 >> 2];
8985 $8 = HEAP32[$0 + -28 >> 2];
8986 $9 = HEAP32[$0 + -32 >> 2];
8987 $11 = HEAP32[$0 + -36 >> 2];
8988 $17 = HEAP32[$0 + -40 >> 2];
8989 $16 = HEAP32[$0 + -44 >> 2];
8990 $6 = HEAP32[$0 + -48 >> 2];
8991 $10 = HEAP32[$2 >> 2];
8992 $43 = $10;
8993 $44 = $10 >> 31;
8994 $10 = HEAP32[$2 + 4 >> 2];
8995 $45 = $10;
8996 $40 = $10 >> 31;
8997 $10 = HEAP32[$2 + 8 >> 2];
8998 $41 = $10;
8999 $42 = $10 >> 31;
9000 $10 = HEAP32[$2 + 12 >> 2];
9001 $37 = $10;
9002 $38 = $10 >> 31;
9003 $10 = HEAP32[$2 + 16 >> 2];
9004 $39 = $10;
9005 $34 = $10 >> 31;
9006 $10 = HEAP32[$2 + 20 >> 2];
9007 $35 = $10;
9008 $36 = $10 >> 31;
9009 $10 = HEAP32[$2 + 24 >> 2];
9010 $31 = $10;
9011 $32 = $10 >> 31;
9012 $10 = HEAP32[$2 + 28 >> 2];
9013 $33 = $10;
9014 $29 = $10 >> 31;
9015 $10 = HEAP32[$2 + 32 >> 2];
9016 $30 = $10;
9017 $26 = $10 >> 31;
9018 $10 = HEAP32[$2 + 36 >> 2];
9019 $27 = $10;
9020 $28 = $10 >> 31;
9021 $10 = HEAP32[$2 + 40 >> 2];
9022 $23 = $10;
9023 $24 = $10 >> 31;
9024 $2 = HEAP32[$2 + 44 >> 2];
9025 $25 = $2;
9026 $21 = $2 >> 31;
9027 $2 = 0;
9028 while (1) {
9029 $10 = $16;
9030 $16 = $17;
9031 $17 = $11;
9032 $11 = $9;
9033 $9 = $8;
9034 $8 = $12;
9035 $12 = $7;
9036 $7 = $18;
9037 $18 = $3;
9038 $3 = $15;
9039 $15 = $13;
9040 $13 = $2 << 2;
9041 $22 = $13 + $5 | 0;
9042 $13 = HEAP32[$0 + $13 >> 2];
9043 $14 = __wasm_i64_mul($10, $10 >> 31, $23, $24);
9044 $19 = i64toi32_i32$HIGH_BITS;
9045 $20 = $14;
9046 $14 = __wasm_i64_mul($6, $6 >> 31, $25, $21);
9047 $20 = $20 + $14 | 0;
9048 $6 = i64toi32_i32$HIGH_BITS + $19 | 0;
9049 $6 = $20 >>> 0 < $14 >>> 0 ? $6 + 1 | 0 : $6;
9050 $14 = __wasm_i64_mul($16, $16 >> 31, $27, $28);
9051 $19 = $14 + $20 | 0;
9052 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9053 $6 = $19 >>> 0 < $14 >>> 0 ? $6 + 1 | 0 : $6;
9054 $14 = __wasm_i64_mul($17, $17 >> 31, $30, $26);
9055 $19 = $14 + $19 | 0;
9056 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9057 $6 = $19 >>> 0 < $14 >>> 0 ? $6 + 1 | 0 : $6;
9058 $14 = __wasm_i64_mul($11, $11 >> 31, $33, $29);
9059 $19 = $14 + $19 | 0;
9060 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9061 $6 = $19 >>> 0 < $14 >>> 0 ? $6 + 1 | 0 : $6;
9062 $14 = __wasm_i64_mul($9, $9 >> 31, $31, $32);
9063 $19 = $14 + $19 | 0;
9064 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9065 $6 = $19 >>> 0 < $14 >>> 0 ? $6 + 1 | 0 : $6;
9066 $14 = __wasm_i64_mul($8, $8 >> 31, $35, $36);
9067 $19 = $14 + $19 | 0;
9068 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9069 $6 = $19 >>> 0 < $14 >>> 0 ? $6 + 1 | 0 : $6;
9070 $14 = __wasm_i64_mul($12, $12 >> 31, $39, $34);
9071 $19 = $14 + $19 | 0;
9072 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9073 $6 = $19 >>> 0 < $14 >>> 0 ? $6 + 1 | 0 : $6;
9074 $14 = __wasm_i64_mul($7, $7 >> 31, $37, $38);
9075 $19 = $14 + $19 | 0;
9076 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9077 $6 = $19 >>> 0 < $14 >>> 0 ? $6 + 1 | 0 : $6;
9078 $14 = __wasm_i64_mul($18, $18 >> 31, $41, $42);
9079 $19 = $14 + $19 | 0;
9080 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9081 $6 = $19 >>> 0 < $14 >>> 0 ? $6 + 1 | 0 : $6;
9082 $14 = __wasm_i64_mul($3, $3 >> 31, $45, $40);
9083 $19 = $14 + $19 | 0;
9084 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9085 $6 = $19 >>> 0 < $14 >>> 0 ? $6 + 1 | 0 : $6;
9086 $14 = __wasm_i64_mul($15, $15 >> 31, $43, $44);
9087 $19 = $14 + $19 | 0;
9088 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9089 $6 = $19 >>> 0 < $14 >>> 0 ? $6 + 1 | 0 : $6;
9090 $14 = $6;
9091 $6 = $4;
9092 $20 = $6 & 31;
9093 HEAP32[$22 >> 2] = $13 - (32 <= ($6 & 63) >>> 0 ? $14 >> $20 : ((1 << $20) - 1 & $14) << 32 - $20 | $19 >>> $20);
9094 $6 = $10;
9095 $2 = $2 + 1 | 0;
9096 if (($2 | 0) != ($1 | 0)) {
9097 continue
9098 }
9099 break;
9100 };
9101 break label$1;
9102 }
9103 if (($3 | 0) != 10) {
9104 if (($1 | 0) < 1) {
9105 break label$1
9106 }
9107 $17 = HEAP32[$0 + -4 >> 2];
9108 $15 = HEAP32[$0 + -8 >> 2];
9109 $3 = HEAP32[$0 + -12 >> 2];
9110 $18 = HEAP32[$0 + -16 >> 2];
9111 $7 = HEAP32[$0 + -20 >> 2];
9112 $12 = HEAP32[$0 + -24 >> 2];
9113 $8 = HEAP32[$0 + -28 >> 2];
9114 $9 = HEAP32[$0 + -32 >> 2];
9115 $16 = HEAP32[$0 + -36 >> 2];
9116 $11 = HEAP32[$2 >> 2];
9117 $34 = $11;
9118 $35 = $11 >> 31;
9119 $11 = HEAP32[$2 + 4 >> 2];
9120 $36 = $11;
9121 $31 = $11 >> 31;
9122 $11 = HEAP32[$2 + 8 >> 2];
9123 $32 = $11;
9124 $33 = $11 >> 31;
9125 $11 = HEAP32[$2 + 12 >> 2];
9126 $29 = $11;
9127 $30 = $11 >> 31;
9128 $11 = HEAP32[$2 + 16 >> 2];
9129 $26 = $11;
9130 $27 = $11 >> 31;
9131 $11 = HEAP32[$2 + 20 >> 2];
9132 $28 = $11;
9133 $23 = $11 >> 31;
9134 $11 = HEAP32[$2 + 24 >> 2];
9135 $24 = $11;
9136 $25 = $11 >> 31;
9137 $11 = HEAP32[$2 + 28 >> 2];
9138 $21 = $11;
9139 $22 = $11 >> 31;
9140 $2 = HEAP32[$2 + 32 >> 2];
9141 $20 = $2;
9142 $19 = $2 >> 31;
9143 $2 = 0;
9144 while (1) {
9145 $11 = $9;
9146 $9 = $8;
9147 $8 = $12;
9148 $12 = $7;
9149 $7 = $18;
9150 $18 = $3;
9151 $3 = $15;
9152 $15 = $17;
9153 $6 = $2 << 2;
9154 $14 = $6 + $5 | 0;
9155 $17 = HEAP32[$0 + $6 >> 2];
9156 $10 = __wasm_i64_mul($11, $11 >> 31, $21, $22);
9157 $6 = i64toi32_i32$HIGH_BITS;
9158 $16 = __wasm_i64_mul($16, $16 >> 31, $20, $19);
9159 $10 = $16 + $10 | 0;
9160 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9161 $6 = $10 >>> 0 < $16 >>> 0 ? $6 + 1 | 0 : $6;
9162 $16 = __wasm_i64_mul($9, $9 >> 31, $24, $25);
9163 $10 = $16 + $10 | 0;
9164 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9165 $6 = $10 >>> 0 < $16 >>> 0 ? $6 + 1 | 0 : $6;
9166 $16 = __wasm_i64_mul($8, $8 >> 31, $28, $23);
9167 $10 = $16 + $10 | 0;
9168 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9169 $6 = $10 >>> 0 < $16 >>> 0 ? $6 + 1 | 0 : $6;
9170 $16 = __wasm_i64_mul($12, $12 >> 31, $26, $27);
9171 $10 = $16 + $10 | 0;
9172 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9173 $6 = $10 >>> 0 < $16 >>> 0 ? $6 + 1 | 0 : $6;
9174 $16 = __wasm_i64_mul($7, $7 >> 31, $29, $30);
9175 $10 = $16 + $10 | 0;
9176 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9177 $6 = $10 >>> 0 < $16 >>> 0 ? $6 + 1 | 0 : $6;
9178 $16 = __wasm_i64_mul($18, $18 >> 31, $32, $33);
9179 $10 = $16 + $10 | 0;
9180 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9181 $6 = $10 >>> 0 < $16 >>> 0 ? $6 + 1 | 0 : $6;
9182 $16 = __wasm_i64_mul($3, $3 >> 31, $36, $31);
9183 $10 = $16 + $10 | 0;
9184 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9185 $6 = $10 >>> 0 < $16 >>> 0 ? $6 + 1 | 0 : $6;
9186 $16 = __wasm_i64_mul($15, $15 >> 31, $34, $35);
9187 $10 = $16 + $10 | 0;
9188 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9189 $6 = $10 >>> 0 < $16 >>> 0 ? $6 + 1 | 0 : $6;
9190 $16 = $6;
9191 $6 = $4;
9192 $13 = $6 & 31;
9193 HEAP32[$14 >> 2] = $17 - (32 <= ($6 & 63) >>> 0 ? $16 >> $13 : ((1 << $13) - 1 & $16) << 32 - $13 | $10 >>> $13);
9194 $16 = $11;
9195 $2 = $2 + 1 | 0;
9196 if (($2 | 0) != ($1 | 0)) {
9197 continue
9198 }
9199 break;
9200 };
9201 break label$1;
9202 }
9203 if (($1 | 0) < 1) {
9204 break label$1
9205 }
9206 $16 = HEAP32[$0 + -4 >> 2];
9207 $15 = HEAP32[$0 + -8 >> 2];
9208 $3 = HEAP32[$0 + -12 >> 2];
9209 $18 = HEAP32[$0 + -16 >> 2];
9210 $7 = HEAP32[$0 + -20 >> 2];
9211 $12 = HEAP32[$0 + -24 >> 2];
9212 $8 = HEAP32[$0 + -28 >> 2];
9213 $9 = HEAP32[$0 + -32 >> 2];
9214 $11 = HEAP32[$0 + -36 >> 2];
9215 $10 = HEAP32[$0 + -40 >> 2];
9216 $6 = HEAP32[$2 >> 2];
9217 $37 = $6;
9218 $38 = $6 >> 31;
9219 $6 = HEAP32[$2 + 4 >> 2];
9220 $39 = $6;
9221 $34 = $6 >> 31;
9222 $6 = HEAP32[$2 + 8 >> 2];
9223 $35 = $6;
9224 $36 = $6 >> 31;
9225 $6 = HEAP32[$2 + 12 >> 2];
9226 $31 = $6;
9227 $32 = $6 >> 31;
9228 $6 = HEAP32[$2 + 16 >> 2];
9229 $33 = $6;
9230 $29 = $6 >> 31;
9231 $6 = HEAP32[$2 + 20 >> 2];
9232 $30 = $6;
9233 $26 = $6 >> 31;
9234 $6 = HEAP32[$2 + 24 >> 2];
9235 $27 = $6;
9236 $28 = $6 >> 31;
9237 $6 = HEAP32[$2 + 28 >> 2];
9238 $23 = $6;
9239 $24 = $6 >> 31;
9240 $6 = HEAP32[$2 + 32 >> 2];
9241 $25 = $6;
9242 $21 = $6 >> 31;
9243 $2 = HEAP32[$2 + 36 >> 2];
9244 $22 = $2;
9245 $20 = $2 >> 31;
9246 $2 = 0;
9247 while (1) {
9248 $17 = $11;
9249 $11 = $9;
9250 $9 = $8;
9251 $8 = $12;
9252 $12 = $7;
9253 $7 = $18;
9254 $18 = $3;
9255 $3 = $15;
9256 $15 = $16;
9257 $6 = $2 << 2;
9258 $19 = $6 + $5 | 0;
9259 $16 = HEAP32[$0 + $6 >> 2];
9260 $13 = __wasm_i64_mul($17, $17 >> 31, $25, $21);
9261 $6 = i64toi32_i32$HIGH_BITS;
9262 $10 = __wasm_i64_mul($10, $10 >> 31, $22, $20);
9263 $13 = $10 + $13 | 0;
9264 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9265 $6 = $13 >>> 0 < $10 >>> 0 ? $6 + 1 | 0 : $6;
9266 $10 = __wasm_i64_mul($11, $11 >> 31, $23, $24);
9267 $13 = $10 + $13 | 0;
9268 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9269 $6 = $13 >>> 0 < $10 >>> 0 ? $6 + 1 | 0 : $6;
9270 $10 = __wasm_i64_mul($9, $9 >> 31, $27, $28);
9271 $13 = $10 + $13 | 0;
9272 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9273 $6 = $13 >>> 0 < $10 >>> 0 ? $6 + 1 | 0 : $6;
9274 $10 = __wasm_i64_mul($8, $8 >> 31, $30, $26);
9275 $13 = $10 + $13 | 0;
9276 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9277 $6 = $13 >>> 0 < $10 >>> 0 ? $6 + 1 | 0 : $6;
9278 $10 = __wasm_i64_mul($12, $12 >> 31, $33, $29);
9279 $13 = $10 + $13 | 0;
9280 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9281 $6 = $13 >>> 0 < $10 >>> 0 ? $6 + 1 | 0 : $6;
9282 $10 = __wasm_i64_mul($7, $7 >> 31, $31, $32);
9283 $13 = $10 + $13 | 0;
9284 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9285 $6 = $13 >>> 0 < $10 >>> 0 ? $6 + 1 | 0 : $6;
9286 $10 = __wasm_i64_mul($18, $18 >> 31, $35, $36);
9287 $13 = $10 + $13 | 0;
9288 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9289 $6 = $13 >>> 0 < $10 >>> 0 ? $6 + 1 | 0 : $6;
9290 $10 = __wasm_i64_mul($3, $3 >> 31, $39, $34);
9291 $13 = $10 + $13 | 0;
9292 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9293 $6 = $13 >>> 0 < $10 >>> 0 ? $6 + 1 | 0 : $6;
9294 $10 = __wasm_i64_mul($15, $15 >> 31, $37, $38);
9295 $13 = $10 + $13 | 0;
9296 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9297 $6 = $13 >>> 0 < $10 >>> 0 ? $6 + 1 | 0 : $6;
9298 $10 = $6;
9299 $6 = $4;
9300 $14 = $6 & 31;
9301 HEAP32[$19 >> 2] = $16 - (32 <= ($6 & 63) >>> 0 ? $10 >> $14 : ((1 << $14) - 1 & $10) << 32 - $14 | $13 >>> $14);
9302 $10 = $17;
9303 $2 = $2 + 1 | 0;
9304 if (($2 | 0) != ($1 | 0)) {
9305 continue
9306 }
9307 break;
9308 };
9309 break label$1;
9310 }
9311 if ($3 >>> 0 >= 5) {
9312 if ($3 >>> 0 >= 7) {
9313 if (($3 | 0) != 8) {
9314 if (($1 | 0) < 1) {
9315 break label$1
9316 }
9317 $9 = HEAP32[$0 + -4 >> 2];
9318 $15 = HEAP32[$0 + -8 >> 2];
9319 $3 = HEAP32[$0 + -12 >> 2];
9320 $18 = HEAP32[$0 + -16 >> 2];
9321 $7 = HEAP32[$0 + -20 >> 2];
9322 $12 = HEAP32[$0 + -24 >> 2];
9323 $11 = HEAP32[$0 + -28 >> 2];
9324 $8 = HEAP32[$2 >> 2];
9325 $29 = $8;
9326 $30 = $8 >> 31;
9327 $8 = HEAP32[$2 + 4 >> 2];
9328 $26 = $8;
9329 $27 = $8 >> 31;
9330 $8 = HEAP32[$2 + 8 >> 2];
9331 $28 = $8;
9332 $23 = $8 >> 31;
9333 $8 = HEAP32[$2 + 12 >> 2];
9334 $24 = $8;
9335 $25 = $8 >> 31;
9336 $8 = HEAP32[$2 + 16 >> 2];
9337 $21 = $8;
9338 $22 = $8 >> 31;
9339 $8 = HEAP32[$2 + 20 >> 2];
9340 $20 = $8;
9341 $19 = $8 >> 31;
9342 $2 = HEAP32[$2 + 24 >> 2];
9343 $14 = $2;
9344 $13 = $2 >> 31;
9345 $2 = 0;
9346 while (1) {
9347 $8 = $12;
9348 $12 = $7;
9349 $7 = $18;
9350 $18 = $3;
9351 $3 = $15;
9352 $15 = $9;
9353 $9 = $2 << 2;
9354 $10 = $9 + $5 | 0;
9355 $9 = HEAP32[$0 + $9 >> 2];
9356 $17 = __wasm_i64_mul($8, $8 >> 31, $20, $19);
9357 $6 = i64toi32_i32$HIGH_BITS;
9358 $11 = __wasm_i64_mul($11, $11 >> 31, $14, $13);
9359 $17 = $11 + $17 | 0;
9360 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9361 $6 = $17 >>> 0 < $11 >>> 0 ? $6 + 1 | 0 : $6;
9362 $11 = __wasm_i64_mul($12, $12 >> 31, $21, $22);
9363 $17 = $11 + $17 | 0;
9364 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9365 $6 = $17 >>> 0 < $11 >>> 0 ? $6 + 1 | 0 : $6;
9366 $11 = __wasm_i64_mul($7, $7 >> 31, $24, $25);
9367 $17 = $11 + $17 | 0;
9368 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9369 $6 = $17 >>> 0 < $11 >>> 0 ? $6 + 1 | 0 : $6;
9370 $11 = __wasm_i64_mul($18, $18 >> 31, $28, $23);
9371 $17 = $11 + $17 | 0;
9372 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9373 $6 = $17 >>> 0 < $11 >>> 0 ? $6 + 1 | 0 : $6;
9374 $11 = __wasm_i64_mul($3, $3 >> 31, $26, $27);
9375 $17 = $11 + $17 | 0;
9376 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9377 $6 = $17 >>> 0 < $11 >>> 0 ? $6 + 1 | 0 : $6;
9378 $11 = __wasm_i64_mul($15, $15 >> 31, $29, $30);
9379 $17 = $11 + $17 | 0;
9380 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9381 $6 = $17 >>> 0 < $11 >>> 0 ? $6 + 1 | 0 : $6;
9382 $16 = $4 & 31;
9383 HEAP32[$10 >> 2] = $9 - (32 <= ($4 & 63) >>> 0 ? $6 >> $16 : ((1 << $16) - 1 & $6) << 32 - $16 | $17 >>> $16);
9384 $11 = $8;
9385 $2 = $2 + 1 | 0;
9386 if (($2 | 0) != ($1 | 0)) {
9387 continue
9388 }
9389 break;
9390 };
9391 break label$1;
9392 }
9393 if (($1 | 0) < 1) {
9394 break label$1
9395 }
9396 $11 = HEAP32[$0 + -4 >> 2];
9397 $15 = HEAP32[$0 + -8 >> 2];
9398 $3 = HEAP32[$0 + -12 >> 2];
9399 $18 = HEAP32[$0 + -16 >> 2];
9400 $7 = HEAP32[$0 + -20 >> 2];
9401 $12 = HEAP32[$0 + -24 >> 2];
9402 $8 = HEAP32[$0 + -28 >> 2];
9403 $17 = HEAP32[$0 + -32 >> 2];
9404 $9 = HEAP32[$2 >> 2];
9405 $31 = $9;
9406 $32 = $9 >> 31;
9407 $9 = HEAP32[$2 + 4 >> 2];
9408 $33 = $9;
9409 $29 = $9 >> 31;
9410 $9 = HEAP32[$2 + 8 >> 2];
9411 $30 = $9;
9412 $26 = $9 >> 31;
9413 $9 = HEAP32[$2 + 12 >> 2];
9414 $27 = $9;
9415 $28 = $9 >> 31;
9416 $9 = HEAP32[$2 + 16 >> 2];
9417 $23 = $9;
9418 $24 = $9 >> 31;
9419 $9 = HEAP32[$2 + 20 >> 2];
9420 $25 = $9;
9421 $21 = $9 >> 31;
9422 $9 = HEAP32[$2 + 24 >> 2];
9423 $22 = $9;
9424 $20 = $9 >> 31;
9425 $2 = HEAP32[$2 + 28 >> 2];
9426 $19 = $2;
9427 $14 = $2 >> 31;
9428 $2 = 0;
9429 while (1) {
9430 $9 = $8;
9431 $8 = $12;
9432 $12 = $7;
9433 $7 = $18;
9434 $18 = $3;
9435 $3 = $15;
9436 $15 = $11;
9437 $11 = $2 << 2;
9438 $13 = $11 + $5 | 0;
9439 $11 = HEAP32[$0 + $11 >> 2];
9440 $16 = __wasm_i64_mul($9, $9 >> 31, $22, $20);
9441 $6 = i64toi32_i32$HIGH_BITS;
9442 $17 = __wasm_i64_mul($17, $17 >> 31, $19, $14);
9443 $16 = $17 + $16 | 0;
9444 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9445 $6 = $16 >>> 0 < $17 >>> 0 ? $6 + 1 | 0 : $6;
9446 $17 = __wasm_i64_mul($8, $8 >> 31, $25, $21);
9447 $16 = $17 + $16 | 0;
9448 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9449 $6 = $16 >>> 0 < $17 >>> 0 ? $6 + 1 | 0 : $6;
9450 $17 = __wasm_i64_mul($12, $12 >> 31, $23, $24);
9451 $16 = $17 + $16 | 0;
9452 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9453 $6 = $16 >>> 0 < $17 >>> 0 ? $6 + 1 | 0 : $6;
9454 $17 = __wasm_i64_mul($7, $7 >> 31, $27, $28);
9455 $16 = $17 + $16 | 0;
9456 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9457 $6 = $16 >>> 0 < $17 >>> 0 ? $6 + 1 | 0 : $6;
9458 $17 = __wasm_i64_mul($18, $18 >> 31, $30, $26);
9459 $16 = $17 + $16 | 0;
9460 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9461 $6 = $16 >>> 0 < $17 >>> 0 ? $6 + 1 | 0 : $6;
9462 $17 = __wasm_i64_mul($3, $3 >> 31, $33, $29);
9463 $16 = $17 + $16 | 0;
9464 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9465 $6 = $16 >>> 0 < $17 >>> 0 ? $6 + 1 | 0 : $6;
9466 $17 = __wasm_i64_mul($15, $15 >> 31, $31, $32);
9467 $16 = $17 + $16 | 0;
9468 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9469 $6 = $16 >>> 0 < $17 >>> 0 ? $6 + 1 | 0 : $6;
9470 $17 = $6;
9471 $6 = $4;
9472 $10 = $6 & 31;
9473 HEAP32[$13 >> 2] = $11 - (32 <= ($6 & 63) >>> 0 ? $17 >> $10 : ((1 << $10) - 1 & $17) << 32 - $10 | $16 >>> $10);
9474 $17 = $9;
9475 $2 = $2 + 1 | 0;
9476 if (($2 | 0) != ($1 | 0)) {
9477 continue
9478 }
9479 break;
9480 };
9481 break label$1;
9482 }
9483 if (($3 | 0) != 6) {
9484 if (($1 | 0) < 1) {
9485 break label$1
9486 }
9487 $12 = HEAP32[$0 + -4 >> 2];
9488 $15 = HEAP32[$0 + -8 >> 2];
9489 $3 = HEAP32[$0 + -12 >> 2];
9490 $18 = HEAP32[$0 + -16 >> 2];
9491 $8 = HEAP32[$0 + -20 >> 2];
9492 $7 = HEAP32[$2 >> 2];
9493 $23 = $7;
9494 $24 = $7 >> 31;
9495 $7 = HEAP32[$2 + 4 >> 2];
9496 $25 = $7;
9497 $21 = $7 >> 31;
9498 $7 = HEAP32[$2 + 8 >> 2];
9499 $22 = $7;
9500 $20 = $7 >> 31;
9501 $7 = HEAP32[$2 + 12 >> 2];
9502 $19 = $7;
9503 $14 = $7 >> 31;
9504 $2 = HEAP32[$2 + 16 >> 2];
9505 $13 = $2;
9506 $10 = $2 >> 31;
9507 $2 = 0;
9508 while (1) {
9509 $7 = $18;
9510 $18 = $3;
9511 $3 = $15;
9512 $15 = $12;
9513 $12 = $2 << 2;
9514 $16 = $12 + $5 | 0;
9515 $12 = HEAP32[$0 + $12 >> 2];
9516 $11 = __wasm_i64_mul($7, $7 >> 31, $19, $14);
9517 $9 = i64toi32_i32$HIGH_BITS;
9518 $8 = __wasm_i64_mul($8, $8 >> 31, $13, $10);
9519 $11 = $8 + $11 | 0;
9520 $6 = i64toi32_i32$HIGH_BITS + $9 | 0;
9521 $6 = $11 >>> 0 < $8 >>> 0 ? $6 + 1 | 0 : $6;
9522 $8 = __wasm_i64_mul($18, $18 >> 31, $22, $20);
9523 $9 = $8 + $11 | 0;
9524 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9525 $6 = $9 >>> 0 < $8 >>> 0 ? $6 + 1 | 0 : $6;
9526 $8 = __wasm_i64_mul($3, $3 >> 31, $25, $21);
9527 $9 = $8 + $9 | 0;
9528 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9529 $6 = $9 >>> 0 < $8 >>> 0 ? $6 + 1 | 0 : $6;
9530 $8 = __wasm_i64_mul($15, $15 >> 31, $23, $24);
9531 $9 = $8 + $9 | 0;
9532 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9533 $6 = $9 >>> 0 < $8 >>> 0 ? $6 + 1 | 0 : $6;
9534 $11 = $4 & 31;
9535 HEAP32[$16 >> 2] = $12 - (32 <= ($4 & 63) >>> 0 ? $6 >> $11 : ((1 << $11) - 1 & $6) << 32 - $11 | $9 >>> $11);
9536 $8 = $7;
9537 $2 = $2 + 1 | 0;
9538 if (($2 | 0) != ($1 | 0)) {
9539 continue
9540 }
9541 break;
9542 };
9543 break label$1;
9544 }
9545 if (($1 | 0) < 1) {
9546 break label$1
9547 }
9548 $8 = HEAP32[$0 + -4 >> 2];
9549 $15 = HEAP32[$0 + -8 >> 2];
9550 $3 = HEAP32[$0 + -12 >> 2];
9551 $18 = HEAP32[$0 + -16 >> 2];
9552 $7 = HEAP32[$0 + -20 >> 2];
9553 $9 = HEAP32[$0 + -24 >> 2];
9554 $12 = HEAP32[$2 >> 2];
9555 $27 = $12;
9556 $28 = $12 >> 31;
9557 $12 = HEAP32[$2 + 4 >> 2];
9558 $23 = $12;
9559 $24 = $12 >> 31;
9560 $12 = HEAP32[$2 + 8 >> 2];
9561 $25 = $12;
9562 $21 = $12 >> 31;
9563 $12 = HEAP32[$2 + 12 >> 2];
9564 $22 = $12;
9565 $20 = $12 >> 31;
9566 $12 = HEAP32[$2 + 16 >> 2];
9567 $19 = $12;
9568 $14 = $12 >> 31;
9569 $2 = HEAP32[$2 + 20 >> 2];
9570 $13 = $2;
9571 $10 = $2 >> 31;
9572 $2 = 0;
9573 while (1) {
9574 $12 = $7;
9575 $7 = $18;
9576 $18 = $3;
9577 $3 = $15;
9578 $15 = $8;
9579 $8 = $2 << 2;
9580 $16 = $8 + $5 | 0;
9581 $8 = HEAP32[$0 + $8 >> 2];
9582 $6 = __wasm_i64_mul($12, $12 >> 31, $19, $14);
9583 $11 = i64toi32_i32$HIGH_BITS;
9584 $9 = __wasm_i64_mul($9, $9 >> 31, $13, $10);
9585 $26 = $9 + $6 | 0;
9586 $6 = i64toi32_i32$HIGH_BITS + $11 | 0;
9587 $6 = $26 >>> 0 < $9 >>> 0 ? $6 + 1 | 0 : $6;
9588 $9 = __wasm_i64_mul($7, $7 >> 31, $22, $20);
9589 $11 = $9 + $26 | 0;
9590 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9591 $6 = $11 >>> 0 < $9 >>> 0 ? $6 + 1 | 0 : $6;
9592 $9 = __wasm_i64_mul($18, $18 >> 31, $25, $21);
9593 $11 = $9 + $11 | 0;
9594 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9595 $6 = $11 >>> 0 < $9 >>> 0 ? $6 + 1 | 0 : $6;
9596 $9 = __wasm_i64_mul($3, $3 >> 31, $23, $24);
9597 $11 = $9 + $11 | 0;
9598 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9599 $6 = $11 >>> 0 < $9 >>> 0 ? $6 + 1 | 0 : $6;
9600 $9 = __wasm_i64_mul($15, $15 >> 31, $27, $28);
9601 $11 = $9 + $11 | 0;
9602 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9603 $6 = $11 >>> 0 < $9 >>> 0 ? $6 + 1 | 0 : $6;
9604 $17 = $4 & 31;
9605 HEAP32[$16 >> 2] = $8 - (32 <= ($4 & 63) >>> 0 ? $6 >> $17 : ((1 << $17) - 1 & $6) << 32 - $17 | $11 >>> $17);
9606 $9 = $12;
9607 $2 = $2 + 1 | 0;
9608 if (($2 | 0) != ($1 | 0)) {
9609 continue
9610 }
9611 break;
9612 };
9613 break label$1;
9614 }
9615 if ($3 >>> 0 >= 3) {
9616 if (($3 | 0) != 4) {
9617 if (($1 | 0) < 1) {
9618 break label$1
9619 }
9620 $18 = HEAP32[$0 + -4 >> 2];
9621 $15 = HEAP32[$0 + -8 >> 2];
9622 $7 = HEAP32[$0 + -12 >> 2];
9623 $3 = HEAP32[$2 >> 2];
9624 $19 = $3;
9625 $14 = $3 >> 31;
9626 $3 = HEAP32[$2 + 4 >> 2];
9627 $13 = $3;
9628 $10 = $3 >> 31;
9629 $2 = HEAP32[$2 + 8 >> 2];
9630 $16 = $2;
9631 $17 = $2 >> 31;
9632 $2 = 0;
9633 while (1) {
9634 $3 = $15;
9635 $15 = $18;
9636 $18 = $2 << 2;
9637 $11 = $18 + $5 | 0;
9638 $18 = HEAP32[$0 + $18 >> 2];
9639 $9 = $18;
9640 $8 = __wasm_i64_mul($3, $3 >> 31, $13, $10);
9641 $12 = i64toi32_i32$HIGH_BITS;
9642 $7 = __wasm_i64_mul($7, $7 >> 31, $16, $17);
9643 $8 = $7 + $8 | 0;
9644 $6 = i64toi32_i32$HIGH_BITS + $12 | 0;
9645 $6 = $8 >>> 0 < $7 >>> 0 ? $6 + 1 | 0 : $6;
9646 $7 = __wasm_i64_mul($15, $15 >> 31, $19, $14);
9647 $12 = $7 + $8 | 0;
9648 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9649 $6 = $12 >>> 0 < $7 >>> 0 ? $6 + 1 | 0 : $6;
9650 $7 = $4;
9651 $8 = $7 & 31;
9652 HEAP32[$11 >> 2] = $9 - (32 <= ($7 & 63) >>> 0 ? $6 >> $8 : ((1 << $8) - 1 & $6) << 32 - $8 | $12 >>> $8);
9653 $7 = $3;
9654 $2 = $2 + 1 | 0;
9655 if (($2 | 0) != ($1 | 0)) {
9656 continue
9657 }
9658 break;
9659 };
9660 break label$1;
9661 }
9662 if (($1 | 0) < 1) {
9663 break label$1
9664 }
9665 $7 = HEAP32[$0 + -4 >> 2];
9666 $15 = HEAP32[$0 + -8 >> 2];
9667 $3 = HEAP32[$0 + -12 >> 2];
9668 $12 = HEAP32[$0 + -16 >> 2];
9669 $18 = HEAP32[$2 >> 2];
9670 $21 = $18;
9671 $22 = $18 >> 31;
9672 $18 = HEAP32[$2 + 4 >> 2];
9673 $20 = $18;
9674 $19 = $18 >> 31;
9675 $18 = HEAP32[$2 + 8 >> 2];
9676 $14 = $18;
9677 $13 = $14 >> 31;
9678 $2 = HEAP32[$2 + 12 >> 2];
9679 $10 = $2;
9680 $16 = $2 >> 31;
9681 $2 = 0;
9682 while (1) {
9683 $18 = $3;
9684 $3 = $15;
9685 $15 = $7;
9686 $7 = $2 << 2;
9687 $17 = $7 + $5 | 0;
9688 $7 = HEAP32[$0 + $7 >> 2];
9689 $9 = __wasm_i64_mul($18, $18 >> 31, $14, $13);
9690 $8 = i64toi32_i32$HIGH_BITS;
9691 $12 = __wasm_i64_mul($12, $12 >> 31, $10, $16);
9692 $9 = $12 + $9 | 0;
9693 $6 = i64toi32_i32$HIGH_BITS + $8 | 0;
9694 $6 = $9 >>> 0 < $12 >>> 0 ? $6 + 1 | 0 : $6;
9695 $12 = __wasm_i64_mul($3, $3 >> 31, $20, $19);
9696 $8 = $12 + $9 | 0;
9697 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9698 $6 = $8 >>> 0 < $12 >>> 0 ? $6 + 1 | 0 : $6;
9699 $12 = __wasm_i64_mul($15, $15 >> 31, $21, $22);
9700 $8 = $12 + $8 | 0;
9701 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
9702 $6 = $8 >>> 0 < $12 >>> 0 ? $6 + 1 | 0 : $6;
9703 $9 = $4 & 31;
9704 HEAP32[$17 >> 2] = $7 - (32 <= ($4 & 63) >>> 0 ? $6 >> $9 : ((1 << $9) - 1 & $6) << 32 - $9 | $8 >>> $9);
9705 $12 = $18;
9706 $2 = $2 + 1 | 0;
9707 if (($2 | 0) != ($1 | 0)) {
9708 continue
9709 }
9710 break;
9711 };
9712 break label$1;
9713 }
9714 if (($3 | 0) != 2) {
9715 if (($1 | 0) < 1) {
9716 break label$1
9717 }
9718 $15 = HEAP32[$0 + -4 >> 2];
9719 $2 = HEAP32[$2 >> 2];
9720 $9 = $2;
9721 $8 = $2 >> 31;
9722 $2 = 0;
9723 while (1) {
9724 $3 = $2 << 2;
9725 $6 = $3 + $5 | 0;
9726 $18 = HEAP32[$0 + $3 >> 2];
9727 $15 = __wasm_i64_mul($15, $15 >> 31, $9, $8);
9728 $7 = i64toi32_i32$HIGH_BITS;
9729 $3 = $4;
9730 $12 = $3 & 31;
9731 HEAP32[$6 >> 2] = $18 - (32 <= ($3 & 63) >>> 0 ? $7 >> $12 : ((1 << $12) - 1 & $7) << 32 - $12 | $15 >>> $12);
9732 $15 = $18;
9733 $2 = $2 + 1 | 0;
9734 if (($2 | 0) != ($1 | 0)) {
9735 continue
9736 }
9737 break;
9738 };
9739 break label$1;
9740 }
9741 if (($1 | 0) < 1) {
9742 break label$1
9743 }
9744 $3 = HEAP32[$0 + -4 >> 2];
9745 $18 = HEAP32[$0 + -8 >> 2];
9746 $15 = HEAP32[$2 >> 2];
9747 $10 = $15;
9748 $16 = $10 >> 31;
9749 $2 = HEAP32[$2 + 4 >> 2];
9750 $17 = $2;
9751 $11 = $2 >> 31;
9752 $2 = 0;
9753 while (1) {
9754 $15 = $3;
9755 $3 = $2 << 2;
9756 $9 = $3 + $5 | 0;
9757 $3 = HEAP32[$0 + $3 >> 2];
9758 $12 = __wasm_i64_mul($15, $15 >> 31, $10, $16);
9759 $7 = i64toi32_i32$HIGH_BITS;
9760 $18 = __wasm_i64_mul($18, $18 >> 31, $17, $11);
9761 $12 = $18 + $12 | 0;
9762 $6 = i64toi32_i32$HIGH_BITS + $7 | 0;
9763 $6 = $12 >>> 0 < $18 >>> 0 ? $6 + 1 | 0 : $6;
9764 $7 = $12;
9765 $12 = $4 & 31;
9766 HEAP32[$9 >> 2] = $3 - (32 <= ($4 & 63) >>> 0 ? $6 >> $12 : ((1 << $12) - 1 & $6) << 32 - $12 | $7 >>> $12);
9767 $18 = $15;
9768 $2 = $2 + 1 | 0;
9769 if (($2 | 0) != ($1 | 0)) {
9770 continue
9771 }
9772 break;
9773 };
9774 }
9775 }
9776
9777 function FLAC__lpc_restore_signal($0, $1, $2, $3, $4, $5) {
9778 $0 = $0 | 0;
9779 $1 = $1 | 0;
9780 $2 = $2 | 0;
9781 $3 = $3 | 0;
9782 $4 = $4 | 0;
9783 $5 = $5 | 0;
9784 var $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0, $23 = 0, $24 = 0, $25 = 0, $26 = 0, $27 = 0, $28 = 0, $29 = 0, $30 = 0;
9785 label$1 : {
9786 if ($3 >>> 0 >= 13) {
9787 if (($1 | 0) < 1) {
9788 break label$1
9789 }
9790 $17 = $3 + -13 | 0;
9791 while (1) {
9792 $25 = 0;
9793 $26 = 0;
9794 $23 = 0;
9795 $24 = 0;
9796 $21 = 0;
9797 $22 = 0;
9798 $19 = 0;
9799 $20 = 0;
9800 $18 = 0;
9801 $15 = 0;
9802 $12 = 0;
9803 $10 = 0;
9804 $14 = 0;
9805 $9 = 0;
9806 $13 = 0;
9807 $7 = 0;
9808 $16 = 0;
9809 $11 = 0;
9810 $8 = 0;
9811 $3 = 0;
9812 label$4 : {
9813 switch ($17 | 0) {
9814 case 19:
9815 $25 = Math_imul(HEAP32[(($6 << 2) + $5 | 0) + -128 >> 2], HEAP32[$2 + 124 >> 2]);
9816 case 18:
9817 $26 = Math_imul(HEAP32[(($6 << 2) + $5 | 0) + -124 >> 2], HEAP32[$2 + 120 >> 2]) + $25 | 0;
9818 case 17:
9819 $23 = Math_imul(HEAP32[(($6 << 2) + $5 | 0) + -120 >> 2], HEAP32[$2 + 116 >> 2]) + $26 | 0;
9820 case 16:
9821 $24 = Math_imul(HEAP32[(($6 << 2) + $5 | 0) + -116 >> 2], HEAP32[$2 + 112 >> 2]) + $23 | 0;
9822 case 15:
9823 $21 = Math_imul(HEAP32[(($6 << 2) + $5 | 0) + -112 >> 2], HEAP32[$2 + 108 >> 2]) + $24 | 0;
9824 case 14:
9825 $22 = Math_imul(HEAP32[(($6 << 2) + $5 | 0) + -108 >> 2], HEAP32[$2 + 104 >> 2]) + $21 | 0;
9826 case 13:
9827 $19 = Math_imul(HEAP32[(($6 << 2) + $5 | 0) + -104 >> 2], HEAP32[$2 + 100 >> 2]) + $22 | 0;
9828 case 12:
9829 $20 = Math_imul(HEAP32[(($6 << 2) + $5 | 0) + -100 >> 2], HEAP32[$2 + 96 >> 2]) + $19 | 0;
9830 case 11:
9831 $18 = Math_imul(HEAP32[(($6 << 2) + $5 | 0) + -96 >> 2], HEAP32[$2 + 92 >> 2]) + $20 | 0;
9832 case 10:
9833 $15 = Math_imul(HEAP32[(($6 << 2) + $5 | 0) + -92 >> 2], HEAP32[$2 + 88 >> 2]) + $18 | 0;
9834 case 9:
9835 $12 = Math_imul(HEAP32[(($6 << 2) + $5 | 0) + -88 >> 2], HEAP32[$2 + 84 >> 2]) + $15 | 0;
9836 case 8:
9837 $10 = Math_imul(HEAP32[(($6 << 2) + $5 | 0) + -84 >> 2], HEAP32[$2 + 80 >> 2]) + $12 | 0;
9838 case 7:
9839 $14 = Math_imul(HEAP32[(($6 << 2) + $5 | 0) + -80 >> 2], HEAP32[$2 + 76 >> 2]) + $10 | 0;
9840 case 6:
9841 $9 = Math_imul(HEAP32[(($6 << 2) + $5 | 0) + -76 >> 2], HEAP32[$2 + 72 >> 2]) + $14 | 0;
9842 case 5:
9843 $13 = Math_imul(HEAP32[(($6 << 2) + $5 | 0) + -72 >> 2], HEAP32[$2 + 68 >> 2]) + $9 | 0;
9844 case 4:
9845 $7 = Math_imul(HEAP32[(($6 << 2) + $5 | 0) + -68 >> 2], HEAP32[$2 + 64 >> 2]) + $13 | 0;
9846 case 3:
9847 $16 = Math_imul(HEAP32[(($6 << 2) + $5 | 0) + -64 >> 2], HEAP32[$2 + 60 >> 2]) + $7 | 0;
9848 case 2:
9849 $11 = Math_imul(HEAP32[(($6 << 2) + $5 | 0) + -60 >> 2], HEAP32[$2 + 56 >> 2]) + $16 | 0;
9850 case 1:
9851 $8 = Math_imul(HEAP32[(($6 << 2) + $5 | 0) + -56 >> 2], HEAP32[$2 + 52 >> 2]) + $11 | 0;
9852 case 0:
9853 $3 = ($6 << 2) + $5 | 0;
9854 $3 = ((((((((((((Math_imul(HEAP32[$3 + -52 >> 2], HEAP32[$2 + 48 >> 2]) + $8 | 0) + Math_imul(HEAP32[$3 + -48 >> 2], HEAP32[$2 + 44 >> 2]) | 0) + Math_imul(HEAP32[$3 + -44 >> 2], HEAP32[$2 + 40 >> 2]) | 0) + Math_imul(HEAP32[$3 + -40 >> 2], HEAP32[$2 + 36 >> 2]) | 0) + Math_imul(HEAP32[$3 + -36 >> 2], HEAP32[$2 + 32 >> 2]) | 0) + Math_imul(HEAP32[$3 + -32 >> 2], HEAP32[$2 + 28 >> 2]) | 0) + Math_imul(HEAP32[$3 + -28 >> 2], HEAP32[$2 + 24 >> 2]) | 0) + Math_imul(HEAP32[$3 + -24 >> 2], HEAP32[$2 + 20 >> 2]) | 0) + Math_imul(HEAP32[$3 + -20 >> 2], HEAP32[$2 + 16 >> 2]) | 0) + Math_imul(HEAP32[$3 + -16 >> 2], HEAP32[$2 + 12 >> 2]) | 0) + Math_imul(HEAP32[$3 + -12 >> 2], HEAP32[$2 + 8 >> 2]) | 0) + Math_imul(HEAP32[$3 + -8 >> 2], HEAP32[$2 + 4 >> 2]) | 0) + Math_imul(HEAP32[$3 + -4 >> 2], HEAP32[$2 >> 2]) | 0;
9855 break;
9856 default:
9857 break label$4;
9858 };
9859 }
9860 $8 = $6 << 2;
9861 HEAP32[$8 + $5 >> 2] = HEAP32[$0 + $8 >> 2] + ($3 >> $4);
9862 $6 = $6 + 1 | 0;
9863 if (($6 | 0) != ($1 | 0)) {
9864 continue
9865 }
9866 break;
9867 };
9868 break label$1;
9869 }
9870 if ($3 >>> 0 >= 9) {
9871 if ($3 >>> 0 >= 11) {
9872 if (($3 | 0) != 12) {
9873 if (($1 | 0) < 1) {
9874 break label$1
9875 }
9876 $6 = HEAP32[$5 + -4 >> 2];
9877 $3 = HEAP32[$5 + -8 >> 2];
9878 $8 = HEAP32[$5 + -12 >> 2];
9879 $11 = HEAP32[$5 + -16 >> 2];
9880 $16 = HEAP32[$5 + -20 >> 2];
9881 $7 = HEAP32[$5 + -24 >> 2];
9882 $13 = HEAP32[$5 + -28 >> 2];
9883 $9 = HEAP32[$5 + -32 >> 2];
9884 $14 = HEAP32[$5 + -36 >> 2];
9885 $10 = HEAP32[$5 + -40 >> 2];
9886 $12 = HEAP32[$5 + -44 >> 2];
9887 $27 = HEAP32[$2 >> 2];
9888 $28 = HEAP32[$2 + 4 >> 2];
9889 $25 = HEAP32[$2 + 8 >> 2];
9890 $26 = HEAP32[$2 + 12 >> 2];
9891 $23 = HEAP32[$2 + 16 >> 2];
9892 $24 = HEAP32[$2 + 20 >> 2];
9893 $21 = HEAP32[$2 + 24 >> 2];
9894 $22 = HEAP32[$2 + 28 >> 2];
9895 $19 = HEAP32[$2 + 32 >> 2];
9896 $20 = HEAP32[$2 + 36 >> 2];
9897 $18 = HEAP32[$2 + 40 >> 2];
9898 $2 = 0;
9899 while (1) {
9900 $17 = $10;
9901 $12 = Math_imul($10, $20) + Math_imul($12, $18) | 0;
9902 $10 = $14;
9903 $12 = $12 + Math_imul($19, $10) | 0;
9904 $14 = $9;
9905 $12 = Math_imul($9, $22) + $12 | 0;
9906 $9 = $13;
9907 $12 = $12 + Math_imul($21, $9) | 0;
9908 $13 = $7;
9909 $12 = Math_imul($7, $24) + $12 | 0;
9910 $7 = $16;
9911 $12 = $12 + Math_imul($23, $7) | 0;
9912 $16 = $11;
9913 $12 = Math_imul($11, $26) + $12 | 0;
9914 $11 = $8;
9915 $15 = Math_imul($8, $25) + $12 | 0;
9916 $8 = $3;
9917 $12 = $2 << 2;
9918 $15 = Math_imul($3, $28) + $15 | 0;
9919 $3 = $6;
9920 $6 = HEAP32[$12 + $0 >> 2] + ($15 + Math_imul($27, $3) >> $4) | 0;
9921 HEAP32[$5 + $12 >> 2] = $6;
9922 $12 = $17;
9923 $2 = $2 + 1 | 0;
9924 if (($2 | 0) != ($1 | 0)) {
9925 continue
9926 }
9927 break;
9928 };
9929 break label$1;
9930 }
9931 if (($1 | 0) < 1) {
9932 break label$1
9933 }
9934 $6 = HEAP32[$5 + -4 >> 2];
9935 $3 = HEAP32[$5 + -8 >> 2];
9936 $8 = HEAP32[$5 + -12 >> 2];
9937 $11 = HEAP32[$5 + -16 >> 2];
9938 $16 = HEAP32[$5 + -20 >> 2];
9939 $7 = HEAP32[$5 + -24 >> 2];
9940 $13 = HEAP32[$5 + -28 >> 2];
9941 $9 = HEAP32[$5 + -32 >> 2];
9942 $14 = HEAP32[$5 + -36 >> 2];
9943 $10 = HEAP32[$5 + -40 >> 2];
9944 $12 = HEAP32[$5 + -44 >> 2];
9945 $15 = HEAP32[$5 + -48 >> 2];
9946 $29 = HEAP32[$2 >> 2];
9947 $30 = HEAP32[$2 + 4 >> 2];
9948 $27 = HEAP32[$2 + 8 >> 2];
9949 $28 = HEAP32[$2 + 12 >> 2];
9950 $25 = HEAP32[$2 + 16 >> 2];
9951 $26 = HEAP32[$2 + 20 >> 2];
9952 $23 = HEAP32[$2 + 24 >> 2];
9953 $24 = HEAP32[$2 + 28 >> 2];
9954 $21 = HEAP32[$2 + 32 >> 2];
9955 $22 = HEAP32[$2 + 36 >> 2];
9956 $19 = HEAP32[$2 + 40 >> 2];
9957 $20 = HEAP32[$2 + 44 >> 2];
9958 $2 = 0;
9959 while (1) {
9960 $17 = $12;
9961 $15 = Math_imul($12, $19) + Math_imul($15, $20) | 0;
9962 $12 = $10;
9963 $15 = Math_imul($10, $22) + $15 | 0;
9964 $10 = $14;
9965 $15 = $15 + Math_imul($21, $10) | 0;
9966 $14 = $9;
9967 $15 = Math_imul($9, $24) + $15 | 0;
9968 $9 = $13;
9969 $15 = $15 + Math_imul($23, $9) | 0;
9970 $13 = $7;
9971 $15 = Math_imul($7, $26) + $15 | 0;
9972 $7 = $16;
9973 $15 = $15 + Math_imul($25, $7) | 0;
9974 $16 = $11;
9975 $15 = Math_imul($11, $28) + $15 | 0;
9976 $11 = $8;
9977 $18 = Math_imul($8, $27) + $15 | 0;
9978 $8 = $3;
9979 $15 = $2 << 2;
9980 $18 = Math_imul($3, $30) + $18 | 0;
9981 $3 = $6;
9982 $6 = HEAP32[$15 + $0 >> 2] + ($18 + Math_imul($29, $3) >> $4) | 0;
9983 HEAP32[$5 + $15 >> 2] = $6;
9984 $15 = $17;
9985 $2 = $2 + 1 | 0;
9986 if (($2 | 0) != ($1 | 0)) {
9987 continue
9988 }
9989 break;
9990 };
9991 break label$1;
9992 }
9993 if (($3 | 0) != 10) {
9994 if (($1 | 0) < 1) {
9995 break label$1
9996 }
9997 $6 = HEAP32[$5 + -4 >> 2];
9998 $3 = HEAP32[$5 + -8 >> 2];
9999 $8 = HEAP32[$5 + -12 >> 2];
10000 $11 = HEAP32[$5 + -16 >> 2];
10001 $16 = HEAP32[$5 + -20 >> 2];
10002 $7 = HEAP32[$5 + -24 >> 2];
10003 $13 = HEAP32[$5 + -28 >> 2];
10004 $9 = HEAP32[$5 + -32 >> 2];
10005 $14 = HEAP32[$5 + -36 >> 2];
10006 $23 = HEAP32[$2 >> 2];
10007 $24 = HEAP32[$2 + 4 >> 2];
10008 $21 = HEAP32[$2 + 8 >> 2];
10009 $22 = HEAP32[$2 + 12 >> 2];
10010 $19 = HEAP32[$2 + 16 >> 2];
10011 $20 = HEAP32[$2 + 20 >> 2];
10012 $18 = HEAP32[$2 + 24 >> 2];
10013 $15 = HEAP32[$2 + 28 >> 2];
10014 $17 = HEAP32[$2 + 32 >> 2];
10015 $2 = 0;
10016 while (1) {
10017 $10 = $9;
10018 $14 = Math_imul($9, $15) + Math_imul($14, $17) | 0;
10019 $9 = $13;
10020 $14 = $14 + Math_imul($18, $9) | 0;
10021 $13 = $7;
10022 $14 = Math_imul($7, $20) + $14 | 0;
10023 $7 = $16;
10024 $14 = $14 + Math_imul($19, $7) | 0;
10025 $16 = $11;
10026 $14 = Math_imul($11, $22) + $14 | 0;
10027 $11 = $8;
10028 $12 = Math_imul($8, $21) + $14 | 0;
10029 $8 = $3;
10030 $14 = $2 << 2;
10031 $12 = Math_imul($3, $24) + $12 | 0;
10032 $3 = $6;
10033 $6 = HEAP32[$14 + $0 >> 2] + ($12 + Math_imul($23, $3) >> $4) | 0;
10034 HEAP32[$5 + $14 >> 2] = $6;
10035 $14 = $10;
10036 $2 = $2 + 1 | 0;
10037 if (($2 | 0) != ($1 | 0)) {
10038 continue
10039 }
10040 break;
10041 };
10042 break label$1;
10043 }
10044 if (($1 | 0) < 1) {
10045 break label$1
10046 }
10047 $6 = HEAP32[$5 + -4 >> 2];
10048 $3 = HEAP32[$5 + -8 >> 2];
10049 $8 = HEAP32[$5 + -12 >> 2];
10050 $11 = HEAP32[$5 + -16 >> 2];
10051 $16 = HEAP32[$5 + -20 >> 2];
10052 $7 = HEAP32[$5 + -24 >> 2];
10053 $13 = HEAP32[$5 + -28 >> 2];
10054 $9 = HEAP32[$5 + -32 >> 2];
10055 $14 = HEAP32[$5 + -36 >> 2];
10056 $10 = HEAP32[$5 + -40 >> 2];
10057 $25 = HEAP32[$2 >> 2];
10058 $26 = HEAP32[$2 + 4 >> 2];
10059 $23 = HEAP32[$2 + 8 >> 2];
10060 $24 = HEAP32[$2 + 12 >> 2];
10061 $21 = HEAP32[$2 + 16 >> 2];
10062 $22 = HEAP32[$2 + 20 >> 2];
10063 $19 = HEAP32[$2 + 24 >> 2];
10064 $20 = HEAP32[$2 + 28 >> 2];
10065 $18 = HEAP32[$2 + 32 >> 2];
10066 $15 = HEAP32[$2 + 36 >> 2];
10067 $2 = 0;
10068 while (1) {
10069 $12 = $14;
10070 $10 = Math_imul($18, $12) + Math_imul($10, $15) | 0;
10071 $14 = $9;
10072 $10 = Math_imul($9, $20) + $10 | 0;
10073 $9 = $13;
10074 $10 = $10 + Math_imul($19, $9) | 0;
10075 $13 = $7;
10076 $10 = Math_imul($7, $22) + $10 | 0;
10077 $7 = $16;
10078 $10 = $10 + Math_imul($21, $7) | 0;
10079 $16 = $11;
10080 $10 = Math_imul($11, $24) + $10 | 0;
10081 $11 = $8;
10082 $17 = Math_imul($8, $23) + $10 | 0;
10083 $8 = $3;
10084 $10 = $2 << 2;
10085 $17 = Math_imul($3, $26) + $17 | 0;
10086 $3 = $6;
10087 $6 = HEAP32[$10 + $0 >> 2] + ($17 + Math_imul($25, $3) >> $4) | 0;
10088 HEAP32[$5 + $10 >> 2] = $6;
10089 $10 = $12;
10090 $2 = $2 + 1 | 0;
10091 if (($2 | 0) != ($1 | 0)) {
10092 continue
10093 }
10094 break;
10095 };
10096 break label$1;
10097 }
10098 if ($3 >>> 0 >= 5) {
10099 if ($3 >>> 0 >= 7) {
10100 if (($3 | 0) != 8) {
10101 if (($1 | 0) < 1) {
10102 break label$1
10103 }
10104 $6 = HEAP32[$5 + -4 >> 2];
10105 $3 = HEAP32[$5 + -8 >> 2];
10106 $8 = HEAP32[$5 + -12 >> 2];
10107 $11 = HEAP32[$5 + -16 >> 2];
10108 $16 = HEAP32[$5 + -20 >> 2];
10109 $7 = HEAP32[$5 + -24 >> 2];
10110 $13 = HEAP32[$5 + -28 >> 2];
10111 $19 = HEAP32[$2 >> 2];
10112 $20 = HEAP32[$2 + 4 >> 2];
10113 $18 = HEAP32[$2 + 8 >> 2];
10114 $15 = HEAP32[$2 + 12 >> 2];
10115 $17 = HEAP32[$2 + 16 >> 2];
10116 $12 = HEAP32[$2 + 20 >> 2];
10117 $10 = HEAP32[$2 + 24 >> 2];
10118 $2 = 0;
10119 while (1) {
10120 $9 = $7;
10121 $13 = Math_imul($7, $12) + Math_imul($10, $13) | 0;
10122 $7 = $16;
10123 $13 = $13 + Math_imul($17, $7) | 0;
10124 $16 = $11;
10125 $13 = Math_imul($11, $15) + $13 | 0;
10126 $11 = $8;
10127 $14 = Math_imul($8, $18) + $13 | 0;
10128 $8 = $3;
10129 $13 = $2 << 2;
10130 $14 = Math_imul($3, $20) + $14 | 0;
10131 $3 = $6;
10132 $6 = HEAP32[$13 + $0 >> 2] + ($14 + Math_imul($19, $3) >> $4) | 0;
10133 HEAP32[$5 + $13 >> 2] = $6;
10134 $13 = $9;
10135 $2 = $2 + 1 | 0;
10136 if (($2 | 0) != ($1 | 0)) {
10137 continue
10138 }
10139 break;
10140 };
10141 break label$1;
10142 }
10143 if (($1 | 0) < 1) {
10144 break label$1
10145 }
10146 $6 = HEAP32[$5 + -4 >> 2];
10147 $3 = HEAP32[$5 + -8 >> 2];
10148 $8 = HEAP32[$5 + -12 >> 2];
10149 $11 = HEAP32[$5 + -16 >> 2];
10150 $16 = HEAP32[$5 + -20 >> 2];
10151 $7 = HEAP32[$5 + -24 >> 2];
10152 $13 = HEAP32[$5 + -28 >> 2];
10153 $9 = HEAP32[$5 + -32 >> 2];
10154 $21 = HEAP32[$2 >> 2];
10155 $22 = HEAP32[$2 + 4 >> 2];
10156 $19 = HEAP32[$2 + 8 >> 2];
10157 $20 = HEAP32[$2 + 12 >> 2];
10158 $18 = HEAP32[$2 + 16 >> 2];
10159 $15 = HEAP32[$2 + 20 >> 2];
10160 $17 = HEAP32[$2 + 24 >> 2];
10161 $12 = HEAP32[$2 + 28 >> 2];
10162 $2 = 0;
10163 while (1) {
10164 $14 = $13;
10165 $9 = Math_imul($17, $13) + Math_imul($9, $12) | 0;
10166 $13 = $7;
10167 $9 = Math_imul($7, $15) + $9 | 0;
10168 $7 = $16;
10169 $9 = $9 + Math_imul($18, $7) | 0;
10170 $16 = $11;
10171 $9 = Math_imul($11, $20) + $9 | 0;
10172 $11 = $8;
10173 $10 = Math_imul($8, $19) + $9 | 0;
10174 $8 = $3;
10175 $9 = $2 << 2;
10176 $10 = Math_imul($3, $22) + $10 | 0;
10177 $3 = $6;
10178 $6 = HEAP32[$9 + $0 >> 2] + ($10 + Math_imul($21, $3) >> $4) | 0;
10179 HEAP32[$5 + $9 >> 2] = $6;
10180 $9 = $14;
10181 $2 = $2 + 1 | 0;
10182 if (($2 | 0) != ($1 | 0)) {
10183 continue
10184 }
10185 break;
10186 };
10187 break label$1;
10188 }
10189 if (($3 | 0) != 6) {
10190 if (($1 | 0) < 1) {
10191 break label$1
10192 }
10193 $6 = HEAP32[$5 + -4 >> 2];
10194 $3 = HEAP32[$5 + -8 >> 2];
10195 $8 = HEAP32[$5 + -12 >> 2];
10196 $11 = HEAP32[$5 + -16 >> 2];
10197 $16 = HEAP32[$5 + -20 >> 2];
10198 $17 = HEAP32[$2 >> 2];
10199 $12 = HEAP32[$2 + 4 >> 2];
10200 $10 = HEAP32[$2 + 8 >> 2];
10201 $14 = HEAP32[$2 + 12 >> 2];
10202 $9 = HEAP32[$2 + 16 >> 2];
10203 $2 = 0;
10204 while (1) {
10205 $7 = $11;
10206 $16 = Math_imul($14, $7) + Math_imul($9, $16) | 0;
10207 $11 = $8;
10208 $13 = Math_imul($8, $10) + $16 | 0;
10209 $8 = $3;
10210 $16 = $2 << 2;
10211 $13 = Math_imul($3, $12) + $13 | 0;
10212 $3 = $6;
10213 $6 = HEAP32[$16 + $0 >> 2] + ($13 + Math_imul($17, $3) >> $4) | 0;
10214 HEAP32[$5 + $16 >> 2] = $6;
10215 $16 = $7;
10216 $2 = $2 + 1 | 0;
10217 if (($2 | 0) != ($1 | 0)) {
10218 continue
10219 }
10220 break;
10221 };
10222 break label$1;
10223 }
10224 if (($1 | 0) < 1) {
10225 break label$1
10226 }
10227 $6 = HEAP32[$5 + -4 >> 2];
10228 $3 = HEAP32[$5 + -8 >> 2];
10229 $8 = HEAP32[$5 + -12 >> 2];
10230 $11 = HEAP32[$5 + -16 >> 2];
10231 $16 = HEAP32[$5 + -20 >> 2];
10232 $7 = HEAP32[$5 + -24 >> 2];
10233 $18 = HEAP32[$2 >> 2];
10234 $15 = HEAP32[$2 + 4 >> 2];
10235 $17 = HEAP32[$2 + 8 >> 2];
10236 $12 = HEAP32[$2 + 12 >> 2];
10237 $10 = HEAP32[$2 + 16 >> 2];
10238 $14 = HEAP32[$2 + 20 >> 2];
10239 $2 = 0;
10240 while (1) {
10241 $13 = $16;
10242 $7 = Math_imul($10, $13) + Math_imul($7, $14) | 0;
10243 $16 = $11;
10244 $7 = Math_imul($11, $12) + $7 | 0;
10245 $11 = $8;
10246 $9 = Math_imul($8, $17) + $7 | 0;
10247 $8 = $3;
10248 $7 = $2 << 2;
10249 $9 = Math_imul($3, $15) + $9 | 0;
10250 $3 = $6;
10251 $6 = HEAP32[$7 + $0 >> 2] + ($9 + Math_imul($18, $3) >> $4) | 0;
10252 HEAP32[$5 + $7 >> 2] = $6;
10253 $7 = $13;
10254 $2 = $2 + 1 | 0;
10255 if (($2 | 0) != ($1 | 0)) {
10256 continue
10257 }
10258 break;
10259 };
10260 break label$1;
10261 }
10262 if ($3 >>> 0 >= 3) {
10263 if (($3 | 0) != 4) {
10264 if (($1 | 0) < 1) {
10265 break label$1
10266 }
10267 $6 = HEAP32[$5 + -4 >> 2];
10268 $3 = HEAP32[$5 + -8 >> 2];
10269 $8 = HEAP32[$5 + -12 >> 2];
10270 $9 = HEAP32[$2 >> 2];
10271 $13 = HEAP32[$2 + 4 >> 2];
10272 $7 = HEAP32[$2 + 8 >> 2];
10273 $2 = 0;
10274 while (1) {
10275 $11 = $3;
10276 $16 = $2 << 2;
10277 $8 = Math_imul($3, $13) + Math_imul($8, $7) | 0;
10278 $3 = $6;
10279 $6 = HEAP32[$16 + $0 >> 2] + ($8 + Math_imul($9, $3) >> $4) | 0;
10280 HEAP32[$5 + $16 >> 2] = $6;
10281 $8 = $11;
10282 $2 = $2 + 1 | 0;
10283 if (($2 | 0) != ($1 | 0)) {
10284 continue
10285 }
10286 break;
10287 };
10288 break label$1;
10289 }
10290 if (($1 | 0) < 1) {
10291 break label$1
10292 }
10293 $6 = HEAP32[$5 + -4 >> 2];
10294 $3 = HEAP32[$5 + -8 >> 2];
10295 $8 = HEAP32[$5 + -12 >> 2];
10296 $11 = HEAP32[$5 + -16 >> 2];
10297 $10 = HEAP32[$2 >> 2];
10298 $14 = HEAP32[$2 + 4 >> 2];
10299 $9 = HEAP32[$2 + 8 >> 2];
10300 $13 = HEAP32[$2 + 12 >> 2];
10301 $2 = 0;
10302 while (1) {
10303 $16 = $8;
10304 $7 = Math_imul($8, $9) + Math_imul($11, $13) | 0;
10305 $8 = $3;
10306 $11 = $2 << 2;
10307 $7 = Math_imul($3, $14) + $7 | 0;
10308 $3 = $6;
10309 $6 = HEAP32[$11 + $0 >> 2] + ($7 + Math_imul($10, $3) >> $4) | 0;
10310 HEAP32[$5 + $11 >> 2] = $6;
10311 $11 = $16;
10312 $2 = $2 + 1 | 0;
10313 if (($2 | 0) != ($1 | 0)) {
10314 continue
10315 }
10316 break;
10317 };
10318 break label$1;
10319 }
10320 if (($3 | 0) != 2) {
10321 if (($1 | 0) < 1) {
10322 break label$1
10323 }
10324 $6 = HEAP32[$5 + -4 >> 2];
10325 $8 = HEAP32[$2 >> 2];
10326 $2 = 0;
10327 while (1) {
10328 $3 = $2 << 2;
10329 $6 = HEAP32[$3 + $0 >> 2] + (Math_imul($6, $8) >> $4) | 0;
10330 HEAP32[$3 + $5 >> 2] = $6;
10331 $2 = $2 + 1 | 0;
10332 if (($2 | 0) != ($1 | 0)) {
10333 continue
10334 }
10335 break;
10336 };
10337 break label$1;
10338 }
10339 if (($1 | 0) < 1) {
10340 break label$1
10341 }
10342 $6 = HEAP32[$5 + -4 >> 2];
10343 $3 = HEAP32[$5 + -8 >> 2];
10344 $7 = HEAP32[$2 >> 2];
10345 $16 = HEAP32[$2 + 4 >> 2];
10346 $2 = 0;
10347 while (1) {
10348 $8 = $6;
10349 $11 = $2 << 2;
10350 $6 = HEAP32[$11 + $0 >> 2] + (Math_imul($6, $7) + Math_imul($3, $16) >> $4) | 0;
10351 HEAP32[$5 + $11 >> 2] = $6;
10352 $3 = $8;
10353 $2 = $2 + 1 | 0;
10354 if (($2 | 0) != ($1 | 0)) {
10355 continue
10356 }
10357 break;
10358 };
10359 }
10360 }
10361
10362 function FLAC__lpc_restore_signal_wide($0, $1, $2, $3, $4, $5) {
10363 $0 = $0 | 0;
10364 $1 = $1 | 0;
10365 $2 = $2 | 0;
10366 $3 = $3 | 0;
10367 $4 = $4 | 0;
10368 $5 = $5 | 0;
10369 var $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0, $23 = 0, $24 = 0, $25 = 0, $26 = 0, $27 = 0, $28 = 0, $29 = 0, $30 = 0, $31 = 0, $32 = 0, $33 = 0, $34 = 0, $35 = 0, $36 = 0, $37 = 0, $38 = 0, $39 = 0, $40 = 0, $41 = 0, $42 = 0, $43 = 0, $44 = 0, $45 = 0, $46 = 0;
10370 label$1 : {
10371 if ($3 >>> 0 >= 13) {
10372 if (($1 | 0) < 1) {
10373 break label$1
10374 }
10375 $13 = $4;
10376 $12 = $3 + -13 | 0;
10377 while (1) {
10378 $4 = 0;
10379 $3 = 0;
10380 label$4 : {
10381 switch ($12 | 0) {
10382 case 19:
10383 $3 = HEAP32[(($9 << 2) + $5 | 0) + -128 >> 2];
10384 $4 = $3;
10385 $7 = $3 >> 31;
10386 $3 = HEAP32[$2 + 124 >> 2];
10387 $4 = __wasm_i64_mul($4, $7, $3, $3 >> 31);
10388 $3 = i64toi32_i32$HIGH_BITS;
10389 case 18:
10390 $7 = HEAP32[(($9 << 2) + $5 | 0) + -124 >> 2];
10391 $6 = $7;
10392 $8 = $7 >> 31;
10393 $7 = HEAP32[$2 + 120 >> 2];
10394 $7 = __wasm_i64_mul($6, $8, $7, $7 >> 31) + $4 | 0;
10395 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
10396 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
10397 $4 = $7;
10398 $3 = $6;
10399 case 17:
10400 $7 = HEAP32[(($9 << 2) + $5 | 0) + -120 >> 2];
10401 $6 = $7;
10402 $8 = $7 >> 31;
10403 $7 = HEAP32[$2 + 116 >> 2];
10404 $7 = __wasm_i64_mul($6, $8, $7, $7 >> 31) + $4 | 0;
10405 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
10406 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
10407 $4 = $7;
10408 $3 = $6;
10409 case 16:
10410 $7 = HEAP32[(($9 << 2) + $5 | 0) + -116 >> 2];
10411 $6 = $7;
10412 $8 = $7 >> 31;
10413 $7 = HEAP32[$2 + 112 >> 2];
10414 $7 = __wasm_i64_mul($6, $8, $7, $7 >> 31) + $4 | 0;
10415 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
10416 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
10417 $4 = $7;
10418 $3 = $6;
10419 case 15:
10420 $7 = HEAP32[(($9 << 2) + $5 | 0) + -112 >> 2];
10421 $6 = $7;
10422 $8 = $7 >> 31;
10423 $7 = HEAP32[$2 + 108 >> 2];
10424 $7 = __wasm_i64_mul($6, $8, $7, $7 >> 31) + $4 | 0;
10425 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
10426 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
10427 $4 = $7;
10428 $3 = $6;
10429 case 14:
10430 $7 = HEAP32[(($9 << 2) + $5 | 0) + -108 >> 2];
10431 $6 = $7;
10432 $8 = $7 >> 31;
10433 $7 = HEAP32[$2 + 104 >> 2];
10434 $7 = __wasm_i64_mul($6, $8, $7, $7 >> 31) + $4 | 0;
10435 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
10436 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
10437 $4 = $7;
10438 $3 = $6;
10439 case 13:
10440 $7 = HEAP32[(($9 << 2) + $5 | 0) + -104 >> 2];
10441 $6 = $7;
10442 $8 = $7 >> 31;
10443 $7 = HEAP32[$2 + 100 >> 2];
10444 $7 = __wasm_i64_mul($6, $8, $7, $7 >> 31) + $4 | 0;
10445 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
10446 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
10447 $4 = $7;
10448 $3 = $6;
10449 case 12:
10450 $7 = HEAP32[(($9 << 2) + $5 | 0) + -100 >> 2];
10451 $6 = $7;
10452 $8 = $7 >> 31;
10453 $7 = HEAP32[$2 + 96 >> 2];
10454 $7 = __wasm_i64_mul($6, $8, $7, $7 >> 31) + $4 | 0;
10455 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
10456 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
10457 $4 = $7;
10458 $3 = $6;
10459 case 11:
10460 $7 = HEAP32[(($9 << 2) + $5 | 0) + -96 >> 2];
10461 $6 = $7;
10462 $8 = $7 >> 31;
10463 $7 = HEAP32[$2 + 92 >> 2];
10464 $7 = __wasm_i64_mul($6, $8, $7, $7 >> 31) + $4 | 0;
10465 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
10466 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
10467 $4 = $7;
10468 $3 = $6;
10469 case 10:
10470 $7 = HEAP32[(($9 << 2) + $5 | 0) + -92 >> 2];
10471 $6 = $7;
10472 $8 = $7 >> 31;
10473 $7 = HEAP32[$2 + 88 >> 2];
10474 $7 = __wasm_i64_mul($6, $8, $7, $7 >> 31) + $4 | 0;
10475 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
10476 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
10477 $4 = $7;
10478 $3 = $6;
10479 case 9:
10480 $7 = HEAP32[(($9 << 2) + $5 | 0) + -88 >> 2];
10481 $6 = $7;
10482 $8 = $7 >> 31;
10483 $7 = HEAP32[$2 + 84 >> 2];
10484 $7 = __wasm_i64_mul($6, $8, $7, $7 >> 31) + $4 | 0;
10485 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
10486 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
10487 $4 = $7;
10488 $3 = $6;
10489 case 8:
10490 $7 = HEAP32[(($9 << 2) + $5 | 0) + -84 >> 2];
10491 $6 = $7;
10492 $8 = $7 >> 31;
10493 $7 = HEAP32[$2 + 80 >> 2];
10494 $7 = __wasm_i64_mul($6, $8, $7, $7 >> 31) + $4 | 0;
10495 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
10496 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
10497 $4 = $7;
10498 $3 = $6;
10499 case 7:
10500 $7 = HEAP32[(($9 << 2) + $5 | 0) + -80 >> 2];
10501 $6 = $7;
10502 $8 = $7 >> 31;
10503 $7 = HEAP32[$2 + 76 >> 2];
10504 $7 = __wasm_i64_mul($6, $8, $7, $7 >> 31) + $4 | 0;
10505 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
10506 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
10507 $4 = $7;
10508 $3 = $6;
10509 case 6:
10510 $7 = HEAP32[(($9 << 2) + $5 | 0) + -76 >> 2];
10511 $6 = $7;
10512 $8 = $7 >> 31;
10513 $7 = HEAP32[$2 + 72 >> 2];
10514 $7 = __wasm_i64_mul($6, $8, $7, $7 >> 31) + $4 | 0;
10515 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
10516 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
10517 $4 = $7;
10518 $3 = $6;
10519 case 5:
10520 $7 = HEAP32[(($9 << 2) + $5 | 0) + -72 >> 2];
10521 $6 = $7;
10522 $8 = $7 >> 31;
10523 $7 = HEAP32[$2 + 68 >> 2];
10524 $7 = __wasm_i64_mul($6, $8, $7, $7 >> 31) + $4 | 0;
10525 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
10526 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
10527 $4 = $7;
10528 $3 = $6;
10529 case 4:
10530 $7 = HEAP32[(($9 << 2) + $5 | 0) + -68 >> 2];
10531 $6 = $7;
10532 $8 = $7 >> 31;
10533 $7 = HEAP32[$2 + 64 >> 2];
10534 $7 = __wasm_i64_mul($6, $8, $7, $7 >> 31) + $4 | 0;
10535 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
10536 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
10537 $4 = $7;
10538 $3 = $6;
10539 case 3:
10540 $7 = HEAP32[(($9 << 2) + $5 | 0) + -64 >> 2];
10541 $6 = $7;
10542 $8 = $7 >> 31;
10543 $7 = HEAP32[$2 + 60 >> 2];
10544 $7 = __wasm_i64_mul($6, $8, $7, $7 >> 31) + $4 | 0;
10545 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
10546 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
10547 $4 = $7;
10548 $3 = $6;
10549 case 2:
10550 $7 = HEAP32[(($9 << 2) + $5 | 0) + -60 >> 2];
10551 $6 = $7;
10552 $8 = $7 >> 31;
10553 $7 = HEAP32[$2 + 56 >> 2];
10554 $7 = __wasm_i64_mul($6, $8, $7, $7 >> 31) + $4 | 0;
10555 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
10556 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
10557 $4 = $7;
10558 $3 = $6;
10559 case 1:
10560 $7 = HEAP32[(($9 << 2) + $5 | 0) + -56 >> 2];
10561 $6 = $7;
10562 $8 = $7 >> 31;
10563 $7 = HEAP32[$2 + 52 >> 2];
10564 $7 = __wasm_i64_mul($6, $8, $7, $7 >> 31) + $4 | 0;
10565 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
10566 $6 = $7 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
10567 $4 = $7;
10568 $3 = $6;
10569 case 0:
10570 $7 = ($9 << 2) + $5 | 0;
10571 $8 = HEAP32[$7 + -52 >> 2];
10572 $6 = $8;
10573 $10 = $8 >> 31;
10574 $8 = HEAP32[$2 + 48 >> 2];
10575 $8 = __wasm_i64_mul($6, $10, $8, $8 >> 31) + $4 | 0;
10576 $6 = $3 + i64toi32_i32$HIGH_BITS | 0;
10577 $6 = $8 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
10578 $3 = HEAP32[$7 + -48 >> 2];
10579 $4 = $3;
10580 $10 = $3 >> 31;
10581 $3 = HEAP32[$2 + 44 >> 2];
10582 $4 = __wasm_i64_mul($4, $10, $3, $3 >> 31);
10583 $3 = $4 + $8 | 0;
10584 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
10585 $6 = $3 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
10586 $8 = $3;
10587 $3 = HEAP32[$7 + -44 >> 2];
10588 $4 = $3;
10589 $10 = $3 >> 31;
10590 $3 = HEAP32[$2 + 40 >> 2];
10591 $4 = __wasm_i64_mul($4, $10, $3, $3 >> 31);
10592 $3 = $8 + $4 | 0;
10593 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
10594 $6 = $3 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
10595 $8 = $3;
10596 $3 = HEAP32[$7 + -40 >> 2];
10597 $4 = $3;
10598 $10 = $3 >> 31;
10599 $3 = HEAP32[$2 + 36 >> 2];
10600 $4 = __wasm_i64_mul($4, $10, $3, $3 >> 31);
10601 $3 = $8 + $4 | 0;
10602 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
10603 $6 = $3 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
10604 $8 = $3;
10605 $3 = HEAP32[$7 + -36 >> 2];
10606 $4 = $3;
10607 $10 = $3 >> 31;
10608 $3 = HEAP32[$2 + 32 >> 2];
10609 $4 = __wasm_i64_mul($4, $10, $3, $3 >> 31);
10610 $3 = $8 + $4 | 0;
10611 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
10612 $6 = $3 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
10613 $8 = $3;
10614 $3 = HEAP32[$7 + -32 >> 2];
10615 $4 = $3;
10616 $10 = $3 >> 31;
10617 $3 = HEAP32[$2 + 28 >> 2];
10618 $4 = __wasm_i64_mul($4, $10, $3, $3 >> 31);
10619 $3 = $8 + $4 | 0;
10620 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
10621 $6 = $3 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
10622 $8 = $3;
10623 $3 = HEAP32[$7 + -28 >> 2];
10624 $4 = $3;
10625 $10 = $3 >> 31;
10626 $3 = HEAP32[$2 + 24 >> 2];
10627 $4 = __wasm_i64_mul($4, $10, $3, $3 >> 31);
10628 $3 = $8 + $4 | 0;
10629 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
10630 $6 = $3 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
10631 $8 = $3;
10632 $3 = HEAP32[$7 + -24 >> 2];
10633 $4 = $3;
10634 $10 = $3 >> 31;
10635 $3 = HEAP32[$2 + 20 >> 2];
10636 $4 = __wasm_i64_mul($4, $10, $3, $3 >> 31);
10637 $3 = $8 + $4 | 0;
10638 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
10639 $6 = $3 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
10640 $8 = $3;
10641 $3 = HEAP32[$7 + -20 >> 2];
10642 $4 = $3;
10643 $10 = $3 >> 31;
10644 $3 = HEAP32[$2 + 16 >> 2];
10645 $4 = __wasm_i64_mul($4, $10, $3, $3 >> 31);
10646 $3 = $8 + $4 | 0;
10647 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
10648 $6 = $3 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
10649 $8 = $3;
10650 $3 = HEAP32[$7 + -16 >> 2];
10651 $4 = $3;
10652 $10 = $3 >> 31;
10653 $3 = HEAP32[$2 + 12 >> 2];
10654 $4 = __wasm_i64_mul($4, $10, $3, $3 >> 31);
10655 $3 = $8 + $4 | 0;
10656 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
10657 $6 = $3 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
10658 $8 = $3;
10659 $3 = HEAP32[$7 + -12 >> 2];
10660 $4 = $3;
10661 $10 = $3 >> 31;
10662 $3 = HEAP32[$2 + 8 >> 2];
10663 $4 = __wasm_i64_mul($4, $10, $3, $3 >> 31);
10664 $3 = $8 + $4 | 0;
10665 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
10666 $6 = $3 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
10667 $8 = $3;
10668 $3 = HEAP32[$7 + -8 >> 2];
10669 $4 = $3;
10670 $10 = $3 >> 31;
10671 $3 = HEAP32[$2 + 4 >> 2];
10672 $4 = __wasm_i64_mul($4, $10, $3, $3 >> 31);
10673 $3 = $8 + $4 | 0;
10674 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
10675 $6 = $3 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
10676 $8 = $3;
10677 $3 = HEAP32[$7 + -4 >> 2];
10678 $4 = $3;
10679 $7 = $3 >> 31;
10680 $3 = HEAP32[$2 >> 2];
10681 $4 = __wasm_i64_mul($4, $7, $3, $3 >> 31);
10682 $3 = $8 + $4 | 0;
10683 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
10684 $6 = $3 >>> 0 < $4 >>> 0 ? $6 + 1 | 0 : $6;
10685 $4 = $3;
10686 $3 = $6;
10687 break;
10688 default:
10689 break label$4;
10690 };
10691 }
10692 $7 = $9 << 2;
10693 $10 = $7 + $5 | 0;
10694 $6 = HEAP32[$0 + $7 >> 2];
10695 $8 = $4;
10696 $4 = $13;
10697 $7 = $4 & 31;
10698 HEAP32[$10 >> 2] = $6 + (32 <= ($4 & 63) >>> 0 ? $3 >> $7 : ((1 << $7) - 1 & $3) << 32 - $7 | $8 >>> $7);
10699 $9 = $9 + 1 | 0;
10700 if (($9 | 0) != ($1 | 0)) {
10701 continue
10702 }
10703 break;
10704 };
10705 break label$1;
10706 }
10707 if ($3 >>> 0 >= 9) {
10708 if ($3 >>> 0 >= 11) {
10709 if (($3 | 0) != 12) {
10710 if (($1 | 0) < 1) {
10711 break label$1
10712 }
10713 $9 = HEAP32[$5 + -4 >> 2];
10714 $3 = HEAP32[$5 + -8 >> 2];
10715 $13 = HEAP32[$5 + -12 >> 2];
10716 $7 = HEAP32[$5 + -16 >> 2];
10717 $8 = HEAP32[$5 + -20 >> 2];
10718 $12 = HEAP32[$5 + -24 >> 2];
10719 $10 = HEAP32[$5 + -28 >> 2];
10720 $11 = HEAP32[$5 + -32 >> 2];
10721 $14 = HEAP32[$5 + -36 >> 2];
10722 $16 = HEAP32[$5 + -40 >> 2];
10723 $15 = HEAP32[$5 + -44 >> 2];
10724 $6 = HEAP32[$2 >> 2];
10725 $17 = $6;
10726 $25 = $6 >> 31;
10727 $6 = HEAP32[$2 + 4 >> 2];
10728 $26 = $6;
10729 $27 = $6 >> 31;
10730 $6 = HEAP32[$2 + 8 >> 2];
10731 $24 = $6;
10732 $29 = $6 >> 31;
10733 $6 = HEAP32[$2 + 12 >> 2];
10734 $30 = $6;
10735 $22 = $6 >> 31;
10736 $6 = HEAP32[$2 + 16 >> 2];
10737 $31 = $6;
10738 $32 = $6 >> 31;
10739 $6 = HEAP32[$2 + 20 >> 2];
10740 $28 = $6;
10741 $34 = $6 >> 31;
10742 $6 = HEAP32[$2 + 24 >> 2];
10743 $35 = $6;
10744 $21 = $6 >> 31;
10745 $6 = HEAP32[$2 + 28 >> 2];
10746 $36 = $6;
10747 $37 = $6 >> 31;
10748 $6 = HEAP32[$2 + 32 >> 2];
10749 $33 = $6;
10750 $39 = $6 >> 31;
10751 $6 = HEAP32[$2 + 36 >> 2];
10752 $40 = $6;
10753 $20 = $6 >> 31;
10754 $2 = HEAP32[$2 + 40 >> 2];
10755 $41 = $2;
10756 $42 = $2 >> 31;
10757 $2 = 0;
10758 while (1) {
10759 $6 = $2 << 2;
10760 $38 = $6 + $5 | 0;
10761 $43 = HEAP32[$0 + $6 >> 2];
10762 $18 = $16;
10763 $6 = __wasm_i64_mul($16, $16 >> 31, $40, $20);
10764 $44 = i64toi32_i32$HIGH_BITS;
10765 $16 = $14;
10766 $19 = __wasm_i64_mul($15, $15 >> 31, $41, $42);
10767 $15 = $19 + $6 | 0;
10768 $6 = i64toi32_i32$HIGH_BITS + $44 | 0;
10769 $6 = $15 >>> 0 < $19 >>> 0 ? $6 + 1 | 0 : $6;
10770 $19 = $15;
10771 $15 = __wasm_i64_mul($14, $14 >> 31, $33, $39);
10772 $14 = $19 + $15 | 0;
10773 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
10774 $6 = $14 >>> 0 < $15 >>> 0 ? $6 + 1 | 0 : $6;
10775 $15 = $14;
10776 $14 = $11;
10777 $19 = $15;
10778 $15 = __wasm_i64_mul($11, $11 >> 31, $36, $37);
10779 $11 = $19 + $15 | 0;
10780 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
10781 $6 = $11 >>> 0 < $15 >>> 0 ? $6 + 1 | 0 : $6;
10782 $15 = $11;
10783 $11 = $10;
10784 $10 = $15;
10785 $15 = __wasm_i64_mul($11, $11 >> 31, $35, $21);
10786 $10 = $10 + $15 | 0;
10787 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
10788 $6 = $10 >>> 0 < $15 >>> 0 ? $6 + 1 | 0 : $6;
10789 $15 = $10;
10790 $10 = $12;
10791 $19 = $15;
10792 $15 = __wasm_i64_mul($12, $12 >> 31, $28, $34);
10793 $12 = $19 + $15 | 0;
10794 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
10795 $6 = $12 >>> 0 < $15 >>> 0 ? $6 + 1 | 0 : $6;
10796 $15 = $12;
10797 $12 = $8;
10798 $19 = $15;
10799 $15 = __wasm_i64_mul($8, $8 >> 31, $31, $32);
10800 $8 = $19 + $15 | 0;
10801 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
10802 $6 = $8 >>> 0 < $15 >>> 0 ? $6 + 1 | 0 : $6;
10803 $15 = $8;
10804 $8 = $7;
10805 $19 = $15;
10806 $15 = __wasm_i64_mul($7, $7 >> 31, $30, $22);
10807 $7 = $19 + $15 | 0;
10808 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
10809 $6 = $7 >>> 0 < $15 >>> 0 ? $6 + 1 | 0 : $6;
10810 $19 = $7;
10811 $7 = $13;
10812 $15 = __wasm_i64_mul($7, $7 >> 31, $24, $29);
10813 $13 = $19 + $15 | 0;
10814 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
10815 $6 = $13 >>> 0 < $15 >>> 0 ? $6 + 1 | 0 : $6;
10816 $15 = $13;
10817 $13 = $3;
10818 $23 = $38;
10819 $19 = $15;
10820 $15 = __wasm_i64_mul($3, $3 >> 31, $26, $27);
10821 $3 = $19 + $15 | 0;
10822 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
10823 $6 = $3 >>> 0 < $15 >>> 0 ? $6 + 1 | 0 : $6;
10824 $19 = $3;
10825 $3 = $9;
10826 $15 = __wasm_i64_mul($3, $3 >> 31, $17, $25);
10827 $9 = $19 + $15 | 0;
10828 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
10829 $6 = $9 >>> 0 < $15 >>> 0 ? $6 + 1 | 0 : $6;
10830 $38 = $9;
10831 $9 = $4;
10832 $15 = $9 & 31;
10833 $9 = (32 <= ($9 & 63) >>> 0 ? $6 >> $15 : ((1 << $15) - 1 & $6) << 32 - $15 | $38 >>> $15) + $43 | 0;
10834 HEAP32[$23 >> 2] = $9;
10835 $15 = $18;
10836 $2 = $2 + 1 | 0;
10837 if (($2 | 0) != ($1 | 0)) {
10838 continue
10839 }
10840 break;
10841 };
10842 break label$1;
10843 }
10844 if (($1 | 0) < 1) {
10845 break label$1
10846 }
10847 $9 = HEAP32[$5 + -4 >> 2];
10848 $3 = HEAP32[$5 + -8 >> 2];
10849 $13 = HEAP32[$5 + -12 >> 2];
10850 $7 = HEAP32[$5 + -16 >> 2];
10851 $8 = HEAP32[$5 + -20 >> 2];
10852 $12 = HEAP32[$5 + -24 >> 2];
10853 $10 = HEAP32[$5 + -28 >> 2];
10854 $11 = HEAP32[$5 + -32 >> 2];
10855 $14 = HEAP32[$5 + -36 >> 2];
10856 $16 = HEAP32[$5 + -40 >> 2];
10857 $15 = HEAP32[$5 + -44 >> 2];
10858 $6 = HEAP32[$5 + -48 >> 2];
10859 $18 = HEAP32[$2 >> 2];
10860 $25 = $18;
10861 $26 = $18 >> 31;
10862 $18 = HEAP32[$2 + 4 >> 2];
10863 $27 = $18;
10864 $24 = $18 >> 31;
10865 $18 = HEAP32[$2 + 8 >> 2];
10866 $29 = $18;
10867 $30 = $18 >> 31;
10868 $18 = HEAP32[$2 + 12 >> 2];
10869 $22 = $18;
10870 $31 = $18 >> 31;
10871 $18 = HEAP32[$2 + 16 >> 2];
10872 $32 = $18;
10873 $28 = $18 >> 31;
10874 $18 = HEAP32[$2 + 20 >> 2];
10875 $34 = $18;
10876 $35 = $18 >> 31;
10877 $18 = HEAP32[$2 + 24 >> 2];
10878 $21 = $18;
10879 $36 = $18 >> 31;
10880 $18 = HEAP32[$2 + 28 >> 2];
10881 $37 = $18;
10882 $33 = $18 >> 31;
10883 $18 = HEAP32[$2 + 32 >> 2];
10884 $39 = $18;
10885 $40 = $18 >> 31;
10886 $18 = HEAP32[$2 + 36 >> 2];
10887 $20 = $18;
10888 $41 = $18 >> 31;
10889 $18 = HEAP32[$2 + 40 >> 2];
10890 $42 = $18;
10891 $38 = $18 >> 31;
10892 $2 = HEAP32[$2 + 44 >> 2];
10893 $43 = $2;
10894 $44 = $2 >> 31;
10895 $2 = 0;
10896 while (1) {
10897 $18 = $2 << 2;
10898 $19 = $18 + $5 | 0;
10899 $46 = HEAP32[$0 + $18 >> 2];
10900 $18 = $15;
10901 $17 = __wasm_i64_mul($15, $15 >> 31, $42, $38);
10902 $23 = i64toi32_i32$HIGH_BITS;
10903 $15 = $16;
10904 $45 = __wasm_i64_mul($6, $6 >> 31, $43, $44);
10905 $17 = $45 + $17 | 0;
10906 $6 = i64toi32_i32$HIGH_BITS + $23 | 0;
10907 $6 = $17 >>> 0 < $45 >>> 0 ? $6 + 1 | 0 : $6;
10908 $23 = $17;
10909 $17 = __wasm_i64_mul($16, $16 >> 31, $20, $41);
10910 $16 = $23 + $17 | 0;
10911 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
10912 $6 = $16 >>> 0 < $17 >>> 0 ? $6 + 1 | 0 : $6;
10913 $17 = $16;
10914 $16 = $14;
10915 $23 = $17;
10916 $17 = __wasm_i64_mul($14, $14 >> 31, $39, $40);
10917 $14 = $23 + $17 | 0;
10918 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
10919 $6 = $14 >>> 0 < $17 >>> 0 ? $6 + 1 | 0 : $6;
10920 $17 = $14;
10921 $14 = $11;
10922 $23 = $17;
10923 $17 = __wasm_i64_mul($11, $11 >> 31, $37, $33);
10924 $11 = $23 + $17 | 0;
10925 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
10926 $6 = $11 >>> 0 < $17 >>> 0 ? $6 + 1 | 0 : $6;
10927 $17 = $11;
10928 $11 = $10;
10929 $10 = $17;
10930 $17 = __wasm_i64_mul($11, $11 >> 31, $21, $36);
10931 $10 = $10 + $17 | 0;
10932 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
10933 $6 = $10 >>> 0 < $17 >>> 0 ? $6 + 1 | 0 : $6;
10934 $17 = $10;
10935 $10 = $12;
10936 $23 = $17;
10937 $17 = __wasm_i64_mul($12, $12 >> 31, $34, $35);
10938 $12 = $23 + $17 | 0;
10939 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
10940 $6 = $12 >>> 0 < $17 >>> 0 ? $6 + 1 | 0 : $6;
10941 $17 = $12;
10942 $12 = $8;
10943 $23 = $17;
10944 $17 = __wasm_i64_mul($8, $8 >> 31, $32, $28);
10945 $8 = $23 + $17 | 0;
10946 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
10947 $6 = $8 >>> 0 < $17 >>> 0 ? $6 + 1 | 0 : $6;
10948 $17 = $8;
10949 $8 = $7;
10950 $23 = $17;
10951 $17 = __wasm_i64_mul($7, $7 >> 31, $22, $31);
10952 $7 = $23 + $17 | 0;
10953 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
10954 $6 = $7 >>> 0 < $17 >>> 0 ? $6 + 1 | 0 : $6;
10955 $23 = $7;
10956 $7 = $13;
10957 $17 = __wasm_i64_mul($7, $7 >> 31, $29, $30);
10958 $13 = $23 + $17 | 0;
10959 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
10960 $6 = $13 >>> 0 < $17 >>> 0 ? $6 + 1 | 0 : $6;
10961 $17 = $13;
10962 $13 = $3;
10963 $23 = $19;
10964 $19 = $17;
10965 $17 = __wasm_i64_mul($3, $3 >> 31, $27, $24);
10966 $3 = $19 + $17 | 0;
10967 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
10968 $6 = $3 >>> 0 < $17 >>> 0 ? $6 + 1 | 0 : $6;
10969 $19 = $3;
10970 $3 = $9;
10971 $17 = __wasm_i64_mul($3, $3 >> 31, $25, $26);
10972 $9 = $19 + $17 | 0;
10973 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
10974 $6 = $9 >>> 0 < $17 >>> 0 ? $6 + 1 | 0 : $6;
10975 $19 = $9;
10976 $9 = $4;
10977 $17 = $9 & 31;
10978 $9 = (32 <= ($9 & 63) >>> 0 ? $6 >> $17 : ((1 << $17) - 1 & $6) << 32 - $17 | $19 >>> $17) + $46 | 0;
10979 HEAP32[$23 >> 2] = $9;
10980 $6 = $18;
10981 $2 = $2 + 1 | 0;
10982 if (($2 | 0) != ($1 | 0)) {
10983 continue
10984 }
10985 break;
10986 };
10987 break label$1;
10988 }
10989 if (($3 | 0) != 10) {
10990 if (($1 | 0) < 1) {
10991 break label$1
10992 }
10993 $9 = HEAP32[$5 + -4 >> 2];
10994 $3 = HEAP32[$5 + -8 >> 2];
10995 $13 = HEAP32[$5 + -12 >> 2];
10996 $7 = HEAP32[$5 + -16 >> 2];
10997 $8 = HEAP32[$5 + -20 >> 2];
10998 $12 = HEAP32[$5 + -24 >> 2];
10999 $10 = HEAP32[$5 + -28 >> 2];
11000 $11 = HEAP32[$5 + -32 >> 2];
11001 $14 = HEAP32[$5 + -36 >> 2];
11002 $6 = HEAP32[$2 >> 2];
11003 $15 = $6;
11004 $18 = $6 >> 31;
11005 $6 = HEAP32[$2 + 4 >> 2];
11006 $17 = $6;
11007 $25 = $6 >> 31;
11008 $6 = HEAP32[$2 + 8 >> 2];
11009 $26 = $6;
11010 $27 = $6 >> 31;
11011 $6 = HEAP32[$2 + 12 >> 2];
11012 $24 = $6;
11013 $29 = $6 >> 31;
11014 $6 = HEAP32[$2 + 16 >> 2];
11015 $30 = $6;
11016 $22 = $6 >> 31;
11017 $6 = HEAP32[$2 + 20 >> 2];
11018 $31 = $6;
11019 $32 = $6 >> 31;
11020 $6 = HEAP32[$2 + 24 >> 2];
11021 $28 = $6;
11022 $34 = $6 >> 31;
11023 $6 = HEAP32[$2 + 28 >> 2];
11024 $35 = $6;
11025 $21 = $6 >> 31;
11026 $2 = HEAP32[$2 + 32 >> 2];
11027 $36 = $2;
11028 $37 = $2 >> 31;
11029 $2 = 0;
11030 while (1) {
11031 $6 = $2 << 2;
11032 $33 = $6 + $5 | 0;
11033 $39 = HEAP32[$0 + $6 >> 2];
11034 $16 = $11;
11035 $6 = __wasm_i64_mul($11, $11 >> 31, $35, $21);
11036 $40 = i64toi32_i32$HIGH_BITS;
11037 $11 = $10;
11038 $20 = __wasm_i64_mul($14, $14 >> 31, $36, $37);
11039 $14 = $20 + $6 | 0;
11040 $6 = i64toi32_i32$HIGH_BITS + $40 | 0;
11041 $6 = $14 >>> 0 < $20 >>> 0 ? $6 + 1 | 0 : $6;
11042 $10 = $14;
11043 $14 = __wasm_i64_mul($11, $11 >> 31, $28, $34);
11044 $10 = $10 + $14 | 0;
11045 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11046 $6 = $10 >>> 0 < $14 >>> 0 ? $6 + 1 | 0 : $6;
11047 $14 = $10;
11048 $10 = $12;
11049 $20 = $14;
11050 $14 = __wasm_i64_mul($12, $12 >> 31, $31, $32);
11051 $12 = $20 + $14 | 0;
11052 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11053 $6 = $12 >>> 0 < $14 >>> 0 ? $6 + 1 | 0 : $6;
11054 $14 = $12;
11055 $12 = $8;
11056 $20 = $14;
11057 $14 = __wasm_i64_mul($8, $8 >> 31, $30, $22);
11058 $8 = $20 + $14 | 0;
11059 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11060 $6 = $8 >>> 0 < $14 >>> 0 ? $6 + 1 | 0 : $6;
11061 $14 = $8;
11062 $8 = $7;
11063 $20 = $14;
11064 $14 = __wasm_i64_mul($7, $7 >> 31, $24, $29);
11065 $7 = $20 + $14 | 0;
11066 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11067 $6 = $7 >>> 0 < $14 >>> 0 ? $6 + 1 | 0 : $6;
11068 $20 = $7;
11069 $7 = $13;
11070 $14 = __wasm_i64_mul($7, $7 >> 31, $26, $27);
11071 $13 = $20 + $14 | 0;
11072 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11073 $6 = $13 >>> 0 < $14 >>> 0 ? $6 + 1 | 0 : $6;
11074 $14 = $13;
11075 $13 = $3;
11076 $19 = $33;
11077 $20 = $14;
11078 $14 = __wasm_i64_mul($3, $3 >> 31, $17, $25);
11079 $3 = $20 + $14 | 0;
11080 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11081 $6 = $3 >>> 0 < $14 >>> 0 ? $6 + 1 | 0 : $6;
11082 $20 = $3;
11083 $3 = $9;
11084 $14 = __wasm_i64_mul($3, $3 >> 31, $15, $18);
11085 $9 = $20 + $14 | 0;
11086 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11087 $6 = $9 >>> 0 < $14 >>> 0 ? $6 + 1 | 0 : $6;
11088 $33 = $9;
11089 $9 = $4;
11090 $14 = $9 & 31;
11091 $9 = (32 <= ($9 & 63) >>> 0 ? $6 >> $14 : ((1 << $14) - 1 & $6) << 32 - $14 | $33 >>> $14) + $39 | 0;
11092 HEAP32[$19 >> 2] = $9;
11093 $14 = $16;
11094 $2 = $2 + 1 | 0;
11095 if (($2 | 0) != ($1 | 0)) {
11096 continue
11097 }
11098 break;
11099 };
11100 break label$1;
11101 }
11102 if (($1 | 0) < 1) {
11103 break label$1
11104 }
11105 $9 = HEAP32[$5 + -4 >> 2];
11106 $3 = HEAP32[$5 + -8 >> 2];
11107 $13 = HEAP32[$5 + -12 >> 2];
11108 $7 = HEAP32[$5 + -16 >> 2];
11109 $8 = HEAP32[$5 + -20 >> 2];
11110 $12 = HEAP32[$5 + -24 >> 2];
11111 $10 = HEAP32[$5 + -28 >> 2];
11112 $11 = HEAP32[$5 + -32 >> 2];
11113 $14 = HEAP32[$5 + -36 >> 2];
11114 $16 = HEAP32[$5 + -40 >> 2];
11115 $6 = HEAP32[$2 >> 2];
11116 $18 = $6;
11117 $17 = $6 >> 31;
11118 $6 = HEAP32[$2 + 4 >> 2];
11119 $25 = $6;
11120 $26 = $6 >> 31;
11121 $6 = HEAP32[$2 + 8 >> 2];
11122 $27 = $6;
11123 $24 = $6 >> 31;
11124 $6 = HEAP32[$2 + 12 >> 2];
11125 $29 = $6;
11126 $30 = $6 >> 31;
11127 $6 = HEAP32[$2 + 16 >> 2];
11128 $22 = $6;
11129 $31 = $6 >> 31;
11130 $6 = HEAP32[$2 + 20 >> 2];
11131 $32 = $6;
11132 $28 = $6 >> 31;
11133 $6 = HEAP32[$2 + 24 >> 2];
11134 $34 = $6;
11135 $35 = $6 >> 31;
11136 $6 = HEAP32[$2 + 28 >> 2];
11137 $21 = $6;
11138 $36 = $6 >> 31;
11139 $6 = HEAP32[$2 + 32 >> 2];
11140 $37 = $6;
11141 $33 = $6 >> 31;
11142 $2 = HEAP32[$2 + 36 >> 2];
11143 $39 = $2;
11144 $40 = $2 >> 31;
11145 $2 = 0;
11146 while (1) {
11147 $6 = $2 << 2;
11148 $20 = $6 + $5 | 0;
11149 $41 = HEAP32[$0 + $6 >> 2];
11150 $15 = $14;
11151 $6 = __wasm_i64_mul($14, $14 >> 31, $37, $33);
11152 $42 = i64toi32_i32$HIGH_BITS;
11153 $14 = $11;
11154 $38 = __wasm_i64_mul($16, $16 >> 31, $39, $40);
11155 $16 = $38 + $6 | 0;
11156 $6 = i64toi32_i32$HIGH_BITS + $42 | 0;
11157 $6 = $16 >>> 0 < $38 >>> 0 ? $6 + 1 | 0 : $6;
11158 $19 = $16;
11159 $16 = __wasm_i64_mul($11, $11 >> 31, $21, $36);
11160 $11 = $19 + $16 | 0;
11161 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11162 $6 = $11 >>> 0 < $16 >>> 0 ? $6 + 1 | 0 : $6;
11163 $16 = $11;
11164 $11 = $10;
11165 $10 = $16;
11166 $16 = __wasm_i64_mul($11, $11 >> 31, $34, $35);
11167 $10 = $10 + $16 | 0;
11168 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11169 $6 = $10 >>> 0 < $16 >>> 0 ? $6 + 1 | 0 : $6;
11170 $16 = $10;
11171 $10 = $12;
11172 $19 = $16;
11173 $16 = __wasm_i64_mul($12, $12 >> 31, $32, $28);
11174 $12 = $19 + $16 | 0;
11175 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11176 $6 = $12 >>> 0 < $16 >>> 0 ? $6 + 1 | 0 : $6;
11177 $16 = $12;
11178 $12 = $8;
11179 $19 = $16;
11180 $16 = __wasm_i64_mul($8, $8 >> 31, $22, $31);
11181 $8 = $19 + $16 | 0;
11182 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11183 $6 = $8 >>> 0 < $16 >>> 0 ? $6 + 1 | 0 : $6;
11184 $16 = $8;
11185 $8 = $7;
11186 $19 = $16;
11187 $16 = __wasm_i64_mul($7, $7 >> 31, $29, $30);
11188 $7 = $19 + $16 | 0;
11189 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11190 $6 = $7 >>> 0 < $16 >>> 0 ? $6 + 1 | 0 : $6;
11191 $19 = $7;
11192 $7 = $13;
11193 $16 = __wasm_i64_mul($7, $7 >> 31, $27, $24);
11194 $13 = $19 + $16 | 0;
11195 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11196 $6 = $13 >>> 0 < $16 >>> 0 ? $6 + 1 | 0 : $6;
11197 $16 = $13;
11198 $13 = $3;
11199 $19 = $20;
11200 $20 = $16;
11201 $16 = __wasm_i64_mul($3, $3 >> 31, $25, $26);
11202 $3 = $20 + $16 | 0;
11203 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11204 $6 = $3 >>> 0 < $16 >>> 0 ? $6 + 1 | 0 : $6;
11205 $20 = $3;
11206 $3 = $9;
11207 $16 = __wasm_i64_mul($3, $3 >> 31, $18, $17);
11208 $9 = $20 + $16 | 0;
11209 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11210 $6 = $9 >>> 0 < $16 >>> 0 ? $6 + 1 | 0 : $6;
11211 $20 = $9;
11212 $9 = $4;
11213 $16 = $9 & 31;
11214 $9 = (32 <= ($9 & 63) >>> 0 ? $6 >> $16 : ((1 << $16) - 1 & $6) << 32 - $16 | $20 >>> $16) + $41 | 0;
11215 HEAP32[$19 >> 2] = $9;
11216 $16 = $15;
11217 $2 = $2 + 1 | 0;
11218 if (($2 | 0) != ($1 | 0)) {
11219 continue
11220 }
11221 break;
11222 };
11223 break label$1;
11224 }
11225 if ($3 >>> 0 >= 5) {
11226 if ($3 >>> 0 >= 7) {
11227 if (($3 | 0) != 8) {
11228 if (($1 | 0) < 1) {
11229 break label$1
11230 }
11231 $9 = HEAP32[$5 + -4 >> 2];
11232 $3 = HEAP32[$5 + -8 >> 2];
11233 $13 = HEAP32[$5 + -12 >> 2];
11234 $7 = HEAP32[$5 + -16 >> 2];
11235 $8 = HEAP32[$5 + -20 >> 2];
11236 $12 = HEAP32[$5 + -24 >> 2];
11237 $10 = HEAP32[$5 + -28 >> 2];
11238 $11 = HEAP32[$2 >> 2];
11239 $14 = $11;
11240 $16 = $11 >> 31;
11241 $11 = HEAP32[$2 + 4 >> 2];
11242 $15 = $11;
11243 $18 = $11 >> 31;
11244 $11 = HEAP32[$2 + 8 >> 2];
11245 $17 = $11;
11246 $25 = $11 >> 31;
11247 $11 = HEAP32[$2 + 12 >> 2];
11248 $26 = $11;
11249 $27 = $11 >> 31;
11250 $11 = HEAP32[$2 + 16 >> 2];
11251 $24 = $11;
11252 $29 = $11 >> 31;
11253 $11 = HEAP32[$2 + 20 >> 2];
11254 $30 = $11;
11255 $22 = $11 >> 31;
11256 $2 = HEAP32[$2 + 24 >> 2];
11257 $31 = $2;
11258 $32 = $2 >> 31;
11259 $2 = 0;
11260 while (1) {
11261 $11 = $2 << 2;
11262 $28 = $11 + $5 | 0;
11263 $34 = HEAP32[$0 + $11 >> 2];
11264 $11 = $12;
11265 $6 = __wasm_i64_mul($11, $11 >> 31, $30, $22);
11266 $35 = i64toi32_i32$HIGH_BITS;
11267 $12 = $8;
11268 $21 = __wasm_i64_mul($10, $10 >> 31, $31, $32);
11269 $10 = $21 + $6 | 0;
11270 $6 = i64toi32_i32$HIGH_BITS + $35 | 0;
11271 $6 = $10 >>> 0 < $21 >>> 0 ? $6 + 1 | 0 : $6;
11272 $21 = $10;
11273 $10 = __wasm_i64_mul($8, $8 >> 31, $24, $29);
11274 $8 = $21 + $10 | 0;
11275 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11276 $6 = $8 >>> 0 < $10 >>> 0 ? $6 + 1 | 0 : $6;
11277 $10 = $8;
11278 $8 = $7;
11279 $21 = $10;
11280 $10 = __wasm_i64_mul($7, $7 >> 31, $26, $27);
11281 $7 = $21 + $10 | 0;
11282 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11283 $6 = $7 >>> 0 < $10 >>> 0 ? $6 + 1 | 0 : $6;
11284 $21 = $7;
11285 $7 = $13;
11286 $10 = __wasm_i64_mul($7, $7 >> 31, $17, $25);
11287 $13 = $21 + $10 | 0;
11288 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11289 $6 = $13 >>> 0 < $10 >>> 0 ? $6 + 1 | 0 : $6;
11290 $10 = $13;
11291 $13 = $3;
11292 $20 = $28;
11293 $21 = $10;
11294 $10 = __wasm_i64_mul($3, $3 >> 31, $15, $18);
11295 $3 = $21 + $10 | 0;
11296 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11297 $6 = $3 >>> 0 < $10 >>> 0 ? $6 + 1 | 0 : $6;
11298 $21 = $3;
11299 $3 = $9;
11300 $10 = __wasm_i64_mul($3, $3 >> 31, $14, $16);
11301 $9 = $21 + $10 | 0;
11302 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11303 $6 = $9 >>> 0 < $10 >>> 0 ? $6 + 1 | 0 : $6;
11304 $28 = $9;
11305 $9 = $4;
11306 $10 = $9 & 31;
11307 $9 = (32 <= ($9 & 63) >>> 0 ? $6 >> $10 : ((1 << $10) - 1 & $6) << 32 - $10 | $28 >>> $10) + $34 | 0;
11308 HEAP32[$20 >> 2] = $9;
11309 $10 = $11;
11310 $2 = $2 + 1 | 0;
11311 if (($2 | 0) != ($1 | 0)) {
11312 continue
11313 }
11314 break;
11315 };
11316 break label$1;
11317 }
11318 if (($1 | 0) < 1) {
11319 break label$1
11320 }
11321 $9 = HEAP32[$5 + -4 >> 2];
11322 $3 = HEAP32[$5 + -8 >> 2];
11323 $13 = HEAP32[$5 + -12 >> 2];
11324 $7 = HEAP32[$5 + -16 >> 2];
11325 $8 = HEAP32[$5 + -20 >> 2];
11326 $12 = HEAP32[$5 + -24 >> 2];
11327 $10 = HEAP32[$5 + -28 >> 2];
11328 $11 = HEAP32[$5 + -32 >> 2];
11329 $6 = HEAP32[$2 >> 2];
11330 $16 = $6;
11331 $15 = $6 >> 31;
11332 $6 = HEAP32[$2 + 4 >> 2];
11333 $18 = $6;
11334 $17 = $6 >> 31;
11335 $6 = HEAP32[$2 + 8 >> 2];
11336 $25 = $6;
11337 $26 = $6 >> 31;
11338 $6 = HEAP32[$2 + 12 >> 2];
11339 $27 = $6;
11340 $24 = $6 >> 31;
11341 $6 = HEAP32[$2 + 16 >> 2];
11342 $29 = $6;
11343 $30 = $6 >> 31;
11344 $6 = HEAP32[$2 + 20 >> 2];
11345 $22 = $6;
11346 $31 = $6 >> 31;
11347 $6 = HEAP32[$2 + 24 >> 2];
11348 $32 = $6;
11349 $28 = $6 >> 31;
11350 $2 = HEAP32[$2 + 28 >> 2];
11351 $34 = $2;
11352 $35 = $2 >> 31;
11353 $2 = 0;
11354 while (1) {
11355 $6 = $2 << 2;
11356 $21 = $6 + $5 | 0;
11357 $36 = HEAP32[$0 + $6 >> 2];
11358 $14 = $10;
11359 $6 = __wasm_i64_mul($10, $10 >> 31, $32, $28);
11360 $37 = i64toi32_i32$HIGH_BITS;
11361 $10 = $12;
11362 $33 = __wasm_i64_mul($11, $11 >> 31, $34, $35);
11363 $11 = $33 + $6 | 0;
11364 $6 = i64toi32_i32$HIGH_BITS + $37 | 0;
11365 $6 = $11 >>> 0 < $33 >>> 0 ? $6 + 1 | 0 : $6;
11366 $20 = $11;
11367 $11 = __wasm_i64_mul($12, $12 >> 31, $22, $31);
11368 $12 = $20 + $11 | 0;
11369 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11370 $6 = $12 >>> 0 < $11 >>> 0 ? $6 + 1 | 0 : $6;
11371 $11 = $12;
11372 $12 = $8;
11373 $20 = $11;
11374 $11 = __wasm_i64_mul($8, $8 >> 31, $29, $30);
11375 $8 = $20 + $11 | 0;
11376 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11377 $6 = $8 >>> 0 < $11 >>> 0 ? $6 + 1 | 0 : $6;
11378 $11 = $8;
11379 $8 = $7;
11380 $20 = $11;
11381 $11 = __wasm_i64_mul($7, $7 >> 31, $27, $24);
11382 $7 = $20 + $11 | 0;
11383 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11384 $6 = $7 >>> 0 < $11 >>> 0 ? $6 + 1 | 0 : $6;
11385 $20 = $7;
11386 $7 = $13;
11387 $11 = __wasm_i64_mul($7, $7 >> 31, $25, $26);
11388 $13 = $20 + $11 | 0;
11389 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11390 $6 = $13 >>> 0 < $11 >>> 0 ? $6 + 1 | 0 : $6;
11391 $11 = $13;
11392 $13 = $3;
11393 $20 = $21;
11394 $21 = $11;
11395 $11 = __wasm_i64_mul($3, $3 >> 31, $18, $17);
11396 $3 = $21 + $11 | 0;
11397 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11398 $6 = $3 >>> 0 < $11 >>> 0 ? $6 + 1 | 0 : $6;
11399 $21 = $3;
11400 $3 = $9;
11401 $11 = __wasm_i64_mul($3, $3 >> 31, $16, $15);
11402 $9 = $21 + $11 | 0;
11403 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11404 $6 = $9 >>> 0 < $11 >>> 0 ? $6 + 1 | 0 : $6;
11405 $21 = $9;
11406 $9 = $4;
11407 $11 = $9 & 31;
11408 $9 = (32 <= ($9 & 63) >>> 0 ? $6 >> $11 : ((1 << $11) - 1 & $6) << 32 - $11 | $21 >>> $11) + $36 | 0;
11409 HEAP32[$20 >> 2] = $9;
11410 $11 = $14;
11411 $2 = $2 + 1 | 0;
11412 if (($2 | 0) != ($1 | 0)) {
11413 continue
11414 }
11415 break;
11416 };
11417 break label$1;
11418 }
11419 if (($3 | 0) != 6) {
11420 if (($1 | 0) < 1) {
11421 break label$1
11422 }
11423 $9 = HEAP32[$5 + -4 >> 2];
11424 $3 = HEAP32[$5 + -8 >> 2];
11425 $13 = HEAP32[$5 + -12 >> 2];
11426 $7 = HEAP32[$5 + -16 >> 2];
11427 $8 = HEAP32[$5 + -20 >> 2];
11428 $12 = HEAP32[$2 >> 2];
11429 $10 = $12;
11430 $11 = $12 >> 31;
11431 $12 = HEAP32[$2 + 4 >> 2];
11432 $14 = $12;
11433 $16 = $12 >> 31;
11434 $12 = HEAP32[$2 + 8 >> 2];
11435 $15 = $12;
11436 $18 = $12 >> 31;
11437 $12 = HEAP32[$2 + 12 >> 2];
11438 $17 = $12;
11439 $25 = $12 >> 31;
11440 $2 = HEAP32[$2 + 16 >> 2];
11441 $26 = $2;
11442 $27 = $2 >> 31;
11443 $2 = 0;
11444 while (1) {
11445 $12 = $2 << 2;
11446 $24 = $12 + $5 | 0;
11447 $29 = HEAP32[$0 + $12 >> 2];
11448 $12 = $7;
11449 $6 = __wasm_i64_mul($7, $7 >> 31, $17, $25);
11450 $30 = i64toi32_i32$HIGH_BITS;
11451 $7 = $13;
11452 $22 = __wasm_i64_mul($8, $8 >> 31, $26, $27);
11453 $8 = $22 + $6 | 0;
11454 $6 = i64toi32_i32$HIGH_BITS + $30 | 0;
11455 $6 = $8 >>> 0 < $22 >>> 0 ? $6 + 1 | 0 : $6;
11456 $13 = $8;
11457 $8 = __wasm_i64_mul($7, $7 >> 31, $15, $18);
11458 $13 = $13 + $8 | 0;
11459 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11460 $6 = $13 >>> 0 < $8 >>> 0 ? $6 + 1 | 0 : $6;
11461 $8 = $13;
11462 $13 = $3;
11463 $22 = $8;
11464 $8 = __wasm_i64_mul($3, $3 >> 31, $14, $16);
11465 $3 = $22 + $8 | 0;
11466 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11467 $6 = $3 >>> 0 < $8 >>> 0 ? $6 + 1 | 0 : $6;
11468 $8 = $3;
11469 $3 = $9;
11470 $9 = __wasm_i64_mul($3, $3 >> 31, $10, $11);
11471 $8 = $8 + $9 | 0;
11472 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11473 $6 = $8 >>> 0 < $9 >>> 0 ? $6 + 1 | 0 : $6;
11474 $9 = $4 & 31;
11475 $9 = (32 <= ($4 & 63) >>> 0 ? $6 >> $9 : ((1 << $9) - 1 & $6) << 32 - $9 | $8 >>> $9) + $29 | 0;
11476 HEAP32[$24 >> 2] = $9;
11477 $8 = $12;
11478 $2 = $2 + 1 | 0;
11479 if (($2 | 0) != ($1 | 0)) {
11480 continue
11481 }
11482 break;
11483 };
11484 break label$1;
11485 }
11486 if (($1 | 0) < 1) {
11487 break label$1
11488 }
11489 $9 = HEAP32[$5 + -4 >> 2];
11490 $3 = HEAP32[$5 + -8 >> 2];
11491 $13 = HEAP32[$5 + -12 >> 2];
11492 $7 = HEAP32[$5 + -16 >> 2];
11493 $8 = HEAP32[$5 + -20 >> 2];
11494 $12 = HEAP32[$5 + -24 >> 2];
11495 $10 = HEAP32[$2 >> 2];
11496 $11 = $10;
11497 $14 = $11 >> 31;
11498 $10 = HEAP32[$2 + 4 >> 2];
11499 $16 = $10;
11500 $15 = $10 >> 31;
11501 $10 = HEAP32[$2 + 8 >> 2];
11502 $18 = $10;
11503 $17 = $10 >> 31;
11504 $10 = HEAP32[$2 + 12 >> 2];
11505 $25 = $10;
11506 $26 = $10 >> 31;
11507 $10 = HEAP32[$2 + 16 >> 2];
11508 $27 = $10;
11509 $24 = $10 >> 31;
11510 $2 = HEAP32[$2 + 20 >> 2];
11511 $29 = $2;
11512 $30 = $2 >> 31;
11513 $2 = 0;
11514 while (1) {
11515 $10 = $2 << 2;
11516 $22 = $10 + $5 | 0;
11517 $31 = HEAP32[$0 + $10 >> 2];
11518 $10 = $8;
11519 $6 = __wasm_i64_mul($8, $8 >> 31, $27, $24);
11520 $32 = i64toi32_i32$HIGH_BITS;
11521 $8 = $7;
11522 $28 = __wasm_i64_mul($12, $12 >> 31, $29, $30);
11523 $12 = $28 + $6 | 0;
11524 $6 = i64toi32_i32$HIGH_BITS + $32 | 0;
11525 $6 = $12 >>> 0 < $28 >>> 0 ? $6 + 1 | 0 : $6;
11526 $21 = $12;
11527 $12 = __wasm_i64_mul($7, $7 >> 31, $25, $26);
11528 $7 = $21 + $12 | 0;
11529 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11530 $6 = $7 >>> 0 < $12 >>> 0 ? $6 + 1 | 0 : $6;
11531 $21 = $7;
11532 $7 = $13;
11533 $12 = __wasm_i64_mul($7, $7 >> 31, $18, $17);
11534 $13 = $21 + $12 | 0;
11535 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11536 $6 = $13 >>> 0 < $12 >>> 0 ? $6 + 1 | 0 : $6;
11537 $12 = $13;
11538 $13 = $3;
11539 $21 = $22;
11540 $22 = $12;
11541 $12 = __wasm_i64_mul($3, $3 >> 31, $16, $15);
11542 $3 = $22 + $12 | 0;
11543 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11544 $6 = $3 >>> 0 < $12 >>> 0 ? $6 + 1 | 0 : $6;
11545 $12 = $3;
11546 $3 = $9;
11547 $9 = __wasm_i64_mul($3, $3 >> 31, $11, $14);
11548 $12 = $12 + $9 | 0;
11549 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11550 $6 = $12 >>> 0 < $9 >>> 0 ? $6 + 1 | 0 : $6;
11551 $9 = $4 & 31;
11552 $9 = (32 <= ($4 & 63) >>> 0 ? $6 >> $9 : ((1 << $9) - 1 & $6) << 32 - $9 | $12 >>> $9) + $31 | 0;
11553 HEAP32[$21 >> 2] = $9;
11554 $12 = $10;
11555 $2 = $2 + 1 | 0;
11556 if (($2 | 0) != ($1 | 0)) {
11557 continue
11558 }
11559 break;
11560 };
11561 break label$1;
11562 }
11563 if ($3 >>> 0 >= 3) {
11564 if (($3 | 0) != 4) {
11565 if (($1 | 0) < 1) {
11566 break label$1
11567 }
11568 $9 = HEAP32[$5 + -4 >> 2];
11569 $3 = HEAP32[$5 + -8 >> 2];
11570 $13 = HEAP32[$5 + -12 >> 2];
11571 $7 = HEAP32[$2 >> 2];
11572 $12 = $7;
11573 $10 = $7 >> 31;
11574 $7 = HEAP32[$2 + 4 >> 2];
11575 $11 = $7;
11576 $14 = $7 >> 31;
11577 $2 = HEAP32[$2 + 8 >> 2];
11578 $16 = $2;
11579 $15 = $2 >> 31;
11580 $2 = 0;
11581 while (1) {
11582 $7 = $2 << 2;
11583 $8 = $7 + $5 | 0;
11584 $18 = HEAP32[$0 + $7 >> 2];
11585 $7 = $3;
11586 $3 = __wasm_i64_mul($7, $7 >> 31, $11, $14);
11587 $6 = i64toi32_i32$HIGH_BITS;
11588 $17 = $8;
11589 $13 = __wasm_i64_mul($13, $13 >> 31, $16, $15);
11590 $3 = $13 + $3 | 0;
11591 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11592 $6 = $3 >>> 0 < $13 >>> 0 ? $6 + 1 | 0 : $6;
11593 $8 = $3;
11594 $3 = $9;
11595 $9 = __wasm_i64_mul($3, $3 >> 31, $12, $10);
11596 $13 = $8 + $9 | 0;
11597 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11598 $6 = $13 >>> 0 < $9 >>> 0 ? $6 + 1 | 0 : $6;
11599 $9 = $13;
11600 $8 = $4 & 31;
11601 $9 = (32 <= ($4 & 63) >>> 0 ? $6 >> $8 : ((1 << $8) - 1 & $6) << 32 - $8 | $9 >>> $8) + $18 | 0;
11602 HEAP32[$17 >> 2] = $9;
11603 $13 = $7;
11604 $2 = $2 + 1 | 0;
11605 if (($2 | 0) != ($1 | 0)) {
11606 continue
11607 }
11608 break;
11609 };
11610 break label$1;
11611 }
11612 if (($1 | 0) < 1) {
11613 break label$1
11614 }
11615 $9 = HEAP32[$5 + -4 >> 2];
11616 $3 = HEAP32[$5 + -8 >> 2];
11617 $13 = HEAP32[$5 + -12 >> 2];
11618 $7 = HEAP32[$5 + -16 >> 2];
11619 $8 = HEAP32[$2 >> 2];
11620 $10 = $8;
11621 $11 = $8 >> 31;
11622 $8 = HEAP32[$2 + 4 >> 2];
11623 $14 = $8;
11624 $16 = $8 >> 31;
11625 $8 = HEAP32[$2 + 8 >> 2];
11626 $15 = $8;
11627 $18 = $8 >> 31;
11628 $2 = HEAP32[$2 + 12 >> 2];
11629 $17 = $2;
11630 $25 = $2 >> 31;
11631 $2 = 0;
11632 while (1) {
11633 $8 = $2 << 2;
11634 $12 = $8 + $5 | 0;
11635 $26 = HEAP32[$0 + $8 >> 2];
11636 $8 = $13;
11637 $6 = __wasm_i64_mul($8, $8 >> 31, $15, $18);
11638 $27 = i64toi32_i32$HIGH_BITS;
11639 $13 = $3;
11640 $22 = $12;
11641 $24 = __wasm_i64_mul($7, $7 >> 31, $17, $25);
11642 $7 = $24 + $6 | 0;
11643 $6 = i64toi32_i32$HIGH_BITS + $27 | 0;
11644 $6 = $7 >>> 0 < $24 >>> 0 ? $6 + 1 | 0 : $6;
11645 $12 = $7;
11646 $7 = __wasm_i64_mul($3, $3 >> 31, $14, $16);
11647 $3 = $12 + $7 | 0;
11648 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11649 $6 = $3 >>> 0 < $7 >>> 0 ? $6 + 1 | 0 : $6;
11650 $7 = $3;
11651 $3 = $9;
11652 $9 = __wasm_i64_mul($3, $3 >> 31, $10, $11);
11653 $7 = $7 + $9 | 0;
11654 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11655 $6 = $7 >>> 0 < $9 >>> 0 ? $6 + 1 | 0 : $6;
11656 $9 = $7;
11657 $7 = $4;
11658 $12 = $7 & 31;
11659 $9 = (32 <= ($7 & 63) >>> 0 ? $6 >> $12 : ((1 << $12) - 1 & $6) << 32 - $12 | $9 >>> $12) + $26 | 0;
11660 HEAP32[$22 >> 2] = $9;
11661 $7 = $8;
11662 $2 = $2 + 1 | 0;
11663 if (($2 | 0) != ($1 | 0)) {
11664 continue
11665 }
11666 break;
11667 };
11668 break label$1;
11669 }
11670 if (($3 | 0) != 2) {
11671 if (($1 | 0) < 1) {
11672 break label$1
11673 }
11674 $9 = HEAP32[$5 + -4 >> 2];
11675 $2 = HEAP32[$2 >> 2];
11676 $8 = $2;
11677 $12 = $2 >> 31;
11678 $2 = 0;
11679 while (1) {
11680 $3 = $2 << 2;
11681 $10 = $3 + $5 | 0;
11682 $6 = HEAP32[$0 + $3 >> 2];
11683 $9 = __wasm_i64_mul($9, $9 >> 31, $8, $12);
11684 $7 = i64toi32_i32$HIGH_BITS;
11685 $3 = $4;
11686 $13 = $3 & 31;
11687 $9 = $6 + (32 <= ($3 & 63) >>> 0 ? $7 >> $13 : ((1 << $13) - 1 & $7) << 32 - $13 | $9 >>> $13) | 0;
11688 HEAP32[$10 >> 2] = $9;
11689 $2 = $2 + 1 | 0;
11690 if (($2 | 0) != ($1 | 0)) {
11691 continue
11692 }
11693 break;
11694 };
11695 break label$1;
11696 }
11697 if (($1 | 0) < 1) {
11698 break label$1
11699 }
11700 $9 = HEAP32[$5 + -4 >> 2];
11701 $3 = HEAP32[$5 + -8 >> 2];
11702 $13 = HEAP32[$2 >> 2];
11703 $8 = $13;
11704 $12 = $8 >> 31;
11705 $2 = HEAP32[$2 + 4 >> 2];
11706 $10 = $2;
11707 $11 = $2 >> 31;
11708 $2 = 0;
11709 while (1) {
11710 $13 = $2 << 2;
11711 $7 = $13 + $5 | 0;
11712 $14 = HEAP32[$0 + $13 >> 2];
11713 $13 = $9;
11714 $9 = __wasm_i64_mul($9, $9 >> 31, $8, $12);
11715 $6 = i64toi32_i32$HIGH_BITS;
11716 $15 = $7;
11717 $7 = $9;
11718 $9 = __wasm_i64_mul($3, $3 >> 31, $10, $11);
11719 $3 = $7 + $9 | 0;
11720 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
11721 $6 = $3 >>> 0 < $9 >>> 0 ? $6 + 1 | 0 : $6;
11722 $9 = $3;
11723 $3 = $4;
11724 $7 = $3 & 31;
11725 $9 = (32 <= ($3 & 63) >>> 0 ? $6 >> $7 : ((1 << $7) - 1 & $6) << 32 - $7 | $9 >>> $7) + $14 | 0;
11726 HEAP32[$15 >> 2] = $9;
11727 $3 = $13;
11728 $2 = $2 + 1 | 0;
11729 if (($2 | 0) != ($1 | 0)) {
11730 continue
11731 }
11732 break;
11733 };
11734 }
11735 }
11736
11737 function FLAC__lpc_compute_expected_bits_per_residual_sample($0, $1) {
11738 if (!!($0 > 0.0)) {
11739 $0 = log(.5 / +($1 >>> 0) * $0) * .5 / .6931471805599453;
11740 return $0 >= 0.0 ? $0 : 0.0;
11741 }
11742 return $0 < 0.0 ? 1.e+32 : 0.0;
11743 }
11744
11745 function FLAC__lpc_compute_best_order($0, $1, $2, $3) {
11746 var $4 = 0.0, $5 = 0, $6 = 0, $7 = 0.0, $8 = 0, $9 = 0, $10 = 0.0;
11747 $5 = 1;
11748 if ($1) {
11749 $10 = .5 / +($2 >>> 0);
11750 $7 = 4294967295.0;
11751 while (1) {
11752 $4 = HEAPF64[($6 << 3) + $0 >> 3];
11753 label$3 : {
11754 if (!!($4 > 0.0)) {
11755 $4 = log($10 * $4) * .5 / .6931471805599453;
11756 $4 = $4 >= 0.0 ? $4 : 0.0;
11757 break label$3;
11758 }
11759 $4 = $4 < 0.0 ? 1.e+32 : 0.0;
11760 }
11761 $4 = $4 * +($2 - $5 >>> 0) + +(Math_imul($3, $5) >>> 0);
11762 $8 = $4 < $7;
11763 $7 = $8 ? $4 : $7;
11764 $9 = $8 ? $6 : $9;
11765 $5 = $5 + 1 | 0;
11766 $6 = $6 + 1 | 0;
11767 if (($6 | 0) != ($1 | 0)) {
11768 continue
11769 }
11770 break;
11771 };
11772 $0 = $9 + 1 | 0;
11773 } else {
11774 $0 = 1
11775 }
11776 return $0;
11777 }
11778
11779 function strlen($0) {
11780 var $1 = 0, $2 = 0, $3 = 0;
11781 label$1 : {
11782 label$2 : {
11783 $1 = $0;
11784 if (!($1 & 3)) {
11785 break label$2
11786 }
11787 if (!HEAPU8[$0 | 0]) {
11788 return 0
11789 }
11790 while (1) {
11791 $1 = $1 + 1 | 0;
11792 if (!($1 & 3)) {
11793 break label$2
11794 }
11795 if (HEAPU8[$1 | 0]) {
11796 continue
11797 }
11798 break;
11799 };
11800 break label$1;
11801 }
11802 while (1) {
11803 $2 = $1;
11804 $1 = $1 + 4 | 0;
11805 $3 = HEAP32[$2 >> 2];
11806 if (!(($3 ^ -1) & $3 + -16843009 & -2139062144)) {
11807 continue
11808 }
11809 break;
11810 };
11811 if (!($3 & 255)) {
11812 return $2 - $0 | 0
11813 }
11814 while (1) {
11815 $3 = HEAPU8[$2 + 1 | 0];
11816 $1 = $2 + 1 | 0;
11817 $2 = $1;
11818 if ($3) {
11819 continue
11820 }
11821 break;
11822 };
11823 }
11824 return $1 - $0 | 0;
11825 }
11826
11827 function __strchrnul($0, $1) {
11828 var $2 = 0, $3 = 0;
11829 label$1 : {
11830 $3 = $1 & 255;
11831 if ($3) {
11832 if ($0 & 3) {
11833 while (1) {
11834 $2 = HEAPU8[$0 | 0];
11835 if (!$2 | ($2 | 0) == ($1 & 255)) {
11836 break label$1
11837 }
11838 $0 = $0 + 1 | 0;
11839 if ($0 & 3) {
11840 continue
11841 }
11842 break;
11843 }
11844 }
11845 $2 = HEAP32[$0 >> 2];
11846 label$5 : {
11847 if (($2 ^ -1) & $2 + -16843009 & -2139062144) {
11848 break label$5
11849 }
11850 $3 = Math_imul($3, 16843009);
11851 while (1) {
11852 $2 = $2 ^ $3;
11853 if (($2 ^ -1) & $2 + -16843009 & -2139062144) {
11854 break label$5
11855 }
11856 $2 = HEAP32[$0 + 4 >> 2];
11857 $0 = $0 + 4 | 0;
11858 if (!($2 + -16843009 & ($2 ^ -1) & -2139062144)) {
11859 continue
11860 }
11861 break;
11862 };
11863 }
11864 while (1) {
11865 $2 = $0;
11866 $3 = HEAPU8[$2 | 0];
11867 if ($3) {
11868 $0 = $2 + 1 | 0;
11869 if (($3 | 0) != ($1 & 255)) {
11870 continue
11871 }
11872 }
11873 break;
11874 };
11875 return $2;
11876 }
11877 return strlen($0) + $0 | 0;
11878 }
11879 return $0;
11880 }
11881
11882 function strchr($0, $1) {
11883 $0 = __strchrnul($0, $1);
11884 return HEAPU8[$0 | 0] == ($1 & 255) ? $0 : 0;
11885 }
11886
11887 function __stdio_write($0, $1, $2) {
11888 $0 = $0 | 0;
11889 $1 = $1 | 0;
11890 $2 = $2 | 0;
11891 var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0;
11892 $3 = global$0 - 32 | 0;
11893 global$0 = $3;
11894 $4 = HEAP32[$0 + 28 >> 2];
11895 HEAP32[$3 + 16 >> 2] = $4;
11896 $5 = HEAP32[$0 + 20 >> 2];
11897 HEAP32[$3 + 28 >> 2] = $2;
11898 HEAP32[$3 + 24 >> 2] = $1;
11899 $1 = $5 - $4 | 0;
11900 HEAP32[$3 + 20 >> 2] = $1;
11901 $4 = $1 + $2 | 0;
11902 $9 = 2;
11903 $1 = $3 + 16 | 0;
11904 label$1 : {
11905 label$2 : {
11906 label$3 : {
11907 if (!__wasi_syscall_ret(__wasi_fd_write(HEAP32[$0 + 60 >> 2], $3 + 16 | 0, 2, $3 + 12 | 0) | 0)) {
11908 while (1) {
11909 $5 = HEAP32[$3 + 12 >> 2];
11910 if (($5 | 0) == ($4 | 0)) {
11911 break label$3
11912 }
11913 if (($5 | 0) <= -1) {
11914 break label$2
11915 }
11916 $6 = HEAP32[$1 + 4 >> 2];
11917 $7 = $5 >>> 0 > $6 >>> 0;
11918 $8 = ($7 << 3) + $1 | 0;
11919 $6 = $5 - ($7 ? $6 : 0) | 0;
11920 HEAP32[$8 >> 2] = $6 + HEAP32[$8 >> 2];
11921 $8 = ($7 ? 12 : 4) + $1 | 0;
11922 HEAP32[$8 >> 2] = HEAP32[$8 >> 2] - $6;
11923 $4 = $4 - $5 | 0;
11924 $1 = $7 ? $1 + 8 | 0 : $1;
11925 $9 = $9 - $7 | 0;
11926 if (!__wasi_syscall_ret(__wasi_fd_write(HEAP32[$0 + 60 >> 2], $1 | 0, $9 | 0, $3 + 12 | 0) | 0)) {
11927 continue
11928 }
11929 break;
11930 }
11931 }
11932 HEAP32[$3 + 12 >> 2] = -1;
11933 if (($4 | 0) != -1) {
11934 break label$2
11935 }
11936 }
11937 $1 = HEAP32[$0 + 44 >> 2];
11938 HEAP32[$0 + 28 >> 2] = $1;
11939 HEAP32[$0 + 20 >> 2] = $1;
11940 HEAP32[$0 + 16 >> 2] = $1 + HEAP32[$0 + 48 >> 2];
11941 $0 = $2;
11942 break label$1;
11943 }
11944 HEAP32[$0 + 28 >> 2] = 0;
11945 HEAP32[$0 + 16 >> 2] = 0;
11946 HEAP32[$0 + 20 >> 2] = 0;
11947 HEAP32[$0 >> 2] = HEAP32[$0 >> 2] | 32;
11948 $0 = 0;
11949 if (($9 | 0) == 2) {
11950 break label$1
11951 }
11952 $0 = $2 - HEAP32[$1 + 4 >> 2] | 0;
11953 }
11954 global$0 = $3 + 32 | 0;
11955 return $0 | 0;
11956 }
11957
11958 function FLAC__memory_alloc_aligned_int32_array($0, $1, $2) {
11959 var $3 = 0;
11960 label$1 : {
11961 if ($0 >>> 0 > 1073741823) {
11962 break label$1
11963 }
11964 $0 = dlmalloc($0 ? $0 << 2 : 1);
11965 if (!$0) {
11966 break label$1
11967 }
11968 $3 = HEAP32[$1 >> 2];
11969 if ($3) {
11970 dlfree($3)
11971 }
11972 HEAP32[$1 >> 2] = $0;
11973 HEAP32[$2 >> 2] = $0;
11974 $3 = 1;
11975 }
11976 return $3;
11977 }
11978
11979 function FLAC__memory_alloc_aligned_uint64_array($0, $1, $2) {
11980 var $3 = 0;
11981 label$1 : {
11982 if ($0 >>> 0 > 536870911) {
11983 break label$1
11984 }
11985 $0 = dlmalloc($0 ? $0 << 3 : 1);
11986 if (!$0) {
11987 break label$1
11988 }
11989 $3 = HEAP32[$1 >> 2];
11990 if ($3) {
11991 dlfree($3)
11992 }
11993 HEAP32[$1 >> 2] = $0;
11994 HEAP32[$2 >> 2] = $0;
11995 $3 = 1;
11996 }
11997 return $3;
11998 }
11999
12000 function safe_malloc_mul_2op_p($0, $1) {
12001 if (!($1 ? $0 : 0)) {
12002 return dlmalloc(1)
12003 }
12004 __wasm_i64_mul($1, 0, $0, 0);
12005 if (i64toi32_i32$HIGH_BITS) {
12006 $0 = 0
12007 } else {
12008 $0 = dlmalloc(Math_imul($0, $1))
12009 }
12010 return $0;
12011 }
12012
12013 function FLAC__fixed_compute_best_predictor($0, $1, $2) {
12014 $0 = $0 | 0;
12015 $1 = $1 | 0;
12016 $2 = $2 | 0;
12017 var $3 = 0, $4 = Math_fround(0), $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0);
12018 if ($1) {
12019 $3 = HEAP32[$0 + -4 >> 2];
12020 $8 = HEAP32[$0 + -8 >> 2];
12021 $12 = $3 - $8 | 0;
12022 $5 = HEAP32[$0 + -12 >> 2];
12023 $9 = $12 + ($5 - $8 | 0) | 0;
12024 $17 = $9 + ((($5 << 1) - $8 | 0) - HEAP32[$0 + -16 >> 2] | 0) | 0;
12025 while (1) {
12026 $8 = HEAP32[($15 << 2) + $0 >> 2];
12027 $5 = $8 >> 31;
12028 $14 = ($5 ^ $5 + $8) + $14 | 0;
12029 $5 = $8 - $3 | 0;
12030 $11 = $5 >> 31;
12031 $13 = ($11 ^ $5 + $11) + $13 | 0;
12032 $11 = $5 - $12 | 0;
12033 $3 = $11 >> 31;
12034 $10 = ($3 ^ $3 + $11) + $10 | 0;
12035 $9 = $11 - $9 | 0;
12036 $3 = $9 >> 31;
12037 $6 = ($3 ^ $3 + $9) + $6 | 0;
12038 $12 = $9 - $17 | 0;
12039 $3 = $12 >> 31;
12040 $7 = ($3 ^ $3 + $12) + $7 | 0;
12041 $3 = $8;
12042 $12 = $5;
12043 $17 = $9;
12044 $9 = $11;
12045 $15 = $15 + 1 | 0;
12046 if (($15 | 0) != ($1 | 0)) {
12047 continue
12048 }
12049 break;
12050 };
12051 }
12052 $0 = $13 >>> 0 < $10 >>> 0 ? $13 : $10;
12053 $0 = $0 >>> 0 < $6 >>> 0 ? $0 : $6;
12054 label$3 : {
12055 if ($14 >>> 0 < ($0 >>> 0 < $7 >>> 0 ? $0 : $7) >>> 0) {
12056 break label$3
12057 }
12058 $16 = 1;
12059 $0 = $10 >>> 0 < $6 >>> 0 ? $10 : $6;
12060 if ($13 >>> 0 < ($0 >>> 0 < $7 >>> 0 ? $0 : $7) >>> 0) {
12061 break label$3
12062 }
12063 $0 = $6 >>> 0 < $7 >>> 0;
12064 $16 = $10 >>> 0 < ($0 ? $6 : $7) >>> 0 ? 2 : $0 ? 3 : 4;
12065 }
12066 $0 = $2;
12067 if ($14) {
12068 $4 = Math_fround(log(+($14 >>> 0) * .6931471805599453 / +($1 >>> 0)) / .6931471805599453)
12069 } else {
12070 $4 = Math_fround(0.0)
12071 }
12072 HEAPF32[$0 >> 2] = $4;
12073 $0 = $2;
12074 if ($13) {
12075 $4 = Math_fround(log(+($13 >>> 0) * .6931471805599453 / +($1 >>> 0)) / .6931471805599453)
12076 } else {
12077 $4 = Math_fround(0.0)
12078 }
12079 HEAPF32[$0 + 4 >> 2] = $4;
12080 $0 = $2;
12081 if ($10) {
12082 $4 = Math_fround(log(+($10 >>> 0) * .6931471805599453 / +($1 >>> 0)) / .6931471805599453)
12083 } else {
12084 $4 = Math_fround(0.0)
12085 }
12086 HEAPF32[$0 + 8 >> 2] = $4;
12087 $0 = $2;
12088 if ($6) {
12089 $4 = Math_fround(log(+($6 >>> 0) * .6931471805599453 / +($1 >>> 0)) / .6931471805599453)
12090 } else {
12091 $4 = Math_fround(0.0)
12092 }
12093 HEAPF32[$0 + 12 >> 2] = $4;
12094 if (!$7) {
12095 HEAPF32[$2 + 16 >> 2] = 0;
12096 return $16 | 0;
12097 }
12098 (wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(log(+($7 >>> 0) * .6931471805599453 / +($1 >>> 0)) / .6931471805599453)), HEAPF32[wasm2js_i32$0 + 16 >> 2] = wasm2js_f32$0;
12099 return $16 | 0;
12100 }
12101
12102 function FLAC__fixed_compute_best_predictor_wide($0, $1, $2) {
12103 $0 = $0 | 0;
12104 $1 = $1 | 0;
12105 $2 = $2 | 0;
12106 var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = Math_fround(0), $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0);
12107 label$1 : {
12108 if (!$1) {
12109 break label$1
12110 }
12111 $5 = HEAP32[$0 + -4 >> 2];
12112 $8 = HEAP32[$0 + -8 >> 2];
12113 $6 = $5 - $8 | 0;
12114 $9 = HEAP32[$0 + -12 >> 2];
12115 $14 = $6 + ($9 - $8 | 0) | 0;
12116 $21 = $14 + ((($9 << 1) - $8 | 0) - HEAP32[$0 + -16 >> 2] | 0) | 0;
12117 $9 = 0;
12118 $8 = 0;
12119 while (1) {
12120 $3 = HEAP32[($20 << 2) + $0 >> 2];
12121 $4 = $3 >> 31;
12122 $4 = $4 ^ $3 + $4;
12123 $7 = $4 + $19 | 0;
12124 if ($7 >>> 0 < $4 >>> 0) {
12125 $18 = $18 + 1 | 0
12126 }
12127 $19 = $7;
12128 $4 = $3 - $5 | 0;
12129 $7 = $4 >> 31;
12130 $7 = $7 ^ $4 + $7;
12131 $5 = $7 + $17 | 0;
12132 if ($5 >>> 0 < $7 >>> 0) {
12133 $15 = $15 + 1 | 0
12134 }
12135 $17 = $5;
12136 $7 = $4 - $6 | 0;
12137 $5 = $7 >> 31;
12138 $5 = $5 ^ $5 + $7;
12139 $6 = $5 + $16 | 0;
12140 if ($6 >>> 0 < $5 >>> 0) {
12141 $10 = $10 + 1 | 0
12142 }
12143 $16 = $6;
12144 $14 = $7 - $14 | 0;
12145 $5 = $14 >> 31;
12146 $5 = $5 ^ $5 + $14;
12147 $6 = $5 + $12 | 0;
12148 if ($6 >>> 0 < $5 >>> 0) {
12149 $8 = $8 + 1 | 0
12150 }
12151 $12 = $6;
12152 $6 = $14 - $21 | 0;
12153 $5 = $6 >> 31;
12154 $5 = $5 ^ $5 + $6;
12155 $6 = $5 + $13 | 0;
12156 if ($6 >>> 0 < $5 >>> 0) {
12157 $9 = $9 + 1 | 0
12158 }
12159 $13 = $6;
12160 $5 = $3;
12161 $6 = $4;
12162 $21 = $14;
12163 $14 = $7;
12164 $20 = $20 + 1 | 0;
12165 if (($20 | 0) != ($1 | 0)) {
12166 continue
12167 }
12168 break;
12169 };
12170 }
12171 $3 = ($10 | 0) == ($15 | 0) & $17 >>> 0 < $16 >>> 0 | $15 >>> 0 < $10 >>> 0;
12172 $4 = $3 ? $17 : $16;
12173 $0 = $4;
12174 $3 = $3 ? $15 : $10;
12175 $4 = ($8 | 0) == ($3 | 0) & $4 >>> 0 < $12 >>> 0 | $3 >>> 0 < $8 >>> 0;
12176 $7 = $4 ? $0 : $12;
12177 $3 = $4 ? $3 : $8;
12178 $4 = ($9 | 0) == ($3 | 0) & $7 >>> 0 < $13 >>> 0 | $3 >>> 0 < $9 >>> 0;
12179 $7 = $4 ? $7 : $13;
12180 $3 = $4 ? $3 : $9;
12181 $0 = 0;
12182 label$4 : {
12183 if (($3 | 0) == ($18 | 0) & $19 >>> 0 < $7 >>> 0 | $18 >>> 0 < $3 >>> 0) {
12184 break label$4
12185 }
12186 $3 = ($8 | 0) == ($10 | 0) & $16 >>> 0 < $12 >>> 0 | $10 >>> 0 < $8 >>> 0;
12187 $4 = $3 ? $16 : $12;
12188 $0 = $4;
12189 $3 = $3 ? $10 : $8;
12190 $4 = ($9 | 0) == ($3 | 0) & $4 >>> 0 < $13 >>> 0 | $3 >>> 0 < $9 >>> 0;
12191 $7 = $4 ? $0 : $13;
12192 $3 = $4 ? $3 : $9;
12193 $0 = 1;
12194 if (($3 | 0) == ($15 | 0) & $17 >>> 0 < $7 >>> 0 | $15 >>> 0 < $3 >>> 0) {
12195 break label$4
12196 }
12197 $0 = ($8 | 0) == ($9 | 0) & $12 >>> 0 < $13 >>> 0 | $8 >>> 0 < $9 >>> 0;
12198 $3 = $0;
12199 $4 = $3 ? $12 : $13;
12200 $0 = $3 ? $8 : $9;
12201 $0 = ($0 | 0) == ($10 | 0) & $16 >>> 0 < $4 >>> 0 | $10 >>> 0 < $0 >>> 0 ? 2 : $3 ? 3 : 4;
12202 }
12203 $6 = $2;
12204 if ($18 | $19) {
12205 $11 = Math_fround(log((+($19 >>> 0) + 4294967296.0 * +($18 >>> 0)) * .6931471805599453 / +($1 >>> 0)) / .6931471805599453)
12206 } else {
12207 $11 = Math_fround(0.0)
12208 }
12209 HEAPF32[$6 >> 2] = $11;
12210 $6 = $2;
12211 if ($15 | $17) {
12212 $11 = Math_fround(log((+($17 >>> 0) + 4294967296.0 * +($15 >>> 0)) * .6931471805599453 / +($1 >>> 0)) / .6931471805599453)
12213 } else {
12214 $11 = Math_fround(0.0)
12215 }
12216 HEAPF32[$6 + 4 >> 2] = $11;
12217 $6 = $2;
12218 if ($10 | $16) {
12219 $11 = Math_fround(log((+($16 >>> 0) + 4294967296.0 * +($10 >>> 0)) * .6931471805599453 / +($1 >>> 0)) / .6931471805599453)
12220 } else {
12221 $11 = Math_fround(0.0)
12222 }
12223 HEAPF32[$6 + 8 >> 2] = $11;
12224 $6 = $2;
12225 if ($8 | $12) {
12226 $11 = Math_fround(log((+($12 >>> 0) + 4294967296.0 * +($8 >>> 0)) * .6931471805599453 / +($1 >>> 0)) / .6931471805599453)
12227 } else {
12228 $11 = Math_fround(0.0)
12229 }
12230 HEAPF32[$6 + 12 >> 2] = $11;
12231 if (!($9 | $13)) {
12232 HEAPF32[$2 + 16 >> 2] = 0;
12233 return $0 | 0;
12234 }
12235 (wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(log((+($13 >>> 0) + 4294967296.0 * +($9 >>> 0)) * .6931471805599453 / +($1 >>> 0)) / .6931471805599453)), HEAPF32[wasm2js_i32$0 + 16 >> 2] = wasm2js_f32$0;
12236 return $0 | 0;
12237 }
12238
12239 function FLAC__fixed_compute_residual($0, $1, $2, $3) {
12240 var $4 = 0, $5 = 0;
12241 label$1 : {
12242 label$2 : {
12243 label$3 : {
12244 switch ($2 | 0) {
12245 case 4:
12246 $2 = 0;
12247 if (($1 | 0) <= 0) {
12248 break label$2
12249 }
12250 while (1) {
12251 $5 = $2 << 2;
12252 $4 = $5 + $0 | 0;
12253 HEAP32[$3 + $5 >> 2] = (HEAP32[$4 + -16 >> 2] + (HEAP32[$4 >> 2] + Math_imul(HEAP32[$4 + -8 >> 2], 6) | 0) | 0) - (HEAP32[$4 + -12 >> 2] + HEAP32[$4 + -4 >> 2] << 2);
12254 $2 = $2 + 1 | 0;
12255 if (($2 | 0) != ($1 | 0)) {
12256 continue
12257 }
12258 break;
12259 };
12260 break label$2;
12261 case 3:
12262 $2 = 0;
12263 if (($1 | 0) <= 0) {
12264 break label$2
12265 }
12266 while (1) {
12267 $5 = $2 << 2;
12268 $4 = $5 + $0 | 0;
12269 HEAP32[$3 + $5 >> 2] = (HEAP32[$4 >> 2] - HEAP32[$4 + -12 >> 2] | 0) + Math_imul(HEAP32[$4 + -8 >> 2] - HEAP32[$4 + -4 >> 2] | 0, 3);
12270 $2 = $2 + 1 | 0;
12271 if (($2 | 0) != ($1 | 0)) {
12272 continue
12273 }
12274 break;
12275 };
12276 break label$2;
12277 case 2:
12278 $2 = 0;
12279 if (($1 | 0) <= 0) {
12280 break label$2
12281 }
12282 while (1) {
12283 $5 = $2 << 2;
12284 $4 = $5 + $0 | 0;
12285 HEAP32[$3 + $5 >> 2] = HEAP32[$4 + -8 >> 2] + (HEAP32[$4 >> 2] - (HEAP32[$4 + -4 >> 2] << 1) | 0);
12286 $2 = $2 + 1 | 0;
12287 if (($2 | 0) != ($1 | 0)) {
12288 continue
12289 }
12290 break;
12291 };
12292 break label$2;
12293 case 0:
12294 break label$1;
12295 case 1:
12296 break label$3;
12297 default:
12298 break label$2;
12299 };
12300 }
12301 $2 = 0;
12302 if (($1 | 0) <= 0) {
12303 break label$2
12304 }
12305 while (1) {
12306 $5 = $2 << 2;
12307 $4 = $5 + $0 | 0;
12308 HEAP32[$3 + $5 >> 2] = HEAP32[$4 >> 2] - HEAP32[$4 + -4 >> 2];
12309 $2 = $2 + 1 | 0;
12310 if (($2 | 0) != ($1 | 0)) {
12311 continue
12312 }
12313 break;
12314 };
12315 }
12316 return;
12317 }
12318 memcpy($3, $0, $1 << 2);
12319 }
12320
12321 function FLAC__fixed_restore_signal($0, $1, $2, $3) {
12322 var $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0;
12323 label$1 : {
12324 label$2 : {
12325 label$3 : {
12326 switch ($2 | 0) {
12327 case 4:
12328 if (($1 | 0) < 1) {
12329 break label$2
12330 }
12331 $5 = HEAP32[$3 + -12 >> 2];
12332 $6 = HEAP32[$3 + -4 >> 2];
12333 $2 = 0;
12334 while (1) {
12335 $8 = $2 << 2;
12336 $7 = $8 + $3 | 0;
12337 $4 = HEAP32[$7 + -8 >> 2];
12338 $6 = ((HEAP32[$0 + $8 >> 2] + Math_imul($4, -6) | 0) - HEAP32[$7 + -16 >> 2] | 0) + ($5 + $6 << 2) | 0;
12339 HEAP32[$7 >> 2] = $6;
12340 $5 = $4;
12341 $2 = $2 + 1 | 0;
12342 if (($2 | 0) != ($1 | 0)) {
12343 continue
12344 }
12345 break;
12346 };
12347 break label$2;
12348 case 3:
12349 if (($1 | 0) < 1) {
12350 break label$2
12351 }
12352 $4 = HEAP32[$3 + -12 >> 2];
12353 $5 = HEAP32[$3 + -4 >> 2];
12354 $2 = 0;
12355 while (1) {
12356 $6 = $2 << 2;
12357 $7 = $6 + $3 | 0;
12358 $8 = HEAP32[$0 + $6 >> 2] + $4 | 0;
12359 $4 = HEAP32[$7 + -8 >> 2];
12360 $5 = $8 + Math_imul($5 - $4 | 0, 3) | 0;
12361 HEAP32[$7 >> 2] = $5;
12362 $2 = $2 + 1 | 0;
12363 if (($2 | 0) != ($1 | 0)) {
12364 continue
12365 }
12366 break;
12367 };
12368 break label$2;
12369 case 2:
12370 if (($1 | 0) < 1) {
12371 break label$2
12372 }
12373 $4 = HEAP32[$3 + -4 >> 2];
12374 $2 = 0;
12375 while (1) {
12376 $5 = $2 << 2;
12377 $6 = $5 + $3 | 0;
12378 $4 = (HEAP32[$0 + $5 >> 2] + ($4 << 1) | 0) - HEAP32[$6 + -8 >> 2] | 0;
12379 HEAP32[$6 >> 2] = $4;
12380 $2 = $2 + 1 | 0;
12381 if (($2 | 0) != ($1 | 0)) {
12382 continue
12383 }
12384 break;
12385 };
12386 break label$2;
12387 case 0:
12388 break label$1;
12389 case 1:
12390 break label$3;
12391 default:
12392 break label$2;
12393 };
12394 }
12395 if (($1 | 0) < 1) {
12396 break label$2
12397 }
12398 $4 = HEAP32[$3 + -4 >> 2];
12399 $2 = 0;
12400 while (1) {
12401 $5 = $2 << 2;
12402 $4 = HEAP32[$5 + $0 >> 2] + $4 | 0;
12403 HEAP32[$3 + $5 >> 2] = $4;
12404 $2 = $2 + 1 | 0;
12405 if (($2 | 0) != ($1 | 0)) {
12406 continue
12407 }
12408 break;
12409 };
12410 }
12411 return;
12412 }
12413 memcpy($3, $0, $1 << 2);
12414 }
12415
12416 function __toread($0) {
12417 var $1 = 0, $2 = 0;
12418 $1 = HEAPU8[$0 + 74 | 0];
12419 HEAP8[$0 + 74 | 0] = $1 + -1 | $1;
12420 if (HEAPU32[$0 + 20 >> 2] > HEAPU32[$0 + 28 >> 2]) {
12421 FUNCTION_TABLE[HEAP32[$0 + 36 >> 2]]($0, 0, 0) | 0
12422 }
12423 HEAP32[$0 + 28 >> 2] = 0;
12424 HEAP32[$0 + 16 >> 2] = 0;
12425 HEAP32[$0 + 20 >> 2] = 0;
12426 $1 = HEAP32[$0 >> 2];
12427 if ($1 & 4) {
12428 HEAP32[$0 >> 2] = $1 | 32;
12429 return -1;
12430 }
12431 $2 = HEAP32[$0 + 44 >> 2] + HEAP32[$0 + 48 >> 2] | 0;
12432 HEAP32[$0 + 8 >> 2] = $2;
12433 HEAP32[$0 + 4 >> 2] = $2;
12434 return $1 << 27 >> 31;
12435 }
12436
12437 function FLAC__stream_decoder_new() {
12438 var $0 = 0, $1 = 0, $2 = 0, $3 = 0, $4 = 0;
12439 $3 = dlcalloc(1, 8);
12440 if ($3) {
12441 $2 = dlcalloc(1, 504);
12442 HEAP32[$3 >> 2] = $2;
12443 if ($2) {
12444 $0 = dlcalloc(1, 6160);
12445 HEAP32[$3 + 4 >> 2] = $0;
12446 if ($0) {
12447 $1 = dlcalloc(1, 44);
12448 HEAP32[$0 + 56 >> 2] = $1;
12449 if ($1) {
12450 HEAP32[$0 + 1128 >> 2] = 16;
12451 $4 = dlmalloc(HEAP32[1364] << 1 & -16);
12452 HEAP32[$0 + 1120 >> 2] = $4;
12453 if ($4) {
12454 HEAP32[$0 + 252 >> 2] = 0;
12455 HEAP32[$0 + 220 >> 2] = 0;
12456 HEAP32[$0 + 224 >> 2] = 0;
12457 $1 = $0 + 3616 | 0;
12458 HEAP32[$1 >> 2] = 0;
12459 HEAP32[$1 + 4 >> 2] = 0;
12460 $1 = $0 + 3608 | 0;
12461 HEAP32[$1 >> 2] = 0;
12462 HEAP32[$1 + 4 >> 2] = 0;
12463 $1 = $0 + 3600 | 0;
12464 HEAP32[$1 >> 2] = 0;
12465 HEAP32[$1 + 4 >> 2] = 0;
12466 $1 = $0 + 3592 | 0;
12467 HEAP32[$1 >> 2] = 0;
12468 HEAP32[$1 + 4 >> 2] = 0;
12469 HEAP32[$0 + 60 >> 2] = 0;
12470 HEAP32[$0 + 64 >> 2] = 0;
12471 HEAP32[$0 + 68 >> 2] = 0;
12472 HEAP32[$0 + 72 >> 2] = 0;
12473 HEAP32[$0 + 76 >> 2] = 0;
12474 HEAP32[$0 + 80 >> 2] = 0;
12475 HEAP32[$0 + 84 >> 2] = 0;
12476 HEAP32[$0 + 88 >> 2] = 0;
12477 HEAP32[$0 + 92 >> 2] = 0;
12478 HEAP32[$0 + 96 >> 2] = 0;
12479 HEAP32[$0 + 100 >> 2] = 0;
12480 HEAP32[$0 + 104 >> 2] = 0;
12481 HEAP32[$0 + 108 >> 2] = 0;
12482 HEAP32[$0 + 112 >> 2] = 0;
12483 HEAP32[$0 + 116 >> 2] = 0;
12484 HEAP32[$0 + 120 >> 2] = 0;
12485 FLAC__format_entropy_coding_method_partitioned_rice_contents_init($0 + 124 | 0);
12486 FLAC__format_entropy_coding_method_partitioned_rice_contents_init($0 + 136 | 0);
12487 FLAC__format_entropy_coding_method_partitioned_rice_contents_init($0 + 148 | 0);
12488 FLAC__format_entropy_coding_method_partitioned_rice_contents_init($0 + 160 | 0);
12489 FLAC__format_entropy_coding_method_partitioned_rice_contents_init($0 + 172 | 0);
12490 FLAC__format_entropy_coding_method_partitioned_rice_contents_init($0 + 184 | 0);
12491 FLAC__format_entropy_coding_method_partitioned_rice_contents_init($0 + 196 | 0);
12492 FLAC__format_entropy_coding_method_partitioned_rice_contents_init($0 + 208 | 0);
12493 HEAP32[$0 + 48 >> 2] = 0;
12494 HEAP32[$0 + 52 >> 2] = 0;
12495 memset($0 + 608 | 0, 512);
12496 HEAP32[$0 + 1124 >> 2] = 0;
12497 HEAP32[$0 + 608 >> 2] = 1;
12498 HEAP32[$0 + 32 >> 2] = 0;
12499 HEAP32[$0 + 24 >> 2] = 0;
12500 HEAP32[$0 + 28 >> 2] = 0;
12501 HEAP32[$0 + 16 >> 2] = 0;
12502 HEAP32[$0 + 20 >> 2] = 0;
12503 HEAP32[$0 + 8 >> 2] = 0;
12504 HEAP32[$0 + 12 >> 2] = 0;
12505 HEAP32[$0 >> 2] = 0;
12506 HEAP32[$0 + 4 >> 2] = 0;
12507 HEAP32[$2 + 28 >> 2] = 0;
12508 FLAC__ogg_decoder_aspect_set_defaults($2 + 32 | 0);
12509 HEAP32[$2 >> 2] = 9;
12510 return $3 | 0;
12511 }
12512 FLAC__bitreader_delete($1);
12513 }
12514 dlfree($0);
12515 }
12516 dlfree($2);
12517 }
12518 dlfree($3);
12519 }
12520 return 0;
12521 }
12522
12523 function FLAC__stream_decoder_delete($0) {
12524 $0 = $0 | 0;
12525 var $1 = 0, $2 = 0;
12526 if ($0) {
12527 FLAC__stream_decoder_finish($0);
12528 $1 = HEAP32[$0 + 4 >> 2];
12529 $2 = HEAP32[$1 + 1120 >> 2];
12530 if ($2) {
12531 dlfree($2);
12532 $1 = HEAP32[$0 + 4 >> 2];
12533 }
12534 FLAC__bitreader_delete(HEAP32[$1 + 56 >> 2]);
12535 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(HEAP32[$0 + 4 >> 2] + 124 | 0);
12536 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(HEAP32[$0 + 4 >> 2] + 136 | 0);
12537 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(HEAP32[$0 + 4 >> 2] + 148 | 0);
12538 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(HEAP32[$0 + 4 >> 2] + 160 | 0);
12539 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(HEAP32[$0 + 4 >> 2] + 172 | 0);
12540 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(HEAP32[$0 + 4 >> 2] + 184 | 0);
12541 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(HEAP32[$0 + 4 >> 2] + 196 | 0);
12542 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(HEAP32[$0 + 4 >> 2] + 208 | 0);
12543 dlfree(HEAP32[$0 + 4 >> 2]);
12544 dlfree(HEAP32[$0 >> 2]);
12545 dlfree($0);
12546 }
12547 }
12548
12549 function FLAC__stream_decoder_finish($0) {
12550 $0 = $0 | 0;
12551 var $1 = 0, $2 = 0, $3 = 0;
12552 $3 = 1;
12553 if (HEAP32[HEAP32[$0 >> 2] >> 2] != 9) {
12554 $1 = HEAP32[$0 + 4 >> 2];
12555 FLAC__MD5Final($1 + 3732 | 0, $1 + 3636 | 0);
12556 dlfree(HEAP32[HEAP32[$0 + 4 >> 2] + 452 >> 2]);
12557 HEAP32[HEAP32[$0 + 4 >> 2] + 452 >> 2] = 0;
12558 $1 = HEAP32[$0 + 4 >> 2];
12559 HEAP32[$1 + 252 >> 2] = 0;
12560 FLAC__bitreader_free(HEAP32[$1 + 56 >> 2]);
12561 $3 = $0 + 4 | 0;
12562 $1 = HEAP32[$0 + 4 >> 2];
12563 $2 = HEAP32[$1 + 60 >> 2];
12564 if ($2) {
12565 dlfree($2 + -16 | 0);
12566 HEAP32[HEAP32[$3 >> 2] + 60 >> 2] = 0;
12567 $1 = HEAP32[$3 >> 2];
12568 }
12569 $2 = HEAP32[$1 + 3592 >> 2];
12570 if ($2) {
12571 dlfree($2);
12572 HEAP32[HEAP32[$3 >> 2] + 92 >> 2] = 0;
12573 HEAP32[HEAP32[$3 >> 2] + 3592 >> 2] = 0;
12574 $1 = HEAP32[$3 >> 2];
12575 }
12576 $2 = HEAP32[$1 - -64 >> 2];
12577 if ($2) {
12578 dlfree($2 + -16 | 0);
12579 HEAP32[HEAP32[$3 >> 2] - -64 >> 2] = 0;
12580 $1 = HEAP32[$3 >> 2];
12581 }
12582 $2 = HEAP32[$1 + 3596 >> 2];
12583 if ($2) {
12584 dlfree($2);
12585 HEAP32[HEAP32[$3 >> 2] + 96 >> 2] = 0;
12586 HEAP32[HEAP32[$3 >> 2] + 3596 >> 2] = 0;
12587 $1 = HEAP32[$3 >> 2];
12588 }
12589 $2 = HEAP32[$1 + 68 >> 2];
12590 if ($2) {
12591 dlfree($2 + -16 | 0);
12592 HEAP32[HEAP32[$3 >> 2] + 68 >> 2] = 0;
12593 $1 = HEAP32[$3 >> 2];
12594 }
12595 $2 = HEAP32[$1 + 3600 >> 2];
12596 if ($2) {
12597 dlfree($2);
12598 HEAP32[HEAP32[$3 >> 2] + 100 >> 2] = 0;
12599 HEAP32[HEAP32[$3 >> 2] + 3600 >> 2] = 0;
12600 $1 = HEAP32[$3 >> 2];
12601 }
12602 $2 = HEAP32[$1 + 72 >> 2];
12603 if ($2) {
12604 dlfree($2 + -16 | 0);
12605 HEAP32[HEAP32[$3 >> 2] + 72 >> 2] = 0;
12606 $1 = HEAP32[$3 >> 2];
12607 }
12608 $2 = HEAP32[$1 + 3604 >> 2];
12609 if ($2) {
12610 dlfree($2);
12611 HEAP32[HEAP32[$3 >> 2] + 104 >> 2] = 0;
12612 HEAP32[HEAP32[$3 >> 2] + 3604 >> 2] = 0;
12613 $1 = HEAP32[$3 >> 2];
12614 }
12615 $2 = HEAP32[$1 + 76 >> 2];
12616 if ($2) {
12617 dlfree($2 + -16 | 0);
12618 HEAP32[HEAP32[$3 >> 2] + 76 >> 2] = 0;
12619 $1 = HEAP32[$3 >> 2];
12620 }
12621 $2 = HEAP32[$1 + 3608 >> 2];
12622 if ($2) {
12623 dlfree($2);
12624 HEAP32[HEAP32[$3 >> 2] + 108 >> 2] = 0;
12625 HEAP32[HEAP32[$3 >> 2] + 3608 >> 2] = 0;
12626 $1 = HEAP32[$3 >> 2];
12627 }
12628 $2 = HEAP32[$1 + 80 >> 2];
12629 if ($2) {
12630 dlfree($2 + -16 | 0);
12631 HEAP32[HEAP32[$3 >> 2] + 80 >> 2] = 0;
12632 $1 = HEAP32[$3 >> 2];
12633 }
12634 $2 = HEAP32[$1 + 3612 >> 2];
12635 if ($2) {
12636 dlfree($2);
12637 HEAP32[HEAP32[$3 >> 2] + 112 >> 2] = 0;
12638 HEAP32[HEAP32[$3 >> 2] + 3612 >> 2] = 0;
12639 $1 = HEAP32[$3 >> 2];
12640 }
12641 $2 = HEAP32[$1 + 84 >> 2];
12642 if ($2) {
12643 dlfree($2 + -16 | 0);
12644 HEAP32[HEAP32[$3 >> 2] + 84 >> 2] = 0;
12645 $1 = HEAP32[$3 >> 2];
12646 }
12647 $2 = HEAP32[$1 + 3616 >> 2];
12648 if ($2) {
12649 dlfree($2);
12650 HEAP32[HEAP32[$3 >> 2] + 116 >> 2] = 0;
12651 HEAP32[HEAP32[$3 >> 2] + 3616 >> 2] = 0;
12652 $1 = HEAP32[$3 >> 2];
12653 }
12654 $2 = HEAP32[$1 + 88 >> 2];
12655 if ($2) {
12656 dlfree($2 + -16 | 0);
12657 HEAP32[HEAP32[$3 >> 2] + 88 >> 2] = 0;
12658 $1 = HEAP32[$3 >> 2];
12659 }
12660 $2 = HEAP32[$1 + 3620 >> 2];
12661 if ($2) {
12662 dlfree($2);
12663 HEAP32[HEAP32[$3 >> 2] + 120 >> 2] = 0;
12664 HEAP32[HEAP32[$3 >> 2] + 3620 >> 2] = 0;
12665 $1 = HEAP32[$3 >> 2];
12666 }
12667 HEAP32[$1 + 220 >> 2] = 0;
12668 HEAP32[$1 + 224 >> 2] = 0;
12669 if (HEAP32[$1 >> 2]) {
12670 $1 = HEAP32[$0 >> 2] + 32 | 0;
12671 ogg_sync_clear($1 + 368 | 0);
12672 ogg_stream_clear($1 + 8 | 0);
12673 $1 = HEAP32[$0 + 4 >> 2];
12674 }
12675 $2 = HEAP32[$1 + 52 >> 2];
12676 if ($2) {
12677 if (($2 | 0) != HEAP32[1887]) {
12678 fclose($2);
12679 $1 = HEAP32[$3 >> 2];
12680 }
12681 HEAP32[$1 + 52 >> 2] = 0;
12682 }
12683 $3 = 1;
12684 if (HEAP32[$1 + 3624 >> 2]) {
12685 $3 = !memcmp($1 + 312 | 0, $1 + 3732 | 0, 16)
12686 }
12687 HEAP32[$1 + 48 >> 2] = 0;
12688 HEAP32[$1 + 3632 >> 2] = 0;
12689 memset($1 + 608 | 0, 512);
12690 HEAP32[$1 + 32 >> 2] = 0;
12691 HEAP32[$1 + 24 >> 2] = 0;
12692 HEAP32[$1 + 28 >> 2] = 0;
12693 HEAP32[$1 + 16 >> 2] = 0;
12694 HEAP32[$1 + 20 >> 2] = 0;
12695 HEAP32[$1 + 8 >> 2] = 0;
12696 HEAP32[$1 + 12 >> 2] = 0;
12697 HEAP32[$1 >> 2] = 0;
12698 HEAP32[$1 + 4 >> 2] = 0;
12699 $1 = HEAP32[$0 + 4 >> 2];
12700 HEAP32[$1 + 1124 >> 2] = 0;
12701 HEAP32[$1 + 608 >> 2] = 1;
12702 $1 = HEAP32[$0 >> 2];
12703 HEAP32[$1 + 28 >> 2] = 0;
12704 FLAC__ogg_decoder_aspect_set_defaults($1 + 32 | 0);
12705 HEAP32[HEAP32[$0 >> 2] >> 2] = 9;
12706 }
12707 return $3 | 0;
12708 }
12709
12710 function FLAC__stream_decoder_init_stream($0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
12711 $0 = $0 | 0;
12712 $1 = $1 | 0;
12713 $2 = $2 | 0;
12714 $3 = $3 | 0;
12715 $4 = $4 | 0;
12716 $5 = $5 | 0;
12717 $6 = $6 | 0;
12718 $7 = $7 | 0;
12719 $8 = $8 | 0;
12720 $9 = $9 | 0;
12721 return init_stream_internal_($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, 0) | 0;
12722 }
12723
12724 function init_stream_internal_($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10) {
12725 var $11 = 0, $12 = 0;
12726 $11 = 5;
12727 label$1 : {
12728 $12 = HEAP32[$0 >> 2];
12729 label$2 : {
12730 if (HEAP32[$12 >> 2] != 9) {
12731 break label$2
12732 }
12733 $11 = 2;
12734 if (!$8 | (!$1 | !$6)) {
12735 break label$2
12736 }
12737 if ($2) {
12738 if (!$5 | (!$3 | !$4)) {
12739 break label$2
12740 }
12741 }
12742 $11 = HEAP32[$0 + 4 >> 2];
12743 HEAP32[$11 >> 2] = $10;
12744 if ($10) {
12745 if (!FLAC__ogg_decoder_aspect_init($12 + 32 | 0)) {
12746 break label$1
12747 }
12748 $11 = HEAP32[$0 + 4 >> 2];
12749 }
12750 FLAC__cpu_info($11 + 3524 | 0);
12751 $10 = HEAP32[$0 + 4 >> 2];
12752 HEAP32[$10 + 44 >> 2] = 5;
12753 HEAP32[$10 + 40 >> 2] = 6;
12754 HEAP32[$10 + 36 >> 2] = 5;
12755 if (!FLAC__bitreader_init(HEAP32[$10 + 56 >> 2], $0)) {
12756 HEAP32[HEAP32[$0 >> 2] >> 2] = 8;
12757 return 3;
12758 }
12759 $10 = HEAP32[$0 + 4 >> 2];
12760 HEAP32[$10 + 48 >> 2] = $9;
12761 HEAP32[$10 + 32 >> 2] = $8;
12762 HEAP32[$10 + 28 >> 2] = $7;
12763 HEAP32[$10 + 24 >> 2] = $6;
12764 HEAP32[$10 + 20 >> 2] = $5;
12765 HEAP32[$10 + 16 >> 2] = $4;
12766 HEAP32[$10 + 12 >> 2] = $3;
12767 HEAP32[$10 + 8 >> 2] = $2;
12768 HEAP32[$10 + 4 >> 2] = $1;
12769 HEAP32[$10 + 3520 >> 2] = 0;
12770 HEAP32[$10 + 248 >> 2] = 0;
12771 HEAP32[$10 + 240 >> 2] = 0;
12772 HEAP32[$10 + 244 >> 2] = 0;
12773 HEAP32[$10 + 228 >> 2] = 0;
12774 HEAP32[$10 + 232 >> 2] = 0;
12775 HEAP32[$10 + 3624 >> 2] = HEAP32[HEAP32[$0 >> 2] + 28 >> 2];
12776 HEAP32[$10 + 3628 >> 2] = 1;
12777 HEAP32[$10 + 3632 >> 2] = 0;
12778 $11 = FLAC__stream_decoder_reset($0) ? 0 : 3;
12779 }
12780 return $11;
12781 }
12782 HEAP32[HEAP32[$0 >> 2] + 4 >> 2] = 4;
12783 return 4;
12784 }
12785
12786 function read_callback_($0, $1, $2) {
12787 $0 = $0 | 0;
12788 $1 = $1 | 0;
12789 $2 = $2 | 0;
12790 var $3 = 0, $4 = 0;
12791 label$1 : {
12792 $3 = HEAP32[$2 + 4 >> 2];
12793 if (HEAP32[$3 >> 2]) {
12794 break label$1
12795 }
12796 $4 = HEAP32[$3 + 20 >> 2];
12797 if (!$4) {
12798 break label$1
12799 }
12800 if (!FUNCTION_TABLE[$4]($2, HEAP32[$3 + 48 >> 2])) {
12801 break label$1
12802 }
12803 HEAP32[$1 >> 2] = 0;
12804 HEAP32[HEAP32[$2 >> 2] >> 2] = 4;
12805 return 0;
12806 }
12807 label$2 : {
12808 label$3 : {
12809 if (HEAP32[$1 >> 2]) {
12810 $3 = HEAP32[$2 + 4 >> 2];
12811 if (!(!HEAP32[$3 + 3632 >> 2] | HEAPU32[$3 + 6152 >> 2] < 21)) {
12812 HEAP32[HEAP32[$2 >> 2] >> 2] = 7;
12813 break label$3;
12814 }
12815 label$6 : {
12816 label$7 : {
12817 label$8 : {
12818 label$9 : {
12819 if (HEAP32[$3 >> 2]) {
12820 $4 = 0;
12821 switch (FLAC__ogg_decoder_aspect_read_callback_wrapper(HEAP32[$2 >> 2] + 32 | 0, $0, $1, $2, HEAP32[$3 + 48 >> 2]) | 0) {
12822 case 0:
12823 case 2:
12824 break label$7;
12825 case 1:
12826 break label$8;
12827 default:
12828 break label$9;
12829 };
12830 }
12831 $4 = FUNCTION_TABLE[HEAP32[$3 + 4 >> 2]]($2, $0, $1, HEAP32[$3 + 48 >> 2]) | 0;
12832 if (($4 | 0) != 2) {
12833 break label$7
12834 }
12835 }
12836 HEAP32[HEAP32[$2 >> 2] >> 2] = 7;
12837 break label$3;
12838 }
12839 $0 = 1;
12840 if (!HEAP32[$1 >> 2]) {
12841 break label$6
12842 }
12843 break label$2;
12844 }
12845 $0 = 1;
12846 if (HEAP32[$1 >> 2]) {
12847 break label$2
12848 }
12849 if (($4 | 0) == 1) {
12850 break label$6
12851 }
12852 $1 = HEAP32[$2 + 4 >> 2];
12853 if (HEAP32[$1 >> 2]) {
12854 break label$2
12855 }
12856 $3 = HEAP32[$1 + 20 >> 2];
12857 if (!$3) {
12858 break label$2
12859 }
12860 if (!FUNCTION_TABLE[$3]($2, HEAP32[$1 + 48 >> 2])) {
12861 break label$2
12862 }
12863 }
12864 HEAP32[HEAP32[$2 >> 2] >> 2] = 4;
12865 break label$3;
12866 }
12867 HEAP32[HEAP32[$2 >> 2] >> 2] = 7;
12868 }
12869 $0 = 0;
12870 }
12871 return $0 | 0;
12872 }
12873
12874 function FLAC__stream_decoder_reset($0) {
12875 $0 = $0 | 0;
12876 var $1 = 0, $2 = 0, $3 = 0;
12877 $1 = HEAP32[$0 + 4 >> 2];
12878 label$1 : {
12879 if (HEAP32[HEAP32[$0 >> 2] >> 2] == 9 ? !HEAP32[$1 + 3628 >> 2] : 0) {
12880 break label$1
12881 }
12882 HEAP32[$1 + 3624 >> 2] = 0;
12883 HEAP32[$1 + 240 >> 2] = 0;
12884 HEAP32[$1 + 244 >> 2] = 0;
12885 if (HEAP32[$1 >> 2]) {
12886 $1 = HEAP32[$0 >> 2] + 32 | 0;
12887 ogg_stream_reset($1 + 8 | 0);
12888 ogg_sync_reset($1 + 368 | 0);
12889 HEAP32[$1 + 408 >> 2] = 0;
12890 HEAP32[$1 + 412 >> 2] = 0;
12891 $1 = HEAP32[$0 + 4 >> 2];
12892 }
12893 $1 = HEAP32[$1 + 56 >> 2];
12894 HEAP32[$1 + 8 >> 2] = 0;
12895 HEAP32[$1 + 12 >> 2] = 0;
12896 HEAP32[$1 + 16 >> 2] = 0;
12897 HEAP32[$1 + 20 >> 2] = 0;
12898 $1 = 1;
12899 $2 = HEAP32[$0 >> 2];
12900 if (!$1) {
12901 HEAP32[$2 >> 2] = 8;
12902 return 0;
12903 }
12904 HEAP32[$2 >> 2] = 2;
12905 $1 = HEAP32[$0 + 4 >> 2];
12906 if (HEAP32[$1 >> 2]) {
12907 FLAC__ogg_decoder_aspect_reset($2 + 32 | 0);
12908 $1 = HEAP32[$0 + 4 >> 2];
12909 }
12910 label$6 : {
12911 if (!HEAP32[$1 + 3628 >> 2]) {
12912 $2 = 0;
12913 if (HEAP32[$1 + 52 >> 2] == HEAP32[1887]) {
12914 break label$1
12915 }
12916 $3 = HEAP32[$1 + 8 >> 2];
12917 if (!$3) {
12918 break label$6
12919 }
12920 if ((FUNCTION_TABLE[$3]($0, 0, 0, HEAP32[$1 + 48 >> 2]) | 0) == 1) {
12921 break label$1
12922 }
12923 $1 = HEAP32[$0 + 4 >> 2];
12924 break label$6;
12925 }
12926 HEAP32[$1 + 3628 >> 2] = 0;
12927 }
12928 HEAP32[HEAP32[$0 >> 2] >> 2] = 0;
12929 HEAP32[$1 + 248 >> 2] = 0;
12930 dlfree(HEAP32[$1 + 452 >> 2]);
12931 HEAP32[HEAP32[$0 + 4 >> 2] + 452 >> 2] = 0;
12932 $1 = HEAP32[$0 + 4 >> 2];
12933 HEAP32[$1 + 252 >> 2] = 0;
12934 HEAP32[$1 + 3624 >> 2] = HEAP32[HEAP32[$0 >> 2] + 28 >> 2];
12935 HEAP32[$1 + 228 >> 2] = 0;
12936 HEAP32[$1 + 232 >> 2] = 0;
12937 FLAC__MD5Init($1 + 3636 | 0);
12938 $0 = HEAP32[$0 + 4 >> 2];
12939 HEAP32[$0 + 6152 >> 2] = 0;
12940 HEAP32[$0 + 6136 >> 2] = 0;
12941 HEAP32[$0 + 6140 >> 2] = 0;
12942 $2 = 1;
12943 }
12944 return $2 | 0;
12945 }
12946
12947 function FLAC__stream_decoder_init_ogg_stream($0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
12948 $0 = $0 | 0;
12949 $1 = $1 | 0;
12950 $2 = $2 | 0;
12951 $3 = $3 | 0;
12952 $4 = $4 | 0;
12953 $5 = $5 | 0;
12954 $6 = $6 | 0;
12955 $7 = $7 | 0;
12956 $8 = $8 | 0;
12957 $9 = $9 | 0;
12958 return init_stream_internal_($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, 1) | 0;
12959 }
12960
12961 function FLAC__stream_decoder_set_ogg_serial_number($0, $1) {
12962 $0 = $0 | 0;
12963 $1 = $1 | 0;
12964 $0 = HEAP32[$0 >> 2];
12965 if (HEAP32[$0 >> 2] == 9) {
12966 $0 = $0 + 32 | 0;
12967 HEAP32[$0 + 4 >> 2] = $1;
12968 HEAP32[$0 >> 2] = 0;
12969 $0 = 1;
12970 } else {
12971 $0 = 0
12972 }
12973 return $0 | 0;
12974 }
12975
12976 function FLAC__stream_decoder_set_md5_checking($0, $1) {
12977 $0 = $0 | 0;
12978 $1 = $1 | 0;
12979 $0 = HEAP32[$0 >> 2];
12980 if (HEAP32[$0 >> 2] == 9) {
12981 HEAP32[$0 + 28 >> 2] = $1;
12982 $0 = 1;
12983 } else {
12984 $0 = 0
12985 }
12986 return $0 | 0;
12987 }
12988
12989 function FLAC__stream_decoder_set_metadata_respond($0, $1) {
12990 $0 = $0 | 0;
12991 $1 = $1 | 0;
12992 var $2 = 0;
12993 label$1 : {
12994 if (HEAP32[HEAP32[$0 >> 2] >> 2] != 9 | $1 >>> 0 > 126) {
12995 break label$1
12996 }
12997 $2 = 1;
12998 $0 = HEAP32[$0 + 4 >> 2];
12999 HEAP32[($0 + ($1 << 2) | 0) + 608 >> 2] = 1;
13000 if (($1 | 0) != 2) {
13001 break label$1
13002 }
13003 HEAP32[$0 + 1124 >> 2] = 0;
13004 }
13005 return $2 | 0;
13006 }
13007
13008 function FLAC__stream_decoder_set_metadata_respond_application($0, $1) {
13009 $0 = $0 | 0;
13010 $1 = $1 | 0;
13011 var $2 = 0, $3 = 0, $4 = 0;
13012 $2 = 0;
13013 label$1 : {
13014 if (HEAP32[HEAP32[$0 >> 2] >> 2] != 9) {
13015 break label$1
13016 }
13017 $3 = HEAP32[$0 + 4 >> 2];
13018 $2 = 1;
13019 if (HEAP32[$3 + 616 >> 2]) {
13020 break label$1
13021 }
13022 $2 = HEAP32[$3 + 1120 >> 2];
13023 label$2 : {
13024 $4 = HEAP32[$3 + 1124 >> 2];
13025 label$3 : {
13026 if (($4 | 0) != HEAP32[$3 + 1128 >> 2]) {
13027 $3 = $2;
13028 break label$3;
13029 }
13030 label$5 : {
13031 if (!$4) {
13032 $3 = dlrealloc($2, 0);
13033 break label$5;
13034 }
13035 if ($4 + $4 >>> 0 >= $4 >>> 0) {
13036 $3 = dlrealloc($2, $4 << 1);
13037 if ($3) {
13038 break label$5
13039 }
13040 dlfree($2);
13041 $3 = HEAP32[$0 + 4 >> 2];
13042 }
13043 HEAP32[$3 + 1120 >> 2] = 0;
13044 break label$2;
13045 }
13046 $2 = HEAP32[$0 + 4 >> 2];
13047 HEAP32[$2 + 1120 >> 2] = $3;
13048 if (!$3) {
13049 break label$2
13050 }
13051 HEAP32[$2 + 1128 >> 2] = HEAP32[$2 + 1128 >> 2] << 1;
13052 $4 = HEAP32[$2 + 1124 >> 2];
13053 }
13054 $2 = $3;
13055 $3 = HEAP32[1364] >>> 3 | 0;
13056 memcpy($2 + Math_imul($3, $4) | 0, $1, $3);
13057 $0 = HEAP32[$0 + 4 >> 2];
13058 HEAP32[$0 + 1124 >> 2] = HEAP32[$0 + 1124 >> 2] + 1;
13059 return 1;
13060 }
13061 HEAP32[HEAP32[$0 >> 2] >> 2] = 8;
13062 $2 = 0;
13063 }
13064 return $2 | 0;
13065 }
13066
13067 function FLAC__stream_decoder_set_metadata_respond_all($0) {
13068 $0 = $0 | 0;
13069 var $1 = 0;
13070 if (HEAP32[HEAP32[$0 >> 2] >> 2] == 9) {
13071 $1 = HEAP32[$0 + 4 >> 2];
13072 $0 = 0;
13073 while (1) {
13074 HEAP32[($1 + ($0 << 2) | 0) + 608 >> 2] = 1;
13075 $0 = $0 + 1 | 0;
13076 if (($0 | 0) != 128) {
13077 continue
13078 }
13079 break;
13080 };
13081 HEAP32[$1 + 1124 >> 2] = 0;
13082 $0 = 1;
13083 } else {
13084 $0 = 0
13085 }
13086 return $0 | 0;
13087 }
13088
13089 function FLAC__stream_decoder_set_metadata_ignore($0, $1) {
13090 $0 = $0 | 0;
13091 $1 = $1 | 0;
13092 var $2 = 0;
13093 label$1 : {
13094 if (HEAP32[HEAP32[$0 >> 2] >> 2] != 9 | $1 >>> 0 > 126) {
13095 break label$1
13096 }
13097 $0 = HEAP32[$0 + 4 >> 2];
13098 HEAP32[($0 + ($1 << 2) | 0) + 608 >> 2] = 0;
13099 $2 = 1;
13100 if (($1 | 0) != 2) {
13101 break label$1
13102 }
13103 HEAP32[$0 + 1124 >> 2] = 0;
13104 }
13105 return $2 | 0;
13106 }
13107
13108 function FLAC__stream_decoder_set_metadata_ignore_application($0, $1) {
13109 $0 = $0 | 0;
13110 $1 = $1 | 0;
13111 var $2 = 0, $3 = 0, $4 = 0;
13112 if (HEAP32[HEAP32[$0 >> 2] >> 2] == 9) {
13113 $2 = HEAP32[$0 + 4 >> 2];
13114 if (!HEAP32[$2 + 616 >> 2]) {
13115 return 1
13116 }
13117 $3 = HEAP32[$2 + 1120 >> 2];
13118 label$3 : {
13119 $4 = HEAP32[$2 + 1124 >> 2];
13120 label$4 : {
13121 if (($4 | 0) != HEAP32[$2 + 1128 >> 2]) {
13122 $2 = $3;
13123 break label$4;
13124 }
13125 label$6 : {
13126 if (!$4) {
13127 $2 = dlrealloc($3, 0);
13128 break label$6;
13129 }
13130 if ($4 + $4 >>> 0 >= $4 >>> 0) {
13131 $2 = dlrealloc($3, $4 << 1);
13132 if ($2) {
13133 break label$6
13134 }
13135 dlfree($3);
13136 $2 = HEAP32[$0 + 4 >> 2];
13137 }
13138 HEAP32[$2 + 1120 >> 2] = 0;
13139 break label$3;
13140 }
13141 $3 = HEAP32[$0 + 4 >> 2];
13142 HEAP32[$3 + 1120 >> 2] = $2;
13143 if (!$2) {
13144 break label$3
13145 }
13146 HEAP32[$3 + 1128 >> 2] = HEAP32[$3 + 1128 >> 2] << 1;
13147 $4 = HEAP32[$3 + 1124 >> 2];
13148 }
13149 $3 = $2;
13150 $2 = HEAP32[1364] >>> 3 | 0;
13151 memcpy($3 + Math_imul($2, $4) | 0, $1, $2);
13152 $0 = HEAP32[$0 + 4 >> 2];
13153 HEAP32[$0 + 1124 >> 2] = HEAP32[$0 + 1124 >> 2] + 1;
13154 return 1;
13155 }
13156 HEAP32[HEAP32[$0 >> 2] >> 2] = 8;
13157 }
13158 return 0;
13159 }
13160
13161 function FLAC__stream_decoder_set_metadata_ignore_all($0) {
13162 $0 = $0 | 0;
13163 if (HEAP32[HEAP32[$0 >> 2] >> 2] == 9) {
13164 memset(HEAP32[$0 + 4 >> 2] + 608 | 0, 512);
13165 HEAP32[HEAP32[$0 + 4 >> 2] + 1124 >> 2] = 0;
13166 $0 = 1;
13167 } else {
13168 $0 = 0
13169 }
13170 return $0 | 0;
13171 }
13172
13173 function FLAC__stream_decoder_get_state($0) {
13174 $0 = $0 | 0;
13175 return HEAP32[HEAP32[$0 >> 2] >> 2];
13176 }
13177
13178 function FLAC__stream_decoder_get_md5_checking($0) {
13179 $0 = $0 | 0;
13180 return HEAP32[HEAP32[$0 >> 2] + 28 >> 2];
13181 }
13182
13183 function FLAC__stream_decoder_process_single($0) {
13184 $0 = $0 | 0;
13185 var $1 = 0, $2 = 0, $3 = 0;
13186 $1 = global$0 - 16 | 0;
13187 global$0 = $1;
13188 $2 = 1;
13189 label$1 : {
13190 while (1) {
13191 label$3 : {
13192 label$4 : {
13193 switch (HEAP32[HEAP32[$0 >> 2] >> 2]) {
13194 case 0:
13195 if (find_metadata_($0)) {
13196 continue
13197 }
13198 $2 = 0;
13199 break label$3;
13200 case 1:
13201 $3 = (read_metadata_($0) | 0) != 0;
13202 break label$1;
13203 case 2:
13204 if (frame_sync_($0)) {
13205 continue
13206 }
13207 break label$3;
13208 case 4:
13209 case 7:
13210 break label$3;
13211 case 3:
13212 break label$4;
13213 default:
13214 break label$1;
13215 };
13216 }
13217 if (!read_frame_($0, $1 + 12 | 0)) {
13218 $2 = 0;
13219 break label$3;
13220 }
13221 if (!HEAP32[$1 + 12 >> 2]) {
13222 continue
13223 }
13224 }
13225 break;
13226 };
13227 $3 = $2;
13228 }
13229 global$0 = $1 + 16 | 0;
13230 return $3 | 0;
13231 }
13232
13233 function find_metadata_($0) {
13234 var $1 = 0, $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0;
13235 $2 = global$0 - 16 | 0;
13236 global$0 = $2;
13237 $5 = 1;
13238 label$1 : {
13239 while (1) {
13240 $1 = 0;
13241 label$3 : {
13242 while (1) {
13243 $6 = HEAP32[$0 + 4 >> 2];
13244 label$5 : {
13245 if (HEAP32[$6 + 3520 >> 2]) {
13246 $4 = HEAPU8[$6 + 3590 | 0];
13247 HEAP32[$2 + 8 >> 2] = $4;
13248 HEAP32[$6 + 3520 >> 2] = 0;
13249 break label$5;
13250 }
13251 if (!FLAC__bitreader_read_raw_uint32(HEAP32[$6 + 56 >> 2], $2 + 8 | 0, 8)) {
13252 $3 = 0;
13253 break label$1;
13254 }
13255 $4 = HEAP32[$2 + 8 >> 2];
13256 }
13257 if (HEAPU8[$3 + 5409 | 0] == ($4 | 0)) {
13258 $3 = $3 + 1 | 0;
13259 $1 = 1;
13260 break label$3;
13261 }
13262 $3 = 0;
13263 if (($1 | 0) == 3) {
13264 break label$1
13265 }
13266 if (HEAPU8[$1 + 7552 | 0] == ($4 | 0)) {
13267 $1 = $1 + 1 | 0;
13268 if (($1 | 0) != 3) {
13269 continue
13270 }
13271 label$10 : {
13272 label$11 : {
13273 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$0 + 4 >> 2] + 56 >> 2], $2 + 12 | 0, 24)) {
13274 break label$11
13275 }
13276 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$0 + 4 >> 2] + 56 >> 2], $2 + 12 | 0, 8)) {
13277 break label$11
13278 }
13279 $4 = HEAP32[$2 + 12 >> 2];
13280 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$0 + 4 >> 2] + 56 >> 2], $2 + 12 | 0, 8)) {
13281 break label$11
13282 }
13283 $6 = HEAP32[$2 + 12 >> 2];
13284 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$0 + 4 >> 2] + 56 >> 2], $2 + 12 | 0, 8)) {
13285 break label$11
13286 }
13287 $7 = HEAP32[$2 + 12 >> 2];
13288 if (FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$0 + 4 >> 2] + 56 >> 2], $2 + 12 | 0, 8)) {
13289 break label$10
13290 }
13291 }
13292 break label$1;
13293 }
13294 if (FLAC__bitreader_skip_byte_block_aligned_no_crc(HEAP32[HEAP32[$0 + 4 >> 2] + 56 >> 2], HEAP32[$2 + 12 >> 2] & 127 | ($7 << 7 & 16256 | ($6 & 127 | $4 << 7 & 16256) << 14))) {
13295 continue
13296 }
13297 break label$1;
13298 }
13299 break;
13300 };
13301 label$12 : {
13302 if (($4 | 0) != 255) {
13303 break label$12
13304 }
13305 HEAP8[HEAP32[$0 + 4 >> 2] + 3588 | 0] = 255;
13306 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$0 + 4 >> 2] + 56 >> 2], $2 + 8 | 0, 8)) {
13307 break label$1
13308 }
13309 $1 = HEAP32[$2 + 8 >> 2];
13310 if (($1 | 0) == 255) {
13311 $1 = HEAP32[$0 + 4 >> 2];
13312 HEAP32[$1 + 3520 >> 2] = 1;
13313 HEAP8[$1 + 3590 | 0] = 255;
13314 break label$12;
13315 }
13316 if (($1 & -2) != 248) {
13317 break label$12
13318 }
13319 HEAP8[HEAP32[$0 + 4 >> 2] + 3589 | 0] = $1;
13320 HEAP32[HEAP32[$0 >> 2] >> 2] = 3;
13321 $3 = 1;
13322 break label$1;
13323 }
13324 $1 = 0;
13325 if (!$5) {
13326 break label$3
13327 }
13328 $5 = HEAP32[$0 + 4 >> 2];
13329 $1 = 0;
13330 if (HEAP32[$5 + 3632 >> 2]) {
13331 break label$3
13332 }
13333 FUNCTION_TABLE[HEAP32[$5 + 32 >> 2]]($0, 0, HEAP32[$5 + 48 >> 2]);
13334 $1 = 0;
13335 }
13336 $5 = $1;
13337 if ($3 >>> 0 < 4) {
13338 continue
13339 }
13340 break;
13341 };
13342 $3 = 1;
13343 HEAP32[HEAP32[$0 >> 2] >> 2] = 1;
13344 }
13345 global$0 = $2 + 16 | 0;
13346 return $3;
13347 }
13348
13349 function read_metadata_($0) {
13350 var $1 = 0, $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0;
13351 $7 = global$0 - 192 | 0;
13352 global$0 = $7;
13353 label$1 : {
13354 label$2 : {
13355 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$0 + 4 >> 2] + 56 >> 2], $7 + 184 | 0, HEAP32[1391])) {
13356 break label$2
13357 }
13358 $15 = HEAP32[$7 + 184 >> 2];
13359 $4 = $0 + 4 | 0;
13360 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $7 + 180 | 0, HEAP32[1392])) {
13361 break label$1
13362 }
13363 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $7 + 176 | 0, HEAP32[1393])) {
13364 break label$1
13365 }
13366 $6 = ($15 | 0) != 0;
13367 label$3 : {
13368 label$4 : {
13369 label$5 : {
13370 label$6 : {
13371 label$7 : {
13372 $2 = HEAP32[$7 + 180 >> 2];
13373 switch ($2 | 0) {
13374 case 3:
13375 break label$6;
13376 case 0:
13377 break label$7;
13378 default:
13379 break label$5;
13380 };
13381 }
13382 $3 = HEAP32[$7 + 176 >> 2];
13383 $2 = 0;
13384 $1 = HEAP32[$4 >> 2];
13385 HEAP32[$1 + 256 >> 2] = 0;
13386 HEAP32[$1 + 264 >> 2] = $3;
13387 HEAP32[$1 + 260 >> 2] = $6;
13388 $5 = HEAP32[$1 + 56 >> 2];
13389 $1 = HEAP32[1356];
13390 if (!FLAC__bitreader_read_raw_uint32($5, $7, $1)) {
13391 break label$1
13392 }
13393 HEAP32[HEAP32[$4 >> 2] + 272 >> 2] = HEAP32[$7 >> 2];
13394 $5 = HEAP32[1357];
13395 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $7, $5)) {
13396 break label$1
13397 }
13398 HEAP32[HEAP32[$4 >> 2] + 276 >> 2] = HEAP32[$7 >> 2];
13399 $6 = HEAP32[1358];
13400 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $7, $6)) {
13401 break label$1
13402 }
13403 HEAP32[HEAP32[$4 >> 2] + 280 >> 2] = HEAP32[$7 >> 2];
13404 $8 = HEAP32[1359];
13405 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $7, $8)) {
13406 break label$1
13407 }
13408 HEAP32[HEAP32[$4 >> 2] + 284 >> 2] = HEAP32[$7 >> 2];
13409 $9 = HEAP32[1360];
13410 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $7, $9)) {
13411 break label$1
13412 }
13413 HEAP32[HEAP32[$4 >> 2] + 288 >> 2] = HEAP32[$7 >> 2];
13414 $10 = HEAP32[1361];
13415 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $7, $10)) {
13416 break label$1
13417 }
13418 HEAP32[HEAP32[$4 >> 2] + 292 >> 2] = HEAP32[$7 >> 2] + 1;
13419 $11 = HEAP32[1362];
13420 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $7, $11)) {
13421 break label$1
13422 }
13423 HEAP32[HEAP32[$4 >> 2] + 296 >> 2] = HEAP32[$7 >> 2] + 1;
13424 $12 = HEAP32[$4 >> 2];
13425 $13 = HEAP32[$12 + 56 >> 2];
13426 $14 = $12 + 304 | 0;
13427 $12 = HEAP32[1363];
13428 if (!FLAC__bitreader_read_raw_uint64($13, $14, $12)) {
13429 break label$1
13430 }
13431 $13 = HEAP32[$4 >> 2];
13432 if (!FLAC__bitreader_read_byte_block_aligned_no_crc(HEAP32[$13 + 56 >> 2], $13 + 312 | 0, 16)) {
13433 break label$1
13434 }
13435 if (!FLAC__bitreader_skip_byte_block_aligned_no_crc(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $3 - (($12 + ($11 + ($10 + ($9 + ($8 + ($6 + ($1 + $5 | 0) | 0) | 0) | 0) | 0) | 0) | 0) + 128 >>> 3 | 0) | 0)) {
13436 break label$2
13437 }
13438 $1 = HEAP32[$4 >> 2];
13439 HEAP32[$1 + 248 >> 2] = 1;
13440 if (!memcmp($1 + 312 | 0, 7555, 16)) {
13441 HEAP32[$1 + 3624 >> 2] = 0
13442 }
13443 if (HEAP32[$1 + 3632 >> 2] | !HEAP32[$1 + 608 >> 2]) {
13444 break label$4
13445 }
13446 $2 = HEAP32[$1 + 28 >> 2];
13447 if (!$2) {
13448 break label$4
13449 }
13450 FUNCTION_TABLE[$2]($0, $1 + 256 | 0, HEAP32[$1 + 48 >> 2]);
13451 break label$4;
13452 }
13453 $1 = HEAP32[$4 >> 2];
13454 HEAP32[$1 + 252 >> 2] = 0;
13455 $5 = HEAP32[$7 + 176 >> 2];
13456 HEAP32[$1 + 448 >> 2] = ($5 >>> 0) / 18;
13457 HEAP32[$1 + 440 >> 2] = $5;
13458 HEAP32[$1 + 436 >> 2] = $6;
13459 HEAP32[$1 + 432 >> 2] = 3;
13460 $1 = HEAP32[$4 >> 2];
13461 $2 = HEAP32[$1 + 452 >> 2];
13462 $3 = HEAP32[$1 + 448 >> 2];
13463 label$9 : {
13464 if ($3) {
13465 __wasm_i64_mul($3, 0, 24, 0);
13466 if (!i64toi32_i32$HIGH_BITS) {
13467 $1 = dlrealloc($2, Math_imul($3, 24));
13468 if ($1) {
13469 HEAP32[HEAP32[$4 >> 2] + 452 >> 2] = $1;
13470 break label$9;
13471 }
13472 dlfree($2);
13473 $1 = HEAP32[$4 >> 2];
13474 }
13475 HEAP32[$1 + 452 >> 2] = 0;
13476 break label$3;
13477 }
13478 $1 = dlrealloc($2, 0);
13479 HEAP32[HEAP32[$4 >> 2] + 452 >> 2] = $1;
13480 if (!$1) {
13481 break label$3
13482 }
13483 }
13484 $2 = HEAP32[$4 >> 2];
13485 $1 = 0;
13486 label$14 : {
13487 if (!HEAP32[$2 + 448 >> 2]) {
13488 break label$14
13489 }
13490 $6 = HEAP32[1367];
13491 $8 = HEAP32[1366];
13492 $9 = HEAP32[1365];
13493 $3 = 0;
13494 while (1) {
13495 if (!FLAC__bitreader_read_raw_uint64(HEAP32[$2 + 56 >> 2], $7, $9)) {
13496 break label$2
13497 }
13498 $2 = HEAP32[$7 + 4 >> 2];
13499 $1 = Math_imul($3, 24);
13500 $10 = HEAP32[$4 >> 2];
13501 $11 = $1 + HEAP32[$10 + 452 >> 2] | 0;
13502 HEAP32[$11 >> 2] = HEAP32[$7 >> 2];
13503 HEAP32[$11 + 4 >> 2] = $2;
13504 if (!FLAC__bitreader_read_raw_uint64(HEAP32[$10 + 56 >> 2], $7, $8)) {
13505 break label$2
13506 }
13507 $2 = HEAP32[$7 + 4 >> 2];
13508 $10 = HEAP32[$4 >> 2];
13509 $11 = $1 + HEAP32[$10 + 452 >> 2] | 0;
13510 HEAP32[$11 + 8 >> 2] = HEAP32[$7 >> 2];
13511 HEAP32[$11 + 12 >> 2] = $2;
13512 if (!FLAC__bitreader_read_raw_uint32(HEAP32[$10 + 56 >> 2], $7 + 188 | 0, $6)) {
13513 break label$2
13514 }
13515 $2 = HEAP32[$4 >> 2];
13516 HEAP32[($1 + HEAP32[$2 + 452 >> 2] | 0) + 16 >> 2] = HEAP32[$7 + 188 >> 2];
13517 $3 = $3 + 1 | 0;
13518 $1 = HEAP32[$2 + 448 >> 2];
13519 if ($3 >>> 0 < $1 >>> 0) {
13520 continue
13521 }
13522 break;
13523 };
13524 $1 = Math_imul($1, -18);
13525 }
13526 $1 = $1 + $5 | 0;
13527 if ($1) {
13528 if (!FLAC__bitreader_skip_byte_block_aligned_no_crc(HEAP32[$2 + 56 >> 2], $1)) {
13529 break label$2
13530 }
13531 $2 = HEAP32[$4 >> 2];
13532 }
13533 HEAP32[$2 + 252 >> 2] = 1;
13534 if (HEAP32[$2 + 3632 >> 2] | !HEAP32[$2 + 620 >> 2]) {
13535 break label$4
13536 }
13537 $1 = HEAP32[$2 + 28 >> 2];
13538 if (!$1) {
13539 break label$4
13540 }
13541 FUNCTION_TABLE[$1]($0, $2 + 432 | 0, HEAP32[$2 + 48 >> 2]);
13542 break label$4;
13543 }
13544 $3 = HEAP32[$4 >> 2];
13545 $8 = HEAP32[($3 + ($2 << 2) | 0) + 608 >> 2];
13546 $5 = HEAP32[$7 + 176 >> 2];
13547 $1 = memset($7, 176);
13548 HEAP32[$1 + 8 >> 2] = $5;
13549 HEAP32[$1 >> 2] = $2;
13550 HEAP32[$1 + 4 >> 2] = $6;
13551 $9 = !$8;
13552 label$17 : {
13553 if (($2 | 0) != 2) {
13554 break label$17
13555 }
13556 $10 = $1 + 16 | 0;
13557 $6 = HEAP32[1364] >>> 3 | 0;
13558 if (!FLAC__bitreader_read_byte_block_aligned_no_crc(HEAP32[$3 + 56 >> 2], $10, $6)) {
13559 break label$2
13560 }
13561 if ($5 >>> 0 < $6 >>> 0) {
13562 HEAP32[HEAP32[$0 >> 2] >> 2] = 8;
13563 $2 = 0;
13564 break label$1;
13565 }
13566 $5 = $5 - $6 | 0;
13567 $3 = HEAP32[$4 >> 2];
13568 $11 = HEAP32[$3 + 1124 >> 2];
13569 if (!$11) {
13570 break label$17
13571 }
13572 $12 = HEAP32[$3 + 1120 >> 2];
13573 $2 = 0;
13574 while (1) {
13575 if (memcmp($12 + Math_imul($2, $6) | 0, $10, $6)) {
13576 $2 = $2 + 1 | 0;
13577 if (($11 | 0) != ($2 | 0)) {
13578 continue
13579 }
13580 break label$17;
13581 }
13582 break;
13583 };
13584 $9 = ($8 | 0) != 0;
13585 }
13586 if ($9) {
13587 if (!FLAC__bitreader_skip_byte_block_aligned_no_crc(HEAP32[$3 + 56 >> 2], $5)) {
13588 break label$2
13589 }
13590 break label$4;
13591 }
13592 label$22 : {
13593 label$23 : {
13594 label$24 : {
13595 label$25 : {
13596 label$26 : {
13597 label$27 : {
13598 label$28 : {
13599 switch (HEAP32[$1 + 180 >> 2]) {
13600 case 1:
13601 if (FLAC__bitreader_skip_byte_block_aligned_no_crc(HEAP32[$3 + 56 >> 2], $5)) {
13602 break label$26
13603 }
13604 $6 = 0;
13605 break label$22;
13606 case 2:
13607 if (!$5) {
13608 break label$27
13609 }
13610 $2 = dlmalloc($5);
13611 HEAP32[$1 + 20 >> 2] = $2;
13612 if (!$2) {
13613 HEAP32[HEAP32[$0 >> 2] >> 2] = 8;
13614 $6 = 0;
13615 break label$22;
13616 }
13617 if (FLAC__bitreader_read_byte_block_aligned_no_crc(HEAP32[$3 + 56 >> 2], $2, $5)) {
13618 break label$26
13619 }
13620 $6 = 0;
13621 break label$22;
13622 case 4:
13623 label$35 : {
13624 if ($5 >>> 0 < 8) {
13625 break label$35
13626 }
13627 $6 = 0;
13628 if (!FLAC__bitreader_read_uint32_little_endian(HEAP32[$3 + 56 >> 2], $1 + 16 | 0)) {
13629 break label$22
13630 }
13631 $5 = $5 + -8 | 0;
13632 $2 = HEAP32[$1 + 16 >> 2];
13633 label$36 : {
13634 if ($2) {
13635 if ($5 >>> 0 < $2 >>> 0) {
13636 HEAP32[$1 + 16 >> 2] = 0;
13637 HEAP32[$1 + 20 >> 2] = 0;
13638 break label$35;
13639 }
13640 label$39 : {
13641 label$40 : {
13642 if (($2 | 0) == -1) {
13643 HEAP32[$1 + 20 >> 2] = 0;
13644 break label$40;
13645 }
13646 $3 = dlmalloc($2 + 1 | 0);
13647 HEAP32[$1 + 20 >> 2] = $3;
13648 if ($3) {
13649 break label$39
13650 }
13651 }
13652 HEAP32[HEAP32[$0 >> 2] >> 2] = 8;
13653 break label$22;
13654 }
13655 if (!FLAC__bitreader_read_byte_block_aligned_no_crc(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $3, $2)) {
13656 break label$22
13657 }
13658 $5 = $5 - $2 | 0;
13659 HEAP8[HEAP32[$1 + 20 >> 2] + HEAP32[$1 + 16 >> 2] | 0] = 0;
13660 break label$36;
13661 }
13662 HEAP32[$1 + 20 >> 2] = 0;
13663 }
13664 if (!FLAC__bitreader_read_uint32_little_endian(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $1 + 24 | 0)) {
13665 break label$22
13666 }
13667 $2 = HEAP32[$1 + 24 >> 2];
13668 if ($2 >>> 0 >= 100001) {
13669 HEAP32[$1 + 24 >> 2] = 0;
13670 break label$22;
13671 }
13672 if (!$2) {
13673 break label$35
13674 }
13675 $3 = safe_malloc_mul_2op_p($2, 8);
13676 HEAP32[$1 + 28 >> 2] = $3;
13677 if (!$3) {
13678 break label$24
13679 }
13680 if (!HEAP32[$1 + 24 >> 2]) {
13681 break label$35
13682 }
13683 HEAP32[$3 >> 2] = 0;
13684 HEAP32[$3 + 4 >> 2] = 0;
13685 $2 = 0;
13686 label$43 : {
13687 if ($5 >>> 0 < 4) {
13688 break label$43
13689 }
13690 while (1) {
13691 if (!FLAC__bitreader_read_uint32_little_endian(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $3)) {
13692 break label$23
13693 }
13694 $5 = $5 + -4 | 0;
13695 $8 = HEAP32[$1 + 28 >> 2];
13696 $9 = $2 << 3;
13697 $3 = $8 + $9 | 0;
13698 $6 = HEAP32[$3 >> 2];
13699 label$45 : {
13700 if ($6) {
13701 if ($5 >>> 0 < $6 >>> 0) {
13702 break label$43
13703 }
13704 label$47 : {
13705 label$48 : {
13706 if (($6 | 0) == -1) {
13707 HEAP32[($8 + ($2 << 3) | 0) + 4 >> 2] = 0;
13708 break label$48;
13709 }
13710 $8 = dlmalloc($6 + 1 | 0);
13711 HEAP32[$3 + 4 >> 2] = $8;
13712 if ($8) {
13713 break label$47
13714 }
13715 }
13716 HEAP32[HEAP32[$0 >> 2] >> 2] = 8;
13717 break label$23;
13718 }
13719 $5 = $5 - $6 | 0;
13720 memset($8, HEAP32[$3 >> 2]);
13721 $6 = FLAC__bitreader_read_byte_block_aligned_no_crc(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], HEAP32[$3 + 4 >> 2], HEAP32[$3 >> 2]);
13722 $8 = $9 + HEAP32[$1 + 28 >> 2] | 0;
13723 $3 = HEAP32[$8 + 4 >> 2];
13724 if (!$6) {
13725 dlfree($3);
13726 HEAP32[(HEAP32[$1 + 28 >> 2] + ($2 << 3) | 0) + 4 >> 2] = 0;
13727 break label$43;
13728 }
13729 HEAP8[$3 + HEAP32[$8 >> 2] | 0] = 0;
13730 break label$45;
13731 }
13732 HEAP32[$3 + 4 >> 2] = 0;
13733 }
13734 $2 = $2 + 1 | 0;
13735 if ($2 >>> 0 >= HEAPU32[$1 + 24 >> 2]) {
13736 break label$35
13737 }
13738 $3 = HEAP32[$1 + 28 >> 2] + ($2 << 3) | 0;
13739 HEAP32[$3 >> 2] = 0;
13740 HEAP32[$3 + 4 >> 2] = 0;
13741 if ($5 >>> 0 >= 4) {
13742 continue
13743 }
13744 break;
13745 };
13746 }
13747 HEAP32[$1 + 24 >> 2] = $2;
13748 }
13749 if (!$5) {
13750 break label$26
13751 }
13752 if (!HEAP32[$1 + 24 >> 2]) {
13753 $2 = $1 + 28 | 0;
13754 dlfree(HEAP32[$2 >> 2]);
13755 HEAP32[$2 >> 2] = 0;
13756 }
13757 if (FLAC__bitreader_skip_byte_block_aligned_no_crc(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $5)) {
13758 break label$26
13759 }
13760 $6 = 0;
13761 break label$22;
13762 case 5:
13763 $6 = 0;
13764 $2 = memset($1 + 16 | 0, 160);
13765 if (!FLAC__bitreader_read_byte_block_aligned_no_crc(HEAP32[$3 + 56 >> 2], $2, HEAP32[1378] >>> 3 | 0)) {
13766 break label$22
13767 }
13768 if (!FLAC__bitreader_read_raw_uint64(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $1 + 152 | 0, HEAP32[1379])) {
13769 break label$22
13770 }
13771 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $1 + 188 | 0, HEAP32[1380])) {
13772 break label$22
13773 }
13774 HEAP32[$1 + 160 >> 2] = HEAP32[$1 + 188 >> 2] != 0;
13775 if (!FLAC__bitreader_skip_bits_no_crc(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], HEAP32[1381])) {
13776 break label$22
13777 }
13778 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $1 + 188 | 0, HEAP32[1382])) {
13779 break label$22
13780 }
13781 $2 = HEAP32[$1 + 188 >> 2];
13782 HEAP32[$1 + 164 >> 2] = $2;
13783 if (!$2) {
13784 break label$26
13785 }
13786 $2 = dlcalloc($2, 32);
13787 HEAP32[$1 + 168 >> 2] = $2;
13788 if (!$2) {
13789 break label$25
13790 }
13791 $9 = HEAP32[1371];
13792 if (!FLAC__bitreader_read_raw_uint64(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $2, $9)) {
13793 break label$22
13794 }
13795 $10 = HEAP32[1373] >>> 3 | 0;
13796 $11 = HEAP32[1370];
13797 $12 = HEAP32[1369];
13798 $8 = HEAP32[1368];
13799 $13 = HEAP32[1377];
13800 $16 = HEAP32[1376];
13801 $17 = HEAP32[1375];
13802 $18 = HEAP32[1374];
13803 $19 = HEAP32[1372];
13804 $5 = 0;
13805 while (1) {
13806 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $1 + 188 | 0, $19)) {
13807 break label$22
13808 }
13809 $2 = ($5 << 5) + $2 | 0;
13810 HEAP8[$2 + 8 | 0] = HEAP32[$1 + 188 >> 2];
13811 if (!FLAC__bitreader_read_byte_block_aligned_no_crc(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $2 + 9 | 0, $10)) {
13812 break label$22
13813 }
13814 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $1 + 188 | 0, $18)) {
13815 break label$22
13816 }
13817 HEAP8[$2 + 22 | 0] = HEAPU8[$2 + 22 | 0] & 254 | HEAP8[$1 + 188 | 0] & 1;
13818 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $1 + 188 | 0, $17)) {
13819 break label$22
13820 }
13821 $3 = $2 + 22 | 0;
13822 HEAP8[$3 | 0] = HEAPU8[$1 + 188 | 0] << 1 & 2 | HEAPU8[$3 | 0] & 253;
13823 if (!FLAC__bitreader_skip_bits_no_crc(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $16)) {
13824 break label$22
13825 }
13826 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $1 + 188 | 0, $13)) {
13827 break label$22
13828 }
13829 $3 = HEAP32[$1 + 188 >> 2];
13830 HEAP8[$2 + 23 | 0] = $3;
13831 label$53 : {
13832 $3 = $3 & 255;
13833 if (!$3) {
13834 break label$53
13835 }
13836 $3 = dlcalloc($3, 16);
13837 HEAP32[$2 + 24 >> 2] = $3;
13838 label$54 : {
13839 if ($3) {
13840 $14 = $2 + 23 | 0;
13841 if (!HEAPU8[$14 | 0]) {
13842 break label$53
13843 }
13844 if (!FLAC__bitreader_read_raw_uint64(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $3, $8)) {
13845 break label$22
13846 }
13847 $20 = $2 + 24 | 0;
13848 $2 = 0;
13849 break label$54;
13850 }
13851 HEAP32[HEAP32[$0 >> 2] >> 2] = 8;
13852 break label$22;
13853 }
13854 while (1) {
13855 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $1 + 188 | 0, $12)) {
13856 break label$22
13857 }
13858 HEAP8[(($2 << 4) + $3 | 0) + 8 | 0] = HEAP32[$1 + 188 >> 2];
13859 if (!FLAC__bitreader_skip_bits_no_crc(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $11)) {
13860 break label$22
13861 }
13862 $2 = $2 + 1 | 0;
13863 if ($2 >>> 0 >= HEAPU8[$14 | 0]) {
13864 break label$53
13865 }
13866 $3 = HEAP32[$20 >> 2];
13867 if (FLAC__bitreader_read_raw_uint64(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $3 + ($2 << 4) | 0, $8)) {
13868 continue
13869 }
13870 break;
13871 };
13872 break label$22;
13873 }
13874 $5 = $5 + 1 | 0;
13875 if ($5 >>> 0 >= HEAPU32[$1 + 164 >> 2]) {
13876 break label$26
13877 }
13878 $2 = HEAP32[$1 + 168 >> 2];
13879 if (FLAC__bitreader_read_raw_uint64(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $2 + ($5 << 5) | 0, $9)) {
13880 continue
13881 }
13882 break;
13883 };
13884 break label$22;
13885 case 6:
13886 label$57 : {
13887 if (!FLAC__bitreader_read_raw_uint32(HEAP32[$3 + 56 >> 2], $1 + 188 | 0, HEAP32[1383])) {
13888 break label$57
13889 }
13890 HEAP32[$1 + 16 >> 2] = HEAP32[$1 + 188 >> 2];
13891 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $1 + 188 | 0, HEAP32[1384])) {
13892 break label$57
13893 }
13894 label$58 : {
13895 $2 = HEAP32[$1 + 188 >> 2];
13896 label$59 : {
13897 if (($2 | 0) == -1) {
13898 HEAP32[$1 + 20 >> 2] = 0;
13899 break label$59;
13900 }
13901 $3 = dlmalloc($2 + 1 | 0);
13902 HEAP32[$1 + 20 >> 2] = $3;
13903 if ($3) {
13904 break label$58
13905 }
13906 }
13907 HEAP32[HEAP32[$0 >> 2] >> 2] = 8;
13908 $6 = 0;
13909 break label$22;
13910 }
13911 if ($2) {
13912 if (!FLAC__bitreader_read_byte_block_aligned_no_crc(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $3, $2)) {
13913 break label$57
13914 }
13915 $3 = HEAP32[$1 + 20 >> 2];
13916 $2 = HEAP32[$1 + 188 >> 2];
13917 } else {
13918 $2 = 0
13919 }
13920 HEAP8[$2 + $3 | 0] = 0;
13921 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $1 + 188 | 0, HEAP32[1385])) {
13922 break label$57
13923 }
13924 label$63 : {
13925 $2 = HEAP32[$1 + 188 >> 2];
13926 label$64 : {
13927 if (($2 | 0) == -1) {
13928 HEAP32[$1 + 24 >> 2] = 0;
13929 break label$64;
13930 }
13931 $3 = dlmalloc($2 + 1 | 0);
13932 HEAP32[$1 + 24 >> 2] = $3;
13933 if ($3) {
13934 break label$63
13935 }
13936 }
13937 HEAP32[HEAP32[$0 >> 2] >> 2] = 8;
13938 $6 = 0;
13939 break label$22;
13940 }
13941 if ($2) {
13942 if (!FLAC__bitreader_read_byte_block_aligned_no_crc(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $3, $2)) {
13943 break label$57
13944 }
13945 $3 = HEAP32[$1 + 24 >> 2];
13946 $2 = HEAP32[$1 + 188 >> 2];
13947 } else {
13948 $2 = 0
13949 }
13950 HEAP8[$2 + $3 | 0] = 0;
13951 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $1 + 28 | 0, HEAP32[1386])) {
13952 break label$57
13953 }
13954 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $1 + 32 | 0, HEAP32[1387])) {
13955 break label$57
13956 }
13957 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $1 + 36 | 0, HEAP32[1388])) {
13958 break label$57
13959 }
13960 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $1 + 40 | 0, HEAP32[1389])) {
13961 break label$57
13962 }
13963 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $1 + 44 | 0, HEAP32[1390])) {
13964 break label$57
13965 }
13966 $2 = HEAP32[$1 + 44 >> 2];
13967 $3 = dlmalloc($2 ? $2 : 1);
13968 HEAP32[$1 + 48 >> 2] = $3;
13969 if (!$3) {
13970 HEAP32[HEAP32[$0 >> 2] >> 2] = 8;
13971 $6 = 0;
13972 break label$22;
13973 }
13974 if (!$2) {
13975 break label$26
13976 }
13977 if (FLAC__bitreader_read_byte_block_aligned_no_crc(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $3, $2)) {
13978 break label$26
13979 }
13980 }
13981 $6 = 0;
13982 break label$22;
13983 case 0:
13984 case 3:
13985 break label$26;
13986 default:
13987 break label$28;
13988 };
13989 }
13990 label$69 : {
13991 if ($5) {
13992 $2 = dlmalloc($5);
13993 HEAP32[$1 + 16 >> 2] = $2;
13994 if ($2) {
13995 break label$69
13996 }
13997 HEAP32[HEAP32[$0 >> 2] >> 2] = 8;
13998 $6 = 0;
13999 break label$22;
14000 }
14001 HEAP32[$1 + 16 >> 2] = 0;
14002 break label$26;
14003 }
14004 if (FLAC__bitreader_read_byte_block_aligned_no_crc(HEAP32[$3 + 56 >> 2], $2, $5)) {
14005 break label$26
14006 }
14007 $6 = 0;
14008 break label$22;
14009 }
14010 HEAP32[$1 + 20 >> 2] = 0;
14011 }
14012 $6 = 1;
14013 $2 = HEAP32[$4 >> 2];
14014 if (HEAP32[$2 + 3632 >> 2]) {
14015 break label$22
14016 }
14017 $3 = HEAP32[$2 + 28 >> 2];
14018 if (!$3) {
14019 break label$22
14020 }
14021 FUNCTION_TABLE[$3]($0, $1, HEAP32[$2 + 48 >> 2]);
14022 break label$22;
14023 }
14024 HEAP32[HEAP32[$0 >> 2] >> 2] = 8;
14025 break label$22;
14026 }
14027 HEAP32[$1 + 24 >> 2] = 0;
14028 HEAP32[HEAP32[$0 >> 2] >> 2] = 8;
14029 break label$22;
14030 }
14031 HEAP32[$1 + 24 >> 2] = $2;
14032 $6 = 0;
14033 }
14034 label$71 : {
14035 label$72 : {
14036 switch (HEAP32[$1 + 180 >> 2] + -1 | 0) {
14037 case 1:
14038 $1 = HEAP32[$1 + 20 >> 2];
14039 if (!$1) {
14040 break label$71
14041 }
14042 dlfree($1);
14043 break label$71;
14044 case 3:
14045 $2 = HEAP32[$1 + 20 >> 2];
14046 if ($2) {
14047 dlfree($2)
14048 }
14049 $3 = HEAP32[$1 + 24 >> 2];
14050 if ($3) {
14051 $2 = 0;
14052 while (1) {
14053 $5 = HEAP32[(HEAP32[$1 + 28 >> 2] + ($2 << 3) | 0) + 4 >> 2];
14054 if ($5) {
14055 dlfree($5);
14056 $3 = HEAP32[$1 + 24 >> 2];
14057 }
14058 $2 = $2 + 1 | 0;
14059 if ($2 >>> 0 < $3 >>> 0) {
14060 continue
14061 }
14062 break;
14063 };
14064 }
14065 $1 = HEAP32[$1 + 28 >> 2];
14066 if (!$1) {
14067 break label$71
14068 }
14069 dlfree($1);
14070 break label$71;
14071 case 4:
14072 $3 = HEAP32[$1 + 164 >> 2];
14073 if ($3) {
14074 $2 = 0;
14075 while (1) {
14076 $5 = HEAP32[(HEAP32[$1 + 168 >> 2] + ($2 << 5) | 0) + 24 >> 2];
14077 if ($5) {
14078 dlfree($5);
14079 $3 = HEAP32[$1 + 164 >> 2];
14080 }
14081 $2 = $2 + 1 | 0;
14082 if ($2 >>> 0 < $3 >>> 0) {
14083 continue
14084 }
14085 break;
14086 };
14087 }
14088 $1 = HEAP32[$1 + 168 >> 2];
14089 if (!$1) {
14090 break label$71
14091 }
14092 dlfree($1);
14093 break label$71;
14094 case 5:
14095 $2 = HEAP32[$1 + 20 >> 2];
14096 if ($2) {
14097 dlfree($2)
14098 }
14099 $2 = HEAP32[$1 + 24 >> 2];
14100 if ($2) {
14101 dlfree($2)
14102 }
14103 $1 = HEAP32[$1 + 48 >> 2];
14104 if (!$1) {
14105 break label$71
14106 }
14107 dlfree($1);
14108 break label$71;
14109 case 0:
14110 break label$71;
14111 default:
14112 break label$72;
14113 };
14114 }
14115 $1 = HEAP32[$1 + 16 >> 2];
14116 if (!$1) {
14117 break label$71
14118 }
14119 dlfree($1);
14120 }
14121 if (!$6) {
14122 break label$2
14123 }
14124 }
14125 $2 = 1;
14126 if (!$15) {
14127 break label$1
14128 }
14129 label$86 : {
14130 label$87 : {
14131 $3 = HEAP32[$4 >> 2];
14132 if (HEAP32[$3 >> 2]) {
14133 break label$87
14134 }
14135 $5 = HEAP32[$3 + 12 >> 2];
14136 if (!$5) {
14137 break label$87
14138 }
14139 $1 = $3 + 6136 | 0;
14140 if (FUNCTION_TABLE[$5]($0, $1, HEAP32[$3 + 48 >> 2])) {
14141 break label$87
14142 }
14143 if (!FLAC__bitreader_is_consumed_byte_aligned(HEAP32[HEAP32[$4 >> 2] + 56 >> 2])) {
14144 break label$87
14145 }
14146 $3 = HEAP32[$1 >> 2];
14147 $4 = HEAP32[HEAP32[$4 >> 2] + 56 >> 2];
14148 $4 = ((HEAP32[$4 + 8 >> 2] - HEAP32[$4 + 16 >> 2] << 5) + (HEAP32[$4 + 12 >> 2] << 3) | 0) - HEAP32[$4 + 20 >> 2] >>> 3 | 0;
14149 $5 = HEAP32[$1 + 4 >> 2] - ($3 >>> 0 < $4 >>> 0) | 0;
14150 HEAP32[$1 >> 2] = $3 - $4;
14151 HEAP32[$1 + 4 >> 2] = $5;
14152 break label$86;
14153 }
14154 $1 = HEAP32[$4 >> 2];
14155 HEAP32[$1 + 6136 >> 2] = 0;
14156 HEAP32[$1 + 6140 >> 2] = 0;
14157 }
14158 HEAP32[HEAP32[$0 >> 2] >> 2] = 2;
14159 break label$1;
14160 }
14161 HEAP32[HEAP32[$0 >> 2] >> 2] = 8;
14162 }
14163 $2 = 0;
14164 }
14165 global$0 = $7 + 192 | 0;
14166 return $2;
14167 }
14168
14169 function frame_sync_($0) {
14170 var $1 = 0, $2 = 0, $3 = 0, $4 = 0, $5 = 0;
14171 $4 = global$0 - 16 | 0;
14172 global$0 = $4;
14173 label$1 : {
14174 label$2 : {
14175 label$3 : {
14176 $2 = HEAP32[$0 + 4 >> 2];
14177 if (!HEAP32[$2 + 248 >> 2]) {
14178 break label$3
14179 }
14180 $3 = HEAP32[$2 + 308 >> 2];
14181 $1 = $3;
14182 $5 = HEAP32[$2 + 304 >> 2];
14183 if (!($1 | $5)) {
14184 break label$3
14185 }
14186 $3 = HEAP32[$2 + 244 >> 2];
14187 if (($1 | 0) == ($3 | 0) & HEAPU32[$2 + 240 >> 2] < $5 >>> 0 | $3 >>> 0 < $1 >>> 0) {
14188 break label$3
14189 }
14190 HEAP32[HEAP32[$0 >> 2] >> 2] = 4;
14191 break label$2;
14192 }
14193 label$4 : {
14194 if (FLAC__bitreader_is_consumed_byte_aligned(HEAP32[$2 + 56 >> 2])) {
14195 break label$4
14196 }
14197 $2 = HEAP32[HEAP32[$0 + 4 >> 2] + 56 >> 2];
14198 if (FLAC__bitreader_read_raw_uint32($2, $4 + 12 | 0, FLAC__bitreader_bits_left_for_byte_alignment($2))) {
14199 break label$4
14200 }
14201 $1 = 0;
14202 break label$1;
14203 }
14204 $2 = 0;
14205 while (1) {
14206 $3 = HEAP32[$0 + 4 >> 2];
14207 label$6 : {
14208 if (HEAP32[$3 + 3520 >> 2]) {
14209 $1 = HEAPU8[$3 + 3590 | 0];
14210 HEAP32[$4 + 12 >> 2] = $1;
14211 HEAP32[$3 + 3520 >> 2] = 0;
14212 break label$6;
14213 }
14214 $1 = 0;
14215 if (!FLAC__bitreader_read_raw_uint32(HEAP32[$3 + 56 >> 2], $4 + 12 | 0, 8)) {
14216 break label$1
14217 }
14218 $1 = HEAP32[$4 + 12 >> 2];
14219 }
14220 label$8 : {
14221 if (($1 | 0) != 255) {
14222 break label$8
14223 }
14224 HEAP8[HEAP32[$0 + 4 >> 2] + 3588 | 0] = 255;
14225 $1 = 0;
14226 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$0 + 4 >> 2] + 56 >> 2], $4 + 12 | 0, 8)) {
14227 break label$1
14228 }
14229 $1 = HEAP32[$4 + 12 >> 2];
14230 if (($1 | 0) == 255) {
14231 $1 = HEAP32[$0 + 4 >> 2];
14232 HEAP32[$1 + 3520 >> 2] = 1;
14233 HEAP8[$1 + 3590 | 0] = 255;
14234 break label$8;
14235 }
14236 if (($1 & -2) != 248) {
14237 break label$8
14238 }
14239 HEAP8[HEAP32[$0 + 4 >> 2] + 3589 | 0] = $1;
14240 HEAP32[HEAP32[$0 >> 2] >> 2] = 3;
14241 break label$2;
14242 }
14243 $1 = $2;
14244 $2 = 1;
14245 if ($1) {
14246 continue
14247 }
14248 $1 = HEAP32[$0 + 4 >> 2];
14249 if (HEAP32[$1 + 3632 >> 2]) {
14250 continue
14251 }
14252 FUNCTION_TABLE[HEAP32[$1 + 32 >> 2]]($0, 0, HEAP32[$1 + 48 >> 2]);
14253 continue;
14254 };
14255 }
14256 $1 = 1;
14257 }
14258 global$0 = $4 + 16 | 0;
14259 return $1;
14260 }
14261
14262 function read_frame_($0, $1) {
14263 var $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
14264 $7 = global$0 + -64 | 0;
14265 global$0 = $7;
14266 HEAP32[$1 >> 2] = 0;
14267 $2 = HEAP32[$0 + 4 >> 2];
14268 $4 = HEAPU16[(HEAPU8[$2 + 3588 | 0] << 1) + 1280 >> 1];
14269 $5 = HEAP32[$2 + 56 >> 2];
14270 HEAP32[$5 + 24 >> 2] = HEAPU16[((HEAPU8[$2 + 3589 | 0] ^ $4 >>> 8) << 1) + 1280 >> 1] ^ $4 << 8 & 65280;
14271 $2 = HEAP32[$5 + 20 >> 2];
14272 HEAP32[$5 + 28 >> 2] = HEAP32[$5 + 16 >> 2];
14273 HEAP32[$5 + 32 >> 2] = $2;
14274 $5 = HEAP32[$0 + 4 >> 2];
14275 HEAP8[$7 + 32 | 0] = HEAPU8[$5 + 3588 | 0];
14276 $2 = HEAPU8[$5 + 3589 | 0];
14277 HEAP32[$7 + 12 >> 2] = 2;
14278 HEAP8[$7 + 33 | 0] = $2;
14279 label$1 : {
14280 if (!FLAC__bitreader_read_raw_uint32(HEAP32[$5 + 56 >> 2], $7 + 28 | 0, 8)) {
14281 break label$1
14282 }
14283 $4 = $0 + 4 | 0;
14284 label$2 : {
14285 label$3 : {
14286 label$4 : {
14287 label$5 : {
14288 $5 = HEAP32[$7 + 28 >> 2];
14289 if (($5 | 0) == 255) {
14290 break label$5
14291 }
14292 HEAP8[$7 + 34 | 0] = $5;
14293 HEAP32[$7 + 12 >> 2] = 3;
14294 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $7 + 28 | 0, 8)) {
14295 break label$3
14296 }
14297 $5 = HEAP32[$7 + 28 >> 2];
14298 if (($5 | 0) == 255) {
14299 break label$5
14300 }
14301 $8 = $2 >>> 1 & 1;
14302 $2 = HEAP32[$7 + 12 >> 2];
14303 HEAP8[$2 + ($7 + 32 | 0) | 0] = $5;
14304 $5 = 1;
14305 HEAP32[$7 + 12 >> 2] = $2 + 1;
14306 $2 = HEAPU8[$7 + 34 | 0];
14307 $3 = $2 >>> 4 | 0;
14308 HEAP32[$7 + 28 >> 2] = $3;
14309 label$6 : {
14310 label$7 : {
14311 label$8 : {
14312 label$9 : {
14313 switch ($3 - 1 | 0) {
14314 case 7:
14315 case 8:
14316 case 9:
14317 case 10:
14318 case 11:
14319 case 12:
14320 case 13:
14321 case 14:
14322 HEAP32[HEAP32[$4 >> 2] + 1136 >> 2] = 256 << $3 + -8;
14323 break label$8;
14324 case 1:
14325 case 2:
14326 case 3:
14327 case 4:
14328 HEAP32[HEAP32[$4 >> 2] + 1136 >> 2] = 576 << $3 + -2;
14329 break label$8;
14330 case 5:
14331 case 6:
14332 break label$7;
14333 case 0:
14334 break label$9;
14335 default:
14336 break label$6;
14337 };
14338 }
14339 HEAP32[HEAP32[$4 >> 2] + 1136 >> 2] = 192;
14340 }
14341 $3 = 0;
14342 }
14343 $5 = $8;
14344 }
14345 $6 = $2 & 15;
14346 HEAP32[$7 + 28 >> 2] = $6;
14347 label$12 : {
14348 label$13 : {
14349 label$14 : {
14350 switch ($6 - 1 | 0) {
14351 default:
14352 $6 = 0;
14353 $8 = HEAP32[$4 >> 2];
14354 if (HEAP32[$8 + 248 >> 2]) {
14355 break label$13
14356 }
14357 $5 = 1;
14358 break label$12;
14359 case 0:
14360 HEAP32[HEAP32[$4 >> 2] + 1140 >> 2] = 88200;
14361 $6 = 0;
14362 break label$12;
14363 case 1:
14364 HEAP32[HEAP32[$4 >> 2] + 1140 >> 2] = 176400;
14365 $6 = 0;
14366 break label$12;
14367 case 2:
14368 HEAP32[HEAP32[$4 >> 2] + 1140 >> 2] = 192e3;
14369 $6 = 0;
14370 break label$12;
14371 case 3:
14372 HEAP32[HEAP32[$4 >> 2] + 1140 >> 2] = 8e3;
14373 $6 = 0;
14374 break label$12;
14375 case 4:
14376 HEAP32[HEAP32[$4 >> 2] + 1140 >> 2] = 16e3;
14377 $6 = 0;
14378 break label$12;
14379 case 5:
14380 HEAP32[HEAP32[$4 >> 2] + 1140 >> 2] = 22050;
14381 $6 = 0;
14382 break label$12;
14383 case 6:
14384 HEAP32[HEAP32[$4 >> 2] + 1140 >> 2] = 24e3;
14385 $6 = 0;
14386 break label$12;
14387 case 7:
14388 HEAP32[HEAP32[$4 >> 2] + 1140 >> 2] = 32e3;
14389 $6 = 0;
14390 break label$12;
14391 case 8:
14392 HEAP32[HEAP32[$4 >> 2] + 1140 >> 2] = 44100;
14393 $6 = 0;
14394 break label$12;
14395 case 9:
14396 HEAP32[HEAP32[$4 >> 2] + 1140 >> 2] = 48e3;
14397 $6 = 0;
14398 break label$12;
14399 case 10:
14400 HEAP32[HEAP32[$4 >> 2] + 1140 >> 2] = 96e3;
14401 $6 = 0;
14402 break label$12;
14403 case 11:
14404 case 12:
14405 case 13:
14406 break label$12;
14407 case 14:
14408 break label$14;
14409 };
14410 }
14411 $5 = HEAP32[$4 >> 2];
14412 if (!HEAP32[$5 + 3632 >> 2]) {
14413 FUNCTION_TABLE[HEAP32[$5 + 32 >> 2]]($0, 1, HEAP32[$5 + 48 >> 2])
14414 }
14415 $2 = HEAP32[$0 >> 2];
14416 HEAP32[$2 >> 2] = 2;
14417 break label$4;
14418 }
14419 HEAP32[$8 + 1140 >> 2] = HEAP32[$8 + 288 >> 2];
14420 }
14421 $10 = HEAPU8[$7 + 35 | 0];
14422 $9 = $10 >>> 4 | 0;
14423 HEAP32[$7 + 28 >> 2] = $9;
14424 label$28 : {
14425 label$29 : {
14426 if ($9 & 8) {
14427 $2 = HEAP32[$4 >> 2];
14428 HEAP32[$2 + 1144 >> 2] = 2;
14429 $8 = 1;
14430 label$31 : {
14431 switch ($9 & 7) {
14432 case 1:
14433 $8 = 2;
14434 break label$29;
14435 case 0:
14436 break label$29;
14437 case 2:
14438 break label$31;
14439 default:
14440 break label$28;
14441 };
14442 }
14443 $8 = 3;
14444 break label$29;
14445 }
14446 $2 = HEAP32[$4 >> 2];
14447 HEAP32[$2 + 1144 >> 2] = $9 + 1;
14448 $8 = 0;
14449 }
14450 HEAP32[$2 + 1148 >> 2] = $8;
14451 $8 = $5;
14452 }
14453 $9 = $10 >>> 1 & 7;
14454 HEAP32[$7 + 28 >> 2] = $9;
14455 $5 = 1;
14456 label$33 : {
14457 label$34 : {
14458 label$35 : {
14459 switch ($9 - 1 | 0) {
14460 default:
14461 if (!HEAP32[$2 + 248 >> 2]) {
14462 break label$33
14463 }
14464 HEAP32[$2 + 1152 >> 2] = HEAP32[$2 + 296 >> 2];
14465 break label$34;
14466 case 0:
14467 HEAP32[$2 + 1152 >> 2] = 8;
14468 break label$34;
14469 case 1:
14470 HEAP32[$2 + 1152 >> 2] = 12;
14471 break label$34;
14472 case 3:
14473 HEAP32[$2 + 1152 >> 2] = 16;
14474 break label$34;
14475 case 4:
14476 HEAP32[$2 + 1152 >> 2] = 20;
14477 break label$34;
14478 case 2:
14479 case 6:
14480 break label$33;
14481 case 5:
14482 break label$35;
14483 };
14484 }
14485 HEAP32[$2 + 1152 >> 2] = 24;
14486 }
14487 $5 = $8;
14488 }
14489 label$41 : {
14490 if (!(!HEAP32[$2 + 248 >> 2] | HEAP32[$2 + 272 >> 2] == HEAP32[$2 + 276 >> 2] ? !(HEAP8[$7 + 33 | 0] & 1) : 0)) {
14491 if (!FLAC__bitreader_read_utf8_uint64(HEAP32[$2 + 56 >> 2], $7 + 16 | 0, $7 + 32 | 0, $7 + 12 | 0)) {
14492 break label$3
14493 }
14494 $8 = HEAP32[$7 + 20 >> 2];
14495 $2 = $8;
14496 $9 = HEAP32[$7 + 16 >> 2];
14497 if (($9 | 0) == -1 & ($2 | 0) == -1) {
14498 $8 = HEAPU8[(HEAP32[$7 + 12 >> 2] + $7 | 0) + 31 | 0];
14499 $5 = HEAP32[$4 >> 2];
14500 HEAP32[$5 + 3520 >> 2] = 1;
14501 HEAP8[$5 + 3590 | 0] = $8;
14502 if (!HEAP32[$5 + 3632 >> 2]) {
14503 FUNCTION_TABLE[HEAP32[$5 + 32 >> 2]]($0, 1, HEAP32[$5 + 48 >> 2])
14504 }
14505 $2 = HEAP32[$0 >> 2];
14506 HEAP32[$2 >> 2] = 2;
14507 break label$4;
14508 }
14509 $8 = HEAP32[$4 >> 2];
14510 $11 = $8 + 1160 | 0;
14511 HEAP32[$11 >> 2] = $9;
14512 HEAP32[$11 + 4 >> 2] = $2;
14513 HEAP32[$8 + 1156 >> 2] = 1;
14514 break label$41;
14515 }
14516 if (!FLAC__bitreader_read_utf8_uint32(HEAP32[$2 + 56 >> 2], $7 + 28 | 0, $7 + 32 | 0, $7 + 12 | 0)) {
14517 break label$3
14518 }
14519 $8 = HEAP32[$7 + 28 >> 2];
14520 if (($8 | 0) == -1) {
14521 $8 = HEAPU8[(HEAP32[$7 + 12 >> 2] + $7 | 0) + 31 | 0];
14522 $5 = HEAP32[$4 >> 2];
14523 HEAP32[$5 + 3520 >> 2] = 1;
14524 HEAP8[$5 + 3590 | 0] = $8;
14525 if (!HEAP32[$5 + 3632 >> 2]) {
14526 FUNCTION_TABLE[HEAP32[$5 + 32 >> 2]]($0, 1, HEAP32[$5 + 48 >> 2])
14527 }
14528 $2 = HEAP32[$0 >> 2];
14529 HEAP32[$2 >> 2] = 2;
14530 break label$4;
14531 }
14532 $2 = HEAP32[$4 >> 2];
14533 HEAP32[$2 + 1160 >> 2] = $8;
14534 HEAP32[$2 + 1156 >> 2] = 0;
14535 }
14536 $2 = HEAP32[$4 >> 2];
14537 if ($3) {
14538 if (!FLAC__bitreader_read_raw_uint32(HEAP32[$2 + 56 >> 2], $7 + 28 | 0, 8)) {
14539 break label$3
14540 }
14541 $2 = HEAP32[$7 + 12 >> 2];
14542 $8 = HEAP32[$7 + 28 >> 2];
14543 HEAP8[$2 + ($7 + 32 | 0) | 0] = $8;
14544 HEAP32[$7 + 12 >> 2] = $2 + 1;
14545 if (($3 | 0) == 7) {
14546 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $7 + 8 | 0, 8)) {
14547 break label$3
14548 }
14549 $8 = HEAP32[$7 + 12 >> 2];
14550 $2 = HEAP32[$7 + 8 >> 2];
14551 HEAP8[$8 + ($7 + 32 | 0) | 0] = $2;
14552 HEAP32[$7 + 12 >> 2] = $8 + 1;
14553 $8 = $2 | HEAP32[$7 + 28 >> 2] << 8;
14554 HEAP32[$7 + 28 >> 2] = $8;
14555 }
14556 $2 = HEAP32[$4 >> 2];
14557 HEAP32[$2 + 1136 >> 2] = $8 + 1;
14558 }
14559 if ($6) {
14560 if (!FLAC__bitreader_read_raw_uint32(HEAP32[$2 + 56 >> 2], $7 + 28 | 0, 8)) {
14561 break label$3
14562 }
14563 $8 = HEAP32[$7 + 12 >> 2];
14564 $2 = HEAP32[$7 + 28 >> 2];
14565 HEAP8[$8 + ($7 + 32 | 0) | 0] = $2;
14566 HEAP32[$7 + 12 >> 2] = $8 + 1;
14567 label$51 : {
14568 if (($6 | 0) != 12) {
14569 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $7 + 8 | 0, 8)) {
14570 break label$3
14571 }
14572 $8 = HEAP32[$7 + 12 >> 2];
14573 $2 = HEAP32[$7 + 8 >> 2];
14574 HEAP8[$8 + ($7 + 32 | 0) | 0] = $2;
14575 HEAP32[$7 + 12 >> 2] = $8 + 1;
14576 $3 = $2 | HEAP32[$7 + 28 >> 2] << 8;
14577 HEAP32[$7 + 28 >> 2] = $3;
14578 if (($6 | 0) == 13) {
14579 break label$51
14580 }
14581 $3 = Math_imul($3, 10);
14582 break label$51;
14583 }
14584 $3 = Math_imul($2, 1e3);
14585 }
14586 $2 = HEAP32[$4 >> 2];
14587 HEAP32[$2 + 1140 >> 2] = $3;
14588 }
14589 if (!FLAC__bitreader_read_raw_uint32(HEAP32[$2 + 56 >> 2], $7 + 28 | 0, 8)) {
14590 break label$3
14591 }
14592 $8 = HEAPU8[$7 + 28 | 0];
14593 $3 = FLAC__crc8($7 + 32 | 0, HEAP32[$7 + 12 >> 2]);
14594 $2 = HEAP32[$4 >> 2];
14595 if (($3 | 0) != ($8 | 0)) {
14596 if (!HEAP32[$2 + 3632 >> 2]) {
14597 FUNCTION_TABLE[HEAP32[$2 + 32 >> 2]]($0, 1, HEAP32[$2 + 48 >> 2])
14598 }
14599 $2 = HEAP32[$0 >> 2];
14600 HEAP32[$2 >> 2] = 2;
14601 break label$4;
14602 }
14603 HEAP32[$2 + 232 >> 2] = 0;
14604 label$55 : {
14605 label$56 : {
14606 if (HEAP32[$2 + 1156 >> 2]) {
14607 break label$56
14608 }
14609 $3 = $2 + 1160 | 0;
14610 $8 = HEAP32[$3 >> 2];
14611 HEAP32[$7 + 28 >> 2] = $8;
14612 HEAP32[$2 + 1156 >> 2] = 1;
14613 $6 = HEAP32[$2 + 228 >> 2];
14614 if ($6) {
14615 (wasm2js_i32$0 = $3, wasm2js_i32$1 = __wasm_i64_mul($6, 0, $8, 0)), HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
14616 HEAP32[$3 + 4 >> 2] = i64toi32_i32$HIGH_BITS;
14617 break label$56;
14618 }
14619 if (HEAP32[$2 + 248 >> 2]) {
14620 $3 = HEAP32[$2 + 272 >> 2];
14621 if (($3 | 0) != HEAP32[$2 + 276 >> 2]) {
14622 break label$55
14623 }
14624 $2 = $2 + 1160 | 0;
14625 (wasm2js_i32$0 = $2, wasm2js_i32$1 = __wasm_i64_mul($3, 0, $8, 0)), HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
14626 HEAP32[$2 + 4 >> 2] = i64toi32_i32$HIGH_BITS;
14627 $8 = HEAP32[$4 >> 2];
14628 HEAP32[$8 + 232 >> 2] = HEAP32[$8 + 276 >> 2];
14629 break label$56;
14630 }
14631 if (!$8) {
14632 $8 = $2 + 1160 | 0;
14633 HEAP32[$8 >> 2] = 0;
14634 HEAP32[$8 + 4 >> 2] = 0;
14635 $8 = HEAP32[$4 >> 2];
14636 HEAP32[$8 + 232 >> 2] = HEAP32[$8 + 1136 >> 2];
14637 break label$56;
14638 }
14639 $3 = $2 + 1160 | 0;
14640 (wasm2js_i32$0 = $3, wasm2js_i32$1 = __wasm_i64_mul(HEAP32[$2 + 1136 >> 2], 0, $8, 0)), HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
14641 HEAP32[$3 + 4 >> 2] = i64toi32_i32$HIGH_BITS;
14642 }
14643 if (!($5 | $10 & 1)) {
14644 $2 = HEAP32[$0 >> 2];
14645 break label$4;
14646 }
14647 $2 = HEAP32[$4 >> 2];
14648 }
14649 label$61 : {
14650 if (!HEAP32[$2 + 3632 >> 2]) {
14651 FUNCTION_TABLE[HEAP32[$2 + 32 >> 2]]($0, 3, HEAP32[$2 + 48 >> 2]);
14652 break label$61;
14653 }
14654 HEAP32[$2 + 6152 >> 2] = HEAP32[$2 + 6152 >> 2] + 1;
14655 }
14656 $2 = HEAP32[$0 >> 2];
14657 HEAP32[$2 >> 2] = 2;
14658 break label$4;
14659 }
14660 $5 = HEAP32[$4 >> 2];
14661 HEAP32[$5 + 3520 >> 2] = 1;
14662 HEAP8[$5 + 3590 | 0] = 255;
14663 if (!HEAP32[$5 + 3632 >> 2]) {
14664 FUNCTION_TABLE[HEAP32[$5 + 32 >> 2]]($0, 1, HEAP32[$5 + 48 >> 2])
14665 }
14666 $2 = HEAP32[$0 >> 2];
14667 HEAP32[$2 >> 2] = 2;
14668 }
14669 $8 = 1;
14670 if (HEAP32[$2 >> 2] == 2) {
14671 break label$1
14672 }
14673 $2 = HEAP32[$4 >> 2];
14674 $5 = HEAP32[$2 + 1144 >> 2];
14675 $6 = HEAP32[$2 + 1136 >> 2];
14676 if (!(HEAPU32[$2 + 224 >> 2] >= $5 >>> 0 ? HEAPU32[$2 + 220 >> 2] >= $6 >>> 0 : 0)) {
14677 $3 = HEAP32[$2 + 60 >> 2];
14678 if ($3) {
14679 dlfree($3 + -16 | 0);
14680 HEAP32[HEAP32[$4 >> 2] + 60 >> 2] = 0;
14681 $2 = HEAP32[$4 >> 2];
14682 }
14683 $3 = HEAP32[$2 + 3592 >> 2];
14684 if ($3) {
14685 dlfree($3);
14686 HEAP32[HEAP32[$4 >> 2] + 92 >> 2] = 0;
14687 HEAP32[HEAP32[$4 >> 2] + 3592 >> 2] = 0;
14688 $2 = HEAP32[$4 >> 2];
14689 }
14690 $3 = HEAP32[$2 - -64 >> 2];
14691 if ($3) {
14692 dlfree($3 + -16 | 0);
14693 HEAP32[HEAP32[$4 >> 2] - -64 >> 2] = 0;
14694 $2 = HEAP32[$4 >> 2];
14695 }
14696 $3 = HEAP32[$2 + 3596 >> 2];
14697 if ($3) {
14698 dlfree($3);
14699 HEAP32[HEAP32[$4 >> 2] + 96 >> 2] = 0;
14700 HEAP32[HEAP32[$4 >> 2] + 3596 >> 2] = 0;
14701 $2 = HEAP32[$4 >> 2];
14702 }
14703 $3 = HEAP32[$2 + 68 >> 2];
14704 if ($3) {
14705 dlfree($3 + -16 | 0);
14706 HEAP32[HEAP32[$4 >> 2] + 68 >> 2] = 0;
14707 $2 = HEAP32[$4 >> 2];
14708 }
14709 $3 = HEAP32[$2 + 3600 >> 2];
14710 if ($3) {
14711 dlfree($3);
14712 HEAP32[HEAP32[$4 >> 2] + 100 >> 2] = 0;
14713 HEAP32[HEAP32[$4 >> 2] + 3600 >> 2] = 0;
14714 $2 = HEAP32[$4 >> 2];
14715 }
14716 $3 = HEAP32[$2 + 72 >> 2];
14717 if ($3) {
14718 dlfree($3 + -16 | 0);
14719 HEAP32[HEAP32[$4 >> 2] + 72 >> 2] = 0;
14720 $2 = HEAP32[$4 >> 2];
14721 }
14722 $3 = HEAP32[$2 + 3604 >> 2];
14723 if ($3) {
14724 dlfree($3);
14725 HEAP32[HEAP32[$4 >> 2] + 104 >> 2] = 0;
14726 HEAP32[HEAP32[$4 >> 2] + 3604 >> 2] = 0;
14727 $2 = HEAP32[$4 >> 2];
14728 }
14729 $3 = HEAP32[$2 + 76 >> 2];
14730 if ($3) {
14731 dlfree($3 + -16 | 0);
14732 HEAP32[HEAP32[$4 >> 2] + 76 >> 2] = 0;
14733 $2 = HEAP32[$4 >> 2];
14734 }
14735 $3 = HEAP32[$2 + 3608 >> 2];
14736 if ($3) {
14737 dlfree($3);
14738 HEAP32[HEAP32[$4 >> 2] + 108 >> 2] = 0;
14739 HEAP32[HEAP32[$4 >> 2] + 3608 >> 2] = 0;
14740 $2 = HEAP32[$4 >> 2];
14741 }
14742 $3 = HEAP32[$2 + 80 >> 2];
14743 if ($3) {
14744 dlfree($3 + -16 | 0);
14745 HEAP32[HEAP32[$4 >> 2] + 80 >> 2] = 0;
14746 $2 = HEAP32[$4 >> 2];
14747 }
14748 $3 = HEAP32[$2 + 3612 >> 2];
14749 if ($3) {
14750 dlfree($3);
14751 HEAP32[HEAP32[$4 >> 2] + 112 >> 2] = 0;
14752 HEAP32[HEAP32[$4 >> 2] + 3612 >> 2] = 0;
14753 $2 = HEAP32[$4 >> 2];
14754 }
14755 $3 = HEAP32[$2 + 84 >> 2];
14756 if ($3) {
14757 dlfree($3 + -16 | 0);
14758 HEAP32[HEAP32[$4 >> 2] + 84 >> 2] = 0;
14759 $2 = HEAP32[$4 >> 2];
14760 }
14761 $3 = HEAP32[$2 + 3616 >> 2];
14762 if ($3) {
14763 dlfree($3);
14764 HEAP32[HEAP32[$4 >> 2] + 116 >> 2] = 0;
14765 HEAP32[HEAP32[$4 >> 2] + 3616 >> 2] = 0;
14766 $2 = HEAP32[$4 >> 2];
14767 }
14768 $3 = HEAP32[$2 + 88 >> 2];
14769 if ($3) {
14770 dlfree($3 + -16 | 0);
14771 HEAP32[HEAP32[$4 >> 2] + 88 >> 2] = 0;
14772 $2 = HEAP32[$4 >> 2];
14773 }
14774 $2 = HEAP32[$2 + 3620 >> 2];
14775 if ($2) {
14776 dlfree($2);
14777 HEAP32[HEAP32[$4 >> 2] + 120 >> 2] = 0;
14778 HEAP32[HEAP32[$4 >> 2] + 3620 >> 2] = 0;
14779 }
14780 label$97 : {
14781 if (!$5) {
14782 break label$97
14783 }
14784 if ($6 >>> 0 > 4294967291) {
14785 break label$2
14786 }
14787 $2 = $6 + 4 | 0;
14788 if (($2 & 1073741823) != ($2 | 0)) {
14789 break label$2
14790 }
14791 $9 = $2 << 2;
14792 $3 = 0;
14793 while (1) {
14794 $2 = dlmalloc($9);
14795 if (!$2) {
14796 break label$2
14797 }
14798 HEAP32[$2 >> 2] = 0;
14799 HEAP32[$2 + 4 >> 2] = 0;
14800 HEAP32[$2 + 8 >> 2] = 0;
14801 HEAP32[$2 + 12 >> 2] = 0;
14802 $10 = $3 << 2;
14803 HEAP32[($10 + HEAP32[$4 >> 2] | 0) + 60 >> 2] = $2 + 16;
14804 $2 = $10 + HEAP32[$4 >> 2] | 0;
14805 if (FLAC__memory_alloc_aligned_int32_array($6, $2 + 3592 | 0, $2 + 92 | 0)) {
14806 $3 = $3 + 1 | 0;
14807 if (($5 | 0) == ($3 | 0)) {
14808 break label$97
14809 }
14810 continue;
14811 }
14812 break;
14813 };
14814 HEAP32[HEAP32[$0 >> 2] >> 2] = 8;
14815 break label$3;
14816 }
14817 $2 = HEAP32[$4 >> 2];
14818 HEAP32[$2 + 224 >> 2] = $5;
14819 HEAP32[$2 + 220 >> 2] = $6;
14820 $5 = HEAP32[$2 + 1144 >> 2];
14821 }
14822 label$100 : {
14823 if ($5) {
14824 $17 = HEAP32[1412];
14825 $20 = -1 << $17 ^ -1;
14826 $18 = HEAP32[1406];
14827 $19 = HEAP32[1405];
14828 $21 = HEAP32[1413];
14829 $5 = 0;
14830 while (1) {
14831 $3 = HEAP32[$2 + 1152 >> 2];
14832 label$103 : {
14833 label$104 : {
14834 switch (HEAP32[$2 + 1148 >> 2] + -1 | 0) {
14835 case 0:
14836 $3 = (($5 | 0) == 1) + $3 | 0;
14837 break label$103;
14838 case 1:
14839 $3 = !$5 + $3 | 0;
14840 break label$103;
14841 case 2:
14842 break label$104;
14843 default:
14844 break label$103;
14845 };
14846 }
14847 $3 = (($5 | 0) == 1) + $3 | 0;
14848 }
14849 if (!FLAC__bitreader_read_raw_uint32(HEAP32[$2 + 56 >> 2], $7 + 28 | 0, 8)) {
14850 break label$3
14851 }
14852 $2 = HEAP32[$7 + 28 >> 2];
14853 HEAP32[$7 + 28 >> 2] = $2 & 254;
14854 $13 = $2 & 1;
14855 label$107 : {
14856 if ($13) {
14857 if (!FLAC__bitreader_read_unary_unsigned(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $7 + 32 | 0)) {
14858 break label$3
14859 }
14860 $2 = HEAP32[$4 >> 2];
14861 $6 = HEAP32[$7 + 32 >> 2] + 1 | 0;
14862 HEAP32[($2 + Math_imul($5, 292) | 0) + 1464 >> 2] = $6;
14863 if ($3 >>> 0 <= $6 >>> 0) {
14864 break label$3
14865 }
14866 $3 = $3 - $6 | 0;
14867 break label$107;
14868 }
14869 $2 = HEAP32[$4 >> 2];
14870 HEAP32[($2 + Math_imul($5, 292) | 0) + 1464 >> 2] = 0;
14871 }
14872 $6 = HEAP32[$7 + 28 >> 2];
14873 label$109 : {
14874 if ($6 & 128) {
14875 if (!HEAP32[$2 + 3632 >> 2]) {
14876 FUNCTION_TABLE[HEAP32[$2 + 32 >> 2]]($0, 0, HEAP32[$2 + 48 >> 2])
14877 }
14878 HEAP32[HEAP32[$0 >> 2] >> 2] = 2;
14879 break label$109;
14880 }
14881 label$112 : {
14882 label$113 : {
14883 label$114 : {
14884 switch ($6 | 0) {
14885 case 0:
14886 $6 = HEAP32[(($5 << 2) + $2 | 0) + 60 >> 2];
14887 $9 = Math_imul($5, 292) + $2 | 0;
14888 HEAP32[$9 + 1176 >> 2] = 0;
14889 if (!FLAC__bitreader_read_raw_int32(HEAP32[$2 + 56 >> 2], $7 + 32 | 0, $3)) {
14890 break label$3
14891 }
14892 HEAP32[$9 + 1180 >> 2] = HEAP32[$7 + 32 >> 2];
14893 $2 = 0;
14894 $3 = HEAP32[$4 >> 2];
14895 if (!HEAP32[$3 + 1136 >> 2]) {
14896 break label$113
14897 }
14898 while (1) {
14899 HEAP32[$6 + ($2 << 2) >> 2] = HEAP32[$7 + 32 >> 2];
14900 $2 = $2 + 1 | 0;
14901 if ($2 >>> 0 < HEAPU32[$3 + 1136 >> 2]) {
14902 continue
14903 }
14904 break;
14905 };
14906 break label$113;
14907 case 2:
14908 $6 = ($2 + 1136 | 0) + Math_imul($5, 292) | 0;
14909 $9 = $6 + 44 | 0;
14910 $10 = $5 << 2;
14911 $11 = HEAP32[($10 + $2 | 0) + 92 >> 2];
14912 HEAP32[$9 >> 2] = $11;
14913 HEAP32[$6 + 40 >> 2] = 1;
14914 $6 = 0;
14915 if (HEAP32[$2 + 1136 >> 2]) {
14916 while (1) {
14917 if (!FLAC__bitreader_read_raw_int32(HEAP32[$2 + 56 >> 2], $7 + 32 | 0, $3)) {
14918 break label$3
14919 }
14920 HEAP32[$11 + ($6 << 2) >> 2] = HEAP32[$7 + 32 >> 2];
14921 $6 = $6 + 1 | 0;
14922 $2 = HEAP32[$4 >> 2];
14923 $12 = HEAP32[$2 + 1136 >> 2];
14924 if ($6 >>> 0 < $12 >>> 0) {
14925 continue
14926 }
14927 break;
14928 };
14929 $6 = $12 << 2;
14930 }
14931 memcpy(HEAP32[($2 + $10 | 0) + 60 >> 2], HEAP32[$9 >> 2], $6);
14932 break label$113;
14933 default:
14934 break label$114;
14935 };
14936 }
14937 if ($6 >>> 0 <= 15) {
14938 label$121 : {
14939 if (!HEAP32[$2 + 3632 >> 2]) {
14940 FUNCTION_TABLE[HEAP32[$2 + 32 >> 2]]($0, 3, HEAP32[$2 + 48 >> 2]);
14941 break label$121;
14942 }
14943 HEAP32[$2 + 6152 >> 2] = HEAP32[$2 + 6152 >> 2] + 1;
14944 }
14945 HEAP32[HEAP32[$0 >> 2] >> 2] = 2;
14946 break label$109;
14947 }
14948 if ($6 >>> 0 <= 24) {
14949 $9 = Math_imul($5, 292) + $2 | 0;
14950 HEAP32[$9 + 1176 >> 2] = 2;
14951 $11 = $5 << 2;
14952 $12 = HEAP32[($11 + $2 | 0) + 92 >> 2];
14953 $10 = $6 >>> 1 & 7;
14954 HEAP32[$9 + 1192 >> 2] = $10;
14955 HEAP32[$9 + 1212 >> 2] = $12;
14956 $6 = HEAP32[$2 + 56 >> 2];
14957 if ($10) {
14958 $12 = $9 + 1196 | 0;
14959 $2 = 0;
14960 while (1) {
14961 if (!FLAC__bitreader_read_raw_int32($6, $7 + 32 | 0, $3)) {
14962 break label$3
14963 }
14964 HEAP32[$12 + ($2 << 2) >> 2] = HEAP32[$7 + 32 >> 2];
14965 $6 = HEAP32[HEAP32[$4 >> 2] + 56 >> 2];
14966 $2 = $2 + 1 | 0;
14967 if (($10 | 0) != ($2 | 0)) {
14968 continue
14969 }
14970 break;
14971 };
14972 }
14973 if (!FLAC__bitreader_read_raw_uint32($6, $7 + 16 | 0, $19)) {
14974 break label$3
14975 }
14976 $6 = $9 + 1180 | 0;
14977 $3 = HEAP32[$7 + 16 >> 2];
14978 HEAP32[$6 >> 2] = $3;
14979 $2 = HEAP32[$4 >> 2];
14980 label$126 : {
14981 label$127 : {
14982 if ($3 >>> 0 <= 1) {
14983 if (!FLAC__bitreader_read_raw_uint32(HEAP32[$2 + 56 >> 2], $7 + 16 | 0, $18)) {
14984 break label$3
14985 }
14986 $2 = HEAP32[$4 >> 2];
14987 $3 = HEAP32[$7 + 16 >> 2];
14988 if (HEAP32[$2 + 1136 >> 2] >>> $3 >>> 0 >= $10 >>> 0) {
14989 break label$127
14990 }
14991 if (!HEAP32[$2 + 3632 >> 2]) {
14992 FUNCTION_TABLE[HEAP32[$2 + 32 >> 2]]($0, 0, HEAP32[$2 + 48 >> 2])
14993 }
14994 HEAP32[HEAP32[$0 >> 2] >> 2] = 2;
14995 break label$126;
14996 }
14997 label$130 : {
14998 if (!HEAP32[$2 + 3632 >> 2]) {
14999 FUNCTION_TABLE[HEAP32[$2 + 32 >> 2]]($0, 3, HEAP32[$2 + 48 >> 2]);
15000 break label$130;
15001 }
15002 HEAP32[$2 + 6152 >> 2] = HEAP32[$2 + 6152 >> 2] + 1;
15003 }
15004 HEAP32[HEAP32[$0 >> 2] >> 2] = 2;
15005 break label$126;
15006 }
15007 HEAP32[$9 + 1184 >> 2] = $3;
15008 $2 = Math_imul($5, 12);
15009 HEAP32[$9 + 1188 >> 2] = ($2 + HEAP32[$4 >> 2] | 0) + 124;
15010 $6 = HEAP32[$6 >> 2];
15011 if ($6 >>> 0 < 2) {
15012 $14 = $3;
15013 $3 = HEAP32[$0 + 4 >> 2];
15014 if (!read_residual_partitioned_rice_($0, $10, $14, ($2 + $3 | 0) + 124 | 0, HEAP32[($3 + $11 | 0) + 92 >> 2], ($6 | 0) == 1)) {
15015 break label$3
15016 }
15017 }
15018 $2 = $10 << 2;
15019 memcpy(HEAP32[($11 + HEAP32[$4 >> 2] | 0) + 60 >> 2], $9 + 1196 | 0, $2);
15020 $3 = HEAP32[$4 >> 2];
15021 $6 = $3 + $11 | 0;
15022 FLAC__fixed_restore_signal(HEAP32[$6 + 92 >> 2], HEAP32[$3 + 1136 >> 2] - $10 | 0, $10, $2 + HEAP32[$6 + 60 >> 2] | 0);
15023 }
15024 if (HEAP32[HEAP32[$0 >> 2] >> 2] == 2) {
15025 break label$109
15026 }
15027 if ($13) {
15028 break label$112
15029 }
15030 break label$109;
15031 }
15032 if ($6 >>> 0 <= 63) {
15033 label$134 : {
15034 if (!HEAP32[$2 + 3632 >> 2]) {
15035 FUNCTION_TABLE[HEAP32[$2 + 32 >> 2]]($0, 3, HEAP32[$2 + 48 >> 2]);
15036 break label$134;
15037 }
15038 HEAP32[$2 + 6152 >> 2] = HEAP32[$2 + 6152 >> 2] + 1;
15039 }
15040 HEAP32[HEAP32[$0 >> 2] >> 2] = 2;
15041 break label$109;
15042 }
15043 $9 = Math_imul($5, 292) + $2 | 0;
15044 HEAP32[$9 + 1176 >> 2] = 3;
15045 $11 = $5 << 2;
15046 $15 = HEAP32[($11 + $2 | 0) + 92 >> 2];
15047 $12 = $6 >>> 1 & 31;
15048 $10 = $12 + 1 | 0;
15049 HEAP32[$9 + 1192 >> 2] = $10;
15050 HEAP32[$9 + 1460 >> 2] = $15;
15051 $6 = HEAP32[$2 + 56 >> 2];
15052 $2 = 0;
15053 while (1) {
15054 if (!FLAC__bitreader_read_raw_int32($6, $7 + 32 | 0, $3)) {
15055 break label$3
15056 }
15057 HEAP32[($9 + ($2 << 2) | 0) + 1332 >> 2] = HEAP32[$7 + 32 >> 2];
15058 $15 = ($2 | 0) != ($12 | 0);
15059 $6 = HEAP32[HEAP32[$4 >> 2] + 56 >> 2];
15060 $2 = $2 + 1 | 0;
15061 if ($15) {
15062 continue
15063 }
15064 break;
15065 };
15066 if (!FLAC__bitreader_read_raw_uint32($6, $7 + 16 | 0, $17)) {
15067 break label$3
15068 }
15069 $2 = HEAP32[$7 + 16 >> 2];
15070 label$137 : {
15071 if (($2 | 0) == ($20 | 0)) {
15072 $2 = HEAP32[$4 >> 2];
15073 if (!HEAP32[$2 + 3632 >> 2]) {
15074 FUNCTION_TABLE[HEAP32[$2 + 32 >> 2]]($0, 0, HEAP32[$2 + 48 >> 2])
15075 }
15076 HEAP32[HEAP32[$0 >> 2] >> 2] = 2;
15077 break label$137;
15078 }
15079 $16 = $9 + 1196 | 0;
15080 HEAP32[$16 >> 2] = $2 + 1;
15081 if (!FLAC__bitreader_read_raw_int32(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $7 + 32 | 0, $21)) {
15082 break label$3
15083 }
15084 $2 = HEAP32[$7 + 32 >> 2];
15085 if (($2 | 0) <= -1) {
15086 $2 = HEAP32[$4 >> 2];
15087 if (!HEAP32[$2 + 3632 >> 2]) {
15088 FUNCTION_TABLE[HEAP32[$2 + 32 >> 2]]($0, 0, HEAP32[$2 + 48 >> 2])
15089 }
15090 HEAP32[HEAP32[$0 >> 2] >> 2] = 2;
15091 break label$137;
15092 }
15093 $15 = $9 + 1200 | 0;
15094 HEAP32[$15 >> 2] = $2;
15095 $6 = HEAP32[HEAP32[$4 >> 2] + 56 >> 2];
15096 $2 = 0;
15097 while (1) {
15098 if (!FLAC__bitreader_read_raw_int32($6, $7 + 32 | 0, HEAP32[$16 >> 2])) {
15099 break label$3
15100 }
15101 HEAP32[($9 + ($2 << 2) | 0) + 1204 >> 2] = HEAP32[$7 + 32 >> 2];
15102 $14 = ($2 | 0) != ($12 | 0);
15103 $6 = HEAP32[HEAP32[$4 >> 2] + 56 >> 2];
15104 $2 = $2 + 1 | 0;
15105 if ($14) {
15106 continue
15107 }
15108 break;
15109 };
15110 if (!FLAC__bitreader_read_raw_uint32($6, $7 + 16 | 0, $19)) {
15111 break label$3
15112 }
15113 $14 = $9 + 1180 | 0;
15114 $6 = HEAP32[$7 + 16 >> 2];
15115 HEAP32[$14 >> 2] = $6;
15116 $2 = HEAP32[$4 >> 2];
15117 label$143 : {
15118 if ($6 >>> 0 <= 1) {
15119 if (!FLAC__bitreader_read_raw_uint32(HEAP32[$2 + 56 >> 2], $7 + 16 | 0, $18)) {
15120 break label$3
15121 }
15122 $2 = HEAP32[$4 >> 2];
15123 $6 = HEAP32[$7 + 16 >> 2];
15124 if (HEAP32[$2 + 1136 >> 2] >>> $6 >>> 0 > $12 >>> 0) {
15125 break label$143
15126 }
15127 if (!HEAP32[$2 + 3632 >> 2]) {
15128 FUNCTION_TABLE[HEAP32[$2 + 32 >> 2]]($0, 0, HEAP32[$2 + 48 >> 2])
15129 }
15130 HEAP32[HEAP32[$0 >> 2] >> 2] = 2;
15131 break label$137;
15132 }
15133 label$146 : {
15134 if (!HEAP32[$2 + 3632 >> 2]) {
15135 FUNCTION_TABLE[HEAP32[$2 + 32 >> 2]]($0, 3, HEAP32[$2 + 48 >> 2]);
15136 break label$146;
15137 }
15138 HEAP32[$2 + 6152 >> 2] = HEAP32[$2 + 6152 >> 2] + 1;
15139 }
15140 HEAP32[HEAP32[$0 >> 2] >> 2] = 2;
15141 break label$137;
15142 }
15143 HEAP32[$9 + 1184 >> 2] = $6;
15144 $2 = Math_imul($5, 12);
15145 HEAP32[$9 + 1188 >> 2] = ($2 + HEAP32[$4 >> 2] | 0) + 124;
15146 $12 = HEAP32[$14 >> 2];
15147 if ($12 >>> 0 < 2) {
15148 $14 = $6;
15149 $6 = HEAP32[$0 + 4 >> 2];
15150 if (!read_residual_partitioned_rice_($0, $10, $14, ($2 + $6 | 0) + 124 | 0, HEAP32[($6 + $11 | 0) + 92 >> 2], ($12 | 0) == 1)) {
15151 break label$3
15152 }
15153 }
15154 $6 = $10 << 2;
15155 memcpy(HEAP32[(HEAP32[$4 >> 2] + $11 | 0) + 60 >> 2], $9 + 1332 | 0, $6);
15156 label$149 : {
15157 $12 = HEAP32[$16 >> 2];
15158 if ($12 + ((Math_clz32($10) ^ 31) + $3 | 0) >>> 0 <= 32) {
15159 $2 = HEAP32[$4 >> 2];
15160 if ($3 >>> 0 > 16 | $12 >>> 0 > 16) {
15161 break label$149
15162 }
15163 $3 = $2 + $11 | 0;
15164 FUNCTION_TABLE[HEAP32[$2 + 44 >> 2]](HEAP32[$3 + 92 >> 2], HEAP32[$2 + 1136 >> 2] - $10 | 0, $9 + 1204 | 0, $10, HEAP32[$15 >> 2], $6 + HEAP32[$3 + 60 >> 2] | 0);
15165 break label$137;
15166 }
15167 $2 = HEAP32[$4 >> 2];
15168 $3 = $2 + $11 | 0;
15169 FUNCTION_TABLE[HEAP32[$2 + 40 >> 2]](HEAP32[$3 + 92 >> 2], HEAP32[$2 + 1136 >> 2] - $10 | 0, $9 + 1204 | 0, $10, HEAP32[$15 >> 2], $6 + HEAP32[$3 + 60 >> 2] | 0);
15170 break label$137;
15171 }
15172 $3 = $2 + $11 | 0;
15173 FUNCTION_TABLE[HEAP32[$2 + 36 >> 2]](HEAP32[$3 + 92 >> 2], HEAP32[$2 + 1136 >> 2] - $10 | 0, $9 + 1204 | 0, $10, HEAP32[$15 >> 2], $6 + HEAP32[$3 + 60 >> 2] | 0);
15174 }
15175 if (!$13 | HEAP32[HEAP32[$0 >> 2] >> 2] == 2) {
15176 break label$109
15177 }
15178 break label$112;
15179 }
15180 if (!$13) {
15181 break label$109
15182 }
15183 }
15184 $3 = HEAP32[$4 >> 2];
15185 $2 = HEAP32[($3 + Math_imul($5, 292) | 0) + 1464 >> 2];
15186 HEAP32[$7 + 28 >> 2] = $2;
15187 if (!HEAP32[$3 + 1136 >> 2]) {
15188 break label$109
15189 }
15190 $6 = HEAP32[($3 + ($5 << 2) | 0) + 60 >> 2];
15191 HEAP32[$6 >> 2] = HEAP32[$6 >> 2] << $2;
15192 $2 = 1;
15193 if (HEAPU32[$3 + 1136 >> 2] < 2) {
15194 break label$109
15195 }
15196 while (1) {
15197 $9 = $6 + ($2 << 2) | 0;
15198 HEAP32[$9 >> 2] = HEAP32[$9 >> 2] << HEAP32[$7 + 28 >> 2];
15199 $2 = $2 + 1 | 0;
15200 if ($2 >>> 0 < HEAPU32[$3 + 1136 >> 2]) {
15201 continue
15202 }
15203 break;
15204 };
15205 }
15206 if (HEAP32[HEAP32[$0 >> 2] >> 2] == 2) {
15207 break label$100
15208 }
15209 $5 = $5 + 1 | 0;
15210 $2 = HEAP32[$4 >> 2];
15211 if ($5 >>> 0 < HEAPU32[$2 + 1144 >> 2]) {
15212 continue
15213 }
15214 break;
15215 };
15216 }
15217 label$152 : {
15218 if (FLAC__bitreader_is_consumed_byte_aligned(HEAP32[$2 + 56 >> 2])) {
15219 break label$152
15220 }
15221 HEAP32[$7 + 32 >> 2] = 0;
15222 $5 = HEAP32[HEAP32[$4 >> 2] + 56 >> 2];
15223 if (!FLAC__bitreader_read_raw_uint32($5, $7 + 32 | 0, FLAC__bitreader_bits_left_for_byte_alignment($5))) {
15224 break label$3
15225 }
15226 if (!HEAP32[$7 + 32 >> 2]) {
15227 break label$152
15228 }
15229 $5 = HEAP32[$4 >> 2];
15230 if (!HEAP32[$5 + 3632 >> 2]) {
15231 FUNCTION_TABLE[HEAP32[$5 + 32 >> 2]]($0, 0, HEAP32[$5 + 48 >> 2])
15232 }
15233 HEAP32[HEAP32[$0 >> 2] >> 2] = 2;
15234 }
15235 if (HEAP32[HEAP32[$0 >> 2] >> 2] == 2) {
15236 break label$1
15237 }
15238 $5 = FLAC__bitreader_get_read_crc16(HEAP32[HEAP32[$4 >> 2] + 56 >> 2]);
15239 $8 = 0;
15240 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$4 >> 2] + 56 >> 2], $7 + 16 | 0, HEAP32[1404])) {
15241 break label$1
15242 }
15243 label$154 : {
15244 if (($5 | 0) == HEAP32[$7 + 16 >> 2]) {
15245 label$156 : {
15246 label$157 : {
15247 label$158 : {
15248 $5 = HEAP32[$4 >> 2];
15249 switch (HEAP32[$5 + 1148 >> 2] + -1 | 0) {
15250 case 2:
15251 break label$156;
15252 case 0:
15253 break label$157;
15254 case 1:
15255 break label$158;
15256 default:
15257 break label$154;
15258 };
15259 }
15260 if (!HEAP32[$5 + 1136 >> 2]) {
15261 break label$154
15262 }
15263 $2 = HEAP32[$5 - -64 >> 2];
15264 $6 = HEAP32[$5 + 60 >> 2];
15265 $3 = 0;
15266 while (1) {
15267 $9 = $3 << 2;
15268 $10 = $9 + $6 | 0;
15269 HEAP32[$10 >> 2] = HEAP32[$10 >> 2] + HEAP32[$2 + $9 >> 2];
15270 $3 = $3 + 1 | 0;
15271 if ($3 >>> 0 < HEAPU32[$5 + 1136 >> 2]) {
15272 continue
15273 }
15274 break;
15275 };
15276 break label$154;
15277 }
15278 if (!HEAP32[$5 + 1136 >> 2]) {
15279 break label$154
15280 }
15281 $2 = HEAP32[$5 - -64 >> 2];
15282 $6 = HEAP32[$5 + 60 >> 2];
15283 $3 = 0;
15284 while (1) {
15285 $9 = $3 << 2;
15286 $10 = $9 + $2 | 0;
15287 HEAP32[$10 >> 2] = HEAP32[$6 + $9 >> 2] - HEAP32[$10 >> 2];
15288 $3 = $3 + 1 | 0;
15289 if ($3 >>> 0 < HEAPU32[$5 + 1136 >> 2]) {
15290 continue
15291 }
15292 break;
15293 };
15294 break label$154;
15295 }
15296 if (!HEAP32[$5 + 1136 >> 2]) {
15297 break label$154
15298 }
15299 $10 = HEAP32[$5 - -64 >> 2];
15300 $11 = HEAP32[$5 + 60 >> 2];
15301 $3 = 0;
15302 while (1) {
15303 $6 = $3 << 2;
15304 $2 = $6 + $11 | 0;
15305 $13 = $6 + $10 | 0;
15306 $6 = HEAP32[$13 >> 2];
15307 $9 = $6 & 1 | HEAP32[$2 >> 2] << 1;
15308 HEAP32[$2 >> 2] = $6 + $9 >> 1;
15309 HEAP32[$13 >> 2] = $9 - $6 >> 1;
15310 $3 = $3 + 1 | 0;
15311 if ($3 >>> 0 < HEAPU32[$5 + 1136 >> 2]) {
15312 continue
15313 }
15314 break;
15315 };
15316 break label$154;
15317 }
15318 $5 = HEAP32[$4 >> 2];
15319 if (!HEAP32[$5 + 3632 >> 2]) {
15320 FUNCTION_TABLE[HEAP32[$5 + 32 >> 2]]($0, 2, HEAP32[$5 + 48 >> 2])
15321 }
15322 $2 = HEAP32[$4 >> 2];
15323 if (!HEAP32[$2 + 1144 >> 2]) {
15324 break label$154
15325 }
15326 $3 = 0;
15327 while (1) {
15328 memset(HEAP32[(($3 << 2) + $2 | 0) + 60 >> 2], HEAP32[$2 + 1136 >> 2] << 2);
15329 $3 = $3 + 1 | 0;
15330 $2 = HEAP32[$4 >> 2];
15331 if ($3 >>> 0 < HEAPU32[$2 + 1144 >> 2]) {
15332 continue
15333 }
15334 break;
15335 };
15336 }
15337 HEAP32[$1 >> 2] = 1;
15338 $2 = HEAP32[$4 >> 2];
15339 $1 = HEAP32[$2 + 232 >> 2];
15340 if ($1) {
15341 HEAP32[$2 + 228 >> 2] = $1
15342 }
15343 $1 = HEAP32[$0 >> 2];
15344 $6 = HEAP32[$2 + 1144 >> 2];
15345 HEAP32[$1 + 8 >> 2] = $6;
15346 HEAP32[$1 + 12 >> 2] = HEAP32[$2 + 1148 >> 2];
15347 $13 = HEAP32[$2 + 1152 >> 2];
15348 HEAP32[$1 + 16 >> 2] = $13;
15349 HEAP32[$1 + 20 >> 2] = HEAP32[$2 + 1140 >> 2];
15350 $5 = HEAP32[$2 + 1136 >> 2];
15351 HEAP32[$1 + 24 >> 2] = $5;
15352 $1 = $2 + 1160 | 0;
15353 $9 = HEAP32[$1 >> 2];
15354 $3 = HEAP32[$1 + 4 >> 2];
15355 $1 = $3;
15356 $12 = $5 + $9 | 0;
15357 if ($12 >>> 0 < $5 >>> 0) {
15358 $1 = $1 + 1 | 0
15359 }
15360 HEAP32[$2 + 240 >> 2] = $12;
15361 HEAP32[$2 + 244 >> 2] = $1;
15362 $10 = $2 + 60 | 0;
15363 $11 = $2 + 1136 | 0;
15364 label$165 : {
15365 label$166 : {
15366 label$167 : {
15367 if (HEAP32[$2 + 3632 >> 2]) {
15368 HEAP32[$2 + 6156 >> 2] = 1;
15369 $13 = HEAP32[$2 + 6144 >> 2];
15370 $5 = HEAP32[$2 + 6148 >> 2];
15371 memcpy($2 + 3752 | 0, $11, 2384);
15372 if (($3 | 0) == ($5 | 0) & $13 >>> 0 < $9 >>> 0 | $5 >>> 0 < $3 >>> 0 | (($1 | 0) == ($5 | 0) & $13 >>> 0 >= $12 >>> 0 | $5 >>> 0 > $1 >>> 0)) {
15373 break label$165
15374 }
15375 $3 = 0;
15376 $1 = HEAP32[$4 >> 2];
15377 HEAP32[$1 + 3632 >> 2] = 0;
15378 $5 = $13 - $9 | 0;
15379 $4 = $5;
15380 if ($4) {
15381 if ($6) {
15382 while (1) {
15383 $9 = $3 << 2;
15384 HEAP32[$9 + ($7 + 32 | 0) >> 2] = HEAP32[($2 + $9 | 0) + 60 >> 2] + ($4 << 2);
15385 $3 = $3 + 1 | 0;
15386 if (($6 | 0) != ($3 | 0)) {
15387 continue
15388 }
15389 break;
15390 }
15391 }
15392 HEAP32[$1 + 3752 >> 2] = HEAP32[$1 + 3752 >> 2] - $4;
15393 $2 = $1 + 3776 | 0;
15394 $4 = $2;
15395 $3 = $2;
15396 $1 = HEAP32[$2 + 4 >> 2];
15397 $2 = $5 + HEAP32[$2 >> 2] | 0;
15398 if ($2 >>> 0 < $5 >>> 0) {
15399 $1 = $1 + 1 | 0
15400 }
15401 HEAP32[$3 >> 2] = $2;
15402 HEAP32[$4 + 4 >> 2] = $1;
15403 $1 = HEAP32[$0 + 4 >> 2];
15404 $1 = FUNCTION_TABLE[HEAP32[$1 + 24 >> 2]]($0, $1 + 3752 | 0, $7 + 32 | 0, HEAP32[$1 + 48 >> 2]) | 0;
15405 break label$167;
15406 }
15407 $1 = FUNCTION_TABLE[HEAP32[$1 + 24 >> 2]]($0, $11, $10, HEAP32[$1 + 48 >> 2]) | 0;
15408 break label$167;
15409 }
15410 label$172 : {
15411 if (!HEAP32[$2 + 248 >> 2]) {
15412 HEAP32[$2 + 3624 >> 2] = 0;
15413 break label$172;
15414 }
15415 if (!HEAP32[$2 + 3624 >> 2]) {
15416 break label$172
15417 }
15418 if (!FLAC__MD5Accumulate($2 + 3636 | 0, $10, $6, $5, $13 + 7 >>> 3 | 0)) {
15419 break label$166
15420 }
15421 $2 = HEAP32[$4 >> 2];
15422 }
15423 $1 = FUNCTION_TABLE[HEAP32[$2 + 24 >> 2]]($0, $11, $10, HEAP32[$2 + 48 >> 2]) | 0;
15424 }
15425 if (!$1) {
15426 break label$165
15427 }
15428 }
15429 HEAP32[HEAP32[$0 >> 2] >> 2] = 7;
15430 break label$1;
15431 }
15432 HEAP32[HEAP32[$0 >> 2] >> 2] = 2;
15433 }
15434 $8 = 1;
15435 break label$1;
15436 }
15437 $8 = 0;
15438 break label$1;
15439 }
15440 HEAP32[HEAP32[$0 >> 2] >> 2] = 8;
15441 $8 = 0;
15442 }
15443 global$0 = $7 - -64 | 0;
15444 return $8;
15445 }
15446
15447 function read_residual_partitioned_rice_($0, $1, $2, $3, $4, $5) {
15448 var $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0;
15449 $6 = global$0 - 16 | 0;
15450 global$0 = $6;
15451 $7 = HEAP32[HEAP32[$0 + 4 >> 2] + 1136 >> 2];
15452 $11 = HEAP32[($5 ? 5644 : 5640) >> 2];
15453 $12 = HEAP32[($5 ? 5632 : 5628) >> 2];
15454 label$1 : {
15455 label$2 : {
15456 if (FLAC__format_entropy_coding_method_partitioned_rice_contents_ensure_size($3, $2 >>> 0 > 6 ? $2 : 6)) {
15457 $8 = $2 ? $7 >>> $2 | 0 : $7 - $1 | 0;
15458 $13 = HEAP32[1409];
15459 if (!$2) {
15460 break label$2
15461 }
15462 $5 = 0;
15463 while (1) {
15464 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$0 + 4 >> 2] + 56 >> 2], $6 + 12 | 0, $12)) {
15465 $7 = 0;
15466 break label$1;
15467 }
15468 $9 = $10 << 2;
15469 HEAP32[$9 + HEAP32[$3 >> 2] >> 2] = HEAP32[$6 + 12 >> 2];
15470 label$6 : {
15471 if (HEAPU32[$6 + 12 >> 2] < $11 >>> 0) {
15472 $7 = 0;
15473 HEAP32[$9 + HEAP32[$3 + 4 >> 2] >> 2] = 0;
15474 $9 = $8 - ($10 ? 0 : $1) | 0;
15475 if (!FLAC__bitreader_read_rice_signed_block(HEAP32[HEAP32[$0 + 4 >> 2] + 56 >> 2], ($5 << 2) + $4 | 0, $9, HEAP32[$6 + 12 >> 2])) {
15476 break label$1
15477 }
15478 $5 = $5 + $9 | 0;
15479 break label$6;
15480 }
15481 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$0 + 4 >> 2] + 56 >> 2], $6 + 12 | 0, $13)) {
15482 $7 = 0;
15483 break label$1;
15484 }
15485 HEAP32[$9 + HEAP32[$3 + 4 >> 2] >> 2] = HEAP32[$6 + 12 >> 2];
15486 $7 = $10 ? 0 : $1;
15487 if ($7 >>> 0 >= $8 >>> 0) {
15488 break label$6
15489 }
15490 while (1) {
15491 if (!FLAC__bitreader_read_raw_int32(HEAP32[HEAP32[$0 + 4 >> 2] + 56 >> 2], $6 + 8 | 0, HEAP32[$6 + 12 >> 2])) {
15492 $7 = 0;
15493 break label$1;
15494 }
15495 HEAP32[($5 << 2) + $4 >> 2] = HEAP32[$6 + 8 >> 2];
15496 $5 = $5 + 1 | 0;
15497 $7 = $7 + 1 | 0;
15498 if (($8 | 0) != ($7 | 0)) {
15499 continue
15500 }
15501 break;
15502 };
15503 }
15504 $7 = 1;
15505 $10 = $10 + 1 | 0;
15506 if (!($10 >>> $2)) {
15507 continue
15508 }
15509 break;
15510 };
15511 break label$1;
15512 }
15513 HEAP32[HEAP32[$0 >> 2] >> 2] = 8;
15514 $7 = 0;
15515 break label$1;
15516 }
15517 $7 = 0;
15518 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$0 + 4 >> 2] + 56 >> 2], $6 + 12 | 0, $12)) {
15519 break label$1
15520 }
15521 HEAP32[HEAP32[$3 >> 2] >> 2] = HEAP32[$6 + 12 >> 2];
15522 label$11 : {
15523 if (HEAPU32[$6 + 12 >> 2] >= $11 >>> 0) {
15524 if (!FLAC__bitreader_read_raw_uint32(HEAP32[HEAP32[$0 + 4 >> 2] + 56 >> 2], $6 + 12 | 0, $13)) {
15525 break label$1
15526 }
15527 HEAP32[HEAP32[$3 + 4 >> 2] >> 2] = HEAP32[$6 + 12 >> 2];
15528 if (!$8) {
15529 break label$11
15530 }
15531 $5 = 0;
15532 while (1) {
15533 if (!FLAC__bitreader_read_raw_int32(HEAP32[HEAP32[$0 + 4 >> 2] + 56 >> 2], $6 + 8 | 0, HEAP32[$6 + 12 >> 2])) {
15534 $7 = 0;
15535 break label$1;
15536 }
15537 HEAP32[($5 << 2) + $4 >> 2] = HEAP32[$6 + 8 >> 2];
15538 $5 = $5 + 1 | 0;
15539 $7 = $7 + 1 | 0;
15540 if (($8 | 0) != ($7 | 0)) {
15541 continue
15542 }
15543 break;
15544 };
15545 break label$11;
15546 }
15547 HEAP32[HEAP32[$3 + 4 >> 2] >> 2] = 0;
15548 if (!FLAC__bitreader_read_rice_signed_block(HEAP32[HEAP32[$0 + 4 >> 2] + 56 >> 2], $4, $8, HEAP32[$6 + 12 >> 2])) {
15549 break label$1
15550 }
15551 }
15552 $7 = 1;
15553 }
15554 global$0 = $6 + 16 | 0;
15555 return $7;
15556 }
15557
15558 function FLAC__stream_decoder_process_until_end_of_metadata($0) {
15559 $0 = $0 | 0;
15560 var $1 = 0, $2 = 0;
15561 label$1 : {
15562 label$2 : {
15563 while (1) {
15564 label$4 : {
15565 $1 = 1;
15566 label$5 : {
15567 switch (HEAP32[HEAP32[$0 >> 2] >> 2]) {
15568 case 0:
15569 if (find_metadata_($0)) {
15570 continue
15571 }
15572 break label$4;
15573 case 2:
15574 case 3:
15575 case 4:
15576 case 7:
15577 break label$2;
15578 case 1:
15579 break label$5;
15580 default:
15581 break label$1;
15582 };
15583 }
15584 if (read_metadata_($0)) {
15585 continue
15586 }
15587 }
15588 break;
15589 };
15590 $1 = 0;
15591 }
15592 $2 = $1;
15593 }
15594 return $2 | 0;
15595 }
15596
15597 function FLAC__stream_decoder_process_until_end_of_stream($0) {
15598 $0 = $0 | 0;
15599 var $1 = 0, $2 = 0, $3 = 0;
15600 $1 = global$0 - 16 | 0;
15601 global$0 = $1;
15602 $2 = 1;
15603 label$1 : {
15604 label$2 : {
15605 while (1) {
15606 label$4 : {
15607 label$5 : {
15608 switch (HEAP32[HEAP32[$0 >> 2] >> 2]) {
15609 case 0:
15610 if (find_metadata_($0)) {
15611 continue
15612 }
15613 break label$4;
15614 case 1:
15615 if (read_metadata_($0)) {
15616 continue
15617 }
15618 break label$4;
15619 case 2:
15620 if (frame_sync_($0)) {
15621 continue
15622 }
15623 break label$2;
15624 case 4:
15625 case 7:
15626 break label$2;
15627 case 3:
15628 break label$5;
15629 default:
15630 break label$1;
15631 };
15632 }
15633 if (read_frame_($0, $1 + 12 | 0)) {
15634 continue
15635 }
15636 }
15637 break;
15638 };
15639 $2 = 0;
15640 }
15641 $3 = $2;
15642 }
15643 global$0 = $1 + 16 | 0;
15644 return $3 | 0;
15645 }
15646
15647 function read_callback_proxy_($0, $1, $2, $3) {
15648 $0 = $0 | 0;
15649 $1 = $1 | 0;
15650 $2 = $2 | 0;
15651 $3 = $3 | 0;
15652 $0 = FUNCTION_TABLE[HEAP32[HEAP32[$0 + 4 >> 2] + 4 >> 2]]($0, $1, $2, $3) | 0;
15653 if ($0 >>> 0 <= 2) {
15654 return HEAP32[($0 << 2) + 7572 >> 2]
15655 }
15656 return 5;
15657 }
15658
15659 function FLAC__bitwriter_free($0) {
15660 var $1 = 0;
15661 $1 = HEAP32[$0 >> 2];
15662 if ($1) {
15663 dlfree($1)
15664 }
15665 HEAP32[$0 + 16 >> 2] = 0;
15666 HEAP32[$0 >> 2] = 0;
15667 HEAP32[$0 + 8 >> 2] = 0;
15668 HEAP32[$0 + 12 >> 2] = 0;
15669 }
15670
15671 function FLAC__bitwriter_init($0) {
15672 var $1 = 0;
15673 HEAP32[$0 + 16 >> 2] = 0;
15674 HEAP32[$0 + 8 >> 2] = 8192;
15675 HEAP32[$0 + 12 >> 2] = 0;
15676 $1 = $0;
15677 $0 = dlmalloc(32768);
15678 HEAP32[$1 >> 2] = $0;
15679 return ($0 | 0) != 0;
15680 }
15681
15682 function FLAC__bitwriter_clear($0) {
15683 HEAP32[$0 + 12 >> 2] = 0;
15684 HEAP32[$0 + 16 >> 2] = 0;
15685 }
15686
15687 function FLAC__bitwriter_get_write_crc16($0, $1) {
15688 var $2 = 0, $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
15689 $2 = global$0 - 16 | 0;
15690 global$0 = $2;
15691 $3 = 0;
15692 label$1 : {
15693 if (!FLAC__bitwriter_get_buffer($0, $2 + 12 | 0, $2 + 8 | 0)) {
15694 break label$1
15695 }
15696 (wasm2js_i32$0 = $1, wasm2js_i32$1 = FLAC__crc16(HEAP32[$2 + 12 >> 2], HEAP32[$2 + 8 >> 2])), HEAP16[wasm2js_i32$0 >> 1] = wasm2js_i32$1;
15697 $3 = 1;
15698 }
15699 global$0 = $2 + 16 | 0;
15700 return $3;
15701 }
15702
15703 function FLAC__bitwriter_get_buffer($0, $1, $2) {
15704 var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0;
15705 $5 = HEAP32[$0 + 16 >> 2];
15706 label$1 : {
15707 if ($5 & 7) {
15708 break label$1
15709 }
15710 label$2 : {
15711 if (!$5) {
15712 $4 = HEAP32[$0 >> 2];
15713 $3 = 0;
15714 break label$2;
15715 }
15716 $6 = HEAP32[$0 + 12 >> 2];
15717 label$4 : {
15718 if (($6 | 0) != HEAP32[$0 + 8 >> 2]) {
15719 break label$4
15720 }
15721 $4 = $5 + 63 >>> 5 | 0;
15722 $3 = $4 + $6 | 0;
15723 if ($3 >>> 0 <= $6 >>> 0) {
15724 break label$4
15725 }
15726 $6 = 0;
15727 $5 = HEAP32[$0 >> 2];
15728 $7 = $3;
15729 $3 = $4 & 1023;
15730 $3 = $7 + ($3 ? 1024 - $3 | 0 : 0) | 0;
15731 label$5 : {
15732 if ($3) {
15733 if (($3 | 0) != ($3 & 1073741823)) {
15734 break label$1
15735 }
15736 $4 = dlrealloc($5, $3 << 2);
15737 if ($4) {
15738 break label$5
15739 }
15740 dlfree($5);
15741 return 0;
15742 }
15743 $4 = dlrealloc($5, 0);
15744 if (!$4) {
15745 break label$1
15746 }
15747 }
15748 HEAP32[$0 + 8 >> 2] = $3;
15749 HEAP32[$0 >> 2] = $4;
15750 $6 = HEAP32[$0 + 12 >> 2];
15751 $5 = HEAP32[$0 + 16 >> 2];
15752 }
15753 $4 = HEAP32[$0 >> 2];
15754 $3 = HEAP32[$0 + 4 >> 2] << 32 - $5;
15755 HEAP32[$4 + ($6 << 2) >> 2] = $3 << 24 | $3 << 8 & 16711680 | ($3 >>> 8 & 65280 | $3 >>> 24);
15756 $3 = HEAP32[$0 + 16 >> 2] >>> 3 | 0;
15757 }
15758 HEAP32[$1 >> 2] = $4;
15759 HEAP32[$2 >> 2] = $3 + (HEAP32[$0 + 12 >> 2] << 2);
15760 $6 = 1;
15761 }
15762 return $6;
15763 }
15764
15765 function FLAC__bitwriter_get_write_crc8($0, $1) {
15766 var $2 = 0, $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
15767 $2 = global$0 - 16 | 0;
15768 global$0 = $2;
15769 $3 = 0;
15770 label$1 : {
15771 if (!FLAC__bitwriter_get_buffer($0, $2 + 12 | 0, $2 + 8 | 0)) {
15772 break label$1
15773 }
15774 (wasm2js_i32$0 = $1, wasm2js_i32$1 = FLAC__crc8(HEAP32[$2 + 12 >> 2], HEAP32[$2 + 8 >> 2])), HEAP8[wasm2js_i32$0 | 0] = wasm2js_i32$1;
15775 $3 = 1;
15776 }
15777 global$0 = $2 + 16 | 0;
15778 return $3;
15779 }
15780
15781 function FLAC__bitwriter_write_zeroes($0, $1) {
15782 var $2 = 0, $3 = 0, $4 = 0, $5 = 0;
15783 label$1 : {
15784 label$2 : {
15785 if (!$1) {
15786 break label$2
15787 }
15788 $2 = HEAP32[$0 + 8 >> 2];
15789 $3 = HEAP32[$0 + 12 >> 2];
15790 label$3 : {
15791 if ($2 >>> 0 > $3 + $1 >>> 0) {
15792 break label$3
15793 }
15794 $4 = $3 + ((HEAP32[$0 + 16 >> 2] + $1 | 0) + 31 >>> 5 | 0) | 0;
15795 if ($4 >>> 0 <= $2 >>> 0) {
15796 break label$3
15797 }
15798 $3 = 0;
15799 $5 = HEAP32[$0 >> 2];
15800 $2 = $4 - $2 & 1023;
15801 $2 = $4 + ($2 ? 1024 - $2 | 0 : 0) | 0;
15802 label$4 : {
15803 if ($2) {
15804 if (($2 | 0) != ($2 & 1073741823)) {
15805 break label$1
15806 }
15807 $4 = dlrealloc($5, $2 << 2);
15808 if ($4) {
15809 break label$4
15810 }
15811 dlfree($5);
15812 return 0;
15813 }
15814 $4 = dlrealloc($5, 0);
15815 if (!$4) {
15816 break label$1
15817 }
15818 }
15819 HEAP32[$0 + 8 >> 2] = $2;
15820 HEAP32[$0 >> 2] = $4;
15821 }
15822 $2 = HEAP32[$0 + 16 >> 2];
15823 if ($2) {
15824 $4 = $2;
15825 $2 = 32 - $2 | 0;
15826 $3 = $2 >>> 0 < $1 >>> 0 ? $2 : $1;
15827 $5 = $4 + $3 | 0;
15828 HEAP32[$0 + 16 >> 2] = $5;
15829 $2 = HEAP32[$0 + 4 >> 2] << $3;
15830 HEAP32[$0 + 4 >> 2] = $2;
15831 if (($5 | 0) != 32) {
15832 break label$2
15833 }
15834 $5 = HEAP32[$0 + 12 >> 2];
15835 HEAP32[$0 + 12 >> 2] = $5 + 1;
15836 HEAP32[HEAP32[$0 >> 2] + ($5 << 2) >> 2] = $2 << 8 & 16711680 | $2 << 24 | ($2 >>> 8 & 65280 | $2 >>> 24);
15837 HEAP32[$0 + 16 >> 2] = 0;
15838 $1 = $1 - $3 | 0;
15839 }
15840 if ($1 >>> 0 >= 32) {
15841 $2 = HEAP32[$0 >> 2];
15842 while (1) {
15843 $3 = HEAP32[$0 + 12 >> 2];
15844 HEAP32[$0 + 12 >> 2] = $3 + 1;
15845 HEAP32[$2 + ($3 << 2) >> 2] = 0;
15846 $1 = $1 + -32 | 0;
15847 if ($1 >>> 0 > 31) {
15848 continue
15849 }
15850 break;
15851 };
15852 }
15853 if (!$1) {
15854 break label$2
15855 }
15856 HEAP32[$0 + 16 >> 2] = $1;
15857 HEAP32[$0 + 4 >> 2] = 0;
15858 }
15859 $3 = 1;
15860 }
15861 return $3;
15862 }
15863
15864 function FLAC__bitwriter_write_raw_uint32($0, $1, $2) {
15865 var $3 = 0;
15866 label$1 : {
15867 if ($2 >>> 0 <= 31) {
15868 $3 = 0;
15869 if ($1 >>> $2) {
15870 break label$1
15871 }
15872 }
15873 $3 = FLAC__bitwriter_write_raw_uint32_nocheck($0, $1, $2);
15874 }
15875 return $3;
15876 }
15877
15878 function FLAC__bitwriter_write_raw_uint32_nocheck($0, $1, $2) {
15879 var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0;
15880 label$1 : {
15881 if (!$0 | $2 >>> 0 > 32) {
15882 break label$1
15883 }
15884 $4 = HEAP32[$0 >> 2];
15885 if (!$4) {
15886 break label$1
15887 }
15888 $6 = 1;
15889 if (!$2) {
15890 break label$1
15891 }
15892 $7 = HEAP32[$0 + 8 >> 2];
15893 $3 = HEAP32[$0 + 12 >> 2];
15894 label$2 : {
15895 if ($7 >>> 0 > $3 + $2 >>> 0) {
15896 $3 = $4;
15897 break label$2;
15898 }
15899 $5 = $3 + ((HEAP32[$0 + 16 >> 2] + $2 | 0) + 31 >>> 5 | 0) | 0;
15900 if ($5 >>> 0 <= $7 >>> 0) {
15901 $3 = $4;
15902 break label$2;
15903 }
15904 $6 = 0;
15905 $3 = $5 - $7 & 1023;
15906 $5 = $5 + ($3 ? 1024 - $3 | 0 : 0) | 0;
15907 label$5 : {
15908 if ($5) {
15909 if (($5 | 0) != ($5 & 1073741823)) {
15910 break label$1
15911 }
15912 $3 = dlrealloc($4, $5 << 2);
15913 if ($3) {
15914 break label$5
15915 }
15916 dlfree($4);
15917 return 0;
15918 }
15919 $3 = dlrealloc($4, 0);
15920 if (!$3) {
15921 break label$1
15922 }
15923 }
15924 HEAP32[$0 + 8 >> 2] = $5;
15925 HEAP32[$0 >> 2] = $3;
15926 }
15927 $4 = HEAP32[$0 + 16 >> 2];
15928 $5 = 32 - $4 | 0;
15929 if ($5 >>> 0 > $2 >>> 0) {
15930 HEAP32[$0 + 16 >> 2] = $2 + $4;
15931 HEAP32[$0 + 4 >> 2] = HEAP32[$0 + 4 >> 2] << $2 | $1;
15932 return 1;
15933 }
15934 if ($4) {
15935 $4 = $2 - $5 | 0;
15936 HEAP32[$0 + 16 >> 2] = $4;
15937 $2 = HEAP32[$0 + 12 >> 2];
15938 HEAP32[$0 + 12 >> 2] = $2 + 1;
15939 $3 = ($2 << 2) + $3 | 0;
15940 $2 = HEAP32[$0 + 4 >> 2] << $5 | $1 >>> $4;
15941 HEAP32[$3 >> 2] = $2 << 24 | $2 << 8 & 16711680 | ($2 >>> 8 & 65280 | $2 >>> 24);
15942 HEAP32[$0 + 4 >> 2] = $1;
15943 return 1;
15944 }
15945 $6 = 1;
15946 $2 = $0;
15947 $0 = HEAP32[$0 + 12 >> 2];
15948 HEAP32[$2 + 12 >> 2] = $0 + 1;
15949 HEAP32[($0 << 2) + $3 >> 2] = $1 << 8 & 16711680 | $1 << 24 | ($1 >>> 8 & 65280 | $1 >>> 24);
15950 }
15951 return $6;
15952 }
15953
15954 function FLAC__bitwriter_write_raw_int32($0, $1, $2) {
15955 return FLAC__bitwriter_write_raw_uint32_nocheck($0, ($2 >>> 0 < 32 ? -1 << $2 ^ -1 : -1) & $1, $2);
15956 }
15957
15958 function FLAC__bitwriter_write_raw_uint64($0, $1, $2, $3) {
15959 var $4 = 0;
15960 label$1 : {
15961 if ($3 >>> 0 >= 33) {
15962 $3 = $3 + -32 | 0;
15963 if ($2 >>> $3 | 0 ? $3 >>> 0 <= 31 : 0) {
15964 break label$1
15965 }
15966 if (!FLAC__bitwriter_write_raw_uint32_nocheck($0, $2, $3)) {
15967 break label$1
15968 }
15969 return (FLAC__bitwriter_write_raw_uint32_nocheck($0, $1, 32) | 0) != 0;
15970 }
15971 if (($3 | 0) != 32) {
15972 if ($1 >>> $3) {
15973 break label$1
15974 }
15975 }
15976 $4 = FLAC__bitwriter_write_raw_uint32_nocheck($0, $1, $3);
15977 }
15978 return $4;
15979 }
15980
15981 function FLAC__bitwriter_write_raw_uint32_little_endian($0, $1) {
15982 var $2 = 0;
15983 label$1 : {
15984 if (!FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 & 255, 8)) {
15985 break label$1
15986 }
15987 if (!FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 >>> 8 & 255, 8)) {
15988 break label$1
15989 }
15990 if (!FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 >>> 16 & 255, 8)) {
15991 break label$1
15992 }
15993 $2 = (FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 >>> 24 | 0, 8) | 0) != 0;
15994 }
15995 return $2;
15996 }
15997
15998 function FLAC__bitwriter_write_byte_block($0, $1, $2) {
15999 var $3 = 0, $4 = 0, $5 = 0, $6 = 0;
16000 $3 = HEAP32[$0 + 8 >> 2];
16001 $4 = HEAP32[$0 + 12 >> 2];
16002 label$1 : {
16003 label$2 : {
16004 if ($3 >>> 0 > ($4 + ($2 >>> 2 | 0) | 0) + 1 >>> 0) {
16005 break label$2
16006 }
16007 $5 = $4 + ((HEAP32[$0 + 16 >> 2] + ($2 << 3) | 0) + 31 >>> 5 | 0) | 0;
16008 if ($5 >>> 0 <= $3 >>> 0) {
16009 break label$2
16010 }
16011 $4 = 0;
16012 $6 = HEAP32[$0 >> 2];
16013 $3 = $5 - $3 & 1023;
16014 $3 = $5 + ($3 ? 1024 - $3 | 0 : 0) | 0;
16015 label$3 : {
16016 if ($3) {
16017 if (($3 | 0) != ($3 & 1073741823)) {
16018 break label$1
16019 }
16020 $5 = dlrealloc($6, $3 << 2);
16021 if ($5) {
16022 break label$3
16023 }
16024 dlfree($6);
16025 return 0;
16026 }
16027 $5 = dlrealloc($6, 0);
16028 if (!$5) {
16029 break label$1
16030 }
16031 }
16032 HEAP32[$0 + 8 >> 2] = $3;
16033 HEAP32[$0 >> 2] = $5;
16034 }
16035 $4 = 1;
16036 if (!$2) {
16037 break label$1
16038 }
16039 $4 = 0;
16040 label$5 : {
16041 while (1) {
16042 if (!FLAC__bitwriter_write_raw_uint32_nocheck($0, HEAPU8[$1 + $4 | 0], 8)) {
16043 break label$5
16044 }
16045 $4 = $4 + 1 | 0;
16046 if (($4 | 0) != ($2 | 0)) {
16047 continue
16048 }
16049 break;
16050 };
16051 return 1;
16052 }
16053 $4 = 0;
16054 }
16055 return $4;
16056 }
16057
16058 function FLAC__bitwriter_write_unary_unsigned($0, $1) {
16059 if ($1 >>> 0 <= 31) {
16060 return FLAC__bitwriter_write_raw_uint32_nocheck($0, 1, $1 + 1 | 0)
16061 }
16062 if (!FLAC__bitwriter_write_zeroes($0, $1)) {
16063 return 0
16064 }
16065 return (FLAC__bitwriter_write_raw_uint32_nocheck($0, 1, 1) | 0) != 0;
16066 }
16067
16068 function FLAC__bitwriter_write_rice_signed_block($0, $1, $2, $3) {
16069 var $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0;
16070 $4 = 1;
16071 label$1 : {
16072 if (!$2) {
16073 break label$1
16074 }
16075 $10 = $3 + 1 | 0;
16076 $11 = -1 << $3;
16077 $12 = -1 >>> 31 - $3 | 0;
16078 while (1) {
16079 $6 = HEAP32[$1 >> 2];
16080 $9 = $6 << 1 ^ $6 >> 31;
16081 $6 = $9 >>> $3 | 0;
16082 $4 = $10 + $6 | 0;
16083 label$3 : {
16084 label$4 : {
16085 $5 = HEAP32[$0 + 16 >> 2];
16086 if (!$5) {
16087 break label$4
16088 }
16089 $7 = $4 + $5 | 0;
16090 if ($7 >>> 0 > 31) {
16091 break label$4
16092 }
16093 HEAP32[$0 + 16 >> 2] = $7;
16094 HEAP32[$0 + 4 >> 2] = ($9 | $11) & $12 | HEAP32[$0 + 4 >> 2] << $4;
16095 break label$3;
16096 }
16097 $8 = HEAP32[$0 + 8 >> 2];
16098 $7 = HEAP32[$0 + 12 >> 2];
16099 label$5 : {
16100 if ($8 >>> 0 > ($7 + ($5 + $6 | 0) | 0) + 1 >>> 0) {
16101 break label$5
16102 }
16103 $4 = $7 + (($4 + $5 | 0) + 31 >>> 5 | 0) | 0;
16104 if ($4 >>> 0 <= $8 >>> 0) {
16105 break label$5
16106 }
16107 $7 = HEAP32[$0 >> 2];
16108 $5 = $4 - $8 & 1023;
16109 $5 = $4 + ($5 ? 1024 - $5 | 0 : 0) | 0;
16110 label$6 : {
16111 if ($5) {
16112 $4 = 0;
16113 if (($5 | 0) != ($5 & 1073741823)) {
16114 break label$1
16115 }
16116 $8 = dlrealloc($7, $5 << 2);
16117 if ($8) {
16118 break label$6
16119 }
16120 dlfree($7);
16121 return 0;
16122 }
16123 $8 = dlrealloc($7, 0);
16124 $4 = 0;
16125 if (!$8) {
16126 break label$1
16127 }
16128 }
16129 HEAP32[$0 + 8 >> 2] = $5;
16130 HEAP32[$0 >> 2] = $8;
16131 }
16132 label$8 : {
16133 if (!$6) {
16134 break label$8
16135 }
16136 $4 = HEAP32[$0 + 16 >> 2];
16137 if ($4) {
16138 $5 = HEAP32[$0 + 4 >> 2];
16139 $7 = 32 - $4 | 0;
16140 if ($6 >>> 0 < $7 >>> 0) {
16141 HEAP32[$0 + 16 >> 2] = $4 + $6;
16142 HEAP32[$0 + 4 >> 2] = $5 << $6;
16143 break label$8;
16144 }
16145 $4 = $5 << $7;
16146 HEAP32[$0 + 4 >> 2] = $4;
16147 $5 = HEAP32[$0 + 12 >> 2];
16148 HEAP32[$0 + 12 >> 2] = $5 + 1;
16149 HEAP32[HEAP32[$0 >> 2] + ($5 << 2) >> 2] = $4 << 8 & 16711680 | $4 << 24 | ($4 >>> 8 & 65280 | $4 >>> 24);
16150 HEAP32[$0 + 16 >> 2] = 0;
16151 $6 = $6 - $7 | 0;
16152 }
16153 if ($6 >>> 0 >= 32) {
16154 $4 = HEAP32[$0 >> 2];
16155 while (1) {
16156 $5 = HEAP32[$0 + 12 >> 2];
16157 HEAP32[$0 + 12 >> 2] = $5 + 1;
16158 HEAP32[$4 + ($5 << 2) >> 2] = 0;
16159 $6 = $6 + -32 | 0;
16160 if ($6 >>> 0 > 31) {
16161 continue
16162 }
16163 break;
16164 };
16165 }
16166 if (!$6) {
16167 break label$8
16168 }
16169 HEAP32[$0 + 16 >> 2] = $6;
16170 HEAP32[$0 + 4 >> 2] = 0;
16171 }
16172 $6 = ($9 | $11) & $12;
16173 $4 = HEAP32[$0 + 4 >> 2];
16174 $7 = HEAP32[$0 + 16 >> 2];
16175 $5 = 32 - $7 | 0;
16176 if ($10 >>> 0 < $5 >>> 0) {
16177 HEAP32[$0 + 16 >> 2] = $7 + $10;
16178 HEAP32[$0 + 4 >> 2] = $6 | $4 << $10;
16179 break label$3;
16180 }
16181 $7 = $10 - $5 | 0;
16182 HEAP32[$0 + 16 >> 2] = $7;
16183 $9 = HEAP32[$0 + 12 >> 2];
16184 HEAP32[$0 + 12 >> 2] = $9 + 1;
16185 $4 = $4 << $5 | $6 >>> $7;
16186 HEAP32[HEAP32[$0 >> 2] + ($9 << 2) >> 2] = $4 << 24 | $4 << 8 & 16711680 | ($4 >>> 8 & 65280 | $4 >>> 24);
16187 HEAP32[$0 + 4 >> 2] = $6;
16188 }
16189 $1 = $1 + 4 | 0;
16190 $2 = $2 + -1 | 0;
16191 if ($2) {
16192 continue
16193 }
16194 break;
16195 };
16196 $4 = 1;
16197 }
16198 return $4;
16199 }
16200
16201 function FLAC__bitwriter_write_utf8_uint32($0, $1) {
16202 if (($1 | 0) >= 0) {
16203 if ($1 >>> 0 <= 127) {
16204 return FLAC__bitwriter_write_raw_uint32_nocheck($0, $1, 8)
16205 }
16206 if ($1 >>> 0 <= 2047) {
16207 return FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 >>> 6 | 192, 8) & FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 & 63 | 128, 8) & 1
16208 }
16209 if ($1 >>> 0 <= 65535) {
16210 return FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 >>> 12 | 224, 8) & FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 >>> 6 & 63 | 128, 8) & FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 & 63 | 128, 8) & 1
16211 }
16212 if ($1 >>> 0 <= 2097151) {
16213 return FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 >>> 18 | 240, 8) & FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 >>> 12 & 63 | 128, 8) & FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 >>> 6 & 63 | 128, 8) & FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 & 63 | 128, 8) & 1
16214 }
16215 if ($1 >>> 0 <= 67108863) {
16216 return FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 >>> 24 | 248, 8) & FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 >>> 18 & 63 | 128, 8) & FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 >>> 12 & 63 | 128, 8) & FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 >>> 6 & 63 | 128, 8) & FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 & 63 | 128, 8) & 1
16217 }
16218 $0 = FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 >>> 30 | 252, 8) & FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 >>> 24 & 63 | 128, 8) & FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 >>> 18 & 63 | 128, 8) & FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 >>> 12 & 63 | 128, 8) & FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 >>> 6 & 63 | 128, 8) & FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 & 63 | 128, 8) & 1;
16219 } else {
16220 $0 = 0
16221 }
16222 return $0;
16223 }
16224
16225 function FLAC__bitwriter_write_utf8_uint64($0, $1, $2) {
16226 if (($2 | 0) == 15 | $2 >>> 0 < 15) {
16227 if (!$2 & $1 >>> 0 <= 127 | $2 >>> 0 < 0) {
16228 return FLAC__bitwriter_write_raw_uint32_nocheck($0, $1, 8)
16229 }
16230 if (!$2 & $1 >>> 0 <= 2047 | $2 >>> 0 < 0) {
16231 return FLAC__bitwriter_write_raw_uint32_nocheck($0, ($2 & 63) << 26 | $1 >>> 6 | 192, 8) & FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 & 63 | 128, 8) & 1
16232 }
16233 if (!$2 & $1 >>> 0 <= 65535 | $2 >>> 0 < 0) {
16234 return FLAC__bitwriter_write_raw_uint32_nocheck($0, ($2 & 4095) << 20 | $1 >>> 12 | 224, 8) & FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 >>> 6 & 63 | 128, 8) & FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 & 63 | 128, 8) & 1
16235 }
16236 if (!$2 & $1 >>> 0 <= 2097151 | $2 >>> 0 < 0) {
16237 return FLAC__bitwriter_write_raw_uint32_nocheck($0, ($2 & 262143) << 14 | $1 >>> 18 | 240, 8) & FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 >>> 12 & 63 | 128, 8) & FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 >>> 6 & 63 | 128, 8) & FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 & 63 | 128, 8) & 1
16238 }
16239 if (!$2 & $1 >>> 0 <= 67108863 | $2 >>> 0 < 0) {
16240 return FLAC__bitwriter_write_raw_uint32_nocheck($0, ($2 & 16777215) << 8 | $1 >>> 24 | 248, 8) & FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 >>> 18 & 63 | 128, 8) & FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 >>> 12 & 63 | 128, 8) & FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 >>> 6 & 63 | 128, 8) & FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 & 63 | 128, 8) & 1
16241 }
16242 if (!$2 & $1 >>> 0 <= 2147483647 | $2 >>> 0 < 0) {
16243 return FLAC__bitwriter_write_raw_uint32_nocheck($0, ($2 & 1073741823) << 2 | $1 >>> 30 | 252, 8) & FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 >>> 24 & 63 | 128, 8) & FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 >>> 18 & 63 | 128, 8) & FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 >>> 12 & 63 | 128, 8) & FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 >>> 6 & 63 | 128, 8) & FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 & 63 | 128, 8) & 1
16244 }
16245 $0 = FLAC__bitwriter_write_raw_uint32_nocheck($0, 254, 8) & FLAC__bitwriter_write_raw_uint32_nocheck($0, ($2 & 1073741823) << 2 | $1 >>> 30 | 128, 8) & FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 >>> 24 & 63 | 128, 8) & FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 >>> 18 & 63 | 128, 8) & FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 >>> 12 & 63 | 128, 8) & FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 >>> 6 & 63 | 128, 8) & FLAC__bitwriter_write_raw_uint32_nocheck($0, $1 & 63 | 128, 8) & 1;
16246 } else {
16247 $0 = 0
16248 }
16249 return $0;
16250 }
16251
16252 function FLAC__ogg_encoder_aspect_init($0) {
16253 if (ogg_stream_init($0 + 8 | 0, HEAP32[$0 >> 2])) {
16254 $0 = 0
16255 } else {
16256 HEAP32[$0 + 392 >> 2] = 0;
16257 HEAP32[$0 + 396 >> 2] = 0;
16258 HEAP32[$0 + 384 >> 2] = 0;
16259 HEAP32[$0 + 388 >> 2] = 1;
16260 $0 = 1;
16261 }
16262 return $0;
16263 }
16264
16265 function FLAC__ogg_encoder_aspect_set_defaults($0) {
16266 HEAP32[$0 >> 2] = 0;
16267 HEAP32[$0 + 4 >> 2] = 0;
16268 }
16269
16270 function FLAC__ogg_encoder_aspect_write_callback_wrapper($0, $1, $2, $3, $4, $5, $6, $7, $8) {
16271 var $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0;
16272 $9 = global$0 - 96 | 0;
16273 global$0 = $9;
16274 label$1 : {
16275 label$2 : {
16276 if (HEAP32[$0 + 384 >> 2]) {
16277 HEAP32[$9 + 72 >> 2] = 0;
16278 HEAP32[$9 + 76 >> 2] = 0;
16279 $12 = $9 + 80 | 0;
16280 $11 = $12;
16281 HEAP32[$11 >> 2] = 0;
16282 HEAP32[$11 + 4 >> 2] = 0;
16283 HEAP32[$9 + 88 >> 2] = 0;
16284 HEAP32[$9 + 92 >> 2] = 0;
16285 HEAP32[$9 + 64 >> 2] = 0;
16286 HEAP32[$9 + 68 >> 2] = 0;
16287 $10 = HEAP32[$0 + 396 >> 2];
16288 $11 = $3;
16289 $13 = HEAP32[$0 + 392 >> 2];
16290 $14 = $11 + $13 | 0;
16291 if ($14 >>> 0 < $13 >>> 0) {
16292 $10 = $10 + 1 | 0
16293 }
16294 HEAP32[$12 >> 2] = $14;
16295 HEAP32[$12 + 4 >> 2] = $10;
16296 label$4 : {
16297 label$5 : {
16298 if (HEAP32[$0 + 388 >> 2]) {
16299 if (($2 | 0) != 38) {
16300 break label$4
16301 }
16302 HEAP8[$9 | 0] = HEAPU8[7536];
16303 $2 = HEAP32[2721];
16304 $2 = HEAPU8[$2 | 0] | HEAPU8[$2 + 1 | 0] << 8 | (HEAPU8[$2 + 2 | 0] << 16 | HEAPU8[$2 + 3 | 0] << 24);
16305 HEAP8[$9 + 5 | 0] = 1;
16306 HEAP8[$9 + 6 | 0] = 0;
16307 HEAP8[$9 + 1 | 0] = $2;
16308 HEAP8[$9 + 2 | 0] = $2 >>> 8;
16309 HEAP8[$9 + 3 | 0] = $2 >>> 16;
16310 HEAP8[$9 + 4 | 0] = $2 >>> 24;
16311 $10 = HEAP32[$0 + 4 >> 2];
16312 $2 = HEAPU8[5409] | HEAPU8[5410] << 8 | (HEAPU8[5411] << 16 | HEAPU8[5412] << 24);
16313 HEAP8[$9 + 9 | 0] = $2;
16314 HEAP8[$9 + 10 | 0] = $2 >>> 8;
16315 HEAP8[$9 + 11 | 0] = $2 >>> 16;
16316 HEAP8[$9 + 12 | 0] = $2 >>> 24;
16317 HEAP8[$9 + 8 | 0] = $10;
16318 HEAP8[$9 + 7 | 0] = $10 >>> 8;
16319 $2 = HEAPU8[$1 + 34 | 0] | HEAPU8[$1 + 35 | 0] << 8 | (HEAPU8[$1 + 36 | 0] << 16 | HEAPU8[$1 + 37 | 0] << 24);
16320 $10 = HEAPU8[$1 + 30 | 0] | HEAPU8[$1 + 31 | 0] << 8 | (HEAPU8[$1 + 32 | 0] << 16 | HEAPU8[$1 + 33 | 0] << 24);
16321 HEAP8[$9 + 43 | 0] = $10;
16322 HEAP8[$9 + 44 | 0] = $10 >>> 8;
16323 HEAP8[$9 + 45 | 0] = $10 >>> 16;
16324 HEAP8[$9 + 46 | 0] = $10 >>> 24;
16325 HEAP8[$9 + 47 | 0] = $2;
16326 HEAP8[$9 + 48 | 0] = $2 >>> 8;
16327 HEAP8[$9 + 49 | 0] = $2 >>> 16;
16328 HEAP8[$9 + 50 | 0] = $2 >>> 24;
16329 $2 = HEAPU8[$1 + 28 | 0] | HEAPU8[$1 + 29 | 0] << 8 | (HEAPU8[$1 + 30 | 0] << 16 | HEAPU8[$1 + 31 | 0] << 24);
16330 $10 = HEAPU8[$1 + 24 | 0] | HEAPU8[$1 + 25 | 0] << 8 | (HEAPU8[$1 + 26 | 0] << 16 | HEAPU8[$1 + 27 | 0] << 24);
16331 HEAP8[$9 + 37 | 0] = $10;
16332 HEAP8[$9 + 38 | 0] = $10 >>> 8;
16333 HEAP8[$9 + 39 | 0] = $10 >>> 16;
16334 HEAP8[$9 + 40 | 0] = $10 >>> 24;
16335 HEAP8[$9 + 41 | 0] = $2;
16336 HEAP8[$9 + 42 | 0] = $2 >>> 8;
16337 HEAP8[$9 + 43 | 0] = $2 >>> 16;
16338 HEAP8[$9 + 44 | 0] = $2 >>> 24;
16339 $2 = HEAPU8[$1 + 20 | 0] | HEAPU8[$1 + 21 | 0] << 8 | (HEAPU8[$1 + 22 | 0] << 16 | HEAPU8[$1 + 23 | 0] << 24);
16340 $10 = HEAPU8[$1 + 16 | 0] | HEAPU8[$1 + 17 | 0] << 8 | (HEAPU8[$1 + 18 | 0] << 16 | HEAPU8[$1 + 19 | 0] << 24);
16341 HEAP8[$9 + 29 | 0] = $10;
16342 HEAP8[$9 + 30 | 0] = $10 >>> 8;
16343 HEAP8[$9 + 31 | 0] = $10 >>> 16;
16344 HEAP8[$9 + 32 | 0] = $10 >>> 24;
16345 HEAP8[$9 + 33 | 0] = $2;
16346 HEAP8[$9 + 34 | 0] = $2 >>> 8;
16347 HEAP8[$9 + 35 | 0] = $2 >>> 16;
16348 HEAP8[$9 + 36 | 0] = $2 >>> 24;
16349 $2 = HEAPU8[$1 + 12 | 0] | HEAPU8[$1 + 13 | 0] << 8 | (HEAPU8[$1 + 14 | 0] << 16 | HEAPU8[$1 + 15 | 0] << 24);
16350 $10 = HEAPU8[$1 + 8 | 0] | HEAPU8[$1 + 9 | 0] << 8 | (HEAPU8[$1 + 10 | 0] << 16 | HEAPU8[$1 + 11 | 0] << 24);
16351 HEAP8[$9 + 21 | 0] = $10;
16352 HEAP8[$9 + 22 | 0] = $10 >>> 8;
16353 HEAP8[$9 + 23 | 0] = $10 >>> 16;
16354 HEAP8[$9 + 24 | 0] = $10 >>> 24;
16355 HEAP8[$9 + 25 | 0] = $2;
16356 HEAP8[$9 + 26 | 0] = $2 >>> 8;
16357 HEAP8[$9 + 27 | 0] = $2 >>> 16;
16358 HEAP8[$9 + 28 | 0] = $2 >>> 24;
16359 $2 = HEAPU8[$1 + 4 | 0] | HEAPU8[$1 + 5 | 0] << 8 | (HEAPU8[$1 + 6 | 0] << 16 | HEAPU8[$1 + 7 | 0] << 24);
16360 $1 = HEAPU8[$1 | 0] | HEAPU8[$1 + 1 | 0] << 8 | (HEAPU8[$1 + 2 | 0] << 16 | HEAPU8[$1 + 3 | 0] << 24);
16361 HEAP8[$9 + 13 | 0] = $1;
16362 HEAP8[$9 + 14 | 0] = $1 >>> 8;
16363 HEAP8[$9 + 15 | 0] = $1 >>> 16;
16364 HEAP8[$9 + 16 | 0] = $1 >>> 24;
16365 HEAP8[$9 + 17 | 0] = $2;
16366 HEAP8[$9 + 18 | 0] = $2 >>> 8;
16367 HEAP8[$9 + 19 | 0] = $2 >>> 16;
16368 HEAP8[$9 + 20 | 0] = $2 >>> 24;
16369 HEAP32[$9 + 68 >> 2] = 51;
16370 HEAP32[$9 + 72 >> 2] = 1;
16371 HEAP32[$9 + 64 >> 2] = $9;
16372 HEAP32[$0 + 388 >> 2] = 0;
16373 break label$5;
16374 }
16375 HEAP32[$9 + 68 >> 2] = $2;
16376 HEAP32[$9 + 64 >> 2] = $1;
16377 }
16378 if ($5) {
16379 HEAP32[$9 + 76 >> 2] = 1
16380 }
16381 $1 = $0 + 8 | 0;
16382 if (ogg_stream_packetin($1, $9 - -64 | 0)) {
16383 break label$4
16384 }
16385 $2 = $0 + 368 | 0;
16386 if (!$3) {
16387 while (1) {
16388 if (!ogg_stream_flush_i($1, $2, 1)) {
16389 break label$2
16390 }
16391 if (FUNCTION_TABLE[$6]($7, HEAP32[$0 + 368 >> 2], HEAP32[$0 + 372 >> 2], 0, $4, $8)) {
16392 break label$4
16393 }
16394 if (!FUNCTION_TABLE[$6]($7, HEAP32[$0 + 376 >> 2], HEAP32[$0 + 380 >> 2], 0, $4, $8)) {
16395 continue
16396 }
16397 break label$4;
16398 }
16399 }
16400 while (1) {
16401 if (!ogg_stream_pageout($1, $2)) {
16402 break label$2
16403 }
16404 if (FUNCTION_TABLE[$6]($7, HEAP32[$0 + 368 >> 2], HEAP32[$0 + 372 >> 2], 0, $4, $8)) {
16405 break label$4
16406 }
16407 if (!FUNCTION_TABLE[$6]($7, HEAP32[$0 + 376 >> 2], HEAP32[$0 + 380 >> 2], 0, $4, $8)) {
16408 continue
16409 }
16410 break;
16411 };
16412 }
16413 $6 = 1;
16414 break label$1;
16415 }
16416 $6 = 1;
16417 if ($3 | $4 | ($2 | 0) != 4 | (HEAPU8[$1 | 0] | HEAPU8[$1 + 1 | 0] << 8 | (HEAPU8[$1 + 2 | 0] << 16 | HEAPU8[$1 + 3 | 0] << 24)) != (HEAPU8[5409] | HEAPU8[5410] << 8 | (HEAPU8[5411] << 16 | HEAPU8[5412] << 24))) {
16418 break label$1
16419 }
16420 HEAP32[$0 + 384 >> 2] = 1;
16421 $11 = $3;
16422 }
16423 $1 = $0;
16424 $3 = $1;
16425 $2 = HEAP32[$1 + 396 >> 2];
16426 $0 = $11 + HEAP32[$1 + 392 >> 2] | 0;
16427 if ($0 >>> 0 < $11 >>> 0) {
16428 $2 = $2 + 1 | 0
16429 }
16430 HEAP32[$3 + 392 >> 2] = $0;
16431 HEAP32[$1 + 396 >> 2] = $2;
16432 $6 = 0;
16433 }
16434 global$0 = $9 + 96 | 0;
16435 return $6;
16436 }
16437
16438 function simple_ogg_page__init($0) {
16439 HEAP32[$0 >> 2] = 0;
16440 HEAP32[$0 + 4 >> 2] = 0;
16441 HEAP32[$0 + 8 >> 2] = 0;
16442 HEAP32[$0 + 12 >> 2] = 0;
16443 }
16444
16445 function simple_ogg_page__clear($0) {
16446 var $1 = 0;
16447 $1 = HEAP32[$0 >> 2];
16448 if ($1) {
16449 dlfree($1)
16450 }
16451 $1 = HEAP32[$0 + 8 >> 2];
16452 if ($1) {
16453 dlfree($1)
16454 }
16455 HEAP32[$0 >> 2] = 0;
16456 HEAP32[$0 + 4 >> 2] = 0;
16457 HEAP32[$0 + 8 >> 2] = 0;
16458 HEAP32[$0 + 12 >> 2] = 0;
16459 }
16460
16461 function simple_ogg_page__get_at($0, $1, $2, $3, $4, $5, $6) {
16462 var $7 = 0, $8 = 0, $9 = 0;
16463 $7 = global$0 - 16 | 0;
16464 global$0 = $7;
16465 label$1 : {
16466 if (!$4) {
16467 break label$1
16468 }
16469 label$2 : {
16470 switch (FUNCTION_TABLE[$4]($0, $1, $2, $6) | 0) {
16471 case 1:
16472 HEAP32[HEAP32[$0 >> 2] >> 2] = 5;
16473 break label$1;
16474 case 0:
16475 break label$2;
16476 default:
16477 break label$1;
16478 };
16479 }
16480 $4 = dlmalloc(282);
16481 HEAP32[$3 >> 2] = $4;
16482 if (!$4) {
16483 HEAP32[HEAP32[$0 >> 2] >> 2] = 8;
16484 break label$1;
16485 }
16486 $8 = 27;
16487 while (1) {
16488 HEAP32[$7 + 12 >> 2] = $8;
16489 $1 = 5;
16490 label$6 : {
16491 label$7 : {
16492 switch (FUNCTION_TABLE[$5]($0, $4, $7 + 12 | 0, $6) | 0) {
16493 case 1:
16494 $1 = HEAP32[$7 + 12 >> 2];
16495 if ($1) {
16496 break label$6
16497 }
16498 $1 = 2;
16499 default:
16500 HEAP32[HEAP32[$0 >> 2] >> 2] = $1;
16501 break label$1;
16502 case 3:
16503 break label$1;
16504 case 0:
16505 break label$7;
16506 };
16507 }
16508 $1 = HEAP32[$7 + 12 >> 2];
16509 }
16510 $4 = $1 + $4 | 0;
16511 $8 = $8 - $1 | 0;
16512 if ($8) {
16513 continue
16514 }
16515 break;
16516 };
16517 $1 = HEAP32[$3 >> 2];
16518 HEAP32[$3 + 4 >> 2] = HEAPU8[$1 + 26 | 0] + 27;
16519 label$10 : {
16520 if (!(HEAP8[$1 + 5 | 0] & 1 | (HEAPU8[$1 | 0] | HEAPU8[$1 + 1 | 0] << 8 | (HEAPU8[$1 + 2 | 0] << 16 | HEAPU8[$1 + 3 | 0] << 24)) != 1399285583 | ((HEAPU8[$1 + 6 | 0] | HEAPU8[$1 + 7 | 0] << 8 | (HEAPU8[$1 + 8 | 0] << 16 | HEAPU8[$1 + 9 | 0] << 24)) != 0 | (HEAPU8[$1 + 10 | 0] | HEAPU8[$1 + 11 | 0] << 8 | (HEAPU8[$1 + 12 | 0] << 16 | HEAPU8[$1 + 13 | 0] << 24)) != 0))) {
16521 $8 = HEAPU8[$1 + 26 | 0];
16522 if ($8) {
16523 break label$10
16524 }
16525 }
16526 HEAP32[HEAP32[$0 >> 2] >> 2] = 2;
16527 break label$1;
16528 }
16529 $4 = $1 + 27 | 0;
16530 while (1) {
16531 HEAP32[$7 + 12 >> 2] = $8;
16532 $1 = 5;
16533 label$13 : {
16534 label$14 : {
16535 switch (FUNCTION_TABLE[$5]($0, $4, $7 + 12 | 0, $6) | 0) {
16536 case 1:
16537 $1 = HEAP32[$7 + 12 >> 2];
16538 if ($1) {
16539 break label$13
16540 }
16541 $1 = 2;
16542 default:
16543 HEAP32[HEAP32[$0 >> 2] >> 2] = $1;
16544 break label$1;
16545 case 3:
16546 break label$1;
16547 case 0:
16548 break label$14;
16549 };
16550 }
16551 $1 = HEAP32[$7 + 12 >> 2];
16552 }
16553 $4 = $1 + $4 | 0;
16554 $8 = $8 - $1 | 0;
16555 if ($8) {
16556 continue
16557 }
16558 break;
16559 };
16560 $4 = 0;
16561 $1 = HEAP32[$3 >> 2];
16562 $2 = HEAPU8[$1 + 26 | 0];
16563 label$17 : {
16564 if (($2 | 0) != 1) {
16565 $2 = $2 + -1 | 0;
16566 while (1) {
16567 if (HEAPU8[($1 + $4 | 0) + 27 | 0] != 255) {
16568 HEAP32[HEAP32[$0 >> 2] >> 2] = 2;
16569 break label$17;
16570 }
16571 $4 = $4 + 1 | 0;
16572 if ($4 >>> 0 < $2 >>> 0) {
16573 continue
16574 }
16575 break;
16576 };
16577 }
16578 $4 = HEAPU8[($1 + $4 | 0) + 27 | 0] + Math_imul($4, 255) | 0;
16579 HEAP32[$3 + 12 >> 2] = $4;
16580 $8 = dlmalloc($4 ? $4 : 1);
16581 HEAP32[$3 + 8 >> 2] = $8;
16582 if (!$8) {
16583 HEAP32[HEAP32[$0 >> 2] >> 2] = 8;
16584 break label$17;
16585 }
16586 $2 = $7;
16587 if ($4) {
16588 while (1) {
16589 HEAP32[$7 + 12 >> 2] = $4;
16590 $1 = 5;
16591 label$24 : {
16592 label$25 : {
16593 switch (FUNCTION_TABLE[$5]($0, $8, $7 + 12 | 0, $6) | 0) {
16594 case 1:
16595 $1 = HEAP32[$7 + 12 >> 2];
16596 if ($1) {
16597 break label$24
16598 }
16599 $1 = 2;
16600 default:
16601 HEAP32[HEAP32[$0 >> 2] >> 2] = $1;
16602 break label$17;
16603 case 3:
16604 break label$17;
16605 case 0:
16606 break label$25;
16607 };
16608 }
16609 $1 = HEAP32[$7 + 12 >> 2];
16610 }
16611 $8 = $1 + $8 | 0;
16612 $4 = $4 - $1 | 0;
16613 if ($4) {
16614 continue
16615 }
16616 break;
16617 };
16618 $1 = HEAP32[$3 >> 2];
16619 }
16620 HEAP32[$2 + 12 >> 2] = HEAPU8[$1 + 22 | 0] | HEAPU8[$1 + 23 | 0] << 8 | (HEAPU8[$1 + 24 | 0] << 16 | HEAPU8[$1 + 25 | 0] << 24);
16621 ogg_page_checksum_set($3);
16622 $1 = HEAP32[$3 >> 2];
16623 if (HEAP32[$7 + 12 >> 2] == (HEAPU8[$1 + 22 | 0] | HEAPU8[$1 + 23 | 0] << 8 | (HEAPU8[$1 + 24 | 0] << 16 | HEAPU8[$1 + 25 | 0] << 24))) {
16624 $9 = 1;
16625 break label$1;
16626 }
16627 HEAP32[HEAP32[$0 >> 2] >> 2] = 2;
16628 }
16629 }
16630 global$0 = $7 + 16 | 0;
16631 return $9;
16632 }
16633
16634 function simple_ogg_page__set_at($0, $1, $2, $3, $4, $5, $6) {
16635 folding_inner0 : {
16636 label$1 : {
16637 if (!$4) {
16638 break label$1
16639 }
16640 label$2 : {
16641 switch (FUNCTION_TABLE[$4]($0, $1, $2, $6) | 0) {
16642 case 1:
16643 break folding_inner0;
16644 case 0:
16645 break label$2;
16646 default:
16647 break label$1;
16648 };
16649 }
16650 ogg_page_checksum_set($3);
16651 if (FUNCTION_TABLE[$5]($0, HEAP32[$3 >> 2], HEAP32[$3 + 4 >> 2], 0, 0, $6)) {
16652 break folding_inner0
16653 }
16654 if (!FUNCTION_TABLE[$5]($0, HEAP32[$3 + 8 >> 2], HEAP32[$3 + 12 >> 2], 0, 0, $6)) {
16655 return 1
16656 }
16657 HEAP32[HEAP32[$0 >> 2] >> 2] = 5;
16658 }
16659 return 0;
16660 }
16661 HEAP32[HEAP32[$0 >> 2] >> 2] = 5;
16662 return 0;
16663 }
16664
16665 function __emscripten_stdout_close($0) {
16666 $0 = $0 | 0;
16667 return 0;
16668 }
16669
16670 function __emscripten_stdout_seek($0, $1, $2, $3) {
16671 $0 = $0 | 0;
16672 $1 = $1 | 0;
16673 $2 = $2 | 0;
16674 $3 = $3 | 0;
16675 i64toi32_i32$HIGH_BITS = 0;
16676 return 0;
16677 }
16678
16679 function strcmp($0, $1) {
16680 var $2 = 0, $3 = 0;
16681 $2 = HEAPU8[$0 | 0];
16682 $3 = HEAPU8[$1 | 0];
16683 label$1 : {
16684 if (!$2 | ($2 | 0) != ($3 | 0)) {
16685 break label$1
16686 }
16687 while (1) {
16688 $3 = HEAPU8[$1 + 1 | 0];
16689 $2 = HEAPU8[$0 + 1 | 0];
16690 if (!$2) {
16691 break label$1
16692 }
16693 $1 = $1 + 1 | 0;
16694 $0 = $0 + 1 | 0;
16695 if (($2 | 0) == ($3 | 0)) {
16696 continue
16697 }
16698 break;
16699 };
16700 }
16701 return $2 - $3 | 0;
16702 }
16703
16704 function __cos($0, $1) {
16705 var $2 = 0.0, $3 = 0.0, $4 = 0.0, $5 = 0.0;
16706 $2 = $0 * $0;
16707 $3 = $2 * .5;
16708 $4 = 1.0 - $3;
16709 $5 = 1.0 - $4 - $3;
16710 $3 = $2 * $2;
16711 return $4 + ($5 + ($2 * ($2 * ($2 * ($2 * 2.480158728947673e-05 + -.001388888888887411) + .0416666666666666) + $3 * $3 * ($2 * ($2 * -1.1359647557788195e-11 + 2.087572321298175e-09) + -2.7557314351390663e-07)) - $0 * $1));
16712 }
16713
16714 function scalbn($0, $1) {
16715 label$1 : {
16716 if (($1 | 0) >= 1024) {
16717 $0 = $0 * 8988465674311579538646525.0e283;
16718 if (($1 | 0) < 2047) {
16719 $1 = $1 + -1023 | 0;
16720 break label$1;
16721 }
16722 $0 = $0 * 8988465674311579538646525.0e283;
16723 $1 = (($1 | 0) < 3069 ? $1 : 3069) + -2046 | 0;
16724 break label$1;
16725 }
16726 if (($1 | 0) > -1023) {
16727 break label$1
16728 }
16729 $0 = $0 * 2.2250738585072014e-308;
16730 if (($1 | 0) > -2045) {
16731 $1 = $1 + 1022 | 0;
16732 break label$1;
16733 }
16734 $0 = $0 * 2.2250738585072014e-308;
16735 $1 = (($1 | 0) > -3066 ? $1 : -3066) + 2044 | 0;
16736 }
16737 wasm2js_scratch_store_i32(0, 0);
16738 wasm2js_scratch_store_i32(1, $1 + 1023 << 20);
16739 return $0 * +wasm2js_scratch_load_f64();
16740 }
16741
16742 function __rem_pio2_large($0, $1, $2, $3) {
16743 var $4 = 0.0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0.0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0;
16744 $7 = global$0 - 560 | 0;
16745 global$0 = $7;
16746 $5 = ($2 + -3 | 0) / 24 | 0;
16747 $16 = ($5 | 0) > 0 ? $5 : 0;
16748 $10 = $2 + Math_imul($16, -24) | 0;
16749 $12 = HEAP32[1901];
16750 $9 = $3 + -1 | 0;
16751 if (($12 + $9 | 0) >= 0) {
16752 $5 = $3 + $12 | 0;
16753 $2 = $16 - $9 | 0;
16754 while (1) {
16755 HEAPF64[($7 + 320 | 0) + ($6 << 3) >> 3] = ($2 | 0) < 0 ? 0.0 : +HEAP32[($2 << 2) + 7616 >> 2];
16756 $2 = $2 + 1 | 0;
16757 $6 = $6 + 1 | 0;
16758 if (($5 | 0) != ($6 | 0)) {
16759 continue
16760 }
16761 break;
16762 };
16763 }
16764 $13 = $10 + -24 | 0;
16765 $5 = 0;
16766 $6 = ($12 | 0) > 0 ? $12 : 0;
16767 $11 = ($3 | 0) < 1;
16768 while (1) {
16769 label$6 : {
16770 if ($11) {
16771 $4 = 0.0;
16772 break label$6;
16773 }
16774 $8 = $5 + $9 | 0;
16775 $2 = 0;
16776 $4 = 0.0;
16777 while (1) {
16778 $4 = $4 + HEAPF64[($2 << 3) + $0 >> 3] * HEAPF64[($7 + 320 | 0) + ($8 - $2 << 3) >> 3];
16779 $2 = $2 + 1 | 0;
16780 if (($3 | 0) != ($2 | 0)) {
16781 continue
16782 }
16783 break;
16784 };
16785 }
16786 HEAPF64[($5 << 3) + $7 >> 3] = $4;
16787 $2 = ($5 | 0) == ($6 | 0);
16788 $5 = $5 + 1 | 0;
16789 if (!$2) {
16790 continue
16791 }
16792 break;
16793 };
16794 $20 = 47 - $10 | 0;
16795 $17 = 48 - $10 | 0;
16796 $21 = $10 + -25 | 0;
16797 $5 = $12;
16798 label$9 : {
16799 while (1) {
16800 $4 = HEAPF64[($5 << 3) + $7 >> 3];
16801 $2 = 0;
16802 $6 = $5;
16803 $9 = ($5 | 0) < 1;
16804 if (!$9) {
16805 while (1) {
16806 $11 = ($7 + 480 | 0) + ($2 << 2) | 0;
16807 $14 = $4;
16808 $4 = $4 * 5.9604644775390625e-08;
16809 label$14 : {
16810 if (Math_abs($4) < 2147483648.0) {
16811 $8 = ~~$4;
16812 break label$14;
16813 }
16814 $8 = -2147483648;
16815 }
16816 $4 = +($8 | 0);
16817 $14 = $14 + $4 * -16777216.0;
16818 label$13 : {
16819 if (Math_abs($14) < 2147483648.0) {
16820 $8 = ~~$14;
16821 break label$13;
16822 }
16823 $8 = -2147483648;
16824 }
16825 HEAP32[$11 >> 2] = $8;
16826 $6 = $6 + -1 | 0;
16827 $4 = HEAPF64[($6 << 3) + $7 >> 3] + $4;
16828 $2 = $2 + 1 | 0;
16829 if (($5 | 0) != ($2 | 0)) {
16830 continue
16831 }
16832 break;
16833 }
16834 }
16835 $4 = scalbn($4, $13);
16836 $4 = $4 + Math_floor($4 * .125) * -8.0;
16837 label$17 : {
16838 if (Math_abs($4) < 2147483648.0) {
16839 $11 = ~~$4;
16840 break label$17;
16841 }
16842 $11 = -2147483648;
16843 }
16844 $4 = $4 - +($11 | 0);
16845 label$19 : {
16846 label$20 : {
16847 label$21 : {
16848 $18 = ($13 | 0) < 1;
16849 label$22 : {
16850 if (!$18) {
16851 $6 = (($5 << 2) + $7 | 0) + 476 | 0;
16852 $8 = HEAP32[$6 >> 2];
16853 $2 = $8 >> $17;
16854 $15 = $6;
16855 $6 = $8 - ($2 << $17) | 0;
16856 HEAP32[$15 >> 2] = $6;
16857 $11 = $2 + $11 | 0;
16858 $8 = $6 >> $20;
16859 break label$22;
16860 }
16861 if ($13) {
16862 break label$21
16863 }
16864 $8 = HEAP32[(($5 << 2) + $7 | 0) + 476 >> 2] >> 23;
16865 }
16866 if (($8 | 0) < 1) {
16867 break label$19
16868 }
16869 break label$20;
16870 }
16871 $8 = 2;
16872 if (!!($4 >= .5)) {
16873 break label$20
16874 }
16875 $8 = 0;
16876 break label$19;
16877 }
16878 $2 = 0;
16879 $6 = 0;
16880 if (!$9) {
16881 while (1) {
16882 $15 = ($7 + 480 | 0) + ($2 << 2) | 0;
16883 $19 = HEAP32[$15 >> 2];
16884 $9 = 16777215;
16885 label$26 : {
16886 label$27 : {
16887 if ($6) {
16888 break label$27
16889 }
16890 $9 = 16777216;
16891 if ($19) {
16892 break label$27
16893 }
16894 $6 = 0;
16895 break label$26;
16896 }
16897 HEAP32[$15 >> 2] = $9 - $19;
16898 $6 = 1;
16899 }
16900 $2 = $2 + 1 | 0;
16901 if (($5 | 0) != ($2 | 0)) {
16902 continue
16903 }
16904 break;
16905 }
16906 }
16907 label$28 : {
16908 if ($18) {
16909 break label$28
16910 }
16911 label$29 : {
16912 switch ($21 | 0) {
16913 case 0:
16914 $2 = (($5 << 2) + $7 | 0) + 476 | 0;
16915 HEAP32[$2 >> 2] = HEAP32[$2 >> 2] & 8388607;
16916 break label$28;
16917 case 1:
16918 break label$29;
16919 default:
16920 break label$28;
16921 };
16922 }
16923 $2 = (($5 << 2) + $7 | 0) + 476 | 0;
16924 HEAP32[$2 >> 2] = HEAP32[$2 >> 2] & 4194303;
16925 }
16926 $11 = $11 + 1 | 0;
16927 if (($8 | 0) != 2) {
16928 break label$19
16929 }
16930 $4 = 1.0 - $4;
16931 $8 = 2;
16932 if (!$6) {
16933 break label$19
16934 }
16935 $4 = $4 - scalbn(1.0, $13);
16936 }
16937 if ($4 == 0.0) {
16938 $6 = 0;
16939 label$32 : {
16940 $2 = $5;
16941 if (($2 | 0) <= ($12 | 0)) {
16942 break label$32
16943 }
16944 while (1) {
16945 $2 = $2 + -1 | 0;
16946 $6 = HEAP32[($7 + 480 | 0) + ($2 << 2) >> 2] | $6;
16947 if (($2 | 0) > ($12 | 0)) {
16948 continue
16949 }
16950 break;
16951 };
16952 if (!$6) {
16953 break label$32
16954 }
16955 $10 = $13;
16956 while (1) {
16957 $10 = $10 + -24 | 0;
16958 $5 = $5 + -1 | 0;
16959 if (!HEAP32[($7 + 480 | 0) + ($5 << 2) >> 2]) {
16960 continue
16961 }
16962 break;
16963 };
16964 break label$9;
16965 }
16966 $2 = 1;
16967 while (1) {
16968 $6 = $2;
16969 $2 = $2 + 1 | 0;
16970 if (!HEAP32[($7 + 480 | 0) + ($12 - $6 << 2) >> 2]) {
16971 continue
16972 }
16973 break;
16974 };
16975 $6 = $5 + $6 | 0;
16976 while (1) {
16977 $9 = $3 + $5 | 0;
16978 $5 = $5 + 1 | 0;
16979 HEAPF64[($7 + 320 | 0) + ($9 << 3) >> 3] = HEAP32[($16 + $5 << 2) + 7616 >> 2];
16980 $2 = 0;
16981 $4 = 0.0;
16982 if (($3 | 0) >= 1) {
16983 while (1) {
16984 $4 = $4 + HEAPF64[($2 << 3) + $0 >> 3] * HEAPF64[($7 + 320 | 0) + ($9 - $2 << 3) >> 3];
16985 $2 = $2 + 1 | 0;
16986 if (($3 | 0) != ($2 | 0)) {
16987 continue
16988 }
16989 break;
16990 }
16991 }
16992 HEAPF64[($5 << 3) + $7 >> 3] = $4;
16993 if (($5 | 0) < ($6 | 0)) {
16994 continue
16995 }
16996 break;
16997 };
16998 $5 = $6;
16999 continue;
17000 }
17001 break;
17002 };
17003 $4 = scalbn($4, 0 - $13 | 0);
17004 label$39 : {
17005 if (!!($4 >= 16777216.0)) {
17006 $3 = ($7 + 480 | 0) + ($5 << 2) | 0;
17007 $14 = $4;
17008 $4 = $4 * 5.9604644775390625e-08;
17009 label$42 : {
17010 if (Math_abs($4) < 2147483648.0) {
17011 $2 = ~~$4;
17012 break label$42;
17013 }
17014 $2 = -2147483648;
17015 }
17016 $4 = $14 + +($2 | 0) * -16777216.0;
17017 label$41 : {
17018 if (Math_abs($4) < 2147483648.0) {
17019 $0 = ~~$4;
17020 break label$41;
17021 }
17022 $0 = -2147483648;
17023 }
17024 HEAP32[$3 >> 2] = $0;
17025 $5 = $5 + 1 | 0;
17026 break label$39;
17027 }
17028 $2 = Math_abs($4) < 2147483648.0 ? ~~$4 : -2147483648;
17029 $10 = $13;
17030 }
17031 HEAP32[($7 + 480 | 0) + ($5 << 2) >> 2] = $2;
17032 }
17033 $4 = scalbn(1.0, $10);
17034 label$47 : {
17035 if (($5 | 0) <= -1) {
17036 break label$47
17037 }
17038 $2 = $5;
17039 while (1) {
17040 HEAPF64[($2 << 3) + $7 >> 3] = $4 * +HEAP32[($7 + 480 | 0) + ($2 << 2) >> 2];
17041 $4 = $4 * 5.9604644775390625e-08;
17042 $0 = ($2 | 0) > 0;
17043 $2 = $2 + -1 | 0;
17044 if ($0) {
17045 continue
17046 }
17047 break;
17048 };
17049 $9 = 0;
17050 if (($5 | 0) < 0) {
17051 break label$47
17052 }
17053 $0 = ($12 | 0) > 0 ? $12 : 0;
17054 $6 = $5;
17055 while (1) {
17056 $3 = $0 >>> 0 < $9 >>> 0 ? $0 : $9;
17057 $10 = $5 - $6 | 0;
17058 $2 = 0;
17059 $4 = 0.0;
17060 while (1) {
17061 $4 = $4 + HEAPF64[($2 << 3) + 10384 >> 3] * HEAPF64[($2 + $6 << 3) + $7 >> 3];
17062 $13 = ($2 | 0) != ($3 | 0);
17063 $2 = $2 + 1 | 0;
17064 if ($13) {
17065 continue
17066 }
17067 break;
17068 };
17069 HEAPF64[($7 + 160 | 0) + ($10 << 3) >> 3] = $4;
17070 $6 = $6 + -1 | 0;
17071 $2 = ($5 | 0) != ($9 | 0);
17072 $9 = $9 + 1 | 0;
17073 if ($2) {
17074 continue
17075 }
17076 break;
17077 };
17078 }
17079 $4 = 0.0;
17080 if (($5 | 0) >= 0) {
17081 $2 = $5;
17082 while (1) {
17083 $4 = $4 + HEAPF64[($7 + 160 | 0) + ($2 << 3) >> 3];
17084 $0 = ($2 | 0) > 0;
17085 $2 = $2 + -1 | 0;
17086 if ($0) {
17087 continue
17088 }
17089 break;
17090 };
17091 }
17092 HEAPF64[$1 >> 3] = $8 ? -$4 : $4;
17093 $4 = HEAPF64[$7 + 160 >> 3] - $4;
17094 $2 = 1;
17095 if (($5 | 0) >= 1) {
17096 while (1) {
17097 $4 = $4 + HEAPF64[($7 + 160 | 0) + ($2 << 3) >> 3];
17098 $0 = ($2 | 0) != ($5 | 0);
17099 $2 = $2 + 1 | 0;
17100 if ($0) {
17101 continue
17102 }
17103 break;
17104 }
17105 }
17106 HEAPF64[$1 + 8 >> 3] = $8 ? -$4 : $4;
17107 global$0 = $7 + 560 | 0;
17108 return $11 & 7;
17109 }
17110
17111 function __rem_pio2($0, $1) {
17112 var $2 = 0.0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0.0, $9 = 0.0, $10 = 0;
17113 $6 = global$0 - 48 | 0;
17114 global$0 = $6;
17115 wasm2js_scratch_store_f64(+$0);
17116 $5 = wasm2js_scratch_load_i32(1) | 0;
17117 $3 = wasm2js_scratch_load_i32(0) | 0;
17118 label$1 : {
17119 label$2 : {
17120 $4 = $5;
17121 $5 = $4;
17122 $7 = $4 & 2147483647;
17123 label$3 : {
17124 if ($7 >>> 0 <= 1074752122) {
17125 if (($5 & 1048575) == 598523) {
17126 break label$3
17127 }
17128 if ($7 >>> 0 <= 1073928572) {
17129 if (($4 | 0) > 0 ? 1 : ($4 | 0) >= 0 ? ($3 >>> 0 < 0 ? 0 : 1) : 0) {
17130 $0 = $0 + -1.5707963267341256;
17131 $2 = $0 + -6.077100506506192e-11;
17132 HEAPF64[$1 >> 3] = $2;
17133 HEAPF64[$1 + 8 >> 3] = $0 - $2 + -6.077100506506192e-11;
17134 $3 = 1;
17135 break label$1;
17136 }
17137 $0 = $0 + 1.5707963267341256;
17138 $2 = $0 + 6.077100506506192e-11;
17139 HEAPF64[$1 >> 3] = $2;
17140 HEAPF64[$1 + 8 >> 3] = $0 - $2 + 6.077100506506192e-11;
17141 $3 = -1;
17142 break label$1;
17143 }
17144 if (($4 | 0) > 0 ? 1 : ($4 | 0) >= 0 ? ($3 >>> 0 < 0 ? 0 : 1) : 0) {
17145 $0 = $0 + -3.1415926534682512;
17146 $2 = $0 + -1.2154201013012384e-10;
17147 HEAPF64[$1 >> 3] = $2;
17148 HEAPF64[$1 + 8 >> 3] = $0 - $2 + -1.2154201013012384e-10;
17149 $3 = 2;
17150 break label$1;
17151 }
17152 $0 = $0 + 3.1415926534682512;
17153 $2 = $0 + 1.2154201013012384e-10;
17154 HEAPF64[$1 >> 3] = $2;
17155 HEAPF64[$1 + 8 >> 3] = $0 - $2 + 1.2154201013012384e-10;
17156 $3 = -2;
17157 break label$1;
17158 }
17159 if ($7 >>> 0 <= 1075594811) {
17160 if ($7 >>> 0 <= 1075183036) {
17161 if (($7 | 0) == 1074977148) {
17162 break label$3
17163 }
17164 if (($4 | 0) > 0 ? 1 : ($4 | 0) >= 0 ? ($3 >>> 0 < 0 ? 0 : 1) : 0) {
17165 $0 = $0 + -4.712388980202377;
17166 $2 = $0 + -1.8231301519518578e-10;
17167 HEAPF64[$1 >> 3] = $2;
17168 HEAPF64[$1 + 8 >> 3] = $0 - $2 + -1.8231301519518578e-10;
17169 $3 = 3;
17170 break label$1;
17171 }
17172 $0 = $0 + 4.712388980202377;
17173 $2 = $0 + 1.8231301519518578e-10;
17174 HEAPF64[$1 >> 3] = $2;
17175 HEAPF64[$1 + 8 >> 3] = $0 - $2 + 1.8231301519518578e-10;
17176 $3 = -3;
17177 break label$1;
17178 }
17179 if (($7 | 0) == 1075388923) {
17180 break label$3
17181 }
17182 if (($4 | 0) > 0 ? 1 : ($4 | 0) >= 0 ? ($3 >>> 0 < 0 ? 0 : 1) : 0) {
17183 $0 = $0 + -6.2831853069365025;
17184 $2 = $0 + -2.430840202602477e-10;
17185 HEAPF64[$1 >> 3] = $2;
17186 HEAPF64[$1 + 8 >> 3] = $0 - $2 + -2.430840202602477e-10;
17187 $3 = 4;
17188 break label$1;
17189 }
17190 $0 = $0 + 6.2831853069365025;
17191 $2 = $0 + 2.430840202602477e-10;
17192 HEAPF64[$1 >> 3] = $2;
17193 HEAPF64[$1 + 8 >> 3] = $0 - $2 + 2.430840202602477e-10;
17194 $3 = -4;
17195 break label$1;
17196 }
17197 if ($7 >>> 0 > 1094263290) {
17198 break label$2
17199 }
17200 }
17201 $9 = $0 * .6366197723675814 + 6755399441055744.0 + -6755399441055744.0;
17202 $2 = $0 + $9 * -1.5707963267341256;
17203 $8 = $9 * 6.077100506506192e-11;
17204 $0 = $2 - $8;
17205 HEAPF64[$1 >> 3] = $0;
17206 wasm2js_scratch_store_f64(+$0);
17207 $3 = wasm2js_scratch_load_i32(1) | 0;
17208 wasm2js_scratch_load_i32(0) | 0;
17209 $4 = $7 >>> 20 | 0;
17210 $5 = ($4 - ($3 >>> 20 & 2047) | 0) < 17;
17211 if (Math_abs($9) < 2147483648.0) {
17212 $3 = ~~$9
17213 } else {
17214 $3 = -2147483648
17215 }
17216 label$14 : {
17217 if ($5) {
17218 break label$14
17219 }
17220 $8 = $2;
17221 $0 = $9 * 6.077100506303966e-11;
17222 $2 = $2 - $0;
17223 $8 = $9 * 2.0222662487959506e-21 - ($8 - $2 - $0);
17224 $0 = $2 - $8;
17225 HEAPF64[$1 >> 3] = $0;
17226 $5 = $4;
17227 wasm2js_scratch_store_f64(+$0);
17228 $4 = wasm2js_scratch_load_i32(1) | 0;
17229 wasm2js_scratch_load_i32(0) | 0;
17230 if (($5 - ($4 >>> 20 & 2047) | 0) < 50) {
17231 break label$14
17232 }
17233 $8 = $2;
17234 $0 = $9 * 2.0222662487111665e-21;
17235 $2 = $2 - $0;
17236 $8 = $9 * 8.4784276603689e-32 - ($8 - $2 - $0);
17237 $0 = $2 - $8;
17238 HEAPF64[$1 >> 3] = $0;
17239 }
17240 HEAPF64[$1 + 8 >> 3] = $2 - $0 - $8;
17241 break label$1;
17242 }
17243 if ($7 >>> 0 >= 2146435072) {
17244 $0 = $0 - $0;
17245 HEAPF64[$1 >> 3] = $0;
17246 HEAPF64[$1 + 8 >> 3] = $0;
17247 $3 = 0;
17248 break label$1;
17249 }
17250 wasm2js_scratch_store_i32(0, $3 | 0);
17251 wasm2js_scratch_store_i32(1, $4 & 1048575 | 1096810496);
17252 $0 = +wasm2js_scratch_load_f64();
17253 $3 = 0;
17254 $5 = 1;
17255 while (1) {
17256 $10 = ($6 + 16 | 0) + ($3 << 3) | 0;
17257 if (Math_abs($0) < 2147483648.0) {
17258 $3 = ~~$0
17259 } else {
17260 $3 = -2147483648
17261 }
17262 $2 = +($3 | 0);
17263 HEAPF64[$10 >> 3] = $2;
17264 $0 = ($0 - $2) * 16777216.0;
17265 $3 = 1;
17266 $10 = $5 & 1;
17267 $5 = 0;
17268 if ($10) {
17269 continue
17270 }
17271 break;
17272 };
17273 HEAPF64[$6 + 32 >> 3] = $0;
17274 label$20 : {
17275 if ($0 != 0.0) {
17276 $3 = 2;
17277 break label$20;
17278 }
17279 $5 = 1;
17280 while (1) {
17281 $3 = $5;
17282 $5 = $3 + -1 | 0;
17283 if (HEAPF64[($6 + 16 | 0) + ($3 << 3) >> 3] == 0.0) {
17284 continue
17285 }
17286 break;
17287 };
17288 }
17289 $3 = __rem_pio2_large($6 + 16 | 0, $6, ($7 >>> 20 | 0) + -1046 | 0, $3 + 1 | 0);
17290 $0 = HEAPF64[$6 >> 3];
17291 if (($4 | 0) < -1 ? 1 : ($4 | 0) <= -1 ? 1 : 0) {
17292 HEAPF64[$1 >> 3] = -$0;
17293 HEAPF64[$1 + 8 >> 3] = -HEAPF64[$6 + 8 >> 3];
17294 $3 = 0 - $3 | 0;
17295 break label$1;
17296 }
17297 HEAPF64[$1 >> 3] = $0;
17298 $4 = HEAP32[$6 + 12 >> 2];
17299 HEAP32[$1 + 8 >> 2] = HEAP32[$6 + 8 >> 2];
17300 HEAP32[$1 + 12 >> 2] = $4;
17301 }
17302 global$0 = $6 + 48 | 0;
17303 return $3;
17304 }
17305
17306 function __sin($0, $1) {
17307 var $2 = 0.0, $3 = 0.0;
17308 $2 = $0 * $0;
17309 $3 = $0;
17310 $0 = $2 * $0;
17311 return $3 - ($2 * ($1 * .5 - $0 * ($2 * ($2 * $2) * ($2 * 1.58969099521155e-10 + -2.5050760253406863e-08) + ($2 * ($2 * 2.7557313707070068e-06 + -1.984126982985795e-04) + .00833333333332249))) - $1 + $0 * .16666666666666632);
17312 }
17313
17314 function cos($0) {
17315 var $1 = 0, $2 = 0.0, $3 = 0;
17316 $1 = global$0 - 16 | 0;
17317 global$0 = $1;
17318 wasm2js_scratch_store_f64(+$0);
17319 $3 = wasm2js_scratch_load_i32(1) | 0;
17320 wasm2js_scratch_load_i32(0) | 0;
17321 $3 = $3 & 2147483647;
17322 label$1 : {
17323 if ($3 >>> 0 <= 1072243195) {
17324 $2 = 1.0;
17325 if ($3 >>> 0 < 1044816030) {
17326 break label$1
17327 }
17328 $2 = __cos($0, 0.0);
17329 break label$1;
17330 }
17331 $2 = $0 - $0;
17332 if ($3 >>> 0 >= 2146435072) {
17333 break label$1
17334 }
17335 label$3 : {
17336 switch (__rem_pio2($0, $1) & 3) {
17337 case 0:
17338 $2 = __cos(HEAPF64[$1 >> 3], HEAPF64[$1 + 8 >> 3]);
17339 break label$1;
17340 case 1:
17341 $2 = -__sin(HEAPF64[$1 >> 3], HEAPF64[$1 + 8 >> 3]);
17342 break label$1;
17343 case 2:
17344 $2 = -__cos(HEAPF64[$1 >> 3], HEAPF64[$1 + 8 >> 3]);
17345 break label$1;
17346 default:
17347 break label$3;
17348 };
17349 }
17350 $2 = __sin(HEAPF64[$1 >> 3], HEAPF64[$1 + 8 >> 3]);
17351 }
17352 $0 = $2;
17353 global$0 = $1 + 16 | 0;
17354 return $0;
17355 }
17356
17357 function exp($0) {
17358 var $1 = 0, $2 = 0.0, $3 = 0, $4 = 0.0, $5 = 0, $6 = 0.0, $7 = 0;
17359 wasm2js_scratch_store_f64(+$0);
17360 $3 = wasm2js_scratch_load_i32(1) | 0;
17361 $7 = wasm2js_scratch_load_i32(0) | 0;
17362 $5 = $3 >>> 31 | 0;
17363 label$1 : {
17364 label$2 : {
17365 label$3 : {
17366 label$4 : {
17367 $6 = $0;
17368 label$5 : {
17369 label$6 : {
17370 $1 = $3;
17371 $3 = $1 & 2147483647;
17372 label$7 : {
17373 if ($3 >>> 0 >= 1082532651) {
17374 $1 = $1 & 2147483647;
17375 if (($1 | 0) == 2146435072 & $7 >>> 0 > 0 | $1 >>> 0 > 2146435072) {
17376 return $0
17377 }
17378 if (!!($0 > 709.782712893384)) {
17379 return $0 * 8988465674311579538646525.0e283
17380 }
17381 if (!($0 < -708.3964185322641)) {
17382 break label$7
17383 }
17384 if (!($0 < -745.1332191019411)) {
17385 break label$7
17386 }
17387 break label$2;
17388 }
17389 if ($3 >>> 0 < 1071001155) {
17390 break label$4
17391 }
17392 if ($3 >>> 0 < 1072734898) {
17393 break label$6
17394 }
17395 }
17396 $0 = $0 * 1.4426950408889634 + HEAPF64[($5 << 3) + 10448 >> 3];
17397 if (Math_abs($0) < 2147483648.0) {
17398 $1 = ~~$0;
17399 break label$5;
17400 }
17401 $1 = -2147483648;
17402 break label$5;
17403 }
17404 $1 = ($5 ^ 1) - $5 | 0;
17405 }
17406 $2 = +($1 | 0);
17407 $0 = $6 + $2 * -.6931471803691238;
17408 $4 = $2 * 1.9082149292705877e-10;
17409 $2 = $0 - $4;
17410 break label$3;
17411 }
17412 if ($3 >>> 0 <= 1043333120) {
17413 break label$1
17414 }
17415 $1 = 0;
17416 $2 = $0;
17417 }
17418 $6 = $0;
17419 $0 = $2 * $2;
17420 $0 = $2 - $0 * ($0 * ($0 * ($0 * ($0 * 4.1381367970572385e-08 + -1.6533902205465252e-06) + 6.613756321437934e-05) + -2.7777777777015593e-03) + .16666666666666602);
17421 $4 = $6 + ($2 * $0 / (2.0 - $0) - $4) + 1.0;
17422 if (!$1) {
17423 break label$2
17424 }
17425 $4 = scalbn($4, $1);
17426 }
17427 return $4;
17428 }
17429 return $0 + 1.0;
17430 }
17431
17432 function FLAC__window_bartlett($0, $1) {
17433 var $2 = 0, $3 = Math_fround(0), $4 = 0, $5 = Math_fround(0), $6 = 0, $7 = 0, $8 = 0;
17434 $7 = $1 + -1 | 0;
17435 label$1 : {
17436 if ($1 & 1) {
17437 $4 = ($7 | 0) / 2 | 0;
17438 if (($1 | 0) >= 0) {
17439 $8 = ($4 | 0) > 0 ? $4 : 0;
17440 $6 = $8 + 1 | 0;
17441 $5 = Math_fround($7 | 0);
17442 while (1) {
17443 $3 = Math_fround($2 | 0);
17444 HEAPF32[($2 << 2) + $0 >> 2] = Math_fround($3 + $3) / $5;
17445 $4 = ($2 | 0) == ($8 | 0);
17446 $2 = $2 + 1 | 0;
17447 if (!$4) {
17448 continue
17449 }
17450 break;
17451 };
17452 }
17453 if (($6 | 0) >= ($1 | 0)) {
17454 break label$1
17455 }
17456 $5 = Math_fround($7 | 0);
17457 while (1) {
17458 $3 = Math_fround($6 | 0);
17459 HEAPF32[($6 << 2) + $0 >> 2] = Math_fround(2.0) - Math_fround(Math_fround($3 + $3) / $5);
17460 $6 = $6 + 1 | 0;
17461 if (($6 | 0) != ($1 | 0)) {
17462 continue
17463 }
17464 break;
17465 };
17466 break label$1;
17467 }
17468 $4 = ($1 | 0) / 2 | 0;
17469 if (($1 | 0) >= 2) {
17470 $5 = Math_fround($7 | 0);
17471 while (1) {
17472 $3 = Math_fround($2 | 0);
17473 HEAPF32[($2 << 2) + $0 >> 2] = Math_fround($3 + $3) / $5;
17474 $2 = $2 + 1 | 0;
17475 if (($4 | 0) != ($2 | 0)) {
17476 continue
17477 }
17478 break;
17479 };
17480 $2 = $4;
17481 }
17482 if (($2 | 0) >= ($1 | 0)) {
17483 break label$1
17484 }
17485 $5 = Math_fround($7 | 0);
17486 while (1) {
17487 $3 = Math_fround($2 | 0);
17488 HEAPF32[($2 << 2) + $0 >> 2] = Math_fround(2.0) - Math_fround(Math_fround($3 + $3) / $5);
17489 $2 = $2 + 1 | 0;
17490 if (($2 | 0) != ($1 | 0)) {
17491 continue
17492 }
17493 break;
17494 };
17495 }
17496 }
17497
17498 function FLAC__window_bartlett_hann($0, $1) {
17499 var $2 = 0, $3 = Math_fround(0), $4 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0);
17500 if (($1 | 0) >= 1) {
17501 $4 = Math_fround($1 + -1 | 0);
17502 while (1) {
17503 $3 = Math_fround(Math_fround($2 | 0) / $4);
17504 (wasm2js_i32$0 = ($2 << 2) + $0 | 0, wasm2js_f32$0 = Math_fround(+Math_fround(Math_abs(Math_fround($3 + Math_fround(-.5)))) * -.47999998927116394 + .6200000047683716 + cos(+$3 * 6.283185307179586) * -.3799999952316284)), HEAPF32[wasm2js_i32$0 >> 2] = wasm2js_f32$0;
17505 $2 = $2 + 1 | 0;
17506 if (($2 | 0) != ($1 | 0)) {
17507 continue
17508 }
17509 break;
17510 };
17511 }
17512 }
17513
17514 function FLAC__window_blackman($0, $1) {
17515 var $2 = 0, $3 = 0.0, $4 = 0.0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0);
17516 if (($1 | 0) >= 1) {
17517 $3 = +($1 + -1 | 0);
17518 while (1) {
17519 $4 = +($2 | 0);
17520 (wasm2js_i32$0 = ($2 << 2) + $0 | 0, wasm2js_f32$0 = Math_fround(cos($4 * 12.566370614359172 / $3) * .07999999821186066 + (cos($4 * 6.283185307179586 / $3) * -.5 + .41999998688697815))), HEAPF32[wasm2js_i32$0 >> 2] = wasm2js_f32$0;
17521 $2 = $2 + 1 | 0;
17522 if (($2 | 0) != ($1 | 0)) {
17523 continue
17524 }
17525 break;
17526 };
17527 }
17528 }
17529
17530 function FLAC__window_blackman_harris_4term_92db_sidelobe($0, $1) {
17531 var $2 = 0, $3 = 0.0, $4 = 0.0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0);
17532 if (($1 | 0) >= 1) {
17533 $3 = +($1 + -1 | 0);
17534 while (1) {
17535 $4 = +($2 | 0);
17536 (wasm2js_i32$0 = ($2 << 2) + $0 | 0, wasm2js_f32$0 = Math_fround(cos($4 * 12.566370614359172 / $3) * .14127999544143677 + (cos($4 * 6.283185307179586 / $3) * -.488290011882782 + .35874998569488525) + cos($4 * 18.84955592153876 / $3) * -.011680000461637974)), HEAPF32[wasm2js_i32$0 >> 2] = wasm2js_f32$0;
17537 $2 = $2 + 1 | 0;
17538 if (($2 | 0) != ($1 | 0)) {
17539 continue
17540 }
17541 break;
17542 };
17543 }
17544 }
17545
17546 function FLAC__window_connes($0, $1) {
17547 var $2 = 0.0, $3 = 0, $4 = 0.0;
17548 if (($1 | 0) >= 1) {
17549 $4 = +($1 + -1 | 0) * .5;
17550 while (1) {
17551 $2 = (+($3 | 0) - $4) / $4;
17552 $2 = 1.0 - $2 * $2;
17553 HEAPF32[($3 << 2) + $0 >> 2] = $2 * $2;
17554 $3 = $3 + 1 | 0;
17555 if (($3 | 0) != ($1 | 0)) {
17556 continue
17557 }
17558 break;
17559 };
17560 }
17561 }
17562
17563 function FLAC__window_flattop($0, $1) {
17564 var $2 = 0.0, $3 = 0, $4 = 0.0, $5 = 0.0, $6 = 0.0, $7 = 0.0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0);
17565 if (($1 | 0) >= 1) {
17566 $2 = +($1 + -1 | 0);
17567 while (1) {
17568 $4 = +($3 | 0);
17569 $5 = cos($4 * 12.566370614359172 / $2);
17570 $6 = cos($4 * 6.283185307179586 / $2);
17571 $7 = cos($4 * 18.84955592153876 / $2);
17572 (wasm2js_i32$0 = ($3 << 2) + $0 | 0, wasm2js_f32$0 = Math_fround(cos($4 * 25.132741228718345 / $2) * 6.9473679177463055e-03 + ($5 * .27726316452026367 + ($6 * -.4166315793991089 + .21557894349098206) + $7 * -.08357894420623779))), HEAPF32[wasm2js_i32$0 >> 2] = wasm2js_f32$0;
17573 $3 = $3 + 1 | 0;
17574 if (($3 | 0) != ($1 | 0)) {
17575 continue
17576 }
17577 break;
17578 };
17579 }
17580 }
17581
17582 function FLAC__window_gauss($0, $1, $2) {
17583 var $3 = 0, $4 = 0.0, $5 = 0.0, $6 = 0.0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0);
17584 if (($1 | 0) >= 1) {
17585 $4 = +($1 + -1 | 0) * .5;
17586 $6 = $4 * +$2;
17587 while (1) {
17588 $5 = (+($3 | 0) - $4) / $6;
17589 (wasm2js_i32$0 = ($3 << 2) + $0 | 0, wasm2js_f32$0 = Math_fround(exp($5 * ($5 * -.5)))), HEAPF32[wasm2js_i32$0 >> 2] = wasm2js_f32$0;
17590 $3 = $3 + 1 | 0;
17591 if (($3 | 0) != ($1 | 0)) {
17592 continue
17593 }
17594 break;
17595 };
17596 }
17597 }
17598
17599 function FLAC__window_hamming($0, $1) {
17600 var $2 = 0, $3 = 0.0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0);
17601 if (($1 | 0) >= 1) {
17602 $3 = +($1 + -1 | 0);
17603 while (1) {
17604 (wasm2js_i32$0 = ($2 << 2) + $0 | 0, wasm2js_f32$0 = Math_fround(cos(+($2 | 0) * 6.283185307179586 / $3) * -.46000000834465027 + .5400000214576721)), HEAPF32[wasm2js_i32$0 >> 2] = wasm2js_f32$0;
17605 $2 = $2 + 1 | 0;
17606 if (($2 | 0) != ($1 | 0)) {
17607 continue
17608 }
17609 break;
17610 };
17611 }
17612 }
17613
17614 function FLAC__window_hann($0, $1) {
17615 var $2 = 0, $3 = 0.0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0);
17616 if (($1 | 0) >= 1) {
17617 $3 = +($1 + -1 | 0);
17618 while (1) {
17619 (wasm2js_i32$0 = ($2 << 2) + $0 | 0, wasm2js_f32$0 = Math_fround(.5 - cos(+($2 | 0) * 6.283185307179586 / $3) * .5)), HEAPF32[wasm2js_i32$0 >> 2] = wasm2js_f32$0;
17620 $2 = $2 + 1 | 0;
17621 if (($2 | 0) != ($1 | 0)) {
17622 continue
17623 }
17624 break;
17625 };
17626 }
17627 }
17628
17629 function FLAC__window_kaiser_bessel($0, $1) {
17630 var $2 = 0, $3 = 0.0, $4 = 0.0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0);
17631 if (($1 | 0) >= 1) {
17632 $3 = +($1 + -1 | 0);
17633 while (1) {
17634 $4 = +($2 | 0);
17635 (wasm2js_i32$0 = ($2 << 2) + $0 | 0, wasm2js_f32$0 = Math_fround(cos($4 * 12.566370614359172 / $3) * .09799999743700027 + (cos($4 * 6.283185307179586 / $3) * -.49799999594688416 + .4020000100135803) + cos($4 * 18.84955592153876 / $3) * -1.0000000474974513e-03)), HEAPF32[wasm2js_i32$0 >> 2] = wasm2js_f32$0;
17636 $2 = $2 + 1 | 0;
17637 if (($2 | 0) != ($1 | 0)) {
17638 continue
17639 }
17640 break;
17641 };
17642 }
17643 }
17644
17645 function FLAC__window_nuttall($0, $1) {
17646 var $2 = 0, $3 = 0.0, $4 = 0.0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0);
17647 if (($1 | 0) >= 1) {
17648 $3 = +($1 + -1 | 0);
17649 while (1) {
17650 $4 = +($2 | 0);
17651 (wasm2js_i32$0 = ($2 << 2) + $0 | 0, wasm2js_f32$0 = Math_fround(cos($4 * 12.566370614359172 / $3) * .13659949600696564 + (cos($4 * 6.283185307179586 / $3) * -.48917749524116516 + .36358189582824707) + cos($4 * 18.84955592153876 / $3) * -.010641099885106087)), HEAPF32[wasm2js_i32$0 >> 2] = wasm2js_f32$0;
17652 $2 = $2 + 1 | 0;
17653 if (($2 | 0) != ($1 | 0)) {
17654 continue
17655 }
17656 break;
17657 };
17658 }
17659 }
17660
17661 function FLAC__window_rectangle($0, $1) {
17662 var $2 = 0;
17663 if (($1 | 0) >= 1) {
17664 while (1) {
17665 HEAP32[($2 << 2) + $0 >> 2] = 1065353216;
17666 $2 = $2 + 1 | 0;
17667 if (($2 | 0) != ($1 | 0)) {
17668 continue
17669 }
17670 break;
17671 }
17672 }
17673 }
17674
17675 function FLAC__window_triangle($0, $1) {
17676 var $2 = 0, $3 = 0, $4 = Math_fround(0), $5 = 0, $6 = Math_fround(0), $7 = 0;
17677 $3 = 1;
17678 label$1 : {
17679 if ($1 & 1) {
17680 $2 = ($1 + 1 | 0) / 2 | 0;
17681 if (($1 | 0) >= 1) {
17682 $4 = Math_fround(Math_fround($1 | 0) + Math_fround(1.0));
17683 $5 = ($2 | 0) > 1 ? $2 : 1;
17684 $3 = $5 + 1 | 0;
17685 $2 = 1;
17686 while (1) {
17687 $6 = Math_fround($2 | 0);
17688 HEAPF32[(($2 << 2) + $0 | 0) + -4 >> 2] = Math_fround($6 + $6) / $4;
17689 $7 = ($2 | 0) == ($5 | 0);
17690 $2 = $2 + 1 | 0;
17691 if (!$7) {
17692 continue
17693 }
17694 break;
17695 };
17696 }
17697 if (($3 | 0) > ($1 | 0)) {
17698 break label$1
17699 }
17700 $4 = Math_fround(Math_fround($1 | 0) + Math_fround(1.0));
17701 while (1) {
17702 HEAPF32[(($3 << 2) + $0 | 0) + -4 >> 2] = Math_fround(($1 - $3 << 1) + 2 | 0) / $4;
17703 $2 = ($1 | 0) == ($3 | 0);
17704 $3 = $3 + 1 | 0;
17705 if (!$2) {
17706 continue
17707 }
17708 break;
17709 };
17710 break label$1;
17711 }
17712 $2 = 1;
17713 if (($1 | 0) >= 2) {
17714 $5 = $1 >>> 1 | 0;
17715 $2 = $5 + 1 | 0;
17716 $4 = Math_fround(Math_fround($1 | 0) + Math_fround(1.0));
17717 while (1) {
17718 $6 = Math_fround($3 | 0);
17719 HEAPF32[(($3 << 2) + $0 | 0) + -4 >> 2] = Math_fround($6 + $6) / $4;
17720 $7 = ($3 | 0) == ($5 | 0);
17721 $3 = $3 + 1 | 0;
17722 if (!$7) {
17723 continue
17724 }
17725 break;
17726 };
17727 }
17728 if (($2 | 0) > ($1 | 0)) {
17729 break label$1
17730 }
17731 $4 = Math_fround(Math_fround($1 | 0) + Math_fround(1.0));
17732 while (1) {
17733 HEAPF32[(($2 << 2) + $0 | 0) + -4 >> 2] = Math_fround(($1 - $2 << 1) + 2 | 0) / $4;
17734 $3 = ($1 | 0) != ($2 | 0);
17735 $2 = $2 + 1 | 0;
17736 if ($3) {
17737 continue
17738 }
17739 break;
17740 };
17741 }
17742 }
17743
17744 function FLAC__window_tukey($0, $1, $2) {
17745 var $3 = 0, $4 = 0, $5 = 0.0, $6 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0);
17746 label$1 : {
17747 if (!!($2 <= Math_fround(0.0))) {
17748 if (($1 | 0) < 1) {
17749 break label$1
17750 }
17751 while (1) {
17752 HEAP32[($3 << 2) + $0 >> 2] = 1065353216;
17753 $3 = $3 + 1 | 0;
17754 if (($3 | 0) != ($1 | 0)) {
17755 continue
17756 }
17757 break;
17758 };
17759 break label$1;
17760 }
17761 if (!!($2 >= Math_fround(1.0))) {
17762 if (($1 | 0) < 1) {
17763 break label$1
17764 }
17765 $5 = +($1 + -1 | 0);
17766 while (1) {
17767 (wasm2js_i32$0 = ($3 << 2) + $0 | 0, wasm2js_f32$0 = Math_fround(.5 - cos(+($3 | 0) * 6.283185307179586 / $5) * .5)), HEAPF32[wasm2js_i32$0 >> 2] = wasm2js_f32$0;
17768 $3 = $3 + 1 | 0;
17769 if (($3 | 0) != ($1 | 0)) {
17770 continue
17771 }
17772 break;
17773 };
17774 break label$1;
17775 }
17776 $2 = Math_fround(Math_fround($2 * Math_fround(.5)) * Math_fround($1 | 0));
17777 label$6 : {
17778 if (Math_fround(Math_abs($2)) < Math_fround(2147483648.0)) {
17779 $4 = ~~$2;
17780 break label$6;
17781 }
17782 $4 = -2147483648;
17783 }
17784 if (($1 | 0) >= 1) {
17785 while (1) {
17786 HEAP32[($3 << 2) + $0 >> 2] = 1065353216;
17787 $3 = $3 + 1 | 0;
17788 if (($3 | 0) != ($1 | 0)) {
17789 continue
17790 }
17791 break;
17792 }
17793 }
17794 if (($4 | 0) < 2) {
17795 break label$1
17796 }
17797 $1 = $1 - $4 | 0;
17798 $6 = $4 + -1 | 0;
17799 $5 = +($6 | 0);
17800 $3 = 0;
17801 while (1) {
17802 (wasm2js_i32$0 = ($3 << 2) + $0 | 0, wasm2js_f32$0 = Math_fround(.5 - cos(+($3 | 0) * 3.141592653589793 / $5) * .5)), HEAPF32[wasm2js_i32$0 >> 2] = wasm2js_f32$0;
17803 (wasm2js_i32$0 = ($1 + $3 << 2) + $0 | 0, wasm2js_f32$0 = Math_fround(.5 - cos(+($3 + $6 | 0) * 3.141592653589793 / $5) * .5)), HEAPF32[wasm2js_i32$0 >> 2] = wasm2js_f32$0;
17804 $3 = $3 + 1 | 0;
17805 if (($4 | 0) != ($3 | 0)) {
17806 continue
17807 }
17808 break;
17809 };
17810 }
17811 }
17812
17813 function FLAC__window_partial_tukey($0, $1, $2, $3, $4) {
17814 var $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = Math_fround(0), $12 = 0.0, $13 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0);
17815 while (1) {
17816 $11 = $2;
17817 $2 = Math_fround(.05000000074505806);
17818 if ($11 <= Math_fround(0.0)) {
17819 continue
17820 }
17821 $2 = Math_fround(.949999988079071);
17822 if ($11 >= Math_fround(1.0)) {
17823 continue
17824 }
17825 break;
17826 };
17827 $2 = Math_fround($1 | 0);
17828 $3 = Math_fround($2 * $3);
17829 label$2 : {
17830 if (Math_fround(Math_abs($3)) < Math_fround(2147483648.0)) {
17831 $6 = ~~$3;
17832 break label$2;
17833 }
17834 $6 = -2147483648;
17835 }
17836 $3 = Math_fround($11 * Math_fround(.5));
17837 $2 = Math_fround($2 * $4);
17838 label$5 : {
17839 if (Math_fround(Math_abs($2)) < Math_fround(2147483648.0)) {
17840 $10 = ~~$2;
17841 break label$5;
17842 }
17843 $10 = -2147483648;
17844 }
17845 $2 = Math_fround($3 * Math_fround($10 - $6 | 0));
17846 label$4 : {
17847 if (Math_fround(Math_abs($2)) < Math_fround(2147483648.0)) {
17848 $7 = ~~$2;
17849 break label$4;
17850 }
17851 $7 = -2147483648;
17852 }
17853 if (!(($6 | 0) < 1 | ($1 | 0) < 1)) {
17854 $5 = $6 + -1 | 0;
17855 $8 = $1 + -1 | 0;
17856 $8 = $5 >>> 0 < $8 >>> 0 ? $5 : $8;
17857 memset($0, ($8 << 2) + 4 | 0);
17858 $5 = $8 + 1 | 0;
17859 while (1) {
17860 $13 = ($9 | 0) == ($8 | 0);
17861 $9 = $9 + 1 | 0;
17862 if (!$13) {
17863 continue
17864 }
17865 break;
17866 };
17867 }
17868 $6 = $6 + $7 | 0;
17869 label$10 : {
17870 if (($5 | 0) >= ($6 | 0) | ($5 | 0) >= ($1 | 0)) {
17871 break label$10
17872 }
17873 $12 = +($7 | 0);
17874 $9 = 1;
17875 while (1) {
17876 (wasm2js_i32$0 = ($5 << 2) + $0 | 0, wasm2js_f32$0 = Math_fround(.5 - cos(+($9 | 0) * 3.141592653589793 / $12) * .5)), HEAPF32[wasm2js_i32$0 >> 2] = wasm2js_f32$0;
17877 $5 = $5 + 1 | 0;
17878 if (($5 | 0) >= ($6 | 0)) {
17879 break label$10
17880 }
17881 $9 = $9 + 1 | 0;
17882 if (($5 | 0) < ($1 | 0)) {
17883 continue
17884 }
17885 break;
17886 };
17887 }
17888 $6 = $10 - $7 | 0;
17889 label$12 : {
17890 if (($5 | 0) >= ($6 | 0) | ($5 | 0) >= ($1 | 0)) {
17891 break label$12
17892 }
17893 while (1) {
17894 HEAP32[($5 << 2) + $0 >> 2] = 1065353216;
17895 $5 = $5 + 1 | 0;
17896 if (($5 | 0) >= ($6 | 0)) {
17897 break label$12
17898 }
17899 if (($5 | 0) < ($1 | 0)) {
17900 continue
17901 }
17902 break;
17903 };
17904 }
17905 label$14 : {
17906 if (($5 | 0) >= ($10 | 0) | ($5 | 0) >= ($1 | 0)) {
17907 break label$14
17908 }
17909 $12 = +($7 | 0);
17910 while (1) {
17911 (wasm2js_i32$0 = ($5 << 2) + $0 | 0, wasm2js_f32$0 = Math_fround(.5 - cos(+($7 | 0) * 3.141592653589793 / $12) * .5)), HEAPF32[wasm2js_i32$0 >> 2] = wasm2js_f32$0;
17912 $5 = $5 + 1 | 0;
17913 if (($5 | 0) >= ($10 | 0)) {
17914 break label$14
17915 }
17916 $7 = $7 + -1 | 0;
17917 if (($5 | 0) < ($1 | 0)) {
17918 continue
17919 }
17920 break;
17921 };
17922 }
17923 if (($5 | 0) < ($1 | 0)) {
17924 memset(($5 << 2) + $0 | 0, $1 - $5 << 2)
17925 }
17926 }
17927
17928 function FLAC__window_punchout_tukey($0, $1, $2, $3, $4) {
17929 var $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0.0, $12 = Math_fround(0), $13 = 0, $14 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0);
17930 while (1) {
17931 $12 = $2;
17932 $2 = Math_fround(.05000000074505806);
17933 if ($12 <= Math_fround(0.0)) {
17934 continue
17935 }
17936 $2 = Math_fround(.949999988079071);
17937 if ($12 >= Math_fround(1.0)) {
17938 continue
17939 }
17940 break;
17941 };
17942 $2 = Math_fround($12 * Math_fround(.5));
17943 $14 = $2;
17944 $12 = Math_fround($1 | 0);
17945 $3 = Math_fround($12 * $3);
17946 label$3 : {
17947 if (Math_fround(Math_abs($3)) < Math_fround(2147483648.0)) {
17948 $10 = ~~$3;
17949 break label$3;
17950 }
17951 $10 = -2147483648;
17952 }
17953 $3 = Math_fround($14 * Math_fround($10 | 0));
17954 label$2 : {
17955 if (Math_fround(Math_abs($3)) < Math_fround(2147483648.0)) {
17956 $6 = ~~$3;
17957 break label$2;
17958 }
17959 $6 = -2147483648;
17960 }
17961 $8 = ($6 | 0) < 1;
17962 $7 = $1;
17963 $3 = Math_fround($12 * $4);
17964 label$7 : {
17965 if (Math_fround(Math_abs($3)) < Math_fround(2147483648.0)) {
17966 $9 = ~~$3;
17967 break label$7;
17968 }
17969 $9 = -2147483648;
17970 }
17971 $2 = Math_fround($2 * Math_fround($7 - $9 | 0));
17972 label$6 : {
17973 if (Math_fround(Math_abs($2)) < Math_fround(2147483648.0)) {
17974 $7 = ~~$2;
17975 break label$6;
17976 }
17977 $7 = -2147483648;
17978 }
17979 if (!(($1 | 0) < 1 | $8)) {
17980 $5 = $6 + -1 >>> 0 < $1 + -1 >>> 0 ? $6 : $1;
17981 $11 = +($6 | 0);
17982 $8 = 0;
17983 $13 = 1;
17984 while (1) {
17985 (wasm2js_i32$0 = ($8 << 2) + $0 | 0, wasm2js_f32$0 = Math_fround(.5 - cos(+($13 | 0) * 3.141592653589793 / $11) * .5)), HEAPF32[wasm2js_i32$0 >> 2] = wasm2js_f32$0;
17986 $13 = $13 + 1 | 0;
17987 $8 = $8 + 1 | 0;
17988 if (($8 | 0) != ($5 | 0)) {
17989 continue
17990 }
17991 break;
17992 };
17993 }
17994 $8 = $10 - $6 | 0;
17995 label$12 : {
17996 if (($5 | 0) >= ($8 | 0) | ($5 | 0) >= ($1 | 0)) {
17997 break label$12
17998 }
17999 while (1) {
18000 HEAP32[($5 << 2) + $0 >> 2] = 1065353216;
18001 $5 = $5 + 1 | 0;
18002 if (($5 | 0) >= ($8 | 0)) {
18003 break label$12
18004 }
18005 if (($5 | 0) < ($1 | 0)) {
18006 continue
18007 }
18008 break;
18009 };
18010 }
18011 label$14 : {
18012 if (($5 | 0) >= ($10 | 0) | ($5 | 0) >= ($1 | 0)) {
18013 break label$14
18014 }
18015 $11 = +($6 | 0);
18016 while (1) {
18017 (wasm2js_i32$0 = ($5 << 2) + $0 | 0, wasm2js_f32$0 = Math_fround(.5 - cos(+($6 | 0) * 3.141592653589793 / $11) * .5)), HEAPF32[wasm2js_i32$0 >> 2] = wasm2js_f32$0;
18018 $5 = $5 + 1 | 0;
18019 if (($5 | 0) >= ($10 | 0)) {
18020 break label$14
18021 }
18022 $6 = $6 + -1 | 0;
18023 if (($5 | 0) < ($1 | 0)) {
18024 continue
18025 }
18026 break;
18027 };
18028 }
18029 label$16 : {
18030 if (($5 | 0) >= ($9 | 0) | ($5 | 0) >= ($1 | 0)) {
18031 break label$16
18032 }
18033 $6 = $5 ^ -1;
18034 $10 = $6 + $9 | 0;
18035 $6 = $1 + $6 | 0;
18036 memset(($5 << 2) + $0 | 0, (($10 >>> 0 < $6 >>> 0 ? $10 : $6) << 2) + 4 | 0);
18037 while (1) {
18038 $5 = $5 + 1 | 0;
18039 if (($5 | 0) >= ($9 | 0)) {
18040 break label$16
18041 }
18042 if (($5 | 0) < ($1 | 0)) {
18043 continue
18044 }
18045 break;
18046 };
18047 }
18048 $9 = $7 + $9 | 0;
18049 label$18 : {
18050 if (($5 | 0) >= ($9 | 0) | ($5 | 0) >= ($1 | 0)) {
18051 break label$18
18052 }
18053 $11 = +($7 | 0);
18054 $6 = 1;
18055 while (1) {
18056 (wasm2js_i32$0 = ($5 << 2) + $0 | 0, wasm2js_f32$0 = Math_fround(.5 - cos(+($6 | 0) * 3.141592653589793 / $11) * .5)), HEAPF32[wasm2js_i32$0 >> 2] = wasm2js_f32$0;
18057 $5 = $5 + 1 | 0;
18058 if (($5 | 0) >= ($9 | 0)) {
18059 break label$18
18060 }
18061 $6 = $6 + 1 | 0;
18062 if (($5 | 0) < ($1 | 0)) {
18063 continue
18064 }
18065 break;
18066 };
18067 }
18068 $6 = $1 - $7 | 0;
18069 label$20 : {
18070 if (($5 | 0) >= ($6 | 0) | ($5 | 0) >= ($1 | 0)) {
18071 break label$20
18072 }
18073 while (1) {
18074 HEAP32[($5 << 2) + $0 >> 2] = 1065353216;
18075 $5 = $5 + 1 | 0;
18076 if (($5 | 0) >= ($6 | 0)) {
18077 break label$20
18078 }
18079 if (($5 | 0) < ($1 | 0)) {
18080 continue
18081 }
18082 break;
18083 };
18084 }
18085 if (($5 | 0) < ($1 | 0)) {
18086 $11 = +($7 | 0);
18087 while (1) {
18088 (wasm2js_i32$0 = ($5 << 2) + $0 | 0, wasm2js_f32$0 = Math_fround(.5 - cos(+($7 | 0) * 3.141592653589793 / $11) * .5)), HEAPF32[wasm2js_i32$0 >> 2] = wasm2js_f32$0;
18089 $7 = $7 + -1 | 0;
18090 $5 = $5 + 1 | 0;
18091 if (($5 | 0) != ($1 | 0)) {
18092 continue
18093 }
18094 break;
18095 };
18096 }
18097 }
18098
18099 function FLAC__window_welch($0, $1) {
18100 var $2 = 0, $3 = 0.0, $4 = 0.0;
18101 if (($1 | 0) >= 1) {
18102 $3 = +($1 + -1 | 0) * .5;
18103 while (1) {
18104 $4 = (+($2 | 0) - $3) / $3;
18105 HEAPF32[($2 << 2) + $0 >> 2] = 1.0 - $4 * $4;
18106 $2 = $2 + 1 | 0;
18107 if (($2 | 0) != ($1 | 0)) {
18108 continue
18109 }
18110 break;
18111 };
18112 }
18113 }
18114
18115 function FLAC__add_metadata_block($0, $1) {
18116 var $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0;
18117 $3 = strlen(HEAP32[2720]);
18118 label$1 : {
18119 if (!FLAC__bitwriter_write_raw_uint32($1, HEAP32[$0 + 4 >> 2], HEAP32[1391])) {
18120 break label$1
18121 }
18122 if (!FLAC__bitwriter_write_raw_uint32($1, HEAP32[$0 >> 2], HEAP32[1392])) {
18123 break label$1
18124 }
18125 $2 = HEAP32[$0 + 8 >> 2];
18126 $2 = HEAP32[$0 >> 2] == 4 ? ($2 + $3 | 0) - HEAP32[$0 + 16 >> 2] | 0 : $2;
18127 $4 = HEAP32[1393];
18128 if ($2 >>> $4) {
18129 break label$1
18130 }
18131 if (!FLAC__bitwriter_write_raw_uint32($1, $2, $4)) {
18132 break label$1
18133 }
18134 label$3 : {
18135 label$4 : {
18136 label$5 : {
18137 label$6 : {
18138 label$7 : {
18139 label$8 : {
18140 label$9 : {
18141 switch (HEAP32[$0 >> 2]) {
18142 case 3:
18143 if (!HEAP32[$0 + 16 >> 2]) {
18144 break label$3
18145 }
18146 $4 = HEAP32[1367];
18147 $6 = HEAP32[1366];
18148 $7 = HEAP32[1365];
18149 $2 = 0;
18150 break label$8;
18151 case 0:
18152 if (!FLAC__bitwriter_write_raw_uint32($1, HEAP32[$0 + 16 >> 2], HEAP32[1356])) {
18153 break label$1
18154 }
18155 if (!FLAC__bitwriter_write_raw_uint32($1, HEAP32[$0 + 20 >> 2], HEAP32[1357])) {
18156 break label$1
18157 }
18158 if (!FLAC__bitwriter_write_raw_uint32($1, HEAP32[$0 + 24 >> 2], HEAP32[1358])) {
18159 break label$1
18160 }
18161 if (!FLAC__bitwriter_write_raw_uint32($1, HEAP32[$0 + 28 >> 2], HEAP32[1359])) {
18162 break label$1
18163 }
18164 if (!FLAC__bitwriter_write_raw_uint32($1, HEAP32[$0 + 32 >> 2], HEAP32[1360])) {
18165 break label$1
18166 }
18167 if (!FLAC__bitwriter_write_raw_uint32($1, HEAP32[$0 + 36 >> 2] + -1 | 0, HEAP32[1361])) {
18168 break label$1
18169 }
18170 if (!FLAC__bitwriter_write_raw_uint32($1, HEAP32[$0 + 40 >> 2] + -1 | 0, HEAP32[1362])) {
18171 break label$1
18172 }
18173 if (!FLAC__bitwriter_write_raw_uint64($1, HEAP32[$0 + 48 >> 2], HEAP32[$0 + 52 >> 2], HEAP32[1363])) {
18174 break label$1
18175 }
18176 if (FLAC__bitwriter_write_byte_block($1, $0 + 56 | 0, 16)) {
18177 break label$3
18178 }
18179 break label$1;
18180 case 1:
18181 if (FLAC__bitwriter_write_zeroes($1, HEAP32[$0 + 8 >> 2] << 3)) {
18182 break label$3
18183 }
18184 break label$1;
18185 case 6:
18186 break label$5;
18187 case 5:
18188 break label$6;
18189 case 4:
18190 break label$7;
18191 case 2:
18192 break label$9;
18193 default:
18194 break label$4;
18195 };
18196 }
18197 $2 = HEAP32[1364] >>> 3 | 0;
18198 if (!FLAC__bitwriter_write_byte_block($1, $0 + 16 | 0, $2)) {
18199 break label$1
18200 }
18201 if (FLAC__bitwriter_write_byte_block($1, HEAP32[$0 + 20 >> 2], HEAP32[$0 + 8 >> 2] - $2 | 0)) {
18202 break label$3
18203 }
18204 break label$1;
18205 }
18206 while (1) {
18207 $3 = Math_imul($2, 24);
18208 $5 = $3 + HEAP32[$0 + 20 >> 2] | 0;
18209 if (!FLAC__bitwriter_write_raw_uint64($1, HEAP32[$5 >> 2], HEAP32[$5 + 4 >> 2], $7)) {
18210 break label$1
18211 }
18212 $5 = $3 + HEAP32[$0 + 20 >> 2] | 0;
18213 if (!FLAC__bitwriter_write_raw_uint64($1, HEAP32[$5 + 8 >> 2], HEAP32[$5 + 12 >> 2], $6)) {
18214 break label$1
18215 }
18216 if (!FLAC__bitwriter_write_raw_uint32($1, HEAP32[($3 + HEAP32[$0 + 20 >> 2] | 0) + 16 >> 2], $4)) {
18217 break label$1
18218 }
18219 $2 = $2 + 1 | 0;
18220 if ($2 >>> 0 < HEAPU32[$0 + 16 >> 2]) {
18221 continue
18222 }
18223 break;
18224 };
18225 break label$3;
18226 }
18227 if (!FLAC__bitwriter_write_raw_uint32_little_endian($1, $3)) {
18228 break label$1
18229 }
18230 if (!FLAC__bitwriter_write_byte_block($1, HEAP32[2720], $3)) {
18231 break label$1
18232 }
18233 if (!FLAC__bitwriter_write_raw_uint32_little_endian($1, HEAP32[$0 + 24 >> 2])) {
18234 break label$1
18235 }
18236 if (!HEAP32[$0 + 24 >> 2]) {
18237 break label$3
18238 }
18239 $2 = 0;
18240 while (1) {
18241 $3 = $2 << 3;
18242 if (!FLAC__bitwriter_write_raw_uint32_little_endian($1, HEAP32[$3 + HEAP32[$0 + 28 >> 2] >> 2])) {
18243 break label$1
18244 }
18245 $3 = $3 + HEAP32[$0 + 28 >> 2] | 0;
18246 if (!FLAC__bitwriter_write_byte_block($1, HEAP32[$3 + 4 >> 2], HEAP32[$3 >> 2])) {
18247 break label$1
18248 }
18249 $2 = $2 + 1 | 0;
18250 if ($2 >>> 0 < HEAPU32[$0 + 24 >> 2]) {
18251 continue
18252 }
18253 break;
18254 };
18255 break label$3;
18256 }
18257 if (!FLAC__bitwriter_write_byte_block($1, $0 + 16 | 0, HEAP32[1378] >>> 3 | 0)) {
18258 break label$1
18259 }
18260 if (!FLAC__bitwriter_write_raw_uint64($1, HEAP32[$0 + 152 >> 2], HEAP32[$0 + 156 >> 2], HEAP32[1379])) {
18261 break label$1
18262 }
18263 if (!FLAC__bitwriter_write_raw_uint32($1, HEAP32[$0 + 160 >> 2] != 0, HEAP32[1380])) {
18264 break label$1
18265 }
18266 if (!FLAC__bitwriter_write_zeroes($1, HEAP32[1381])) {
18267 break label$1
18268 }
18269 if (!FLAC__bitwriter_write_raw_uint32($1, HEAP32[$0 + 164 >> 2], HEAP32[1382])) {
18270 break label$1
18271 }
18272 if (!HEAP32[$0 + 164 >> 2]) {
18273 break label$3
18274 }
18275 $6 = HEAP32[1373] >>> 3 | 0;
18276 $7 = HEAP32[1370];
18277 $5 = HEAP32[1369];
18278 $9 = HEAP32[1368];
18279 $10 = HEAP32[1377];
18280 $11 = HEAP32[1376];
18281 $12 = HEAP32[1375];
18282 $13 = HEAP32[1374];
18283 $14 = HEAP32[1372];
18284 $15 = HEAP32[1371];
18285 $3 = 0;
18286 while (1) {
18287 $2 = HEAP32[$0 + 168 >> 2] + ($3 << 5) | 0;
18288 if (!FLAC__bitwriter_write_raw_uint64($1, HEAP32[$2 >> 2], HEAP32[$2 + 4 >> 2], $15)) {
18289 break label$1
18290 }
18291 if (!FLAC__bitwriter_write_raw_uint32($1, HEAPU8[$2 + 8 | 0], $14)) {
18292 break label$1
18293 }
18294 if (!FLAC__bitwriter_write_byte_block($1, $2 + 9 | 0, $6)) {
18295 break label$1
18296 }
18297 if (!FLAC__bitwriter_write_raw_uint32($1, HEAP8[$2 + 22 | 0] & 1, $13)) {
18298 break label$1
18299 }
18300 if (!FLAC__bitwriter_write_raw_uint32($1, HEAPU8[$2 + 22 | 0] >>> 1 & 1, $12)) {
18301 break label$1
18302 }
18303 if (!FLAC__bitwriter_write_zeroes($1, $11)) {
18304 break label$1
18305 }
18306 if (!FLAC__bitwriter_write_raw_uint32($1, HEAPU8[$2 + 23 | 0], $10)) {
18307 break label$1
18308 }
18309 label$16 : {
18310 $8 = $2 + 23 | 0;
18311 if (!HEAPU8[$8 | 0]) {
18312 break label$16
18313 }
18314 $16 = $2 + 24 | 0;
18315 $2 = 0;
18316 while (1) {
18317 $4 = HEAP32[$16 >> 2] + ($2 << 4) | 0;
18318 if (!FLAC__bitwriter_write_raw_uint64($1, HEAP32[$4 >> 2], HEAP32[$4 + 4 >> 2], $9)) {
18319 return 0
18320 }
18321 if (!FLAC__bitwriter_write_raw_uint32($1, HEAPU8[$4 + 8 | 0], $5)) {
18322 return 0
18323 }
18324 if (FLAC__bitwriter_write_zeroes($1, $7)) {
18325 $2 = $2 + 1 | 0;
18326 if ($2 >>> 0 >= HEAPU8[$8 | 0]) {
18327 break label$16
18328 }
18329 continue;
18330 }
18331 break;
18332 };
18333 return 0;
18334 }
18335 $3 = $3 + 1 | 0;
18336 if ($3 >>> 0 < HEAPU32[$0 + 164 >> 2]) {
18337 continue
18338 }
18339 break;
18340 };
18341 break label$3;
18342 }
18343 if (!FLAC__bitwriter_write_raw_uint32($1, HEAP32[$0 + 16 >> 2], HEAP32[1383])) {
18344 break label$1
18345 }
18346 $2 = strlen(HEAP32[$0 + 20 >> 2]);
18347 if (!FLAC__bitwriter_write_raw_uint32($1, $2, HEAP32[1384])) {
18348 break label$1
18349 }
18350 if (!FLAC__bitwriter_write_byte_block($1, HEAP32[$0 + 20 >> 2], $2)) {
18351 break label$1
18352 }
18353 $2 = strlen(HEAP32[$0 + 24 >> 2]);
18354 if (!FLAC__bitwriter_write_raw_uint32($1, $2, HEAP32[1385])) {
18355 break label$1
18356 }
18357 if (!FLAC__bitwriter_write_byte_block($1, HEAP32[$0 + 24 >> 2], $2)) {
18358 break label$1
18359 }
18360 if (!FLAC__bitwriter_write_raw_uint32($1, HEAP32[$0 + 28 >> 2], HEAP32[1386])) {
18361 break label$1
18362 }
18363 if (!FLAC__bitwriter_write_raw_uint32($1, HEAP32[$0 + 32 >> 2], HEAP32[1387])) {
18364 break label$1
18365 }
18366 if (!FLAC__bitwriter_write_raw_uint32($1, HEAP32[$0 + 36 >> 2], HEAP32[1388])) {
18367 break label$1
18368 }
18369 if (!FLAC__bitwriter_write_raw_uint32($1, HEAP32[$0 + 40 >> 2], HEAP32[1389])) {
18370 break label$1
18371 }
18372 if (!FLAC__bitwriter_write_raw_uint32($1, HEAP32[$0 + 44 >> 2], HEAP32[1390])) {
18373 break label$1
18374 }
18375 if (FLAC__bitwriter_write_byte_block($1, HEAP32[$0 + 48 >> 2], HEAP32[$0 + 44 >> 2])) {
18376 break label$3
18377 }
18378 break label$1;
18379 }
18380 if (!FLAC__bitwriter_write_byte_block($1, HEAP32[$0 + 16 >> 2], HEAP32[$0 + 8 >> 2])) {
18381 break label$1
18382 }
18383 }
18384 $17 = 1;
18385 }
18386 return $17;
18387 }
18388
18389 function FLAC__frame_add_header($0, $1) {
18390 var $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0;
18391 $5 = global$0 - 16 | 0;
18392 global$0 = $5;
18393 label$1 : {
18394 if (!FLAC__bitwriter_write_raw_uint32($1, HEAP32[1394], HEAP32[1395])) {
18395 break label$1
18396 }
18397 if (!FLAC__bitwriter_write_raw_uint32($1, 0, HEAP32[1396])) {
18398 break label$1
18399 }
18400 if (!FLAC__bitwriter_write_raw_uint32($1, HEAP32[$0 + 20 >> 2] != 0, HEAP32[1397])) {
18401 break label$1
18402 }
18403 $8 = 16;
18404 $9 = 1;
18405 $3 = $1;
18406 label$3 : {
18407 label$4 : {
18408 label$5 : {
18409 label$6 : {
18410 label$7 : {
18411 label$8 : {
18412 label$9 : {
18413 label$10 : {
18414 label$11 : {
18415 $2 = HEAP32[$0 >> 2];
18416 if (($2 | 0) <= 2047) {
18417 if (($2 | 0) <= 575) {
18418 $4 = 1;
18419 if (($2 | 0) == 192) {
18420 break label$3
18421 }
18422 if (($2 | 0) == 256) {
18423 break label$8
18424 }
18425 if (($2 | 0) != 512) {
18426 break label$4
18427 }
18428 $4 = 9;
18429 break label$3;
18430 }
18431 if (($2 | 0) == 576) {
18432 break label$11
18433 }
18434 if (($2 | 0) == 1024) {
18435 break label$7
18436 }
18437 if (($2 | 0) != 1152) {
18438 break label$4
18439 }
18440 $4 = 3;
18441 break label$3;
18442 }
18443 if (($2 | 0) <= 4607) {
18444 if (($2 | 0) == 2048) {
18445 break label$6
18446 }
18447 if (($2 | 0) == 2304) {
18448 break label$10
18449 }
18450 if (($2 | 0) != 4096) {
18451 break label$4
18452 }
18453 $4 = 12;
18454 break label$3;
18455 }
18456 if (($2 | 0) <= 16383) {
18457 if (($2 | 0) == 4608) {
18458 break label$9
18459 }
18460 if (($2 | 0) != 8192) {
18461 break label$4
18462 }
18463 $4 = 13;
18464 break label$3;
18465 }
18466 if (($2 | 0) == 16384) {
18467 break label$5
18468 }
18469 if (($2 | 0) != 32768) {
18470 break label$4
18471 }
18472 $4 = 15;
18473 break label$3;
18474 }
18475 $4 = 2;
18476 break label$3;
18477 }
18478 $4 = 4;
18479 break label$3;
18480 }
18481 $4 = 5;
18482 break label$3;
18483 }
18484 $4 = 8;
18485 break label$3;
18486 }
18487 $4 = 10;
18488 break label$3;
18489 }
18490 $4 = 11;
18491 break label$3;
18492 }
18493 $4 = 14;
18494 break label$3;
18495 }
18496 $2 = $2 >>> 0 < 257;
18497 $8 = $2 ? 8 : 16;
18498 $9 = 0;
18499 $4 = $2 ? 6 : 7;
18500 }
18501 if (!FLAC__bitwriter_write_raw_uint32($3, $4, HEAP32[1398])) {
18502 break label$1
18503 }
18504 label$16 : {
18505 label$17 : {
18506 label$18 : {
18507 label$19 : {
18508 label$20 : {
18509 label$21 : {
18510 label$22 : {
18511 label$23 : {
18512 $2 = HEAP32[$0 + 4 >> 2];
18513 if (($2 | 0) <= 44099) {
18514 if (($2 | 0) <= 22049) {
18515 if (($2 | 0) == 8e3) {
18516 break label$23
18517 }
18518 if (($2 | 0) != 16e3) {
18519 break label$17
18520 }
18521 $3 = 5;
18522 break label$16;
18523 }
18524 if (($2 | 0) == 22050) {
18525 break label$22
18526 }
18527 if (($2 | 0) == 24e3) {
18528 break label$21
18529 }
18530 if (($2 | 0) != 32e3) {
18531 break label$17
18532 }
18533 $3 = 8;
18534 break label$16;
18535 }
18536 if (($2 | 0) <= 95999) {
18537 if (($2 | 0) == 44100) {
18538 break label$20
18539 }
18540 if (($2 | 0) == 48e3) {
18541 break label$19
18542 }
18543 $3 = 1;
18544 if (($2 | 0) == 88200) {
18545 break label$16
18546 }
18547 break label$17;
18548 }
18549 if (($2 | 0) == 96e3) {
18550 break label$18
18551 }
18552 if (($2 | 0) != 192e3) {
18553 if (($2 | 0) != 176400) {
18554 break label$17
18555 }
18556 $3 = 2;
18557 break label$16;
18558 }
18559 $3 = 3;
18560 break label$16;
18561 }
18562 $3 = 4;
18563 break label$16;
18564 }
18565 $3 = 6;
18566 break label$16;
18567 }
18568 $3 = 7;
18569 break label$16;
18570 }
18571 $3 = 9;
18572 break label$16;
18573 }
18574 $3 = 10;
18575 break label$16;
18576 }
18577 $3 = 11;
18578 break label$16;
18579 }
18580 $6 = ($2 >>> 0) % 1e3 | 0;
18581 if ($2 >>> 0 <= 255e3) {
18582 $3 = 12;
18583 $7 = 12;
18584 if (!$6) {
18585 break label$16
18586 }
18587 }
18588 if (!(($2 >>> 0) % 10)) {
18589 $3 = 14;
18590 $7 = 14;
18591 break label$16;
18592 }
18593 $3 = $2 >>> 0 < 65536 ? 13 : 0;
18594 $7 = $3;
18595 }
18596 $6 = 0;
18597 if (!FLAC__bitwriter_write_raw_uint32($1, $3, HEAP32[1399])) {
18598 break label$1
18599 }
18600 label$30 : {
18601 label$31 : {
18602 switch (HEAP32[$0 + 12 >> 2]) {
18603 case 0:
18604 $3 = HEAP32[$0 + 8 >> 2] + -1 | 0;
18605 break label$30;
18606 case 1:
18607 $3 = 8;
18608 break label$30;
18609 case 2:
18610 $3 = 9;
18611 break label$30;
18612 case 3:
18613 break label$31;
18614 default:
18615 break label$30;
18616 };
18617 }
18618 $3 = 10;
18619 }
18620 if (!FLAC__bitwriter_write_raw_uint32($1, $3, HEAP32[1400])) {
18621 break label$1
18622 }
18623 $3 = $1;
18624 $2 = __wasm_rotl_i32(HEAP32[$0 + 16 >> 2] + -8 | 0, 30);
18625 if ($2 >>> 0 <= 4) {
18626 $2 = HEAP32[($2 << 2) + 10464 >> 2]
18627 } else {
18628 $2 = 0
18629 }
18630 if (!FLAC__bitwriter_write_raw_uint32($3, $2, HEAP32[1401])) {
18631 break label$1
18632 }
18633 if (!FLAC__bitwriter_write_raw_uint32($1, 0, HEAP32[1402])) {
18634 break label$1
18635 }
18636 label$37 : {
18637 if (!HEAP32[$0 + 20 >> 2]) {
18638 if (FLAC__bitwriter_write_utf8_uint32($1, HEAP32[$0 + 24 >> 2])) {
18639 break label$37
18640 }
18641 break label$1;
18642 }
18643 if (!FLAC__bitwriter_write_utf8_uint64($1, HEAP32[$0 + 24 >> 2], HEAP32[$0 + 28 >> 2])) {
18644 break label$1
18645 }
18646 }
18647 if (!$9) {
18648 if (!FLAC__bitwriter_write_raw_uint32($1, HEAP32[$0 >> 2] + -1 | 0, $8)) {
18649 break label$1
18650 }
18651 }
18652 label$40 : {
18653 label$41 : {
18654 switch ($7 + -12 | 0) {
18655 case 0:
18656 if (FLAC__bitwriter_write_raw_uint32($1, HEAPU32[$0 + 4 >> 2] / 1e3 | 0, 8)) {
18657 break label$40
18658 }
18659 break label$1;
18660 case 1:
18661 if (FLAC__bitwriter_write_raw_uint32($1, HEAP32[$0 + 4 >> 2], 16)) {
18662 break label$40
18663 }
18664 break label$1;
18665 case 2:
18666 break label$41;
18667 default:
18668 break label$40;
18669 };
18670 }
18671 if (!FLAC__bitwriter_write_raw_uint32($1, HEAPU32[$0 + 4 >> 2] / 10 | 0, 16)) {
18672 break label$1
18673 }
18674 }
18675 if (!FLAC__bitwriter_get_write_crc8($1, $5 + 15 | 0)) {
18676 break label$1
18677 }
18678 $6 = (FLAC__bitwriter_write_raw_uint32($1, HEAPU8[$5 + 15 | 0], HEAP32[1403]) | 0) != 0;
18679 }
18680 global$0 = $5 + 16 | 0;
18681 return $6;
18682 }
18683
18684 function FLAC__subframe_add_constant($0, $1, $2, $3) {
18685 var $4 = 0;
18686 label$1 : {
18687 if (!FLAC__bitwriter_write_raw_uint32($3, HEAP32[1417] | ($2 | 0) != 0, HEAP32[1416] + (HEAP32[1415] + HEAP32[1414] | 0) | 0)) {
18688 break label$1
18689 }
18690 if ($2) {
18691 if (!FLAC__bitwriter_write_unary_unsigned($3, $2 + -1 | 0)) {
18692 break label$1
18693 }
18694 }
18695 $4 = (FLAC__bitwriter_write_raw_int32($3, HEAP32[$0 >> 2], $1) | 0) != 0;
18696 }
18697 return $4;
18698 }
18699
18700 function FLAC__subframe_add_fixed($0, $1, $2, $3, $4) {
18701 var $5 = 0;
18702 label$1 : {
18703 if (!FLAC__bitwriter_write_raw_uint32($4, HEAP32[1419] | ($3 | 0) != 0 | HEAP32[$0 + 12 >> 2] << 1, HEAP32[1416] + (HEAP32[1415] + HEAP32[1414] | 0) | 0)) {
18704 break label$1
18705 }
18706 if ($3) {
18707 if (!FLAC__bitwriter_write_unary_unsigned($4, $3 + -1 | 0)) {
18708 break label$1
18709 }
18710 }
18711 label$3 : {
18712 if (!HEAP32[$0 + 12 >> 2]) {
18713 break label$3
18714 }
18715 $3 = 0;
18716 while (1) {
18717 if (FLAC__bitwriter_write_raw_int32($4, HEAP32[(($3 << 2) + $0 | 0) + 16 >> 2], $2)) {
18718 $3 = $3 + 1 | 0;
18719 if ($3 >>> 0 < HEAPU32[$0 + 12 >> 2]) {
18720 continue
18721 }
18722 break label$3;
18723 }
18724 break;
18725 };
18726 return 0;
18727 }
18728 if (!FLAC__bitwriter_write_raw_uint32($4, HEAP32[$0 >> 2], HEAP32[1405])) {
18729 break label$1
18730 }
18731 label$6 : {
18732 if (HEAPU32[$0 >> 2] > 1) {
18733 break label$6
18734 }
18735 if (!FLAC__bitwriter_write_raw_uint32($4, HEAP32[$0 + 4 >> 2], HEAP32[1406])) {
18736 break label$1
18737 }
18738 $2 = HEAP32[$0 >> 2];
18739 if ($2 >>> 0 > 1) {
18740 break label$6
18741 }
18742 $3 = $1;
18743 $1 = HEAP32[$0 + 8 >> 2];
18744 if (!add_residual_partitioned_rice_($4, HEAP32[$0 + 32 >> 2], $3, HEAP32[$0 + 12 >> 2], HEAP32[$1 >> 2], HEAP32[$1 + 4 >> 2], HEAP32[$0 + 4 >> 2], ($2 | 0) == 1)) {
18745 break label$1
18746 }
18747 }
18748 $5 = 1;
18749 }
18750 return $5;
18751 }
18752
18753 function add_residual_partitioned_rice_($0, $1, $2, $3, $4, $5, $6, $7) {
18754 var $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0;
18755 $12 = HEAP32[($7 ? 5644 : 5640) >> 2];
18756 $9 = HEAP32[($7 ? 5632 : 5628) >> 2];
18757 label$1 : {
18758 label$2 : {
18759 if (!$6) {
18760 if (!HEAP32[$5 >> 2]) {
18761 if (!FLAC__bitwriter_write_raw_uint32($0, HEAP32[$4 >> 2], $9)) {
18762 break label$2
18763 }
18764 if (!FLAC__bitwriter_write_rice_signed_block($0, $1, $2, HEAP32[$4 >> 2])) {
18765 break label$2
18766 }
18767 break label$1;
18768 }
18769 if (!FLAC__bitwriter_write_raw_uint32($0, $12, $9)) {
18770 break label$2
18771 }
18772 if (!FLAC__bitwriter_write_raw_uint32($0, HEAP32[$5 >> 2], HEAP32[1409])) {
18773 break label$2
18774 }
18775 if (!$2) {
18776 break label$1
18777 }
18778 $7 = 0;
18779 while (1) {
18780 if (FLAC__bitwriter_write_raw_int32($0, HEAP32[($7 << 2) + $1 >> 2], HEAP32[$5 >> 2])) {
18781 $7 = $7 + 1 | 0;
18782 if (($7 | 0) != ($2 | 0)) {
18783 continue
18784 }
18785 break label$1;
18786 }
18787 break;
18788 };
18789 return 0;
18790 }
18791 $15 = $2 + $3 >>> $6 | 0;
18792 $16 = HEAP32[1409];
18793 $2 = 0;
18794 while (1) {
18795 $7 = $2;
18796 $13 = $15 - ($10 ? 0 : $3) | 0;
18797 $2 = $7 + $13 | 0;
18798 $14 = $10 << 2;
18799 $8 = $14 + $5 | 0;
18800 label$8 : {
18801 if (!HEAP32[$8 >> 2]) {
18802 $11 = 0;
18803 $8 = $4 + $14 | 0;
18804 if (!FLAC__bitwriter_write_raw_uint32($0, HEAP32[$8 >> 2], $9)) {
18805 break label$2
18806 }
18807 if (FLAC__bitwriter_write_rice_signed_block($0, ($7 << 2) + $1 | 0, $13, HEAP32[$8 >> 2])) {
18808 break label$8
18809 }
18810 break label$2;
18811 }
18812 $11 = 0;
18813 if (!FLAC__bitwriter_write_raw_uint32($0, $12, $9)) {
18814 break label$2
18815 }
18816 if (!FLAC__bitwriter_write_raw_uint32($0, HEAP32[$8 >> 2], $16)) {
18817 break label$2
18818 }
18819 if ($7 >>> 0 >= $2 >>> 0) {
18820 break label$8
18821 }
18822 while (1) {
18823 if (!FLAC__bitwriter_write_raw_int32($0, HEAP32[($7 << 2) + $1 >> 2], HEAP32[$8 >> 2])) {
18824 break label$2
18825 }
18826 $7 = $7 + 1 | 0;
18827 if (($7 | 0) != ($2 | 0)) {
18828 continue
18829 }
18830 break;
18831 };
18832 }
18833 $11 = 1;
18834 $10 = $10 + 1 | 0;
18835 if (!($10 >>> $6)) {
18836 continue
18837 }
18838 break;
18839 };
18840 }
18841 return $11;
18842 }
18843 return 1;
18844 }
18845
18846 function FLAC__subframe_add_lpc($0, $1, $2, $3, $4) {
18847 var $5 = 0;
18848 label$1 : {
18849 if (!FLAC__bitwriter_write_raw_uint32($4, (HEAP32[$0 + 12 >> 2] << 1) + -2 | (HEAP32[1420] | ($3 | 0) != 0), HEAP32[1416] + (HEAP32[1415] + HEAP32[1414] | 0) | 0)) {
18850 break label$1
18851 }
18852 if ($3) {
18853 if (!FLAC__bitwriter_write_unary_unsigned($4, $3 + -1 | 0)) {
18854 break label$1
18855 }
18856 }
18857 label$3 : {
18858 if (!HEAP32[$0 + 12 >> 2]) {
18859 break label$3
18860 }
18861 $3 = 0;
18862 while (1) {
18863 if (FLAC__bitwriter_write_raw_int32($4, HEAP32[(($3 << 2) + $0 | 0) + 152 >> 2], $2)) {
18864 $3 = $3 + 1 | 0;
18865 if ($3 >>> 0 < HEAPU32[$0 + 12 >> 2]) {
18866 continue
18867 }
18868 break label$3;
18869 }
18870 break;
18871 };
18872 return 0;
18873 }
18874 if (!FLAC__bitwriter_write_raw_uint32($4, HEAP32[$0 + 16 >> 2] + -1 | 0, HEAP32[1412])) {
18875 break label$1
18876 }
18877 if (!FLAC__bitwriter_write_raw_int32($4, HEAP32[$0 + 20 >> 2], HEAP32[1413])) {
18878 break label$1
18879 }
18880 label$6 : {
18881 if (!HEAP32[$0 + 12 >> 2]) {
18882 break label$6
18883 }
18884 $3 = 0;
18885 while (1) {
18886 if (FLAC__bitwriter_write_raw_int32($4, HEAP32[(($3 << 2) + $0 | 0) + 24 >> 2], HEAP32[$0 + 16 >> 2])) {
18887 $3 = $3 + 1 | 0;
18888 if ($3 >>> 0 < HEAPU32[$0 + 12 >> 2]) {
18889 continue
18890 }
18891 break label$6;
18892 }
18893 break;
18894 };
18895 return 0;
18896 }
18897 if (!FLAC__bitwriter_write_raw_uint32($4, HEAP32[$0 >> 2], HEAP32[1405])) {
18898 break label$1
18899 }
18900 label$9 : {
18901 if (HEAPU32[$0 >> 2] > 1) {
18902 break label$9
18903 }
18904 if (!FLAC__bitwriter_write_raw_uint32($4, HEAP32[$0 + 4 >> 2], HEAP32[1406])) {
18905 break label$1
18906 }
18907 $2 = HEAP32[$0 >> 2];
18908 if ($2 >>> 0 > 1) {
18909 break label$9
18910 }
18911 $3 = $1;
18912 $1 = HEAP32[$0 + 8 >> 2];
18913 if (!add_residual_partitioned_rice_($4, HEAP32[$0 + 280 >> 2], $3, HEAP32[$0 + 12 >> 2], HEAP32[$1 >> 2], HEAP32[$1 + 4 >> 2], HEAP32[$0 + 4 >> 2], ($2 | 0) == 1)) {
18914 break label$1
18915 }
18916 }
18917 $5 = 1;
18918 }
18919 return $5;
18920 }
18921
18922 function FLAC__subframe_add_verbatim($0, $1, $2, $3, $4) {
18923 $0 = HEAP32[$0 >> 2];
18924 label$1 : {
18925 if (!FLAC__bitwriter_write_raw_uint32($4, HEAP32[1418] | ($3 | 0) != 0, HEAP32[1416] + (HEAP32[1415] + HEAP32[1414] | 0) | 0)) {
18926 break label$1
18927 }
18928 if ($3) {
18929 if (!FLAC__bitwriter_write_unary_unsigned($4, $3 + -1 | 0)) {
18930 break label$1
18931 }
18932 }
18933 if (!$1) {
18934 return 1
18935 }
18936 $3 = 0;
18937 label$4 : {
18938 while (1) {
18939 if (!FLAC__bitwriter_write_raw_int32($4, HEAP32[$0 + ($3 << 2) >> 2], $2)) {
18940 break label$4
18941 }
18942 $3 = $3 + 1 | 0;
18943 if (($3 | 0) != ($1 | 0)) {
18944 continue
18945 }
18946 break;
18947 };
18948 return 1;
18949 }
18950 }
18951 return 0;
18952 }
18953
18954 function strncmp($0, $1, $2) {
18955 var $3 = 0, $4 = 0, $5 = 0;
18956 if (!$2) {
18957 return 0
18958 }
18959 $3 = HEAPU8[$0 | 0];
18960 label$2 : {
18961 if (!$3) {
18962 break label$2
18963 }
18964 while (1) {
18965 label$4 : {
18966 $4 = HEAPU8[$1 | 0];
18967 if (($4 | 0) != ($3 | 0)) {
18968 break label$4
18969 }
18970 $2 = $2 + -1 | 0;
18971 if (!$2 | !$4) {
18972 break label$4
18973 }
18974 $1 = $1 + 1 | 0;
18975 $3 = HEAPU8[$0 + 1 | 0];
18976 $0 = $0 + 1 | 0;
18977 if ($3) {
18978 continue
18979 }
18980 break label$2;
18981 }
18982 break;
18983 };
18984 $5 = $3;
18985 }
18986 return ($5 & 255) - HEAPU8[$1 | 0] | 0;
18987 }
18988
18989 function __uflow($0) {
18990 var $1 = 0, $2 = 0;
18991 $1 = global$0 - 16 | 0;
18992 global$0 = $1;
18993 $2 = -1;
18994 label$1 : {
18995 if (__toread($0)) {
18996 break label$1
18997 }
18998 if ((FUNCTION_TABLE[HEAP32[$0 + 32 >> 2]]($0, $1 + 15 | 0, 1) | 0) != 1) {
18999 break label$1
19000 }
19001 $2 = HEAPU8[$1 + 15 | 0];
19002 }
19003 global$0 = $1 + 16 | 0;
19004 return $2;
19005 }
19006
19007 function __shlim($0) {
19008 var $1 = 0, $2 = 0, $3 = 0, $4 = 0;
19009 HEAP32[$0 + 112 >> 2] = 0;
19010 HEAP32[$0 + 116 >> 2] = 0;
19011 $3 = HEAP32[$0 + 8 >> 2];
19012 $4 = HEAP32[$0 + 4 >> 2];
19013 $1 = $3 - $4 | 0;
19014 $2 = $1 >> 31;
19015 HEAP32[$0 + 120 >> 2] = $1;
19016 HEAP32[$0 + 124 >> 2] = $2;
19017 if (!((($2 | 0) < 0 ? 1 : ($2 | 0) <= 0 ? ($1 >>> 0 > 0 ? 0 : 1) : 0) | 1)) {
19018 HEAP32[$0 + 104 >> 2] = $4;
19019 return;
19020 }
19021 HEAP32[$0 + 104 >> 2] = $3;
19022 }
19023
19024 function __shgetc($0) {
19025 var $1 = 0, $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0;
19026 $2 = HEAP32[$0 + 116 >> 2];
19027 $3 = $2;
19028 label$1 : {
19029 $5 = HEAP32[$0 + 112 >> 2];
19030 label$2 : {
19031 if ($2 | $5) {
19032 $2 = HEAP32[$0 + 124 >> 2];
19033 if (($2 | 0) > ($3 | 0) ? 1 : ($2 | 0) >= ($3 | 0) ? (HEAPU32[$0 + 120 >> 2] < $5 >>> 0 ? 0 : 1) : 0) {
19034 break label$2
19035 }
19036 }
19037 $5 = __uflow($0);
19038 if (($5 | 0) > -1) {
19039 break label$1
19040 }
19041 }
19042 HEAP32[$0 + 104 >> 2] = 0;
19043 return -1;
19044 }
19045 $2 = HEAP32[$0 + 8 >> 2];
19046 $3 = HEAP32[$0 + 116 >> 2];
19047 $4 = $3;
19048 label$4 : {
19049 label$5 : {
19050 $1 = HEAP32[$0 + 112 >> 2];
19051 if (!($3 | $1)) {
19052 break label$5
19053 }
19054 $3 = (HEAP32[$0 + 124 >> 2] ^ -1) + $4 | 0;
19055 $4 = HEAP32[$0 + 120 >> 2] ^ -1;
19056 $1 = $4 + $1 | 0;
19057 if ($1 >>> 0 < $4 >>> 0) {
19058 $3 = $3 + 1 | 0
19059 }
19060 $4 = $1;
19061 $1 = HEAP32[$0 + 4 >> 2];
19062 $6 = $2 - $1 | 0;
19063 $7 = $4 >>> 0 < $6 >>> 0 ? 0 : 1;
19064 $6 = $6 >> 31;
19065 if (($3 | 0) > ($6 | 0) ? 1 : ($3 | 0) >= ($6 | 0) ? $7 : 0) {
19066 break label$5
19067 }
19068 HEAP32[$0 + 104 >> 2] = $4 + $1;
19069 break label$4;
19070 }
19071 HEAP32[$0 + 104 >> 2] = $2;
19072 }
19073 label$6 : {
19074 if (!$2) {
19075 $2 = HEAP32[$0 + 4 >> 2];
19076 break label$6;
19077 }
19078 $3 = $0;
19079 $1 = $2;
19080 $2 = HEAP32[$0 + 4 >> 2];
19081 $1 = ($1 - $2 | 0) + 1 | 0;
19082 $4 = $1 + HEAP32[$0 + 120 >> 2] | 0;
19083 $0 = HEAP32[$0 + 124 >> 2] + ($1 >> 31) | 0;
19084 HEAP32[$3 + 120 >> 2] = $4;
19085 HEAP32[$3 + 124 >> 2] = $4 >>> 0 < $1 >>> 0 ? $0 + 1 | 0 : $0;
19086 }
19087 $0 = $2 + -1 | 0;
19088 if (HEAPU8[$0 | 0] != ($5 | 0)) {
19089 HEAP8[$0 | 0] = $5
19090 }
19091 return $5;
19092 }
19093
19094 function __extendsftf2($0, $1) {
19095 var $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0;
19096 $4 = global$0 - 16 | 0;
19097 global$0 = $4;
19098 $5 = (wasm2js_scratch_store_f32($1), wasm2js_scratch_load_i32(0));
19099 $2 = $5 & 2147483647;
19100 label$1 : {
19101 if ($2 + -8388608 >>> 0 <= 2130706431) {
19102 $3 = $2;
19103 $2 = $2 >>> 7 | 0;
19104 $3 = $3 << 25;
19105 $2 = $2 + 1065353216 | 0;
19106 $6 = $3;
19107 $2 = $3 >>> 0 < 0 ? $2 + 1 | 0 : $2;
19108 break label$1;
19109 }
19110 if ($2 >>> 0 >= 2139095040) {
19111 $2 = $5;
19112 $3 = $2 >>> 7 | 0;
19113 $6 = $2 << 25;
19114 $2 = $3 | 2147418112;
19115 break label$1;
19116 }
19117 if (!$2) {
19118 $2 = 0;
19119 break label$1;
19120 }
19121 $3 = $2;
19122 $2 = Math_clz32($2);
19123 __ashlti3($4, $3, 0, 0, 0, $2 + 81 | 0);
19124 $7 = HEAP32[$4 >> 2];
19125 $8 = HEAP32[$4 + 4 >> 2];
19126 $6 = HEAP32[$4 + 8 >> 2];
19127 $2 = HEAP32[$4 + 12 >> 2] ^ 65536 | 16265 - $2 << 16;
19128 }
19129 HEAP32[$0 >> 2] = $7;
19130 HEAP32[$0 + 4 >> 2] = $8;
19131 HEAP32[$0 + 8 >> 2] = $6;
19132 HEAP32[$0 + 12 >> 2] = $5 & -2147483648 | $2;
19133 global$0 = $4 + 16 | 0;
19134 }
19135
19136 function __floatsitf($0, $1) {
19137 var $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0;
19138 $3 = global$0 - 16 | 0;
19139 global$0 = $3;
19140 $6 = $0;
19141 $7 = $0;
19142 label$1 : {
19143 if (!$1) {
19144 $1 = 0;
19145 $5 = 0;
19146 break label$1;
19147 }
19148 $2 = $1 >> 31;
19149 $4 = $2 + $1 ^ $2;
19150 $2 = Math_clz32($4);
19151 __ashlti3($3, $4, 0, 0, 0, $2 + 81 | 0);
19152 $2 = (HEAP32[$3 + 12 >> 2] ^ 65536) + (16414 - $2 << 16) | 0;
19153 $4 = 0 + HEAP32[$3 + 8 >> 2] | 0;
19154 if ($4 >>> 0 < $5 >>> 0) {
19155 $2 = $2 + 1 | 0
19156 }
19157 $1 = $1 & -2147483648 | $2;
19158 $2 = HEAP32[$3 + 4 >> 2];
19159 $5 = HEAP32[$3 >> 2];
19160 }
19161 HEAP32[$7 >> 2] = $5;
19162 HEAP32[$6 + 4 >> 2] = $2;
19163 HEAP32[$0 + 8 >> 2] = $4;
19164 HEAP32[$0 + 12 >> 2] = $1;
19165 global$0 = $3 + 16 | 0;
19166 }
19167
19168 function __multf3($0, $1, $2, $3, $4, $5, $6, $7, $8) {
19169 var $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0, $23 = 0, $24 = 0, $25 = 0, $26 = 0, $27 = 0, $28 = 0, $29 = 0, $30 = 0, $31 = 0, $32 = 0, $33 = 0, $34 = 0, $35 = 0, $36 = 0, $37 = 0, $38 = 0, $39 = 0, $40 = 0, $41 = 0, $42 = 0, $43 = 0, $44 = 0, $45 = 0, $46 = 0, $47 = 0;
19170 $13 = global$0 - 96 | 0;
19171 global$0 = $13;
19172 $15 = $2;
19173 $10 = $6;
19174 $19 = ($10 & 131071) << 15 | $5 >>> 17;
19175 $9 = $8 & 65535;
19176 $21 = $9;
19177 $17 = $7;
19178 $10 = $7;
19179 $24 = $10 << 15 | $6 >>> 17;
19180 $14 = ($4 ^ $8) & -2147483648;
19181 $10 = $4 & 65535;
19182 $12 = $10;
19183 $16 = $3;
19184 $27 = $10;
19185 $10 = $9;
19186 $25 = ($10 & 131071) << 15 | $7 >>> 17;
19187 $37 = $8 >>> 16 & 32767;
19188 $38 = $4 >>> 16 & 32767;
19189 label$1 : {
19190 label$2 : {
19191 if ($38 + -1 >>> 0 <= 32765) {
19192 $20 = 0;
19193 if ($37 + -1 >>> 0 < 32766) {
19194 break label$2
19195 }
19196 }
19197 $11 = $4 & 2147483647;
19198 $9 = $11;
19199 $10 = $3;
19200 if (!(!$3 & ($9 | 0) == 2147418112 ? !($1 | $2) : ($9 | 0) == 2147418112 & $3 >>> 0 < 0 | $9 >>> 0 < 2147418112)) {
19201 $22 = $3;
19202 $14 = $4 | 32768;
19203 break label$1;
19204 }
19205 $11 = $8 & 2147483647;
19206 $4 = $11;
19207 $3 = $7;
19208 if (!(!$3 & ($4 | 0) == 2147418112 ? !($5 | $6) : ($4 | 0) == 2147418112 & $3 >>> 0 < 0 | $4 >>> 0 < 2147418112)) {
19209 $22 = $7;
19210 $14 = $8 | 32768;
19211 $1 = $5;
19212 $2 = $6;
19213 break label$1;
19214 }
19215 if (!($1 | $10 | ($9 ^ 2147418112 | $2))) {
19216 if (!($3 | $5 | ($4 | $6))) {
19217 $14 = 2147450880;
19218 $1 = 0;
19219 $2 = 0;
19220 break label$1;
19221 }
19222 $14 = $14 | 2147418112;
19223 $1 = 0;
19224 $2 = 0;
19225 break label$1;
19226 }
19227 if (!($3 | $5 | ($4 ^ 2147418112 | $6))) {
19228 $3 = $1 | $10;
19229 $4 = $2 | $9;
19230 $1 = 0;
19231 $2 = 0;
19232 if (!($3 | $4)) {
19233 $14 = 2147450880;
19234 break label$1;
19235 }
19236 $14 = $14 | 2147418112;
19237 break label$1;
19238 }
19239 if (!($1 | $10 | ($2 | $9))) {
19240 $1 = 0;
19241 $2 = 0;
19242 break label$1;
19243 }
19244 if (!($3 | $5 | ($4 | $6))) {
19245 $1 = 0;
19246 $2 = 0;
19247 break label$1;
19248 }
19249 $3 = 0;
19250 if (($9 | 0) == 65535 | $9 >>> 0 < 65535) {
19251 $9 = $1;
19252 $8 = $2;
19253 $3 = !($12 | $16);
19254 $7 = $3 << 6;
19255 $10 = Math_clz32($3 ? $1 : $16) + 32 | 0;
19256 $1 = Math_clz32($3 ? $2 : $12);
19257 $1 = $7 + (($1 | 0) == 32 ? $10 : $1) | 0;
19258 __ashlti3($13 + 80 | 0, $9, $8, $16, $12, $1 + -15 | 0);
19259 $16 = HEAP32[$13 + 88 >> 2];
19260 $15 = HEAP32[$13 + 84 >> 2];
19261 $27 = HEAP32[$13 + 92 >> 2];
19262 $3 = 16 - $1 | 0;
19263 $1 = HEAP32[$13 + 80 >> 2];
19264 }
19265 $20 = $3;
19266 if ($4 >>> 0 > 65535) {
19267 break label$2
19268 }
19269 $2 = !($17 | $21);
19270 $4 = $2 << 6;
19271 $7 = Math_clz32($2 ? $5 : $17) + 32 | 0;
19272 $2 = Math_clz32($2 ? $6 : $21);
19273 $2 = $4 + (($2 | 0) == 32 ? $7 : $2) | 0;
19274 $8 = $2;
19275 __ashlti3($13 - -64 | 0, $5, $6, $17, $21, $2 + -15 | 0);
19276 $5 = HEAP32[$13 + 76 >> 2];
19277 $2 = $5;
19278 $7 = HEAP32[$13 + 72 >> 2];
19279 $4 = $7;
19280 $4 = $4 << 15;
19281 $10 = HEAP32[$13 + 68 >> 2];
19282 $24 = $10 >>> 17 | $4;
19283 $4 = $10;
19284 $5 = HEAP32[$13 + 64 >> 2];
19285 $19 = ($4 & 131071) << 15 | $5 >>> 17;
19286 $25 = ($2 & 131071) << 15 | $7 >>> 17;
19287 $20 = ($3 - $8 | 0) + 16 | 0;
19288 }
19289 $3 = $19;
19290 $17 = 0;
19291 $8 = __wasm_i64_mul($3, 0, $1, $17);
19292 $2 = i64toi32_i32$HIGH_BITS;
19293 $26 = $2;
19294 $23 = $5 << 15 & -32768;
19295 $5 = __wasm_i64_mul($23, 0, $15, 0);
19296 $4 = $5 + $8 | 0;
19297 $11 = i64toi32_i32$HIGH_BITS + $2 | 0;
19298 $11 = $4 >>> 0 < $5 >>> 0 ? $11 + 1 | 0 : $11;
19299 $2 = $4;
19300 $5 = 0;
19301 $6 = __wasm_i64_mul($23, $28, $1, $17);
19302 $4 = $5 + $6 | 0;
19303 $9 = i64toi32_i32$HIGH_BITS + $2 | 0;
19304 $9 = $4 >>> 0 < $6 >>> 0 ? $9 + 1 | 0 : $9;
19305 $19 = $4;
19306 $6 = $9;
19307 $32 = ($2 | 0) == ($9 | 0) & $4 >>> 0 < $5 >>> 0 | $9 >>> 0 < $2 >>> 0;
19308 $41 = __wasm_i64_mul($3, $39, $15, $40);
19309 $33 = i64toi32_i32$HIGH_BITS;
19310 $29 = $16;
19311 $5 = __wasm_i64_mul($23, $28, $16, 0);
19312 $4 = $5 + $41 | 0;
19313 $12 = i64toi32_i32$HIGH_BITS + $33 | 0;
19314 $12 = $4 >>> 0 < $5 >>> 0 ? $12 + 1 | 0 : $12;
19315 $42 = $4;
19316 $7 = __wasm_i64_mul($24, 0, $1, $17);
19317 $4 = $4 + $7 | 0;
19318 $5 = i64toi32_i32$HIGH_BITS + $12 | 0;
19319 $34 = $4;
19320 $5 = $4 >>> 0 < $7 >>> 0 ? $5 + 1 | 0 : $5;
19321 $21 = $5;
19322 $7 = $5;
19323 $5 = ($11 | 0) == ($26 | 0) & $2 >>> 0 < $8 >>> 0 | $11 >>> 0 < $26 >>> 0;
19324 $4 = $11;
19325 $2 = $4 + $34 | 0;
19326 $9 = $5 + $7 | 0;
19327 $26 = $2;
19328 $9 = $2 >>> 0 < $4 >>> 0 ? $9 + 1 | 0 : $9;
19329 $4 = $9;
19330 $7 = $2;
19331 $44 = __wasm_i64_mul($3, $39, $16, $43);
19332 $35 = i64toi32_i32$HIGH_BITS;
19333 $2 = $23;
19334 $30 = $27 | 65536;
19335 $23 = $18;
19336 $5 = __wasm_i64_mul($2, $28, $30, $18);
19337 $2 = $5 + $44 | 0;
19338 $9 = i64toi32_i32$HIGH_BITS + $35 | 0;
19339 $9 = $2 >>> 0 < $5 >>> 0 ? $9 + 1 | 0 : $9;
19340 $45 = $2;
19341 $10 = __wasm_i64_mul($15, $40, $24, $46);
19342 $2 = $2 + $10 | 0;
19343 $18 = $9;
19344 $5 = $9 + i64toi32_i32$HIGH_BITS | 0;
19345 $5 = $2 >>> 0 < $10 >>> 0 ? $5 + 1 | 0 : $5;
19346 $36 = $2;
19347 $31 = $25 & 2147483647 | -2147483648;
19348 $2 = __wasm_i64_mul($31, 0, $1, $17);
19349 $1 = $36 + $2 | 0;
19350 $17 = $5;
19351 $10 = $5 + i64toi32_i32$HIGH_BITS | 0;
19352 $28 = $1;
19353 $2 = $1 >>> 0 < $2 >>> 0 ? $10 + 1 | 0 : $10;
19354 $9 = $4 + $1 | 0;
19355 $5 = 0;
19356 $1 = $5 + $7 | 0;
19357 if ($1 >>> 0 < $5 >>> 0) {
19358 $9 = $9 + 1 | 0
19359 }
19360 $27 = $1;
19361 $25 = $9;
19362 $5 = $9;
19363 $7 = $1 + $32 | 0;
19364 if ($7 >>> 0 < $1 >>> 0) {
19365 $5 = $5 + 1 | 0
19366 }
19367 $8 = $5;
19368 $16 = ($20 + ($37 + $38 | 0) | 0) + -16383 | 0;
19369 $5 = __wasm_i64_mul($29, $43, $24, $46);
19370 $1 = i64toi32_i32$HIGH_BITS;
19371 $11 = 0;
19372 $10 = __wasm_i64_mul($3, $39, $30, $23);
19373 $3 = $10 + $5 | 0;
19374 $9 = i64toi32_i32$HIGH_BITS + $1 | 0;
19375 $9 = $3 >>> 0 < $10 >>> 0 ? $9 + 1 | 0 : $9;
19376 $20 = $3;
19377 $10 = $3;
19378 $3 = $9;
19379 $9 = ($1 | 0) == ($3 | 0) & $10 >>> 0 < $5 >>> 0 | $3 >>> 0 < $1 >>> 0;
19380 $5 = __wasm_i64_mul($31, $47, $15, $40);
19381 $1 = $5 + $10 | 0;
19382 $10 = i64toi32_i32$HIGH_BITS + $3 | 0;
19383 $10 = $1 >>> 0 < $5 >>> 0 ? $10 + 1 | 0 : $10;
19384 $15 = $1;
19385 $5 = $1;
19386 $1 = $10;
19387 $3 = ($3 | 0) == ($1 | 0) & $5 >>> 0 < $20 >>> 0 | $1 >>> 0 < $3 >>> 0;
19388 $5 = $9 + $3 | 0;
19389 if ($5 >>> 0 < $3 >>> 0) {
19390 $11 = 1
19391 }
19392 $10 = $5;
19393 $3 = $1;
19394 $5 = $11;
19395 $32 = $10;
19396 $9 = 0;
19397 $10 = ($12 | 0) == ($21 | 0) & $34 >>> 0 < $42 >>> 0 | $21 >>> 0 < $12 >>> 0;
19398 $12 = $10 + (($12 | 0) == ($33 | 0) & $42 >>> 0 < $41 >>> 0 | $12 >>> 0 < $33 >>> 0) | 0;
19399 if ($12 >>> 0 < $10 >>> 0) {
19400 $9 = 1
19401 }
19402 $11 = $12;
19403 $12 = $12 + $15 | 0;
19404 $10 = $3 + $9 | 0;
19405 $20 = $12;
19406 $9 = $12;
19407 $10 = $9 >>> 0 < $11 >>> 0 ? $10 + 1 | 0 : $10;
19408 $3 = $10;
19409 $1 = ($1 | 0) == ($3 | 0) & $9 >>> 0 < $15 >>> 0 | $3 >>> 0 < $1 >>> 0;
19410 $10 = $32 + $1 | 0;
19411 if ($10 >>> 0 < $1 >>> 0) {
19412 $5 = $5 + 1 | 0
19413 }
19414 $1 = $10;
19415 $10 = __wasm_i64_mul($31, $47, $30, $23);
19416 $1 = $1 + $10 | 0;
19417 $9 = i64toi32_i32$HIGH_BITS + $5 | 0;
19418 $9 = $1 >>> 0 < $10 >>> 0 ? $9 + 1 | 0 : $9;
19419 $11 = $1;
19420 $12 = __wasm_i64_mul($31, $47, $29, $43);
19421 $5 = i64toi32_i32$HIGH_BITS;
19422 $15 = __wasm_i64_mul($24, $46, $30, $23);
19423 $1 = $15 + $12 | 0;
19424 $10 = i64toi32_i32$HIGH_BITS + $5 | 0;
19425 $10 = $1 >>> 0 < $15 >>> 0 ? $10 + 1 | 0 : $10;
19426 $15 = $1;
19427 $1 = $10;
19428 $10 = ($5 | 0) == ($1 | 0) & $15 >>> 0 < $12 >>> 0 | $1 >>> 0 < $5 >>> 0;
19429 $5 = $1 + $11 | 0;
19430 $11 = $9 + $10 | 0;
19431 $10 = $5 >>> 0 < $1 >>> 0 ? $11 + 1 | 0 : $11;
19432 $29 = $5;
19433 $9 = $3 + $15 | 0;
19434 $11 = 0;
19435 $1 = $11 + $20 | 0;
19436 if ($1 >>> 0 < $11 >>> 0) {
19437 $9 = $9 + 1 | 0
19438 }
19439 $12 = $1;
19440 $5 = $1;
19441 $1 = $9;
19442 $3 = ($3 | 0) == ($1 | 0) & $5 >>> 0 < $20 >>> 0 | $1 >>> 0 < $3 >>> 0;
19443 $5 = $29 + $3 | 0;
19444 if ($5 >>> 0 < $3 >>> 0) {
19445 $10 = $10 + 1 | 0
19446 }
19447 $15 = $5;
19448 $11 = $1;
19449 $9 = 0;
19450 $5 = ($18 | 0) == ($17 | 0) & $36 >>> 0 < $45 >>> 0 | $17 >>> 0 < $18 >>> 0;
19451 $18 = $5 + (($18 | 0) == ($35 | 0) & $45 >>> 0 < $44 >>> 0 | $18 >>> 0 < $35 >>> 0) | 0;
19452 if ($18 >>> 0 < $5 >>> 0) {
19453 $9 = 1
19454 }
19455 $5 = $18 + (($2 | 0) == ($17 | 0) & $28 >>> 0 < $36 >>> 0 | $2 >>> 0 < $17 >>> 0) | 0;
19456 $3 = $2;
19457 $2 = $3 + $12 | 0;
19458 $11 = $5 + $11 | 0;
19459 $11 = $2 >>> 0 < $3 >>> 0 ? $11 + 1 | 0 : $11;
19460 $18 = $2;
19461 $3 = $2;
19462 $2 = $11;
19463 $1 = ($1 | 0) == ($2 | 0) & $3 >>> 0 < $12 >>> 0 | $2 >>> 0 < $1 >>> 0;
19464 $3 = $1 + $15 | 0;
19465 if ($3 >>> 0 < $1 >>> 0) {
19466 $10 = $10 + 1 | 0
19467 }
19468 $1 = $2;
19469 $9 = $10;
19470 $10 = $3;
19471 $5 = 0;
19472 $3 = ($4 | 0) == ($25 | 0) & $27 >>> 0 < $26 >>> 0 | $25 >>> 0 < $4 >>> 0;
19473 $4 = $3 + (($4 | 0) == ($21 | 0) & $26 >>> 0 < $34 >>> 0 | $4 >>> 0 < $21 >>> 0) | 0;
19474 if ($4 >>> 0 < $3 >>> 0) {
19475 $5 = 1
19476 }
19477 $3 = $4 + $18 | 0;
19478 $11 = $1 + $5 | 0;
19479 $11 = $3 >>> 0 < $4 >>> 0 ? $11 + 1 | 0 : $11;
19480 $1 = $3;
19481 $4 = $11;
19482 $1 = ($2 | 0) == ($4 | 0) & $1 >>> 0 < $18 >>> 0 | $4 >>> 0 < $2 >>> 0;
19483 $2 = $10 + $1 | 0;
19484 if ($2 >>> 0 < $1 >>> 0) {
19485 $9 = $9 + 1 | 0
19486 }
19487 $1 = $2;
19488 $2 = $9;
19489 label$13 : {
19490 if ($2 & 65536) {
19491 $16 = $16 + 1 | 0;
19492 break label$13;
19493 }
19494 $12 = $6 >>> 31 | 0;
19495 $9 = $2 << 1 | $1 >>> 31;
19496 $1 = $1 << 1 | $4 >>> 31;
19497 $2 = $9;
19498 $9 = $4 << 1 | $3 >>> 31;
19499 $3 = $3 << 1 | $8 >>> 31;
19500 $4 = $9;
19501 $10 = $19;
19502 $9 = $6 << 1 | $10 >>> 31;
19503 $19 = $10 << 1;
19504 $6 = $9;
19505 $10 = $8 << 1 | $7 >>> 31;
19506 $7 = $7 << 1 | $12;
19507 $8 = $10;
19508 }
19509 if (($16 | 0) >= 32767) {
19510 $14 = $14 | 2147418112;
19511 $1 = 0;
19512 $2 = 0;
19513 break label$1;
19514 }
19515 label$16 : {
19516 if (($16 | 0) <= 0) {
19517 $5 = 1 - $16 | 0;
19518 if ($5 >>> 0 <= 127) {
19519 $10 = $16 + 127 | 0;
19520 __ashlti3($13 + 48 | 0, $19, $6, $7, $8, $10);
19521 __ashlti3($13 + 32 | 0, $3, $4, $1, $2, $10);
19522 __lshrti3($13 + 16 | 0, $19, $6, $7, $8, $5);
19523 __lshrti3($13, $3, $4, $1, $2, $5);
19524 $19 = (HEAP32[$13 + 48 >> 2] | HEAP32[$13 + 56 >> 2]) != 0 | (HEAP32[$13 + 52 >> 2] | HEAP32[$13 + 60 >> 2]) != 0 | (HEAP32[$13 + 32 >> 2] | HEAP32[$13 + 16 >> 2]);
19525 $6 = HEAP32[$13 + 36 >> 2] | HEAP32[$13 + 20 >> 2];
19526 $7 = HEAP32[$13 + 40 >> 2] | HEAP32[$13 + 24 >> 2];
19527 $8 = HEAP32[$13 + 44 >> 2] | HEAP32[$13 + 28 >> 2];
19528 $3 = HEAP32[$13 >> 2];
19529 $4 = HEAP32[$13 + 4 >> 2];
19530 $2 = HEAP32[$13 + 12 >> 2];
19531 $1 = HEAP32[$13 + 8 >> 2];
19532 break label$16;
19533 }
19534 $1 = 0;
19535 $2 = 0;
19536 break label$1;
19537 }
19538 $2 = $2 & 65535 | $16 << 16;
19539 }
19540 $22 = $1 | $22;
19541 $14 = $2 | $14;
19542 if (!(!$7 & ($8 | 0) == -2147483648 ? !($6 | $19) : ($8 | 0) > -1 ? 1 : 0)) {
19543 $11 = $14;
19544 $12 = $4;
19545 $1 = $3 + 1 | 0;
19546 if ($1 >>> 0 < 1) {
19547 $12 = $12 + 1 | 0
19548 }
19549 $2 = $12;
19550 $3 = ($4 | 0) == ($2 | 0) & $1 >>> 0 < $3 >>> 0 | $2 >>> 0 < $4 >>> 0;
19551 $4 = $3 + $22 | 0;
19552 if ($4 >>> 0 < $3 >>> 0) {
19553 $11 = $11 + 1 | 0
19554 }
19555 $22 = $4;
19556 $14 = $11;
19557 break label$1;
19558 }
19559 if ($7 | $19 | ($8 ^ -2147483648 | $6)) {
19560 $1 = $3;
19561 $2 = $4;
19562 break label$1;
19563 }
19564 $12 = $14;
19565 $9 = $4;
19566 $1 = $3 & 1;
19567 $2 = $1 + $3 | 0;
19568 if ($2 >>> 0 < $1 >>> 0) {
19569 $9 = $9 + 1 | 0
19570 }
19571 $1 = $2;
19572 $2 = $9;
19573 $3 = ($4 | 0) == ($2 | 0) & $1 >>> 0 < $3 >>> 0 | $2 >>> 0 < $4 >>> 0;
19574 $4 = $3 + $22 | 0;
19575 if ($4 >>> 0 < $3 >>> 0) {
19576 $12 = $12 + 1 | 0
19577 }
19578 $22 = $4;
19579 $14 = $12;
19580 }
19581 HEAP32[$0 >> 2] = $1;
19582 HEAP32[$0 + 4 >> 2] = $2;
19583 HEAP32[$0 + 8 >> 2] = $22;
19584 HEAP32[$0 + 12 >> 2] = $14;
19585 global$0 = $13 + 96 | 0;
19586 }
19587
19588 function __addtf3($0, $1, $2, $3, $4, $5, $6, $7, $8) {
19589 var $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0;
19590 $11 = global$0 - 112 | 0;
19591 global$0 = $11;
19592 $12 = $7;
19593 $14 = $8 & 2147483647;
19594 $10 = $2 + -1 | 0;
19595 $9 = $1 + -1 | 0;
19596 if (($9 | 0) != -1) {
19597 $10 = $10 + 1 | 0
19598 }
19599 $13 = $9;
19600 $17 = ($9 | 0) == -1 & ($10 | 0) == -1;
19601 $15 = $4 & 2147483647;
19602 $9 = $15;
19603 $16 = $3;
19604 $10 = ($2 | 0) == ($10 | 0) & $13 >>> 0 < $1 >>> 0 | $10 >>> 0 < $2 >>> 0;
19605 $13 = $3 + $10 | 0;
19606 if ($13 >>> 0 < $10 >>> 0) {
19607 $9 = $9 + 1 | 0
19608 }
19609 $13 = $13 + -1 | 0;
19610 $10 = $9 + -1 | 0;
19611 $9 = $13;
19612 label$1 : {
19613 label$2 : {
19614 $10 = ($9 | 0) != -1 ? $10 + 1 | 0 : $10;
19615 if (!(($9 | 0) == -1 & ($10 | 0) == 2147418111 ? $17 : $10 >>> 0 > 2147418111)) {
19616 $10 = $6 + -1 | 0;
19617 $9 = $5 + -1 | 0;
19618 if (($9 | 0) != -1) {
19619 $10 = $10 + 1 | 0
19620 }
19621 $13 = $9;
19622 $17 = ($9 | 0) != -1 | ($10 | 0) != -1;
19623 $9 = $14;
19624 $10 = ($6 | 0) == ($10 | 0) & $13 >>> 0 < $5 >>> 0 | $10 >>> 0 < $6 >>> 0;
19625 $13 = $10 + $12 | 0;
19626 if ($13 >>> 0 < $10 >>> 0) {
19627 $9 = $9 + 1 | 0
19628 }
19629 $10 = $13 + -1 | 0;
19630 $9 = $9 + -1 | 0;
19631 $9 = ($10 | 0) != -1 ? $9 + 1 | 0 : $9;
19632 if (($10 | 0) == -1 & ($9 | 0) == 2147418111 ? $17 : ($9 | 0) == 2147418111 & ($10 | 0) != -1 | $9 >>> 0 < 2147418111) {
19633 break label$2
19634 }
19635 }
19636 if (!(!$16 & ($15 | 0) == 2147418112 ? !($1 | $2) : ($15 | 0) == 2147418112 & $16 >>> 0 < 0 | $15 >>> 0 < 2147418112)) {
19637 $7 = $3;
19638 $8 = $4 | 32768;
19639 $5 = $1;
19640 $6 = $2;
19641 break label$1;
19642 }
19643 if (!(!$12 & ($14 | 0) == 2147418112 ? !($5 | $6) : ($14 | 0) == 2147418112 & $12 >>> 0 < 0 | $14 >>> 0 < 2147418112)) {
19644 $8 = $8 | 32768;
19645 break label$1;
19646 }
19647 if (!($1 | $16 | ($15 ^ 2147418112 | $2))) {
19648 $9 = $3;
19649 $3 = !($1 ^ $5 | $3 ^ $7 | ($2 ^ $6 | $4 ^ $8 ^ -2147483648));
19650 $7 = $3 ? 0 : $9;
19651 $8 = $3 ? 2147450880 : $4;
19652 $5 = $3 ? 0 : $1;
19653 $6 = $3 ? 0 : $2;
19654 break label$1;
19655 }
19656 if (!($5 | $12 | ($14 ^ 2147418112 | $6))) {
19657 break label$1
19658 }
19659 if (!($1 | $16 | ($2 | $15))) {
19660 if ($5 | $12 | ($6 | $14)) {
19661 break label$1
19662 }
19663 $5 = $1 & $5;
19664 $6 = $2 & $6;
19665 $7 = $3 & $7;
19666 $8 = $4 & $8;
19667 break label$1;
19668 }
19669 if ($5 | $12 | ($6 | $14)) {
19670 break label$2
19671 }
19672 $5 = $1;
19673 $6 = $2;
19674 $7 = $3;
19675 $8 = $4;
19676 break label$1;
19677 }
19678 $10 = ($12 | 0) == ($16 | 0) & ($14 | 0) == ($15 | 0) ? ($2 | 0) == ($6 | 0) & $5 >>> 0 > $1 >>> 0 | $6 >>> 0 > $2 >>> 0 : ($14 | 0) == ($15 | 0) & $12 >>> 0 > $16 >>> 0 | $14 >>> 0 > $15 >>> 0;
19679 $9 = $10;
19680 $15 = $9 ? $5 : $1;
19681 $14 = $9 ? $6 : $2;
19682 $12 = $9 ? $8 : $4;
19683 $16 = $12;
19684 $13 = $9 ? $7 : $3;
19685 $9 = $12 & 65535;
19686 $4 = $10 ? $4 : $8;
19687 $18 = $4;
19688 $3 = $10 ? $3 : $7;
19689 $17 = $4 >>> 16 & 32767;
19690 $12 = $12 >>> 16 & 32767;
19691 if (!$12) {
19692 $4 = !($9 | $13);
19693 $7 = $4 << 6;
19694 $8 = Math_clz32($4 ? $15 : $13) + 32 | 0;
19695 $4 = Math_clz32($4 ? $14 : $9);
19696 $4 = $7 + (($4 | 0) == 32 ? $8 : $4) | 0;
19697 __ashlti3($11 + 96 | 0, $15, $14, $13, $9, $4 + -15 | 0);
19698 $13 = HEAP32[$11 + 104 >> 2];
19699 $15 = HEAP32[$11 + 96 >> 2];
19700 $14 = HEAP32[$11 + 100 >> 2];
19701 $12 = 16 - $4 | 0;
19702 $9 = HEAP32[$11 + 108 >> 2];
19703 }
19704 $5 = $10 ? $1 : $5;
19705 $6 = $10 ? $2 : $6;
19706 $1 = $3;
19707 $2 = $18 & 65535;
19708 if ($17) {
19709 $1 = $2
19710 } else {
19711 $7 = $1;
19712 $3 = !($1 | $2);
19713 $4 = $3 << 6;
19714 $8 = Math_clz32($3 ? $5 : $1) + 32 | 0;
19715 $1 = Math_clz32($3 ? $6 : $2);
19716 $1 = $4 + (($1 | 0) == 32 ? $8 : $1) | 0;
19717 __ashlti3($11 + 80 | 0, $5, $6, $7, $2, $1 + -15 | 0);
19718 $17 = 16 - $1 | 0;
19719 $5 = HEAP32[$11 + 80 >> 2];
19720 $6 = HEAP32[$11 + 84 >> 2];
19721 $3 = HEAP32[$11 + 88 >> 2];
19722 $1 = HEAP32[$11 + 92 >> 2];
19723 }
19724 $2 = $3;
19725 $10 = $1 << 3 | $2 >>> 29;
19726 $7 = $2 << 3 | $6 >>> 29;
19727 $8 = $10 | 524288;
19728 $1 = $13;
19729 $3 = $9 << 3 | $1 >>> 29;
19730 $4 = $1 << 3 | $14 >>> 29;
19731 $13 = $3;
19732 $10 = $16 ^ $18;
19733 $1 = $5;
19734 $9 = $6 << 3 | $1 >>> 29;
19735 $1 = $1 << 3;
19736 $2 = $9;
19737 $5 = $12 - $17 | 0;
19738 $3 = $1;
19739 label$11 : {
19740 if (!$5) {
19741 break label$11
19742 }
19743 if ($5 >>> 0 > 127) {
19744 $7 = 0;
19745 $8 = 0;
19746 $9 = 0;
19747 $3 = 1;
19748 break label$11;
19749 }
19750 __ashlti3($11 - -64 | 0, $1, $2, $7, $8, 128 - $5 | 0);
19751 __lshrti3($11 + 48 | 0, $1, $2, $7, $8, $5);
19752 $7 = HEAP32[$11 + 56 >> 2];
19753 $8 = HEAP32[$11 + 60 >> 2];
19754 $9 = HEAP32[$11 + 52 >> 2];
19755 $3 = HEAP32[$11 + 48 >> 2] | ((HEAP32[$11 + 64 >> 2] | HEAP32[$11 + 72 >> 2]) != 0 | (HEAP32[$11 + 68 >> 2] | HEAP32[$11 + 76 >> 2]) != 0);
19756 }
19757 $6 = $9;
19758 $13 = $13 | 524288;
19759 $1 = $15;
19760 $9 = $14 << 3 | $1 >>> 29;
19761 $2 = $1 << 3;
19762 label$13 : {
19763 if (($10 | 0) < -1 ? 1 : ($10 | 0) <= -1 ? 1 : 0) {
19764 $14 = $3;
19765 $1 = $2 - $3 | 0;
19766 $15 = $4 - $7 | 0;
19767 $3 = ($6 | 0) == ($9 | 0) & $2 >>> 0 < $3 >>> 0 | $9 >>> 0 < $6 >>> 0;
19768 $5 = $15 - $3 | 0;
19769 $2 = $9 - (($2 >>> 0 < $14 >>> 0) + $6 | 0) | 0;
19770 $6 = ($13 - (($4 >>> 0 < $7 >>> 0) + $8 | 0) | 0) - ($15 >>> 0 < $3 >>> 0) | 0;
19771 if (!($1 | $5 | ($2 | $6))) {
19772 $5 = 0;
19773 $6 = 0;
19774 $7 = 0;
19775 $8 = 0;
19776 break label$1;
19777 }
19778 if ($6 >>> 0 > 524287) {
19779 break label$13
19780 }
19781 $7 = $1;
19782 $3 = !($5 | $6);
19783 $4 = $3 << 6;
19784 $8 = Math_clz32($3 ? $1 : $5) + 32 | 0;
19785 $1 = Math_clz32($3 ? $2 : $6);
19786 $1 = $4 + (($1 | 0) == 32 ? $8 : $1) | 0;
19787 $1 = $1 + -12 | 0;
19788 __ashlti3($11 + 32 | 0, $7, $2, $5, $6, $1);
19789 $12 = $12 - $1 | 0;
19790 $5 = HEAP32[$11 + 40 >> 2];
19791 $6 = HEAP32[$11 + 44 >> 2];
19792 $1 = HEAP32[$11 + 32 >> 2];
19793 $2 = HEAP32[$11 + 36 >> 2];
19794 break label$13;
19795 }
19796 $10 = $6 + $9 | 0;
19797 $1 = $3;
19798 $2 = $1 + $2 | 0;
19799 if ($2 >>> 0 < $1 >>> 0) {
19800 $10 = $10 + 1 | 0
19801 }
19802 $1 = $2;
19803 $2 = $10;
19804 $6 = ($6 | 0) == ($2 | 0) & $1 >>> 0 < $3 >>> 0 | $2 >>> 0 < $6 >>> 0;
19805 $10 = $8 + $13 | 0;
19806 $3 = $4 + $7 | 0;
19807 if ($3 >>> 0 < $4 >>> 0) {
19808 $10 = $10 + 1 | 0
19809 }
19810 $5 = $3;
19811 $4 = $6 + $3 | 0;
19812 $3 = $10;
19813 $3 = $4 >>> 0 < $5 >>> 0 ? $3 + 1 | 0 : $3;
19814 $5 = $4;
19815 $6 = $3;
19816 if (!($3 & 1048576)) {
19817 break label$13
19818 }
19819 $1 = $1 & 1 | (($2 & 1) << 31 | $1 >>> 1);
19820 $2 = $5 << 31 | $2 >>> 1;
19821 $12 = $12 + 1 | 0;
19822 $5 = ($6 & 1) << 31 | $5 >>> 1;
19823 $6 = $6 >>> 1 | 0;
19824 }
19825 $7 = 0;
19826 $9 = $16 & -2147483648;
19827 if (($12 | 0) >= 32767) {
19828 $8 = $9 | 2147418112;
19829 $5 = 0;
19830 $6 = 0;
19831 break label$1;
19832 }
19833 $4 = 0;
19834 label$17 : {
19835 if (($12 | 0) > 0) {
19836 $4 = $12;
19837 break label$17;
19838 }
19839 __ashlti3($11 + 16 | 0, $1, $2, $5, $6, $12 + 127 | 0);
19840 __lshrti3($11, $1, $2, $5, $6, 1 - $12 | 0);
19841 $1 = HEAP32[$11 >> 2] | ((HEAP32[$11 + 16 >> 2] | HEAP32[$11 + 24 >> 2]) != 0 | (HEAP32[$11 + 20 >> 2] | HEAP32[$11 + 28 >> 2]) != 0);
19842 $2 = HEAP32[$11 + 4 >> 2];
19843 $5 = HEAP32[$11 + 8 >> 2];
19844 $6 = HEAP32[$11 + 12 >> 2];
19845 }
19846 $7 = $7 | (($6 & 7) << 29 | $5 >>> 3);
19847 $4 = $9 | $6 >>> 3 & 65535 | $4 << 16;
19848 $9 = $5 << 29;
19849 $3 = 0;
19850 $5 = $9;
19851 $6 = ($2 & 7) << 29 | $1 >>> 3 | $3;
19852 $9 = $4;
19853 $3 = $2 >>> 3 | $5;
19854 $10 = $3;
19855 $4 = $1 & 7;
19856 $1 = $4 >>> 0 > 4;
19857 $2 = $1 + $6 | 0;
19858 if ($2 >>> 0 < $1 >>> 0) {
19859 $10 = $10 + 1 | 0
19860 }
19861 $1 = $2;
19862 $2 = $10;
19863 $3 = ($3 | 0) == ($2 | 0) & $1 >>> 0 < $6 >>> 0 | $2 >>> 0 < $3 >>> 0;
19864 $5 = $3 + $7 | 0;
19865 if ($5 >>> 0 < $3 >>> 0) {
19866 $9 = $9 + 1 | 0
19867 }
19868 $4 = ($4 | 0) == 4;
19869 $3 = $4 ? $1 & 1 : 0;
19870 $8 = $9;
19871 $7 = $5;
19872 $4 = 0;
19873 $9 = $2 + $4 | 0;
19874 $2 = $1 + $3 | 0;
19875 if ($2 >>> 0 < $1 >>> 0) {
19876 $9 = $9 + 1 | 0
19877 }
19878 $5 = $2;
19879 $1 = $2;
19880 $6 = $9;
19881 $1 = ($4 | 0) == ($9 | 0) & $1 >>> 0 < $3 >>> 0 | $9 >>> 0 < $4 >>> 0;
19882 $2 = $7 + $1 | 0;
19883 if ($2 >>> 0 < $1 >>> 0) {
19884 $8 = $8 + 1 | 0
19885 }
19886 $7 = $2;
19887 }
19888 HEAP32[$0 >> 2] = $5;
19889 HEAP32[$0 + 4 >> 2] = $6;
19890 HEAP32[$0 + 8 >> 2] = $7;
19891 HEAP32[$0 + 12 >> 2] = $8;
19892 global$0 = $11 + 112 | 0;
19893 }
19894
19895 function __extenddftf2($0, $1) {
19896 var $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0;
19897 $5 = global$0 - 16 | 0;
19898 global$0 = $5;
19899 wasm2js_scratch_store_f64(+$1);
19900 $8 = wasm2js_scratch_load_i32(1) | 0;
19901 $6 = wasm2js_scratch_load_i32(0) | 0;
19902 $7 = $8 & 2147483647;
19903 $2 = $7;
19904 $4 = $2 + -1048576 | 0;
19905 $3 = $6;
19906 if ($3 >>> 0 < 0) {
19907 $4 = $4 + 1 | 0
19908 }
19909 label$1 : {
19910 if (($4 | 0) == 2145386495 | $4 >>> 0 < 2145386495) {
19911 $7 = $3 << 28;
19912 $4 = ($2 & 15) << 28 | $3 >>> 4;
19913 $2 = ($2 >>> 4 | 0) + 1006632960 | 0;
19914 $3 = $4;
19915 $2 = $3 >>> 0 < 0 ? $2 + 1 | 0 : $2;
19916 break label$1;
19917 }
19918 if (($2 | 0) == 2146435072 & $3 >>> 0 >= 0 | $2 >>> 0 > 2146435072) {
19919 $7 = $6 << 28;
19920 $4 = $6;
19921 $2 = $8;
19922 $6 = $2 >>> 4 | 0;
19923 $3 = ($2 & 15) << 28 | $4 >>> 4;
19924 $2 = $6 | 2147418112;
19925 break label$1;
19926 }
19927 if (!($2 | $3)) {
19928 $7 = 0;
19929 $3 = 0;
19930 $2 = 0;
19931 break label$1;
19932 }
19933 $4 = $2;
19934 $2 = ($2 | 0) == 1 & $3 >>> 0 < 0 | $2 >>> 0 < 1 ? Math_clz32($6) + 32 | 0 : Math_clz32($2);
19935 __ashlti3($5, $3, $4, 0, 0, $2 + 49 | 0);
19936 $9 = HEAP32[$5 >> 2];
19937 $7 = HEAP32[$5 + 4 >> 2];
19938 $3 = HEAP32[$5 + 8 >> 2];
19939 $2 = HEAP32[$5 + 12 >> 2] ^ 65536 | 15372 - $2 << 16;
19940 }
19941 HEAP32[$0 >> 2] = $9;
19942 HEAP32[$0 + 4 >> 2] = $7;
19943 HEAP32[$0 + 8 >> 2] = $3;
19944 HEAP32[$0 + 12 >> 2] = $8 & -2147483648 | $2;
19945 global$0 = $5 + 16 | 0;
19946 }
19947
19948 function __letf2($0, $1, $2, $3, $4, $5, $6, $7) {
19949 var $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0;
19950 $9 = 1;
19951 $8 = $3 & 2147483647;
19952 $12 = $8;
19953 $10 = $2;
19954 label$1 : {
19955 if (!$2 & ($8 | 0) == 2147418112 ? $0 | $1 : ($8 | 0) == 2147418112 & $2 >>> 0 > 0 | $8 >>> 0 > 2147418112) {
19956 break label$1
19957 }
19958 $11 = $7 & 2147483647;
19959 $13 = $11;
19960 $8 = $6;
19961 if (!$6 & ($11 | 0) == 2147418112 ? $4 | $5 : ($11 | 0) == 2147418112 & $6 >>> 0 > 0 | $11 >>> 0 > 2147418112) {
19962 break label$1
19963 }
19964 if (!($0 | $4 | ($8 | $10) | ($1 | $5 | ($12 | $13)))) {
19965 return 0
19966 }
19967 $10 = $3 & $7;
19968 if (($10 | 0) > 0 ? 1 : ($10 | 0) >= 0 ? (($2 & $6) >>> 0 < 0 ? 0 : 1) : 0) {
19969 $9 = -1;
19970 if (($2 | 0) == ($6 | 0) & ($3 | 0) == ($7 | 0) ? ($1 | 0) == ($5 | 0) & $0 >>> 0 < $4 >>> 0 | $1 >>> 0 < $5 >>> 0 : ($3 | 0) < ($7 | 0) ? 1 : ($3 | 0) <= ($7 | 0) ? ($2 >>> 0 >= $6 >>> 0 ? 0 : 1) : 0) {
19971 break label$1
19972 }
19973 return ($0 ^ $4 | $2 ^ $6) != 0 | ($1 ^ $5 | $3 ^ $7) != 0;
19974 }
19975 $9 = -1;
19976 if (($2 | 0) == ($6 | 0) & ($3 | 0) == ($7 | 0) ? ($1 | 0) == ($5 | 0) & $0 >>> 0 > $4 >>> 0 | $1 >>> 0 > $5 >>> 0 : ($3 | 0) > ($7 | 0) ? 1 : ($3 | 0) >= ($7 | 0) ? ($2 >>> 0 <= $6 >>> 0 ? 0 : 1) : 0) {
19977 break label$1
19978 }
19979 $9 = ($0 ^ $4 | $2 ^ $6) != 0 | ($1 ^ $5 | $3 ^ $7) != 0;
19980 }
19981 return $9;
19982 }
19983
19984 function __getf2($0, $1, $2, $3, $4) {
19985 var $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0;
19986 $7 = -1;
19987 $5 = $3 & 2147483647;
19988 $8 = $5;
19989 $6 = $2;
19990 label$1 : {
19991 if (!$2 & ($5 | 0) == 2147418112 ? $0 | $1 : ($5 | 0) == 2147418112 & $2 >>> 0 > 0 | $5 >>> 0 > 2147418112) {
19992 break label$1
19993 }
19994 $5 = $4 & 2147483647;
19995 $9 = $5;
19996 if (($5 | 0) == 2147418112 ? 0 : $5 >>> 0 > 2147418112) {
19997 break label$1
19998 }
19999 if (!($0 | $6 | ($1 | ($8 | $9)))) {
20000 return 0
20001 }
20002 $6 = $3 & $4;
20003 if (($6 | 0) > 0 ? 1 : ($6 | 0) >= 0 ? 1 : 0) {
20004 if (!$2 & ($3 | 0) == ($4 | 0) ? !$1 & $0 >>> 0 < 0 | $1 >>> 0 < 0 : ($3 | 0) < ($4 | 0) ? 1 : ($3 | 0) <= ($4 | 0) ? ($2 >>> 0 >= 0 ? 0 : 1) : 0) {
20005 break label$1
20006 }
20007 return ($0 | $2) != 0 | ($1 | $3 ^ $4) != 0;
20008 }
20009 if (!$2 & ($3 | 0) == ($4 | 0) ? !$1 & $0 >>> 0 > 0 | $1 >>> 0 > 0 : ($3 | 0) > ($4 | 0) ? 1 : ($3 | 0) >= ($4 | 0) ? ($2 >>> 0 <= 0 ? 0 : 1) : 0) {
20010 break label$1
20011 }
20012 $7 = ($0 | $2) != 0 | ($1 | $3 ^ $4) != 0;
20013 }
20014 return $7;
20015 }
20016
20017 function copysignl($0, $1, $2, $3, $4, $5, $6, $7, $8) {
20018 HEAP32[$0 >> 2] = $1;
20019 HEAP32[$0 + 4 >> 2] = $2;
20020 HEAP32[$0 + 8 >> 2] = $3;
20021 HEAP32[$0 + 12 >> 2] = $4 & 65535 | ($8 >>> 16 & 32768 | $4 >>> 16 & 32767) << 16;
20022 }
20023
20024 function __floatunsitf($0, $1) {
20025 var $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0;
20026 $2 = global$0 - 16 | 0;
20027 global$0 = $2;
20028 $6 = $0;
20029 $7 = $0;
20030 label$1 : {
20031 if (!$1) {
20032 $1 = 0;
20033 $3 = 0;
20034 break label$1;
20035 }
20036 $3 = $1;
20037 $1 = Math_clz32($1) ^ 31;
20038 __ashlti3($2, $3, 0, 0, 0, 112 - $1 | 0);
20039 $1 = (HEAP32[$2 + 12 >> 2] ^ 65536) + ($1 + 16383 << 16) | 0;
20040 $4 = 0 + HEAP32[$2 + 8 >> 2] | 0;
20041 if ($4 >>> 0 < $5 >>> 0) {
20042 $1 = $1 + 1 | 0
20043 }
20044 $5 = HEAP32[$2 + 4 >> 2];
20045 $3 = HEAP32[$2 >> 2];
20046 }
20047 HEAP32[$7 >> 2] = $3;
20048 HEAP32[$6 + 4 >> 2] = $5;
20049 HEAP32[$0 + 8 >> 2] = $4;
20050 HEAP32[$0 + 12 >> 2] = $1;
20051 global$0 = $2 + 16 | 0;
20052 }
20053
20054 function __subtf3($0, $1, $2, $3, $4, $5, $6, $7, $8) {
20055 var $9 = 0;
20056 $9 = global$0 - 16 | 0;
20057 global$0 = $9;
20058 __addtf3($9, $1, $2, $3, $4, $5, $6, $7, $8 ^ -2147483648);
20059 $1 = HEAP32[$9 + 4 >> 2];
20060 HEAP32[$0 >> 2] = HEAP32[$9 >> 2];
20061 HEAP32[$0 + 4 >> 2] = $1;
20062 $1 = HEAP32[$9 + 12 >> 2];
20063 HEAP32[$0 + 8 >> 2] = HEAP32[$9 + 8 >> 2];
20064 HEAP32[$0 + 12 >> 2] = $1;
20065 global$0 = $9 + 16 | 0;
20066 }
20067
20068 function scalbnl($0, $1, $2, $3, $4, $5) {
20069 var $6 = 0;
20070 $6 = global$0 - 80 | 0;
20071 global$0 = $6;
20072 label$1 : {
20073 if (($5 | 0) >= 16384) {
20074 __multf3($6 + 32 | 0, $1, $2, $3, $4, 0, 0, 0, 2147352576);
20075 $3 = HEAP32[$6 + 40 >> 2];
20076 $4 = HEAP32[$6 + 44 >> 2];
20077 $1 = HEAP32[$6 + 32 >> 2];
20078 $2 = HEAP32[$6 + 36 >> 2];
20079 if (($5 | 0) < 32767) {
20080 $5 = $5 + -16383 | 0;
20081 break label$1;
20082 }
20083 __multf3($6 + 16 | 0, $1, $2, $3, $4, 0, 0, 0, 2147352576);
20084 $5 = (($5 | 0) < 49149 ? $5 : 49149) + -32766 | 0;
20085 $3 = HEAP32[$6 + 24 >> 2];
20086 $4 = HEAP32[$6 + 28 >> 2];
20087 $1 = HEAP32[$6 + 16 >> 2];
20088 $2 = HEAP32[$6 + 20 >> 2];
20089 break label$1;
20090 }
20091 if (($5 | 0) > -16383) {
20092 break label$1
20093 }
20094 __multf3($6 - -64 | 0, $1, $2, $3, $4, 0, 0, 0, 65536);
20095 $3 = HEAP32[$6 + 72 >> 2];
20096 $4 = HEAP32[$6 + 76 >> 2];
20097 $1 = HEAP32[$6 + 64 >> 2];
20098 $2 = HEAP32[$6 + 68 >> 2];
20099 if (($5 | 0) > -32765) {
20100 $5 = $5 + 16382 | 0;
20101 break label$1;
20102 }
20103 __multf3($6 + 48 | 0, $1, $2, $3, $4, 0, 0, 0, 65536);
20104 $5 = (($5 | 0) > -49146 ? $5 : -49146) + 32764 | 0;
20105 $3 = HEAP32[$6 + 56 >> 2];
20106 $4 = HEAP32[$6 + 60 >> 2];
20107 $1 = HEAP32[$6 + 48 >> 2];
20108 $2 = HEAP32[$6 + 52 >> 2];
20109 }
20110 __multf3($6, $1, $2, $3, $4, 0, 0, 0, $5 + 16383 << 16);
20111 $1 = HEAP32[$6 + 12 >> 2];
20112 HEAP32[$0 + 8 >> 2] = HEAP32[$6 + 8 >> 2];
20113 HEAP32[$0 + 12 >> 2] = $1;
20114 $1 = HEAP32[$6 + 4 >> 2];
20115 HEAP32[$0 >> 2] = HEAP32[$6 >> 2];
20116 HEAP32[$0 + 4 >> 2] = $1;
20117 global$0 = $6 + 80 | 0;
20118 }
20119
20120 function __multi3($0, $1, $2, $3, $4) {
20121 var $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0;
20122 $5 = __wasm_i64_mul($1, $2, 0, 0);
20123 $6 = i64toi32_i32$HIGH_BITS;
20124 $7 = __wasm_i64_mul(0, 0, $3, $4);
20125 $5 = $5 + $7 | 0;
20126 $6 = i64toi32_i32$HIGH_BITS + $6 | 0;
20127 $9 = __wasm_i64_mul($4, 0, $2, 0);
20128 $8 = $5 + $9 | 0;
20129 $5 = i64toi32_i32$HIGH_BITS + ($5 >>> 0 < $7 >>> 0 ? $6 + 1 | 0 : $6) | 0;
20130 $6 = __wasm_i64_mul($3, 0, $1, 0);
20131 $10 = i64toi32_i32$HIGH_BITS;
20132 $7 = __wasm_i64_mul($2, 0, $3, 0);
20133 $3 = $10 + $7 | 0;
20134 $2 = $8 >>> 0 < $9 >>> 0 ? $5 + 1 | 0 : $5;
20135 $5 = i64toi32_i32$HIGH_BITS;
20136 $5 = $3 >>> 0 < $7 >>> 0 ? $5 + 1 | 0 : $5;
20137 $8 = $5 + $8 | 0;
20138 if ($8 >>> 0 < $5 >>> 0) {
20139 $2 = $2 + 1 | 0
20140 }
20141 $1 = __wasm_i64_mul($1, 0, $4, 0) + $3 | 0;
20142 $4 = i64toi32_i32$HIGH_BITS;
20143 $3 = $1 >>> 0 < $3 >>> 0 ? $4 + 1 | 0 : $4;
20144 $4 = $8 + $3 | 0;
20145 if ($4 >>> 0 < $3 >>> 0) {
20146 $2 = $2 + 1 | 0
20147 }
20148 HEAP32[$0 + 8 >> 2] = $4;
20149 HEAP32[$0 + 12 >> 2] = $2;
20150 HEAP32[$0 >> 2] = $6;
20151 HEAP32[$0 + 4 >> 2] = $1;
20152 }
20153
20154 function __divtf3($0, $1, $2, $3, $4, $5, $6, $7, $8) {
20155 var $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0, $23 = 0, $24 = 0, $25 = 0, $26 = 0, $27 = 0, $28 = 0, $29 = 0, $30 = 0, $31 = 0, $32 = 0, $33 = 0, $34 = 0, $35 = 0, $36 = 0, $37 = 0, $38 = 0, $39 = 0, $40 = 0, $41 = 0;
20156 $13 = global$0 - 192 | 0;
20157 global$0 = $13;
20158 $29 = $7;
20159 $32 = $8 & 65535;
20160 $16 = $3;
20161 $14 = $4 & 65535;
20162 $28 = ($4 ^ $8) & -2147483648;
20163 $17 = $8 >>> 16 & 32767;
20164 label$1 : {
20165 $19 = $4 >>> 16 & 32767;
20166 label$2 : {
20167 label$3 : {
20168 if ($19 + -1 >>> 0 <= 32765) {
20169 if ($17 + -1 >>> 0 < 32766) {
20170 break label$3
20171 }
20172 }
20173 $10 = $4 & 2147483647;
20174 $11 = $10;
20175 $9 = $3;
20176 if (!(!$9 & ($10 | 0) == 2147418112 ? !($1 | $2) : ($10 | 0) == 2147418112 & $9 >>> 0 < 0 | $10 >>> 0 < 2147418112)) {
20177 $33 = $3;
20178 $28 = $4 | 32768;
20179 break label$2;
20180 }
20181 $10 = $8 & 2147483647;
20182 $4 = $10;
20183 $3 = $7;
20184 if (!(!$3 & ($10 | 0) == 2147418112 ? !($5 | $6) : ($10 | 0) == 2147418112 & $3 >>> 0 < 0 | $10 >>> 0 < 2147418112)) {
20185 $33 = $7;
20186 $28 = $8 | 32768;
20187 $1 = $5;
20188 $2 = $6;
20189 break label$2;
20190 }
20191 if (!($1 | $9 | ($11 ^ 2147418112 | $2))) {
20192 if (!($3 | $5 | ($4 ^ 2147418112 | $6))) {
20193 $1 = 0;
20194 $2 = 0;
20195 $28 = 2147450880;
20196 break label$2;
20197 }
20198 $28 = $28 | 2147418112;
20199 $1 = 0;
20200 $2 = 0;
20201 break label$2;
20202 }
20203 if (!($3 | $5 | ($4 ^ 2147418112 | $6))) {
20204 $1 = 0;
20205 $2 = 0;
20206 break label$2;
20207 }
20208 if (!($1 | $9 | ($2 | $11))) {
20209 break label$1
20210 }
20211 if (!($3 | $5 | ($4 | $6))) {
20212 $28 = $28 | 2147418112;
20213 $1 = 0;
20214 $2 = 0;
20215 break label$2;
20216 }
20217 $10 = 0;
20218 if (($11 | 0) == 65535 | $11 >>> 0 < 65535) {
20219 $8 = $1;
20220 $3 = !($14 | $16);
20221 $7 = $3 << 6;
20222 $9 = Math_clz32($3 ? $1 : $16) + 32 | 0;
20223 $1 = Math_clz32($3 ? $2 : $14);
20224 $1 = $7 + (($1 | 0) == 32 ? $9 : $1) | 0;
20225 __ashlti3($13 + 176 | 0, $8, $2, $16, $14, $1 + -15 | 0);
20226 $10 = 16 - $1 | 0;
20227 $16 = HEAP32[$13 + 184 >> 2];
20228 $14 = HEAP32[$13 + 188 >> 2];
20229 $2 = HEAP32[$13 + 180 >> 2];
20230 $1 = HEAP32[$13 + 176 >> 2];
20231 }
20232 if ($4 >>> 0 > 65535) {
20233 break label$3
20234 }
20235 $3 = !($29 | $32);
20236 $4 = $3 << 6;
20237 $7 = Math_clz32($3 ? $5 : $29) + 32 | 0;
20238 $3 = Math_clz32($3 ? $6 : $32);
20239 $3 = $4 + (($3 | 0) == 32 ? $7 : $3) | 0;
20240 __ashlti3($13 + 160 | 0, $5, $6, $29, $32, $3 + -15 | 0);
20241 $10 = ($3 + $10 | 0) + -16 | 0;
20242 $29 = HEAP32[$13 + 168 >> 2];
20243 $32 = HEAP32[$13 + 172 >> 2];
20244 $5 = HEAP32[$13 + 160 >> 2];
20245 $6 = HEAP32[$13 + 164 >> 2];
20246 }
20247 $4 = $32 | 65536;
20248 $31 = $4;
20249 $38 = $29;
20250 $3 = $29;
20251 $12 = $4 << 15 | $3 >>> 17;
20252 $3 = $3 << 15 | $6 >>> 17;
20253 $7 = -102865788 - $3 | 0;
20254 $4 = $12;
20255 $9 = $4;
20256 $8 = 1963258675 - ($9 + (4192101508 < $3 >>> 0) | 0) | 0;
20257 __multi3($13 + 144 | 0, $3, $9, $7, $8);
20258 $9 = HEAP32[$13 + 152 >> 2];
20259 __multi3($13 + 128 | 0, 0 - $9 | 0, 0 - (HEAP32[$13 + 156 >> 2] + (0 < $9 >>> 0) | 0) | 0, $7, $8);
20260 $7 = HEAP32[$13 + 136 >> 2];
20261 $8 = $7 << 1 | HEAP32[$13 + 132 >> 2] >>> 31;
20262 $7 = HEAP32[$13 + 140 >> 2] << 1 | $7 >>> 31;
20263 __multi3($13 + 112 | 0, $8, $7, $3, $4);
20264 $9 = $7;
20265 $7 = HEAP32[$13 + 120 >> 2];
20266 __multi3($13 + 96 | 0, $8, $9, 0 - $7 | 0, 0 - (HEAP32[$13 + 124 >> 2] + (0 < $7 >>> 0) | 0) | 0);
20267 $7 = HEAP32[$13 + 104 >> 2];
20268 $11 = HEAP32[$13 + 108 >> 2] << 1 | $7 >>> 31;
20269 $8 = $7 << 1 | HEAP32[$13 + 100 >> 2] >>> 31;
20270 __multi3($13 + 80 | 0, $8, $11, $3, $4);
20271 $7 = HEAP32[$13 + 88 >> 2];
20272 __multi3($13 - -64 | 0, $8, $11, 0 - $7 | 0, 0 - (HEAP32[$13 + 92 >> 2] + (0 < $7 >>> 0) | 0) | 0);
20273 $7 = HEAP32[$13 + 72 >> 2];
20274 $8 = $7 << 1 | HEAP32[$13 + 68 >> 2] >>> 31;
20275 $7 = HEAP32[$13 + 76 >> 2] << 1 | $7 >>> 31;
20276 __multi3($13 + 48 | 0, $8, $7, $3, $4);
20277 $9 = $7;
20278 $7 = HEAP32[$13 + 56 >> 2];
20279 __multi3($13 + 32 | 0, $8, $9, 0 - $7 | 0, 0 - (HEAP32[$13 + 60 >> 2] + (0 < $7 >>> 0) | 0) | 0);
20280 $7 = HEAP32[$13 + 40 >> 2];
20281 $11 = HEAP32[$13 + 44 >> 2] << 1 | $7 >>> 31;
20282 $8 = $7 << 1 | HEAP32[$13 + 36 >> 2] >>> 31;
20283 __multi3($13 + 16 | 0, $8, $11, $3, $4);
20284 $7 = HEAP32[$13 + 24 >> 2];
20285 __multi3($13, $8, $11, 0 - $7 | 0, 0 - (HEAP32[$13 + 28 >> 2] + (0 < $7 >>> 0) | 0) | 0);
20286 $34 = ($19 - $17 | 0) + $10 | 0;
20287 $7 = HEAP32[$13 + 8 >> 2];
20288 $9 = HEAP32[$13 + 12 >> 2] << 1 | $7 >>> 31;
20289 $8 = $7 << 1;
20290 $10 = $9 + -1 | 0;
20291 $8 = (HEAP32[$13 + 4 >> 2] >>> 31 | $8) + -1 | 0;
20292 if (($8 | 0) != -1) {
20293 $10 = $10 + 1 | 0
20294 }
20295 $7 = $8;
20296 $9 = 0;
20297 $21 = $9;
20298 $20 = $4;
20299 $11 = 0;
20300 $12 = __wasm_i64_mul($7, $9, $4, $11);
20301 $4 = i64toi32_i32$HIGH_BITS;
20302 $19 = $4;
20303 $22 = $10;
20304 $17 = 0;
20305 $9 = $3;
20306 $7 = __wasm_i64_mul($10, $17, $9, 0);
20307 $3 = $7 + $12 | 0;
20308 $10 = i64toi32_i32$HIGH_BITS + $4 | 0;
20309 $10 = $3 >>> 0 < $7 >>> 0 ? $10 + 1 | 0 : $10;
20310 $7 = $3;
20311 $3 = $10;
20312 $15 = __wasm_i64_mul($8, $21, $9, $15);
20313 $4 = 0 + $15 | 0;
20314 $10 = $7;
20315 $9 = $10 + i64toi32_i32$HIGH_BITS | 0;
20316 $9 = $4 >>> 0 < $15 >>> 0 ? $9 + 1 | 0 : $9;
20317 $15 = $4;
20318 $4 = $9;
20319 $9 = ($10 | 0) == ($9 | 0) & $15 >>> 0 < $23 >>> 0 | $9 >>> 0 < $10 >>> 0;
20320 $10 = ($3 | 0) == ($19 | 0) & $10 >>> 0 < $12 >>> 0 | $3 >>> 0 < $19 >>> 0;
20321 $7 = $3;
20322 $3 = __wasm_i64_mul($22, $17, $20, $11) + $3 | 0;
20323 $11 = $10 + i64toi32_i32$HIGH_BITS | 0;
20324 $11 = $3 >>> 0 < $7 >>> 0 ? $11 + 1 | 0 : $11;
20325 $7 = $3;
20326 $3 = $9 + $3 | 0;
20327 $9 = $11;
20328 $26 = $3;
20329 $7 = $3 >>> 0 < $7 >>> 0 ? $9 + 1 | 0 : $9;
20330 $3 = $6;
20331 $24 = ($3 & 131071) << 15 | $5 >>> 17;
20332 $20 = __wasm_i64_mul($8, $21, $24, 0);
20333 $3 = i64toi32_i32$HIGH_BITS;
20334 $23 = $3;
20335 $10 = $5;
20336 $18 = $10 << 15 & -32768;
20337 $11 = __wasm_i64_mul($22, $17, $18, 0);
20338 $9 = $11 + $20 | 0;
20339 $10 = i64toi32_i32$HIGH_BITS + $3 | 0;
20340 $10 = $9 >>> 0 < $11 >>> 0 ? $10 + 1 | 0 : $10;
20341 $3 = $10;
20342 $25 = __wasm_i64_mul($8, $21, $18, $25);
20343 $18 = 0 + $25 | 0;
20344 $10 = $9 + i64toi32_i32$HIGH_BITS | 0;
20345 $10 = $18 >>> 0 < $25 >>> 0 ? $10 + 1 | 0 : $10;
20346 $10 = ($9 | 0) == ($10 | 0) & $18 >>> 0 < $30 >>> 0 | $10 >>> 0 < $9 >>> 0;
20347 $9 = ($3 | 0) == ($23 | 0) & $9 >>> 0 < $20 >>> 0 | $3 >>> 0 < $23 >>> 0;
20348 $12 = $3;
20349 $3 = __wasm_i64_mul($22, $17, $24, $27) + $3 | 0;
20350 $11 = $9 + i64toi32_i32$HIGH_BITS | 0;
20351 $11 = $3 >>> 0 < $12 >>> 0 ? $11 + 1 | 0 : $11;
20352 $9 = $3;
20353 $3 = $10 + $9 | 0;
20354 $12 = $3 >>> 0 < $9 >>> 0 ? $11 + 1 | 0 : $11;
20355 $10 = $3;
20356 $3 = $15 + $3 | 0;
20357 $9 = $12 + $4 | 0;
20358 $9 = $3 >>> 0 < $10 >>> 0 ? $9 + 1 | 0 : $9;
20359 $19 = $3;
20360 $10 = $7;
20361 $20 = $9;
20362 $3 = ($4 | 0) == ($9 | 0) & $3 >>> 0 < $15 >>> 0 | $9 >>> 0 < $4 >>> 0;
20363 $4 = $3 + $26 | 0;
20364 if ($4 >>> 0 < $3 >>> 0) {
20365 $10 = $10 + 1 | 0
20366 }
20367 $9 = $10;
20368 $3 = ($19 | 0) != 0 | ($20 | 0) != 0;
20369 $4 = $4 + $3 | 0;
20370 if ($4 >>> 0 < $3 >>> 0) {
20371 $9 = $9 + 1 | 0
20372 }
20373 $10 = $4;
20374 $4 = 0 - $10 | 0;
20375 $15 = 0;
20376 $7 = __wasm_i64_mul($4, $15, $8, $21);
20377 $3 = i64toi32_i32$HIGH_BITS;
20378 $23 = $3;
20379 $18 = __wasm_i64_mul($22, $17, $4, $15);
20380 $4 = i64toi32_i32$HIGH_BITS;
20381 $26 = $4;
20382 $24 = 0 - ((0 < $10 >>> 0) + $9 | 0) | 0;
20383 $9 = 0;
20384 $15 = __wasm_i64_mul($8, $21, $24, $9);
20385 $12 = $15 + $18 | 0;
20386 $10 = i64toi32_i32$HIGH_BITS + $4 | 0;
20387 $10 = $12 >>> 0 < $15 >>> 0 ? $10 + 1 | 0 : $10;
20388 $4 = $12;
20389 $15 = 0 + $7 | 0;
20390 $11 = $3 + $4 | 0;
20391 $11 = $15 >>> 0 < $27 >>> 0 ? $11 + 1 | 0 : $11;
20392 $12 = $15;
20393 $3 = $11;
20394 $11 = ($23 | 0) == ($3 | 0) & $12 >>> 0 < $7 >>> 0 | $3 >>> 0 < $23 >>> 0;
20395 $12 = ($10 | 0) == ($26 | 0) & $4 >>> 0 < $18 >>> 0 | $10 >>> 0 < $26 >>> 0;
20396 $4 = __wasm_i64_mul($22, $17, $24, $9) + $10 | 0;
20397 $9 = $12 + i64toi32_i32$HIGH_BITS | 0;
20398 $9 = $4 >>> 0 < $10 >>> 0 ? $9 + 1 | 0 : $9;
20399 $7 = $4;
20400 $4 = $11 + $4 | 0;
20401 if ($4 >>> 0 < $7 >>> 0) {
20402 $9 = $9 + 1 | 0
20403 }
20404 $24 = $4;
20405 $7 = $9;
20406 $4 = 0 - $19 | 0;
20407 $27 = 0 - ((0 < $19 >>> 0) + $20 | 0) | 0;
20408 $19 = 0;
20409 $26 = __wasm_i64_mul($27, $19, $8, $21);
20410 $18 = i64toi32_i32$HIGH_BITS;
20411 $20 = $4;
20412 $25 = 0;
20413 $9 = __wasm_i64_mul($4, $25, $22, $17);
20414 $4 = $9 + $26 | 0;
20415 $10 = i64toi32_i32$HIGH_BITS + $18 | 0;
20416 $11 = $4;
20417 $4 = $4 >>> 0 < $9 >>> 0 ? $10 + 1 | 0 : $10;
20418 $20 = __wasm_i64_mul($8, $21, $20, $25);
20419 $8 = 0 + $20 | 0;
20420 $9 = $11;
20421 $10 = $9 + i64toi32_i32$HIGH_BITS | 0;
20422 $10 = $8 >>> 0 < $20 >>> 0 ? $10 + 1 | 0 : $10;
20423 $10 = ($9 | 0) == ($10 | 0) & $8 >>> 0 < $30 >>> 0 | $10 >>> 0 < $9 >>> 0;
20424 $9 = ($4 | 0) == ($18 | 0) & $9 >>> 0 < $26 >>> 0 | $4 >>> 0 < $18 >>> 0;
20425 $8 = $4;
20426 $4 = __wasm_i64_mul($27, $19, $22, $17) + $4 | 0;
20427 $12 = $9 + i64toi32_i32$HIGH_BITS | 0;
20428 $12 = $4 >>> 0 < $8 >>> 0 ? $12 + 1 | 0 : $12;
20429 $8 = $4;
20430 $4 = $10 + $4 | 0;
20431 $9 = $12;
20432 $9 = $4 >>> 0 < $8 >>> 0 ? $9 + 1 | 0 : $9;
20433 $8 = $4;
20434 $4 = $15 + $4 | 0;
20435 $9 = $9 + $3 | 0;
20436 $9 = $4 >>> 0 < $8 >>> 0 ? $9 + 1 | 0 : $9;
20437 $8 = $4;
20438 $10 = $7;
20439 $4 = $9;
20440 $3 = ($3 | 0) == ($9 | 0) & $8 >>> 0 < $15 >>> 0 | $9 >>> 0 < $3 >>> 0;
20441 $7 = $3 + $24 | 0;
20442 if ($7 >>> 0 < $3 >>> 0) {
20443 $10 = $10 + 1 | 0
20444 }
20445 $3 = $7;
20446 $9 = $10;
20447 $12 = $3;
20448 $11 = $4 + -1 | 0;
20449 $3 = $8 + -2 | 0;
20450 if ($3 >>> 0 < 4294967294) {
20451 $11 = $11 + 1 | 0
20452 }
20453 $7 = $3;
20454 $10 = $3;
20455 $3 = $11;
20456 $4 = ($4 | 0) == ($3 | 0) & $10 >>> 0 < $8 >>> 0 | $3 >>> 0 < $4 >>> 0;
20457 $8 = $12 + $4 | 0;
20458 if ($8 >>> 0 < $4 >>> 0) {
20459 $9 = $9 + 1 | 0
20460 }
20461 $4 = $8 + -1 | 0;
20462 $10 = $9 + -1 | 0;
20463 $10 = ($4 | 0) != -1 ? $10 + 1 | 0 : $10;
20464 $8 = 0;
20465 $22 = $8;
20466 $17 = $4;
20467 $9 = $16;
20468 $18 = $9 << 2 | $2 >>> 30;
20469 $24 = 0;
20470 $12 = __wasm_i64_mul($4, $8, $18, $24);
20471 $8 = i64toi32_i32$HIGH_BITS;
20472 $15 = $8;
20473 $11 = $8;
20474 $8 = $2;
20475 $27 = ($8 & 1073741823) << 2 | $1 >>> 30;
20476 $25 = $10;
20477 $8 = 0;
20478 $9 = __wasm_i64_mul($27, 0, $10, $8);
20479 $4 = $9 + $12 | 0;
20480 $11 = i64toi32_i32$HIGH_BITS + $11 | 0;
20481 $11 = $4 >>> 0 < $9 >>> 0 ? $11 + 1 | 0 : $11;
20482 $9 = $4;
20483 $20 = $11;
20484 $23 = ($15 | 0) == ($11 | 0) & $9 >>> 0 < $12 >>> 0 | $11 >>> 0 < $15 >>> 0;
20485 $12 = $11;
20486 $11 = 0;
20487 $15 = $11;
20488 $10 = 0;
20489 $26 = $3;
20490 $30 = (($14 & 1073741823) << 2 | $16 >>> 30) & -262145 | 262144;
20491 $4 = __wasm_i64_mul($3, $11, $30, 0);
20492 $3 = $4 + $9 | 0;
20493 $12 = i64toi32_i32$HIGH_BITS + $12 | 0;
20494 $12 = $3 >>> 0 < $4 >>> 0 ? $12 + 1 | 0 : $12;
20495 $16 = $3;
20496 $4 = $12;
20497 $3 = ($20 | 0) == ($4 | 0) & $3 >>> 0 < $9 >>> 0 | $4 >>> 0 < $20 >>> 0;
20498 $9 = $3 + $23 | 0;
20499 if ($9 >>> 0 < $3 >>> 0) {
20500 $10 = 1
20501 }
20502 $11 = __wasm_i64_mul($25, $8, $30, $35);
20503 $3 = $11 + $9 | 0;
20504 $9 = i64toi32_i32$HIGH_BITS + $10 | 0;
20505 $10 = $3 >>> 0 < $11 >>> 0 ? $9 + 1 | 0 : $9;
20506 $11 = __wasm_i64_mul($17, $22, $30, $35);
20507 $9 = i64toi32_i32$HIGH_BITS;
20508 $2 = $3;
20509 $14 = __wasm_i64_mul($18, $24, $25, $8);
20510 $3 = $14 + $11 | 0;
20511 $12 = i64toi32_i32$HIGH_BITS + $9 | 0;
20512 $12 = $3 >>> 0 < $14 >>> 0 ? $12 + 1 | 0 : $12;
20513 $14 = $3;
20514 $3 = $12;
20515 $12 = ($9 | 0) == ($3 | 0) & $14 >>> 0 < $11 >>> 0 | $3 >>> 0 < $9 >>> 0;
20516 $11 = $2 + $3 | 0;
20517 $10 = $10 + $12 | 0;
20518 $9 = $11;
20519 $12 = $9 >>> 0 < $3 >>> 0 ? $10 + 1 | 0 : $10;
20520 $2 = $9;
20521 $11 = $4 + $14 | 0;
20522 $10 = 0;
20523 $3 = $10 + $16 | 0;
20524 if ($3 >>> 0 < $10 >>> 0) {
20525 $11 = $11 + 1 | 0
20526 }
20527 $14 = $3;
20528 $9 = $3;
20529 $3 = $11;
20530 $4 = ($4 | 0) == ($3 | 0) & $9 >>> 0 < $16 >>> 0 | $3 >>> 0 < $4 >>> 0;
20531 $9 = $2 + $4 | 0;
20532 if ($9 >>> 0 < $4 >>> 0) {
20533 $12 = $12 + 1 | 0
20534 }
20535 $39 = $9;
20536 $4 = $14;
20537 $10 = $3;
20538 $16 = __wasm_i64_mul($27, $19, $26, $15);
20539 $11 = i64toi32_i32$HIGH_BITS;
20540 $20 = $7;
20541 $23 = __wasm_i64_mul($7, 0, $18, $24);
20542 $7 = $23 + $16 | 0;
20543 $9 = i64toi32_i32$HIGH_BITS + $11 | 0;
20544 $9 = $7 >>> 0 < $23 >>> 0 ? $9 + 1 | 0 : $9;
20545 $21 = $7;
20546 $7 = $9;
20547 $16 = ($11 | 0) == ($9 | 0) & $21 >>> 0 < $16 >>> 0 | $9 >>> 0 < $11 >>> 0;
20548 $11 = $9;
20549 $40 = $4;
20550 $9 = 0;
20551 $41 = $16;
20552 $36 = $1 << 2 & -4;
20553 $2 = 0;
20554 $16 = __wasm_i64_mul($17, $22, $36, $2);
20555 $4 = $16 + $21 | 0;
20556 $11 = i64toi32_i32$HIGH_BITS + $11 | 0;
20557 $11 = $4 >>> 0 < $16 >>> 0 ? $11 + 1 | 0 : $11;
20558 $23 = $4;
20559 $16 = $4;
20560 $4 = $11;
20561 $7 = ($7 | 0) == ($4 | 0) & $16 >>> 0 < $21 >>> 0 | $4 >>> 0 < $7 >>> 0;
20562 $11 = $41 + $7 | 0;
20563 if ($11 >>> 0 < $7 >>> 0) {
20564 $9 = 1
20565 }
20566 $7 = $40 + $11 | 0;
20567 $10 = $9 + $10 | 0;
20568 $10 = $7 >>> 0 < $11 >>> 0 ? $10 + 1 | 0 : $10;
20569 $16 = $7;
20570 $11 = $12;
20571 $7 = $10;
20572 $3 = ($3 | 0) == ($10 | 0) & $16 >>> 0 < $14 >>> 0 | $10 >>> 0 < $3 >>> 0;
20573 $9 = $3 + $39 | 0;
20574 if ($9 >>> 0 < $3 >>> 0) {
20575 $11 = $11 + 1 | 0
20576 }
20577 $40 = $9;
20578 $14 = $16;
20579 $21 = $7;
20580 $39 = __wasm_i64_mul($25, $8, $36, $2);
20581 $25 = i64toi32_i32$HIGH_BITS;
20582 $8 = __wasm_i64_mul($30, $35, $20, $37);
20583 $3 = $8 + $39 | 0;
20584 $12 = i64toi32_i32$HIGH_BITS + $25 | 0;
20585 $12 = $3 >>> 0 < $8 >>> 0 ? $12 + 1 | 0 : $12;
20586 $30 = $3;
20587 $9 = __wasm_i64_mul($18, $24, $26, $15);
20588 $3 = $3 + $9 | 0;
20589 $8 = $12;
20590 $10 = $8 + i64toi32_i32$HIGH_BITS | 0;
20591 $10 = $3 >>> 0 < $9 >>> 0 ? $10 + 1 | 0 : $10;
20592 $18 = $3;
20593 $12 = __wasm_i64_mul($17, $22, $27, $19);
20594 $3 = $3 + $12 | 0;
20595 $9 = i64toi32_i32$HIGH_BITS + $10 | 0;
20596 $17 = $3;
20597 $9 = $3 >>> 0 < $12 >>> 0 ? $9 + 1 | 0 : $9;
20598 $22 = 0;
20599 $12 = $11;
20600 $3 = $9;
20601 $9 = ($9 | 0) == ($10 | 0) & $17 >>> 0 < $18 >>> 0 | $9 >>> 0 < $10 >>> 0;
20602 $11 = ($8 | 0) == ($25 | 0) & $30 >>> 0 < $39 >>> 0 | $8 >>> 0 < $25 >>> 0;
20603 $8 = ($8 | 0) == ($10 | 0) & $18 >>> 0 < $30 >>> 0 | $10 >>> 0 < $8 >>> 0;
20604 $10 = $11 + $8 | 0;
20605 $10 >>> 0 < $8 >>> 0;
20606 $8 = $9 + $10 | 0;
20607 $10 = $8;
20608 $9 = $3 | 0;
20609 $8 = $9 + $14 | 0;
20610 $10 = ($10 | $22) + $21 | 0;
20611 $10 = $8 >>> 0 < $9 >>> 0 ? $10 + 1 | 0 : $10;
20612 $21 = $8;
20613 $14 = $10;
20614 $7 = ($7 | 0) == ($10 | 0) & $8 >>> 0 < $16 >>> 0 | $10 >>> 0 < $7 >>> 0;
20615 $8 = $7 + $40 | 0;
20616 if ($8 >>> 0 < $7 >>> 0) {
20617 $12 = $12 + 1 | 0
20618 }
20619 $24 = $8;
20620 $8 = $12;
20621 $12 = $21;
20622 $16 = $14;
20623 $22 = $23;
20624 $26 = __wasm_i64_mul($26, $15, $36, $2);
20625 $15 = i64toi32_i32$HIGH_BITS;
20626 $9 = __wasm_i64_mul($27, $19, $20, $37);
20627 $7 = $9 + $26 | 0;
20628 $11 = i64toi32_i32$HIGH_BITS + $15 | 0;
20629 $11 = $7 >>> 0 < $9 >>> 0 ? $11 + 1 | 0 : $11;
20630 $10 = $11;
20631 $19 = $10;
20632 $11 = 0;
20633 $9 = ($10 | 0) == ($15 | 0) & $7 >>> 0 < $26 >>> 0 | $10 >>> 0 < $15 >>> 0;
20634 $7 = $10 + $22 | 0;
20635 $10 = ($9 | $11) + $4 | 0;
20636 $10 = $7 >>> 0 < $19 >>> 0 ? $10 + 1 | 0 : $10;
20637 $19 = $7;
20638 $9 = $7;
20639 $7 = $10;
20640 $9 = ($4 | 0) == ($10 | 0) & $9 >>> 0 < $22 >>> 0 | $10 >>> 0 < $4 >>> 0;
20641 $23 = $12;
20642 $4 = $9;
20643 $9 = $10 + $17 | 0;
20644 $12 = 0;
20645 $3 = $12 + $19 | 0;
20646 if ($3 >>> 0 < $12 >>> 0) {
20647 $9 = $9 + 1 | 0
20648 }
20649 $3 = ($7 | 0) == ($9 | 0) & $3 >>> 0 < $19 >>> 0 | $9 >>> 0 < $7 >>> 0;
20650 $4 = $4 + $3 | 0;
20651 if ($4 >>> 0 < $3 >>> 0) {
20652 $11 = 1
20653 }
20654 $3 = $23 + $4 | 0;
20655 $12 = $11 + $16 | 0;
20656 $7 = $3;
20657 $9 = $8;
20658 $12 = $3 >>> 0 < $4 >>> 0 ? $12 + 1 | 0 : $12;
20659 $8 = $12;
20660 $3 = ($14 | 0) == ($8 | 0) & $3 >>> 0 < $21 >>> 0 | $8 >>> 0 < $14 >>> 0;
20661 $4 = $3 + $24 | 0;
20662 if ($4 >>> 0 < $3 >>> 0) {
20663 $9 = $9 + 1 | 0
20664 }
20665 $3 = $4;
20666 $4 = $9;
20667 label$12 : {
20668 if (($9 | 0) == 131071 | $9 >>> 0 < 131071) {
20669 $22 = 0;
20670 $14 = $5;
20671 $18 = 0;
20672 $10 = __wasm_i64_mul($7, $22, $14, $18);
20673 $11 = i64toi32_i32$HIGH_BITS;
20674 $9 = $1 << 17;
20675 $1 = 0;
20676 $2 = ($10 | 0) != 0 | ($11 | 0) != 0;
20677 $16 = $1 - $2 | 0;
20678 $30 = $9 - ($1 >>> 0 < $2 >>> 0) | 0;
20679 $19 = 0 - $10 | 0;
20680 $15 = 0 - ((0 < $10 >>> 0) + $11 | 0) | 0;
20681 $2 = 0;
20682 $24 = __wasm_i64_mul($8, $2, $14, $18);
20683 $1 = i64toi32_i32$HIGH_BITS;
20684 $27 = $1;
20685 $17 = 0;
20686 $10 = __wasm_i64_mul($7, $22, $6, $17);
20687 $9 = $10 + $24 | 0;
20688 $11 = i64toi32_i32$HIGH_BITS + $1 | 0;
20689 $11 = $9 >>> 0 < $10 >>> 0 ? $11 + 1 | 0 : $11;
20690 $1 = $9;
20691 $10 = $9;
20692 $20 = 0;
20693 $9 = $20;
20694 $23 = $10;
20695 $9 = ($10 | 0) == ($15 | 0) & $19 >>> 0 < $9 >>> 0 | $15 >>> 0 < $10 >>> 0;
20696 $21 = $16 - $9 | 0;
20697 $30 = $30 - ($16 >>> 0 < $9 >>> 0) | 0;
20698 $9 = __wasm_i64_mul($3, 0, $14, $18);
20699 $10 = i64toi32_i32$HIGH_BITS;
20700 $14 = __wasm_i64_mul($7, $22, $29, 0);
20701 $9 = $14 + $9 | 0;
20702 $12 = i64toi32_i32$HIGH_BITS + $10 | 0;
20703 $12 = $9 >>> 0 < $14 >>> 0 ? $12 + 1 | 0 : $12;
20704 $14 = __wasm_i64_mul($8, $2, $6, $17);
20705 $9 = $14 + $9 | 0;
20706 $10 = i64toi32_i32$HIGH_BITS + $12 | 0;
20707 $10 = $9 >>> 0 < $14 >>> 0 ? $10 + 1 | 0 : $10;
20708 $12 = $10;
20709 $10 = ($11 | 0) == ($27 | 0) & $1 >>> 0 < $24 >>> 0 | $11 >>> 0 < $27 >>> 0;
20710 $1 = $11 + $9 | 0;
20711 $10 = $10 + $12 | 0;
20712 $10 = $1 >>> 0 < $11 >>> 0 ? $10 + 1 | 0 : $10;
20713 $11 = $1;
20714 $1 = $10;
20715 $9 = __wasm_i64_mul($7, $8, $31, 0);
20716 $14 = i64toi32_i32$HIGH_BITS;
20717 $16 = $11;
20718 $11 = __wasm_i64_mul($5, $6, $4, 0);
20719 $10 = $11 + $9 | 0;
20720 $9 = i64toi32_i32$HIGH_BITS + $14 | 0;
20721 $9 = $10 >>> 0 < $11 >>> 0 ? $9 + 1 | 0 : $9;
20722 $12 = __wasm_i64_mul($3, $4, $6, $17);
20723 $11 = $12 + $10 | 0;
20724 $9 = __wasm_i64_mul($8, $2, $29, $32);
20725 $2 = $9 + $11 | 0;
20726 $9 = $2;
20727 $10 = 0;
20728 $2 = $16 + $10 | 0;
20729 $9 = $1 + $9 | 0;
20730 $1 = $2;
20731 $16 = $21 - $1 | 0;
20732 $2 = $30 - (($21 >>> 0 < $1 >>> 0) + ($1 >>> 0 < $10 >>> 0 ? $9 + 1 | 0 : $9) | 0) | 0;
20733 $34 = $34 + -1 | 0;
20734 $29 = $19 - $20 | 0;
20735 $1 = $15 - (($19 >>> 0 < $20 >>> 0) + $23 | 0) | 0;
20736 break label$12;
20737 }
20738 $17 = $8 >>> 1 | 0;
20739 $11 = 0;
20740 $12 = $1 << 16;
20741 $10 = $3 << 31;
20742 $7 = ($8 & 1) << 31 | $7 >>> 1;
20743 $8 = $8 >>> 1 | $10;
20744 $27 = 0;
20745 $25 = 0;
20746 $1 = __wasm_i64_mul($7, $27, $5, $25);
20747 $9 = i64toi32_i32$HIGH_BITS;
20748 $10 = $9;
20749 $9 = ($1 | 0) != 0 | ($9 | 0) != 0;
20750 $14 = $2 - $9 | 0;
20751 $37 = $12 - ($2 >>> 0 < $9 >>> 0) | 0;
20752 $21 = 0 - $1 | 0;
20753 $22 = 0 - ((0 < $1 >>> 0) + $10 | 0) | 0;
20754 $12 = $22;
20755 $15 = 0;
20756 $20 = __wasm_i64_mul($7, $27, $6, $15);
20757 $1 = i64toi32_i32$HIGH_BITS;
20758 $35 = $1;
20759 $23 = $17 | $3 << 31;
20760 $36 = $4 << 31 | $3 >>> 1 | $11;
20761 $10 = $23;
20762 $17 = __wasm_i64_mul($10, 0, $5, $25);
20763 $2 = $17 + $20 | 0;
20764 $9 = i64toi32_i32$HIGH_BITS + $1 | 0;
20765 $9 = $2 >>> 0 < $17 >>> 0 ? $9 + 1 | 0 : $9;
20766 $1 = $9;
20767 $9 = $2;
20768 $26 = $9;
20769 $18 = 0;
20770 $9 = ($9 | 0) == ($12 | 0) & $21 >>> 0 < $18 >>> 0 | $12 >>> 0 < $9 >>> 0;
20771 $24 = $14 - $9 | 0;
20772 $37 = $37 - ($14 >>> 0 < $9 >>> 0) | 0;
20773 $10 = __wasm_i64_mul($6, $15, $10, $11);
20774 $11 = i64toi32_i32$HIGH_BITS;
20775 $9 = $4;
20776 $12 = $9 >>> 1 | 0;
20777 $17 = ($9 & 1) << 31 | $3 >>> 1;
20778 $14 = $12;
20779 $12 = __wasm_i64_mul($17, 0, $5, $25);
20780 $9 = $12 + $10 | 0;
20781 $10 = i64toi32_i32$HIGH_BITS + $11 | 0;
20782 $10 = $9 >>> 0 < $12 >>> 0 ? $10 + 1 | 0 : $10;
20783 $12 = __wasm_i64_mul($7, $27, $29, 0);
20784 $11 = $12 + $9 | 0;
20785 $9 = i64toi32_i32$HIGH_BITS + $10 | 0;
20786 $10 = $11;
20787 $11 = $10 >>> 0 < $12 >>> 0 ? $9 + 1 | 0 : $9;
20788 $9 = ($1 | 0) == ($35 | 0) & $2 >>> 0 < $20 >>> 0 | $1 >>> 0 < $35 >>> 0;
20789 $2 = $1;
20790 $1 = $1 + $10 | 0;
20791 $11 = $9 + $11 | 0;
20792 $9 = $1;
20793 $1 = $9 >>> 0 < $2 >>> 0 ? $11 + 1 | 0 : $11;
20794 $2 = __wasm_i64_mul($7, $8, $31, 0);
20795 $10 = i64toi32_i32$HIGH_BITS;
20796 $11 = $9;
20797 $3 = __wasm_i64_mul($5, $6, $4 >>> 1 | 0, 0);
20798 $2 = $3 + $2 | 0;
20799 $9 = i64toi32_i32$HIGH_BITS + $10 | 0;
20800 $9 = $2 >>> 0 < $3 >>> 0 ? $9 + 1 | 0 : $9;
20801 $3 = __wasm_i64_mul($6, $15, $17, $14);
20802 $2 = $3 + $2 | 0;
20803 $9 = i64toi32_i32$HIGH_BITS + $9 | 0;
20804 $3 = __wasm_i64_mul($23, $36, $29, $32);
20805 $2 = $3 + $2 | 0;
20806 $9 = $2;
20807 $3 = 0;
20808 $2 = $11 + $3 | 0;
20809 $10 = $1 + $9 | 0;
20810 $1 = $2;
20811 $16 = $24 - $1 | 0;
20812 $2 = $37 - (($24 >>> 0 < $1 >>> 0) + ($1 >>> 0 < $3 >>> 0 ? $10 + 1 | 0 : $10) | 0) | 0;
20813 $3 = $17;
20814 $4 = $14;
20815 $29 = $21 - $18 | 0;
20816 $1 = $22 - (($21 >>> 0 < $18 >>> 0) + $26 | 0) | 0;
20817 }
20818 if (($34 | 0) >= 16384) {
20819 $28 = $28 | 2147418112;
20820 $1 = 0;
20821 $2 = 0;
20822 break label$2;
20823 }
20824 $11 = $34 + 16383 | 0;
20825 if (($34 | 0) <= -16383) {
20826 label$16 : {
20827 if ($11) {
20828 break label$16
20829 }
20830 $11 = $8;
20831 $14 = $29;
20832 $12 = $1 << 1 | $14 >>> 31;
20833 $9 = $14 << 1;
20834 $6 = ($6 | 0) == ($12 | 0) & $9 >>> 0 > $5 >>> 0 | $12 >>> 0 > $6 >>> 0;
20835 $9 = $4 & 65535;
20836 $5 = $16;
20837 $12 = $2 << 1 | $5 >>> 31;
20838 $2 = $5 << 1 | $1 >>> 31;
20839 $4 = $2;
20840 $1 = $12;
20841 $1 = ($4 | 0) == ($38 | 0) & ($1 | 0) == ($31 | 0) ? $6 : ($31 | 0) == ($1 | 0) & $4 >>> 0 > $38 >>> 0 | $1 >>> 0 > $31 >>> 0;
20842 $2 = $1 + $7 | 0;
20843 if ($2 >>> 0 < $1 >>> 0) {
20844 $11 = $11 + 1 | 0
20845 }
20846 $1 = $2;
20847 $4 = $1;
20848 $2 = $11;
20849 $4 = $3 + (($8 | 0) == ($11 | 0) & $4 >>> 0 < $7 >>> 0 | $11 >>> 0 < $8 >>> 0) | 0;
20850 if ($4 >>> 0 < $3 >>> 0) {
20851 $9 = $9 + 1 | 0
20852 }
20853 $3 = $9;
20854 if (!($9 & 65536)) {
20855 break label$16
20856 }
20857 $33 = $4 | $33;
20858 $28 = $3 | $28;
20859 break label$2;
20860 }
20861 $1 = 0;
20862 $2 = 0;
20863 break label$2;
20864 }
20865 $10 = $8;
20866 $4 = $4 & 65535;
20867 $14 = $29;
20868 $9 = $1 << 1 | $14 >>> 31;
20869 $14 = $14 << 1;
20870 $6 = ($6 | 0) == ($9 | 0) & $14 >>> 0 >= $5 >>> 0 | $9 >>> 0 > $6 >>> 0;
20871 $5 = $16;
20872 $9 = $2 << 1 | $5 >>> 31;
20873 $2 = $5 << 1 | $1 >>> 31;
20874 $1 = ($2 | 0) == ($38 | 0) & ($9 | 0) == ($31 | 0) ? $6 : ($31 | 0) == ($9 | 0) & $2 >>> 0 >= $38 >>> 0 | $9 >>> 0 > $31 >>> 0;
20875 $2 = $1 + $7 | 0;
20876 if ($2 >>> 0 < $1 >>> 0) {
20877 $10 = $10 + 1 | 0
20878 }
20879 $1 = $2;
20880 $2 = $10;
20881 $5 = $3;
20882 $3 = (($8 | 0) == ($10 | 0) & $1 >>> 0 < $7 >>> 0 | $10 >>> 0 < $8 >>> 0) + $3 | 0;
20883 $10 = $11 << 16 | $4;
20884 $33 = $3 | $33;
20885 $28 = $28 | ($3 >>> 0 < $5 >>> 0 ? $10 + 1 | 0 : $10);
20886 }
20887 HEAP32[$0 >> 2] = $1;
20888 HEAP32[$0 + 4 >> 2] = $2;
20889 HEAP32[$0 + 8 >> 2] = $33;
20890 HEAP32[$0 + 12 >> 2] = $28;
20891 global$0 = $13 + 192 | 0;
20892 return;
20893 }
20894 HEAP32[$0 >> 2] = 0;
20895 HEAP32[$0 + 4 >> 2] = 0;
20896 $1 = !($3 | $5 | ($4 | $6));
20897 HEAP32[$0 + 8 >> 2] = $1 ? 0 : $33;
20898 HEAP32[$0 + 12 >> 2] = $1 ? 2147450880 : $28;
20899 global$0 = $13 + 192 | 0;
20900 }
20901
20902 function __fpclassifyl($0, $1, $2, $3) {
20903 var $4 = 0, $5 = 0;
20904 $5 = $3 & 65535;
20905 $3 = $3 >>> 16 & 32767;
20906 label$1 : {
20907 if (($3 | 0) != 32767) {
20908 $4 = 4;
20909 if ($3) {
20910 break label$1
20911 }
20912 return $0 | $2 | ($1 | $5) ? 3 : 2;
20913 }
20914 $4 = !($0 | $2 | ($1 | $5));
20915 }
20916 return $4;
20917 }
20918
20919 function fmodl($0, $1, $2, $3, $4, $5, $6, $7, $8) {
20920 var $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0;
20921 $9 = global$0 - 128 | 0;
20922 global$0 = $9;
20923 label$1 : {
20924 label$2 : {
20925 label$3 : {
20926 if (!__letf2($5, $6, $7, $8, 0, 0, 0, 0)) {
20927 break label$3
20928 }
20929 $10 = __fpclassifyl($5, $6, $7, $8);
20930 $19 = $4 >>> 16 | 0;
20931 $14 = $19 & 32767;
20932 if (($14 | 0) == 32767) {
20933 break label$3
20934 }
20935 if ($10) {
20936 break label$2
20937 }
20938 }
20939 __multf3($9 + 16 | 0, $1, $2, $3, $4, $5, $6, $7, $8);
20940 $4 = HEAP32[$9 + 16 >> 2];
20941 $3 = HEAP32[$9 + 20 >> 2];
20942 $2 = HEAP32[$9 + 24 >> 2];
20943 $1 = HEAP32[$9 + 28 >> 2];
20944 __divtf3($9, $4, $3, $2, $1, $4, $3, $2, $1);
20945 $3 = HEAP32[$9 + 8 >> 2];
20946 $4 = HEAP32[$9 + 12 >> 2];
20947 $7 = HEAP32[$9 >> 2];
20948 $8 = HEAP32[$9 + 4 >> 2];
20949 break label$1;
20950 }
20951 $11 = $4 & 65535 | $14 << 16;
20952 $12 = $11;
20953 $13 = $3;
20954 $15 = $7;
20955 $18 = $8 >>> 16 & 32767;
20956 $10 = $8 & 65535 | $18 << 16;
20957 if ((__letf2($1, $2, $13, $12, $5, $6, $7, $10) | 0) <= 0) {
20958 if (__letf2($1, $2, $13, $12, $5, $6, $15, $10)) {
20959 $7 = $1;
20960 $8 = $2;
20961 break label$1;
20962 }
20963 __multf3($9 + 112 | 0, $1, $2, $3, $4, 0, 0, 0, 0);
20964 $3 = HEAP32[$9 + 120 >> 2];
20965 $4 = HEAP32[$9 + 124 >> 2];
20966 $7 = HEAP32[$9 + 112 >> 2];
20967 $8 = HEAP32[$9 + 116 >> 2];
20968 break label$1;
20969 }
20970 if ($14) {
20971 $8 = $2;
20972 $7 = $1;
20973 } else {
20974 __multf3($9 + 96 | 0, $1, $2, $13, $12, 0, 0, 0, 1081540608);
20975 $7 = HEAP32[$9 + 108 >> 2];
20976 $12 = $7;
20977 $13 = HEAP32[$9 + 104 >> 2];
20978 $14 = ($7 >>> 16 | 0) + -120 | 0;
20979 $8 = HEAP32[$9 + 100 >> 2];
20980 $7 = HEAP32[$9 + 96 >> 2];
20981 }
20982 if (!$18) {
20983 __multf3($9 + 80 | 0, $5, $6, $15, $10, 0, 0, 0, 1081540608);
20984 $5 = HEAP32[$9 + 92 >> 2];
20985 $10 = $5;
20986 $15 = HEAP32[$9 + 88 >> 2];
20987 $18 = ($10 >>> 16 | 0) + -120 | 0;
20988 $6 = HEAP32[$9 + 84 >> 2];
20989 $5 = HEAP32[$9 + 80 >> 2];
20990 }
20991 $21 = $15;
20992 $11 = $15;
20993 $15 = $13 - $11 | 0;
20994 $12 = $12 & 65535 | 65536;
20995 $20 = $10 & 65535 | 65536;
20996 $10 = ($6 | 0) == ($8 | 0) & $7 >>> 0 < $5 >>> 0 | $8 >>> 0 < $6 >>> 0;
20997 $11 = ($12 - ($20 + ($13 >>> 0 < $11 >>> 0) | 0) | 0) - ($15 >>> 0 < $10 >>> 0) | 0;
20998 $17 = $15 - $10 | 0;
20999 $16 = ($11 | 0) > -1 ? 1 : 0;
21000 $15 = $7 - $5 | 0;
21001 $10 = $8 - (($7 >>> 0 < $5 >>> 0) + $6 | 0) | 0;
21002 if (($14 | 0) > ($18 | 0)) {
21003 while (1) {
21004 label$11 : {
21005 if ($16 & 1) {
21006 if (!($15 | $17 | ($10 | $11))) {
21007 __multf3($9 + 32 | 0, $1, $2, $3, $4, 0, 0, 0, 0);
21008 $3 = HEAP32[$9 + 40 >> 2];
21009 $4 = HEAP32[$9 + 44 >> 2];
21010 $7 = HEAP32[$9 + 32 >> 2];
21011 $8 = HEAP32[$9 + 36 >> 2];
21012 break label$1;
21013 }
21014 $7 = $17;
21015 $16 = $11 << 1 | $7 >>> 31;
21016 $17 = $7 << 1;
21017 $11 = $16;
21018 $16 = 0;
21019 $7 = $10 >>> 31 | 0;
21020 break label$11;
21021 }
21022 $11 = 0;
21023 $10 = $8;
21024 $17 = $8 >>> 31 | 0;
21025 $15 = $7;
21026 $7 = $13;
21027 $16 = $12 << 1 | $7 >>> 31;
21028 $7 = $7 << 1;
21029 }
21030 $13 = $7 | $17;
21031 $8 = $13;
21032 $7 = $21;
21033 $17 = $8 - $7 | 0;
21034 $12 = $11 | $16;
21035 $11 = $12 - (($8 >>> 0 < $7 >>> 0) + $20 | 0) | 0;
21036 $7 = $15;
21037 $16 = $10 << 1 | $7 >>> 31;
21038 $7 = $7 << 1;
21039 $8 = $16;
21040 $10 = ($6 | 0) == ($8 | 0) & $7 >>> 0 < $5 >>> 0 | $8 >>> 0 < $6 >>> 0;
21041 $11 = $11 - ($17 >>> 0 < $10 >>> 0) | 0;
21042 $17 = $17 - $10 | 0;
21043 $16 = ($11 | 0) > -1 ? 1 : 0;
21044 $15 = $7 - $5 | 0;
21045 $10 = $8 - (($7 >>> 0 < $5 >>> 0) + $6 | 0) | 0;
21046 $14 = $14 + -1 | 0;
21047 if (($14 | 0) > ($18 | 0)) {
21048 continue
21049 }
21050 break;
21051 };
21052 $14 = $18;
21053 }
21054 label$14 : {
21055 if (!$16) {
21056 break label$14
21057 }
21058 $7 = $15;
21059 $13 = $17;
21060 $8 = $10;
21061 $12 = $11;
21062 if ($7 | $13 | ($8 | $12)) {
21063 break label$14
21064 }
21065 __multf3($9 + 48 | 0, $1, $2, $3, $4, 0, 0, 0, 0);
21066 $3 = HEAP32[$9 + 56 >> 2];
21067 $4 = HEAP32[$9 + 60 >> 2];
21068 $7 = HEAP32[$9 + 48 >> 2];
21069 $8 = HEAP32[$9 + 52 >> 2];
21070 break label$1;
21071 }
21072 if (($12 | 0) == 65535 | $12 >>> 0 < 65535) {
21073 while (1) {
21074 $3 = $8 >>> 31 | 0;
21075 $1 = 0;
21076 $14 = $14 + -1 | 0;
21077 $11 = $8 << 1 | $7 >>> 31;
21078 $7 = $7 << 1;
21079 $8 = $11;
21080 $2 = $13;
21081 $16 = $12 << 1 | $2 >>> 31;
21082 $13 = $2 << 1 | $3;
21083 $1 = $1 | $16;
21084 $12 = $1;
21085 if (($1 | 0) == 65536 & $13 >>> 0 < 0 | $1 >>> 0 < 65536) {
21086 continue
21087 }
21088 break;
21089 }
21090 }
21091 $1 = $19 & 32768;
21092 if (($14 | 0) <= 0) {
21093 __multf3($9 - -64 | 0, $7, $8, $13, $12 & 65535 | ($1 | $14 + 120) << 16, 0, 0, 0, 1065811968);
21094 $3 = HEAP32[$9 + 72 >> 2];
21095 $4 = HEAP32[$9 + 76 >> 2];
21096 $7 = HEAP32[$9 + 64 >> 2];
21097 $8 = HEAP32[$9 + 68 >> 2];
21098 break label$1;
21099 }
21100 $3 = $13;
21101 $4 = $12 & 65535 | ($1 | $14) << 16;
21102 }
21103 HEAP32[$0 >> 2] = $7;
21104 HEAP32[$0 + 4 >> 2] = $8;
21105 HEAP32[$0 + 8 >> 2] = $3;
21106 HEAP32[$0 + 12 >> 2] = $4;
21107 global$0 = $9 + 128 | 0;
21108 }
21109
21110 function __floatscan($0, $1) {
21111 var $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0;
21112 $5 = global$0 - 48 | 0;
21113 global$0 = $5;
21114 $4 = $1 + 4 | 0;
21115 $7 = HEAP32[2644];
21116 $10 = HEAP32[2641];
21117 while (1) {
21118 $2 = HEAP32[$1 + 4 >> 2];
21119 label$4 : {
21120 if ($2 >>> 0 < HEAPU32[$1 + 104 >> 2]) {
21121 HEAP32[$4 >> 2] = $2 + 1;
21122 $2 = HEAPU8[$2 | 0];
21123 break label$4;
21124 }
21125 $2 = __shgetc($1);
21126 }
21127 if (($2 | 0) == 32 | $2 + -9 >>> 0 < 5) {
21128 continue
21129 }
21130 break;
21131 };
21132 $6 = 1;
21133 label$6 : {
21134 label$7 : {
21135 switch ($2 + -43 | 0) {
21136 case 0:
21137 case 2:
21138 break label$7;
21139 default:
21140 break label$6;
21141 };
21142 }
21143 $6 = ($2 | 0) == 45 ? -1 : 1;
21144 $2 = HEAP32[$1 + 4 >> 2];
21145 if ($2 >>> 0 < HEAPU32[$1 + 104 >> 2]) {
21146 HEAP32[$4 >> 2] = $2 + 1;
21147 $2 = HEAPU8[$2 | 0];
21148 break label$6;
21149 }
21150 $2 = __shgetc($1);
21151 }
21152 label$1 : {
21153 label$9 : {
21154 label$10 : {
21155 while (1) {
21156 if (HEAP8[$3 + 10484 | 0] == ($2 | 32)) {
21157 label$13 : {
21158 if ($3 >>> 0 > 6) {
21159 break label$13
21160 }
21161 $2 = HEAP32[$1 + 4 >> 2];
21162 if ($2 >>> 0 < HEAPU32[$1 + 104 >> 2]) {
21163 HEAP32[$4 >> 2] = $2 + 1;
21164 $2 = HEAPU8[$2 | 0];
21165 break label$13;
21166 }
21167 $2 = __shgetc($1);
21168 }
21169 $3 = $3 + 1 | 0;
21170 if (($3 | 0) != 8) {
21171 continue
21172 }
21173 break label$10;
21174 }
21175 break;
21176 };
21177 if (($3 | 0) != 3) {
21178 if (($3 | 0) == 8) {
21179 break label$10
21180 }
21181 if ($3 >>> 0 < 4) {
21182 break label$9
21183 }
21184 if (($3 | 0) == 8) {
21185 break label$10
21186 }
21187 }
21188 $1 = HEAP32[$1 + 104 >> 2];
21189 if ($1) {
21190 HEAP32[$4 >> 2] = HEAP32[$4 >> 2] + -1
21191 }
21192 if ($3 >>> 0 < 4) {
21193 break label$10
21194 }
21195 while (1) {
21196 if ($1) {
21197 HEAP32[$4 >> 2] = HEAP32[$4 >> 2] + -1
21198 }
21199 $3 = $3 + -1 | 0;
21200 if ($3 >>> 0 > 3) {
21201 continue
21202 }
21203 break;
21204 };
21205 }
21206 __extendsftf2($5, Math_fround(Math_fround($6 | 0) * Math_fround(infinity)));
21207 $6 = HEAP32[$5 + 8 >> 2];
21208 $2 = HEAP32[$5 + 12 >> 2];
21209 $8 = HEAP32[$5 >> 2];
21210 $9 = HEAP32[$5 + 4 >> 2];
21211 break label$1;
21212 }
21213 label$19 : {
21214 label$20 : {
21215 label$21 : {
21216 if ($3) {
21217 break label$21
21218 }
21219 $3 = 0;
21220 while (1) {
21221 if (HEAP8[$3 + 10493 | 0] != ($2 | 32)) {
21222 break label$21
21223 }
21224 label$23 : {
21225 if ($3 >>> 0 > 1) {
21226 break label$23
21227 }
21228 $2 = HEAP32[$1 + 4 >> 2];
21229 if ($2 >>> 0 < HEAPU32[$1 + 104 >> 2]) {
21230 HEAP32[$4 >> 2] = $2 + 1;
21231 $2 = HEAPU8[$2 | 0];
21232 break label$23;
21233 }
21234 $2 = __shgetc($1);
21235 }
21236 $3 = $3 + 1 | 0;
21237 if (($3 | 0) != 3) {
21238 continue
21239 }
21240 break;
21241 };
21242 break label$20;
21243 }
21244 label$25 : {
21245 switch ($3 | 0) {
21246 case 0:
21247 label$27 : {
21248 if (($2 | 0) != 48) {
21249 break label$27
21250 }
21251 $3 = HEAP32[$1 + 4 >> 2];
21252 label$28 : {
21253 if ($3 >>> 0 < HEAPU32[$1 + 104 >> 2]) {
21254 HEAP32[$4 >> 2] = $3 + 1;
21255 $3 = HEAPU8[$3 | 0];
21256 break label$28;
21257 }
21258 $3 = __shgetc($1);
21259 }
21260 if (($3 & -33) == 88) {
21261 hexfloat($5 + 16 | 0, $1, $10, $7, $6);
21262 $6 = HEAP32[$5 + 24 >> 2];
21263 $2 = HEAP32[$5 + 28 >> 2];
21264 $8 = HEAP32[$5 + 16 >> 2];
21265 $9 = HEAP32[$5 + 20 >> 2];
21266 break label$1;
21267 }
21268 if (!HEAP32[$1 + 104 >> 2]) {
21269 break label$27
21270 }
21271 HEAP32[$4 >> 2] = HEAP32[$4 >> 2] + -1;
21272 }
21273 decfloat($5 + 32 | 0, $1, $2, $10, $7, $6);
21274 $6 = HEAP32[$5 + 40 >> 2];
21275 $2 = HEAP32[$5 + 44 >> 2];
21276 $8 = HEAP32[$5 + 32 >> 2];
21277 $9 = HEAP32[$5 + 36 >> 2];
21278 break label$1;
21279 case 3:
21280 break label$20;
21281 default:
21282 break label$25;
21283 };
21284 }
21285 if (HEAP32[$1 + 104 >> 2]) {
21286 HEAP32[$4 >> 2] = HEAP32[$4 >> 2] + -1
21287 }
21288 break label$19;
21289 }
21290 label$32 : {
21291 $3 = HEAP32[$1 + 4 >> 2];
21292 label$33 : {
21293 if ($3 >>> 0 < HEAPU32[$1 + 104 >> 2]) {
21294 HEAP32[$4 >> 2] = $3 + 1;
21295 $2 = HEAPU8[$3 | 0];
21296 break label$33;
21297 }
21298 $2 = __shgetc($1);
21299 }
21300 if (($2 | 0) == 40) {
21301 $3 = 1;
21302 break label$32;
21303 }
21304 $6 = 0;
21305 $2 = 2147450880;
21306 if (!HEAP32[$1 + 104 >> 2]) {
21307 break label$1
21308 }
21309 HEAP32[$4 >> 2] = HEAP32[$4 >> 2] + -1;
21310 break label$1;
21311 }
21312 while (1) {
21313 $2 = HEAP32[$1 + 4 >> 2];
21314 label$37 : {
21315 if ($2 >>> 0 < HEAPU32[$1 + 104 >> 2]) {
21316 HEAP32[$4 >> 2] = $2 + 1;
21317 $7 = HEAPU8[$2 | 0];
21318 break label$37;
21319 }
21320 $7 = __shgetc($1);
21321 }
21322 if (!($7 + -97 >>> 0 >= 26 ? !($7 + -48 >>> 0 < 10 | $7 + -65 >>> 0 < 26 | ($7 | 0) == 95) : 0)) {
21323 $3 = $3 + 1 | 0;
21324 continue;
21325 }
21326 break;
21327 };
21328 $6 = 0;
21329 $2 = 2147450880;
21330 if (($7 | 0) == 41) {
21331 break label$1
21332 }
21333 $1 = HEAP32[$1 + 104 >> 2];
21334 if ($1) {
21335 HEAP32[$4 >> 2] = HEAP32[$4 >> 2] + -1
21336 }
21337 if (!$3) {
21338 break label$1
21339 }
21340 while (1) {
21341 $3 = $3 + -1 | 0;
21342 if ($1) {
21343 HEAP32[$4 >> 2] = HEAP32[$4 >> 2] + -1
21344 }
21345 if ($3) {
21346 continue
21347 }
21348 break;
21349 };
21350 break label$1;
21351 }
21352 HEAP32[2896] = 28;
21353 __shlim($1);
21354 $6 = 0;
21355 $2 = 0;
21356 }
21357 HEAP32[$0 >> 2] = $8;
21358 HEAP32[$0 + 4 >> 2] = $9;
21359 HEAP32[$0 + 8 >> 2] = $6;
21360 HEAP32[$0 + 12 >> 2] = $2;
21361 global$0 = $5 + 48 | 0;
21362 }
21363
21364 function hexfloat($0, $1, $2, $3, $4) {
21365 var $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0, $23 = 0, $24 = 0;
21366 $5 = global$0 - 432 | 0;
21367 global$0 = $5;
21368 $6 = HEAP32[$1 + 4 >> 2];
21369 label$1 : {
21370 if ($6 >>> 0 < HEAPU32[$1 + 104 >> 2]) {
21371 HEAP32[$1 + 4 >> 2] = $6 + 1;
21372 $7 = HEAPU8[$6 | 0];
21373 break label$1;
21374 }
21375 $7 = __shgetc($1);
21376 }
21377 label$3 : {
21378 label$4 : {
21379 while (1) {
21380 if (($7 | 0) != 48) {
21381 label$6 : {
21382 if (($7 | 0) != 46) {
21383 break label$3
21384 }
21385 $6 = HEAP32[$1 + 4 >> 2];
21386 if ($6 >>> 0 >= HEAPU32[$1 + 104 >> 2]) {
21387 break label$6
21388 }
21389 HEAP32[$1 + 4 >> 2] = $6 + 1;
21390 $7 = HEAPU8[$6 | 0];
21391 break label$4;
21392 }
21393 } else {
21394 $6 = HEAP32[$1 + 4 >> 2];
21395 if ($6 >>> 0 < HEAPU32[$1 + 104 >> 2]) {
21396 HEAP32[$1 + 4 >> 2] = $6 + 1;
21397 $7 = HEAPU8[$6 | 0];
21398 } else {
21399 $7 = __shgetc($1)
21400 }
21401 $21 = 1;
21402 continue;
21403 }
21404 break;
21405 };
21406 $7 = __shgetc($1);
21407 }
21408 $20 = 1;
21409 if (($7 | 0) != 48) {
21410 break label$3
21411 }
21412 while (1) {
21413 $6 = HEAP32[$1 + 4 >> 2];
21414 label$10 : {
21415 if ($6 >>> 0 < HEAPU32[$1 + 104 >> 2]) {
21416 HEAP32[$1 + 4 >> 2] = $6 + 1;
21417 $7 = HEAPU8[$6 | 0];
21418 break label$10;
21419 }
21420 $7 = __shgetc($1);
21421 }
21422 $13 = $13 + -1 | 0;
21423 $17 = $17 + -1 | 0;
21424 if (($17 | 0) != -1) {
21425 $13 = $13 + 1 | 0
21426 }
21427 if (($7 | 0) == 48) {
21428 continue
21429 }
21430 break;
21431 };
21432 $21 = 1;
21433 }
21434 $12 = 1073676288;
21435 $6 = 0;
21436 while (1) {
21437 label$13 : {
21438 $22 = $7 | 32;
21439 label$14 : {
21440 label$15 : {
21441 $23 = $7 + -48 | 0;
21442 if ($23 >>> 0 < 10) {
21443 break label$15
21444 }
21445 if ($22 + -97 >>> 0 > 5 ? ($7 | 0) != 46 : 0) {
21446 break label$13
21447 }
21448 if (($7 | 0) != 46) {
21449 break label$15
21450 }
21451 if ($20) {
21452 break label$13
21453 }
21454 $20 = 1;
21455 $17 = $9;
21456 $13 = $6;
21457 break label$14;
21458 }
21459 $7 = ($7 | 0) > 57 ? $22 + -87 | 0 : $23;
21460 label$16 : {
21461 if (($6 | 0) < 0 ? 1 : ($6 | 0) <= 0 ? ($9 >>> 0 > 7 ? 0 : 1) : 0) {
21462 $14 = $7 + ($14 << 4) | 0;
21463 break label$16;
21464 }
21465 if (($6 | 0) < 0 ? 1 : ($6 | 0) <= 0 ? ($9 >>> 0 > 28 ? 0 : 1) : 0) {
21466 __floatsitf($5 + 48 | 0, $7);
21467 __multf3($5 + 32 | 0, $18, $19, $8, $12, 0, 0, 0, 1073414144);
21468 $18 = HEAP32[$5 + 32 >> 2];
21469 $19 = HEAP32[$5 + 36 >> 2];
21470 $8 = HEAP32[$5 + 40 >> 2];
21471 $12 = HEAP32[$5 + 44 >> 2];
21472 __multf3($5 + 16 | 0, $18, $19, $8, $12, HEAP32[$5 + 48 >> 2], HEAP32[$5 + 52 >> 2], HEAP32[$5 + 56 >> 2], HEAP32[$5 + 60 >> 2]);
21473 __addtf3($5, $10, $11, $15, $16, HEAP32[$5 + 16 >> 2], HEAP32[$5 + 20 >> 2], HEAP32[$5 + 24 >> 2], HEAP32[$5 + 28 >> 2]);
21474 $15 = HEAP32[$5 + 8 >> 2];
21475 $16 = HEAP32[$5 + 12 >> 2];
21476 $10 = HEAP32[$5 >> 2];
21477 $11 = HEAP32[$5 + 4 >> 2];
21478 break label$16;
21479 }
21480 if (!$7 | $24) {
21481 break label$16
21482 }
21483 __multf3($5 + 80 | 0, $18, $19, $8, $12, 0, 0, 0, 1073610752);
21484 __addtf3($5 - -64 | 0, $10, $11, $15, $16, HEAP32[$5 + 80 >> 2], HEAP32[$5 + 84 >> 2], HEAP32[$5 + 88 >> 2], HEAP32[$5 + 92 >> 2]);
21485 $15 = HEAP32[$5 + 72 >> 2];
21486 $16 = HEAP32[$5 + 76 >> 2];
21487 $24 = 1;
21488 $10 = HEAP32[$5 + 64 >> 2];
21489 $11 = HEAP32[$5 + 68 >> 2];
21490 }
21491 $9 = $9 + 1 | 0;
21492 if ($9 >>> 0 < 1) {
21493 $6 = $6 + 1 | 0
21494 }
21495 $21 = 1;
21496 }
21497 $7 = HEAP32[$1 + 4 >> 2];
21498 if ($7 >>> 0 < HEAPU32[$1 + 104 >> 2]) {
21499 HEAP32[$1 + 4 >> 2] = $7 + 1;
21500 $7 = HEAPU8[$7 | 0];
21501 } else {
21502 $7 = __shgetc($1)
21503 }
21504 continue;
21505 }
21506 break;
21507 };
21508 label$20 : {
21509 label$21 : {
21510 if (!$21) {
21511 if (!HEAP32[$1 + 104 >> 2]) {
21512 break label$21
21513 }
21514 $2 = HEAP32[$1 + 4 >> 2];
21515 HEAP32[$1 + 4 >> 2] = $2 + -1;
21516 HEAP32[$1 + 4 >> 2] = $2 + -2;
21517 if (!$20) {
21518 break label$21
21519 }
21520 HEAP32[$1 + 4 >> 2] = $2 + -3;
21521 break label$21;
21522 }
21523 if (($6 | 0) < 0 ? 1 : ($6 | 0) <= 0 ? ($9 >>> 0 > 7 ? 0 : 1) : 0) {
21524 $8 = $9;
21525 $12 = $6;
21526 while (1) {
21527 $14 = $14 << 4;
21528 $8 = $8 + 1 | 0;
21529 if ($8 >>> 0 < 1) {
21530 $12 = $12 + 1 | 0
21531 }
21532 if (($8 | 0) != 8 | $12) {
21533 continue
21534 }
21535 break;
21536 };
21537 }
21538 label$27 : {
21539 if (($7 & -33) == 80) {
21540 $8 = scanexp($1);
21541 $7 = i64toi32_i32$HIGH_BITS;
21542 $12 = $7;
21543 if ($8 | ($7 | 0) != -2147483648) {
21544 break label$27
21545 }
21546 $8 = 0;
21547 $12 = 0;
21548 if (!HEAP32[$1 + 104 >> 2]) {
21549 break label$27
21550 }
21551 HEAP32[$1 + 4 >> 2] = HEAP32[$1 + 4 >> 2] + -1;
21552 break label$27;
21553 }
21554 $8 = 0;
21555 $12 = 0;
21556 if (!HEAP32[$1 + 104 >> 2]) {
21557 break label$27
21558 }
21559 HEAP32[$1 + 4 >> 2] = HEAP32[$1 + 4 >> 2] + -1;
21560 }
21561 if (!$14) {
21562 __extenddftf2($5 + 112 | 0, +($4 | 0) * 0.0);
21563 $10 = HEAP32[$5 + 112 >> 2];
21564 $11 = HEAP32[$5 + 116 >> 2];
21565 $2 = HEAP32[$5 + 120 >> 2];
21566 $1 = HEAP32[$5 + 124 >> 2];
21567 break label$20;
21568 }
21569 $1 = $20 ? $17 : $9;
21570 $6 = ($20 ? $13 : $6) << 2 | $1 >>> 30;
21571 $1 = $8 + ($1 << 2) | 0;
21572 $13 = $1 + -32 | 0;
21573 $9 = $13;
21574 $6 = $6 + $12 | 0;
21575 $1 = ($1 >>> 0 < $8 >>> 0 ? $6 + 1 | 0 : $6) + -1 | 0;
21576 $6 = $9 >>> 0 < 4294967264 ? $1 + 1 | 0 : $1;
21577 if (($6 | 0) > 0 ? 1 : ($6 | 0) >= 0 ? ($9 >>> 0 <= 0 - $3 >>> 0 ? 0 : 1) : 0) {
21578 HEAP32[2896] = 68;
21579 __floatsitf($5 + 160 | 0, $4);
21580 __multf3($5 + 144 | 0, HEAP32[$5 + 160 >> 2], HEAP32[$5 + 164 >> 2], HEAP32[$5 + 168 >> 2], HEAP32[$5 + 172 >> 2], -1, -1, -1, 2147418111);
21581 __multf3($5 + 128 | 0, HEAP32[$5 + 144 >> 2], HEAP32[$5 + 148 >> 2], HEAP32[$5 + 152 >> 2], HEAP32[$5 + 156 >> 2], -1, -1, -1, 2147418111);
21582 $10 = HEAP32[$5 + 128 >> 2];
21583 $11 = HEAP32[$5 + 132 >> 2];
21584 $2 = HEAP32[$5 + 136 >> 2];
21585 $1 = HEAP32[$5 + 140 >> 2];
21586 break label$20;
21587 }
21588 $1 = $3 + -226 | 0;
21589 $7 = $9 >>> 0 < $1 >>> 0 ? 0 : 1;
21590 $1 = $1 >> 31;
21591 if (($6 | 0) > ($1 | 0) ? 1 : ($6 | 0) >= ($1 | 0) ? $7 : 0) {
21592 if (($14 | 0) > -1) {
21593 while (1) {
21594 __addtf3($5 + 416 | 0, $10, $11, $15, $16, 0, 0, 0, -1073807360);
21595 $1 = __getf2($10, $11, $15, $16, 1073610752);
21596 $8 = ($1 | 0) < 0;
21597 __addtf3($5 + 400 | 0, $10, $11, $15, $16, $8 ? $10 : HEAP32[$5 + 416 >> 2], $8 ? $11 : HEAP32[$5 + 420 >> 2], $8 ? $15 : HEAP32[$5 + 424 >> 2], $8 ? $16 : HEAP32[$5 + 428 >> 2]);
21598 $6 = $6 + -1 | 0;
21599 $9 = $9 + -1 | 0;
21600 if (($9 | 0) != -1) {
21601 $6 = $6 + 1 | 0
21602 }
21603 $15 = HEAP32[$5 + 408 >> 2];
21604 $16 = HEAP32[$5 + 412 >> 2];
21605 $10 = HEAP32[$5 + 400 >> 2];
21606 $11 = HEAP32[$5 + 404 >> 2];
21607 $14 = $14 << 1 | ($1 | 0) > -1;
21608 if (($14 | 0) > -1) {
21609 continue
21610 }
21611 break;
21612 }
21613 }
21614 $1 = ($9 - $3 | 0) + 32 | 0;
21615 $8 = $1;
21616 $7 = $2;
21617 $12 = $1 >>> 0 >= $2 >>> 0 ? 0 : 1;
21618 $2 = $6 - (($3 >> 31) + ($9 >>> 0 < $3 >>> 0) | 0) | 0;
21619 $1 = $1 >>> 0 < 32 ? $2 + 1 | 0 : $2;
21620 $1 = (($1 | 0) < 0 ? 1 : ($1 | 0) <= 0 ? $12 : 0) ? (($8 | 0) > 0 ? $8 : 0) : $7;
21621 label$35 : {
21622 if (($1 | 0) >= 113) {
21623 __floatsitf($5 + 384 | 0, $4);
21624 $17 = HEAP32[$5 + 392 >> 2];
21625 $13 = HEAP32[$5 + 396 >> 2];
21626 $18 = HEAP32[$5 + 384 >> 2];
21627 $19 = HEAP32[$5 + 388 >> 2];
21628 $6 = 0;
21629 $4 = 0;
21630 $3 = 0;
21631 $2 = 0;
21632 break label$35;
21633 }
21634 __extenddftf2($5 + 352 | 0, scalbn(1.0, 144 - $1 | 0));
21635 __floatsitf($5 + 336 | 0, $4);
21636 $18 = HEAP32[$5 + 336 >> 2];
21637 $19 = HEAP32[$5 + 340 >> 2];
21638 $17 = HEAP32[$5 + 344 >> 2];
21639 $13 = HEAP32[$5 + 348 >> 2];
21640 copysignl($5 + 368 | 0, HEAP32[$5 + 352 >> 2], HEAP32[$5 + 356 >> 2], HEAP32[$5 + 360 >> 2], HEAP32[$5 + 364 >> 2], $18, $19, $17, $13);
21641 $6 = HEAP32[$5 + 376 >> 2];
21642 $4 = HEAP32[$5 + 380 >> 2];
21643 $3 = HEAP32[$5 + 372 >> 2];
21644 $2 = HEAP32[$5 + 368 >> 2];
21645 }
21646 $1 = !($14 & 1) & ((__letf2($10, $11, $15, $16, 0, 0, 0, 0) | 0) != 0 & ($1 | 0) < 32);
21647 __floatunsitf($5 + 320 | 0, $1 + $14 | 0);
21648 __multf3($5 + 304 | 0, $18, $19, $17, $13, HEAP32[$5 + 320 >> 2], HEAP32[$5 + 324 >> 2], HEAP32[$5 + 328 >> 2], HEAP32[$5 + 332 >> 2]);
21649 __addtf3($5 + 272 | 0, HEAP32[$5 + 304 >> 2], HEAP32[$5 + 308 >> 2], HEAP32[$5 + 312 >> 2], HEAP32[$5 + 316 >> 2], $2, $3, $6, $4);
21650 __multf3($5 + 288 | 0, $1 ? 0 : $10, $1 ? 0 : $11, $1 ? 0 : $15, $1 ? 0 : $16, $18, $19, $17, $13);
21651 __addtf3($5 + 256 | 0, HEAP32[$5 + 288 >> 2], HEAP32[$5 + 292 >> 2], HEAP32[$5 + 296 >> 2], HEAP32[$5 + 300 >> 2], HEAP32[$5 + 272 >> 2], HEAP32[$5 + 276 >> 2], HEAP32[$5 + 280 >> 2], HEAP32[$5 + 284 >> 2]);
21652 __subtf3($5 + 240 | 0, HEAP32[$5 + 256 >> 2], HEAP32[$5 + 260 >> 2], HEAP32[$5 + 264 >> 2], HEAP32[$5 + 268 >> 2], $2, $3, $6, $4);
21653 $1 = HEAP32[$5 + 240 >> 2];
21654 $2 = HEAP32[$5 + 244 >> 2];
21655 $3 = HEAP32[$5 + 248 >> 2];
21656 $4 = HEAP32[$5 + 252 >> 2];
21657 if (!__letf2($1, $2, $3, $4, 0, 0, 0, 0)) {
21658 HEAP32[2896] = 68
21659 }
21660 scalbnl($5 + 224 | 0, $1, $2, $3, $4, $9);
21661 $10 = HEAP32[$5 + 224 >> 2];
21662 $11 = HEAP32[$5 + 228 >> 2];
21663 $2 = HEAP32[$5 + 232 >> 2];
21664 $1 = HEAP32[$5 + 236 >> 2];
21665 break label$20;
21666 }
21667 HEAP32[2896] = 68;
21668 __floatsitf($5 + 208 | 0, $4);
21669 __multf3($5 + 192 | 0, HEAP32[$5 + 208 >> 2], HEAP32[$5 + 212 >> 2], HEAP32[$5 + 216 >> 2], HEAP32[$5 + 220 >> 2], 0, 0, 0, 65536);
21670 __multf3($5 + 176 | 0, HEAP32[$5 + 192 >> 2], HEAP32[$5 + 196 >> 2], HEAP32[$5 + 200 >> 2], HEAP32[$5 + 204 >> 2], 0, 0, 0, 65536);
21671 $10 = HEAP32[$5 + 176 >> 2];
21672 $11 = HEAP32[$5 + 180 >> 2];
21673 $2 = HEAP32[$5 + 184 >> 2];
21674 $1 = HEAP32[$5 + 188 >> 2];
21675 break label$20;
21676 }
21677 __extenddftf2($5 + 96 | 0, +($4 | 0) * 0.0);
21678 $10 = HEAP32[$5 + 96 >> 2];
21679 $11 = HEAP32[$5 + 100 >> 2];
21680 $2 = HEAP32[$5 + 104 >> 2];
21681 $1 = HEAP32[$5 + 108 >> 2];
21682 }
21683 HEAP32[$0 >> 2] = $10;
21684 HEAP32[$0 + 4 >> 2] = $11;
21685 HEAP32[$0 + 8 >> 2] = $2;
21686 HEAP32[$0 + 12 >> 2] = $1;
21687 global$0 = $5 + 432 | 0;
21688 }
21689
21690 function decfloat($0, $1, $2, $3, $4, $5) {
21691 var $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0, $23 = 0, $24 = 0.0, $25 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_i32$2 = 0;
21692 $6 = global$0 - 8976 | 0;
21693 global$0 = $6;
21694 $22 = $3 + $4 | 0;
21695 $25 = 0 - $22 | 0;
21696 label$1 : {
21697 label$2 : {
21698 while (1) {
21699 if (($2 | 0) != 48) {
21700 label$4 : {
21701 if (($2 | 0) != 46) {
21702 break label$1
21703 }
21704 $2 = HEAP32[$1 + 4 >> 2];
21705 if ($2 >>> 0 >= HEAPU32[$1 + 104 >> 2]) {
21706 break label$4
21707 }
21708 HEAP32[$1 + 4 >> 2] = $2 + 1;
21709 $2 = HEAPU8[$2 | 0];
21710 break label$2;
21711 }
21712 } else {
21713 $2 = HEAP32[$1 + 4 >> 2];
21714 if ($2 >>> 0 < HEAPU32[$1 + 104 >> 2]) {
21715 $9 = 1;
21716 HEAP32[$1 + 4 >> 2] = $2 + 1;
21717 $2 = HEAPU8[$2 | 0];
21718 } else {
21719 $9 = 1;
21720 $2 = __shgetc($1);
21721 }
21722 continue;
21723 }
21724 break;
21725 };
21726 $2 = __shgetc($1);
21727 }
21728 $14 = 1;
21729 if (($2 | 0) != 48) {
21730 break label$1
21731 }
21732 while (1) {
21733 $2 = HEAP32[$1 + 4 >> 2];
21734 label$8 : {
21735 if ($2 >>> 0 < HEAPU32[$1 + 104 >> 2]) {
21736 HEAP32[$1 + 4 >> 2] = $2 + 1;
21737 $2 = HEAPU8[$2 | 0];
21738 break label$8;
21739 }
21740 $2 = __shgetc($1);
21741 }
21742 $7 = $7 + -1 | 0;
21743 $8 = $8 + -1 | 0;
21744 if (($8 | 0) != -1) {
21745 $7 = $7 + 1 | 0
21746 }
21747 if (($2 | 0) == 48) {
21748 continue
21749 }
21750 break;
21751 };
21752 $9 = 1;
21753 }
21754 HEAP32[$6 + 784 >> 2] = 0;
21755 label$10 : {
21756 label$11 : {
21757 $12 = ($2 | 0) == 46;
21758 $13 = $2 + -48 | 0;
21759 label$13 : {
21760 label$14 : {
21761 label$15 : {
21762 if ($12 | $13 >>> 0 <= 9) {
21763 while (1) {
21764 label$19 : {
21765 if ($12 & 1) {
21766 if (!$14) {
21767 $8 = $10;
21768 $7 = $11;
21769 $14 = 1;
21770 break label$19;
21771 }
21772 $9 = !$9;
21773 break label$15;
21774 }
21775 $10 = $10 + 1 | 0;
21776 if ($10 >>> 0 < 1) {
21777 $11 = $11 + 1 | 0
21778 }
21779 if (($15 | 0) <= 2044) {
21780 $20 = ($2 | 0) == 48 ? $20 : $10;
21781 $9 = ($6 + 784 | 0) + ($15 << 2) | 0;
21782 HEAP32[$9 >> 2] = $17 ? (Math_imul(HEAP32[$9 >> 2], 10) + $2 | 0) + -48 | 0 : $13;
21783 $9 = 1;
21784 $13 = $17 + 1 | 0;
21785 $2 = ($13 | 0) == 9;
21786 $17 = $2 ? 0 : $13;
21787 $15 = $2 + $15 | 0;
21788 break label$19;
21789 }
21790 if (($2 | 0) == 48) {
21791 break label$19
21792 }
21793 HEAP32[$6 + 8960 >> 2] = HEAP32[$6 + 8960 >> 2] | 1;
21794 $20 = 18396;
21795 }
21796 $2 = HEAP32[$1 + 4 >> 2];
21797 label$25 : {
21798 if ($2 >>> 0 < HEAPU32[$1 + 104 >> 2]) {
21799 HEAP32[$1 + 4 >> 2] = $2 + 1;
21800 $2 = HEAPU8[$2 | 0];
21801 break label$25;
21802 }
21803 $2 = __shgetc($1);
21804 }
21805 $12 = ($2 | 0) == 46;
21806 $13 = $2 + -48 | 0;
21807 if ($12 | $13 >>> 0 < 10) {
21808 continue
21809 }
21810 break;
21811 }
21812 }
21813 $8 = $14 ? $8 : $10;
21814 $7 = $14 ? $7 : $11;
21815 if (!(!$9 | ($2 & -33) != 69)) {
21816 $12 = scanexp($1);
21817 $2 = i64toi32_i32$HIGH_BITS;
21818 $16 = $2;
21819 label$28 : {
21820 if ($12 | ($2 | 0) != -2147483648) {
21821 break label$28
21822 }
21823 $12 = 0;
21824 $16 = 0;
21825 if (!HEAP32[$1 + 104 >> 2]) {
21826 break label$28
21827 }
21828 HEAP32[$1 + 4 >> 2] = HEAP32[$1 + 4 >> 2] + -1;
21829 }
21830 if (!$9) {
21831 break label$13
21832 }
21833 $7 = $7 + $16 | 0;
21834 $8 = $8 + $12 | 0;
21835 if ($8 >>> 0 < $12 >>> 0) {
21836 $7 = $7 + 1 | 0
21837 }
21838 break label$11;
21839 }
21840 $9 = !$9;
21841 if (($2 | 0) < 0) {
21842 break label$14
21843 }
21844 }
21845 if (!HEAP32[$1 + 104 >> 2]) {
21846 break label$14
21847 }
21848 HEAP32[$1 + 4 >> 2] = HEAP32[$1 + 4 >> 2] + -1;
21849 }
21850 if (!$9) {
21851 break label$11
21852 }
21853 }
21854 HEAP32[2896] = 28;
21855 $10 = 0;
21856 $11 = 0;
21857 __shlim($1);
21858 $2 = 0;
21859 $1 = 0;
21860 break label$10;
21861 }
21862 $1 = HEAP32[$6 + 784 >> 2];
21863 if (!$1) {
21864 __extenddftf2($6, +($5 | 0) * 0.0);
21865 $10 = HEAP32[$6 >> 2];
21866 $11 = HEAP32[$6 + 4 >> 2];
21867 $2 = HEAP32[$6 + 8 >> 2];
21868 $1 = HEAP32[$6 + 12 >> 2];
21869 break label$10;
21870 }
21871 if (!(($8 | 0) != ($10 | 0) | ($7 | 0) != ($11 | 0) | (($11 | 0) > 0 ? 1 : ($11 | 0) >= 0 ? ($10 >>> 0 <= 9 ? 0 : 1) : 0) | ($1 >>> $3 | 0 ? ($3 | 0) <= 30 : 0))) {
21872 __floatsitf($6 + 48 | 0, $5);
21873 __floatunsitf($6 + 32 | 0, $1);
21874 __multf3($6 + 16 | 0, HEAP32[$6 + 48 >> 2], HEAP32[$6 + 52 >> 2], HEAP32[$6 + 56 >> 2], HEAP32[$6 + 60 >> 2], HEAP32[$6 + 32 >> 2], HEAP32[$6 + 36 >> 2], HEAP32[$6 + 40 >> 2], HEAP32[$6 + 44 >> 2]);
21875 $10 = HEAP32[$6 + 16 >> 2];
21876 $11 = HEAP32[$6 + 20 >> 2];
21877 $2 = HEAP32[$6 + 24 >> 2];
21878 $1 = HEAP32[$6 + 28 >> 2];
21879 break label$10;
21880 }
21881 if (($7 | 0) > 0 ? 1 : ($7 | 0) >= 0 ? ($8 >>> 0 <= ($4 | 0) / -2 >>> 0 ? 0 : 1) : 0) {
21882 HEAP32[2896] = 68;
21883 __floatsitf($6 + 96 | 0, $5);
21884 __multf3($6 + 80 | 0, HEAP32[$6 + 96 >> 2], HEAP32[$6 + 100 >> 2], HEAP32[$6 + 104 >> 2], HEAP32[$6 + 108 >> 2], -1, -1, -1, 2147418111);
21885 __multf3($6 - -64 | 0, HEAP32[$6 + 80 >> 2], HEAP32[$6 + 84 >> 2], HEAP32[$6 + 88 >> 2], HEAP32[$6 + 92 >> 2], -1, -1, -1, 2147418111);
21886 $10 = HEAP32[$6 + 64 >> 2];
21887 $11 = HEAP32[$6 + 68 >> 2];
21888 $2 = HEAP32[$6 + 72 >> 2];
21889 $1 = HEAP32[$6 + 76 >> 2];
21890 break label$10;
21891 }
21892 $1 = $4 + -226 | 0;
21893 $2 = $8 >>> 0 >= $1 >>> 0 ? 0 : 1;
21894 $1 = $1 >> 31;
21895 if (($7 | 0) < ($1 | 0) ? 1 : ($7 | 0) <= ($1 | 0) ? $2 : 0) {
21896 HEAP32[2896] = 68;
21897 __floatsitf($6 + 144 | 0, $5);
21898 __multf3($6 + 128 | 0, HEAP32[$6 + 144 >> 2], HEAP32[$6 + 148 >> 2], HEAP32[$6 + 152 >> 2], HEAP32[$6 + 156 >> 2], 0, 0, 0, 65536);
21899 __multf3($6 + 112 | 0, HEAP32[$6 + 128 >> 2], HEAP32[$6 + 132 >> 2], HEAP32[$6 + 136 >> 2], HEAP32[$6 + 140 >> 2], 0, 0, 0, 65536);
21900 $10 = HEAP32[$6 + 112 >> 2];
21901 $11 = HEAP32[$6 + 116 >> 2];
21902 $2 = HEAP32[$6 + 120 >> 2];
21903 $1 = HEAP32[$6 + 124 >> 2];
21904 break label$10;
21905 }
21906 if ($17) {
21907 if (($17 | 0) <= 8) {
21908 $2 = ($6 + 784 | 0) + ($15 << 2) | 0;
21909 $1 = HEAP32[$2 >> 2];
21910 while (1) {
21911 $1 = Math_imul($1, 10);
21912 $17 = $17 + 1 | 0;
21913 if (($17 | 0) != 9) {
21914 continue
21915 }
21916 break;
21917 };
21918 HEAP32[$2 >> 2] = $1;
21919 }
21920 $15 = $15 + 1 | 0;
21921 }
21922 label$36 : {
21923 $14 = $8;
21924 if (($20 | 0) > ($8 | 0) | ($20 | 0) >= 9 | ($8 | 0) > 17) {
21925 break label$36
21926 }
21927 if (($14 | 0) == 9) {
21928 __floatsitf($6 + 192 | 0, $5);
21929 __floatunsitf($6 + 176 | 0, HEAP32[$6 + 784 >> 2]);
21930 __multf3($6 + 160 | 0, HEAP32[$6 + 192 >> 2], HEAP32[$6 + 196 >> 2], HEAP32[$6 + 200 >> 2], HEAP32[$6 + 204 >> 2], HEAP32[$6 + 176 >> 2], HEAP32[$6 + 180 >> 2], HEAP32[$6 + 184 >> 2], HEAP32[$6 + 188 >> 2]);
21931 $10 = HEAP32[$6 + 160 >> 2];
21932 $11 = HEAP32[$6 + 164 >> 2];
21933 $2 = HEAP32[$6 + 168 >> 2];
21934 $1 = HEAP32[$6 + 172 >> 2];
21935 break label$10;
21936 }
21937 if (($14 | 0) <= 8) {
21938 __floatsitf($6 + 272 | 0, $5);
21939 __floatunsitf($6 + 256 | 0, HEAP32[$6 + 784 >> 2]);
21940 __multf3($6 + 240 | 0, HEAP32[$6 + 272 >> 2], HEAP32[$6 + 276 >> 2], HEAP32[$6 + 280 >> 2], HEAP32[$6 + 284 >> 2], HEAP32[$6 + 256 >> 2], HEAP32[$6 + 260 >> 2], HEAP32[$6 + 264 >> 2], HEAP32[$6 + 268 >> 2]);
21941 __floatsitf($6 + 224 | 0, HEAP32[(0 - $14 << 2) + 10560 >> 2]);
21942 __divtf3($6 + 208 | 0, HEAP32[$6 + 240 >> 2], HEAP32[$6 + 244 >> 2], HEAP32[$6 + 248 >> 2], HEAP32[$6 + 252 >> 2], HEAP32[$6 + 224 >> 2], HEAP32[$6 + 228 >> 2], HEAP32[$6 + 232 >> 2], HEAP32[$6 + 236 >> 2]);
21943 $10 = HEAP32[$6 + 208 >> 2];
21944 $11 = HEAP32[$6 + 212 >> 2];
21945 $2 = HEAP32[$6 + 216 >> 2];
21946 $1 = HEAP32[$6 + 220 >> 2];
21947 break label$10;
21948 }
21949 $1 = (Math_imul($14, -3) + $3 | 0) + 27 | 0;
21950 $2 = HEAP32[$6 + 784 >> 2];
21951 if ($2 >>> $1 | 0 ? ($1 | 0) <= 30 : 0) {
21952 break label$36
21953 }
21954 __floatsitf($6 + 352 | 0, $5);
21955 __floatunsitf($6 + 336 | 0, $2);
21956 __multf3($6 + 320 | 0, HEAP32[$6 + 352 >> 2], HEAP32[$6 + 356 >> 2], HEAP32[$6 + 360 >> 2], HEAP32[$6 + 364 >> 2], HEAP32[$6 + 336 >> 2], HEAP32[$6 + 340 >> 2], HEAP32[$6 + 344 >> 2], HEAP32[$6 + 348 >> 2]);
21957 __floatsitf($6 + 304 | 0, HEAP32[($14 << 2) + 10488 >> 2]);
21958 __multf3($6 + 288 | 0, HEAP32[$6 + 320 >> 2], HEAP32[$6 + 324 >> 2], HEAP32[$6 + 328 >> 2], HEAP32[$6 + 332 >> 2], HEAP32[$6 + 304 >> 2], HEAP32[$6 + 308 >> 2], HEAP32[$6 + 312 >> 2], HEAP32[$6 + 316 >> 2]);
21959 $10 = HEAP32[$6 + 288 >> 2];
21960 $11 = HEAP32[$6 + 292 >> 2];
21961 $2 = HEAP32[$6 + 296 >> 2];
21962 $1 = HEAP32[$6 + 300 >> 2];
21963 break label$10;
21964 }
21965 while (1) {
21966 $2 = $15;
21967 $15 = $2 + -1 | 0;
21968 if (!HEAP32[($6 + 784 | 0) + ($15 << 2) >> 2]) {
21969 continue
21970 }
21971 break;
21972 };
21973 $17 = 0;
21974 $1 = ($14 | 0) % 9 | 0;
21975 label$40 : {
21976 if (!$1) {
21977 $9 = 0;
21978 break label$40;
21979 }
21980 $13 = ($14 | 0) > -1 ? $1 : $1 + 9 | 0;
21981 label$42 : {
21982 if (!$2) {
21983 $9 = 0;
21984 $2 = 0;
21985 break label$42;
21986 }
21987 $8 = HEAP32[(0 - $13 << 2) + 10560 >> 2];
21988 $10 = 1e9 / ($8 | 0) | 0;
21989 $12 = 0;
21990 $1 = 0;
21991 $9 = 0;
21992 while (1) {
21993 $11 = ($6 + 784 | 0) + ($1 << 2) | 0;
21994 $15 = HEAP32[$11 >> 2];
21995 $16 = ($15 >>> 0) / ($8 >>> 0) | 0;
21996 $7 = $12 + $16 | 0;
21997 HEAP32[$11 >> 2] = $7;
21998 $7 = !$7 & ($1 | 0) == ($9 | 0);
21999 $9 = $7 ? $9 + 1 & 2047 : $9;
22000 $14 = $7 ? $14 + -9 | 0 : $14;
22001 $12 = Math_imul($10, $15 - Math_imul($8, $16) | 0);
22002 $1 = $1 + 1 | 0;
22003 if (($2 | 0) != ($1 | 0)) {
22004 continue
22005 }
22006 break;
22007 };
22008 if (!$12) {
22009 break label$42
22010 }
22011 HEAP32[($6 + 784 | 0) + ($2 << 2) >> 2] = $12;
22012 $2 = $2 + 1 | 0;
22013 }
22014 $14 = ($14 - $13 | 0) + 9 | 0;
22015 }
22016 while (1) {
22017 $11 = ($6 + 784 | 0) + ($9 << 2) | 0;
22018 label$46 : {
22019 while (1) {
22020 if (($14 | 0) != 36 | HEAPU32[$11 >> 2] >= 10384593 ? ($14 | 0) >= 36 : 0) {
22021 break label$46
22022 }
22023 $15 = $2 + 2047 | 0;
22024 $12 = 0;
22025 $13 = $2;
22026 while (1) {
22027 $2 = $13;
22028 $10 = $15 & 2047;
22029 $13 = ($6 + 784 | 0) + ($10 << 2) | 0;
22030 $1 = HEAP32[$13 >> 2];
22031 $7 = $1 >>> 3 | 0;
22032 $1 = $1 << 29;
22033 $8 = $1 + $12 | 0;
22034 if ($8 >>> 0 < $1 >>> 0) {
22035 $7 = $7 + 1 | 0
22036 }
22037 $1 = 0;
22038 if (!(!$7 & $8 >>> 0 < 1000000001 | $7 >>> 0 < 0)) {
22039 $1 = __wasm_i64_udiv($8, $7, 1e9);
22040 $8 = $8 - __wasm_i64_mul($1, i64toi32_i32$HIGH_BITS, 1e9, 0) | 0;
22041 }
22042 $12 = $1;
22043 HEAP32[$13 >> 2] = $8;
22044 $13 = ($10 | 0) != ($2 + -1 & 2047) ? $2 : ($9 | 0) == ($10 | 0) ? $2 : $8 ? $2 : $10;
22045 $15 = $10 + -1 | 0;
22046 if (($9 | 0) != ($10 | 0)) {
22047 continue
22048 }
22049 break;
22050 };
22051 $17 = $17 + -29 | 0;
22052 if (!$12) {
22053 continue
22054 }
22055 break;
22056 };
22057 $9 = $9 + -1 & 2047;
22058 if (($13 | 0) == ($9 | 0)) {
22059 $1 = ($6 + 784 | 0) + (($13 + 2046 & 2047) << 2) | 0;
22060 $2 = $13 + -1 & 2047;
22061 HEAP32[$1 >> 2] = HEAP32[$1 >> 2] | HEAP32[($6 + 784 | 0) + ($2 << 2) >> 2];
22062 }
22063 $14 = $14 + 9 | 0;
22064 HEAP32[($6 + 784 | 0) + ($9 << 2) >> 2] = $12;
22065 continue;
22066 }
22067 break;
22068 };
22069 label$52 : {
22070 label$53 : while (1) {
22071 $8 = $2 + 1 & 2047;
22072 $10 = ($6 + 784 | 0) + (($2 + -1 & 2047) << 2) | 0;
22073 while (1) {
22074 $7 = ($14 | 0) > 45 ? 9 : 1;
22075 label$55 : {
22076 while (1) {
22077 $13 = $9;
22078 $1 = 0;
22079 label$57 : {
22080 while (1) {
22081 label$59 : {
22082 $9 = $1 + $13 & 2047;
22083 if (($9 | 0) == ($2 | 0)) {
22084 break label$59
22085 }
22086 $9 = HEAP32[($6 + 784 | 0) + ($9 << 2) >> 2];
22087 $11 = HEAP32[($1 << 2) + 10512 >> 2];
22088 if ($9 >>> 0 < $11 >>> 0) {
22089 break label$59
22090 }
22091 if ($9 >>> 0 > $11 >>> 0) {
22092 break label$57
22093 }
22094 $1 = $1 + 1 | 0;
22095 if (($1 | 0) != 4) {
22096 continue
22097 }
22098 }
22099 break;
22100 };
22101 if (($14 | 0) != 36) {
22102 break label$57
22103 }
22104 $8 = 0;
22105 $7 = 0;
22106 $1 = 0;
22107 $10 = 0;
22108 $11 = 0;
22109 while (1) {
22110 $9 = $1 + $13 & 2047;
22111 if (($9 | 0) == ($2 | 0)) {
22112 $2 = $2 + 1 & 2047;
22113 HEAP32[(($2 << 2) + $6 | 0) + 780 >> 2] = 0;
22114 }
22115 __multf3($6 + 768 | 0, $8, $7, $10, $11, 0, 0, 1342177280, 1075633366);
22116 __floatunsitf($6 + 752 | 0, HEAP32[($6 + 784 | 0) + ($9 << 2) >> 2]);
22117 __addtf3($6 + 736 | 0, HEAP32[$6 + 768 >> 2], HEAP32[$6 + 772 >> 2], HEAP32[$6 + 776 >> 2], HEAP32[$6 + 780 >> 2], HEAP32[$6 + 752 >> 2], HEAP32[$6 + 756 >> 2], HEAP32[$6 + 760 >> 2], HEAP32[$6 + 764 >> 2]);
22118 $10 = HEAP32[$6 + 744 >> 2];
22119 $11 = HEAP32[$6 + 748 >> 2];
22120 $8 = HEAP32[$6 + 736 >> 2];
22121 $7 = HEAP32[$6 + 740 >> 2];
22122 $1 = $1 + 1 | 0;
22123 if (($1 | 0) != 4) {
22124 continue
22125 }
22126 break;
22127 };
22128 __floatsitf($6 + 720 | 0, $5);
22129 __multf3($6 + 704 | 0, $8, $7, $10, $11, HEAP32[$6 + 720 >> 2], HEAP32[$6 + 724 >> 2], HEAP32[$6 + 728 >> 2], HEAP32[$6 + 732 >> 2]);
22130 $10 = HEAP32[$6 + 712 >> 2];
22131 $11 = HEAP32[$6 + 716 >> 2];
22132 $8 = 0;
22133 $7 = 0;
22134 $12 = HEAP32[$6 + 704 >> 2];
22135 $16 = HEAP32[$6 + 708 >> 2];
22136 $23 = $17 + 113 | 0;
22137 $4 = $23 - $4 | 0;
22138 $20 = ($4 | 0) < ($3 | 0);
22139 $1 = $20 ? (($4 | 0) > 0 ? $4 : 0) : $3;
22140 if (($1 | 0) <= 112) {
22141 break label$55
22142 }
22143 $14 = 0;
22144 $15 = 0;
22145 $9 = 0;
22146 $3 = 0;
22147 break label$52;
22148 }
22149 $17 = $7 + $17 | 0;
22150 $9 = $2;
22151 if (($2 | 0) == ($13 | 0)) {
22152 continue
22153 }
22154 break;
22155 };
22156 $11 = 1e9 >>> $7 | 0;
22157 $12 = -1 << $7 ^ -1;
22158 $1 = 0;
22159 $9 = $13;
22160 while (1) {
22161 $15 = ($6 + 784 | 0) + ($13 << 2) | 0;
22162 $16 = HEAP32[$15 >> 2];
22163 $1 = $1 + ($16 >>> $7 | 0) | 0;
22164 HEAP32[$15 >> 2] = $1;
22165 $1 = !$1 & ($9 | 0) == ($13 | 0);
22166 $9 = $1 ? $9 + 1 & 2047 : $9;
22167 $14 = $1 ? $14 + -9 | 0 : $14;
22168 $1 = Math_imul($11, $12 & $16);
22169 $13 = $13 + 1 & 2047;
22170 if (($13 | 0) != ($2 | 0)) {
22171 continue
22172 }
22173 break;
22174 };
22175 if (!$1) {
22176 continue
22177 }
22178 if (($8 | 0) != ($9 | 0)) {
22179 HEAP32[($6 + 784 | 0) + ($2 << 2) >> 2] = $1;
22180 $2 = $8;
22181 continue label$53;
22182 }
22183 HEAP32[$10 >> 2] = HEAP32[$10 >> 2] | 1;
22184 $9 = $8;
22185 continue;
22186 }
22187 break;
22188 };
22189 break;
22190 };
22191 __extenddftf2($6 + 656 | 0, scalbn(1.0, 225 - $1 | 0));
22192 copysignl($6 + 688 | 0, HEAP32[$6 + 656 >> 2], HEAP32[$6 + 660 >> 2], HEAP32[$6 + 664 >> 2], HEAP32[$6 + 668 >> 2], $12, $16, $10, $11);
22193 $9 = HEAP32[$6 + 696 >> 2];
22194 $3 = HEAP32[$6 + 700 >> 2];
22195 $14 = HEAP32[$6 + 688 >> 2];
22196 $15 = HEAP32[$6 + 692 >> 2];
22197 __extenddftf2($6 + 640 | 0, scalbn(1.0, 113 - $1 | 0));
22198 fmodl($6 + 672 | 0, $12, $16, $10, $11, HEAP32[$6 + 640 >> 2], HEAP32[$6 + 644 >> 2], HEAP32[$6 + 648 >> 2], HEAP32[$6 + 652 >> 2]);
22199 $8 = HEAP32[$6 + 672 >> 2];
22200 $7 = HEAP32[$6 + 676 >> 2];
22201 $18 = HEAP32[$6 + 680 >> 2];
22202 $19 = HEAP32[$6 + 684 >> 2];
22203 __subtf3($6 + 624 | 0, $12, $16, $10, $11, $8, $7, $18, $19);
22204 __addtf3($6 + 608 | 0, $14, $15, $9, $3, HEAP32[$6 + 624 >> 2], HEAP32[$6 + 628 >> 2], HEAP32[$6 + 632 >> 2], HEAP32[$6 + 636 >> 2]);
22205 $10 = HEAP32[$6 + 616 >> 2];
22206 $11 = HEAP32[$6 + 620 >> 2];
22207 $12 = HEAP32[$6 + 608 >> 2];
22208 $16 = HEAP32[$6 + 612 >> 2];
22209 }
22210 $21 = $13 + 4 & 2047;
22211 label$64 : {
22212 if (($21 | 0) == ($2 | 0)) {
22213 break label$64
22214 }
22215 $21 = HEAP32[($6 + 784 | 0) + ($21 << 2) >> 2];
22216 label$65 : {
22217 if ($21 >>> 0 <= 499999999) {
22218 if (($13 + 5 & 2047) == ($2 | 0) ? !$21 : 0) {
22219 break label$65
22220 }
22221 __extenddftf2($6 + 496 | 0, +($5 | 0) * .25);
22222 __addtf3($6 + 480 | 0, $8, $7, $18, $19, HEAP32[$6 + 496 >> 2], HEAP32[$6 + 500 >> 2], HEAP32[$6 + 504 >> 2], HEAP32[$6 + 508 >> 2]);
22223 $18 = HEAP32[$6 + 488 >> 2];
22224 $19 = HEAP32[$6 + 492 >> 2];
22225 $8 = HEAP32[$6 + 480 >> 2];
22226 $7 = HEAP32[$6 + 484 >> 2];
22227 break label$65;
22228 }
22229 if (($21 | 0) != 5e8) {
22230 __extenddftf2($6 + 592 | 0, +($5 | 0) * .75);
22231 __addtf3($6 + 576 | 0, $8, $7, $18, $19, HEAP32[$6 + 592 >> 2], HEAP32[$6 + 596 >> 2], HEAP32[$6 + 600 >> 2], HEAP32[$6 + 604 >> 2]);
22232 $18 = HEAP32[$6 + 584 >> 2];
22233 $19 = HEAP32[$6 + 588 >> 2];
22234 $8 = HEAP32[$6 + 576 >> 2];
22235 $7 = HEAP32[$6 + 580 >> 2];
22236 break label$65;
22237 }
22238 $24 = +($5 | 0);
22239 if (($13 + 5 & 2047) == ($2 | 0)) {
22240 __extenddftf2($6 + 528 | 0, $24 * .5);
22241 __addtf3($6 + 512 | 0, $8, $7, $18, $19, HEAP32[$6 + 528 >> 2], HEAP32[$6 + 532 >> 2], HEAP32[$6 + 536 >> 2], HEAP32[$6 + 540 >> 2]);
22242 $18 = HEAP32[$6 + 520 >> 2];
22243 $19 = HEAP32[$6 + 524 >> 2];
22244 $8 = HEAP32[$6 + 512 >> 2];
22245 $7 = HEAP32[$6 + 516 >> 2];
22246 break label$65;
22247 }
22248 __extenddftf2($6 + 560 | 0, $24 * .75);
22249 __addtf3($6 + 544 | 0, $8, $7, $18, $19, HEAP32[$6 + 560 >> 2], HEAP32[$6 + 564 >> 2], HEAP32[$6 + 568 >> 2], HEAP32[$6 + 572 >> 2]);
22250 $18 = HEAP32[$6 + 552 >> 2];
22251 $19 = HEAP32[$6 + 556 >> 2];
22252 $8 = HEAP32[$6 + 544 >> 2];
22253 $7 = HEAP32[$6 + 548 >> 2];
22254 }
22255 if (($1 | 0) > 111) {
22256 break label$64
22257 }
22258 fmodl($6 + 464 | 0, $8, $7, $18, $19, 0, 0, 0, 1073676288);
22259 if (__letf2(HEAP32[$6 + 464 >> 2], HEAP32[$6 + 468 >> 2], HEAP32[$6 + 472 >> 2], HEAP32[$6 + 476 >> 2], 0, 0, 0, 0)) {
22260 break label$64
22261 }
22262 __addtf3($6 + 448 | 0, $8, $7, $18, $19, 0, 0, 0, 1073676288);
22263 $18 = HEAP32[$6 + 456 >> 2];
22264 $19 = HEAP32[$6 + 460 >> 2];
22265 $8 = HEAP32[$6 + 448 >> 2];
22266 $7 = HEAP32[$6 + 452 >> 2];
22267 }
22268 __addtf3($6 + 432 | 0, $12, $16, $10, $11, $8, $7, $18, $19);
22269 __subtf3($6 + 416 | 0, HEAP32[$6 + 432 >> 2], HEAP32[$6 + 436 >> 2], HEAP32[$6 + 440 >> 2], HEAP32[$6 + 444 >> 2], $14, $15, $9, $3);
22270 $10 = HEAP32[$6 + 424 >> 2];
22271 $11 = HEAP32[$6 + 428 >> 2];
22272 $12 = HEAP32[$6 + 416 >> 2];
22273 $16 = HEAP32[$6 + 420 >> 2];
22274 label$69 : {
22275 if (($23 & 2147483647) <= (-2 - $22 | 0)) {
22276 break label$69
22277 }
22278 $2 = $6 + 400 | 0;
22279 HEAP32[$2 + 8 >> 2] = $10;
22280 HEAP32[$2 + 12 >> 2] = $11 & 2147483647;
22281 HEAP32[$2 >> 2] = $12;
22282 HEAP32[$2 + 4 >> 2] = $16;
22283 __multf3($6 + 384 | 0, $12, $16, $10, $11, 0, 0, 0, 1073610752);
22284 $3 = __getf2(HEAP32[$6 + 400 >> 2], HEAP32[$6 + 404 >> 2], HEAP32[$6 + 408 >> 2], HEAP32[$6 + 412 >> 2], 1081081856);
22285 $2 = ($3 | 0) < 0;
22286 $10 = $2 ? $10 : HEAP32[$6 + 392 >> 2];
22287 $11 = $2 ? $11 : HEAP32[$6 + 396 >> 2];
22288 $12 = $2 ? $12 : HEAP32[$6 + 384 >> 2];
22289 $16 = $2 ? $16 : HEAP32[$6 + 388 >> 2];
22290 $17 = (($3 | 0) > -1) + $17 | 0;
22291 if (wasm2js_i32$0 = !($20 & ($2 | ($1 | 0) != ($4 | 0)) & (__letf2($8, $7, $18, $19, 0, 0, 0, 0) | 0) != 0), wasm2js_i32$1 = 0, wasm2js_i32$2 = ($17 + 110 | 0) <= ($25 | 0), wasm2js_i32$2 ? wasm2js_i32$0 : wasm2js_i32$1) {
22292 break label$69
22293 }
22294 HEAP32[2896] = 68;
22295 }
22296 scalbnl($6 + 368 | 0, $12, $16, $10, $11, $17);
22297 $10 = HEAP32[$6 + 368 >> 2];
22298 $11 = HEAP32[$6 + 372 >> 2];
22299 $2 = HEAP32[$6 + 376 >> 2];
22300 $1 = HEAP32[$6 + 380 >> 2];
22301 }
22302 HEAP32[$0 >> 2] = $10;
22303 HEAP32[$0 + 4 >> 2] = $11;
22304 HEAP32[$0 + 8 >> 2] = $2;
22305 HEAP32[$0 + 12 >> 2] = $1;
22306 global$0 = $6 + 8976 | 0;
22307 }
22308
22309 function scanexp($0) {
22310 var $1 = 0, $2 = 0, $3 = 0, $4 = 0, $5 = 0;
22311 label$1 : {
22312 label$2 : {
22313 label$3 : {
22314 $3 = HEAP32[$0 + 4 >> 2];
22315 label$4 : {
22316 if ($3 >>> 0 < HEAPU32[$0 + 104 >> 2]) {
22317 HEAP32[$0 + 4 >> 2] = $3 + 1;
22318 $2 = HEAPU8[$3 | 0];
22319 break label$4;
22320 }
22321 $2 = __shgetc($0);
22322 }
22323 switch ($2 + -43 | 0) {
22324 case 0:
22325 case 2:
22326 break label$2;
22327 default:
22328 break label$3;
22329 };
22330 }
22331 $1 = $2 + -48 | 0;
22332 break label$1;
22333 }
22334 $5 = ($2 | 0) == 45;
22335 $3 = HEAP32[$0 + 4 >> 2];
22336 label$6 : {
22337 if ($3 >>> 0 < HEAPU32[$0 + 104 >> 2]) {
22338 HEAP32[$0 + 4 >> 2] = $3 + 1;
22339 $2 = HEAPU8[$3 | 0];
22340 break label$6;
22341 }
22342 $2 = __shgetc($0);
22343 }
22344 $1 = $2 + -48 | 0;
22345 if (!($1 >>> 0 < 10 | !HEAP32[$0 + 104 >> 2])) {
22346 HEAP32[$0 + 4 >> 2] = HEAP32[$0 + 4 >> 2] + -1
22347 }
22348 }
22349 label$9 : {
22350 if ($1 >>> 0 < 10) {
22351 $1 = 0;
22352 while (1) {
22353 $1 = Math_imul($1, 10) + $2 | 0;
22354 $3 = HEAP32[$0 + 4 >> 2];
22355 label$12 : {
22356 if ($3 >>> 0 < HEAPU32[$0 + 104 >> 2]) {
22357 HEAP32[$0 + 4 >> 2] = $3 + 1;
22358 $2 = HEAPU8[$3 | 0];
22359 break label$12;
22360 }
22361 $2 = __shgetc($0);
22362 }
22363 $4 = $2 + -48 | 0;
22364 $1 = $1 + -48 | 0;
22365 if (($1 | 0) < 214748364 ? $4 >>> 0 <= 9 : 0) {
22366 continue
22367 }
22368 break;
22369 };
22370 $3 = $1;
22371 $1 = $1 >> 31;
22372 label$14 : {
22373 if ($4 >>> 0 >= 10) {
22374 break label$14
22375 }
22376 while (1) {
22377 $1 = __wasm_i64_mul($3, $1, 10, 0);
22378 $3 = $1 + $2 | 0;
22379 $2 = i64toi32_i32$HIGH_BITS;
22380 $4 = $3 >>> 0 < $1 >>> 0 ? $2 + 1 | 0 : $2;
22381 $1 = HEAP32[$0 + 4 >> 2];
22382 label$16 : {
22383 if ($1 >>> 0 < HEAPU32[$0 + 104 >> 2]) {
22384 HEAP32[$0 + 4 >> 2] = $1 + 1;
22385 $2 = HEAPU8[$1 | 0];
22386 break label$16;
22387 }
22388 $2 = __shgetc($0);
22389 }
22390 $1 = $4 + -1 | 0;
22391 $3 = $3 + -48 | 0;
22392 if ($3 >>> 0 < 4294967248) {
22393 $1 = $1 + 1 | 0
22394 }
22395 $4 = $2 + -48 | 0;
22396 if ($4 >>> 0 > 9) {
22397 break label$14
22398 }
22399 if (($1 | 0) < 21474836 ? 1 : ($1 | 0) <= 21474836 ? ($3 >>> 0 >= 2061584302 ? 0 : 1) : 0) {
22400 continue
22401 }
22402 break;
22403 };
22404 }
22405 if ($4 >>> 0 < 10) {
22406 while (1) {
22407 $2 = HEAP32[$0 + 4 >> 2];
22408 label$20 : {
22409 if ($2 >>> 0 < HEAPU32[$0 + 104 >> 2]) {
22410 HEAP32[$0 + 4 >> 2] = $2 + 1;
22411 $2 = HEAPU8[$2 | 0];
22412 break label$20;
22413 }
22414 $2 = __shgetc($0);
22415 }
22416 if ($2 + -48 >>> 0 < 10) {
22417 continue
22418 }
22419 break;
22420 }
22421 }
22422 if (HEAP32[$0 + 104 >> 2]) {
22423 HEAP32[$0 + 4 >> 2] = HEAP32[$0 + 4 >> 2] + -1
22424 }
22425 $0 = $3;
22426 $3 = $5 ? 0 - $0 | 0 : $0;
22427 $1 = $5 ? 0 - ($1 + (0 < $0 >>> 0) | 0) | 0 : $1;
22428 break label$9;
22429 }
22430 $3 = 0;
22431 $1 = -2147483648;
22432 if (!HEAP32[$0 + 104 >> 2]) {
22433 break label$9
22434 }
22435 HEAP32[$0 + 4 >> 2] = HEAP32[$0 + 4 >> 2] + -1;
22436 i64toi32_i32$HIGH_BITS = -2147483648;
22437 return 0;
22438 }
22439 i64toi32_i32$HIGH_BITS = $1;
22440 return $3;
22441 }
22442
22443 function strtox($0, $1) {
22444 var $2 = 0, $3 = 0, $4 = 0;
22445 $2 = global$0 - 160 | 0;
22446 global$0 = $2;
22447 memset($2 + 16 | 0, 144);
22448 HEAP32[$2 + 92 >> 2] = -1;
22449 HEAP32[$2 + 60 >> 2] = $1;
22450 HEAP32[$2 + 24 >> 2] = -1;
22451 HEAP32[$2 + 20 >> 2] = $1;
22452 __shlim($2 + 16 | 0);
22453 __floatscan($2, $2 + 16 | 0);
22454 $1 = HEAP32[$2 + 8 >> 2];
22455 $3 = HEAP32[$2 + 12 >> 2];
22456 $4 = HEAP32[$2 + 4 >> 2];
22457 HEAP32[$0 >> 2] = HEAP32[$2 >> 2];
22458 HEAP32[$0 + 4 >> 2] = $4;
22459 HEAP32[$0 + 8 >> 2] = $1;
22460 HEAP32[$0 + 12 >> 2] = $3;
22461 global$0 = $2 + 160 | 0;
22462 }
22463
22464 function strtod($0) {
22465 var $1 = 0, $2 = 0.0;
22466 $1 = global$0 - 16 | 0;
22467 global$0 = $1;
22468 strtox($1, $0);
22469 $2 = __trunctfdf2(HEAP32[$1 >> 2], HEAP32[$1 + 4 >> 2], HEAP32[$1 + 8 >> 2], HEAP32[$1 + 12 >> 2]);
22470 global$0 = $1 + 16 | 0;
22471 return $2;
22472 }
22473
22474 function FLAC__stream_encoder_new() {
22475 var $0 = 0, $1 = 0, $2 = 0, $3 = 0;
22476 $1 = dlcalloc(1, 8);
22477 if (!$1) {
22478 return 0
22479 }
22480 $0 = dlcalloc(1, 1032);
22481 HEAP32[$1 >> 2] = $0;
22482 label$2 : {
22483 if (!$0) {
22484 break label$2
22485 }
22486 $3 = dlcalloc(1, 11856);
22487 HEAP32[$1 + 4 >> 2] = $3;
22488 if (!$3) {
22489 dlfree($0);
22490 break label$2;
22491 }
22492 $0 = dlcalloc(1, 20);
22493 $3 = HEAP32[$1 + 4 >> 2];
22494 HEAP32[$3 + 6856 >> 2] = $0;
22495 if (!$0) {
22496 dlfree($3);
22497 dlfree(HEAP32[$1 >> 2]);
22498 break label$2;
22499 }
22500 HEAP32[$3 + 7296 >> 2] = 0;
22501 $0 = HEAP32[$1 >> 2];
22502 HEAP32[$0 + 44 >> 2] = 13;
22503 HEAP32[$0 + 48 >> 2] = 1056964608;
22504 HEAP32[$0 + 36 >> 2] = 0;
22505 HEAP32[$0 + 40 >> 2] = 1;
22506 HEAP32[$0 + 28 >> 2] = 16;
22507 HEAP32[$0 + 32 >> 2] = 44100;
22508 HEAP32[$0 + 20 >> 2] = 0;
22509 HEAP32[$0 + 24 >> 2] = 2;
22510 HEAP32[$0 + 12 >> 2] = 1;
22511 HEAP32[$0 + 16 >> 2] = 0;
22512 HEAP32[$0 + 4 >> 2] = 0;
22513 HEAP32[$0 + 8 >> 2] = 1;
22514 $0 = HEAP32[$1 >> 2];
22515 HEAP32[$0 + 592 >> 2] = 0;
22516 HEAP32[$0 + 596 >> 2] = 0;
22517 HEAP32[$0 + 556 >> 2] = 0;
22518 HEAP32[$0 + 560 >> 2] = 0;
22519 HEAP32[$0 + 564 >> 2] = 0;
22520 HEAP32[$0 + 568 >> 2] = 0;
22521 HEAP32[$0 + 572 >> 2] = 0;
22522 HEAP32[$0 + 576 >> 2] = 0;
22523 HEAP32[$0 + 580 >> 2] = 0;
22524 HEAP32[$0 + 584 >> 2] = 0;
22525 HEAP32[$0 + 600 >> 2] = 0;
22526 HEAP32[$0 + 604 >> 2] = 0;
22527 $3 = HEAP32[$1 + 4 >> 2];
22528 $2 = $3;
22529 HEAP32[$2 + 7248 >> 2] = 0;
22530 HEAP32[$2 + 7252 >> 2] = 0;
22531 HEAP32[$2 + 7048 >> 2] = 0;
22532 $2 = $2 + 7256 | 0;
22533 HEAP32[$2 >> 2] = 0;
22534 HEAP32[$2 + 4 >> 2] = 0;
22535 $2 = $3 + 7264 | 0;
22536 HEAP32[$2 >> 2] = 0;
22537 HEAP32[$2 + 4 >> 2] = 0;
22538 $2 = $3 + 7272 | 0;
22539 HEAP32[$2 >> 2] = 0;
22540 HEAP32[$2 + 4 >> 2] = 0;
22541 $2 = $3 + 7280 | 0;
22542 HEAP32[$2 >> 2] = 0;
22543 HEAP32[$2 + 4 >> 2] = 0;
22544 HEAP32[$3 + 7288 >> 2] = 0;
22545 FLAC__ogg_encoder_aspect_set_defaults($0 + 632 | 0);
22546 $0 = HEAP32[$1 >> 2];
22547 label$5 : {
22548 if (HEAP32[$0 >> 2] != 1) {
22549 break label$5
22550 }
22551 HEAP32[$0 + 16 >> 2] = 1;
22552 HEAP32[$0 + 20 >> 2] = 0;
22553 FLAC__stream_encoder_set_apodization($1, 10777);
22554 $0 = HEAP32[$1 >> 2];
22555 if (HEAP32[$0 >> 2] != 1) {
22556 break label$5
22557 }
22558 HEAP32[$0 + 576 >> 2] = 0;
22559 HEAP32[$0 + 580 >> 2] = 5;
22560 HEAP32[$0 + 564 >> 2] = 0;
22561 HEAP32[$0 + 568 >> 2] = 0;
22562 HEAP32[$0 + 556 >> 2] = 8;
22563 HEAP32[$0 + 560 >> 2] = 0;
22564 }
22565 $0 = HEAP32[$1 + 4 >> 2];
22566 HEAP32[$0 + 11848 >> 2] = 0;
22567 HEAP32[$0 + 6176 >> 2] = $0 + 336;
22568 $0 = HEAP32[$1 + 4 >> 2];
22569 HEAP32[$0 + 6180 >> 2] = $0 + 628;
22570 $0 = HEAP32[$1 + 4 >> 2];
22571 HEAP32[$0 + 6184 >> 2] = $0 + 920;
22572 $0 = HEAP32[$1 + 4 >> 2];
22573 HEAP32[$0 + 6188 >> 2] = $0 + 1212;
22574 $0 = HEAP32[$1 + 4 >> 2];
22575 HEAP32[$0 + 6192 >> 2] = $0 + 1504;
22576 $0 = HEAP32[$1 + 4 >> 2];
22577 HEAP32[$0 + 6196 >> 2] = $0 + 1796;
22578 $0 = HEAP32[$1 + 4 >> 2];
22579 HEAP32[$0 + 6200 >> 2] = $0 + 2088;
22580 $0 = HEAP32[$1 + 4 >> 2];
22581 HEAP32[$0 + 6204 >> 2] = $0 + 2380;
22582 $0 = HEAP32[$1 + 4 >> 2];
22583 HEAP32[$0 + 6208 >> 2] = $0 + 2672;
22584 $0 = HEAP32[$1 + 4 >> 2];
22585 HEAP32[$0 + 6212 >> 2] = $0 + 2964;
22586 $0 = HEAP32[$1 + 4 >> 2];
22587 HEAP32[$0 + 6216 >> 2] = $0 + 3256;
22588 $0 = HEAP32[$1 + 4 >> 2];
22589 HEAP32[$0 + 6220 >> 2] = $0 + 3548;
22590 $0 = HEAP32[$1 + 4 >> 2];
22591 HEAP32[$0 + 6224 >> 2] = $0 + 3840;
22592 $0 = HEAP32[$1 + 4 >> 2];
22593 HEAP32[$0 + 6228 >> 2] = $0 + 4132;
22594 $0 = HEAP32[$1 + 4 >> 2];
22595 HEAP32[$0 + 6232 >> 2] = $0 + 4424;
22596 $0 = HEAP32[$1 + 4 >> 2];
22597 HEAP32[$0 + 6236 >> 2] = $0 + 4716;
22598 $0 = HEAP32[$1 + 4 >> 2];
22599 HEAP32[$0 + 6240 >> 2] = $0 + 5008;
22600 $0 = HEAP32[$1 + 4 >> 2];
22601 HEAP32[$0 + 6244 >> 2] = $0 + 5300;
22602 $0 = HEAP32[$1 + 4 >> 2];
22603 HEAP32[$0 + 6248 >> 2] = $0 + 5592;
22604 $0 = HEAP32[$1 + 4 >> 2];
22605 HEAP32[$0 + 6252 >> 2] = $0 + 5884;
22606 $0 = HEAP32[$1 + 4 >> 2];
22607 HEAP32[$0 + 6640 >> 2] = $0 + 6256;
22608 $0 = HEAP32[$1 + 4 >> 2];
22609 HEAP32[$0 + 6644 >> 2] = $0 + 6268;
22610 $0 = HEAP32[$1 + 4 >> 2];
22611 HEAP32[$0 + 6648 >> 2] = $0 + 6280;
22612 $0 = HEAP32[$1 + 4 >> 2];
22613 HEAP32[$0 + 6652 >> 2] = $0 + 6292;
22614 $0 = HEAP32[$1 + 4 >> 2];
22615 HEAP32[$0 + 6656 >> 2] = $0 + 6304;
22616 $0 = HEAP32[$1 + 4 >> 2];
22617 HEAP32[$0 + 6660 >> 2] = $0 + 6316;
22618 $0 = HEAP32[$1 + 4 >> 2];
22619 HEAP32[$0 + 6664 >> 2] = $0 + 6328;
22620 $0 = HEAP32[$1 + 4 >> 2];
22621 HEAP32[$0 + 6668 >> 2] = $0 + 6340;
22622 $0 = HEAP32[$1 + 4 >> 2];
22623 HEAP32[$0 + 6672 >> 2] = $0 + 6352;
22624 $0 = HEAP32[$1 + 4 >> 2];
22625 HEAP32[$0 + 6676 >> 2] = $0 + 6364;
22626 $0 = HEAP32[$1 + 4 >> 2];
22627 HEAP32[$0 + 6680 >> 2] = $0 + 6376;
22628 $0 = HEAP32[$1 + 4 >> 2];
22629 HEAP32[$0 + 6684 >> 2] = $0 + 6388;
22630 $0 = HEAP32[$1 + 4 >> 2];
22631 HEAP32[$0 + 6688 >> 2] = $0 + 6400;
22632 $0 = HEAP32[$1 + 4 >> 2];
22633 HEAP32[$0 + 6692 >> 2] = $0 + 6412;
22634 $0 = HEAP32[$1 + 4 >> 2];
22635 HEAP32[$0 + 6696 >> 2] = $0 + 6424;
22636 $0 = HEAP32[$1 + 4 >> 2];
22637 HEAP32[$0 + 6700 >> 2] = $0 + 6436;
22638 $0 = HEAP32[$1 + 4 >> 2];
22639 HEAP32[$0 + 6704 >> 2] = $0 + 6448;
22640 $0 = HEAP32[$1 + 4 >> 2];
22641 HEAP32[$0 + 6708 >> 2] = $0 + 6460;
22642 $0 = HEAP32[$1 + 4 >> 2];
22643 HEAP32[$0 + 6712 >> 2] = $0 + 6472;
22644 $0 = HEAP32[$1 + 4 >> 2];
22645 HEAP32[$0 + 6716 >> 2] = $0 + 6484;
22646 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(HEAP32[$1 + 4 >> 2] + 6256 | 0);
22647 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(HEAP32[$1 + 4 >> 2] + 6268 | 0);
22648 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(HEAP32[$1 + 4 >> 2] + 6280 | 0);
22649 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(HEAP32[$1 + 4 >> 2] + 6292 | 0);
22650 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(HEAP32[$1 + 4 >> 2] + 6304 | 0);
22651 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(HEAP32[$1 + 4 >> 2] + 6316 | 0);
22652 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(HEAP32[$1 + 4 >> 2] + 6328 | 0);
22653 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(HEAP32[$1 + 4 >> 2] + 6340 | 0);
22654 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(HEAP32[$1 + 4 >> 2] + 6352 | 0);
22655 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(HEAP32[$1 + 4 >> 2] + 6364 | 0);
22656 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(HEAP32[$1 + 4 >> 2] + 6376 | 0);
22657 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(HEAP32[$1 + 4 >> 2] + 6388 | 0);
22658 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(HEAP32[$1 + 4 >> 2] + 6400 | 0);
22659 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(HEAP32[$1 + 4 >> 2] + 6412 | 0);
22660 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(HEAP32[$1 + 4 >> 2] + 6424 | 0);
22661 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(HEAP32[$1 + 4 >> 2] + 6436 | 0);
22662 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(HEAP32[$1 + 4 >> 2] + 6448 | 0);
22663 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(HEAP32[$1 + 4 >> 2] + 6460 | 0);
22664 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(HEAP32[$1 + 4 >> 2] + 6472 | 0);
22665 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(HEAP32[$1 + 4 >> 2] + 6484 | 0);
22666 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(HEAP32[$1 + 4 >> 2] + 11724 | 0);
22667 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(HEAP32[$1 + 4 >> 2] + 11736 | 0);
22668 HEAP32[HEAP32[$1 >> 2] >> 2] = 1;
22669 return $1 | 0;
22670 }
22671 dlfree($1);
22672 return 0;
22673 }
22674
22675 function FLAC__stream_encoder_set_apodization($0, $1) {
22676 var $2 = 0, $3 = 0, $4 = 0, $5 = Math_fround(0), $6 = Math_fround(0), $7 = 0, $8 = 0.0, $9 = Math_fround(0), $10 = 0, $11 = 0;
22677 $2 = HEAP32[$0 >> 2];
22678 label$1 : {
22679 if (HEAP32[$2 >> 2] != 1) {
22680 break label$1
22681 }
22682 HEAP32[$2 + 40 >> 2] = 0;
22683 while (1) {
22684 label$3 : {
22685 label$4 : {
22686 label$5 : {
22687 label$6 : {
22688 label$7 : {
22689 label$8 : {
22690 label$9 : {
22691 label$10 : {
22692 label$11 : {
22693 label$12 : {
22694 label$13 : {
22695 label$14 : {
22696 label$15 : {
22697 label$16 : {
22698 $10 = strchr($1, 59);
22699 label$17 : {
22700 if ($10) {
22701 $4 = $10 - $1 | 0;
22702 break label$17;
22703 }
22704 $4 = strlen($1);
22705 }
22706 $11 = ($4 | 0) != 8;
22707 if (!$11) {
22708 if (strncmp(10584, $1, 8)) {
22709 break label$16
22710 }
22711 HEAP32[$2 + 40 >> 2] = $3 + 1;
22712 HEAP32[(($3 << 4) + $2 | 0) + 44 >> 2] = 0;
22713 break label$3;
22714 }
22715 label$20 : {
22716 switch ($4 + -6 | 0) {
22717 case 1:
22718 break label$13;
22719 case 0:
22720 break label$14;
22721 case 20:
22722 break label$15;
22723 case 7:
22724 break label$20;
22725 default:
22726 break label$12;
22727 };
22728 }
22729 $7 = 1;
22730 if (strncmp(10593, $1, 13)) {
22731 break label$11
22732 }
22733 HEAP32[$2 + 40 >> 2] = $3 + 1;
22734 HEAP32[(($3 << 4) + $2 | 0) + 44 >> 2] = 1;
22735 break label$3;
22736 }
22737 $7 = 0;
22738 if (strncmp(10607, $1, 8)) {
22739 break label$11
22740 }
22741 HEAP32[$2 + 40 >> 2] = $3 + 1;
22742 HEAP32[(($3 << 4) + $2 | 0) + 44 >> 2] = 2;
22743 break label$3;
22744 }
22745 $7 = 0;
22746 if (strncmp(10616, $1, 26)) {
22747 break label$11
22748 }
22749 HEAP32[$2 + 40 >> 2] = $3 + 1;
22750 HEAP32[(($3 << 4) + $2 | 0) + 44 >> 2] = 3;
22751 break label$3;
22752 }
22753 if (strncmp(10643, $1, 6)) {
22754 break label$3
22755 }
22756 HEAP32[$2 + 40 >> 2] = $3 + 1;
22757 HEAP32[(($3 << 4) + $2 | 0) + 44 >> 2] = 4;
22758 break label$3;
22759 }
22760 if (strncmp(10650, $1, 7)) {
22761 break label$10
22762 }
22763 HEAP32[$2 + 40 >> 2] = $3 + 1;
22764 HEAP32[(($3 << 4) + $2 | 0) + 44 >> 2] = 5;
22765 break label$3;
22766 }
22767 $7 = 0;
22768 if ($4 >>> 0 < 8) {
22769 break label$9
22770 }
22771 }
22772 if (strncmp(10658, $1, 6)) {
22773 break label$8
22774 }
22775 $6 = Math_fround(strtod($1 + 6 | 0));
22776 if ($6 > Math_fround(0.0) ^ 1 | $6 <= Math_fround(.5) ^ 1) {
22777 break label$3
22778 }
22779 $1 = HEAP32[$0 >> 2];
22780 HEAPF32[((HEAP32[$1 + 40 >> 2] << 4) + $1 | 0) + 48 >> 2] = $6;
22781 $1 = HEAP32[$0 >> 2];
22782 $4 = HEAP32[$1 + 40 >> 2];
22783 HEAP32[$1 + 40 >> 2] = $4 + 1;
22784 HEAP32[($1 + ($4 << 4) | 0) + 44 >> 2] = 6;
22785 break label$3;
22786 }
22787 if (strncmp(10665, $1, 7)) {
22788 break label$7
22789 }
22790 HEAP32[$2 + 40 >> 2] = $3 + 1;
22791 HEAP32[(($3 << 4) + $2 | 0) + 44 >> 2] = 7;
22792 break label$3;
22793 }
22794 label$21 : {
22795 switch ($4 + -4 | 0) {
22796 case 0:
22797 break label$21;
22798 case 1:
22799 break label$5;
22800 default:
22801 break label$3;
22802 };
22803 }
22804 if (strncmp(10673, $1, 4)) {
22805 break label$3
22806 }
22807 HEAP32[$2 + 40 >> 2] = $3 + 1;
22808 HEAP32[(($3 << 4) + $2 | 0) + 44 >> 2] = 8;
22809 break label$3;
22810 }
22811 if (!$7) {
22812 break label$6
22813 }
22814 if (strncmp(10678, $1, 13)) {
22815 break label$6
22816 }
22817 HEAP32[$2 + 40 >> 2] = $3 + 1;
22818 HEAP32[(($3 << 4) + $2 | 0) + 44 >> 2] = 9;
22819 break label$3;
22820 }
22821 if (strncmp(10692, $1, 7)) {
22822 break label$3
22823 }
22824 HEAP32[$2 + 40 >> 2] = $3 + 1;
22825 HEAP32[(($3 << 4) + $2 | 0) + 44 >> 2] = 10;
22826 break label$3;
22827 }
22828 label$22 : {
22829 if (($4 | 0) != 9) {
22830 break label$22
22831 }
22832 if (strncmp(10700, $1, 9)) {
22833 break label$22
22834 }
22835 HEAP32[$2 + 40 >> 2] = $3 + 1;
22836 HEAP32[(($3 << 4) + $2 | 0) + 44 >> 2] = 11;
22837 break label$3;
22838 }
22839 if (!$11) {
22840 if (!strncmp(10710, $1, 8)) {
22841 HEAP32[$2 + 40 >> 2] = $3 + 1;
22842 HEAP32[(($3 << 4) + $2 | 0) + 44 >> 2] = 12;
22843 break label$3;
22844 }
22845 if (strncmp(10719, $1, 6)) {
22846 break label$3
22847 }
22848 break label$4;
22849 }
22850 if (!strncmp(10719, $1, 6)) {
22851 break label$4
22852 }
22853 if ($4 >>> 0 < 16) {
22854 break label$3
22855 }
22856 if (!strncmp(10726, $1, 14)) {
22857 $8 = strtod($1 + 14 | 0);
22858 label$26 : {
22859 if (Math_abs($8) < 2147483648.0) {
22860 $4 = ~~$8;
22861 break label$26;
22862 }
22863 $4 = -2147483648;
22864 }
22865 $3 = strchr($1, 47);
22866 $5 = Math_fround(.10000000149011612);
22867 label$28 : {
22868 if (!$3) {
22869 break label$28
22870 }
22871 $2 = $3 + 1 | 0;
22872 $5 = Math_fround(.9900000095367432);
22873 if (!(Math_fround(strtod($2)) < Math_fround(.9900000095367432))) {
22874 break label$28
22875 }
22876 $5 = Math_fround(strtod($2));
22877 }
22878 $1 = strchr($3 ? $3 + 1 | 0 : $1, 47);
22879 $6 = Math_fround(.20000000298023224);
22880 label$30 : {
22881 if (!$1) {
22882 break label$30
22883 }
22884 $6 = Math_fround(strtod($1 + 1 | 0));
22885 }
22886 $1 = HEAP32[$0 >> 2];
22887 $2 = HEAP32[$1 + 40 >> 2];
22888 if (($4 | 0) <= 1) {
22889 HEAPF32[(($2 << 4) + $1 | 0) + 48 >> 2] = $6;
22890 $1 = HEAP32[$0 >> 2];
22891 $4 = HEAP32[$1 + 40 >> 2];
22892 HEAP32[$1 + 40 >> 2] = $4 + 1;
22893 HEAP32[($1 + ($4 << 4) | 0) + 44 >> 2] = 13;
22894 break label$3;
22895 }
22896 if ($2 + $4 >>> 0 > 31) {
22897 break label$3
22898 }
22899 $9 = Math_fround(Math_fround(Math_fround(1.0) / Math_fround(Math_fround(1.0) - $5)) + Math_fround(-1.0));
22900 $5 = Math_fround($9 + Math_fround($4 | 0));
22901 $3 = 0;
22902 while (1) {
22903 HEAPF32[(($2 << 4) + $1 | 0) + 48 >> 2] = $6;
22904 $1 = HEAP32[$0 >> 2];
22905 HEAPF32[((HEAP32[$1 + 40 >> 2] << 4) + $1 | 0) + 52 >> 2] = Math_fround($3 | 0) / $5;
22906 $1 = HEAP32[$0 >> 2];
22907 $3 = $3 + 1 | 0;
22908 HEAPF32[((HEAP32[$1 + 40 >> 2] << 4) + $1 | 0) + 56 >> 2] = Math_fround($9 + Math_fround($3 | 0)) / $5;
22909 $1 = HEAP32[$0 >> 2];
22910 $7 = HEAP32[$1 + 40 >> 2];
22911 $2 = $7 + 1 | 0;
22912 HEAP32[$1 + 40 >> 2] = $2;
22913 HEAP32[(($7 << 4) + $1 | 0) + 44 >> 2] = 14;
22914 if (($3 | 0) != ($4 | 0)) {
22915 continue
22916 }
22917 break;
22918 };
22919 break label$3;
22920 }
22921 if ($4 >>> 0 < 17) {
22922 break label$3
22923 }
22924 if (strncmp(10741, $1, 15)) {
22925 break label$3
22926 }
22927 $8 = strtod($1 + 15 | 0);
22928 label$33 : {
22929 if (Math_abs($8) < 2147483648.0) {
22930 $4 = ~~$8;
22931 break label$33;
22932 }
22933 $4 = -2147483648;
22934 }
22935 $6 = Math_fround(.20000000298023224);
22936 $3 = strchr($1, 47);
22937 $5 = Math_fround(.20000000298023224);
22938 label$35 : {
22939 if (!$3) {
22940 break label$35
22941 }
22942 $2 = $3 + 1 | 0;
22943 $5 = Math_fround(.9900000095367432);
22944 if (!(Math_fround(strtod($2)) < Math_fround(.9900000095367432))) {
22945 break label$35
22946 }
22947 $5 = Math_fround(strtod($2));
22948 }
22949 $1 = strchr($3 ? $3 + 1 | 0 : $1, 47);
22950 if ($1) {
22951 $6 = Math_fround(strtod($1 + 1 | 0))
22952 }
22953 $1 = HEAP32[$0 >> 2];
22954 $2 = HEAP32[$1 + 40 >> 2];
22955 if (($4 | 0) <= 1) {
22956 HEAPF32[(($2 << 4) + $1 | 0) + 48 >> 2] = $6;
22957 $1 = HEAP32[$0 >> 2];
22958 $4 = HEAP32[$1 + 40 >> 2];
22959 HEAP32[$1 + 40 >> 2] = $4 + 1;
22960 HEAP32[($1 + ($4 << 4) | 0) + 44 >> 2] = 13;
22961 break label$3;
22962 }
22963 if ($2 + $4 >>> 0 > 31) {
22964 break label$3
22965 }
22966 $9 = Math_fround(Math_fround(Math_fround(1.0) / Math_fround(Math_fround(1.0) - $5)) + Math_fround(-1.0));
22967 $5 = Math_fround($9 + Math_fround($4 | 0));
22968 $3 = 0;
22969 while (1) {
22970 HEAPF32[(($2 << 4) + $1 | 0) + 48 >> 2] = $6;
22971 $1 = HEAP32[$0 >> 2];
22972 HEAPF32[((HEAP32[$1 + 40 >> 2] << 4) + $1 | 0) + 52 >> 2] = Math_fround($3 | 0) / $5;
22973 $1 = HEAP32[$0 >> 2];
22974 $3 = $3 + 1 | 0;
22975 HEAPF32[((HEAP32[$1 + 40 >> 2] << 4) + $1 | 0) + 56 >> 2] = Math_fround($9 + Math_fround($3 | 0)) / $5;
22976 $1 = HEAP32[$0 >> 2];
22977 $7 = HEAP32[$1 + 40 >> 2];
22978 $2 = $7 + 1 | 0;
22979 HEAP32[$1 + 40 >> 2] = $2;
22980 HEAP32[(($7 << 4) + $1 | 0) + 44 >> 2] = 15;
22981 if (($3 | 0) != ($4 | 0)) {
22982 continue
22983 }
22984 break;
22985 };
22986 break label$3;
22987 }
22988 if (strncmp(10757, $1, 5)) {
22989 break label$3
22990 }
22991 HEAP32[$2 + 40 >> 2] = $3 + 1;
22992 HEAP32[(($3 << 4) + $2 | 0) + 44 >> 2] = 16;
22993 break label$3;
22994 }
22995 $6 = Math_fround(strtod($1 + 6 | 0));
22996 if ($6 >= Math_fround(0.0) ^ 1 | $6 <= Math_fround(1.0) ^ 1) {
22997 break label$3
22998 }
22999 $1 = HEAP32[$0 >> 2];
23000 HEAPF32[((HEAP32[$1 + 40 >> 2] << 4) + $1 | 0) + 48 >> 2] = $6;
23001 $1 = HEAP32[$0 >> 2];
23002 $4 = HEAP32[$1 + 40 >> 2];
23003 HEAP32[$1 + 40 >> 2] = $4 + 1;
23004 HEAP32[($1 + ($4 << 4) | 0) + 44 >> 2] = 13;
23005 }
23006 $2 = HEAP32[$0 >> 2];
23007 $3 = HEAP32[$2 + 40 >> 2];
23008 if ($10) {
23009 $1 = $10 + 1 | 0;
23010 if (($3 | 0) != 32) {
23011 continue
23012 }
23013 }
23014 break;
23015 };
23016 $4 = 1;
23017 if ($3) {
23018 break label$1
23019 }
23020 HEAP32[$2 + 40 >> 2] = 1;
23021 HEAP32[$2 + 44 >> 2] = 13;
23022 HEAP32[$2 + 48 >> 2] = 1056964608;
23023 }
23024 return $4;
23025 }
23026
23027 function FLAC__stream_encoder_delete($0) {
23028 $0 = $0 | 0;
23029 var $1 = 0, $2 = 0;
23030 if ($0) {
23031 HEAP32[HEAP32[$0 + 4 >> 2] + 11848 >> 2] = 1;
23032 FLAC__stream_encoder_finish($0);
23033 $1 = HEAP32[$0 + 4 >> 2];
23034 $2 = HEAP32[$1 + 11752 >> 2];
23035 if ($2) {
23036 FLAC__stream_decoder_delete($2);
23037 $1 = HEAP32[$0 + 4 >> 2];
23038 }
23039 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear($1 + 6256 | 0);
23040 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(HEAP32[$0 + 4 >> 2] + 6268 | 0);
23041 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(HEAP32[$0 + 4 >> 2] + 6280 | 0);
23042 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(HEAP32[$0 + 4 >> 2] + 6292 | 0);
23043 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(HEAP32[$0 + 4 >> 2] + 6304 | 0);
23044 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(HEAP32[$0 + 4 >> 2] + 6316 | 0);
23045 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(HEAP32[$0 + 4 >> 2] + 6328 | 0);
23046 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(HEAP32[$0 + 4 >> 2] + 6340 | 0);
23047 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(HEAP32[$0 + 4 >> 2] + 6352 | 0);
23048 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(HEAP32[$0 + 4 >> 2] + 6364 | 0);
23049 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(HEAP32[$0 + 4 >> 2] + 6376 | 0);
23050 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(HEAP32[$0 + 4 >> 2] + 6388 | 0);
23051 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(HEAP32[$0 + 4 >> 2] + 6400 | 0);
23052 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(HEAP32[$0 + 4 >> 2] + 6412 | 0);
23053 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(HEAP32[$0 + 4 >> 2] + 6424 | 0);
23054 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(HEAP32[$0 + 4 >> 2] + 6436 | 0);
23055 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(HEAP32[$0 + 4 >> 2] + 6448 | 0);
23056 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(HEAP32[$0 + 4 >> 2] + 6460 | 0);
23057 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(HEAP32[$0 + 4 >> 2] + 6472 | 0);
23058 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(HEAP32[$0 + 4 >> 2] + 6484 | 0);
23059 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(HEAP32[$0 + 4 >> 2] + 11724 | 0);
23060 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(HEAP32[$0 + 4 >> 2] + 11736 | 0);
23061 FLAC__bitreader_delete(HEAP32[HEAP32[$0 + 4 >> 2] + 6856 >> 2]);
23062 dlfree(HEAP32[$0 + 4 >> 2]);
23063 dlfree(HEAP32[$0 >> 2]);
23064 dlfree($0);
23065 }
23066 }
23067
23068 function FLAC__stream_encoder_finish($0) {
23069 $0 = $0 | 0;
23070 var $1 = 0, $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0;
23071 $7 = global$0 - 32 | 0;
23072 global$0 = $7;
23073 label$1 : {
23074 if (!$0) {
23075 break label$1
23076 }
23077 label$3 : {
23078 label$4 : {
23079 $5 = HEAP32[$0 >> 2];
23080 $1 = HEAP32[$5 >> 2];
23081 switch ($1 | 0) {
23082 case 1:
23083 break label$1;
23084 case 0:
23085 break label$4;
23086 default:
23087 break label$3;
23088 };
23089 }
23090 $2 = HEAP32[$0 + 4 >> 2];
23091 if (HEAP32[$2 + 11848 >> 2]) {
23092 break label$3
23093 }
23094 $2 = HEAP32[$2 + 7052 >> 2];
23095 if (!$2) {
23096 break label$3
23097 }
23098 $3 = HEAP32[$5 + 36 >> 2];
23099 HEAP32[$5 + 36 >> 2] = $2;
23100 $3 = !process_frame_($0, ($2 | 0) != ($3 | 0), 1);
23101 $5 = HEAP32[$0 >> 2];
23102 }
23103 if (HEAP32[$5 + 12 >> 2]) {
23104 $2 = HEAP32[$0 + 4 >> 2];
23105 FLAC__MD5Final($2 + 6928 | 0, $2 + 7060 | 0);
23106 }
23107 $5 = $0 + 4 | 0;
23108 $1 = HEAP32[$0 + 4 >> 2];
23109 label$6 : {
23110 if (HEAP32[$1 + 11848 >> 2]) {
23111 $2 = $3;
23112 break label$6;
23113 }
23114 $4 = HEAP32[$0 >> 2];
23115 label$8 : {
23116 if (HEAP32[$4 >> 2]) {
23117 break label$8
23118 }
23119 $11 = HEAP32[$1 + 7268 >> 2];
23120 if ($11) {
23121 label$10 : {
23122 if (HEAP32[$1 + 7260 >> 2]) {
23123 $13 = HEAP32[$1 + 6900 >> 2];
23124 $12 = HEAP32[$1 + 6896 >> 2];
23125 $2 = $1 + 6920 | 0;
23126 $8 = HEAP32[$2 >> 2];
23127 $9 = HEAP32[$2 + 4 >> 2];
23128 if ((FUNCTION_TABLE[$11]($0, 0, 0, HEAP32[$1 + 7288 >> 2]) | 0) == 2) {
23129 break label$10
23130 }
23131 simple_ogg_page__init($7);
23132 $2 = HEAP32[$0 >> 2];
23133 $4 = HEAP32[$2 + 608 >> 2];
23134 $6 = HEAP32[$2 + 612 >> 2];
23135 $2 = HEAP32[$0 + 4 >> 2];
23136 label$12 : {
23137 if (!simple_ogg_page__get_at($0, $4, $6, $7, HEAP32[$2 + 7268 >> 2], HEAP32[$2 + 7264 >> 2], HEAP32[$2 + 7288 >> 2])) {
23138 break label$12
23139 }
23140 $11 = HEAP32[1357] + HEAP32[1356] | 0;
23141 $14 = HEAP32[1362] + (HEAP32[1361] + (HEAP32[1360] + (HEAP32[1359] + ($11 + HEAP32[1358] | 0) | 0) | 0) | 0) | 0;
23142 $2 = $14 + HEAP32[1363] >>> 3 | 0;
23143 if ($2 + 33 >>> 0 > HEAPU32[$7 + 12 >> 2]) {
23144 HEAP32[HEAP32[$0 >> 2] >> 2] = 2;
23145 simple_ogg_page__clear($7);
23146 break label$10;
23147 }
23148 $4 = $1 + 6936 | 0;
23149 $10 = HEAPU8[$4 + 4 | 0] | HEAPU8[$4 + 5 | 0] << 8 | (HEAPU8[$4 + 6 | 0] << 16 | HEAPU8[$4 + 7 | 0] << 24);
23150 $2 = $2 + HEAP32[$7 + 8 >> 2] | 0;
23151 $4 = HEAPU8[$4 | 0] | HEAPU8[$4 + 1 | 0] << 8 | (HEAPU8[$4 + 2 | 0] << 16 | HEAPU8[$4 + 3 | 0] << 24);
23152 HEAP8[$2 + 25 | 0] = $4;
23153 HEAP8[$2 + 26 | 0] = $4 >>> 8;
23154 HEAP8[$2 + 27 | 0] = $4 >>> 16;
23155 HEAP8[$2 + 28 | 0] = $4 >>> 24;
23156 HEAP8[$2 + 29 | 0] = $10;
23157 HEAP8[$2 + 30 | 0] = $10 >>> 8;
23158 HEAP8[$2 + 31 | 0] = $10 >>> 16;
23159 HEAP8[$2 + 32 | 0] = $10 >>> 24;
23160 $1 = $1 + 6928 | 0;
23161 $4 = HEAPU8[$1 + 4 | 0] | HEAPU8[$1 + 5 | 0] << 8 | (HEAPU8[$1 + 6 | 0] << 16 | HEAPU8[$1 + 7 | 0] << 24);
23162 $1 = HEAPU8[$1 | 0] | HEAPU8[$1 + 1 | 0] << 8 | (HEAPU8[$1 + 2 | 0] << 16 | HEAPU8[$1 + 3 | 0] << 24);
23163 HEAP8[$2 + 17 | 0] = $1;
23164 HEAP8[$2 + 18 | 0] = $1 >>> 8;
23165 HEAP8[$2 + 19 | 0] = $1 >>> 16;
23166 HEAP8[$2 + 20 | 0] = $1 >>> 24;
23167 HEAP8[$2 + 21 | 0] = $4;
23168 HEAP8[$2 + 22 | 0] = $4 >>> 8;
23169 HEAP8[$2 + 23 | 0] = $4 >>> 16;
23170 HEAP8[$2 + 24 | 0] = $4 >>> 24;
23171 $2 = $14 + -4 >>> 3 | 0;
23172 if ($2 + 22 >>> 0 > HEAPU32[$7 + 12 >> 2]) {
23173 HEAP32[HEAP32[$0 >> 2] >> 2] = 2;
23174 simple_ogg_page__clear($7);
23175 break label$10;
23176 }
23177 $2 = $2 + HEAP32[$7 + 8 >> 2] | 0;
23178 HEAP8[$2 + 21 | 0] = $8;
23179 HEAP8[$2 + 20 | 0] = ($9 & 255) << 24 | $8 >>> 8;
23180 HEAP8[$2 + 19 | 0] = ($9 & 65535) << 16 | $8 >>> 16;
23181 HEAP8[$2 + 18 | 0] = ($9 & 16777215) << 8 | $8 >>> 24;
23182 $2 = $2 + 17 | 0;
23183 HEAP8[$2 | 0] = HEAPU8[$2 | 0] & 240 | $9 & 15;
23184 $2 = $11 >>> 3 | 0;
23185 if ($2 + 23 >>> 0 > HEAPU32[$7 + 12 >> 2]) {
23186 HEAP32[HEAP32[$0 >> 2] >> 2] = 2;
23187 simple_ogg_page__clear($7);
23188 break label$10;
23189 }
23190 $2 = $2 + HEAP32[$7 + 8 >> 2] | 0;
23191 HEAP8[$2 + 22 | 0] = $13;
23192 HEAP8[$2 + 21 | 0] = $13 >>> 8;
23193 HEAP8[$2 + 20 | 0] = $13 >>> 16;
23194 HEAP8[$2 + 19 | 0] = $12;
23195 HEAP8[$2 + 18 | 0] = $12 >>> 8;
23196 HEAP8[$2 + 17 | 0] = $12 >>> 16;
23197 $2 = HEAP32[$0 >> 2];
23198 $4 = HEAP32[$2 + 608 >> 2];
23199 $1 = HEAP32[$2 + 612 >> 2];
23200 $2 = HEAP32[$0 + 4 >> 2];
23201 $2 = simple_ogg_page__set_at($0, $4, $1, $7, HEAP32[$2 + 7268 >> 2], HEAP32[$2 + 7276 >> 2], HEAP32[$2 + 7288 >> 2]);
23202 simple_ogg_page__clear($7);
23203 if (!$2) {
23204 break label$10
23205 }
23206 $2 = HEAP32[HEAP32[$5 >> 2] + 7048 >> 2];
23207 if (!$2 | !HEAP32[$2 >> 2]) {
23208 break label$10
23209 }
23210 $1 = HEAP32[$0 >> 2];
23211 if (!(HEAP32[$1 + 616 >> 2] | HEAP32[$1 + 620 >> 2])) {
23212 break label$10
23213 }
23214 FLAC__format_seektable_sort($2);
23215 simple_ogg_page__init($7);
23216 $2 = HEAP32[$0 >> 2];
23217 $4 = HEAP32[$2 + 616 >> 2];
23218 $1 = HEAP32[$2 + 620 >> 2];
23219 $2 = HEAP32[$0 + 4 >> 2];
23220 if (!simple_ogg_page__get_at($0, $4, $1, $7, HEAP32[$2 + 7268 >> 2], HEAP32[$2 + 7264 >> 2], HEAP32[$2 + 7288 >> 2])) {
23221 break label$12
23222 }
23223 $6 = HEAP32[$5 >> 2];
23224 $2 = HEAP32[$6 + 7048 >> 2];
23225 $1 = HEAP32[$2 >> 2];
23226 if (HEAP32[$7 + 12 >> 2] != (Math_imul($1, 18) + 4 | 0)) {
23227 HEAP32[HEAP32[$0 >> 2] >> 2] = 2;
23228 simple_ogg_page__clear($7);
23229 break label$10;
23230 }
23231 if ($1) {
23232 $1 = HEAP32[$7 + 8 >> 2] + 4 | 0;
23233 $4 = 0;
23234 while (1) {
23235 $8 = HEAP32[$2 + 4 >> 2] + Math_imul($4, 24) | 0;
23236 $9 = HEAP32[$8 >> 2];
23237 $2 = HEAP32[$8 + 4 >> 2];
23238 $10 = HEAP32[$8 + 8 >> 2];
23239 $6 = HEAP32[$8 + 12 >> 2];
23240 $8 = HEAP32[$8 + 16 >> 2];
23241 HEAP8[$1 + 17 | 0] = $8;
23242 HEAP8[$1 + 15 | 0] = $10;
23243 HEAP8[$1 + 7 | 0] = $9;
23244 HEAP8[$1 + 16 | 0] = $8 >>> 8;
23245 HEAP8[$1 + 14 | 0] = ($6 & 255) << 24 | $10 >>> 8;
23246 HEAP8[$1 + 13 | 0] = ($6 & 65535) << 16 | $10 >>> 16;
23247 HEAP8[$1 + 12 | 0] = ($6 & 16777215) << 8 | $10 >>> 24;
23248 HEAP8[$1 + 11 | 0] = $6;
23249 HEAP8[$1 + 10 | 0] = $6 >>> 8;
23250 HEAP8[$1 + 9 | 0] = $6 >>> 16;
23251 HEAP8[$1 + 8 | 0] = $6 >>> 24;
23252 HEAP8[$1 + 6 | 0] = ($2 & 255) << 24 | $9 >>> 8;
23253 HEAP8[$1 + 5 | 0] = ($2 & 65535) << 16 | $9 >>> 16;
23254 HEAP8[$1 + 4 | 0] = ($2 & 16777215) << 8 | $9 >>> 24;
23255 HEAP8[$1 + 3 | 0] = $2;
23256 HEAP8[$1 + 2 | 0] = $2 >>> 8;
23257 HEAP8[$1 + 1 | 0] = $2 >>> 16;
23258 HEAP8[$1 | 0] = $2 >>> 24;
23259 $1 = $1 + 18 | 0;
23260 $4 = $4 + 1 | 0;
23261 $6 = HEAP32[$5 >> 2];
23262 $2 = HEAP32[$6 + 7048 >> 2];
23263 if ($4 >>> 0 < HEAPU32[$2 >> 2]) {
23264 continue
23265 }
23266 break;
23267 };
23268 }
23269 $2 = HEAP32[$0 >> 2];
23270 simple_ogg_page__set_at($0, HEAP32[$2 + 616 >> 2], HEAP32[$2 + 620 >> 2], $7, HEAP32[$6 + 7268 >> 2], HEAP32[$6 + 7276 >> 2], HEAP32[$6 + 7288 >> 2]);
23271 }
23272 simple_ogg_page__clear($7);
23273 break label$10;
23274 }
23275 $13 = HEAP32[$1 + 6912 >> 2];
23276 $8 = HEAP32[$1 + 6900 >> 2];
23277 $9 = HEAP32[$1 + 6896 >> 2];
23278 $6 = $1 + 6920 | 0;
23279 $2 = HEAP32[$6 >> 2];
23280 $6 = HEAP32[$6 + 4 >> 2];
23281 label$19 : {
23282 label$20 : {
23283 $16 = $0;
23284 $10 = HEAP32[$4 + 612 >> 2];
23285 $12 = HEAP32[1357] + HEAP32[1356] | 0;
23286 $14 = HEAP32[1362] + (HEAP32[1361] + (HEAP32[1360] + (HEAP32[1359] + ($12 + HEAP32[1358] | 0) | 0) | 0) | 0) | 0;
23287 $15 = ($14 + HEAP32[1363] >>> 3 | 0) + 4 | 0;
23288 $4 = $15 + HEAP32[$4 + 608 >> 2] | 0;
23289 if ($4 >>> 0 < $15 >>> 0) {
23290 $10 = $10 + 1 | 0
23291 }
23292 switch (FUNCTION_TABLE[$11]($16, $4, $10, HEAP32[$1 + 7288 >> 2]) | 0) {
23293 case 0:
23294 break label$19;
23295 case 1:
23296 break label$20;
23297 default:
23298 break label$10;
23299 };
23300 }
23301 HEAP32[HEAP32[$0 >> 2] >> 2] = 5;
23302 break label$10;
23303 }
23304 $4 = $1 + 6928 | 0;
23305 $1 = HEAP32[$0 + 4 >> 2];
23306 if (FUNCTION_TABLE[HEAP32[$1 + 7276 >> 2]]($0, $4, 16, 0, 0, HEAP32[$1 + 7288 >> 2])) {
23307 HEAP32[HEAP32[$0 >> 2] >> 2] = 5;
23308 break label$10;
23309 }
23310 HEAP8[$7 + 4 | 0] = $2;
23311 HEAP8[$7 + 3 | 0] = ($6 & 255) << 24 | $2 >>> 8;
23312 HEAP8[$7 + 2 | 0] = ($6 & 65535) << 16 | $2 >>> 16;
23313 HEAP8[$7 + 1 | 0] = ($6 & 16777215) << 8 | $2 >>> 24;
23314 HEAP8[$7 | 0] = ($6 & 15 | $13 << 4) + 240;
23315 label$22 : {
23316 label$23 : {
23317 $2 = ($14 + -4 >>> 3 | 0) + 4 | 0;
23318 $1 = HEAP32[$0 >> 2];
23319 $4 = $2 + HEAP32[$1 + 608 >> 2] | 0;
23320 $1 = HEAP32[$1 + 612 >> 2];
23321 $1 = $4 >>> 0 < $2 >>> 0 ? $1 + 1 | 0 : $1;
23322 $2 = HEAP32[$0 + 4 >> 2];
23323 switch (FUNCTION_TABLE[HEAP32[$2 + 7268 >> 2]]($0, $4, $1, HEAP32[$2 + 7288 >> 2]) | 0) {
23324 case 0:
23325 break label$22;
23326 case 1:
23327 break label$23;
23328 default:
23329 break label$10;
23330 };
23331 }
23332 HEAP32[HEAP32[$0 >> 2] >> 2] = 5;
23333 break label$10;
23334 }
23335 $2 = HEAP32[$0 + 4 >> 2];
23336 if (FUNCTION_TABLE[HEAP32[$2 + 7276 >> 2]]($0, $7, 5, 0, 0, HEAP32[$2 + 7288 >> 2])) {
23337 HEAP32[HEAP32[$0 >> 2] >> 2] = 5;
23338 break label$10;
23339 }
23340 HEAP8[$7 + 5 | 0] = $8;
23341 HEAP8[$7 + 4 | 0] = $8 >>> 8;
23342 HEAP8[$7 + 3 | 0] = $8 >>> 16;
23343 HEAP8[$7 + 2 | 0] = $9;
23344 HEAP8[$7 + 1 | 0] = $9 >>> 8;
23345 HEAP8[$7 | 0] = $9 >>> 16;
23346 label$25 : {
23347 label$26 : {
23348 $2 = ($12 >>> 3 | 0) + 4 | 0;
23349 $1 = HEAP32[$0 >> 2];
23350 $4 = $2 + HEAP32[$1 + 608 >> 2] | 0;
23351 $1 = HEAP32[$1 + 612 >> 2];
23352 $1 = $4 >>> 0 < $2 >>> 0 ? $1 + 1 | 0 : $1;
23353 $2 = HEAP32[$0 + 4 >> 2];
23354 switch (FUNCTION_TABLE[HEAP32[$2 + 7268 >> 2]]($0, $4, $1, HEAP32[$2 + 7288 >> 2]) | 0) {
23355 case 0:
23356 break label$25;
23357 case 1:
23358 break label$26;
23359 default:
23360 break label$10;
23361 };
23362 }
23363 HEAP32[HEAP32[$0 >> 2] >> 2] = 5;
23364 break label$10;
23365 }
23366 $2 = HEAP32[$0 + 4 >> 2];
23367 if (FUNCTION_TABLE[HEAP32[$2 + 7276 >> 2]]($0, $7, 6, 0, 0, HEAP32[$2 + 7288 >> 2])) {
23368 HEAP32[HEAP32[$0 >> 2] >> 2] = 5;
23369 break label$10;
23370 }
23371 $2 = HEAP32[HEAP32[$5 >> 2] + 7048 >> 2];
23372 if (!$2 | !HEAP32[$2 >> 2]) {
23373 break label$10
23374 }
23375 $1 = HEAP32[$0 >> 2];
23376 if (!(HEAP32[$1 + 616 >> 2] | HEAP32[$1 + 620 >> 2])) {
23377 break label$10
23378 }
23379 FLAC__format_seektable_sort($2);
23380 label$28 : {
23381 label$29 : {
23382 label$30 : {
23383 $2 = HEAP32[$0 >> 2];
23384 $1 = HEAP32[$2 + 616 >> 2] + 4 | 0;
23385 $2 = HEAP32[$2 + 620 >> 2];
23386 $4 = $1 >>> 0 < 4 ? $2 + 1 | 0 : $2;
23387 $2 = HEAP32[$0 + 4 >> 2];
23388 switch (FUNCTION_TABLE[HEAP32[$2 + 7268 >> 2]]($0, $1, $4, HEAP32[$2 + 7288 >> 2]) | 0) {
23389 case 1:
23390 break label$29;
23391 case 0:
23392 break label$30;
23393 default:
23394 break label$10;
23395 };
23396 }
23397 $4 = HEAP32[$5 >> 2];
23398 $1 = HEAP32[$4 + 7048 >> 2];
23399 if (!HEAP32[$1 >> 2]) {
23400 break label$10
23401 }
23402 $6 = 0;
23403 break label$28;
23404 }
23405 HEAP32[HEAP32[$0 >> 2] >> 2] = 5;
23406 break label$10;
23407 }
23408 while (1) {
23409 label$32 : {
23410 $9 = Math_imul($6, 24);
23411 $8 = $9 + HEAP32[$1 + 4 >> 2] | 0;
23412 $2 = HEAP32[$8 + 4 >> 2];
23413 $8 = HEAP32[$8 >> 2];
23414 $10 = $8 << 24 | $8 << 8 & 16711680;
23415 HEAP32[$7 >> 2] = (($2 & 255) << 24 | $8 >>> 8) & -16777216 | (($2 & 16777215) << 8 | $8 >>> 24) & 16711680 | ($2 >>> 8 & 65280 | $2 >>> 24);
23416 HEAP32[$7 + 4 >> 2] = ($2 << 24 | $8 >>> 8) & 65280 | ($2 << 8 | $8 >>> 24) & 255 | $10;
23417 $8 = $9 + HEAP32[$1 + 4 >> 2] | 0;
23418 $2 = HEAP32[$8 + 12 >> 2];
23419 $8 = HEAP32[$8 + 8 >> 2];
23420 $10 = $8 << 24 | $8 << 8 & 16711680;
23421 HEAP32[$7 + 8 >> 2] = (($2 & 255) << 24 | $8 >>> 8) & -16777216 | (($2 & 16777215) << 8 | $8 >>> 24) & 16711680 | ($2 >>> 8 & 65280 | $2 >>> 24);
23422 HEAP32[$7 + 12 >> 2] = ($2 << 24 | $8 >>> 8) & 65280 | ($2 << 8 | $8 >>> 24) & 255 | $10;
23423 $2 = HEAPU16[($9 + HEAP32[$1 + 4 >> 2] | 0) + 16 >> 1];
23424 HEAP16[$7 + 16 >> 1] = ($2 << 24 | $2 << 8 & 16711680) >>> 16;
23425 if (FUNCTION_TABLE[HEAP32[$4 + 7276 >> 2]]($0, $7, 18, 0, 0, HEAP32[$4 + 7288 >> 2])) {
23426 break label$32
23427 }
23428 $6 = $6 + 1 | 0;
23429 $4 = HEAP32[$5 >> 2];
23430 $1 = HEAP32[$4 + 7048 >> 2];
23431 if ($6 >>> 0 < HEAPU32[$1 >> 2]) {
23432 continue
23433 }
23434 break label$10;
23435 }
23436 break;
23437 };
23438 HEAP32[HEAP32[$0 >> 2] >> 2] = 5;
23439 }
23440 $1 = HEAP32[$0 + 4 >> 2];
23441 $4 = HEAP32[$0 >> 2];
23442 $3 = HEAP32[$4 >> 2] ? 1 : $3;
23443 }
23444 $2 = HEAP32[$1 + 7280 >> 2];
23445 if (!$2) {
23446 break label$8
23447 }
23448 FUNCTION_TABLE[$2]($0, $1 + 6872 | 0, HEAP32[$1 + 7288 >> 2]);
23449 $4 = HEAP32[$0 >> 2];
23450 }
23451 if (!HEAP32[$4 + 4 >> 2]) {
23452 $2 = $3;
23453 break label$6;
23454 }
23455 $2 = HEAP32[HEAP32[$5 >> 2] + 11752 >> 2];
23456 if (!$2) {
23457 $2 = $3;
23458 break label$6;
23459 }
23460 if (FLAC__stream_decoder_finish($2)) {
23461 $2 = $3;
23462 break label$6;
23463 }
23464 $2 = 1;
23465 if ($3) {
23466 break label$6
23467 }
23468 HEAP32[HEAP32[$0 >> 2] >> 2] = 4;
23469 }
23470 $1 = HEAP32[$5 >> 2];
23471 $3 = HEAP32[$1 + 7296 >> 2];
23472 if ($3) {
23473 if (($3 | 0) != HEAP32[1896]) {
23474 fclose($3);
23475 $1 = HEAP32[$5 >> 2];
23476 }
23477 HEAP32[$1 + 7296 >> 2] = 0;
23478 }
23479 if (HEAP32[$1 + 7260 >> 2]) {
23480 ogg_stream_clear(HEAP32[$0 >> 2] + 640 | 0)
23481 }
23482 $1 = HEAP32[$0 >> 2];
23483 $3 = HEAP32[$1 + 600 >> 2];
23484 if ($3) {
23485 dlfree($3);
23486 $1 = HEAP32[$0 >> 2];
23487 HEAP32[$1 + 600 >> 2] = 0;
23488 HEAP32[$1 + 604 >> 2] = 0;
23489 }
23490 if (HEAP32[$1 + 24 >> 2]) {
23491 $3 = 0;
23492 while (1) {
23493 $4 = HEAP32[$5 >> 2];
23494 $1 = $3 << 2;
23495 $6 = HEAP32[($4 + $1 | 0) + 7328 >> 2];
23496 if ($6) {
23497 dlfree($6);
23498 HEAP32[($1 + HEAP32[$5 >> 2] | 0) + 7328 >> 2] = 0;
23499 $4 = HEAP32[$5 >> 2];
23500 }
23501 $4 = HEAP32[($4 + $1 | 0) + 7368 >> 2];
23502 if ($4) {
23503 dlfree($4);
23504 HEAP32[($1 + HEAP32[$5 >> 2] | 0) + 7368 >> 2] = 0;
23505 }
23506 $3 = $3 + 1 | 0;
23507 if ($3 >>> 0 < HEAPU32[HEAP32[$0 >> 2] + 24 >> 2]) {
23508 continue
23509 }
23510 break;
23511 };
23512 }
23513 $1 = HEAP32[$5 >> 2];
23514 $3 = HEAP32[$1 + 7360 >> 2];
23515 if ($3) {
23516 dlfree($3);
23517 HEAP32[HEAP32[$5 >> 2] + 7360 >> 2] = 0;
23518 $1 = HEAP32[$5 >> 2];
23519 }
23520 $3 = HEAP32[$1 + 7400 >> 2];
23521 if ($3) {
23522 dlfree($3);
23523 HEAP32[HEAP32[$5 >> 2] + 7400 >> 2] = 0;
23524 $1 = HEAP32[$5 >> 2];
23525 }
23526 $3 = HEAP32[$1 + 7364 >> 2];
23527 if ($3) {
23528 dlfree($3);
23529 HEAP32[HEAP32[$5 >> 2] + 7364 >> 2] = 0;
23530 $1 = HEAP32[$5 >> 2];
23531 }
23532 $3 = HEAP32[$1 + 7404 >> 2];
23533 if ($3) {
23534 dlfree($3);
23535 HEAP32[HEAP32[$5 >> 2] + 7404 >> 2] = 0;
23536 $1 = HEAP32[$5 >> 2];
23537 }
23538 $4 = HEAP32[$0 >> 2];
23539 if (HEAP32[$4 + 40 >> 2]) {
23540 $3 = 0;
23541 while (1) {
23542 $6 = $3 << 2;
23543 $8 = HEAP32[($6 + $1 | 0) + 7408 >> 2];
23544 if ($8) {
23545 dlfree($8);
23546 HEAP32[($6 + HEAP32[$0 + 4 >> 2] | 0) + 7408 >> 2] = 0;
23547 $4 = HEAP32[$0 >> 2];
23548 $1 = HEAP32[$0 + 4 >> 2];
23549 }
23550 $3 = $3 + 1 | 0;
23551 if ($3 >>> 0 < HEAPU32[$4 + 40 >> 2]) {
23552 continue
23553 }
23554 break;
23555 };
23556 }
23557 $3 = HEAP32[$1 + 7536 >> 2];
23558 if ($3) {
23559 dlfree($3);
23560 $1 = HEAP32[$0 + 4 >> 2];
23561 HEAP32[$1 + 7536 >> 2] = 0;
23562 $4 = HEAP32[$0 >> 2];
23563 }
23564 if (HEAP32[$4 + 24 >> 2]) {
23565 $4 = 0;
23566 while (1) {
23567 $3 = $4 << 3;
23568 $6 = HEAP32[($3 + $1 | 0) + 7540 >> 2];
23569 if ($6) {
23570 dlfree($6);
23571 HEAP32[($3 + HEAP32[$5 >> 2] | 0) + 7540 >> 2] = 0;
23572 $1 = HEAP32[$5 >> 2];
23573 }
23574 $6 = HEAP32[($1 + $3 | 0) + 7544 >> 2];
23575 if ($6) {
23576 dlfree($6);
23577 HEAP32[($3 + HEAP32[$5 >> 2] | 0) + 7544 >> 2] = 0;
23578 $1 = HEAP32[$5 >> 2];
23579 }
23580 $4 = $4 + 1 | 0;
23581 if ($4 >>> 0 < HEAPU32[HEAP32[$0 >> 2] + 24 >> 2]) {
23582 continue
23583 }
23584 break;
23585 };
23586 }
23587 $3 = HEAP32[$1 + 7604 >> 2];
23588 if ($3) {
23589 dlfree($3);
23590 HEAP32[HEAP32[$5 >> 2] + 7604 >> 2] = 0;
23591 $1 = HEAP32[$5 >> 2];
23592 }
23593 $3 = HEAP32[$1 + 7608 >> 2];
23594 if ($3) {
23595 dlfree($3);
23596 HEAP32[HEAP32[$5 >> 2] + 7608 >> 2] = 0;
23597 $1 = HEAP32[$5 >> 2];
23598 }
23599 $3 = HEAP32[$1 + 7612 >> 2];
23600 if ($3) {
23601 dlfree($3);
23602 HEAP32[HEAP32[$5 >> 2] + 7612 >> 2] = 0;
23603 $1 = HEAP32[$5 >> 2];
23604 }
23605 $3 = HEAP32[$1 + 7616 >> 2];
23606 if ($3) {
23607 dlfree($3);
23608 HEAP32[HEAP32[$5 >> 2] + 7616 >> 2] = 0;
23609 $1 = HEAP32[$5 >> 2];
23610 }
23611 $3 = HEAP32[$1 + 7620 >> 2];
23612 if ($3) {
23613 dlfree($3);
23614 $1 = HEAP32[$5 >> 2];
23615 HEAP32[$1 + 7620 >> 2] = 0;
23616 }
23617 $3 = HEAP32[$1 + 7624 >> 2];
23618 if ($3) {
23619 dlfree($3);
23620 $1 = HEAP32[$5 >> 2];
23621 HEAP32[$1 + 7624 >> 2] = 0;
23622 }
23623 $3 = HEAP32[$0 >> 2];
23624 if (!(!HEAP32[$3 + 4 >> 2] | !HEAP32[$3 + 24 >> 2])) {
23625 $5 = 0;
23626 while (1) {
23627 $4 = $5 << 2;
23628 $6 = HEAP32[($4 + $1 | 0) + 11764 >> 2];
23629 if ($6) {
23630 dlfree($6);
23631 HEAP32[($4 + HEAP32[$0 + 4 >> 2] | 0) + 11764 >> 2] = 0;
23632 $1 = HEAP32[$0 + 4 >> 2];
23633 $3 = HEAP32[$0 >> 2];
23634 }
23635 $5 = $5 + 1 | 0;
23636 if ($5 >>> 0 < HEAPU32[$3 + 24 >> 2]) {
23637 continue
23638 }
23639 break;
23640 };
23641 }
23642 FLAC__bitwriter_free(HEAP32[$1 + 6856 >> 2]);
23643 $3 = HEAP32[$0 >> 2];
23644 HEAP32[$3 + 44 >> 2] = 13;
23645 HEAP32[$3 + 48 >> 2] = 1056964608;
23646 HEAP32[$3 + 36 >> 2] = 0;
23647 HEAP32[$3 + 40 >> 2] = 1;
23648 HEAP32[$3 + 28 >> 2] = 16;
23649 HEAP32[$3 + 32 >> 2] = 44100;
23650 HEAP32[$3 + 20 >> 2] = 0;
23651 HEAP32[$3 + 24 >> 2] = 2;
23652 HEAP32[$3 + 12 >> 2] = 1;
23653 HEAP32[$3 + 16 >> 2] = 0;
23654 HEAP32[$3 + 4 >> 2] = 0;
23655 HEAP32[$3 + 8 >> 2] = 1;
23656 $3 = HEAP32[$0 >> 2];
23657 HEAP32[$3 + 592 >> 2] = 0;
23658 HEAP32[$3 + 596 >> 2] = 0;
23659 HEAP32[$3 + 556 >> 2] = 0;
23660 HEAP32[$3 + 560 >> 2] = 0;
23661 HEAP32[$3 + 564 >> 2] = 0;
23662 HEAP32[$3 + 568 >> 2] = 0;
23663 HEAP32[$3 + 572 >> 2] = 0;
23664 HEAP32[$3 + 576 >> 2] = 0;
23665 HEAP32[$3 + 580 >> 2] = 0;
23666 HEAP32[$3 + 584 >> 2] = 0;
23667 HEAP32[$3 + 600 >> 2] = 0;
23668 HEAP32[$3 + 604 >> 2] = 0;
23669 $1 = HEAP32[$0 + 4 >> 2];
23670 HEAP32[$1 + 7248 >> 2] = 0;
23671 HEAP32[$1 + 7252 >> 2] = 0;
23672 HEAP32[$1 + 7048 >> 2] = 0;
23673 $5 = $1 + 7256 | 0;
23674 HEAP32[$5 >> 2] = 0;
23675 HEAP32[$5 + 4 >> 2] = 0;
23676 $5 = $1 + 7264 | 0;
23677 HEAP32[$5 >> 2] = 0;
23678 HEAP32[$5 + 4 >> 2] = 0;
23679 $5 = $1 + 7272 | 0;
23680 HEAP32[$5 >> 2] = 0;
23681 HEAP32[$5 + 4 >> 2] = 0;
23682 $5 = $1 + 7280 | 0;
23683 HEAP32[$5 >> 2] = 0;
23684 HEAP32[$5 + 4 >> 2] = 0;
23685 HEAP32[$1 + 7288 >> 2] = 0;
23686 FLAC__ogg_encoder_aspect_set_defaults($3 + 632 | 0);
23687 $1 = HEAP32[$0 >> 2];
23688 label$74 : {
23689 if (HEAP32[$1 >> 2] != 1) {
23690 break label$74
23691 }
23692 HEAP32[$1 + 16 >> 2] = 1;
23693 HEAP32[$1 + 20 >> 2] = 0;
23694 FLAC__stream_encoder_set_apodization($0, 10777);
23695 $1 = HEAP32[$0 >> 2];
23696 if (HEAP32[$1 >> 2] != 1) {
23697 break label$74
23698 }
23699 HEAP32[$1 + 576 >> 2] = 0;
23700 HEAP32[$1 + 580 >> 2] = 5;
23701 HEAP32[$1 + 564 >> 2] = 0;
23702 HEAP32[$1 + 568 >> 2] = 0;
23703 HEAP32[$1 + 556 >> 2] = 8;
23704 HEAP32[$1 + 560 >> 2] = 0;
23705 }
23706 if (!$2) {
23707 HEAP32[$1 >> 2] = 1
23708 }
23709 $1 = !$2;
23710 }
23711 global$0 = $7 + 32 | 0;
23712 return $1 | 0;
23713 }
23714
23715 function process_frame_($0, $1, $2) {
23716 var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0;
23717 $8 = global$0 - 48 | 0;
23718 global$0 = $8;
23719 label$1 : {
23720 label$2 : {
23721 $4 = HEAP32[$0 >> 2];
23722 if (!HEAP32[$4 + 12 >> 2]) {
23723 break label$2
23724 }
23725 $3 = HEAP32[$0 + 4 >> 2];
23726 $3 = FLAC__MD5Accumulate($3 + 7060 | 0, $3 + 4 | 0, HEAP32[$4 + 24 >> 2], HEAP32[$4 + 36 >> 2], HEAP32[$4 + 28 >> 2] + 7 >>> 3 | 0);
23727 $4 = HEAP32[$0 >> 2];
23728 if ($3) {
23729 break label$2
23730 }
23731 HEAP32[$4 >> 2] = 8;
23732 $1 = 0;
23733 break label$1;
23734 }
23735 $3 = HEAP32[$4 + 576 >> 2];
23736 if ($1) {
23737 $12 = 0
23738 } else {
23739 $1 = FLAC__format_get_max_rice_partition_order_from_blocksize(HEAP32[$4 + 36 >> 2]);
23740 $4 = HEAP32[$0 >> 2];
23741 $5 = HEAP32[$4 + 580 >> 2];
23742 $12 = $1 >>> 0 < $5 >>> 0 ? $1 : $5;
23743 }
23744 $7 = HEAP32[$4 + 36 >> 2];
23745 HEAP32[$8 + 8 >> 2] = $7;
23746 HEAP32[$8 + 12 >> 2] = HEAP32[$4 + 32 >> 2];
23747 $1 = HEAP32[$4 + 24 >> 2];
23748 HEAP32[$8 + 20 >> 2] = 0;
23749 HEAP32[$8 + 16 >> 2] = $1;
23750 $1 = HEAP32[$4 + 28 >> 2];
23751 HEAP32[$8 + 28 >> 2] = 0;
23752 HEAP32[$8 + 24 >> 2] = $1;
23753 $5 = HEAP32[$0 + 4 >> 2];
23754 HEAP32[$8 + 32 >> 2] = HEAP32[$5 + 7056 >> 2];
23755 $14 = $3 >>> 0 < $12 >>> 0 ? $3 : $12;
23756 label$5 : {
23757 label$6 : {
23758 label$7 : {
23759 label$8 : {
23760 label$9 : {
23761 label$10 : {
23762 label$11 : {
23763 if (!HEAP32[$4 + 16 >> 2]) {
23764 $10 = 1;
23765 break label$11;
23766 }
23767 if (!HEAP32[$4 + 20 >> 2] | !HEAP32[$5 + 6864 >> 2]) {
23768 break label$11
23769 }
23770 $10 = 1;
23771 $13 = 1;
23772 if (HEAP32[$5 + 6868 >> 2]) {
23773 break label$10
23774 }
23775 }
23776 label$13 : {
23777 if (!HEAP32[$4 + 24 >> 2]) {
23778 $3 = 0;
23779 break label$13;
23780 }
23781 while (1) {
23782 $13 = ($6 << 2) + $5 | 0;
23783 $3 = 0;
23784 $11 = 0;
23785 label$16 : {
23786 if (!$7) {
23787 break label$16
23788 }
23789 $15 = HEAP32[$13 + 4 >> 2];
23790 $1 = 0;
23791 while (1) {
23792 label$18 : {
23793 $3 = HEAP32[$15 + ($1 << 2) >> 2] | $3;
23794 $9 = $3 & 1;
23795 $1 = $1 + 1 | 0;
23796 if ($1 >>> 0 >= $7 >>> 0) {
23797 break label$18
23798 }
23799 if (!$9) {
23800 continue
23801 }
23802 }
23803 break;
23804 };
23805 $1 = 0;
23806 $11 = 0;
23807 if (!$3) {
23808 break label$16
23809 }
23810 $11 = 0;
23811 if ($9) {
23812 break label$16
23813 }
23814 while (1) {
23815 $1 = $1 + 1 | 0;
23816 $9 = $3 & 2;
23817 $3 = $3 >> 1;
23818 if (!$9) {
23819 continue
23820 }
23821 break;
23822 };
23823 $9 = 0;
23824 $11 = 0;
23825 if (!$1) {
23826 break label$16
23827 }
23828 while (1) {
23829 $3 = $15 + ($9 << 2) | 0;
23830 HEAP32[$3 >> 2] = HEAP32[$3 >> 2] >> $1;
23831 $9 = $9 + 1 | 0;
23832 if (($9 | 0) != ($7 | 0)) {
23833 continue
23834 }
23835 break;
23836 };
23837 $11 = $1;
23838 }
23839 $1 = $11;
23840 $7 = Math_imul($6, 584) + $5 | 0;
23841 $3 = HEAP32[$4 + 28 >> 2];
23842 $1 = $1 >>> 0 > $3 >>> 0 ? $3 : $1;
23843 HEAP32[$7 + 624 >> 2] = $1;
23844 HEAP32[$7 + 916 >> 2] = $1;
23845 HEAP32[$13 + 216 >> 2] = $3 - $1;
23846 $6 = $6 + 1 | 0;
23847 $3 = HEAP32[$4 + 24 >> 2];
23848 if ($6 >>> 0 >= $3 >>> 0) {
23849 break label$13
23850 }
23851 $7 = HEAP32[$4 + 36 >> 2];
23852 continue;
23853 };
23854 }
23855 $1 = 1;
23856 if ($10) {
23857 break label$9
23858 }
23859 $7 = HEAP32[$4 + 36 >> 2];
23860 $13 = 0;
23861 }
23862 $9 = HEAP32[$5 + 36 >> 2];
23863 $3 = 0;
23864 $6 = 0;
23865 label$21 : {
23866 if (!$7) {
23867 break label$21
23868 }
23869 $1 = 0;
23870 while (1) {
23871 label$23 : {
23872 $1 = HEAP32[($6 << 2) + $9 >> 2] | $1;
23873 $10 = $1 & 1;
23874 $6 = $6 + 1 | 0;
23875 if ($6 >>> 0 >= $7 >>> 0) {
23876 break label$23
23877 }
23878 if (!$10) {
23879 continue
23880 }
23881 }
23882 break;
23883 };
23884 $6 = 0;
23885 if ($10 | !$1) {
23886 break label$21
23887 }
23888 while (1) {
23889 $6 = $6 + 1 | 0;
23890 $10 = $1 & 2;
23891 $1 = $1 >> 1;
23892 if (!$10) {
23893 continue
23894 }
23895 break;
23896 };
23897 $1 = 0;
23898 if (!$6) {
23899 $6 = 0;
23900 break label$21;
23901 }
23902 while (1) {
23903 $10 = ($1 << 2) + $9 | 0;
23904 HEAP32[$10 >> 2] = HEAP32[$10 >> 2] >> $6;
23905 $1 = $1 + 1 | 0;
23906 if (($7 | 0) != ($1 | 0)) {
23907 continue
23908 }
23909 break;
23910 };
23911 }
23912 $1 = HEAP32[$4 + 28 >> 2];
23913 $6 = $6 >>> 0 > $1 >>> 0 ? $1 : $6;
23914 HEAP32[$5 + 5296 >> 2] = $6;
23915 HEAP32[$5 + 5588 >> 2] = $6;
23916 HEAP32[$5 + 248 >> 2] = $1 - $6;
23917 $6 = HEAP32[$4 + 36 >> 2];
23918 label$27 : {
23919 if (!$6) {
23920 break label$27
23921 }
23922 $7 = HEAP32[$5 + 40 >> 2];
23923 $1 = 0;
23924 while (1) {
23925 label$29 : {
23926 $3 = HEAP32[$7 + ($1 << 2) >> 2] | $3;
23927 $10 = $3 & 1;
23928 $1 = $1 + 1 | 0;
23929 if ($1 >>> 0 >= $6 >>> 0) {
23930 break label$29
23931 }
23932 if (!$10) {
23933 continue
23934 }
23935 }
23936 break;
23937 };
23938 $1 = 0;
23939 if (!$3) {
23940 $3 = 0;
23941 break label$27;
23942 }
23943 if ($10) {
23944 $3 = 0;
23945 break label$27;
23946 }
23947 while (1) {
23948 $1 = $1 + 1 | 0;
23949 $10 = $3 & 2;
23950 $3 = $3 >> 1;
23951 if (!$10) {
23952 continue
23953 }
23954 break;
23955 };
23956 $3 = 0;
23957 if (!$1) {
23958 break label$27
23959 }
23960 while (1) {
23961 $10 = $7 + ($3 << 2) | 0;
23962 HEAP32[$10 >> 2] = HEAP32[$10 >> 2] >> $1;
23963 $3 = $3 + 1 | 0;
23964 if (($6 | 0) != ($3 | 0)) {
23965 continue
23966 }
23967 break;
23968 };
23969 $3 = $1;
23970 }
23971 $1 = HEAP32[$4 + 28 >> 2];
23972 $3 = $3 >>> 0 > $1 >>> 0 ? $1 : $3;
23973 HEAP32[$5 + 5880 >> 2] = $3;
23974 HEAP32[$5 + 6172 >> 2] = $3;
23975 HEAP32[$5 + 252 >> 2] = ($1 - $3 | 0) + 1;
23976 if ($13) {
23977 break label$8
23978 }
23979 $3 = HEAP32[$4 + 24 >> 2];
23980 $1 = 0;
23981 }
23982 $4 = $1;
23983 if ($3) {
23984 $3 = 0;
23985 while (1) {
23986 $1 = ($3 << 2) + $5 | 0;
23987 $5 = ($3 << 3) + $5 | 0;
23988 process_subframe_($0, $14, $12, $8 + 8 | 0, HEAP32[$1 + 216 >> 2], HEAP32[$1 + 4 >> 2], $5 + 6176 | 0, $5 + 6640 | 0, $5 + 256 | 0, $1 + 6768 | 0, $1 + 6808 | 0);
23989 $5 = HEAP32[$0 + 4 >> 2];
23990 $3 = $3 + 1 | 0;
23991 if ($3 >>> 0 < HEAPU32[HEAP32[$0 >> 2] + 24 >> 2]) {
23992 continue
23993 }
23994 break;
23995 };
23996 }
23997 if ($4) {
23998 break label$7
23999 }
24000 $9 = HEAP32[$5 + 36 >> 2];
24001 }
24002 process_subframe_($0, $14, $12, $8 + 8 | 0, HEAP32[$5 + 248 >> 2], $9, $5 + 6240 | 0, $5 + 6704 | 0, $5 + 320 | 0, $5 + 6800 | 0, $5 + 6840 | 0);
24003 $1 = HEAP32[$0 + 4 >> 2];
24004 process_subframe_($0, $14, $12, $8 + 8 | 0, HEAP32[$1 + 252 >> 2], HEAP32[$1 + 40 >> 2], $1 + 6248 | 0, $1 + 6712 | 0, $1 + 328 | 0, $1 + 6804 | 0, $1 + 6844 | 0);
24005 $11 = $8;
24006 $1 = HEAP32[$0 + 4 >> 2];
24007 label$36 : {
24008 if (!(!HEAP32[HEAP32[$0 >> 2] + 20 >> 2] | !HEAP32[$1 + 6864 >> 2])) {
24009 $3 = HEAP32[$1 + 6868 >> 2] ? 3 : 0;
24010 break label$36;
24011 }
24012 $3 = HEAP32[$1 + 6844 >> 2];
24013 $5 = HEAP32[$1 + 6808 >> 2];
24014 $4 = $3 + $5 | 0;
24015 $6 = HEAP32[$1 + 6812 >> 2];
24016 $5 = $5 + $6 | 0;
24017 $7 = $4 >>> 0 < $5 >>> 0;
24018 $6 = $3 + $6 | 0;
24019 $5 = $7 ? $4 : $5;
24020 $4 = $6 >>> 0 < $5 >>> 0;
24021 $3 = $3 + HEAP32[$1 + 6840 >> 2] >>> 0 < ($4 ? $6 : $5) >>> 0 ? 3 : $4 ? 2 : $7;
24022 }
24023 HEAP32[$11 + 20 >> 2] = $3;
24024 if (!FLAC__frame_add_header($8 + 8 | 0, HEAP32[$1 + 6856 >> 2])) {
24025 HEAP32[HEAP32[$0 >> 2] >> 2] = 7;
24026 $1 = 0;
24027 break label$1;
24028 }
24029 $5 = $0;
24030 $6 = HEAP32[$8 + 8 >> 2];
24031 label$39 : {
24032 label$40 : {
24033 switch ($3 | 0) {
24034 default:
24035 $3 = HEAP32[$0 + 4 >> 2];
24036 $7 = 0;
24037 $1 = 0;
24038 $4 = 0;
24039 $9 = 0;
24040 break label$39;
24041 case 0:
24042 $3 = HEAP32[$0 + 4 >> 2];
24043 $4 = $3 + 336 | 0;
24044 $1 = $4 + Math_imul(HEAP32[$3 + 6768 >> 2], 292) | 0;
24045 $7 = ($4 + Math_imul(HEAP32[$3 + 6772 >> 2], 292) | 0) + 584 | 0;
24046 $4 = HEAP32[$3 + 216 >> 2];
24047 $9 = HEAP32[$3 + 220 >> 2];
24048 break label$39;
24049 case 1:
24050 $3 = HEAP32[$0 + 4 >> 2];
24051 $1 = ($3 + Math_imul(HEAP32[$3 + 6768 >> 2], 292) | 0) + 336 | 0;
24052 $7 = (Math_imul(HEAP32[$3 + 6804 >> 2], 292) + $3 | 0) + 5592 | 0;
24053 $4 = HEAP32[$3 + 216 >> 2];
24054 $9 = HEAP32[$3 + 252 >> 2];
24055 break label$39;
24056 case 2:
24057 $3 = HEAP32[$0 + 4 >> 2];
24058 $7 = ($3 + Math_imul(HEAP32[$3 + 6772 >> 2], 292) | 0) + 920 | 0;
24059 $1 = (Math_imul(HEAP32[$3 + 6804 >> 2], 292) + $3 | 0) + 5592 | 0;
24060 $4 = HEAP32[$3 + 252 >> 2];
24061 $9 = HEAP32[$3 + 220 >> 2];
24062 break label$39;
24063 case 3:
24064 break label$40;
24065 };
24066 }
24067 $3 = HEAP32[$0 + 4 >> 2];
24068 $4 = $3 + 5008 | 0;
24069 $1 = $4 + Math_imul(HEAP32[$3 + 6800 >> 2], 292) | 0;
24070 $7 = ($4 + Math_imul(HEAP32[$3 + 6804 >> 2], 292) | 0) + 584 | 0;
24071 $4 = HEAP32[$3 + 248 >> 2];
24072 $9 = HEAP32[$3 + 252 >> 2];
24073 }
24074 if (!add_subframe_($5, $6, $4, $1, HEAP32[$3 + 6856 >> 2])) {
24075 break label$6
24076 }
24077 if (!add_subframe_($0, HEAP32[$8 + 8 >> 2], $9, $7, HEAP32[HEAP32[$0 + 4 >> 2] + 6856 >> 2])) {
24078 break label$6
24079 }
24080 $1 = HEAP32[$0 >> 2];
24081 break label$5;
24082 }
24083 $3 = FLAC__frame_add_header($8 + 8 | 0, HEAP32[$5 + 6856 >> 2]);
24084 $1 = HEAP32[$0 >> 2];
24085 if ($3) {
24086 if (!HEAP32[$1 + 24 >> 2]) {
24087 break label$5
24088 }
24089 $3 = 0;
24090 while (1) {
24091 $1 = HEAP32[$0 + 4 >> 2];
24092 $5 = $1 + ($3 << 2) | 0;
24093 if (!add_subframe_($0, HEAP32[$8 + 8 >> 2], HEAP32[$5 + 216 >> 2], (($1 + Math_imul($3, 584) | 0) + Math_imul(HEAP32[$5 + 6768 >> 2], 292) | 0) + 336 | 0, HEAP32[$1 + 6856 >> 2])) {
24094 break label$6
24095 }
24096 $3 = $3 + 1 | 0;
24097 $1 = HEAP32[$0 >> 2];
24098 if ($3 >>> 0 < HEAPU32[$1 + 24 >> 2]) {
24099 continue
24100 }
24101 break;
24102 };
24103 break label$5;
24104 }
24105 HEAP32[$1 >> 2] = 7;
24106 }
24107 $1 = 0;
24108 break label$1;
24109 }
24110 if (HEAP32[$1 + 20 >> 2]) {
24111 $1 = HEAP32[$0 + 4 >> 2];
24112 $3 = HEAP32[$1 + 6864 >> 2] + 1 | 0;
24113 HEAP32[$1 + 6864 >> 2] = $3 >>> 0 < HEAPU32[$1 + 6860 >> 2] ? $3 : 0;
24114 }
24115 $1 = HEAP32[$0 + 4 >> 2];
24116 HEAP32[$1 + 6868 >> 2] = HEAP32[$8 + 20 >> 2];
24117 $1 = HEAP32[$1 + 6856 >> 2];
24118 $3 = HEAP32[$1 + 16 >> 2] & 7;
24119 $11 = 1;
24120 __inlined_func$FLAC__bitwriter_zero_pad_to_byte_boundary : {
24121 if (!$3) {
24122 break __inlined_func$FLAC__bitwriter_zero_pad_to_byte_boundary
24123 }
24124 $11 = FLAC__bitwriter_write_zeroes($1, 8 - $3 | 0);
24125 }
24126 if (!$11) {
24127 HEAP32[HEAP32[$0 >> 2] >> 2] = 8;
24128 $1 = 0;
24129 break label$1;
24130 }
24131 label$49 : {
24132 if (FLAC__bitwriter_get_write_crc16(HEAP32[HEAP32[$0 + 4 >> 2] + 6856 >> 2], $8 + 8 | 0)) {
24133 if (FLAC__bitwriter_write_raw_uint32(HEAP32[HEAP32[$0 + 4 >> 2] + 6856 >> 2], HEAPU16[$8 + 8 >> 1], HEAP32[1404])) {
24134 break label$49
24135 }
24136 }
24137 HEAP32[HEAP32[$0 >> 2] >> 2] = 8;
24138 $1 = 0;
24139 break label$1;
24140 }
24141 $1 = 0;
24142 if (!write_bitbuffer_($0, HEAP32[HEAP32[$0 >> 2] + 36 >> 2], $2)) {
24143 break label$1
24144 }
24145 $1 = HEAP32[$0 + 4 >> 2];
24146 HEAP32[$1 + 7052 >> 2] = 0;
24147 HEAP32[$1 + 7056 >> 2] = HEAP32[$1 + 7056 >> 2] + 1;
24148 $2 = $1 + 6920 | 0;
24149 $3 = $2;
24150 $11 = $3;
24151 $1 = HEAP32[$3 + 4 >> 2];
24152 $0 = HEAP32[HEAP32[$0 >> 2] + 36 >> 2];
24153 $2 = $0 + HEAP32[$3 >> 2] | 0;
24154 if ($2 >>> 0 < $0 >>> 0) {
24155 $1 = $1 + 1 | 0
24156 }
24157 HEAP32[$11 >> 2] = $2;
24158 HEAP32[$3 + 4 >> 2] = $1;
24159 $1 = 1;
24160 }
24161 $0 = $1;
24162 global$0 = $8 + 48 | 0;
24163 return $0;
24164 }
24165
24166 function FLAC__stream_encoder_init_stream($0, $1, $2, $3, $4, $5) {
24167 $0 = $0 | 0;
24168 $1 = $1 | 0;
24169 $2 = $2 | 0;
24170 $3 = $3 | 0;
24171 $4 = $4 | 0;
24172 $5 = $5 | 0;
24173 return init_stream_internal__1($0, 0, $1, $2, $3, $4, $5, 0) | 0;
24174 }
24175
24176 function init_stream_internal__1($0, $1, $2, $3, $4, $5, $6, $7) {
24177 var $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0.0, $17 = 0, $18 = 0, $19 = 0;
24178 $15 = global$0 - 176 | 0;
24179 global$0 = $15;
24180 $9 = 13;
24181 $8 = HEAP32[$0 >> 2];
24182 label$1 : {
24183 if (HEAP32[$8 >> 2] != 1) {
24184 break label$1
24185 }
24186 $9 = 3;
24187 if (!$2 | ($4 ? 0 : $3)) {
24188 break label$1
24189 }
24190 $9 = 4;
24191 $11 = HEAP32[$8 + 24 >> 2];
24192 if ($11 + -1 >>> 0 > 7) {
24193 break label$1
24194 }
24195 label$2 : {
24196 label$3 : {
24197 if (($11 | 0) != 2) {
24198 HEAP32[$8 + 16 >> 2] = 0;
24199 break label$3;
24200 }
24201 if (HEAP32[$8 + 16 >> 2]) {
24202 break label$2
24203 }
24204 }
24205 HEAP32[$8 + 20 >> 2] = 0;
24206 }
24207 $11 = HEAP32[$8 + 28 >> 2];
24208 if ($11 >>> 0 >= 32) {
24209 HEAP32[$8 + 16 >> 2] = 0;
24210 $9 = 5;
24211 break label$1;
24212 }
24213 $9 = 5;
24214 if ($11 + -4 >>> 0 > 20) {
24215 break label$1
24216 }
24217 if (HEAP32[$8 + 32 >> 2] + -1 >>> 0 >= 655350) {
24218 $9 = 6;
24219 break label$1;
24220 }
24221 $8 = HEAP32[$0 >> 2];
24222 $10 = HEAP32[$8 + 36 >> 2];
24223 label$7 : {
24224 if (!$10) {
24225 $10 = HEAP32[$8 + 556 >> 2] ? 4096 : 1152;
24226 HEAP32[$8 + 36 >> 2] = $10;
24227 break label$7;
24228 }
24229 $9 = 7;
24230 if ($10 + -16 >>> 0 > 65519) {
24231 break label$1
24232 }
24233 }
24234 $9 = 8;
24235 $11 = HEAP32[$8 + 556 >> 2];
24236 if ($11 >>> 0 > 32) {
24237 break label$1
24238 }
24239 $9 = 10;
24240 if ($10 >>> 0 < $11 >>> 0) {
24241 break label$1
24242 }
24243 $11 = HEAP32[$8 + 560 >> 2];
24244 label$9 : {
24245 if (!$11) {
24246 $13 = $8;
24247 $11 = HEAP32[$8 + 28 >> 2];
24248 label$11 : {
24249 if ($11 >>> 0 <= 15) {
24250 $11 = $11 >>> 0 > 5 ? ($11 >>> 1 | 0) + 2 | 0 : 5;
24251 break label$11;
24252 }
24253 if (($11 | 0) == 16) {
24254 $11 = 7;
24255 if ($10 >>> 0 < 193) {
24256 break label$11
24257 }
24258 $11 = 8;
24259 if ($10 >>> 0 < 385) {
24260 break label$11
24261 }
24262 $11 = 9;
24263 if ($10 >>> 0 < 577) {
24264 break label$11
24265 }
24266 $11 = 10;
24267 if ($10 >>> 0 < 1153) {
24268 break label$11
24269 }
24270 $11 = 11;
24271 if ($10 >>> 0 < 2305) {
24272 break label$11
24273 }
24274 $11 = $10 >>> 0 < 4609 ? 12 : 13;
24275 break label$11;
24276 }
24277 $11 = 13;
24278 if ($10 >>> 0 < 385) {
24279 break label$11
24280 }
24281 $11 = $10 >>> 0 < 1153 ? 14 : 15;
24282 }
24283 HEAP32[$13 + 560 >> 2] = $11;
24284 break label$9;
24285 }
24286 $9 = 9;
24287 if ($11 + -5 >>> 0 > 10) {
24288 break label$1
24289 }
24290 }
24291 label$14 : {
24292 if (!HEAP32[$8 + 8 >> 2]) {
24293 $10 = HEAP32[$8 + 580 >> 2];
24294 break label$14;
24295 }
24296 $9 = 11;
24297 if (!(($10 >>> 0 < 4609 | HEAPU32[$8 + 32 >> 2] > 48e3) & $10 >>> 0 < 16385)) {
24298 break label$1
24299 }
24300 if (!FLAC__format_sample_rate_is_subset(HEAP32[HEAP32[$0 >> 2] + 32 >> 2])) {
24301 break label$1
24302 }
24303 $8 = HEAP32[$0 >> 2];
24304 if (__wasm_rotl_i32(HEAP32[$8 + 28 >> 2] + -8 | 0, 30) >>> 0 > 4) {
24305 break label$1
24306 }
24307 $10 = HEAP32[$8 + 580 >> 2];
24308 if ($10 >>> 0 > 8) {
24309 break label$1
24310 }
24311 if (HEAPU32[$8 + 32 >> 2] > 48e3) {
24312 break label$14
24313 }
24314 if (HEAPU32[$8 + 36 >> 2] > 4608 | HEAPU32[$8 + 556 >> 2] > 12) {
24315 break label$1
24316 }
24317 }
24318 $11 = 1 << HEAP32[1406];
24319 if ($10 >>> 0 >= $11 >>> 0) {
24320 $10 = $11 + -1 | 0;
24321 HEAP32[$8 + 580 >> 2] = $10;
24322 }
24323 if (HEAPU32[$8 + 576 >> 2] >= $10 >>> 0) {
24324 HEAP32[$8 + 576 >> 2] = $10
24325 }
24326 label$18 : {
24327 if (!$7) {
24328 break label$18
24329 }
24330 $10 = HEAP32[$8 + 600 >> 2];
24331 if (!$10) {
24332 break label$18
24333 }
24334 $13 = HEAP32[$8 + 604 >> 2];
24335 if ($13 >>> 0 < 2) {
24336 break label$18
24337 }
24338 $9 = 1;
24339 while (1) {
24340 $11 = HEAP32[($9 << 2) + $10 >> 2];
24341 if (!(!$11 | HEAP32[$11 >> 2] != 4)) {
24342 while (1) {
24343 $8 = ($9 << 2) + $10 | 0;
24344 $9 = $9 + -1 | 0;
24345 HEAP32[$8 >> 2] = HEAP32[($9 << 2) + $10 >> 2];
24346 $10 = HEAP32[HEAP32[$0 >> 2] + 600 >> 2];
24347 if ($9) {
24348 continue
24349 }
24350 break;
24351 };
24352 HEAP32[$10 >> 2] = $11;
24353 $8 = HEAP32[$0 >> 2];
24354 break label$18;
24355 }
24356 $9 = $9 + 1 | 0;
24357 if (($13 | 0) != ($9 | 0)) {
24358 continue
24359 }
24360 break;
24361 };
24362 }
24363 $13 = HEAP32[$8 + 604 >> 2];
24364 label$22 : {
24365 label$23 : {
24366 $10 = HEAP32[$8 + 600 >> 2];
24367 if ($10) {
24368 $11 = 0;
24369 if (!$13) {
24370 break label$22
24371 }
24372 while (1) {
24373 $8 = HEAP32[($11 << 2) + $10 >> 2];
24374 if (!(!$8 | HEAP32[$8 >> 2] != 3)) {
24375 HEAP32[HEAP32[$0 + 4 >> 2] + 7048 >> 2] = $8 + 16;
24376 break label$23;
24377 }
24378 $11 = $11 + 1 | 0;
24379 if (($13 | 0) != ($11 | 0)) {
24380 continue
24381 }
24382 break;
24383 };
24384 break label$23;
24385 }
24386 $9 = 12;
24387 if ($13) {
24388 break label$1
24389 }
24390 $11 = 0;
24391 break label$22;
24392 }
24393 $8 = 0;
24394 $13 = 0;
24395 $11 = 0;
24396 while (1) {
24397 $9 = 12;
24398 label$28 : {
24399 label$29 : {
24400 label$30 : {
24401 label$31 : {
24402 label$32 : {
24403 $10 = HEAP32[($14 << 2) + $10 >> 2];
24404 switch (HEAP32[$10 >> 2]) {
24405 case 0:
24406 break label$1;
24407 case 6:
24408 break label$29;
24409 case 5:
24410 break label$30;
24411 case 4:
24412 break label$31;
24413 case 3:
24414 break label$32;
24415 default:
24416 break label$28;
24417 };
24418 }
24419 if ($18) {
24420 break label$1
24421 }
24422 $18 = 1;
24423 $11 = $13;
24424 $12 = $8;
24425 if (FLAC__format_seektable_is_legal($10 + 16 | 0)) {
24426 break label$28
24427 }
24428 break label$1;
24429 }
24430 $11 = 1;
24431 $12 = $8;
24432 if (!$13) {
24433 break label$28
24434 }
24435 break label$1;
24436 }
24437 $11 = $13;
24438 $12 = $8;
24439 if (FLAC__format_cuesheet_is_legal($10 + 16 | 0, HEAP32[$10 + 160 >> 2])) {
24440 break label$28
24441 }
24442 break label$1;
24443 }
24444 $17 = $10 + 16 | 0;
24445 if (!FLAC__format_picture_is_legal($17)) {
24446 break label$1
24447 }
24448 $11 = $13;
24449 $12 = $8;
24450 label$33 : {
24451 switch (HEAP32[$17 >> 2] + -1 | 0) {
24452 case 0:
24453 if ($19) {
24454 break label$1
24455 }
24456 $12 = HEAP32[$10 + 20 >> 2];
24457 if (strcmp($12, 10763)) {
24458 if (strcmp($12, 10773)) {
24459 break label$1
24460 }
24461 }
24462 if (HEAP32[$10 + 28 >> 2] != 32) {
24463 break label$1
24464 }
24465 $19 = 1;
24466 $11 = $13;
24467 $12 = $8;
24468 if (HEAP32[$10 + 32 >> 2] == 32) {
24469 break label$28
24470 }
24471 break label$1;
24472 case 1:
24473 break label$33;
24474 default:
24475 break label$28;
24476 };
24477 }
24478 $12 = 1;
24479 if ($8) {
24480 break label$1
24481 }
24482 }
24483 $14 = $14 + 1 | 0;
24484 $8 = HEAP32[$0 >> 2];
24485 if ($14 >>> 0 >= HEAPU32[$8 + 604 >> 2]) {
24486 break label$22
24487 }
24488 $10 = HEAP32[$8 + 600 >> 2];
24489 $8 = $12;
24490 $13 = $11;
24491 continue;
24492 };
24493 }
24494 $10 = 0;
24495 $14 = HEAP32[$0 + 4 >> 2];
24496 HEAP32[$14 >> 2] = 0;
24497 if (HEAP32[$8 + 24 >> 2]) {
24498 while (1) {
24499 $8 = $10 << 2;
24500 HEAP32[($8 + $14 | 0) + 4 >> 2] = 0;
24501 HEAP32[($8 + HEAP32[$0 + 4 >> 2] | 0) + 7328 >> 2] = 0;
24502 HEAP32[($8 + HEAP32[$0 + 4 >> 2] | 0) + 44 >> 2] = 0;
24503 HEAP32[($8 + HEAP32[$0 + 4 >> 2] | 0) + 7368 >> 2] = 0;
24504 $14 = HEAP32[$0 + 4 >> 2];
24505 $10 = $10 + 1 | 0;
24506 if ($10 >>> 0 < HEAPU32[HEAP32[$0 >> 2] + 24 >> 2]) {
24507 continue
24508 }
24509 break;
24510 }
24511 }
24512 $8 = 0;
24513 HEAP32[$14 + 36 >> 2] = 0;
24514 HEAP32[HEAP32[$0 + 4 >> 2] + 7360 >> 2] = 0;
24515 HEAP32[HEAP32[$0 + 4 >> 2] + 76 >> 2] = 0;
24516 HEAP32[HEAP32[$0 + 4 >> 2] + 7400 >> 2] = 0;
24517 HEAP32[HEAP32[$0 + 4 >> 2] + 40 >> 2] = 0;
24518 HEAP32[HEAP32[$0 + 4 >> 2] + 7364 >> 2] = 0;
24519 HEAP32[HEAP32[$0 + 4 >> 2] + 80 >> 2] = 0;
24520 HEAP32[HEAP32[$0 + 4 >> 2] + 7404 >> 2] = 0;
24521 $9 = HEAP32[$0 + 4 >> 2];
24522 $10 = HEAP32[$0 >> 2];
24523 if (HEAP32[$10 + 40 >> 2]) {
24524 while (1) {
24525 $12 = $8 << 2;
24526 HEAP32[($12 + $9 | 0) + 84 >> 2] = 0;
24527 HEAP32[($12 + HEAP32[$0 + 4 >> 2] | 0) + 7408 >> 2] = 0;
24528 $9 = HEAP32[$0 + 4 >> 2];
24529 $8 = $8 + 1 | 0;
24530 $10 = HEAP32[$0 >> 2];
24531 if ($8 >>> 0 < HEAPU32[$10 + 40 >> 2]) {
24532 continue
24533 }
24534 break;
24535 }
24536 }
24537 $8 = 0;
24538 HEAP32[$9 + 7536 >> 2] = 0;
24539 HEAP32[$9 + 212 >> 2] = 0;
24540 if (HEAP32[$10 + 24 >> 2]) {
24541 while (1) {
24542 $12 = $8 << 3;
24543 HEAP32[($12 + $9 | 0) + 256 >> 2] = 0;
24544 HEAP32[($12 + HEAP32[$0 + 4 >> 2] | 0) + 7540 >> 2] = 0;
24545 HEAP32[($12 + HEAP32[$0 + 4 >> 2] | 0) + 260 >> 2] = 0;
24546 HEAP32[($12 + HEAP32[$0 + 4 >> 2] | 0) + 7544 >> 2] = 0;
24547 $9 = HEAP32[$0 + 4 >> 2];
24548 HEAP32[($9 + ($8 << 2) | 0) + 6768 >> 2] = 0;
24549 $8 = $8 + 1 | 0;
24550 if ($8 >>> 0 < HEAPU32[HEAP32[$0 >> 2] + 24 >> 2]) {
24551 continue
24552 }
24553 break;
24554 }
24555 }
24556 HEAP32[$9 + 320 >> 2] = 0;
24557 HEAP32[HEAP32[$0 + 4 >> 2] + 7604 >> 2] = 0;
24558 HEAP32[HEAP32[$0 + 4 >> 2] + 324 >> 2] = 0;
24559 HEAP32[HEAP32[$0 + 4 >> 2] + 7608 >> 2] = 0;
24560 $8 = HEAP32[$0 + 4 >> 2];
24561 HEAP32[$8 + 6800 >> 2] = 0;
24562 HEAP32[$8 + 328 >> 2] = 0;
24563 HEAP32[HEAP32[$0 + 4 >> 2] + 7612 >> 2] = 0;
24564 HEAP32[HEAP32[$0 + 4 >> 2] + 332 >> 2] = 0;
24565 HEAP32[HEAP32[$0 + 4 >> 2] + 7616 >> 2] = 0;
24566 $8 = HEAP32[$0 + 4 >> 2];
24567 HEAP32[$8 + 7620 >> 2] = 0;
24568 HEAP32[$8 + 7624 >> 2] = 0;
24569 HEAP32[$8 + 6848 >> 2] = 0;
24570 HEAP32[$8 + 6852 >> 2] = 0;
24571 HEAP32[$8 + 6804 >> 2] = 0;
24572 $12 = HEAP32[$0 >> 2];
24573 $13 = HEAP32[$12 + 36 >> 2];
24574 $12 = HEAP32[$12 + 32 >> 2];
24575 HEAP32[$8 + 7052 >> 2] = 0;
24576 HEAP32[$8 + 7056 >> 2] = 0;
24577 HEAP32[$8 + 6864 >> 2] = 0;
24578 $9 = $8;
24579 $16 = +($12 >>> 0) * .4 / +($13 >>> 0) + .5;
24580 label$42 : {
24581 if ($16 < 4294967296.0 & $16 >= 0.0) {
24582 $12 = ~~$16 >>> 0;
24583 break label$42;
24584 }
24585 $12 = 0;
24586 }
24587 HEAP32[$9 + 6860 >> 2] = $12 ? $12 : 1;
24588 FLAC__cpu_info($8 + 7156 | 0);
24589 $9 = HEAP32[$0 + 4 >> 2];
24590 HEAP32[$9 + 7244 >> 2] = 12;
24591 HEAP32[$9 + 7240 >> 2] = 13;
24592 HEAP32[$9 + 7236 >> 2] = 12;
24593 HEAP32[$9 + 7228 >> 2] = 14;
24594 HEAP32[$9 + 7224 >> 2] = 15;
24595 HEAP32[$9 + 7220 >> 2] = 16;
24596 HEAP32[$9 + 7232 >> 2] = 17;
24597 $10 = HEAP32[$0 >> 2];
24598 HEAP32[$10 >> 2] = 0;
24599 HEAP32[$9 + 7260 >> 2] = $7;
24600 label$44 : {
24601 label$45 : {
24602 label$46 : {
24603 if ($7) {
24604 if (!FLAC__ogg_encoder_aspect_init($10 + 632 | 0)) {
24605 break label$46
24606 }
24607 $10 = HEAP32[$0 >> 2];
24608 $9 = HEAP32[$0 + 4 >> 2];
24609 }
24610 $8 = $0 + 4 | 0;
24611 HEAP32[$9 + 7276 >> 2] = $2;
24612 HEAP32[$9 + 7264 >> 2] = $1;
24613 HEAP32[$9 + 7288 >> 2] = $6;
24614 HEAP32[$9 + 7280 >> 2] = $5;
24615 HEAP32[$9 + 7272 >> 2] = $4;
24616 HEAP32[$9 + 7268 >> 2] = $3;
24617 $1 = HEAP32[$10 + 36 >> 2];
24618 if (HEAPU32[$9 >> 2] < $1 >>> 0) {
24619 $3 = $1 + 5 | 0;
24620 label$49 : {
24621 label$50 : {
24622 label$51 : {
24623 if (HEAP32[$10 + 24 >> 2]) {
24624 $2 = 0;
24625 while (1) {
24626 $5 = $2 << 2;
24627 $4 = $5 + HEAP32[$8 >> 2] | 0;
24628 $6 = FLAC__memory_alloc_aligned_int32_array($3, $4 + 7328 | 0, $4 + 4 | 0);
24629 $4 = HEAP32[($5 + HEAP32[$8 >> 2] | 0) + 4 >> 2];
24630 HEAP32[$4 >> 2] = 0;
24631 HEAP32[$4 + 4 >> 2] = 0;
24632 HEAP32[$4 + 8 >> 2] = 0;
24633 HEAP32[$4 + 12 >> 2] = 0;
24634 $4 = ($5 + HEAP32[$8 >> 2] | 0) + 4 | 0;
24635 HEAP32[$4 >> 2] = HEAP32[$4 >> 2] + 16;
24636 if (!$6) {
24637 break label$51
24638 }
24639 $2 = $2 + 1 | 0;
24640 if ($2 >>> 0 < HEAPU32[HEAP32[$0 >> 2] + 24 >> 2]) {
24641 continue
24642 }
24643 break;
24644 };
24645 }
24646 $2 = HEAP32[$8 >> 2];
24647 $4 = FLAC__memory_alloc_aligned_int32_array($3, $2 + 7360 | 0, $2 + 36 | 0);
24648 $2 = HEAP32[HEAP32[$8 >> 2] + 36 >> 2];
24649 HEAP32[$2 >> 2] = 0;
24650 HEAP32[$2 + 4 >> 2] = 0;
24651 HEAP32[$2 + 8 >> 2] = 0;
24652 HEAP32[$2 + 12 >> 2] = 0;
24653 $2 = HEAP32[$8 >> 2];
24654 HEAP32[$2 + 36 >> 2] = HEAP32[$2 + 36 >> 2] + 16;
24655 if ($4) {
24656 $2 = HEAP32[$8 >> 2];
24657 $3 = FLAC__memory_alloc_aligned_int32_array($3, $2 + 7364 | 0, $2 + 40 | 0);
24658 $2 = HEAP32[HEAP32[$8 >> 2] + 40 >> 2];
24659 HEAP32[$2 >> 2] = 0;
24660 HEAP32[$2 + 4 >> 2] = 0;
24661 HEAP32[$2 + 8 >> 2] = 0;
24662 HEAP32[$2 + 12 >> 2] = 0;
24663 $2 = HEAP32[$8 >> 2] + 40 | 0;
24664 HEAP32[$2 >> 2] = HEAP32[$2 >> 2] + 16;
24665 $2 = ($3 | 0) != 0;
24666 } else {
24667 $2 = ($4 | 0) != 0
24668 }
24669 if (!$2) {
24670 break label$51
24671 }
24672 $3 = HEAP32[$0 >> 2];
24673 if (HEAP32[$3 + 556 >> 2]) {
24674 $2 = HEAP32[$8 >> 2];
24675 if (HEAP32[$3 + 40 >> 2]) {
24676 $9 = 0;
24677 while (1) {
24678 $2 = ($9 << 2) + $2 | 0;
24679 if (!FLAC__memory_alloc_aligned_int32_array($1, $2 + 7408 | 0, $2 + 84 | 0)) {
24680 break label$51
24681 }
24682 $2 = HEAP32[$0 + 4 >> 2];
24683 $9 = $9 + 1 | 0;
24684 if ($9 >>> 0 < HEAPU32[HEAP32[$0 >> 2] + 40 >> 2]) {
24685 continue
24686 }
24687 break;
24688 };
24689 }
24690 if (!FLAC__memory_alloc_aligned_int32_array($1, $2 + 7536 | 0, $2 + 212 | 0)) {
24691 break label$51
24692 }
24693 }
24694 $6 = 0;
24695 $10 = 1;
24696 $5 = 0;
24697 while (1) {
24698 if ($5 >>> 0 < HEAPU32[HEAP32[$0 >> 2] + 24 >> 2]) {
24699 $9 = 0;
24700 $2 = 1;
24701 $3 = 0;
24702 while (1) {
24703 if ($9 & 1) {
24704 break label$51
24705 }
24706 $3 = (HEAP32[$8 >> 2] + ($5 << 3) | 0) + ($3 << 2) | 0;
24707 $4 = FLAC__memory_alloc_aligned_int32_array($1, $3 + 7540 | 0, $3 + 256 | 0);
24708 $7 = $2 & ($4 | 0) != 0;
24709 $9 = !$4;
24710 $3 = 1;
24711 $2 = 0;
24712 if ($7) {
24713 continue
24714 }
24715 break;
24716 };
24717 $5 = $5 + 1 | 0;
24718 if ($4) {
24719 continue
24720 }
24721 break label$51;
24722 }
24723 break;
24724 };
24725 $7 = 1;
24726 while (1) {
24727 $9 = 0;
24728 $2 = 1;
24729 $3 = 0;
24730 if (!$7) {
24731 break label$51
24732 }
24733 while (1) {
24734 if ($9 & 1) {
24735 break label$51
24736 }
24737 $3 = (HEAP32[$8 >> 2] + ($6 << 3) | 0) + ($3 << 2) | 0;
24738 $4 = FLAC__memory_alloc_aligned_int32_array($1, $3 + 7604 | 0, $3 + 320 | 0);
24739 $5 = $2 & ($4 | 0) != 0;
24740 $9 = !$4;
24741 $3 = 1;
24742 $2 = 0;
24743 if ($5) {
24744 continue
24745 }
24746 break;
24747 };
24748 $7 = ($4 | 0) != 0;
24749 $2 = $10 & $7;
24750 $6 = 1;
24751 $10 = 0;
24752 if ($2) {
24753 continue
24754 }
24755 break;
24756 };
24757 if (!$4) {
24758 break label$51
24759 }
24760 $3 = $1 << 1;
24761 $2 = HEAP32[$0 + 4 >> 2];
24762 $2 = FLAC__memory_alloc_aligned_uint64_array($3, $2 + 7620 | 0, $2 + 6848 | 0);
24763 $9 = HEAP32[$0 >> 2];
24764 $4 = HEAP32[$9 + 572 >> 2];
24765 if (!$4 | !$2) {
24766 break label$50
24767 }
24768 $2 = HEAP32[$8 >> 2];
24769 if (FLAC__memory_alloc_aligned_int32_array($3, $2 + 7624 | 0, $2 + 6852 | 0)) {
24770 break label$49
24771 }
24772 }
24773 $9 = HEAP32[$0 >> 2];
24774 break label$44;
24775 }
24776 if ($4 | !$2) {
24777 break label$44
24778 }
24779 }
24780 $9 = HEAP32[$8 >> 2];
24781 label$64 : {
24782 if (($1 | 0) == HEAP32[$9 >> 2]) {
24783 break label$64
24784 }
24785 $2 = HEAP32[$0 >> 2];
24786 if (!HEAP32[$2 + 556 >> 2] | !HEAP32[$2 + 40 >> 2]) {
24787 break label$64
24788 }
24789 $9 = 0;
24790 while (1) {
24791 label$66 : {
24792 label$67 : {
24793 label$68 : {
24794 label$69 : {
24795 label$70 : {
24796 label$71 : {
24797 label$72 : {
24798 label$73 : {
24799 label$74 : {
24800 label$75 : {
24801 label$76 : {
24802 label$77 : {
24803 label$78 : {
24804 label$79 : {
24805 label$80 : {
24806 label$81 : {
24807 label$82 : {
24808 label$83 : {
24809 label$84 : {
24810 $2 = ($9 << 4) + $2 | 0;
24811 switch (HEAP32[$2 + 44 >> 2]) {
24812 case 16:
24813 break label$68;
24814 case 15:
24815 break label$69;
24816 case 14:
24817 break label$70;
24818 case 13:
24819 break label$71;
24820 case 12:
24821 break label$72;
24822 case 11:
24823 break label$73;
24824 case 10:
24825 break label$74;
24826 case 9:
24827 break label$75;
24828 case 8:
24829 break label$76;
24830 case 7:
24831 break label$77;
24832 case 6:
24833 break label$78;
24834 case 5:
24835 break label$79;
24836 case 4:
24837 break label$80;
24838 case 3:
24839 break label$81;
24840 case 2:
24841 break label$82;
24842 case 1:
24843 break label$83;
24844 case 0:
24845 break label$84;
24846 default:
24847 break label$67;
24848 };
24849 }
24850 FLAC__window_bartlett(HEAP32[(HEAP32[$8 >> 2] + ($9 << 2) | 0) + 84 >> 2], $1);
24851 break label$66;
24852 }
24853 FLAC__window_bartlett_hann(HEAP32[(HEAP32[$8 >> 2] + ($9 << 2) | 0) + 84 >> 2], $1);
24854 break label$66;
24855 }
24856 FLAC__window_blackman(HEAP32[(HEAP32[$8 >> 2] + ($9 << 2) | 0) + 84 >> 2], $1);
24857 break label$66;
24858 }
24859 FLAC__window_blackman_harris_4term_92db_sidelobe(HEAP32[(HEAP32[$8 >> 2] + ($9 << 2) | 0) + 84 >> 2], $1);
24860 break label$66;
24861 }
24862 FLAC__window_connes(HEAP32[(HEAP32[$8 >> 2] + ($9 << 2) | 0) + 84 >> 2], $1);
24863 break label$66;
24864 }
24865 FLAC__window_flattop(HEAP32[(HEAP32[$8 >> 2] + ($9 << 2) | 0) + 84 >> 2], $1);
24866 break label$66;
24867 }
24868 FLAC__window_gauss(HEAP32[(HEAP32[$8 >> 2] + ($9 << 2) | 0) + 84 >> 2], $1, HEAPF32[$2 + 48 >> 2]);
24869 break label$66;
24870 }
24871 FLAC__window_hamming(HEAP32[(HEAP32[$8 >> 2] + ($9 << 2) | 0) + 84 >> 2], $1);
24872 break label$66;
24873 }
24874 FLAC__window_hann(HEAP32[(HEAP32[$8 >> 2] + ($9 << 2) | 0) + 84 >> 2], $1);
24875 break label$66;
24876 }
24877 FLAC__window_kaiser_bessel(HEAP32[(HEAP32[$8 >> 2] + ($9 << 2) | 0) + 84 >> 2], $1);
24878 break label$66;
24879 }
24880 FLAC__window_nuttall(HEAP32[(HEAP32[$8 >> 2] + ($9 << 2) | 0) + 84 >> 2], $1);
24881 break label$66;
24882 }
24883 FLAC__window_rectangle(HEAP32[(HEAP32[$8 >> 2] + ($9 << 2) | 0) + 84 >> 2], $1);
24884 break label$66;
24885 }
24886 FLAC__window_triangle(HEAP32[(HEAP32[$8 >> 2] + ($9 << 2) | 0) + 84 >> 2], $1);
24887 break label$66;
24888 }
24889 FLAC__window_tukey(HEAP32[(HEAP32[$8 >> 2] + ($9 << 2) | 0) + 84 >> 2], $1, HEAPF32[$2 + 48 >> 2]);
24890 break label$66;
24891 }
24892 FLAC__window_partial_tukey(HEAP32[(HEAP32[$8 >> 2] + ($9 << 2) | 0) + 84 >> 2], $1, HEAPF32[$2 + 48 >> 2], HEAPF32[$2 + 52 >> 2], HEAPF32[$2 + 56 >> 2]);
24893 break label$66;
24894 }
24895 FLAC__window_punchout_tukey(HEAP32[(HEAP32[$8 >> 2] + ($9 << 2) | 0) + 84 >> 2], $1, HEAPF32[$2 + 48 >> 2], HEAPF32[$2 + 52 >> 2], HEAPF32[$2 + 56 >> 2]);
24896 break label$66;
24897 }
24898 FLAC__window_welch(HEAP32[(HEAP32[$8 >> 2] + ($9 << 2) | 0) + 84 >> 2], $1);
24899 break label$66;
24900 }
24901 FLAC__window_hann(HEAP32[(HEAP32[$8 >> 2] + ($9 << 2) | 0) + 84 >> 2], $1);
24902 }
24903 $9 = $9 + 1 | 0;
24904 $2 = HEAP32[$0 >> 2];
24905 if ($9 >>> 0 < HEAPU32[$2 + 40 >> 2]) {
24906 continue
24907 }
24908 break;
24909 };
24910 $9 = HEAP32[$8 >> 2];
24911 }
24912 HEAP32[$9 >> 2] = $1;
24913 }
24914 $1 = FLAC__bitwriter_init(HEAP32[$9 + 6856 >> 2]);
24915 $3 = HEAP32[$0 >> 2];
24916 if (!$1) {
24917 HEAP32[$3 >> 2] = 8;
24918 $9 = 1;
24919 break label$1;
24920 }
24921 if (HEAP32[$3 + 4 >> 2]) {
24922 $9 = 1;
24923 $2 = HEAP32[$8 >> 2];
24924 $1 = HEAP32[$3 + 36 >> 2] + 1 | 0;
24925 HEAP32[$2 + 11796 >> 2] = $1;
24926 label$87 : {
24927 if (!HEAP32[$3 + 24 >> 2]) {
24928 break label$87
24929 }
24930 $1 = safe_malloc_mul_2op_p(4, $1);
24931 HEAP32[HEAP32[$0 + 4 >> 2] + 11764 >> 2] = $1;
24932 $3 = HEAP32[$0 >> 2];
24933 if ($1) {
24934 while (1) {
24935 $2 = HEAP32[$8 >> 2];
24936 if ($9 >>> 0 >= HEAPU32[$3 + 24 >> 2]) {
24937 break label$87
24938 }
24939 $1 = safe_malloc_mul_2op_p(4, HEAP32[$2 + 11796 >> 2]);
24940 HEAP32[(HEAP32[$0 + 4 >> 2] + ($9 << 2) | 0) + 11764 >> 2] = $1;
24941 $9 = $9 + 1 | 0;
24942 $3 = HEAP32[$0 >> 2];
24943 if ($1) {
24944 continue
24945 }
24946 break;
24947 }
24948 }
24949 HEAP32[$3 >> 2] = 8;
24950 $9 = 1;
24951 break label$1;
24952 }
24953 HEAP32[$2 + 11800 >> 2] = 0;
24954 label$90 : {
24955 $2 = HEAP32[$2 + 11752 >> 2];
24956 if ($2) {
24957 break label$90
24958 }
24959 $2 = FLAC__stream_decoder_new();
24960 HEAP32[HEAP32[$8 >> 2] + 11752 >> 2] = $2;
24961 if ($2) {
24962 break label$90
24963 }
24964 HEAP32[HEAP32[$0 >> 2] >> 2] = 3;
24965 $9 = 1;
24966 break label$1;
24967 }
24968 $1 = FLAC__stream_decoder_init_stream($2, 18, 0, 0, 0, 0, 19, 20, 21, $0);
24969 $3 = HEAP32[$0 >> 2];
24970 if ($1) {
24971 break label$45
24972 }
24973 $2 = !HEAP32[$3 + 4 >> 2];
24974 } else {
24975 $2 = 1
24976 }
24977 $1 = HEAP32[$8 >> 2];
24978 HEAP32[$1 + 7312 >> 2] = 0;
24979 HEAP32[$1 + 7316 >> 2] = 0;
24980 HEAP32[$1 + 7292 >> 2] = 0;
24981 $4 = $1 + 11816 | 0;
24982 HEAP32[$4 >> 2] = 0;
24983 HEAP32[$4 + 4 >> 2] = 0;
24984 $4 = $1 + 11824 | 0;
24985 HEAP32[$4 >> 2] = 0;
24986 HEAP32[$4 + 4 >> 2] = 0;
24987 $4 = $1 + 11832 | 0;
24988 HEAP32[$4 >> 2] = 0;
24989 HEAP32[$4 + 4 >> 2] = 0;
24990 HEAP32[$1 + 11840 >> 2] = 0;
24991 HEAP32[$3 + 624 >> 2] = 0;
24992 HEAP32[$3 + 628 >> 2] = 0;
24993 HEAP32[$3 + 616 >> 2] = 0;
24994 HEAP32[$3 + 620 >> 2] = 0;
24995 HEAP32[$3 + 608 >> 2] = 0;
24996 HEAP32[$3 + 612 >> 2] = 0;
24997 if (!$2) {
24998 HEAP32[$1 + 11756 >> 2] = 0
24999 }
25000 if (!FLAC__bitwriter_write_raw_uint32(HEAP32[$1 + 6856 >> 2], HEAP32[1354], HEAP32[1355])) {
25001 HEAP32[HEAP32[$0 >> 2] >> 2] = 7;
25002 $9 = 1;
25003 break label$1;
25004 }
25005 $9 = 1;
25006 if (!write_bitbuffer_($0, 0, 0)) {
25007 break label$1
25008 }
25009 $1 = HEAP32[$0 + 4 >> 2];
25010 $2 = HEAP32[$0 >> 2];
25011 if (HEAP32[$2 + 4 >> 2]) {
25012 HEAP32[$1 + 11756 >> 2] = 1
25013 }
25014 HEAP32[$1 + 6872 >> 2] = 0;
25015 HEAP32[$1 + 6876 >> 2] = 0;
25016 HEAP32[$1 + 6880 >> 2] = 34;
25017 HEAP32[$1 + 6888 >> 2] = HEAP32[$2 + 36 >> 2];
25018 HEAP32[HEAP32[$0 + 4 >> 2] + 6892 >> 2] = HEAP32[HEAP32[$0 >> 2] + 36 >> 2];
25019 HEAP32[HEAP32[$0 + 4 >> 2] + 6896 >> 2] = 0;
25020 HEAP32[HEAP32[$0 + 4 >> 2] + 6900 >> 2] = 0;
25021 HEAP32[HEAP32[$0 + 4 >> 2] + 6904 >> 2] = HEAP32[HEAP32[$0 >> 2] + 32 >> 2];
25022 HEAP32[HEAP32[$0 + 4 >> 2] + 6908 >> 2] = HEAP32[HEAP32[$0 >> 2] + 24 >> 2];
25023 HEAP32[HEAP32[$0 + 4 >> 2] + 6912 >> 2] = HEAP32[HEAP32[$0 >> 2] + 28 >> 2];
25024 $1 = HEAP32[$0 >> 2];
25025 $2 = HEAP32[$1 + 596 >> 2];
25026 $3 = HEAP32[$0 + 4 >> 2] + 6920 | 0;
25027 HEAP32[$3 >> 2] = HEAP32[$1 + 592 >> 2];
25028 HEAP32[$3 + 4 >> 2] = $2;
25029 $1 = HEAP32[$0 + 4 >> 2];
25030 $2 = $1 + 6936 | 0;
25031 HEAP32[$2 >> 2] = 0;
25032 HEAP32[$2 + 4 >> 2] = 0;
25033 $1 = $1 + 6928 | 0;
25034 HEAP32[$1 >> 2] = 0;
25035 HEAP32[$1 + 4 >> 2] = 0;
25036 if (HEAP32[HEAP32[$0 >> 2] + 12 >> 2]) {
25037 FLAC__MD5Init(HEAP32[$8 >> 2] + 7060 | 0)
25038 }
25039 $1 = HEAP32[$8 >> 2];
25040 if (!FLAC__add_metadata_block($1 + 6872 | 0, HEAP32[$1 + 6856 >> 2])) {
25041 HEAP32[HEAP32[$0 >> 2] >> 2] = 7;
25042 break label$1;
25043 }
25044 if (!write_bitbuffer_($0, 0, 0)) {
25045 break label$1
25046 }
25047 HEAP32[HEAP32[$8 >> 2] + 6896 >> 2] = -1 << HEAP32[1358] ^ -1;
25048 $1 = HEAP32[$8 >> 2] + 6920 | 0;
25049 HEAP32[$1 >> 2] = 0;
25050 HEAP32[$1 + 4 >> 2] = 0;
25051 if (!$11) {
25052 HEAP32[$15 >> 2] = 4;
25053 $2 = HEAP32[HEAP32[$0 >> 2] + 604 >> 2];
25054 $1 = $15;
25055 HEAP32[$1 + 24 >> 2] = 0;
25056 HEAP32[$1 + 28 >> 2] = 0;
25057 HEAP32[$1 + 16 >> 2] = 0;
25058 HEAP32[$1 + 20 >> 2] = 0;
25059 HEAP32[$1 + 8 >> 2] = 8;
25060 HEAP32[$1 + 4 >> 2] = !$2;
25061 if (!FLAC__add_metadata_block($1, HEAP32[HEAP32[$0 + 4 >> 2] + 6856 >> 2])) {
25062 HEAP32[HEAP32[$0 >> 2] >> 2] = 7;
25063 break label$1;
25064 }
25065 if (!write_bitbuffer_($0, 0, 0)) {
25066 break label$1
25067 }
25068 }
25069 label$98 : {
25070 $3 = HEAP32[$0 >> 2];
25071 $4 = HEAP32[$3 + 604 >> 2];
25072 if (!$4) {
25073 break label$98
25074 }
25075 $2 = 0;
25076 while (1) {
25077 $1 = HEAP32[HEAP32[$3 + 600 >> 2] + ($2 << 2) >> 2];
25078 HEAP32[$1 + 4 >> 2] = ($4 + -1 | 0) == ($2 | 0);
25079 if (!FLAC__add_metadata_block($1, HEAP32[HEAP32[$8 >> 2] + 6856 >> 2])) {
25080 HEAP32[HEAP32[$0 >> 2] >> 2] = 7;
25081 break label$1;
25082 }
25083 if (write_bitbuffer_($0, 0, 0)) {
25084 $2 = $2 + 1 | 0;
25085 $3 = HEAP32[$0 >> 2];
25086 $4 = HEAP32[$3 + 604 >> 2];
25087 if ($2 >>> 0 >= $4 >>> 0) {
25088 break label$98
25089 }
25090 continue;
25091 }
25092 break;
25093 };
25094 break label$1;
25095 }
25096 label$102 : {
25097 $1 = HEAP32[$8 >> 2];
25098 $2 = HEAP32[$1 + 7272 >> 2];
25099 if (!$2) {
25100 break label$102
25101 }
25102 $1 = FUNCTION_TABLE[$2]($0, $3 + 624 | 0, HEAP32[$1 + 7288 >> 2]) | 0;
25103 $3 = HEAP32[$0 >> 2];
25104 if (($1 | 0) != 1) {
25105 break label$102
25106 }
25107 HEAP32[$3 >> 2] = 5;
25108 break label$1;
25109 }
25110 $9 = 0;
25111 if (!HEAP32[$3 + 4 >> 2]) {
25112 break label$1
25113 }
25114 HEAP32[HEAP32[$8 >> 2] + 11756 >> 2] = 2;
25115 break label$1;
25116 }
25117 HEAP32[HEAP32[$0 >> 2] >> 2] = 2;
25118 $9 = 1;
25119 break label$1;
25120 }
25121 HEAP32[$3 >> 2] = 3;
25122 $9 = 1;
25123 break label$1;
25124 }
25125 HEAP32[$9 >> 2] = 8;
25126 $9 = 1;
25127 }
25128 global$0 = $15 + 176 | 0;
25129 return $9;
25130 }
25131
25132 function precompute_partition_info_sums_($0, $1, $2, $3, $4, $5, $6) {
25133 $0 = $0 | 0;
25134 $1 = $1 | 0;
25135 $2 = $2 | 0;
25136 $3 = $3 | 0;
25137 $4 = $4 | 0;
25138 $5 = $5 | 0;
25139 $6 = $6 | 0;
25140 var $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0;
25141 $11 = 1 << $5;
25142 $14 = $11 >>> 0 > 1 ? $11 : 1;
25143 $8 = 0 - $3 | 0;
25144 $12 = $2 + $3 >>> $5 | 0;
25145 $9 = $12 - $3 | 0;
25146 label$1 : {
25147 if ($6 + 4 >>> 0 < (Math_clz32($12) ^ -32) + 33 >>> 0) {
25148 $6 = 0;
25149 while (1) {
25150 $3 = 0;
25151 $8 = $8 + $12 | 0;
25152 if ($7 >>> 0 < $8 >>> 0) {
25153 while (1) {
25154 $2 = HEAP32[($7 << 2) + $0 >> 2];
25155 $10 = $2 >> 31;
25156 $3 = ($10 ^ $2 + $10) + $3 | 0;
25157 $7 = $7 + 1 | 0;
25158 if ($7 >>> 0 < $8 >>> 0) {
25159 continue
25160 }
25161 break;
25162 };
25163 $7 = $9;
25164 }
25165 $2 = ($6 << 3) + $1 | 0;
25166 HEAP32[$2 >> 2] = $3;
25167 HEAP32[$2 + 4 >> 2] = 0;
25168 $9 = $9 + $12 | 0;
25169 $6 = $6 + 1 | 0;
25170 if (($14 | 0) != ($6 | 0)) {
25171 continue
25172 }
25173 break;
25174 };
25175 break label$1;
25176 }
25177 $2 = 0;
25178 while (1) {
25179 $13 = 0;
25180 $3 = 0;
25181 $8 = $8 + $12 | 0;
25182 if ($7 >>> 0 < $8 >>> 0) {
25183 while (1) {
25184 $6 = HEAP32[($7 << 2) + $0 >> 2];
25185 $10 = $6 >> 31;
25186 $10 = $10 ^ $6 + $10;
25187 $6 = $10 + $13 | 0;
25188 if ($6 >>> 0 < $10 >>> 0) {
25189 $3 = $3 + 1 | 0
25190 }
25191 $13 = $6;
25192 $7 = $7 + 1 | 0;
25193 if ($7 >>> 0 < $8 >>> 0) {
25194 continue
25195 }
25196 break;
25197 };
25198 $7 = $9;
25199 }
25200 $6 = ($2 << 3) + $1 | 0;
25201 HEAP32[$6 >> 2] = $13;
25202 HEAP32[$6 + 4 >> 2] = $3;
25203 $9 = $9 + $12 | 0;
25204 $2 = $2 + 1 | 0;
25205 if (($14 | 0) != ($2 | 0)) {
25206 continue
25207 }
25208 break;
25209 };
25210 }
25211 if (($5 | 0) > ($4 | 0)) {
25212 $7 = 0;
25213 $0 = $11;
25214 while (1) {
25215 $5 = $5 + -1 | 0;
25216 $8 = 0;
25217 $0 = $0 >>> 1 | 0;
25218 if ($0) {
25219 while (1) {
25220 $3 = ($7 << 3) + $1 | 0;
25221 $2 = HEAP32[$3 + 8 >> 2];
25222 $9 = HEAP32[$3 + 12 >> 2] + HEAP32[$3 + 4 >> 2] | 0;
25223 $3 = HEAP32[$3 >> 2];
25224 $2 = $3 + $2 | 0;
25225 if ($2 >>> 0 < $3 >>> 0) {
25226 $9 = $9 + 1 | 0
25227 }
25228 $6 = ($11 << 3) + $1 | 0;
25229 HEAP32[$6 >> 2] = $2;
25230 HEAP32[$6 + 4 >> 2] = $9;
25231 $7 = $7 + 2 | 0;
25232 $11 = $11 + 1 | 0;
25233 $8 = $8 + 1 | 0;
25234 if (($8 | 0) != ($0 | 0)) {
25235 continue
25236 }
25237 break;
25238 }
25239 }
25240 if (($5 | 0) > ($4 | 0)) {
25241 continue
25242 }
25243 break;
25244 };
25245 }
25246 }
25247
25248 function verify_read_callback_($0, $1, $2, $3) {
25249 $0 = $0 | 0;
25250 $1 = $1 | 0;
25251 $2 = $2 | 0;
25252 $3 = $3 | 0;
25253 var $4 = 0, $5 = 0;
25254 $5 = HEAP32[$3 + 4 >> 2];
25255 if (HEAP32[$5 + 11760 >> 2]) {
25256 HEAP32[$2 >> 2] = 4;
25257 $0 = HEAPU8[5409] | HEAPU8[5410] << 8 | (HEAPU8[5411] << 16 | HEAPU8[5412] << 24);
25258 HEAP8[$1 | 0] = $0;
25259 HEAP8[$1 + 1 | 0] = $0 >>> 8;
25260 HEAP8[$1 + 2 | 0] = $0 >>> 16;
25261 HEAP8[$1 + 3 | 0] = $0 >>> 24;
25262 HEAP32[HEAP32[$3 + 4 >> 2] + 11760 >> 2] = 0;
25263 return 0;
25264 }
25265 $0 = HEAP32[$5 + 11812 >> 2];
25266 if (!$0) {
25267 return 2
25268 }
25269 $4 = HEAP32[$2 >> 2];
25270 if ($0 >>> 0 < $4 >>> 0) {
25271 HEAP32[$2 >> 2] = $0;
25272 $4 = $0;
25273 }
25274 memcpy($1, HEAP32[$5 + 11804 >> 2], $4);
25275 $0 = HEAP32[$3 + 4 >> 2];
25276 $1 = $0 + 11804 | 0;
25277 $3 = $1;
25278 $4 = HEAP32[$1 >> 2];
25279 $1 = HEAP32[$2 >> 2];
25280 HEAP32[$3 >> 2] = $4 + $1;
25281 $0 = $0 + 11812 | 0;
25282 HEAP32[$0 >> 2] = HEAP32[$0 >> 2] - $1;
25283 return 0;
25284 }
25285
25286 function verify_write_callback_($0, $1, $2, $3) {
25287 $0 = $0 | 0;
25288 $1 = $1 | 0;
25289 $2 = $2 | 0;
25290 $3 = $3 | 0;
25291 var $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
25292 $7 = HEAP32[$1 >> 2];
25293 $5 = HEAP32[$3 + 4 >> 2];
25294 $0 = HEAP32[$1 + 8 >> 2];
25295 if ($0) {
25296 $4 = $7 << 2;
25297 while (1) {
25298 $8 = $6 << 2;
25299 $9 = HEAP32[$8 + $2 >> 2];
25300 $10 = HEAP32[($5 + $8 | 0) + 11764 >> 2];
25301 if (memcmp($9, $10, $4)) {
25302 $4 = 0;
25303 label$4 : {
25304 if ($7) {
25305 $0 = 0;
25306 while (1) {
25307 $2 = $0 << 2;
25308 $8 = HEAP32[$2 + $9 >> 2];
25309 $2 = HEAP32[$2 + $10 >> 2];
25310 if (($8 | 0) != ($2 | 0)) {
25311 $4 = $0;
25312 break label$4;
25313 }
25314 $0 = $0 + 1 | 0;
25315 if (($7 | 0) != ($0 | 0)) {
25316 continue
25317 }
25318 break;
25319 };
25320 }
25321 $2 = 0;
25322 $8 = 0;
25323 }
25324 $9 = HEAP32[$1 + 28 >> 2];
25325 $0 = $4;
25326 $11 = $0 + HEAP32[$1 + 24 >> 2] | 0;
25327 if ($11 >>> 0 < $0 >>> 0) {
25328 $9 = $9 + 1 | 0
25329 }
25330 $10 = $5 + 11816 | 0;
25331 HEAP32[$10 >> 2] = $11;
25332 HEAP32[$10 + 4 >> 2] = $9;
25333 $0 = HEAP32[$1 + 28 >> 2];
25334 $1 = HEAP32[$1 + 24 >> 2];
25335 HEAP32[$5 + 11840 >> 2] = $8;
25336 HEAP32[$5 + 11836 >> 2] = $2;
25337 HEAP32[$5 + 11832 >> 2] = $4;
25338 HEAP32[$5 + 11828 >> 2] = $6;
25339 (wasm2js_i32$0 = $5 + 11824 | 0, wasm2js_i32$1 = __wasm_i64_udiv($1, $0, $7)), HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
25340 HEAP32[HEAP32[$3 >> 2] >> 2] = 4;
25341 return 1;
25342 }
25343 $6 = $6 + 1 | 0;
25344 if (($0 | 0) != ($6 | 0)) {
25345 continue
25346 }
25347 break;
25348 };
25349 $2 = $5 + 11800 | 0;
25350 $1 = HEAP32[$2 >> 2] - $7 | 0;
25351 HEAP32[$2 >> 2] = $1;
25352 label$8 : {
25353 if (!$0) {
25354 break label$8
25355 }
25356 $2 = HEAP32[$5 + 11764 >> 2];
25357 $4 = $2;
25358 $2 = $7 << 2;
25359 memmove($4, $4 + $2 | 0, $1 << 2);
25360 $6 = 1;
25361 if (($0 | 0) == 1) {
25362 break label$8
25363 }
25364 while (1) {
25365 $1 = HEAP32[$3 + 4 >> 2];
25366 $4 = HEAP32[($1 + ($6 << 2) | 0) + 11764 >> 2];
25367 memmove($4, $2 + $4 | 0, HEAP32[$1 + 11800 >> 2] << 2);
25368 $6 = $6 + 1 | 0;
25369 if (($0 | 0) != ($6 | 0)) {
25370 continue
25371 }
25372 break;
25373 };
25374 }
25375 return 0;
25376 }
25377 $0 = $5 + 11800 | 0;
25378 HEAP32[$0 >> 2] = HEAP32[$0 >> 2] - $7;
25379 return 0;
25380 }
25381
25382 function verify_metadata_callback_($0, $1, $2) {
25383 $0 = $0 | 0;
25384 $1 = $1 | 0;
25385 $2 = $2 | 0;
25386 }
25387
25388 function verify_error_callback_($0, $1, $2) {
25389 $0 = $0 | 0;
25390 $1 = $1 | 0;
25391 $2 = $2 | 0;
25392 HEAP32[HEAP32[$2 >> 2] >> 2] = 3;
25393 }
25394
25395 function write_bitbuffer_($0, $1, $2) {
25396 var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0;
25397 $5 = global$0 - 16 | 0;
25398 global$0 = $5;
25399 $4 = FLAC__bitwriter_get_buffer(HEAP32[HEAP32[$0 + 4 >> 2] + 6856 >> 2], $5 + 4 | 0, $5);
25400 $3 = HEAP32[$0 >> 2];
25401 label$1 : {
25402 label$2 : {
25403 if (!$4) {
25404 HEAP32[$3 >> 2] = 8;
25405 break label$2;
25406 }
25407 label$4 : {
25408 if (!HEAP32[$3 + 4 >> 2]) {
25409 break label$4
25410 }
25411 $3 = HEAP32[$0 + 4 >> 2];
25412 HEAP32[$3 + 11804 >> 2] = HEAP32[$5 + 4 >> 2];
25413 HEAP32[$3 + 11812 >> 2] = HEAP32[$5 >> 2];
25414 if (!HEAP32[$3 + 11756 >> 2]) {
25415 HEAP32[$3 + 11760 >> 2] = 1;
25416 break label$4;
25417 }
25418 if (FLAC__stream_decoder_process_single(HEAP32[$3 + 11752 >> 2])) {
25419 break label$4
25420 }
25421 FLAC__bitwriter_clear(HEAP32[HEAP32[$0 + 4 >> 2] + 6856 >> 2]);
25422 $0 = HEAP32[$0 >> 2];
25423 if (HEAP32[$0 >> 2] == 4) {
25424 break label$1
25425 }
25426 HEAP32[$0 >> 2] = 3;
25427 break label$1;
25428 }
25429 $12 = HEAP32[$5 >> 2];
25430 $14 = HEAP32[$5 + 4 >> 2];
25431 HEAP32[$5 + 8 >> 2] = 0;
25432 HEAP32[$5 + 12 >> 2] = 0;
25433 label$6 : {
25434 label$7 : {
25435 $3 = HEAP32[$0 + 4 >> 2];
25436 $4 = HEAP32[$3 + 7272 >> 2];
25437 if (!$4) {
25438 break label$7
25439 }
25440 if ((FUNCTION_TABLE[$4]($0, $5 + 8 | 0, HEAP32[$3 + 7288 >> 2]) | 0) != 1) {
25441 break label$7
25442 }
25443 break label$6;
25444 }
25445 label$8 : {
25446 if ($1) {
25447 break label$8
25448 }
25449 label$9 : {
25450 switch (HEAPU8[$14 | 0] & 127) {
25451 case 0:
25452 $3 = HEAP32[$5 + 12 >> 2];
25453 $4 = HEAP32[$0 >> 2];
25454 HEAP32[$4 + 608 >> 2] = HEAP32[$5 + 8 >> 2];
25455 HEAP32[$4 + 612 >> 2] = $3;
25456 break label$8;
25457 case 3:
25458 break label$9;
25459 default:
25460 break label$8;
25461 };
25462 }
25463 $3 = HEAP32[$0 >> 2];
25464 if (HEAP32[$3 + 616 >> 2] | HEAP32[$3 + 620 >> 2]) {
25465 break label$8
25466 }
25467 $4 = HEAP32[$5 + 12 >> 2];
25468 HEAP32[$3 + 616 >> 2] = HEAP32[$5 + 8 >> 2];
25469 HEAP32[$3 + 620 >> 2] = $4;
25470 }
25471 $6 = HEAP32[$0 + 4 >> 2];
25472 $7 = HEAP32[$6 + 7048 >> 2];
25473 label$11 : {
25474 if (!$7) {
25475 break label$11
25476 }
25477 $8 = HEAP32[$0 >> 2];
25478 $4 = $8;
25479 $3 = HEAP32[$4 + 628 >> 2];
25480 $15 = HEAP32[$4 + 624 >> 2];
25481 if (!($3 | $15)) {
25482 break label$11
25483 }
25484 $16 = HEAP32[$7 >> 2];
25485 if (!$16) {
25486 break label$11
25487 }
25488 $10 = HEAP32[$6 + 7292 >> 2];
25489 if ($10 >>> 0 >= $16 >>> 0) {
25490 break label$11
25491 }
25492 $13 = HEAP32[$6 + 7316 >> 2];
25493 $4 = $13;
25494 $17 = HEAP32[$6 + 7312 >> 2];
25495 $18 = HEAP32[$8 + 36 >> 2];
25496 $8 = $18;
25497 $9 = $17 + $8 | 0;
25498 if ($9 >>> 0 < $8 >>> 0) {
25499 $4 = $4 + 1 | 0
25500 }
25501 $4 = $4 + -1 | 0;
25502 $11 = $4 + 1 | 0;
25503 $8 = $4;
25504 $4 = $9 + -1 | 0;
25505 $8 = ($4 | 0) != -1 ? $11 : $8;
25506 $19 = HEAP32[$7 + 4 >> 2];
25507 while (1) {
25508 $7 = $19 + Math_imul($10, 24) | 0;
25509 $11 = HEAP32[$7 >> 2];
25510 $9 = HEAP32[$7 + 4 >> 2];
25511 if (($8 | 0) == ($9 | 0) & $11 >>> 0 > $4 >>> 0 | $9 >>> 0 > $8 >>> 0) {
25512 break label$11
25513 }
25514 if (($9 | 0) == ($13 | 0) & $11 >>> 0 >= $17 >>> 0 | $9 >>> 0 > $13 >>> 0) {
25515 HEAP32[$7 >> 2] = $17;
25516 HEAP32[$7 + 4 >> 2] = $13;
25517 $9 = HEAP32[$5 + 8 >> 2];
25518 $11 = HEAP32[$5 + 12 >> 2];
25519 HEAP32[$7 + 16 >> 2] = $18;
25520 HEAP32[$7 + 8 >> 2] = $9 - $15;
25521 HEAP32[$7 + 12 >> 2] = $11 - ($3 + ($9 >>> 0 < $15 >>> 0) | 0);
25522 }
25523 $10 = $10 + 1 | 0;
25524 HEAP32[$6 + 7292 >> 2] = $10;
25525 if (($10 | 0) != ($16 | 0)) {
25526 continue
25527 }
25528 break;
25529 };
25530 }
25531 label$14 : {
25532 if (HEAP32[$6 + 7260 >> 2]) {
25533 $2 = FLAC__ogg_encoder_aspect_write_callback_wrapper(HEAP32[$0 >> 2] + 632 | 0, $14, $12, $1, HEAP32[$6 + 7056 >> 2], $2, HEAP32[$6 + 7276 >> 2], $0, HEAP32[$6 + 7288 >> 2]);
25534 break label$14;
25535 }
25536 $2 = FUNCTION_TABLE[HEAP32[$6 + 7276 >> 2]]($0, $14, $12, $1, HEAP32[$6 + 7056 >> 2], HEAP32[$6 + 7288 >> 2]) | 0;
25537 }
25538 if (!$2) {
25539 $2 = HEAP32[$0 + 4 >> 2];
25540 $3 = $2;
25541 $8 = $3;
25542 $4 = HEAP32[$3 + 7308 >> 2];
25543 $6 = $12 + HEAP32[$3 + 7304 >> 2] | 0;
25544 if ($6 >>> 0 < $12 >>> 0) {
25545 $4 = $4 + 1 | 0
25546 }
25547 HEAP32[$8 + 7304 >> 2] = $6;
25548 HEAP32[$3 + 7308 >> 2] = $4;
25549 $3 = HEAP32[$2 + 7316 >> 2];
25550 $4 = HEAP32[$2 + 7312 >> 2] + $1 | 0;
25551 if ($4 >>> 0 < $1 >>> 0) {
25552 $3 = $3 + 1 | 0
25553 }
25554 HEAP32[$2 + 7312 >> 2] = $4;
25555 HEAP32[$2 + 7316 >> 2] = $3;
25556 $10 = 1;
25557 $4 = $2;
25558 $3 = HEAP32[$2 + 7320 >> 2];
25559 $2 = HEAP32[$2 + 7056 >> 2] + 1 | 0;
25560 HEAP32[$4 + 7320 >> 2] = $3 >>> 0 > $2 >>> 0 ? $3 : $2;
25561 FLAC__bitwriter_clear(HEAP32[HEAP32[$0 + 4 >> 2] + 6856 >> 2]);
25562 if (!$1) {
25563 break label$1
25564 }
25565 $1 = HEAP32[$0 + 4 >> 2] + 6896 | 0;
25566 $2 = HEAP32[$1 >> 2];
25567 $4 = $1;
25568 $1 = HEAP32[$5 >> 2];
25569 HEAP32[$4 >> 2] = $1 >>> 0 < $2 >>> 0 ? $1 : $2;
25570 $2 = HEAP32[$0 + 4 >> 2] + 6900 | 0;
25571 $0 = HEAP32[$2 >> 2];
25572 HEAP32[$2 >> 2] = $1 >>> 0 > $0 >>> 0 ? $1 : $0;
25573 break label$1;
25574 }
25575 }
25576 HEAP32[HEAP32[$0 >> 2] >> 2] = 5;
25577 FLAC__bitwriter_clear(HEAP32[HEAP32[$0 + 4 >> 2] + 6856 >> 2]);
25578 HEAP32[HEAP32[$0 >> 2] >> 2] = 5;
25579 }
25580 $10 = 0;
25581 }
25582 global$0 = $5 + 16 | 0;
25583 return $10;
25584 }
25585
25586 function FLAC__stream_encoder_init_ogg_stream($0, $1, $2, $3, $4, $5, $6) {
25587 $0 = $0 | 0;
25588 $1 = $1 | 0;
25589 $2 = $2 | 0;
25590 $3 = $3 | 0;
25591 $4 = $4 | 0;
25592 $5 = $5 | 0;
25593 $6 = $6 | 0;
25594 return init_stream_internal__1($0, $1, $2, $3, $4, $5, $6, 1) | 0;
25595 }
25596
25597 function process_subframe_($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10) {
25598 var $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0, $23 = 0, $24 = 0.0, $25 = 0, $26 = 0, $27 = 0.0, $28 = 0, $29 = 0, $30 = 0, $31 = 0, $32 = 0, $33 = 0, $34 = 0, $35 = Math_fround(0), $36 = 0, $37 = 0, $38 = 0, $39 = 0, $40 = 0, $41 = 0, $42 = Math_fround(0), $43 = 0, $44 = 0, $45 = 0, $46 = 0, $47 = 0, $48 = 0;
25599 $14 = global$0 - 576 | 0;
25600 global$0 = $14;
25601 $25 = HEAP32[(HEAPU32[HEAP32[$0 >> 2] + 28 >> 2] > 16 ? 5644 : 5640) >> 2];
25602 $12 = HEAP32[$3 >> 2];
25603 label$1 : {
25604 label$2 : {
25605 if (HEAP32[HEAP32[$0 + 4 >> 2] + 7256 >> 2]) {
25606 $11 = -1;
25607 if ($12 >>> 0 > 3) {
25608 break label$2
25609 }
25610 }
25611 $16 = HEAP32[$6 >> 2];
25612 HEAP32[$16 + 4 >> 2] = $5;
25613 HEAP32[$16 >> 2] = 1;
25614 $11 = HEAP32[$16 + 288 >> 2] + (HEAP32[1416] + (HEAP32[1415] + (HEAP32[1414] + Math_imul($4, $12) | 0) | 0) | 0) | 0;
25615 $12 = HEAP32[$3 >> 2];
25616 if ($12 >>> 0 < 4) {
25617 break label$1
25618 }
25619 }
25620 $13 = HEAP32[$0 + 4 >> 2];
25621 $16 = $12 + -4 | 0;
25622 label$4 : {
25623 if (((Math_clz32($16 | 1) ^ 31) + $4 | 0) + 4 >>> 0 <= 32) {
25624 $13 = FUNCTION_TABLE[HEAP32[$13 + 7224 >> 2]]($5 + 16 | 0, $16, $14 + 416 | 0) | 0;
25625 break label$4;
25626 }
25627 $13 = FUNCTION_TABLE[HEAP32[$13 + 7228 >> 2]]($5 + 16 | 0, $16, $14 + 416 | 0) | 0;
25628 }
25629 label$6 : {
25630 label$7 : {
25631 label$8 : {
25632 label$9 : {
25633 $15 = HEAP32[$0 + 4 >> 2];
25634 if (HEAP32[$15 + 7248 >> 2] | HEAPF32[$14 + 420 >> 2] != Math_fround(0.0)) {
25635 break label$9
25636 }
25637 $12 = 1;
25638 $17 = HEAP32[$5 >> 2];
25639 $16 = HEAP32[$3 >> 2];
25640 if ($16 >>> 0 <= 1) {
25641 break label$8
25642 }
25643 while (1) {
25644 if (($17 | 0) != HEAP32[($12 << 2) + $5 >> 2]) {
25645 break label$9
25646 }
25647 $12 = $12 + 1 | 0;
25648 if ($12 >>> 0 < $16 >>> 0) {
25649 continue
25650 }
25651 break;
25652 };
25653 break label$8;
25654 }
25655 $12 = HEAP32[$0 >> 2];
25656 if (!HEAP32[$15 + 7252 >> 2]) {
25657 $16 = $11;
25658 break label$7;
25659 }
25660 $16 = -1;
25661 if (($11 | 0) != -1) {
25662 $16 = $11;
25663 break label$6;
25664 }
25665 if (!HEAP32[$12 + 556 >> 2]) {
25666 break label$7
25667 }
25668 $16 = $11;
25669 break label$6;
25670 }
25671 $0 = HEAP32[$6 + 4 >> 2];
25672 HEAP32[$0 + 4 >> 2] = $17;
25673 HEAP32[$0 >> 2] = 0;
25674 $0 = HEAP32[$0 + 288 >> 2] + (HEAP32[1416] + (HEAP32[1415] + (HEAP32[1414] + $4 | 0) | 0) | 0) | 0;
25675 $19 = $0 >>> 0 < $11 >>> 0;
25676 $11 = $19 ? $0 : $11;
25677 break label$1;
25678 }
25679 $11 = HEAP32[$12 + 568 >> 2];
25680 $18 = $11 ? 0 : $13;
25681 $13 = $11 ? 4 : $13;
25682 $11 = HEAP32[$3 >> 2];
25683 $29 = $13 >>> 0 < $11 >>> 0 ? $13 : $11 + -1 | 0;
25684 if ($18 >>> 0 > $29 >>> 0) {
25685 break label$6
25686 }
25687 $32 = $25 + -1 | 0;
25688 $33 = HEAP32[1416];
25689 $30 = HEAP32[1415];
25690 $34 = HEAP32[1414];
25691 $42 = Math_fround($4 >>> 0);
25692 while (1) {
25693 $12 = $18 << 2;
25694 $35 = HEAPF32[$12 + ($14 + 416 | 0) >> 2];
25695 if (!($35 >= $42)) {
25696 $31 = !$19;
25697 $17 = $31 << 2;
25698 $36 = HEAP32[$17 + $7 >> 2];
25699 $21 = HEAP32[$6 + $17 >> 2];
25700 $23 = HEAP32[HEAP32[$0 >> 2] + 572 >> 2];
25701 $11 = HEAP32[$0 + 4 >> 2];
25702 $13 = HEAP32[$11 + 6852 >> 2];
25703 $15 = HEAP32[$11 + 6848 >> 2];
25704 $11 = $5 + $12 | 0;
25705 $12 = HEAP32[$3 >> 2] - $18 | 0;
25706 $17 = HEAP32[$8 + $17 >> 2];
25707 FLAC__fixed_compute_residual($11, $12, $18, $17);
25708 HEAP32[$21 + 36 >> 2] = $17;
25709 HEAP32[$21 + 12 >> 2] = $36;
25710 HEAP32[$21 >> 2] = 2;
25711 HEAP32[$21 + 4 >> 2] = 0;
25712 $37 = $35 > Math_fround(0.0);
25713 $26 = HEAP32[$0 + 4 >> 2];
25714 $22 = $18;
25715 $27 = +$35 + .5;
25716 label$15 : {
25717 if ($27 < 4294967296.0 & $27 >= 0.0) {
25718 $11 = ~~$27 >>> 0;
25719 break label$15;
25720 }
25721 $11 = 0;
25722 }
25723 $11 = $37 ? $11 + 1 | 0 : 1;
25724 $15 = find_best_partition_order_($26, $17, $15, $13, $12, $22, $11 >>> 0 < $25 >>> 0 ? $11 : $32, $25, $1, $2, $4, $23, $21 + 4 | 0);
25725 HEAP32[$21 + 16 >> 2] = $18;
25726 if ($18) {
25727 $13 = $21 + 20 | 0;
25728 $11 = 0;
25729 while (1) {
25730 $12 = $11 << 2;
25731 HEAP32[$12 + $13 >> 2] = HEAP32[$5 + $12 >> 2];
25732 $11 = $11 + 1 | 0;
25733 if (($18 | 0) != ($11 | 0)) {
25734 continue
25735 }
25736 break;
25737 };
25738 }
25739 $11 = HEAP32[$21 + 288 >> 2] + ($33 + ($30 + ($34 + ($15 + Math_imul($4, $18) | 0) | 0) | 0) | 0) | 0;
25740 $12 = $11 >>> 0 < $16 >>> 0;
25741 $19 = $12 ? $31 : $19;
25742 $16 = $12 ? $11 : $16;
25743 }
25744 $18 = $18 + 1 | 0;
25745 if ($18 >>> 0 <= $29 >>> 0) {
25746 continue
25747 }
25748 break;
25749 };
25750 $12 = HEAP32[$0 >> 2];
25751 }
25752 $13 = HEAP32[$12 + 556 >> 2];
25753 if (!$13) {
25754 $11 = $16;
25755 break label$1;
25756 }
25757 $11 = HEAP32[$3 >> 2];
25758 $13 = $13 >>> 0 < $11 >>> 0 ? $13 : $11 + -1 | 0;
25759 HEAP32[$14 + 12 >> 2] = $13;
25760 if (!$13) {
25761 $11 = $16;
25762 break label$1;
25763 }
25764 if (!HEAP32[$12 + 40 >> 2]) {
25765 $11 = $16;
25766 break label$1;
25767 }
25768 $40 = 33 - $4 | 0;
25769 $43 = $25 + -1 | 0;
25770 $44 = HEAP32[1413];
25771 $45 = HEAP32[1412];
25772 $46 = HEAP32[1416];
25773 $21 = HEAP32[1415];
25774 $47 = HEAP32[1414];
25775 $27 = +($4 >>> 0);
25776 $29 = $4 >>> 0 < 18;
25777 $32 = $4 >>> 0 > 16;
25778 $33 = $4 >>> 0 > 17;
25779 while (1) {
25780 $12 = HEAP32[$0 + 4 >> 2];
25781 FLAC__lpc_window_data($5, HEAP32[($12 + ($38 << 2) | 0) + 84 >> 2], HEAP32[$12 + 212 >> 2], $11);
25782 $11 = HEAP32[$0 + 4 >> 2];
25783 FUNCTION_TABLE[HEAP32[$11 + 7232 >> 2]](HEAP32[$11 + 212 >> 2], HEAP32[$3 >> 2], HEAP32[$14 + 12 >> 2] + 1 | 0, $14 + 272 | 0);
25784 label$23 : {
25785 if (HEAPF32[$14 + 272 >> 2] == Math_fround(0.0)) {
25786 break label$23
25787 }
25788 FLAC__lpc_compute_lp_coefficients($14 + 272 | 0, $14 + 12 | 0, HEAP32[$0 + 4 >> 2] + 7628 | 0, $14 + 16 | 0);
25789 $15 = 1;
25790 $12 = HEAP32[$14 + 12 >> 2];
25791 $17 = HEAP32[$0 >> 2];
25792 if (!HEAP32[$17 + 568 >> 2]) {
25793 $11 = $14;
25794 $12 = FLAC__lpc_compute_best_order($11 + 16 | 0, $12, HEAP32[$3 >> 2], (HEAP32[$17 + 564 >> 2] ? 5 : HEAP32[$17 + 560 >> 2]) + $4 | 0);
25795 HEAP32[$11 + 12 >> 2] = $12;
25796 $15 = $12;
25797 }
25798 $11 = HEAP32[$3 >> 2];
25799 if ($12 >>> 0 >= $11 >>> 0) {
25800 $12 = $11 + -1 | 0;
25801 HEAP32[$14 + 12 >> 2] = $12;
25802 }
25803 if ($15 >>> 0 > $12 >>> 0) {
25804 break label$23
25805 }
25806 while (1) {
25807 label$29 : {
25808 $30 = $15 + -1 | 0;
25809 $24 = FLAC__lpc_compute_expected_bits_per_residual_sample(HEAPF64[($14 + 16 | 0) + ($30 << 3) >> 3], $11 - $15 | 0);
25810 if ($24 >= $27) {
25811 break label$29
25812 }
25813 $11 = $24 > 0.0;
25814 $24 = $24 + .5;
25815 label$30 : {
25816 if ($24 < 4294967296.0 & $24 >= 0.0) {
25817 $13 = ~~$24 >>> 0;
25818 break label$30;
25819 }
25820 $13 = 0;
25821 }
25822 $13 = $11 ? $13 + 1 | 0 : 1;
25823 $11 = $13 >>> 0 < $25 >>> 0;
25824 $12 = HEAP32[$0 >> 2];
25825 label$32 : {
25826 if (HEAP32[$12 + 564 >> 2]) {
25827 $22 = 5;
25828 $26 = 15;
25829 if ($33) {
25830 break label$32
25831 }
25832 $17 = (Math_clz32($15) ^ -32) + $40 | 0;
25833 if ($17 >>> 0 > 14) {
25834 break label$32
25835 }
25836 $26 = $17 >>> 0 > 5 ? $17 : 5;
25837 break label$32;
25838 }
25839 $26 = HEAP32[$12 + 560 >> 2];
25840 $22 = $26;
25841 }
25842 $34 = $11 ? $13 : $43;
25843 $39 = ($15 << 2) + $5 | 0;
25844 $11 = Math_clz32($15);
25845 $31 = $11 ^ 31;
25846 $41 = ($11 ^ -32) + $40 | 0;
25847 while (1) {
25848 $23 = HEAP32[$3 >> 2];
25849 $13 = !$19;
25850 $11 = $13 << 2;
25851 $37 = HEAP32[$11 + $7 >> 2];
25852 $20 = HEAP32[$6 + $11 >> 2];
25853 $28 = HEAP32[$8 + $11 >> 2];
25854 $36 = HEAP32[$12 + 572 >> 2];
25855 $12 = HEAP32[$0 + 4 >> 2];
25856 $18 = HEAP32[$12 + 6852 >> 2];
25857 $17 = HEAP32[$12 + 6848 >> 2];
25858 $11 = 0;
25859 $48 = $19;
25860 $19 = ($12 + ($30 << 7) | 0) + 7628 | 0;
25861 $12 = $29 ? ($41 >>> 0 > $22 >>> 0 ? $22 : $41) : $22;
25862 if (!FLAC__lpc_quantize_coefficients($19, $15, $12, $14 + 448 | 0, $14 + 444 | 0)) {
25863 $23 = $23 - $15 | 0;
25864 $19 = $4 + $12 | 0;
25865 label$37 : {
25866 if ($19 + $31 >>> 0 <= 32) {
25867 $11 = HEAP32[$0 + 4 >> 2];
25868 if (!($12 >>> 0 > 16 | $32)) {
25869 FUNCTION_TABLE[HEAP32[$11 + 7244 >> 2]]($39, $23, $14 + 448 | 0, $15, HEAP32[$14 + 444 >> 2], $28);
25870 break label$37;
25871 }
25872 FUNCTION_TABLE[HEAP32[$11 + 7236 >> 2]]($39, $23, $14 + 448 | 0, $15, HEAP32[$14 + 444 >> 2], $28);
25873 break label$37;
25874 }
25875 FUNCTION_TABLE[HEAP32[HEAP32[$0 + 4 >> 2] + 7240 >> 2]]($39, $23, $14 + 448 | 0, $15, HEAP32[$14 + 444 >> 2], $28);
25876 }
25877 HEAP32[$20 >> 2] = 3;
25878 HEAP32[$20 + 4 >> 2] = 0;
25879 HEAP32[$20 + 284 >> 2] = $28;
25880 HEAP32[$20 + 12 >> 2] = $37;
25881 $18 = find_best_partition_order_(HEAP32[$0 + 4 >> 2], $28, $17, $18, $23, $15, $34, $25, $1, $2, $4, $36, $20 + 4 | 0);
25882 HEAP32[$20 + 20 >> 2] = $12;
25883 HEAP32[$20 + 16 >> 2] = $15;
25884 HEAP32[$20 + 24 >> 2] = HEAP32[$14 + 444 >> 2];
25885 memcpy($20 + 28 | 0, $14 + 448 | 0, 128);
25886 $11 = 0;
25887 if ($15) {
25888 while (1) {
25889 $17 = $11 << 2;
25890 HEAP32[($17 + $20 | 0) + 156 >> 2] = HEAP32[$5 + $17 >> 2];
25891 $11 = $11 + 1 | 0;
25892 if (($15 | 0) != ($11 | 0)) {
25893 continue
25894 }
25895 break;
25896 }
25897 }
25898 $11 = ((HEAP32[$20 + 288 >> 2] + (((($18 + Math_imul($15, $19) | 0) + $47 | 0) + $21 | 0) + $46 | 0) | 0) + $45 | 0) + $44 | 0;
25899 }
25900 $12 = ($11 | 0) != 0 & $11 >>> 0 < $16 >>> 0;
25901 $19 = $12 ? $13 : $48;
25902 $16 = $12 ? $11 : $16;
25903 $22 = $22 + 1 | 0;
25904 if ($22 >>> 0 > $26 >>> 0) {
25905 break label$29
25906 }
25907 $12 = HEAP32[$0 >> 2];
25908 continue;
25909 };
25910 }
25911 $15 = $15 + 1 | 0;
25912 if ($15 >>> 0 > HEAPU32[$14 + 12 >> 2]) {
25913 break label$23
25914 }
25915 $11 = HEAP32[$3 >> 2];
25916 continue;
25917 };
25918 }
25919 $38 = $38 + 1 | 0;
25920 if ($38 >>> 0 < HEAPU32[HEAP32[$0 >> 2] + 40 >> 2]) {
25921 $11 = HEAP32[$3 >> 2];
25922 continue;
25923 }
25924 break;
25925 };
25926 $11 = $16;
25927 }
25928 if (($11 | 0) == -1) {
25929 $0 = HEAP32[$3 >> 2];
25930 $1 = HEAP32[($19 << 2) + $6 >> 2];
25931 HEAP32[$1 + 4 >> 2] = $5;
25932 HEAP32[$1 >> 2] = 1;
25933 $11 = HEAP32[$1 + 288 >> 2] + (HEAP32[1416] + (HEAP32[1415] + (HEAP32[1414] + Math_imul($0, $4) | 0) | 0) | 0) | 0;
25934 }
25935 HEAP32[$9 >> 2] = $19;
25936 HEAP32[$10 >> 2] = $11;
25937 global$0 = $14 + 576 | 0;
25938 }
25939
25940 function add_subframe_($0, $1, $2, $3, $4) {
25941 var $5 = 0;
25942 $5 = 1;
25943 label$1 : {
25944 label$2 : {
25945 label$3 : {
25946 switch (HEAP32[$3 >> 2]) {
25947 case 0:
25948 if (FLAC__subframe_add_constant($3 + 4 | 0, $2, HEAP32[$3 + 288 >> 2], $4)) {
25949 break label$1
25950 }
25951 break label$2;
25952 case 2:
25953 if (FLAC__subframe_add_fixed($3 + 4 | 0, $1 - HEAP32[$3 + 16 >> 2] | 0, $2, HEAP32[$3 + 288 >> 2], $4)) {
25954 break label$1
25955 }
25956 break label$2;
25957 case 3:
25958 if (FLAC__subframe_add_lpc($3 + 4 | 0, $1 - HEAP32[$3 + 16 >> 2] | 0, $2, HEAP32[$3 + 288 >> 2], $4)) {
25959 break label$1
25960 }
25961 break label$2;
25962 case 1:
25963 break label$3;
25964 default:
25965 break label$1;
25966 };
25967 }
25968 if (FLAC__subframe_add_verbatim($3 + 4 | 0, $1, $2, HEAP32[$3 + 288 >> 2], $4)) {
25969 break label$1
25970 }
25971 }
25972 HEAP32[HEAP32[$0 >> 2] >> 2] = 7;
25973 $5 = 0;
25974 }
25975 return $5;
25976 }
25977
25978 function FLAC__stream_encoder_set_ogg_serial_number($0, $1) {
25979 $0 = $0 | 0;
25980 $1 = $1 | 0;
25981 $0 = HEAP32[$0 >> 2];
25982 if (HEAP32[$0 >> 2] == 1) {
25983 HEAP32[$0 + 632 >> 2] = $1;
25984 $0 = 1;
25985 } else {
25986 $0 = 0
25987 }
25988 return $0 | 0;
25989 }
25990
25991 function FLAC__stream_encoder_set_verify($0, $1) {
25992 $0 = $0 | 0;
25993 $1 = $1 | 0;
25994 $0 = HEAP32[$0 >> 2];
25995 if (HEAP32[$0 >> 2] == 1) {
25996 HEAP32[$0 + 4 >> 2] = $1;
25997 $0 = 1;
25998 } else {
25999 $0 = 0
26000 }
26001 return $0 | 0;
26002 }
26003
26004 function FLAC__stream_encoder_set_channels($0, $1) {
26005 $0 = $0 | 0;
26006 $1 = $1 | 0;
26007 $0 = HEAP32[$0 >> 2];
26008 if (HEAP32[$0 >> 2] == 1) {
26009 HEAP32[$0 + 24 >> 2] = $1;
26010 $0 = 1;
26011 } else {
26012 $0 = 0
26013 }
26014 return $0 | 0;
26015 }
26016
26017 function FLAC__stream_encoder_set_bits_per_sample($0, $1) {
26018 $0 = $0 | 0;
26019 $1 = $1 | 0;
26020 $0 = HEAP32[$0 >> 2];
26021 if (HEAP32[$0 >> 2] == 1) {
26022 HEAP32[$0 + 28 >> 2] = $1;
26023 $0 = 1;
26024 } else {
26025 $0 = 0
26026 }
26027 return $0 | 0;
26028 }
26029
26030 function FLAC__stream_encoder_set_sample_rate($0, $1) {
26031 $0 = $0 | 0;
26032 $1 = $1 | 0;
26033 $0 = HEAP32[$0 >> 2];
26034 if (HEAP32[$0 >> 2] == 1) {
26035 HEAP32[$0 + 32 >> 2] = $1;
26036 $0 = 1;
26037 } else {
26038 $0 = 0
26039 }
26040 return $0 | 0;
26041 }
26042
26043 function FLAC__stream_encoder_set_compression_level($0, $1) {
26044 $0 = $0 | 0;
26045 $1 = $1 | 0;
26046 var $2 = 0, $3 = 0, $4 = 0;
26047 $3 = HEAP32[$0 >> 2];
26048 if (HEAP32[$3 >> 2] == 1) {
26049 $2 = Math_imul($1 >>> 0 < 8 ? $1 : 8, 44);
26050 $1 = $2 + 11184 | 0;
26051 $4 = HEAP32[$1 + 4 >> 2];
26052 HEAP32[$3 + 16 >> 2] = HEAP32[$1 >> 2];
26053 HEAP32[$3 + 20 >> 2] = $4;
26054 $3 = FLAC__stream_encoder_set_apodization($0, HEAP32[$1 + 40 >> 2]);
26055 $1 = 0;
26056 $0 = HEAP32[$0 >> 2];
26057 if (HEAP32[$0 >> 2] == 1) {
26058 $1 = $2 + 11184 | 0;
26059 $2 = HEAP32[$1 + 32 >> 2];
26060 HEAP32[$0 + 576 >> 2] = HEAP32[$1 + 28 >> 2];
26061 HEAP32[$0 + 580 >> 2] = $2;
26062 HEAP32[$0 + 568 >> 2] = HEAP32[$1 + 24 >> 2];
26063 HEAP32[$0 + 564 >> 2] = HEAP32[$1 + 16 >> 2];
26064 $2 = HEAP32[$1 + 12 >> 2];
26065 HEAP32[$0 + 556 >> 2] = HEAP32[$1 + 8 >> 2];
26066 HEAP32[$0 + 560 >> 2] = $2;
26067 $1 = $3 & 1;
26068 $0 = 1;
26069 } else {
26070 $0 = 0
26071 }
26072 $0 = $0 & $1;
26073 } else {
26074 $0 = 0
26075 }
26076 return $0 | 0;
26077 }
26078
26079 function FLAC__stream_encoder_set_blocksize($0, $1) {
26080 $0 = $0 | 0;
26081 $1 = $1 | 0;
26082 $0 = HEAP32[$0 >> 2];
26083 if (HEAP32[$0 >> 2] == 1) {
26084 HEAP32[$0 + 36 >> 2] = $1;
26085 $0 = 1;
26086 } else {
26087 $0 = 0
26088 }
26089 return $0 | 0;
26090 }
26091
26092 function FLAC__stream_encoder_set_total_samples_estimate($0, $1, $2) {
26093 var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0;
26094 $0 = HEAP32[$0 >> 2];
26095 if (HEAP32[$0 >> 2] == 1) {
26096 $6 = $2;
26097 $7 = $0;
26098 $8 = $1;
26099 $4 = HEAP32[1363];
26100 $3 = $4 & 31;
26101 if (32 <= ($4 & 63) >>> 0) {
26102 $4 = -1 << $3;
26103 $3 = 0;
26104 } else {
26105 $4 = (1 << $3) - 1 & -1 >>> 32 - $3 | -1 << $3;
26106 $3 = -1 << $3;
26107 }
26108 $5 = $3 ^ -1;
26109 $3 = $4 ^ -1;
26110 $1 = ($2 | 0) == ($3 | 0) & $5 >>> 0 > $1 >>> 0 | $3 >>> 0 > $2 >>> 0;
26111 HEAP32[$7 + 592 >> 2] = $1 ? $8 : $5;
26112 HEAP32[$0 + 596 >> 2] = $1 ? $6 : $3;
26113 $0 = 1;
26114 } else {
26115 $0 = 0
26116 }
26117 return $0;
26118 }
26119
26120 function FLAC__stream_encoder_set_metadata($0, $1, $2) {
26121 $0 = $0 | 0;
26122 $1 = $1 | 0;
26123 $2 = $2 | 0;
26124 var $3 = 0, $4 = 0;
26125 $3 = HEAP32[$0 >> 2];
26126 if (HEAP32[$3 >> 2] == 1) {
26127 $4 = HEAP32[$3 + 600 >> 2];
26128 if ($4) {
26129 dlfree($4);
26130 $3 = HEAP32[$0 >> 2];
26131 HEAP32[$3 + 600 >> 2] = 0;
26132 HEAP32[$3 + 604 >> 2] = 0;
26133 }
26134 $2 = $1 ? $2 : 0;
26135 if ($2) {
26136 $3 = safe_malloc_mul_2op_p(4, $2);
26137 if (!$3) {
26138 return 0
26139 }
26140 $1 = memcpy($3, $1, $2 << 2);
26141 $3 = HEAP32[$0 >> 2];
26142 HEAP32[$3 + 604 >> 2] = $2;
26143 HEAP32[$3 + 600 >> 2] = $1;
26144 }
26145 $0 = $3 + 632 | 0;
26146 if ($2 >>> HEAP32[1886]) {
26147 $0 = 0
26148 } else {
26149 HEAP32[$0 + 4 >> 2] = $2;
26150 $0 = 1;
26151 }
26152 $0 = ($0 | 0) != 0;
26153 } else {
26154 $0 = 0
26155 }
26156 return $0 | 0;
26157 }
26158
26159 function FLAC__stream_encoder_get_verify_decoder_state($0) {
26160 $0 = $0 | 0;
26161 if (!HEAP32[HEAP32[$0 >> 2] + 4 >> 2]) {
26162 return 9
26163 }
26164 return FLAC__stream_decoder_get_state(HEAP32[HEAP32[$0 + 4 >> 2] + 11752 >> 2]) | 0;
26165 }
26166
26167 function FLAC__stream_encoder_get_verify($0) {
26168 $0 = $0 | 0;
26169 return HEAP32[HEAP32[$0 >> 2] + 4 >> 2];
26170 }
26171
26172 function FLAC__stream_encoder_process($0, $1, $2) {
26173 $0 = $0 | 0;
26174 $1 = $1 | 0;
26175 $2 = $2 | 0;
26176 var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0;
26177 $5 = HEAP32[$0 >> 2];
26178 $11 = HEAP32[$5 + 36 >> 2];
26179 $16 = $11 + 1 | 0;
26180 $4 = HEAP32[$0 + 4 >> 2];
26181 $10 = HEAP32[$5 + 24 >> 2];
26182 $13 = $11 << 2;
26183 label$1 : {
26184 while (1) {
26185 $3 = $16 - HEAP32[$4 + 7052 >> 2] | 0;
26186 $6 = $2 - $7 | 0;
26187 $6 = $3 >>> 0 < $6 >>> 0 ? $3 : $6;
26188 if (HEAP32[$5 + 4 >> 2]) {
26189 if ($10) {
26190 $5 = $6 << 2;
26191 $3 = 0;
26192 while (1) {
26193 $8 = $3 << 2;
26194 memcpy(HEAP32[($8 + $4 | 0) + 11764 >> 2] + (HEAP32[$4 + 11800 >> 2] << 2) | 0, HEAP32[$1 + $8 >> 2] + ($7 << 2) | 0, $5);
26195 $3 = $3 + 1 | 0;
26196 if (($10 | 0) != ($3 | 0)) {
26197 continue
26198 }
26199 break;
26200 };
26201 }
26202 $4 = $4 + 11800 | 0;
26203 HEAP32[$4 >> 2] = HEAP32[$4 >> 2] + $6;
26204 }
26205 if ($10) {
26206 $5 = $6 << 2;
26207 $4 = 0;
26208 $3 = 0;
26209 while (1) {
26210 $8 = $3 << 2;
26211 $12 = HEAP32[$8 + $1 >> 2];
26212 if (!$12) {
26213 break label$1
26214 }
26215 $9 = $8;
26216 $8 = HEAP32[$0 + 4 >> 2];
26217 memcpy(HEAP32[($9 + $8 | 0) + 4 >> 2] + (HEAP32[$8 + 7052 >> 2] << 2) | 0, $12 + ($7 << 2) | 0, $5);
26218 $3 = $3 + 1 | 0;
26219 if (($10 | 0) != ($3 | 0)) {
26220 continue
26221 }
26222 break;
26223 };
26224 }
26225 $5 = HEAP32[$0 >> 2];
26226 label$8 : {
26227 if (HEAP32[$5 + 16 >> 2]) {
26228 $4 = HEAP32[$0 + 4 >> 2];
26229 if ($7 >>> 0 >= $2 >>> 0) {
26230 break label$8
26231 }
26232 $3 = HEAP32[$4 + 7052 >> 2];
26233 if ($3 >>> 0 > $11 >>> 0) {
26234 break label$8
26235 }
26236 $8 = HEAP32[$4 + 40 >> 2];
26237 $12 = HEAP32[$4 + 36 >> 2];
26238 $17 = HEAP32[$1 + 4 >> 2];
26239 $18 = HEAP32[$1 >> 2];
26240 while (1) {
26241 $14 = $3 << 2;
26242 $9 = $7 << 2;
26243 $15 = $9 + $18 | 0;
26244 $9 = $9 + $17 | 0;
26245 HEAP32[$14 + $8 >> 2] = HEAP32[$15 >> 2] - HEAP32[$9 >> 2];
26246 HEAP32[$12 + $14 >> 2] = HEAP32[$9 >> 2] + HEAP32[$15 >> 2] >> 1;
26247 $7 = $7 + 1 | 0;
26248 if ($7 >>> 0 >= $2 >>> 0) {
26249 break label$8
26250 }
26251 $3 = $3 + 1 | 0;
26252 if ($3 >>> 0 <= $11 >>> 0) {
26253 continue
26254 }
26255 break;
26256 };
26257 break label$8;
26258 }
26259 $7 = $7 + $6 | 0;
26260 $4 = HEAP32[$0 + 4 >> 2];
26261 }
26262 $3 = HEAP32[$4 + 7052 >> 2] + $6 | 0;
26263 HEAP32[$4 + 7052 >> 2] = $3;
26264 if ($3 >>> 0 > $11 >>> 0) {
26265 $4 = 0;
26266 if (!process_frame_($0, 0, 0)) {
26267 break label$1
26268 }
26269 if ($10) {
26270 $4 = HEAP32[$0 + 4 >> 2];
26271 $3 = 0;
26272 while (1) {
26273 $6 = HEAP32[($4 + ($3 << 2) | 0) + 4 >> 2];
26274 HEAP32[$6 >> 2] = HEAP32[$6 + $13 >> 2];
26275 $3 = $3 + 1 | 0;
26276 if (($10 | 0) != ($3 | 0)) {
26277 continue
26278 }
26279 break;
26280 };
26281 }
26282 $4 = HEAP32[$0 + 4 >> 2];
26283 $5 = HEAP32[$0 >> 2];
26284 if (HEAP32[$5 + 16 >> 2]) {
26285 $3 = HEAP32[$4 + 36 >> 2];
26286 HEAP32[$3 >> 2] = HEAP32[$3 + $13 >> 2];
26287 $3 = HEAP32[$4 + 40 >> 2];
26288 HEAP32[$3 >> 2] = HEAP32[$3 + $13 >> 2];
26289 }
26290 HEAP32[$4 + 7052 >> 2] = 1;
26291 }
26292 if ($7 >>> 0 < $2 >>> 0) {
26293 continue
26294 }
26295 break;
26296 };
26297 $4 = 1;
26298 }
26299 return $4 | 0;
26300 }
26301
26302 function FLAC__stream_encoder_process_interleaved($0, $1, $2) {
26303 $0 = $0 | 0;
26304 $1 = $1 | 0;
26305 $2 = $2 | 0;
26306 var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0;
26307 $3 = HEAP32[$0 >> 2];
26308 $9 = HEAP32[$3 + 36 >> 2];
26309 $16 = $9 + 1 | 0;
26310 label$1 : {
26311 label$2 : {
26312 $10 = HEAP32[$3 + 24 >> 2];
26313 if (!(!HEAP32[$3 + 16 >> 2] | ($10 | 0) != 2)) {
26314 while (1) {
26315 $4 = HEAP32[$0 + 4 >> 2];
26316 if (HEAP32[$3 + 4 >> 2]) {
26317 $3 = HEAP32[$4 + 11800 >> 2];
26318 $5 = $16 - HEAP32[$4 + 7052 >> 2] | 0;
26319 $6 = $2 - $7 | 0;
26320 $8 = $5 >>> 0 < $6 >>> 0 ? $5 : $6;
26321 label$6 : {
26322 if (!$8) {
26323 break label$6
26324 }
26325 if (!$10) {
26326 $3 = $3 + $8 | 0;
26327 break label$6;
26328 }
26329 $5 = $7 << 1;
26330 $11 = HEAP32[$4 + 11768 >> 2];
26331 $15 = HEAP32[$4 + 11764 >> 2];
26332 $6 = 0;
26333 while (1) {
26334 $13 = $3 << 2;
26335 $14 = $5 << 2;
26336 HEAP32[$13 + $15 >> 2] = HEAP32[$14 + $1 >> 2];
26337 HEAP32[$11 + $13 >> 2] = HEAP32[($14 | 4) + $1 >> 2];
26338 $3 = $3 + 1 | 0;
26339 $5 = $5 + 2 | 0;
26340 $6 = $6 + 1 | 0;
26341 if (($8 | 0) != ($6 | 0)) {
26342 continue
26343 }
26344 break;
26345 };
26346 }
26347 HEAP32[$4 + 11800 >> 2] = $3;
26348 }
26349 $5 = $7 >>> 0 < $2 >>> 0;
26350 $3 = HEAP32[$4 + 7052 >> 2];
26351 label$9 : {
26352 if ($3 >>> 0 > $9 >>> 0 | $7 >>> 0 >= $2 >>> 0) {
26353 break label$9
26354 }
26355 $11 = HEAP32[$4 + 40 >> 2];
26356 $15 = HEAP32[$4 + 8 >> 2];
26357 $13 = HEAP32[$4 + 36 >> 2];
26358 $14 = HEAP32[$4 + 4 >> 2];
26359 while (1) {
26360 $5 = $3 << 2;
26361 $8 = ($12 << 2) + $1 | 0;
26362 $6 = HEAP32[$8 >> 2];
26363 HEAP32[$5 + $14 >> 2] = $6;
26364 $8 = HEAP32[$8 + 4 >> 2];
26365 HEAP32[$5 + $15 >> 2] = $8;
26366 HEAP32[$5 + $11 >> 2] = $6 - $8;
26367 HEAP32[$5 + $13 >> 2] = $6 + $8 >> 1;
26368 $3 = $3 + 1 | 0;
26369 $12 = $12 + 2 | 0;
26370 $7 = $7 + 1 | 0;
26371 $5 = $7 >>> 0 < $2 >>> 0;
26372 if ($7 >>> 0 >= $2 >>> 0) {
26373 break label$9
26374 }
26375 if ($3 >>> 0 <= $9 >>> 0) {
26376 continue
26377 }
26378 break;
26379 };
26380 }
26381 HEAP32[$4 + 7052 >> 2] = $3;
26382 if ($3 >>> 0 > $9 >>> 0) {
26383 $3 = 0;
26384 if (!process_frame_($0, 0, 0)) {
26385 break label$1
26386 }
26387 $3 = HEAP32[$0 + 4 >> 2];
26388 $6 = HEAP32[$3 + 4 >> 2];
26389 $4 = $6;
26390 $6 = $9 << 2;
26391 HEAP32[$4 >> 2] = HEAP32[$4 + $6 >> 2];
26392 $4 = HEAP32[$3 + 8 >> 2];
26393 HEAP32[$4 >> 2] = HEAP32[$4 + $6 >> 2];
26394 $4 = HEAP32[$3 + 36 >> 2];
26395 HEAP32[$4 >> 2] = HEAP32[$4 + $6 >> 2];
26396 $4 = HEAP32[$3 + 40 >> 2];
26397 HEAP32[$4 >> 2] = HEAP32[$4 + $6 >> 2];
26398 HEAP32[$3 + 7052 >> 2] = 1;
26399 }
26400 if (!$5) {
26401 break label$2
26402 }
26403 $3 = HEAP32[$0 >> 2];
26404 continue;
26405 }
26406 }
26407 while (1) {
26408 $7 = HEAP32[$0 + 4 >> 2];
26409 if (HEAP32[$3 + 4 >> 2]) {
26410 $6 = HEAP32[$7 + 11800 >> 2];
26411 $3 = $16 - HEAP32[$7 + 7052 >> 2] | 0;
26412 $5 = $2 - $4 | 0;
26413 $8 = $3 >>> 0 < $5 >>> 0 ? $3 : $5;
26414 label$14 : {
26415 if (!$8) {
26416 break label$14
26417 }
26418 if (!$10) {
26419 $6 = $6 + $8 | 0;
26420 break label$14;
26421 }
26422 $5 = Math_imul($4, $10);
26423 $11 = 0;
26424 while (1) {
26425 $3 = 0;
26426 while (1) {
26427 HEAP32[HEAP32[($7 + ($3 << 2) | 0) + 11764 >> 2] + ($6 << 2) >> 2] = HEAP32[($5 << 2) + $1 >> 2];
26428 $5 = $5 + 1 | 0;
26429 $3 = $3 + 1 | 0;
26430 if (($10 | 0) != ($3 | 0)) {
26431 continue
26432 }
26433 break;
26434 };
26435 $6 = $6 + 1 | 0;
26436 $11 = $11 + 1 | 0;
26437 if (($8 | 0) != ($11 | 0)) {
26438 continue
26439 }
26440 break;
26441 };
26442 }
26443 HEAP32[$7 + 11800 >> 2] = $6;
26444 }
26445 $6 = $4 >>> 0 < $2 >>> 0;
26446 $5 = HEAP32[$7 + 7052 >> 2];
26447 label$18 : {
26448 if ($5 >>> 0 > $9 >>> 0 | $4 >>> 0 >= $2 >>> 0) {
26449 break label$18
26450 }
26451 if ($10) {
26452 while (1) {
26453 $3 = 0;
26454 while (1) {
26455 HEAP32[HEAP32[($7 + ($3 << 2) | 0) + 4 >> 2] + ($5 << 2) >> 2] = HEAP32[($12 << 2) + $1 >> 2];
26456 $12 = $12 + 1 | 0;
26457 $3 = $3 + 1 | 0;
26458 if (($10 | 0) != ($3 | 0)) {
26459 continue
26460 }
26461 break;
26462 };
26463 $5 = $5 + 1 | 0;
26464 $4 = $4 + 1 | 0;
26465 $6 = $4 >>> 0 < $2 >>> 0;
26466 if ($4 >>> 0 >= $2 >>> 0) {
26467 break label$18
26468 }
26469 if ($5 >>> 0 <= $9 >>> 0) {
26470 continue
26471 }
26472 break label$18;
26473 }
26474 }
26475 while (1) {
26476 $5 = $5 + 1 | 0;
26477 $4 = $4 + 1 | 0;
26478 $6 = $4 >>> 0 < $2 >>> 0;
26479 if ($4 >>> 0 >= $2 >>> 0) {
26480 break label$18
26481 }
26482 if ($5 >>> 0 <= $9 >>> 0) {
26483 continue
26484 }
26485 break;
26486 };
26487 }
26488 HEAP32[$7 + 7052 >> 2] = $5;
26489 if ($5 >>> 0 > $9 >>> 0) {
26490 $3 = 0;
26491 if (!process_frame_($0, 0, 0)) {
26492 break label$1
26493 }
26494 $5 = HEAP32[$0 + 4 >> 2];
26495 if ($10) {
26496 $3 = 0;
26497 while (1) {
26498 $7 = HEAP32[($5 + ($3 << 2) | 0) + 4 >> 2];
26499 HEAP32[$7 >> 2] = HEAP32[$7 + ($9 << 2) >> 2];
26500 $3 = $3 + 1 | 0;
26501 if (($10 | 0) != ($3 | 0)) {
26502 continue
26503 }
26504 break;
26505 };
26506 }
26507 HEAP32[$5 + 7052 >> 2] = 1;
26508 }
26509 if (!$6) {
26510 break label$2
26511 }
26512 $3 = HEAP32[$0 >> 2];
26513 continue;
26514 };
26515 }
26516 $3 = 1;
26517 }
26518 return $3 | 0;
26519 }
26520
26521 function find_best_partition_order_($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12) {
26522 var $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0, $23 = 0, $24 = 0, $25 = 0, $26 = 0, $27 = 0, $28 = 0, $29 = 0, $30 = 0, $31 = 0, $32 = 0, $33 = 0, $34 = 0, $35 = 0, $36 = 0, $37 = 0, $38 = 0, $39 = 0, $40 = 0;
26523 $26 = $4 + $5 | 0;
26524 $14 = FLAC__format_get_max_rice_partition_order_from_blocksize_limited_max_and_predictor_order($9, $26, $5);
26525 $22 = $14 >>> 0 > $8 >>> 0 ? $8 : $14;
26526 FUNCTION_TABLE[HEAP32[$0 + 7220 >> 2]]($1, $2, $4, $5, $22, $14, $10);
26527 label$1 : {
26528 if (!$11) {
26529 break label$1
26530 }
26531 $10 = 0;
26532 $8 = 0;
26533 if (($14 | 0) >= 0) {
26534 $8 = 1 << $14;
26535 $20 = $8 >>> 0 > 1 ? $8 : 1;
26536 $16 = $26 >>> $14 | 0;
26537 while (1) {
26538 $17 = 0;
26539 $9 = $13;
26540 $18 = 0;
26541 $27 = ($15 << 2) + $3 | 0;
26542 label$4 : {
26543 label$5 : {
26544 $23 = $15 ? 0 : $5;
26545 $19 = $16 - $23 | 0;
26546 if (!$19) {
26547 break label$5
26548 }
26549 while (1) {
26550 $21 = $17;
26551 $17 = HEAP32[($9 << 2) + $1 >> 2];
26552 $17 = $21 | $17 >> 31 ^ $17;
26553 $9 = $9 + 1 | 0;
26554 $18 = $18 + 1 | 0;
26555 if (($19 | 0) != ($18 | 0)) {
26556 continue
26557 }
26558 break;
26559 };
26560 $13 = ($13 + $16 | 0) - $23 | 0;
26561 if (!$17) {
26562 break label$5
26563 }
26564 $9 = (Math_clz32($17) ^ 31) + 2 | 0;
26565 break label$4;
26566 }
26567 $9 = 1;
26568 }
26569 HEAP32[$27 >> 2] = $9;
26570 $15 = $15 + 1 | 0;
26571 if (($20 | 0) != ($15 | 0)) {
26572 continue
26573 }
26574 break;
26575 };
26576 }
26577 if (($14 | 0) <= ($22 | 0)) {
26578 break label$1
26579 }
26580 $1 = $14;
26581 while (1) {
26582 $1 = $1 + -1 | 0;
26583 $9 = 0;
26584 while (1) {
26585 $13 = ($10 << 2) + $3 | 0;
26586 $15 = HEAP32[$13 >> 2];
26587 $13 = HEAP32[$13 + 4 >> 2];
26588 HEAP32[($8 << 2) + $3 >> 2] = $15 >>> 0 > $13 >>> 0 ? $15 : $13;
26589 $8 = $8 + 1 | 0;
26590 $10 = $10 + 2 | 0;
26591 $9 = $9 + 1 | 0;
26592 if (!($9 >>> $1)) {
26593 continue
26594 }
26595 break;
26596 };
26597 if (($1 | 0) > ($22 | 0)) {
26598 continue
26599 }
26600 break;
26601 };
26602 }
26603 label$9 : {
26604 if (($14 | 0) < ($22 | 0)) {
26605 HEAP32[$12 + 4 >> 2] = 0;
26606 $2 = 6;
26607 break label$9;
26608 }
26609 $28 = HEAP32[1407];
26610 $40 = $28 + (Math_imul($6 + 1 | 0, $4) - ($4 >>> 1 | 0) | 0) | 0;
26611 $35 = $7 + -1 | 0;
26612 $36 = HEAP32[1409] + HEAP32[1408] | 0;
26613 $23 = HEAP32[1406] + HEAP32[1405] | 0;
26614 $27 = $6 + -1 | 0;
26615 while (1) {
26616 label$12 : {
26617 $20 = $14;
26618 $37 = !$29;
26619 $1 = Math_imul($37, 12) + $0 | 0;
26620 $8 = $1 + 11724 | 0;
26621 FLAC__format_entropy_coding_method_partitioned_rice_contents_ensure_size($8, $14 >>> 0 > 6 ? $14 : 6);
26622 $38 = ($30 << 2) + $3 | 0;
26623 $25 = ($30 << 3) + $2 | 0;
26624 $39 = HEAP32[$1 + 11728 >> 2];
26625 $31 = HEAP32[$8 >> 2];
26626 label$13 : {
26627 if ($14) {
26628 $32 = $26 >>> $20 | 0;
26629 if ($32 >>> 0 <= $5 >>> 0) {
26630 break label$12
26631 }
26632 $18 = 0;
26633 $33 = 0;
26634 $21 = $23;
26635 if (!$11) {
26636 while (1) {
26637 $17 = $32 - ($18 ? 0 : $5) | 0;
26638 $1 = $25 + ($18 << 3) | 0;
26639 $13 = HEAP32[$1 + 4 >> 2];
26640 $16 = HEAP32[$1 >> 2];
26641 label$17 : {
26642 if (!$13 & $16 >>> 0 >= 268435457 | $13 >>> 0 > 0) {
26643 $1 = $17;
26644 $10 = 0;
26645 $8 = 0;
26646 label$19 : {
26647 if (($13 | 0) == 16777216 & $16 >>> 0 > 0 | $13 >>> 0 > 16777216) {
26648 $14 = $1;
26649 $9 = 0;
26650 break label$19;
26651 }
26652 $14 = $1;
26653 $9 = 0;
26654 $15 = $1 >>> 25 | 0;
26655 $19 = $1 << 7;
26656 if (($13 | 0) == ($15 | 0) & $19 >>> 0 >= $16 >>> 0 | $15 >>> 0 > $13 >>> 0) {
26657 break label$19
26658 }
26659 while (1) {
26660 $8 = $8 + 8 | 0;
26661 $15 = $10 << 15 | $1 >>> 17;
26662 $19 = $1 << 15;
26663 $9 = $10 << 8 | $1 >>> 24;
26664 $14 = $1 << 8;
26665 $1 = $14;
26666 $10 = $9;
26667 if (($13 | 0) == ($15 | 0) & $19 >>> 0 < $16 >>> 0 | $15 >>> 0 < $13 >>> 0) {
26668 continue
26669 }
26670 break;
26671 };
26672 }
26673 if (($9 | 0) == ($13 | 0) & $14 >>> 0 >= $16 >>> 0 | $9 >>> 0 > $13 >>> 0) {
26674 break label$17
26675 }
26676 while (1) {
26677 $8 = $8 + 1 | 0;
26678 $1 = $14;
26679 $15 = $9 << 1 | $1 >>> 31;
26680 $14 = $1 << 1;
26681 $1 = $14;
26682 $9 = $15;
26683 if (($13 | 0) == ($9 | 0) & $1 >>> 0 < $16 >>> 0 | $9 >>> 0 < $13 >>> 0) {
26684 continue
26685 }
26686 break;
26687 };
26688 break label$17;
26689 }
26690 $8 = 0;
26691 $10 = $17;
26692 $1 = $16;
26693 if ($10 << 3 >>> 0 < $1 >>> 0) {
26694 while (1) {
26695 $8 = $8 + 4 | 0;
26696 $9 = $10 << 7;
26697 $10 = $10 << 4;
26698 if ($9 >>> 0 < $1 >>> 0) {
26699 continue
26700 }
26701 break;
26702 }
26703 }
26704 if ($10 >>> 0 >= $1 >>> 0) {
26705 break label$17
26706 }
26707 while (1) {
26708 $8 = $8 + 1 | 0;
26709 $10 = $10 << 1;
26710 if ($10 >>> 0 < $1 >>> 0) {
26711 continue
26712 }
26713 break;
26714 };
26715 }
26716 $8 = $8 >>> 0 < $7 >>> 0 ? $8 : $35;
26717 $10 = $8 + -1 | 0;
26718 $1 = $10 & 31;
26719 $1 = (($28 - ($17 >>> 1 | 0) | 0) + Math_imul($17, $8 + 1 | 0) | 0) + ($8 ? (32 <= ($10 & 63) >>> 0 ? $13 >>> $1 | 0 : ((1 << $1) - 1 & $13) << 32 - $1 | $16 >>> $1) : $16 << 1) | 0;
26720 $33 = ($1 | 0) == -1 ? $33 : $8;
26721 HEAP32[$31 + ($18 << 2) >> 2] = $33;
26722 $21 = $1 + $21 | 0;
26723 $18 = $18 + 1 | 0;
26724 if (!($18 >>> $20)) {
26725 continue
26726 }
26727 break label$13;
26728 }
26729 }
26730 while (1) {
26731 $17 = $32 - ($18 ? 0 : $5) | 0;
26732 $1 = $25 + ($18 << 3) | 0;
26733 $13 = HEAP32[$1 + 4 >> 2];
26734 $16 = HEAP32[$1 >> 2];
26735 label$27 : {
26736 label$28 : {
26737 if (!$13 & $16 >>> 0 >= 268435457 | $13 >>> 0 > 0) {
26738 $1 = $17;
26739 $10 = 0;
26740 $8 = 0;
26741 if (($13 | 0) == 16777216 & $16 >>> 0 > 0 | $13 >>> 0 > 16777216) {
26742 break label$28
26743 }
26744 $14 = $1;
26745 $9 = 0;
26746 $15 = $1 >>> 25 | 0;
26747 $19 = $1 << 7;
26748 if (($13 | 0) == ($15 | 0) & $19 >>> 0 >= $16 >>> 0 | $15 >>> 0 > $13 >>> 0) {
26749 break label$28
26750 }
26751 while (1) {
26752 $8 = $8 + 8 | 0;
26753 $1 = $9;
26754 $10 = $14;
26755 $15 = $1 << 15 | $10 >>> 17;
26756 $19 = $10 << 15;
26757 $9 = $1 << 8;
26758 $1 = $10;
26759 $9 = $9 | $1 >>> 24;
26760 $1 = $1 << 8;
26761 $14 = $1;
26762 $10 = $9;
26763 if (($13 | 0) == ($15 | 0) & $19 >>> 0 < $16 >>> 0 | $15 >>> 0 < $13 >>> 0) {
26764 continue
26765 }
26766 break;
26767 };
26768 break label$28;
26769 }
26770 $8 = 0;
26771 $10 = $17;
26772 $1 = $16;
26773 if ($10 << 3 >>> 0 < $1 >>> 0) {
26774 while (1) {
26775 $8 = $8 + 4 | 0;
26776 $9 = $10 << 7;
26777 $10 = $10 << 4;
26778 if ($9 >>> 0 < $1 >>> 0) {
26779 continue
26780 }
26781 break;
26782 }
26783 }
26784 if ($10 >>> 0 >= $1 >>> 0) {
26785 break label$27
26786 }
26787 while (1) {
26788 $8 = $8 + 1 | 0;
26789 $10 = $10 << 1;
26790 if ($10 >>> 0 < $1 >>> 0) {
26791 continue
26792 }
26793 break;
26794 };
26795 break label$27;
26796 }
26797 if (($10 | 0) == ($13 | 0) & $1 >>> 0 >= $16 >>> 0 | $10 >>> 0 > $13 >>> 0) {
26798 break label$27
26799 }
26800 while (1) {
26801 $8 = $8 + 1 | 0;
26802 $15 = $10 << 1 | $1 >>> 31;
26803 $1 = $1 << 1;
26804 $10 = $15;
26805 if (($13 | 0) == ($10 | 0) & $1 >>> 0 < $16 >>> 0 | $10 >>> 0 < $13 >>> 0) {
26806 continue
26807 }
26808 break;
26809 };
26810 }
26811 $9 = $18 << 2;
26812 $1 = HEAP32[$9 + $38 >> 2];
26813 $19 = $1;
26814 $10 = Math_imul($1, $17) + $36 | 0;
26815 $8 = $8 >>> 0 < $7 >>> 0 ? $8 : $35;
26816 $15 = $8 + -1 | 0;
26817 $1 = $15 & 31;
26818 $14 = (($28 - ($17 >>> 1 | 0) | 0) + Math_imul($17, $8 + 1 | 0) | 0) + ($8 ? (32 <= ($15 & 63) >>> 0 ? $13 >>> $1 | 0 : ((1 << $1) - 1 & $13) << 32 - $1 | $16 >>> $1) : $16 << 1) | 0;
26819 $1 = $10 >>> 0 > $14 >>> 0;
26820 HEAP32[$9 + $39 >> 2] = $1 ? 0 : $19;
26821 HEAP32[$9 + $31 >> 2] = $1 ? $8 : 0;
26822 $21 = ($1 ? $14 : $10) + $21 | 0;
26823 $18 = $18 + 1 | 0;
26824 if (!($18 >>> $20)) {
26825 continue
26826 }
26827 break;
26828 };
26829 break label$13;
26830 }
26831 $9 = HEAP32[$25 + 4 >> 2];
26832 $1 = $27;
26833 $8 = $1 & 31;
26834 $10 = HEAP32[$25 >> 2];
26835 $8 = ($6 ? (32 <= ($1 & 63) >>> 0 ? $9 >>> $8 | 0 : ((1 << $8) - 1 & $9) << 32 - $8 | $10 >>> $8) : $10 << 1) + $40 | 0;
26836 $10 = ($8 | 0) == -1 ? 0 : $6;
26837 if ($11) {
26838 $9 = HEAP32[$38 >> 2];
26839 $14 = Math_imul($9, $4) + $36 | 0;
26840 $1 = $14 >>> 0 > $8 >>> 0;
26841 HEAP32[$39 >> 2] = $1 ? 0 : $9;
26842 $10 = $1 ? $10 : 0;
26843 $8 = $1 ? $8 : $14;
26844 }
26845 HEAP32[$31 >> 2] = $10;
26846 $21 = $8 + $23 | 0;
26847 }
26848 $1 = $34 + -1 >>> 0 < $21 >>> 0;
26849 $24 = $1 ? $24 : $20;
26850 $29 = $1 ? $29 : $37;
26851 $34 = $1 ? $34 : $21;
26852 $14 = $20 + -1 | 0;
26853 $30 = (1 << $20) + $30 | 0;
26854 if (($20 | 0) > ($22 | 0)) {
26855 continue
26856 }
26857 }
26858 break;
26859 };
26860 HEAP32[$12 + 4 >> 2] = $24;
26861 $2 = $24 >>> 0 > 6 ? $24 : 6;
26862 }
26863 $1 = HEAP32[$12 + 8 >> 2];
26864 FLAC__format_entropy_coding_method_partitioned_rice_contents_ensure_size($1, $2);
26865 $2 = Math_imul($29, 12) + $0 | 0;
26866 $0 = 1 << $24;
26867 $3 = $0 << 2;
26868 memcpy(HEAP32[$1 >> 2], HEAP32[$2 + 11724 >> 2], $3);
26869 if ($11) {
26870 memcpy(HEAP32[$1 + 4 >> 2], HEAP32[$2 + 11728 >> 2], $3)
26871 }
26872 $0 = $0 >>> 0 > 1 ? $0 : 1;
26873 $2 = HEAP32[1410];
26874 $1 = HEAP32[$1 >> 2];
26875 $8 = 0;
26876 label$37 : {
26877 while (1) {
26878 if (HEAPU32[$1 + ($8 << 2) >> 2] < $2 >>> 0) {
26879 $8 = $8 + 1 | 0;
26880 if (($0 | 0) != ($8 | 0)) {
26881 continue
26882 }
26883 break label$37;
26884 }
26885 break;
26886 };
26887 HEAP32[$12 >> 2] = 1;
26888 }
26889 return $34;
26890 }
26891
26892 function stackSave() {
26893 return global$0 | 0;
26894 }
26895
26896 function stackRestore($0) {
26897 $0 = $0 | 0;
26898 global$0 = $0;
26899 }
26900
26901 function stackAlloc($0) {
26902 $0 = $0 | 0;
26903 $0 = global$0 - $0 & -16;
26904 global$0 = $0;
26905 return $0 | 0;
26906 }
26907
26908 function __growWasmMemory($0) {
26909 $0 = $0 | 0;
26910 return __wasm_memory_grow($0 | 0) | 0;
26911 }
26912
26913 function dynCall_iii($0, $1, $2) {
26914 $0 = $0 | 0;
26915 $1 = $1 | 0;
26916 $2 = $2 | 0;
26917 return FUNCTION_TABLE[$0]($1, $2) | 0;
26918 }
26919
26920 function dynCall_ii($0, $1) {
26921 $0 = $0 | 0;
26922 $1 = $1 | 0;
26923 return FUNCTION_TABLE[$0]($1) | 0;
26924 }
26925
26926 function dynCall_iiii($0, $1, $2, $3) {
26927 $0 = $0 | 0;
26928 $1 = $1 | 0;
26929 $2 = $2 | 0;
26930 $3 = $3 | 0;
26931 return FUNCTION_TABLE[$0]($1, $2, $3) | 0;
26932 }
26933
26934 function dynCall_viiiiii($0, $1, $2, $3, $4, $5, $6) {
26935 $0 = $0 | 0;
26936 $1 = $1 | 0;
26937 $2 = $2 | 0;
26938 $3 = $3 | 0;
26939 $4 = $4 | 0;
26940 $5 = $5 | 0;
26941 $6 = $6 | 0;
26942 FUNCTION_TABLE[$0]($1, $2, $3, $4, $5, $6);
26943 }
26944
26945 function dynCall_iiiii($0, $1, $2, $3, $4) {
26946 $0 = $0 | 0;
26947 $1 = $1 | 0;
26948 $2 = $2 | 0;
26949 $3 = $3 | 0;
26950 $4 = $4 | 0;
26951 return FUNCTION_TABLE[$0]($1, $2, $3, $4) | 0;
26952 }
26953
26954 function dynCall_viiiiiii($0, $1, $2, $3, $4, $5, $6, $7) {
26955 $0 = $0 | 0;
26956 $1 = $1 | 0;
26957 $2 = $2 | 0;
26958 $3 = $3 | 0;
26959 $4 = $4 | 0;
26960 $5 = $5 | 0;
26961 $6 = $6 | 0;
26962 $7 = $7 | 0;
26963 FUNCTION_TABLE[$0]($1, $2, $3, $4, $5, $6, $7);
26964 }
26965
26966 function dynCall_viiii($0, $1, $2, $3, $4) {
26967 $0 = $0 | 0;
26968 $1 = $1 | 0;
26969 $2 = $2 | 0;
26970 $3 = $3 | 0;
26971 $4 = $4 | 0;
26972 FUNCTION_TABLE[$0]($1, $2, $3, $4);
26973 }
26974
26975 function dynCall_viii($0, $1, $2, $3) {
26976 $0 = $0 | 0;
26977 $1 = $1 | 0;
26978 $2 = $2 | 0;
26979 $3 = $3 | 0;
26980 FUNCTION_TABLE[$0]($1, $2, $3);
26981 }
26982
26983 function legalstub$FLAC__stream_encoder_set_total_samples_estimate($0, $1, $2) {
26984 $0 = $0 | 0;
26985 $1 = $1 | 0;
26986 $2 = $2 | 0;
26987 return FLAC__stream_encoder_set_total_samples_estimate($0, $1, $2) | 0;
26988 }
26989
26990 function legalstub$dynCall_jiji($0, $1, $2, $3, $4) {
26991 $0 = $0 | 0;
26992 $1 = $1 | 0;
26993 $2 = $2 | 0;
26994 $3 = $3 | 0;
26995 $4 = $4 | 0;
26996 $0 = FUNCTION_TABLE[$0]($1, $2, $3, $4) | 0;
26997 setTempRet0(i64toi32_i32$HIGH_BITS | 0);
26998 return $0 | 0;
26999 }
27000
27001 function _ZN17compiler_builtins3int3mul3Mul3mul17h070e9a1c69faec5bE($0, $1, $2, $3) {
27002 var $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0;
27003 $4 = $2 >>> 16 | 0;
27004 $5 = $0 >>> 16 | 0;
27005 $9 = Math_imul($4, $5);
27006 $6 = $2 & 65535;
27007 $7 = $0 & 65535;
27008 $8 = Math_imul($6, $7);
27009 $5 = ($8 >>> 16 | 0) + Math_imul($5, $6) | 0;
27010 $4 = ($5 & 65535) + Math_imul($4, $7) | 0;
27011 $0 = (Math_imul($1, $2) + $9 | 0) + Math_imul($0, $3) + ($5 >>> 16) + ($4 >>> 16) | 0;
27012 $1 = $8 & 65535 | $4 << 16;
27013 i64toi32_i32$HIGH_BITS = $0;
27014 return $1;
27015 }
27016
27017 function _ZN17compiler_builtins3int4udiv10divmod_u6417h6026910b5ed08e40E($0, $1, $2) {
27018 var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0;
27019 label$1 : {
27020 label$2 : {
27021 label$3 : {
27022 label$4 : {
27023 label$5 : {
27024 label$6 : {
27025 label$7 : {
27026 label$9 : {
27027 label$11 : {
27028 $3 = $1;
27029 if ($3) {
27030 $4 = $2;
27031 if (!$4) {
27032 break label$11
27033 }
27034 break label$9;
27035 }
27036 $1 = $0;
27037 $0 = ($0 >>> 0) / ($2 >>> 0) | 0;
27038 __wasm_intrinsics_temp_i64 = $1 - Math_imul($0, $2) | 0;
27039 __wasm_intrinsics_temp_i64$hi = 0;
27040 i64toi32_i32$HIGH_BITS = 0;
27041 return $0;
27042 }
27043 if (!$0) {
27044 break label$7
27045 }
27046 break label$6;
27047 }
27048 $6 = $4 + -1 | 0;
27049 if (!($6 & $4)) {
27050 break label$5
27051 }
27052 $6 = (Math_clz32($4) + 33 | 0) - Math_clz32($3) | 0;
27053 $7 = 0 - $6 | 0;
27054 break label$3;
27055 }
27056 __wasm_intrinsics_temp_i64 = 0;
27057 $0 = ($3 >>> 0) / 0 | 0;
27058 __wasm_intrinsics_temp_i64$hi = $3 - Math_imul($0, 0) | 0;
27059 i64toi32_i32$HIGH_BITS = 0;
27060 return $0;
27061 }
27062 $3 = 32 - Math_clz32($3) | 0;
27063 if ($3 >>> 0 < 31) {
27064 break label$4
27065 }
27066 break label$2;
27067 }
27068 __wasm_intrinsics_temp_i64 = $0 & $6;
27069 __wasm_intrinsics_temp_i64$hi = 0;
27070 if (($4 | 0) == 1) {
27071 break label$1
27072 }
27073 $3 = __wasm_ctz_i32($4);
27074 $2 = $3 & 31;
27075 if (32 <= ($3 & 63) >>> 0) {
27076 $4 = 0;
27077 $0 = $1 >>> $2 | 0;
27078 } else {
27079 $4 = $1 >>> $2 | 0;
27080 $0 = ((1 << $2) - 1 & $1) << 32 - $2 | $0 >>> $2;
27081 }
27082 i64toi32_i32$HIGH_BITS = $4;
27083 return $0;
27084 }
27085 $6 = $3 + 1 | 0;
27086 $7 = 63 - $3 | 0;
27087 }
27088 $3 = $1;
27089 $4 = $6 & 63;
27090 $5 = $4 & 31;
27091 if (32 <= $4 >>> 0) {
27092 $4 = 0;
27093 $5 = $3 >>> $5 | 0;
27094 } else {
27095 $4 = $3 >>> $5 | 0;
27096 $5 = ((1 << $5) - 1 & $3) << 32 - $5 | $0 >>> $5;
27097 }
27098 $7 = $7 & 63;
27099 $3 = $7 & 31;
27100 if (32 <= $7 >>> 0) {
27101 $1 = $0 << $3;
27102 $0 = 0;
27103 } else {
27104 $1 = (1 << $3) - 1 & $0 >>> 32 - $3 | $1 << $3;
27105 $0 = $0 << $3;
27106 }
27107 if ($6) {
27108 $7 = -1;
27109 $3 = $2 + -1 | 0;
27110 if (($3 | 0) != -1) {
27111 $7 = 0
27112 }
27113 while (1) {
27114 $8 = $5 << 1 | $1 >>> 31;
27115 $9 = $8;
27116 $4 = $4 << 1 | $5 >>> 31;
27117 $8 = $7 - ($4 + ($3 >>> 0 < $8 >>> 0) | 0) >> 31;
27118 $10 = $2 & $8;
27119 $5 = $9 - $10 | 0;
27120 $4 = $4 - ($9 >>> 0 < $10 >>> 0) | 0;
27121 $1 = $1 << 1 | $0 >>> 31;
27122 $0 = $11 | $0 << 1;
27123 $8 = $8 & 1;
27124 $11 = $8;
27125 $6 = $6 + -1 | 0;
27126 if ($6) {
27127 continue
27128 }
27129 break;
27130 };
27131 }
27132 __wasm_intrinsics_temp_i64 = $5;
27133 __wasm_intrinsics_temp_i64$hi = $4;
27134 i64toi32_i32$HIGH_BITS = $1 << 1 | $0 >>> 31;
27135 return $8 | $0 << 1;
27136 }
27137 __wasm_intrinsics_temp_i64 = $0;
27138 __wasm_intrinsics_temp_i64$hi = $1;
27139 $0 = 0;
27140 $1 = 0;
27141 }
27142 i64toi32_i32$HIGH_BITS = $1;
27143 return $0;
27144 }
27145
27146 function __wasm_ctz_i32($0) {
27147 if ($0) {
27148 return 31 - Math_clz32($0 + -1 ^ $0) | 0
27149 }
27150 return 32;
27151 }
27152
27153 function __wasm_i64_mul($0, $1, $2, $3) {
27154 $0 = _ZN17compiler_builtins3int3mul3Mul3mul17h070e9a1c69faec5bE($0, $1, $2, $3);
27155 return $0;
27156 }
27157
27158 function __wasm_i64_udiv($0, $1, $2) {
27159 return _ZN17compiler_builtins3int4udiv10divmod_u6417h6026910b5ed08e40E($0, $1, $2);
27160 }
27161
27162 function __wasm_i64_urem($0, $1) {
27163 _ZN17compiler_builtins3int4udiv10divmod_u6417h6026910b5ed08e40E($0, $1, 588);
27164 i64toi32_i32$HIGH_BITS = __wasm_intrinsics_temp_i64$hi;
27165 return __wasm_intrinsics_temp_i64;
27166 }
27167
27168 function __wasm_rotl_i32($0, $1) {
27169 var $2 = 0, $3 = 0;
27170 $2 = $1 & 31;
27171 $3 = (-1 >>> $2 & $0) << $2;
27172 $2 = $0;
27173 $0 = 0 - $1 & 31;
27174 return $3 | ($2 & -1 << $0) >>> $0;
27175 }
27176
27177 // EMSCRIPTEN_END_FUNCS
27178;
27179 FUNCTION_TABLE[1] = seekpoint_compare_;
27180 FUNCTION_TABLE[2] = __stdio_close;
27181 FUNCTION_TABLE[3] = __stdio_read;
27182 FUNCTION_TABLE[4] = __stdio_seek;
27183 FUNCTION_TABLE[5] = FLAC__lpc_restore_signal;
27184 FUNCTION_TABLE[6] = FLAC__lpc_restore_signal_wide;
27185 FUNCTION_TABLE[7] = read_callback_;
27186 FUNCTION_TABLE[8] = read_callback_proxy_;
27187 FUNCTION_TABLE[9] = __emscripten_stdout_close;
27188 FUNCTION_TABLE[10] = __stdio_write;
27189 FUNCTION_TABLE[11] = __emscripten_stdout_seek;
27190 FUNCTION_TABLE[12] = FLAC__lpc_compute_residual_from_qlp_coefficients;
27191 FUNCTION_TABLE[13] = FLAC__lpc_compute_residual_from_qlp_coefficients_wide;
27192 FUNCTION_TABLE[14] = FLAC__fixed_compute_best_predictor_wide;
27193 FUNCTION_TABLE[15] = FLAC__fixed_compute_best_predictor;
27194 FUNCTION_TABLE[16] = precompute_partition_info_sums_;
27195 FUNCTION_TABLE[17] = FLAC__lpc_compute_autocorrelation;
27196 FUNCTION_TABLE[18] = verify_read_callback_;
27197 FUNCTION_TABLE[19] = verify_write_callback_;
27198 FUNCTION_TABLE[20] = verify_metadata_callback_;
27199 FUNCTION_TABLE[21] = verify_error_callback_;
27200 function __wasm_memory_size() {
27201 return buffer.byteLength / 65536 | 0;
27202 }
27203
27204 function __wasm_memory_grow(pagesToAdd) {
27205 pagesToAdd = pagesToAdd | 0;
27206 var oldPages = __wasm_memory_size() | 0;
27207 var newPages = oldPages + pagesToAdd | 0;
27208 if ((oldPages < newPages) && (newPages < 65536)) {
27209 var newBuffer = new ArrayBuffer(Math_imul(newPages, 65536));
27210 var newHEAP8 = new global.Int8Array(newBuffer);
27211 newHEAP8.set(HEAP8);
27212 HEAP8 = newHEAP8;
27213 HEAP8 = new global.Int8Array(newBuffer);
27214 HEAP16 = new global.Int16Array(newBuffer);
27215 HEAP32 = new global.Int32Array(newBuffer);
27216 HEAPU8 = new global.Uint8Array(newBuffer);
27217 HEAPU16 = new global.Uint16Array(newBuffer);
27218 HEAPU32 = new global.Uint32Array(newBuffer);
27219 HEAPF32 = new global.Float32Array(newBuffer);
27220 HEAPF64 = new global.Float64Array(newBuffer);
27221 buffer = newBuffer;
27222 memory.buffer = newBuffer;
27223 }
27224 return oldPages;
27225 }
27226
27227 return {
27228 "__wasm_call_ctors": __wasm_call_ctors,
27229 "FLAC__stream_decoder_new": FLAC__stream_decoder_new,
27230 "FLAC__stream_decoder_delete": FLAC__stream_decoder_delete,
27231 "FLAC__stream_decoder_finish": FLAC__stream_decoder_finish,
27232 "FLAC__stream_decoder_init_stream": FLAC__stream_decoder_init_stream,
27233 "FLAC__stream_decoder_reset": FLAC__stream_decoder_reset,
27234 "FLAC__stream_decoder_init_ogg_stream": FLAC__stream_decoder_init_ogg_stream,
27235 "FLAC__stream_decoder_set_ogg_serial_number": FLAC__stream_decoder_set_ogg_serial_number,
27236 "FLAC__stream_decoder_set_md5_checking": FLAC__stream_decoder_set_md5_checking,
27237 "FLAC__stream_decoder_set_metadata_respond": FLAC__stream_decoder_set_metadata_respond,
27238 "FLAC__stream_decoder_set_metadata_respond_application": FLAC__stream_decoder_set_metadata_respond_application,
27239 "FLAC__stream_decoder_set_metadata_respond_all": FLAC__stream_decoder_set_metadata_respond_all,
27240 "FLAC__stream_decoder_set_metadata_ignore": FLAC__stream_decoder_set_metadata_ignore,
27241 "FLAC__stream_decoder_set_metadata_ignore_application": FLAC__stream_decoder_set_metadata_ignore_application,
27242 "FLAC__stream_decoder_set_metadata_ignore_all": FLAC__stream_decoder_set_metadata_ignore_all,
27243 "FLAC__stream_decoder_get_state": FLAC__stream_decoder_get_state,
27244 "FLAC__stream_decoder_get_md5_checking": FLAC__stream_decoder_get_md5_checking,
27245 "FLAC__stream_decoder_process_single": FLAC__stream_decoder_process_single,
27246 "FLAC__stream_decoder_process_until_end_of_metadata": FLAC__stream_decoder_process_until_end_of_metadata,
27247 "FLAC__stream_decoder_process_until_end_of_stream": FLAC__stream_decoder_process_until_end_of_stream,
27248 "FLAC__stream_encoder_new": FLAC__stream_encoder_new,
27249 "FLAC__stream_encoder_delete": FLAC__stream_encoder_delete,
27250 "FLAC__stream_encoder_finish": FLAC__stream_encoder_finish,
27251 "FLAC__stream_encoder_init_stream": FLAC__stream_encoder_init_stream,
27252 "FLAC__stream_encoder_init_ogg_stream": FLAC__stream_encoder_init_ogg_stream,
27253 "FLAC__stream_encoder_set_ogg_serial_number": FLAC__stream_encoder_set_ogg_serial_number,
27254 "FLAC__stream_encoder_set_verify": FLAC__stream_encoder_set_verify,
27255 "FLAC__stream_encoder_set_channels": FLAC__stream_encoder_set_channels,
27256 "FLAC__stream_encoder_set_bits_per_sample": FLAC__stream_encoder_set_bits_per_sample,
27257 "FLAC__stream_encoder_set_sample_rate": FLAC__stream_encoder_set_sample_rate,
27258 "FLAC__stream_encoder_set_compression_level": FLAC__stream_encoder_set_compression_level,
27259 "FLAC__stream_encoder_set_blocksize": FLAC__stream_encoder_set_blocksize,
27260 "FLAC__stream_encoder_set_total_samples_estimate": legalstub$FLAC__stream_encoder_set_total_samples_estimate,
27261 "FLAC__stream_encoder_set_metadata": FLAC__stream_encoder_set_metadata,
27262 "FLAC__stream_encoder_get_state": FLAC__stream_decoder_get_state,
27263 "FLAC__stream_encoder_get_verify_decoder_state": FLAC__stream_encoder_get_verify_decoder_state,
27264 "FLAC__stream_encoder_get_verify": FLAC__stream_encoder_get_verify,
27265 "FLAC__stream_encoder_process": FLAC__stream_encoder_process,
27266 "FLAC__stream_encoder_process_interleaved": FLAC__stream_encoder_process_interleaved,
27267 "__errno_location": __errno_location,
27268 "stackSave": stackSave,
27269 "stackRestore": stackRestore,
27270 "stackAlloc": stackAlloc,
27271 "malloc": dlmalloc,
27272 "free": dlfree,
27273 "__growWasmMemory": __growWasmMemory,
27274 "dynCall_iii": dynCall_iii,
27275 "dynCall_ii": dynCall_ii,
27276 "dynCall_iiii": dynCall_iiii,
27277 "dynCall_jiji": legalstub$dynCall_jiji,
27278 "dynCall_viiiiii": dynCall_viiiiii,
27279 "dynCall_iiiii": dynCall_iiiii,
27280 "dynCall_viiiiiii": dynCall_viiiiiii,
27281 "dynCall_viiii": dynCall_viiii,
27282 "dynCall_viii": dynCall_viii
27283 };
27284}
27285
27286var bufferView = new Uint8Array(wasmMemory.buffer);
27287for (var base64ReverseLookup = new Uint8Array(123/*'z'+1*/), i = 25; i >= 0; --i) {
27288 base64ReverseLookup[48+i] = 52+i; // '0-9'
27289 base64ReverseLookup[65+i] = i; // 'A-Z'
27290 base64ReverseLookup[97+i] = 26+i; // 'a-z'
27291 }
27292 base64ReverseLookup[43] = 62; // '+'
27293 base64ReverseLookup[47] = 63; // '/'
27294 /** @noinline Inlining this function would mean expanding the base64 string 4x times in the source code, which Closure seems to be happy to do. */
27295 function base64DecodeToExistingUint8Array(uint8Array, offset, b64) {
27296 var b1, b2, i = 0, j = offset, bLength = b64.length, end = offset + (bLength*3>>2) - (b64[bLength-2] == '=') - (b64[bLength-1] == '=');
27297 for (; i < bLength; i += 4) {
27298 b1 = base64ReverseLookup[b64.charCodeAt(i+1)];
27299 b2 = base64ReverseLookup[b64.charCodeAt(i+2)];
27300 uint8Array[j++] = base64ReverseLookup[b64.charCodeAt(i)] << 2 | b1 >> 4;
27301 if (j < end) uint8Array[j++] = b1 << 4 | b2 >> 2;
27302 if (j < end) uint8Array[j++] = b2 << 6 | base64ReverseLookup[b64.charCodeAt(i+3)];
27303 }
27304 }
27305 base64DecodeToExistingUint8Array(bufferView, 1025, "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");
27306base64DecodeToExistingUint8Array(bufferView, 6516, "tx3BBG47ggnZJkMN3HYEE2trxReyTYYaBVBHHrjtCCYP8Mki1taKL2HLSytkmww104bNMQqgjjy9vU84cNsRTMfG0Ege4JNFqf1SQaytFV8bsNRbwpaXVnWLVlLINhlqfyvYbqYNm2MREFpnFEAdeaNd3H16e59wzWZedOC2I5hXq+Kcjo2hkTmQYJU8wCeLi93mj1L7pYLl5mSGWFsrvu9G6ro2YKm3gX1os4QtL60zMO6p6hatpF0LbKCQbTLUJ3Dz0P5WsN1JS3HZTBs2x/sG98MiILTOlT11yiiAOvKfnfv2Rru4+/Gmef/09j7hQ+v/5ZrNvOgt0H3sd3CGNMBtRzAZSwQ9rlbFOasGgiccG0MjxT0ALnIgwSrPnY4SeIBPFqGmDBsWu80fE+uKAaT2SwV90AgIys3JDAerl3iwtlZ8aZAVcd6N1HXb3ZNrbMBSb7XmEWIC+9Bmv0afXghbXlrRfR1XZmDcU2Mwm03ULVpJDQsZRLoW2ECXxqWsINtkqPn9J6VO4OahS7Chv/ytYLsliyO2kpbisi8rrYqYNmyOQRAvg/YN7ofzXamZREBonZ1mK5Aqe+qU5x204FAAdeSJJjbpPjv37TtrsPOMdnH3VVAy+uJN8/5f8LzG6O19wjHLPs+G1v/Lg4a41TSbedHtvTrcWqD72O7gDGlZ/c1tgNuOYDfGT2Qylgh6hYvJflytinPrsEt3Vg0ET+EQxUs4NoZGjytHQop7AFw9ZsFY5ECCVVNdQ1GeOx0lKSbcIfAAnyxHHV4oQk0ZNvVQ2DIsdps/m2taOybWFQORy9QHSO2XCv/wVg76oBEQTb3QFJSbkxkjhlIdDlYv8blL7vVgba3413Bs/NIgK+JlPermvBup6wsGaO+2uyfXAabm09iApd5vnWTaas0jxN3Q4sAE9qHNs+tgyX6NPr3JkP+5ELa8tKerfbCi+zquFeb7qszAuKd73XmjxmA2m3F995+oW7SSH0Z1lhoWMoitC/OMdC2wgcMwcYWZkIpdLo1LWferCFRAtslQReaOTvL7T0or3QxHnMDNQyF9gnuWYEN/T0YAcvhbwXb9C4ZoShZHbJMwBGEkLcVl6UubEV5WWhWHcBkYMG3YHDU9nwKCIF4GWwYdC+wb3A9RppM35rtSMz+dET6IgNA6jdCXJDrNViDj6xUtVPbUKXkmqcXOO2jBFx0rzKAA6silUK3WEk1s0strL998du7bwcuh43bWYOev8CPqGO3i7h29pfCqoGT0c4Yn+cSb5v0J/biJvuB5jWfGOoDQ2/uE1Yu8mmKWfZ67sD6TDK3/l7EQsK8GDXGr3ysypmg286JtZrS82nt1uANdNrW0QPexf0ZMQUMAAAAQAAAAiCoAAElEMw==");
27307base64DecodeToExistingUint8Array(bufferView, 7576, "AQAAAAUAAAAYKw==");
27308base64DecodeToExistingUint8Array(bufferView, 7600, "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");
27309base64DecodeToExistingUint8Array(bufferView, 10387, "QPsh+T8AAAAALUR0PgAAAICYRvg8AAAAYFHMeDsAAACAgxvwOQAAAEAgJXo4AAAAgCKC4zYAAAAAHfNpNQAAAAAAAOA/AAAAAAAA4L8BAAAAAgAAAAQAAAAFAAAABgAAAGluZmluaXR5AG5hbg==");
27310base64DecodeToExistingUint8Array(bufferView, 10512, "0XSeAFedvSqAcFIP//8+JwoAAABkAAAA6AMAABAnAACghgEAQEIPAICWmAAA4fUFGAAAADUAAABxAAAAa////877//+Sv///YmFydGxldHQAYmFydGxldHRfaGFubgBibGFja21hbgBibGFja21hbl9oYXJyaXNfNHRlcm1fOTJkYgBjb25uZXMAZmxhdHRvcABnYXVzcygAaGFtbWluZwBoYW5uAGthaXNlcl9iZXNzZWwAbnV0dGFsbAByZWN0YW5nbGUAdHJpYW5nbGUAdHVrZXkoAHBhcnRpYWxfdHVrZXkoAHB1bmNob3V0X3R1a2V5KAB3ZWxjaABpbWFnZS9wbmcALS0+AHR1a2V5KDVlLTEpAHR1a2V5KDVlLTEpO3BhcnRpYWxfdHVrZXkoMikAdHVrZXkoNWUtMSk7cGFydGlhbF90dWtleSgyKTtwdW5jaG91dF90dWtleSgzKQ==");
27311base64DecodeToExistingUint8Array(bufferView, 10881, "FQAAcR0AAAk=");
27312base64DecodeToExistingUint8Array(bufferView, 10900, "Ag==");
27313base64DecodeToExistingUint8Array(bufferView, 10920, "AwAAAAAAAAAEAAAASC8AAAAE");
27314base64DecodeToExistingUint8Array(bufferView, 10964, "/////w==");
27315base64DecodeToExistingUint8Array(bufferView, 11032, "BQ==");
27316base64DecodeToExistingUint8Array(bufferView, 11044, "CQ==");
27317base64DecodeToExistingUint8Array(bufferView, 11068, "CgAAAAsAAABYMwAAAAQ=");
27318base64DecodeToExistingUint8Array(bufferView, 11092, "AQ==");
27319base64DecodeToExistingUint8Array(bufferView, 11107, "Cv////8=");
27320base64DecodeToExistingUint8Array(bufferView, 11176, "GCs=");
27321base64DecodeToExistingUint8Array(bufferView, 11216, "AwAAAAAAAAAZKgAAAQAAAAE=");
27322base64DecodeToExistingUint8Array(bufferView, 11260, "AwAAAAAAAAAZKgAAAQ==");
27323base64DecodeToExistingUint8Array(bufferView, 11304, "AwAAAAAAAAAZKg==");
27324base64DecodeToExistingUint8Array(bufferView, 11324, "Bg==");
27325base64DecodeToExistingUint8Array(bufferView, 11348, "BAAAAAAAAAAZKgAAAQAAAAEAAAAI");
27326base64DecodeToExistingUint8Array(bufferView, 11392, "BAAAAAAAAAAZKgAAAQAAAAAAAAAI");
27327base64DecodeToExistingUint8Array(bufferView, 11436, "BQAAAAAAAAAZKgAAAQAAAAAAAAAI");
27328base64DecodeToExistingUint8Array(bufferView, 11480, "BgAAAAAAAAAlKgAAAQAAAAAAAAAM");
27329base64DecodeToExistingUint8Array(bufferView, 11524, "BgAAAAAAAAAlKgAAAQAAAAAAAAAM");
27330base64DecodeToExistingUint8Array(bufferView, 11568, "BgAAAAAAAABCKg==");
27331return asmFunc({
27332 'Int8Array': Int8Array,
27333 'Int16Array': Int16Array,
27334 'Int32Array': Int32Array,
27335 'Uint8Array': Uint8Array,
27336 'Uint16Array': Uint16Array,
27337 'Uint32Array': Uint32Array,
27338 'Float32Array': Float32Array,
27339 'Float64Array': Float64Array,
27340 'NaN': NaN,
27341 'Infinity': Infinity,
27342 'Math': Math
27343 },
27344 asmLibraryArg,
27345 wasmMemory.buffer
27346)
27347
27348}
27349)(asmLibraryArg, wasmMemory, wasmTable);
27350 },
27351
27352 instantiate: /** @suppress{checkTypes} */ function(binary, info) {
27353 return {
27354 then: function(ok) {
27355 ok({
27356 'instance': new WebAssembly.Instance(new WebAssembly.Module(binary))
27357 });
27358 }
27359 };
27360 },
27361
27362 RuntimeError: Error
27363};
27364
27365// We don't need to actually download a wasm binary, mark it as present but empty.
27366wasmBinary = [];
27367
27368
27369
27370if (typeof WebAssembly !== 'object') {
27371 abort('no native wasm support detected');
27372}
27373
27374
27375
27376
27377// In MINIMAL_RUNTIME, setValue() and getValue() are only available when building with safe heap enabled, for heap safety checking.
27378// In traditional runtime, setValue() and getValue() are always available (although their use is highly discouraged due to perf penalties)
27379
27380/** @param {number} ptr
27381 @param {number} value
27382 @param {string} type
27383 @param {number|boolean=} noSafe */
27384function setValue(ptr, value, type, noSafe) {
27385 type = type || 'i8';
27386 if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
27387 switch(type) {
27388 case 'i1': HEAP8[((ptr)>>0)]=value; break;
27389 case 'i8': HEAP8[((ptr)>>0)]=value; break;
27390 case 'i16': HEAP16[((ptr)>>1)]=value; break;
27391 case 'i32': HEAP32[((ptr)>>2)]=value; break;
27392 case 'i64': (tempI64 = [value>>>0,(tempDouble=value,(+(Math_abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? ((Math_min((+(Math_floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math_ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)],HEAP32[((ptr)>>2)]=tempI64[0],HEAP32[(((ptr)+(4))>>2)]=tempI64[1]); break;
27393 case 'float': HEAPF32[((ptr)>>2)]=value; break;
27394 case 'double': HEAPF64[((ptr)>>3)]=value; break;
27395 default: abort('invalid type for setValue: ' + type);
27396 }
27397}
27398
27399/** @param {number} ptr
27400 @param {string} type
27401 @param {number|boolean=} noSafe */
27402function getValue(ptr, type, noSafe) {
27403 type = type || 'i8';
27404 if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
27405 switch(type) {
27406 case 'i1': return HEAP8[((ptr)>>0)];
27407 case 'i8': return HEAP8[((ptr)>>0)];
27408 case 'i16': return HEAP16[((ptr)>>1)];
27409 case 'i32': return HEAP32[((ptr)>>2)];
27410 case 'i64': return HEAP32[((ptr)>>2)];
27411 case 'float': return HEAPF32[((ptr)>>2)];
27412 case 'double': return HEAPF64[((ptr)>>3)];
27413 default: abort('invalid type for getValue: ' + type);
27414 }
27415 return null;
27416}
27417
27418
27419
27420
27421
27422
27423// Wasm globals
27424
27425var wasmMemory;
27426
27427// In fastcomp asm.js, we don't need a wasm Table at all.
27428// In the wasm backend, we polyfill the WebAssembly object,
27429// so this creates a (non-native-wasm) table for us.
27430var wasmTable = new WebAssembly.Table({
27431 'initial': 22,
27432 'maximum': 22 + 5,
27433 'element': 'anyfunc'
27434});
27435
27436
27437//========================================
27438// Runtime essentials
27439//========================================
27440
27441// whether we are quitting the application. no code should run after this.
27442// set in exit() and abort()
27443var ABORT = false;
27444
27445// set by exit() and abort(). Passed to 'onExit' handler.
27446// NOTE: This is also used as the process return code code in shell environments
27447// but only when noExitRuntime is false.
27448var EXITSTATUS = 0;
27449
27450/** @type {function(*, string=)} */
27451function assert(condition, text) {
27452 if (!condition) {
27453 abort('Assertion failed: ' + text);
27454 }
27455}
27456
27457// Returns the C function with a specified identifier (for C++, you need to do manual name mangling)
27458function getCFunc(ident) {
27459 var func = Module['_' + ident]; // closure exported function
27460 assert(func, 'Cannot call unknown function ' + ident + ', make sure it is exported');
27461 return func;
27462}
27463
27464// C calling interface.
27465/** @param {string|null=} returnType
27466 @param {Array=} argTypes
27467 @param {Arguments|Array=} args
27468 @param {Object=} opts */
27469function ccall(ident, returnType, argTypes, args, opts) {
27470 // For fast lookup of conversion functions
27471 var toC = {
27472 'string': function(str) {
27473 var ret = 0;
27474 if (str !== null && str !== undefined && str !== 0) { // null string
27475 // at most 4 bytes per UTF-8 code point, +1 for the trailing '\0'
27476 var len = (str.length << 2) + 1;
27477 ret = stackAlloc(len);
27478 stringToUTF8(str, ret, len);
27479 }
27480 return ret;
27481 },
27482 'array': function(arr) {
27483 var ret = stackAlloc(arr.length);
27484 writeArrayToMemory(arr, ret);
27485 return ret;
27486 }
27487 };
27488
27489 function convertReturnValue(ret) {
27490 if (returnType === 'string') return UTF8ToString(ret);
27491 if (returnType === 'boolean') return Boolean(ret);
27492 return ret;
27493 }
27494
27495 var func = getCFunc(ident);
27496 var cArgs = [];
27497 var stack = 0;
27498 if (args) {
27499 for (var i = 0; i < args.length; i++) {
27500 var converter = toC[argTypes[i]];
27501 if (converter) {
27502 if (stack === 0) stack = stackSave();
27503 cArgs[i] = converter(args[i]);
27504 } else {
27505 cArgs[i] = args[i];
27506 }
27507 }
27508 }
27509 var ret = func.apply(null, cArgs);
27510
27511 ret = convertReturnValue(ret);
27512 if (stack !== 0) stackRestore(stack);
27513 return ret;
27514}
27515
27516/** @param {string=} returnType
27517 @param {Array=} argTypes
27518 @param {Object=} opts */
27519function cwrap(ident, returnType, argTypes, opts) {
27520 argTypes = argTypes || [];
27521 // When the function takes numbers and returns a number, we can just return
27522 // the original function
27523 var numericArgs = argTypes.every(function(type){ return type === 'number'});
27524 var numericRet = returnType !== 'string';
27525 if (numericRet && numericArgs && !opts) {
27526 return getCFunc(ident);
27527 }
27528 return function() {
27529 return ccall(ident, returnType, argTypes, arguments, opts);
27530 }
27531}
27532
27533var ALLOC_NORMAL = 0; // Tries to use _malloc()
27534var ALLOC_STACK = 1; // Lives for the duration of the current function call
27535var ALLOC_DYNAMIC = 2; // Cannot be freed except through sbrk
27536var ALLOC_NONE = 3; // Do not allocate
27537
27538// allocate(): This is for internal use. You can use it yourself as well, but the interface
27539// is a little tricky (see docs right below). The reason is that it is optimized
27540// for multiple syntaxes to save space in generated code. So you should
27541// normally not use allocate(), and instead allocate memory using _malloc(),
27542// initialize it with setValue(), and so forth.
27543// @slab: An array of data, or a number. If a number, then the size of the block to allocate,
27544// in *bytes* (note that this is sometimes confusing: the next parameter does not
27545// affect this!)
27546// @types: Either an array of types, one for each byte (or 0 if no type at that position),
27547// or a single type which is used for the entire block. This only matters if there
27548// is initial data - if @slab is a number, then this does not matter at all and is
27549// ignored.
27550// @allocator: How to allocate memory, see ALLOC_*
27551/** @type {function((TypedArray|Array<number>|number), string, number, number=)} */
27552function allocate(slab, types, allocator, ptr) {
27553 var zeroinit, size;
27554 if (typeof slab === 'number') {
27555 zeroinit = true;
27556 size = slab;
27557 } else {
27558 zeroinit = false;
27559 size = slab.length;
27560 }
27561
27562 var singleType = typeof types === 'string' ? types : null;
27563
27564 var ret;
27565 if (allocator == ALLOC_NONE) {
27566 ret = ptr;
27567 } else {
27568 ret = [_malloc,
27569 stackAlloc,
27570 dynamicAlloc][allocator](Math.max(size, singleType ? 1 : types.length));
27571 }
27572
27573 if (zeroinit) {
27574 var stop;
27575 ptr = ret;
27576 assert((ret & 3) == 0);
27577 stop = ret + (size & ~3);
27578 for (; ptr < stop; ptr += 4) {
27579 HEAP32[((ptr)>>2)]=0;
27580 }
27581 stop = ret + size;
27582 while (ptr < stop) {
27583 HEAP8[((ptr++)>>0)]=0;
27584 }
27585 return ret;
27586 }
27587
27588 if (singleType === 'i8') {
27589 if (slab.subarray || slab.slice) {
27590 HEAPU8.set(/** @type {!Uint8Array} */ (slab), ret);
27591 } else {
27592 HEAPU8.set(new Uint8Array(slab), ret);
27593 }
27594 return ret;
27595 }
27596
27597 var i = 0, type, typeSize, previousType;
27598 while (i < size) {
27599 var curr = slab[i];
27600
27601 type = singleType || types[i];
27602 if (type === 0) {
27603 i++;
27604 continue;
27605 }
27606
27607 if (type == 'i64') type = 'i32'; // special case: we have one i32 here, and one i32 later
27608
27609 setValue(ret+i, curr, type);
27610
27611 // no need to look up size unless type changes, so cache it
27612 if (previousType !== type) {
27613 typeSize = getNativeTypeSize(type);
27614 previousType = type;
27615 }
27616 i += typeSize;
27617 }
27618
27619 return ret;
27620}
27621
27622// Allocate memory during any stage of startup - static memory early on, dynamic memory later, malloc when ready
27623function getMemory(size) {
27624 if (!runtimeInitialized) return dynamicAlloc(size);
27625 return _malloc(size);
27626}
27627
27628
27629
27630
27631// runtime_strings.js: Strings related runtime functions that are part of both MINIMAL_RUNTIME and regular runtime.
27632
27633// Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the given array that contains uint8 values, returns
27634// a copy of that string as a Javascript String object.
27635
27636var UTF8Decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf8') : undefined;
27637
27638/**
27639 * @param {number} idx
27640 * @param {number=} maxBytesToRead
27641 * @return {string}
27642 */
27643function UTF8ArrayToString(heap, idx, maxBytesToRead) {
27644 var endIdx = idx + maxBytesToRead;
27645 var endPtr = idx;
27646 // TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself.
27647 // Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage.
27648 // (As a tiny code save trick, compare endPtr against endIdx using a negation, so that undefined means Infinity)
27649 while (heap[endPtr] && !(endPtr >= endIdx)) ++endPtr;
27650
27651 if (endPtr - idx > 16 && heap.subarray && UTF8Decoder) {
27652 return UTF8Decoder.decode(heap.subarray(idx, endPtr));
27653 } else {
27654 var str = '';
27655 // If building with TextDecoder, we have already computed the string length above, so test loop end condition against that
27656 while (idx < endPtr) {
27657 // For UTF8 byte structure, see:
27658 // http://en.wikipedia.org/wiki/UTF-8#Description
27659 // https://www.ietf.org/rfc/rfc2279.txt
27660 // https://tools.ietf.org/html/rfc3629
27661 var u0 = heap[idx++];
27662 if (!(u0 & 0x80)) { str += String.fromCharCode(u0); continue; }
27663 var u1 = heap[idx++] & 63;
27664 if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; }
27665 var u2 = heap[idx++] & 63;
27666 if ((u0 & 0xF0) == 0xE0) {
27667 u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
27668 } else {
27669 u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heap[idx++] & 63);
27670 }
27671
27672 if (u0 < 0x10000) {
27673 str += String.fromCharCode(u0);
27674 } else {
27675 var ch = u0 - 0x10000;
27676 str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));
27677 }
27678 }
27679 }
27680 return str;
27681}
27682
27683// Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the emscripten HEAP, returns a
27684// copy of that string as a Javascript String object.
27685// maxBytesToRead: an optional length that specifies the maximum number of bytes to read. You can omit
27686// this parameter to scan the string until the first \0 byte. If maxBytesToRead is
27687// passed, and the string at [ptr, ptr+maxBytesToReadr[ contains a null byte in the
27688// middle, then the string will cut short at that byte index (i.e. maxBytesToRead will
27689// not produce a string of exact length [ptr, ptr+maxBytesToRead[)
27690// N.B. mixing frequent uses of UTF8ToString() with and without maxBytesToRead may
27691// throw JS JIT optimizations off, so it is worth to consider consistently using one
27692// style or the other.
27693/**
27694 * @param {number} ptr
27695 * @param {number=} maxBytesToRead
27696 * @return {string}
27697 */
27698function UTF8ToString(ptr, maxBytesToRead) {
27699 return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : '';
27700}
27701
27702// Copies the given Javascript String object 'str' to the given byte array at address 'outIdx',
27703// encoded in UTF8 form and null-terminated. The copy will require at most str.length*4+1 bytes of space in the HEAP.
27704// Use the function lengthBytesUTF8 to compute the exact number of bytes (excluding null terminator) that this function will write.
27705// Parameters:
27706// str: the Javascript string to copy.
27707// heap: the array to copy to. Each index in this array is assumed to be one 8-byte element.
27708// outIdx: The starting offset in the array to begin the copying.
27709// maxBytesToWrite: The maximum number of bytes this function can write to the array.
27710// This count should include the null terminator,
27711// i.e. if maxBytesToWrite=1, only the null terminator will be written and nothing else.
27712// maxBytesToWrite=0 does not write any bytes to the output, not even the null terminator.
27713// Returns the number of bytes written, EXCLUDING the null terminator.
27714
27715function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {
27716 if (!(maxBytesToWrite > 0)) // Parameter maxBytesToWrite is not optional. Negative values, 0, null, undefined and false each don't write out any bytes.
27717 return 0;
27718
27719 var startIdx = outIdx;
27720 var endIdx = outIdx + maxBytesToWrite - 1; // -1 for string null terminator.
27721 for (var i = 0; i < str.length; ++i) {
27722 // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! So decode UTF16->UTF32->UTF8.
27723 // See http://unicode.org/faq/utf_bom.html#utf16-3
27724 // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description and https://www.ietf.org/rfc/rfc2279.txt and https://tools.ietf.org/html/rfc3629
27725 var u = str.charCodeAt(i); // possibly a lead surrogate
27726 if (u >= 0xD800 && u <= 0xDFFF) {
27727 var u1 = str.charCodeAt(++i);
27728 u = 0x10000 + ((u & 0x3FF) << 10) | (u1 & 0x3FF);
27729 }
27730 if (u <= 0x7F) {
27731 if (outIdx >= endIdx) break;
27732 heap[outIdx++] = u;
27733 } else if (u <= 0x7FF) {
27734 if (outIdx + 1 >= endIdx) break;
27735 heap[outIdx++] = 0xC0 | (u >> 6);
27736 heap[outIdx++] = 0x80 | (u & 63);
27737 } else if (u <= 0xFFFF) {
27738 if (outIdx + 2 >= endIdx) break;
27739 heap[outIdx++] = 0xE0 | (u >> 12);
27740 heap[outIdx++] = 0x80 | ((u >> 6) & 63);
27741 heap[outIdx++] = 0x80 | (u & 63);
27742 } else {
27743 if (outIdx + 3 >= endIdx) break;
27744 heap[outIdx++] = 0xF0 | (u >> 18);
27745 heap[outIdx++] = 0x80 | ((u >> 12) & 63);
27746 heap[outIdx++] = 0x80 | ((u >> 6) & 63);
27747 heap[outIdx++] = 0x80 | (u & 63);
27748 }
27749 }
27750 // Null-terminate the pointer to the buffer.
27751 heap[outIdx] = 0;
27752 return outIdx - startIdx;
27753}
27754
27755// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
27756// null-terminated and encoded in UTF8 form. The copy will require at most str.length*4+1 bytes of space in the HEAP.
27757// Use the function lengthBytesUTF8 to compute the exact number of bytes (excluding null terminator) that this function will write.
27758// Returns the number of bytes written, EXCLUDING the null terminator.
27759
27760function stringToUTF8(str, outPtr, maxBytesToWrite) {
27761 return stringToUTF8Array(str, HEAPU8,outPtr, maxBytesToWrite);
27762}
27763
27764// Returns the number of bytes the given Javascript string takes if encoded as a UTF8 byte array, EXCLUDING the null terminator byte.
27765function lengthBytesUTF8(str) {
27766 var len = 0;
27767 for (var i = 0; i < str.length; ++i) {
27768 // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! So decode UTF16->UTF32->UTF8.
27769 // See http://unicode.org/faq/utf_bom.html#utf16-3
27770 var u = str.charCodeAt(i); // possibly a lead surrogate
27771 if (u >= 0xD800 && u <= 0xDFFF) u = 0x10000 + ((u & 0x3FF) << 10) | (str.charCodeAt(++i) & 0x3FF);
27772 if (u <= 0x7F) ++len;
27773 else if (u <= 0x7FF) len += 2;
27774 else if (u <= 0xFFFF) len += 3;
27775 else len += 4;
27776 }
27777 return len;
27778}
27779
27780
27781
27782
27783
27784// runtime_strings_extra.js: Strings related runtime functions that are available only in regular runtime.
27785
27786// Given a pointer 'ptr' to a null-terminated ASCII-encoded string in the emscripten HEAP, returns
27787// a copy of that string as a Javascript String object.
27788
27789function AsciiToString(ptr) {
27790 var str = '';
27791 while (1) {
27792 var ch = HEAPU8[((ptr++)>>0)];
27793 if (!ch) return str;
27794 str += String.fromCharCode(ch);
27795 }
27796}
27797
27798// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
27799// null-terminated and encoded in ASCII form. The copy will require at most str.length+1 bytes of space in the HEAP.
27800
27801function stringToAscii(str, outPtr) {
27802 return writeAsciiToMemory(str, outPtr, false);
27803}
27804
27805// Given a pointer 'ptr' to a null-terminated UTF16LE-encoded string in the emscripten HEAP, returns
27806// a copy of that string as a Javascript String object.
27807
27808var UTF16Decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-16le') : undefined;
27809
27810function UTF16ToString(ptr, maxBytesToRead) {
27811 var endPtr = ptr;
27812 // TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself.
27813 // Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage.
27814 var idx = endPtr >> 1;
27815 var maxIdx = idx + maxBytesToRead / 2;
27816 // If maxBytesToRead is not passed explicitly, it will be undefined, and this
27817 // will always evaluate to true. This saves on code size.
27818 while (!(idx >= maxIdx) && HEAPU16[idx]) ++idx;
27819 endPtr = idx << 1;
27820
27821 if (endPtr - ptr > 32 && UTF16Decoder) {
27822 return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr));
27823 } else {
27824 var i = 0;
27825
27826 var str = '';
27827 while (1) {
27828 var codeUnit = HEAP16[(((ptr)+(i*2))>>1)];
27829 if (codeUnit == 0 || i == maxBytesToRead / 2) return str;
27830 ++i;
27831 // fromCharCode constructs a character from a UTF-16 code unit, so we can pass the UTF16 string right through.
27832 str += String.fromCharCode(codeUnit);
27833 }
27834 }
27835}
27836
27837// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
27838// null-terminated and encoded in UTF16 form. The copy will require at most str.length*4+2 bytes of space in the HEAP.
27839// Use the function lengthBytesUTF16() to compute the exact number of bytes (excluding null terminator) that this function will write.
27840// Parameters:
27841// str: the Javascript string to copy.
27842// outPtr: Byte address in Emscripten HEAP where to write the string to.
27843// maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null
27844// terminator, i.e. if maxBytesToWrite=2, only the null terminator will be written and nothing else.
27845// maxBytesToWrite<2 does not write any bytes to the output, not even the null terminator.
27846// Returns the number of bytes written, EXCLUDING the null terminator.
27847
27848function stringToUTF16(str, outPtr, maxBytesToWrite) {
27849 // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed.
27850 if (maxBytesToWrite === undefined) {
27851 maxBytesToWrite = 0x7FFFFFFF;
27852 }
27853 if (maxBytesToWrite < 2) return 0;
27854 maxBytesToWrite -= 2; // Null terminator.
27855 var startPtr = outPtr;
27856 var numCharsToWrite = (maxBytesToWrite < str.length*2) ? (maxBytesToWrite / 2) : str.length;
27857 for (var i = 0; i < numCharsToWrite; ++i) {
27858 // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP.
27859 var codeUnit = str.charCodeAt(i); // possibly a lead surrogate
27860 HEAP16[((outPtr)>>1)]=codeUnit;
27861 outPtr += 2;
27862 }
27863 // Null-terminate the pointer to the HEAP.
27864 HEAP16[((outPtr)>>1)]=0;
27865 return outPtr - startPtr;
27866}
27867
27868// Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte.
27869
27870function lengthBytesUTF16(str) {
27871 return str.length*2;
27872}
27873
27874function UTF32ToString(ptr, maxBytesToRead) {
27875 var i = 0;
27876
27877 var str = '';
27878 // If maxBytesToRead is not passed explicitly, it will be undefined, and this
27879 // will always evaluate to true. This saves on code size.
27880 while (!(i >= maxBytesToRead / 4)) {
27881 var utf32 = HEAP32[(((ptr)+(i*4))>>2)];
27882 if (utf32 == 0) break;
27883 ++i;
27884 // Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing.
27885 // See http://unicode.org/faq/utf_bom.html#utf16-3
27886 if (utf32 >= 0x10000) {
27887 var ch = utf32 - 0x10000;
27888 str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));
27889 } else {
27890 str += String.fromCharCode(utf32);
27891 }
27892 }
27893 return str;
27894}
27895
27896// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
27897// null-terminated and encoded in UTF32 form. The copy will require at most str.length*4+4 bytes of space in the HEAP.
27898// Use the function lengthBytesUTF32() to compute the exact number of bytes (excluding null terminator) that this function will write.
27899// Parameters:
27900// str: the Javascript string to copy.
27901// outPtr: Byte address in Emscripten HEAP where to write the string to.
27902// maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null
27903// terminator, i.e. if maxBytesToWrite=4, only the null terminator will be written and nothing else.
27904// maxBytesToWrite<4 does not write any bytes to the output, not even the null terminator.
27905// Returns the number of bytes written, EXCLUDING the null terminator.
27906
27907function stringToUTF32(str, outPtr, maxBytesToWrite) {
27908 // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed.
27909 if (maxBytesToWrite === undefined) {
27910 maxBytesToWrite = 0x7FFFFFFF;
27911 }
27912 if (maxBytesToWrite < 4) return 0;
27913 var startPtr = outPtr;
27914 var endPtr = startPtr + maxBytesToWrite - 4;
27915 for (var i = 0; i < str.length; ++i) {
27916 // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap.
27917 // See http://unicode.org/faq/utf_bom.html#utf16-3
27918 var codeUnit = str.charCodeAt(i); // possibly a lead surrogate
27919 if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) {
27920 var trailSurrogate = str.charCodeAt(++i);
27921 codeUnit = 0x10000 + ((codeUnit & 0x3FF) << 10) | (trailSurrogate & 0x3FF);
27922 }
27923 HEAP32[((outPtr)>>2)]=codeUnit;
27924 outPtr += 4;
27925 if (outPtr + 4 > endPtr) break;
27926 }
27927 // Null-terminate the pointer to the HEAP.
27928 HEAP32[((outPtr)>>2)]=0;
27929 return outPtr - startPtr;
27930}
27931
27932// Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte.
27933
27934function lengthBytesUTF32(str) {
27935 var len = 0;
27936 for (var i = 0; i < str.length; ++i) {
27937 // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap.
27938 // See http://unicode.org/faq/utf_bom.html#utf16-3
27939 var codeUnit = str.charCodeAt(i);
27940 if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) ++i; // possibly a lead surrogate, so skip over the tail surrogate.
27941 len += 4;
27942 }
27943
27944 return len;
27945}
27946
27947// Allocate heap space for a JS string, and write it there.
27948// It is the responsibility of the caller to free() that memory.
27949function allocateUTF8(str) {
27950 var size = lengthBytesUTF8(str) + 1;
27951 var ret = _malloc(size);
27952 if (ret) stringToUTF8Array(str, HEAP8, ret, size);
27953 return ret;
27954}
27955
27956// Allocate stack space for a JS string, and write it there.
27957function allocateUTF8OnStack(str) {
27958 var size = lengthBytesUTF8(str) + 1;
27959 var ret = stackAlloc(size);
27960 stringToUTF8Array(str, HEAP8, ret, size);
27961 return ret;
27962}
27963
27964// Deprecated: This function should not be called because it is unsafe and does not provide
27965// a maximum length limit of how many bytes it is allowed to write. Prefer calling the
27966// function stringToUTF8Array() instead, which takes in a maximum length that can be used
27967// to be secure from out of bounds writes.
27968/** @deprecated
27969 @param {boolean=} dontAddNull */
27970function writeStringToMemory(string, buffer, dontAddNull) {
27971 warnOnce('writeStringToMemory is deprecated and should not be called! Use stringToUTF8() instead!');
27972
27973 var /** @type {number} */ lastChar, /** @type {number} */ end;
27974 if (dontAddNull) {
27975 // stringToUTF8Array always appends null. If we don't want to do that, remember the
27976 // character that existed at the location where the null will be placed, and restore
27977 // that after the write (below).
27978 end = buffer + lengthBytesUTF8(string);
27979 lastChar = HEAP8[end];
27980 }
27981 stringToUTF8(string, buffer, Infinity);
27982 if (dontAddNull) HEAP8[end] = lastChar; // Restore the value under the null character.
27983}
27984
27985function writeArrayToMemory(array, buffer) {
27986 HEAP8.set(array, buffer);
27987}
27988
27989/** @param {boolean=} dontAddNull */
27990function writeAsciiToMemory(str, buffer, dontAddNull) {
27991 for (var i = 0; i < str.length; ++i) {
27992 HEAP8[((buffer++)>>0)]=str.charCodeAt(i);
27993 }
27994 // Null-terminate the pointer to the HEAP.
27995 if (!dontAddNull) HEAP8[((buffer)>>0)]=0;
27996}
27997
27998
27999
28000// Memory management
28001
28002var PAGE_SIZE = 16384;
28003var WASM_PAGE_SIZE = 65536;
28004var ASMJS_PAGE_SIZE = 16777216;
28005
28006function alignUp(x, multiple) {
28007 if (x % multiple > 0) {
28008 x += multiple - (x % multiple);
28009 }
28010 return x;
28011}
28012
28013var HEAP,
28014/** @type {ArrayBuffer} */
28015 buffer,
28016/** @type {Int8Array} */
28017 HEAP8,
28018/** @type {Uint8Array} */
28019 HEAPU8,
28020/** @type {Int16Array} */
28021 HEAP16,
28022/** @type {Uint16Array} */
28023 HEAPU16,
28024/** @type {Int32Array} */
28025 HEAP32,
28026/** @type {Uint32Array} */
28027 HEAPU32,
28028/** @type {Float32Array} */
28029 HEAPF32,
28030/** @type {Float64Array} */
28031 HEAPF64;
28032
28033function updateGlobalBufferAndViews(buf) {
28034 buffer = buf;
28035 Module['HEAP8'] = HEAP8 = new Int8Array(buf);
28036 Module['HEAP16'] = HEAP16 = new Int16Array(buf);
28037 Module['HEAP32'] = HEAP32 = new Int32Array(buf);
28038 Module['HEAPU8'] = HEAPU8 = new Uint8Array(buf);
28039 Module['HEAPU16'] = HEAPU16 = new Uint16Array(buf);
28040 Module['HEAPU32'] = HEAPU32 = new Uint32Array(buf);
28041 Module['HEAPF32'] = HEAPF32 = new Float32Array(buf);
28042 Module['HEAPF64'] = HEAPF64 = new Float64Array(buf);
28043}
28044
28045var STATIC_BASE = 1024,
28046 STACK_BASE = 5257216,
28047 STACKTOP = STACK_BASE,
28048 STACK_MAX = 14336,
28049 DYNAMIC_BASE = 5257216,
28050 DYNAMICTOP_PTR = 14176;
28051
28052
28053
28054var TOTAL_STACK = 5242880;
28055
28056var INITIAL_INITIAL_MEMORY = Module['INITIAL_MEMORY'] || 16777216;
28057
28058
28059
28060
28061
28062
28063
28064
28065
28066// In non-standalone/normal mode, we create the memory here.
28067
28068
28069
28070// Create the main memory. (Note: this isn't used in STANDALONE_WASM mode since the wasm
28071// memory is created in the wasm, not in JS.)
28072
28073 if (Module['wasmMemory']) {
28074 wasmMemory = Module['wasmMemory'];
28075 } else
28076 {
28077 wasmMemory = new WebAssembly.Memory({
28078 'initial': INITIAL_INITIAL_MEMORY / WASM_PAGE_SIZE
28079 ,
28080 'maximum': 2147483648 / WASM_PAGE_SIZE
28081 });
28082 }
28083
28084
28085if (wasmMemory) {
28086 buffer = wasmMemory.buffer;
28087}
28088
28089// If the user provides an incorrect length, just use that length instead rather than providing the user to
28090// specifically provide the memory length with Module['INITIAL_MEMORY'].
28091INITIAL_INITIAL_MEMORY = buffer.byteLength;
28092updateGlobalBufferAndViews(buffer);
28093
28094HEAP32[DYNAMICTOP_PTR>>2] = DYNAMIC_BASE;
28095
28096
28097
28098
28099
28100
28101
28102
28103
28104
28105
28106
28107
28108
28109function callRuntimeCallbacks(callbacks) {
28110 while(callbacks.length > 0) {
28111 var callback = callbacks.shift();
28112 if (typeof callback == 'function') {
28113 callback(Module); // Pass the module as the first argument.
28114 continue;
28115 }
28116 var func = callback.func;
28117 if (typeof func === 'number') {
28118 if (callback.arg === undefined) {
28119 Module['dynCall_v'](func);
28120 } else {
28121 Module['dynCall_vi'](func, callback.arg);
28122 }
28123 } else {
28124 func(callback.arg === undefined ? null : callback.arg);
28125 }
28126 }
28127}
28128
28129var __ATPRERUN__ = []; // functions called before the runtime is initialized
28130var __ATINIT__ = []; // functions called during startup
28131var __ATMAIN__ = []; // functions called when main() is to be run
28132var __ATEXIT__ = []; // functions called during shutdown
28133var __ATPOSTRUN__ = []; // functions called after the main() is called
28134
28135var runtimeInitialized = false;
28136var runtimeExited = false;
28137
28138
28139function preRun() {
28140
28141 if (Module['preRun']) {
28142 if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];
28143 while (Module['preRun'].length) {
28144 addOnPreRun(Module['preRun'].shift());
28145 }
28146 }
28147
28148 callRuntimeCallbacks(__ATPRERUN__);
28149}
28150
28151function initRuntime() {
28152 runtimeInitialized = true;
28153 if (!Module["noFSInit"] && !FS.init.initialized) FS.init();
28154TTY.init();
28155 callRuntimeCallbacks(__ATINIT__);
28156}
28157
28158function preMain() {
28159 FS.ignorePermissions = false;
28160 callRuntimeCallbacks(__ATMAIN__);
28161}
28162
28163function exitRuntime() {
28164 runtimeExited = true;
28165}
28166
28167function postRun() {
28168
28169 if (Module['postRun']) {
28170 if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']];
28171 while (Module['postRun'].length) {
28172 addOnPostRun(Module['postRun'].shift());
28173 }
28174 }
28175
28176 callRuntimeCallbacks(__ATPOSTRUN__);
28177}
28178
28179function addOnPreRun(cb) {
28180 __ATPRERUN__.unshift(cb);
28181}
28182
28183function addOnInit(cb) {
28184 __ATINIT__.unshift(cb);
28185}
28186
28187function addOnPreMain(cb) {
28188 __ATMAIN__.unshift(cb);
28189}
28190
28191function addOnExit(cb) {
28192}
28193
28194function addOnPostRun(cb) {
28195 __ATPOSTRUN__.unshift(cb);
28196}
28197
28198/** @param {number|boolean=} ignore */
28199function unSign(value, bits, ignore) {
28200 if (value >= 0) {
28201 return value;
28202 }
28203 return bits <= 32 ? 2*Math.abs(1 << (bits-1)) + value // Need some trickery, since if bits == 32, we are right at the limit of the bits JS uses in bitshifts
28204 : Math.pow(2, bits) + value;
28205}
28206/** @param {number|boolean=} ignore */
28207function reSign(value, bits, ignore) {
28208 if (value <= 0) {
28209 return value;
28210 }
28211 var half = bits <= 32 ? Math.abs(1 << (bits-1)) // abs is needed if bits == 32
28212 : Math.pow(2, bits-1);
28213 if (value >= half && (bits <= 32 || value > half)) { // for huge values, we can hit the precision limit and always get true here. so don't do that
28214 // but, in general there is no perfect solution here. With 64-bit ints, we get rounding and errors
28215 // TODO: In i64 mode 1, resign the two parts separately and safely
28216 value = -2*half + value; // Cannot bitshift half, as it may be at the limit of the bits JS uses in bitshifts
28217 }
28218 return value;
28219}
28220
28221
28222
28223
28224// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul
28225
28226// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/fround
28227
28228// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32
28229
28230// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc
28231
28232
28233var Math_abs = Math.abs;
28234var Math_cos = Math.cos;
28235var Math_sin = Math.sin;
28236var Math_tan = Math.tan;
28237var Math_acos = Math.acos;
28238var Math_asin = Math.asin;
28239var Math_atan = Math.atan;
28240var Math_atan2 = Math.atan2;
28241var Math_exp = Math.exp;
28242var Math_log = Math.log;
28243var Math_sqrt = Math.sqrt;
28244var Math_ceil = Math.ceil;
28245var Math_floor = Math.floor;
28246var Math_pow = Math.pow;
28247var Math_imul = Math.imul;
28248var Math_fround = Math.fround;
28249var Math_round = Math.round;
28250var Math_min = Math.min;
28251var Math_max = Math.max;
28252var Math_clz32 = Math.clz32;
28253var Math_trunc = Math.trunc;
28254
28255
28256
28257// A counter of dependencies for calling run(). If we need to
28258// do asynchronous work before running, increment this and
28259// decrement it. Incrementing must happen in a place like
28260// Module.preRun (used by emcc to add file preloading).
28261// Note that you can add dependencies in preRun, even though
28262// it happens right before run - run will be postponed until
28263// the dependencies are met.
28264var runDependencies = 0;
28265var runDependencyWatcher = null;
28266var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled
28267
28268function getUniqueRunDependency(id) {
28269 return id;
28270}
28271
28272function addRunDependency(id) {
28273 runDependencies++;
28274
28275 if (Module['monitorRunDependencies']) {
28276 Module['monitorRunDependencies'](runDependencies);
28277 }
28278
28279}
28280
28281function removeRunDependency(id) {
28282 runDependencies--;
28283
28284 if (Module['monitorRunDependencies']) {
28285 Module['monitorRunDependencies'](runDependencies);
28286 }
28287
28288 if (runDependencies == 0) {
28289 if (runDependencyWatcher !== null) {
28290 clearInterval(runDependencyWatcher);
28291 runDependencyWatcher = null;
28292 }
28293 if (dependenciesFulfilled) {
28294 var callback = dependenciesFulfilled;
28295 dependenciesFulfilled = null;
28296 callback(); // can add another dependenciesFulfilled
28297 }
28298 }
28299}
28300
28301Module["preloadedImages"] = {}; // maps url to image data
28302Module["preloadedAudios"] = {}; // maps url to audio data
28303
28304/** @param {string|number=} what */
28305function abort(what) {
28306 if (Module['onAbort']) {
28307 Module['onAbort'](what);
28308 }
28309
28310 what += '';
28311 out(what);
28312 err(what);
28313
28314 ABORT = true;
28315 EXITSTATUS = 1;
28316
28317 what = 'abort(' + what + '). Build with -s ASSERTIONS=1 for more info.';
28318
28319 // Throw a wasm runtime error, because a JS error might be seen as a foreign
28320 // exception, which means we'd run destructors on it. We need the error to
28321 // simply make the program stop.
28322 throw new WebAssembly.RuntimeError(what);
28323}
28324
28325
28326var memoryInitializer = null;
28327
28328
28329
28330
28331
28332
28333
28334
28335
28336
28337
28338
28339function hasPrefix(str, prefix) {
28340 return String.prototype.startsWith ?
28341 str.startsWith(prefix) :
28342 str.indexOf(prefix) === 0;
28343}
28344
28345// Prefix of data URIs emitted by SINGLE_FILE and related options.
28346var dataURIPrefix = 'data:application/octet-stream;base64,';
28347
28348// Indicates whether filename is a base64 data URI.
28349function isDataURI(filename) {
28350 return hasPrefix(filename, dataURIPrefix);
28351}
28352
28353var fileURIPrefix = "file://";
28354
28355// Indicates whether filename is delivered via file protocol (as opposed to http/https)
28356function isFileURI(filename) {
28357 return hasPrefix(filename, fileURIPrefix);
28358}
28359
28360
28361
28362
28363var wasmBinaryFile = 'libflac.wasm';
28364if (!isDataURI(wasmBinaryFile)) {
28365 wasmBinaryFile = locateFile(wasmBinaryFile);
28366}
28367
28368function getBinary() {
28369 try {
28370 if (wasmBinary) {
28371 return new Uint8Array(wasmBinary);
28372 }
28373
28374 var binary = tryParseAsDataURI(wasmBinaryFile);
28375 if (binary) {
28376 return binary;
28377 }
28378 if (readBinary) {
28379 return readBinary(wasmBinaryFile);
28380 } else {
28381 throw "both async and sync fetching of the wasm failed";
28382 }
28383 }
28384 catch (err) {
28385 abort(err);
28386 }
28387}
28388
28389function getBinaryPromise() {
28390 // If we don't have the binary yet, and have the Fetch api, use that;
28391 // in some environments, like Electron's render process, Fetch api may be present, but have a different context than expected, let's only use it on the Web
28392 if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) && typeof fetch === 'function'
28393 // Let's not use fetch to get objects over file:// as it's most likely Cordova which doesn't support fetch for file://
28394 && !isFileURI(wasmBinaryFile)
28395 ) {
28396 return fetch(wasmBinaryFile, { credentials: 'same-origin' }).then(function(response) {
28397 if (!response['ok']) {
28398 throw "failed to load wasm binary file at '" + wasmBinaryFile + "'";
28399 }
28400 return response['arrayBuffer']();
28401 }).catch(function () {
28402 return getBinary();
28403 });
28404 }
28405 // Otherwise, getBinary should be able to get it synchronously
28406 return new Promise(function(resolve, reject) {
28407 resolve(getBinary());
28408 });
28409}
28410
28411
28412
28413// Create the wasm instance.
28414// Receives the wasm imports, returns the exports.
28415function createWasm() {
28416 // prepare imports
28417 var info = {
28418 'env': asmLibraryArg,
28419 'wasi_snapshot_preview1': asmLibraryArg
28420 };
28421 // Load the wasm module and create an instance of using native support in the JS engine.
28422 // handle a generated wasm instance, receiving its exports and
28423 // performing other necessary setup
28424 /** @param {WebAssembly.Module=} module*/
28425 function receiveInstance(instance, module) {
28426 var exports = instance.exports;
28427 Module['asm'] = exports;
28428 removeRunDependency('wasm-instantiate');
28429 }
28430 // we can't run yet (except in a pthread, where we have a custom sync instantiator)
28431 addRunDependency('wasm-instantiate');
28432
28433
28434 function receiveInstantiatedSource(output) {
28435 // 'output' is a WebAssemblyInstantiatedSource object which has both the module and instance.
28436 // receiveInstance() will swap in the exports (to Module.asm) so they can be called
28437 // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line.
28438 // When the regression is fixed, can restore the above USE_PTHREADS-enabled path.
28439 receiveInstance(output['instance']);
28440 }
28441
28442
28443 function instantiateArrayBuffer(receiver) {
28444 return getBinaryPromise().then(function(binary) {
28445 return WebAssembly.instantiate(binary, info);
28446 }).then(receiver, function(reason) {
28447 err('failed to asynchronously prepare wasm: ' + reason);
28448
28449
28450 abort(reason);
28451 });
28452 }
28453
28454 // Prefer streaming instantiation if available.
28455 function instantiateAsync() {
28456 if (!wasmBinary &&
28457 typeof WebAssembly.instantiateStreaming === 'function' &&
28458 !isDataURI(wasmBinaryFile) &&
28459 // Don't use streaming for file:// delivered objects in a webview, fetch them synchronously.
28460 !isFileURI(wasmBinaryFile) &&
28461 typeof fetch === 'function') {
28462 fetch(wasmBinaryFile, { credentials: 'same-origin' }).then(function (response) {
28463 var result = WebAssembly.instantiateStreaming(response, info);
28464 return result.then(receiveInstantiatedSource, function(reason) {
28465 // We expect the most common failure cause to be a bad MIME type for the binary,
28466 // in which case falling back to ArrayBuffer instantiation should work.
28467 err('wasm streaming compile failed: ' + reason);
28468 err('falling back to ArrayBuffer instantiation');
28469 return instantiateArrayBuffer(receiveInstantiatedSource);
28470 });
28471 });
28472 } else {
28473 return instantiateArrayBuffer(receiveInstantiatedSource);
28474 }
28475 }
28476 // User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback
28477 // to manually instantiate the Wasm module themselves. This allows pages to run the instantiation parallel
28478 // to any other async startup actions they are performing.
28479 if (Module['instantiateWasm']) {
28480 try {
28481 var exports = Module['instantiateWasm'](info, receiveInstance);
28482 return exports;
28483 } catch(e) {
28484 err('Module.instantiateWasm callback failed with error: ' + e);
28485 return false;
28486 }
28487 }
28488
28489 instantiateAsync();
28490 return {}; // no exports yet; we'll fill them in later
28491}
28492
28493
28494// Globals used by JS i64 conversions
28495var tempDouble;
28496var tempI64;
28497
28498// === Body ===
28499
28500var ASM_CONSTS = {
28501
28502};
28503
28504
28505
28506
28507// STATICTOP = STATIC_BASE + 13312;
28508/* global initializers */ __ATINIT__.push({ func: function() { ___wasm_call_ctors() } });
28509
28510
28511
28512
28513/* no memory initializer */
28514// {{PRE_LIBRARY}}
28515
28516
28517 function demangle(func) {
28518 return func;
28519 }
28520
28521 function demangleAll(text) {
28522 var regex =
28523 /\b_Z[\w\d_]+/g;
28524 return text.replace(regex,
28525 function(x) {
28526 var y = demangle(x);
28527 return x === y ? x : (y + ' [' + x + ']');
28528 });
28529 }
28530
28531 function jsStackTrace() {
28532 var err = new Error();
28533 if (!err.stack) {
28534 // IE10+ special cases: It does have callstack info, but it is only populated if an Error object is thrown,
28535 // so try that as a special-case.
28536 try {
28537 throw new Error();
28538 } catch(e) {
28539 err = e;
28540 }
28541 if (!err.stack) {
28542 return '(no stack trace available)';
28543 }
28544 }
28545 return err.stack.toString();
28546 }
28547
28548 function stackTrace() {
28549 var js = jsStackTrace();
28550 if (Module['extraStackTrace']) js += '\n' + Module['extraStackTrace']();
28551 return demangleAll(js);
28552 }
28553
28554 function _emscripten_get_sbrk_ptr() {
28555 return 14176;
28556 }
28557
28558 function _emscripten_memcpy_big(dest, src, num) {
28559 HEAPU8.copyWithin(dest, src, src + num);
28560 }
28561
28562
28563 function _emscripten_get_heap_size() {
28564 return HEAPU8.length;
28565 }
28566
28567 function emscripten_realloc_buffer(size) {
28568 try {
28569 // round size grow request up to wasm page size (fixed 64KB per spec)
28570 wasmMemory.grow((size - buffer.byteLength + 65535) >>> 16); // .grow() takes a delta compared to the previous size
28571 updateGlobalBufferAndViews(wasmMemory.buffer);
28572 return 1 /*success*/;
28573 } catch(e) {
28574 }
28575 }function _emscripten_resize_heap(requestedSize) {
28576 requestedSize = requestedSize >>> 0;
28577 var oldSize = _emscripten_get_heap_size();
28578 // With pthreads, races can happen (another thread might increase the size in between), so return a failure, and let the caller retry.
28579
28580
28581 var PAGE_MULTIPLE = 65536;
28582
28583 // Memory resize rules:
28584 // 1. When resizing, always produce a resized heap that is at least 16MB (to avoid tiny heap sizes receiving lots of repeated resizes at startup)
28585 // 2. Always increase heap size to at least the requested size, rounded up to next page multiple.
28586 // 3a. If MEMORY_GROWTH_LINEAR_STEP == -1, excessively resize the heap geometrically: increase the heap size according to
28587 // MEMORY_GROWTH_GEOMETRIC_STEP factor (default +20%),
28588 // At most overreserve by MEMORY_GROWTH_GEOMETRIC_CAP bytes (default 96MB).
28589 // 3b. If MEMORY_GROWTH_LINEAR_STEP != -1, excessively resize the heap linearly: increase the heap size by at least MEMORY_GROWTH_LINEAR_STEP bytes.
28590 // 4. Max size for the heap is capped at 2048MB-PAGE_MULTIPLE, or by MAXIMUM_MEMORY, or by ASAN limit, depending on which is smallest
28591 // 5. If we were unable to allocate as much memory, it may be due to over-eager decision to excessively reserve due to (3) above.
28592 // Hence if an allocation fails, cut down on the amount of excess growth, in an attempt to succeed to perform a smaller allocation.
28593
28594 // A limit was set for how much we can grow. We should not exceed that
28595 // (the wasm binary specifies it, so if we tried, we'd fail anyhow).
28596 var maxHeapSize = 2147483648;
28597 if (requestedSize > maxHeapSize) {
28598 return false;
28599 }
28600
28601 var minHeapSize = 16777216;
28602
28603 // Loop through potential heap size increases. If we attempt a too eager reservation that fails, cut down on the
28604 // attempted size and reserve a smaller bump instead. (max 3 times, chosen somewhat arbitrarily)
28605 for(var cutDown = 1; cutDown <= 4; cutDown *= 2) {
28606 var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown); // ensure geometric growth
28607 // but limit overreserving (default to capping at +96MB overgrowth at most)
28608 overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296 );
28609
28610
28611 var newSize = Math.min(maxHeapSize, alignUp(Math.max(minHeapSize, requestedSize, overGrownHeapSize), PAGE_MULTIPLE));
28612
28613 var replacement = emscripten_realloc_buffer(newSize);
28614 if (replacement) {
28615
28616 return true;
28617 }
28618 }
28619 return false;
28620 }
28621
28622
28623
28624 var PATH={splitPath:function(filename) {
28625 var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
28626 return splitPathRe.exec(filename).slice(1);
28627 },normalizeArray:function(parts, allowAboveRoot) {
28628 // if the path tries to go above the root, `up` ends up > 0
28629 var up = 0;
28630 for (var i = parts.length - 1; i >= 0; i--) {
28631 var last = parts[i];
28632 if (last === '.') {
28633 parts.splice(i, 1);
28634 } else if (last === '..') {
28635 parts.splice(i, 1);
28636 up++;
28637 } else if (up) {
28638 parts.splice(i, 1);
28639 up--;
28640 }
28641 }
28642 // if the path is allowed to go above the root, restore leading ..s
28643 if (allowAboveRoot) {
28644 for (; up; up--) {
28645 parts.unshift('..');
28646 }
28647 }
28648 return parts;
28649 },normalize:function(path) {
28650 var isAbsolute = path.charAt(0) === '/',
28651 trailingSlash = path.substr(-1) === '/';
28652 // Normalize the path
28653 path = PATH.normalizeArray(path.split('/').filter(function(p) {
28654 return !!p;
28655 }), !isAbsolute).join('/');
28656 if (!path && !isAbsolute) {
28657 path = '.';
28658 }
28659 if (path && trailingSlash) {
28660 path += '/';
28661 }
28662 return (isAbsolute ? '/' : '') + path;
28663 },dirname:function(path) {
28664 var result = PATH.splitPath(path),
28665 root = result[0],
28666 dir = result[1];
28667 if (!root && !dir) {
28668 // No dirname whatsoever
28669 return '.';
28670 }
28671 if (dir) {
28672 // It has a dirname, strip trailing slash
28673 dir = dir.substr(0, dir.length - 1);
28674 }
28675 return root + dir;
28676 },basename:function(path) {
28677 // EMSCRIPTEN return '/'' for '/', not an empty string
28678 if (path === '/') return '/';
28679 var lastSlash = path.lastIndexOf('/');
28680 if (lastSlash === -1) return path;
28681 return path.substr(lastSlash+1);
28682 },extname:function(path) {
28683 return PATH.splitPath(path)[3];
28684 },join:function() {
28685 var paths = Array.prototype.slice.call(arguments, 0);
28686 return PATH.normalize(paths.join('/'));
28687 },join2:function(l, r) {
28688 return PATH.normalize(l + '/' + r);
28689 }};
28690
28691
28692 function setErrNo(value) {
28693 HEAP32[((___errno_location())>>2)]=value;
28694 return value;
28695 }
28696
28697 var PATH_FS={resolve:function() {
28698 var resolvedPath = '',
28699 resolvedAbsolute = false;
28700 for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
28701 var path = (i >= 0) ? arguments[i] : FS.cwd();
28702 // Skip empty and invalid entries
28703 if (typeof path !== 'string') {
28704 throw new TypeError('Arguments to path.resolve must be strings');
28705 } else if (!path) {
28706 return ''; // an invalid portion invalidates the whole thing
28707 }
28708 resolvedPath = path + '/' + resolvedPath;
28709 resolvedAbsolute = path.charAt(0) === '/';
28710 }
28711 // At this point the path should be resolved to a full absolute path, but
28712 // handle relative paths to be safe (might happen when process.cwd() fails)
28713 resolvedPath = PATH.normalizeArray(resolvedPath.split('/').filter(function(p) {
28714 return !!p;
28715 }), !resolvedAbsolute).join('/');
28716 return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
28717 },relative:function(from, to) {
28718 from = PATH_FS.resolve(from).substr(1);
28719 to = PATH_FS.resolve(to).substr(1);
28720 function trim(arr) {
28721 var start = 0;
28722 for (; start < arr.length; start++) {
28723 if (arr[start] !== '') break;
28724 }
28725 var end = arr.length - 1;
28726 for (; end >= 0; end--) {
28727 if (arr[end] !== '') break;
28728 }
28729 if (start > end) return [];
28730 return arr.slice(start, end - start + 1);
28731 }
28732 var fromParts = trim(from.split('/'));
28733 var toParts = trim(to.split('/'));
28734 var length = Math.min(fromParts.length, toParts.length);
28735 var samePartsLength = length;
28736 for (var i = 0; i < length; i++) {
28737 if (fromParts[i] !== toParts[i]) {
28738 samePartsLength = i;
28739 break;
28740 }
28741 }
28742 var outputParts = [];
28743 for (var i = samePartsLength; i < fromParts.length; i++) {
28744 outputParts.push('..');
28745 }
28746 outputParts = outputParts.concat(toParts.slice(samePartsLength));
28747 return outputParts.join('/');
28748 }};
28749
28750 var TTY={ttys:[],init:function () {
28751 // https://github.com/emscripten-core/emscripten/pull/1555
28752 // if (ENVIRONMENT_IS_NODE) {
28753 // // currently, FS.init does not distinguish if process.stdin is a file or TTY
28754 // // device, it always assumes it's a TTY device. because of this, we're forcing
28755 // // process.stdin to UTF8 encoding to at least make stdin reading compatible
28756 // // with text files until FS.init can be refactored.
28757 // process['stdin']['setEncoding']('utf8');
28758 // }
28759 },shutdown:function() {
28760 // https://github.com/emscripten-core/emscripten/pull/1555
28761 // if (ENVIRONMENT_IS_NODE) {
28762 // // inolen: any idea as to why node -e 'process.stdin.read()' wouldn't exit immediately (with process.stdin being a tty)?
28763 // // isaacs: because now it's reading from the stream, you've expressed interest in it, so that read() kicks off a _read() which creates a ReadReq operation
28764 // // inolen: I thought read() in that case was a synchronous operation that just grabbed some amount of buffered data if it exists?
28765 // // isaacs: it is. but it also triggers a _read() call, which calls readStart() on the handle
28766 // // isaacs: do process.stdin.pause() and i'd think it'd probably close the pending call
28767 // process['stdin']['pause']();
28768 // }
28769 },register:function(dev, ops) {
28770 TTY.ttys[dev] = { input: [], output: [], ops: ops };
28771 FS.registerDevice(dev, TTY.stream_ops);
28772 },stream_ops:{open:function(stream) {
28773 var tty = TTY.ttys[stream.node.rdev];
28774 if (!tty) {
28775 throw new FS.ErrnoError(43);
28776 }
28777 stream.tty = tty;
28778 stream.seekable = false;
28779 },close:function(stream) {
28780 // flush any pending line data
28781 stream.tty.ops.flush(stream.tty);
28782 },flush:function(stream) {
28783 stream.tty.ops.flush(stream.tty);
28784 },read:function(stream, buffer, offset, length, pos /* ignored */) {
28785 if (!stream.tty || !stream.tty.ops.get_char) {
28786 throw new FS.ErrnoError(60);
28787 }
28788 var bytesRead = 0;
28789 for (var i = 0; i < length; i++) {
28790 var result;
28791 try {
28792 result = stream.tty.ops.get_char(stream.tty);
28793 } catch (e) {
28794 throw new FS.ErrnoError(29);
28795 }
28796 if (result === undefined && bytesRead === 0) {
28797 throw new FS.ErrnoError(6);
28798 }
28799 if (result === null || result === undefined) break;
28800 bytesRead++;
28801 buffer[offset+i] = result;
28802 }
28803 if (bytesRead) {
28804 stream.node.timestamp = Date.now();
28805 }
28806 return bytesRead;
28807 },write:function(stream, buffer, offset, length, pos) {
28808 if (!stream.tty || !stream.tty.ops.put_char) {
28809 throw new FS.ErrnoError(60);
28810 }
28811 try {
28812 for (var i = 0; i < length; i++) {
28813 stream.tty.ops.put_char(stream.tty, buffer[offset+i]);
28814 }
28815 } catch (e) {
28816 throw new FS.ErrnoError(29);
28817 }
28818 if (length) {
28819 stream.node.timestamp = Date.now();
28820 }
28821 return i;
28822 }},default_tty_ops:{get_char:function(tty) {
28823 if (!tty.input.length) {
28824 var result = null;
28825 if (ENVIRONMENT_IS_NODE) {
28826 // we will read data by chunks of BUFSIZE
28827 var BUFSIZE = 256;
28828 var buf = Buffer.alloc ? Buffer.alloc(BUFSIZE) : new Buffer(BUFSIZE);
28829 var bytesRead = 0;
28830
28831 try {
28832 bytesRead = nodeFS.readSync(process.stdin.fd, buf, 0, BUFSIZE, null);
28833 } catch(e) {
28834 // Cross-platform differences: on Windows, reading EOF throws an exception, but on other OSes,
28835 // reading EOF returns 0. Uniformize behavior by treating the EOF exception to return 0.
28836 if (e.toString().indexOf('EOF') != -1) bytesRead = 0;
28837 else throw e;
28838 }
28839
28840 if (bytesRead > 0) {
28841 result = buf.slice(0, bytesRead).toString('utf-8');
28842 } else {
28843 result = null;
28844 }
28845 } else
28846 if (typeof window != 'undefined' &&
28847 typeof window.prompt == 'function') {
28848 // Browser.
28849 result = window.prompt('Input: '); // returns null on cancel
28850 if (result !== null) {
28851 result += '\n';
28852 }
28853 } else if (typeof readline == 'function') {
28854 // Command line.
28855 result = readline();
28856 if (result !== null) {
28857 result += '\n';
28858 }
28859 }
28860 if (!result) {
28861 return null;
28862 }
28863 tty.input = intArrayFromString(result, true);
28864 }
28865 return tty.input.shift();
28866 },put_char:function(tty, val) {
28867 if (val === null || val === 10) {
28868 out(UTF8ArrayToString(tty.output, 0));
28869 tty.output = [];
28870 } else {
28871 if (val != 0) tty.output.push(val); // val == 0 would cut text output off in the middle.
28872 }
28873 },flush:function(tty) {
28874 if (tty.output && tty.output.length > 0) {
28875 out(UTF8ArrayToString(tty.output, 0));
28876 tty.output = [];
28877 }
28878 }},default_tty1_ops:{put_char:function(tty, val) {
28879 if (val === null || val === 10) {
28880 err(UTF8ArrayToString(tty.output, 0));
28881 tty.output = [];
28882 } else {
28883 if (val != 0) tty.output.push(val);
28884 }
28885 },flush:function(tty) {
28886 if (tty.output && tty.output.length > 0) {
28887 err(UTF8ArrayToString(tty.output, 0));
28888 tty.output = [];
28889 }
28890 }}};
28891
28892 var MEMFS={ops_table:null,mount:function(mount) {
28893 return MEMFS.createNode(null, '/', 16384 | 511 /* 0777 */, 0);
28894 },createNode:function(parent, name, mode, dev) {
28895 if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
28896 // no supported
28897 throw new FS.ErrnoError(63);
28898 }
28899 if (!MEMFS.ops_table) {
28900 MEMFS.ops_table = {
28901 dir: {
28902 node: {
28903 getattr: MEMFS.node_ops.getattr,
28904 setattr: MEMFS.node_ops.setattr,
28905 lookup: MEMFS.node_ops.lookup,
28906 mknod: MEMFS.node_ops.mknod,
28907 rename: MEMFS.node_ops.rename,
28908 unlink: MEMFS.node_ops.unlink,
28909 rmdir: MEMFS.node_ops.rmdir,
28910 readdir: MEMFS.node_ops.readdir,
28911 symlink: MEMFS.node_ops.symlink
28912 },
28913 stream: {
28914 llseek: MEMFS.stream_ops.llseek
28915 }
28916 },
28917 file: {
28918 node: {
28919 getattr: MEMFS.node_ops.getattr,
28920 setattr: MEMFS.node_ops.setattr
28921 },
28922 stream: {
28923 llseek: MEMFS.stream_ops.llseek,
28924 read: MEMFS.stream_ops.read,
28925 write: MEMFS.stream_ops.write,
28926 allocate: MEMFS.stream_ops.allocate,
28927 mmap: MEMFS.stream_ops.mmap,
28928 msync: MEMFS.stream_ops.msync
28929 }
28930 },
28931 link: {
28932 node: {
28933 getattr: MEMFS.node_ops.getattr,
28934 setattr: MEMFS.node_ops.setattr,
28935 readlink: MEMFS.node_ops.readlink
28936 },
28937 stream: {}
28938 },
28939 chrdev: {
28940 node: {
28941 getattr: MEMFS.node_ops.getattr,
28942 setattr: MEMFS.node_ops.setattr
28943 },
28944 stream: FS.chrdev_stream_ops
28945 }
28946 };
28947 }
28948 var node = FS.createNode(parent, name, mode, dev);
28949 if (FS.isDir(node.mode)) {
28950 node.node_ops = MEMFS.ops_table.dir.node;
28951 node.stream_ops = MEMFS.ops_table.dir.stream;
28952 node.contents = {};
28953 } else if (FS.isFile(node.mode)) {
28954 node.node_ops = MEMFS.ops_table.file.node;
28955 node.stream_ops = MEMFS.ops_table.file.stream;
28956 node.usedBytes = 0; // The actual number of bytes used in the typed array, as opposed to contents.length which gives the whole capacity.
28957 // When the byte data of the file is populated, this will point to either a typed array, or a normal JS array. Typed arrays are preferred
28958 // for performance, and used by default. However, typed arrays are not resizable like normal JS arrays are, so there is a small disk size
28959 // penalty involved for appending file writes that continuously grow a file similar to std::vector capacity vs used -scheme.
28960 node.contents = null;
28961 } else if (FS.isLink(node.mode)) {
28962 node.node_ops = MEMFS.ops_table.link.node;
28963 node.stream_ops = MEMFS.ops_table.link.stream;
28964 } else if (FS.isChrdev(node.mode)) {
28965 node.node_ops = MEMFS.ops_table.chrdev.node;
28966 node.stream_ops = MEMFS.ops_table.chrdev.stream;
28967 }
28968 node.timestamp = Date.now();
28969 // add the new node to the parent
28970 if (parent) {
28971 parent.contents[name] = node;
28972 }
28973 return node;
28974 },getFileDataAsRegularArray:function(node) {
28975 if (node.contents && node.contents.subarray) {
28976 var arr = [];
28977 for (var i = 0; i < node.usedBytes; ++i) arr.push(node.contents[i]);
28978 return arr; // Returns a copy of the original data.
28979 }
28980 return node.contents; // No-op, the file contents are already in a JS array. Return as-is.
28981 },getFileDataAsTypedArray:function(node) {
28982 if (!node.contents) return new Uint8Array(0);
28983 if (node.contents.subarray) return node.contents.subarray(0, node.usedBytes); // Make sure to not return excess unused bytes.
28984 return new Uint8Array(node.contents);
28985 },expandFileStorage:function(node, newCapacity) {
28986 var prevCapacity = node.contents ? node.contents.length : 0;
28987 if (prevCapacity >= newCapacity) return; // No need to expand, the storage was already large enough.
28988 // Don't expand strictly to the given requested limit if it's only a very small increase, but instead geometrically grow capacity.
28989 // For small filesizes (<1MB), perform size*2 geometric increase, but for large sizes, do a much more conservative size*1.125 increase to
28990 // avoid overshooting the allocation cap by a very large margin.
28991 var CAPACITY_DOUBLING_MAX = 1024 * 1024;
28992 newCapacity = Math.max(newCapacity, (prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2.0 : 1.125)) >>> 0);
28993 if (prevCapacity != 0) newCapacity = Math.max(newCapacity, 256); // At minimum allocate 256b for each file when expanding.
28994 var oldContents = node.contents;
28995 node.contents = new Uint8Array(newCapacity); // Allocate new storage.
28996 if (node.usedBytes > 0) node.contents.set(oldContents.subarray(0, node.usedBytes), 0); // Copy old data over to the new storage.
28997 return;
28998 },resizeFileStorage:function(node, newSize) {
28999 if (node.usedBytes == newSize) return;
29000 if (newSize == 0) {
29001 node.contents = null; // Fully decommit when requesting a resize to zero.
29002 node.usedBytes = 0;
29003 return;
29004 }
29005 if (!node.contents || node.contents.subarray) { // Resize a typed array if that is being used as the backing store.
29006 var oldContents = node.contents;
29007 node.contents = new Uint8Array(newSize); // Allocate new storage.
29008 if (oldContents) {
29009 node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes))); // Copy old data over to the new storage.
29010 }
29011 node.usedBytes = newSize;
29012 return;
29013 }
29014 // Backing with a JS array.
29015 if (!node.contents) node.contents = [];
29016 if (node.contents.length > newSize) node.contents.length = newSize;
29017 else while (node.contents.length < newSize) node.contents.push(0);
29018 node.usedBytes = newSize;
29019 },node_ops:{getattr:function(node) {
29020 var attr = {};
29021 // device numbers reuse inode numbers.
29022 attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
29023 attr.ino = node.id;
29024 attr.mode = node.mode;
29025 attr.nlink = 1;
29026 attr.uid = 0;
29027 attr.gid = 0;
29028 attr.rdev = node.rdev;
29029 if (FS.isDir(node.mode)) {
29030 attr.size = 4096;
29031 } else if (FS.isFile(node.mode)) {
29032 attr.size = node.usedBytes;
29033 } else if (FS.isLink(node.mode)) {
29034 attr.size = node.link.length;
29035 } else {
29036 attr.size = 0;
29037 }
29038 attr.atime = new Date(node.timestamp);
29039 attr.mtime = new Date(node.timestamp);
29040 attr.ctime = new Date(node.timestamp);
29041 // NOTE: In our implementation, st_blocks = Math.ceil(st_size/st_blksize),
29042 // but this is not required by the standard.
29043 attr.blksize = 4096;
29044 attr.blocks = Math.ceil(attr.size / attr.blksize);
29045 return attr;
29046 },setattr:function(node, attr) {
29047 if (attr.mode !== undefined) {
29048 node.mode = attr.mode;
29049 }
29050 if (attr.timestamp !== undefined) {
29051 node.timestamp = attr.timestamp;
29052 }
29053 if (attr.size !== undefined) {
29054 MEMFS.resizeFileStorage(node, attr.size);
29055 }
29056 },lookup:function(parent, name) {
29057 throw FS.genericErrors[44];
29058 },mknod:function(parent, name, mode, dev) {
29059 return MEMFS.createNode(parent, name, mode, dev);
29060 },rename:function(old_node, new_dir, new_name) {
29061 // if we're overwriting a directory at new_name, make sure it's empty.
29062 if (FS.isDir(old_node.mode)) {
29063 var new_node;
29064 try {
29065 new_node = FS.lookupNode(new_dir, new_name);
29066 } catch (e) {
29067 }
29068 if (new_node) {
29069 for (var i in new_node.contents) {
29070 throw new FS.ErrnoError(55);
29071 }
29072 }
29073 }
29074 // do the internal rewiring
29075 delete old_node.parent.contents[old_node.name];
29076 old_node.name = new_name;
29077 new_dir.contents[new_name] = old_node;
29078 old_node.parent = new_dir;
29079 },unlink:function(parent, name) {
29080 delete parent.contents[name];
29081 },rmdir:function(parent, name) {
29082 var node = FS.lookupNode(parent, name);
29083 for (var i in node.contents) {
29084 throw new FS.ErrnoError(55);
29085 }
29086 delete parent.contents[name];
29087 },readdir:function(node) {
29088 var entries = ['.', '..'];
29089 for (var key in node.contents) {
29090 if (!node.contents.hasOwnProperty(key)) {
29091 continue;
29092 }
29093 entries.push(key);
29094 }
29095 return entries;
29096 },symlink:function(parent, newname, oldpath) {
29097 var node = MEMFS.createNode(parent, newname, 511 /* 0777 */ | 40960, 0);
29098 node.link = oldpath;
29099 return node;
29100 },readlink:function(node) {
29101 if (!FS.isLink(node.mode)) {
29102 throw new FS.ErrnoError(28);
29103 }
29104 return node.link;
29105 }},stream_ops:{read:function(stream, buffer, offset, length, position) {
29106 var contents = stream.node.contents;
29107 if (position >= stream.node.usedBytes) return 0;
29108 var size = Math.min(stream.node.usedBytes - position, length);
29109 if (size > 8 && contents.subarray) { // non-trivial, and typed array
29110 buffer.set(contents.subarray(position, position + size), offset);
29111 } else {
29112 for (var i = 0; i < size; i++) buffer[offset + i] = contents[position + i];
29113 }
29114 return size;
29115 },write:function(stream, buffer, offset, length, position, canOwn) {
29116 // If the buffer is located in main memory (HEAP), and if
29117 // memory can grow, we can't hold on to references of the
29118 // memory buffer, as they may get invalidated. That means we
29119 // need to do copy its contents.
29120 if (buffer.buffer === HEAP8.buffer) {
29121 canOwn = false;
29122 }
29123
29124 if (!length) return 0;
29125 var node = stream.node;
29126 node.timestamp = Date.now();
29127
29128 if (buffer.subarray && (!node.contents || node.contents.subarray)) { // This write is from a typed array to a typed array?
29129 if (canOwn) {
29130 node.contents = buffer.subarray(offset, offset + length);
29131 node.usedBytes = length;
29132 return length;
29133 } else if (node.usedBytes === 0 && position === 0) { // If this is a simple first write to an empty file, do a fast set since we don't need to care about old data.
29134 node.contents = buffer.slice(offset, offset + length);
29135 node.usedBytes = length;
29136 return length;
29137 } else if (position + length <= node.usedBytes) { // Writing to an already allocated and used subrange of the file?
29138 node.contents.set(buffer.subarray(offset, offset + length), position);
29139 return length;
29140 }
29141 }
29142
29143 // Appending to an existing file and we need to reallocate, or source data did not come as a typed array.
29144 MEMFS.expandFileStorage(node, position+length);
29145 if (node.contents.subarray && buffer.subarray) node.contents.set(buffer.subarray(offset, offset + length), position); // Use typed array write if available.
29146 else {
29147 for (var i = 0; i < length; i++) {
29148 node.contents[position + i] = buffer[offset + i]; // Or fall back to manual write if not.
29149 }
29150 }
29151 node.usedBytes = Math.max(node.usedBytes, position + length);
29152 return length;
29153 },llseek:function(stream, offset, whence) {
29154 var position = offset;
29155 if (whence === 1) {
29156 position += stream.position;
29157 } else if (whence === 2) {
29158 if (FS.isFile(stream.node.mode)) {
29159 position += stream.node.usedBytes;
29160 }
29161 }
29162 if (position < 0) {
29163 throw new FS.ErrnoError(28);
29164 }
29165 return position;
29166 },allocate:function(stream, offset, length) {
29167 MEMFS.expandFileStorage(stream.node, offset + length);
29168 stream.node.usedBytes = Math.max(stream.node.usedBytes, offset + length);
29169 },mmap:function(stream, address, length, position, prot, flags) {
29170 // We don't currently support location hints for the address of the mapping
29171 assert(address === 0);
29172
29173 if (!FS.isFile(stream.node.mode)) {
29174 throw new FS.ErrnoError(43);
29175 }
29176 var ptr;
29177 var allocated;
29178 var contents = stream.node.contents;
29179 // Only make a new copy when MAP_PRIVATE is specified.
29180 if (!(flags & 2) && contents.buffer === buffer) {
29181 // We can't emulate MAP_SHARED when the file is not backed by the buffer
29182 // we're mapping to (e.g. the HEAP buffer).
29183 allocated = false;
29184 ptr = contents.byteOffset;
29185 } else {
29186 // Try to avoid unnecessary slices.
29187 if (position > 0 || position + length < contents.length) {
29188 if (contents.subarray) {
29189 contents = contents.subarray(position, position + length);
29190 } else {
29191 contents = Array.prototype.slice.call(contents, position, position + length);
29192 }
29193 }
29194 allocated = true;
29195 ptr = _malloc(length);
29196 if (!ptr) {
29197 throw new FS.ErrnoError(48);
29198 }
29199 HEAP8.set(contents, ptr);
29200 }
29201 return { ptr: ptr, allocated: allocated };
29202 },msync:function(stream, buffer, offset, length, mmapFlags) {
29203 if (!FS.isFile(stream.node.mode)) {
29204 throw new FS.ErrnoError(43);
29205 }
29206 if (mmapFlags & 2) {
29207 // MAP_PRIVATE calls need not to be synced back to underlying fs
29208 return 0;
29209 }
29210
29211 var bytesWritten = MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false);
29212 // should we check if bytesWritten and length are the same?
29213 return 0;
29214 }}};var FS={root:null,mounts:[],devices:{},streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,trackingDelegate:{},tracking:{openFlags:{READ:1,WRITE:2}},ErrnoError:null,genericErrors:{},filesystems:null,syncFSRequests:0,handleFSError:function(e) {
29215 if (!(e instanceof FS.ErrnoError)) throw e + ' : ' + stackTrace();
29216 return setErrNo(e.errno);
29217 },lookupPath:function(path, opts) {
29218 path = PATH_FS.resolve(FS.cwd(), path);
29219 opts = opts || {};
29220
29221 if (!path) return { path: '', node: null };
29222
29223 var defaults = {
29224 follow_mount: true,
29225 recurse_count: 0
29226 };
29227 for (var key in defaults) {
29228 if (opts[key] === undefined) {
29229 opts[key] = defaults[key];
29230 }
29231 }
29232
29233 if (opts.recurse_count > 8) { // max recursive lookup of 8
29234 throw new FS.ErrnoError(32);
29235 }
29236
29237 // split the path
29238 var parts = PATH.normalizeArray(path.split('/').filter(function(p) {
29239 return !!p;
29240 }), false);
29241
29242 // start at the root
29243 var current = FS.root;
29244 var current_path = '/';
29245
29246 for (var i = 0; i < parts.length; i++) {
29247 var islast = (i === parts.length-1);
29248 if (islast && opts.parent) {
29249 // stop resolving
29250 break;
29251 }
29252
29253 current = FS.lookupNode(current, parts[i]);
29254 current_path = PATH.join2(current_path, parts[i]);
29255
29256 // jump to the mount's root node if this is a mountpoint
29257 if (FS.isMountpoint(current)) {
29258 if (!islast || (islast && opts.follow_mount)) {
29259 current = current.mounted.root;
29260 }
29261 }
29262
29263 // by default, lookupPath will not follow a symlink if it is the final path component.
29264 // setting opts.follow = true will override this behavior.
29265 if (!islast || opts.follow) {
29266 var count = 0;
29267 while (FS.isLink(current.mode)) {
29268 var link = FS.readlink(current_path);
29269 current_path = PATH_FS.resolve(PATH.dirname(current_path), link);
29270
29271 var lookup = FS.lookupPath(current_path, { recurse_count: opts.recurse_count });
29272 current = lookup.node;
29273
29274 if (count++ > 40) { // limit max consecutive symlinks to 40 (SYMLOOP_MAX).
29275 throw new FS.ErrnoError(32);
29276 }
29277 }
29278 }
29279 }
29280
29281 return { path: current_path, node: current };
29282 },getPath:function(node) {
29283 var path;
29284 while (true) {
29285 if (FS.isRoot(node)) {
29286 var mount = node.mount.mountpoint;
29287 if (!path) return mount;
29288 return mount[mount.length-1] !== '/' ? mount + '/' + path : mount + path;
29289 }
29290 path = path ? node.name + '/' + path : node.name;
29291 node = node.parent;
29292 }
29293 },hashName:function(parentid, name) {
29294 var hash = 0;
29295
29296
29297 for (var i = 0; i < name.length; i++) {
29298 hash = ((hash << 5) - hash + name.charCodeAt(i)) | 0;
29299 }
29300 return ((parentid + hash) >>> 0) % FS.nameTable.length;
29301 },hashAddNode:function(node) {
29302 var hash = FS.hashName(node.parent.id, node.name);
29303 node.name_next = FS.nameTable[hash];
29304 FS.nameTable[hash] = node;
29305 },hashRemoveNode:function(node) {
29306 var hash = FS.hashName(node.parent.id, node.name);
29307 if (FS.nameTable[hash] === node) {
29308 FS.nameTable[hash] = node.name_next;
29309 } else {
29310 var current = FS.nameTable[hash];
29311 while (current) {
29312 if (current.name_next === node) {
29313 current.name_next = node.name_next;
29314 break;
29315 }
29316 current = current.name_next;
29317 }
29318 }
29319 },lookupNode:function(parent, name) {
29320 var errCode = FS.mayLookup(parent);
29321 if (errCode) {
29322 throw new FS.ErrnoError(errCode, parent);
29323 }
29324 var hash = FS.hashName(parent.id, name);
29325 for (var node = FS.nameTable[hash]; node; node = node.name_next) {
29326 var nodeName = node.name;
29327 if (node.parent.id === parent.id && nodeName === name) {
29328 return node;
29329 }
29330 }
29331 // if we failed to find it in the cache, call into the VFS
29332 return FS.lookup(parent, name);
29333 },createNode:function(parent, name, mode, rdev) {
29334 var node = new FS.FSNode(parent, name, mode, rdev);
29335
29336 FS.hashAddNode(node);
29337
29338 return node;
29339 },destroyNode:function(node) {
29340 FS.hashRemoveNode(node);
29341 },isRoot:function(node) {
29342 return node === node.parent;
29343 },isMountpoint:function(node) {
29344 return !!node.mounted;
29345 },isFile:function(mode) {
29346 return (mode & 61440) === 32768;
29347 },isDir:function(mode) {
29348 return (mode & 61440) === 16384;
29349 },isLink:function(mode) {
29350 return (mode & 61440) === 40960;
29351 },isChrdev:function(mode) {
29352 return (mode & 61440) === 8192;
29353 },isBlkdev:function(mode) {
29354 return (mode & 61440) === 24576;
29355 },isFIFO:function(mode) {
29356 return (mode & 61440) === 4096;
29357 },isSocket:function(mode) {
29358 return (mode & 49152) === 49152;
29359 },flagModes:{"r":0,"rs":1052672,"r+":2,"w":577,"wx":705,"xw":705,"w+":578,"wx+":706,"xw+":706,"a":1089,"ax":1217,"xa":1217,"a+":1090,"ax+":1218,"xa+":1218},modeStringToFlags:function(str) {
29360 var flags = FS.flagModes[str];
29361 if (typeof flags === 'undefined') {
29362 throw new Error('Unknown file open mode: ' + str);
29363 }
29364 return flags;
29365 },flagsToPermissionString:function(flag) {
29366 var perms = ['r', 'w', 'rw'][flag & 3];
29367 if ((flag & 512)) {
29368 perms += 'w';
29369 }
29370 return perms;
29371 },nodePermissions:function(node, perms) {
29372 if (FS.ignorePermissions) {
29373 return 0;
29374 }
29375 // return 0 if any user, group or owner bits are set.
29376 if (perms.indexOf('r') !== -1 && !(node.mode & 292)) {
29377 return 2;
29378 } else if (perms.indexOf('w') !== -1 && !(node.mode & 146)) {
29379 return 2;
29380 } else if (perms.indexOf('x') !== -1 && !(node.mode & 73)) {
29381 return 2;
29382 }
29383 return 0;
29384 },mayLookup:function(dir) {
29385 var errCode = FS.nodePermissions(dir, 'x');
29386 if (errCode) return errCode;
29387 if (!dir.node_ops.lookup) return 2;
29388 return 0;
29389 },mayCreate:function(dir, name) {
29390 try {
29391 var node = FS.lookupNode(dir, name);
29392 return 20;
29393 } catch (e) {
29394 }
29395 return FS.nodePermissions(dir, 'wx');
29396 },mayDelete:function(dir, name, isdir) {
29397 var node;
29398 try {
29399 node = FS.lookupNode(dir, name);
29400 } catch (e) {
29401 return e.errno;
29402 }
29403 var errCode = FS.nodePermissions(dir, 'wx');
29404 if (errCode) {
29405 return errCode;
29406 }
29407 if (isdir) {
29408 if (!FS.isDir(node.mode)) {
29409 return 54;
29410 }
29411 if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
29412 return 10;
29413 }
29414 } else {
29415 if (FS.isDir(node.mode)) {
29416 return 31;
29417 }
29418 }
29419 return 0;
29420 },mayOpen:function(node, flags) {
29421 if (!node) {
29422 return 44;
29423 }
29424 if (FS.isLink(node.mode)) {
29425 return 32;
29426 } else if (FS.isDir(node.mode)) {
29427 if (FS.flagsToPermissionString(flags) !== 'r' || // opening for write
29428 (flags & 512)) { // TODO: check for O_SEARCH? (== search for dir only)
29429 return 31;
29430 }
29431 }
29432 return FS.nodePermissions(node, FS.flagsToPermissionString(flags));
29433 },MAX_OPEN_FDS:4096,nextfd:function(fd_start, fd_end) {
29434 fd_start = fd_start || 0;
29435 fd_end = fd_end || FS.MAX_OPEN_FDS;
29436 for (var fd = fd_start; fd <= fd_end; fd++) {
29437 if (!FS.streams[fd]) {
29438 return fd;
29439 }
29440 }
29441 throw new FS.ErrnoError(33);
29442 },getStream:function(fd) {
29443 return FS.streams[fd];
29444 },createStream:function(stream, fd_start, fd_end) {
29445 if (!FS.FSStream) {
29446 FS.FSStream = /** @constructor */ function(){};
29447 FS.FSStream.prototype = {
29448 object: {
29449 get: function() { return this.node; },
29450 set: function(val) { this.node = val; }
29451 },
29452 isRead: {
29453 get: function() { return (this.flags & 2097155) !== 1; }
29454 },
29455 isWrite: {
29456 get: function() { return (this.flags & 2097155) !== 0; }
29457 },
29458 isAppend: {
29459 get: function() { return (this.flags & 1024); }
29460 }
29461 };
29462 }
29463 // clone it, so we can return an instance of FSStream
29464 var newStream = new FS.FSStream();
29465 for (var p in stream) {
29466 newStream[p] = stream[p];
29467 }
29468 stream = newStream;
29469 var fd = FS.nextfd(fd_start, fd_end);
29470 stream.fd = fd;
29471 FS.streams[fd] = stream;
29472 return stream;
29473 },closeStream:function(fd) {
29474 FS.streams[fd] = null;
29475 },chrdev_stream_ops:{open:function(stream) {
29476 var device = FS.getDevice(stream.node.rdev);
29477 // override node's stream ops with the device's
29478 stream.stream_ops = device.stream_ops;
29479 // forward the open call
29480 if (stream.stream_ops.open) {
29481 stream.stream_ops.open(stream);
29482 }
29483 },llseek:function() {
29484 throw new FS.ErrnoError(70);
29485 }},major:function(dev) {
29486 return ((dev) >> 8);
29487 },minor:function(dev) {
29488 return ((dev) & 0xff);
29489 },makedev:function(ma, mi) {
29490 return ((ma) << 8 | (mi));
29491 },registerDevice:function(dev, ops) {
29492 FS.devices[dev] = { stream_ops: ops };
29493 },getDevice:function(dev) {
29494 return FS.devices[dev];
29495 },getMounts:function(mount) {
29496 var mounts = [];
29497 var check = [mount];
29498
29499 while (check.length) {
29500 var m = check.pop();
29501
29502 mounts.push(m);
29503
29504 check.push.apply(check, m.mounts);
29505 }
29506
29507 return mounts;
29508 },syncfs:function(populate, callback) {
29509 if (typeof(populate) === 'function') {
29510 callback = populate;
29511 populate = false;
29512 }
29513
29514 FS.syncFSRequests++;
29515
29516 if (FS.syncFSRequests > 1) {
29517 err('warning: ' + FS.syncFSRequests + ' FS.syncfs operations in flight at once, probably just doing extra work');
29518 }
29519
29520 var mounts = FS.getMounts(FS.root.mount);
29521 var completed = 0;
29522
29523 function doCallback(errCode) {
29524 FS.syncFSRequests--;
29525 return callback(errCode);
29526 }
29527
29528 function done(errCode) {
29529 if (errCode) {
29530 if (!done.errored) {
29531 done.errored = true;
29532 return doCallback(errCode);
29533 }
29534 return;
29535 }
29536 if (++completed >= mounts.length) {
29537 doCallback(null);
29538 }
29539 };
29540
29541 // sync all mounts
29542 mounts.forEach(function (mount) {
29543 if (!mount.type.syncfs) {
29544 return done(null);
29545 }
29546 mount.type.syncfs(mount, populate, done);
29547 });
29548 },mount:function(type, opts, mountpoint) {
29549 var root = mountpoint === '/';
29550 var pseudo = !mountpoint;
29551 var node;
29552
29553 if (root && FS.root) {
29554 throw new FS.ErrnoError(10);
29555 } else if (!root && !pseudo) {
29556 var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
29557
29558 mountpoint = lookup.path; // use the absolute path
29559 node = lookup.node;
29560
29561 if (FS.isMountpoint(node)) {
29562 throw new FS.ErrnoError(10);
29563 }
29564
29565 if (!FS.isDir(node.mode)) {
29566 throw new FS.ErrnoError(54);
29567 }
29568 }
29569
29570 var mount = {
29571 type: type,
29572 opts: opts,
29573 mountpoint: mountpoint,
29574 mounts: []
29575 };
29576
29577 // create a root node for the fs
29578 var mountRoot = type.mount(mount);
29579 mountRoot.mount = mount;
29580 mount.root = mountRoot;
29581
29582 if (root) {
29583 FS.root = mountRoot;
29584 } else if (node) {
29585 // set as a mountpoint
29586 node.mounted = mount;
29587
29588 // add the new mount to the current mount's children
29589 if (node.mount) {
29590 node.mount.mounts.push(mount);
29591 }
29592 }
29593
29594 return mountRoot;
29595 },unmount:function (mountpoint) {
29596 var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
29597
29598 if (!FS.isMountpoint(lookup.node)) {
29599 throw new FS.ErrnoError(28);
29600 }
29601
29602 // destroy the nodes for this mount, and all its child mounts
29603 var node = lookup.node;
29604 var mount = node.mounted;
29605 var mounts = FS.getMounts(mount);
29606
29607 Object.keys(FS.nameTable).forEach(function (hash) {
29608 var current = FS.nameTable[hash];
29609
29610 while (current) {
29611 var next = current.name_next;
29612
29613 if (mounts.indexOf(current.mount) !== -1) {
29614 FS.destroyNode(current);
29615 }
29616
29617 current = next;
29618 }
29619 });
29620
29621 // no longer a mountpoint
29622 node.mounted = null;
29623
29624 // remove this mount from the child mounts
29625 var idx = node.mount.mounts.indexOf(mount);
29626 node.mount.mounts.splice(idx, 1);
29627 },lookup:function(parent, name) {
29628 return parent.node_ops.lookup(parent, name);
29629 },mknod:function(path, mode, dev) {
29630 var lookup = FS.lookupPath(path, { parent: true });
29631 var parent = lookup.node;
29632 var name = PATH.basename(path);
29633 if (!name || name === '.' || name === '..') {
29634 throw new FS.ErrnoError(28);
29635 }
29636 var errCode = FS.mayCreate(parent, name);
29637 if (errCode) {
29638 throw new FS.ErrnoError(errCode);
29639 }
29640 if (!parent.node_ops.mknod) {
29641 throw new FS.ErrnoError(63);
29642 }
29643 return parent.node_ops.mknod(parent, name, mode, dev);
29644 },create:function(path, mode) {
29645 mode = mode !== undefined ? mode : 438 /* 0666 */;
29646 mode &= 4095;
29647 mode |= 32768;
29648 return FS.mknod(path, mode, 0);
29649 },mkdir:function(path, mode) {
29650 mode = mode !== undefined ? mode : 511 /* 0777 */;
29651 mode &= 511 | 512;
29652 mode |= 16384;
29653 return FS.mknod(path, mode, 0);
29654 },mkdirTree:function(path, mode) {
29655 var dirs = path.split('/');
29656 var d = '';
29657 for (var i = 0; i < dirs.length; ++i) {
29658 if (!dirs[i]) continue;
29659 d += '/' + dirs[i];
29660 try {
29661 FS.mkdir(d, mode);
29662 } catch(e) {
29663 if (e.errno != 20) throw e;
29664 }
29665 }
29666 },mkdev:function(path, mode, dev) {
29667 if (typeof(dev) === 'undefined') {
29668 dev = mode;
29669 mode = 438 /* 0666 */;
29670 }
29671 mode |= 8192;
29672 return FS.mknod(path, mode, dev);
29673 },symlink:function(oldpath, newpath) {
29674 if (!PATH_FS.resolve(oldpath)) {
29675 throw new FS.ErrnoError(44);
29676 }
29677 var lookup = FS.lookupPath(newpath, { parent: true });
29678 var parent = lookup.node;
29679 if (!parent) {
29680 throw new FS.ErrnoError(44);
29681 }
29682 var newname = PATH.basename(newpath);
29683 var errCode = FS.mayCreate(parent, newname);
29684 if (errCode) {
29685 throw new FS.ErrnoError(errCode);
29686 }
29687 if (!parent.node_ops.symlink) {
29688 throw new FS.ErrnoError(63);
29689 }
29690 return parent.node_ops.symlink(parent, newname, oldpath);
29691 },rename:function(old_path, new_path) {
29692 var old_dirname = PATH.dirname(old_path);
29693 var new_dirname = PATH.dirname(new_path);
29694 var old_name = PATH.basename(old_path);
29695 var new_name = PATH.basename(new_path);
29696 // parents must exist
29697 var lookup, old_dir, new_dir;
29698 try {
29699 lookup = FS.lookupPath(old_path, { parent: true });
29700 old_dir = lookup.node;
29701 lookup = FS.lookupPath(new_path, { parent: true });
29702 new_dir = lookup.node;
29703 } catch (e) {
29704 throw new FS.ErrnoError(10);
29705 }
29706 if (!old_dir || !new_dir) throw new FS.ErrnoError(44);
29707 // need to be part of the same mount
29708 if (old_dir.mount !== new_dir.mount) {
29709 throw new FS.ErrnoError(75);
29710 }
29711 // source must exist
29712 var old_node = FS.lookupNode(old_dir, old_name);
29713 // old path should not be an ancestor of the new path
29714 var relative = PATH_FS.relative(old_path, new_dirname);
29715 if (relative.charAt(0) !== '.') {
29716 throw new FS.ErrnoError(28);
29717 }
29718 // new path should not be an ancestor of the old path
29719 relative = PATH_FS.relative(new_path, old_dirname);
29720 if (relative.charAt(0) !== '.') {
29721 throw new FS.ErrnoError(55);
29722 }
29723 // see if the new path already exists
29724 var new_node;
29725 try {
29726 new_node = FS.lookupNode(new_dir, new_name);
29727 } catch (e) {
29728 // not fatal
29729 }
29730 // early out if nothing needs to change
29731 if (old_node === new_node) {
29732 return;
29733 }
29734 // we'll need to delete the old entry
29735 var isdir = FS.isDir(old_node.mode);
29736 var errCode = FS.mayDelete(old_dir, old_name, isdir);
29737 if (errCode) {
29738 throw new FS.ErrnoError(errCode);
29739 }
29740 // need delete permissions if we'll be overwriting.
29741 // need create permissions if new doesn't already exist.
29742 errCode = new_node ?
29743 FS.mayDelete(new_dir, new_name, isdir) :
29744 FS.mayCreate(new_dir, new_name);
29745 if (errCode) {
29746 throw new FS.ErrnoError(errCode);
29747 }
29748 if (!old_dir.node_ops.rename) {
29749 throw new FS.ErrnoError(63);
29750 }
29751 if (FS.isMountpoint(old_node) || (new_node && FS.isMountpoint(new_node))) {
29752 throw new FS.ErrnoError(10);
29753 }
29754 // if we are going to change the parent, check write permissions
29755 if (new_dir !== old_dir) {
29756 errCode = FS.nodePermissions(old_dir, 'w');
29757 if (errCode) {
29758 throw new FS.ErrnoError(errCode);
29759 }
29760 }
29761 try {
29762 if (FS.trackingDelegate['willMovePath']) {
29763 FS.trackingDelegate['willMovePath'](old_path, new_path);
29764 }
29765 } catch(e) {
29766 err("FS.trackingDelegate['willMovePath']('"+old_path+"', '"+new_path+"') threw an exception: " + e.message);
29767 }
29768 // remove the node from the lookup hash
29769 FS.hashRemoveNode(old_node);
29770 // do the underlying fs rename
29771 try {
29772 old_dir.node_ops.rename(old_node, new_dir, new_name);
29773 } catch (e) {
29774 throw e;
29775 } finally {
29776 // add the node back to the hash (in case node_ops.rename
29777 // changed its name)
29778 FS.hashAddNode(old_node);
29779 }
29780 try {
29781 if (FS.trackingDelegate['onMovePath']) FS.trackingDelegate['onMovePath'](old_path, new_path);
29782 } catch(e) {
29783 err("FS.trackingDelegate['onMovePath']('"+old_path+"', '"+new_path+"') threw an exception: " + e.message);
29784 }
29785 },rmdir:function(path) {
29786 var lookup = FS.lookupPath(path, { parent: true });
29787 var parent = lookup.node;
29788 var name = PATH.basename(path);
29789 var node = FS.lookupNode(parent, name);
29790 var errCode = FS.mayDelete(parent, name, true);
29791 if (errCode) {
29792 throw new FS.ErrnoError(errCode);
29793 }
29794 if (!parent.node_ops.rmdir) {
29795 throw new FS.ErrnoError(63);
29796 }
29797 if (FS.isMountpoint(node)) {
29798 throw new FS.ErrnoError(10);
29799 }
29800 try {
29801 if (FS.trackingDelegate['willDeletePath']) {
29802 FS.trackingDelegate['willDeletePath'](path);
29803 }
29804 } catch(e) {
29805 err("FS.trackingDelegate['willDeletePath']('"+path+"') threw an exception: " + e.message);
29806 }
29807 parent.node_ops.rmdir(parent, name);
29808 FS.destroyNode(node);
29809 try {
29810 if (FS.trackingDelegate['onDeletePath']) FS.trackingDelegate['onDeletePath'](path);
29811 } catch(e) {
29812 err("FS.trackingDelegate['onDeletePath']('"+path+"') threw an exception: " + e.message);
29813 }
29814 },readdir:function(path) {
29815 var lookup = FS.lookupPath(path, { follow: true });
29816 var node = lookup.node;
29817 if (!node.node_ops.readdir) {
29818 throw new FS.ErrnoError(54);
29819 }
29820 return node.node_ops.readdir(node);
29821 },unlink:function(path) {
29822 var lookup = FS.lookupPath(path, { parent: true });
29823 var parent = lookup.node;
29824 var name = PATH.basename(path);
29825 var node = FS.lookupNode(parent, name);
29826 var errCode = FS.mayDelete(parent, name, false);
29827 if (errCode) {
29828 // According to POSIX, we should map EISDIR to EPERM, but
29829 // we instead do what Linux does (and we must, as we use
29830 // the musl linux libc).
29831 throw new FS.ErrnoError(errCode);
29832 }
29833 if (!parent.node_ops.unlink) {
29834 throw new FS.ErrnoError(63);
29835 }
29836 if (FS.isMountpoint(node)) {
29837 throw new FS.ErrnoError(10);
29838 }
29839 try {
29840 if (FS.trackingDelegate['willDeletePath']) {
29841 FS.trackingDelegate['willDeletePath'](path);
29842 }
29843 } catch(e) {
29844 err("FS.trackingDelegate['willDeletePath']('"+path+"') threw an exception: " + e.message);
29845 }
29846 parent.node_ops.unlink(parent, name);
29847 FS.destroyNode(node);
29848 try {
29849 if (FS.trackingDelegate['onDeletePath']) FS.trackingDelegate['onDeletePath'](path);
29850 } catch(e) {
29851 err("FS.trackingDelegate['onDeletePath']('"+path+"') threw an exception: " + e.message);
29852 }
29853 },readlink:function(path) {
29854 var lookup = FS.lookupPath(path);
29855 var link = lookup.node;
29856 if (!link) {
29857 throw new FS.ErrnoError(44);
29858 }
29859 if (!link.node_ops.readlink) {
29860 throw new FS.ErrnoError(28);
29861 }
29862 return PATH_FS.resolve(FS.getPath(link.parent), link.node_ops.readlink(link));
29863 },stat:function(path, dontFollow) {
29864 var lookup = FS.lookupPath(path, { follow: !dontFollow });
29865 var node = lookup.node;
29866 if (!node) {
29867 throw new FS.ErrnoError(44);
29868 }
29869 if (!node.node_ops.getattr) {
29870 throw new FS.ErrnoError(63);
29871 }
29872 return node.node_ops.getattr(node);
29873 },lstat:function(path) {
29874 return FS.stat(path, true);
29875 },chmod:function(path, mode, dontFollow) {
29876 var node;
29877 if (typeof path === 'string') {
29878 var lookup = FS.lookupPath(path, { follow: !dontFollow });
29879 node = lookup.node;
29880 } else {
29881 node = path;
29882 }
29883 if (!node.node_ops.setattr) {
29884 throw new FS.ErrnoError(63);
29885 }
29886 node.node_ops.setattr(node, {
29887 mode: (mode & 4095) | (node.mode & ~4095),
29888 timestamp: Date.now()
29889 });
29890 },lchmod:function(path, mode) {
29891 FS.chmod(path, mode, true);
29892 },fchmod:function(fd, mode) {
29893 var stream = FS.getStream(fd);
29894 if (!stream) {
29895 throw new FS.ErrnoError(8);
29896 }
29897 FS.chmod(stream.node, mode);
29898 },chown:function(path, uid, gid, dontFollow) {
29899 var node;
29900 if (typeof path === 'string') {
29901 var lookup = FS.lookupPath(path, { follow: !dontFollow });
29902 node = lookup.node;
29903 } else {
29904 node = path;
29905 }
29906 if (!node.node_ops.setattr) {
29907 throw new FS.ErrnoError(63);
29908 }
29909 node.node_ops.setattr(node, {
29910 timestamp: Date.now()
29911 // we ignore the uid / gid for now
29912 });
29913 },lchown:function(path, uid, gid) {
29914 FS.chown(path, uid, gid, true);
29915 },fchown:function(fd, uid, gid) {
29916 var stream = FS.getStream(fd);
29917 if (!stream) {
29918 throw new FS.ErrnoError(8);
29919 }
29920 FS.chown(stream.node, uid, gid);
29921 },truncate:function(path, len) {
29922 if (len < 0) {
29923 throw new FS.ErrnoError(28);
29924 }
29925 var node;
29926 if (typeof path === 'string') {
29927 var lookup = FS.lookupPath(path, { follow: true });
29928 node = lookup.node;
29929 } else {
29930 node = path;
29931 }
29932 if (!node.node_ops.setattr) {
29933 throw new FS.ErrnoError(63);
29934 }
29935 if (FS.isDir(node.mode)) {
29936 throw new FS.ErrnoError(31);
29937 }
29938 if (!FS.isFile(node.mode)) {
29939 throw new FS.ErrnoError(28);
29940 }
29941 var errCode = FS.nodePermissions(node, 'w');
29942 if (errCode) {
29943 throw new FS.ErrnoError(errCode);
29944 }
29945 node.node_ops.setattr(node, {
29946 size: len,
29947 timestamp: Date.now()
29948 });
29949 },ftruncate:function(fd, len) {
29950 var stream = FS.getStream(fd);
29951 if (!stream) {
29952 throw new FS.ErrnoError(8);
29953 }
29954 if ((stream.flags & 2097155) === 0) {
29955 throw new FS.ErrnoError(28);
29956 }
29957 FS.truncate(stream.node, len);
29958 },utime:function(path, atime, mtime) {
29959 var lookup = FS.lookupPath(path, { follow: true });
29960 var node = lookup.node;
29961 node.node_ops.setattr(node, {
29962 timestamp: Math.max(atime, mtime)
29963 });
29964 },open:function(path, flags, mode, fd_start, fd_end) {
29965 if (path === "") {
29966 throw new FS.ErrnoError(44);
29967 }
29968 flags = typeof flags === 'string' ? FS.modeStringToFlags(flags) : flags;
29969 mode = typeof mode === 'undefined' ? 438 /* 0666 */ : mode;
29970 if ((flags & 64)) {
29971 mode = (mode & 4095) | 32768;
29972 } else {
29973 mode = 0;
29974 }
29975 var node;
29976 if (typeof path === 'object') {
29977 node = path;
29978 } else {
29979 path = PATH.normalize(path);
29980 try {
29981 var lookup = FS.lookupPath(path, {
29982 follow: !(flags & 131072)
29983 });
29984 node = lookup.node;
29985 } catch (e) {
29986 // ignore
29987 }
29988 }
29989 // perhaps we need to create the node
29990 var created = false;
29991 if ((flags & 64)) {
29992 if (node) {
29993 // if O_CREAT and O_EXCL are set, error out if the node already exists
29994 if ((flags & 128)) {
29995 throw new FS.ErrnoError(20);
29996 }
29997 } else {
29998 // node doesn't exist, try to create it
29999 node = FS.mknod(path, mode, 0);
30000 created = true;
30001 }
30002 }
30003 if (!node) {
30004 throw new FS.ErrnoError(44);
30005 }
30006 // can't truncate a device
30007 if (FS.isChrdev(node.mode)) {
30008 flags &= ~512;
30009 }
30010 // if asked only for a directory, then this must be one
30011 if ((flags & 65536) && !FS.isDir(node.mode)) {
30012 throw new FS.ErrnoError(54);
30013 }
30014 // check permissions, if this is not a file we just created now (it is ok to
30015 // create and write to a file with read-only permissions; it is read-only
30016 // for later use)
30017 if (!created) {
30018 var errCode = FS.mayOpen(node, flags);
30019 if (errCode) {
30020 throw new FS.ErrnoError(errCode);
30021 }
30022 }
30023 // do truncation if necessary
30024 if ((flags & 512)) {
30025 FS.truncate(node, 0);
30026 }
30027 // we've already handled these, don't pass down to the underlying vfs
30028 flags &= ~(128 | 512 | 131072);
30029
30030 // register the stream with the filesystem
30031 var stream = FS.createStream({
30032 node: node,
30033 path: FS.getPath(node), // we want the absolute path to the node
30034 flags: flags,
30035 seekable: true,
30036 position: 0,
30037 stream_ops: node.stream_ops,
30038 // used by the file family libc calls (fopen, fwrite, ferror, etc.)
30039 ungotten: [],
30040 error: false
30041 }, fd_start, fd_end);
30042 // call the new stream's open function
30043 if (stream.stream_ops.open) {
30044 stream.stream_ops.open(stream);
30045 }
30046 if (Module['logReadFiles'] && !(flags & 1)) {
30047 if (!FS.readFiles) FS.readFiles = {};
30048 if (!(path in FS.readFiles)) {
30049 FS.readFiles[path] = 1;
30050 err("FS.trackingDelegate error on read file: " + path);
30051 }
30052 }
30053 try {
30054 if (FS.trackingDelegate['onOpenFile']) {
30055 var trackingFlags = 0;
30056 if ((flags & 2097155) !== 1) {
30057 trackingFlags |= FS.tracking.openFlags.READ;
30058 }
30059 if ((flags & 2097155) !== 0) {
30060 trackingFlags |= FS.tracking.openFlags.WRITE;
30061 }
30062 FS.trackingDelegate['onOpenFile'](path, trackingFlags);
30063 }
30064 } catch(e) {
30065 err("FS.trackingDelegate['onOpenFile']('"+path+"', flags) threw an exception: " + e.message);
30066 }
30067 return stream;
30068 },close:function(stream) {
30069 if (FS.isClosed(stream)) {
30070 throw new FS.ErrnoError(8);
30071 }
30072 if (stream.getdents) stream.getdents = null; // free readdir state
30073 try {
30074 if (stream.stream_ops.close) {
30075 stream.stream_ops.close(stream);
30076 }
30077 } catch (e) {
30078 throw e;
30079 } finally {
30080 FS.closeStream(stream.fd);
30081 }
30082 stream.fd = null;
30083 },isClosed:function(stream) {
30084 return stream.fd === null;
30085 },llseek:function(stream, offset, whence) {
30086 if (FS.isClosed(stream)) {
30087 throw new FS.ErrnoError(8);
30088 }
30089 if (!stream.seekable || !stream.stream_ops.llseek) {
30090 throw new FS.ErrnoError(70);
30091 }
30092 if (whence != 0 && whence != 1 && whence != 2) {
30093 throw new FS.ErrnoError(28);
30094 }
30095 stream.position = stream.stream_ops.llseek(stream, offset, whence);
30096 stream.ungotten = [];
30097 return stream.position;
30098 },read:function(stream, buffer, offset, length, position) {
30099 if (length < 0 || position < 0) {
30100 throw new FS.ErrnoError(28);
30101 }
30102 if (FS.isClosed(stream)) {
30103 throw new FS.ErrnoError(8);
30104 }
30105 if ((stream.flags & 2097155) === 1) {
30106 throw new FS.ErrnoError(8);
30107 }
30108 if (FS.isDir(stream.node.mode)) {
30109 throw new FS.ErrnoError(31);
30110 }
30111 if (!stream.stream_ops.read) {
30112 throw new FS.ErrnoError(28);
30113 }
30114 var seeking = typeof position !== 'undefined';
30115 if (!seeking) {
30116 position = stream.position;
30117 } else if (!stream.seekable) {
30118 throw new FS.ErrnoError(70);
30119 }
30120 var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position);
30121 if (!seeking) stream.position += bytesRead;
30122 return bytesRead;
30123 },write:function(stream, buffer, offset, length, position, canOwn) {
30124 if (length < 0 || position < 0) {
30125 throw new FS.ErrnoError(28);
30126 }
30127 if (FS.isClosed(stream)) {
30128 throw new FS.ErrnoError(8);
30129 }
30130 if ((stream.flags & 2097155) === 0) {
30131 throw new FS.ErrnoError(8);
30132 }
30133 if (FS.isDir(stream.node.mode)) {
30134 throw new FS.ErrnoError(31);
30135 }
30136 if (!stream.stream_ops.write) {
30137 throw new FS.ErrnoError(28);
30138 }
30139 if (stream.seekable && stream.flags & 1024) {
30140 // seek to the end before writing in append mode
30141 FS.llseek(stream, 0, 2);
30142 }
30143 var seeking = typeof position !== 'undefined';
30144 if (!seeking) {
30145 position = stream.position;
30146 } else if (!stream.seekable) {
30147 throw new FS.ErrnoError(70);
30148 }
30149 var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn);
30150 if (!seeking) stream.position += bytesWritten;
30151 try {
30152 if (stream.path && FS.trackingDelegate['onWriteToFile']) FS.trackingDelegate['onWriteToFile'](stream.path);
30153 } catch(e) {
30154 err("FS.trackingDelegate['onWriteToFile']('"+stream.path+"') threw an exception: " + e.message);
30155 }
30156 return bytesWritten;
30157 },allocate:function(stream, offset, length) {
30158 if (FS.isClosed(stream)) {
30159 throw new FS.ErrnoError(8);
30160 }
30161 if (offset < 0 || length <= 0) {
30162 throw new FS.ErrnoError(28);
30163 }
30164 if ((stream.flags & 2097155) === 0) {
30165 throw new FS.ErrnoError(8);
30166 }
30167 if (!FS.isFile(stream.node.mode) && !FS.isDir(stream.node.mode)) {
30168 throw new FS.ErrnoError(43);
30169 }
30170 if (!stream.stream_ops.allocate) {
30171 throw new FS.ErrnoError(138);
30172 }
30173 stream.stream_ops.allocate(stream, offset, length);
30174 },mmap:function(stream, address, length, position, prot, flags) {
30175 // User requests writing to file (prot & PROT_WRITE != 0).
30176 // Checking if we have permissions to write to the file unless
30177 // MAP_PRIVATE flag is set. According to POSIX spec it is possible
30178 // to write to file opened in read-only mode with MAP_PRIVATE flag,
30179 // as all modifications will be visible only in the memory of
30180 // the current process.
30181 if ((prot & 2) !== 0
30182 && (flags & 2) === 0
30183 && (stream.flags & 2097155) !== 2) {
30184 throw new FS.ErrnoError(2);
30185 }
30186 if ((stream.flags & 2097155) === 1) {
30187 throw new FS.ErrnoError(2);
30188 }
30189 if (!stream.stream_ops.mmap) {
30190 throw new FS.ErrnoError(43);
30191 }
30192 return stream.stream_ops.mmap(stream, address, length, position, prot, flags);
30193 },msync:function(stream, buffer, offset, length, mmapFlags) {
30194 if (!stream || !stream.stream_ops.msync) {
30195 return 0;
30196 }
30197 return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags);
30198 },munmap:function(stream) {
30199 return 0;
30200 },ioctl:function(stream, cmd, arg) {
30201 if (!stream.stream_ops.ioctl) {
30202 throw new FS.ErrnoError(59);
30203 }
30204 return stream.stream_ops.ioctl(stream, cmd, arg);
30205 },readFile:function(path, opts) {
30206 opts = opts || {};
30207 opts.flags = opts.flags || 'r';
30208 opts.encoding = opts.encoding || 'binary';
30209 if (opts.encoding !== 'utf8' && opts.encoding !== 'binary') {
30210 throw new Error('Invalid encoding type "' + opts.encoding + '"');
30211 }
30212 var ret;
30213 var stream = FS.open(path, opts.flags);
30214 var stat = FS.stat(path);
30215 var length = stat.size;
30216 var buf = new Uint8Array(length);
30217 FS.read(stream, buf, 0, length, 0);
30218 if (opts.encoding === 'utf8') {
30219 ret = UTF8ArrayToString(buf, 0);
30220 } else if (opts.encoding === 'binary') {
30221 ret = buf;
30222 }
30223 FS.close(stream);
30224 return ret;
30225 },writeFile:function(path, data, opts) {
30226 opts = opts || {};
30227 opts.flags = opts.flags || 'w';
30228 var stream = FS.open(path, opts.flags, opts.mode);
30229 if (typeof data === 'string') {
30230 var buf = new Uint8Array(lengthBytesUTF8(data)+1);
30231 var actualNumBytes = stringToUTF8Array(data, buf, 0, buf.length);
30232 FS.write(stream, buf, 0, actualNumBytes, undefined, opts.canOwn);
30233 } else if (ArrayBuffer.isView(data)) {
30234 FS.write(stream, data, 0, data.byteLength, undefined, opts.canOwn);
30235 } else {
30236 throw new Error('Unsupported data type');
30237 }
30238 FS.close(stream);
30239 },cwd:function() {
30240 return FS.currentPath;
30241 },chdir:function(path) {
30242 var lookup = FS.lookupPath(path, { follow: true });
30243 if (lookup.node === null) {
30244 throw new FS.ErrnoError(44);
30245 }
30246 if (!FS.isDir(lookup.node.mode)) {
30247 throw new FS.ErrnoError(54);
30248 }
30249 var errCode = FS.nodePermissions(lookup.node, 'x');
30250 if (errCode) {
30251 throw new FS.ErrnoError(errCode);
30252 }
30253 FS.currentPath = lookup.path;
30254 },createDefaultDirectories:function() {
30255 FS.mkdir('/tmp');
30256 FS.mkdir('/home');
30257 FS.mkdir('/home/web_user');
30258 },createDefaultDevices:function() {
30259 // create /dev
30260 FS.mkdir('/dev');
30261 // setup /dev/null
30262 FS.registerDevice(FS.makedev(1, 3), {
30263 read: function() { return 0; },
30264 write: function(stream, buffer, offset, length, pos) { return length; }
30265 });
30266 FS.mkdev('/dev/null', FS.makedev(1, 3));
30267 // setup /dev/tty and /dev/tty1
30268 // stderr needs to print output using Module['printErr']
30269 // so we register a second tty just for it.
30270 TTY.register(FS.makedev(5, 0), TTY.default_tty_ops);
30271 TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops);
30272 FS.mkdev('/dev/tty', FS.makedev(5, 0));
30273 FS.mkdev('/dev/tty1', FS.makedev(6, 0));
30274 // setup /dev/[u]random
30275 var random_device;
30276 if (typeof crypto === 'object' && typeof crypto['getRandomValues'] === 'function') {
30277 // for modern web browsers
30278 var randomBuffer = new Uint8Array(1);
30279 random_device = function() { crypto.getRandomValues(randomBuffer); return randomBuffer[0]; };
30280 } else
30281 if (ENVIRONMENT_IS_NODE) {
30282 // for nodejs with or without crypto support included
30283 try {
30284 var crypto_module = require('crypto');
30285 // nodejs has crypto support
30286 random_device = function() { return crypto_module['randomBytes'](1)[0]; };
30287 } catch (e) {
30288 // nodejs doesn't have crypto support
30289 }
30290 } else
30291 {}
30292 if (!random_device) {
30293 // we couldn't find a proper implementation, as Math.random() is not suitable for /dev/random, see emscripten-core/emscripten/pull/7096
30294 random_device = function() { abort("random_device"); };
30295 }
30296 FS.createDevice('/dev', 'random', random_device);
30297 FS.createDevice('/dev', 'urandom', random_device);
30298 // we're not going to emulate the actual shm device,
30299 // just create the tmp dirs that reside in it commonly
30300 FS.mkdir('/dev/shm');
30301 FS.mkdir('/dev/shm/tmp');
30302 },createSpecialDirectories:function() {
30303 // create /proc/self/fd which allows /proc/self/fd/6 => readlink gives the name of the stream for fd 6 (see test_unistd_ttyname)
30304 FS.mkdir('/proc');
30305 FS.mkdir('/proc/self');
30306 FS.mkdir('/proc/self/fd');
30307 FS.mount({
30308 mount: function() {
30309 var node = FS.createNode('/proc/self', 'fd', 16384 | 511 /* 0777 */, 73);
30310 node.node_ops = {
30311 lookup: function(parent, name) {
30312 var fd = +name;
30313 var stream = FS.getStream(fd);
30314 if (!stream) throw new FS.ErrnoError(8);
30315 var ret = {
30316 parent: null,
30317 mount: { mountpoint: 'fake' },
30318 node_ops: { readlink: function() { return stream.path } }
30319 };
30320 ret.parent = ret; // make it look like a simple root node
30321 return ret;
30322 }
30323 };
30324 return node;
30325 }
30326 }, {}, '/proc/self/fd');
30327 },createStandardStreams:function() {
30328 // TODO deprecate the old functionality of a single
30329 // input / output callback and that utilizes FS.createDevice
30330 // and instead require a unique set of stream ops
30331
30332 // by default, we symlink the standard streams to the
30333 // default tty devices. however, if the standard streams
30334 // have been overwritten we create a unique device for
30335 // them instead.
30336 if (Module['stdin']) {
30337 FS.createDevice('/dev', 'stdin', Module['stdin']);
30338 } else {
30339 FS.symlink('/dev/tty', '/dev/stdin');
30340 }
30341 if (Module['stdout']) {
30342 FS.createDevice('/dev', 'stdout', null, Module['stdout']);
30343 } else {
30344 FS.symlink('/dev/tty', '/dev/stdout');
30345 }
30346 if (Module['stderr']) {
30347 FS.createDevice('/dev', 'stderr', null, Module['stderr']);
30348 } else {
30349 FS.symlink('/dev/tty1', '/dev/stderr');
30350 }
30351
30352 // open default streams for the stdin, stdout and stderr devices
30353 var stdin = FS.open('/dev/stdin', 'r');
30354 var stdout = FS.open('/dev/stdout', 'w');
30355 var stderr = FS.open('/dev/stderr', 'w');
30356 },ensureErrnoError:function() {
30357 if (FS.ErrnoError) return;
30358 FS.ErrnoError = /** @this{Object} */ function ErrnoError(errno, node) {
30359 this.node = node;
30360 this.setErrno = /** @this{Object} */ function(errno) {
30361 this.errno = errno;
30362 };
30363 this.setErrno(errno);
30364 this.message = 'FS error';
30365
30366 };
30367 FS.ErrnoError.prototype = new Error();
30368 FS.ErrnoError.prototype.constructor = FS.ErrnoError;
30369 // Some errors may happen quite a bit, to avoid overhead we reuse them (and suffer a lack of stack info)
30370 [44].forEach(function(code) {
30371 FS.genericErrors[code] = new FS.ErrnoError(code);
30372 FS.genericErrors[code].stack = '<generic error, no stack>';
30373 });
30374 },staticInit:function() {
30375 FS.ensureErrnoError();
30376
30377 FS.nameTable = new Array(4096);
30378
30379 FS.mount(MEMFS, {}, '/');
30380
30381 FS.createDefaultDirectories();
30382 FS.createDefaultDevices();
30383 FS.createSpecialDirectories();
30384
30385 FS.filesystems = {
30386 'MEMFS': MEMFS,
30387 };
30388 },init:function(input, output, error) {
30389 FS.init.initialized = true;
30390
30391 FS.ensureErrnoError();
30392
30393 // Allow Module.stdin etc. to provide defaults, if none explicitly passed to us here
30394 Module['stdin'] = input || Module['stdin'];
30395 Module['stdout'] = output || Module['stdout'];
30396 Module['stderr'] = error || Module['stderr'];
30397
30398 FS.createStandardStreams();
30399 },quit:function() {
30400 FS.init.initialized = false;
30401 // force-flush all streams, so we get musl std streams printed out
30402 var fflush = Module['_fflush'];
30403 if (fflush) fflush(0);
30404 // close all of our streams
30405 for (var i = 0; i < FS.streams.length; i++) {
30406 var stream = FS.streams[i];
30407 if (!stream) {
30408 continue;
30409 }
30410 FS.close(stream);
30411 }
30412 },getMode:function(canRead, canWrite) {
30413 var mode = 0;
30414 if (canRead) mode |= 292 | 73;
30415 if (canWrite) mode |= 146;
30416 return mode;
30417 },joinPath:function(parts, forceRelative) {
30418 var path = PATH.join.apply(null, parts);
30419 if (forceRelative && path[0] == '/') path = path.substr(1);
30420 return path;
30421 },absolutePath:function(relative, base) {
30422 return PATH_FS.resolve(base, relative);
30423 },standardizePath:function(path) {
30424 return PATH.normalize(path);
30425 },findObject:function(path, dontResolveLastLink) {
30426 var ret = FS.analyzePath(path, dontResolveLastLink);
30427 if (ret.exists) {
30428 return ret.object;
30429 } else {
30430 setErrNo(ret.error);
30431 return null;
30432 }
30433 },analyzePath:function(path, dontResolveLastLink) {
30434 // operate from within the context of the symlink's target
30435 try {
30436 var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
30437 path = lookup.path;
30438 } catch (e) {
30439 }
30440 var ret = {
30441 isRoot: false, exists: false, error: 0, name: null, path: null, object: null,
30442 parentExists: false, parentPath: null, parentObject: null
30443 };
30444 try {
30445 var lookup = FS.lookupPath(path, { parent: true });
30446 ret.parentExists = true;
30447 ret.parentPath = lookup.path;
30448 ret.parentObject = lookup.node;
30449 ret.name = PATH.basename(path);
30450 lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
30451 ret.exists = true;
30452 ret.path = lookup.path;
30453 ret.object = lookup.node;
30454 ret.name = lookup.node.name;
30455 ret.isRoot = lookup.path === '/';
30456 } catch (e) {
30457 ret.error = e.errno;
30458 };
30459 return ret;
30460 },createFolder:function(parent, name, canRead, canWrite) {
30461 var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
30462 var mode = FS.getMode(canRead, canWrite);
30463 return FS.mkdir(path, mode);
30464 },createPath:function(parent, path, canRead, canWrite) {
30465 parent = typeof parent === 'string' ? parent : FS.getPath(parent);
30466 var parts = path.split('/').reverse();
30467 while (parts.length) {
30468 var part = parts.pop();
30469 if (!part) continue;
30470 var current = PATH.join2(parent, part);
30471 try {
30472 FS.mkdir(current);
30473 } catch (e) {
30474 // ignore EEXIST
30475 }
30476 parent = current;
30477 }
30478 return current;
30479 },createFile:function(parent, name, properties, canRead, canWrite) {
30480 var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
30481 var mode = FS.getMode(canRead, canWrite);
30482 return FS.create(path, mode);
30483 },createDataFile:function(parent, name, data, canRead, canWrite, canOwn) {
30484 var path = name ? PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name) : parent;
30485 var mode = FS.getMode(canRead, canWrite);
30486 var node = FS.create(path, mode);
30487 if (data) {
30488 if (typeof data === 'string') {
30489 var arr = new Array(data.length);
30490 for (var i = 0, len = data.length; i < len; ++i) arr[i] = data.charCodeAt(i);
30491 data = arr;
30492 }
30493 // make sure we can write to the file
30494 FS.chmod(node, mode | 146);
30495 var stream = FS.open(node, 'w');
30496 FS.write(stream, data, 0, data.length, 0, canOwn);
30497 FS.close(stream);
30498 FS.chmod(node, mode);
30499 }
30500 return node;
30501 },createDevice:function(parent, name, input, output) {
30502 var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
30503 var mode = FS.getMode(!!input, !!output);
30504 if (!FS.createDevice.major) FS.createDevice.major = 64;
30505 var dev = FS.makedev(FS.createDevice.major++, 0);
30506 // Create a fake device that a set of stream ops to emulate
30507 // the old behavior.
30508 FS.registerDevice(dev, {
30509 open: function(stream) {
30510 stream.seekable = false;
30511 },
30512 close: function(stream) {
30513 // flush any pending line data
30514 if (output && output.buffer && output.buffer.length) {
30515 output(10);
30516 }
30517 },
30518 read: function(stream, buffer, offset, length, pos /* ignored */) {
30519 var bytesRead = 0;
30520 for (var i = 0; i < length; i++) {
30521 var result;
30522 try {
30523 result = input();
30524 } catch (e) {
30525 throw new FS.ErrnoError(29);
30526 }
30527 if (result === undefined && bytesRead === 0) {
30528 throw new FS.ErrnoError(6);
30529 }
30530 if (result === null || result === undefined) break;
30531 bytesRead++;
30532 buffer[offset+i] = result;
30533 }
30534 if (bytesRead) {
30535 stream.node.timestamp = Date.now();
30536 }
30537 return bytesRead;
30538 },
30539 write: function(stream, buffer, offset, length, pos) {
30540 for (var i = 0; i < length; i++) {
30541 try {
30542 output(buffer[offset+i]);
30543 } catch (e) {
30544 throw new FS.ErrnoError(29);
30545 }
30546 }
30547 if (length) {
30548 stream.node.timestamp = Date.now();
30549 }
30550 return i;
30551 }
30552 });
30553 return FS.mkdev(path, mode, dev);
30554 },createLink:function(parent, name, target, canRead, canWrite) {
30555 var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
30556 return FS.symlink(target, path);
30557 },forceLoadFile:function(obj) {
30558 if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true;
30559 var success = true;
30560 if (typeof XMLHttpRequest !== 'undefined') {
30561 throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.");
30562 } else if (read_) {
30563 // Command-line.
30564 try {
30565 // WARNING: Can't read binary files in V8's d8 or tracemonkey's js, as
30566 // read() will try to parse UTF8.
30567 obj.contents = intArrayFromString(read_(obj.url), true);
30568 obj.usedBytes = obj.contents.length;
30569 } catch (e) {
30570 success = false;
30571 }
30572 } else {
30573 throw new Error('Cannot load without read() or XMLHttpRequest.');
30574 }
30575 if (!success) setErrNo(29);
30576 return success;
30577 },createLazyFile:function(parent, name, url, canRead, canWrite) {
30578 // Lazy chunked Uint8Array (implements get and length from Uint8Array). Actual getting is abstracted away for eventual reuse.
30579 /** @constructor */
30580 function LazyUint8Array() {
30581 this.lengthKnown = false;
30582 this.chunks = []; // Loaded chunks. Index is the chunk number
30583 }
30584 LazyUint8Array.prototype.get = /** @this{Object} */ function LazyUint8Array_get(idx) {
30585 if (idx > this.length-1 || idx < 0) {
30586 return undefined;
30587 }
30588 var chunkOffset = idx % this.chunkSize;
30589 var chunkNum = (idx / this.chunkSize)|0;
30590 return this.getter(chunkNum)[chunkOffset];
30591 };
30592 LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) {
30593 this.getter = getter;
30594 };
30595 LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() {
30596 // Find length
30597 var xhr = new XMLHttpRequest();
30598 xhr.open('HEAD', url, false);
30599 xhr.send(null);
30600 if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
30601 var datalength = Number(xhr.getResponseHeader("Content-length"));
30602 var header;
30603 var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes";
30604 var usesGzip = (header = xhr.getResponseHeader("Content-Encoding")) && header === "gzip";
30605
30606 var chunkSize = 1024*1024; // Chunk size in bytes
30607
30608 if (!hasByteServing) chunkSize = datalength;
30609
30610 // Function to get a range from the remote URL.
30611 var doXHR = (function(from, to) {
30612 if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!");
30613 if (to > datalength-1) throw new Error("only " + datalength + " bytes available! programmer error!");
30614
30615 // TODO: Use mozResponseArrayBuffer, responseStream, etc. if available.
30616 var xhr = new XMLHttpRequest();
30617 xhr.open('GET', url, false);
30618 if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to);
30619
30620 // Some hints to the browser that we want binary data.
30621 if (typeof Uint8Array != 'undefined') xhr.responseType = 'arraybuffer';
30622 if (xhr.overrideMimeType) {
30623 xhr.overrideMimeType('text/plain; charset=x-user-defined');
30624 }
30625
30626 xhr.send(null);
30627 if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
30628 if (xhr.response !== undefined) {
30629 return new Uint8Array(/** @type{Array<number>} */(xhr.response || []));
30630 } else {
30631 return intArrayFromString(xhr.responseText || '', true);
30632 }
30633 });
30634 var lazyArray = this;
30635 lazyArray.setDataGetter(function(chunkNum) {
30636 var start = chunkNum * chunkSize;
30637 var end = (chunkNum+1) * chunkSize - 1; // including this byte
30638 end = Math.min(end, datalength-1); // if datalength-1 is selected, this is the last block
30639 if (typeof(lazyArray.chunks[chunkNum]) === "undefined") {
30640 lazyArray.chunks[chunkNum] = doXHR(start, end);
30641 }
30642 if (typeof(lazyArray.chunks[chunkNum]) === "undefined") throw new Error("doXHR failed!");
30643 return lazyArray.chunks[chunkNum];
30644 });
30645
30646 if (usesGzip || !datalength) {
30647 // if the server uses gzip or doesn't supply the length, we have to download the whole file to get the (uncompressed) length
30648 chunkSize = datalength = 1; // this will force getter(0)/doXHR do download the whole file
30649 datalength = this.getter(0).length;
30650 chunkSize = datalength;
30651 out("LazyFiles on gzip forces download of the whole file when length is accessed");
30652 }
30653
30654 this._length = datalength;
30655 this._chunkSize = chunkSize;
30656 this.lengthKnown = true;
30657 };
30658 if (typeof XMLHttpRequest !== 'undefined') {
30659 if (!ENVIRONMENT_IS_WORKER) throw 'Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc';
30660 var lazyArray = new LazyUint8Array();
30661 Object.defineProperties(lazyArray, {
30662 length: {
30663 get: /** @this{Object} */ function() {
30664 if(!this.lengthKnown) {
30665 this.cacheLength();
30666 }
30667 return this._length;
30668 }
30669 },
30670 chunkSize: {
30671 get: /** @this{Object} */ function() {
30672 if(!this.lengthKnown) {
30673 this.cacheLength();
30674 }
30675 return this._chunkSize;
30676 }
30677 }
30678 });
30679
30680 var properties = { isDevice: false, contents: lazyArray };
30681 } else {
30682 var properties = { isDevice: false, url: url };
30683 }
30684
30685 var node = FS.createFile(parent, name, properties, canRead, canWrite);
30686 // This is a total hack, but I want to get this lazy file code out of the
30687 // core of MEMFS. If we want to keep this lazy file concept I feel it should
30688 // be its own thin LAZYFS proxying calls to MEMFS.
30689 if (properties.contents) {
30690 node.contents = properties.contents;
30691 } else if (properties.url) {
30692 node.contents = null;
30693 node.url = properties.url;
30694 }
30695 // Add a function that defers querying the file size until it is asked the first time.
30696 Object.defineProperties(node, {
30697 usedBytes: {
30698 get: /** @this {FSNode} */ function() { return this.contents.length; }
30699 }
30700 });
30701 // override each stream op with one that tries to force load the lazy file first
30702 var stream_ops = {};
30703 var keys = Object.keys(node.stream_ops);
30704 keys.forEach(function(key) {
30705 var fn = node.stream_ops[key];
30706 stream_ops[key] = function forceLoadLazyFile() {
30707 if (!FS.forceLoadFile(node)) {
30708 throw new FS.ErrnoError(29);
30709 }
30710 return fn.apply(null, arguments);
30711 };
30712 });
30713 // use a custom read function
30714 stream_ops.read = function stream_ops_read(stream, buffer, offset, length, position) {
30715 if (!FS.forceLoadFile(node)) {
30716 throw new FS.ErrnoError(29);
30717 }
30718 var contents = stream.node.contents;
30719 if (position >= contents.length)
30720 return 0;
30721 var size = Math.min(contents.length - position, length);
30722 if (contents.slice) { // normal array
30723 for (var i = 0; i < size; i++) {
30724 buffer[offset + i] = contents[position + i];
30725 }
30726 } else {
30727 for (var i = 0; i < size; i++) { // LazyUint8Array from sync binary XHR
30728 buffer[offset + i] = contents.get(position + i);
30729 }
30730 }
30731 return size;
30732 };
30733 node.stream_ops = stream_ops;
30734 return node;
30735 },createPreloadedFile:function(parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) {
30736 Browser.init(); // XXX perhaps this method should move onto Browser?
30737 // TODO we should allow people to just pass in a complete filename instead
30738 // of parent and name being that we just join them anyways
30739 var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent;
30740 var dep = getUniqueRunDependency('cp ' + fullname); // might have several active requests for the same fullname
30741 function processData(byteArray) {
30742 function finish(byteArray) {
30743 if (preFinish) preFinish();
30744 if (!dontCreateFile) {
30745 FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn);
30746 }
30747 if (onload) onload();
30748 removeRunDependency(dep);
30749 }
30750 var handled = false;
30751 Module['preloadPlugins'].forEach(function(plugin) {
30752 if (handled) return;
30753 if (plugin['canHandle'](fullname)) {
30754 plugin['handle'](byteArray, fullname, finish, function() {
30755 if (onerror) onerror();
30756 removeRunDependency(dep);
30757 });
30758 handled = true;
30759 }
30760 });
30761 if (!handled) finish(byteArray);
30762 }
30763 addRunDependency(dep);
30764 if (typeof url == 'string') {
30765 Browser.asyncLoad(url, function(byteArray) {
30766 processData(byteArray);
30767 }, onerror);
30768 } else {
30769 processData(url);
30770 }
30771 },indexedDB:function() {
30772 return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
30773 },DB_NAME:function() {
30774 return 'EM_FS_' + window.location.pathname;
30775 },DB_VERSION:20,DB_STORE_NAME:"FILE_DATA",saveFilesToDB:function(paths, onload, onerror) {
30776 onload = onload || function(){};
30777 onerror = onerror || function(){};
30778 var indexedDB = FS.indexedDB();
30779 try {
30780 var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
30781 } catch (e) {
30782 return onerror(e);
30783 }
30784 openRequest.onupgradeneeded = function openRequest_onupgradeneeded() {
30785 out('creating db');
30786 var db = openRequest.result;
30787 db.createObjectStore(FS.DB_STORE_NAME);
30788 };
30789 openRequest.onsuccess = function openRequest_onsuccess() {
30790 var db = openRequest.result;
30791 var transaction = db.transaction([FS.DB_STORE_NAME], 'readwrite');
30792 var files = transaction.objectStore(FS.DB_STORE_NAME);
30793 var ok = 0, fail = 0, total = paths.length;
30794 function finish() {
30795 if (fail == 0) onload(); else onerror();
30796 }
30797 paths.forEach(function(path) {
30798 var putRequest = files.put(FS.analyzePath(path).object.contents, path);
30799 putRequest.onsuccess = function putRequest_onsuccess() { ok++; if (ok + fail == total) finish() };
30800 putRequest.onerror = function putRequest_onerror() { fail++; if (ok + fail == total) finish() };
30801 });
30802 transaction.onerror = onerror;
30803 };
30804 openRequest.onerror = onerror;
30805 },loadFilesFromDB:function(paths, onload, onerror) {
30806 onload = onload || function(){};
30807 onerror = onerror || function(){};
30808 var indexedDB = FS.indexedDB();
30809 try {
30810 var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
30811 } catch (e) {
30812 return onerror(e);
30813 }
30814 openRequest.onupgradeneeded = onerror; // no database to load from
30815 openRequest.onsuccess = function openRequest_onsuccess() {
30816 var db = openRequest.result;
30817 try {
30818 var transaction = db.transaction([FS.DB_STORE_NAME], 'readonly');
30819 } catch(e) {
30820 onerror(e);
30821 return;
30822 }
30823 var files = transaction.objectStore(FS.DB_STORE_NAME);
30824 var ok = 0, fail = 0, total = paths.length;
30825 function finish() {
30826 if (fail == 0) onload(); else onerror();
30827 }
30828 paths.forEach(function(path) {
30829 var getRequest = files.get(path);
30830 getRequest.onsuccess = function getRequest_onsuccess() {
30831 if (FS.analyzePath(path).exists) {
30832 FS.unlink(path);
30833 }
30834 FS.createDataFile(PATH.dirname(path), PATH.basename(path), getRequest.result, true, true, true);
30835 ok++;
30836 if (ok + fail == total) finish();
30837 };
30838 getRequest.onerror = function getRequest_onerror() { fail++; if (ok + fail == total) finish() };
30839 });
30840 transaction.onerror = onerror;
30841 };
30842 openRequest.onerror = onerror;
30843 }};var SYSCALLS={mappings:{},DEFAULT_POLLMASK:5,umask:511,calculateAt:function(dirfd, path) {
30844 if (path[0] !== '/') {
30845 // relative path
30846 var dir;
30847 if (dirfd === -100) {
30848 dir = FS.cwd();
30849 } else {
30850 var dirstream = FS.getStream(dirfd);
30851 if (!dirstream) throw new FS.ErrnoError(8);
30852 dir = dirstream.path;
30853 }
30854 path = PATH.join2(dir, path);
30855 }
30856 return path;
30857 },doStat:function(func, path, buf) {
30858 try {
30859 var stat = func(path);
30860 } catch (e) {
30861 if (e && e.node && PATH.normalize(path) !== PATH.normalize(FS.getPath(e.node))) {
30862 // an error occurred while trying to look up the path; we should just report ENOTDIR
30863 return -54;
30864 }
30865 throw e;
30866 }
30867 HEAP32[((buf)>>2)]=stat.dev;
30868 HEAP32[(((buf)+(4))>>2)]=0;
30869 HEAP32[(((buf)+(8))>>2)]=stat.ino;
30870 HEAP32[(((buf)+(12))>>2)]=stat.mode;
30871 HEAP32[(((buf)+(16))>>2)]=stat.nlink;
30872 HEAP32[(((buf)+(20))>>2)]=stat.uid;
30873 HEAP32[(((buf)+(24))>>2)]=stat.gid;
30874 HEAP32[(((buf)+(28))>>2)]=stat.rdev;
30875 HEAP32[(((buf)+(32))>>2)]=0;
30876 (tempI64 = [stat.size>>>0,(tempDouble=stat.size,(+(Math_abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? ((Math_min((+(Math_floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math_ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)],HEAP32[(((buf)+(40))>>2)]=tempI64[0],HEAP32[(((buf)+(44))>>2)]=tempI64[1]);
30877 HEAP32[(((buf)+(48))>>2)]=4096;
30878 HEAP32[(((buf)+(52))>>2)]=stat.blocks;
30879 HEAP32[(((buf)+(56))>>2)]=(stat.atime.getTime() / 1000)|0;
30880 HEAP32[(((buf)+(60))>>2)]=0;
30881 HEAP32[(((buf)+(64))>>2)]=(stat.mtime.getTime() / 1000)|0;
30882 HEAP32[(((buf)+(68))>>2)]=0;
30883 HEAP32[(((buf)+(72))>>2)]=(stat.ctime.getTime() / 1000)|0;
30884 HEAP32[(((buf)+(76))>>2)]=0;
30885 (tempI64 = [stat.ino>>>0,(tempDouble=stat.ino,(+(Math_abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? ((Math_min((+(Math_floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math_ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)],HEAP32[(((buf)+(80))>>2)]=tempI64[0],HEAP32[(((buf)+(84))>>2)]=tempI64[1]);
30886 return 0;
30887 },doMsync:function(addr, stream, len, flags, offset) {
30888 var buffer = HEAPU8.slice(addr, addr + len);
30889 FS.msync(stream, buffer, offset, len, flags);
30890 },doMkdir:function(path, mode) {
30891 // remove a trailing slash, if one - /a/b/ has basename of '', but
30892 // we want to create b in the context of this function
30893 path = PATH.normalize(path);
30894 if (path[path.length-1] === '/') path = path.substr(0, path.length-1);
30895 FS.mkdir(path, mode, 0);
30896 return 0;
30897 },doMknod:function(path, mode, dev) {
30898 // we don't want this in the JS API as it uses mknod to create all nodes.
30899 switch (mode & 61440) {
30900 case 32768:
30901 case 8192:
30902 case 24576:
30903 case 4096:
30904 case 49152:
30905 break;
30906 default: return -28;
30907 }
30908 FS.mknod(path, mode, dev);
30909 return 0;
30910 },doReadlink:function(path, buf, bufsize) {
30911 if (bufsize <= 0) return -28;
30912 var ret = FS.readlink(path);
30913
30914 var len = Math.min(bufsize, lengthBytesUTF8(ret));
30915 var endChar = HEAP8[buf+len];
30916 stringToUTF8(ret, buf, bufsize+1);
30917 // readlink is one of the rare functions that write out a C string, but does never append a null to the output buffer(!)
30918 // stringToUTF8() always appends a null byte, so restore the character under the null byte after the write.
30919 HEAP8[buf+len] = endChar;
30920
30921 return len;
30922 },doAccess:function(path, amode) {
30923 if (amode & ~7) {
30924 // need a valid mode
30925 return -28;
30926 }
30927 var node;
30928 var lookup = FS.lookupPath(path, { follow: true });
30929 node = lookup.node;
30930 if (!node) {
30931 return -44;
30932 }
30933 var perms = '';
30934 if (amode & 4) perms += 'r';
30935 if (amode & 2) perms += 'w';
30936 if (amode & 1) perms += 'x';
30937 if (perms /* otherwise, they've just passed F_OK */ && FS.nodePermissions(node, perms)) {
30938 return -2;
30939 }
30940 return 0;
30941 },doDup:function(path, flags, suggestFD) {
30942 var suggest = FS.getStream(suggestFD);
30943 if (suggest) FS.close(suggest);
30944 return FS.open(path, flags, 0, suggestFD, suggestFD).fd;
30945 },doReadv:function(stream, iov, iovcnt, offset) {
30946 var ret = 0;
30947 for (var i = 0; i < iovcnt; i++) {
30948 var ptr = HEAP32[(((iov)+(i*8))>>2)];
30949 var len = HEAP32[(((iov)+(i*8 + 4))>>2)];
30950 var curr = FS.read(stream, HEAP8,ptr, len, offset);
30951 if (curr < 0) return -1;
30952 ret += curr;
30953 if (curr < len) break; // nothing more to read
30954 }
30955 return ret;
30956 },doWritev:function(stream, iov, iovcnt, offset) {
30957 var ret = 0;
30958 for (var i = 0; i < iovcnt; i++) {
30959 var ptr = HEAP32[(((iov)+(i*8))>>2)];
30960 var len = HEAP32[(((iov)+(i*8 + 4))>>2)];
30961 var curr = FS.write(stream, HEAP8,ptr, len, offset);
30962 if (curr < 0) return -1;
30963 ret += curr;
30964 }
30965 return ret;
30966 },varargs:undefined,get:function() {
30967 SYSCALLS.varargs += 4;
30968 var ret = HEAP32[(((SYSCALLS.varargs)-(4))>>2)];
30969 return ret;
30970 },getStr:function(ptr) {
30971 var ret = UTF8ToString(ptr);
30972 return ret;
30973 },getStreamFromFD:function(fd) {
30974 var stream = FS.getStream(fd);
30975 if (!stream) throw new FS.ErrnoError(8);
30976 return stream;
30977 },get64:function(low, high) {
30978 return low;
30979 }};function _fd_close(fd) {try {
30980
30981 var stream = SYSCALLS.getStreamFromFD(fd);
30982 FS.close(stream);
30983 return 0;
30984 } catch (e) {
30985 if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
30986 return e.errno;
30987 }
30988 }
30989
30990 function _fd_read(fd, iov, iovcnt, pnum) {try {
30991
30992 var stream = SYSCALLS.getStreamFromFD(fd);
30993 var num = SYSCALLS.doReadv(stream, iov, iovcnt);
30994 HEAP32[((pnum)>>2)]=num
30995 return 0;
30996 } catch (e) {
30997 if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
30998 return e.errno;
30999 }
31000 }
31001
31002 function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {try {
31003
31004
31005 var stream = SYSCALLS.getStreamFromFD(fd);
31006 var HIGH_OFFSET = 0x100000000; // 2^32
31007 // use an unsigned operator on low and shift high by 32-bits
31008 var offset = offset_high * HIGH_OFFSET + (offset_low >>> 0);
31009
31010 var DOUBLE_LIMIT = 0x20000000000000; // 2^53
31011 // we also check for equality since DOUBLE_LIMIT + 1 == DOUBLE_LIMIT
31012 if (offset <= -DOUBLE_LIMIT || offset >= DOUBLE_LIMIT) {
31013 return -61;
31014 }
31015
31016 FS.llseek(stream, offset, whence);
31017 (tempI64 = [stream.position>>>0,(tempDouble=stream.position,(+(Math_abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? ((Math_min((+(Math_floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math_ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)],HEAP32[((newOffset)>>2)]=tempI64[0],HEAP32[(((newOffset)+(4))>>2)]=tempI64[1]);
31018 if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null; // reset readdir state
31019 return 0;
31020 } catch (e) {
31021 if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
31022 return e.errno;
31023 }
31024 }
31025
31026 function _fd_write(fd, iov, iovcnt, pnum) {try {
31027
31028 var stream = SYSCALLS.getStreamFromFD(fd);
31029 var num = SYSCALLS.doWritev(stream, iov, iovcnt);
31030 HEAP32[((pnum)>>2)]=num
31031 return 0;
31032 } catch (e) {
31033 if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
31034 return e.errno;
31035 }
31036 }
31037
31038
31039 function _round(d) {
31040 d = +d;
31041 return d >= +0 ? +Math_floor(d + +0.5) : +Math_ceil(d - +0.5);
31042 }
31043
31044 function _setTempRet0($i) {
31045 setTempRet0(($i) | 0);
31046 }
31047var FSNode = /** @constructor */ function(parent, name, mode, rdev) {
31048 if (!parent) {
31049 parent = this; // root node sets parent to itself
31050 }
31051 this.parent = parent;
31052 this.mount = parent.mount;
31053 this.mounted = null;
31054 this.id = FS.nextInode++;
31055 this.name = name;
31056 this.mode = mode;
31057 this.node_ops = {};
31058 this.stream_ops = {};
31059 this.rdev = rdev;
31060 };
31061 var readMode = 292/*292*/ | 73/*73*/;
31062 var writeMode = 146/*146*/;
31063 Object.defineProperties(FSNode.prototype, {
31064 read: {
31065 get: /** @this{FSNode} */function() {
31066 return (this.mode & readMode) === readMode;
31067 },
31068 set: /** @this{FSNode} */function(val) {
31069 val ? this.mode |= readMode : this.mode &= ~readMode;
31070 }
31071 },
31072 write: {
31073 get: /** @this{FSNode} */function() {
31074 return (this.mode & writeMode) === writeMode;
31075 },
31076 set: /** @this{FSNode} */function(val) {
31077 val ? this.mode |= writeMode : this.mode &= ~writeMode;
31078 }
31079 },
31080 isFolder: {
31081 get: /** @this{FSNode} */function() {
31082 return FS.isDir(this.mode);
31083 }
31084 },
31085 isDevice: {
31086 get: /** @this{FSNode} */function() {
31087 return FS.isChrdev(this.mode);
31088 }
31089 }
31090 });
31091 FS.FSNode = FSNode;
31092 FS.staticInit();;
31093var ASSERTIONS = false;
31094
31095
31096
31097/** @type {function(string, boolean=, number=)} */
31098function intArrayFromString(stringy, dontAddNull, length) {
31099 var len = length > 0 ? length : lengthBytesUTF8(stringy)+1;
31100 var u8array = new Array(len);
31101 var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length);
31102 if (dontAddNull) u8array.length = numBytesWritten;
31103 return u8array;
31104}
31105
31106function intArrayToString(array) {
31107 var ret = [];
31108 for (var i = 0; i < array.length; i++) {
31109 var chr = array[i];
31110 if (chr > 0xFF) {
31111 if (ASSERTIONS) {
31112 assert(false, 'Character code ' + chr + ' (' + String.fromCharCode(chr) + ') at offset ' + i + ' not in 0x00-0xFF.');
31113 }
31114 chr &= 0xFF;
31115 }
31116 ret.push(String.fromCharCode(chr));
31117 }
31118 return ret.join('');
31119}
31120
31121
31122// Copied from https://github.com/strophe/strophejs/blob/e06d027/src/polyfills.js#L149
31123
31124// This code was written by Tyler Akins and has been placed in the
31125// public domain. It would be nice if you left this header intact.
31126// Base64 code from Tyler Akins -- http://rumkin.com
31127
31128/**
31129 * Decodes a base64 string.
31130 * @param {string} input The string to decode.
31131 */
31132var decodeBase64 = typeof atob === 'function' ? atob : function (input) {
31133 var keyStr = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
31134
31135 var output = '';
31136 var chr1, chr2, chr3;
31137 var enc1, enc2, enc3, enc4;
31138 var i = 0;
31139 // remove all characters that are not A-Z, a-z, 0-9, +, /, or =
31140 input = input.replace(/[^A-Za-z0-9\+\/\=]/g, '');
31141 do {
31142 enc1 = keyStr.indexOf(input.charAt(i++));
31143 enc2 = keyStr.indexOf(input.charAt(i++));
31144 enc3 = keyStr.indexOf(input.charAt(i++));
31145 enc4 = keyStr.indexOf(input.charAt(i++));
31146
31147 chr1 = (enc1 << 2) | (enc2 >> 4);
31148 chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
31149 chr3 = ((enc3 & 3) << 6) | enc4;
31150
31151 output = output + String.fromCharCode(chr1);
31152
31153 if (enc3 !== 64) {
31154 output = output + String.fromCharCode(chr2);
31155 }
31156 if (enc4 !== 64) {
31157 output = output + String.fromCharCode(chr3);
31158 }
31159 } while (i < input.length);
31160 return output;
31161};
31162
31163// Converts a string of base64 into a byte array.
31164// Throws error on invalid input.
31165function intArrayFromBase64(s) {
31166 if (typeof ENVIRONMENT_IS_NODE === 'boolean' && ENVIRONMENT_IS_NODE) {
31167 var buf;
31168 try {
31169 // TODO: Update Node.js externs, Closure does not recognize the following Buffer.from()
31170 /**@suppress{checkTypes}*/
31171 buf = Buffer.from(s, 'base64');
31172 } catch (_) {
31173 buf = new Buffer(s, 'base64');
31174 }
31175 return new Uint8Array(buf['buffer'], buf['byteOffset'], buf['byteLength']);
31176 }
31177
31178 try {
31179 var decoded = decodeBase64(s);
31180 var bytes = new Uint8Array(decoded.length);
31181 for (var i = 0 ; i < decoded.length ; ++i) {
31182 bytes[i] = decoded.charCodeAt(i);
31183 }
31184 return bytes;
31185 } catch (_) {
31186 throw new Error('Converting base64 string to bytes failed.');
31187 }
31188}
31189
31190// If filename is a base64 data URI, parses and returns data (Buffer on node,
31191// Uint8Array otherwise). If filename is not a base64 data URI, returns undefined.
31192function tryParseAsDataURI(filename) {
31193 if (!isDataURI(filename)) {
31194 return;
31195 }
31196
31197 return intArrayFromBase64(filename.slice(dataURIPrefix.length));
31198}
31199
31200
31201// ASM_LIBRARY EXTERN PRIMITIVES: Math_floor,Math_ceil
31202
31203var asmGlobalArg = {};
31204var asmLibraryArg = { "emscripten_get_sbrk_ptr": _emscripten_get_sbrk_ptr, "emscripten_memcpy_big": _emscripten_memcpy_big, "emscripten_resize_heap": _emscripten_resize_heap, "fd_close": _fd_close, "fd_read": _fd_read, "fd_seek": _fd_seek, "fd_write": _fd_write, "getTempRet0": getTempRet0, "memory": wasmMemory, "round": _round, "setTempRet0": setTempRet0, "table": wasmTable };
31205var asm = createWasm();
31206/** @type {function(...*):?} */
31207var ___wasm_call_ctors = Module["___wasm_call_ctors"] = function() {
31208 return (___wasm_call_ctors = Module["___wasm_call_ctors"] = Module["asm"]["__wasm_call_ctors"]).apply(null, arguments);
31209};
31210
31211/** @type {function(...*):?} */
31212var _FLAC__stream_decoder_new = Module["_FLAC__stream_decoder_new"] = function() {
31213 return (_FLAC__stream_decoder_new = Module["_FLAC__stream_decoder_new"] = Module["asm"]["FLAC__stream_decoder_new"]).apply(null, arguments);
31214};
31215
31216/** @type {function(...*):?} */
31217var _FLAC__stream_decoder_delete = Module["_FLAC__stream_decoder_delete"] = function() {
31218 return (_FLAC__stream_decoder_delete = Module["_FLAC__stream_decoder_delete"] = Module["asm"]["FLAC__stream_decoder_delete"]).apply(null, arguments);
31219};
31220
31221/** @type {function(...*):?} */
31222var _FLAC__stream_decoder_finish = Module["_FLAC__stream_decoder_finish"] = function() {
31223 return (_FLAC__stream_decoder_finish = Module["_FLAC__stream_decoder_finish"] = Module["asm"]["FLAC__stream_decoder_finish"]).apply(null, arguments);
31224};
31225
31226/** @type {function(...*):?} */
31227var _FLAC__stream_decoder_init_stream = Module["_FLAC__stream_decoder_init_stream"] = function() {
31228 return (_FLAC__stream_decoder_init_stream = Module["_FLAC__stream_decoder_init_stream"] = Module["asm"]["FLAC__stream_decoder_init_stream"]).apply(null, arguments);
31229};
31230
31231/** @type {function(...*):?} */
31232var _FLAC__stream_decoder_reset = Module["_FLAC__stream_decoder_reset"] = function() {
31233 return (_FLAC__stream_decoder_reset = Module["_FLAC__stream_decoder_reset"] = Module["asm"]["FLAC__stream_decoder_reset"]).apply(null, arguments);
31234};
31235
31236/** @type {function(...*):?} */
31237var _FLAC__stream_decoder_init_ogg_stream = Module["_FLAC__stream_decoder_init_ogg_stream"] = function() {
31238 return (_FLAC__stream_decoder_init_ogg_stream = Module["_FLAC__stream_decoder_init_ogg_stream"] = Module["asm"]["FLAC__stream_decoder_init_ogg_stream"]).apply(null, arguments);
31239};
31240
31241/** @type {function(...*):?} */
31242var _FLAC__stream_decoder_set_ogg_serial_number = Module["_FLAC__stream_decoder_set_ogg_serial_number"] = function() {
31243 return (_FLAC__stream_decoder_set_ogg_serial_number = Module["_FLAC__stream_decoder_set_ogg_serial_number"] = Module["asm"]["FLAC__stream_decoder_set_ogg_serial_number"]).apply(null, arguments);
31244};
31245
31246/** @type {function(...*):?} */
31247var _FLAC__stream_decoder_set_md5_checking = Module["_FLAC__stream_decoder_set_md5_checking"] = function() {
31248 return (_FLAC__stream_decoder_set_md5_checking = Module["_FLAC__stream_decoder_set_md5_checking"] = Module["asm"]["FLAC__stream_decoder_set_md5_checking"]).apply(null, arguments);
31249};
31250
31251/** @type {function(...*):?} */
31252var _FLAC__stream_decoder_set_metadata_respond = Module["_FLAC__stream_decoder_set_metadata_respond"] = function() {
31253 return (_FLAC__stream_decoder_set_metadata_respond = Module["_FLAC__stream_decoder_set_metadata_respond"] = Module["asm"]["FLAC__stream_decoder_set_metadata_respond"]).apply(null, arguments);
31254};
31255
31256/** @type {function(...*):?} */
31257var _FLAC__stream_decoder_set_metadata_respond_application = Module["_FLAC__stream_decoder_set_metadata_respond_application"] = function() {
31258 return (_FLAC__stream_decoder_set_metadata_respond_application = Module["_FLAC__stream_decoder_set_metadata_respond_application"] = Module["asm"]["FLAC__stream_decoder_set_metadata_respond_application"]).apply(null, arguments);
31259};
31260
31261/** @type {function(...*):?} */
31262var _FLAC__stream_decoder_set_metadata_respond_all = Module["_FLAC__stream_decoder_set_metadata_respond_all"] = function() {
31263 return (_FLAC__stream_decoder_set_metadata_respond_all = Module["_FLAC__stream_decoder_set_metadata_respond_all"] = Module["asm"]["FLAC__stream_decoder_set_metadata_respond_all"]).apply(null, arguments);
31264};
31265
31266/** @type {function(...*):?} */
31267var _FLAC__stream_decoder_set_metadata_ignore = Module["_FLAC__stream_decoder_set_metadata_ignore"] = function() {
31268 return (_FLAC__stream_decoder_set_metadata_ignore = Module["_FLAC__stream_decoder_set_metadata_ignore"] = Module["asm"]["FLAC__stream_decoder_set_metadata_ignore"]).apply(null, arguments);
31269};
31270
31271/** @type {function(...*):?} */
31272var _FLAC__stream_decoder_set_metadata_ignore_application = Module["_FLAC__stream_decoder_set_metadata_ignore_application"] = function() {
31273 return (_FLAC__stream_decoder_set_metadata_ignore_application = Module["_FLAC__stream_decoder_set_metadata_ignore_application"] = Module["asm"]["FLAC__stream_decoder_set_metadata_ignore_application"]).apply(null, arguments);
31274};
31275
31276/** @type {function(...*):?} */
31277var _FLAC__stream_decoder_set_metadata_ignore_all = Module["_FLAC__stream_decoder_set_metadata_ignore_all"] = function() {
31278 return (_FLAC__stream_decoder_set_metadata_ignore_all = Module["_FLAC__stream_decoder_set_metadata_ignore_all"] = Module["asm"]["FLAC__stream_decoder_set_metadata_ignore_all"]).apply(null, arguments);
31279};
31280
31281/** @type {function(...*):?} */
31282var _FLAC__stream_decoder_get_state = Module["_FLAC__stream_decoder_get_state"] = function() {
31283 return (_FLAC__stream_decoder_get_state = Module["_FLAC__stream_decoder_get_state"] = Module["asm"]["FLAC__stream_decoder_get_state"]).apply(null, arguments);
31284};
31285
31286/** @type {function(...*):?} */
31287var _FLAC__stream_decoder_get_md5_checking = Module["_FLAC__stream_decoder_get_md5_checking"] = function() {
31288 return (_FLAC__stream_decoder_get_md5_checking = Module["_FLAC__stream_decoder_get_md5_checking"] = Module["asm"]["FLAC__stream_decoder_get_md5_checking"]).apply(null, arguments);
31289};
31290
31291/** @type {function(...*):?} */
31292var _FLAC__stream_decoder_process_single = Module["_FLAC__stream_decoder_process_single"] = function() {
31293 return (_FLAC__stream_decoder_process_single = Module["_FLAC__stream_decoder_process_single"] = Module["asm"]["FLAC__stream_decoder_process_single"]).apply(null, arguments);
31294};
31295
31296/** @type {function(...*):?} */
31297var _FLAC__stream_decoder_process_until_end_of_metadata = Module["_FLAC__stream_decoder_process_until_end_of_metadata"] = function() {
31298 return (_FLAC__stream_decoder_process_until_end_of_metadata = Module["_FLAC__stream_decoder_process_until_end_of_metadata"] = Module["asm"]["FLAC__stream_decoder_process_until_end_of_metadata"]).apply(null, arguments);
31299};
31300
31301/** @type {function(...*):?} */
31302var _FLAC__stream_decoder_process_until_end_of_stream = Module["_FLAC__stream_decoder_process_until_end_of_stream"] = function() {
31303 return (_FLAC__stream_decoder_process_until_end_of_stream = Module["_FLAC__stream_decoder_process_until_end_of_stream"] = Module["asm"]["FLAC__stream_decoder_process_until_end_of_stream"]).apply(null, arguments);
31304};
31305
31306/** @type {function(...*):?} */
31307var _FLAC__stream_encoder_new = Module["_FLAC__stream_encoder_new"] = function() {
31308 return (_FLAC__stream_encoder_new = Module["_FLAC__stream_encoder_new"] = Module["asm"]["FLAC__stream_encoder_new"]).apply(null, arguments);
31309};
31310
31311/** @type {function(...*):?} */
31312var _FLAC__stream_encoder_delete = Module["_FLAC__stream_encoder_delete"] = function() {
31313 return (_FLAC__stream_encoder_delete = Module["_FLAC__stream_encoder_delete"] = Module["asm"]["FLAC__stream_encoder_delete"]).apply(null, arguments);
31314};
31315
31316/** @type {function(...*):?} */
31317var _FLAC__stream_encoder_finish = Module["_FLAC__stream_encoder_finish"] = function() {
31318 return (_FLAC__stream_encoder_finish = Module["_FLAC__stream_encoder_finish"] = Module["asm"]["FLAC__stream_encoder_finish"]).apply(null, arguments);
31319};
31320
31321/** @type {function(...*):?} */
31322var _FLAC__stream_encoder_init_stream = Module["_FLAC__stream_encoder_init_stream"] = function() {
31323 return (_FLAC__stream_encoder_init_stream = Module["_FLAC__stream_encoder_init_stream"] = Module["asm"]["FLAC__stream_encoder_init_stream"]).apply(null, arguments);
31324};
31325
31326/** @type {function(...*):?} */
31327var _FLAC__stream_encoder_init_ogg_stream = Module["_FLAC__stream_encoder_init_ogg_stream"] = function() {
31328 return (_FLAC__stream_encoder_init_ogg_stream = Module["_FLAC__stream_encoder_init_ogg_stream"] = Module["asm"]["FLAC__stream_encoder_init_ogg_stream"]).apply(null, arguments);
31329};
31330
31331/** @type {function(...*):?} */
31332var _FLAC__stream_encoder_set_ogg_serial_number = Module["_FLAC__stream_encoder_set_ogg_serial_number"] = function() {
31333 return (_FLAC__stream_encoder_set_ogg_serial_number = Module["_FLAC__stream_encoder_set_ogg_serial_number"] = Module["asm"]["FLAC__stream_encoder_set_ogg_serial_number"]).apply(null, arguments);
31334};
31335
31336/** @type {function(...*):?} */
31337var _FLAC__stream_encoder_set_verify = Module["_FLAC__stream_encoder_set_verify"] = function() {
31338 return (_FLAC__stream_encoder_set_verify = Module["_FLAC__stream_encoder_set_verify"] = Module["asm"]["FLAC__stream_encoder_set_verify"]).apply(null, arguments);
31339};
31340
31341/** @type {function(...*):?} */
31342var _FLAC__stream_encoder_set_channels = Module["_FLAC__stream_encoder_set_channels"] = function() {
31343 return (_FLAC__stream_encoder_set_channels = Module["_FLAC__stream_encoder_set_channels"] = Module["asm"]["FLAC__stream_encoder_set_channels"]).apply(null, arguments);
31344};
31345
31346/** @type {function(...*):?} */
31347var _FLAC__stream_encoder_set_bits_per_sample = Module["_FLAC__stream_encoder_set_bits_per_sample"] = function() {
31348 return (_FLAC__stream_encoder_set_bits_per_sample = Module["_FLAC__stream_encoder_set_bits_per_sample"] = Module["asm"]["FLAC__stream_encoder_set_bits_per_sample"]).apply(null, arguments);
31349};
31350
31351/** @type {function(...*):?} */
31352var _FLAC__stream_encoder_set_sample_rate = Module["_FLAC__stream_encoder_set_sample_rate"] = function() {
31353 return (_FLAC__stream_encoder_set_sample_rate = Module["_FLAC__stream_encoder_set_sample_rate"] = Module["asm"]["FLAC__stream_encoder_set_sample_rate"]).apply(null, arguments);
31354};
31355
31356/** @type {function(...*):?} */
31357var _FLAC__stream_encoder_set_compression_level = Module["_FLAC__stream_encoder_set_compression_level"] = function() {
31358 return (_FLAC__stream_encoder_set_compression_level = Module["_FLAC__stream_encoder_set_compression_level"] = Module["asm"]["FLAC__stream_encoder_set_compression_level"]).apply(null, arguments);
31359};
31360
31361/** @type {function(...*):?} */
31362var _FLAC__stream_encoder_set_blocksize = Module["_FLAC__stream_encoder_set_blocksize"] = function() {
31363 return (_FLAC__stream_encoder_set_blocksize = Module["_FLAC__stream_encoder_set_blocksize"] = Module["asm"]["FLAC__stream_encoder_set_blocksize"]).apply(null, arguments);
31364};
31365
31366/** @type {function(...*):?} */
31367var _FLAC__stream_encoder_set_total_samples_estimate = Module["_FLAC__stream_encoder_set_total_samples_estimate"] = function() {
31368 return (_FLAC__stream_encoder_set_total_samples_estimate = Module["_FLAC__stream_encoder_set_total_samples_estimate"] = Module["asm"]["FLAC__stream_encoder_set_total_samples_estimate"]).apply(null, arguments);
31369};
31370
31371/** @type {function(...*):?} */
31372var _FLAC__stream_encoder_set_metadata = Module["_FLAC__stream_encoder_set_metadata"] = function() {
31373 return (_FLAC__stream_encoder_set_metadata = Module["_FLAC__stream_encoder_set_metadata"] = Module["asm"]["FLAC__stream_encoder_set_metadata"]).apply(null, arguments);
31374};
31375
31376/** @type {function(...*):?} */
31377var _FLAC__stream_encoder_get_state = Module["_FLAC__stream_encoder_get_state"] = function() {
31378 return (_FLAC__stream_encoder_get_state = Module["_FLAC__stream_encoder_get_state"] = Module["asm"]["FLAC__stream_encoder_get_state"]).apply(null, arguments);
31379};
31380
31381/** @type {function(...*):?} */
31382var _FLAC__stream_encoder_get_verify_decoder_state = Module["_FLAC__stream_encoder_get_verify_decoder_state"] = function() {
31383 return (_FLAC__stream_encoder_get_verify_decoder_state = Module["_FLAC__stream_encoder_get_verify_decoder_state"] = Module["asm"]["FLAC__stream_encoder_get_verify_decoder_state"]).apply(null, arguments);
31384};
31385
31386/** @type {function(...*):?} */
31387var _FLAC__stream_encoder_get_verify = Module["_FLAC__stream_encoder_get_verify"] = function() {
31388 return (_FLAC__stream_encoder_get_verify = Module["_FLAC__stream_encoder_get_verify"] = Module["asm"]["FLAC__stream_encoder_get_verify"]).apply(null, arguments);
31389};
31390
31391/** @type {function(...*):?} */
31392var _FLAC__stream_encoder_process = Module["_FLAC__stream_encoder_process"] = function() {
31393 return (_FLAC__stream_encoder_process = Module["_FLAC__stream_encoder_process"] = Module["asm"]["FLAC__stream_encoder_process"]).apply(null, arguments);
31394};
31395
31396/** @type {function(...*):?} */
31397var _FLAC__stream_encoder_process_interleaved = Module["_FLAC__stream_encoder_process_interleaved"] = function() {
31398 return (_FLAC__stream_encoder_process_interleaved = Module["_FLAC__stream_encoder_process_interleaved"] = Module["asm"]["FLAC__stream_encoder_process_interleaved"]).apply(null, arguments);
31399};
31400
31401/** @type {function(...*):?} */
31402var ___errno_location = Module["___errno_location"] = function() {
31403 return (___errno_location = Module["___errno_location"] = Module["asm"]["__errno_location"]).apply(null, arguments);
31404};
31405
31406/** @type {function(...*):?} */
31407var stackSave = Module["stackSave"] = function() {
31408 return (stackSave = Module["stackSave"] = Module["asm"]["stackSave"]).apply(null, arguments);
31409};
31410
31411/** @type {function(...*):?} */
31412var stackRestore = Module["stackRestore"] = function() {
31413 return (stackRestore = Module["stackRestore"] = Module["asm"]["stackRestore"]).apply(null, arguments);
31414};
31415
31416/** @type {function(...*):?} */
31417var stackAlloc = Module["stackAlloc"] = function() {
31418 return (stackAlloc = Module["stackAlloc"] = Module["asm"]["stackAlloc"]).apply(null, arguments);
31419};
31420
31421/** @type {function(...*):?} */
31422var _malloc = Module["_malloc"] = function() {
31423 return (_malloc = Module["_malloc"] = Module["asm"]["malloc"]).apply(null, arguments);
31424};
31425
31426/** @type {function(...*):?} */
31427var _free = Module["_free"] = function() {
31428 return (_free = Module["_free"] = Module["asm"]["free"]).apply(null, arguments);
31429};
31430
31431/** @type {function(...*):?} */
31432var __growWasmMemory = Module["__growWasmMemory"] = function() {
31433 return (__growWasmMemory = Module["__growWasmMemory"] = Module["asm"]["__growWasmMemory"]).apply(null, arguments);
31434};
31435
31436/** @type {function(...*):?} */
31437var dynCall_iii = Module["dynCall_iii"] = function() {
31438 return (dynCall_iii = Module["dynCall_iii"] = Module["asm"]["dynCall_iii"]).apply(null, arguments);
31439};
31440
31441/** @type {function(...*):?} */
31442var dynCall_ii = Module["dynCall_ii"] = function() {
31443 return (dynCall_ii = Module["dynCall_ii"] = Module["asm"]["dynCall_ii"]).apply(null, arguments);
31444};
31445
31446/** @type {function(...*):?} */
31447var dynCall_iiii = Module["dynCall_iiii"] = function() {
31448 return (dynCall_iiii = Module["dynCall_iiii"] = Module["asm"]["dynCall_iiii"]).apply(null, arguments);
31449};
31450
31451/** @type {function(...*):?} */
31452var dynCall_jiji = Module["dynCall_jiji"] = function() {
31453 return (dynCall_jiji = Module["dynCall_jiji"] = Module["asm"]["dynCall_jiji"]).apply(null, arguments);
31454};
31455
31456/** @type {function(...*):?} */
31457var dynCall_viiiiii = Module["dynCall_viiiiii"] = function() {
31458 return (dynCall_viiiiii = Module["dynCall_viiiiii"] = Module["asm"]["dynCall_viiiiii"]).apply(null, arguments);
31459};
31460
31461/** @type {function(...*):?} */
31462var dynCall_iiiii = Module["dynCall_iiiii"] = function() {
31463 return (dynCall_iiiii = Module["dynCall_iiiii"] = Module["asm"]["dynCall_iiiii"]).apply(null, arguments);
31464};
31465
31466/** @type {function(...*):?} */
31467var dynCall_viiiiiii = Module["dynCall_viiiiiii"] = function() {
31468 return (dynCall_viiiiiii = Module["dynCall_viiiiiii"] = Module["asm"]["dynCall_viiiiiii"]).apply(null, arguments);
31469};
31470
31471/** @type {function(...*):?} */
31472var dynCall_viiii = Module["dynCall_viiii"] = function() {
31473 return (dynCall_viiii = Module["dynCall_viiii"] = Module["asm"]["dynCall_viiii"]).apply(null, arguments);
31474};
31475
31476/** @type {function(...*):?} */
31477var dynCall_viii = Module["dynCall_viii"] = function() {
31478 return (dynCall_viii = Module["dynCall_viii"] = Module["asm"]["dynCall_viii"]).apply(null, arguments);
31479};
31480
31481
31482
31483
31484
31485// === Auto-generated postamble setup entry stuff ===
31486
31487
31488
31489
31490Module["ccall"] = ccall;
31491Module["cwrap"] = cwrap;
31492Module["setValue"] = setValue;
31493Module["getValue"] = getValue;
31494
31495
31496
31497
31498
31499
31500
31501
31502
31503
31504
31505
31506
31507
31508
31509
31510
31511
31512
31513
31514
31515
31516
31517
31518
31519
31520
31521
31522
31523
31524
31525
31526
31527
31528
31529
31530
31531
31532
31533
31534
31535
31536
31537
31538
31539
31540
31541
31542
31543
31544
31545
31546
31547
31548
31549
31550
31551
31552
31553
31554
31555
31556
31557
31558
31559
31560
31561
31562
31563
31564
31565
31566
31567
31568
31569
31570
31571
31572
31573
31574
31575
31576
31577
31578
31579
31580
31581
31582
31583
31584
31585
31586
31587
31588
31589
31590
31591
31592
31593
31594
31595
31596
31597
31598
31599
31600
31601
31602
31603
31604
31605
31606
31607
31608
31609
31610
31611
31612
31613
31614
31615
31616
31617
31618
31619
31620
31621
31622
31623
31624
31625
31626
31627
31628var calledRun;
31629
31630/**
31631 * @constructor
31632 * @this {ExitStatus}
31633 */
31634function ExitStatus(status) {
31635 this.name = "ExitStatus";
31636 this.message = "Program terminated with exit(" + status + ")";
31637 this.status = status;
31638}
31639
31640var calledMain = false;
31641
31642
31643dependenciesFulfilled = function runCaller() {
31644 // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false)
31645 if (!calledRun) run();
31646 if (!calledRun) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled
31647};
31648
31649
31650
31651
31652
31653/** @type {function(Array=)} */
31654function run(args) {
31655 args = args || arguments_;
31656
31657 if (runDependencies > 0) {
31658 return;
31659 }
31660
31661
31662 preRun();
31663
31664 if (runDependencies > 0) return; // a preRun added a dependency, run will be called later
31665
31666 function doRun() {
31667 // run may have just been called through dependencies being fulfilled just in this very frame,
31668 // or while the async setStatus time below was happening
31669 if (calledRun) return;
31670 calledRun = true;
31671 Module['calledRun'] = true;
31672
31673 if (ABORT) return;
31674
31675 initRuntime();
31676
31677 preMain();
31678
31679 if (Module['onRuntimeInitialized']) Module['onRuntimeInitialized']();
31680
31681
31682 postRun();
31683 }
31684
31685 if (Module['setStatus']) {
31686 Module['setStatus']('Running...');
31687 setTimeout(function() {
31688 setTimeout(function() {
31689 Module['setStatus']('');
31690 }, 1);
31691 doRun();
31692 }, 1);
31693 } else
31694 {
31695 doRun();
31696 }
31697}
31698Module['run'] = run;
31699
31700
31701/** @param {boolean|number=} implicit */
31702function exit(status, implicit) {
31703
31704 // if this is just main exit-ing implicitly, and the status is 0, then we
31705 // don't need to do anything here and can just leave. if the status is
31706 // non-zero, though, then we need to report it.
31707 // (we may have warned about this earlier, if a situation justifies doing so)
31708 if (implicit && noExitRuntime && status === 0) {
31709 return;
31710 }
31711
31712 if (noExitRuntime) {
31713 } else {
31714
31715 ABORT = true;
31716 EXITSTATUS = status;
31717
31718 exitRuntime();
31719
31720 if (Module['onExit']) Module['onExit'](status);
31721 }
31722
31723 quit_(status, new ExitStatus(status));
31724}
31725
31726if (Module['preInit']) {
31727 if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']];
31728 while (Module['preInit'].length > 0) {
31729 Module['preInit'].pop()();
31730 }
31731}
31732
31733
31734 noExitRuntime = true;
31735
31736run();
31737
31738
31739
31740
31741
31742
31743// {{MODULE_ADDITIONS}}
31744
31745
31746
31747//libflac function wrappers
31748
31749/**
31750 * HELPER read/extract stream info meta-data from frame header / meta-data
31751 * @param {POINTER} p_streaminfo
31752 * @returns StreamInfo
31753 */
31754function _readStreamInfo(p_streaminfo){//-> FLAC__StreamMetadata.type (FLAC__MetadataType) === FLAC__METADATA_TYPE_STREAMINFO (0)
31755
31756 /*
31757 typedef struct {
31758 unsigned min_blocksize, max_blocksize;
31759 unsigned min_framesize, max_framesize;
31760 unsigned sample_rate;
31761 unsigned channels;
31762 unsigned bits_per_sample;
31763 FLAC__uint64 total_samples;
31764 FLAC__byte md5sum[16];
31765 } FLAC__StreamMetadata_StreamInfo;
31766 */
31767
31768 var min_blocksize = Module.getValue(p_streaminfo,'i32');//4 bytes
31769 var max_blocksize = Module.getValue(p_streaminfo+4,'i32');//4 bytes
31770
31771 var min_framesize = Module.getValue(p_streaminfo+8,'i32');//4 bytes
31772 var max_framesize = Module.getValue(p_streaminfo+12,'i32');//4 bytes
31773
31774 var sample_rate = Module.getValue(p_streaminfo+16,'i32');//4 bytes
31775 var channels = Module.getValue(p_streaminfo+20,'i32');//4 bytes
31776
31777 var bits_per_sample = Module.getValue(p_streaminfo+24,'i32');//4 bytes
31778
31779 //FIXME should be at p_streaminfo+28, but seems to be at p_streaminfo+32
31780 var total_samples = Module.getValue(p_streaminfo+32,'i64');//8 bytes
31781
31782 var md5sum = _readMd5(p_streaminfo+40);//16 bytes
31783
31784 return {
31785 min_blocksize: min_blocksize,
31786 max_blocksize: max_blocksize,
31787 min_framesize: min_framesize,
31788 max_framesize: max_framesize,
31789 sampleRate: sample_rate,
31790 channels: channels,
31791 bitsPerSample: bits_per_sample,
31792 total_samples: total_samples,
31793 md5sum: md5sum
31794 };
31795}
31796
31797/**
31798 * read MD5 checksum
31799 * @param {POINTER} p_md5
31800 * @returns {String} as HEX string representation
31801 */
31802function _readMd5(p_md5){
31803
31804 var sb = [], v, str;
31805 for(var i=0, len = 16; i < len; ++i){
31806 v = Module.getValue(p_md5+i,'i8');//1 byte
31807 if(v < 0) v = 256 + v;//<- "convert" to uint8, if necessary
31808 str = v.toString(16);
31809 if(str.length < 2) str = '0' + str;//<- add padding, if necessary
31810 sb.push(str);
31811 }
31812 return sb.join('');
31813}
31814
31815/**
31816 * HELPER: read frame data
31817 *
31818 * @param {POINTER} p_frame
31819 * @param {CodingOptions} [enc_opt]
31820 * @returns FrameHeader
31821 */
31822function _readFrameHdr(p_frame, enc_opt){
31823
31824 /*
31825 typedef struct {
31826 unsigned blocksize;
31827 unsigned sample_rate;
31828 unsigned channels;
31829 FLAC__ChannelAssignment channel_assignment;
31830 unsigned bits_per_sample;
31831 FLAC__FrameNumberType number_type;
31832 union {
31833 FLAC__uint32 frame_number;
31834 FLAC__uint64 sample_number;
31835 } number;
31836 FLAC__uint8 crc;
31837 } FLAC__FrameHeader;
31838 */
31839
31840 var blocksize = Module.getValue(p_frame,'i32');//4 bytes
31841 var sample_rate = Module.getValue(p_frame+4,'i32');//4 bytes
31842 var channels = Module.getValue(p_frame+8,'i32');//4 bytes
31843
31844 // 0: FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT independent channels
31845 // 1: FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE left+side stereo
31846 // 2: FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE right+side stereo
31847 // 3: FLAC__CHANNEL_ASSIGNMENT_MID_SIDE mid+side stereo
31848 var channel_assignment = Module.getValue(p_frame+12,'i32');//4 bytes
31849
31850 var bits_per_sample = Module.getValue(p_frame+16,'i32');
31851
31852 // 0: FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER number contains the frame number
31853 // 1: FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER number contains the sample number of first sample in frame
31854 var number_type = Module.getValue(p_frame+20,'i32');
31855
31856 // union {} number: The frame number or sample number of first sample in frame; use the number_type value to determine which to use.
31857 var frame_number = Module.getValue(p_frame+24,'i32');
31858 var sample_number = Module.getValue(p_frame+24,'i64');
31859
31860 var number = number_type === 0? frame_number : sample_number;
31861 var numberType = number_type === 0? 'frames' : 'samples';
31862
31863 var crc = Module.getValue(p_frame+36,'i8');
31864
31865 var subframes;
31866 if(enc_opt && enc_opt.analyseSubframes){
31867 var subOffset = {offset: 40};
31868 subframes = [];
31869 for(var i=0; i < channels; ++i){
31870 subframes.push(_readSubFrameHdr(p_frame, subOffset, blocksize, enc_opt));
31871 }
31872 //TODO read footer
31873 // console.log(' footer crc ', Module.getValue(p_frame + subOffset.offset,'i16'));
31874 }
31875
31876 return {
31877 blocksize: blocksize,
31878 sampleRate: sample_rate,
31879 channels: channels,
31880 channelAssignment: channel_assignment,
31881 bitsPerSample: bits_per_sample,
31882 number: number,
31883 numberType: numberType,
31884 crc: crc,
31885 subframes: subframes
31886 };
31887}
31888
31889
31890function _readSubFrameHdr(p_subframe, subOffset, block_size, enc_opt){
31891 /*
31892 FLAC__SubframeType type
31893 union {
31894 FLAC__Subframe_Constant constant
31895 FLAC__Subframe_Fixed fixed
31896 FLAC__Subframe_LPC lpc
31897 FLAC__Subframe_Verbatim verbatim
31898 } data
31899 unsigned wasted_bits
31900 */
31901
31902 var type = Module.getValue(p_subframe + subOffset.offset, 'i32');
31903 subOffset.offset += 4;
31904
31905 var data;
31906 switch(type){
31907 case 0: //FLAC__SUBFRAME_TYPE_CONSTANT
31908 data = {value: Module.getValue(p_subframe + subOffset.offset, 'i32')};
31909 subOffset.offset += 284;//4;
31910 break;
31911 case 1: //FLAC__SUBFRAME_TYPE_VERBATIM
31912 data = Module.getValue(p_subframe + subOffset.offset, 'i32');
31913 subOffset.offset += 284;//4;
31914 break;
31915 case 2: //FLAC__SUBFRAME_TYPE_FIXED
31916 data = _readSubFrameHdrFixedData(p_subframe, subOffset, block_size, false, enc_opt);
31917 break;
31918 case 3: //FLAC__SUBFRAME_TYPE_LPC
31919 data = _readSubFrameHdrFixedData(p_subframe, subOffset, block_size, true, enc_opt);
31920 break;
31921 }
31922
31923 var offset = subOffset.offset;
31924 var wasted_bits = Module.getValue(p_subframe + offset, 'i32');
31925 subOffset.offset += 4;
31926
31927 return {
31928 type: type,//['CONSTANT', 'VERBATIM', 'FIXED', 'LPC'][type],
31929 data: data,
31930 wastedBits: wasted_bits
31931 }
31932}
31933
31934function _readSubFrameHdrFixedData(p_subframe_data, subOffset, block_size, is_lpc, enc_opt){
31935
31936 var offset = subOffset.offset;
31937
31938 var data = {order: -1, contents: {parameters: [], rawBits: []}};
31939 //FLAC__Subframe_Fixed:
31940 // FLAC__EntropyCodingMethod entropy_coding_method
31941 // unsigned order
31942 // FLAC__int32 warmup [FLAC__MAX_FIXED_ORDER]
31943 // const FLAC__int32 * residual
31944
31945 //FLAC__EntropyCodingMethod:
31946 // FLAC__EntropyCodingMethodType type
31947 // union {
31948 // FLAC__EntropyCodingMethod_PartitionedRice partitioned_rice
31949 // } data
31950
31951 //FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE 0 Residual is coded by partitioning into contexts, each with it's own 4-bit Rice parameter.
31952 //FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2 1 Residual is coded by partitioning into contexts, each with it's own 5-bit Rice parameter.
31953 var entropyType = Module.getValue(p_subframe_data, 'i32');
31954 offset += 4;
31955
31956 //FLAC__EntropyCodingMethod_PartitionedRice:
31957 // unsigned order
31958 var entropyOrder = Module.getValue(p_subframe_data + offset, 'i32');
31959 data.order = entropyOrder;
31960 offset += 4;
31961
31962 //FLAC__EntropyCodingMethod_PartitionedRice:
31963 // FLAC__EntropyCodingMethod_PartitionedRiceContents * contents
31964 var partitions = 1 << entropyOrder, params = data.contents.parameters, raws = data.contents.rawBits;
31965 //FLAC__EntropyCodingMethod_PartitionedRiceContents
31966 // unsigned * parameters
31967 // unsigned * raw_bits
31968 // unsigned capacity_by_order
31969 var ppart = Module.getValue(p_subframe_data + offset, 'i32');
31970 var pparams = Module.getValue(ppart, 'i32');
31971 var praw = Module.getValue(ppart + 4, 'i32');
31972 data.contents.capacityByOrder = Module.getValue(ppart + 8, 'i32');
31973 for(var i=0; i < partitions; ++i){
31974 params.push(Module.getValue(pparams + (i*4), 'i32'));
31975 raws.push(Module.getValue(praw + (i*4), 'i32'));
31976 }
31977 offset += 4;
31978
31979 //FLAC__Subframe_Fixed:
31980 // unsigned order
31981 var order = Module.getValue(p_subframe_data + offset, 'i32');
31982 offset += 4;
31983
31984 var warmup = [], res;
31985
31986 if(is_lpc){
31987 //FLAC__Subframe_LPC
31988
31989 // unsigned qlp_coeff_precision
31990 var qlp_coeff_precision = Module.getValue(p_subframe_data + offset, 'i32');
31991 offset += 4;
31992 // int quantization_level
31993 var quantization_level = Module.getValue(p_subframe_data + offset, 'i32');
31994 offset += 4;
31995
31996 //FLAC__Subframe_LPC :
31997 // FLAC__int32 qlp_coeff [FLAC__MAX_LPC_ORDER]
31998 var qlp_coeff = [];
31999 for(var i=0; i < order; ++i){
32000 qlp_coeff.push(Module.getValue(p_subframe_data + offset, 'i32'));
32001 offset += 4;
32002 }
32003 data.qlp_coeff = qlp_coeff;
32004 data.qlp_coeff_precision = qlp_coeff_precision;
32005 data.quantization_level = quantization_level;
32006
32007 //FLAC__Subframe_LPC:
32008 // FLAC__int32 warmup [FLAC__MAX_LPC_ORDER]
32009 offset = subOffset.offset + 152;
32010 offset = _readSubFrameHdrWarmup(p_subframe_data, offset, warmup, order);
32011
32012 //FLAC__Subframe_LPC:
32013 // const FLAC__int32 * residual
32014 if(enc_opt && enc_opt.analyseResiduals){
32015 offset = subOffset.offset + 280;
32016 res = _readSubFrameHdrResidual(p_subframe_data + offset, block_size, order);
32017 }
32018
32019 } else {
32020
32021 //FLAC__Subframe_Fixed:
32022 // FLAC__int32 warmup [FLAC__MAX_FIXED_ORDER]
32023 offset = _readSubFrameHdrWarmup(p_subframe_data, offset, warmup, order);
32024
32025 //FLAC__Subframe_Fixed:
32026 // const FLAC__int32 * residual
32027 offset = subOffset.offset + 32;
32028 if(enc_opt && enc_opt.analyseResiduals){
32029 res = _readSubFrameHdrResidual(p_subframe_data + offset, block_size, order);
32030 }
32031 }
32032
32033 subOffset.offset += 284;
32034 return {
32035 partition: {
32036 type: entropyType,
32037 data: data
32038 },
32039 order: order,
32040 warmup: warmup,
32041 residual: res
32042 }
32043}
32044
32045
32046function _readSubFrameHdrWarmup(p_subframe_data, offset, warmup, order){
32047
32048 // FLAC__int32 warmup [FLAC__MAX_FIXED_ORDER | FLAC__MAX_LPC_ORDER]
32049 for(var i=0; i < order; ++i){
32050 warmup.push(Module.getValue(p_subframe_data + offset, 'i32'));
32051 offset += 4;
32052 }
32053 return offset;
32054}
32055
32056
32057function _readSubFrameHdrResidual(p_subframe_data_res, block_size, order){
32058 // const FLAC__int32 * residual
32059 var pres = Module.getValue(p_subframe_data_res, 'i32');
32060 var res = [];//Module.getValue(pres, 'i32');
32061 //TODO read residual all values(?)
32062 // -> "The residual signal, length == (blocksize minus order) samples.
32063 for(var i=0, size = block_size - order; i < size; ++i){
32064 res.push(Module.getValue(pres + (i*4), 'i32'));
32065 }
32066 return res;
32067}
32068
32069function _readConstChar(ptr, length, sb){
32070 sb.splice(0);
32071 var ch;
32072 for(var i=0; i < length; ++i){
32073 ch = Module.getValue(ptr + i,'i8');
32074 if(ch === 0){
32075 break;
32076 }
32077 sb.push(String.fromCodePoint(ch));
32078 }
32079 return sb.join('');
32080}
32081
32082function _readNullTerminatedChar(ptr, sb){
32083 sb.splice(0);
32084 var ch = 1, i = 0;
32085 while(ch > 0){
32086 ch = Module.getValue(ptr + i++, 'i8');
32087 if(ch === 0){
32088 break;
32089 }
32090 sb.push(String.fromCodePoint(ch));
32091 }
32092 return sb.join('');
32093}
32094
32095
32096/**
32097 * HELPER read/extract padding metadata meta-data from meta-data block
32098 * @param {POINTER} p_padding_metadata
32099 * @returns PaddingMetadata
32100 */
32101function _readPaddingMetadata(p_padding_metadata){//-> FLAC__StreamMetadata.type (FLAC__MetadataType) === FLAC__METADATA_TYPE_PADDING (1)
32102
32103 //FLAC__StreamMetadata_Padding:
32104 // int dummy
32105 return {
32106 dummy: Module.getValue(p_padding_metadata,'i32')
32107 }
32108}
32109
32110/**
32111 * HELPER read/extract application metadata meta-data from meta-data block
32112 * @param {POINTER} p_application_metadata
32113 * @returns ApplicationMetadata
32114 */
32115function _readApplicationMetadata(p_application_metadata){//-> FLAC__StreamMetadata.type (FLAC__MetadataType) === FLAC__METADATA_TYPE_APPLICATION (2)
32116
32117 //FLAC__StreamMetadata_Application:
32118 // FLAC__byte id [4]
32119 // FLAC__byte * data
32120 return {
32121 id : Module.getValue(p_application_metadata,'i32'),
32122 data: Module.getValue(p_application_metadata + 4,'i32')//TODO should read (binary) data?
32123 }
32124}
32125
32126
32127/**
32128 * HELPER read/extract seek table metadata meta-data from meta-data block
32129 * @param {POINTER} p_seek_table_metadata
32130 * @returns SeekTableMetadata
32131 */
32132function _readSeekTableMetadata(p_seek_table_metadata){//-> FLAC__StreamMetadata.type (FLAC__MetadataType) === FLAC__METADATA_TYPE_SEEKTABLE (3)
32133
32134 //FLAC__StreamMetadata_SeekTable:
32135 // unsigned num_points
32136 // FLAC__StreamMetadata_SeekPoint * points
32137
32138 var num_points = Module.getValue(p_seek_table_metadata,'i32');
32139
32140 var ptrPoints = Module.getValue(p_seek_table_metadata + 4,'i32');
32141 var points = [];
32142 for(var i=0; i < num_points; ++i){
32143
32144 //FLAC__StreamMetadata_SeekPoint:
32145 // FLAC__uint64 sample_number
32146 // FLAC__uint64 stream_offset
32147 // unsigned frame_samples
32148
32149 points.push({
32150 sample_number: Module.getValue(ptrPoints + (i * 24),'i64'),
32151 stream_offset: Module.getValue(ptrPoints + (i * 24) + 8,'i64'),
32152 frame_samples: Module.getValue(ptrPoints + (i * 24) + 16,'i32')
32153 });
32154 }
32155
32156 return {
32157 num_points: num_points,
32158 points: points
32159 }
32160}
32161
32162/**
32163 * HELPER read/extract vorbis comment meta-data from meta-data block
32164 * @param {POINTER} p_vorbiscomment
32165 * @returns VorbisComment
32166 */
32167function _readVorbisComment(p_vorbiscomment){//-> FLAC__StreamMetadata.type (FLAC__MetadataType) === FLAC__METADATA_TYPE_VORBIS_COMMENT (4)
32168
32169 // FLAC__StreamMetadata_VorbisComment
32170 // FLAC__StreamMetadata_VorbisComment_Entry vendor_string:
32171 // FLAC__uint32 length
32172 // FLAC__byte * entry
32173 var length = Module.getValue(p_vorbiscomment,'i32');
32174 var entry = Module.getValue(p_vorbiscomment + 4,'i32');
32175
32176 var sb = [];
32177 var strEntry = _readConstChar(entry, length, sb);
32178
32179 // FLAC__uint32 num_comments
32180 var num_comments = Module.getValue(p_vorbiscomment + 8,'i32');
32181
32182 // FLAC__StreamMetadata_VorbisComment_Entry * comments
32183 var comments = [], clen, centry;
32184 var pc = Module.getValue(p_vorbiscomment + 12, 'i32')
32185 for(var i=0; i < num_comments; ++i){
32186
32187 // FLAC__StreamMetadata_VorbisComment_Entry
32188 // FLAC__uint32 length
32189 // FLAC__byte * entry
32190
32191 clen = Module.getValue(pc + (i*8), 'i32');
32192 if(clen === 0){
32193 continue;
32194 }
32195
32196 centry = Module.getValue(pc + (i*8) + 4, 'i32');
32197 comments.push(_readConstChar(centry, clen, sb));
32198 }
32199
32200 return {
32201 vendor_string: strEntry,
32202 num_comments: num_comments,
32203 comments: comments
32204 }
32205}
32206
32207/**
32208 * HELPER read/extract cue sheet meta-data from meta-data block
32209 * @param {POINTER} p_cue_sheet
32210 * @returns CueSheetMetadata
32211 */
32212function _readCueSheetMetadata(p_cue_sheet){//-> FLAC__StreamMetadata.type (FLAC__MetadataType) === FLAC__METADATA_TYPE_CUESHEET (5)
32213
32214 // char media_catalog_number [129]
32215 // FLAC__uint64 lead_in
32216 // FLAC__bool is_cd
32217 // unsigned num_tracks
32218 // FLAC__StreamMetadata_CueSheet_Track * tracks
32219
32220 var sb = [];
32221 var media_catalog_number = _readConstChar(p_cue_sheet, 129, sb);
32222
32223 var lead_in = Module.getValue(p_cue_sheet + 136,'i64');
32224
32225 var is_cd = Module.getValue(p_cue_sheet + 144,'i8');
32226 var num_tracks = Module.getValue(p_cue_sheet + 148,'i32');
32227
32228 var ptrTrack = Module.getValue(p_cue_sheet + 152,'i32');
32229 var tracks = [], trackOffset = ptrTrack;
32230 if(ptrTrack !== 0){
32231
32232 for(var i=0; i < num_tracks; ++i){
32233
32234 var tr = _readCueSheetMetadata_track(trackOffset, sb);
32235 tracks.push(tr);
32236 trackOffset += 32;
32237 }
32238 }
32239
32240 return {
32241 media_catalog_number: media_catalog_number,
32242 lead_in: lead_in,
32243 is_cd: is_cd,
32244 num_tracks: num_tracks,
32245 tracks: tracks
32246 }
32247}
32248
32249/**
32250 * helper read track data for cue-sheet metadata
32251 * @param {POINTER} p_cue_sheet_track pointer to the track data
32252 * @param {string[]} sb "string buffer" temporary buffer for reading string (may be reset)
32253 * @return {CueSheetTrack}
32254 */
32255function _readCueSheetMetadata_track(p_cue_sheet_track, sb){
32256
32257 // FLAC__StreamMetadata_CueSheet_Track:
32258 // FLAC__uint64 offset
32259 // FLAC__byte number
32260 // char isrc [13]
32261 // unsigned type:1
32262 // unsigned pre_emphasis:1
32263 // FLAC__byte num_indices
32264 // FLAC__StreamMetadata_CueSheet_Index * indices
32265
32266 var typePremph = Module.getValue(p_cue_sheet_track + 22,'i8');
32267 var num_indices = Module.getValue(p_cue_sheet_track + 23,'i8');
32268
32269 var indices = [];
32270 var track = {
32271 offset: Module.getValue(p_cue_sheet_track,'i64'),
32272 number: Module.getValue(p_cue_sheet_track + 8,'i8') &255,
32273 isrc: _readConstChar(p_cue_sheet_track + 9, 13, sb),
32274 type: typePremph & 1? 'NON_AUDIO' : 'AUDIO',
32275 pre_emphasis: !!(typePremph & 2),
32276 num_indices: num_indices,
32277 indices: indices
32278 }
32279
32280 var idx;
32281 if(num_indices > 0){
32282 idx = Module.getValue(p_cue_sheet_track + 24,'i32');
32283
32284 //FLAC__StreamMetadata_CueSheet_Index:
32285 // FLAC__uint64 offset
32286 // FLAC__byte number
32287
32288 for(var i=0; i < num_indices; ++i){
32289 indices.push({
32290 offset: Module.getValue(idx + (i*16),'i64'),
32291 number: Module.getValue(idx + (i*16) + 8,'i8')
32292 });
32293 }
32294 }
32295
32296 return track;
32297}
32298
32299/**
32300 * HELPER read/extract picture meta-data from meta-data block
32301 * @param {POINTER} p_picture_metadata
32302 * @returns PictureMetadata
32303 */
32304function _readPictureMetadata(p_picture_metadata){//-> FLAC__StreamMetadata.type (FLAC__MetadataType) === FLAC__METADATA_TYPE_PICTURE (6)
32305
32306 // FLAC__StreamMetadata_Picture_Type type
32307 // char * mime_type
32308 // FLAC__byte * description
32309 // FLAC__uint32 width
32310 // FLAC__uint32 height
32311 // FLAC__uint32 depth
32312 // FLAC__uint32 colors
32313 // FLAC__uint32 data_length
32314 // FLAC__byte * data
32315
32316 var type = Module.getValue(p_picture_metadata,'i32');
32317
32318 var mime = Module.getValue(p_picture_metadata + 4,'i32');
32319
32320 var sb = [];
32321 var mime_type = _readNullTerminatedChar(mime, sb);
32322
32323 var desc = Module.getValue(p_picture_metadata + 8,'i32');
32324 var description = _readNullTerminatedChar(desc, sb);
32325
32326 var width = Module.getValue(p_picture_metadata + 12,'i32');
32327 var height = Module.getValue(p_picture_metadata + 16,'i32');
32328 var depth = Module.getValue(p_picture_metadata + 20,'i32');
32329 var colors = Module.getValue(p_picture_metadata + 24,'i32');
32330 var data_length = Module.getValue(p_picture_metadata + 28,'i32');
32331
32332 var data = Module.getValue(p_picture_metadata + 32,'i32');
32333
32334 var buffer = Uint8Array.from(Module.HEAPU8.subarray(data, data + data_length));
32335
32336 return {
32337 type: type,
32338 mime_type: mime_type,
32339 description: description,
32340 width: width,
32341 height: height,
32342 depth: depth,
32343 colors: colors,
32344 data_length: data_length,
32345 data: buffer
32346 }
32347}
32348
32349/**
32350 * HELPER workaround / fix for returned write-buffer when decoding FLAC
32351 *
32352 * @param {number} heapOffset
32353 * the offset for the data on HEAPU8
32354 * @param {Uint8Array} newBuffer
32355 * the target buffer into which the data should be written -- with the correct (block) size
32356 * @param {boolean} applyFix
32357 * whether or not to apply the data repair heuristics
32358 * (handling duplicated/triplicated values in raw data)
32359 */
32360function __fix_write_buffer(heapOffset, newBuffer, applyFix){
32361
32362 var dv = new DataView(newBuffer.buffer);
32363 var targetSize = newBuffer.length;
32364
32365 var increase = !applyFix? 1 : 2;//<- for FIX/workaround, NOTE: e.g. if 24-bit padding occurres, there is no fix/increase needed (more details comment below)
32366 var buffer = HEAPU8.subarray(heapOffset, heapOffset + targetSize * increase);
32367
32368 // FIXME for some reason, the bytes values 0 (min) and 255 (max) get "triplicated",
32369 // or inserted "doubled" which should be ignored, i.e.
32370 // x x x -> x
32371 // x x -> <ignored>
32372 // where x is 0 or 255
32373 // -> HACK for now: remove/"over-read" 2 of the values, for each of these triplets/doublications
32374 var jump, isPrint;
32375 for(var i=0, j=0, size = buffer.length; i < size && j < targetSize; ++i, ++j){
32376
32377 if(i === size-1 && j < targetSize - 1){
32378 //increase heap-view, in order to read more (valid) data into the target buffer
32379 buffer = HEAPU8.subarray(heapOffset, size + targetSize);
32380 size = buffer.length;
32381 }
32382
32383 // NOTE if e.g. 24-bit padding occurres, there does not seem to be no duplication/triplication of 255 or 0, so must not try to fix!
32384 if(applyFix && (buffer[i] === 0 || buffer[i] === 255)){
32385
32386 jump = 0;
32387 isPrint = true;
32388
32389 if(i + 1 < size && buffer[i] === buffer[i+1]){
32390
32391 ++jump;
32392
32393 if(i + 2 < size){
32394 if(buffer[i] === buffer[i+2]){
32395 ++jump;
32396 } else {
32397 //if only 2 occurrences: ignore value
32398 isPrint = false;
32399 }
32400 }
32401 }//else: if single value: do print (an do not jump)
32402
32403
32404 if(isPrint){
32405 dv.setUint8(j, buffer[i]);
32406 if(jump === 2 && i + 3 < size && buffer[i] === buffer[i+3]){
32407 //special case for reducing triples in case the following value is also the same
32408 // (ie. something like: x x x |+ x)
32409 // -> then: do write the value one more time, and jump one further ahead
32410 // i.e. if value occurs 4 times in a row, write 2 values
32411 ++jump;
32412 dv.setUint8(++j, buffer[i]);
32413 }
32414 } else {
32415 --j;
32416 }
32417
32418 i += jump;//<- apply jump, if there were value duplications
32419
32420 } else {
32421 dv.setUint8(j, buffer[i]);
32422 }
32423
32424 }
32425}
32426
32427
32428// FLAC__STREAM_DECODER_READ_STATUS_CONTINUE The read was OK and decoding can continue.
32429// FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM The read was attempted while at the end of the stream. Note that the client must only return this value when the read callback was called when already at the end of the stream. Otherwise, if the read itself moves to the end of the stream, the client should still return the data and FLAC__STREAM_DECODER_READ_STATUS_CONTINUE, and then on the next read callback it should return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM with a byte count of 0.
32430// FLAC__STREAM_DECODER_READ_STATUS_ABORT An unrecoverable error occurred. The decoder will return from the process call.
32431var FLAC__STREAM_DECODER_READ_STATUS_CONTINUE = 0;
32432var FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM = 1;
32433var FLAC__STREAM_DECODER_READ_STATUS_ABORT = 2;
32434
32435// FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE The write was OK and decoding can continue.
32436// FLAC__STREAM_DECODER_WRITE_STATUS_ABORT An unrecoverable error occurred. The decoder will return from the process call.
32437var FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE = 0;
32438var FLAC__STREAM_DECODER_WRITE_STATUS_ABORT = 1;
32439
32440/**
32441 * @interface FLAC__StreamDecoderInitStatus
32442 * @memberOf Flac
32443 *
32444 * @property {"FLAC__STREAM_DECODER_INIT_STATUS_OK"} 0 Initialization was successful.
32445 * @property {"FLAC__STREAM_DECODER_INIT_STATUS_UNSUPPORTED_CONTAINER"} 1 The library was not compiled with support for the given container format.
32446 * @property {"FLAC__STREAM_DECODER_INIT_STATUS_INVALID_CALLBACKS"} 2 A required callback was not supplied.
32447 * @property {"FLAC__STREAM_DECODER_INIT_STATUS_MEMORY_ALLOCATION_ERROR"} 3 An error occurred allocating memory.
32448 * @property {"FLAC__STREAM_DECODER_INIT_STATUS_ERROR_OPENING_FILE"} 4 fopen() failed in FLAC__stream_decoder_init_file() or FLAC__stream_decoder_init_ogg_file().
32449 * @property {"FLAC__STREAM_DECODER_INIT_STATUS_ALREADY_INITIALIZED"} 5 FLAC__stream_decoder_init_*() was called when the decoder was already initialized, usually because FLAC__stream_decoder_finish() was not called.
32450 */
32451var FLAC__STREAM_DECODER_INIT_STATUS_OK = 0;
32452var FLAC__STREAM_DECODER_INIT_STATUS_UNSUPPORTED_CONTAINER = 1;
32453var FLAC__STREAM_DECODER_INIT_STATUS_INVALID_CALLBACKS = 2;
32454var FLAC__STREAM_DECODER_INIT_STATUS_MEMORY_ALLOCATION_ERROR = 3;
32455var FLAC__STREAM_DECODER_INIT_STATUS_ERROR_OPENING_FILE = 4;
32456var FLAC__STREAM_DECODER_INIT_STATUS_ALREADY_INITIALIZED = 5;
32457
32458/**
32459 * @interface FLAC__StreamEncoderInitStatus
32460 * @memberOf Flac
32461 *
32462 * @property {"FLAC__STREAM_ENCODER_INIT_STATUS_OK"} 0 Initialization was successful.
32463 * @property {"FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR"} 1 General failure to set up encoder; call FLAC__stream_encoder_get_state() for cause.
32464 * @property {"FLAC__STREAM_ENCODER_INIT_STATUS_UNSUPPORTED_CONTAINER"} 2 The library was not compiled with support for the given container format.
32465 * @property {"FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_CALLBACKS"} 3 A required callback was not supplied.
32466 * @property {"FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_NUMBER_OF_CHANNELS"} 4 The encoder has an invalid setting for number of channels.
32467 * @property {"FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BITS_PER_SAMPLE"} 5 The encoder has an invalid setting for bits-per-sample. FLAC supports 4-32 bps but the reference encoder currently supports only up to 24 bps.
32468 * @property {"FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_SAMPLE_RATE"} 6 The encoder has an invalid setting for the input sample rate.
32469 * @property {"FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BLOCK_SIZE"} 7 The encoder has an invalid setting for the block size.
32470 * @property {"FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_MAX_LPC_ORDER"} 8 The encoder has an invalid setting for the maximum LPC order.
32471 * @property {"FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_QLP_COEFF_PRECISION"} 9 The encoder has an invalid setting for the precision of the quantized linear predictor coefficients.
32472 * @property {"FLAC__STREAM_ENCODER_INIT_STATUS_BLOCK_SIZE_TOO_SMALL_FOR_LPC_ORDER"} 10 The specified block size is less than the maximum LPC order.
32473 * @property {"FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE"} 11 The encoder is bound to the Subset but other settings violate it.
32474 * @property {"FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA"} 12 The metadata input to the encoder is invalid, in one of the following ways:
32475 * FLAC__stream_encoder_set_metadata() was called with a null pointer but a block count > 0
32476 * One of the metadata blocks contains an undefined type
32477 * It contains an illegal CUESHEET as checked by FLAC__format_cuesheet_is_legal()
32478 * It contains an illegal SEEKTABLE as checked by FLAC__format_seektable_is_legal()
32479 * It contains more than one SEEKTABLE block or more than one VORBIS_COMMENT block
32480 * @property {"FLAC__STREAM_ENCODER_INIT_STATUS_ALREADY_INITIALIZED"} 13 FLAC__stream_encoder_init_*() was called when the encoder was already initialized, usually because FLAC__stream_encoder_finish() was not called.
32481 */
32482var FLAC__STREAM_ENCODER_INIT_STATUS_OK = 0;
32483var FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR = 1;
32484var FLAC__STREAM_ENCODER_INIT_STATUS_UNSUPPORTED_CONTAINER = 2;
32485var FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_CALLBACKS = 3;
32486var FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_NUMBER_OF_CHANNELS = 4;
32487var FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BITS_PER_SAMPLE = 5;
32488var FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_SAMPLE_RATE = 6;
32489var FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BLOCK_SIZE = 7;
32490var FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_MAX_LPC_ORDER = 8;
32491var FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_QLP_COEFF_PRECISION = 9;
32492var FLAC__STREAM_ENCODER_INIT_STATUS_BLOCK_SIZE_TOO_SMALL_FOR_LPC_ORDER = 10;
32493var FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE = 11;
32494var FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA = 12;
32495var FLAC__STREAM_ENCODER_INIT_STATUS_ALREADY_INITIALIZED = 13;
32496
32497//FLAC__STREAM_ENCODER_WRITE_STATUS_OK The write was OK and encoding can continue.
32498//FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR An unrecoverable error occurred. The encoder will return from the process call
32499var FLAC__STREAM_ENCODER_WRITE_STATUS_OK = 0;
32500var FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR = 1;
32501
32502
32503/**
32504 * Map for encoder/decoder callback functions
32505 *
32506 * <pre>[ID] -> {function_type: FUNCTION}</pre>
32507 *
32508 * type: {[id: number]: {[callback_type: string]: function}}
32509 * @private
32510 */
32511var coders = {};
32512
32513/**
32514 * Get a registered callback for the encoder / decoder instance
32515 *
32516 * @param {Number} p_coder
32517 * the encoder/decoder pointer (ID)
32518 * @param {String} func_type
32519 * the callback type, one of
32520 * "write" | "read" | "error" | "metadata"
32521 * @returns {Function} the callback (or VOID if there is no callback registered)
32522 * @private
32523 */
32524function getCallback(p_coder, func_type){
32525 if(coders[p_coder]){
32526 return coders[p_coder][func_type];
32527 }
32528}
32529
32530/**
32531 * Register a callback for an encoder / decoder instance (will / should be deleted, when finish()/delete())
32532 *
32533 * @param {Number} p_coder
32534 * the encoder/decoder pointer (ID)
32535 * @param {String} func_type
32536 * the callback type, one of
32537 * "write" | "read" | "error" | "metadata"
32538 * @param {Function} callback
32539 * the callback function
32540 * @private
32541 */
32542function setCallback(p_coder, func_type, callback){
32543 if(!coders[p_coder]){
32544 coders[p_coder] = {};
32545 }
32546 coders[p_coder][func_type] = callback;
32547}
32548
32549/**
32550 * Get coding options for the encoder / decoder instance:
32551 * returns FALSY when not set.
32552 *
32553 * @param {Number} p_coder
32554 * the encoder/decoder pointer (ID)
32555 * @returns {CodingOptions} the coding options
32556 * @private
32557 * @memberOf Flac
32558 */
32559function _getOptions(p_coder){
32560 if(coders[p_coder]){
32561 return coders[p_coder]["options"];
32562 }
32563}
32564
32565/**
32566 * Set coding options for an encoder / decoder instance (will / should be deleted, when finish()/delete())
32567 *
32568 * @param {Number} p_coder
32569 * the encoder/decoder pointer (ID)
32570 * @param {CodingOptions} options
32571 * the coding options
32572 * @private
32573 * @memberOf Flac
32574 */
32575function _setOptions(p_coder, options){
32576 if(!coders[p_coder]){
32577 coders[p_coder] = {};
32578 }
32579 coders[p_coder]["options"] = options;
32580}
32581
32582//(const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], size_t bytes, unsigned samples, unsigned current_frame, void *client_data)
32583// -> FLAC__StreamEncoderWriteStatus
32584var enc_write_fn_ptr = addFunction(function(p_encoder, buffer, bytes, samples, current_frame, p_client_data){
32585 var retdata = new Uint8Array(bytes);
32586 retdata.set(HEAPU8.subarray(buffer, buffer + bytes));
32587 var write_callback_fn = getCallback(p_encoder, 'write');
32588 try{
32589 write_callback_fn(retdata, bytes, samples, current_frame, p_client_data);
32590 } catch(err) {
32591 console.error(err);
32592 return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR;
32593 }
32594 return FLAC__STREAM_ENCODER_WRITE_STATUS_OK;
32595}, 'iiiiiii');
32596
32597//(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data)
32598// -> FLAC__StreamDecoderReadStatus
32599var dec_read_fn_ptr = addFunction(function(p_decoder, buffer, bytes, p_client_data){
32600 //FLAC__StreamDecoderReadCallback, see https://xiph.org/flac/api/group__flac__stream__decoder.html#ga7a5f593b9bc2d163884348b48c4285fd
32601
32602 var len = Module.getValue(bytes, 'i32');
32603
32604 if(len === 0){
32605 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
32606 }
32607
32608 var read_callback_fn = getCallback(p_decoder, 'read');
32609
32610 //callback must return object with: {buffer: TypedArray, readDataLength: number, error: boolean}
32611 var readResult = read_callback_fn(len, p_client_data);
32612 //in case of END_OF_STREAM or an error, readResult.readDataLength must be returned with 0
32613
32614 var readLen = readResult.readDataLength;
32615 Module.setValue(bytes, readLen, 'i32');
32616
32617 if(readResult.error){
32618 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
32619 }
32620
32621 if(readLen === 0){
32622 return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
32623 }
32624
32625 var readBuf = readResult.buffer;
32626
32627 var dataHeap = new Uint8Array(Module.HEAPU8.buffer, buffer, readLen);
32628 dataHeap.set(new Uint8Array(readBuf));
32629
32630 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
32631}, 'iiiii');
32632
32633//(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 *const buffer[], void *client_data)
32634// -> FLAC__StreamDecoderWriteStatus
32635var dec_write_fn_ptr = addFunction(function(p_decoder, p_frame, p_buffer, p_client_data){
32636
32637 // var dec = Module.getValue(p_decoder,'i32');
32638 // var clientData = Module.getValue(p_client_data,'i32');
32639
32640 var dec_opts = _getOptions(p_decoder);
32641 var frameInfo = _readFrameHdr(p_frame, dec_opts);
32642
32643// console.log(frameInfo);//DEBUG
32644
32645 var channels = frameInfo.channels;
32646 var block_size = frameInfo.blocksize * (frameInfo.bitsPerSample / 8);
32647
32648 //whether or not to apply data fixing heuristics (e.g. not needed for 24-bit samples)
32649 var isFix = frameInfo.bitsPerSample !== 24;
32650
32651 //take padding bits into account for calculating buffer size
32652 // -> seems to be done for uneven byte sizes, i.e. 1 (8 bits) and 3 (24 bits)
32653 var padding = (frameInfo.bitsPerSample / 8)%2;
32654 if(padding > 0){
32655 block_size += frameInfo.blocksize * padding;
32656 }
32657
32658 var data = [];//<- array for the data of each channel
32659 var bufferOffset, _buffer;
32660
32661 for(var i=0; i < channels; ++i){
32662
32663 bufferOffset = Module.getValue(p_buffer + (i*4),'i32');
32664
32665 _buffer = new Uint8Array(block_size);
32666 //FIXME HACK for "strange" data (see helper function __fix_write_buffer)
32667 __fix_write_buffer(bufferOffset, _buffer, isFix);
32668
32669 data.push(_buffer.subarray(0, block_size));
32670 }
32671
32672 var write_callback_fn = getCallback(p_decoder, 'write');
32673 var res = write_callback_fn(data, frameInfo);//, clientData);
32674
32675 // FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE The write was OK and decoding can continue.
32676 // FLAC__STREAM_DECODER_WRITE_STATUS_ABORT An unrecoverable error occurred. The decoder will return from the process call.
32677
32678 return res !== false? FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE : FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
32679}, 'iiiii');
32680
32681/**
32682 * Decoding error codes.
32683 *
32684 * <br>
32685 * If the error code is not known, value <code>FLAC__STREAM_DECODER_ERROR__UNKNOWN__</code> is used.
32686 *
32687 * @property {"FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC"} 0 An error in the stream caused the decoder to lose synchronization.
32688 * @property {"FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER"} 1 The decoder encountered a corrupted frame header.
32689 * @property {"FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH"} 2 The frame's data did not match the CRC in the footer.
32690 * @property {"FLAC__STREAM_DECODER_ERROR_STATUS_UNPARSEABLE_STREAM"} 3 The decoder encountered reserved fields in use in the stream.
32691 *
32692 *
32693 * @interface FLAC__StreamDecoderErrorStatus
32694 * @memberOf Flac
32695 */
32696var DecoderErrorCode = {
32697 0: 'FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC',
32698 1: 'FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER',
32699 2: 'FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH',
32700 3: 'FLAC__STREAM_DECODER_ERROR_STATUS_UNPARSEABLE_STREAM'
32701}
32702
32703//(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
32704// -> void
32705var dec_error_fn_ptr = addFunction(function(p_decoder, err, p_client_data){
32706
32707 //err:
32708 var msg = DecoderErrorCode[err] || 'FLAC__STREAM_DECODER_ERROR__UNKNOWN__';//<- this should never happen;
32709
32710 var error_callback_fn = getCallback(p_decoder, 'error');
32711 error_callback_fn(err, msg, p_client_data);
32712}, 'viii');
32713
32714//(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data) -> void
32715//(const FLAC__StreamEncoder *encoder, const FLAC__StreamMetadata *metadata, void *client_data) -> void
32716var metadata_fn_ptr = addFunction(function(p_coder, p_metadata, p_client_data){
32717 /*
32718 typedef struct {
32719 FLAC__MetadataType type;
32720 FLAC__bool is_last;
32721 unsigned length;
32722 union {
32723 FLAC__StreamMetadata_StreamInfo stream_info;
32724 FLAC__StreamMetadata_Padding padding;
32725 FLAC__StreamMetadata_Application application;
32726 FLAC__StreamMetadata_SeekTable seek_table;
32727 FLAC__StreamMetadata_VorbisComment vorbis_comment;
32728 FLAC__StreamMetadata_CueSheet cue_sheet;
32729 FLAC__StreamMetadata_Picture picture;
32730 FLAC__StreamMetadata_Unknown unknown;
32731 } data;
32732 } FLAC__StreamMetadata;
32733 */
32734
32735 /*
32736 FLAC__METADATA_TYPE_STREAMINFO STREAMINFO block
32737 FLAC__METADATA_TYPE_PADDING PADDING block
32738 FLAC__METADATA_TYPE_APPLICATION APPLICATION block
32739 FLAC__METADATA_TYPE_SEEKTABLE SEEKTABLE block
32740 FLAC__METADATA_TYPE_VORBIS_COMMENT VORBISCOMMENT block (a.k.a. FLAC tags)
32741 FLAC__METADATA_TYPE_CUESHEET CUESHEET block
32742 FLAC__METADATA_TYPE_PICTURE PICTURE block
32743 FLAC__METADATA_TYPE_UNDEFINED marker to denote beginning of undefined type range; this number will increase as new metadata types are added
32744 FLAC__MAX_METADATA_TYPE No type will ever be greater than this. There is not enough room in the protocol block.
32745 */
32746
32747 var type = Module.getValue(p_metadata,'i32');//4 bytes
32748 var is_last = Module.getValue(p_metadata+4,'i32');//4 bytes
32749 var length = Module.getValue(p_metadata+8,'i64');//8 bytes
32750
32751 var meta_data = {
32752 type: type,
32753 isLast: is_last,
32754 length: length,
32755 data: void(0)
32756 };
32757
32758 var metadata_callback_fn = getCallback(p_coder, 'metadata');
32759 if(type === 0){// === FLAC__METADATA_TYPE_STREAMINFO
32760
32761 meta_data.data = _readStreamInfo(p_metadata+16);
32762 metadata_callback_fn(meta_data.data, meta_data);
32763
32764 } else {
32765
32766 var data;
32767 switch(type){
32768 case 1: //FLAC__METADATA_TYPE_PADDING
32769 data = _readPaddingMetadata(p_metadata+16);
32770 break;
32771 case 2: //FLAC__METADATA_TYPE_APPLICATION
32772 data = readApplicationMetadata(p_metadata+16);
32773 break;
32774 case 3: //FLAC__METADATA_TYPE_SEEKTABLE
32775 data = _readSeekTableMetadata(p_metadata+16);
32776 break;
32777
32778 case 4: //FLAC__METADATA_TYPE_VORBIS_COMMENT
32779 data = _readVorbisComment(p_metadata+16);
32780 break;
32781
32782 case 5: //FLAC__METADATA_TYPE_CUESHEET
32783 data = _readCueSheetMetadata(p_metadata+16);
32784 break;
32785
32786 case 6: //FLAC__METADATA_TYPE_PICTURE
32787 data = _readPictureMetadata(p_metadata+16);
32788 break;
32789 default: { //NOTE this should not happen, and the raw data is very likely not correct!
32790 var cod_opts = _getOptions(p_coder);
32791 if(cod_opts && cod_opts.enableRawMetadata){
32792 var buffer = Uint8Array.from(HEAPU8.subarray(p_metadata+16, p_metadata+16+length));
32793 meta_data.raw = buffer;
32794 }
32795 }
32796
32797 }
32798
32799 meta_data.data = data;
32800 metadata_callback_fn(void(0), meta_data);
32801 }
32802
32803}, 'viii');
32804
32805
32806////////////// helper fields and functions for event handling
32807// see exported on()/off() functions
32808var listeners = {};
32809var persistedEvents = [];
32810var add_event_listener = function (eventName, listener){
32811 var list = listeners[eventName];
32812 if(!list){
32813 list = [listener];
32814 listeners[eventName] = list;
32815 } else {
32816 list.push(listener);
32817 }
32818 check_and_trigger_persisted_event(eventName, listener);
32819};
32820var check_and_trigger_persisted_event = function(eventName, listener){
32821 var activated;
32822 for(var i=persistedEvents.length-1; i >= 0; --i){
32823 activated = persistedEvents[i];
32824 if(activated && activated.event === eventName){
32825 listener.apply(null, activated.args);
32826 break;
32827 }
32828 }
32829};
32830var remove_event_listener = function (eventName, listener){
32831 var list = listeners[eventName];
32832 if(list){
32833 for(var i=list.length-1; i >= 0; --i){
32834 if(list[i] === listener){
32835 list.splice(i, 1);
32836 }
32837 }
32838 }
32839};
32840/**
32841 * HELPER: fire an event
32842 * @param {string} eventName
32843 * the event name
32844 * @param {any[]} [args] OPITIONAL
32845 * the arguments when triggering the listeners
32846 * @param {boolean} [isPersist] OPTIONAL (positinal argument!)
32847 * if TRUE, handlers for this event that will be registered after this will get triggered immediately
32848 * (i.e. event is "persistent": once triggered it stays "active")
32849 *
32850 */
32851var do_fire_event = function (eventName, args, isPersist){
32852 if(_exported['on'+eventName]){
32853 _exported['on'+eventName].apply(null, args);
32854 }
32855 var list = listeners[eventName];
32856 if(list){
32857 for(var i=0, size=list.length; i < size; ++i){
32858 list[i].apply(null, args)
32859 }
32860 }
32861 if(isPersist){
32862 persistedEvents.push({event: eventName, args: args});
32863 }
32864}
32865
32866///////////////////////////////////// export / public: /////////////////////////////////////////////
32867/**
32868 * The <code>Flac</code> module that provides functionality
32869 * for encoding WAV/PCM audio to Flac and decoding Flac to PCM.
32870 *
32871 * <br/><br/>
32872 * <p>
32873 * NOTE most functions are named analogous to the original C library functions,
32874 * so that its documentation may be used for further reading.
32875 * </p>
32876 *
32877 * @see https://xiph.org/flac/api/group__flac__stream__encoder.html
32878 * @see https://xiph.org/flac/api/group__flac__stream__decoder.html
32879 *
32880 * @class Flac
32881 * @namespace Flac
32882 */
32883var _exported = {
32884 _module: Module,//internal: reference to Flac module
32885 _clear_enc_cb: function(enc_ptr){//internal function: remove reference to encoder instance and its callbacks
32886 delete coders[enc_ptr];
32887 },
32888 _clear_dec_cb: function(dec_ptr){//internal function: remove reference to decoder instance and its callbacks
32889 delete coders[dec_ptr];
32890 },
32891 /**
32892 * Additional options for encoding or decoding
32893 * @interface CodingOptions
32894 * @memberOf Flac
32895 * @property {boolean} [analyseSubframes] for decoding: include subframes metadata in write-callback metadata, DEFAULT: false
32896 * @property {boolean} [analyseResiduals] for decoding: include residual data in subframes metadata in write-callback metadata, NOTE {@link #analyseSubframes} muste also be enabled, DEFAULT: false
32897 * @property {boolean} [enableRawMetadata] DEBUG option for decoding: enable receiving raw metadata for unknown metadata types in second argument in the metadata-callback, DEFAULT: false
32898 *
32899 * @see Flac#setOptions
32900 * @see Flac~metadata_callback_fn
32901 * @see Flac#FLAC__stream_decoder_set_metadata_respond_all
32902 */
32903 /**
32904 * FLAC raw metadata
32905 *
32906 * @interface MetadataBlock
32907 * @memberOf Flac
32908 * @property {Flac.FLAC__MetadataType} type the type of the metadata
32909 * @property {boolean} isLast if it is the last block of metadata
32910 * @property {number} length the length of the metadata block (bytes)
32911 * @property {Flac.StreamMetadata | Flac.PaddingMetadata | Flac.ApplicationMetadata | Flac.SeekTableMetadata | Flac.CueSheetMetadata | Flac.PictureMetadata} [data] the metadata (omitted for unknown metadata types)
32912 * @property {Uint8Array} [raw] raw metadata (for debugging: enable via {@link Flac#setOptions})
32913 */
32914 /**
32915 * FLAC padding metadata block
32916 *
32917 * @interface PaddingMetadata
32918 * @memberOf Flac
32919 * @property {number} dummy Conceptually this is an empty struct since we don't store the padding bytes. Empty structs are not allowed by some C compilers, hence the dummy.
32920 *
32921 * @see Flac.FLAC__MetadataType#FLAC__METADATA_TYPE_PADDING
32922 */
32923 /**
32924 * FLAC application metadata block
32925 *
32926 * NOTE the application meta data type is not really supported, i.e. the
32927 * (binary) data is only a pointer to the memory heap.
32928 *
32929 * @interface ApplicationMetadata
32930 * @memberOf Flac
32931 * @property {number} id the application ID
32932 * @property {number} data (pointer)
32933 *
32934 * @see Flac.FLAC__MetadataType#FLAC__METADATA_TYPE_APPLICATION
32935 * @see <a href="https://xiph.org/flac/format.html#metadata_block_application">application block format specification</a>
32936 */
32937 /**
32938 * FLAC seek table metadata block
32939 *
32940 * <p>
32941 * From the format specification:
32942 *
32943 * The seek points must be sorted by ascending sample number.
32944 *
32945 * Each seek point's sample number must be the first sample of the target frame.
32946 *
32947 * Each seek point's sample number must be unique within the table
32948 *
32949 * Existence of a SEEKTABLE block implies a correct setting of total_samples in the stream_info block.
32950 *
32951 * Behavior is undefined when more than one SEEKTABLE block is present in a stream.
32952 *
32953 * @interface SeekTableMetadata
32954 * @memberOf Flac
32955 * @property {number} num_points the number of seek points
32956 * @property {Flac.SeekPoint[]} points the seek points
32957 *
32958 * @see Flac.FLAC__MetadataType#FLAC__METADATA_TYPE_SEEKTABLE
32959 */
32960 /**
32961 * FLAC seek point data
32962 *
32963 * @interface SeekPoint
32964 * @memberOf Flac
32965 * @property {number} sample_number The sample number of the target frame. NOTE <code>-1</code> for a placeholder point.
32966 * @property {number} stream_offset The offset, in bytes, of the target frame with respect to beginning of the first frame.
32967 * @property {number} frame_samples The number of samples in the target frame.
32968 *
32969 * @see Flac.SeekTableMetadata
32970 */
32971 /**
32972 * FLAC vorbis comment metadata block
32973 *
32974 * @interface VorbisCommentMetadata
32975 * @memberOf Flac
32976 * @property {string} vendor_string the vendor string
32977 * @property {number} num_comments the number of comments
32978 * @property {string[]} comments the comments
32979 *
32980 * @see Flac.FLAC__MetadataType#FLAC__METADATA_TYPE_VORBIS_COMMENT
32981 */
32982 /**
32983 * FLAC cue sheet metadata block
32984 *
32985 * @interface CueSheetMetadata
32986 * @memberOf Flac
32987 * @property {string} media_catalog_number Media catalog number, in ASCII printable characters 0x20-0x7e. In general, the media catalog number may be 0 to 128 bytes long.
32988 * @property {number} lead_in The number of lead-in samples.
32989 * @property {boolean} is_cd true if CUESHEET corresponds to a Compact Disc, else false.
32990 * @property {number} num_tracks The number of tracks.
32991 * @property {Flac.CueSheetTrack[]} tracks the tracks
32992 *
32993 * @see Flac.FLAC__MetadataType#FLAC__METADATA_TYPE_CUESHEET
32994 */
32995 /**
32996 * FLAC cue sheet track data
32997 *
32998 * @interface CueSheetTrack
32999 * @memberOf Flac
33000 * @property {number} offset Track offset in samples, relative to the beginning of the FLAC audio stream.
33001 * @property {number} number The track number.
33002 * @property {string} isrc Track ISRC. This is a 12-digit alphanumeric code.
33003 * @property {"AUDIO" | "NON_AUDIO"} type The track type: audio or non-audio.
33004 * @property {boolean} pre_emphasis The pre-emphasis flag
33005 * @property {number} num_indices The number of track index points.
33006 * @property {Flac.CueSheetTracIndex} indices The track index points.
33007 *
33008 * @see Flac.CueSheetMetadata
33009 */
33010 /**
33011 * FLAC track index data for cue sheet metadata
33012 *
33013 * @interface CueSheetTracIndex
33014 * @memberOf Flac
33015 * @property {number} offset Offset in samples, relative to the track offset, of the index point.
33016 * @property {number} number The index point number.
33017 *
33018 * @see Flac.CueSheetTrack
33019 */
33020 /**
33021 * FLAC picture metadata block
33022 *
33023 * @interface PictureMetadata
33024 * @memberOf Flac
33025 * @property {Flac.FLAC__StreamMetadata_Picture_Type} type The kind of picture stored.
33026 * @property {string} mime_type Picture data's MIME type, in ASCII printable characters 0x20-0x7e, NUL terminated. For best compatibility with players, use picture data of MIME type image/jpeg or image/png. A MIME type of 'â>' is also allowed, in which case the picture data should be a complete URL.
33027 * @property {string} description Picture's description.
33028 * @property {number} width Picture's width in pixels.
33029 * @property {number} height Picture's height in pixels.
33030 * @property {number} depth Picture's color depth in bits-per-pixel.
33031 * @property {number} colors For indexed palettes (like GIF), picture's number of colors (the number of palette entries), or 0 for non-indexed (i.e. 2^depth).
33032 * @property {number} data_length Length of binary picture data in bytes.
33033 * @property {Uint8Array} data Binary picture data.
33034 */
33035 /**
33036 * An enumeration of the PICTURE types (see FLAC__StreamMetadataPicture and id3 v2.4 APIC tag).
33037 *
33038 * @interface FLAC__StreamMetadata_Picture_Type
33039 * @memberOf Flac
33040 * @property {"FLAC__STREAM_METADATA_PICTURE_TYPE_OTHER"} 0 Other
33041 * @property {"FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON_STANDARD"} 1 32x32 pixels 'file icon' (PNG only)
33042 * @property {"FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON"} 2 Other file icon
33043 * @property {"FLAC__STREAM_METADATA_PICTURE_TYPE_FRONT_COVER"} 3 Cover (front)
33044 * @property {"FLAC__STREAM_METADATA_PICTURE_TYPE_BACK_COVER"} 4 Cover (back)
33045 * @property {"FLAC__STREAM_METADATA_PICTURE_TYPE_LEAFLET_PAGE"} 5 Leaflet page
33046 * @property {"FLAC__STREAM_METADATA_PICTURE_TYPE_MEDIA"} 6 Media (e.g. label side of CD)
33047 * @property {"FLAC__STREAM_METADATA_PICTURE_TYPE_LEAD_ARTIST"} 7 Lead artist/lead performer/soloist
33048 * @property {"FLAC__STREAM_METADATA_PICTURE_TYPE_ARTIST"} 8 Artist/performer
33049 * @property {"FLAC__STREAM_METADATA_PICTURE_TYPE_CONDUCTOR"} 9 Conductor
33050 * @property {"FLAC__STREAM_METADATA_PICTURE_TYPE_BAND"} 10 Band/Orchestra
33051 * @property {"FLAC__STREAM_METADATA_PICTURE_TYPE_COMPOSER"} 11 Composer
33052 * @property {"FLAC__STREAM_METADATA_PICTURE_TYPE_LYRICIST"} 12 Lyricist/text writer
33053 * @property {"FLAC__STREAM_METADATA_PICTURE_TYPE_RECORDING_LOCATION"} 13 Recording Location
33054 * @property {"FLAC__STREAM_METADATA_PICTURE_TYPE_DURING_RECORDING"} 14 During recording
33055 * @property {"FLAC__STREAM_METADATA_PICTURE_TYPE_DURING_PERFORMANCE"} 15 During performance
33056 * @property {"FLAC__STREAM_METADATA_PICTURE_TYPE_VIDEO_SCREEN_CAPTURE"} 16 Movie/video screen capture
33057 * @property {"FLAC__STREAM_METADATA_PICTURE_TYPE_FISH"} 17 A bright coloured fish
33058 * @property {"FLAC__STREAM_METADATA_PICTURE_TYPE_ILLUSTRATION"} 18 Illustration
33059 * @property {"FLAC__STREAM_METADATA_PICTURE_TYPE_BAND_LOGOTYPE"} 19 Band/artist logotype
33060 * @property {"FLAC__STREAM_METADATA_PICTURE_TYPE_PUBLISHER_LOGOTYPE"} 20 Publisher/Studio logotype
33061 *
33062 * @see Flac.PictureMetadata
33063 */
33064
33065 /**
33066 * An enumeration of the available metadata block types.
33067 *
33068 * @interface FLAC__MetadataType
33069 * @memberOf Flac
33070 *
33071 * @property {"FLAC__METADATA_TYPE_STREAMINFO"}Â 0 STREAMINFO block
33072 * @property {"FLAC__METADATA_TYPE_PADDING"}Â 1 PADDING block
33073 * @property {"FLAC__METADATA_TYPE_APPLICATION"}Â 2 APPLICATION block
33074 * @property {"FLAC__METADATA_TYPE_SEEKTABLE"}Â 3 SEEKTABLE block
33075 * @property {"FLAC__METADATA_TYPE_VORBIS_COMMENT"}Â 4 VORBISCOMMENT block (a.k.a. FLAC tags)
33076 * @property {"FLAC__METADATA_TYPE_CUESHEET"}Â 5 CUESHEET block
33077 * @property {"FLAC__METADATA_TYPE_PICTURE"}Â 6 PICTURE block
33078 * @property {"FLAC__METADATA_TYPE_UNDEFINED"}Â 7 marker to denote beginning of undefined type range; this number will increase as new metadata types are added
33079 * @property {"FLAC__MAX_METADATA_TYPE"}Â 126 No type will ever be greater than this. There is not enough room in the protocol block.
33080 *
33081 * @see Flac.MetadataBlock
33082 * @see <a href="https://xiph.org/flac/format.html">FLAC format documentation</a>
33083 */
33084 /**
33085 * @function
33086 * @public
33087 * @memberOf Flac#
33088 * @copydoc Flac._setOptions
33089 */
33090 setOptions: _setOptions,
33091 /**
33092 * @function
33093 * @public
33094 * @memberOf Flac#
33095 * @copydoc Flac._getOptions
33096 */
33097 getOptions: _getOptions,
33098 /**
33099 * Returns if Flac has been initialized / is ready to be used.
33100 *
33101 * @returns {boolean} <code>true</code>, if Flac is ready to be used
33102 *
33103 * @memberOf Flac#
33104 * @function
33105 * @see #onready
33106 * @see #on
33107 */
33108 isReady: function() { return _flac_ready; },
33109 /**
33110 * Hook for handler function that gets called, when asynchronous initialization has finished.
33111 *
33112 * NOTE that if the execution environment does not support <code>Object#defineProperty</code>, then
33113 * this function is not called, after {@link #isReady} is <code>true</code>.
33114 * In this case, {@link #isReady} should be checked, before setting <code>onready</code>
33115 * and if it is <code>true</code>, handler should be executed immediately instead of setting <code>onready</code>.
33116 *
33117 * @memberOf Flac#
33118 * @function
33119 * @param {Flac.event:ReadyEvent} event the ready-event object
33120 * @see #isReady
33121 * @see #on
33122 * @default undefined
33123 * @example
33124 * // [1] if Object.defineProperty() IS supported:
33125 * Flac.onready = function(event){
33126 * //gets executed when library becomes ready, or immediately, if it already is ready...
33127 * doSomethingWithFlac();
33128 * };
33129 *
33130 * // [2] if Object.defineProperty() is NOT supported:
33131 * // do check Flac.isReady(), and only set handler, if not ready yet
33132 * // (otherwise immediately excute handler code)
33133 * if(!Flac.isReady()){
33134 * Flac.onready = function(event){
33135 * //gets executed when library becomes ready...
33136 * doSomethingWithFlac();
33137 * };
33138 * } else {
33139 * // Flac is already ready: immediately start processing
33140 * doSomethingWithFlac();
33141 * }
33142 */
33143 onready: void(0),
33144 /**
33145 * Ready event: is fired when the library has been initialized and is ready to be used
33146 * (e.g. asynchronous loading of binary / WASM modules has been completed).
33147 *
33148 * Before this event is fired, use of functions related to encoding and decoding may
33149 * cause errors.
33150 *
33151 * @event ReadyEvent
33152 * @memberOf Flac
33153 * @type {object}
33154 * @property {"ready"} type the type of the event <code>"ready"</code>
33155 * @property {Flac} target the initalized FLAC library instance
33156 *
33157 * @see #isReady
33158 * @see #on
33159 */
33160 /**
33161 * Created event: is fired when an encoder or decoder was created.
33162 *
33163 * @event CreatedEvent
33164 * @memberOf Flac
33165 * @type {object}
33166 * @property {"created"} type the type of the event <code>"created"</code>
33167 * @property {Flac.CoderChangedEventData} target the information for the created encoder or decoder
33168 *
33169 * @see #on
33170 */
33171 /**
33172 * Destroyed event: is fired when an encoder or decoder was destroyed.
33173 *
33174 * @event DestroyedEvent
33175 * @memberOf Flac
33176 * @type {object}
33177 * @property {"destroyed"} type the type of the event <code>"destroyed"</code>
33178 * @property {Flac.CoderChangedEventData} target the information for the destroyed encoder or decoder
33179 *
33180 * @see #on
33181 */
33182 /**
33183 * Life cycle event data for signaling life cycle changes of encoder or decoder instances
33184 * @interface CoderChangedEventData
33185 * @memberOf Flac
33186 * @property {number} id the ID for the encoder or decoder instance
33187 * @property {"encoder" | "decoder"} type signifies whether the event is for an encoder or decoder instance
33188 * @property {any} [data] specific data for the life cycle change
33189 *
33190 * @see Flac.event:CreatedEvent
33191 * @see Flac.event:DestroyedEvent
33192 */
33193 /**
33194 * Add an event listener for module-events.
33195 * Supported events:
33196 * <ul>
33197 * <li> <code>"ready"</code> → {@link Flac.event:ReadyEvent}: emitted when module is ready for usage (i.e. {@link #isReady} is true)<br/>
33198 * <em>NOTE listener will get immediately triggered if module is already <code>"ready"</code></em>
33199 * </li>
33200 * <li> <code>"created"</code> → {@link Flac.event:CreatedEvent}: emitted when an encoder or decoder instance was created<br/>
33201 * </li>
33202 * <li> <code>"destroyed"</code> → {@link Flac.event:DestroyedEvent}: emitted when an encoder or decoder instance was destroyed<br/>
33203 * </li>
33204 * </ul>
33205 *
33206 * @param {string} eventName
33207 * @param {Function} listener
33208 *
33209 * @memberOf Flac#
33210 * @function
33211 * @see #off
33212 * @see #onready
33213 * @see Flac.event:ReadyEvent
33214 * @see Flac.event:CreatedEvent
33215 * @see Flac.event:DestroyedEvent
33216 * @example
33217 * Flac.on('ready', function(event){
33218 * //gets executed when library is ready, or becomes ready...
33219 * });
33220 */
33221 on: add_event_listener,
33222 /**
33223 * Remove an event listener for module-events.
33224 * @param {string} eventName
33225 * @param {Function} listener
33226 *
33227 * @memberOf Flac#
33228 * @function
33229 * @see #on
33230 */
33231 off: remove_event_listener,
33232
33233 /**
33234 * Set the "verify" flag. If true, the encoder will verify it's own encoded output by feeding it through an internal decoder and comparing the original signal against the decoded signal. If a mismatch occurs, the process call will return false. Note that this will slow the encoding process by the extra time required for decoding and comparison.
33235 *
33236 * <p>
33237 * NOTE: only use on un-initilized encoder instances!
33238 *
33239 * @param {number} encoder
33240 * the ID of the encoder instance
33241 *
33242 * @param {boolean} is_verify enable/disable checksum verification during encoding
33243 *
33244 * @returns {boolean} <code>false</code> if the encoder is already initialized, else <code>true</code>
33245 *
33246 * @see #create_libflac_encoder
33247 * @see #FLAC__stream_encoder_get_verify
33248 *
33249 * @memberOf Flac#
33250 * @function
33251 */
33252 FLAC__stream_encoder_set_verify: function(encoder, is_verify){
33253 is_verify = is_verify? 1 : 0;
33254 Module.ccall('FLAC__stream_encoder_set_verify', 'number', ['number', 'number'], [ encoder, is_verify ]);
33255 },
33256 /**
33257 * Set the compression level
33258 *
33259 * The compression level is roughly proportional to the amount of effort the encoder expends to compress the file. A higher level usually means more computation but higher compression. The default level is suitable for most applications.
33260 *
33261 * Currently the levels range from 0 (fastest, least compression) to 8 (slowest, most compression). A value larger than 8 will be treated as 8.
33262 *
33263 *
33264 * <p>
33265 * NOTE: only use on un-initilized encoder instances!
33266 *
33267 * @param {number} encoder
33268 * the ID of the encoder instance
33269 *
33270 * @param {Flac.CompressionLevel} compression_level the desired Flac compression level: [0, 8]
33271 *
33272 * @returns {boolean} <code>false</code> if the encoder is already initialized, else <code>true</code>
33273 *
33274 * @see #create_libflac_encoder
33275 * @see Flac.CompressionLevel
33276 * @see <a href="https://xiph.org/flac/api/group__flac__stream__encoder.html#gae49cf32f5256cb47eecd33779493ac85">FLAC API for FLAC__stream_encoder_set_compression_level()</a>
33277 *
33278 * @memberOf Flac#
33279 * @function
33280 */
33281 FLAC__stream_encoder_set_compression_level: Module.cwrap('FLAC__stream_encoder_set_compression_level', 'number', [ 'number', 'number' ]),
33282 /**
33283 * Set the blocksize to use while encoding.
33284 * The number of samples to use per frame. Use 0 to let the encoder estimate a blocksize; this is usually best.
33285 *
33286 * <p>
33287 * NOTE: only use on un-initilized encoder instances!
33288 *
33289 * @param {number} encoder
33290 * the ID of the encoder instance
33291 *
33292 * @param {number} block_size the number of samples to use per frame
33293 *
33294 * @returns {boolean} <code>false</code> if the encoder is already initialized, else <code>true</code>
33295 *
33296 * @see #create_libflac_encoder
33297 *
33298 * @memberOf Flac#
33299 * @function
33300 */
33301 FLAC__stream_encoder_set_blocksize: Module.cwrap('FLAC__stream_encoder_set_blocksize', 'number', [ 'number', 'number']),
33302
33303
33304 /**
33305 * Get the state of the verify stream decoder. Useful when the stream encoder state is FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR.
33306 *
33307 * @param {number} encoder
33308 * the ID of the encoder instance
33309 *
33310 * @returns {Flac.FLAC__StreamDecoderState} the verify stream decoder state
33311 *
33312 * @memberOf Flac#
33313 * @function
33314 */
33315 FLAC__stream_encoder_get_verify_decoder_state: Module.cwrap('FLAC__stream_encoder_get_verify_decoder_state', 'number', ['number']),
33316
33317 /**
33318 * Get the "verify" flag for the encoder.
33319 *
33320 * @param {number} encoder
33321 * the ID of the encoder instance
33322 *
33323 * @returns {boolean} the verify flag for the encoder
33324 *
33325 *
33326 * @memberOf Flac#
33327 * @function
33328 *
33329 * @see #FLAC__stream_encoder_set_verify
33330 */
33331 FLAC__stream_encoder_get_verify: Module.cwrap('FLAC__stream_encoder_get_verify', 'number', ['number']),
33332/*
33333
33334TODO export other encoder API functions?:
33335
33336FLAC__bool FLAC__stream_encoder_set_channels (FLAC__StreamEncoder *encoder, unsigned value)
33337
33338FLAC__bool FLAC__stream_encoder_set_bits_per_sample (FLAC__StreamEncoder *encoder, unsigned value)
33339
33340FLAC__bool FLAC__stream_encoder_set_sample_rate (FLAC__StreamEncoder *encoder, unsigned value)
33341
33342FLAC__bool FLAC__stream_encoder_set_do_mid_side_stereo (FLAC__StreamEncoder *encoder, FLAC__bool value)
33343
33344FLAC__bool FLAC__stream_encoder_set_loose_mid_side_stereo (FLAC__StreamEncoder *encoder, FLAC__bool value)
33345
33346FLAC__bool FLAC__stream_encoder_set_apodization (FLAC__StreamEncoder *encoder, const char *specification)
33347
33348FLAC__bool FLAC__stream_encoder_set_max_lpc_order (FLAC__StreamEncoder *encoder, unsigned value)
33349
33350FLAC__bool FLAC__stream_encoder_set_qlp_coeff_precision (FLAC__StreamEncoder *encoder, unsigned value)
33351
33352FLAC__bool FLAC__stream_encoder_set_do_qlp_coeff_prec_search (FLAC__StreamEncoder *encoder, FLAC__bool value)
33353
33354FLAC__bool FLAC__stream_encoder_set_do_escape_coding (FLAC__StreamEncoder *encoder, FLAC__bool value)
33355
33356FLAC__bool FLAC__stream_encoder_set_do_exhaustive_model_search (FLAC__StreamEncoder *encoder, FLAC__bool value)
33357
33358FLAC__bool FLAC__stream_encoder_set_min_residual_partition_order (FLAC__StreamEncoder *encoder, unsigned value)
33359
33360FLAC__bool FLAC__stream_encoder_set_max_residual_partition_order (FLAC__StreamEncoder *encoder, unsigned value)
33361
33362FLAC__bool FLAC__stream_encoder_set_rice_parameter_search_dist (FLAC__StreamEncoder *encoder, unsigned value)
33363
33364FLAC__bool FLAC__stream_encoder_get_streamable_subset (const FLAC__StreamEncoder *encoder)
33365
33366unsigned FLAC__stream_encoder_get_channels (const FLAC__StreamEncoder *encoder)
33367
33368unsigned FLAC__stream_encoder_get_bits_per_sample (const FLAC__StreamEncoder *encoder)
33369
33370unsigned FLAC__stream_encoder_get_sample_rate (const FLAC__StreamEncoder *encoder)
33371
33372unsigned FLAC__stream_encoder_get_blocksize (const FLAC__StreamEncoder *encoder)
33373
33374FLAC__bool FLAC__stream_encoder_get_do_mid_side_stereo (const FLAC__StreamEncoder *encoder)
33375
33376FLAC__bool FLAC__stream_encoder_get_loose_mid_side_stereo (const FLAC__StreamEncoder *encoder)
33377
33378unsigned FLAC__stream_encoder_get_max_lpc_order (const FLAC__StreamEncoder *encoder)
33379
33380unsigned FLAC__stream_encoder_get_qlp_coeff_precision (const FLAC__StreamEncoder *encoder)
33381
33382FLAC__bool FLAC__stream_encoder_get_do_qlp_coeff_prec_search (const FLAC__StreamEncoder *encoder)
33383
33384FLAC__bool FLAC__stream_encoder_get_do_escape_coding (const FLAC__StreamEncoder *encoder)
33385
33386FLAC__bool FLAC__stream_encoder_get_do_exhaustive_model_search (const FLAC__StreamEncoder *encoder)
33387
33388unsigned FLAC__stream_encoder_get_min_residual_partition_order (const FLAC__StreamEncoder *encoder)
33389
33390unsigned FLAC__stream_encoder_get_max_residual_partition_order (const FLAC__StreamEncoder *encoder)
33391
33392unsigned FLAC__stream_encoder_get_rice_parameter_search_dist (const FLAC__StreamEncoder *encoder)
33393
33394FLAC__uint64 FLAC__stream_encoder_get_total_samples_estimate (const FLAC__StreamEncoder *encoder)
33395
33396
33397
33398TODO export other decoder API functions?:
33399
33400
33401const char * FLAC__stream_decoder_get_resolved_state_string (const FLAC__StreamDecoder *decoder)
33402
33403FLAC__uint64 FLAC__stream_decoder_get_total_samples (const FLAC__StreamDecoder *decoder)
33404
33405unsigned FLAC__stream_decoder_get_channels (const FLAC__StreamDecoder *decoder)
33406
33407unsigned FLAC__stream_decoder_get_bits_per_sample (const FLAC__StreamDecoder *decoder)
33408
33409unsigned FLAC__stream_decoder_get_sample_rate (const FLAC__StreamDecoder *decoder)
33410
33411unsigned FLAC__stream_decoder_get_blocksize (const FLAC__StreamDecoder *decoder)
33412
33413
33414FLAC__bool FLAC__stream_decoder_flush (FLAC__StreamDecoder *decoder)
33415
33416FLAC__bool FLAC__stream_decoder_skip_single_frame (FLAC__StreamDecoder *decoder)
33417
33418 */
33419
33420 /**
33421 * Set the compression level
33422 *
33423 * The compression level is roughly proportional to the amount of effort the encoder expends to compress the file. A higher level usually means more computation but higher compression. The default level is suitable for most applications.
33424 *
33425 * Currently the levels range from 0 (fastest, least compression) to 8 (slowest, most compression). A value larger than 8 will be treated as 8.
33426 *
33427 * This function automatically calls the following other set functions with appropriate values, so the client does not need to unless it specifically wants to override them:
33428 * <pre>
33429 * FLAC__stream_encoder_set_do_mid_side_stereo()
33430 * FLAC__stream_encoder_set_loose_mid_side_stereo()
33431 * FLAC__stream_encoder_set_apodization()
33432 * FLAC__stream_encoder_set_max_lpc_order()
33433 * FLAC__stream_encoder_set_qlp_coeff_precision()
33434 * FLAC__stream_encoder_set_do_qlp_coeff_prec_search()
33435 * FLAC__stream_encoder_set_do_escape_coding()
33436 * FLAC__stream_encoder_set_do_exhaustive_model_search()
33437 * FLAC__stream_encoder_set_min_residual_partition_order()
33438 * FLAC__stream_encoder_set_max_residual_partition_order()
33439 * FLAC__stream_encoder_set_rice_parameter_search_dist()
33440 * </pre>
33441 * The actual values set for each level are:
33442 * | level | do mid-side stereo | loose mid-side stereo | apodization | max lpc order | qlp coeff precision | qlp coeff prec search | escape coding | exhaustive model search | min residual partition order | max residual partition order | rice parameter search dist |
33443 * |--------|---------------------|------------------------|------------------------------------------------|----------------|----------------------|------------------------|----------------|--------------------------|-------------------------------|-------------------------------|------------------------------|
33444 * | 0 | false | false | tukey(0.5) | 0 | 0 | false | false | false | 0 | 3 | 0 |
33445 * | 1 | true | true | tukey(0.5) | 0 | 0 | false | false | false | 0 | 3 | 0 |
33446 * | 2 | true | false | tukey(0.5) | 0 | 0 | false | false | false | 0 | 3 | 0 |
33447 * | 3 | false | false | tukey(0.5) | 6 | 0 | false | false | false | 0 | 4 | 0 |
33448 * | 4 | true | true | tukey(0.5) | 8 | 0 | false | false | false | 0 | 4 | 0 |
33449 * | 5 | true | false | tukey(0.5) | 8 | 0 | false | false | false | 0 | 5 | 0 |
33450 * | 6 | true | false | tukey(0.5);partial_tukey(2) | 8 | 0 | false | false | false | 0 | 6 | 0 |
33451 * | 7 | true | false | tukey(0.5);partial_tukey(2) | 12 | 0 | false | false | false | 0 | 6 | 0 |
33452 * | 8 | true | false | tukey(0.5);partial_tukey(2);punchout_tukey(3) | 12 | 0 | false | false | false | 0 | 6 | 0 |
33453 *
33454 * @interface CompressionLevel
33455 * @memberOf Flac
33456 *
33457 * @property {"FLAC__COMPRESSION_LEVEL_0"} 0 compression level 0
33458 * @property {"FLAC__COMPRESSION_LEVEL_1"} 1 compression level 1
33459 * @property {"FLAC__COMPRESSION_LEVEL_2"} 2 compression level 2
33460 * @property {"FLAC__COMPRESSION_LEVEL_3"} 3 compression level 3
33461 * @property {"FLAC__COMPRESSION_LEVEL_4"} 4 compression level 4
33462 * @property {"FLAC__COMPRESSION_LEVEL_5"} 5 compression level 5
33463 * @property {"FLAC__COMPRESSION_LEVEL_6"} 6 compression level 6
33464 * @property {"FLAC__COMPRESSION_LEVEL_7"} 7 compression level 7
33465 * @property {"FLAC__COMPRESSION_LEVEL_8"} 8 compression level 8
33466 */
33467 /**
33468 * Create an encoder.
33469 *
33470 * @param {number} sample_rate
33471 * the sample rate of the input PCM data
33472 * @param {number} channels
33473 * the number of channels of the input PCM data
33474 * @param {number} bps
33475 * bits per sample of the input PCM data
33476 * @param {Flac.CompressionLevel} compression_level
33477 * the desired Flac compression level: [0, 8]
33478 * @param {number} [total_samples] OPTIONAL
33479 * the number of total samples of the input PCM data:<br>
33480 * Sets an estimate of the total samples that will be encoded.
33481 * This is merely an estimate and may be set to 0 if unknown.
33482 * This value will be written to the STREAMINFO block before encoding,
33483 * and can remove the need for the caller to rewrite the value later if
33484 * the value is known before encoding.<br>
33485 * If specified, the it will be written into metadata of the FLAC header.<br>
33486 * DEFAULT: 0 (i.e. unknown number of samples)
33487 * @param {boolean} [is_verify] OPTIONAL
33488 * enable/disable checksum verification during encoding<br>
33489 * DEFAULT: true<br>
33490 * NOTE: this argument is positional (i.e. total_samples must also be given)
33491 * @param {number} [block_size] OPTIONAL
33492 * the number of samples to use per frame.<br>
33493 * DEFAULT: 0 (i.e. encoder sets block size automatically)
33494 * NOTE: this argument is positional (i.e. total_samples and is_verify must also be given)
33495 *
33496 *
33497 * @returns {number} the ID of the created encoder instance (or 0, if there was an error)
33498 *
33499 * @memberOf Flac#
33500 * @function
33501 */
33502 create_libflac_encoder: function(sample_rate, channels, bps, compression_level, total_samples, is_verify, block_size){
33503 is_verify = typeof is_verify === 'undefined'? 1 : is_verify + 0;
33504 total_samples = typeof total_samples === 'number'? total_samples : 0;
33505 block_size = typeof block_size === 'number'? block_size : 0;
33506 var ok = true;
33507 var encoder = Module.ccall('FLAC__stream_encoder_new', 'number', [ ], [ ]);
33508 ok &= Module.ccall('FLAC__stream_encoder_set_verify', 'number', ['number', 'number'], [ encoder, is_verify ]);
33509 ok &= Module.ccall('FLAC__stream_encoder_set_compression_level', 'number', ['number', 'number'], [ encoder, compression_level ]);
33510 ok &= Module.ccall('FLAC__stream_encoder_set_channels', 'number', ['number', 'number'], [ encoder, channels ]);
33511 ok &= Module.ccall('FLAC__stream_encoder_set_bits_per_sample', 'number', ['number', 'number'], [ encoder, bps ]);
33512 ok &= Module.ccall('FLAC__stream_encoder_set_sample_rate', 'number', ['number', 'number'], [ encoder, sample_rate ]);
33513 ok &= Module.ccall('FLAC__stream_encoder_set_blocksize', 'number', [ 'number', 'number'], [ encoder, block_size ]);
33514 ok &= Module.ccall('FLAC__stream_encoder_set_total_samples_estimate', 'number', ['number', 'number'], [ encoder, total_samples ]);
33515 if (ok){
33516 do_fire_event('created', [{type: 'created', target: {id: encoder, type: 'encoder'}}], false);
33517 return encoder;
33518 }
33519 return 0;
33520 },
33521 /**
33522 * @deprecated use {@link #create_libflac_encoder} instead
33523 * @memberOf Flac#
33524 * @function
33525 */
33526 init_libflac_encoder: function(){
33527 console.warn('Flac.init_libflac_encoder() is deprecated, use Flac.create_libflac_encoder() instead!');
33528 return this.create_libflac_encoder.apply(this, arguments);
33529 },
33530
33531 /**
33532 * Create a decoder.
33533 *
33534 * @param {boolean} [is_verify]
33535 * enable/disable checksum verification during decoding<br>
33536 * DEFAULT: true
33537 *
33538 * @returns {number} the ID of the created decoder instance (or 0, if there was an error)
33539 *
33540 * @memberOf Flac#
33541 * @function
33542 */
33543 create_libflac_decoder: function(is_verify){
33544 is_verify = typeof is_verify === 'undefined'? 1 : is_verify + 0;
33545 var ok = true;
33546 var decoder = Module.ccall('FLAC__stream_decoder_new', 'number', [ ], [ ]);
33547 ok &= Module.ccall('FLAC__stream_decoder_set_md5_checking', 'number', ['number', 'number'], [ decoder, is_verify ]);
33548 if (ok){
33549 do_fire_event('created', [{type: 'created', target: {id: decoder, type: 'decoder'}}], false);
33550 return decoder;
33551 }
33552 return 0;
33553 },
33554 /**
33555 * @deprecated use {@link #create_libflac_decoder} instead
33556 * @memberOf Flac#
33557 * @function
33558 */
33559 init_libflac_decoder: function(){
33560 console.warn('Flac.init_libflac_decoder() is deprecated, use Flac.create_libflac_decoder() instead!');
33561 return this.create_libflac_decoder.apply(this, arguments);
33562 },
33563 /**
33564 * The callback for writing the encoded FLAC data.
33565 *
33566 * @callback Flac~encoder_write_callback_fn
33567 * @param {Uint8Array} data the encoded FLAC data
33568 * @param {number} numberOfBytes the number of bytes in data
33569 * @param {number} samples the number of samples encoded in data
33570 * @param {number} currentFrame the number of the (current) encoded frame in data
33571 * @returns {void | false} returning <code>false</code> indicates that an
33572 * unrecoverable error occurred and decoding should be aborted
33573 */
33574 /**
33575 * The callback for the metadata of the encoded/decoded Flac data.
33576 *
33577 * By default, only the STREAMINFO metadata is enabled.
33578 *
33579 * For other metadata types {@link Flac.FLAC__MetadataType} they need to be enabled,
33580 * see e.g. {@link Flac#FLAC__stream_decoder_set_metadata_respond}
33581 *
33582 * @callback Flac~metadata_callback_fn
33583 * @param {Flac.StreamMetadata | undefined} metadata the FLAC meta data, NOTE only STREAMINFO is returned in first argument, for other types use 2nd argument's <code>metadataBlock.data<code>
33584 * @param {Flac.MetadataBlock} metadataBlock the detailed meta data block
33585 *
33586 * @see Flac#init_decoder_stream
33587 * @see Flac#init_encoder_stream
33588 * @see Flac.CodingOptions
33589 * @see Flac#FLAC__stream_decoder_set_metadata_respond_all
33590 */
33591 /**
33592 * FLAC meta data
33593 * @interface Metadata
33594 * @memberOf Flac
33595 * @property {number} sampleRate the sample rate (Hz)
33596 * @property {number} channels the number of channels
33597 * @property {number} bitsPerSample bits per sample
33598 */
33599 /**
33600 * FLAC stream meta data
33601 * @interface StreamMetadata
33602 * @memberOf Flac
33603 * @augments Flac.Metadata
33604 * @property {number} min_blocksize the minimal block size (bytes)
33605 * @property {number} max_blocksize the maximal block size (bytes)
33606 * @property {number} min_framesize the minimal frame size (bytes)
33607 * @property {number} max_framesize the maximal frame size (bytes)
33608 * @property {number} total_samples the total number of (encoded/decoded) samples
33609 * @property {string} md5sum the MD5 checksum for the decoded data (if validation is active)
33610 */
33611 /**
33612 * Initialize the encoder.
33613 *
33614 * @param {number} encoder
33615 * the ID of the encoder instance that has not been initialized (or has been reset)
33616 *
33617 * @param {Flac~encoder_write_callback_fn} write_callback_fn
33618 * the callback for writing the encoded Flac data:
33619 * <pre>write_callback_fn(data: Uint8Array, numberOfBytes: Number, samples: Number, currentFrame: Number)</pre>
33620 *
33621 * @param {Flac~metadata_callback_fn} [metadata_callback_fn] OPTIONAL
33622 * the callback for the metadata of the encoded Flac data:
33623 * <pre>metadata_callback_fn(metadata: StreamMetadata)</pre>
33624 *
33625 * @param {number|boolean} [ogg_serial_number] OPTIONAL
33626 * if number or <code>true</code> is specified, the encoder will be initialized to
33627 * write to an OGG container, see {@link Flac.init_encoder_ogg_stream}:
33628 * <code>true</code> will set a default serial number (<code>1</code>),
33629 * if specified as number, it will be used as the stream's serial number within the ogg container.
33630 *
33631 * @returns {Flac.FLAC__StreamEncoderInitStatus} the encoder status (<code>0</code> for <code>FLAC__STREAM_ENCODER_INIT_STATUS_OK</code>)
33632 *
33633 * @memberOf Flac#
33634 * @function
33635 */
33636 init_encoder_stream: function(encoder, write_callback_fn, metadata_callback_fn, ogg_serial_number, client_data){
33637
33638 var is_ogg = (ogg_serial_number === true);
33639 client_data = client_data|0;
33640
33641 if(typeof write_callback_fn !== 'function'){
33642 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_CALLBACKS;
33643 }
33644 setCallback(encoder, 'write', write_callback_fn);
33645
33646 var __metadata_callback_fn_ptr = 0;
33647 if(typeof metadata_callback_fn === 'function'){
33648 setCallback(encoder, 'metadata', metadata_callback_fn);
33649 __metadata_callback_fn_ptr = metadata_fn_ptr;
33650 }
33651
33652 //NOTE the following comments are used for auto-detecting exported functions (only change if ccall function name(s) change!):
33653 // Module.ccall('FLAC__stream_encoder_init_stream'
33654 var func_name = 'FLAC__stream_encoder_init_stream';
33655 var args_types = ['number', 'number', 'number', 'number', 'number', 'number'];
33656 var args = [
33657 encoder,
33658 enc_write_fn_ptr,
33659 0,// FLAC__StreamEncoderSeekCallback
33660 0,// FLAC__StreamEncoderTellCallback
33661 __metadata_callback_fn_ptr,
33662 client_data
33663 ];
33664
33665 if(typeof ogg_serial_number === 'number'){
33666
33667 is_ogg = true;
33668
33669 } else if(is_ogg){//else: set default serial number for stream in OGG container
33670
33671 //NOTE from FLAC docs: "It is recommended to set a serial number explicitly as the default of '0' may collide with other streams."
33672 ogg_serial_number = 1;
33673 }
33674
33675 if(is_ogg){
33676 //NOTE the following comments are used for auto-detecting exported functions (only change if ccall function name(s) change!):
33677 // Module.ccall('FLAC__stream_encoder_init_ogg_stream'
33678 func_name = 'FLAC__stream_encoder_init_ogg_stream';
33679
33680 //2nd arg: FLAC__StreamEncoderReadCallback ptr -> duplicate first entry & insert at [1]
33681 args.unshift(args[0]);
33682 args[1] = 0;// FLAC__StreamEncoderReadCallback
33683
33684 args_types.unshift(args_types[0]);
33685 args_types[1] = 'number';
33686
33687
33688 //NOTE ignore BOOL return value when setting serial number, since init-call's returned
33689 // status will also indicate, if encoder already has been initialized
33690 Module.ccall(
33691 'FLAC__stream_encoder_set_ogg_serial_number', 'number',
33692 ['number', 'number'],
33693 [ encoder, ogg_serial_number ]
33694 );
33695 }
33696
33697 var init_status = Module.ccall(func_name, 'number', args_types, args);
33698
33699 return init_status;
33700 },
33701 /**
33702 * Initialize the encoder for writing to an OGG container.
33703 *
33704 * @param {number} [ogg_serial_number] OPTIONAL
33705 * the serial number for the stream in the OGG container
33706 * DEFAULT: <code>1</code>
33707 *
33708 * @memberOf Flac#
33709 * @function
33710 * @copydoc #init_encoder_stream
33711 */
33712 init_encoder_ogg_stream: function(encoder, write_callback_fn, metadata_callback_fn, ogg_serial_number, client_data){
33713
33714 if(typeof ogg_serial_number !== 'number'){
33715 ogg_serial_number = true;
33716 }
33717 return this.init_encoder_stream(encoder, write_callback_fn, metadata_callback_fn, ogg_serial_number, client_data);
33718 },
33719 /**
33720 * Result / return value for {@link Flac~decoder_read_callback_fn} callback function
33721 *
33722 * @interface ReadResult
33723 * @memberOf Flac
33724 * @property {TypedArray} buffer a TypedArray (e.g. Uint8Array) with the read data
33725 * @property {number} readDataLength the number of read data bytes. A number of <code>0</code> (zero) indicates that the end-of-stream is reached.
33726 * @property {boolean} [error] OPTIONAL value of <code>true</code> indicates that an error occured (decoding will be aborted)
33727 */
33728 /**
33729 * Result / return value for {@link Flac~decoder_read_callback_fn} callback function for signifying that there is no more data to read
33730 *
33731 * @interface CompletedReadResult
33732 * @memberOf Flac
33733 * @augments Flac.ReadResult
33734 * @property {TypedArray | undefined} buffer a TypedArray (e.g. Uint8Array) with the read data (will be ignored in case readDataLength is <code>0</code>)
33735 * @property {0} readDataLength the number of read data bytes: The number of <code>0</code> (zero) indicates that the end-of-stream is reached.
33736 */
33737 /**
33738 * The callback for reading the FLAC data that will be decoded.
33739 *
33740 * @callback Flac~decoder_read_callback_fn
33741 * @param {number} numberOfBytes the maximal number of bytes that the read callback can return
33742 * @returns {Flac.ReadResult | Flac.CompletedReadResult} the result of the reading action/request
33743 */
33744 /**
33745 * The callback for writing the decoded FLAC data.
33746 *
33747 * @callback Flac~decoder_write_callback_fn
33748 * @param {Uint8Array[]} data array of the channels with the decoded PCM data as <code>Uint8Array</code>s
33749 * @param {Flac.BlockMetadata} frameInfo the metadata information for the decoded data
33750 */
33751 /**
33752 * The callback for reporting decoding errors.
33753 *
33754 * @callback Flac~decoder_error_callback_fn
33755 * @param {number} errorCode the error code
33756 * @param {Flac.FLAC__StreamDecoderErrorStatus} errorDescription the string representation / description of the error
33757 */
33758 /**
33759 * FLAC block meta data
33760 * @interface BlockMetadata
33761 * @augments Flac.Metadata
33762 * @memberOf Flac
33763 *
33764 * @property {number} blocksize the block size (bytes)
33765 * @property {number} number the number of the decoded samples or frames
33766 * @property {string} numberType the type to which <code>number</code> refers to: either <code>"frames"</code> or <code>"samples"</code>
33767 * @property {Flac.FLAC__ChannelAssignment} channelAssignment the channel assignment
33768 * @property {string} crc the MD5 checksum for the decoded data, if validation is enabled
33769 * @property {Flac.SubFrameMetadata[]} [subframes] the metadata of the subframes. The array length corresponds to the number of channels. NOTE will only be included if {@link Flac.CodingOptions CodingOptions.analyseSubframes} is enabled for the decoder.
33770 *
33771 * @see Flac.CodingOptions
33772 * @see Flac#setOptions
33773 */
33774 /**
33775 * FLAC subframe metadata
33776 * @interface SubFrameMetadata
33777 * @memberOf Flac
33778 *
33779 * @property {Flac.FLAC__SubframeType} type the type of the subframe
33780 * @property {number|Flac.FixedSubFrameData|Flac.LPCSubFrameData} data the type specific metadata for subframe
33781 * @property {number} wastedBits the wasted bits-per-sample
33782 */
33783 /**
33784 * metadata for FIXED subframe type
33785 * @interface FixedSubFrameData
33786 * @memberOf Flac
33787 *
33788 * @property {number} order The polynomial order.
33789 * @property {number[]} warmup Warmup samples to prime the predictor, length == order.
33790 * @property {Flac.SubFramePartition} partition The residual coding method.
33791 * @property {number[]} [residual] The residual signal, length == (blocksize minus order) samples.
33792 * NOTE will only be included if {@link Flac.CodingOptions CodingOptions.analyseSubframes} is enabled for the decoder.
33793 */
33794 /**
33795 * metadata for LPC subframe type
33796 * @interface LPCSubFrameData
33797 * @augments Flac.FixedSubFrameData
33798 * @memberOf Flac
33799 *
33800 * @property {number} order The FIR order.
33801 * @property {number[]} qlp_coeff FIR filter coefficients.
33802 * @property {number} qlp_coeff_precision Quantized FIR filter coefficient precision in bits.
33803 * @property {number} quantization_level The qlp coeff shift needed.
33804 */
33805 /**
33806 * metadata for FIXED or LPC subframe partitions
33807 * @interface SubFramePartition
33808 * @memberOf Flac
33809 *
33810 * @property {Flac.FLAC__EntropyCodingMethodType} type the entropy coding method
33811 * @property {Flac.SubFramePartitionData} data metadata for a Rice partitioned residual
33812 */
33813 /**
33814 * metadata for FIXED or LPC subframe partition data
33815 * @interface SubFramePartitionData
33816 * @memberOf Flac
33817 *
33818 * @property {number} order The partition order, i.e. # of contexts = 2 ^ order.
33819 * @property {Flac.SubFramePartitionContent} contents The context's Rice parameters and/or raw bits.
33820 */
33821 /**
33822 * metadata for FIXED or LPC subframe partition data content
33823 * @interface SubFramePartitionContent
33824 * @memberOf Flac
33825 *
33826 * @property {number[]} parameters The Rice parameters for each context.
33827 * @property {number[]} rawBits Widths for escape-coded partitions. Will be non-zero for escaped partitions and zero for unescaped partitions.
33828 * @property {number} capacityByOrder The capacity of the parameters and raw_bits arrays specified as an order, i.e. the number of array elements allocated is 2 ^ capacity_by_order.
33829 */
33830 /**
33831 * The types for FLAC subframes
33832 *
33833 * @interface FLAC__SubframeType
33834 * @memberOf Flac
33835 *
33836 * @property {"FLAC__SUBFRAME_TYPE_CONSTANT"}Â 0 constant signal
33837 * @property {"FLAC__SUBFRAME_TYPE_VERBATIM"}Â 1 uncompressed signal
33838 * @property {"FLAC__SUBFRAME_TYPE_FIXED"}Â 2 fixed polynomial prediction
33839 * @property {"FLAC__SUBFRAME_TYPE_LPC"}Â 3 linear prediction
33840 */
33841 /**
33842 * The channel assignment for the (decoded) frame.
33843 *
33844 * @interface FLAC__ChannelAssignment
33845 * @memberOf Flac
33846 *
33847 * @property {"FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT"} 0 independent channels
33848 * @property {"FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE"} 1 left+side stereo
33849 * @property {"FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE"} 2 right+side stereo
33850 * @property {"FLAC__CHANNEL_ASSIGNMENT_MID_SIDE"} 3 mid+side stereo
33851 */
33852 /**
33853 * entropy coding methods
33854 *
33855 * @interface FLAC__EntropyCodingMethodType
33856 * @memberOf Flac
33857 *
33858 * @property {"FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE"}Â 0 Residual is coded by partitioning into contexts, each with it's own 4-bit Rice parameter.
33859 * @property {"FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2"}Â 1 Residual is coded by partitioning into contexts, each with it's own 5-bit Rice parameter.
33860 */
33861 /**
33862 * Initialize the decoder.
33863 *
33864 * @param {number} decoder
33865 * the ID of the decoder instance that has not been initialized (or has been reset)
33866 *
33867 * @param {Flac~decoder_read_callback_fn} read_callback_fn
33868 * the callback for reading the Flac data that should get decoded:
33869 * <pre>read_callback_fn(numberOfBytes: Number) : {buffer: ArrayBuffer, readDataLength: number, error: boolean}</pre>
33870 *
33871 * @param {Flac~decoder_write_callback_fn} write_callback_fn
33872 * the callback for writing the decoded data:
33873 * <pre>write_callback_fn(data: Uint8Array[], frameInfo: Metadata)</pre>
33874 *
33875 * @param {Flac~decoder_error_callback_fn} error_callback_fn
33876 * the error callback:
33877 * <pre>error_callback_fn(errorCode: Number, errorDescription: String)</pre>
33878 *
33879 * @param {Flac~metadata_callback_fn} [metadata_callback_fn] OPTIONAL
33880 * callback for receiving the metadata of FLAC data that will be decoded:
33881 * <pre>metadata_callback_fn(metadata: StreamMetadata)</pre>
33882 *
33883 * @param {number|boolean} [ogg_serial_number] OPTIONAL
33884 * if number or <code>true</code> is specified, the decoder will be initilized to
33885 * read from an OGG container, see {@link Flac.init_decoder_ogg_stream}:<br/>
33886 * <code>true</code> will use the default serial number, if specified as number the
33887 * corresponding stream with the serial number from the ogg container will be used.
33888 *
33889 * @returns {Flac.FLAC__StreamDecoderInitStatus} the decoder status(<code>0</code> for <code>FLAC__STREAM_DECODER_INIT_STATUS_OK</code>)
33890 *
33891 * @memberOf Flac#
33892 * @function
33893 */
33894 init_decoder_stream: function(decoder, read_callback_fn, write_callback_fn, error_callback_fn, metadata_callback_fn, ogg_serial_number, client_data){
33895
33896 client_data = client_data|0;
33897
33898 if(typeof read_callback_fn !== 'function'){
33899 return FLAC__STREAM_DECODER_INIT_STATUS_INVALID_CALLBACKS;
33900 }
33901 setCallback(decoder, 'read', read_callback_fn);
33902
33903 if(typeof write_callback_fn !== 'function'){
33904 return FLAC__STREAM_DECODER_INIT_STATUS_INVALID_CALLBACKS;
33905 }
33906 setCallback(decoder, 'write', write_callback_fn);
33907
33908 var __error_callback_fn_ptr = 0;
33909 if(typeof error_callback_fn === 'function'){
33910 setCallback(decoder, 'error', error_callback_fn);
33911 __error_callback_fn_ptr = dec_error_fn_ptr;
33912 }
33913
33914 var __metadata_callback_fn_ptr = 0;
33915 if(typeof metadata_callback_fn === 'function'){
33916 setCallback(decoder, 'metadata', metadata_callback_fn);
33917 __metadata_callback_fn_ptr = metadata_fn_ptr;
33918 }
33919
33920 var is_ogg = (ogg_serial_number === true);
33921 if(typeof ogg_serial_number === 'number'){
33922
33923 is_ogg = true;
33924
33925 //NOTE ignore BOOL return value when setting serial number, since init-call's returned
33926 // status will also indicate, if decoder already has been initialized
33927 Module.ccall(
33928 'FLAC__stream_decoder_set_ogg_serial_number', 'number',
33929 ['number', 'number'],
33930 [ decoder, ogg_serial_number ]
33931 );
33932 }
33933
33934 //NOTE the following comments are used for auto-detecting exported functions (only change if ccall function name(s) change!):
33935 // Module.ccall('FLAC__stream_decoder_init_stream'
33936 // Module.ccall('FLAC__stream_decoder_init_ogg_stream'
33937 var init_func_name = !is_ogg? 'FLAC__stream_decoder_init_stream' : 'FLAC__stream_decoder_init_ogg_stream';
33938
33939 var init_status = Module.ccall(
33940 init_func_name, 'number',
33941 [ 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number'],
33942 [
33943 decoder,
33944 dec_read_fn_ptr,
33945 0,// FLAC__StreamDecoderSeekCallback
33946 0,// FLAC__StreamDecoderTellCallback
33947 0,// FLAC__StreamDecoderLengthCallback
33948 0,// FLAC__StreamDecoderEofCallback
33949 dec_write_fn_ptr,
33950 __metadata_callback_fn_ptr,
33951 __error_callback_fn_ptr,
33952 client_data
33953 ]
33954 );
33955
33956 return init_status;
33957 },
33958 /**
33959 * Initialize the decoder for writing to an OGG container.
33960 *
33961 * @param {number} [ogg_serial_number] OPTIONAL
33962 * the serial number for the stream in the OGG container that should be decoded.<br/>
33963 * The default behavior is to use the serial number of the first Ogg page. Setting a serial number here will explicitly specify which stream is to be decoded.
33964 *
33965 * @memberOf Flac#
33966 * @function
33967 * @copydoc #init_decoder_stream
33968 */
33969 init_decoder_ogg_stream: function(decoder, read_callback_fn, write_callback_fn, error_callback_fn, metadata_callback_fn, ogg_serial_number, client_data){
33970
33971 if(typeof ogg_serial_number !== 'number'){
33972 ogg_serial_number = true;
33973 }
33974 return this.init_decoder_stream(decoder, read_callback_fn, write_callback_fn, error_callback_fn, metadata_callback_fn, ogg_serial_number, client_data);
33975 },
33976 /**
33977 * Encode / submit data for encoding.
33978 *
33979 * This version allows you to supply the input data where the channels are interleaved into a
33980 * single array (i.e. channel0_sample0, channel1_sample0, ... , channelN_sample0, channel0_sample1, ...).
33981 *
33982 * The samples need not be block-aligned but they must be sample-aligned, i.e. the first value should be
33983 * channel0_sample0 and the last value channelN_sampleM.
33984 *
33985 * Each sample should be a signed integer, right-justified to the resolution set by bits-per-sample.
33986 *
33987 * For example, if the resolution is 16 bits per sample, the samples should all be in the range [-32768,32767].
33988 *
33989 *
33990 * For applications where channel order is important, channels must follow the order as described in the frame header.
33991 *
33992 * @param {number} encoder
33993 * the ID of the encoder instance
33994 *
33995 * @param {TypedArray} buffer
33996 * the audio data in a typed array with signed integers (and size according to the set bits-per-sample setting)
33997 *
33998 * @param {number} num_of_samples
33999 * the number of samples in buffer
34000 *
34001 * @returns {boolean} true if successful, else false; in this case, check the encoder state with FLAC__stream_encoder_get_state() to see what went wrong.
34002 *
34003 * @memberOf Flac#
34004 * @function
34005 */
34006 FLAC__stream_encoder_process_interleaved: function(encoder, buffer, num_of_samples){
34007 // get the length of the data in bytes
34008 var numBytes = buffer.length * buffer.BYTES_PER_ELEMENT;
34009 // malloc enough space for the data
34010 var ptr = Module._malloc(numBytes);
34011 // get a bytes-wise view on the newly allocated buffer
34012 var heapBytes= new Uint8Array(Module.HEAPU8.buffer, ptr, numBytes);
34013 // copy data into heapBytes
34014 heapBytes.set(new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength));// issue #11 (2): do use byteOffset and byteLength for copying the data in case the underlying buffer/ArrayBuffer of the TypedArray view is larger than the TypedArray
34015 var status = Module.ccall('FLAC__stream_encoder_process_interleaved', 'number',
34016 ['number', 'number', 'number'],
34017 [encoder, heapBytes.byteOffset, num_of_samples]
34018 );
34019 Module._free(ptr);
34020 return status;
34021 },
34022
34023 /**
34024 * Encode / submit data for encoding.
34025 *
34026 * Submit data for encoding. This version allows you to supply the input data via an array of pointers,
34027 * each pointer pointing to an array of samples samples representing one channel.
34028 * The samples need not be block-aligned, but each channel should have the same number of samples.
34029 *
34030 * Each sample should be a signed integer, right-justified to the resolution set by FLAC__stream_encoder_set_bits_per_sample().
34031 * For example, if the resolution is 16 bits per sample, the samples should all be in the range [-32768,32767].
34032 *
34033 *
34034 * For applications where channel order is important, channels must follow the order as described in the frame header.
34035 *
34036 * @param {number} encoder
34037 * the ID of the encoder instance
34038 *
34039 * @param {TypedArray[]} channelBuffers
34040 * an array for the audio data channels as typed arrays with signed integers (and size according to the set bits-per-sample setting)
34041 *
34042 * @param {number} num_of_samples
34043 * the number of samples in one channel (i.e. one of the buffers)
34044 *
34045 * @returns {boolean} true if successful, else false; in this case, check the encoder state with FLAC__stream_encoder_get_state() to see what went wrong.
34046 *
34047 * @memberOf Flac#
34048 * @function
34049 */
34050 FLAC__stream_encoder_process: function(encoder, channelBuffers, num_of_samples){
34051
34052 var ptrInfo = this._create_pointer_array(channelBuffers);
34053 var pointerPtr = ptrInfo.pointerPointer;
34054
34055 var status = Module.ccall('FLAC__stream_encoder_process', 'number',
34056 ['number', 'number', 'number'],
34057 [encoder, pointerPtr, num_of_samples]
34058 );
34059
34060 this._destroy_pointer_array(ptrInfo);
34061 return status;
34062 },
34063 /**
34064 * Decodes a single frame.
34065 *
34066 * To check decoding progress, use {@link #FLAC__stream_decoder_get_state}.
34067 *
34068 * @param {number} decoder
34069 * the ID of the decoder instance
34070 *
34071 * @returns {boolean} FALSE if an error occurred
34072 *
34073 * @memberOf Flac#
34074 * @function
34075 */
34076 FLAC__stream_decoder_process_single: Module.cwrap('FLAC__stream_decoder_process_single', 'number', ['number']),
34077
34078 /**
34079 * Decodes data until end of stream.
34080 *
34081 * @param {number} decoder
34082 * the ID of the decoder instance
34083 *
34084 * @returns {boolean} FALSE if an error occurred
34085 *
34086 * @memberOf Flac#
34087 * @function
34088 */
34089 FLAC__stream_decoder_process_until_end_of_stream: Module.cwrap('FLAC__stream_decoder_process_until_end_of_stream', 'number', ['number']),
34090
34091 /**
34092 * Decodes data until end of metadata.
34093 *
34094 * @param {number} decoder
34095 * the ID of the decoder instance
34096 *
34097 * @returns {boolean} false if any fatal read, write, or memory allocation error occurred (meaning decoding must stop), else true.
34098 *
34099 * @memberOf Flac#
34100 * @function
34101 */
34102 FLAC__stream_decoder_process_until_end_of_metadata: Module.cwrap('FLAC__stream_decoder_process_until_end_of_metadata', 'number', ['number']),
34103
34104 /**
34105 * Decoder state code.
34106 *
34107 * @interface FLAC__StreamDecoderState
34108 * @memberOf Flac
34109 *
34110 * @property {"FLAC__STREAM_DECODER_SEARCH_FOR_METADATA"} 0 The decoder is ready to search for metadata
34111 * @property {"FLAC__STREAM_DECODER_READ_METADATA"} 1 The decoder is ready to or is in the process of reading metadata
34112 * @property {"FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC"} 2 The decoder is ready to or is in the process of searching for the frame sync code
34113 * @property {"FLAC__STREAM_DECODER_READ_FRAME"} 3 The decoder is ready to or is in the process of reading a frame
34114 * @property {"FLAC__STREAM_DECODER_END_OF_STREAM"} 4 The decoder has reached the end of the stream
34115 * @property {"FLAC__STREAM_DECODER_OGG_ERROR"} 5 An error occurred in the underlying Ogg layer
34116 * @property {"FLAC__STREAM_DECODER_SEEK_ERROR"} 6 An error occurred while seeking. The decoder must be flushed with FLAC__stream_decoder_flush() or reset with FLAC__stream_decoder_reset() before decoding can continue
34117 * @property {"FLAC__STREAM_DECODER_ABORTED"} 7 The decoder was aborted by the read callback
34118 * @property {"FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR"} 8 An error occurred allocating memory. The decoder is in an invalid state and can no longer be used
34119 * @property {"FLAC__STREAM_DECODER_UNINITIALIZED"} 9 The decoder is in the uninitialized state; one of the FLAC__stream_decoder_init_*() functions must be called before samples can be processed.
34120 *
34121 */
34122 /**
34123 *
34124 * @param {number} decoder
34125 * the ID of the decoder instance
34126 *
34127 * @returns {Flac.FLAC__StreamDecoderState} the decoder state
34128 *
34129 * @memberOf Flac#
34130 * @function
34131 */
34132 FLAC__stream_decoder_get_state: Module.cwrap('FLAC__stream_decoder_get_state', 'number', ['number']),
34133
34134 /**
34135 * Encoder state code.
34136 *
34137 * @interface FLAC__StreamEncoderState
34138 * @memberOf Flac
34139 *
34140 * @property {"FLAC__STREAM_ENCODER_OK"} 0 The encoder is in the normal OK state and samples can be processed.
34141 * @property {"FLAC__STREAM_ENCODER_UNINITIALIZED"} 1 The encoder is in the uninitialized state; one of the FLAC__stream_encoder_init_*() functions must be called before samples can be processed.
34142 * @property {"FLAC__STREAM_ENCODER_OGG_ERROR"} 2 An error occurred in the underlying Ogg layer.
34143 * @property {"FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR"} 3 An error occurred in the underlying verify stream decoder; check FLAC__stream_encoder_get_verify_decoder_state().
34144 * @property {"FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA"} 4 The verify decoder detected a mismatch between the original audio signal and the decoded audio signal.
34145 * @property {"FLAC__STREAM_ENCODER_CLIENT_ERROR"} 5 One of the callbacks returned a fatal error.
34146 * @property {"FLAC__STREAM_ENCODER_IO_ERROR"} 6 An I/O error occurred while opening/reading/writing a file. Check errno.
34147 * @property {"FLAC__STREAM_ENCODER_FRAMING_ERROR"} 7 An error occurred while writing the stream; usually, the write_callback returned an error.
34148 * @property {"FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR"} 8 Memory allocation failed.
34149 *
34150 */
34151 /**
34152 *
34153 * @param {number} encoder
34154 * the ID of the encoder instance
34155 *
34156 * @returns {Flac.FLAC__StreamEncoderState} the encoder state
34157 *
34158 * @memberOf Flac#
34159 * @function
34160 */
34161 FLAC__stream_encoder_get_state: Module.cwrap('FLAC__stream_encoder_get_state', 'number', ['number']),
34162 /**
34163 * Direct the decoder to pass on all metadata blocks of type type.
34164 *
34165 * By default, only the STREAMINFO block is returned via the metadata callback.
34166 *
34167 * <p>
34168 * NOTE: only use on un-initilized decoder instances!
34169 *
34170 * @param {number} decoder
34171 * the ID of the decoder instance
34172 *
34173 * @param {Flac.FLAC__MetadataType} type the metadata type to be enabled
34174 *
34175 * @returns {boolean} <code>false</code> if the decoder is already initialized, else <code>true</code>
34176 *
34177 * @memberOf Flac#
34178 * @function
34179 *
34180 * @see Flac#FLAC__stream_decoder_set_metadata_respond_all
34181 */
34182 FLAC__stream_decoder_set_metadata_respond: Module.cwrap('FLAC__stream_decoder_set_metadata_respond', 'number', ['number', 'number']),
34183 /**
34184 * Direct the decoder to pass on all APPLICATION metadata blocks of the given id.
34185 *
34186 * By default, only the STREAMINFO block is returned via the metadata callback.
34187 *
34188 * <p>
34189 * NOTE: only use on un-initilized decoder instances!
34190 *
34191 * @param {number} decoder
34192 * the ID of the decoder instance
34193 *
34194 * @param {number} id the ID of application metadata
34195 *
34196 * @returns {boolean} <code>false</code> if the decoder is already initialized, else <code>true</code>
34197 *
34198 * @memberOf Flac#
34199 * @function
34200 *
34201 * @see Flac#FLAC__stream_decoder_set_metadata_respond_all
34202 */
34203 FLAC__stream_decoder_set_metadata_respond_application: Module.cwrap('FLAC__stream_decoder_set_metadata_respond_application', 'number', ['number', 'number']),// (FLAC__StreamDecoder *decoder, const FLAC__byte id[4])
34204 /**
34205 * Direct the decoder to pass on all metadata blocks of any type.
34206 *
34207 * By default, only the STREAMINFO block is returned via the metadata callback.
34208 *
34209 * <p>
34210 * NOTE: only use on un-initilized decoder instances!
34211 *
34212 * @param {number} decoder
34213 * the ID of the decoder instance
34214 *
34215 * @returns {boolean} <code>false</code> if the decoder is already initialized, else <code>true</code>
34216 *
34217 * @memberOf Flac#
34218 * @function
34219 *
34220 * @see Flac#FLAC__stream_decoder_set_metadata_ignore_all
34221 * @see Flac#FLAC__stream_decoder_set_metadata_respond_application
34222 * @see Flac#FLAC__stream_decoder_set_metadata_respond
34223 */
34224 FLAC__stream_decoder_set_metadata_respond_all: Module.cwrap('FLAC__stream_decoder_set_metadata_respond_all', 'number', ['number']),// (FLAC__StreamDecoder *decoder)
34225 /**
34226 * Direct the decoder to filter out all metadata blocks of type type.
34227 *
34228 * By default, only the STREAMINFO block is returned via the metadata callback.
34229 *
34230 * <p>
34231 * NOTE: only use on un-initilized decoder instances!
34232 *
34233 * @param {number} decoder
34234 * the ID of the decoder instance
34235 *
34236 * @param {Flac.FLAC__MetadataType} type the metadata type to be ignored
34237 *
34238 * @returns {boolean} <code>false</code> if the decoder is already initialized, else <code>true</code>
34239 *
34240 * @memberOf Flac#
34241 * @function
34242 *
34243 * @see Flac#FLAC__stream_decoder_set_metadata_ignore_all
34244 */
34245 FLAC__stream_decoder_set_metadata_ignore: Module.cwrap('FLAC__stream_decoder_set_metadata_ignore', 'number', ['number', 'number']),// (FLAC__StreamDecoder *decoder, FLAC__MetadataType type)
34246 /**
34247 * Direct the decoder to filter out all APPLICATION metadata blocks of the given id.
34248 *
34249 * By default, only the STREAMINFO block is returned via the metadata callback.
34250 *
34251 * <p>
34252 * NOTE: only use on un-initilized decoder instances!
34253 *
34254 * @param {number} decoder
34255 * the ID of the decoder instance
34256 *
34257 * @param {number} id the ID of application metadata
34258 *
34259 * @returns {boolean} <code>false</code> if the decoder is already initialized, else <code>true</code>
34260 *
34261 * @memberOf Flac#
34262 * @function
34263 *
34264 * @see Flac#FLAC__stream_decoder_set_metadata_ignore_all
34265 */
34266 FLAC__stream_decoder_set_metadata_ignore_application: Module.cwrap('FLAC__stream_decoder_set_metadata_ignore_application', 'number', ['number', 'number']),// (FLAC__StreamDecoder *decoder, const FLAC__byte id[4])
34267 /**
34268 * Direct the decoder to filter out all metadata blocks of any type.
34269 *
34270 * By default, only the STREAMINFO block is returned via the metadata callback.
34271 *
34272 * <p>
34273 * NOTE: only use on un-initilized decoder instances!
34274 *
34275 * @param {number} decoder
34276 * the ID of the decoder instance
34277 *
34278 * @returns {boolean} <code>false</code> if the decoder is already initialized, else <code>true</code>
34279 *
34280 * @memberOf Flac#
34281 * @function
34282 *
34283 * @see Flac#FLAC__stream_decoder_set_metadata_respond_all
34284 * @see Flac#FLAC__stream_decoder_set_metadata_ignore
34285 * @see Flac#FLAC__stream_decoder_set_metadata_ignore_application
34286 */
34287 FLAC__stream_decoder_set_metadata_ignore_all: Module.cwrap('FLAC__stream_decoder_set_metadata_ignore_all', 'number', ['number']),// (FLAC__StreamDecoder *decoder)
34288 /**
34289 * Set the metadata blocks to be emitted to the stream before encoding. A value of NULL, 0 implies no metadata; otherwise, supply an array of pointers to metadata blocks.
34290 * The array is non-const since the encoder may need to change the is_last flag inside them, and in some cases update seek point offsets. Otherwise, the encoder
34291 * will not modify or free the blocks. It is up to the caller to free the metadata blocks after encoding finishes.
34292 *
34293 * <p>
34294 * The encoder stores only copies of the pointers in the metadata array; the metadata blocks themselves must survive at least until after FLAC__stream_encoder_finish() returns.
34295 * Do not free the blocks until then.
34296 *
34297 * The STREAMINFO block is always written and no STREAMINFO block may occur in the supplied array.
34298 *
34299 * By default the encoder does not create a SEEKTABLE. If one is supplied in the metadata array, but the client has specified that it does not support seeking,
34300 * then the SEEKTABLE will be written verbatim. However by itself this is not very useful as the client will not know the stream offsets for the seekpoints ahead of time.
34301 * In order to get a proper seektable the client must support seeking. See next note.
34302 *
34303 * SEEKTABLE blocks are handled specially. Since you will not know the values for the seek point stream offsets, you should pass in a SEEKTABLE 'template', that is,
34304 * a SEEKTABLE object with the required sample numbers (or placeholder points), with 0 for the frame_samples and stream_offset fields for each point.
34305 * If the client has specified that it supports seeking by providing a seek callback to FLAC__stream_encoder_init_stream() or both seek AND read callback to
34306 * FLAC__stream_encoder_init_ogg_stream() (or by using FLAC__stream_encoder_init*_file() or FLAC__stream_encoder_init*_FILE()), then while it is encoding the encoder will
34307 * fill the stream offsets in for you and when encoding is finished, it will seek back and write the real values into the SEEKTABLE block in the stream. There are helper
34308 * routines for manipulating seektable template blocks; see metadata.h: FLAC__metadata_object_seektable_template_*(). If the client does not support seeking,
34309 * the SEEKTABLE will have inaccurate offsets which will slow down or remove the ability to seek in the FLAC stream.
34310 *
34311 * The encoder instance will modify the first SEEKTABLE block as it transforms the template to a valid seektable while encoding, but it is still up to the caller to free
34312 * all metadata blocks after encoding.
34313 *
34314 * A VORBIS_COMMENT block may be supplied. The vendor string in it will be ignored. libFLAC will use it's own vendor string. libFLAC will not modify the passed-in
34315 * VORBIS_COMMENT's vendor string, it will simply write it's own into the stream. If no VORBIS_COMMENT block is present in the metadata array, libFLAC will write an
34316 * empty one, containing only the vendor string.
34317 *
34318 * The Ogg FLAC mapping requires that the VORBIS_COMMENT block be the second metadata block of the stream. The encoder already supplies the STREAMINFO block automatically.
34319 *
34320 * If metadata does not contain a VORBIS_COMMENT block, the encoder will supply that too. Otherwise, if metadata does contain a VORBIS_COMMENT block and it is not the first,
34321 * the init function will reorder metadata by moving the VORBIS_COMMENT block to the front; the relative ordering of the other blocks will remain as they were.
34322 *
34323 * The Ogg FLAC mapping limits the number of metadata blocks per stream to 65535. If num_blocks exceeds this the function will return false.
34324 *
34325 * @param {number} encoder
34326 * the ID of the encoder instance
34327 *
34328 * @param {Flac.PointerInfo} metadataBuffersPointer
34329 *
34330 * @param {number} num_blocks
34331 *
34332 * @returns {boolean} <code>false</code> if the encoder is already initialized, else <code>true</code>. <code>false</code> if the encoder is already initialized, or if num_blocks > 65535 if encoding to Ogg FLAC, else true.
34333 *
34334 * @memberOf Flac#
34335 * @function
34336 *
34337 * @see Flac.FLAC__MetadataType
34338 * @see Flac#_create_pointer_array
34339 * @see Flac#_destroy_pointer_array
34340 */
34341 FLAC__stream_encoder_set_metadata: function(encoder, metadataBuffersPointer, num_blocks){// ( FLAC__StreamEncoder * encoder, FLAC__StreamMetadata ** metadata, unsigned num_blocks)
34342 var status = Module.ccall('FLAC__stream_encoder_set_metadata', 'number',
34343 ['number', 'number', 'number'],
34344 [encoder, metadataBuffersPointer.pointerPointer, num_blocks]
34345 );
34346 return status;
34347 },
34348 /**
34349 * Helper object for allocating an array of buffers on the (memory) heap.
34350 *
34351 * @interface PointerInfo
34352 * @memberOf Flac
34353 * @property {number} pointerPointer pointer to the array of (pointer) buffers
34354 * @property {number[]} dataPointer array of pointers to the allocated data arrays (i.e. buffers)
34355 *
34356 * @see Flac#_create_pointer_array
34357 * @see Flac#_destroy_pointer_array
34358 */
34359 /**
34360 * Helper function for creating pointer (and allocating the data) to an array of buffers on the (memory) heap.
34361 *
34362 * Use the returned <code>PointerInfo.dataPointer</code> as argument, where the array-pointer is required.
34363 *
34364 * NOTE: afer use, the allocated buffers on the heap need be freed, see {@link #_destroy_pointer_array}.
34365 *
34366 * @param {Uint8Array[]} bufferArray
34367 * the buffer for which to create
34368 *
34369 * @returns {Flac.PointerInfo} <code>false</code> if the decoder is already initialized, else <code>true</code>
34370 *
34371 * @memberOf Flac#
34372 * @function
34373 *
34374 * @see Flac#_destroy_pointer_array
34375 */
34376 _create_pointer_array: function(bufferArray){
34377 var size=bufferArray.length;
34378 var ptrs = [], ptrData = new Uint32Array(size);
34379 var ptrOffsets = new DataView(ptrData.buffer);
34380 var buffer, numBytes, heapBytes, ptr;
34381 for(var i=0, size; i < size; ++i){
34382 buffer = bufferArray[i];
34383 // get the length of the data in bytes
34384 numBytes = buffer.length * buffer.BYTES_PER_ELEMENT;
34385 // malloc enough space for the data
34386 ptr = Module._malloc(numBytes);
34387 ptrs.push(ptr);
34388 // get a bytes-wise view on the newly allocated buffer
34389 heapBytes = new Uint8Array(Module.HEAPU8.buffer, ptr, numBytes);
34390 // copy data into heapBytes
34391 heapBytes.set(new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength));// use FIX for issue #11 (2)
34392 ptrOffsets.setUint32(i*4, ptr, true);
34393 }
34394 var nPointerBytes = ptrData.length * ptrData.BYTES_PER_ELEMENT
34395 var pointerPtr = Module._malloc(nPointerBytes);
34396 var pointerHeap = new Uint8Array(Module.HEAPU8.buffer, pointerPtr, nPointerBytes);
34397 pointerHeap.set( new Uint8Array(ptrData.buffer) );
34398
34399 return {
34400 dataPointer: ptrs,
34401 pointerPointer: pointerPtr
34402 };
34403 },
34404 /**
34405 * Helper function for destroying/freeing a previously created pointer (and allocating the data) of an array of buffers on the (memory) heap.
34406 *
34407 * @param {Flac.PointerInfo} pointerInfo
34408 * the pointer / allocation information that should be destroyed/freed
34409 *
34410 *
34411 * @memberOf Flac#
34412 * @function
34413 *
34414 * @see Flac#_create_pointer_array
34415 */
34416 _destroy_pointer_array: function(pointerInfo){
34417 var pointerArray = pointerInfo.dataPointer;
34418 for(var i=0, size=pointerArray.length; i < size; ++i){
34419 Module._free(pointerArray[i]);
34420 }
34421 Module._free(pointerInfo.pointerPointer);
34422 },
34423 /**
34424 * Get if MD5 verification is enabled for the decoder
34425 *
34426 * @param {number} decoder
34427 * the ID of the decoder instance
34428 *
34429 * @returns {boolean} <code>true</code> if MD5 verification is enabled
34430 *
34431 * @memberOf Flac#
34432 * @function
34433 *
34434 * @see #FLAC__stream_decoder_set_md5_checking
34435 */
34436 FLAC__stream_decoder_get_md5_checking: Module.cwrap('FLAC__stream_decoder_get_md5_checking', 'number', ['number']),
34437
34438 /**
34439 * Set the "MD5 signature checking" flag. If true, the decoder will compute the MD5 signature of the unencoded audio data while decoding and compare it to the signature from the STREAMINFO block,
34440 * if it exists, during {@link Flac.FLAC__stream_decoder_finish FLAC__stream_decoder_finish()}.
34441 *
34442 * MD5 signature checking will be turned off (until the next {@link Flac.FLAC__stream_decoder_reset FLAC__stream_decoder_reset()}) if there is no signature in the STREAMINFO block or when a seek is attempted.
34443 *
34444 * Clients that do not use the MD5 check should leave this off to speed up decoding.
34445 *
34446 * @param {number} decoder
34447 * the ID of the decoder instance
34448 * @param {boolean} is_verify
34449 * enable/disable checksum verification during decoding
34450 * @returns {boolean} FALSE if the decoder is already initialized, else TRUE.
34451 *
34452 * @memberOf Flac#
34453 * @function
34454 *
34455 * @see #FLAC__stream_decoder_get_md5_checking
34456 */
34457 FLAC__stream_decoder_set_md5_checking: function(decoder, is_verify){
34458 is_verify = is_verify? 1 : 0;
34459 return Module.ccall('FLAC__stream_decoder_set_md5_checking', 'number', ['number', 'number'], [ decoder, is_verify ]);
34460 },
34461
34462 /**
34463 * Finish the encoding process.
34464 *
34465 * @param {number} encoder
34466 * the ID of the encoder instance
34467 *
34468 * @returns {boolean} <code>false</code> if an error occurred processing the last frame;
34469 * or if verify mode is set, there was a verify mismatch; else <code>true</code>.
34470 * If <code>false</code>, caller should check the state with {@link Flac#FLAC__stream_encoder_get_state}
34471 * for more information about the error.
34472 *
34473 * @memberOf Flac#
34474 * @function
34475 */
34476 FLAC__stream_encoder_finish: Module.cwrap('FLAC__stream_encoder_finish', 'number', [ 'number' ]),
34477 /**
34478 * Finish the decoding process.
34479 *
34480 * The decoder can be reused, after initializing it again.
34481 *
34482 * @param {number} decoder
34483 * the ID of the decoder instance
34484 *
34485 * @returns {boolean} <code>false</code> if MD5 checking is on AND a STREAMINFO block was available AND the MD5 signature in
34486 * the STREAMINFO block was non-zero AND the signature does not match the one computed by the decoder;
34487 * else <code>true</code>.
34488 *
34489 * @memberOf Flac#
34490 * @function
34491 */
34492 FLAC__stream_decoder_finish: Module.cwrap('FLAC__stream_decoder_finish', 'number', [ 'number' ]),
34493 /**
34494 * Reset the decoder for reuse.
34495 *
34496 * <p>
34497 * NOTE: Needs to be re-initialized, before it can be used again
34498 *
34499 * @param {number} decoder
34500 * the ID of the decoder instance
34501 *
34502 * @returns {boolean} true if successful
34503 *
34504 * @see #init_decoder_stream
34505 * @see #init_decoder_ogg_stream
34506 *
34507 * @memberOf Flac#
34508 * @function
34509 */
34510 FLAC__stream_decoder_reset: Module.cwrap('FLAC__stream_decoder_reset', 'number', [ 'number' ]),
34511 /**
34512 * Delete the encoder instance, and free up its resources.
34513 *
34514 * @param {number} encoder
34515 * the ID of the encoder instance
34516 *
34517 * @memberOf Flac#
34518 * @function
34519 */
34520 FLAC__stream_encoder_delete: function(encoder){
34521 this._clear_enc_cb(encoder);//<- remove callback references
34522 Module.ccall('FLAC__stream_encoder_delete', 'number', [ 'number' ], [encoder]);
34523 do_fire_event('destroyed', [{type: 'destroyed', target: {id: encoder, type: 'encoder'}}], false);
34524 },
34525 /**
34526 * Delete the decoder instance, and free up its resources.
34527 *
34528 * @param {number} decoder
34529 * the ID of the decoder instance
34530 *
34531 * @memberOf Flac#
34532 * @function
34533 */
34534 FLAC__stream_decoder_delete: function(decoder){
34535 this._clear_dec_cb(decoder);//<- remove callback references
34536 Module.ccall('FLAC__stream_decoder_delete', 'number', [ 'number' ], [decoder]);
34537 do_fire_event('destroyed', [{type: 'destroyed', target: {id: decoder, type: 'decoder'}}], false);
34538 }
34539
34540};//END: var _exported = {
34541
34542//if Properties are supported by JS execution environment:
34543// support "immediate triggering" onready function, if library is already initialized when setting onready callback
34544if(typeof Object.defineProperty === 'function'){
34545 //add internal field for storing onready callback:
34546 _exported._onready = void(0);
34547 //define getter & define setter with "immediate trigger" functionality:
34548 Object.defineProperty(_exported, 'onready', {
34549 get() { return this._onready; },
34550 set(newValue) {
34551 this._onready = newValue;
34552 if(newValue && this.isReady()){
34553 check_and_trigger_persisted_event('ready', newValue);
34554 }
34555 }
34556 });
34557} else {
34558 //if Properties are NOTE supported by JS execution environment:
34559 // pring usage warning for onready hook instead
34560 console.warn('WARN: note that setting Flac.onready handler after Flac.isReady() is already true, will have no effect, that is, the handler function will not be triggered!');
34561}
34562
34563if(expLib && expLib.exports){
34564 expLib.exports = _exported;
34565}
34566return _exported;
34567
34568}));//END: UMD wrapper
34569